GNULDBackend.h revision affc150dc44fab1911775a49636d0ce85333b634
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_GNU_LDBACKEND_H 10#define MCLD_TARGET_GNU_LDBACKEND_H 11#ifdef ENABLE_UNITTEST 12#include <gtest.h> 13#endif 14 15#include <llvm/Support/ELF.h> 16#include <mcld/ADT/HashTable.h> 17#include <mcld/ADT/HashEntry.h> 18#include <mcld/LD/EhFrameHdr.h> 19#include <mcld/LD/ELFDynObjFileFormat.h> 20#include <mcld/LD/ELFDynObjReader.h> 21#include <mcld/LD/ELFDynObjWriter.h> 22#include <mcld/LD/ELFExecFileFormat.h> 23#include <mcld/LD/ELFExecWriter.h> 24#include <mcld/LD/ELFObjectReader.h> 25#include <mcld/LD/ELFObjectWriter.h> 26#include <mcld/LD/ELFSegment.h> 27#include <mcld/LD/ELFSegmentFactory.h> 28#include <mcld/LD/GNUArchiveReader.h> 29#include <mcld/Support/GCFactory.h> 30#include <mcld/Target/ELFDynamic.h> 31#include <mcld/Target/TargetLDBackend.h> 32 33namespace mcld 34{ 35 36struct SymCompare 37{ 38 bool operator()(const LDSymbol* X, const LDSymbol* Y) const 39 { return (X==Y); } 40}; 41 42struct PtrHash 43{ 44 size_t operator()(const LDSymbol* pKey) const 45 { 46 return (unsigned((uintptr_t)pKey) >> 4) ^ 47 (unsigned((uintptr_t)pKey) >> 9); 48 } 49}; 50 51class MCLDInfo; 52class Layout; 53class SymbolCategory; 54 55/** \class GNULDBackend 56 * \brief GNULDBackend provides a common interface for all GNU Unix-OS 57 * LDBackend. 58 */ 59class GNULDBackend : public TargetLDBackend 60{ 61protected: 62 GNULDBackend(); 63 64public: 65 virtual ~GNULDBackend(); 66 67 // ----- readers/writers ----- // 68 bool initArchiveReader(MCLinker& pLinker, MCLDInfo& pInfo); 69 bool initObjectReader(MCLinker& pLinker); 70 bool initDynObjReader(MCLinker& pLinker); 71 bool initObjectWriter(MCLinker& pLinker); 72 bool initDynObjWriter(MCLinker& pLinker); 73 bool initExecWriter(MCLinker& pLinker); 74 75 GNUArchiveReader *getArchiveReader(); 76 const GNUArchiveReader *getArchiveReader() const; 77 78 ELFObjectReader *getObjectReader(); 79 const ELFObjectReader *getObjectReader() const; 80 81 ELFDynObjReader *getDynObjReader(); 82 const ELFDynObjReader *getDynObjReader() const; 83 84 ELFObjectWriter *getObjectWriter(); 85 const ELFObjectWriter *getObjectWriter() const; 86 87 ELFDynObjWriter *getDynObjWriter(); 88 const ELFDynObjWriter *getDynObjWriter() const; 89 90 ELFExecWriter *getExecWriter(); 91 const ELFExecWriter *getExecWriter() const; 92 93 // ----- output sections ----- // 94 /// initExecSections - initialize sections of the output executable file. 95 bool initExecSections(MCLinker& pMCLinker); 96 97 /// initDynObjSections - initialize sections of the output shared object. 98 bool initDynObjSections(MCLinker& pMCLinker); 99 100 /// getOutputFormat - get the sections of the output file. 101 ELFFileFormat* getOutputFormat(const Output& pOutput); 102 const ELFFileFormat* getOutputFormat(const Output& pOutput) const; 103 104 ELFDynObjFileFormat* getDynObjFileFormat(); 105 const ELFDynObjFileFormat* getDynObjFileFormat() const; 106 107 ELFExecFileFormat* getExecFileFormat(); 108 const ELFExecFileFormat* getExecFileFormat() const; 109 110 // ----- target symbols ----- // 111 /// initStandardSymbols - initialize standard symbols. 112 /// Some section symbols is undefined in input object, and linkers must set 113 /// up its value. Take __init_array_begin for example. This symbol is an 114 /// undefined symbol in input objects. MCLinker must finalize its value 115 /// to the begin of the .init_array section, then relocation enties to 116 /// __init_array_begin can be applied without emission of "undefined 117 /// reference to `__init_array_begin'". 118 bool initStandardSymbols(MCLinker& pLinker, const Output& pOutput); 119 120 /// finalizeSymbol - Linker checks pSymbol.reserved() if it's not zero, 121 /// then it will ask backend to finalize the symbol value. 122 /// @return ture - if backend set the symbol value sucessfully 123 /// @return false - if backend do not recognize the symbol 124 bool finalizeSymbols(MCLinker& pLinker, const Output& pOutput) { 125 return (finalizeStandardSymbols(pLinker, pOutput) && 126 finalizeTargetSymbols(pLinker, pOutput)); 127 } 128 129 /// finalizeStandardSymbols - set the value of standard symbols 130 virtual bool finalizeStandardSymbols(MCLinker& pLinker, 131 const Output& pOutput); 132 133 /// finalizeTargetSymbols - set the value of target symbols 134 virtual bool finalizeTargetSymbols(MCLinker& pLinker, 135 const Output& pOutput) = 0; 136 137 size_t sectionStartOffset() const; 138 139 /// The return value of machine() it the same as e_machine in the ELF header*/ 140 virtual uint32_t machine() const = 0; 141 142 /// ELFVersion - the value of e_ident[EI_VERSION] 143 virtual uint8_t ELFVersion() const 144 { return llvm::ELF::EV_CURRENT; } 145 146 /// OSABI - the value of e_ident[EI_OSABI] 147 virtual uint8_t OSABI() const = 0; 148 149 /// ABIVersion - the value of e_ident[EI_ABIVRESION] 150 virtual uint8_t ABIVersion() const = 0; 151 152 /// flags - the value of ElfXX_Ehdr::e_flags 153 virtual uint64_t flags() const = 0; 154 155 /// entry - the symbol name of the entry point 156 virtual const char* entry() const 157 { return "_start"; } 158 159 /// dyld - the name of the default dynamic linker 160 /// target may override this function if needed. 161 /// @ref gnu ld, bfd/elf32-i386.c:521 162 virtual const char* dyld() const 163 { return "/usr/lib/libc.so.1"; } 164 165 /// defaultTextSegmentAddr - target should specify its own default start address 166 /// of the text segment. esp. for exec. 167 virtual uint64_t defaultTextSegmentAddr() const 168 { return 0x0; } 169 170 /// segmentStartAddr - this function returns the start address of the segment 171 uint64_t segmentStartAddr(const Output& pOutput, 172 const MCLDInfo& pInfo) const; 173 174 /// sizeNamePools - compute the size of regular name pools 175 /// In ELF executable files, regular name pools are .symtab, .strtab., 176 /// .dynsym, .dynstr, and .hash 177 virtual void sizeNamePools(const Output& pOutput, 178 const SymbolCategory& pSymbols, 179 const MCLDInfo& pLDInfo); 180 181 /// emitSectionData - emit target-dependent section data 182 virtual uint64_t emitSectionData(const Output& pOutput, 183 const LDSection& pSection, 184 const MCLDInfo& pInfo, 185 const Layout& pLayout, 186 MemoryRegion& pRegion) const = 0; 187 188 /// emitRegNamePools - emit regular name pools - .symtab, .strtab 189 virtual void emitRegNamePools(Output& pOutput, 190 SymbolCategory& pSymbols, 191 const Layout& pLayout, 192 const MCLDInfo& pLDInfo); 193 194 /// emitNamePools - emit dynamic name pools - .dyntab, .dynstr, .hash 195 virtual void emitDynNamePools(Output& pOutput, 196 SymbolCategory& pSymbols, 197 const Layout& pLayout, 198 const MCLDInfo& pLDInfo); 199 200 /// sizeInterp - compute the size of program interpreter's name 201 /// In ELF executables, this is the length of dynamic linker's path name 202 virtual void sizeInterp(const Output& pOutput, const MCLDInfo& pLDInfo); 203 204 /// emitInterp - emit the .interp 205 virtual void emitInterp(Output& pOutput, const MCLDInfo& pLDInfo); 206 207 /// getSectionOrder - compute the layout order of the section 208 /// Layout calls this function to get the default order of the pSectHdr. 209 /// If the pSectHdr.type() is LDFileFormat::Target, then getSectionOrder() 210 /// will call getTargetSectionOrder(). 211 /// 212 /// If targets favors certain order for general sections, please override 213 /// this function. 214 /// 215 /// @see getTargetSectionOrder 216 virtual unsigned int getSectionOrder(const Output& pOutput, 217 const LDSection& pSectHdr, 218 const MCLDInfo& pInfo) const; 219 220 /// getTargetSectionOrder - compute the layout order of target section 221 /// If the target favors certain order for the given gSectHdr, please 222 /// override this function. 223 /// 224 /// By default, this function returns the maximun order, and pSectHdr 225 /// will be the last section to be laid out. 226 virtual unsigned int 227 getTargetSectionOrder(const Output& pOutput, 228 const LDSection& pSectHdr, 229 const MCLDInfo& pInfo) const 230 { return (unsigned int)-1; } 231 232 /// numOfSegments - return the number of segments 233 /// if the target favors other ways to emit program header, please override 234 /// this function 235 virtual unsigned int numOfSegments() const 236 { return m_ELFSegmentTable.size(); } 237 238 /// elfSegmentTable - return the reference of the elf segment table 239 ELFSegmentFactory& elfSegmentTable() 240 { return m_ELFSegmentTable; } 241 242 /// elfSegmentTable - return the reference of the elf segment table 243 const ELFSegmentFactory& elfSegmentTable() const 244 { return m_ELFSegmentTable; } 245 246 /// commonPageSize - the common page size of the target machine, and we set it 247 /// to 4K here. If target favors the different size, please override this 248 /// function 249 virtual uint64_t commonPageSize(const MCLDInfo& pInfo) const; 250 251 /// abiPageSize - the abi page size of the target machine, and we set it to 4K 252 /// here. If target favors the different size, please override this function 253 virtual uint64_t abiPageSize(const MCLDInfo& pInfo) const; 254 255 /// getSymbolIdx - get the symbol index of ouput symbol table 256 size_t getSymbolIdx(LDSymbol* pSymbol) const; 257 258 /// isDefaultExecStack - target should specify whether the stack is default 259 /// executable. If target favors another choice, please override this function 260 virtual bool isDefaultExecStack() const 261 { return true; } 262 263 /// allocateCommonSymbols - allocate common symbols in the corresponding 264 /// sections. 265 /// Different concrete target backend may overlap this function. 266 virtual bool allocateCommonSymbols(const MCLDInfo& pLDInfo, MCLinker& pLinker) const; 267 268 /// isSymbolPreemtible - whether the symbol can be preemted by other 269 /// link unit 270 /// @ref Google gold linker, symtab.h:551 271 bool isSymbolPreemptible(const ResolveInfo& pSym, 272 const MCLDInfo& pLDInfo, 273 const Output& pOutput) const; 274 275protected: 276 uint64_t getSymbolSize(const LDSymbol& pSymbol) const; 277 278 uint64_t getSymbolInfo(const LDSymbol& pSymbol) const; 279 280 uint64_t getSymbolValue(const LDSymbol& pSymbol) const; 281 282 uint64_t getSymbolShndx(const LDSymbol& pSymbol, const Layout& pLayout) const; 283 284 /// getHashBucketCount - calculate hash bucket count. 285 /// @ref Google gold linker, dynobj.cc:791 286 static unsigned getHashBucketCount(unsigned pNumOfSymbols, bool pIsGNUStyle); 287 288 /// isDynamicSymbol 289 /// @ref Google gold linker: symtab.cc:311 290 static bool isDynamicSymbol(const LDSymbol& pSymbol, const Output& pOutput); 291 292 /// isOutputPIC - return whether the output is position-independent 293 bool isOutputPIC(const Output& pOutput, const MCLDInfo& pInfo) const; 294 295 /// isStaticLink - return whether we're doing static link 296 bool isStaticLink(const Output& pOutput, const MCLDInfo& pInfo) const; 297 298public: 299 /// symbolNeedsPLT - return whether the symbol needs a PLT entry 300 /// @ref Google gold linker, symtab.h:596 301 bool symbolNeedsPLT(const ResolveInfo& pSym, 302 const MCLDInfo& pLDInfo, 303 const Output& pOutput) const; 304 305 /// symbolNeedsDynRel - return whether the symbol needs a dynamic relocation 306 /// @ref Google gold linker, symtab.h:645 307 bool symbolNeedsDynRel(const ResolveInfo& pSym, 308 bool pSymHasPLT, 309 const MCLDInfo& pLDInfo, 310 const Output& pOutput, 311 bool isAbsReloc) const; 312 313 /// symbolNeedsCopyReloc - return whether the symbol needs a copy relocation 314 bool symbolNeedsCopyReloc(const Layout& pLayout, 315 const Relocation& pReloc, 316 const ResolveInfo& pSym, 317 const MCLDInfo& pLDInfo, 318 const Output& pOutput) const; 319 320private: 321 /// createProgramHdrs - base on output sections to create the program headers 322 void createProgramHdrs(Output& pOutput, 323 const MCLDInfo& pInfo); 324 325 /// setupProgramHdrs - set up the attributes of segments 326 /// (i.e., offset, addresses, file/mem size, flag, and alignment) 327 void setupProgramHdrs(const Output& pOutput, const MCLDInfo& pInfo); 328 329 /// getSegmentFlag - give a section flag and return the corresponding segment 330 /// flag 331 inline uint32_t getSegmentFlag(const uint32_t pSectionFlag) 332 { 333 uint32_t flag = llvm::ELF::PF_R; 334 if (0 != (pSectionFlag & llvm::ELF::SHF_WRITE)) 335 flag |= llvm::ELF::PF_W; 336 if (0 != (pSectionFlag & llvm::ELF::SHF_EXECINSTR)) 337 flag |= llvm::ELF::PF_X; 338 return flag; 339 } 340 341 /// createGNUStackInfo - create an output GNU stack section or segment if needed 342 void createGNUStackInfo(const Output& pOutput, 343 const MCLDInfo& pInfo, 344 MCLinker& pLinker); 345 346 /// preLayout - Backend can do any needed modification before layout 347 void preLayout(const Output& pOutput, 348 const MCLDInfo& pInfo, 349 MCLinker& pLinker); 350 351 /// postLayout -Backend can do any needed modification after layout 352 void postLayout(const Output& pOutput, 353 const MCLDInfo& pInfo, 354 MCLinker& pLinker); 355 356 /// preLayout - Backend can do any needed modification before layout 357 virtual void doPreLayout(const Output& pOutput, 358 const MCLDInfo& pInfo, 359 MCLinker& pLinker) = 0; 360 361 /// postLayout -Backend can do any needed modification after layout 362 virtual void doPostLayout(const Output& pOutput, 363 const MCLDInfo& pInfo, 364 MCLinker& pLinker) = 0; 365 366 /// postProcessing - Backend can do any needed modification in the final stage 367 void postProcessing(const Output& pOutput, 368 const MCLDInfo& pInfo, 369 MCLinker& pLinker); 370 371 /// dynamic - the dynamic section of the target machine. 372 virtual ELFDynamic& dynamic() = 0; 373 374 /// dynamic - the dynamic section of the target machine. 375 virtual const ELFDynamic& dynamic() const = 0; 376 377protected: 378 // Based on Kind in LDFileFormat to define basic section orders for ELF, and 379 // refer gold linker to add more enumerations to handle Regular and BSS kind 380 enum SectionOrder { 381 SHO_INTERP = 1, // .interp 382 SHO_RO_NOTE, // .note.ABI-tag, .note.gnu.build-id 383 SHO_NAMEPOOL, // *.hash, .dynsym, .dynstr 384 SHO_RELOCATION, // .rel.*, .rela.* 385 SHO_REL_PLT, // .rel.plt should come after other .rel.* 386 SHO_INIT, // .init 387 SHO_PLT, // .plt 388 SHO_TEXT, // .text 389 SHO_FINI, // .fini 390 SHO_RO, // .rodata 391 SHO_EXCEPTION, // .eh_frame_hdr, .eh_frame, .gcc_except_table 392 SHO_TLS_DATA, // .tdata 393 SHO_TLS_BSS, // .tbss 394 SHO_RELRO_LOCAL, // .data.rel.ro.local 395 SHO_RELRO, // .data.rel.ro, 396 SHO_RELRO_LAST, // for x86 to adjust .got if needed 397 SHO_NON_RELRO_FIRST, // for x86 to adjust .got.plt if needed 398 SHO_DATA, // .data 399 SHO_LARGE_DATA, // .ldata 400 SHO_RW_NOTE, // 401 SHO_SMALL_DATA, // .sdata 402 SHO_SMALL_BSS, // .sbss 403 SHO_BSS, // .bss 404 SHO_LARGE_BSS, // .lbss 405 SHO_UNDEFINED = ~(0U) // default order 406 }; 407 408 typedef HashEntry<LDSymbol*, size_t, SymCompare> HashEntryType; 409 typedef HashTable<HashEntryType, PtrHash, EntryFactory<HashEntryType> > HashTableType; 410 411protected: 412 // ----- readers and writers ----- // 413 GNUArchiveReader* m_pArchiveReader; 414 ELFObjectReader* m_pObjectReader; 415 ELFDynObjReader* m_pDynObjReader; 416 ELFObjectWriter* m_pObjectWriter; 417 ELFDynObjWriter* m_pDynObjWriter; 418 ELFExecWriter* m_pExecWriter; 419 420 // ----- file formats ----- // 421 ELFDynObjFileFormat* m_pDynObjFileFormat; 422 ELFExecFileFormat* m_pExecFileFormat; 423 424 // ELF segment factory 425 ELFSegmentFactory m_ELFSegmentTable; 426 427 // map the LDSymbol to its index in the output symbol table 428 HashTableType* m_pSymIndexMap; 429 430 // section .eh_frame_hdr 431 EhFrameHdr* m_pEhFrameHdr; 432 433 // ----- standard symbols ----- // 434 // section symbols 435 LDSymbol* f_pPreInitArrayStart; 436 LDSymbol* f_pPreInitArrayEnd; 437 LDSymbol* f_pInitArrayStart; 438 LDSymbol* f_pInitArrayEnd; 439 LDSymbol* f_pFiniArrayStart; 440 LDSymbol* f_pFiniArrayEnd; 441 LDSymbol* f_pStack; 442 443 // segment symbols 444 LDSymbol* f_pExecutableStart; 445 LDSymbol* f_pEText; 446 LDSymbol* f_p_EText; 447 LDSymbol* f_p__EText; 448 LDSymbol* f_pEData; 449 LDSymbol* f_p_EData; 450 LDSymbol* f_pBSSStart; 451 LDSymbol* f_pEnd; 452 LDSymbol* f_p_End; 453}; 454 455} // namespace of mcld 456 457#endif 458 459