1//===- LDFileFormat.h -----------------------------------------------------===//
2//
3//                     The MCLinker Project
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9#ifndef MCLD_LD_ELFFILEFORMAT_H_
10#define MCLD_LD_ELFFILEFORMAT_H_
11#include "mcld/LD/LDFileFormat.h"
12#include "mcld/LD/LDSection.h"
13
14namespace mcld {
15
16class ObjectBuilder;
17
18/** \class ELFFileFormat
19 *  \brief ELFFileFormat describes the common file formats in ELF.
20 *  LDFileFormats control the formats of the output file.
21 *
22 *  @ref "Object Files," Ch. 4, in System V Application Binary Interface,
23 *  Fourth Edition.
24 *
25 *  @ref "Object Format," Ch. 10, in ISO/IEC 23360 Part 1:2010(E), Linux
26 *  Standard Base Core Specification 4.1.
27 */
28class ELFFileFormat : public LDFileFormat {
29 private:
30  /// initObjectFormat - initialize sections that are dependent on object
31  /// formats. (executable, shared objects or relocatable objects).
32  virtual void initObjectFormat(ObjectBuilder& pBuilder,
33                                unsigned int pBitClass) = 0;
34
35 public:
36  ELFFileFormat();
37
38  void initStdSections(ObjectBuilder& pBuilder, unsigned int pBitClass);
39
40  // -----  capacity  ----- //
41  /// @ref Special Sections, Ch. 4.17, System V ABI, 4th edition.
42  bool hasNULLSection() const {
43    return (f_pNULLSection != NULL) && (f_pNULLSection->size() != 0);
44  }
45
46  bool hasGOT() const { return (f_pGOT != NULL) && (f_pGOT->size() != 0); }
47
48  bool hasPLT() const { return (f_pPLT != NULL) && (f_pPLT->size() != 0); }
49
50  bool hasRelDyn() const {
51    return (f_pRelDyn != NULL) && (f_pRelDyn->size() != 0);
52  }
53
54  bool hasRelPlt() const {
55    return (f_pRelPlt != NULL) && (f_pRelPlt->size() != 0);
56  }
57
58  bool hasRelaDyn() const {
59    return (f_pRelaDyn != NULL) && (f_pRelaDyn->size() != 0);
60  }
61
62  bool hasRelaPlt() const {
63    return (f_pRelaPlt != NULL) && (f_pRelaPlt->size() != 0);
64  }
65
66  /// @ref 10.3.1.1, ISO/IEC 23360, Part 1:2010(E), p. 21.
67  bool hasComment() const {
68    return (f_pComment != NULL) && (f_pComment->size() != 0);
69  }
70
71  bool hasData1() const {
72    return (f_pData1 != NULL) && (f_pData1->size() != 0);
73  }
74
75  bool hasDebug() const {
76    return (f_pDebug != NULL) && (f_pDebug->size() != 0);
77  }
78
79  bool hasDynamic() const {
80    return (f_pDynamic != NULL) && (f_pDynamic->size() != 0);
81  }
82
83  bool hasDynStrTab() const {
84    return (f_pDynStrTab != NULL) && (f_pDynStrTab->size() != 0);
85  }
86
87  bool hasDynSymTab() const {
88    return (f_pDynSymTab != NULL) && (f_pDynSymTab->size() != 0);
89  }
90
91  bool hasFini() const { return (f_pFini != NULL) && (f_pFini->size() != 0); }
92
93  bool hasFiniArray() const {
94    return (f_pFiniArray != NULL) && (f_pFiniArray->size() != 0);
95  }
96
97  bool hasHashTab() const {
98    return (f_pHashTab != NULL) && (f_pHashTab->size() != 0);
99  }
100
101  bool hasInit() const { return (f_pInit != NULL) && (f_pInit->size() != 0); }
102
103  bool hasInitArray() const {
104    return (f_pInitArray != NULL) && (f_pInitArray->size() != 0);
105  }
106
107  bool hasInterp() const {
108    return (f_pInterp != NULL) && (f_pInterp->size() != 0);
109  }
110
111  bool hasLine() const { return (f_pLine != NULL) && (f_pLine->size() != 0); }
112
113  bool hasNote() const { return (f_pNote != NULL) && (f_pNote->size() != 0); }
114
115  bool hasPreInitArray() const {
116    return (f_pPreInitArray != NULL) && (f_pPreInitArray->size() != 0);
117  }
118
119  bool hasROData1() const {
120    return (f_pROData1 != NULL) && (f_pROData1->size() != 0);
121  }
122
123  bool hasShStrTab() const {
124    return (f_pShStrTab != NULL) && (f_pShStrTab->size() != 0);
125  }
126
127  bool hasStrTab() const {
128    return (f_pStrTab != NULL) && (f_pStrTab->size() != 0);
129  }
130
131  bool hasSymTab() const {
132    return (f_pSymTab != NULL) && (f_pSymTab->size() != 0);
133  }
134
135  bool hasTBSS() const { return (f_pTBSS != NULL) && (f_pTBSS->size() != 0); }
136
137  bool hasTData() const {
138    return (f_pTData != NULL) && (f_pTData->size() != 0);
139  }
140
141  /// @ref 10.3.1.2, ISO/IEC 23360, Part 1:2010(E), p. 24.
142  bool hasCtors() const {
143    return (f_pCtors != NULL) && (f_pCtors->size() != 0);
144  }
145
146  bool hasDataRelRo() const {
147    return (f_pDataRelRo != NULL) && (f_pDataRelRo->size() != 0);
148  }
149
150  bool hasDtors() const {
151    return (f_pDtors != NULL) && (f_pDtors->size() != 0);
152  }
153
154  bool hasEhFrame() const {
155    return (f_pEhFrame != NULL) && (f_pEhFrame->size() != 0);
156  }
157
158  bool hasEhFrameHdr() const {
159    return (f_pEhFrameHdr != NULL) && (f_pEhFrameHdr->size() != 0);
160  }
161
162  bool hasGCCExceptTable() const {
163    return (f_pGCCExceptTable != NULL) && (f_pGCCExceptTable->size() != 0);
164  }
165
166  bool hasGNUVersion() const {
167    return (f_pGNUVersion != NULL) && (f_pGNUVersion->size() != 0);
168  }
169
170  bool hasGNUVersionD() const {
171    return (f_pGNUVersionD != NULL) && (f_pGNUVersionD->size() != 0);
172  }
173
174  bool hasGNUVersionR() const {
175    return (f_pGNUVersionR != NULL) && (f_pGNUVersionR->size() != 0);
176  }
177
178  bool hasGOTPLT() const {
179    return (f_pGOTPLT != NULL) && (f_pGOTPLT->size() != 0);
180  }
181
182  bool hasJCR() const { return (f_pJCR != NULL) && (f_pJCR->size() != 0); }
183
184  bool hasNoteABITag() const {
185    return (f_pNoteABITag != NULL) && (f_pNoteABITag->size() != 0);
186  }
187
188  bool hasStab() const { return (f_pStab != NULL) && (f_pStab->size() != 0); }
189
190  bool hasStabStr() const {
191    return (f_pStabStr != NULL) && (f_pStabStr->size() != 0);
192  }
193
194  bool hasStack() const {
195    return (f_pStack != NULL) && (f_pStack->size() != 0);
196  }
197
198  bool hasStackNote() const { return (f_pStackNote != NULL); }
199
200  bool hasDataRelRoLocal() const {
201    return (f_pDataRelRoLocal != NULL) && (f_pDataRelRoLocal->size() != 0);
202  }
203
204  bool hasGNUHashTab() const {
205    return (f_pGNUHashTab != NULL) && (f_pGNUHashTab->size() != 0);
206  }
207
208  // -----  access functions  ----- //
209  /// @ref Special Sections, Ch. 4.17, System V ABI, 4th edition.
210  LDSection& getNULLSection() {
211    assert(f_pNULLSection != NULL);
212    return *f_pNULLSection;
213  }
214
215  const LDSection& getNULLSection() const {
216    assert(f_pNULLSection != NULL);
217    return *f_pNULLSection;
218  }
219
220  LDSection& getGOT() {
221    assert(f_pGOT != NULL);
222    return *f_pGOT;
223  }
224
225  const LDSection& getGOT() const {
226    assert(f_pGOT != NULL);
227    return *f_pGOT;
228  }
229
230  LDSection& getPLT() {
231    assert(f_pPLT != NULL);
232    return *f_pPLT;
233  }
234
235  const LDSection& getPLT() const {
236    assert(f_pPLT != NULL);
237    return *f_pPLT;
238  }
239
240  LDSection& getRelDyn() {
241    assert(f_pRelDyn != NULL);
242    return *f_pRelDyn;
243  }
244
245  const LDSection& getRelDyn() const {
246    assert(f_pRelDyn != NULL);
247    return *f_pRelDyn;
248  }
249
250  LDSection& getRelPlt() {
251    assert(f_pRelPlt != NULL);
252    return *f_pRelPlt;
253  }
254
255  const LDSection& getRelPlt() const {
256    assert(f_pRelPlt != NULL);
257    return *f_pRelPlt;
258  }
259
260  LDSection& getRelaDyn() {
261    assert(f_pRelaDyn != NULL);
262    return *f_pRelaDyn;
263  }
264
265  const LDSection& getRelaDyn() const {
266    assert(f_pRelaDyn != NULL);
267    return *f_pRelaDyn;
268  }
269
270  LDSection& getRelaPlt() {
271    assert(f_pRelaPlt != NULL);
272    return *f_pRelaPlt;
273  }
274
275  const LDSection& getRelaPlt() const {
276    assert(f_pRelaPlt != NULL);
277    return *f_pRelaPlt;
278  }
279
280  LDSection& getComment() {
281    assert(f_pComment != NULL);
282    return *f_pComment;
283  }
284
285  /// @ref 10.3.1.1, ISO/IEC 23360, Part 1:2010(E), p. 21.
286  const LDSection& getComment() const {
287    assert(f_pComment != NULL);
288    return *f_pComment;
289  }
290
291  LDSection& getData1() {
292    assert(f_pData1 != NULL);
293    return *f_pData1;
294  }
295
296  const LDSection& getData1() const {
297    assert(f_pData1 != NULL);
298    return *f_pData1;
299  }
300
301  LDSection& getDebug() {
302    assert(f_pDebug != NULL);
303    return *f_pDebug;
304  }
305
306  const LDSection& getDebug() const {
307    assert(f_pDebug != NULL);
308    return *f_pDebug;
309  }
310
311  LDSection& getDynamic() {
312    assert(f_pDynamic != NULL);
313    return *f_pDynamic;
314  }
315
316  const LDSection& getDynamic() const {
317    assert(f_pDynamic != NULL);
318    return *f_pDynamic;
319  }
320
321  LDSection& getDynStrTab() {
322    assert(f_pDynStrTab != NULL);
323    return *f_pDynStrTab;
324  }
325
326  const LDSection& getDynStrTab() const {
327    assert(f_pDynStrTab != NULL);
328    return *f_pDynStrTab;
329  }
330
331  LDSection& getDynSymTab() {
332    assert(f_pDynSymTab != NULL);
333    return *f_pDynSymTab;
334  }
335
336  const LDSection& getDynSymTab() const {
337    assert(f_pDynSymTab != NULL);
338    return *f_pDynSymTab;
339  }
340
341  LDSection& getFini() {
342    assert(f_pFini != NULL);
343    return *f_pFini;
344  }
345
346  const LDSection& getFini() const {
347    assert(f_pFini != NULL);
348    return *f_pFini;
349  }
350
351  LDSection& getFiniArray() {
352    assert(f_pFiniArray != NULL);
353    return *f_pFiniArray;
354  }
355
356  const LDSection& getFiniArray() const {
357    assert(f_pFiniArray != NULL);
358    return *f_pFiniArray;
359  }
360
361  LDSection& getHashTab() {
362    assert(f_pHashTab != NULL);
363    return *f_pHashTab;
364  }
365
366  const LDSection& getHashTab() const {
367    assert(f_pHashTab != NULL);
368    return *f_pHashTab;
369  }
370
371  LDSection& getInit() {
372    assert(f_pInit != NULL);
373    return *f_pInit;
374  }
375
376  const LDSection& getInit() const {
377    assert(f_pInit != NULL);
378    return *f_pInit;
379  }
380
381  LDSection& getInitArray() {
382    assert(f_pInitArray != NULL);
383    return *f_pInitArray;
384  }
385
386  const LDSection& getInitArray() const {
387    assert(f_pInitArray != NULL);
388    return *f_pInitArray;
389  }
390
391  LDSection& getInterp() {
392    assert(f_pInterp != NULL);
393    return *f_pInterp;
394  }
395
396  const LDSection& getInterp() const {
397    assert(f_pInterp != NULL);
398    return *f_pInterp;
399  }
400
401  LDSection& getLine() {
402    assert(f_pLine != NULL);
403    return *f_pLine;
404  }
405
406  const LDSection& getLine() const {
407    assert(f_pLine != NULL);
408    return *f_pLine;
409  }
410
411  LDSection& getNote() {
412    assert(f_pNote != NULL);
413    return *f_pNote;
414  }
415
416  const LDSection& getNote() const {
417    assert(f_pNote != NULL);
418    return *f_pNote;
419  }
420
421  LDSection& getPreInitArray() {
422    assert(f_pPreInitArray != NULL);
423    return *f_pPreInitArray;
424  }
425
426  const LDSection& getPreInitArray() const {
427    assert(f_pPreInitArray != NULL);
428    return *f_pPreInitArray;
429  }
430
431  LDSection& getROData1() {
432    assert(f_pROData1 != NULL);
433    return *f_pROData1;
434  }
435
436  const LDSection& getROData1() const {
437    assert(f_pROData1 != NULL);
438    return *f_pROData1;
439  }
440
441  LDSection& getShStrTab() {
442    assert(f_pShStrTab != NULL);
443    return *f_pShStrTab;
444  }
445
446  const LDSection& getShStrTab() const {
447    assert(f_pShStrTab != NULL);
448    return *f_pShStrTab;
449  }
450
451  LDSection& getStrTab() {
452    assert(f_pStrTab != NULL);
453    return *f_pStrTab;
454  }
455
456  const LDSection& getStrTab() const {
457    assert(f_pStrTab != NULL);
458    return *f_pStrTab;
459  }
460
461  LDSection& getSymTab() {
462    assert(f_pSymTab != NULL);
463    return *f_pSymTab;
464  }
465
466  const LDSection& getSymTab() const {
467    assert(f_pSymTab != NULL);
468    return *f_pSymTab;
469  }
470
471  LDSection& getTBSS() {
472    assert(f_pTBSS != NULL);
473    return *f_pTBSS;
474  }
475
476  const LDSection& getTBSS() const {
477    assert(f_pTBSS != NULL);
478    return *f_pTBSS;
479  }
480
481  LDSection& getTData() {
482    assert(f_pTData != NULL);
483    return *f_pTData;
484  }
485
486  const LDSection& getTData() const {
487    assert(f_pTData != NULL);
488    return *f_pTData;
489  }
490
491  /// @ref 10.3.1.2, ISO/IEC 23360, Part 1:2010(E), p. 24.
492  LDSection& getCtors() {
493    assert(f_pCtors != NULL);
494    return *f_pCtors;
495  }
496
497  const LDSection& getCtors() const {
498    assert(f_pCtors != NULL);
499    return *f_pCtors;
500  }
501
502  LDSection& getDataRelRo() {
503    assert(f_pDataRelRo != NULL);
504    return *f_pDataRelRo;
505  }
506
507  const LDSection& getDataRelRo() const {
508    assert(f_pDataRelRo != NULL);
509    return *f_pDataRelRo;
510  }
511
512  LDSection& getDtors() {
513    assert(f_pDtors != NULL);
514    return *f_pDtors;
515  }
516
517  const LDSection& getDtors() const {
518    assert(f_pDtors != NULL);
519    return *f_pDtors;
520  }
521
522  LDSection& getEhFrame() {
523    assert(f_pEhFrame != NULL);
524    return *f_pEhFrame;
525  }
526
527  const LDSection& getEhFrame() const {
528    assert(f_pEhFrame != NULL);
529    return *f_pEhFrame;
530  }
531
532  LDSection& getEhFrameHdr() {
533    assert(f_pEhFrameHdr != NULL);
534    return *f_pEhFrameHdr;
535  }
536
537  const LDSection& getEhFrameHdr() const {
538    assert(f_pEhFrameHdr != NULL);
539    return *f_pEhFrameHdr;
540  }
541
542  LDSection& getGCCExceptTable() {
543    assert(f_pGCCExceptTable != NULL);
544    return *f_pGCCExceptTable;
545  }
546
547  const LDSection& getGCCExceptTable() const {
548    assert(f_pGCCExceptTable != NULL);
549    return *f_pGCCExceptTable;
550  }
551
552  LDSection& getGNUVersion() {
553    assert(f_pGNUVersion != NULL);
554    return *f_pGNUVersion;
555  }
556
557  const LDSection& getGNUVersion() const {
558    assert(f_pGNUVersion != NULL);
559    return *f_pGNUVersion;
560  }
561
562  LDSection& getGNUVersionD() {
563    assert(f_pGNUVersionD != NULL);
564    return *f_pGNUVersionD;
565  }
566
567  const LDSection& getGNUVersionD() const {
568    assert(f_pGNUVersionD != NULL);
569    return *f_pGNUVersionD;
570  }
571
572  LDSection& getGNUVersionR() {
573    assert(f_pGNUVersionR != NULL);
574    return *f_pGNUVersionR;
575  }
576
577  const LDSection& getGNUVersionR() const {
578    assert(f_pGNUVersionR != NULL);
579    return *f_pGNUVersionR;
580  }
581
582  LDSection& getGOTPLT() {
583    assert(f_pGOTPLT != NULL);
584    return *f_pGOTPLT;
585  }
586
587  const LDSection& getGOTPLT() const {
588    assert(f_pGOTPLT != NULL);
589    return *f_pGOTPLT;
590  }
591
592  LDSection& getJCR() {
593    assert(f_pJCR != NULL);
594    return *f_pJCR;
595  }
596
597  const LDSection& getJCR() const {
598    assert(f_pJCR != NULL);
599    return *f_pJCR;
600  }
601
602  LDSection& getNoteABITag() {
603    assert(f_pNoteABITag != NULL);
604    return *f_pNoteABITag;
605  }
606
607  const LDSection& getNoteABITag() const {
608    assert(f_pNoteABITag != NULL);
609    return *f_pNoteABITag;
610  }
611
612  LDSection& getStab() {
613    assert(f_pStab != NULL);
614    return *f_pStab;
615  }
616
617  const LDSection& getStab() const {
618    assert(f_pStab != NULL);
619    return *f_pStab;
620  }
621
622  LDSection& getStabStr() {
623    assert(f_pStabStr != NULL);
624    return *f_pStabStr;
625  }
626
627  const LDSection& getStabStr() const {
628    assert(f_pStabStr != NULL);
629    return *f_pStabStr;
630  }
631
632  LDSection& getStack() {
633    assert(f_pStack != NULL);
634    return *f_pStack;
635  }
636
637  const LDSection& getStack() const {
638    assert(f_pStack != NULL);
639    return *f_pStack;
640  }
641
642  LDSection& getStackNote() {
643    assert(f_pStackNote != NULL);
644    return *f_pStackNote;
645  }
646
647  const LDSection& getStackNote() const {
648    assert(f_pStackNote != NULL);
649    return *f_pStackNote;
650  }
651
652  LDSection& getDataRelRoLocal() {
653    assert(f_pDataRelRoLocal != NULL);
654    return *f_pDataRelRoLocal;
655  }
656
657  const LDSection& getDataRelRoLocal() const {
658    assert(f_pDataRelRoLocal != NULL);
659    return *f_pDataRelRoLocal;
660  }
661
662  LDSection& getGNUHashTab() {
663    assert(f_pGNUHashTab != NULL);
664    return *f_pGNUHashTab;
665  }
666
667  const LDSection& getGNUHashTab() const {
668    assert(f_pGNUHashTab != NULL);
669    return *f_pGNUHashTab;
670  }
671
672 protected:
673  //         variable name         :  ELF
674  /// @ref Special Sections, Ch. 4.17, System V ABI, 4th edition.
675  LDSection* f_pNULLSection;
676  LDSection* f_pGOT;      // .got
677  LDSection* f_pPLT;      // .plt
678  LDSection* f_pRelDyn;   // .rel.dyn
679  LDSection* f_pRelPlt;   // .rel.plt
680  LDSection* f_pRelaDyn;  // .rela.dyn
681  LDSection* f_pRelaPlt;  // .rela.plt
682
683  /// @ref 10.3.1.1, ISO/IEC 23360, Part 1:2010(E), p. 21.
684  LDSection* f_pComment;       // .comment
685  LDSection* f_pData1;         // .data1
686  LDSection* f_pDebug;         // .debug
687  LDSection* f_pDynamic;       // .dynamic
688  LDSection* f_pDynStrTab;     // .dynstr
689  LDSection* f_pDynSymTab;     // .dynsym
690  LDSection* f_pFini;          // .fini
691  LDSection* f_pFiniArray;     // .fini_array
692  LDSection* f_pHashTab;       // .hash
693  LDSection* f_pInit;          // .init
694  LDSection* f_pInitArray;     // .init_array
695  LDSection* f_pInterp;        // .interp
696  LDSection* f_pLine;          // .line
697  LDSection* f_pNote;          // .note
698  LDSection* f_pPreInitArray;  // .preinit_array
699  LDSection* f_pROData1;       // .rodata1
700  LDSection* f_pShStrTab;      // .shstrtab
701  LDSection* f_pStrTab;        // .strtab
702  LDSection* f_pSymTab;        // .symtab
703  LDSection* f_pTBSS;          // .tbss
704  LDSection* f_pTData;         // .tdata
705
706  /// @ref 10.3.1.2, ISO/IEC 23360, Part 1:2010(E), p. 24.
707  LDSection* f_pCtors;           // .ctors
708  LDSection* f_pDataRelRo;       // .data.rel.ro
709  LDSection* f_pDtors;           // .dtors
710  LDSection* f_pEhFrame;         // .eh_frame
711  LDSection* f_pEhFrameHdr;      // .eh_frame_hdr
712  LDSection* f_pGCCExceptTable;  // .gcc_except_table
713  LDSection* f_pGNUVersion;      // .gnu.version
714  LDSection* f_pGNUVersionD;     // .gnu.version_d
715  LDSection* f_pGNUVersionR;     // .gnu.version_r
716  LDSection* f_pGOTPLT;          // .got.plt
717  LDSection* f_pJCR;             // .jcr
718  LDSection* f_pNoteABITag;      // .note.ABI-tag
719  LDSection* f_pStab;            // .stab
720  LDSection* f_pStabStr;         // .stabstr
721
722  /// practical
723  LDSection* f_pStack;           // .stack
724  LDSection* f_pStackNote;       // .note.GNU-stack
725  LDSection* f_pDataRelRoLocal;  // .data.rel.ro.local
726  LDSection* f_pGNUHashTab;      // .gnu.hash
727};
728
729}  // namespace mcld
730
731#endif  // MCLD_LD_ELFFILEFORMAT_H_
732