1 //===- GNULDBackend.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_TARGET_GNULDBACKEND_H_ 10 #define MCLD_TARGET_GNULDBACKEND_H_ 11 12 #include "mcld/Module.h" 13 #include "mcld/LD/ELFBinaryReader.h" 14 #include "mcld/LD/ELFDynObjReader.h" 15 #include "mcld/LD/ELFObjectReader.h" 16 #include "mcld/LD/ELFObjectWriter.h" 17 #include "mcld/LD/GNUArchiveReader.h" 18 #include "mcld/Target/TargetLDBackend.h" 19 20 #include <llvm/Support/ELF.h> 21 22 #include <cstdint> 23 24 namespace mcld { 25 26 class BranchIslandFactory; 27 class EhFrameHdr; 28 class ELFAttribute; 29 class ELFDynamic; 30 class ELFDynObjFileFormat; 31 class ELFExecFileFormat; 32 class ELFFileFormat; 33 class ELFObjectFileFormat; 34 class ELFSegmentFactory; 35 class GNUInfo; 36 class IRBuilder; 37 class Layout; 38 class LinkerConfig; 39 class LinkerScript; 40 class Module; 41 class Relocation; 42 class StubFactory; 43 44 /** \class GNULDBackend 45 * \brief GNULDBackend provides a common interface for all GNU Unix-OS 46 * LDBackend. 47 */ 48 class GNULDBackend : public TargetLDBackend { 49 protected: 50 GNULDBackend(const LinkerConfig& pConfig, GNUInfo* pInfo); 51 52 public: 53 virtual ~GNULDBackend(); 54 55 // ----- readers/writers ----- // 56 GNUArchiveReader* createArchiveReader(Module& pModule); 57 ELFObjectReader* createObjectReader(IRBuilder& pBuilder); 58 ELFDynObjReader* createDynObjReader(IRBuilder& pBuilder); 59 ELFBinaryReader* createBinaryReader(IRBuilder& pBuilder); 60 ELFObjectWriter* createWriter(); 61 62 // ----- output sections ----- // 63 /// initStdSections - initialize standard sections of the output file. 64 bool initStdSections(ObjectBuilder& pBuilder); 65 66 /// getOutputFormat - get the sections of the output file. 67 const ELFFileFormat* getOutputFormat() const; 68 ELFFileFormat* getOutputFormat(); 69 70 // ----- target symbols ----- // 71 /// initStandardSymbols - initialize standard symbols. 72 /// Some section symbols is undefined in input object, and linkers must set 73 /// up its value. Take __init_array_begin for example. This symbol is an 74 /// undefined symbol in input objects. ObjectLinker must finalize its value 75 /// to the begin of the .init_array section, then relocation enties to 76 /// __init_array_begin can be applied without emission of "undefined 77 /// reference to `__init_array_begin'". 78 bool initStandardSymbols(IRBuilder& pBuilder, Module& pModule); 79 80 /// finalizeSymbol - Linker checks pSymbol.reserved() if it's not zero, 81 /// then it will ask backend to finalize the symbol value. 82 /// @return ture - if backend set the symbol value sucessfully 83 /// @return false - if backend do not recognize the symbol finalizeSymbols()84 bool finalizeSymbols() { 85 return (finalizeStandardSymbols() && finalizeTargetSymbols()); 86 } 87 88 /// finalizeStandardSymbols - set the value of standard symbols 89 virtual bool finalizeStandardSymbols(); 90 91 /// finalizeTargetSymbols - set the value of target symbols 92 virtual bool finalizeTargetSymbols() = 0; 93 94 /// finalizeTLSSymbol - set the value of a TLS symbol 95 virtual bool finalizeTLSSymbol(LDSymbol& pSymbol); 96 97 size_t sectionStartOffset() const; 98 getInfo()99 const GNUInfo& getInfo() const { return *m_pInfo; } getInfo()100 GNUInfo& getInfo() { return *m_pInfo; } 101 hasTextRel()102 bool hasTextRel() const { return m_bHasTextRel; } 103 hasStaticTLS()104 bool hasStaticTLS() const { return m_bHasStaticTLS; } 105 106 /// getSegmentStartAddr - return the start address of the segment 107 uint64_t getSegmentStartAddr(const LinkerScript& pScript) const; 108 109 /// sizeShstrtab - compute the size of .shstrtab 110 void sizeShstrtab(Module& pModule); 111 112 /// sizeNamePools - compute the size of regular name pools 113 /// In ELF executable files, regular name pools are .symtab, .strtab., 114 /// .dynsym, .dynstr, and .hash 115 virtual void sizeNamePools(Module& pModule); 116 117 /// emitSectionData - emit target-dependent section data 118 virtual uint64_t emitSectionData(const LDSection& pSection, 119 MemoryRegion& pRegion) const = 0; 120 121 /// emitRegNamePools - emit regular name pools - .symtab, .strtab 122 virtual void emitRegNamePools(const Module& pModule, 123 FileOutputBuffer& pOutput); 124 125 /// emitNamePools - emit dynamic name pools - .dyntab, .dynstr, .hash 126 virtual void emitDynNamePools(Module& pModule, FileOutputBuffer& pOutput); 127 128 /// emitELFHashTab - emit .hash 129 virtual void emitELFHashTab(const Module::SymbolTable& pSymtab, 130 FileOutputBuffer& pOutput); 131 132 /// emitGNUHashTab - emit .gnu.hash 133 virtual void emitGNUHashTab(Module::SymbolTable& pSymtab, 134 FileOutputBuffer& pOutput); 135 136 /// sizeInterp - compute the size of program interpreter's name 137 /// In ELF executables, this is the length of dynamic linker's path name 138 virtual void sizeInterp(); 139 140 /// emitInterp - emit the .interp 141 virtual void emitInterp(FileOutputBuffer& pOutput); 142 143 /// hasEntryInStrTab - symbol has an entry in a .strtab 144 virtual bool hasEntryInStrTab(const LDSymbol& pSym) const; 145 146 /// orderSymbolTable - order symbol table before emitting 147 virtual void orderSymbolTable(Module& pModule); 148 149 void setHasStaticTLS(bool pVal = true) { m_bHasStaticTLS = pVal; } 150 151 /// getSectionOrder - compute the layout order of the section 152 /// Layout calls this function to get the default order of the pSectHdr. 153 /// If the pSectHdr.type() is LDFileFormat::Target, then getSectionOrder() 154 /// will call getTargetSectionOrder(). 155 /// 156 /// If targets favors certain order for general sections, please override 157 /// this function. 158 /// 159 /// @see getTargetSectionOrder 160 virtual unsigned int getSectionOrder(const LDSection& pSectHdr) const; 161 162 /// getTargetSectionOrder - compute the layout order of target section 163 /// If the target favors certain order for the given gSectHdr, please 164 /// override this function. 165 /// 166 /// By default, this function returns the maximun order, and pSectHdr 167 /// will be the last section to be laid out. getTargetSectionOrder(const LDSection & pSectHdr)168 virtual unsigned int getTargetSectionOrder(const LDSection& pSectHdr) const { 169 return (unsigned int)-1; 170 } 171 172 /// elfSegmentTable - return the reference of the elf segment table 173 ELFSegmentFactory& elfSegmentTable(); 174 175 /// elfSegmentTable - return the reference of the elf segment table 176 const ELFSegmentFactory& elfSegmentTable() const; 177 178 /// commonPageSize - the common page size of the target machine 179 uint64_t commonPageSize() const; 180 181 /// abiPageSize - the abi page size of the target machine 182 uint64_t abiPageSize() const; 183 184 /// getSymbolIdx - get the symbol index of ouput symbol table 185 size_t getSymbolIdx(const LDSymbol* pSymbol) const; 186 187 /// allocateCommonSymbols - allocate common symbols in the corresponding 188 /// sections. 189 /// Different concrete target backend may overlap this function. 190 virtual bool allocateCommonSymbols(Module& pModule); 191 192 /// mergeFlags - update set of ELF header flags mergeFlags(Input & pInput,const char * ELF_hdr)193 virtual void mergeFlags(Input& pInput, const char* ELF_hdr) {} 194 195 /// updateSectionFlags - update pTo's flags when merging pFrom 196 /// update the output section flags based on input section flags. 197 virtual bool updateSectionFlags(LDSection& pTo, const LDSection& pFrom); 198 199 /// readRelocation - read ELF32_Rel entry 200 virtual bool readRelocation(const llvm::ELF::Elf32_Rel& pRel, 201 uint32_t& pType, 202 uint32_t& pSymIdx, 203 uint32_t& pOffset) const; 204 205 /// readRelocation - read ELF32_Rela entry 206 virtual bool readRelocation(const llvm::ELF::Elf32_Rela& pRel, 207 uint32_t& pType, 208 uint32_t& pSymIdx, 209 uint32_t& pOffset, 210 int32_t& pAddend) const; 211 212 /// readRelocation - read ELF64_Rel entry 213 virtual bool readRelocation(const llvm::ELF::Elf64_Rel& pRel, 214 uint32_t& pType, 215 uint32_t& pSymIdx, 216 uint64_t& pOffset) const; 217 218 /// readRel - read ELF64_Rela entry 219 virtual bool readRelocation(const llvm::ELF::Elf64_Rela& pRel, 220 uint32_t& pType, 221 uint32_t& pSymIdx, 222 uint64_t& pOffset, 223 int64_t& pAddend) const; 224 225 /// emitRelocation - write data to the ELF32_Rel entry 226 virtual void emitRelocation(llvm::ELF::Elf32_Rel& pRel, 227 uint32_t pType, 228 uint32_t pSymIdx, 229 uint32_t pOffset) const; 230 231 /// emitRelocation - write data to the ELF32_Rela entry 232 virtual void emitRelocation(llvm::ELF::Elf32_Rela& pRel, 233 uint32_t pType, 234 uint32_t pSymIdx, 235 uint32_t pOffset, 236 int32_t pAddend) const; 237 238 /// emitRelocation - write data to the ELF64_Rel entry 239 virtual void emitRelocation(llvm::ELF::Elf64_Rel& pRel, 240 uint32_t pType, 241 uint32_t pSymIdx, 242 uint64_t pOffset) const; 243 244 /// emitRelocation - write data to the ELF64_Rela entry 245 virtual void emitRelocation(llvm::ELF::Elf64_Rela& pRel, 246 uint32_t pType, 247 uint32_t pSymIdx, 248 uint64_t pOffset, 249 int64_t pAddend) const; 250 251 /// symbolNeedsPLT - return whether the symbol needs a PLT entry 252 bool symbolNeedsPLT(const ResolveInfo& pSym) const; 253 254 /// symbolNeedsCopyReloc - return whether the symbol needs a copy relocation 255 bool symbolNeedsCopyReloc(const Relocation& pReloc, 256 const ResolveInfo& pSym) const; 257 258 /// symbolNeedsDynRel - return whether the symbol needs a dynamic relocation 259 bool symbolNeedsDynRel(const ResolveInfo& pSym, 260 bool pSymHasPLT, 261 bool isAbsReloc) const; 262 263 /// isSymbolPreemptible - whether the symbol can be preemted by other link 264 /// units 265 bool isSymbolPreemptible(const ResolveInfo& pSym) const; 266 267 /// symbolHasFinalValue - return true if the symbol's value can be decided at 268 /// link time 269 bool symbolFinalValueIsKnown(const ResolveInfo& pSym) const; 270 271 /// isDynamicSymbol 272 bool isDynamicSymbol(const LDSymbol& pSymbol) const; 273 274 /// isDynamicSymbol 275 bool isDynamicSymbol(const ResolveInfo& pResolveInfo) const; 276 getSymDesc(uint16_t pShndx)277 virtual ResolveInfo::Desc getSymDesc(uint16_t pShndx) const { 278 return ResolveInfo::Define; 279 } 280 hasTDATASymbol()281 bool hasTDATASymbol() const { return (f_pTDATA != NULL); } hasTBSSSymbol()282 bool hasTBSSSymbol() const { return (f_pTBSS != NULL); } 283 setTDATASymbol(LDSymbol & pTDATA)284 void setTDATASymbol(LDSymbol& pTDATA) { f_pTDATA = &pTDATA; } setTBSSSymbol(LDSymbol & pTBSS)285 void setTBSSSymbol(LDSymbol& pTBSS) { f_pTBSS = &pTBSS; } 286 287 // getTDATASymbol - get section symbol of .tdata 288 LDSymbol& getTDATASymbol(); 289 const LDSymbol& getTDATASymbol() const; 290 291 /// getTBSSSymbol - get section symbol of .tbss 292 LDSymbol& getTBSSSymbol(); 293 const LDSymbol& getTBSSSymbol() const; 294 295 /// getEntry - get the entry point name 296 llvm::StringRef getEntry(const Module& pModule) const; 297 298 // ----- relaxation ----- // 299 /// initBRIslandFactory - initialize the branch island factory for relaxation 300 bool initBRIslandFactory(); 301 302 /// initStubFactory - initialize the stub factory for relaxation 303 bool initStubFactory(); 304 305 /// getBRIslandFactory getBRIslandFactory()306 BranchIslandFactory* getBRIslandFactory() { return m_pBRIslandFactory; } 307 308 /// getStubFactory getStubFactory()309 StubFactory* getStubFactory() { return m_pStubFactory; } 310 311 /// maxFwdBranchOffset - return the max forward branch offset of the backend. 312 /// Target can override this function if needed. maxFwdBranchOffset()313 virtual int64_t maxFwdBranchOffset() const { return INT64_MAX; } 314 315 /// maxBwdBranchOffset - return the max backward branch offset of the backend. 316 /// Target can override this function if needed. maxBwdBranchOffset()317 virtual int64_t maxBwdBranchOffset() const { return 0; } 318 319 /// stubGroupSize - return the group size to place stubs between sections. 320 virtual unsigned stubGroupSize() const; 321 322 /// checkAndSetHasTextRel - check pSection flag to set HasTextRel 323 void checkAndSetHasTextRel(const LDSection& pSection); 324 325 /// sortRelocation - sort the dynamic relocations to let dynamic linker 326 /// process relocations more efficiently 327 void sortRelocation(LDSection& pSection); 328 329 /// createAndSizeEhFrameHdr - This is seperated since we may add eh_frame 330 /// entry in the middle 331 void createAndSizeEhFrameHdr(Module& pModule); 332 333 /// attribute - the attribute section data. attribute()334 ELFAttribute& attribute() { return *m_pAttribute; } 335 336 /// attribute - the attribute section data. attribute()337 const ELFAttribute& attribute() const { return *m_pAttribute; } 338 339 /// mayHaveUnsafeFunctionPointerAccess - check if the section may have unsafe 340 /// function pointer access 341 bool mayHaveUnsafeFunctionPointerAccess(const LDSection& pSection) const; 342 343 protected: 344 /// getRelEntrySize - the size in BYTE of rel type relocation 345 virtual size_t getRelEntrySize() = 0; 346 347 /// getRelEntrySize - the size in BYTE of rela type relocation 348 virtual size_t getRelaEntrySize() = 0; 349 350 uint64_t getSymbolSize(const LDSymbol& pSymbol) const; 351 352 uint64_t getSymbolInfo(const LDSymbol& pSymbol) const; 353 354 uint64_t getSymbolValue(const LDSymbol& pSymbol) const; 355 356 uint64_t getSymbolShndx(const LDSymbol& pSymbol) const; 357 358 /// isTemporary - Whether pSymbol is a local label. 359 virtual bool isTemporary(const LDSymbol& pSymbol) const; 360 361 /// getHashBucketCount - calculate hash bucket count. 362 static unsigned getHashBucketCount(unsigned pNumOfSymbols, bool pIsGNUStyle); 363 364 /// getGNUHashMaskbitslog2 - calculate the number of mask bits in log2 365 unsigned getGNUHashMaskbitslog2(unsigned pNumOfSymbols) const; 366 367 /// emitSymbol32 - emit an ELF32 symbol 368 void emitSymbol32(llvm::ELF::Elf32_Sym& pSym32, 369 LDSymbol& pSymbol, 370 char* pStrtab, 371 size_t pStrtabsize, 372 size_t pSymtabIdx); 373 374 /// emitSymbol64 - emit an ELF64 symbol 375 void emitSymbol64(llvm::ELF::Elf64_Sym& pSym64, 376 LDSymbol& pSymbol, 377 char* pStrtab, 378 size_t pStrtabsize, 379 size_t pSymtabIdx); 380 381 protected: 382 /// createProgramHdrs - base on output sections to create the program headers 383 void createProgramHdrs(Module& pModule); 384 385 /// doCreateProgramHdrs - backend can implement this function to create the 386 /// target-dependent segments 387 virtual void doCreateProgramHdrs(Module& pModule) = 0; 388 389 /// setupProgramHdrs - set up the attributes of segments 390 /// (i.e., offset, addresses, file/mem size, flag, and alignment) 391 void setupProgramHdrs(const LinkerScript& pScript); 392 393 /// getSegmentFlag - give a section flag and return the corresponding segment 394 /// flag 395 inline uint32_t getSegmentFlag(const uint32_t pSectionFlag); 396 397 /// setupGNUStackInfo - setup the section flag of .note.GNU-stack in output 398 void setupGNUStackInfo(Module& pModule); 399 400 /// setOutputSectionOffset - helper function to set output sections' offset. 401 void setOutputSectionOffset(Module& pModule); 402 403 /// setOutputSectionAddress - helper function to set output sections' address. 404 void setOutputSectionAddress(Module& pModule); 405 406 /// placeOutputSections - place output sections based on SectionMap 407 void placeOutputSections(Module& pModule); 408 409 /// layout - layout method 410 void layout(Module& pModule); 411 412 /// preLayout - Backend can do any needed modification before layout 413 void preLayout(Module& pModule, IRBuilder& pBuilder); 414 415 /// postLayout -Backend can do any needed modification after layout 416 void postLayout(Module& pModule, IRBuilder& pBuilder); 417 418 /// preLayout - Backend can do any needed modification before layout 419 virtual void doPreLayout(IRBuilder& pBuilder) = 0; 420 421 /// postLayout -Backend can do any needed modification after layout 422 virtual void doPostLayout(Module& pModule, IRBuilder& pLinker) = 0; 423 424 /// postProcessing - Backend can do any needed modification in the final stage 425 void postProcessing(FileOutputBuffer& pOutput); 426 427 /// dynamic - the dynamic section of the target machine. 428 virtual ELFDynamic& dynamic() = 0; 429 430 /// dynamic - the dynamic section of the target machine. 431 virtual const ELFDynamic& dynamic() const = 0; 432 433 /// relax - the relaxation pass 434 virtual bool relax(Module& pModule, IRBuilder& pBuilder); 435 436 /// mayRelax - Backends should override this function if they need relaxation mayRelax()437 virtual bool mayRelax() { return false; } 438 439 /// doRelax - Backend can orevride this function to add its relaxation 440 /// implementation. Return true if the output (e.g., .text) is "relaxed" 441 /// (i.e. layout is changed), and set pFinished to true if everything is fit, 442 /// otherwise set it to false. doRelax(Module & pModule,IRBuilder & pBuilder,bool & pFinished)443 virtual bool doRelax(Module& pModule, IRBuilder& pBuilder, bool& pFinished) { 444 return false; 445 } 446 447 protected: 448 // Based on Kind in LDFileFormat to define basic section orders for ELF. 449 enum SectionOrder { 450 SHO_NULL = 0, // NULL 451 SHO_INTERP, // .interp 452 SHO_RO_NOTE, // .note.ABI-tag, .note.gnu.build-id 453 SHO_NAMEPOOL, // *.hash, .dynsym, .dynstr 454 SHO_RELOCATION, // .rel.*, .rela.* 455 SHO_REL_PLT, // .rel.plt should come after other .rel.* 456 SHO_INIT, // .init 457 SHO_PLT, // .plt 458 SHO_TEXT, // .text 459 SHO_FINI, // .fini 460 SHO_RO, // .rodata 461 SHO_EXCEPTION, // .eh_frame_hdr, .eh_frame, .gcc_except_table 462 SHO_TLS_DATA, // .tdata 463 SHO_TLS_BSS, // .tbss 464 SHO_RELRO_LOCAL, // .data.rel.ro.local 465 SHO_RELRO, // .data.rel.ro, 466 SHO_RELRO_LAST, // for x86 to adjust .got if needed 467 SHO_NON_RELRO_FIRST, // for x86 to adjust .got.plt if needed 468 SHO_DATA, // .data 469 SHO_LARGE_DATA, // .ldata 470 SHO_RW_NOTE, // 471 SHO_SMALL_DATA, // .sdata 472 SHO_SMALL_BSS, // .sbss 473 SHO_BSS, // .bss 474 SHO_LARGE_BSS, // .lbss 475 SHO_UNDEFINED, // default order 476 SHO_STRTAB // .strtab 477 }; 478 479 // for -z combreloc 480 struct RelocCompare { RelocCompareRelocCompare481 explicit RelocCompare(const GNULDBackend& pBackend) : m_Backend(pBackend) {} 482 bool operator()(const Relocation& X, const Relocation& Y) const; 483 484 private: 485 const GNULDBackend& m_Backend; 486 }; 487 488 // for gnu style hash table 489 struct DynsymCompare { 490 bool needGNUHash(const LDSymbol& X) const; 491 492 bool operator()(const LDSymbol* X, const LDSymbol* Y) const; 493 }; 494 495 struct SymCompare { operatorSymCompare496 bool operator()(const LDSymbol* X, const LDSymbol* Y) const { 497 return (X == Y); 498 } 499 }; 500 501 struct SymPtrHash { operatorSymPtrHash502 size_t operator()(const LDSymbol* pKey) const { 503 return (unsigned((uintptr_t)pKey) >> 4) ^ 504 (unsigned((uintptr_t)pKey) >> 9); 505 } 506 }; 507 508 typedef HashEntry<LDSymbol*, size_t, SymCompare> SymHashEntryType; 509 typedef HashTable<SymHashEntryType, 510 SymPtrHash, 511 EntryFactory<SymHashEntryType> > HashTableType; 512 513 protected: 514 ELFObjectReader* m_pObjectReader; 515 516 // ----- file formats ----- // 517 ELFDynObjFileFormat* m_pDynObjFileFormat; 518 ELFExecFileFormat* m_pExecFileFormat; 519 ELFObjectFileFormat* m_pObjectFileFormat; 520 521 // GNUInfo 522 GNUInfo* m_pInfo; 523 524 // ELF segment factory 525 ELFSegmentFactory* m_pELFSegmentTable; 526 527 // branch island factory 528 BranchIslandFactory* m_pBRIslandFactory; 529 530 // stub factory 531 StubFactory* m_pStubFactory; 532 533 // map the LDSymbol to its index in the output symbol table 534 HashTableType* m_pSymIndexMap; 535 536 // section .eh_frame_hdr 537 EhFrameHdr* m_pEhFrameHdr; 538 539 // attribute section 540 ELFAttribute* m_pAttribute; 541 542 // ----- dynamic flags ----- // 543 // DF_TEXTREL of DT_FLAGS 544 bool m_bHasTextRel; 545 546 // DF_STATIC_TLS of DT_FLAGS 547 bool m_bHasStaticTLS; 548 549 // ----- standard symbols ----- // 550 // section symbols 551 LDSymbol* f_pPreInitArrayStart; 552 LDSymbol* f_pPreInitArrayEnd; 553 LDSymbol* f_pInitArrayStart; 554 LDSymbol* f_pInitArrayEnd; 555 LDSymbol* f_pFiniArrayStart; 556 LDSymbol* f_pFiniArrayEnd; 557 LDSymbol* f_pStack; 558 LDSymbol* f_pDynamic; 559 560 // section symbols for .tdata and .tbss 561 LDSymbol* f_pTDATA; 562 LDSymbol* f_pTBSS; 563 564 // segment symbols 565 LDSymbol* f_pExecutableStart; 566 LDSymbol* f_pEText; 567 LDSymbol* f_p_EText; 568 LDSymbol* f_p__EText; 569 LDSymbol* f_pEData; 570 LDSymbol* f_p_EData; 571 LDSymbol* f_pBSSStart; 572 LDSymbol* f_pEnd; 573 LDSymbol* f_p_End; 574 }; 575 576 } // namespace mcld 577 578 #endif // MCLD_TARGET_GNULDBACKEND_H_ 579