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 24using namespace mcld; 25 26//===----------------------------------------------------------------------===// 27// GNULDBackend 28GNULDBackend::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 41GNULDBackend::~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 61size_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 67bool 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 77bool GNULDBackend::initObjectReader(MCLinker& pLinker) 78{ 79 if (0 == m_pObjectReader) 80 m_pObjectReader = new ELFObjectReader(*this, pLinker); 81 return true; 82} 83 84bool GNULDBackend::initDynObjReader(MCLinker& pLinker) 85{ 86 if (0 == m_pDynObjReader) 87 m_pDynObjReader = new ELFDynObjReader(*this, pLinker); 88 return true; 89} 90 91bool GNULDBackend::initObjectWriter(MCLinker&) 92{ 93 // TODO 94 return true; 95} 96 97bool GNULDBackend::initDynObjWriter(MCLinker& pLinker) 98{ 99 if (0 == m_pDynObjWriter) 100 m_pDynObjWriter = new ELFDynObjWriter(*this, pLinker); 101 return true; 102} 103 104bool 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 114bool 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 124bool GNULDBackend::initStandardSymbols(MCLinker& pLinker) 125{ 126 return true; 127} 128 129GNUArchiveReader *GNULDBackend::getArchiveReader() 130{ 131 assert(0 != m_pArchiveReader); 132 return m_pArchiveReader; 133} 134 135GNUArchiveReader *GNULDBackend::getArchiveReader() const 136{ 137 assert(0 != m_pArchiveReader); 138 return m_pArchiveReader; 139} 140 141ELFObjectReader *GNULDBackend::getObjectReader() 142{ 143 assert(0 != m_pObjectReader); 144 return m_pObjectReader; 145} 146 147ELFObjectReader *GNULDBackend::getObjectReader() const 148{ 149 assert(0 != m_pObjectReader); 150 return m_pObjectReader; 151} 152 153ELFDynObjReader *GNULDBackend::getDynObjReader() 154{ 155 assert(0 != m_pDynObjReader); 156 return m_pDynObjReader; 157} 158 159ELFDynObjReader *GNULDBackend::getDynObjReader() const 160{ 161 assert(0 != m_pDynObjReader); 162 return m_pDynObjReader; 163} 164 165ELFObjectWriter *GNULDBackend::getObjectWriter() 166{ 167 // TODO 168 return NULL; 169} 170 171ELFObjectWriter *GNULDBackend::getObjectWriter() const 172{ 173 // TODO 174 return NULL; 175} 176 177ELFDynObjWriter *GNULDBackend::getDynObjWriter() 178{ 179 assert(0 != m_pDynObjWriter); 180 return m_pDynObjWriter; 181} 182 183ELFDynObjWriter *GNULDBackend::getDynObjWriter() const 184{ 185 assert(0 != m_pDynObjWriter); 186 return m_pDynObjWriter; 187} 188 189ELFDynObjFileFormat* GNULDBackend::getDynObjFileFormat() 190{ 191 assert(0 != m_pDynObjFileFormat); 192 return m_pDynObjFileFormat; 193} 194 195ELFDynObjFileFormat* GNULDBackend::getDynObjFileFormat() const 196{ 197 assert(0 != m_pDynObjFileFormat); 198 return m_pDynObjFileFormat; 199} 200 201ELFExecFileFormat* GNULDBackend::getExecFileFormat() 202{ 203 assert(0 != m_pExecFileFormat); 204 return m_pExecFileFormat; 205} 206 207ELFExecFileFormat* 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 216void 217GNULDBackend::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 327void 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 443void 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 637unsigned 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 719uint64_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 729uint64_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() 752uint64_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() 761uint64_t 762GNULDBackend::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 784size_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 791void 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 803void 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 903void 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 932void 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 960void 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 969void 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 979unsigned 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 1005bool 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