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