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