LLVM  10.0.0svn
COFFYAML.cpp
Go to the documentation of this file.
1 //===- COFFYAML.cpp - COFF YAMLIO implementation --------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines classes for handling the YAML representation of COFF.
10 //
11 //===----------------------------------------------------------------------===//
12 
14 #include "llvm/ADT/StringRef.h"
16 #include <cstdint>
17 #include <cstring>
18 
19 #define ECase(X) IO.enumCase(Value, #X, COFF::X);
20 
21 namespace llvm {
22 
23 namespace COFFYAML {
24 
25 Section::Section() { memset(&Header, 0, sizeof(COFF::section)); }
26 Symbol::Symbol() { memset(&Header, 0, sizeof(COFF::symbol)); }
27 Object::Object() { memset(&Header, 0, sizeof(COFF::header)); }
28 
29 } // end namespace COFFYAML
30 
31 namespace yaml {
32 
33 void ScalarEnumerationTraits<COFFYAML::COMDATType>::enumeration(
34  IO &IO, COFFYAML::COMDATType &Value) {
35  IO.enumCase(Value, "0", 0);
43 }
44 
45 void
46 ScalarEnumerationTraits<COFFYAML::WeakExternalCharacteristics>::enumeration(
48  IO.enumCase(Value, "0", 0);
52 }
53 
54 void ScalarEnumerationTraits<COFFYAML::AuxSymbolType>::enumeration(
55  IO &IO, COFFYAML::AuxSymbolType &Value) {
57 }
58 
59 void ScalarEnumerationTraits<COFF::MachineTypes>::enumeration(
60  IO &IO, COFF::MachineTypes &Value) {
83 }
84 
85 void ScalarEnumerationTraits<COFF::SymbolBaseType>::enumeration(
86  IO &IO, COFF::SymbolBaseType &Value) {
103 }
104 
105 void ScalarEnumerationTraits<COFF::SymbolStorageClass>::enumeration(
106  IO &IO, COFF::SymbolStorageClass &Value) {
134 }
135 
136 void ScalarEnumerationTraits<COFF::SymbolComplexType>::enumeration(
137  IO &IO, COFF::SymbolComplexType &Value) {
142 }
143 
144 void ScalarEnumerationTraits<COFF::RelocationTypeI386>::enumeration(
145  IO &IO, COFF::RelocationTypeI386 &Value) {
157 }
158 
159 void ScalarEnumerationTraits<COFF::RelocationTypeAMD64>::enumeration(
160  IO &IO, COFF::RelocationTypeAMD64 &Value) {
178 }
179 
180 void ScalarEnumerationTraits<COFF::RelocationTypesARM>::enumeration(
181  IO &IO, COFF::RelocationTypesARM &Value) {
199 }
200 
201 void ScalarEnumerationTraits<COFF::RelocationTypesARM64>::enumeration(
221 }
222 
223 void ScalarEnumerationTraits<COFF::WindowsSubsystem>::enumeration(
224  IO &IO, COFF::WindowsSubsystem &Value) {
239 }
240 #undef ECase
241 
242 #define BCase(X) IO.bitSetCase(Value, #X, COFF::X);
243 void ScalarBitSetTraits<COFF::Characteristics>::bitset(
244  IO &IO, COFF::Characteristics &Value) {
260 }
261 
262 void ScalarBitSetTraits<COFF::SectionCharacteristics>::bitset(
286 }
287 
288 void ScalarBitSetTraits<COFF::DLLCharacteristics>::bitset(
289  IO &IO, COFF::DLLCharacteristics &Value) {
301 }
302 #undef BCase
303 
304 namespace {
305 
306 struct NSectionSelectionType {
307  NSectionSelectionType(IO &)
309  NSectionSelectionType(IO &, uint8_t C)
311 
312  uint8_t denormalize(IO &) { return SelectionType; }
313 
315 };
316 
317 struct NWeakExternalCharacteristics {
318  NWeakExternalCharacteristics(IO &)
320  NWeakExternalCharacteristics(IO &, uint32_t C)
322 
323  uint32_t denormalize(IO &) { return Characteristics; }
324 
326 };
327 
328 struct NSectionCharacteristics {
329  NSectionCharacteristics(IO &)
331  NSectionCharacteristics(IO &, uint32_t C)
333 
334  uint32_t denormalize(IO &) { return Characteristics; }
335 
337 };
338 
339 struct NAuxTokenType {
340  NAuxTokenType(IO &)
342  NAuxTokenType(IO &, uint8_t C)
344 
345  uint32_t denormalize(IO &) { return AuxType; }
346 
348 };
349 
350 struct NStorageClass {
351  NStorageClass(IO &) : StorageClass(COFF::SymbolStorageClass(0)) {}
352  NStorageClass(IO &, uint8_t S) : StorageClass(COFF::SymbolStorageClass(S)) {}
353 
354  uint8_t denormalize(IO &) { return StorageClass; }
355 
357 };
358 
359 struct NMachine {
360  NMachine(IO &) : Machine(COFF::MachineTypes(0)) {}
361  NMachine(IO &, uint16_t M) : Machine(COFF::MachineTypes(M)) {}
362 
363  uint16_t denormalize(IO &) { return Machine; }
364 
366 };
367 
368 struct NHeaderCharacteristics {
369  NHeaderCharacteristics(IO &) : Characteristics(COFF::Characteristics(0)) {}
370  NHeaderCharacteristics(IO &, uint16_t C)
372 
373  uint16_t denormalize(IO &) { return Characteristics; }
374 
376 };
377 
378 template <typename RelocType>
379 struct NType {
380  NType(IO &) : Type(RelocType(0)) {}
381  NType(IO &, uint16_t T) : Type(RelocType(T)) {}
382 
383  uint16_t denormalize(IO &) { return Type; }
384 
385  RelocType Type;
386 };
387 
388 struct NWindowsSubsystem {
389  NWindowsSubsystem(IO &) : Subsystem(COFF::WindowsSubsystem(0)) {}
390  NWindowsSubsystem(IO &, uint16_t C) : Subsystem(COFF::WindowsSubsystem(C)) {}
391 
392  uint16_t denormalize(IO &) { return Subsystem; }
393 
395 };
396 
397 struct NDLLCharacteristics {
398  NDLLCharacteristics(IO &) : Characteristics(COFF::DLLCharacteristics(0)) {}
399  NDLLCharacteristics(IO &, uint16_t C)
401 
402  uint16_t denormalize(IO &) { return Characteristics; }
403 
405 };
406 
407 } // end anonymous namespace
408 
410  COFFYAML::Relocation &Rel) {
411  IO.mapRequired("VirtualAddress", Rel.VirtualAddress);
412  IO.mapOptional("SymbolName", Rel.SymbolName, StringRef());
413  IO.mapOptional("SymbolTableIndex", Rel.SymbolTableIndex);
414 
415  COFF::header &H = *static_cast<COFF::header *>(IO.getContext());
417  MappingNormalization<NType<COFF::RelocationTypeI386>, uint16_t> NT(
418  IO, Rel.Type);
419  IO.mapRequired("Type", NT->Type);
420  } else if (H.Machine == COFF::IMAGE_FILE_MACHINE_AMD64) {
421  MappingNormalization<NType<COFF::RelocationTypeAMD64>, uint16_t> NT(
422  IO, Rel.Type);
423  IO.mapRequired("Type", NT->Type);
424  } else if (H.Machine == COFF::IMAGE_FILE_MACHINE_ARMNT) {
425  MappingNormalization<NType<COFF::RelocationTypesARM>, uint16_t> NT(
426  IO, Rel.Type);
427  IO.mapRequired("Type", NT->Type);
428  } else if (H.Machine == COFF::IMAGE_FILE_MACHINE_ARM64) {
429  MappingNormalization<NType<COFF::RelocationTypesARM64>, uint16_t> NT(
430  IO, Rel.Type);
431  IO.mapRequired("Type", NT->Type);
432  } else {
433  IO.mapRequired("Type", Rel.Type);
434  }
435 }
436 
438  COFF::DataDirectory &DD) {
439  IO.mapRequired("RelativeVirtualAddress", DD.RelativeVirtualAddress);
440  IO.mapRequired("Size", DD.Size);
441 }
442 
444  COFFYAML::PEHeader &PH) {
445  MappingNormalization<NWindowsSubsystem, uint16_t> NWS(IO,
446  PH.Header.Subsystem);
447  MappingNormalization<NDLLCharacteristics, uint16_t> NDC(
448  IO, PH.Header.DLLCharacteristics);
449 
450  IO.mapRequired("AddressOfEntryPoint", PH.Header.AddressOfEntryPoint);
451  IO.mapRequired("ImageBase", PH.Header.ImageBase);
452  IO.mapRequired("SectionAlignment", PH.Header.SectionAlignment);
453  IO.mapRequired("FileAlignment", PH.Header.FileAlignment);
454  IO.mapRequired("MajorOperatingSystemVersion",
456  IO.mapRequired("MinorOperatingSystemVersion",
458  IO.mapRequired("MajorImageVersion", PH.Header.MajorImageVersion);
459  IO.mapRequired("MinorImageVersion", PH.Header.MinorImageVersion);
460  IO.mapRequired("MajorSubsystemVersion", PH.Header.MajorSubsystemVersion);
461  IO.mapRequired("MinorSubsystemVersion", PH.Header.MinorSubsystemVersion);
462  IO.mapRequired("Subsystem", NWS->Subsystem);
463  IO.mapRequired("DLLCharacteristics", NDC->Characteristics);
464  IO.mapRequired("SizeOfStackReserve", PH.Header.SizeOfStackReserve);
465  IO.mapRequired("SizeOfStackCommit", PH.Header.SizeOfStackCommit);
466  IO.mapRequired("SizeOfHeapReserve", PH.Header.SizeOfHeapReserve);
467  IO.mapRequired("SizeOfHeapCommit", PH.Header.SizeOfHeapCommit);
468 
469  IO.mapOptional("ExportTable", PH.DataDirectories[COFF::EXPORT_TABLE]);
470  IO.mapOptional("ImportTable", PH.DataDirectories[COFF::IMPORT_TABLE]);
471  IO.mapOptional("ResourceTable", PH.DataDirectories[COFF::RESOURCE_TABLE]);
472  IO.mapOptional("ExceptionTable", PH.DataDirectories[COFF::EXCEPTION_TABLE]);
473  IO.mapOptional("CertificateTable", PH.DataDirectories[COFF::CERTIFICATE_TABLE]);
474  IO.mapOptional("BaseRelocationTable",
476  IO.mapOptional("Debug", PH.DataDirectories[COFF::DEBUG_DIRECTORY]);
477  IO.mapOptional("Architecture", PH.DataDirectories[COFF::ARCHITECTURE]);
478  IO.mapOptional("GlobalPtr", PH.DataDirectories[COFF::GLOBAL_PTR]);
479  IO.mapOptional("TlsTable", PH.DataDirectories[COFF::TLS_TABLE]);
480  IO.mapOptional("LoadConfigTable",
482  IO.mapOptional("BoundImport", PH.DataDirectories[COFF::BOUND_IMPORT]);
483  IO.mapOptional("IAT", PH.DataDirectories[COFF::IAT]);
484  IO.mapOptional("DelayImportDescriptor",
486  IO.mapOptional("ClrRuntimeHeader",
488 }
489 
491  MappingNormalization<NMachine, uint16_t> NM(IO, H.Machine);
492  MappingNormalization<NHeaderCharacteristics, uint16_t> NC(IO,
493  H.Characteristics);
494 
495  IO.mapRequired("Machine", NM->Machine);
496  IO.mapOptional("Characteristics", NC->Characteristics);
497  IO.setContext(static_cast<void *>(&H));
498 }
499 
501  IO &IO, COFF::AuxiliaryFunctionDefinition &AFD) {
502  IO.mapRequired("TagIndex", AFD.TagIndex);
503  IO.mapRequired("TotalSize", AFD.TotalSize);
504  IO.mapRequired("PointerToLinenumber", AFD.PointerToLinenumber);
505  IO.mapRequired("PointerToNextFunction", AFD.PointerToNextFunction);
506 }
507 
509  IO &IO, COFF::AuxiliarybfAndefSymbol &AAS) {
510  IO.mapRequired("Linenumber", AAS.Linenumber);
511  IO.mapRequired("PointerToNextFunction", AAS.PointerToNextFunction);
512 }
513 
515  IO &IO, COFF::AuxiliaryWeakExternal &AWE) {
516  MappingNormalization<NWeakExternalCharacteristics, uint32_t> NWEC(
517  IO, AWE.Characteristics);
518  IO.mapRequired("TagIndex", AWE.TagIndex);
519  IO.mapRequired("Characteristics", NWEC->Characteristics);
520 }
521 
523  IO &IO, COFF::AuxiliarySectionDefinition &ASD) {
524  MappingNormalization<NSectionSelectionType, uint8_t> NSST(
525  IO, ASD.Selection);
526 
527  IO.mapRequired("Length", ASD.Length);
528  IO.mapRequired("NumberOfRelocations", ASD.NumberOfRelocations);
529  IO.mapRequired("NumberOfLinenumbers", ASD.NumberOfLinenumbers);
530  IO.mapRequired("CheckSum", ASD.CheckSum);
531  IO.mapRequired("Number", ASD.Number);
532  IO.mapOptional("Selection", NSST->SelectionType, COFFYAML::COMDATType(0));
533 }
534 
536  IO &IO, COFF::AuxiliaryCLRToken &ACT) {
537  MappingNormalization<NAuxTokenType, uint8_t> NATT(IO, ACT.AuxType);
538  IO.mapRequired("AuxType", NATT->AuxType);
539  IO.mapRequired("SymbolTableIndex", ACT.SymbolTableIndex);
540 }
541 
543  MappingNormalization<NStorageClass, uint8_t> NS(IO, S.Header.StorageClass);
544 
545  IO.mapRequired("Name", S.Name);
546  IO.mapRequired("Value", S.Header.Value);
547  IO.mapRequired("SectionNumber", S.Header.SectionNumber);
548  IO.mapRequired("SimpleType", S.SimpleType);
549  IO.mapRequired("ComplexType", S.ComplexType);
550  IO.mapRequired("StorageClass", NS->StorageClass);
551  IO.mapOptional("FunctionDefinition", S.FunctionDefinition);
552  IO.mapOptional("bfAndefSymbol", S.bfAndefSymbol);
553  IO.mapOptional("WeakExternal", S.WeakExternal);
554  IO.mapOptional("File", S.File, StringRef());
555  IO.mapOptional("SectionDefinition", S.SectionDefinition);
556  IO.mapOptional("CLRToken", S.CLRToken);
557 }
558 
560  MappingNormalization<NSectionCharacteristics, uint32_t> NC(
561  IO, Sec.Header.Characteristics);
562  IO.mapRequired("Name", Sec.Name);
563  IO.mapRequired("Characteristics", NC->Characteristics);
564  IO.mapOptional("VirtualAddress", Sec.Header.VirtualAddress, 0U);
565  IO.mapOptional("VirtualSize", Sec.Header.VirtualSize, 0U);
566  IO.mapOptional("Alignment", Sec.Alignment, 0U);
567 
568  // If this is a .debug$S .debug$T .debug$P, or .debug$H section parse the
569  // semantic representation of the symbols/types. If it is any other kind
570  // of section, just deal in raw bytes.
571  IO.mapOptional("SectionData", Sec.SectionData);
572  if (Sec.Name == ".debug$S")
573  IO.mapOptional("Subsections", Sec.DebugS);
574  else if (Sec.Name == ".debug$T")
575  IO.mapOptional("Types", Sec.DebugT);
576  else if (Sec.Name == ".debug$P")
577  IO.mapOptional("PrecompTypes", Sec.DebugP);
578  else if (Sec.Name == ".debug$H")
579  IO.mapOptional("GlobalHashes", Sec.DebugH);
580 
581  // Uninitialized sections, such as .bss, typically have no data, but the size
582  // is carried in SizeOfRawData, even though PointerToRawData is zero.
583  if (Sec.SectionData.binary_size() == 0 &&
584  NC->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA)
585  IO.mapOptional("SizeOfRawData", Sec.Header.SizeOfRawData);
586 
587  IO.mapOptional("Relocations", Sec.Relocations);
588 }
589 
591  IO.mapTag("!COFF", true);
592  IO.mapOptional("OptionalHeader", Obj.OptionalHeader);
593  IO.mapRequired("header", Obj.Header);
594  IO.mapRequired("sections", Obj.Sections);
595  IO.mapRequired("symbols", Obj.Symbols);
596 }
597 
598 } // end namespace yaml
599 
600 } // end namespace llvm
Debugging info has been removed.
Definition: COFF.h:147
uint64_t CallInst * C
COFF::section Header
Definition: COFFYAML.h:70
Isolation aware, but do not isolate the image.
Definition: COFF.h:629
The Windows GUI subsystem.
Definition: COFF.h:603
SymbolBaseType
Definition: COFF.h:239
The POSIX character subsystem.
Definition: COFF.h:606
COFF::PE32Header Header
Definition: COFFYAML.h:99
WeakExternalCharacteristics
Definition: COFF.h:438
COFF::SymbolBaseType SimpleType
Definition: COFFYAML.h:85
This class represents lattice values for constants.
Definition: AllocatorList.h:23
int32_t SectionNumber
Definition: COFF.h:190
uint32_t Value
Definition: COFF.h:189
uint32_t SizeOfRawData
Definition: COFF.h:274
Physical end of function.
Definition: COFF.h:206
The image file is a DLL.
Definition: COFF.h:155
An EFI ROM image.
Definition: COFF.h:614
Optional< COFF::AuxiliarybfAndefSymbol > bfAndefSymbol
Definition: COFFYAML.h:88
uint32_t SectionAlignment
Definition: COFF.h:551
RelocationTypeI386
Definition: COFF.h:330
COFF::symbol Header
Definition: COFFYAML.h:84
uint32_t SizeOfHeapReserve
Definition: COFF.h:568
AuxSymbolType
Definition: COFF.h:268
Used with void pointers and functions.
Definition: COFF.h:241
An EFI driver with boot services.
Definition: COFF.h:610
Code integrity checks are enforced.
Definition: COFF.h:625
COFF::SymbolStorageClass StorageClass
Definition: COFFYAML.cpp:356
No complex type; simple scalar variable.
Definition: COFF.h:259
A pointer to base type.
Definition: COFF.h:260
uint16_t Machine
Definition: COFF.h:66
WindowsSubsystem
Definition: COFF.h:600
uint32_t ImageBase
Definition: COFF.h:550
uint16_t MinorSubsystemVersion
Definition: COFF.h:558
An unsigned integer of natural size.
Definition: COFF.h:254
COFF::header Header
Definition: COFFYAML.h:105
uint16_t Characteristics
Definition: COFF.h:72
MachineTypes
Definition: COFF.h:93
Machine is based on a 32bit word architecture.
Definition: COFF.h:145
".bf" or ".ef" - beginning or end of function
Definition: COFF.h:229
An 8-byte floating-point number.
Definition: COFF.h:247
uint32_t SizeOfStackReserve
Definition: COFF.h:566
std::vector< Relocation > Relocations
Definition: COFFYAML.h:77
Aggressively trim working set. This is deprecated and must be 0.
Definition: COFF.h:138
DLLCharacteristics
Definition: COFF.h:619
uint32_t FileAlignment
Definition: COFF.h:552
uint16_t MajorOperatingSystemVersion
Definition: COFF.h:553
RelocationTypesARM64
Definition: COFF.h:384
An unsigned 4-byte integer.
Definition: COFF.h:255
External symbol in dmert public lib.
Definition: COFF.h:236
std::vector< Section > Sections
Definition: COFFYAML.h:106
Big endian: the MSB precedes the LSB in memory.
Definition: COFF.h:160
ASLR with 64 bit address space.
Definition: COFF.h:621
COFFYAML::COMDATType SelectionType
Definition: COFFYAML.cpp:314
The file does not contain base relocations and must be loaded at its preferred base.
Definition: COFF.h:128
uint32_t AddressOfEntryPoint
Definition: COFF.h:547
COFF::MachineTypes Machine
Definition: COFFYAML.cpp:365
Does not use structured exception handling (SEH).
Definition: COFF.h:632
uint32_t SizeOfHeapCommit
Definition: COFF.h:569
SectionCharacteristics
Definition: COFF.h:283
RelocationTypeAMD64
Definition: COFF.h:344
std::vector< CodeViewYAML::LeafRecord > DebugP
Definition: COFFYAML.h:75
uint16_t MinorOperatingSystemVersion
Definition: COFF.h:554
COFF::WindowsSubsystem Subsystem
Definition: COFFYAML.cpp:394
Image can handle > 2GiB addresses.
Definition: COFF.h:140
Line number, reformatted as symbol.
Definition: COFF.h:233
#define ECase(X)
Definition: COFFYAML.cpp:19
#define H(x, y, z)
Definition: MD5.cpp:57
An array of base type.
Definition: COFF.h:262
Member of enumeration.
Definition: COFF.h:223
Register variable.
Definition: COFF.h:211
No type information or unknown base type.
Definition: COFF.h:240
uint16_t Subsystem
Definition: COFF.h:563
uint16_t DLLCharacteristics
Definition: COFF.h:565
Little endian: the LSB precedes the MSB in memory.
Definition: COFF.h:143
A member of enumeration (a specific value).
Definition: COFF.h:251
Native Windows 9x driver.
Definition: COFF.h:607
uint32_t VirtualAddress
Definition: COFF.h:273
COFF line numbers have been stripped.
Definition: COFF.h:133
Device drivers and native Windows processes.
Definition: COFF.h:602
uint16_t MajorSubsystemVersion
Definition: COFF.h:557
ArrayRef< uint8_t >::size_type binary_size() const
The number of bytes that are represented by this BinaryRef.
Definition: YAML.h:80
Characteristics
Definition: COFF.h:123
yaml::BinaryRef SectionData
Definition: COFFYAML.h:72
The image file is a system file, not a user program.
Definition: COFF.h:153
Optional< COFF::AuxiliaryFunctionDefinition > FunctionDefinition
Definition: COFFYAML.h:87
COFFYAML::AuxSymbolType AuxType
Definition: COFFYAML.cpp:347
std::vector< CodeViewYAML::LeafRecord > DebugT
Definition: COFFYAML.h:74
A 4-byte signed integer.
Definition: COFF.h:245
Optional< COFF::AuxiliaryCLRToken > CLRToken
Definition: COFFYAML.h:92
Image supports Control Flow Guard.
Definition: COFF.h:638
An enumerated type.
Definition: COFF.h:250
#define NC
Definition: regutils.h:42
An EFI driver with run-time services.
Definition: COFF.h:612
uint32_t RelativeVirtualAddress
Definition: COFF.h:576
uint32_t VirtualSize
Definition: COFF.h:272
COMDATType
Definition: COFF.h:405
SymbolStorageClass
Storage class tells where and what the symbol represents.
Definition: COFF.h:203
".bb" or ".eb" - beginning or end of block
Definition: COFF.h:227
A 2-byte signed integer.
Definition: COFF.h:243
A byte; unsigned 1-byte integer.
Definition: COFF.h:252
Function argument.
Definition: COFF.h:216
If the image is on removable media, fully load it and copy it to swap.
Definition: COFF.h:149
Optional< COFF::DataDirectory > DataDirectories[COFF::NUM_DATA_DIRECTORIES]
Definition: COFFYAML.h:100
If the image is on network media, fully load it and copy it to swap.
Definition: COFF.h:151
The file is valid and can be run.
Definition: COFF.h:130
A natural integer type on the target.
Definition: COFF.h:244
The OS/2 character subsytem.
Definition: COFF.h:605
COFF symbol table entries for local symbols have been removed.
Definition: COFF.h:136
DLL can be relocated at load time.
Definition: COFF.h:623
Optional< COFF::AuxiliaryWeakExternal > WeakExternal
Definition: COFFYAML.h:89
COFFYAML::WeakExternalCharacteristics Characteristics
Definition: COFFYAML.cpp:325
This file should only be run on a uniprocessor machine.
Definition: COFF.h:157
RelocationTypesARM
Definition: COFF.h:364
A 4-byte floating-point number.
Definition: COFF.h:246
A word; unsigned 2-byte integer.
Definition: COFF.h:253
An unknown subsystem.
Definition: COFF.h:601
uint32_t SizeOfStackCommit
Definition: COFF.h:567
The Windows character subsystem.
Definition: COFF.h:604
uint8_t StorageClass
Definition: COFF.h:192
std::vector< CodeViewYAML::YAMLDebugSubsection > DebugS
Definition: COFFYAML.h:73
uint16_t MinorImageVersion
Definition: COFF.h:556
Optional< uint32_t > SymbolTableIndex
Definition: COFFYAML.h:66
LLVM Value Representation.
Definition: Value.h:74
std::vector< Symbol > Symbols
Definition: COFFYAML.h:107
A character (signed byte).
Definition: COFF.h:242
uint16_t MajorImageVersion
Definition: COFF.h:555
SymbolComplexType
Definition: COFF.h:258
#define BCase(X)
Definition: COFFYAML.cpp:242
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
COFF::SymbolComplexType ComplexType
Definition: COFFYAML.h:86
Optional< CodeViewYAML::DebugHSection > DebugH
Definition: COFFYAML.h:76
Optional< PEHeader > OptionalHeader
Definition: COFFYAML.h:104
uint32_t Characteristics
Definition: COFF.h:280
Optional< COFF::AuxiliarySectionDefinition > SectionDefinition
Definition: COFFYAML.h:91
A function that returns a base type.
Definition: COFF.h:261