contrib/llvm/lib/Object/COFFObjectFile.cpp

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