1 //===- GNULDBackend.cpp ---------------------------------------------------===// 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 #include <llvm/Support/ELF.h> 10 #include <mcld/ADT/SizeTraits.h> 11 #include <mcld/Target/GNULDBackend.h> 12 #include <mcld/MC/MCLDInfo.h> 13 #include <mcld/MC/MCLDOutput.h> 14 #include <mcld/MC/MCLDInputTree.h> 15 #include <mcld/MC/SymbolCategory.h> 16 #include <mcld/LD/LDSymbol.h> 17 #include <mcld/LD/Layout.h> 18 #include <mcld/Support/MemoryArea.h> 19 #include <mcld/Support/MemoryRegion.h> 20 #include <string> 21 #include <cstring> 22 #include <cassert> 23 24 using namespace mcld; 25 26 //===----------------------------------------------------------------------===// 27 // GNULDBackend 28 GNULDBackend::GNULDBackend() 29 : m_pArchiveReader(0), 30 m_pObjectReader(0), 31 m_pDynObjReader(0), 32 m_pObjectWriter(0), 33 m_pDynObjWriter(0), 34 m_pDynObjFileFormat(0), 35 m_pExecFileFormat(0), 36 m_ELFSegmentTable(9)// magic number 37 { 38 m_pSymIndexMap = new HashTableType(1024); 39 } 40 41 GNULDBackend::~GNULDBackend() 42 { 43 if (m_pArchiveReader) 44 delete m_pArchiveReader; 45 if (m_pObjectReader) 46 delete m_pObjectReader; 47 if (m_pDynObjReader) 48 delete m_pDynObjReader; 49 if (m_pObjectWriter) 50 delete m_pObjectWriter; 51 if (m_pDynObjWriter) 52 delete m_pDynObjWriter; 53 if (m_pDynObjFileFormat) 54 delete m_pDynObjFileFormat; 55 if (m_pExecFileFormat) 56 delete m_pExecFileFormat; 57 if(m_pSymIndexMap) 58 delete m_pSymIndexMap; 59 } 60 61 size_t GNULDBackend::sectionStartOffset() const 62 { 63 // FIXME: use fixed offset, we need 10 segments by default 64 return sizeof(llvm::ELF::Elf64_Ehdr)+10*sizeof(llvm::ELF::Elf64_Phdr); 65 } 66 67 bool GNULDBackend::initArchiveReader(MCLinker&, MCLDInfo &pInfo) 68 { 69 if (0 == m_pArchiveReader) 70 { 71 LDReader::Endian isLittleEndian = LDReader::LittleEndian; 72 m_pArchiveReader = new GNUArchiveReader(pInfo, isLittleEndian); 73 } 74 return true; 75 } 76 77 bool GNULDBackend::initObjectReader(MCLinker& pLinker) 78 { 79 if (0 == m_pObjectReader) 80 m_pObjectReader = new ELFObjectReader(*this, pLinker); 81 return true; 82 } 83 84 bool GNULDBackend::initDynObjReader(MCLinker& pLinker) 85 { 86 if (0 == m_pDynObjReader) 87 m_pDynObjReader = new ELFDynObjReader(*this, pLinker); 88 return true; 89 } 90 91 bool GNULDBackend::initObjectWriter(MCLinker&) 92 { 93 // TODO 94 return true; 95 } 96 97 bool GNULDBackend::initDynObjWriter(MCLinker& pLinker) 98 { 99 if (0 == m_pDynObjWriter) 100 m_pDynObjWriter = new ELFDynObjWriter(*this, pLinker); 101 return true; 102 } 103 104 bool GNULDBackend::initExecSections(MCLinker& pMCLinker) 105 { 106 if (0 == m_pExecFileFormat) 107 m_pExecFileFormat = new ELFExecFileFormat(*this); 108 109 // initialize standard sections 110 m_pExecFileFormat->initStdSections(pMCLinker); 111 return true; 112 } 113 114 bool GNULDBackend::initDynObjSections(MCLinker& pMCLinker) 115 { 116 if (0 == m_pDynObjFileFormat) 117 m_pDynObjFileFormat = new ELFDynObjFileFormat(*this); 118 119 // initialize standard sections 120 m_pDynObjFileFormat->initStdSections(pMCLinker); 121 return true; 122 } 123 124 bool GNULDBackend::initStandardSymbols(MCLinker& pLinker) 125 { 126 return true; 127 } 128 129 GNUArchiveReader *GNULDBackend::getArchiveReader() 130 { 131 assert(0 != m_pArchiveReader); 132 return m_pArchiveReader; 133 } 134 135 GNUArchiveReader *GNULDBackend::getArchiveReader() const 136 { 137 assert(0 != m_pArchiveReader); 138 return m_pArchiveReader; 139 } 140 141 ELFObjectReader *GNULDBackend::getObjectReader() 142 { 143 assert(0 != m_pObjectReader); 144 return m_pObjectReader; 145 } 146 147 ELFObjectReader *GNULDBackend::getObjectReader() const 148 { 149 assert(0 != m_pObjectReader); 150 return m_pObjectReader; 151 } 152 153 ELFDynObjReader *GNULDBackend::getDynObjReader() 154 { 155 assert(0 != m_pDynObjReader); 156 return m_pDynObjReader; 157 } 158 159 ELFDynObjReader *GNULDBackend::getDynObjReader() const 160 { 161 assert(0 != m_pDynObjReader); 162 return m_pDynObjReader; 163 } 164 165 ELFObjectWriter *GNULDBackend::getObjectWriter() 166 { 167 // TODO 168 return NULL; 169 } 170 171 ELFObjectWriter *GNULDBackend::getObjectWriter() const 172 { 173 // TODO 174 return NULL; 175 } 176 177 ELFDynObjWriter *GNULDBackend::getDynObjWriter() 178 { 179 assert(0 != m_pDynObjWriter); 180 return m_pDynObjWriter; 181 } 182 183 ELFDynObjWriter *GNULDBackend::getDynObjWriter() const 184 { 185 assert(0 != m_pDynObjWriter); 186 return m_pDynObjWriter; 187 } 188 189 ELFDynObjFileFormat* GNULDBackend::getDynObjFileFormat() 190 { 191 assert(0 != m_pDynObjFileFormat); 192 return m_pDynObjFileFormat; 193 } 194 195 ELFDynObjFileFormat* GNULDBackend::getDynObjFileFormat() const 196 { 197 assert(0 != m_pDynObjFileFormat); 198 return m_pDynObjFileFormat; 199 } 200 201 ELFExecFileFormat* GNULDBackend::getExecFileFormat() 202 { 203 assert(0 != m_pExecFileFormat); 204 return m_pExecFileFormat; 205 } 206 207 ELFExecFileFormat* GNULDBackend::getExecFileFormat() const 208 { 209 assert(0 != m_pExecFileFormat); 210 return m_pExecFileFormat; 211 } 212 213 /// sizeNamePools - compute the size of regular name pools 214 /// In ELF executable files, regular name pools are .symtab, .strtab, 215 /// .dynsym, .dynstr, and .hash 216 void 217 GNULDBackend::sizeNamePools(const Output& pOutput, 218 const SymbolCategory& pSymbols, 219 const MCLDInfo& pLDInfo) 220 { 221 // size of string tables starts from 1 to hold the null character in their 222 // first byte 223 size_t symtab = 1; 224 size_t dynsym = 1; 225 // number of entries in symbol tables starts from 1 to hold the special entry 226 // at index 0 (STN_UNDEF). See ELF Spec Book I, p1-21. 227 size_t strtab = 1; 228 size_t dynstr = 1; 229 size_t hash = 0; 230 231 // compute size of .symtab, .dynsym and .strtab 232 SymbolCategory::const_iterator symbol; 233 SymbolCategory::const_iterator symEnd = pSymbols.end(); 234 for (symbol = pSymbols.begin(); symbol != symEnd; ++symbol) { 235 size_t str_size = (*symbol)->nameSize() + 1; 236 if (isDynamicSymbol(**symbol, pOutput)) { 237 ++dynsym; 238 dynstr += str_size; 239 } 240 ++symtab; 241 strtab += str_size; 242 } 243 244 ELFFileFormat* file_format = NULL; 245 switch(pOutput.type()) { 246 // compute size of .dynstr and .hash 247 case Output::DynObj: 248 file_format = getDynObjFileFormat(); 249 break; 250 case Output::Exec: 251 file_format = getExecFileFormat(); 252 break; 253 case Output::Object: 254 default: 255 // TODO: not support yet 256 return; 257 } 258 259 switch(pOutput.type()) { 260 // compute size of .dynstr and .hash 261 case Output::DynObj: 262 case Output::Exec: { 263 // add DT_NEED strings into .dynstr and .dynamic 264 // Rules: 265 // 1. ignore --no-add-needed 266 // 2. force count in --no-as-needed 267 // 3. judge --as-needed 268 InputTree::const_bfs_iterator input, inputEnd = pLDInfo.inputs().bfs_end(); 269 for (input = pLDInfo.inputs().bfs_begin(); input != inputEnd; ++input) { 270 if (Input::DynObj == (*input)->type()) { 271 // --add-needed 272 if ((*input)->attribute()->isAddNeeded()) { 273 // --no-as-needed 274 if (!(*input)->attribute()->isAsNeeded()) { 275 dynstr += (*input)->name().size() + 1; 276 dynamic().reserveNeedEntry(); 277 } 278 // --as-needed 279 else if ((*input)->isNeeded()) { 280 dynstr += (*input)->name().size() + 1; 281 dynamic().reserveNeedEntry(); 282 } 283 } 284 } 285 } // for 286 287 // compute .hash 288 // Both Elf32_Word and Elf64_Word are 4 bytes 289 hash = (2 + getHashBucketCount(dynsym, false) + dynsym) * 290 sizeof(llvm::ELF::Elf32_Word); 291 292 // set size 293 dynstr += pOutput.name().size() + 1; 294 if (32 == bitclass()) 295 file_format->getDynSymTab().setSize(dynsym*sizeof(llvm::ELF::Elf32_Sym)); 296 else 297 file_format->getDynSymTab().setSize(dynsym*sizeof(llvm::ELF::Elf64_Sym)); 298 file_format->getDynStrTab().setSize(dynstr); 299 file_format->getHashTab().setSize(hash); 300 301 } 302 /* fall through */ 303 case Output::Object: { 304 if (32 == bitclass()) 305 file_format->getSymTab().setSize(symtab*sizeof(llvm::ELF::Elf32_Sym)); 306 else 307 file_format->getSymTab().setSize(symtab*sizeof(llvm::ELF::Elf64_Sym)); 308 file_format->getStrTab().setSize(strtab); 309 break; 310 } 311 } // end of switch 312 313 // reserve fixed entries in the .dynamic section. 314 if (Output::DynObj == pOutput.type() || Output::Exec == pOutput.type()) { 315 // Because some entries in .dynamic section need information of .dynsym, 316 // .dynstr, .symtab, .strtab and .hash, we can not reserve non-DT_NEEDED 317 // entries until we get the size of the sections mentioned above 318 dynamic().reserveEntries(pLDInfo, *file_format); 319 file_format->getDynamic().setSize(dynamic().numOfBytes()); 320 } 321 } 322 323 /// emitRegNamePools - emit regular name pools - .symtab, .strtab 324 /// 325 /// the size of these tables should be computed before layout 326 /// layout should computes the start offset of these tables 327 void GNULDBackend::emitRegNamePools(Output& pOutput, 328 SymbolCategory& pSymbols, 329 const Layout& pLayout, 330 const MCLDInfo& pLDInfo) 331 { 332 333 assert(pOutput.hasMemArea()); 334 335 bool sym_exist = false; 336 HashTableType::entry_type* entry = 0; 337 338 ELFFileFormat* file_format = NULL; 339 switch(pOutput.type()) { 340 // compute size of .dynstr and .hash 341 case Output::DynObj: 342 file_format = getDynObjFileFormat(); 343 break; 344 case Output::Exec: 345 file_format = getExecFileFormat(); 346 break; 347 case Output::Object: 348 default: 349 // add first symbol into m_pSymIndexMap 350 entry = m_pSymIndexMap->insert(NULL, sym_exist); 351 entry->setValue(0); 352 353 // TODO: not support yet 354 return; 355 } 356 357 LDSection& symtab_sect = file_format->getSymTab(); 358 LDSection& strtab_sect = file_format->getStrTab(); 359 360 MemoryRegion* symtab_region = pOutput.memArea()->request(symtab_sect.offset(), 361 symtab_sect.size()); 362 MemoryRegion* strtab_region = pOutput.memArea()->request(strtab_sect.offset(), 363 strtab_sect.size()); 364 365 // set up symtab_region 366 llvm::ELF::Elf32_Sym* symtab32 = NULL; 367 llvm::ELF::Elf64_Sym* symtab64 = NULL; 368 if (32 == bitclass()) 369 symtab32 = (llvm::ELF::Elf32_Sym*)symtab_region->start(); 370 else if (64 == bitclass()) 371 symtab64 = (llvm::ELF::Elf64_Sym*)symtab_region->start(); 372 else 373 llvm::report_fatal_error(llvm::Twine("unsupported bitclass ") + 374 llvm::Twine(bitclass()) + 375 llvm::Twine(".\n")); 376 // set up strtab_region 377 char* strtab = (char*)strtab_region->start(); 378 strtab[0] = '\0'; 379 380 // initialize the first ELF symbol 381 if (32 == bitclass()) { 382 symtab32[0].st_name = 0; 383 symtab32[0].st_value = 0; 384 symtab32[0].st_size = 0; 385 symtab32[0].st_info = 0; 386 symtab32[0].st_other = 0; 387 symtab32[0].st_shndx = 0; 388 } 389 else { // must 64 390 symtab64[0].st_name = 0; 391 symtab64[0].st_value = 0; 392 symtab64[0].st_size = 0; 393 symtab64[0].st_info = 0; 394 symtab64[0].st_other = 0; 395 symtab64[0].st_shndx = 0; 396 } 397 398 size_t symtabIdx = 1; 399 size_t strtabsize = 1; 400 // compute size of .symtab, .dynsym and .strtab 401 SymbolCategory::iterator symbol; 402 SymbolCategory::iterator symEnd = pSymbols.end(); 403 for (symbol = pSymbols.begin(); symbol != symEnd; ++symbol) { 404 405 // maintain output's symbol and index map if building .o file 406 if (Output::Object == pOutput.type()) { 407 entry = m_pSymIndexMap->insert(NULL, sym_exist); 408 entry->setValue(symtabIdx); 409 } 410 411 // FIXME: check the endian between host and target 412 // write out symbol 413 if (32 == bitclass()) { 414 symtab32[symtabIdx].st_name = strtabsize; 415 symtab32[symtabIdx].st_value = getSymbolValue(**symbol); 416 symtab32[symtabIdx].st_size = getSymbolSize(**symbol); 417 symtab32[symtabIdx].st_info = getSymbolInfo(**symbol); 418 symtab32[symtabIdx].st_other = (*symbol)->visibility(); 419 symtab32[symtabIdx].st_shndx = getSymbolShndx(**symbol, pLayout); 420 } 421 else { // must 64 422 symtab64[symtabIdx].st_name = strtabsize; 423 symtab64[symtabIdx].st_value = getSymbolValue(**symbol); 424 symtab64[symtabIdx].st_size = getSymbolSize(**symbol); 425 symtab64[symtabIdx].st_info = getSymbolInfo(**symbol); 426 symtab64[symtabIdx].st_other = (*symbol)->visibility(); 427 symtab64[symtabIdx].st_shndx = getSymbolShndx(**symbol, pLayout); 428 } 429 // write out string 430 strcpy((strtab + strtabsize), (*symbol)->name()); 431 432 // write out 433 // sum up counters 434 ++symtabIdx; 435 strtabsize += (*symbol)->nameSize() + 1; 436 } 437 } 438 439 /// emitNamePools - emit dynamic name pools - .dyntab, .dynstr, .hash 440 /// 441 /// the size of these tables should be computed before layout 442 /// layout should computes the start offset of these tables 443 void GNULDBackend::emitDynNamePools(Output& pOutput, 444 SymbolCategory& pSymbols, 445 const Layout& pLayout, 446 const MCLDInfo& pLDInfo) 447 { 448 assert(pOutput.hasMemArea()); 449 ELFFileFormat* file_format = NULL; 450 451 bool sym_exist = false; 452 HashTableType::entry_type* entry = 0; 453 454 switch(pOutput.type()) { 455 // compute size of .dynstr and .hash 456 case Output::DynObj: 457 file_format = getDynObjFileFormat(); 458 break; 459 case Output::Exec: 460 file_format = getExecFileFormat(); 461 break; 462 case Output::Object: 463 default: 464 // TODO: not support yet 465 return; 466 } 467 468 LDSection& symtab_sect = file_format->getDynSymTab(); 469 LDSection& strtab_sect = file_format->getDynStrTab(); 470 LDSection& hash_sect = file_format->getHashTab(); 471 LDSection& dyn_sect = file_format->getDynamic(); 472 473 MemoryRegion* symtab_region = pOutput.memArea()->request(symtab_sect.offset(), 474 symtab_sect.size()); 475 MemoryRegion* strtab_region = pOutput.memArea()->request(strtab_sect.offset(), 476 strtab_sect.size()); 477 MemoryRegion* hash_region = pOutput.memArea()->request(hash_sect.offset(), 478 hash_sect.size()); 479 MemoryRegion* dyn_region = pOutput.memArea()->request(dyn_sect.offset(), 480 dyn_sect.size()); 481 // set up symtab_region 482 llvm::ELF::Elf32_Sym* symtab32 = NULL; 483 llvm::ELF::Elf64_Sym* symtab64 = NULL; 484 if (32 == bitclass()) 485 symtab32 = (llvm::ELF::Elf32_Sym*)symtab_region->start(); 486 else if (64 == bitclass()) 487 symtab64 = (llvm::ELF::Elf64_Sym*)symtab_region->start(); 488 else 489 llvm::report_fatal_error(llvm::Twine("unsupported bitclass ") + 490 llvm::Twine(bitclass()) + 491 llvm::Twine(".\n")); 492 493 // initialize the first ELF symbol 494 if (32 == bitclass()) { 495 symtab32[0].st_name = 0; 496 symtab32[0].st_value = 0; 497 symtab32[0].st_size = 0; 498 symtab32[0].st_info = 0; 499 symtab32[0].st_other = 0; 500 symtab32[0].st_shndx = 0; 501 } 502 else { // must 64 503 symtab64[0].st_name = 0; 504 symtab64[0].st_value = 0; 505 symtab64[0].st_size = 0; 506 symtab64[0].st_info = 0; 507 symtab64[0].st_other = 0; 508 symtab64[0].st_shndx = 0; 509 } 510 // set up strtab_region 511 char* strtab = (char*)strtab_region->start(); 512 strtab[0] = '\0'; 513 514 // add the first symbol into m_pSymIndexMap 515 entry = m_pSymIndexMap->insert(NULL, sym_exist); 516 entry->setValue(0); 517 518 size_t symtabIdx = 1; 519 size_t strtabsize = 1; 520 521 // emit of .dynsym, and .dynstr 522 SymbolCategory::iterator symbol; 523 SymbolCategory::iterator symEnd = pSymbols.end(); 524 for (symbol = pSymbols.begin(); symbol != symEnd; ++symbol) { 525 if (!isDynamicSymbol(**symbol, pOutput)) 526 continue; 527 528 // maintain output's symbol and index map 529 entry = m_pSymIndexMap->insert(*symbol, sym_exist); 530 entry->setValue(symtabIdx); 531 532 // FIXME: check the endian between host and target 533 // write out symbol 534 if (32 == bitclass()) { 535 symtab32[symtabIdx].st_name = strtabsize; 536 symtab32[symtabIdx].st_value = (*symbol)->value(); 537 symtab32[symtabIdx].st_size = getSymbolSize(**symbol); 538 symtab32[symtabIdx].st_info = getSymbolInfo(**symbol); 539 symtab32[symtabIdx].st_other = (*symbol)->visibility(); 540 symtab32[symtabIdx].st_shndx = getSymbolShndx(**symbol, pLayout); 541 } 542 else { // must 64 543 symtab64[symtabIdx].st_name = strtabsize; 544 symtab64[symtabIdx].st_value = (*symbol)->value(); 545 symtab64[symtabIdx].st_size = getSymbolSize(**symbol); 546 symtab64[symtabIdx].st_info = getSymbolInfo(**symbol); 547 symtab64[symtabIdx].st_other = (*symbol)->visibility(); 548 symtab64[symtabIdx].st_shndx = getSymbolShndx(**symbol, pLayout); 549 } 550 // write out string 551 strcpy((strtab + strtabsize), (*symbol)->name()); 552 553 // sum up counters 554 ++symtabIdx; 555 strtabsize += (*symbol)->nameSize() + 1; 556 } 557 558 // emit DT_NEED 559 // add DT_NEED strings into .dynstr 560 // Rules: 561 // 1. ignore --no-add-needed 562 // 2. force count in --no-as-needed 563 // 3. judge --as-needed 564 ELFDynamic::iterator dt_need = dynamic().needBegin(); 565 InputTree::const_bfs_iterator input, inputEnd = pLDInfo.inputs().bfs_end(); 566 for (input = pLDInfo.inputs().bfs_begin(); input != inputEnd; ++input) { 567 if (Input::DynObj == (*input)->type()) { 568 // --add-needed 569 if ((*input)->attribute()->isAddNeeded()) { 570 // --no-as-needed 571 if (!(*input)->attribute()->isAsNeeded()) { 572 strcpy((strtab + strtabsize), (*input)->name().c_str()); 573 (*dt_need)->setValue(llvm::ELF::DT_NEEDED, strtabsize); 574 strtabsize += (*input)->name().size() + 1; 575 ++dt_need; 576 } 577 // --as-needed 578 else if ((*input)->isNeeded()) { 579 strcpy((strtab + strtabsize), (*input)->name().c_str()); 580 (*dt_need)->setValue(llvm::ELF::DT_NEEDED, strtabsize); 581 strtabsize += (*input)->name().size() + 1; 582 ++dt_need; 583 } 584 } 585 } 586 } // for 587 588 // emit soname 589 // initialize value of ELF .dynamic section 590 dynamic().applySoname(strtabsize); 591 dynamic().applyEntries(pLDInfo, *file_format); 592 dynamic().emit(dyn_sect, *dyn_region); 593 594 strcpy((strtab + strtabsize), pOutput.name().c_str()); 595 strtabsize += pOutput.name().size() + 1; 596 597 // emit hash table 598 // FIXME: this verion only emit SVR4 hash section. 599 // Please add GNU new hash section 600 601 // both 32 and 64 bits hash table use 32-bit entry 602 // set up hash_region 603 uint32_t* word_array = (uint32_t*)hash_region->start(); 604 uint32_t& nbucket = word_array[0]; 605 uint32_t& nchain = word_array[1]; 606 607 nbucket = getHashBucketCount(symtabIdx, false); 608 nchain = symtabIdx; 609 610 uint32_t* bucket = (word_array + 2); 611 uint32_t* chain = (bucket + nbucket); 612 613 // initialize bucket 614 bzero((void*)bucket, nbucket); 615 616 StringHash<ELF> hash_func; 617 618 if (32 == bitclass()) { 619 for (size_t sym_idx=0; sym_idx < symtabIdx; ++sym_idx) { 620 llvm::StringRef name(strtab + symtab32[sym_idx].st_name); 621 size_t bucket_pos = hash_func(name) % nbucket; 622 chain[sym_idx] = bucket[bucket_pos]; 623 bucket[bucket_pos] = sym_idx; 624 } 625 } 626 else if (64 == bitclass()) { 627 for (size_t sym_idx=0; sym_idx < symtabIdx; ++sym_idx) { 628 llvm::StringRef name(strtab + symtab64[sym_idx].st_name); 629 size_t bucket_pos = hash_func(name) % nbucket; 630 chain[sym_idx] = bucket[bucket_pos]; 631 bucket[bucket_pos] = sym_idx; 632 } 633 } 634 } 635 636 /// getSectionOrder 637 unsigned int GNULDBackend::getSectionOrder(const Output& pOutput, 638 const LDSection& pSectHdr) const 639 { 640 // NULL section should be the "1st" section 641 if (LDFileFormat::Null == pSectHdr.kind()) 642 return 0; 643 644 // if the section is not ALLOC, lay it out until the last possible moment 645 if (0 == (pSectHdr.flag() & llvm::ELF::SHF_ALLOC)) 646 return SHO_UNDEFINED; 647 648 bool is_write = (pSectHdr.flag() & llvm::ELF::SHF_WRITE) != 0; 649 bool is_exec = (pSectHdr.flag() & llvm::ELF::SHF_EXECINSTR) != 0; 650 ELFFileFormat* file_format = NULL; 651 switch (pOutput.type()) { 652 case Output::DynObj: 653 file_format = getDynObjFileFormat(); 654 break; 655 case Output::Exec: 656 file_format = getExecFileFormat(); 657 break; 658 case Output::Object: 659 default: 660 assert(0 && "Not support yet.\n"); 661 break; 662 } 663 664 // TODO: need to take care other possible output sections 665 switch (pSectHdr.kind()) { 666 case LDFileFormat::Regular: 667 if (is_exec) { 668 if (&pSectHdr == &file_format->getInit()) 669 return SHO_INIT; 670 if (&pSectHdr == &file_format->getFini()) 671 return SHO_FINI; 672 return SHO_TEXT; 673 } else if (!is_write) { 674 return SHO_RO; 675 } else { 676 if (pSectHdr.type() == llvm::ELF::SHT_PREINIT_ARRAY || 677 pSectHdr.type() == llvm::ELF::SHT_INIT_ARRAY || 678 pSectHdr.type() == llvm::ELF::SHT_FINI_ARRAY || 679 &pSectHdr == &file_format->getCtors() || 680 &pSectHdr == &file_format->getDtors()) 681 return SHO_RELRO; 682 683 return SHO_DATA; 684 } 685 686 case LDFileFormat::BSS: 687 return SHO_BSS; 688 689 case LDFileFormat::NamePool: 690 if (&pSectHdr == &file_format->getDynamic()) 691 return SHO_RELRO; 692 return SHO_NAMEPOOL; 693 694 case LDFileFormat::Relocation: 695 if (&pSectHdr == &file_format->getRelPlt() || 696 &pSectHdr == &file_format->getRelaPlt()) 697 return SHO_REL_PLT; 698 return SHO_RELOCATION; 699 700 // get the order from target for target specific sections 701 case LDFileFormat::Target: 702 return getTargetSectionOrder(pOutput, pSectHdr); 703 704 // handle .interp 705 case LDFileFormat::Note: 706 return SHO_INTERP; 707 708 case LDFileFormat::Exception: 709 return SHO_EHFRAME; 710 711 case LDFileFormat::MetaData: 712 case LDFileFormat::Debug: 713 default: 714 return SHO_UNDEFINED; 715 } 716 } 717 718 /// getSymbolSize 719 uint64_t GNULDBackend::getSymbolSize(const LDSymbol& pSymbol) const 720 { 721 // @ref Google gold linker: symtab.cc: 2780 722 // undefined and dynamic symbols should have zero size. 723 if (pSymbol.isDyn() || pSymbol.desc() == ResolveInfo::Undefined) 724 return 0x0; 725 return pSymbol.resolveInfo()->size(); 726 } 727 728 /// getSymbolInfo 729 uint64_t GNULDBackend::getSymbolInfo(const LDSymbol& pSymbol) const 730 { 731 // set binding 732 uint8_t bind = 0x0; 733 if (pSymbol.resolveInfo()->isLocal()) 734 bind = llvm::ELF::STB_LOCAL; 735 else if (pSymbol.resolveInfo()->isGlobal()) 736 bind = llvm::ELF::STB_GLOBAL; 737 else if (pSymbol.resolveInfo()->isWeak()) 738 bind = llvm::ELF::STB_WEAK; 739 else if (pSymbol.resolveInfo()->isAbsolute()) { 740 // (Luba) Is a absolute but not global (weak or local) symbol meaningful? 741 bind = llvm::ELF::STB_GLOBAL; 742 } 743 744 if (pSymbol.visibility() == llvm::ELF::STV_INTERNAL || 745 pSymbol.visibility() == llvm::ELF::STV_HIDDEN) 746 bind = llvm::ELF::STB_LOCAL; 747 748 return (pSymbol.resolveInfo()->type() | (bind << 4)); 749 } 750 751 /// getSymbolValue - this function is called after layout() 752 uint64_t GNULDBackend::getSymbolValue(const LDSymbol& pSymbol) const 753 { 754 if (pSymbol.isDyn()) 755 return 0x0; 756 757 return pSymbol.value(); 758 } 759 760 /// getSymbolShndx - this function is called after layout() 761 uint64_t 762 GNULDBackend::getSymbolShndx(const LDSymbol& pSymbol, const Layout& pLayout) const 763 { 764 if (pSymbol.resolveInfo()->isAbsolute()) 765 return llvm::ELF::SHN_ABS; 766 if (pSymbol.resolveInfo()->isCommon()) 767 return llvm::ELF::SHN_COMMON; 768 if (pSymbol.resolveInfo()->isUndef() || pSymbol.isDyn()) 769 return llvm::ELF::SHN_UNDEF; 770 771 if (pSymbol.resolveInfo()->isLocal()) { 772 switch (pSymbol.type()) { 773 case ResolveInfo::NoType: 774 case ResolveInfo::File: 775 return llvm::ELF::SHN_ABS; 776 } 777 } 778 779 assert(pSymbol.hasFragRef()); 780 return pLayout.getOutputLDSection(*pSymbol.fragRef()->frag())->index(); 781 } 782 783 /// getSymbolIdx - called by emitRelocation to get the ouput symbol table index 784 size_t GNULDBackend::getSymbolIdx(LDSymbol* pSymbol) const 785 { 786 HashTableType::iterator entry = m_pSymIndexMap->find(pSymbol); 787 return entry.getEntry()->value(); 788 } 789 790 /// emitProgramHdrs - emit ELF program headers 791 void GNULDBackend::emitProgramHdrs(Output& pOutput) 792 { 793 assert(NULL != pOutput.context()); 794 createProgramHdrs(*pOutput.context()); 795 796 if (32 == bitclass()) 797 writeELF32ProgramHdrs(pOutput); 798 else 799 writeELF64ProgramHdrs(pOutput); 800 } 801 802 /// createProgramHdrs - base on output sections to create the program headers 803 void GNULDBackend::createProgramHdrs(LDContext& pContext) 804 { 805 // make PT_PHDR 806 m_ELFSegmentTable.produce(llvm::ELF::PT_PHDR); 807 808 // make PT_INTERP 809 LDSection* interp = pContext.getSection(".interp"); 810 if (NULL != interp) { 811 ELFSegment* interp_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_INTERP); 812 interp_seg->addSection(interp); 813 interp_seg->setAlign(bitclass() / 8); 814 } 815 816 uint32_t cur_seg_flag, prev_seg_flag = getSegmentFlag(0); 817 uint64_t padding = 0; 818 ELFSegment* load_seg = NULL; 819 // make possible PT_LOAD segments 820 LDContext::sect_iterator sect, sect_end = pContext.sectEnd(); 821 for (sect = pContext.sectBegin(); sect != sect_end; ++sect) { 822 if (0 == ((*sect)->flag() & llvm::ELF::SHF_ALLOC) && 823 LDFileFormat::Null != (*sect)->kind()) 824 continue; 825 826 // FIXME: Now only separate writable and non-writable PT_LOAD 827 cur_seg_flag = getSegmentFlag((*sect)->flag()); 828 if ((prev_seg_flag & llvm::ELF::PF_W) ^ (cur_seg_flag & llvm::ELF::PF_W) || 829 LDFileFormat::Null == (*sect)->kind()) { 830 // create new PT_LOAD segment 831 load_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_LOAD); 832 load_seg->setAlign(pagesize()); 833 834 // check if this segment needs padding 835 padding = 0; 836 if (((*sect)->offset() & (load_seg->align() - 1)) != 0) 837 padding = load_seg->align(); 838 } 839 840 assert(NULL != load_seg); 841 load_seg->addSection(*sect); 842 load_seg->updateFlag(cur_seg_flag); 843 844 // FIXME: set section's vma 845 // need to handle start vma for user-defined one or for executable. 846 (*sect)->setAddr((*sect)->offset() + padding); 847 848 prev_seg_flag = cur_seg_flag; 849 } 850 851 // make PT_DYNAMIC 852 LDSection* dynamic = pContext.getSection(".dynamic"); 853 if (NULL != dynamic) { 854 ELFSegment* dyn_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_DYNAMIC); 855 dyn_seg->setFlag(llvm::ELF::PF_R | llvm::ELF::PF_W); 856 dyn_seg->addSection(dynamic); 857 dyn_seg->setAlign(bitclass() / 8); 858 } 859 860 // update segment info 861 uint64_t file_size = 0; 862 ELFSegmentFactory::iterator seg, seg_end = m_ELFSegmentTable.end(); 863 for (seg = m_ELFSegmentTable.begin(); seg != seg_end; ++seg) { 864 ELFSegment& segment = *seg; 865 866 // update PT_PHDR 867 if (llvm::ELF::PT_PHDR == segment.type()) { 868 uint64_t offset, phdr_size; 869 if (32 == bitclass()) { 870 offset = sizeof(llvm::ELF::Elf32_Ehdr); 871 phdr_size = sizeof(llvm::ELF::Elf32_Phdr); 872 } 873 else { 874 offset = sizeof(llvm::ELF::Elf64_Ehdr); 875 phdr_size = sizeof(llvm::ELF::Elf64_Phdr); 876 } 877 segment.setOffset(offset); 878 segment.setVaddr(offset); 879 segment.setPaddr(segment.vaddr()); 880 segment.setFilesz(numOfSegments() * phdr_size); 881 segment.setMemsz(numOfSegments() * phdr_size); 882 segment.setAlign(bitclass() / 8); 883 continue; 884 } 885 886 assert(NULL != segment.getFirstSection()); 887 segment.setOffset(segment.getFirstSection()->offset()); 888 segment.setVaddr(segment.getFirstSection()->addr()); 889 segment.setPaddr(segment.vaddr()); 890 891 const LDSection* last_sect = segment.getLastSection(); 892 assert(NULL != last_sect); 893 file_size = last_sect->offset() - segment.offset(); 894 if (LDFileFormat::BSS != last_sect->kind()) 895 file_size += last_sect->size(); 896 segment.setFilesz(file_size); 897 898 segment.setMemsz(last_sect->addr() - segment.vaddr() + last_sect->size()); 899 } 900 } 901 902 /// writeELF32ProgramHdrs - write out the ELF32 program headers 903 void GNULDBackend::writeELF32ProgramHdrs(Output& pOutput) 904 { 905 assert(pOutput.hasMemArea()); 906 907 uint64_t start_offset, phdr_size; 908 909 start_offset = sizeof(llvm::ELF::Elf32_Ehdr); 910 phdr_size = sizeof(llvm::ELF::Elf32_Phdr); 911 // Program header must start directly after ELF header 912 MemoryRegion *region = pOutput.memArea()->request(start_offset, 913 numOfSegments()*phdr_size); 914 915 llvm::ELF::Elf32_Phdr* phdr = (llvm::ELF::Elf32_Phdr*)region->start(); 916 917 size_t index = 0; 918 ELFSegmentFactory::iterator seg, segEnd = m_ELFSegmentTable.end(); 919 for (seg = m_ELFSegmentTable.begin(); seg != segEnd; ++seg, ++index) { 920 phdr[index].p_type = (*seg).type(); 921 phdr[index].p_flags = (*seg).flag(); 922 phdr[index].p_offset = (*seg).offset(); 923 phdr[index].p_vaddr = (*seg).vaddr(); 924 phdr[index].p_paddr = (*seg).paddr(); 925 phdr[index].p_filesz = (*seg).filesz(); 926 phdr[index].p_memsz = (*seg).memsz(); 927 phdr[index].p_align = (*seg).align(); 928 } 929 } 930 931 /// writeELF64ProgramHdrs - write out the ELF64 program headers 932 void GNULDBackend::writeELF64ProgramHdrs(Output& pOutput) 933 { 934 assert(pOutput.hasMemArea()); 935 936 uint64_t start_offset, phdr_size; 937 938 start_offset = sizeof(llvm::ELF::Elf64_Ehdr); 939 phdr_size = sizeof(llvm::ELF::Elf64_Phdr); 940 // Program header must start directly after ELF header 941 MemoryRegion *region = pOutput.memArea()->request(start_offset, 942 numOfSegments() *phdr_size); 943 llvm::ELF::Elf64_Phdr* phdr = (llvm::ELF::Elf64_Phdr*)region->start(); 944 945 size_t index = 0; 946 ELFSegmentFactory::iterator seg, segEnd = m_ELFSegmentTable.end(); 947 for (seg = m_ELFSegmentTable.begin(); seg != segEnd; ++seg, ++index) { 948 phdr[index].p_type = (*seg).type(); 949 phdr[index].p_flags = (*seg).flag(); 950 phdr[index].p_offset = (*seg).offset(); 951 phdr[index].p_vaddr = (*seg).vaddr(); 952 phdr[index].p_paddr = (*seg).paddr(); 953 phdr[index].p_filesz = (*seg).filesz(); 954 phdr[index].p_memsz = (*seg).memsz(); 955 phdr[index].p_align = (*seg).align(); 956 } 957 } 958 959 /// preLayout - Backend can do any needed modification before layout 960 void GNULDBackend::preLayout(const Output& pOutput, 961 const MCLDInfo& pLDInfo, 962 MCLinker& pLinker) 963 { 964 // prelayout target first 965 doPreLayout(pOutput, pLDInfo, pLinker); 966 } 967 968 /// postLayout -Backend can do any needed modification after layout 969 void GNULDBackend::postLayout(const Output& pOutput, 970 const MCLDInfo& pInfo, 971 MCLinker& pLinker) 972 { 973 // post layout target first 974 doPostLayout(pOutput, pInfo, pLinker); 975 } 976 977 /// getHashBucketCount - calculate hash bucket count. 978 /// @ref Google gold linker, dynobj.cc:791 979 unsigned GNULDBackend::getHashBucketCount(unsigned pNumOfSymbols, 980 bool pIsGNUStyle) 981 { 982 // @ref Google gold, dynobj.cc:loc 791 983 static const unsigned int buckets[] = 984 { 985 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209, 986 16411, 32771, 65537, 131101, 262147 987 }; 988 const unsigned buckets_count = sizeof buckets / sizeof buckets[0]; 989 990 unsigned int result = 1; 991 for (unsigned i = 0; i < buckets_count; ++i) { 992 if (pNumOfSymbols < buckets[i]) 993 break; 994 result = buckets[i]; 995 } 996 997 if (pIsGNUStyle && result < 2) 998 result = 2; 999 1000 return result; 1001 } 1002 1003 /// isDynamicSymbol 1004 /// @ref Google gold linker: symtab.cc:311 1005 bool GNULDBackend::isDynamicSymbol(const LDSymbol& pSymbol, 1006 const Output& pOutput) 1007 { 1008 // If a local symbol is in the LDContext's symbol table, it's a real local 1009 // symbol. We should not add it 1010 if (pSymbol.binding() == ResolveInfo::Local) 1011 return false; 1012 1013 // If we are building shared object, and the visibility is external, we 1014 // need to add it. 1015 if (Output::DynObj == pOutput.type()) 1016 if (pSymbol.resolveInfo()->visibility() == ResolveInfo::Default || 1017 pSymbol.resolveInfo()->visibility() == ResolveInfo::Protected) 1018 return true; 1019 1020 return false; 1021 } 1022