1 //===- COFFObjectFile.cpp - COFF object file implementation ---------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file declares the COFFObjectFile class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/ADT/ArrayRef.h" 14 #include "llvm/ADT/StringRef.h" 15 #include "llvm/ADT/StringSwitch.h" 16 #include "llvm/ADT/Triple.h" 17 #include "llvm/ADT/iterator_range.h" 18 #include "llvm/BinaryFormat/COFF.h" 19 #include "llvm/Object/Binary.h" 20 #include "llvm/Object/COFF.h" 21 #include "llvm/Object/Error.h" 22 #include "llvm/Object/ObjectFile.h" 23 #include "llvm/Support/BinaryStreamReader.h" 24 #include "llvm/Support/Endian.h" 25 #include "llvm/Support/Error.h" 26 #include "llvm/Support/ErrorHandling.h" 27 #include "llvm/Support/MathExtras.h" 28 #include "llvm/Support/MemoryBuffer.h" 29 #include <algorithm> 30 #include <cassert> 31 #include <cinttypes> 32 #include <cstddef> 33 #include <cstring> 34 #include <limits> 35 #include <memory> 36 #include <system_error> 37 38 using namespace llvm; 39 using namespace object; 40 41 using support::ulittle16_t; 42 using support::ulittle32_t; 43 using support::ulittle64_t; 44 using support::little16_t; 45 46 // Returns false if size is greater than the buffer size. And sets ec. 47 static bool checkSize(MemoryBufferRef M, std::error_code &EC, uint64_t Size) { 48 if (M.getBufferSize() < Size) { 49 EC = object_error::unexpected_eof; 50 return false; 51 } 52 return true; 53 } 54 55 // Sets Obj unless any bytes in [addr, addr + size) fall outsize of m. 56 // Returns unexpected_eof if error. 57 template <typename T> 58 static Error getObject(const T *&Obj, MemoryBufferRef M, const void *Ptr, 59 const uint64_t Size = sizeof(T)) { 60 uintptr_t Addr = reinterpret_cast<uintptr_t>(Ptr); 61 if (Error E = Binary::checkOffset(M, Addr, Size)) 62 return E; 63 Obj = reinterpret_cast<const T *>(Addr); 64 return Error::success(); 65 } 66 67 // Decode a string table entry in base 64 (//AAAAAA). Expects \arg Str without 68 // prefixed slashes. 69 static bool decodeBase64StringEntry(StringRef Str, uint32_t &Result) { 70 assert(Str.size() <= 6 && "String too long, possible overflow."); 71 if (Str.size() > 6) 72 return true; 73 74 uint64_t Value = 0; 75 while (!Str.empty()) { 76 unsigned CharVal; 77 if (Str[0] >= 'A' && Str[0] <= 'Z') // 0..25 78 CharVal = Str[0] - 'A'; 79 else if (Str[0] >= 'a' && Str[0] <= 'z') // 26..51 80 CharVal = Str[0] - 'a' + 26; 81 else if (Str[0] >= '0' && Str[0] <= '9') // 52..61 82 CharVal = Str[0] - '0' + 52; 83 else if (Str[0] == '+') // 62 84 CharVal = 62; 85 else if (Str[0] == '/') // 63 86 CharVal = 63; 87 else 88 return true; 89 90 Value = (Value * 64) + CharVal; 91 Str = Str.substr(1); 92 } 93 94 if (Value > std::numeric_limits<uint32_t>::max()) 95 return true; 96 97 Result = static_cast<uint32_t>(Value); 98 return false; 99 } 100 101 template <typename coff_symbol_type> 102 const coff_symbol_type *COFFObjectFile::toSymb(DataRefImpl Ref) const { 103 const coff_symbol_type *Addr = 104 reinterpret_cast<const coff_symbol_type *>(Ref.p); 105 106 assert(!checkOffset(Data, reinterpret_cast<uintptr_t>(Addr), sizeof(*Addr))); 107 #ifndef NDEBUG 108 // Verify that the symbol points to a valid entry in the symbol table. 109 uintptr_t Offset = 110 reinterpret_cast<uintptr_t>(Addr) - reinterpret_cast<uintptr_t>(base()); 111 112 assert((Offset - getPointerToSymbolTable()) % sizeof(coff_symbol_type) == 0 && 113 "Symbol did not point to the beginning of a symbol"); 114 #endif 115 116 return Addr; 117 } 118 119 const coff_section *COFFObjectFile::toSec(DataRefImpl Ref) const { 120 const coff_section *Addr = reinterpret_cast<const coff_section*>(Ref.p); 121 122 #ifndef NDEBUG 123 // Verify that the section points to a valid entry in the section table. 124 if (Addr < SectionTable || Addr >= (SectionTable + getNumberOfSections())) 125 report_fatal_error("Section was outside of section table."); 126 127 uintptr_t Offset = reinterpret_cast<uintptr_t>(Addr) - 128 reinterpret_cast<uintptr_t>(SectionTable); 129 assert(Offset % sizeof(coff_section) == 0 && 130 "Section did not point to the beginning of a section"); 131 #endif 132 133 return Addr; 134 } 135 136 void COFFObjectFile::moveSymbolNext(DataRefImpl &Ref) const { 137 auto End = reinterpret_cast<uintptr_t>(StringTable); 138 if (SymbolTable16) { 139 const coff_symbol16 *Symb = toSymb<coff_symbol16>(Ref); 140 Symb += 1 + Symb->NumberOfAuxSymbols; 141 Ref.p = std::min(reinterpret_cast<uintptr_t>(Symb), End); 142 } else if (SymbolTable32) { 143 const coff_symbol32 *Symb = toSymb<coff_symbol32>(Ref); 144 Symb += 1 + Symb->NumberOfAuxSymbols; 145 Ref.p = std::min(reinterpret_cast<uintptr_t>(Symb), End); 146 } else { 147 llvm_unreachable("no symbol table pointer!"); 148 } 149 } 150 151 Expected<StringRef> COFFObjectFile::getSymbolName(DataRefImpl Ref) const { 152 return getSymbolName(getCOFFSymbol(Ref)); 153 } 154 155 uint64_t COFFObjectFile::getSymbolValueImpl(DataRefImpl Ref) const { 156 return getCOFFSymbol(Ref).getValue(); 157 } 158 159 uint32_t COFFObjectFile::getSymbolAlignment(DataRefImpl Ref) const { 160 // MSVC/link.exe seems to align symbols to the next-power-of-2 161 // up to 32 bytes. 162 COFFSymbolRef Symb = getCOFFSymbol(Ref); 163 return std::min(uint64_t(32), PowerOf2Ceil(Symb.getValue())); 164 } 165 166 Expected<uint64_t> COFFObjectFile::getSymbolAddress(DataRefImpl Ref) const { 167 uint64_t Result = cantFail(getSymbolValue(Ref)); 168 COFFSymbolRef Symb = getCOFFSymbol(Ref); 169 int32_t SectionNumber = Symb.getSectionNumber(); 170 171 if (Symb.isAnyUndefined() || Symb.isCommon() || 172 COFF::isReservedSectionNumber(SectionNumber)) 173 return Result; 174 175 Expected<const coff_section *> Section = getSection(SectionNumber); 176 if (!Section) 177 return Section.takeError(); 178 Result += (*Section)->VirtualAddress; 179 180 // The section VirtualAddress does not include ImageBase, and we want to 181 // return virtual addresses. 182 Result += getImageBase(); 183 184 return Result; 185 } 186 187 Expected<SymbolRef::Type> COFFObjectFile::getSymbolType(DataRefImpl Ref) const { 188 COFFSymbolRef Symb = getCOFFSymbol(Ref); 189 int32_t SectionNumber = Symb.getSectionNumber(); 190 191 if (Symb.getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION) 192 return SymbolRef::ST_Function; 193 if (Symb.isAnyUndefined()) 194 return SymbolRef::ST_Unknown; 195 if (Symb.isCommon()) 196 return SymbolRef::ST_Data; 197 if (Symb.isFileRecord()) 198 return SymbolRef::ST_File; 199 200 // TODO: perhaps we need a new symbol type ST_Section. 201 if (SectionNumber == COFF::IMAGE_SYM_DEBUG || Symb.isSectionDefinition()) 202 return SymbolRef::ST_Debug; 203 204 if (!COFF::isReservedSectionNumber(SectionNumber)) 205 return SymbolRef::ST_Data; 206 207 return SymbolRef::ST_Other; 208 } 209 210 Expected<uint32_t> COFFObjectFile::getSymbolFlags(DataRefImpl Ref) const { 211 COFFSymbolRef Symb = getCOFFSymbol(Ref); 212 uint32_t Result = SymbolRef::SF_None; 213 214 if (Symb.isExternal() || Symb.isWeakExternal()) 215 Result |= SymbolRef::SF_Global; 216 217 if (const coff_aux_weak_external *AWE = Symb.getWeakExternal()) { 218 Result |= SymbolRef::SF_Weak; 219 if (AWE->Characteristics != COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS) 220 Result |= SymbolRef::SF_Undefined; 221 } 222 223 if (Symb.getSectionNumber() == COFF::IMAGE_SYM_ABSOLUTE) 224 Result |= SymbolRef::SF_Absolute; 225 226 if (Symb.isFileRecord()) 227 Result |= SymbolRef::SF_FormatSpecific; 228 229 if (Symb.isSectionDefinition()) 230 Result |= SymbolRef::SF_FormatSpecific; 231 232 if (Symb.isCommon()) 233 Result |= SymbolRef::SF_Common; 234 235 if (Symb.isUndefined()) 236 Result |= SymbolRef::SF_Undefined; 237 238 return Result; 239 } 240 241 uint64_t COFFObjectFile::getCommonSymbolSizeImpl(DataRefImpl Ref) const { 242 COFFSymbolRef Symb = getCOFFSymbol(Ref); 243 return Symb.getValue(); 244 } 245 246 Expected<section_iterator> 247 COFFObjectFile::getSymbolSection(DataRefImpl Ref) const { 248 COFFSymbolRef Symb = getCOFFSymbol(Ref); 249 if (COFF::isReservedSectionNumber(Symb.getSectionNumber())) 250 return section_end(); 251 Expected<const coff_section *> Sec = getSection(Symb.getSectionNumber()); 252 if (!Sec) 253 return Sec.takeError(); 254 DataRefImpl Ret; 255 Ret.p = reinterpret_cast<uintptr_t>(*Sec); 256 return section_iterator(SectionRef(Ret, this)); 257 } 258 259 unsigned COFFObjectFile::getSymbolSectionID(SymbolRef Sym) const { 260 COFFSymbolRef Symb = getCOFFSymbol(Sym.getRawDataRefImpl()); 261 return Symb.getSectionNumber(); 262 } 263 264 void COFFObjectFile::moveSectionNext(DataRefImpl &Ref) const { 265 const coff_section *Sec = toSec(Ref); 266 Sec += 1; 267 Ref.p = reinterpret_cast<uintptr_t>(Sec); 268 } 269 270 Expected<StringRef> COFFObjectFile::getSectionName(DataRefImpl Ref) const { 271 const coff_section *Sec = toSec(Ref); 272 return getSectionName(Sec); 273 } 274 275 uint64_t COFFObjectFile::getSectionAddress(DataRefImpl Ref) const { 276 const coff_section *Sec = toSec(Ref); 277 uint64_t Result = Sec->VirtualAddress; 278 279 // The section VirtualAddress does not include ImageBase, and we want to 280 // return virtual addresses. 281 Result += getImageBase(); 282 return Result; 283 } 284 285 uint64_t COFFObjectFile::getSectionIndex(DataRefImpl Sec) const { 286 return toSec(Sec) - SectionTable; 287 } 288 289 uint64_t COFFObjectFile::getSectionSize(DataRefImpl Ref) const { 290 return getSectionSize(toSec(Ref)); 291 } 292 293 Expected<ArrayRef<uint8_t>> 294 COFFObjectFile::getSectionContents(DataRefImpl Ref) const { 295 const coff_section *Sec = toSec(Ref); 296 ArrayRef<uint8_t> Res; 297 if (Error E = getSectionContents(Sec, Res)) 298 return std::move(E); 299 return Res; 300 } 301 302 uint64_t COFFObjectFile::getSectionAlignment(DataRefImpl Ref) const { 303 const coff_section *Sec = toSec(Ref); 304 return Sec->getAlignment(); 305 } 306 307 bool COFFObjectFile::isSectionCompressed(DataRefImpl Sec) const { 308 return false; 309 } 310 311 bool COFFObjectFile::isSectionText(DataRefImpl Ref) const { 312 const coff_section *Sec = toSec(Ref); 313 return Sec->Characteristics & COFF::IMAGE_SCN_CNT_CODE; 314 } 315 316 bool COFFObjectFile::isSectionData(DataRefImpl Ref) const { 317 const coff_section *Sec = toSec(Ref); 318 return Sec->Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA; 319 } 320 321 bool COFFObjectFile::isSectionBSS(DataRefImpl Ref) const { 322 const coff_section *Sec = toSec(Ref); 323 const uint32_t BssFlags = COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA | 324 COFF::IMAGE_SCN_MEM_READ | 325 COFF::IMAGE_SCN_MEM_WRITE; 326 return (Sec->Characteristics & BssFlags) == BssFlags; 327 } 328 329 // The .debug sections are the only debug sections for COFF 330 // (\see MCObjectFileInfo.cpp). 331 bool COFFObjectFile::isDebugSection(DataRefImpl Ref) const { 332 Expected<StringRef> SectionNameOrErr = getSectionName(Ref); 333 if (!SectionNameOrErr) { 334 // TODO: Report the error message properly. 335 consumeError(SectionNameOrErr.takeError()); 336 return false; 337 } 338 StringRef SectionName = SectionNameOrErr.get(); 339 return SectionName.startswith(".debug"); 340 } 341 342 unsigned COFFObjectFile::getSectionID(SectionRef Sec) const { 343 uintptr_t Offset = 344 Sec.getRawDataRefImpl().p - reinterpret_cast<uintptr_t>(SectionTable); 345 assert((Offset % sizeof(coff_section)) == 0); 346 return (Offset / sizeof(coff_section)) + 1; 347 } 348 349 bool COFFObjectFile::isSectionVirtual(DataRefImpl Ref) const { 350 const coff_section *Sec = toSec(Ref); 351 // In COFF, a virtual section won't have any in-file 352 // content, so the file pointer to the content will be zero. 353 return Sec->PointerToRawData == 0; 354 } 355 356 static uint32_t getNumberOfRelocations(const coff_section *Sec, 357 MemoryBufferRef M, const uint8_t *base) { 358 // The field for the number of relocations in COFF section table is only 359 // 16-bit wide. If a section has more than 65535 relocations, 0xFFFF is set to 360 // NumberOfRelocations field, and the actual relocation count is stored in the 361 // VirtualAddress field in the first relocation entry. 362 if (Sec->hasExtendedRelocations()) { 363 const coff_relocation *FirstReloc; 364 if (Error E = getObject(FirstReloc, M, 365 reinterpret_cast<const coff_relocation *>( 366 base + Sec->PointerToRelocations))) { 367 consumeError(std::move(E)); 368 return 0; 369 } 370 // -1 to exclude this first relocation entry. 371 return FirstReloc->VirtualAddress - 1; 372 } 373 return Sec->NumberOfRelocations; 374 } 375 376 static const coff_relocation * 377 getFirstReloc(const coff_section *Sec, MemoryBufferRef M, const uint8_t *Base) { 378 uint64_t NumRelocs = getNumberOfRelocations(Sec, M, Base); 379 if (!NumRelocs) 380 return nullptr; 381 auto begin = reinterpret_cast<const coff_relocation *>( 382 Base + Sec->PointerToRelocations); 383 if (Sec->hasExtendedRelocations()) { 384 // Skip the first relocation entry repurposed to store the number of 385 // relocations. 386 begin++; 387 } 388 if (auto E = Binary::checkOffset(M, reinterpret_cast<uintptr_t>(begin), 389 sizeof(coff_relocation) * NumRelocs)) { 390 consumeError(std::move(E)); 391 return nullptr; 392 } 393 return begin; 394 } 395 396 relocation_iterator COFFObjectFile::section_rel_begin(DataRefImpl Ref) const { 397 const coff_section *Sec = toSec(Ref); 398 const coff_relocation *begin = getFirstReloc(Sec, Data, base()); 399 if (begin && Sec->VirtualAddress != 0) 400 report_fatal_error("Sections with relocations should have an address of 0"); 401 DataRefImpl Ret; 402 Ret.p = reinterpret_cast<uintptr_t>(begin); 403 return relocation_iterator(RelocationRef(Ret, this)); 404 } 405 406 relocation_iterator COFFObjectFile::section_rel_end(DataRefImpl Ref) const { 407 const coff_section *Sec = toSec(Ref); 408 const coff_relocation *I = getFirstReloc(Sec, Data, base()); 409 if (I) 410 I += getNumberOfRelocations(Sec, Data, base()); 411 DataRefImpl Ret; 412 Ret.p = reinterpret_cast<uintptr_t>(I); 413 return relocation_iterator(RelocationRef(Ret, this)); 414 } 415 416 // Initialize the pointer to the symbol table. 417 Error COFFObjectFile::initSymbolTablePtr() { 418 if (COFFHeader) 419 if (Error E = getObject( 420 SymbolTable16, Data, base() + getPointerToSymbolTable(), 421 (uint64_t)getNumberOfSymbols() * getSymbolTableEntrySize())) 422 return E; 423 424 if (COFFBigObjHeader) 425 if (Error E = getObject( 426 SymbolTable32, Data, base() + getPointerToSymbolTable(), 427 (uint64_t)getNumberOfSymbols() * getSymbolTableEntrySize())) 428 return E; 429 430 // Find string table. The first four byte of the string table contains the 431 // total size of the string table, including the size field itself. If the 432 // string table is empty, the value of the first four byte would be 4. 433 uint32_t StringTableOffset = getPointerToSymbolTable() + 434 getNumberOfSymbols() * getSymbolTableEntrySize(); 435 const uint8_t *StringTableAddr = base() + StringTableOffset; 436 const ulittle32_t *StringTableSizePtr; 437 if (Error E = getObject(StringTableSizePtr, Data, StringTableAddr)) 438 return E; 439 StringTableSize = *StringTableSizePtr; 440 if (Error E = getObject(StringTable, Data, StringTableAddr, StringTableSize)) 441 return E; 442 443 // Treat table sizes < 4 as empty because contrary to the PECOFF spec, some 444 // tools like cvtres write a size of 0 for an empty table instead of 4. 445 if (StringTableSize < 4) 446 StringTableSize = 4; 447 448 // Check that the string table is null terminated if has any in it. 449 if (StringTableSize > 4 && StringTable[StringTableSize - 1] != 0) 450 return errorCodeToError(object_error::parse_failed); 451 return Error::success(); 452 } 453 454 uint64_t COFFObjectFile::getImageBase() const { 455 if (PE32Header) 456 return PE32Header->ImageBase; 457 else if (PE32PlusHeader) 458 return PE32PlusHeader->ImageBase; 459 // This actually comes up in practice. 460 return 0; 461 } 462 463 // Returns the file offset for the given VA. 464 Error COFFObjectFile::getVaPtr(uint64_t Addr, uintptr_t &Res) const { 465 uint64_t ImageBase = getImageBase(); 466 uint64_t Rva = Addr - ImageBase; 467 assert(Rva <= UINT32_MAX); 468 return getRvaPtr((uint32_t)Rva, Res); 469 } 470 471 // Returns the file offset for the given RVA. 472 Error COFFObjectFile::getRvaPtr(uint32_t Addr, uintptr_t &Res) const { 473 for (const SectionRef &S : sections()) { 474 const coff_section *Section = getCOFFSection(S); 475 uint32_t SectionStart = Section->VirtualAddress; 476 uint32_t SectionEnd = Section->VirtualAddress + Section->VirtualSize; 477 if (SectionStart <= Addr && Addr < SectionEnd) { 478 uint32_t Offset = Addr - SectionStart; 479 Res = reinterpret_cast<uintptr_t>(base()) + Section->PointerToRawData + 480 Offset; 481 return Error::success(); 482 } 483 } 484 return errorCodeToError(object_error::parse_failed); 485 } 486 487 Error COFFObjectFile::getRvaAndSizeAsBytes(uint32_t RVA, uint32_t Size, 488 ArrayRef<uint8_t> &Contents) const { 489 for (const SectionRef &S : sections()) { 490 const coff_section *Section = getCOFFSection(S); 491 uint32_t SectionStart = Section->VirtualAddress; 492 // Check if this RVA is within the section bounds. Be careful about integer 493 // overflow. 494 uint32_t OffsetIntoSection = RVA - SectionStart; 495 if (SectionStart <= RVA && OffsetIntoSection < Section->VirtualSize && 496 Size <= Section->VirtualSize - OffsetIntoSection) { 497 uintptr_t Begin = reinterpret_cast<uintptr_t>(base()) + 498 Section->PointerToRawData + OffsetIntoSection; 499 Contents = 500 ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(Begin), Size); 501 return Error::success(); 502 } 503 } 504 return errorCodeToError(object_error::parse_failed); 505 } 506 507 // Returns hint and name fields, assuming \p Rva is pointing to a Hint/Name 508 // table entry. 509 Error COFFObjectFile::getHintName(uint32_t Rva, uint16_t &Hint, 510 StringRef &Name) const { 511 uintptr_t IntPtr = 0; 512 if (Error E = getRvaPtr(Rva, IntPtr)) 513 return E; 514 const uint8_t *Ptr = reinterpret_cast<const uint8_t *>(IntPtr); 515 Hint = *reinterpret_cast<const ulittle16_t *>(Ptr); 516 Name = StringRef(reinterpret_cast<const char *>(Ptr + 2)); 517 return Error::success(); 518 } 519 520 Error COFFObjectFile::getDebugPDBInfo(const debug_directory *DebugDir, 521 const codeview::DebugInfo *&PDBInfo, 522 StringRef &PDBFileName) const { 523 ArrayRef<uint8_t> InfoBytes; 524 if (Error E = getRvaAndSizeAsBytes( 525 DebugDir->AddressOfRawData, DebugDir->SizeOfData, InfoBytes)) 526 return E; 527 if (InfoBytes.size() < sizeof(*PDBInfo) + 1) 528 return errorCodeToError(object_error::parse_failed); 529 PDBInfo = reinterpret_cast<const codeview::DebugInfo *>(InfoBytes.data()); 530 InfoBytes = InfoBytes.drop_front(sizeof(*PDBInfo)); 531 PDBFileName = StringRef(reinterpret_cast<const char *>(InfoBytes.data()), 532 InfoBytes.size()); 533 // Truncate the name at the first null byte. Ignore any padding. 534 PDBFileName = PDBFileName.split('\0').first; 535 return Error::success(); 536 } 537 538 Error COFFObjectFile::getDebugPDBInfo(const codeview::DebugInfo *&PDBInfo, 539 StringRef &PDBFileName) const { 540 for (const debug_directory &D : debug_directories()) 541 if (D.Type == COFF::IMAGE_DEBUG_TYPE_CODEVIEW) 542 return getDebugPDBInfo(&D, PDBInfo, PDBFileName); 543 // If we get here, there is no PDB info to return. 544 PDBInfo = nullptr; 545 PDBFileName = StringRef(); 546 return Error::success(); 547 } 548 549 // Find the import table. 550 Error COFFObjectFile::initImportTablePtr() { 551 // First, we get the RVA of the import table. If the file lacks a pointer to 552 // the import table, do nothing. 553 const data_directory *DataEntry = getDataDirectory(COFF::IMPORT_TABLE); 554 if (!DataEntry) 555 return Error::success(); 556 557 // Do nothing if the pointer to import table is NULL. 558 if (DataEntry->RelativeVirtualAddress == 0) 559 return Error::success(); 560 561 uint32_t ImportTableRva = DataEntry->RelativeVirtualAddress; 562 563 // Find the section that contains the RVA. This is needed because the RVA is 564 // the import table's memory address which is different from its file offset. 565 uintptr_t IntPtr = 0; 566 if (Error E = getRvaPtr(ImportTableRva, IntPtr)) 567 return E; 568 if (Error E = checkOffset(Data, IntPtr, DataEntry->Size)) 569 return E; 570 ImportDirectory = reinterpret_cast< 571 const coff_import_directory_table_entry *>(IntPtr); 572 return Error::success(); 573 } 574 575 // Initializes DelayImportDirectory and NumberOfDelayImportDirectory. 576 Error COFFObjectFile::initDelayImportTablePtr() { 577 const data_directory *DataEntry = 578 getDataDirectory(COFF::DELAY_IMPORT_DESCRIPTOR); 579 if (!DataEntry) 580 return Error::success(); 581 if (DataEntry->RelativeVirtualAddress == 0) 582 return Error::success(); 583 584 uint32_t RVA = DataEntry->RelativeVirtualAddress; 585 NumberOfDelayImportDirectory = DataEntry->Size / 586 sizeof(delay_import_directory_table_entry) - 1; 587 588 uintptr_t IntPtr = 0; 589 if (Error E = getRvaPtr(RVA, IntPtr)) 590 return E; 591 DelayImportDirectory = reinterpret_cast< 592 const delay_import_directory_table_entry *>(IntPtr); 593 return Error::success(); 594 } 595 596 // Find the export table. 597 Error COFFObjectFile::initExportTablePtr() { 598 // First, we get the RVA of the export table. If the file lacks a pointer to 599 // the export table, do nothing. 600 const data_directory *DataEntry = getDataDirectory(COFF::EXPORT_TABLE); 601 if (!DataEntry) 602 return Error::success(); 603 604 // Do nothing if the pointer to export table is NULL. 605 if (DataEntry->RelativeVirtualAddress == 0) 606 return Error::success(); 607 608 uint32_t ExportTableRva = DataEntry->RelativeVirtualAddress; 609 uintptr_t IntPtr = 0; 610 if (Error E = getRvaPtr(ExportTableRva, IntPtr)) 611 return E; 612 ExportDirectory = 613 reinterpret_cast<const export_directory_table_entry *>(IntPtr); 614 return Error::success(); 615 } 616 617 Error COFFObjectFile::initBaseRelocPtr() { 618 const data_directory *DataEntry = 619 getDataDirectory(COFF::BASE_RELOCATION_TABLE); 620 if (!DataEntry) 621 return Error::success(); 622 if (DataEntry->RelativeVirtualAddress == 0) 623 return Error::success(); 624 625 uintptr_t IntPtr = 0; 626 if (Error E = getRvaPtr(DataEntry->RelativeVirtualAddress, IntPtr)) 627 return E; 628 BaseRelocHeader = reinterpret_cast<const coff_base_reloc_block_header *>( 629 IntPtr); 630 BaseRelocEnd = reinterpret_cast<coff_base_reloc_block_header *>( 631 IntPtr + DataEntry->Size); 632 // FIXME: Verify the section containing BaseRelocHeader has at least 633 // DataEntry->Size bytes after DataEntry->RelativeVirtualAddress. 634 return Error::success(); 635 } 636 637 Error COFFObjectFile::initDebugDirectoryPtr() { 638 // Get the RVA of the debug directory. Do nothing if it does not exist. 639 const data_directory *DataEntry = getDataDirectory(COFF::DEBUG_DIRECTORY); 640 if (!DataEntry) 641 return Error::success(); 642 643 // Do nothing if the RVA is NULL. 644 if (DataEntry->RelativeVirtualAddress == 0) 645 return Error::success(); 646 647 // Check that the size is a multiple of the entry size. 648 if (DataEntry->Size % sizeof(debug_directory) != 0) 649 return errorCodeToError(object_error::parse_failed); 650 651 uintptr_t IntPtr = 0; 652 if (Error E = getRvaPtr(DataEntry->RelativeVirtualAddress, IntPtr)) 653 return E; 654 DebugDirectoryBegin = reinterpret_cast<const debug_directory *>(IntPtr); 655 DebugDirectoryEnd = reinterpret_cast<const debug_directory *>( 656 IntPtr + DataEntry->Size); 657 // FIXME: Verify the section containing DebugDirectoryBegin has at least 658 // DataEntry->Size bytes after DataEntry->RelativeVirtualAddress. 659 return Error::success(); 660 } 661 662 Error COFFObjectFile::initTLSDirectoryPtr() { 663 // Get the RVA of the TLS directory. Do nothing if it does not exist. 664 const data_directory *DataEntry = getDataDirectory(COFF::TLS_TABLE); 665 if (!DataEntry) 666 return Error::success(); 667 668 // Do nothing if the RVA is NULL. 669 if (DataEntry->RelativeVirtualAddress == 0) 670 return Error::success(); 671 672 uint64_t DirSize = 673 is64() ? sizeof(coff_tls_directory64) : sizeof(coff_tls_directory32); 674 675 // Check that the size is correct. 676 if (DataEntry->Size != DirSize) 677 return createStringError( 678 object_error::parse_failed, 679 "TLS Directory size (%u) is not the expected size (%" PRIu64 ").", 680 static_cast<uint32_t>(DataEntry->Size), DirSize); 681 682 uintptr_t IntPtr = 0; 683 if (Error E = getRvaPtr(DataEntry->RelativeVirtualAddress, IntPtr)) 684 return E; 685 686 if (is64()) 687 TLSDirectory64 = reinterpret_cast<const coff_tls_directory64 *>(IntPtr); 688 else 689 TLSDirectory32 = reinterpret_cast<const coff_tls_directory32 *>(IntPtr); 690 691 return Error::success(); 692 } 693 694 Error COFFObjectFile::initLoadConfigPtr() { 695 // Get the RVA of the debug directory. Do nothing if it does not exist. 696 const data_directory *DataEntry = getDataDirectory(COFF::LOAD_CONFIG_TABLE); 697 if (!DataEntry) 698 return Error::success(); 699 700 // Do nothing if the RVA is NULL. 701 if (DataEntry->RelativeVirtualAddress == 0) 702 return Error::success(); 703 uintptr_t IntPtr = 0; 704 if (Error E = getRvaPtr(DataEntry->RelativeVirtualAddress, IntPtr)) 705 return E; 706 707 LoadConfig = (const void *)IntPtr; 708 return Error::success(); 709 } 710 711 Expected<std::unique_ptr<COFFObjectFile>> 712 COFFObjectFile::create(MemoryBufferRef Object) { 713 std::unique_ptr<COFFObjectFile> Obj(new COFFObjectFile(std::move(Object))); 714 if (Error E = Obj->initialize()) 715 return std::move(E); 716 return std::move(Obj); 717 } 718 719 COFFObjectFile::COFFObjectFile(MemoryBufferRef Object) 720 : ObjectFile(Binary::ID_COFF, Object), COFFHeader(nullptr), 721 COFFBigObjHeader(nullptr), PE32Header(nullptr), PE32PlusHeader(nullptr), 722 DataDirectory(nullptr), SectionTable(nullptr), SymbolTable16(nullptr), 723 SymbolTable32(nullptr), StringTable(nullptr), StringTableSize(0), 724 ImportDirectory(nullptr), DelayImportDirectory(nullptr), 725 NumberOfDelayImportDirectory(0), ExportDirectory(nullptr), 726 BaseRelocHeader(nullptr), BaseRelocEnd(nullptr), 727 DebugDirectoryBegin(nullptr), DebugDirectoryEnd(nullptr), 728 TLSDirectory32(nullptr), TLSDirectory64(nullptr) {} 729 730 Error COFFObjectFile::initialize() { 731 // Check that we at least have enough room for a header. 732 std::error_code EC; 733 if (!checkSize(Data, EC, sizeof(coff_file_header))) 734 return errorCodeToError(EC); 735 736 // The current location in the file where we are looking at. 737 uint64_t CurPtr = 0; 738 739 // PE header is optional and is present only in executables. If it exists, 740 // it is placed right after COFF header. 741 bool HasPEHeader = false; 742 743 // Check if this is a PE/COFF file. 744 if (checkSize(Data, EC, sizeof(dos_header) + sizeof(COFF::PEMagic))) { 745 // PE/COFF, seek through MS-DOS compatibility stub and 4-byte 746 // PE signature to find 'normal' COFF header. 747 const auto *DH = reinterpret_cast<const dos_header *>(base()); 748 if (DH->Magic[0] == 'M' && DH->Magic[1] == 'Z') { 749 CurPtr = DH->AddressOfNewExeHeader; 750 // Check the PE magic bytes. ("PE\0\0") 751 if (memcmp(base() + CurPtr, COFF::PEMagic, sizeof(COFF::PEMagic)) != 0) { 752 return errorCodeToError(object_error::parse_failed); 753 } 754 CurPtr += sizeof(COFF::PEMagic); // Skip the PE magic bytes. 755 HasPEHeader = true; 756 } 757 } 758 759 if (Error E = getObject(COFFHeader, Data, base() + CurPtr)) 760 return E; 761 762 // It might be a bigobj file, let's check. Note that COFF bigobj and COFF 763 // import libraries share a common prefix but bigobj is more restrictive. 764 if (!HasPEHeader && COFFHeader->Machine == COFF::IMAGE_FILE_MACHINE_UNKNOWN && 765 COFFHeader->NumberOfSections == uint16_t(0xffff) && 766 checkSize(Data, EC, sizeof(coff_bigobj_file_header))) { 767 if (Error E = getObject(COFFBigObjHeader, Data, base() + CurPtr)) 768 return E; 769 770 // Verify that we are dealing with bigobj. 771 if (COFFBigObjHeader->Version >= COFF::BigObjHeader::MinBigObjectVersion && 772 std::memcmp(COFFBigObjHeader->UUID, COFF::BigObjMagic, 773 sizeof(COFF::BigObjMagic)) == 0) { 774 COFFHeader = nullptr; 775 CurPtr += sizeof(coff_bigobj_file_header); 776 } else { 777 // It's not a bigobj. 778 COFFBigObjHeader = nullptr; 779 } 780 } 781 if (COFFHeader) { 782 // The prior checkSize call may have failed. This isn't a hard error 783 // because we were just trying to sniff out bigobj. 784 EC = std::error_code(); 785 CurPtr += sizeof(coff_file_header); 786 787 if (COFFHeader->isImportLibrary()) 788 return errorCodeToError(EC); 789 } 790 791 if (HasPEHeader) { 792 const pe32_header *Header; 793 if (Error E = getObject(Header, Data, base() + CurPtr)) 794 return E; 795 796 const uint8_t *DataDirAddr; 797 uint64_t DataDirSize; 798 if (Header->Magic == COFF::PE32Header::PE32) { 799 PE32Header = Header; 800 DataDirAddr = base() + CurPtr + sizeof(pe32_header); 801 DataDirSize = sizeof(data_directory) * PE32Header->NumberOfRvaAndSize; 802 } else if (Header->Magic == COFF::PE32Header::PE32_PLUS) { 803 PE32PlusHeader = reinterpret_cast<const pe32plus_header *>(Header); 804 DataDirAddr = base() + CurPtr + sizeof(pe32plus_header); 805 DataDirSize = sizeof(data_directory) * PE32PlusHeader->NumberOfRvaAndSize; 806 } else { 807 // It's neither PE32 nor PE32+. 808 return errorCodeToError(object_error::parse_failed); 809 } 810 if (Error E = getObject(DataDirectory, Data, DataDirAddr, DataDirSize)) 811 return E; 812 } 813 814 if (COFFHeader) 815 CurPtr += COFFHeader->SizeOfOptionalHeader; 816 817 assert(COFFHeader || COFFBigObjHeader); 818 819 if (Error E = 820 getObject(SectionTable, Data, base() + CurPtr, 821 (uint64_t)getNumberOfSections() * sizeof(coff_section))) 822 return E; 823 824 // Initialize the pointer to the symbol table. 825 if (getPointerToSymbolTable() != 0) { 826 if (Error E = initSymbolTablePtr()) { 827 // Recover from errors reading the symbol table. 828 consumeError(std::move(E)); 829 SymbolTable16 = nullptr; 830 SymbolTable32 = nullptr; 831 StringTable = nullptr; 832 StringTableSize = 0; 833 } 834 } else { 835 // We had better not have any symbols if we don't have a symbol table. 836 if (getNumberOfSymbols() != 0) { 837 return errorCodeToError(object_error::parse_failed); 838 } 839 } 840 841 // Initialize the pointer to the beginning of the import table. 842 if (Error E = initImportTablePtr()) 843 return E; 844 if (Error E = initDelayImportTablePtr()) 845 return E; 846 847 // Initialize the pointer to the export table. 848 if (Error E = initExportTablePtr()) 849 return E; 850 851 // Initialize the pointer to the base relocation table. 852 if (Error E = initBaseRelocPtr()) 853 return E; 854 855 // Initialize the pointer to the debug directory. 856 if (Error E = initDebugDirectoryPtr()) 857 return E; 858 859 // Initialize the pointer to the TLS directory. 860 if (Error E = initTLSDirectoryPtr()) 861 return E; 862 863 if (Error E = initLoadConfigPtr()) 864 return E; 865 866 return Error::success(); 867 } 868 869 basic_symbol_iterator COFFObjectFile::symbol_begin() const { 870 DataRefImpl Ret; 871 Ret.p = getSymbolTable(); 872 return basic_symbol_iterator(SymbolRef(Ret, this)); 873 } 874 875 basic_symbol_iterator COFFObjectFile::symbol_end() const { 876 // The symbol table ends where the string table begins. 877 DataRefImpl Ret; 878 Ret.p = reinterpret_cast<uintptr_t>(StringTable); 879 return basic_symbol_iterator(SymbolRef(Ret, this)); 880 } 881 882 import_directory_iterator COFFObjectFile::import_directory_begin() const { 883 if (!ImportDirectory) 884 return import_directory_end(); 885 if (ImportDirectory->isNull()) 886 return import_directory_end(); 887 return import_directory_iterator( 888 ImportDirectoryEntryRef(ImportDirectory, 0, this)); 889 } 890 891 import_directory_iterator COFFObjectFile::import_directory_end() const { 892 return import_directory_iterator( 893 ImportDirectoryEntryRef(nullptr, -1, this)); 894 } 895 896 delay_import_directory_iterator 897 COFFObjectFile::delay_import_directory_begin() const { 898 return delay_import_directory_iterator( 899 DelayImportDirectoryEntryRef(DelayImportDirectory, 0, this)); 900 } 901 902 delay_import_directory_iterator 903 COFFObjectFile::delay_import_directory_end() const { 904 return delay_import_directory_iterator( 905 DelayImportDirectoryEntryRef( 906 DelayImportDirectory, NumberOfDelayImportDirectory, this)); 907 } 908 909 export_directory_iterator COFFObjectFile::export_directory_begin() const { 910 return export_directory_iterator( 911 ExportDirectoryEntryRef(ExportDirectory, 0, this)); 912 } 913 914 export_directory_iterator COFFObjectFile::export_directory_end() const { 915 if (!ExportDirectory) 916 return export_directory_iterator(ExportDirectoryEntryRef(nullptr, 0, this)); 917 ExportDirectoryEntryRef Ref(ExportDirectory, 918 ExportDirectory->AddressTableEntries, this); 919 return export_directory_iterator(Ref); 920 } 921 922 section_iterator COFFObjectFile::section_begin() const { 923 DataRefImpl Ret; 924 Ret.p = reinterpret_cast<uintptr_t>(SectionTable); 925 return section_iterator(SectionRef(Ret, this)); 926 } 927 928 section_iterator COFFObjectFile::section_end() const { 929 DataRefImpl Ret; 930 int NumSections = 931 COFFHeader && COFFHeader->isImportLibrary() ? 0 : getNumberOfSections(); 932 Ret.p = reinterpret_cast<uintptr_t>(SectionTable + NumSections); 933 return section_iterator(SectionRef(Ret, this)); 934 } 935 936 base_reloc_iterator COFFObjectFile::base_reloc_begin() const { 937 return base_reloc_iterator(BaseRelocRef(BaseRelocHeader, this)); 938 } 939 940 base_reloc_iterator COFFObjectFile::base_reloc_end() const { 941 return base_reloc_iterator(BaseRelocRef(BaseRelocEnd, this)); 942 } 943 944 uint8_t COFFObjectFile::getBytesInAddress() const { 945 return getArch() == Triple::x86_64 || getArch() == Triple::aarch64 ? 8 : 4; 946 } 947 948 StringRef COFFObjectFile::getFileFormatName() const { 949 switch(getMachine()) { 950 case COFF::IMAGE_FILE_MACHINE_I386: 951 return "COFF-i386"; 952 case COFF::IMAGE_FILE_MACHINE_AMD64: 953 return "COFF-x86-64"; 954 case COFF::IMAGE_FILE_MACHINE_ARMNT: 955 return "COFF-ARM"; 956 case COFF::IMAGE_FILE_MACHINE_ARM64: 957 return "COFF-ARM64"; 958 default: 959 return "COFF-<unknown arch>"; 960 } 961 } 962 963 Triple::ArchType COFFObjectFile::getArch() const { 964 switch (getMachine()) { 965 case COFF::IMAGE_FILE_MACHINE_I386: 966 return Triple::x86; 967 case COFF::IMAGE_FILE_MACHINE_AMD64: 968 return Triple::x86_64; 969 case COFF::IMAGE_FILE_MACHINE_ARMNT: 970 return Triple::thumb; 971 case COFF::IMAGE_FILE_MACHINE_ARM64: 972 return Triple::aarch64; 973 default: 974 return Triple::UnknownArch; 975 } 976 } 977 978 Expected<uint64_t> COFFObjectFile::getStartAddress() const { 979 if (PE32Header) 980 return PE32Header->AddressOfEntryPoint; 981 return 0; 982 } 983 984 iterator_range<import_directory_iterator> 985 COFFObjectFile::import_directories() const { 986 return make_range(import_directory_begin(), import_directory_end()); 987 } 988 989 iterator_range<delay_import_directory_iterator> 990 COFFObjectFile::delay_import_directories() const { 991 return make_range(delay_import_directory_begin(), 992 delay_import_directory_end()); 993 } 994 995 iterator_range<export_directory_iterator> 996 COFFObjectFile::export_directories() const { 997 return make_range(export_directory_begin(), export_directory_end()); 998 } 999 1000 iterator_range<base_reloc_iterator> COFFObjectFile::base_relocs() const { 1001 return make_range(base_reloc_begin(), base_reloc_end()); 1002 } 1003 1004 const data_directory *COFFObjectFile::getDataDirectory(uint32_t Index) const { 1005 if (!DataDirectory) 1006 return nullptr; 1007 assert(PE32Header || PE32PlusHeader); 1008 uint32_t NumEnt = PE32Header ? PE32Header->NumberOfRvaAndSize 1009 : PE32PlusHeader->NumberOfRvaAndSize; 1010 if (Index >= NumEnt) 1011 return nullptr; 1012 return &DataDirectory[Index]; 1013 } 1014 1015 Expected<const coff_section *> COFFObjectFile::getSection(int32_t Index) const { 1016 // Perhaps getting the section of a reserved section index should be an error, 1017 // but callers rely on this to return null. 1018 if (COFF::isReservedSectionNumber(Index)) 1019 return (const coff_section *)nullptr; 1020 if (static_cast<uint32_t>(Index) <= getNumberOfSections()) { 1021 // We already verified the section table data, so no need to check again. 1022 return SectionTable + (Index - 1); 1023 } 1024 return errorCodeToError(object_error::parse_failed); 1025 } 1026 1027 Expected<StringRef> COFFObjectFile::getString(uint32_t Offset) const { 1028 if (StringTableSize <= 4) 1029 // Tried to get a string from an empty string table. 1030 return errorCodeToError(object_error::parse_failed); 1031 if (Offset >= StringTableSize) 1032 return errorCodeToError(object_error::unexpected_eof); 1033 return StringRef(StringTable + Offset); 1034 } 1035 1036 Expected<StringRef> COFFObjectFile::getSymbolName(COFFSymbolRef Symbol) const { 1037 return getSymbolName(Symbol.getGeneric()); 1038 } 1039 1040 Expected<StringRef> 1041 COFFObjectFile::getSymbolName(const coff_symbol_generic *Symbol) const { 1042 // Check for string table entry. First 4 bytes are 0. 1043 if (Symbol->Name.Offset.Zeroes == 0) 1044 return getString(Symbol->Name.Offset.Offset); 1045 1046 // Null terminated, let ::strlen figure out the length. 1047 if (Symbol->Name.ShortName[COFF::NameSize - 1] == 0) 1048 return StringRef(Symbol->Name.ShortName); 1049 1050 // Not null terminated, use all 8 bytes. 1051 return StringRef(Symbol->Name.ShortName, COFF::NameSize); 1052 } 1053 1054 ArrayRef<uint8_t> 1055 COFFObjectFile::getSymbolAuxData(COFFSymbolRef Symbol) const { 1056 const uint8_t *Aux = nullptr; 1057 1058 size_t SymbolSize = getSymbolTableEntrySize(); 1059 if (Symbol.getNumberOfAuxSymbols() > 0) { 1060 // AUX data comes immediately after the symbol in COFF 1061 Aux = reinterpret_cast<const uint8_t *>(Symbol.getRawPtr()) + SymbolSize; 1062 #ifndef NDEBUG 1063 // Verify that the Aux symbol points to a valid entry in the symbol table. 1064 uintptr_t Offset = uintptr_t(Aux) - uintptr_t(base()); 1065 if (Offset < getPointerToSymbolTable() || 1066 Offset >= 1067 getPointerToSymbolTable() + (getNumberOfSymbols() * SymbolSize)) 1068 report_fatal_error("Aux Symbol data was outside of symbol table."); 1069 1070 assert((Offset - getPointerToSymbolTable()) % SymbolSize == 0 && 1071 "Aux Symbol data did not point to the beginning of a symbol"); 1072 #endif 1073 } 1074 return makeArrayRef(Aux, Symbol.getNumberOfAuxSymbols() * SymbolSize); 1075 } 1076 1077 uint32_t COFFObjectFile::getSymbolIndex(COFFSymbolRef Symbol) const { 1078 uintptr_t Offset = 1079 reinterpret_cast<uintptr_t>(Symbol.getRawPtr()) - getSymbolTable(); 1080 assert(Offset % getSymbolTableEntrySize() == 0 && 1081 "Symbol did not point to the beginning of a symbol"); 1082 size_t Index = Offset / getSymbolTableEntrySize(); 1083 assert(Index < getNumberOfSymbols()); 1084 return Index; 1085 } 1086 1087 Expected<StringRef> 1088 COFFObjectFile::getSectionName(const coff_section *Sec) const { 1089 StringRef Name; 1090 if (Sec->Name[COFF::NameSize - 1] == 0) 1091 // Null terminated, let ::strlen figure out the length. 1092 Name = Sec->Name; 1093 else 1094 // Not null terminated, use all 8 bytes. 1095 Name = StringRef(Sec->Name, COFF::NameSize); 1096 1097 // Check for string table entry. First byte is '/'. 1098 if (Name.startswith("/")) { 1099 uint32_t Offset; 1100 if (Name.startswith("//")) { 1101 if (decodeBase64StringEntry(Name.substr(2), Offset)) 1102 return createStringError(object_error::parse_failed, 1103 "invalid section name"); 1104 } else { 1105 if (Name.substr(1).getAsInteger(10, Offset)) 1106 return createStringError(object_error::parse_failed, 1107 "invalid section name"); 1108 } 1109 return getString(Offset); 1110 } 1111 1112 return Name; 1113 } 1114 1115 uint64_t COFFObjectFile::getSectionSize(const coff_section *Sec) const { 1116 // SizeOfRawData and VirtualSize change what they represent depending on 1117 // whether or not we have an executable image. 1118 // 1119 // For object files, SizeOfRawData contains the size of section's data; 1120 // VirtualSize should be zero but isn't due to buggy COFF writers. 1121 // 1122 // For executables, SizeOfRawData *must* be a multiple of FileAlignment; the 1123 // actual section size is in VirtualSize. It is possible for VirtualSize to 1124 // be greater than SizeOfRawData; the contents past that point should be 1125 // considered to be zero. 1126 if (getDOSHeader()) 1127 return std::min(Sec->VirtualSize, Sec->SizeOfRawData); 1128 return Sec->SizeOfRawData; 1129 } 1130 1131 Error COFFObjectFile::getSectionContents(const coff_section *Sec, 1132 ArrayRef<uint8_t> &Res) const { 1133 // In COFF, a virtual section won't have any in-file 1134 // content, so the file pointer to the content will be zero. 1135 if (Sec->PointerToRawData == 0) 1136 return Error::success(); 1137 // The only thing that we need to verify is that the contents is contained 1138 // within the file bounds. We don't need to make sure it doesn't cover other 1139 // data, as there's nothing that says that is not allowed. 1140 uintptr_t ConStart = 1141 reinterpret_cast<uintptr_t>(base()) + Sec->PointerToRawData; 1142 uint32_t SectionSize = getSectionSize(Sec); 1143 if (Error E = checkOffset(Data, ConStart, SectionSize)) 1144 return E; 1145 Res = makeArrayRef(reinterpret_cast<const uint8_t *>(ConStart), SectionSize); 1146 return Error::success(); 1147 } 1148 1149 const coff_relocation *COFFObjectFile::toRel(DataRefImpl Rel) const { 1150 return reinterpret_cast<const coff_relocation*>(Rel.p); 1151 } 1152 1153 void COFFObjectFile::moveRelocationNext(DataRefImpl &Rel) const { 1154 Rel.p = reinterpret_cast<uintptr_t>( 1155 reinterpret_cast<const coff_relocation*>(Rel.p) + 1); 1156 } 1157 1158 uint64_t COFFObjectFile::getRelocationOffset(DataRefImpl Rel) const { 1159 const coff_relocation *R = toRel(Rel); 1160 return R->VirtualAddress; 1161 } 1162 1163 symbol_iterator COFFObjectFile::getRelocationSymbol(DataRefImpl Rel) const { 1164 const coff_relocation *R = toRel(Rel); 1165 DataRefImpl Ref; 1166 if (R->SymbolTableIndex >= getNumberOfSymbols()) 1167 return symbol_end(); 1168 if (SymbolTable16) 1169 Ref.p = reinterpret_cast<uintptr_t>(SymbolTable16 + R->SymbolTableIndex); 1170 else if (SymbolTable32) 1171 Ref.p = reinterpret_cast<uintptr_t>(SymbolTable32 + R->SymbolTableIndex); 1172 else 1173 llvm_unreachable("no symbol table pointer!"); 1174 return symbol_iterator(SymbolRef(Ref, this)); 1175 } 1176 1177 uint64_t COFFObjectFile::getRelocationType(DataRefImpl Rel) const { 1178 const coff_relocation* R = toRel(Rel); 1179 return R->Type; 1180 } 1181 1182 const coff_section * 1183 COFFObjectFile::getCOFFSection(const SectionRef &Section) const { 1184 return toSec(Section.getRawDataRefImpl()); 1185 } 1186 1187 COFFSymbolRef COFFObjectFile::getCOFFSymbol(const DataRefImpl &Ref) const { 1188 if (SymbolTable16) 1189 return toSymb<coff_symbol16>(Ref); 1190 if (SymbolTable32) 1191 return toSymb<coff_symbol32>(Ref); 1192 llvm_unreachable("no symbol table pointer!"); 1193 } 1194 1195 COFFSymbolRef COFFObjectFile::getCOFFSymbol(const SymbolRef &Symbol) const { 1196 return getCOFFSymbol(Symbol.getRawDataRefImpl()); 1197 } 1198 1199 const coff_relocation * 1200 COFFObjectFile::getCOFFRelocation(const RelocationRef &Reloc) const { 1201 return toRel(Reloc.getRawDataRefImpl()); 1202 } 1203 1204 ArrayRef<coff_relocation> 1205 COFFObjectFile::getRelocations(const coff_section *Sec) const { 1206 return {getFirstReloc(Sec, Data, base()), 1207 getNumberOfRelocations(Sec, Data, base())}; 1208 } 1209 1210 #define LLVM_COFF_SWITCH_RELOC_TYPE_NAME(reloc_type) \ 1211 case COFF::reloc_type: \ 1212 return #reloc_type; 1213 1214 StringRef COFFObjectFile::getRelocationTypeName(uint16_t Type) const { 1215 switch (getMachine()) { 1216 case COFF::IMAGE_FILE_MACHINE_AMD64: 1217 switch (Type) { 1218 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ABSOLUTE); 1219 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR64); 1220 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR32); 1221 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR32NB); 1222 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32); 1223 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_1); 1224 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_2); 1225 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_3); 1226 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_4); 1227 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_5); 1228 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SECTION); 1229 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SECREL); 1230 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SECREL7); 1231 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_TOKEN); 1232 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SREL32); 1233 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_PAIR); 1234 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SSPAN32); 1235 default: 1236 return "Unknown"; 1237 } 1238 break; 1239 case COFF::IMAGE_FILE_MACHINE_ARMNT: 1240 switch (Type) { 1241 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_ABSOLUTE); 1242 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_ADDR32); 1243 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_ADDR32NB); 1244 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BRANCH24); 1245 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BRANCH11); 1246 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_TOKEN); 1247 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BLX24); 1248 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BLX11); 1249 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_REL32); 1250 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_SECTION); 1251 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_SECREL); 1252 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_MOV32A); 1253 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_MOV32T); 1254 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BRANCH20T); 1255 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BRANCH24T); 1256 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BLX23T); 1257 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_PAIR); 1258 default: 1259 return "Unknown"; 1260 } 1261 break; 1262 case COFF::IMAGE_FILE_MACHINE_ARM64: 1263 switch (Type) { 1264 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_ABSOLUTE); 1265 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_ADDR32); 1266 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_ADDR32NB); 1267 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_BRANCH26); 1268 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_PAGEBASE_REL21); 1269 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_REL21); 1270 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_PAGEOFFSET_12A); 1271 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_PAGEOFFSET_12L); 1272 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_SECREL); 1273 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_SECREL_LOW12A); 1274 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_SECREL_HIGH12A); 1275 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_SECREL_LOW12L); 1276 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_TOKEN); 1277 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_SECTION); 1278 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_ADDR64); 1279 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_BRANCH19); 1280 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_BRANCH14); 1281 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_REL32); 1282 default: 1283 return "Unknown"; 1284 } 1285 break; 1286 case COFF::IMAGE_FILE_MACHINE_I386: 1287 switch (Type) { 1288 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_ABSOLUTE); 1289 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR16); 1290 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_REL16); 1291 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR32); 1292 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR32NB); 1293 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SEG12); 1294 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECTION); 1295 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECREL); 1296 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_TOKEN); 1297 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECREL7); 1298 LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_REL32); 1299 default: 1300 return "Unknown"; 1301 } 1302 break; 1303 default: 1304 return "Unknown"; 1305 } 1306 } 1307 1308 #undef LLVM_COFF_SWITCH_RELOC_TYPE_NAME 1309 1310 void COFFObjectFile::getRelocationTypeName( 1311 DataRefImpl Rel, SmallVectorImpl<char> &Result) const { 1312 const coff_relocation *Reloc = toRel(Rel); 1313 StringRef Res = getRelocationTypeName(Reloc->Type); 1314 Result.append(Res.begin(), Res.end()); 1315 } 1316 1317 bool COFFObjectFile::isRelocatableObject() const { 1318 return !DataDirectory; 1319 } 1320 1321 StringRef COFFObjectFile::mapDebugSectionName(StringRef Name) const { 1322 return StringSwitch<StringRef>(Name) 1323 .Case("eh_fram", "eh_frame") 1324 .Default(Name); 1325 } 1326 1327 bool ImportDirectoryEntryRef:: 1328 operator==(const ImportDirectoryEntryRef &Other) const { 1329 return ImportTable == Other.ImportTable && Index == Other.Index; 1330 } 1331 1332 void ImportDirectoryEntryRef::moveNext() { 1333 ++Index; 1334 if (ImportTable[Index].isNull()) { 1335 Index = -1; 1336 ImportTable = nullptr; 1337 } 1338 } 1339 1340 Error ImportDirectoryEntryRef::getImportTableEntry( 1341 const coff_import_directory_table_entry *&Result) const { 1342 return getObject(Result, OwningObject->Data, ImportTable + Index); 1343 } 1344 1345 static imported_symbol_iterator 1346 makeImportedSymbolIterator(const COFFObjectFile *Object, 1347 uintptr_t Ptr, int Index) { 1348 if (Object->getBytesInAddress() == 4) { 1349 auto *P = reinterpret_cast<const import_lookup_table_entry32 *>(Ptr); 1350 return imported_symbol_iterator(ImportedSymbolRef(P, Index, Object)); 1351 } 1352 auto *P = reinterpret_cast<const import_lookup_table_entry64 *>(Ptr); 1353 return imported_symbol_iterator(ImportedSymbolRef(P, Index, Object)); 1354 } 1355 1356 static imported_symbol_iterator 1357 importedSymbolBegin(uint32_t RVA, const COFFObjectFile *Object) { 1358 uintptr_t IntPtr = 0; 1359 // FIXME: Handle errors. 1360 cantFail(Object->getRvaPtr(RVA, IntPtr)); 1361 return makeImportedSymbolIterator(Object, IntPtr, 0); 1362 } 1363 1364 static imported_symbol_iterator 1365 importedSymbolEnd(uint32_t RVA, const COFFObjectFile *Object) { 1366 uintptr_t IntPtr = 0; 1367 // FIXME: Handle errors. 1368 cantFail(Object->getRvaPtr(RVA, IntPtr)); 1369 // Forward the pointer to the last entry which is null. 1370 int Index = 0; 1371 if (Object->getBytesInAddress() == 4) { 1372 auto *Entry = reinterpret_cast<ulittle32_t *>(IntPtr); 1373 while (*Entry++) 1374 ++Index; 1375 } else { 1376 auto *Entry = reinterpret_cast<ulittle64_t *>(IntPtr); 1377 while (*Entry++) 1378 ++Index; 1379 } 1380 return makeImportedSymbolIterator(Object, IntPtr, Index); 1381 } 1382 1383 imported_symbol_iterator 1384 ImportDirectoryEntryRef::imported_symbol_begin() const { 1385 return importedSymbolBegin(ImportTable[Index].ImportAddressTableRVA, 1386 OwningObject); 1387 } 1388 1389 imported_symbol_iterator 1390 ImportDirectoryEntryRef::imported_symbol_end() const { 1391 return importedSymbolEnd(ImportTable[Index].ImportAddressTableRVA, 1392 OwningObject); 1393 } 1394 1395 iterator_range<imported_symbol_iterator> 1396 ImportDirectoryEntryRef::imported_symbols() const { 1397 return make_range(imported_symbol_begin(), imported_symbol_end()); 1398 } 1399 1400 imported_symbol_iterator ImportDirectoryEntryRef::lookup_table_begin() const { 1401 return importedSymbolBegin(ImportTable[Index].ImportLookupTableRVA, 1402 OwningObject); 1403 } 1404 1405 imported_symbol_iterator ImportDirectoryEntryRef::lookup_table_end() const { 1406 return importedSymbolEnd(ImportTable[Index].ImportLookupTableRVA, 1407 OwningObject); 1408 } 1409 1410 iterator_range<imported_symbol_iterator> 1411 ImportDirectoryEntryRef::lookup_table_symbols() const { 1412 return make_range(lookup_table_begin(), lookup_table_end()); 1413 } 1414 1415 Error ImportDirectoryEntryRef::getName(StringRef &Result) const { 1416 uintptr_t IntPtr = 0; 1417 if (Error E = OwningObject->getRvaPtr(ImportTable[Index].NameRVA, IntPtr)) 1418 return E; 1419 Result = StringRef(reinterpret_cast<const char *>(IntPtr)); 1420 return Error::success(); 1421 } 1422 1423 Error 1424 ImportDirectoryEntryRef::getImportLookupTableRVA(uint32_t &Result) const { 1425 Result = ImportTable[Index].ImportLookupTableRVA; 1426 return Error::success(); 1427 } 1428 1429 Error ImportDirectoryEntryRef::getImportAddressTableRVA( 1430 uint32_t &Result) const { 1431 Result = ImportTable[Index].ImportAddressTableRVA; 1432 return Error::success(); 1433 } 1434 1435 bool DelayImportDirectoryEntryRef:: 1436 operator==(const DelayImportDirectoryEntryRef &Other) const { 1437 return Table == Other.Table && Index == Other.Index; 1438 } 1439 1440 void DelayImportDirectoryEntryRef::moveNext() { 1441 ++Index; 1442 } 1443 1444 imported_symbol_iterator 1445 DelayImportDirectoryEntryRef::imported_symbol_begin() const { 1446 return importedSymbolBegin(Table[Index].DelayImportNameTable, 1447 OwningObject); 1448 } 1449 1450 imported_symbol_iterator 1451 DelayImportDirectoryEntryRef::imported_symbol_end() const { 1452 return importedSymbolEnd(Table[Index].DelayImportNameTable, 1453 OwningObject); 1454 } 1455 1456 iterator_range<imported_symbol_iterator> 1457 DelayImportDirectoryEntryRef::imported_symbols() const { 1458 return make_range(imported_symbol_begin(), imported_symbol_end()); 1459 } 1460 1461 Error DelayImportDirectoryEntryRef::getName(StringRef &Result) const { 1462 uintptr_t IntPtr = 0; 1463 if (Error E = OwningObject->getRvaPtr(Table[Index].Name, IntPtr)) 1464 return E; 1465 Result = StringRef(reinterpret_cast<const char *>(IntPtr)); 1466 return Error::success(); 1467 } 1468 1469 Error DelayImportDirectoryEntryRef::getDelayImportTable( 1470 const delay_import_directory_table_entry *&Result) const { 1471 Result = &Table[Index]; 1472 return Error::success(); 1473 } 1474 1475 Error DelayImportDirectoryEntryRef::getImportAddress(int AddrIndex, 1476 uint64_t &Result) const { 1477 uint32_t RVA = Table[Index].DelayImportAddressTable + 1478 AddrIndex * (OwningObject->is64() ? 8 : 4); 1479 uintptr_t IntPtr = 0; 1480 if (Error E = OwningObject->getRvaPtr(RVA, IntPtr)) 1481 return E; 1482 if (OwningObject->is64()) 1483 Result = *reinterpret_cast<const ulittle64_t *>(IntPtr); 1484 else 1485 Result = *reinterpret_cast<const ulittle32_t *>(IntPtr); 1486 return Error::success(); 1487 } 1488 1489 bool ExportDirectoryEntryRef:: 1490 operator==(const ExportDirectoryEntryRef &Other) const { 1491 return ExportTable == Other.ExportTable && Index == Other.Index; 1492 } 1493 1494 void ExportDirectoryEntryRef::moveNext() { 1495 ++Index; 1496 } 1497 1498 // Returns the name of the current export symbol. If the symbol is exported only 1499 // by ordinal, the empty string is set as a result. 1500 Error ExportDirectoryEntryRef::getDllName(StringRef &Result) const { 1501 uintptr_t IntPtr = 0; 1502 if (Error E = OwningObject->getRvaPtr(ExportTable->NameRVA, IntPtr)) 1503 return E; 1504 Result = StringRef(reinterpret_cast<const char *>(IntPtr)); 1505 return Error::success(); 1506 } 1507 1508 // Returns the starting ordinal number. 1509 Error ExportDirectoryEntryRef::getOrdinalBase(uint32_t &Result) const { 1510 Result = ExportTable->OrdinalBase; 1511 return Error::success(); 1512 } 1513 1514 // Returns the export ordinal of the current export symbol. 1515 Error ExportDirectoryEntryRef::getOrdinal(uint32_t &Result) const { 1516 Result = ExportTable->OrdinalBase + Index; 1517 return Error::success(); 1518 } 1519 1520 // Returns the address of the current export symbol. 1521 Error ExportDirectoryEntryRef::getExportRVA(uint32_t &Result) const { 1522 uintptr_t IntPtr = 0; 1523 if (Error EC = 1524 OwningObject->getRvaPtr(ExportTable->ExportAddressTableRVA, IntPtr)) 1525 return EC; 1526 const export_address_table_entry *entry = 1527 reinterpret_cast<const export_address_table_entry *>(IntPtr); 1528 Result = entry[Index].ExportRVA; 1529 return Error::success(); 1530 } 1531 1532 // Returns the name of the current export symbol. If the symbol is exported only 1533 // by ordinal, the empty string is set as a result. 1534 Error 1535 ExportDirectoryEntryRef::getSymbolName(StringRef &Result) const { 1536 uintptr_t IntPtr = 0; 1537 if (Error EC = 1538 OwningObject->getRvaPtr(ExportTable->OrdinalTableRVA, IntPtr)) 1539 return EC; 1540 const ulittle16_t *Start = reinterpret_cast<const ulittle16_t *>(IntPtr); 1541 1542 uint32_t NumEntries = ExportTable->NumberOfNamePointers; 1543 int Offset = 0; 1544 for (const ulittle16_t *I = Start, *E = Start + NumEntries; 1545 I < E; ++I, ++Offset) { 1546 if (*I != Index) 1547 continue; 1548 if (Error EC = 1549 OwningObject->getRvaPtr(ExportTable->NamePointerRVA, IntPtr)) 1550 return EC; 1551 const ulittle32_t *NamePtr = reinterpret_cast<const ulittle32_t *>(IntPtr); 1552 if (Error EC = OwningObject->getRvaPtr(NamePtr[Offset], IntPtr)) 1553 return EC; 1554 Result = StringRef(reinterpret_cast<const char *>(IntPtr)); 1555 return Error::success(); 1556 } 1557 Result = ""; 1558 return Error::success(); 1559 } 1560 1561 Error ExportDirectoryEntryRef::isForwarder(bool &Result) const { 1562 const data_directory *DataEntry = 1563 OwningObject->getDataDirectory(COFF::EXPORT_TABLE); 1564 if (!DataEntry) 1565 return errorCodeToError(object_error::parse_failed); 1566 uint32_t RVA; 1567 if (auto EC = getExportRVA(RVA)) 1568 return EC; 1569 uint32_t Begin = DataEntry->RelativeVirtualAddress; 1570 uint32_t End = DataEntry->RelativeVirtualAddress + DataEntry->Size; 1571 Result = (Begin <= RVA && RVA < End); 1572 return Error::success(); 1573 } 1574 1575 Error ExportDirectoryEntryRef::getForwardTo(StringRef &Result) const { 1576 uint32_t RVA; 1577 if (auto EC = getExportRVA(RVA)) 1578 return EC; 1579 uintptr_t IntPtr = 0; 1580 if (auto EC = OwningObject->getRvaPtr(RVA, IntPtr)) 1581 return EC; 1582 Result = StringRef(reinterpret_cast<const char *>(IntPtr)); 1583 return Error::success(); 1584 } 1585 1586 bool ImportedSymbolRef:: 1587 operator==(const ImportedSymbolRef &Other) const { 1588 return Entry32 == Other.Entry32 && Entry64 == Other.Entry64 1589 && Index == Other.Index; 1590 } 1591 1592 void ImportedSymbolRef::moveNext() { 1593 ++Index; 1594 } 1595 1596 Error ImportedSymbolRef::getSymbolName(StringRef &Result) const { 1597 uint32_t RVA; 1598 if (Entry32) { 1599 // If a symbol is imported only by ordinal, it has no name. 1600 if (Entry32[Index].isOrdinal()) 1601 return Error::success(); 1602 RVA = Entry32[Index].getHintNameRVA(); 1603 } else { 1604 if (Entry64[Index].isOrdinal()) 1605 return Error::success(); 1606 RVA = Entry64[Index].getHintNameRVA(); 1607 } 1608 uintptr_t IntPtr = 0; 1609 if (Error EC = OwningObject->getRvaPtr(RVA, IntPtr)) 1610 return EC; 1611 // +2 because the first two bytes is hint. 1612 Result = StringRef(reinterpret_cast<const char *>(IntPtr + 2)); 1613 return Error::success(); 1614 } 1615 1616 Error ImportedSymbolRef::isOrdinal(bool &Result) const { 1617 if (Entry32) 1618 Result = Entry32[Index].isOrdinal(); 1619 else 1620 Result = Entry64[Index].isOrdinal(); 1621 return Error::success(); 1622 } 1623 1624 Error ImportedSymbolRef::getHintNameRVA(uint32_t &Result) const { 1625 if (Entry32) 1626 Result = Entry32[Index].getHintNameRVA(); 1627 else 1628 Result = Entry64[Index].getHintNameRVA(); 1629 return Error::success(); 1630 } 1631 1632 Error ImportedSymbolRef::getOrdinal(uint16_t &Result) const { 1633 uint32_t RVA; 1634 if (Entry32) { 1635 if (Entry32[Index].isOrdinal()) { 1636 Result = Entry32[Index].getOrdinal(); 1637 return Error::success(); 1638 } 1639 RVA = Entry32[Index].getHintNameRVA(); 1640 } else { 1641 if (Entry64[Index].isOrdinal()) { 1642 Result = Entry64[Index].getOrdinal(); 1643 return Error::success(); 1644 } 1645 RVA = Entry64[Index].getHintNameRVA(); 1646 } 1647 uintptr_t IntPtr = 0; 1648 if (Error EC = OwningObject->getRvaPtr(RVA, IntPtr)) 1649 return EC; 1650 Result = *reinterpret_cast<const ulittle16_t *>(IntPtr); 1651 return Error::success(); 1652 } 1653 1654 Expected<std::unique_ptr<COFFObjectFile>> 1655 ObjectFile::createCOFFObjectFile(MemoryBufferRef Object) { 1656 return COFFObjectFile::create(Object); 1657 } 1658 1659 bool BaseRelocRef::operator==(const BaseRelocRef &Other) const { 1660 return Header == Other.Header && Index == Other.Index; 1661 } 1662 1663 void BaseRelocRef::moveNext() { 1664 // Header->BlockSize is the size of the current block, including the 1665 // size of the header itself. 1666 uint32_t Size = sizeof(*Header) + 1667 sizeof(coff_base_reloc_block_entry) * (Index + 1); 1668 if (Size == Header->BlockSize) { 1669 // .reloc contains a list of base relocation blocks. Each block 1670 // consists of the header followed by entries. The header contains 1671 // how many entories will follow. When we reach the end of the 1672 // current block, proceed to the next block. 1673 Header = reinterpret_cast<const coff_base_reloc_block_header *>( 1674 reinterpret_cast<const uint8_t *>(Header) + Size); 1675 Index = 0; 1676 } else { 1677 ++Index; 1678 } 1679 } 1680 1681 Error BaseRelocRef::getType(uint8_t &Type) const { 1682 auto *Entry = reinterpret_cast<const coff_base_reloc_block_entry *>(Header + 1); 1683 Type = Entry[Index].getType(); 1684 return Error::success(); 1685 } 1686 1687 Error BaseRelocRef::getRVA(uint32_t &Result) const { 1688 auto *Entry = reinterpret_cast<const coff_base_reloc_block_entry *>(Header + 1); 1689 Result = Header->PageRVA + Entry[Index].getOffset(); 1690 return Error::success(); 1691 } 1692 1693 #define RETURN_IF_ERROR(Expr) \ 1694 do { \ 1695 Error E = (Expr); \ 1696 if (E) \ 1697 return std::move(E); \ 1698 } while (0) 1699 1700 Expected<ArrayRef<UTF16>> 1701 ResourceSectionRef::getDirStringAtOffset(uint32_t Offset) { 1702 BinaryStreamReader Reader = BinaryStreamReader(BBS); 1703 Reader.setOffset(Offset); 1704 uint16_t Length; 1705 RETURN_IF_ERROR(Reader.readInteger(Length)); 1706 ArrayRef<UTF16> RawDirString; 1707 RETURN_IF_ERROR(Reader.readArray(RawDirString, Length)); 1708 return RawDirString; 1709 } 1710 1711 Expected<ArrayRef<UTF16>> 1712 ResourceSectionRef::getEntryNameString(const coff_resource_dir_entry &Entry) { 1713 return getDirStringAtOffset(Entry.Identifier.getNameOffset()); 1714 } 1715 1716 Expected<const coff_resource_dir_table &> 1717 ResourceSectionRef::getTableAtOffset(uint32_t Offset) { 1718 const coff_resource_dir_table *Table = nullptr; 1719 1720 BinaryStreamReader Reader(BBS); 1721 Reader.setOffset(Offset); 1722 RETURN_IF_ERROR(Reader.readObject(Table)); 1723 assert(Table != nullptr); 1724 return *Table; 1725 } 1726 1727 Expected<const coff_resource_dir_entry &> 1728 ResourceSectionRef::getTableEntryAtOffset(uint32_t Offset) { 1729 const coff_resource_dir_entry *Entry = nullptr; 1730 1731 BinaryStreamReader Reader(BBS); 1732 Reader.setOffset(Offset); 1733 RETURN_IF_ERROR(Reader.readObject(Entry)); 1734 assert(Entry != nullptr); 1735 return *Entry; 1736 } 1737 1738 Expected<const coff_resource_data_entry &> 1739 ResourceSectionRef::getDataEntryAtOffset(uint32_t Offset) { 1740 const coff_resource_data_entry *Entry = nullptr; 1741 1742 BinaryStreamReader Reader(BBS); 1743 Reader.setOffset(Offset); 1744 RETURN_IF_ERROR(Reader.readObject(Entry)); 1745 assert(Entry != nullptr); 1746 return *Entry; 1747 } 1748 1749 Expected<const coff_resource_dir_table &> 1750 ResourceSectionRef::getEntrySubDir(const coff_resource_dir_entry &Entry) { 1751 assert(Entry.Offset.isSubDir()); 1752 return getTableAtOffset(Entry.Offset.value()); 1753 } 1754 1755 Expected<const coff_resource_data_entry &> 1756 ResourceSectionRef::getEntryData(const coff_resource_dir_entry &Entry) { 1757 assert(!Entry.Offset.isSubDir()); 1758 return getDataEntryAtOffset(Entry.Offset.value()); 1759 } 1760 1761 Expected<const coff_resource_dir_table &> ResourceSectionRef::getBaseTable() { 1762 return getTableAtOffset(0); 1763 } 1764 1765 Expected<const coff_resource_dir_entry &> 1766 ResourceSectionRef::getTableEntry(const coff_resource_dir_table &Table, 1767 uint32_t Index) { 1768 if (Index >= (uint32_t)(Table.NumberOfNameEntries + Table.NumberOfIDEntries)) 1769 return createStringError(object_error::parse_failed, "index out of range"); 1770 const uint8_t *TablePtr = reinterpret_cast<const uint8_t *>(&Table); 1771 ptrdiff_t TableOffset = TablePtr - BBS.data().data(); 1772 return getTableEntryAtOffset(TableOffset + sizeof(Table) + 1773 Index * sizeof(coff_resource_dir_entry)); 1774 } 1775 1776 Error ResourceSectionRef::load(const COFFObjectFile *O) { 1777 for (const SectionRef &S : O->sections()) { 1778 Expected<StringRef> Name = S.getName(); 1779 if (!Name) 1780 return Name.takeError(); 1781 1782 if (*Name == ".rsrc" || *Name == ".rsrc$01") 1783 return load(O, S); 1784 } 1785 return createStringError(object_error::parse_failed, 1786 "no resource section found"); 1787 } 1788 1789 Error ResourceSectionRef::load(const COFFObjectFile *O, const SectionRef &S) { 1790 Obj = O; 1791 Section = S; 1792 Expected<StringRef> Contents = Section.getContents(); 1793 if (!Contents) 1794 return Contents.takeError(); 1795 BBS = BinaryByteStream(*Contents, support::little); 1796 const coff_section *COFFSect = Obj->getCOFFSection(Section); 1797 ArrayRef<coff_relocation> OrigRelocs = Obj->getRelocations(COFFSect); 1798 Relocs.reserve(OrigRelocs.size()); 1799 for (const coff_relocation &R : OrigRelocs) 1800 Relocs.push_back(&R); 1801 llvm::sort(Relocs, [](const coff_relocation *A, const coff_relocation *B) { 1802 return A->VirtualAddress < B->VirtualAddress; 1803 }); 1804 return Error::success(); 1805 } 1806 1807 Expected<StringRef> 1808 ResourceSectionRef::getContents(const coff_resource_data_entry &Entry) { 1809 if (!Obj) 1810 return createStringError(object_error::parse_failed, "no object provided"); 1811 1812 // Find a potential relocation at the DataRVA field (first member of 1813 // the coff_resource_data_entry struct). 1814 const uint8_t *EntryPtr = reinterpret_cast<const uint8_t *>(&Entry); 1815 ptrdiff_t EntryOffset = EntryPtr - BBS.data().data(); 1816 coff_relocation RelocTarget{ulittle32_t(EntryOffset), ulittle32_t(0), 1817 ulittle16_t(0)}; 1818 auto RelocsForOffset = 1819 std::equal_range(Relocs.begin(), Relocs.end(), &RelocTarget, 1820 [](const coff_relocation *A, const coff_relocation *B) { 1821 return A->VirtualAddress < B->VirtualAddress; 1822 }); 1823 1824 if (RelocsForOffset.first != RelocsForOffset.second) { 1825 // We found a relocation with the right offset. Check that it does have 1826 // the expected type. 1827 const coff_relocation &R = **RelocsForOffset.first; 1828 uint16_t RVAReloc; 1829 switch (Obj->getMachine()) { 1830 case COFF::IMAGE_FILE_MACHINE_I386: 1831 RVAReloc = COFF::IMAGE_REL_I386_DIR32NB; 1832 break; 1833 case COFF::IMAGE_FILE_MACHINE_AMD64: 1834 RVAReloc = COFF::IMAGE_REL_AMD64_ADDR32NB; 1835 break; 1836 case COFF::IMAGE_FILE_MACHINE_ARMNT: 1837 RVAReloc = COFF::IMAGE_REL_ARM_ADDR32NB; 1838 break; 1839 case COFF::IMAGE_FILE_MACHINE_ARM64: 1840 RVAReloc = COFF::IMAGE_REL_ARM64_ADDR32NB; 1841 break; 1842 default: 1843 return createStringError(object_error::parse_failed, 1844 "unsupported architecture"); 1845 } 1846 if (R.Type != RVAReloc) 1847 return createStringError(object_error::parse_failed, 1848 "unexpected relocation type"); 1849 // Get the relocation's symbol 1850 Expected<COFFSymbolRef> Sym = Obj->getSymbol(R.SymbolTableIndex); 1851 if (!Sym) 1852 return Sym.takeError(); 1853 // And the symbol's section 1854 Expected<const coff_section *> Section = 1855 Obj->getSection(Sym->getSectionNumber()); 1856 if (!Section) 1857 return Section.takeError(); 1858 // Add the initial value of DataRVA to the symbol's offset to find the 1859 // data it points at. 1860 uint64_t Offset = Entry.DataRVA + Sym->getValue(); 1861 ArrayRef<uint8_t> Contents; 1862 if (Error E = Obj->getSectionContents(*Section, Contents)) 1863 return std::move(E); 1864 if (Offset + Entry.DataSize > Contents.size()) 1865 return createStringError(object_error::parse_failed, 1866 "data outside of section"); 1867 // Return a reference to the data inside the section. 1868 return StringRef(reinterpret_cast<const char *>(Contents.data()) + Offset, 1869 Entry.DataSize); 1870 } else { 1871 // Relocatable objects need a relocation for the DataRVA field. 1872 if (Obj->isRelocatableObject()) 1873 return createStringError(object_error::parse_failed, 1874 "no relocation found for DataRVA"); 1875 1876 // Locate the section that contains the address that DataRVA points at. 1877 uint64_t VA = Entry.DataRVA + Obj->getImageBase(); 1878 for (const SectionRef &S : Obj->sections()) { 1879 if (VA >= S.getAddress() && 1880 VA + Entry.DataSize <= S.getAddress() + S.getSize()) { 1881 uint64_t Offset = VA - S.getAddress(); 1882 Expected<StringRef> Contents = S.getContents(); 1883 if (!Contents) 1884 return Contents.takeError(); 1885 return Contents->slice(Offset, Offset + Entry.DataSize); 1886 } 1887 } 1888 return createStringError(object_error::parse_failed, 1889 "address not found in image"); 1890 } 1891 } 1892