1 //===- ELFReader.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 <mcld/LD/ELFReader.h> 10 11 #include <mcld/IRBuilder.h> 12 #include <mcld/Fragment/FillFragment.h> 13 #include <mcld/LD/EhFrame.h> 14 #include <mcld/LD/SectionData.h> 15 #include <mcld/Target/GNULDBackend.h> 16 #include <mcld/Support/MemoryRegion.h> 17 #include <mcld/Support/MsgHandling.h> 18 #include <mcld/Object/ObjectBuilder.h> 19 20 #include <cstring> 21 22 #include <llvm/ADT/StringRef.h> 23 #include <llvm/ADT/Twine.h> 24 #include <llvm/Support/ELF.h> 25 #include <llvm/Support/Host.h> 26 27 #include <iostream> 28 29 using namespace mcld; 30 31 //===----------------------------------------------------------------------===// 32 // ELFReader<32, true> 33 //===----------------------------------------------------------------------===// 34 /// constructor 35 ELFReader<32, true>::ELFReader(GNULDBackend& pBackend) 36 : ELFReaderIF(pBackend) { 37 } 38 39 /// destructor 40 ELFReader<32, true>::~ELFReader() 41 { 42 } 43 44 /// isELF - is this a ELF file 45 bool ELFReader<32, true>::isELF(void* pELFHeader) const 46 { 47 llvm::ELF::Elf32_Ehdr* hdr = 48 reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader); 49 if (0 == memcmp(llvm::ELF::ElfMagic, hdr, 4)) 50 return true; 51 return false; 52 } 53 54 /// readRegularSection - read a regular section and create fragments. 55 bool 56 ELFReader<32, true>::readRegularSection(Input& pInput, SectionData& pSD) const 57 { 58 uint32_t offset = pInput.fileOffset() + pSD.getSection().offset(); 59 uint32_t size = pSD.getSection().size(); 60 61 Fragment* frag = IRBuilder::CreateRegion(pInput, offset, size); 62 ObjectBuilder::AppendFragment(*frag, pSD); 63 return true; 64 } 65 66 /// readSymbols - read ELF symbols and create LDSymbol 67 bool ELFReader<32, true>::readSymbols(Input& pInput, 68 IRBuilder& pBuilder, 69 const MemoryRegion& pRegion, 70 const char* pStrTab) const 71 { 72 // get number of symbols 73 size_t entsize = pRegion.size()/sizeof(llvm::ELF::Elf32_Sym); 74 const llvm::ELF::Elf32_Sym* symtab = 75 reinterpret_cast<const llvm::ELF::Elf32_Sym*>(pRegion.start()); 76 77 uint32_t st_name = 0x0; 78 uint32_t st_value = 0x0; 79 uint32_t st_size = 0x0; 80 uint8_t st_info = 0x0; 81 uint8_t st_other = 0x0; 82 uint16_t st_shndx = 0x0; 83 84 // skip the first NULL symbol 85 pInput.context()->addSymbol(LDSymbol::Null()); 86 87 for (size_t idx = 1; idx < entsize; ++idx) { 88 st_info = symtab[idx].st_info; 89 st_other = symtab[idx].st_other; 90 91 if (llvm::sys::isLittleEndianHost()) { 92 st_name = symtab[idx].st_name; 93 st_value = symtab[idx].st_value; 94 st_size = symtab[idx].st_size; 95 st_shndx = symtab[idx].st_shndx; 96 } 97 else { 98 st_name = mcld::bswap32(symtab[idx].st_name); 99 st_value = mcld::bswap32(symtab[idx].st_value); 100 st_size = mcld::bswap32(symtab[idx].st_size); 101 st_shndx = mcld::bswap16(symtab[idx].st_shndx); 102 } 103 104 // If the section should not be included, set the st_shndx SHN_UNDEF 105 // - A section in interrelated groups are not included. 106 if (pInput.type() == Input::Object && 107 st_shndx < llvm::ELF::SHN_LORESERVE && 108 st_shndx != llvm::ELF::SHN_UNDEF) { 109 if (NULL == pInput.context()->getSection(st_shndx)) 110 st_shndx = llvm::ELF::SHN_UNDEF; 111 } 112 113 // get ld_type 114 ResolveInfo::Type ld_type = getSymType(st_info, st_shndx); 115 116 // get ld_desc 117 ResolveInfo::Desc ld_desc = getSymDesc(st_shndx, pInput); 118 119 // get ld_binding 120 ResolveInfo::Binding ld_binding = getSymBinding((st_info >> 4), st_shndx, st_other); 121 122 // get ld_value - ld_value must be section relative. 123 uint64_t ld_value = getSymValue(st_value, st_shndx, pInput); 124 125 // get ld_vis 126 ResolveInfo::Visibility ld_vis = getSymVisibility(st_other); 127 128 // get section 129 LDSection* section = NULL; 130 if (st_shndx < llvm::ELF::SHN_LORESERVE) // including ABS and COMMON 131 section = pInput.context()->getSection(st_shndx); 132 133 // get ld_name 134 std::string ld_name; 135 if (ResolveInfo::Section == ld_type) { 136 // Section symbol's st_name is the section index. 137 assert(NULL != section && "get a invalid section"); 138 ld_name = section->name(); 139 } 140 else { 141 ld_name = std::string(pStrTab + st_name); 142 } 143 144 pBuilder.AddSymbol(pInput, 145 ld_name, 146 ld_type, 147 ld_desc, 148 ld_binding, 149 st_size, 150 ld_value, 151 section, ld_vis); 152 } // end of for loop 153 return true; 154 } 155 156 //===----------------------------------------------------------------------===// 157 // ELFReader::read relocations - read ELF rela and rel, and create Relocation 158 //===----------------------------------------------------------------------===// 159 /// ELFReader::readRela - read ELF rela and create Relocation 160 bool ELFReader<32, true>::readRela(Input& pInput, 161 LDSection& pSection, 162 const MemoryRegion& pRegion) const 163 { 164 // get the number of rela 165 size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf32_Rela); 166 const llvm::ELF::Elf32_Rela* relaTab = 167 reinterpret_cast<const llvm::ELF::Elf32_Rela*>(pRegion.start()); 168 169 for (size_t idx=0; idx < entsize; ++idx) { 170 uint32_t r_offset = 0x0; 171 uint32_t r_info = 0x0; 172 int32_t r_addend = 0; 173 if (llvm::sys::isLittleEndianHost()) { 174 r_offset = relaTab[idx].r_offset; 175 r_info = relaTab[idx].r_info; 176 r_addend = relaTab[idx].r_addend; 177 } 178 else { 179 r_offset = mcld::bswap32(relaTab[idx].r_offset); 180 r_info = mcld::bswap32(relaTab[idx].r_info); 181 r_addend = mcld::bswap32(relaTab[idx].r_addend); 182 } 183 184 uint8_t r_type = static_cast<unsigned char>(r_info); 185 uint32_t r_sym = (r_info >> 8); 186 LDSymbol* symbol = pInput.context()->getSymbol(r_sym); 187 if (NULL == symbol) { 188 fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path(); 189 } 190 191 IRBuilder::AddRelocation(pSection, r_type, *symbol, r_offset, r_addend); 192 } // end of for 193 return true; 194 } 195 196 /// readRel - read ELF rel and create Relocation 197 bool ELFReader<32, true>::readRel(Input& pInput, 198 LDSection& pSection, 199 const MemoryRegion& pRegion) const 200 { 201 // get the number of rel 202 size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf32_Rel); 203 const llvm::ELF::Elf32_Rel* relTab = 204 reinterpret_cast<const llvm::ELF::Elf32_Rel*>(pRegion.start()); 205 206 for (size_t idx=0; idx < entsize; ++idx) { 207 uint32_t r_offset = 0x0; 208 uint32_t r_info = 0x0; 209 if (llvm::sys::isLittleEndianHost()) { 210 r_offset = relTab[idx].r_offset; 211 r_info = relTab[idx].r_info; 212 } 213 else { 214 r_offset = mcld::bswap32(relTab[idx].r_offset); 215 r_info = mcld::bswap32(relTab[idx].r_info); 216 } 217 218 uint8_t r_type = static_cast<unsigned char>(r_info); 219 uint32_t r_sym = (r_info >> 8); 220 221 LDSymbol* symbol = pInput.context()->getSymbol(r_sym); 222 if (NULL == symbol) { 223 fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path(); 224 } 225 226 IRBuilder::AddRelocation(pSection, r_type, *symbol, r_offset); 227 } // end of for 228 return true; 229 } 230 231 /// isMyEndian - is this ELF file in the same endian to me? 232 bool ELFReader<32, true>::isMyEndian(void* pELFHeader) const 233 { 234 llvm::ELF::Elf32_Ehdr* hdr = 235 reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader); 236 237 return (hdr->e_ident[llvm::ELF::EI_DATA] == llvm::ELF::ELFDATA2LSB); 238 } 239 240 /// isMyMachine - is this ELF file generated for the same machine. 241 bool ELFReader<32, true>::isMyMachine(void* pELFHeader) const 242 { 243 llvm::ELF::Elf32_Ehdr* hdr = 244 reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader); 245 246 if (llvm::sys::isLittleEndianHost()) 247 return (hdr->e_machine == target().getInfo().machine()); 248 return (mcld::bswap16(hdr->e_machine) == target().getInfo().machine()); 249 } 250 251 /// fileType - return the file type 252 Input::Type ELFReader<32, true>::fileType(void* pELFHeader) const 253 { 254 llvm::ELF::Elf32_Ehdr* hdr = 255 reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader); 256 uint32_t type = 0x0; 257 if (llvm::sys::isLittleEndianHost()) 258 type = hdr->e_type; 259 else 260 type = mcld::bswap16(hdr->e_type); 261 262 switch(type) { 263 case llvm::ELF::ET_REL: 264 return Input::Object; 265 case llvm::ELF::ET_EXEC: 266 return Input::Exec; 267 case llvm::ELF::ET_DYN: 268 return Input::DynObj; 269 case llvm::ELF::ET_CORE: 270 return Input::CoreFile; 271 case llvm::ELF::ET_NONE: 272 default: 273 return Input::Unknown; 274 } 275 } 276 277 /// readSectionHeaders - read ELF section header table and create LDSections 278 bool 279 ELFReader<32, true>::readSectionHeaders(Input& pInput, void* pELFHeader) const 280 { 281 llvm::ELF::Elf32_Ehdr* ehdr = 282 reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader); 283 284 uint32_t shoff = 0x0; 285 uint16_t shentsize = 0x0; 286 uint32_t shnum = 0x0; 287 uint32_t shstrtab = 0x0; 288 289 if (llvm::sys::isLittleEndianHost()) { 290 shoff = ehdr->e_shoff; 291 shentsize = ehdr->e_shentsize; 292 shnum = ehdr->e_shnum; 293 shstrtab = ehdr->e_shstrndx; 294 } 295 else { 296 shoff = mcld::bswap32(ehdr->e_shoff); 297 shentsize = mcld::bswap16(ehdr->e_shentsize); 298 shnum = mcld::bswap16(ehdr->e_shnum); 299 shstrtab = mcld::bswap16(ehdr->e_shstrndx); 300 } 301 302 // If the file has no section header table, e_shoff holds zero. 303 if (0x0 == shoff) 304 return true; 305 306 llvm::ELF::Elf32_Shdr *shdr = NULL; 307 MemoryRegion* shdr_region = NULL; 308 uint32_t sh_name = 0x0; 309 uint32_t sh_type = 0x0; 310 uint32_t sh_flags = 0x0; 311 uint32_t sh_offset = 0x0; 312 uint32_t sh_size = 0x0; 313 uint32_t sh_link = 0x0; 314 uint32_t sh_info = 0x0; 315 uint32_t sh_addralign = 0x0; 316 317 // if shnum and shstrtab overflow, the actual values are in the 1st shdr 318 if (shnum == llvm::ELF::SHN_UNDEF || shstrtab == llvm::ELF::SHN_XINDEX) { 319 shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff, 320 shentsize); 321 shdr = reinterpret_cast<llvm::ELF::Elf32_Shdr*>(shdr_region->start()); 322 323 if (llvm::sys::isLittleEndianHost()) { 324 sh_size = shdr->sh_size; 325 sh_link = shdr->sh_link; 326 } 327 else { 328 sh_size = mcld::bswap32(shdr->sh_size); 329 sh_link = mcld::bswap32(shdr->sh_link); 330 } 331 pInput.memArea()->release(shdr_region); 332 333 if (shnum == llvm::ELF::SHN_UNDEF) 334 shnum = sh_size; 335 if (shstrtab == llvm::ELF::SHN_XINDEX) 336 shstrtab = sh_link; 337 338 shoff += shentsize; 339 } 340 341 shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff, 342 shnum * shentsize); 343 llvm::ELF::Elf32_Shdr * shdrTab = 344 reinterpret_cast<llvm::ELF::Elf32_Shdr*>(shdr_region->start()); 345 346 // get .shstrtab first 347 shdr = &shdrTab[shstrtab]; 348 if (llvm::sys::isLittleEndianHost()) { 349 sh_offset = shdr->sh_offset; 350 sh_size = shdr->sh_size; 351 } 352 else { 353 sh_offset = mcld::bswap32(shdr->sh_offset); 354 sh_size = mcld::bswap32(shdr->sh_size); 355 } 356 357 MemoryRegion* sect_name_region = pInput.memArea()->request( 358 pInput.fileOffset() + sh_offset, sh_size); 359 const char* sect_name = 360 reinterpret_cast<const char*>(sect_name_region->start()); 361 362 LinkInfoList link_info_list; 363 364 // create all LDSections, including first NULL section. 365 for (size_t idx = 0; idx < shnum; ++idx) { 366 if (llvm::sys::isLittleEndianHost()) { 367 sh_name = shdrTab[idx].sh_name; 368 sh_type = shdrTab[idx].sh_type; 369 sh_flags = shdrTab[idx].sh_flags; 370 sh_offset = shdrTab[idx].sh_offset; 371 sh_size = shdrTab[idx].sh_size; 372 sh_link = shdrTab[idx].sh_link; 373 sh_info = shdrTab[idx].sh_info; 374 sh_addralign = shdrTab[idx].sh_addralign; 375 } 376 else { 377 sh_name = mcld::bswap32(shdrTab[idx].sh_name); 378 sh_type = mcld::bswap32(shdrTab[idx].sh_type); 379 sh_flags = mcld::bswap32(shdrTab[idx].sh_flags); 380 sh_offset = mcld::bswap32(shdrTab[idx].sh_offset); 381 sh_size = mcld::bswap32(shdrTab[idx].sh_size); 382 sh_link = mcld::bswap32(shdrTab[idx].sh_link); 383 sh_info = mcld::bswap32(shdrTab[idx].sh_info); 384 sh_addralign = mcld::bswap32(shdrTab[idx].sh_addralign); 385 } 386 387 LDSection* section = IRBuilder::CreateELFHeader(pInput, 388 sect_name+sh_name, 389 sh_type, 390 sh_flags, 391 sh_addralign); 392 section->setSize(sh_size); 393 section->setOffset(sh_offset); 394 section->setInfo(sh_info); 395 396 if (sh_link != 0x0 || sh_info != 0x0) { 397 LinkInfo link_info = { section, sh_link, sh_info }; 398 link_info_list.push_back(link_info); 399 } 400 } // end of for 401 402 // set up InfoLink 403 LinkInfoList::iterator info, infoEnd = link_info_list.end(); 404 for (info = link_info_list.begin(); info != infoEnd; ++info) { 405 if (LDFileFormat::NamePool == info->section->kind() || 406 LDFileFormat::Group == info->section->kind() || 407 LDFileFormat::Note == info->section->kind()) { 408 info->section->setLink(pInput.context()->getSection(info->sh_link)); 409 continue; 410 } 411 if (LDFileFormat::Relocation == info->section->kind()) { 412 info->section->setLink(pInput.context()->getSection(info->sh_info)); 413 continue; 414 } 415 } 416 417 pInput.memArea()->release(shdr_region); 418 pInput.memArea()->release(sect_name_region); 419 420 return true; 421 } 422 423 /// readSignature - read a symbol from the given Input and index in symtab 424 /// This is used to get the signature of a group section. 425 ResolveInfo* ELFReader<32, true>::readSignature(Input& pInput, 426 LDSection& pSymTab, 427 uint32_t pSymIdx) const 428 { 429 LDSection* symtab = &pSymTab; 430 LDSection* strtab = symtab->getLink(); 431 assert(NULL != symtab && NULL != strtab); 432 433 uint32_t offset = pInput.fileOffset() + symtab->offset() + 434 sizeof(llvm::ELF::Elf32_Sym) * pSymIdx; 435 MemoryRegion* symbol_region = 436 pInput.memArea()->request(offset, sizeof(llvm::ELF::Elf32_Sym)); 437 llvm::ELF::Elf32_Sym* entry = 438 reinterpret_cast<llvm::ELF::Elf32_Sym*>(symbol_region->start()); 439 440 uint32_t st_name = 0x0; 441 uint8_t st_info = 0x0; 442 uint8_t st_other = 0x0; 443 uint16_t st_shndx = 0x0; 444 st_info = entry->st_info; 445 st_other = entry->st_other; 446 if (llvm::sys::isLittleEndianHost()) { 447 st_name = entry->st_name; 448 st_shndx = entry->st_shndx; 449 } 450 else { 451 st_name = mcld::bswap32(entry->st_name); 452 st_shndx = mcld::bswap16(entry->st_shndx); 453 } 454 455 MemoryRegion* strtab_region = pInput.memArea()->request( 456 pInput.fileOffset() + strtab->offset(), strtab->size()); 457 458 // get ld_name 459 llvm::StringRef ld_name( 460 reinterpret_cast<char*>(strtab_region->start() + st_name)); 461 462 ResolveInfo* result = ResolveInfo::Create(ld_name); 463 result->setSource(pInput.type() == Input::DynObj); 464 result->setType(static_cast<ResolveInfo::Type>(st_info & 0xF)); 465 result->setDesc(getSymDesc(st_shndx, pInput)); 466 result->setBinding(getSymBinding((st_info >> 4), st_shndx, st_other)); 467 result->setVisibility(getSymVisibility(st_other)); 468 469 // release regions 470 pInput.memArea()->release(symbol_region); 471 pInput.memArea()->release(strtab_region); 472 473 return result; 474 } 475 476 /// readDynamic - read ELF .dynamic in input dynobj 477 bool ELFReader<32, true>::readDynamic(Input& pInput) const 478 { 479 assert(pInput.type() == Input::DynObj); 480 const LDSection* dynamic_sect = pInput.context()->getSection(".dynamic"); 481 if (NULL == dynamic_sect) { 482 fatal(diag::err_cannot_read_section) << ".dynamic"; 483 } 484 const LDSection* dynstr_sect = dynamic_sect->getLink(); 485 if (NULL == dynstr_sect) { 486 fatal(diag::err_cannot_read_section) << ".dynstr"; 487 } 488 489 MemoryRegion* dynamic_region = pInput.memArea()->request( 490 pInput.fileOffset() + dynamic_sect->offset(), dynamic_sect->size()); 491 492 MemoryRegion* dynstr_region = pInput.memArea()->request( 493 pInput.fileOffset() + dynstr_sect->offset(), dynstr_sect->size()); 494 495 assert(NULL != dynamic_region && NULL != dynstr_region); 496 497 const llvm::ELF::Elf32_Dyn* dynamic = 498 (llvm::ELF::Elf32_Dyn*) dynamic_region->start(); 499 const char* dynstr = (const char*) dynstr_region->start(); 500 bool hasSOName = false; 501 size_t numOfEntries = dynamic_sect->size() / sizeof(llvm::ELF::Elf32_Dyn); 502 503 for (size_t idx = 0; idx < numOfEntries; ++idx) { 504 505 llvm::ELF::Elf32_Sword d_tag = 0x0; 506 llvm::ELF::Elf32_Word d_val = 0x0; 507 508 if (llvm::sys::isLittleEndianHost()) { 509 d_tag = dynamic[idx].d_tag; 510 d_val = dynamic[idx].d_un.d_val; 511 } else { 512 d_tag = mcld::bswap32(dynamic[idx].d_tag); 513 d_val = mcld::bswap32(dynamic[idx].d_un.d_val); 514 } 515 516 switch (d_tag) { 517 case llvm::ELF::DT_SONAME: 518 assert(d_val < dynstr_sect->size()); 519 pInput.setName(sys::fs::Path(dynstr + d_val).filename().native()); 520 hasSOName = true; 521 break; 522 case llvm::ELF::DT_NEEDED: 523 // TODO: 524 break; 525 case llvm::ELF::DT_NULL: 526 default: 527 break; 528 } 529 } 530 531 // if there is no SONAME in .dynamic, then set it from input path 532 if (!hasSOName) 533 pInput.setName(pInput.path().filename().native()); 534 535 pInput.memArea()->release(dynamic_region); 536 pInput.memArea()->release(dynstr_region); 537 return true; 538 } 539 540 //===----------------------------------------------------------------------===// 541 // ELFReader<64, true> 542 //===----------------------------------------------------------------------===// 543 /// constructor 544 ELFReader<64, true>::ELFReader(GNULDBackend& pBackend) 545 : ELFReaderIF(pBackend) { 546 } 547 548 /// destructor 549 ELFReader<64, true>::~ELFReader() 550 { 551 } 552 553 /// isELF - is this a ELF file 554 bool ELFReader<64, true>::isELF(void* pELFHeader) const 555 { 556 llvm::ELF::Elf64_Ehdr* hdr = 557 reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader); 558 if (0 == memcmp(llvm::ELF::ElfMagic, hdr, 4)) 559 return true; 560 return false; 561 } 562 563 /// readRegularSection - read a regular section and create fragments. 564 bool 565 ELFReader<64, true>::readRegularSection(Input& pInput, SectionData& pSD) const 566 { 567 uint64_t offset = pInput.fileOffset() + pSD.getSection().offset(); 568 uint64_t size = pSD.getSection().size(); 569 570 Fragment* frag = IRBuilder::CreateRegion(pInput, offset, size); 571 ObjectBuilder::AppendFragment(*frag, pSD); 572 return true; 573 } 574 575 /// readSymbols - read ELF symbols and create LDSymbol 576 bool ELFReader<64, true>::readSymbols(Input& pInput, 577 IRBuilder& pBuilder, 578 const MemoryRegion& pRegion, 579 const char* pStrTab) const 580 { 581 // get number of symbols 582 size_t entsize = pRegion.size()/sizeof(llvm::ELF::Elf64_Sym); 583 const llvm::ELF::Elf64_Sym* symtab = 584 reinterpret_cast<const llvm::ELF::Elf64_Sym*>(pRegion.start()); 585 586 uint32_t st_name = 0x0; 587 uint64_t st_value = 0x0; 588 uint64_t st_size = 0x0; 589 uint8_t st_info = 0x0; 590 uint8_t st_other = 0x0; 591 uint16_t st_shndx = 0x0; 592 593 // skip the first NULL symbol 594 pInput.context()->addSymbol(LDSymbol::Null()); 595 596 for (size_t idx = 1; idx < entsize; ++idx) { 597 st_info = symtab[idx].st_info; 598 st_other = symtab[idx].st_other; 599 600 if (llvm::sys::isLittleEndianHost()) { 601 st_name = symtab[idx].st_name; 602 st_value = symtab[idx].st_value; 603 st_size = symtab[idx].st_size; 604 st_shndx = symtab[idx].st_shndx; 605 } 606 else { 607 st_name = mcld::bswap32(symtab[idx].st_name); 608 st_value = mcld::bswap64(symtab[idx].st_value); 609 st_size = mcld::bswap64(symtab[idx].st_size); 610 st_shndx = mcld::bswap16(symtab[idx].st_shndx); 611 } 612 613 // If the section should not be included, set the st_shndx SHN_UNDEF 614 // - A section in interrelated groups are not included. 615 if (pInput.type() == Input::Object && 616 st_shndx < llvm::ELF::SHN_LORESERVE && 617 st_shndx != llvm::ELF::SHN_UNDEF) { 618 if (NULL == pInput.context()->getSection(st_shndx)) 619 st_shndx = llvm::ELF::SHN_UNDEF; 620 } 621 622 // get ld_type 623 ResolveInfo::Type ld_type = getSymType(st_info, st_shndx); 624 625 // get ld_desc 626 ResolveInfo::Desc ld_desc = getSymDesc(st_shndx, pInput); 627 628 // get ld_binding 629 ResolveInfo::Binding ld_binding = getSymBinding((st_info >> 4), st_shndx, st_other); 630 631 // get ld_value - ld_value must be section relative. 632 uint64_t ld_value = getSymValue(st_value, st_shndx, pInput); 633 634 // get ld_vis 635 ResolveInfo::Visibility ld_vis = getSymVisibility(st_other); 636 637 // get section 638 LDSection* section = NULL; 639 if (st_shndx < llvm::ELF::SHN_LORESERVE) // including ABS and COMMON 640 section = pInput.context()->getSection(st_shndx); 641 642 // get ld_name 643 std::string ld_name; 644 if (ResolveInfo::Section == ld_type) { 645 // Section symbol's st_name is the section index. 646 assert(NULL != section && "get a invalid section"); 647 ld_name = section->name(); 648 } 649 else { 650 ld_name = std::string(pStrTab + st_name); 651 } 652 653 pBuilder.AddSymbol(pInput, 654 ld_name, 655 ld_type, 656 ld_desc, 657 ld_binding, 658 st_size, 659 ld_value, 660 section, ld_vis); 661 } // end of for loop 662 return true; 663 } 664 665 //===----------------------------------------------------------------------===// 666 // ELFReader::read relocations - read ELF rela and rel, and create Relocation 667 //===----------------------------------------------------------------------===// 668 /// ELFReader::readRela - read ELF rela and create Relocation 669 bool ELFReader<64, true>::readRela(Input& pInput, 670 LDSection& pSection, 671 const MemoryRegion& pRegion) const 672 { 673 // get the number of rela 674 size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf64_Rela); 675 const llvm::ELF::Elf64_Rela* relaTab = 676 reinterpret_cast<const llvm::ELF::Elf64_Rela*>(pRegion.start()); 677 678 for (size_t idx=0; idx < entsize; ++idx) { 679 uint64_t r_offset = 0x0; 680 uint64_t r_info = 0x0; 681 int64_t r_addend = 0; 682 if (llvm::sys::isLittleEndianHost()) { 683 r_offset = relaTab[idx].r_offset; 684 r_info = relaTab[idx].r_info; 685 r_addend = relaTab[idx].r_addend; 686 } 687 else { 688 r_offset = mcld::bswap64(relaTab[idx].r_offset); 689 r_info = mcld::bswap64(relaTab[idx].r_info); 690 r_addend = mcld::bswap64(relaTab[idx].r_addend); 691 } 692 693 uint32_t r_type = static_cast<uint32_t>(r_info); 694 uint32_t r_sym = (r_info >> 32); 695 LDSymbol* symbol = pInput.context()->getSymbol(r_sym); 696 if (NULL == symbol) { 697 fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path(); 698 } 699 700 IRBuilder::AddRelocation(pSection, r_type, *symbol, r_offset, r_addend); 701 } // end of for 702 return true; 703 } 704 705 /// readRel - read ELF rel and create Relocation 706 bool ELFReader<64, true>::readRel(Input& pInput, 707 LDSection& pSection, 708 const MemoryRegion& pRegion) const 709 { 710 // get the number of rel 711 size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf64_Rel); 712 const llvm::ELF::Elf64_Rel* relTab = 713 reinterpret_cast<const llvm::ELF::Elf64_Rel*>(pRegion.start()); 714 715 for (size_t idx=0; idx < entsize; ++idx) { 716 uint64_t r_offset = 0x0; 717 uint64_t r_info = 0x0; 718 if (llvm::sys::isLittleEndianHost()) { 719 r_offset = relTab[idx].r_offset; 720 r_info = relTab[idx].r_info; 721 } 722 else { 723 r_offset = mcld::bswap64(relTab[idx].r_offset); 724 r_info = mcld::bswap64(relTab[idx].r_info); 725 } 726 727 uint32_t r_type = static_cast<uint32_t>(r_info); 728 uint32_t r_sym = (r_info >> 32); 729 730 LDSymbol* symbol = pInput.context()->getSymbol(r_sym); 731 if (NULL == symbol) { 732 fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path(); 733 } 734 735 IRBuilder::AddRelocation(pSection, r_type, *symbol, r_offset); 736 } // end of for 737 return true; 738 } 739 740 /// isMyEndian - is this ELF file in the same endian to me? 741 bool ELFReader<64, true>::isMyEndian(void* pELFHeader) const 742 { 743 llvm::ELF::Elf64_Ehdr* hdr = 744 reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader); 745 746 return (hdr->e_ident[llvm::ELF::EI_DATA] == llvm::ELF::ELFDATA2LSB); 747 } 748 749 /// isMyMachine - is this ELF file generated for the same machine. 750 bool ELFReader<64, true>::isMyMachine(void* pELFHeader) const 751 { 752 llvm::ELF::Elf64_Ehdr* hdr = 753 reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader); 754 755 if (llvm::sys::isLittleEndianHost()) 756 return (hdr->e_machine == target().getInfo().machine()); 757 return (mcld::bswap16(hdr->e_machine) == target().getInfo().machine()); 758 } 759 760 /// fileType - return the file type 761 Input::Type ELFReader<64, true>::fileType(void* pELFHeader) const 762 { 763 llvm::ELF::Elf64_Ehdr* hdr = 764 reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader); 765 uint32_t type = 0x0; 766 if (llvm::sys::isLittleEndianHost()) 767 type = hdr->e_type; 768 else 769 type = mcld::bswap16(hdr->e_type); 770 771 switch(type) { 772 case llvm::ELF::ET_REL: 773 return Input::Object; 774 case llvm::ELF::ET_EXEC: 775 return Input::Exec; 776 case llvm::ELF::ET_DYN: 777 return Input::DynObj; 778 case llvm::ELF::ET_CORE: 779 return Input::CoreFile; 780 case llvm::ELF::ET_NONE: 781 default: 782 return Input::Unknown; 783 } 784 } 785 786 /// readSectionHeaders - read ELF section header table and create LDSections 787 bool 788 ELFReader<64, true>::readSectionHeaders(Input& pInput, void* pELFHeader) const 789 { 790 llvm::ELF::Elf64_Ehdr* ehdr = 791 reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader); 792 793 uint64_t shoff = 0x0; 794 uint16_t shentsize = 0x0; 795 uint32_t shnum = 0x0; 796 uint32_t shstrtab = 0x0; 797 798 if (llvm::sys::isLittleEndianHost()) { 799 shoff = ehdr->e_shoff; 800 shentsize = ehdr->e_shentsize; 801 shnum = ehdr->e_shnum; 802 shstrtab = ehdr->e_shstrndx; 803 } 804 else { 805 shoff = mcld::bswap64(ehdr->e_shoff); 806 shentsize = mcld::bswap16(ehdr->e_shentsize); 807 shnum = mcld::bswap16(ehdr->e_shnum); 808 shstrtab = mcld::bswap16(ehdr->e_shstrndx); 809 } 810 811 // If the file has no section header table, e_shoff holds zero. 812 if (0x0 == shoff) 813 return true; 814 815 llvm::ELF::Elf64_Shdr *shdr = NULL; 816 MemoryRegion* shdr_region = NULL; 817 uint32_t sh_name = 0x0; 818 uint32_t sh_type = 0x0; 819 uint64_t sh_flags = 0x0; 820 uint64_t sh_offset = 0x0; 821 uint64_t sh_size = 0x0; 822 uint32_t sh_link = 0x0; 823 uint32_t sh_info = 0x0; 824 uint64_t sh_addralign = 0x0; 825 826 // if shnum and shstrtab overflow, the actual values are in the 1st shdr 827 if (shnum == llvm::ELF::SHN_UNDEF || shstrtab == llvm::ELF::SHN_XINDEX) { 828 shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff, 829 shentsize); 830 shdr = reinterpret_cast<llvm::ELF::Elf64_Shdr*>(shdr_region->start()); 831 832 if (llvm::sys::isLittleEndianHost()) { 833 sh_size = shdr->sh_size; 834 sh_link = shdr->sh_link; 835 } 836 else { 837 sh_size = mcld::bswap64(shdr->sh_size); 838 sh_link = mcld::bswap32(shdr->sh_link); 839 } 840 pInput.memArea()->release(shdr_region); 841 842 if (shnum == llvm::ELF::SHN_UNDEF) 843 shnum = sh_size; 844 if (shstrtab == llvm::ELF::SHN_XINDEX) 845 shstrtab = sh_link; 846 847 shoff += shentsize; 848 } 849 850 shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff, 851 shnum * shentsize); 852 llvm::ELF::Elf64_Shdr * shdrTab = 853 reinterpret_cast<llvm::ELF::Elf64_Shdr*>(shdr_region->start()); 854 855 // get .shstrtab first 856 shdr = &shdrTab[shstrtab]; 857 if (llvm::sys::isLittleEndianHost()) { 858 sh_offset = shdr->sh_offset; 859 sh_size = shdr->sh_size; 860 } 861 else { 862 sh_offset = mcld::bswap64(shdr->sh_offset); 863 sh_size = mcld::bswap64(shdr->sh_size); 864 } 865 866 MemoryRegion* sect_name_region = pInput.memArea()->request( 867 pInput.fileOffset() + sh_offset, sh_size); 868 const char* sect_name = 869 reinterpret_cast<const char*>(sect_name_region->start()); 870 871 LinkInfoList link_info_list; 872 873 // create all LDSections, including first NULL section. 874 for (size_t idx = 0; idx < shnum; ++idx) { 875 if (llvm::sys::isLittleEndianHost()) { 876 sh_name = shdrTab[idx].sh_name; 877 sh_type = shdrTab[idx].sh_type; 878 sh_flags = shdrTab[idx].sh_flags; 879 sh_offset = shdrTab[idx].sh_offset; 880 sh_size = shdrTab[idx].sh_size; 881 sh_link = shdrTab[idx].sh_link; 882 sh_info = shdrTab[idx].sh_info; 883 sh_addralign = shdrTab[idx].sh_addralign; 884 } 885 else { 886 sh_name = mcld::bswap32(shdrTab[idx].sh_name); 887 sh_type = mcld::bswap32(shdrTab[idx].sh_type); 888 sh_flags = mcld::bswap64(shdrTab[idx].sh_flags); 889 sh_offset = mcld::bswap64(shdrTab[idx].sh_offset); 890 sh_size = mcld::bswap64(shdrTab[idx].sh_size); 891 sh_link = mcld::bswap32(shdrTab[idx].sh_link); 892 sh_info = mcld::bswap32(shdrTab[idx].sh_info); 893 sh_addralign = mcld::bswap64(shdrTab[idx].sh_addralign); 894 } 895 896 LDSection* section = IRBuilder::CreateELFHeader(pInput, 897 sect_name+sh_name, 898 sh_type, 899 sh_flags, 900 sh_addralign); 901 section->setSize(sh_size); 902 section->setOffset(sh_offset); 903 section->setInfo(sh_info); 904 905 if (sh_link != 0x0 || sh_info != 0x0) { 906 LinkInfo link_info = { section, sh_link, sh_info }; 907 link_info_list.push_back(link_info); 908 } 909 } // end of for 910 911 // set up InfoLink 912 LinkInfoList::iterator info, infoEnd = link_info_list.end(); 913 for (info = link_info_list.begin(); info != infoEnd; ++info) { 914 if (LDFileFormat::NamePool == info->section->kind() || 915 LDFileFormat::Group == info->section->kind() || 916 LDFileFormat::Note == info->section->kind()) { 917 info->section->setLink(pInput.context()->getSection(info->sh_link)); 918 continue; 919 } 920 if (LDFileFormat::Relocation == info->section->kind()) { 921 info->section->setLink(pInput.context()->getSection(info->sh_info)); 922 continue; 923 } 924 } 925 926 pInput.memArea()->release(shdr_region); 927 pInput.memArea()->release(sect_name_region); 928 929 return true; 930 } 931 932 /// readSignature - read a symbol from the given Input and index in symtab 933 /// This is used to get the signature of a group section. 934 ResolveInfo* ELFReader<64, true>::readSignature(Input& pInput, 935 LDSection& pSymTab, 936 uint32_t pSymIdx) const 937 { 938 LDSection* symtab = &pSymTab; 939 LDSection* strtab = symtab->getLink(); 940 assert(NULL != symtab && NULL != strtab); 941 942 uint64_t offset = pInput.fileOffset() + symtab->offset() + 943 sizeof(llvm::ELF::Elf64_Sym) * pSymIdx; 944 MemoryRegion* symbol_region = 945 pInput.memArea()->request(offset, sizeof(llvm::ELF::Elf64_Sym)); 946 llvm::ELF::Elf64_Sym* entry = 947 reinterpret_cast<llvm::ELF::Elf64_Sym*>(symbol_region->start()); 948 949 uint32_t st_name = 0x0; 950 uint8_t st_info = 0x0; 951 uint8_t st_other = 0x0; 952 uint16_t st_shndx = 0x0; 953 st_info = entry->st_info; 954 st_other = entry->st_other; 955 if (llvm::sys::isLittleEndianHost()) { 956 st_name = entry->st_name; 957 st_shndx = entry->st_shndx; 958 } 959 else { 960 st_name = mcld::bswap32(entry->st_name); 961 st_shndx = mcld::bswap16(entry->st_shndx); 962 } 963 964 MemoryRegion* strtab_region = pInput.memArea()->request( 965 pInput.fileOffset() + strtab->offset(), strtab->size()); 966 967 // get ld_name 968 llvm::StringRef ld_name( 969 reinterpret_cast<char*>(strtab_region->start() + st_name)); 970 971 ResolveInfo* result = ResolveInfo::Create(ld_name); 972 result->setSource(pInput.type() == Input::DynObj); 973 result->setType(static_cast<ResolveInfo::Type>(st_info & 0xF)); 974 result->setDesc(getSymDesc(st_shndx, pInput)); 975 result->setBinding(getSymBinding((st_info >> 4), st_shndx, st_other)); 976 result->setVisibility(getSymVisibility(st_other)); 977 978 // release regions 979 pInput.memArea()->release(symbol_region); 980 pInput.memArea()->release(strtab_region); 981 982 return result; 983 } 984 985 /// readDynamic - read ELF .dynamic in input dynobj 986 bool ELFReader<64, true>::readDynamic(Input& pInput) const 987 { 988 assert(pInput.type() == Input::DynObj); 989 const LDSection* dynamic_sect = pInput.context()->getSection(".dynamic"); 990 if (NULL == dynamic_sect) { 991 fatal(diag::err_cannot_read_section) << ".dynamic"; 992 } 993 const LDSection* dynstr_sect = dynamic_sect->getLink(); 994 if (NULL == dynstr_sect) { 995 fatal(diag::err_cannot_read_section) << ".dynstr"; 996 } 997 998 MemoryRegion* dynamic_region = pInput.memArea()->request( 999 pInput.fileOffset() + dynamic_sect->offset(), dynamic_sect->size()); 1000 1001 MemoryRegion* dynstr_region = pInput.memArea()->request( 1002 pInput.fileOffset() + dynstr_sect->offset(), dynstr_sect->size()); 1003 1004 assert(NULL != dynamic_region && NULL != dynstr_region); 1005 1006 const llvm::ELF::Elf64_Dyn* dynamic = 1007 (llvm::ELF::Elf64_Dyn*) dynamic_region->start(); 1008 const char* dynstr = (const char*) dynstr_region->start(); 1009 bool hasSOName = false; 1010 size_t numOfEntries = dynamic_sect->size() / sizeof(llvm::ELF::Elf64_Dyn); 1011 1012 for (size_t idx = 0; idx < numOfEntries; ++idx) { 1013 1014 llvm::ELF::Elf64_Sxword d_tag = 0x0; 1015 llvm::ELF::Elf64_Xword d_val = 0x0; 1016 1017 if (llvm::sys::isLittleEndianHost()) { 1018 d_tag = dynamic[idx].d_tag; 1019 d_val = dynamic[idx].d_un.d_val; 1020 } else { 1021 d_tag = mcld::bswap64(dynamic[idx].d_tag); 1022 d_val = mcld::bswap64(dynamic[idx].d_un.d_val); 1023 } 1024 1025 switch (d_tag) { 1026 case llvm::ELF::DT_SONAME: 1027 assert(d_val < dynstr_sect->size()); 1028 pInput.setName(sys::fs::Path(dynstr + d_val).filename().native()); 1029 hasSOName = true; 1030 break; 1031 case llvm::ELF::DT_NEEDED: 1032 // TODO: 1033 break; 1034 case llvm::ELF::DT_NULL: 1035 default: 1036 break; 1037 } 1038 } 1039 1040 // if there is no SONAME in .dynamic, then set it from input path 1041 if (!hasSOName) 1042 pInput.setName(pInput.path().filename().native()); 1043 1044 pInput.memArea()->release(dynamic_region); 1045 pInput.memArea()->release(dynstr_region); 1046 return true; 1047 } 1048 1049
