LCOV - code coverage report
Current view: top level - include/llvm/Object - COFF.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 108 128 84.4 %
Date: 2018-06-17 00:07:59 Functions: 13 15 86.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- COFF.h - 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             : #ifndef LLVM_OBJECT_COFF_H
      15             : #define LLVM_OBJECT_COFF_H
      16             : 
      17             : #include "llvm/ADT/iterator_range.h"
      18             : #include "llvm/BinaryFormat/COFF.h"
      19             : #include "llvm/MC/SubtargetFeature.h"
      20             : #include "llvm/Object/Binary.h"
      21             : #include "llvm/Object/CVDebugRecord.h"
      22             : #include "llvm/Object/Error.h"
      23             : #include "llvm/Object/ObjectFile.h"
      24             : #include "llvm/Support/BinaryByteStream.h"
      25             : #include "llvm/Support/ConvertUTF.h"
      26             : #include "llvm/Support/Endian.h"
      27             : #include "llvm/Support/ErrorHandling.h"
      28             : #include <cassert>
      29             : #include <cstddef>
      30             : #include <cstdint>
      31             : #include <system_error>
      32             : 
      33             : namespace llvm {
      34             : 
      35             : template <typename T> class ArrayRef;
      36             : 
      37             : namespace object {
      38             : 
      39             : class BaseRelocRef;
      40             : class DelayImportDirectoryEntryRef;
      41             : class ExportDirectoryEntryRef;
      42             : class ImportDirectoryEntryRef;
      43             : class ImportedSymbolRef;
      44             : class ResourceSectionRef;
      45             : 
      46             : using import_directory_iterator = content_iterator<ImportDirectoryEntryRef>;
      47             : using delay_import_directory_iterator =
      48             :     content_iterator<DelayImportDirectoryEntryRef>;
      49             : using export_directory_iterator = content_iterator<ExportDirectoryEntryRef>;
      50             : using imported_symbol_iterator = content_iterator<ImportedSymbolRef>;
      51             : using base_reloc_iterator = content_iterator<BaseRelocRef>;
      52             : 
      53             : /// The DOS compatible header at the front of all PE/COFF executables.
      54             : struct dos_header {
      55             :   char                 Magic[2];
      56             :   support::ulittle16_t UsedBytesInTheLastPage;
      57             :   support::ulittle16_t FileSizeInPages;
      58             :   support::ulittle16_t NumberOfRelocationItems;
      59             :   support::ulittle16_t HeaderSizeInParagraphs;
      60             :   support::ulittle16_t MinimumExtraParagraphs;
      61             :   support::ulittle16_t MaximumExtraParagraphs;
      62             :   support::ulittle16_t InitialRelativeSS;
      63             :   support::ulittle16_t InitialSP;
      64             :   support::ulittle16_t Checksum;
      65             :   support::ulittle16_t InitialIP;
      66             :   support::ulittle16_t InitialRelativeCS;
      67             :   support::ulittle16_t AddressOfRelocationTable;
      68             :   support::ulittle16_t OverlayNumber;
      69             :   support::ulittle16_t Reserved[4];
      70             :   support::ulittle16_t OEMid;
      71             :   support::ulittle16_t OEMinfo;
      72             :   support::ulittle16_t Reserved2[10];
      73             :   support::ulittle32_t AddressOfNewExeHeader;
      74             : };
      75             : 
      76             : struct coff_file_header {
      77             :   support::ulittle16_t Machine;
      78             :   support::ulittle16_t NumberOfSections;
      79             :   support::ulittle32_t TimeDateStamp;
      80             :   support::ulittle32_t PointerToSymbolTable;
      81             :   support::ulittle32_t NumberOfSymbols;
      82             :   support::ulittle16_t SizeOfOptionalHeader;
      83             :   support::ulittle16_t Characteristics;
      84             : 
      85             :   bool isImportLibrary() const { return NumberOfSections == 0xffff; }
      86             : };
      87             : 
      88             : struct coff_bigobj_file_header {
      89             :   support::ulittle16_t Sig1;
      90             :   support::ulittle16_t Sig2;
      91             :   support::ulittle16_t Version;
      92             :   support::ulittle16_t Machine;
      93             :   support::ulittle32_t TimeDateStamp;
      94             :   uint8_t              UUID[16];
      95             :   support::ulittle32_t unused1;
      96             :   support::ulittle32_t unused2;
      97             :   support::ulittle32_t unused3;
      98             :   support::ulittle32_t unused4;
      99             :   support::ulittle32_t NumberOfSections;
     100             :   support::ulittle32_t PointerToSymbolTable;
     101             :   support::ulittle32_t NumberOfSymbols;
     102             : };
     103             : 
     104             : /// The 32-bit PE header that follows the COFF header.
     105             : struct pe32_header {
     106             :   support::ulittle16_t Magic;
     107             :   uint8_t MajorLinkerVersion;
     108             :   uint8_t MinorLinkerVersion;
     109             :   support::ulittle32_t SizeOfCode;
     110             :   support::ulittle32_t SizeOfInitializedData;
     111             :   support::ulittle32_t SizeOfUninitializedData;
     112             :   support::ulittle32_t AddressOfEntryPoint;
     113             :   support::ulittle32_t BaseOfCode;
     114             :   support::ulittle32_t BaseOfData;
     115             :   support::ulittle32_t ImageBase;
     116             :   support::ulittle32_t SectionAlignment;
     117             :   support::ulittle32_t FileAlignment;
     118             :   support::ulittle16_t MajorOperatingSystemVersion;
     119             :   support::ulittle16_t MinorOperatingSystemVersion;
     120             :   support::ulittle16_t MajorImageVersion;
     121             :   support::ulittle16_t MinorImageVersion;
     122             :   support::ulittle16_t MajorSubsystemVersion;
     123             :   support::ulittle16_t MinorSubsystemVersion;
     124             :   support::ulittle32_t Win32VersionValue;
     125             :   support::ulittle32_t SizeOfImage;
     126             :   support::ulittle32_t SizeOfHeaders;
     127             :   support::ulittle32_t CheckSum;
     128             :   support::ulittle16_t Subsystem;
     129             :   // FIXME: This should be DllCharacteristics.
     130             :   support::ulittle16_t DLLCharacteristics;
     131             :   support::ulittle32_t SizeOfStackReserve;
     132             :   support::ulittle32_t SizeOfStackCommit;
     133             :   support::ulittle32_t SizeOfHeapReserve;
     134             :   support::ulittle32_t SizeOfHeapCommit;
     135             :   support::ulittle32_t LoaderFlags;
     136             :   // FIXME: This should be NumberOfRvaAndSizes.
     137             :   support::ulittle32_t NumberOfRvaAndSize;
     138             : };
     139             : 
     140             : /// The 64-bit PE header that follows the COFF header.
     141             : struct pe32plus_header {
     142             :   support::ulittle16_t Magic;
     143             :   uint8_t MajorLinkerVersion;
     144             :   uint8_t MinorLinkerVersion;
     145             :   support::ulittle32_t SizeOfCode;
     146             :   support::ulittle32_t SizeOfInitializedData;
     147             :   support::ulittle32_t SizeOfUninitializedData;
     148             :   support::ulittle32_t AddressOfEntryPoint;
     149             :   support::ulittle32_t BaseOfCode;
     150             :   support::ulittle64_t ImageBase;
     151             :   support::ulittle32_t SectionAlignment;
     152             :   support::ulittle32_t FileAlignment;
     153             :   support::ulittle16_t MajorOperatingSystemVersion;
     154             :   support::ulittle16_t MinorOperatingSystemVersion;
     155             :   support::ulittle16_t MajorImageVersion;
     156             :   support::ulittle16_t MinorImageVersion;
     157             :   support::ulittle16_t MajorSubsystemVersion;
     158             :   support::ulittle16_t MinorSubsystemVersion;
     159             :   support::ulittle32_t Win32VersionValue;
     160             :   support::ulittle32_t SizeOfImage;
     161             :   support::ulittle32_t SizeOfHeaders;
     162             :   support::ulittle32_t CheckSum;
     163             :   support::ulittle16_t Subsystem;
     164             :   support::ulittle16_t DLLCharacteristics;
     165             :   support::ulittle64_t SizeOfStackReserve;
     166             :   support::ulittle64_t SizeOfStackCommit;
     167             :   support::ulittle64_t SizeOfHeapReserve;
     168             :   support::ulittle64_t SizeOfHeapCommit;
     169             :   support::ulittle32_t LoaderFlags;
     170             :   support::ulittle32_t NumberOfRvaAndSize;
     171             : };
     172             : 
     173             : struct data_directory {
     174             :   support::ulittle32_t RelativeVirtualAddress;
     175             :   support::ulittle32_t Size;
     176             : };
     177             : 
     178             : struct debug_directory {
     179             :   support::ulittle32_t Characteristics;
     180             :   support::ulittle32_t TimeDateStamp;
     181             :   support::ulittle16_t MajorVersion;
     182             :   support::ulittle16_t MinorVersion;
     183             :   support::ulittle32_t Type;
     184             :   support::ulittle32_t SizeOfData;
     185             :   support::ulittle32_t AddressOfRawData;
     186             :   support::ulittle32_t PointerToRawData;
     187             : };
     188             : 
     189             : template <typename IntTy>
     190             : struct import_lookup_table_entry {
     191             :   IntTy Data;
     192             : 
     193          70 :   bool isOrdinal() const { return Data < 0; }
     194             : 
     195             :   uint16_t getOrdinal() const {
     196             :     assert(isOrdinal() && "ILT entry is not an ordinal!");
     197           6 :     return Data & 0xFFFF;
     198             :   }
     199             : 
     200             :   uint32_t getHintNameRVA() const {
     201             :     assert(!isOrdinal() && "ILT entry is not a Hint/Name RVA!");
     202          54 :     return Data & 0xFFFFFFFF;
     203             :   }
     204             : };
     205             : 
     206             : using import_lookup_table_entry32 =
     207             :     import_lookup_table_entry<support::little32_t>;
     208             : using import_lookup_table_entry64 =
     209             :     import_lookup_table_entry<support::little64_t>;
     210             : 
     211             : struct delay_import_directory_table_entry {
     212             :   // dumpbin reports this field as "Characteristics" instead of "Attributes".
     213             :   support::ulittle32_t Attributes;
     214             :   support::ulittle32_t Name;
     215             :   support::ulittle32_t ModuleHandle;
     216             :   support::ulittle32_t DelayImportAddressTable;
     217             :   support::ulittle32_t DelayImportNameTable;
     218             :   support::ulittle32_t BoundDelayImportTable;
     219             :   support::ulittle32_t UnloadDelayImportTable;
     220             :   support::ulittle32_t TimeStamp;
     221             : };
     222             : 
     223             : struct export_directory_table_entry {
     224             :   support::ulittle32_t ExportFlags;
     225             :   support::ulittle32_t TimeDateStamp;
     226             :   support::ulittle16_t MajorVersion;
     227             :   support::ulittle16_t MinorVersion;
     228             :   support::ulittle32_t NameRVA;
     229             :   support::ulittle32_t OrdinalBase;
     230             :   support::ulittle32_t AddressTableEntries;
     231             :   support::ulittle32_t NumberOfNamePointers;
     232             :   support::ulittle32_t ExportAddressTableRVA;
     233             :   support::ulittle32_t NamePointerRVA;
     234             :   support::ulittle32_t OrdinalTableRVA;
     235             : };
     236             : 
     237             : union export_address_table_entry {
     238             :   support::ulittle32_t ExportRVA;
     239             :   support::ulittle32_t ForwarderRVA;
     240             : };
     241             : 
     242             : using export_name_pointer_table_entry = support::ulittle32_t;
     243             : using export_ordinal_table_entry = support::ulittle16_t;
     244             : 
     245             : struct StringTableOffset {
     246             :   support::ulittle32_t Zeroes;
     247             :   support::ulittle32_t Offset;
     248             : };
     249             : 
     250             : template <typename SectionNumberType>
     251             : struct coff_symbol {
     252             :   union {
     253             :     char ShortName[COFF::NameSize];
     254             :     StringTableOffset Offset;
     255             :   } Name;
     256             : 
     257             :   support::ulittle32_t Value;
     258             :   SectionNumberType SectionNumber;
     259             : 
     260             :   support::ulittle16_t Type;
     261             : 
     262             :   uint8_t StorageClass;
     263             :   uint8_t NumberOfAuxSymbols;
     264             : };
     265             : 
     266             : using coff_symbol16 = coff_symbol<support::ulittle16_t>;
     267             : using coff_symbol32 = coff_symbol<support::ulittle32_t>;
     268             : 
     269             : // Contains only common parts of coff_symbol16 and coff_symbol32.
     270             : struct coff_symbol_generic {
     271             :   union {
     272             :     char ShortName[COFF::NameSize];
     273             :     StringTableOffset Offset;
     274             :   } Name;
     275             :   support::ulittle32_t Value;
     276             : };
     277             : 
     278             : struct coff_aux_section_definition;
     279             : 
     280             : class COFFSymbolRef {
     281             : public:
     282             :   COFFSymbolRef() = default;
     283             :   COFFSymbolRef(const coff_symbol16 *CS) : CS16(CS) {}
     284             :   COFFSymbolRef(const coff_symbol32 *CS) : CS32(CS) {}
     285             : 
     286             :   const void *getRawPtr() const {
     287         368 :     return CS16 ? static_cast<const void *>(CS16) : CS32;
     288             :   }
     289             : 
     290             :   const coff_symbol_generic *getGeneric() const {
     291        7388 :     if (CS16)
     292             :       return reinterpret_cast<const coff_symbol_generic *>(CS16);
     293           4 :     return reinterpret_cast<const coff_symbol_generic *>(CS32);
     294             :   }
     295             : 
     296             :   friend bool operator<(COFFSymbolRef A, COFFSymbolRef B) {
     297             :     return A.getRawPtr() < B.getRawPtr();
     298             :   }
     299             : 
     300             :   bool isBigObj() const {
     301         435 :     if (CS16)
     302             :       return false;
     303           3 :     if (CS32)
     304             :       return true;
     305           0 :     llvm_unreachable("COFFSymbolRef points to nothing!");
     306             :   }
     307             : 
     308             :   const char *getShortName() const {
     309             :     return CS16 ? CS16->Name.ShortName : CS32->Name.ShortName;
     310             :   }
     311             : 
     312             :   const StringTableOffset &getStringTableOffset() const {
     313             :     assert(isSet() && "COFFSymbolRef points to nothing!");
     314             :     return CS16 ? CS16->Name.Offset : CS32->Name.Offset;
     315             :   }
     316             : 
     317        3350 :   uint32_t getValue() const { return CS16 ? CS16->Value : CS32->Value; }
     318             : 
     319             :   int32_t getSectionNumber() const {
     320             :     assert(isSet() && "COFFSymbolRef points to nothing!");
     321       32335 :     if (CS16) {
     322             :       // Reserved sections are returned as negative numbers.
     323       32323 :       if (CS16->SectionNumber <= COFF::MaxNumberOfSections16)
     324       31634 :         return CS16->SectionNumber;
     325         689 :       return static_cast<int16_t>(CS16->SectionNumber);
     326             :     }
     327          24 :     return static_cast<int32_t>(CS32->SectionNumber);
     328             :   }
     329             : 
     330             :   uint16_t getType() const {
     331             :     assert(isSet() && "COFFSymbolRef points to nothing!");
     332        1129 :     return CS16 ? CS16->Type : CS32->Type;
     333             :   }
     334             : 
     335             :   uint8_t getStorageClass() const {
     336             :     assert(isSet() && "COFFSymbolRef points to nothing!");
     337       47505 :     return CS16 ? CS16->StorageClass : CS32->StorageClass;
     338             :   }
     339             : 
     340             :   uint8_t getNumberOfAuxSymbols() const {
     341             :     assert(isSet() && "COFFSymbolRef points to nothing!");
     342       12273 :     return CS16 ? CS16->NumberOfAuxSymbols : CS32->NumberOfAuxSymbols;
     343             :   }
     344             : 
     345         764 :   uint8_t getBaseType() const { return getType() & 0x0F; }
     346             : 
     347             :   uint8_t getComplexType() const {
     348         837 :     return (getType() & 0xF0) >> COFF::SCT_COMPLEX_TYPE_SHIFT;
     349             :   }
     350             : 
     351             :   template <typename T> const T *getAux() const {
     352         636 :     return CS16 ? reinterpret_cast<const T *>(CS16 + 1)
     353           0 :                 : reinterpret_cast<const T *>(CS32 + 1);
     354             :   }
     355             : 
     356         631 :   const coff_aux_section_definition *getSectionDefinition() const {
     357        1262 :     if (!getNumberOfAuxSymbols() ||
     358             :         getStorageClass() != COFF::IMAGE_SYM_CLASS_STATIC)
     359             :       return nullptr;
     360             :     return getAux<coff_aux_section_definition>();
     361             :   }
     362             : 
     363             :   bool isAbsolute() const {
     364             :     return getSectionNumber() == -1;
     365             :   }
     366             : 
     367             :   bool isExternal() const {
     368          10 :     return getStorageClass() == COFF::IMAGE_SYM_CLASS_EXTERNAL;
     369             :   }
     370             : 
     371        9734 :   bool isCommon() const {
     372       14450 :     return isExternal() && getSectionNumber() == COFF::IMAGE_SYM_UNDEFINED &&
     373        9734 :            getValue() != 0;
     374             :   }
     375             : 
     376       10362 :   bool isUndefined() const {
     377       15615 :     return isExternal() && getSectionNumber() == COFF::IMAGE_SYM_UNDEFINED &&
     378       10362 :            getValue() == 0;
     379             :   }
     380             : 
     381             :   bool isWeakExternal() const {
     382         212 :     return getStorageClass() == COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL;
     383             :   }
     384             : 
     385         526 :   bool isFunctionDefinition() const {
     386         362 :     return isExternal() && getBaseType() == COFF::IMAGE_SYM_TYPE_NULL &&
     387         642 :            getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION &&
     388         526 :            !COFF::isReservedSectionNumber(getSectionNumber());
     389             :   }
     390             : 
     391             :   bool isFunctionLineInfo() const {
     392             :     return getStorageClass() == COFF::IMAGE_SYM_CLASS_FUNCTION;
     393             :   }
     394             : 
     395        7113 :   bool isAnyUndefined() const {
     396       13466 :     return isUndefined() || isWeakExternal();
     397             :   }
     398             : 
     399             :   bool isFileRecord() const {
     400             :     return getStorageClass() == COFF::IMAGE_SYM_CLASS_FILE;
     401             :   }
     402             : 
     403             :   bool isSection() const {
     404             :     return getStorageClass() == COFF::IMAGE_SYM_CLASS_SECTION;
     405             :   }
     406             : 
     407        6487 :   bool isSectionDefinition() const {
     408             :     // C++/CLI creates external ABS symbols for non-const appdomain globals.
     409             :     // These are also followed by an auxiliary section definition.
     410             :     bool isAppdomainGlobal =
     411        9307 :         getStorageClass() == COFF::IMAGE_SYM_CLASS_EXTERNAL &&
     412             :         getSectionNumber() == COFF::IMAGE_SYM_ABSOLUTE;
     413        6487 :     bool isOrdinarySection = getStorageClass() == COFF::IMAGE_SYM_CLASS_STATIC;
     414        6487 :     if (!getNumberOfAuxSymbols())
     415             :       return false;
     416        2499 :     return isAppdomainGlobal || isOrdinarySection;
     417             :   }
     418             : 
     419             :   bool isCLRToken() const {
     420             :     return getStorageClass() == COFF::IMAGE_SYM_CLASS_CLR_TOKEN;
     421             :   }
     422             : 
     423             : private:
     424             :   bool isSet() const { return CS16 || CS32; }
     425             : 
     426             :   const coff_symbol16 *CS16 = nullptr;
     427             :   const coff_symbol32 *CS32 = nullptr;
     428             : };
     429             : 
     430             : struct coff_section {
     431             :   char Name[COFF::NameSize];
     432             :   support::ulittle32_t VirtualSize;
     433             :   support::ulittle32_t VirtualAddress;
     434             :   support::ulittle32_t SizeOfRawData;
     435             :   support::ulittle32_t PointerToRawData;
     436             :   support::ulittle32_t PointerToRelocations;
     437             :   support::ulittle32_t PointerToLinenumbers;
     438             :   support::ulittle16_t NumberOfRelocations;
     439             :   support::ulittle16_t NumberOfLinenumbers;
     440             :   support::ulittle32_t Characteristics;
     441             : 
     442             :   // Returns true if the actual number of relocations is stored in
     443             :   // VirtualAddress field of the first relocation table entry.
     444             :   bool hasExtendedRelocations() const {
     445        7783 :     return (Characteristics & COFF::IMAGE_SCN_LNK_NRELOC_OVFL) &&
     446             :            NumberOfRelocations == UINT16_MAX;
     447             :   }
     448             : 
     449             :   uint32_t getAlignment() const {
     450             :     // The IMAGE_SCN_TYPE_NO_PAD bit is a legacy way of getting to
     451             :     // IMAGE_SCN_ALIGN_1BYTES.
     452        1512 :     if (Characteristics & COFF::IMAGE_SCN_TYPE_NO_PAD)
     453             :       return 1;
     454             : 
     455             :     // Bit [20:24] contains section alignment. 0 means use a default alignment
     456             :     // of 16.
     457        1512 :     uint32_t Shift = (Characteristics >> 20) & 0xF;
     458        1512 :     if (Shift > 0)
     459        1504 :       return 1U << (Shift - 1);
     460             :     return 16;
     461             :   }
     462             : };
     463             : 
     464             : struct coff_relocation {
     465             :   support::ulittle32_t VirtualAddress;
     466             :   support::ulittle32_t SymbolTableIndex;
     467             :   support::ulittle16_t Type;
     468             : };
     469             : 
     470             : struct coff_aux_function_definition {
     471             :   support::ulittle32_t TagIndex;
     472             :   support::ulittle32_t TotalSize;
     473             :   support::ulittle32_t PointerToLinenumber;
     474             :   support::ulittle32_t PointerToNextFunction;
     475             :   char Unused1[2];
     476             : };
     477             : 
     478             : static_assert(sizeof(coff_aux_function_definition) == 18,
     479             :               "auxiliary entry must be 18 bytes");
     480             : 
     481             : struct coff_aux_bf_and_ef_symbol {
     482             :   char Unused1[4];
     483             :   support::ulittle16_t Linenumber;
     484             :   char Unused2[6];
     485             :   support::ulittle32_t PointerToNextFunction;
     486             :   char Unused3[2];
     487             : };
     488             : 
     489             : static_assert(sizeof(coff_aux_bf_and_ef_symbol) == 18,
     490             :               "auxiliary entry must be 18 bytes");
     491             : 
     492             : struct coff_aux_weak_external {
     493             :   support::ulittle32_t TagIndex;
     494             :   support::ulittle32_t Characteristics;
     495             :   char Unused1[10];
     496             : };
     497             : 
     498             : static_assert(sizeof(coff_aux_weak_external) == 18,
     499             :               "auxiliary entry must be 18 bytes");
     500             : 
     501             : struct coff_aux_section_definition {
     502             :   support::ulittle32_t Length;
     503             :   support::ulittle16_t NumberOfRelocations;
     504             :   support::ulittle16_t NumberOfLinenumbers;
     505             :   support::ulittle32_t CheckSum;
     506             :   support::ulittle16_t NumberLowPart;
     507             :   uint8_t              Selection;
     508             :   uint8_t              Unused;
     509             :   support::ulittle16_t NumberHighPart;
     510             :   int32_t getNumber(bool IsBigObj) const {
     511         435 :     uint32_t Number = static_cast<uint32_t>(NumberLowPart);
     512          55 :     if (IsBigObj)
     513           3 :       Number |= static_cast<uint32_t>(NumberHighPart) << 16;
     514         368 :     return static_cast<int32_t>(Number);
     515             :   }
     516             : };
     517             : 
     518             : static_assert(sizeof(coff_aux_section_definition) == 18,
     519             :               "auxiliary entry must be 18 bytes");
     520             : 
     521             : struct coff_aux_clr_token {
     522             :   uint8_t              AuxType;
     523             :   uint8_t              Reserved;
     524             :   support::ulittle32_t SymbolTableIndex;
     525             :   char                 MBZ[12];
     526             : };
     527             : 
     528             : static_assert(sizeof(coff_aux_clr_token) == 18,
     529             :               "auxiliary entry must be 18 bytes");
     530             : 
     531             : struct coff_import_header {
     532             :   support::ulittle16_t Sig1;
     533             :   support::ulittle16_t Sig2;
     534             :   support::ulittle16_t Version;
     535             :   support::ulittle16_t Machine;
     536             :   support::ulittle32_t TimeDateStamp;
     537             :   support::ulittle32_t SizeOfData;
     538             :   support::ulittle16_t OrdinalHint;
     539             :   support::ulittle16_t TypeInfo;
     540             : 
     541          47 :   int getType() const { return TypeInfo & 0x3; }
     542         125 :   int getNameType() const { return (TypeInfo >> 2) & 0x7; }
     543             : };
     544             : 
     545             : struct coff_import_directory_table_entry {
     546             :   support::ulittle32_t ImportLookupTableRVA;
     547             :   support::ulittle32_t TimeDateStamp;
     548             :   support::ulittle32_t ForwarderChain;
     549             :   support::ulittle32_t NameRVA;
     550             :   support::ulittle32_t ImportAddressTableRVA;
     551             : 
     552             :   bool isNull() const {
     553          28 :     return ImportLookupTableRVA == 0 && TimeDateStamp == 0 &&
     554          65 :            ForwarderChain == 0 && NameRVA == 0 && ImportAddressTableRVA == 0;
     555             :   }
     556             : };
     557             : 
     558             : template <typename IntTy>
     559             : struct coff_tls_directory {
     560             :   IntTy StartAddressOfRawData;
     561             :   IntTy EndAddressOfRawData;
     562             :   IntTy AddressOfIndex;
     563             :   IntTy AddressOfCallBacks;
     564             :   support::ulittle32_t SizeOfZeroFill;
     565             :   support::ulittle32_t Characteristics;
     566             : 
     567             :   uint32_t getAlignment() const {
     568             :     // Bit [20:24] contains section alignment.
     569           1 :     uint32_t Shift = (Characteristics & 0x00F00000) >> 20;
     570           1 :     if (Shift > 0)
     571           0 :       return 1U << (Shift - 1);
     572             :     return 0;
     573             :   }
     574             : };
     575             : 
     576             : using coff_tls_directory32 = coff_tls_directory<support::little32_t>;
     577             : using coff_tls_directory64 = coff_tls_directory<support::little64_t>;
     578             : 
     579             : /// Bits in control flow guard flags as we understand them.
     580             : enum class coff_guard_flags : uint32_t {
     581             :   CFInstrumented = 0x00000100,
     582             :   HasFidTable = 0x00000400,
     583             :   ProtectDelayLoadIAT = 0x00001000,
     584             :   DelayLoadIATSection = 0x00002000, // Delay load in separate section
     585             :   HasLongJmpTable = 0x00010000,
     586             :   FidTableHasFlags = 0x10000000, // Indicates that fid tables are 5 bytes
     587             : };
     588             : 
     589             : struct coff_load_config_code_integrity {
     590             :   support::ulittle16_t Flags;
     591             :   support::ulittle16_t Catalog;
     592             :   support::ulittle32_t CatalogOffset;
     593             :   support::ulittle32_t Reserved;
     594             : };
     595             : 
     596             : /// 32-bit load config (IMAGE_LOAD_CONFIG_DIRECTORY32)
     597             : struct coff_load_configuration32 {
     598             :   support::ulittle32_t Size;
     599             :   support::ulittle32_t TimeDateStamp;
     600             :   support::ulittle16_t MajorVersion;
     601             :   support::ulittle16_t MinorVersion;
     602             :   support::ulittle32_t GlobalFlagsClear;
     603             :   support::ulittle32_t GlobalFlagsSet;
     604             :   support::ulittle32_t CriticalSectionDefaultTimeout;
     605             :   support::ulittle32_t DeCommitFreeBlockThreshold;
     606             :   support::ulittle32_t DeCommitTotalFreeThreshold;
     607             :   support::ulittle32_t LockPrefixTable;
     608             :   support::ulittle32_t MaximumAllocationSize;
     609             :   support::ulittle32_t VirtualMemoryThreshold;
     610             :   support::ulittle32_t ProcessAffinityMask;
     611             :   support::ulittle32_t ProcessHeapFlags;
     612             :   support::ulittle16_t CSDVersion;
     613             :   support::ulittle16_t DependentLoadFlags;
     614             :   support::ulittle32_t EditList;
     615             :   support::ulittle32_t SecurityCookie;
     616             :   support::ulittle32_t SEHandlerTable;
     617             :   support::ulittle32_t SEHandlerCount;
     618             : 
     619             :   // Added in MSVC 2015 for /guard:cf.
     620             :   support::ulittle32_t GuardCFCheckFunction;
     621             :   support::ulittle32_t GuardCFCheckDispatch;
     622             :   support::ulittle32_t GuardCFFunctionTable;
     623             :   support::ulittle32_t GuardCFFunctionCount;
     624             :   support::ulittle32_t GuardFlags; // coff_guard_flags
     625             : 
     626             :   // Added in MSVC 2017
     627             :   coff_load_config_code_integrity CodeIntegrity;
     628             :   support::ulittle32_t GuardAddressTakenIatEntryTable;
     629             :   support::ulittle32_t GuardAddressTakenIatEntryCount;
     630             :   support::ulittle32_t GuardLongJumpTargetTable;
     631             :   support::ulittle32_t GuardLongJumpTargetCount;
     632             :   support::ulittle32_t DynamicValueRelocTable;
     633             :   support::ulittle32_t CHPEMetadataPointer;
     634             :   support::ulittle32_t GuardRFFailureRoutine;
     635             :   support::ulittle32_t GuardRFFailureRoutineFunctionPointer;
     636             :   support::ulittle32_t DynamicValueRelocTableOffset;
     637             :   support::ulittle16_t DynamicValueRelocTableSection;
     638             :   support::ulittle16_t Reserved2;
     639             :   support::ulittle32_t GuardRFVerifyStackPointerFunctionPointer;
     640             :   support::ulittle32_t HotPatchTableOffset;
     641             : };
     642             : 
     643             : /// 64-bit load config (IMAGE_LOAD_CONFIG_DIRECTORY64)
     644             : struct coff_load_configuration64 {
     645             :   support::ulittle32_t Size;
     646             :   support::ulittle32_t TimeDateStamp;
     647             :   support::ulittle16_t MajorVersion;
     648             :   support::ulittle16_t MinorVersion;
     649             :   support::ulittle32_t GlobalFlagsClear;
     650             :   support::ulittle32_t GlobalFlagsSet;
     651             :   support::ulittle32_t CriticalSectionDefaultTimeout;
     652             :   support::ulittle64_t DeCommitFreeBlockThreshold;
     653             :   support::ulittle64_t DeCommitTotalFreeThreshold;
     654             :   support::ulittle64_t LockPrefixTable;
     655             :   support::ulittle64_t MaximumAllocationSize;
     656             :   support::ulittle64_t VirtualMemoryThreshold;
     657             :   support::ulittle64_t ProcessAffinityMask;
     658             :   support::ulittle32_t ProcessHeapFlags;
     659             :   support::ulittle16_t CSDVersion;
     660             :   support::ulittle16_t DependentLoadFlags;
     661             :   support::ulittle64_t EditList;
     662             :   support::ulittle64_t SecurityCookie;
     663             :   support::ulittle64_t SEHandlerTable;
     664             :   support::ulittle64_t SEHandlerCount;
     665             : 
     666             :   // Added in MSVC 2015 for /guard:cf.
     667             :   support::ulittle64_t GuardCFCheckFunction;
     668             :   support::ulittle64_t GuardCFCheckDispatch;
     669             :   support::ulittle64_t GuardCFFunctionTable;
     670             :   support::ulittle64_t GuardCFFunctionCount;
     671             :   support::ulittle32_t GuardFlags;
     672             : 
     673             :   // Added in MSVC 2017
     674             :   coff_load_config_code_integrity CodeIntegrity;
     675             :   support::ulittle64_t GuardAddressTakenIatEntryTable;
     676             :   support::ulittle64_t GuardAddressTakenIatEntryCount;
     677             :   support::ulittle64_t GuardLongJumpTargetTable;
     678             :   support::ulittle64_t GuardLongJumpTargetCount;
     679             :   support::ulittle64_t DynamicValueRelocTable;
     680             :   support::ulittle64_t CHPEMetadataPointer;
     681             :   support::ulittle64_t GuardRFFailureRoutine;
     682             :   support::ulittle64_t GuardRFFailureRoutineFunctionPointer;
     683             :   support::ulittle32_t DynamicValueRelocTableOffset;
     684             :   support::ulittle16_t DynamicValueRelocTableSection;
     685             :   support::ulittle16_t Reserved2;
     686             :   support::ulittle64_t GuardRFVerifyStackPointerFunctionPointer;
     687             :   support::ulittle32_t HotPatchTableOffset;
     688             : };
     689             : 
     690             : struct coff_runtime_function_x64 {
     691             :   support::ulittle32_t BeginAddress;
     692             :   support::ulittle32_t EndAddress;
     693             :   support::ulittle32_t UnwindInformation;
     694             : };
     695             : 
     696             : struct coff_base_reloc_block_header {
     697             :   support::ulittle32_t PageRVA;
     698             :   support::ulittle32_t BlockSize;
     699             : };
     700             : 
     701             : struct coff_base_reloc_block_entry {
     702             :   support::ulittle16_t Data;
     703             : 
     704         100 :   int getType() const { return Data >> 12; }
     705             :   int getOffset() const { return Data & ((1 << 12) - 1); }
     706             : };
     707             : 
     708             : struct coff_resource_dir_entry {
     709             :   union {
     710             :     support::ulittle32_t NameOffset;
     711             :     support::ulittle32_t ID;
     712             :     uint32_t getNameOffset() const {
     713          28 :       return maskTrailingOnes<uint32_t>(31) & NameOffset;
     714             :     }
     715             :     // Even though the PE/COFF spec doesn't mention this, the high bit of a name
     716             :     // offset is set.
     717          72 :     void setNameOffset(uint32_t Offset) { NameOffset = Offset | (1 << 31); }
     718             :   } Identifier;
     719             :   union {
     720             :     support::ulittle32_t DataEntryOffset;
     721             :     support::ulittle32_t SubdirOffset;
     722             : 
     723         204 :     bool isSubDir() const { return SubdirOffset >> 31; }
     724             :     uint32_t value() const {
     725         222 :       return maskTrailingOnes<uint32_t>(31) & SubdirOffset;
     726             :     }
     727             : 
     728             :   } Offset;
     729             : };
     730             : 
     731             : struct coff_resource_data_entry {
     732             :   support::ulittle32_t DataRVA;
     733             :   support::ulittle32_t DataSize;
     734             :   support::ulittle32_t Codepage;
     735             :   support::ulittle32_t Reserved;
     736             : };
     737             : 
     738             : struct coff_resource_dir_table {
     739             :   support::ulittle32_t Characteristics;
     740             :   support::ulittle32_t TimeDateStamp;
     741             :   support::ulittle16_t MajorVersion;
     742             :   support::ulittle16_t MinorVersion;
     743             :   support::ulittle16_t NumberOfNameEntries;
     744             :   support::ulittle16_t NumberOfIDEntries;
     745             : };
     746             : 
     747             : struct debug_h_header {
     748             :   support::ulittle32_t Magic;
     749             :   support::ulittle16_t Version;
     750             :   support::ulittle16_t HashAlgorithm;
     751             : };
     752             : 
     753        3304 : class COFFObjectFile : public ObjectFile {
     754             : private:
     755             :   friend class ImportDirectoryEntryRef;
     756             :   friend class ExportDirectoryEntryRef;
     757             :   const coff_file_header *COFFHeader;
     758             :   const coff_bigobj_file_header *COFFBigObjHeader;
     759             :   const pe32_header *PE32Header;
     760             :   const pe32plus_header *PE32PlusHeader;
     761             :   const data_directory *DataDirectory;
     762             :   const coff_section *SectionTable;
     763             :   const coff_symbol16 *SymbolTable16;
     764             :   const coff_symbol32 *SymbolTable32;
     765             :   const char *StringTable;
     766             :   uint32_t StringTableSize;
     767             :   const coff_import_directory_table_entry *ImportDirectory;
     768             :   const delay_import_directory_table_entry *DelayImportDirectory;
     769             :   uint32_t NumberOfDelayImportDirectory;
     770             :   const export_directory_table_entry *ExportDirectory;
     771             :   const coff_base_reloc_block_header *BaseRelocHeader;
     772             :   const coff_base_reloc_block_header *BaseRelocEnd;
     773             :   const debug_directory *DebugDirectoryBegin;
     774             :   const debug_directory *DebugDirectoryEnd;
     775             :   // Either coff_load_configuration32 or coff_load_configuration64.
     776             :   const void *LoadConfig = nullptr;
     777             : 
     778             :   std::error_code getString(uint32_t offset, StringRef &Res) const;
     779             : 
     780             :   template <typename coff_symbol_type>
     781             :   const coff_symbol_type *toSymb(DataRefImpl Symb) const;
     782             :   const coff_section *toSec(DataRefImpl Sec) const;
     783             :   const coff_relocation *toRel(DataRefImpl Rel) const;
     784             : 
     785             :   std::error_code initSymbolTablePtr();
     786             :   std::error_code initImportTablePtr();
     787             :   std::error_code initDelayImportTablePtr();
     788             :   std::error_code initExportTablePtr();
     789             :   std::error_code initBaseRelocPtr();
     790             :   std::error_code initDebugDirectoryPtr();
     791             :   std::error_code initLoadConfigPtr();
     792             : 
     793             : public:
     794             :   uintptr_t getSymbolTable() const {
     795        4325 :     if (SymbolTable16)
     796        4291 :       return reinterpret_cast<uintptr_t>(SymbolTable16);
     797          34 :     if (SymbolTable32)
     798           1 :       return reinterpret_cast<uintptr_t>(SymbolTable32);
     799             :     return uintptr_t(0);
     800             :   }
     801             : 
     802             :   uint16_t getMachine() const {
     803      154139 :     if (COFFHeader)
     804             :       return COFFHeader->Machine;
     805           4 :     if (COFFBigObjHeader)
     806             :       return COFFBigObjHeader->Machine;
     807           0 :     llvm_unreachable("no COFF header!");
     808             :   }
     809             : 
     810             :   uint16_t getSizeOfOptionalHeader() const {
     811         114 :     if (COFFHeader)
     812             :       return COFFHeader->isImportLibrary() ? 0
     813         113 :                                            : COFFHeader->SizeOfOptionalHeader;
     814             :     // bigobj doesn't have this field.
     815           1 :     if (COFFBigObjHeader)
     816             :       return 0;
     817           0 :     llvm_unreachable("no COFF header!");
     818             :   }
     819             : 
     820             :   uint16_t getCharacteristics() const {
     821         128 :     if (COFFHeader)
     822         127 :       return COFFHeader->isImportLibrary() ? 0 : COFFHeader->Characteristics;
     823             :     // bigobj doesn't have characteristics to speak of,
     824             :     // editbin will silently lie to you if you attempt to set any.
     825           1 :     if (COFFBigObjHeader)
     826             :       return 0;
     827           0 :     llvm_unreachable("no COFF header!");
     828             :   }
     829             : 
     830             :   uint32_t getTimeDateStamp() const {
     831         228 :     if (COFFHeader)
     832             :       return COFFHeader->TimeDateStamp;
     833           2 :     if (COFFBigObjHeader)
     834             :       return COFFBigObjHeader->TimeDateStamp;
     835           0 :     llvm_unreachable("no COFF header!");
     836             :   }
     837             : 
     838             :   uint32_t getNumberOfSections() const {
     839       14809 :     if (COFFHeader)
     840       14788 :       return COFFHeader->isImportLibrary() ? 0 : COFFHeader->NumberOfSections;
     841           7 :     if (COFFBigObjHeader)
     842             :       return COFFBigObjHeader->NumberOfSections;
     843           0 :     llvm_unreachable("no COFF header!");
     844             :   }
     845             : 
     846             :   uint32_t getPointerToSymbolTable() const {
     847        3146 :     if (COFFHeader)
     848        4503 :       return COFFHeader->isImportLibrary() ? 0
     849             :                                            : COFFHeader->PointerToSymbolTable;
     850           3 :     if (COFFBigObjHeader)
     851             :       return COFFBigObjHeader->PointerToSymbolTable;
     852           0 :     llvm_unreachable("no COFF header!");
     853             :   }
     854             : 
     855             :   uint32_t getRawNumberOfSymbols() const {
     856        6889 :     if (COFFHeader)
     857        6874 :       return COFFHeader->isImportLibrary() ? 0 : COFFHeader->NumberOfSymbols;
     858           2 :     if (COFFBigObjHeader)
     859             :       return COFFBigObjHeader->NumberOfSymbols;
     860           0 :     llvm_unreachable("no COFF header!");
     861             :   }
     862             : 
     863             :   uint32_t getNumberOfSymbols() const {
     864        8661 :     if (!SymbolTable16 && !SymbolTable32)
     865             :       return 0;
     866        5527 :     return getRawNumberOfSymbols();
     867             :   }
     868             : 
     869             :   const coff_load_configuration32 *getLoadConfig32() const {
     870             :     assert(!is64());
     871             :     return reinterpret_cast<const coff_load_configuration32 *>(LoadConfig);
     872             :   }
     873             : 
     874             :   const coff_load_configuration64 *getLoadConfig64() const {
     875             :     assert(is64());
     876             :     return reinterpret_cast<const coff_load_configuration64 *>(LoadConfig);
     877             :   }
     878             : 
     879             : protected:
     880             :   void moveSymbolNext(DataRefImpl &Symb) const override;
     881             :   Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
     882             :   Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
     883             :   uint32_t getSymbolAlignment(DataRefImpl Symb) const override;
     884             :   uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
     885             :   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
     886             :   uint32_t getSymbolFlags(DataRefImpl Symb) const override;
     887             :   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
     888             :   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
     889             :   void moveSectionNext(DataRefImpl &Sec) const override;
     890             :   std::error_code getSectionName(DataRefImpl Sec,
     891             :                                  StringRef &Res) const override;
     892             :   uint64_t getSectionAddress(DataRefImpl Sec) const override;
     893             :   uint64_t getSectionIndex(DataRefImpl Sec) const override;
     894             :   uint64_t getSectionSize(DataRefImpl Sec) const override;
     895             :   std::error_code getSectionContents(DataRefImpl Sec,
     896             :                                      StringRef &Res) const override;
     897             :   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
     898             :   bool isSectionCompressed(DataRefImpl Sec) const override;
     899             :   bool isSectionText(DataRefImpl Sec) const override;
     900             :   bool isSectionData(DataRefImpl Sec) const override;
     901             :   bool isSectionBSS(DataRefImpl Sec) const override;
     902             :   bool isSectionVirtual(DataRefImpl Sec) const override;
     903             :   relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
     904             :   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
     905             : 
     906             :   void moveRelocationNext(DataRefImpl &Rel) const override;
     907             :   uint64_t getRelocationOffset(DataRefImpl Rel) const override;
     908             :   symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
     909             :   uint64_t getRelocationType(DataRefImpl Rel) const override;
     910             :   void getRelocationTypeName(DataRefImpl Rel,
     911             :                              SmallVectorImpl<char> &Result) const override;
     912             : 
     913             : public:
     914             :   COFFObjectFile(MemoryBufferRef Object, std::error_code &EC);
     915             : 
     916             :   basic_symbol_iterator symbol_begin() const override;
     917             :   basic_symbol_iterator symbol_end() const override;
     918             :   section_iterator section_begin() const override;
     919             :   section_iterator section_end() const override;
     920             : 
     921             :   const coff_section *getCOFFSection(const SectionRef &Section) const;
     922             :   COFFSymbolRef getCOFFSymbol(const DataRefImpl &Ref) const;
     923             :   COFFSymbolRef getCOFFSymbol(const SymbolRef &Symbol) const;
     924             :   const coff_relocation *getCOFFRelocation(const RelocationRef &Reloc) const;
     925             :   unsigned getSectionID(SectionRef Sec) const;
     926             :   unsigned getSymbolSectionID(SymbolRef Sym) const;
     927             : 
     928             :   uint8_t getBytesInAddress() const override;
     929             :   StringRef getFileFormatName() const override;
     930             :   Triple::ArchType getArch() const override;
     931         104 :   SubtargetFeatures getFeatures() const override { return SubtargetFeatures(); }
     932             : 
     933             :   import_directory_iterator import_directory_begin() const;
     934             :   import_directory_iterator import_directory_end() const;
     935             :   delay_import_directory_iterator delay_import_directory_begin() const;
     936             :   delay_import_directory_iterator delay_import_directory_end() const;
     937             :   export_directory_iterator export_directory_begin() const;
     938             :   export_directory_iterator export_directory_end() const;
     939             :   base_reloc_iterator base_reloc_begin() const;
     940             :   base_reloc_iterator base_reloc_end() const;
     941             :   const debug_directory *debug_directory_begin() const {
     942             :     return DebugDirectoryBegin;
     943             :   }
     944             :   const debug_directory *debug_directory_end() const {
     945             :     return DebugDirectoryEnd;
     946             :   }
     947             : 
     948             :   iterator_range<import_directory_iterator> import_directories() const;
     949             :   iterator_range<delay_import_directory_iterator>
     950             :       delay_import_directories() const;
     951             :   iterator_range<export_directory_iterator> export_directories() const;
     952             :   iterator_range<base_reloc_iterator> base_relocs() const;
     953             :   iterator_range<const debug_directory *> debug_directories() const {
     954          59 :     return make_range(debug_directory_begin(), debug_directory_end());
     955             :   }
     956             : 
     957             :   const dos_header *getDOSHeader() const {
     958      153081 :     if (!PE32Header && !PE32PlusHeader)
     959             :       return nullptr;
     960             :     return reinterpret_cast<const dos_header *>(base());
     961             :   }
     962             :   std::error_code getPE32Header(const pe32_header *&Res) const;
     963             :   std::error_code getPE32PlusHeader(const pe32plus_header *&Res) const;
     964             :   std::error_code getDataDirectory(uint32_t index,
     965             :                                    const data_directory *&Res) const;
     966             :   std::error_code getSection(int32_t index, const coff_section *&Res) const;
     967             : 
     968             :   template <typename coff_symbol_type>
     969        3608 :   std::error_code getSymbol(uint32_t Index,
     970             :                             const coff_symbol_type *&Res) const {
     971        3608 :     if (Index >= getNumberOfSymbols())
     972           0 :       return object_error::parse_failed;
     973             : 
     974        7216 :     Res = reinterpret_cast<coff_symbol_type *>(getSymbolTable()) + Index;
     975        3608 :     return std::error_code();
     976             :   }
     977        3608 :   Expected<COFFSymbolRef> getSymbol(uint32_t index) const {
     978        3608 :     if (SymbolTable16) {
     979        3608 :       const coff_symbol16 *Symb = nullptr;
     980        3608 :       if (std::error_code EC = getSymbol(index, Symb))
     981           0 :         return errorCodeToError(EC);
     982        3608 :       return COFFSymbolRef(Symb);
     983             :     }
     984           0 :     if (SymbolTable32) {
     985           0 :       const coff_symbol32 *Symb = nullptr;
     986           0 :       if (std::error_code EC = getSymbol(index, Symb))
     987           0 :         return errorCodeToError(EC);
     988           0 :       return COFFSymbolRef(Symb);
     989             :     }
     990           0 :     return errorCodeToError(object_error::parse_failed);
     991             :   }
     992             : 
     993             :   template <typename T>
     994          21 :   std::error_code getAuxSymbol(uint32_t index, const T *&Res) const {
     995          21 :     Expected<COFFSymbolRef> S = getSymbol(index);
     996          21 :     if (Error E = S.takeError())
     997           0 :       return errorToErrorCode(std::move(E));
     998          21 :     Res = reinterpret_cast<const T *>(S->getRawPtr());
     999          21 :     return std::error_code();
    1000             :   }
    1001             : 
    1002             :   std::error_code getSymbolName(COFFSymbolRef Symbol, StringRef &Res) const;
    1003             :   std::error_code getSymbolName(const coff_symbol_generic *Symbol,
    1004             :                                 StringRef &Res) const;
    1005             : 
    1006             :   ArrayRef<uint8_t> getSymbolAuxData(COFFSymbolRef Symbol) const;
    1007             : 
    1008             :   size_t getSymbolTableEntrySize() const {
    1009        2536 :     if (COFFHeader)
    1010             :       return sizeof(coff_symbol16);
    1011          10 :     if (COFFBigObjHeader)
    1012             :       return sizeof(coff_symbol32);
    1013           0 :     llvm_unreachable("null symbol table pointer!");
    1014             :   }
    1015             : 
    1016             :   ArrayRef<coff_relocation> getRelocations(const coff_section *Sec) const;
    1017             : 
    1018             :   std::error_code getSectionName(const coff_section *Sec, StringRef &Res) const;
    1019             :   uint64_t getSectionSize(const coff_section *Sec) const;
    1020             :   std::error_code getSectionContents(const coff_section *Sec,
    1021             :                                      ArrayRef<uint8_t> &Res) const;
    1022             : 
    1023             :   uint64_t getImageBase() const;
    1024             :   std::error_code getVaPtr(uint64_t VA, uintptr_t &Res) const;
    1025             :   std::error_code getRvaPtr(uint32_t Rva, uintptr_t &Res) const;
    1026             : 
    1027             :   /// Given an RVA base and size, returns a valid array of bytes or an error
    1028             :   /// code if the RVA and size is not contained completely within a valid
    1029             :   /// section.
    1030             :   std::error_code getRvaAndSizeAsBytes(uint32_t RVA, uint32_t Size,
    1031             :                                        ArrayRef<uint8_t> &Contents) const;
    1032             : 
    1033             :   std::error_code getHintName(uint32_t Rva, uint16_t &Hint,
    1034             :                               StringRef &Name) const;
    1035             : 
    1036             :   /// Get PDB information out of a codeview debug directory entry.
    1037             :   std::error_code getDebugPDBInfo(const debug_directory *DebugDir,
    1038             :                                   const codeview::DebugInfo *&Info,
    1039             :                                   StringRef &PDBFileName) const;
    1040             : 
    1041             :   /// Get PDB information from an executable. If the information is not present,
    1042             :   /// Info will be set to nullptr and PDBFileName will be empty. An error is
    1043             :   /// returned only on corrupt object files. Convenience accessor that can be
    1044             :   /// used if the debug directory is not already handy.
    1045             :   std::error_code getDebugPDBInfo(const codeview::DebugInfo *&Info,
    1046             :                                   StringRef &PDBFileName) const;
    1047             : 
    1048             :   bool isRelocatableObject() const override;
    1049          30 :   bool is64() const { return PE32PlusHeader; }
    1050             : 
    1051        3097 :   static bool classof(const Binary *v) { return v->isCOFF(); }
    1052             : };
    1053             : 
    1054             : // The iterator for the import directory table.
    1055             : class ImportDirectoryEntryRef {
    1056             : public:
    1057             :   ImportDirectoryEntryRef() = default;
    1058             :   ImportDirectoryEntryRef(const coff_import_directory_table_entry *Table,
    1059             :                           uint32_t I, const COFFObjectFile *Owner)
    1060             :       : ImportTable(Table), Index(I), OwningObject(Owner) {}
    1061             : 
    1062             :   bool operator==(const ImportDirectoryEntryRef &Other) const;
    1063             :   void moveNext();
    1064             : 
    1065             :   imported_symbol_iterator imported_symbol_begin() const;
    1066             :   imported_symbol_iterator imported_symbol_end() const;
    1067             :   iterator_range<imported_symbol_iterator> imported_symbols() const;
    1068             : 
    1069             :   imported_symbol_iterator lookup_table_begin() const;
    1070             :   imported_symbol_iterator lookup_table_end() const;
    1071             :   iterator_range<imported_symbol_iterator> lookup_table_symbols() const;
    1072             : 
    1073             :   std::error_code getName(StringRef &Result) const;
    1074             :   std::error_code getImportLookupTableRVA(uint32_t &Result) const;
    1075             :   std::error_code getImportAddressTableRVA(uint32_t &Result) const;
    1076             : 
    1077             :   std::error_code
    1078             :   getImportTableEntry(const coff_import_directory_table_entry *&Result) const;
    1079             : 
    1080             : private:
    1081             :   const coff_import_directory_table_entry *ImportTable;
    1082             :   uint32_t Index;
    1083             :   const COFFObjectFile *OwningObject = nullptr;
    1084             : };
    1085             : 
    1086             : class DelayImportDirectoryEntryRef {
    1087             : public:
    1088             :   DelayImportDirectoryEntryRef() = default;
    1089             :   DelayImportDirectoryEntryRef(const delay_import_directory_table_entry *T,
    1090             :                                uint32_t I, const COFFObjectFile *Owner)
    1091             :       : Table(T), Index(I), OwningObject(Owner) {}
    1092             : 
    1093             :   bool operator==(const DelayImportDirectoryEntryRef &Other) const;
    1094             :   void moveNext();
    1095             : 
    1096             :   imported_symbol_iterator imported_symbol_begin() const;
    1097             :   imported_symbol_iterator imported_symbol_end() const;
    1098             :   iterator_range<imported_symbol_iterator> imported_symbols() const;
    1099             : 
    1100             :   std::error_code getName(StringRef &Result) const;
    1101             :   std::error_code getDelayImportTable(
    1102             :       const delay_import_directory_table_entry *&Result) const;
    1103             :   std::error_code getImportAddress(int AddrIndex, uint64_t &Result) const;
    1104             : 
    1105             : private:
    1106             :   const delay_import_directory_table_entry *Table;
    1107             :   uint32_t Index;
    1108             :   const COFFObjectFile *OwningObject = nullptr;
    1109             : };
    1110             : 
    1111             : // The iterator for the export directory table entry.
    1112             : class ExportDirectoryEntryRef {
    1113             : public:
    1114             :   ExportDirectoryEntryRef() = default;
    1115             :   ExportDirectoryEntryRef(const export_directory_table_entry *Table, uint32_t I,
    1116             :                           const COFFObjectFile *Owner)
    1117             :       : ExportTable(Table), Index(I), OwningObject(Owner) {}
    1118             : 
    1119             :   bool operator==(const ExportDirectoryEntryRef &Other) const;
    1120             :   void moveNext();
    1121             : 
    1122             :   std::error_code getDllName(StringRef &Result) const;
    1123             :   std::error_code getOrdinalBase(uint32_t &Result) const;
    1124             :   std::error_code getOrdinal(uint32_t &Result) const;
    1125             :   std::error_code getExportRVA(uint32_t &Result) const;
    1126             :   std::error_code getSymbolName(StringRef &Result) const;
    1127             : 
    1128             :   std::error_code isForwarder(bool &Result) const;
    1129             :   std::error_code getForwardTo(StringRef &Result) const;
    1130             : 
    1131             : private:
    1132             :   const export_directory_table_entry *ExportTable;
    1133             :   uint32_t Index;
    1134             :   const COFFObjectFile *OwningObject = nullptr;
    1135             : };
    1136             : 
    1137             : class ImportedSymbolRef {
    1138             : public:
    1139             :   ImportedSymbolRef() = default;
    1140             :   ImportedSymbolRef(const import_lookup_table_entry32 *Entry, uint32_t I,
    1141             :                     const COFFObjectFile *Owner)
    1142             :       : Entry32(Entry), Entry64(nullptr), Index(I), OwningObject(Owner) {}
    1143             :   ImportedSymbolRef(const import_lookup_table_entry64 *Entry, uint32_t I,
    1144             :                     const COFFObjectFile *Owner)
    1145             :       : Entry32(nullptr), Entry64(Entry), Index(I), OwningObject(Owner) {}
    1146             : 
    1147             :   bool operator==(const ImportedSymbolRef &Other) const;
    1148             :   void moveNext();
    1149             : 
    1150             :   std::error_code getSymbolName(StringRef &Result) const;
    1151             :   std::error_code isOrdinal(bool &Result) const;
    1152             :   std::error_code getOrdinal(uint16_t &Result) const;
    1153             :   std::error_code getHintNameRVA(uint32_t &Result) const;
    1154             : 
    1155             : private:
    1156             :   const import_lookup_table_entry32 *Entry32;
    1157             :   const import_lookup_table_entry64 *Entry64;
    1158             :   uint32_t Index;
    1159             :   const COFFObjectFile *OwningObject = nullptr;
    1160             : };
    1161             : 
    1162             : class BaseRelocRef {
    1163             : public:
    1164             :   BaseRelocRef() = default;
    1165             :   BaseRelocRef(const coff_base_reloc_block_header *Header,
    1166             :                const COFFObjectFile *Owner)
    1167             :       : Header(Header), Index(0) {}
    1168             : 
    1169             :   bool operator==(const BaseRelocRef &Other) const;
    1170             :   void moveNext();
    1171             : 
    1172             :   std::error_code getType(uint8_t &Type) const;
    1173             :   std::error_code getRVA(uint32_t &Result) const;
    1174             : 
    1175             : private:
    1176             :   const coff_base_reloc_block_header *Header;
    1177             :   uint32_t Index;
    1178             : };
    1179             : 
    1180             : class ResourceSectionRef {
    1181             : public:
    1182             :   ResourceSectionRef() = default;
    1183             :   explicit ResourceSectionRef(StringRef Ref) : BBS(Ref, support::little) {}
    1184             : 
    1185             :   Expected<ArrayRef<UTF16>>
    1186             :   getEntryNameString(const coff_resource_dir_entry &Entry);
    1187             :   Expected<const coff_resource_dir_table &>
    1188             :   getEntrySubDir(const coff_resource_dir_entry &Entry);
    1189             :   Expected<const coff_resource_dir_table &> getBaseTable();
    1190             : 
    1191             : private:
    1192             :   BinaryByteStream BBS;
    1193             : 
    1194             :   Expected<const coff_resource_dir_table &> getTableAtOffset(uint32_t Offset);
    1195             :   Expected<ArrayRef<UTF16>> getDirStringAtOffset(uint32_t Offset);
    1196             : };
    1197             : 
    1198             : // Corresponds to `_FPO_DATA` structure in the PE/COFF spec.
    1199             : struct FpoData {
    1200             :   support::ulittle32_t Offset; // ulOffStart: Offset 1st byte of function code
    1201             :   support::ulittle32_t Size;   // cbProcSize: # bytes in function
    1202             :   support::ulittle32_t NumLocals; // cdwLocals: # bytes in locals/4
    1203             :   support::ulittle16_t NumParams; // cdwParams: # bytes in params/4
    1204             :   support::ulittle16_t Attributes;
    1205             : 
    1206             :   // cbProlog: # bytes in prolog
    1207             :   int getPrologSize() const { return Attributes & 0xF; }
    1208             : 
    1209             :   // cbRegs: # regs saved
    1210             :   int getNumSavedRegs() const { return (Attributes >> 8) & 0x7; }
    1211             : 
    1212             :   // fHasSEH: true if seh is func
    1213             :   bool hasSEH() const { return (Attributes >> 9) & 1; }
    1214             : 
    1215             :   // fUseBP: true if EBP has been allocated
    1216             :   bool useBP() const { return (Attributes >> 10) & 1; }
    1217             : 
    1218             :   // cbFrame: frame pointer
    1219             :   int getFP() const { return Attributes >> 14; }
    1220             : };
    1221             : 
    1222             : } // end namespace object
    1223             : 
    1224             : } // end namespace llvm
    1225             : 
    1226             : #endif // LLVM_OBJECT_COFF_H

Generated by: LCOV version 1.13