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