1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
|
// output.h -- manage the output file for gold -*- C++ -*-
#ifndef GOLD_OUTPUT_H
#define GOLD_OUTPUT_H
#include <cassert>
#include <list>
#include <vector>
#include "elfcpp.h"
#include "layout.h"
#include "reloc-types.h"
namespace gold
{
class General_options;
class Object;
class Output_file;
class Output_section;
template<int size, bool big_endian>
class Sized_target;
template<int size, bool big_endian>
class Sized_relobj;
// An abtract class for data which has to go into the output file.
class Output_data
{
public:
explicit Output_data(off_t data_size = 0)
: address_(0), data_size_(data_size), offset_(-1)
{ }
virtual
~Output_data();
// Return the address. This is only valid after Layout::finalize is
// finished.
uint64_t
address() const
{ return this->address_; }
// Return the size of the data. This must be valid after
// Layout::finalize calls set_address, but need not be valid before
// then.
off_t
data_size() const
{ return this->data_size_; }
// Return the file offset. This is only valid after
// Layout::finalize is finished.
off_t
offset() const
{ return this->offset_; }
// Return the required alignment.
uint64_t
addralign() const
{ return this->do_addralign(); }
// Return whether this is an Output_section.
bool
is_section() const
{ return this->do_is_section(); }
// Return whether this is an Output_section of the specified type.
bool
is_section_type(elfcpp::Elf_Word stt) const
{ return this->do_is_section_type(stt); }
// Return whether this is an Output_section with the specified flag
// set.
bool
is_section_flag_set(elfcpp::Elf_Xword shf) const
{ return this->do_is_section_flag_set(shf); }
// Return the output section index, if there is an output section.
unsigned int
out_shndx() const
{ return this->do_out_shndx(); }
// Set the output section index, if this is an output section.
void
set_out_shndx(unsigned int shndx)
{ this->do_set_out_shndx(shndx); }
// Set the address and file offset of this data. This is called
// during Layout::finalize.
void
set_address(uint64_t addr, off_t off);
// Write the data to the output file. This is called after
// Layout::finalize is complete.
void
write(Output_file* file)
{ this->do_write(file); }
protected:
// Functions that child classes may or in some cases must implement.
// Write the data to the output file.
virtual void
do_write(Output_file*) = 0;
// Return the required alignment.
virtual uint64_t
do_addralign() const = 0;
// Return whether this is an Output_section.
virtual bool
do_is_section() const
{ return false; }
// Return whether this is an Output_section of the specified type.
// This only needs to be implement by Output_section.
virtual bool
do_is_section_type(elfcpp::Elf_Word) const
{ return false; }
// Return whether this is an Output_section with the specific flag
// set. This only needs to be implemented by Output_section.
virtual bool
do_is_section_flag_set(elfcpp::Elf_Xword) const
{ return false; }
// Return the output section index, if there is an output section.
virtual unsigned int
do_out_shndx() const
{ abort(); }
// Set the output section index, if this is an output section.
virtual void
do_set_out_shndx(unsigned int)
{ abort(); }
// Set the address and file offset of the data. This only needs to
// be implemented if the child needs to know.
virtual void
do_set_address(uint64_t, off_t)
{ }
// Functions that child classes may call.
// Set the size of the data.
void
set_data_size(off_t data_size)
{ this->data_size_ = data_size; }
// Return default alignment for a size--32 or 64.
static uint64_t
default_alignment(int size);
private:
Output_data(const Output_data&);
Output_data& operator=(const Output_data&);
// Memory address in file (not always meaningful).
uint64_t address_;
// Size of data in file.
off_t data_size_;
// Offset within file.
off_t offset_;
};
// Output the section headers.
class Output_section_headers : public Output_data
{
public:
Output_section_headers(int size,
bool big_endian,
const Layout::Segment_list&,
const Layout::Section_list&,
const Stringpool*);
// Write the data to the file.
void
do_write(Output_file*);
// Return the required alignment.
uint64_t
do_addralign() const
{ return Output_data::default_alignment(this->size_); }
private:
// Write the data to the file with the right size and endianness.
template<int size, bool big_endian>
void
do_sized_write(Output_file*);
int size_;
bool big_endian_;
const Layout::Segment_list& segment_list_;
const Layout::Section_list& section_list_;
const Stringpool* secnamepool_;
};
// Output the segment headers.
class Output_segment_headers : public Output_data
{
public:
Output_segment_headers(int size, bool big_endian,
const Layout::Segment_list& segment_list);
// Write the data to the file.
void
do_write(Output_file*);
// Return the required alignment.
uint64_t
do_addralign() const
{ return Output_data::default_alignment(this->size_); }
private:
// Write the data to the file with the right size and endianness.
template<int size, bool big_endian>
void
do_sized_write(Output_file*);
int size_;
bool big_endian_;
const Layout::Segment_list& segment_list_;
};
// Output the ELF file header.
class Output_file_header : public Output_data
{
public:
Output_file_header(int size,
bool big_endian,
const General_options&,
const Target*,
const Symbol_table*,
const Output_segment_headers*);
// Add information about the section headers. We lay out the ELF
// file header before we create the section headers.
void set_section_info(const Output_section_headers*,
const Output_section* shstrtab);
// Write the data to the file.
void
do_write(Output_file*);
// Return the required alignment.
uint64_t
do_addralign() const
{ return Output_data::default_alignment(this->size_); }
// Set the address and offset--we only implement this for error
// checking.
void
do_set_address(uint64_t, off_t off) const
{ assert(off == 0); }
private:
// Write the data to the file with the right size and endianness.
template<int size, bool big_endian>
void
do_sized_write(Output_file*);
int size_;
bool big_endian_;
const General_options& options_;
const Target* target_;
const Symbol_table* symtab_;
const Output_segment_headers* segment_header_;
const Output_section_headers* section_header_;
const Output_section* shstrtab_;
};
// Output sections are mainly comprised of input sections. However,
// there are cases where we have data to write out which is not in an
// input section. Output_section_data is used in such cases. This is
// an abstract base class.
class Output_section_data : public Output_data
{
public:
Output_section_data(off_t data_size, uint64_t addralign)
: Output_data(data_size), output_section_(NULL), addralign_(addralign)
{ }
Output_section_data(uint64_t addralign)
: Output_data(0), output_section_(NULL), addralign_(addralign)
{ }
// Record the output section.
void
set_output_section(Output_section* os)
{
assert(this->output_section_ == NULL);
this->output_section_ = os;
}
protected:
// The child class must implement do_write.
// Return the required alignment.
uint64_t
do_addralign() const
{ return this->addralign_; }
// Return the section index of the output section.
unsigned int
do_out_shndx() const;
private:
// The output section for this section.
const Output_section* output_section_;
// The required alignment.
uint64_t addralign_;
};
// A simple case of Output_data in which we have constant data to
// output.
class Output_data_const : public Output_section_data
{
public:
Output_data_const(const std::string& data, uint64_t addralign)
: Output_section_data(data.size(), addralign), data_(data)
{ }
Output_data_const(const char* p, off_t len, uint64_t addralign)
: Output_section_data(len, addralign), data_(p, len)
{ }
Output_data_const(const unsigned char* p, off_t len, uint64_t addralign)
: Output_section_data(len, addralign),
data_(reinterpret_cast<const char*>(p), len)
{ }
// Write the data to the file.
void
do_write(Output_file* output);
private:
std::string data_;
};
// Output_data_common is used to handle the common symbols. This is
// quite simple.
class Output_data_common : public Output_section_data
{
public:
Output_data_common(uint64_t addralign)
: Output_section_data(addralign)
{ }
// Set the size.
void
set_common_size(off_t common_size)
{ this->set_data_size(common_size); }
// Write out the data--there is nothing to do, as common symbols are
// always zero and are stored in the BSS.
void
do_write(Output_file*)
{ }
};
// This POD class is used to represent a single reloc in the output
// file. This could be a private class within Output_data_reloc, but
// the templatization is complex enough that I broke it out into a
// separate class. The class is templatized on either elfcpp::SHT_REL
// or elfcpp::SHT_RELA, and also on whether this is a dynamic
// relocation or an ordinary relocation.
// A relocation can be against a global symbol, a local symbol, an
// output section, or the undefined symbol at index 0. We represent
// the latter by using a NULL global symbol.
template<int sh_type, bool dynamic, int size, bool big_endian>
class Output_reloc;
template<bool dynamic, int size, bool big_endian>
class Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
{
public:
typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
// An uninitialized entry. We need this because we want to put
// instances of this class into an STL container.
Output_reloc()
: local_sym_index_(INVALID_CODE)
{ }
// A reloc against a global symbol.
Output_reloc(Symbol* gsym, unsigned int type, Address address)
: local_sym_index_(GSYM_CODE), type_(type), address_(address)
{ this->u_.gsym = gsym; }
// A reloc against a local symbol.
Output_reloc(Sized_relobj<size, big_endian>* object,
unsigned int local_sym_index,
unsigned int type, Address address)
: local_sym_index_(local_sym_index), type_(type), address_(address)
{
assert(local_sym_index != GSYM_CODE && local_sym_index != INVALID_CODE);
this->u_.object = object;
}
// A reloc against the STT_SECTION symbol of an output section.
Output_reloc(Output_section* os, unsigned int type, Address address)
: local_sym_index_(SECTION_CODE), type_(type), address_(address)
{ this->u_.os = os; }
// Write the reloc entry to an output view.
void
write(unsigned char* pov) const;
// Write the offset and info fields to Write_rel.
template<typename Write_rel>
void write_rel(Write_rel*) const;
private:
// Return the symbol index. We can't do a double template
// specialization, so we do a secondary template here.
unsigned int
get_symbol_index() const;
// Codes for local_sym_index_.
enum
{
// Global symbol.
GSYM_CODE = -1U,
// Output section.
SECTION_CODE = -2U,
// Invalid uninitialized entry.
INVALID_CODE = -3U
};
union
{
// For a local symbol, the object. We will never generate a
// relocation against a local symbol in a dynamic object; that
// doesn't make sense. And our callers will always be
// templatized, so we use Sized_relobj here.
Sized_relobj<size, big_endian>* object;
// For a global symbol, the symbol. If this is NULL, it indicates
// a relocation against the undefined 0 symbol.
Symbol* gsym;
// For a relocation against an output section, the output section.
Output_section* os;
} u_;
// For a local symbol, the local symbol index. This is GSYM_CODE
// for a global symbol, or INVALID_CODE for an uninitialized value.
unsigned int local_sym_index_;
unsigned int type_;
Address address_;
};
// The SHT_RELA version of Output_reloc<>. This is just derived from
// the SHT_REL version of Output_reloc, but it adds an addend.
template<bool dynamic, int size, bool big_endian>
class Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>
{
public:
typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
typedef typename elfcpp::Elf_types<size>::Elf_Addr Addend;
// An uninitialized entry.
Output_reloc()
: rel_()
{ }
// A reloc against a global symbol.
Output_reloc(Symbol* gsym, unsigned int type, Address address, Addend addend)
: rel_(gsym, type, address), addend_(addend)
{ }
// A reloc against a local symbol.
Output_reloc(Sized_relobj<size, big_endian>* object,
unsigned int local_sym_index,
unsigned int type, Address address, Addend addend)
: rel_(object, local_sym_index, type, address), addend_(addend)
{ }
// A reloc against the STT_SECTION symbol of an output section.
Output_reloc(Output_section* os, unsigned int type, Address address,
Addend addend)
: rel_(os, type, address), addend_(addend)
{ }
// Write the reloc entry to an output view.
void
write(unsigned char* pov) const;
private:
// The basic reloc.
Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian> rel_;
// The addend.
Addend addend_;
};
// Output_data_reloc is used to manage a section containing relocs.
// SH_TYPE is either elfcpp::SHT_REL or elfcpp::SHT_RELA. DYNAMIC
// indicates whether this is a dynamic relocation or a normal
// relocation. Output_data_reloc_base is a base class.
// Output_data_reloc is the real class, which we specialize based on
// the reloc type.
template<int sh_type, bool dynamic, int size, bool big_endian>
class Output_data_reloc_base : public Output_section_data
{
public:
typedef Output_reloc<sh_type, dynamic, size, big_endian> Output_reloc_type;
typedef typename Output_reloc_type::Address Address;
static const int reloc_size =
Reloc_types<sh_type, size, big_endian>::reloc_size;
// Construct the section.
Output_data_reloc_base()
: Output_section_data(Output_data::default_alignment(size))
{ }
// Write out the data.
void
do_write(Output_file*);
protected:
// Add a relocation entry.
void
add(const Output_reloc_type& reloc)
{
this->relocs_.push_back(reloc);
this->set_data_size(this->relocs_.size() * reloc_size);
}
private:
typedef std::vector<Output_reloc_type> Relocs;
Relocs relocs_;
};
// The class which callers actually create.
template<int sh_type, bool dynamic, int size, bool big_endian>
class Output_data_reloc;
// The SHT_REL version of Output_data_reloc.
template<bool dynamic, int size, bool big_endian>
class Output_data_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
: public Output_data_reloc_base<elfcpp::SHT_REL, dynamic, size, big_endian>
{
private:
typedef Output_data_reloc_base<elfcpp::SHT_REL, dynamic, size,
big_endian> Base;
public:
typedef typename Base::Output_reloc_type Output_reloc_type;
typedef typename Output_reloc_type::Address Address;
Output_data_reloc()
: Output_data_reloc_base<elfcpp::SHT_REL, dynamic, size, big_endian>()
{ }
// Add a reloc against a global symbol.
void
add_global(Symbol* gsym, unsigned int type, Address address)
{ this->add(Output_reloc_type(gsym, type, address)); }
// Add a reloc against a local symbol.
void
add_local(Sized_relobj<size, big_endian>* object,
unsigned int local_sym_index, unsigned int type, Address address)
{ this->add(Output_reloc_type(object, local_sym_index, type, address)); }
// A reloc against the STT_SECTION symbol of an output section.
void
add_output_section(Output_section* os, unsigned int type, Address address)
{ this->add(Output_reloc_type(os, type, address)); }
};
// The SHT_RELA version of Output_data_reloc.
template<bool dynamic, int size, bool big_endian>
class Output_data_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>
: public Output_data_reloc_base<elfcpp::SHT_RELA, dynamic, size, big_endian>
{
private:
typedef Output_data_reloc_base<elfcpp::SHT_RELA, dynamic, size,
big_endian> Base;
public:
typedef typename Base::Output_reloc_type Output_reloc_type;
typedef typename Output_reloc_type::Address Address;
typedef typename Output_reloc_type::Addend Addend;
Output_data_reloc()
: Output_data_reloc_base<elfcpp::SHT_RELA, dynamic, size, big_endian>()
{ }
// Add a reloc against a global symbol.
void
add_global(Symbol* gsym, unsigned int type, Address address, Addend addend)
{ this->add(Output_reloc_type(gsym, type, address, addend)); }
// Add a reloc against a local symbol.
void
add_local(Sized_relobj<size, big_endian>* object,
unsigned int local_sym_index, unsigned int type,
Address address, Addend addend)
{
this->add(Output_reloc_type(object, local_sym_index, type, address,
addend));
}
// A reloc against the STT_SECTION symbol of an output section.
void
add_output_section(Output_section* os, unsigned int type, Address address,
Addend addend)
{ this->add(Output_reloc_type(os, type, address, addend)); }
};
// Output_data_got is used to manage a GOT. Each entry in the GOT is
// for one symbol--either a global symbol or a local symbol in an
// object. The target specific code adds entries to the GOT as
// needed.
template<int size, bool big_endian>
class Output_data_got : public Output_section_data
{
public:
typedef typename elfcpp::Elf_types<size>::Elf_Addr Valtype;
Output_data_got()
: Output_section_data(Output_data::default_alignment(size)),
entries_()
{ }
// Add an entry for a global symbol to the GOT. Return true if this
// is a new GOT entry, false if the symbol was already in the GOT.
bool
add_global(Symbol* gsym);
// Add an entry for a local symbol to the GOT. This returns the
// offset of the new entry from the start of the GOT.
unsigned int
add_local(Object* object, unsigned int sym_index)
{
this->entries_.push_back(Got_entry(object, sym_index));
this->set_got_size();
return this->last_got_offset();
}
// Add a constant to the GOT. This returns the offset of the new
// entry from the start of the GOT.
unsigned int
add_constant(Valtype constant)
{
this->entries_.push_back(Got_entry(constant));
this->set_got_size();
return this->last_got_offset();
}
// Write out the GOT table.
void
do_write(Output_file*);
private:
// This POD class holds a single GOT entry.
class Got_entry
{
public:
// Create a zero entry.
Got_entry()
: local_sym_index_(CONSTANT_CODE)
{ this->u_.constant = 0; }
// Create a global symbol entry.
Got_entry(Symbol* gsym)
: local_sym_index_(GSYM_CODE)
{ this->u_.gsym = gsym; }
// Create a local symbol entry.
Got_entry(Object* object, unsigned int local_sym_index)
: local_sym_index_(local_sym_index)
{
assert(local_sym_index != GSYM_CODE
&& local_sym_index != CONSTANT_CODE);
this->u_.object = object;
}
// Create a constant entry. The constant is a host value--it will
// be swapped, if necessary, when it is written out.
Got_entry(Valtype constant)
: local_sym_index_(CONSTANT_CODE)
{ this->u_.constant = constant; }
// Write the GOT entry to an output view.
void
write(unsigned char* pov) const;
private:
enum
{
GSYM_CODE = -1U,
CONSTANT_CODE = -2U
};
union
{
// For a local symbol, the object.
Object* object;
// For a global symbol, the symbol.
Symbol* gsym;
// For a constant, the constant.
Valtype constant;
} u_;
// For a local symbol, the local symbol index. This is GSYM_CODE
// for a global symbol, or CONSTANT_CODE for a constant.
unsigned int local_sym_index_;
};
typedef std::vector<Got_entry> Got_entries;
// Return the offset into the GOT of GOT entry I.
unsigned int
got_offset(unsigned int i) const
{ return i * (size / 8); }
// Return the offset into the GOT of the last entry added.
unsigned int
last_got_offset() const
{ return this->got_offset(this->entries_.size() - 1); }
// Set the size of the section.
void
set_got_size()
{ this->set_data_size(this->got_offset(this->entries_.size())); }
// The list of GOT entries.
Got_entries entries_;
};
// An output section. We don't expect to have too many output
// sections, so we don't bother to do a template on the size.
class Output_section : public Output_data
{
public:
// Create an output section, giving the name, type, and flags.
Output_section(const char* name, elfcpp::Elf_Word, elfcpp::Elf_Xword,
bool may_add_data);
virtual ~Output_section();
// Add a new input section SHNDX, named NAME, with header SHDR, from
// object OBJECT. Return the offset within the output section.
template<int size, bool big_endian>
off_t
add_input_section(Relobj* object, unsigned int shndx, const char *name,
const elfcpp::Shdr<size, big_endian>& shdr);
// Add generated data ODATA to this output section.
void
add_output_section_data(Output_section_data* posd);
// Return the section name.
const char*
name() const
{ return this->name_; }
// Return the section type.
elfcpp::Elf_Word
type() const
{ return this->type_; }
// Return the section flags.
elfcpp::Elf_Xword
flags() const
{ return this->flags_; }
// Return the section index in the output file.
unsigned int
do_out_shndx() const
{ return this->out_shndx_; }
// Set the output section index.
void
do_set_out_shndx(unsigned int shndx)
{ this->out_shndx_ = shndx; }
// Set the entsize field.
void
set_entsize(uint64_t v)
{ this->entsize_ = v; }
// Set the link field.
void
set_link(unsigned int v)
{ this->link_ = v; }
// Set the info field.
void
set_info(unsigned int v)
{ this->info_ = v; }
// Set the addralign field.
void
set_addralign(uint64_t v)
{ this->addralign_ = v; }
// Indicate that we need a symtab index.
void
set_needs_symtab_index()
{ this->needs_symtab_index_ = true; }
// Return whether we need a symtab index.
bool
needs_symtab_index() const
{ return this->needs_symtab_index_; }
// Get the symtab index.
unsigned int
symtab_index() const
{
assert(this->symtab_index_ != 0);
return this->symtab_index_;
}
// Set the symtab index.
void
set_symtab_index(unsigned int index)
{
assert(index != 0);
this->symtab_index_ = index;
}
// Indicate that we need a dynsym index.
void
set_needs_dynsym_index()
{ this->needs_dynsym_index_ = true; }
// Return whether we need a dynsym index.
bool
needs_dynsym_index() const
{ return this->needs_dynsym_index_; }
// Get the dynsym index.
unsigned int
dynsym_index() const
{
assert(this->dynsym_index_ != 0);
return this->dynsym_index_;
}
// Set the dynsym index.
void
set_dynsym_index(unsigned int index)
{
assert(index != 0);
this->dynsym_index_ = index;
}
// Set the address of the Output_section. For a typical
// Output_section, there is nothing to do, but if there are any
// Output_section_data objects we need to set the final addresses
// here.
void
do_set_address(uint64_t, off_t);
// Write the data to the file. For a typical Output_section, this
// does nothing: the data is written out by calling Object::Relocate
// on each input object. But if there are any Output_section_data
// objects we do need to write them out here.
virtual void
do_write(Output_file*);
// Return the address alignment--function required by parent class.
uint64_t
do_addralign() const
{ return this->addralign_; }
// Return whether this is an Output_section.
bool
do_is_section() const
{ return true; }
// Return whether this is a section of the specified type.
bool
do_is_section_type(elfcpp::Elf_Word type) const
{ return this->type_ == type; }
// Return whether the specified section flag is set.
bool
do_is_section_flag_set(elfcpp::Elf_Xword flag) const
{ return (this->flags_ & flag) != 0; }
// Write the section header into *OPHDR.
template<int size, bool big_endian>
void
write_header(const Stringpool*, elfcpp::Shdr_write<size, big_endian>*) const;
private:
// In some cases we need to keep a list of the input sections
// associated with this output section. We only need the list if we
// might have to change the offsets of the input section within the
// output section after we add the input section. The ordinary
// input sections will be written out when we process the object
// file, and as such we don't need to track them here. We do need
// to track Output_section_data objects here. We store instances of
// this structure in a std::vector, so it must be a POD. There can
// be many instances of this structure, so we use a union to save
// some space.
class Input_section
{
public:
Input_section()
: shndx_(0), p2align_(0), data_size_(0)
{ this->u_.object = NULL; }
Input_section(Relobj* object, unsigned int shndx, off_t data_size,
uint64_t addralign)
: shndx_(shndx),
p2align_(ffsll(static_cast<long long>(addralign))),
data_size_(data_size)
{
assert(shndx != -1U);
this->u_.object = object;
}
Input_section(Output_section_data* posd)
: shndx_(-1U),
p2align_(ffsll(static_cast<long long>(posd->addralign()))),
data_size_(0)
{ this->u_.posd = posd; }
// The required alignment.
uint64_t
addralign() const
{ return static_cast<uint64_t>(1) << this->p2align_; }
// Return the required size.
off_t
data_size() const;
// Set the address and file offset. This is called during
// Layout::finalize. SECOFF is the file offset of the enclosing
// section.
void
set_address(uint64_t addr, off_t off, off_t secoff);
// Write out the data. This does nothing for an input section.
void
write(Output_file*);
private:
// Whether this is an input section.
bool
is_input_section() const
{ return this->shndx_ != -1U; }
// For an ordinary input section, this is the section index in
// the input file. For an Output_section_data, this is -1U.
unsigned int shndx_;
// The required alignment, stored as a power of 2.
unsigned int p2align_;
// For an ordinary input section, the section size.
off_t data_size_;
union
{
// If shndx_ != -1U, this points to the object which holds the
// input section.
Relobj* object;
// If shndx_ == -1U, this is the data to write out.
Output_section_data* posd;
} u_;
};
typedef std::vector<Input_section> Input_section_list;
// Most of these fields are only valid after layout.
// The name of the section. This will point into a Stringpool.
const char* name_;
// The section address is in the parent class.
// The section alignment.
uint64_t addralign_;
// The section entry size.
uint64_t entsize_;
// The file offset is in the parent class.
// The section link field.
unsigned int link_;
// The section info field.
unsigned int info_;
// The section type.
elfcpp::Elf_Word type_;
// The section flags.
elfcpp::Elf_Xword flags_;
// The section index.
unsigned int out_shndx_;
// If there is a STT_SECTION for this output section in the normal
// symbol table, this is the symbol index. This starts out as zero.
// It is initialized in Layout::finalize() to be the index, or -1U
// if there isn't one.
unsigned int symtab_index_;
// If there is a STT_SECTION for this output section in the dynamic
// symbol table, this is the symbol index. This starts out as zero.
// It is initialized in Layout::finalize() to be the index, or -1U
// if there isn't one.
unsigned int dynsym_index_;
// The input sections. This will be empty in cases where we don't
// need to keep track of them.
Input_section_list input_sections_;
// The offset of the first entry in input_sections_.
off_t first_input_offset_;
// Whether we permit adding data.
bool may_add_data_ : 1;
// Whether this output section needs a STT_SECTION symbol in the
// normal symbol table. This will be true if there is a relocation
// which needs it.
bool needs_symtab_index_ : 1;
// Whether this output section needs a STT_SECTION symbol in the
// dynamic symbol table. This will be true if there is a dynamic
// relocation which needs it.
bool needs_dynsym_index_ : 1;
};
// A special Output_section which represents the symbol table
// (SHT_SYMTAB). The actual data is written out by
// Symbol_table::write_globals.
class Output_section_symtab : public Output_section
{
public:
Output_section_symtab(const char* name, off_t data_size)
: Output_section(name, elfcpp::SHT_SYMTAB, 0, false)
{ this->set_data_size(data_size); }
// The data is written out by Symbol_table::write_globals. We don't
// do anything here.
void
do_write(Output_file*)
{ }
};
// A special Output_section which represents the dynamic symbol table
// (SHT_DYNSYM). The actual data is written out by
// Symbol_table::write_globals.
class Output_section_dynsym : public Output_section
{
public:
Output_section_dynsym(const char* name, off_t data_size)
: Output_section(name, elfcpp::SHT_DYNSYM, 0, false)
{ this->set_data_size(data_size); }
// The data is written out by Symbol_table::write_globals. We don't
// do anything here.
void
do_write(Output_file*)
{ }
};
// A special Output_section which holds a string table.
class Output_section_strtab : public Output_section
{
public:
Output_section_strtab(const char* name, Stringpool* contents);
// Write out the data.
void
do_write(Output_file*);
private:
Stringpool* contents_;
};
// An output segment. PT_LOAD segments are built from collections of
// output sections. Other segments typically point within PT_LOAD
// segments, and are built directly as needed.
class Output_segment
{
public:
// Create an output segment, specifying the type and flags.
Output_segment(elfcpp::Elf_Word, elfcpp::Elf_Word);
// Return the virtual address.
uint64_t
vaddr() const
{ return this->vaddr_; }
// Return the physical address.
uint64_t
paddr() const
{ return this->paddr_; }
// Return the segment type.
elfcpp::Elf_Word
type() const
{ return this->type_; }
// Return the segment flags.
elfcpp::Elf_Word
flags() const
{ return this->flags_; }
// Return the memory size.
uint64_t
memsz() const
{ return this->memsz_; }
// Return the file size.
off_t
filesz() const
{ return this->filesz_; }
// Return the maximum alignment of the Output_data.
uint64_t
addralign();
// Add an Output_section to this segment.
void
add_output_section(Output_section* os, elfcpp::Elf_Word seg_flags)
{ this->add_output_section(os, seg_flags, false); }
// Add an Output_section to the start of this segment.
void
add_initial_output_section(Output_section* os, elfcpp::Elf_Word seg_flags)
{ this->add_output_section(os, seg_flags, true); }
// Add an Output_data (which is not an Output_section) to the start
// of this segment.
void
add_initial_output_data(Output_data*);
// Set the address of the segment to ADDR and the offset to *POFF
// (aligned if necessary), and set the addresses and offsets of all
// contained output sections accordingly. Set the section indexes
// of all contained output sections starting with *PSHNDX. Return
// the address of the immediately following segment. Update *POFF
// and *PSHNDX. This should only be called for a PT_LOAD segment.
uint64_t
set_section_addresses(uint64_t addr, off_t* poff, unsigned int* pshndx);
// Set the offset of this segment based on the section. This should
// only be called for a non-PT_LOAD segment.
void
set_offset();
// Return the number of output sections.
unsigned int
output_section_count() const;
// Write the segment header into *OPHDR.
template<int size, bool big_endian>
void
write_header(elfcpp::Phdr_write<size, big_endian>*);
// Write the section headers of associated sections into V.
template<int size, bool big_endian>
unsigned char*
write_section_headers(const Stringpool*,
unsigned char* v,
unsigned int* pshndx ACCEPT_SIZE_ENDIAN) const;
private:
Output_segment(const Output_segment&);
Output_segment& operator=(const Output_segment&);
typedef std::list<Output_data*> Output_data_list;
// Add an Output_section to this segment, specifying front or back.
void
add_output_section(Output_section*, elfcpp::Elf_Word seg_flags,
bool front);
// Find the maximum alignment in an Output_data_list.
static uint64_t
maximum_alignment(const Output_data_list*);
// Set the section addresses in an Output_data_list.
uint64_t
set_section_list_addresses(Output_data_list*, uint64_t addr, off_t* poff,
unsigned int* pshndx);
// Return the number of Output_sections in an Output_data_list.
unsigned int
output_section_count_list(const Output_data_list*) const;
// Write the section headers in the list into V.
template<int size, bool big_endian>
unsigned char*
write_section_headers_list(const Stringpool*, const Output_data_list*,
unsigned char* v,
unsigned int* pshdx ACCEPT_SIZE_ENDIAN) const;
// The list of output data with contents attached to this segment.
Output_data_list output_data_;
// The list of output data without contents attached to this segment.
Output_data_list output_bss_;
// The segment virtual address.
uint64_t vaddr_;
// The segment physical address.
uint64_t paddr_;
// The size of the segment in memory.
uint64_t memsz_;
// The segment alignment.
uint64_t align_;
// The offset of the segment data within the file.
off_t offset_;
// The size of the segment data in the file.
off_t filesz_;
// The segment type;
elfcpp::Elf_Word type_;
// The segment flags.
elfcpp::Elf_Word flags_;
// Whether we have set align_.
bool is_align_known_;
};
// This class represents the output file.
class Output_file
{
public:
Output_file(const General_options& options);
// Open the output file. FILE_SIZE is the final size of the file.
void
open(off_t file_size);
// Close the output file and make sure there are no error.
void
close();
// We currently always use mmap which makes the view handling quite
// simple. In the future we may support other approaches.
// Write data to the output file.
void
write(off_t offset, const void* data, off_t len)
{ memcpy(this->base_ + offset, data, len); }
// Get a buffer to use to write to the file, given the offset into
// the file and the size.
unsigned char*
get_output_view(off_t start, off_t size)
{
assert(start >= 0 && size >= 0 && start + size <= this->file_size_);
return this->base_ + start;
}
// VIEW must have been returned by get_output_view. Write the
// buffer to the file, passing in the offset and the size.
void
write_output_view(off_t, off_t, unsigned char*)
{ }
private:
// General options.
const General_options& options_;
// File name.
const char* name_;
// File descriptor.
int o_;
// File size.
off_t file_size_;
// Base of file mapped into memory.
unsigned char* base_;
};
} // End namespace gold.
#endif // !defined(GOLD_OUTPUT_H)
|