1 //===- COFFObjectFile.cpp - COFF object file implementation -----*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file declares the COFFObjectFile class. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/Object/COFF.h" 15 #include "llvm/ADT/ArrayRef.h" 16 #include "llvm/ADT/SmallString.h" 17 #include "llvm/ADT/StringSwitch.h" 18 #include "llvm/ADT/Triple.h" 19 20 #include <ctype.h> 21 22 using namespace llvm; 23 using namespace object; 24 25 namespace { 26 using support::ulittle8_t; 27 using support::ulittle16_t; 28 using support::ulittle32_t; 29 using support::little16_t; 30 } 31 32 namespace { 33 // Returns false if size is greater than the buffer size. And sets ec. 34 bool checkSize(const MemoryBuffer *m, error_code &ec, uint64_t size) { 35 if (m->getBufferSize() < size) { 36 ec = object_error::unexpected_eof; 37 return false; 38 } 39 return true; 40 } 41 42 // Returns false if any bytes in [addr, addr + size) fall outsize of m. 43 bool checkAddr(const MemoryBuffer *m, 44 error_code &ec, 45 uintptr_t addr, 46 uint64_t size) { 47 if (addr + size < addr || 48 addr + size < size || 49 addr + size > uintptr_t(m->getBufferEnd())) { 50 ec = object_error::unexpected_eof; 51 return false; 52 } 53 return true; 54 } 55 } 56 57 const coff_symbol *COFFObjectFile::toSymb(DataRefImpl Symb) const { 58 const coff_symbol *addr = reinterpret_cast<const coff_symbol*>(Symb.p); 59 60 # ifndef NDEBUG 61 // Verify that the symbol points to a valid entry in the symbol table. 62 uintptr_t offset = uintptr_t(addr) - uintptr_t(base()); 63 if (offset < Header->PointerToSymbolTable 64 || offset >= Header->PointerToSymbolTable 65 + (Header->NumberOfSymbols * sizeof(coff_symbol))) 66 report_fatal_error("Symbol was outside of symbol table."); 67 68 assert((offset - Header->PointerToSymbolTable) % sizeof(coff_symbol) 69 == 0 && "Symbol did not point to the beginning of a symbol"); 70 # endif 71 72 return addr; 73 } 74 75 const coff_section *COFFObjectFile::toSec(DataRefImpl Sec) const { 76 const coff_section *addr = reinterpret_cast<const coff_section*>(Sec.p); 77 78 # ifndef NDEBUG 79 // Verify that the section points to a valid entry in the section table. 80 if (addr < SectionTable 81 || addr >= (SectionTable + Header->NumberOfSections)) 82 report_fatal_error("Section was outside of section table."); 83 84 uintptr_t offset = uintptr_t(addr) - uintptr_t(SectionTable); 85 assert(offset % sizeof(coff_section) == 0 && 86 "Section did not point to the beginning of a section"); 87 # endif 88 89 return addr; 90 } 91 92 error_code COFFObjectFile::getSymbolNext(DataRefImpl Symb, 93 SymbolRef &Result) const { 94 const coff_symbol *symb = toSymb(Symb); 95 symb += 1 + symb->NumberOfAuxSymbols; 96 Symb.p = reinterpret_cast<uintptr_t>(symb); 97 Result = SymbolRef(Symb, this); 98 return object_error::success; 99 } 100 101 error_code COFFObjectFile::getSymbolName(DataRefImpl Symb, 102 StringRef &Result) const { 103 const coff_symbol *symb = toSymb(Symb); 104 return getSymbolName(symb, Result); 105 } 106 107 error_code COFFObjectFile::getSymbolFileOffset(DataRefImpl Symb, 108 uint64_t &Result) const { 109 const coff_symbol *symb = toSymb(Symb); 110 const coff_section *Section = NULL; 111 if (error_code ec = getSection(symb->SectionNumber, Section)) 112 return ec; 113 char Type; 114 if (error_code ec = getSymbolNMTypeChar(Symb, Type)) 115 return ec; 116 if (Type == 'U' || Type == 'w') 117 Result = UnknownAddressOrSize; 118 else if (Section) 119 Result = Section->PointerToRawData + symb->Value; 120 else 121 Result = symb->Value; 122 return object_error::success; 123 } 124 125 error_code COFFObjectFile::getSymbolAddress(DataRefImpl Symb, 126 uint64_t &Result) const { 127 const coff_symbol *symb = toSymb(Symb); 128 const coff_section *Section = NULL; 129 if (error_code ec = getSection(symb->SectionNumber, Section)) 130 return ec; 131 char Type; 132 if (error_code ec = getSymbolNMTypeChar(Symb, Type)) 133 return ec; 134 if (Type == 'U' || Type == 'w') 135 Result = UnknownAddressOrSize; 136 else if (Section) 137 Result = Section->VirtualAddress + symb->Value; 138 else 139 Result = symb->Value; 140 return object_error::success; 141 } 142 143 error_code COFFObjectFile::getSymbolType(DataRefImpl Symb, 144 SymbolRef::Type &Result) const { 145 const coff_symbol *symb = toSymb(Symb); 146 Result = SymbolRef::ST_Other; 147 if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL && 148 symb->SectionNumber == COFF::IMAGE_SYM_UNDEFINED) { 149 Result = SymbolRef::ST_Unknown; 150 } else { 151 if (symb->getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION) { 152 Result = SymbolRef::ST_Function; 153 } else { 154 char Type; 155 if (error_code ec = getSymbolNMTypeChar(Symb, Type)) 156 return ec; 157 if (Type == 'r' || Type == 'R') { 158 Result = SymbolRef::ST_Data; 159 } 160 } 161 } 162 return object_error::success; 163 } 164 165 error_code COFFObjectFile::getSymbolFlags(DataRefImpl Symb, 166 uint32_t &Result) const { 167 const coff_symbol *symb = toSymb(Symb); 168 Result = SymbolRef::SF_None; 169 170 // TODO: Correctly set SF_FormatSpecific, SF_ThreadLocal, SF_Common 171 172 if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL && 173 symb->SectionNumber == COFF::IMAGE_SYM_UNDEFINED) 174 Result |= SymbolRef::SF_Undefined; 175 176 // TODO: This are certainly too restrictive. 177 if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL) 178 Result |= SymbolRef::SF_Global; 179 180 if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL) 181 Result |= SymbolRef::SF_Weak; 182 183 if (symb->SectionNumber == COFF::IMAGE_SYM_ABSOLUTE) 184 Result |= SymbolRef::SF_Absolute; 185 186 return object_error::success; 187 } 188 189 error_code COFFObjectFile::getSymbolSize(DataRefImpl Symb, 190 uint64_t &Result) const { 191 // FIXME: Return the correct size. This requires looking at all the symbols 192 // in the same section as this symbol, and looking for either the next 193 // symbol, or the end of the section. 194 const coff_symbol *symb = toSymb(Symb); 195 const coff_section *Section = NULL; 196 if (error_code ec = getSection(symb->SectionNumber, Section)) 197 return ec; 198 char Type; 199 if (error_code ec = getSymbolNMTypeChar(Symb, Type)) 200 return ec; 201 if (Type == 'U' || Type == 'w') 202 Result = UnknownAddressOrSize; 203 else if (Section) 204 Result = Section->SizeOfRawData - symb->Value; 205 else 206 Result = 0; 207 return object_error::success; 208 } 209 210 error_code COFFObjectFile::getSymbolNMTypeChar(DataRefImpl Symb, 211 char &Result) const { 212 const coff_symbol *symb = toSymb(Symb); 213 StringRef name; 214 if (error_code ec = getSymbolName(Symb, name)) 215 return ec; 216 char ret = StringSwitch<char>(name) 217 .StartsWith(".debug", 'N') 218 .StartsWith(".sxdata", 'N') 219 .Default('?'); 220 221 if (ret != '?') { 222 Result = ret; 223 return object_error::success; 224 } 225 226 uint32_t Characteristics = 0; 227 if (symb->SectionNumber > 0) { 228 const coff_section *Section = NULL; 229 if (error_code ec = getSection(symb->SectionNumber, Section)) 230 return ec; 231 Characteristics = Section->Characteristics; 232 } 233 234 switch (symb->SectionNumber) { 235 case COFF::IMAGE_SYM_UNDEFINED: 236 // Check storage classes. 237 if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL) { 238 Result = 'w'; 239 return object_error::success; // Don't do ::toupper. 240 } else if (symb->Value != 0) // Check for common symbols. 241 ret = 'c'; 242 else 243 ret = 'u'; 244 break; 245 case COFF::IMAGE_SYM_ABSOLUTE: 246 ret = 'a'; 247 break; 248 case COFF::IMAGE_SYM_DEBUG: 249 ret = 'n'; 250 break; 251 default: 252 // Check section type. 253 if (Characteristics & COFF::IMAGE_SCN_CNT_CODE) 254 ret = 't'; 255 else if ( Characteristics & COFF::IMAGE_SCN_MEM_READ 256 && ~Characteristics & COFF::IMAGE_SCN_MEM_WRITE) // Read only. 257 ret = 'r'; 258 else if (Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA) 259 ret = 'd'; 260 else if (Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA) 261 ret = 'b'; 262 else if (Characteristics & COFF::IMAGE_SCN_LNK_INFO) 263 ret = 'i'; 264 265 // Check for section symbol. 266 else if ( symb->StorageClass == COFF::IMAGE_SYM_CLASS_STATIC 267 && symb->Value == 0) 268 ret = 's'; 269 } 270 271 if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL) 272 ret = ::toupper(ret); 273 274 Result = ret; 275 return object_error::success; 276 } 277 278 error_code COFFObjectFile::getSymbolSection(DataRefImpl Symb, 279 section_iterator &Result) const { 280 const coff_symbol *symb = toSymb(Symb); 281 if (symb->SectionNumber <= COFF::IMAGE_SYM_UNDEFINED) 282 Result = end_sections(); 283 else { 284 const coff_section *sec = 0; 285 if (error_code ec = getSection(symb->SectionNumber, sec)) return ec; 286 DataRefImpl Sec; 287 Sec.p = reinterpret_cast<uintptr_t>(sec); 288 Result = section_iterator(SectionRef(Sec, this)); 289 } 290 return object_error::success; 291 } 292 293 error_code COFFObjectFile::getSectionNext(DataRefImpl Sec, 294 SectionRef &Result) const { 295 const coff_section *sec = toSec(Sec); 296 sec += 1; 297 Sec.p = reinterpret_cast<uintptr_t>(sec); 298 Result = SectionRef(Sec, this); 299 return object_error::success; 300 } 301 302 error_code COFFObjectFile::getSectionName(DataRefImpl Sec, 303 StringRef &Result) const { 304 const coff_section *sec = toSec(Sec); 305 return getSectionName(sec, Result); 306 } 307 308 error_code COFFObjectFile::getSectionAddress(DataRefImpl Sec, 309 uint64_t &Result) const { 310 const coff_section *sec = toSec(Sec); 311 Result = sec->VirtualAddress; 312 return object_error::success; 313 } 314 315 error_code COFFObjectFile::getSectionSize(DataRefImpl Sec, 316 uint64_t &Result) const { 317 const coff_section *sec = toSec(Sec); 318 Result = sec->SizeOfRawData; 319 return object_error::success; 320 } 321 322 error_code COFFObjectFile::getSectionContents(DataRefImpl Sec, 323 StringRef &Result) const { 324 const coff_section *sec = toSec(Sec); 325 ArrayRef<uint8_t> Res; 326 error_code EC = getSectionContents(sec, Res); 327 Result = StringRef(reinterpret_cast<const char*>(Res.data()), Res.size()); 328 return EC; 329 } 330 331 error_code COFFObjectFile::getSectionAlignment(DataRefImpl Sec, 332 uint64_t &Res) const { 333 const coff_section *sec = toSec(Sec); 334 if (!sec) 335 return object_error::parse_failed; 336 Res = uint64_t(1) << (((sec->Characteristics & 0x00F00000) >> 20) - 1); 337 return object_error::success; 338 } 339 340 error_code COFFObjectFile::isSectionText(DataRefImpl Sec, 341 bool &Result) const { 342 const coff_section *sec = toSec(Sec); 343 Result = sec->Characteristics & COFF::IMAGE_SCN_CNT_CODE; 344 return object_error::success; 345 } 346 347 error_code COFFObjectFile::isSectionData(DataRefImpl Sec, 348 bool &Result) const { 349 const coff_section *sec = toSec(Sec); 350 Result = sec->Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA; 351 return object_error::success; 352 } 353 354 error_code COFFObjectFile::isSectionBSS(DataRefImpl Sec, 355 bool &Result) const { 356 const coff_section *sec = toSec(Sec); 357 Result = sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA; 358 return object_error::success; 359 } 360 361 error_code COFFObjectFile::isSectionRequiredForExecution(DataRefImpl Sec, 362 bool &Result) const { 363 // FIXME: Unimplemented 364 Result = true; 365 return object_error::success; 366 } 367 368 error_code COFFObjectFile::isSectionVirtual(DataRefImpl Sec, 369 bool &Result) const { 370 const coff_section *sec = toSec(Sec); 371 Result = sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA; 372 return object_error::success; 373 } 374 375 error_code COFFObjectFile::isSectionZeroInit(DataRefImpl Sec, 376 bool &Result) const { 377 // FIXME: Unimplemented 378 Result = false; 379 return object_error::success; 380 } 381 382 error_code COFFObjectFile::sectionContainsSymbol(DataRefImpl Sec, 383 DataRefImpl Symb, 384 bool &Result) const { 385 const coff_section *sec = toSec(Sec); 386 const coff_symbol *symb = toSymb(Symb); 387 const coff_section *symb_sec = 0; 388 if (error_code ec = getSection(symb->SectionNumber, symb_sec)) return ec; 389 if (symb_sec == sec) 390 Result = true; 391 else 392 Result = false; 393 return object_error::success; 394 } 395 396 relocation_iterator COFFObjectFile::getSectionRelBegin(DataRefImpl Sec) const { 397 const coff_section *sec = toSec(Sec); 398 DataRefImpl ret; 399 if (sec->NumberOfRelocations == 0) 400 ret.p = 0; 401 else 402 ret.p = reinterpret_cast<uintptr_t>(base() + sec->PointerToRelocations); 403 404 return relocation_iterator(RelocationRef(ret, this)); 405 } 406 407 relocation_iterator COFFObjectFile::getSectionRelEnd(DataRefImpl Sec) const { 408 const coff_section *sec = toSec(Sec); 409 DataRefImpl ret; 410 if (sec->NumberOfRelocations == 0) 411 ret.p = 0; 412 else 413 ret.p = reinterpret_cast<uintptr_t>( 414 reinterpret_cast<const coff_relocation*>( 415 base() + sec->PointerToRelocations) 416 + sec->NumberOfRelocations); 417 418 return relocation_iterator(RelocationRef(ret, this)); 419 } 420 421 COFFObjectFile::COFFObjectFile(MemoryBuffer *Object, error_code &ec) 422 : ObjectFile(Binary::ID_COFF, Object, ec) 423 , Header(0) 424 , SectionTable(0) 425 , SymbolTable(0) 426 , StringTable(0) 427 , StringTableSize(0) { 428 // Check that we at least have enough room for a header. 429 if (!checkSize(Data, ec, sizeof(coff_file_header))) return; 430 431 // The actual starting location of the COFF header in the file. This can be 432 // non-zero in PE/COFF files. 433 uint64_t HeaderStart = 0; 434 435 // Check if this is a PE/COFF file. 436 if (base()[0] == 0x4d && base()[1] == 0x5a) { 437 // PE/COFF, seek through MS-DOS compatibility stub and 4-byte 438 // PE signature to find 'normal' COFF header. 439 if (!checkSize(Data, ec, 0x3c + 8)) return; 440 HeaderStart = *reinterpret_cast<const ulittle16_t *>(base() + 0x3c); 441 // Check the PE header. ("PE\0\0") 442 if (std::memcmp(base() + HeaderStart, "PE\0\0", 4) != 0) { 443 ec = object_error::parse_failed; 444 return; 445 } 446 HeaderStart += 4; // Skip the PE Header. 447 } 448 449 Header = reinterpret_cast<const coff_file_header *>(base() + HeaderStart); 450 if (!checkAddr(Data, ec, uintptr_t(Header), sizeof(coff_file_header))) 451 return; 452 453 SectionTable = 454 reinterpret_cast<const coff_section *>( base() 455 + HeaderStart 456 + sizeof(coff_file_header) 457 + Header->SizeOfOptionalHeader); 458 if (!checkAddr(Data, ec, uintptr_t(SectionTable), 459 Header->NumberOfSections * sizeof(coff_section))) 460 return; 461 462 if (Header->PointerToSymbolTable != 0) { 463 SymbolTable = 464 reinterpret_cast<const coff_symbol *>(base() 465 + Header->PointerToSymbolTable); 466 if (!checkAddr(Data, ec, uintptr_t(SymbolTable), 467 Header->NumberOfSymbols * sizeof(coff_symbol))) 468 return; 469 470 // Find string table. 471 StringTable = reinterpret_cast<const char *>(base()) 472 + Header->PointerToSymbolTable 473 + Header->NumberOfSymbols * sizeof(coff_symbol); 474 if (!checkAddr(Data, ec, uintptr_t(StringTable), sizeof(ulittle32_t))) 475 return; 476 477 StringTableSize = *reinterpret_cast<const ulittle32_t *>(StringTable); 478 if (!checkAddr(Data, ec, uintptr_t(StringTable), StringTableSize)) 479 return; 480 // Check that the string table is null terminated if has any in it. 481 if (StringTableSize < 4 482 || (StringTableSize > 4 && StringTable[StringTableSize - 1] != 0)) { 483 ec = object_error::parse_failed; 484 return; 485 } 486 } 487 488 ec = object_error::success; 489 } 490 491 symbol_iterator COFFObjectFile::begin_symbols() const { 492 DataRefImpl ret; 493 ret.p = reinterpret_cast<intptr_t>(SymbolTable); 494 return symbol_iterator(SymbolRef(ret, this)); 495 } 496 497 symbol_iterator COFFObjectFile::end_symbols() const { 498 // The symbol table ends where the string table begins. 499 DataRefImpl ret; 500 ret.p = reinterpret_cast<intptr_t>(StringTable); 501 return symbol_iterator(SymbolRef(ret, this)); 502 } 503 504 symbol_iterator COFFObjectFile::begin_dynamic_symbols() const { 505 // TODO: implement 506 report_fatal_error("Dynamic symbols unimplemented in COFFObjectFile"); 507 } 508 509 symbol_iterator COFFObjectFile::end_dynamic_symbols() const { 510 // TODO: implement 511 report_fatal_error("Dynamic symbols unimplemented in COFFObjectFile"); 512 } 513 514 library_iterator COFFObjectFile::begin_libraries_needed() const { 515 // TODO: implement 516 report_fatal_error("Libraries needed unimplemented in COFFObjectFile"); 517 } 518 519 library_iterator COFFObjectFile::end_libraries_needed() const { 520 // TODO: implement 521 report_fatal_error("Libraries needed unimplemented in COFFObjectFile"); 522 } 523 524 StringRef COFFObjectFile::getLoadName() const { 525 // COFF does not have this field. 526 return ""; 527 } 528 529 530 section_iterator COFFObjectFile::begin_sections() const { 531 DataRefImpl ret; 532 ret.p = reinterpret_cast<intptr_t>(SectionTable); 533 return section_iterator(SectionRef(ret, this)); 534 } 535 536 section_iterator COFFObjectFile::end_sections() const { 537 DataRefImpl ret; 538 ret.p = reinterpret_cast<intptr_t>(SectionTable + Header->NumberOfSections); 539 return section_iterator(SectionRef(ret, this)); 540 } 541 542 uint8_t COFFObjectFile::getBytesInAddress() const { 543 return getArch() == Triple::x86_64 ? 8 : 4; 544 } 545 546 StringRef COFFObjectFile::getFileFormatName() const { 547 switch(Header->Machine) { 548 case COFF::IMAGE_FILE_MACHINE_I386: 549 return "COFF-i386"; 550 case COFF::IMAGE_FILE_MACHINE_AMD64: 551 return "COFF-x86-64"; 552 default: 553 return "COFF-<unknown arch>"; 554 } 555 } 556 557 unsigned COFFObjectFile::getArch() const { 558 switch(Header->Machine) { 559 case COFF::IMAGE_FILE_MACHINE_I386: 560 return Triple::x86; 561 case COFF::IMAGE_FILE_MACHINE_AMD64: 562 return Triple::x86_64; 563 default: 564 return Triple::UnknownArch; 565 } 566 } 567 568 error_code COFFObjectFile::getHeader(const coff_file_header *&Res) const { 569 Res = Header; 570 return object_error::success; 571 } 572 573 error_code COFFObjectFile::getSection(int32_t index, 574 const coff_section *&Result) const { 575 // Check for special index values. 576 if (index == COFF::IMAGE_SYM_UNDEFINED || 577 index == COFF::IMAGE_SYM_ABSOLUTE || 578 index == COFF::IMAGE_SYM_DEBUG) 579 Result = NULL; 580 else if (index > 0 && index <= Header->NumberOfSections) 581 // We already verified the section table data, so no need to check again. 582 Result = SectionTable + (index - 1); 583 else 584 return object_error::parse_failed; 585 return object_error::success; 586 } 587 588 error_code COFFObjectFile::getString(uint32_t offset, 589 StringRef &Result) const { 590 if (StringTableSize <= 4) 591 // Tried to get a string from an empty string table. 592 return object_error::parse_failed; 593 if (offset >= StringTableSize) 594 return object_error::unexpected_eof; 595 Result = StringRef(StringTable + offset); 596 return object_error::success; 597 } 598 599 error_code COFFObjectFile::getSymbol(uint32_t index, 600 const coff_symbol *&Result) const { 601 if (index < Header->NumberOfSymbols) 602 Result = SymbolTable + index; 603 else 604 return object_error::parse_failed; 605 return object_error::success; 606 } 607 608 error_code COFFObjectFile::getSymbolName(const coff_symbol *symbol, 609 StringRef &Res) const { 610 // Check for string table entry. First 4 bytes are 0. 611 if (symbol->Name.Offset.Zeroes == 0) { 612 uint32_t Offset = symbol->Name.Offset.Offset; 613 if (error_code ec = getString(Offset, Res)) 614 return ec; 615 return object_error::success; 616 } 617 618 if (symbol->Name.ShortName[7] == 0) 619 // Null terminated, let ::strlen figure out the length. 620 Res = StringRef(symbol->Name.ShortName); 621 else 622 // Not null terminated, use all 8 bytes. 623 Res = StringRef(symbol->Name.ShortName, 8); 624 return object_error::success; 625 } 626 627 ArrayRef<uint8_t> COFFObjectFile::getSymbolAuxData( 628 const coff_symbol *symbol) const { 629 const uint8_t *aux = NULL; 630 631 if ( symbol->NumberOfAuxSymbols > 0 ) { 632 // AUX data comes immediately after the symbol in COFF 633 aux = reinterpret_cast<const uint8_t *>(symbol + 1); 634 # ifndef NDEBUG 635 // Verify that the aux symbol points to a valid entry in the symbol table. 636 uintptr_t offset = uintptr_t(aux) - uintptr_t(base()); 637 if (offset < Header->PointerToSymbolTable 638 || offset >= Header->PointerToSymbolTable 639 + (Header->NumberOfSymbols * sizeof(coff_symbol))) 640 report_fatal_error("Aux Symbol data was outside of symbol table."); 641 642 assert((offset - Header->PointerToSymbolTable) % sizeof(coff_symbol) 643 == 0 && "Aux Symbol data did not point to the beginning of a symbol"); 644 # endif 645 } 646 return ArrayRef<uint8_t>(aux, symbol->NumberOfAuxSymbols * sizeof(coff_symbol)); 647 } 648 649 error_code COFFObjectFile::getSectionName(const coff_section *Sec, 650 StringRef &Res) const { 651 StringRef Name; 652 if (Sec->Name[7] == 0) 653 // Null terminated, let ::strlen figure out the length. 654 Name = Sec->Name; 655 else 656 // Not null terminated, use all 8 bytes. 657 Name = StringRef(Sec->Name, 8); 658 659 // Check for string table entry. First byte is '/'. 660 if (Name[0] == '/') { 661 uint32_t Offset; 662 if (Name.substr(1).getAsInteger(10, Offset)) 663 return object_error::parse_failed; 664 if (error_code ec = getString(Offset, Name)) 665 return ec; 666 } 667 668 Res = Name; 669 return object_error::success; 670 } 671 672 error_code COFFObjectFile::getSectionContents(const coff_section *Sec, 673 ArrayRef<uint8_t> &Res) const { 674 // The only thing that we need to verify is that the contents is contained 675 // within the file bounds. We don't need to make sure it doesn't cover other 676 // data, as there's nothing that says that is not allowed. 677 uintptr_t ConStart = uintptr_t(base()) + Sec->PointerToRawData; 678 uintptr_t ConEnd = ConStart + Sec->SizeOfRawData; 679 if (ConEnd > uintptr_t(Data->getBufferEnd())) 680 return object_error::parse_failed; 681 Res = ArrayRef<uint8_t>(reinterpret_cast<const unsigned char*>(ConStart), 682 Sec->SizeOfRawData); 683 return object_error::success; 684 } 685 686 const coff_relocation *COFFObjectFile::toRel(DataRefImpl Rel) const { 687 return reinterpret_cast<const coff_relocation*>(Rel.p); 688 } 689 error_code COFFObjectFile::getRelocationNext(DataRefImpl Rel, 690 RelocationRef &Res) const { 691 Rel.p = reinterpret_cast<uintptr_t>( 692 reinterpret_cast<const coff_relocation*>(Rel.p) + 1); 693 Res = RelocationRef(Rel, this); 694 return object_error::success; 695 } 696 error_code COFFObjectFile::getRelocationAddress(DataRefImpl Rel, 697 uint64_t &Res) const { 698 Res = toRel(Rel)->VirtualAddress; 699 return object_error::success; 700 } 701 error_code COFFObjectFile::getRelocationOffset(DataRefImpl Rel, 702 uint64_t &Res) const { 703 Res = toRel(Rel)->VirtualAddress; 704 return object_error::success; 705 } 706 error_code COFFObjectFile::getRelocationSymbol(DataRefImpl Rel, 707 SymbolRef &Res) const { 708 const coff_relocation* R = toRel(Rel); 709 DataRefImpl Symb; 710 Symb.p = reinterpret_cast<uintptr_t>(SymbolTable + R->SymbolTableIndex); 711 Res = SymbolRef(Symb, this); 712 return object_error::success; 713 } 714 error_code COFFObjectFile::getRelocationType(DataRefImpl Rel, 715 uint64_t &Res) const { 716 const coff_relocation* R = toRel(Rel); 717 Res = R->Type; 718 return object_error::success; 719 } 720 721 const coff_section *COFFObjectFile::getCOFFSection(section_iterator &It) const { 722 return toSec(It->getRawDataRefImpl()); 723 } 724 725 const coff_symbol *COFFObjectFile::getCOFFSymbol(symbol_iterator &It) const { 726 return toSymb(It->getRawDataRefImpl()); 727 } 728 729 const coff_relocation *COFFObjectFile::getCOFFRelocation( 730 relocation_iterator &It) const { 731 return toRel(It->getRawDataRefImpl()); 732 } 733 734 735 #define LLVM_COFF_SWITCH_RELOC_TYPE_NAME(enum) \ 736 case COFF::enum: res = #enum; break; 737 738 error_code COFFObjectFile::getRelocationTypeName(DataRefImpl Rel, 739 SmallVectorImpl<char> &Result) const { 740 const coff_relocation *reloc = toRel(Rel); 741 StringRef res; 742 switch (Header->Machine) { 743 case COFF::IMAGE_FILE_MACHINE_AMD64: 744 switch (reloc->Type) { 745 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ABSOLUTE); 746 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR64); 747 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR32); 748 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR32NB); 749 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32); 750 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_1); 751 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_2); 752 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_3); 753 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_4); 754 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_5); 755 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SECTION); 756 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SECREL); 757 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SECREL7); 758 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_TOKEN); 759 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SREL32); 760 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_PAIR); 761 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SSPAN32); 762 default: 763 res = "Unknown"; 764 } 765 break; 766 case COFF::IMAGE_FILE_MACHINE_I386: 767 switch (reloc->Type) { 768 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_ABSOLUTE); 769 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR16); 770 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_REL16); 771 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR32); 772 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR32NB); 773 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SEG12); 774 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECTION); 775 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECREL); 776 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_TOKEN); 777 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECREL7); 778 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_REL32); 779 default: 780 res = "Unknown"; 781 } 782 break; 783 default: 784 res = "Unknown"; 785 } 786 Result.append(res.begin(), res.end()); 787 return object_error::success; 788 } 789 790 #undef LLVM_COFF_SWITCH_RELOC_TYPE_NAME 791 792 error_code COFFObjectFile::getRelocationAdditionalInfo(DataRefImpl Rel, 793 int64_t &Res) const { 794 Res = 0; 795 return object_error::success; 796 } 797 error_code COFFObjectFile::getRelocationValueString(DataRefImpl Rel, 798 SmallVectorImpl<char> &Result) const { 799 const coff_relocation *reloc = toRel(Rel); 800 const coff_symbol *symb = 0; 801 if (error_code ec = getSymbol(reloc->SymbolTableIndex, symb)) return ec; 802 DataRefImpl sym; 803 sym.p = reinterpret_cast<uintptr_t>(symb); 804 StringRef symname; 805 if (error_code ec = getSymbolName(sym, symname)) return ec; 806 Result.append(symname.begin(), symname.end()); 807 return object_error::success; 808 } 809 810 error_code COFFObjectFile::getLibraryNext(DataRefImpl LibData, 811 LibraryRef &Result) const { 812 report_fatal_error("getLibraryNext not implemented in COFFObjectFile"); 813 } 814 815 error_code COFFObjectFile::getLibraryPath(DataRefImpl LibData, 816 StringRef &Result) const { 817 report_fatal_error("getLibraryPath not implemented in COFFObjectFile"); 818 } 819 820 namespace llvm { 821 822 ObjectFile *ObjectFile::createCOFFObjectFile(MemoryBuffer *Object) { 823 error_code ec; 824 return new COFFObjectFile(Object, ec); 825 } 826 827 } // end namespace llvm 828