LLVM  7.0.0svn
COFFYAML.cpp
Go to the documentation of this file.
1 //===- COFFYAML.cpp - COFF YAMLIO implementation --------------------------===//
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 defines classes for handling the YAML representation of COFF.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/ADT/StringRef.h"
17 #include <cstdint>
18 #include <cstring>
19 
20 #define ECase(X) IO.enumCase(Value, #X, COFF::X);
21 
22 namespace llvm {
23 
24 namespace COFFYAML {
25 
26 Section::Section() { memset(&Header, 0, sizeof(COFF::section)); }
27 Symbol::Symbol() { memset(&Header, 0, sizeof(COFF::symbol)); }
28 Object::Object() { memset(&Header, 0, sizeof(COFF::header)); }
29 
30 } // end namespace COFFYAML
31 
32 namespace yaml {
33 
34 void ScalarEnumerationTraits<COFFYAML::COMDATType>::enumeration(
35  IO &IO, COFFYAML::COMDATType &Value) {
36  IO.enumCase(Value, "0", 0);
44 }
45 
46 void
47 ScalarEnumerationTraits<COFFYAML::WeakExternalCharacteristics>::enumeration(
49  IO.enumCase(Value, "0", 0);
53 }
54 
55 void ScalarEnumerationTraits<COFFYAML::AuxSymbolType>::enumeration(
56  IO &IO, COFFYAML::AuxSymbolType &Value) {
58 }
59 
60 void ScalarEnumerationTraits<COFF::MachineTypes>::enumeration(
61  IO &IO, COFF::MachineTypes &Value) {
84 }
85 
86 void ScalarEnumerationTraits<COFF::SymbolBaseType>::enumeration(
87  IO &IO, COFF::SymbolBaseType &Value) {
104 }
105 
106 void ScalarEnumerationTraits<COFF::SymbolStorageClass>::enumeration(
107  IO &IO, COFF::SymbolStorageClass &Value) {
135 }
136 
137 void ScalarEnumerationTraits<COFF::SymbolComplexType>::enumeration(
138  IO &IO, COFF::SymbolComplexType &Value) {
143 }
144 
145 void ScalarEnumerationTraits<COFF::RelocationTypeI386>::enumeration(
146  IO &IO, COFF::RelocationTypeI386 &Value) {
158 }
159 
160 void ScalarEnumerationTraits<COFF::RelocationTypeAMD64>::enumeration(
161  IO &IO, COFF::RelocationTypeAMD64 &Value) {
179 }
180 
181 void ScalarEnumerationTraits<COFF::RelocationTypesARM>::enumeration(
182  IO &IO, COFF::RelocationTypesARM &Value) {
198 }
199 
200 void ScalarEnumerationTraits<COFF::RelocationTypesARM64>::enumeration(
219 }
220 
221 void ScalarEnumerationTraits<COFF::WindowsSubsystem>::enumeration(
222  IO &IO, COFF::WindowsSubsystem &Value) {
237 }
238 #undef ECase
239 
240 #define BCase(X) IO.bitSetCase(Value, #X, COFF::X);
241 void ScalarBitSetTraits<COFF::Characteristics>::bitset(
242  IO &IO, COFF::Characteristics &Value) {
258 }
259 
260 void ScalarBitSetTraits<COFF::SectionCharacteristics>::bitset(
284 }
285 
286 void ScalarBitSetTraits<COFF::DLLCharacteristics>::bitset(
287  IO &IO, COFF::DLLCharacteristics &Value) {
299 }
300 #undef BCase
301 
302 namespace {
303 
304 struct NSectionSelectionType {
305  NSectionSelectionType(IO &)
307  NSectionSelectionType(IO &, uint8_t C)
309 
310  uint8_t denormalize(IO &) { return SelectionType; }
311 
313 };
314 
315 struct NWeakExternalCharacteristics {
316  NWeakExternalCharacteristics(IO &)
318  NWeakExternalCharacteristics(IO &, uint32_t C)
320 
321  uint32_t denormalize(IO &) { return Characteristics; }
322 
324 };
325 
326 struct NSectionCharacteristics {
327  NSectionCharacteristics(IO &)
329  NSectionCharacteristics(IO &, uint32_t C)
331 
332  uint32_t denormalize(IO &) { return Characteristics; }
333 
335 };
336 
337 struct NAuxTokenType {
338  NAuxTokenType(IO &)
340  NAuxTokenType(IO &, uint8_t C)
342 
343  uint32_t denormalize(IO &) { return AuxType; }
344 
346 };
347 
348 struct NStorageClass {
349  NStorageClass(IO &) : StorageClass(COFF::SymbolStorageClass(0)) {}
350  NStorageClass(IO &, uint8_t S) : StorageClass(COFF::SymbolStorageClass(S)) {}
351 
352  uint8_t denormalize(IO &) { return StorageClass; }
353 
355 };
356 
357 struct NMachine {
358  NMachine(IO &) : Machine(COFF::MachineTypes(0)) {}
359  NMachine(IO &, uint16_t M) : Machine(COFF::MachineTypes(M)) {}
360 
361  uint16_t denormalize(IO &) { return Machine; }
362 
364 };
365 
366 struct NHeaderCharacteristics {
367  NHeaderCharacteristics(IO &) : Characteristics(COFF::Characteristics(0)) {}
368  NHeaderCharacteristics(IO &, uint16_t C)
370 
371  uint16_t denormalize(IO &) { return Characteristics; }
372 
374 };
375 
376 template <typename RelocType>
377 struct NType {
378  NType(IO &) : Type(RelocType(0)) {}
379  NType(IO &, uint16_t T) : Type(RelocType(T)) {}
380 
381  uint16_t denormalize(IO &) { return Type; }
382 
383  RelocType Type;
384 };
385 
386 struct NWindowsSubsystem {
387  NWindowsSubsystem(IO &) : Subsystem(COFF::WindowsSubsystem(0)) {}
388  NWindowsSubsystem(IO &, uint16_t C) : Subsystem(COFF::WindowsSubsystem(C)) {}
389 
390  uint16_t denormalize(IO &) { return Subsystem; }
391 
393 };
394 
395 struct NDLLCharacteristics {
396  NDLLCharacteristics(IO &) : Characteristics(COFF::DLLCharacteristics(0)) {}
397  NDLLCharacteristics(IO &, uint16_t C)
399 
400  uint16_t denormalize(IO &) { return Characteristics; }
401 
403 };
404 
405 } // end anonymous namespace
406 
408  COFFYAML::Relocation &Rel) {
409  IO.mapRequired("VirtualAddress", Rel.VirtualAddress);
410  IO.mapRequired("SymbolName", Rel.SymbolName);
411 
412  COFF::header &H = *static_cast<COFF::header *>(IO.getContext());
414  MappingNormalization<NType<COFF::RelocationTypeI386>, uint16_t> NT(
415  IO, Rel.Type);
416  IO.mapRequired("Type", NT->Type);
417  } else if (H.Machine == COFF::IMAGE_FILE_MACHINE_AMD64) {
418  MappingNormalization<NType<COFF::RelocationTypeAMD64>, uint16_t> NT(
419  IO, Rel.Type);
420  IO.mapRequired("Type", NT->Type);
421  } else if (H.Machine == COFF::IMAGE_FILE_MACHINE_ARMNT) {
422  MappingNormalization<NType<COFF::RelocationTypesARM>, uint16_t> NT(
423  IO, Rel.Type);
424  IO.mapRequired("Type", NT->Type);
425  } else if (H.Machine == COFF::IMAGE_FILE_MACHINE_ARM64) {
426  MappingNormalization<NType<COFF::RelocationTypesARM64>, uint16_t> NT(
427  IO, Rel.Type);
428  IO.mapRequired("Type", NT->Type);
429  } else {
430  IO.mapRequired("Type", Rel.Type);
431  }
432 }
433 
435  COFF::DataDirectory &DD) {
436  IO.mapRequired("RelativeVirtualAddress", DD.RelativeVirtualAddress);
437  IO.mapRequired("Size", DD.Size);
438 }
439 
441  COFFYAML::PEHeader &PH) {
442  MappingNormalization<NWindowsSubsystem, uint16_t> NWS(IO,
443  PH.Header.Subsystem);
444  MappingNormalization<NDLLCharacteristics, uint16_t> NDC(
445  IO, PH.Header.DLLCharacteristics);
446 
447  IO.mapRequired("AddressOfEntryPoint", PH.Header.AddressOfEntryPoint);
448  IO.mapRequired("ImageBase", PH.Header.ImageBase);
449  IO.mapRequired("SectionAlignment", PH.Header.SectionAlignment);
450  IO.mapRequired("FileAlignment", PH.Header.FileAlignment);
451  IO.mapRequired("MajorOperatingSystemVersion",
453  IO.mapRequired("MinorOperatingSystemVersion",
455  IO.mapRequired("MajorImageVersion", PH.Header.MajorImageVersion);
456  IO.mapRequired("MinorImageVersion", PH.Header.MinorImageVersion);
457  IO.mapRequired("MajorSubsystemVersion", PH.Header.MajorSubsystemVersion);
458  IO.mapRequired("MinorSubsystemVersion", PH.Header.MinorSubsystemVersion);
459  IO.mapRequired("Subsystem", NWS->Subsystem);
460  IO.mapRequired("DLLCharacteristics", NDC->Characteristics);
461  IO.mapRequired("SizeOfStackReserve", PH.Header.SizeOfStackReserve);
462  IO.mapRequired("SizeOfStackCommit", PH.Header.SizeOfStackCommit);
463  IO.mapRequired("SizeOfHeapReserve", PH.Header.SizeOfHeapReserve);
464  IO.mapRequired("SizeOfHeapCommit", PH.Header.SizeOfHeapCommit);
465 
466  IO.mapOptional("ExportTable", PH.DataDirectories[COFF::EXPORT_TABLE]);
467  IO.mapOptional("ImportTable", PH.DataDirectories[COFF::IMPORT_TABLE]);
468  IO.mapOptional("ResourceTable", PH.DataDirectories[COFF::RESOURCE_TABLE]);
469  IO.mapOptional("ExceptionTable", PH.DataDirectories[COFF::EXCEPTION_TABLE]);
470  IO.mapOptional("CertificateTable", PH.DataDirectories[COFF::CERTIFICATE_TABLE]);
471  IO.mapOptional("BaseRelocationTable",
473  IO.mapOptional("Debug", PH.DataDirectories[COFF::DEBUG_DIRECTORY]);
474  IO.mapOptional("Architecture", PH.DataDirectories[COFF::ARCHITECTURE]);
475  IO.mapOptional("GlobalPtr", PH.DataDirectories[COFF::GLOBAL_PTR]);
476  IO.mapOptional("TlsTable", PH.DataDirectories[COFF::TLS_TABLE]);
477  IO.mapOptional("LoadConfigTable",
479  IO.mapOptional("BoundImport", PH.DataDirectories[COFF::BOUND_IMPORT]);
480  IO.mapOptional("IAT", PH.DataDirectories[COFF::IAT]);
481  IO.mapOptional("DelayImportDescriptor",
483  IO.mapOptional("ClrRuntimeHeader",
485 }
486 
488  MappingNormalization<NMachine, uint16_t> NM(IO, H.Machine);
489  MappingNormalization<NHeaderCharacteristics, uint16_t> NC(IO,
490  H.Characteristics);
491 
492  IO.mapRequired("Machine", NM->Machine);
493  IO.mapOptional("Characteristics", NC->Characteristics);
494  IO.setContext(static_cast<void *>(&H));
495 }
496 
498  IO &IO, COFF::AuxiliaryFunctionDefinition &AFD) {
499  IO.mapRequired("TagIndex", AFD.TagIndex);
500  IO.mapRequired("TotalSize", AFD.TotalSize);
501  IO.mapRequired("PointerToLinenumber", AFD.PointerToLinenumber);
502  IO.mapRequired("PointerToNextFunction", AFD.PointerToNextFunction);
503 }
504 
506  IO &IO, COFF::AuxiliarybfAndefSymbol &AAS) {
507  IO.mapRequired("Linenumber", AAS.Linenumber);
508  IO.mapRequired("PointerToNextFunction", AAS.PointerToNextFunction);
509 }
510 
512  IO &IO, COFF::AuxiliaryWeakExternal &AWE) {
513  MappingNormalization<NWeakExternalCharacteristics, uint32_t> NWEC(
514  IO, AWE.Characteristics);
515  IO.mapRequired("TagIndex", AWE.TagIndex);
516  IO.mapRequired("Characteristics", NWEC->Characteristics);
517 }
518 
520  IO &IO, COFF::AuxiliarySectionDefinition &ASD) {
521  MappingNormalization<NSectionSelectionType, uint8_t> NSST(
522  IO, ASD.Selection);
523 
524  IO.mapRequired("Length", ASD.Length);
525  IO.mapRequired("NumberOfRelocations", ASD.NumberOfRelocations);
526  IO.mapRequired("NumberOfLinenumbers", ASD.NumberOfLinenumbers);
527  IO.mapRequired("CheckSum", ASD.CheckSum);
528  IO.mapRequired("Number", ASD.Number);
529  IO.mapOptional("Selection", NSST->SelectionType, COFFYAML::COMDATType(0));
530 }
531 
533  IO &IO, COFF::AuxiliaryCLRToken &ACT) {
534  MappingNormalization<NAuxTokenType, uint8_t> NATT(IO, ACT.AuxType);
535  IO.mapRequired("AuxType", NATT->AuxType);
536  IO.mapRequired("SymbolTableIndex", ACT.SymbolTableIndex);
537 }
538 
540  MappingNormalization<NStorageClass, uint8_t> NS(IO, S.Header.StorageClass);
541 
542  IO.mapRequired("Name", S.Name);
543  IO.mapRequired("Value", S.Header.Value);
544  IO.mapRequired("SectionNumber", S.Header.SectionNumber);
545  IO.mapRequired("SimpleType", S.SimpleType);
546  IO.mapRequired("ComplexType", S.ComplexType);
547  IO.mapRequired("StorageClass", NS->StorageClass);
548  IO.mapOptional("FunctionDefinition", S.FunctionDefinition);
549  IO.mapOptional("bfAndefSymbol", S.bfAndefSymbol);
550  IO.mapOptional("WeakExternal", S.WeakExternal);
551  IO.mapOptional("File", S.File, StringRef());
552  IO.mapOptional("SectionDefinition", S.SectionDefinition);
553  IO.mapOptional("CLRToken", S.CLRToken);
554 }
555 
557  MappingNormalization<NSectionCharacteristics, uint32_t> NC(
558  IO, Sec.Header.Characteristics);
559  IO.mapRequired("Name", Sec.Name);
560  IO.mapRequired("Characteristics", NC->Characteristics);
561  IO.mapOptional("VirtualAddress", Sec.Header.VirtualAddress, 0U);
562  IO.mapOptional("VirtualSize", Sec.Header.VirtualSize, 0U);
563  IO.mapOptional("Alignment", Sec.Alignment, 0U);
564 
565  // If this is a .debug$S .debug$T, or .debug$H section parse the semantic
566  // representation of the symbols/types. If it is any other kind of section,
567  // just deal in raw bytes.
568  IO.mapOptional("SectionData", Sec.SectionData);
569  if (Sec.Name == ".debug$S")
570  IO.mapOptional("Subsections", Sec.DebugS);
571  else if (Sec.Name == ".debug$T")
572  IO.mapOptional("Types", Sec.DebugT);
573  else if (Sec.Name == ".debug$H")
574  IO.mapOptional("GlobalHashes", Sec.DebugH);
575 
576  IO.mapOptional("Relocations", Sec.Relocations);
577 }
578 
580  IO.mapTag("!COFF", true);
581  IO.mapOptional("OptionalHeader", Obj.OptionalHeader);
582  IO.mapRequired("header", Obj.Header);
583  IO.mapRequired("sections", Obj.Sections);
584  IO.mapRequired("symbols", Obj.Symbols);
585 }
586 
587 } // end namespace yaml
588 
589 } // end namespace llvm
Debugging info has been removed.
Definition: COFF.h:148
uint64_t CallInst * C
COFF::section Header
Definition: COFFYAML.h:65
Isolation aware, but do not isolate the image.
Definition: COFF.h:627
The Windows GUI subsystem.
Definition: COFF.h:601
SymbolBaseType
Definition: COFF.h:240
The POSIX character subsystem.
Definition: COFF.h:604
COFF::PE32Header Header
Definition: COFFYAML.h:93
WeakExternalCharacteristics
Definition: COFF.h:436
COFF::SymbolBaseType SimpleType
Definition: COFFYAML.h:79
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
int32_t SectionNumber
Definition: COFF.h:191
uint32_t Value
Definition: COFF.h:190
Physical end of function.
Definition: COFF.h:207
The image file is a DLL.
Definition: COFF.h:156
An EFI ROM image.
Definition: COFF.h:612
Optional< COFF::AuxiliarybfAndefSymbol > bfAndefSymbol
Definition: COFFYAML.h:82
uint32_t SectionAlignment
Definition: COFF.h:549
RelocationTypeI386
Definition: COFF.h:331
COFF::symbol Header
Definition: COFFYAML.h:78
uint32_t SizeOfHeapReserve
Definition: COFF.h:566
AuxSymbolType
Definition: COFF.h:269
Used with void pointers and functions.
Definition: COFF.h:242
An EFI driver with boot services.
Definition: COFF.h:608
Code integrity checks are enforced.
Definition: COFF.h:623
COFF::SymbolStorageClass StorageClass
Definition: COFFYAML.cpp:354
No complex type; simple scalar variable.
Definition: COFF.h:260
A pointer to base type.
Definition: COFF.h:261
uint16_t Machine
Definition: COFF.h:67
WindowsSubsystem
Definition: COFF.h:598
uint32_t ImageBase
Definition: COFF.h:548
uint16_t MinorSubsystemVersion
Definition: COFF.h:556
An unsigned integer of natural size.
Definition: COFF.h:255
COFF::header Header
Definition: COFFYAML.h:99
uint16_t Characteristics
Definition: COFF.h:73
MachineTypes
Definition: COFF.h:94
Machine is based on a 32bit word architecture.
Definition: COFF.h:146
".bf" or ".ef" - beginning or end of function
Definition: COFF.h:230
An 8-byte floating-point number.
Definition: COFF.h:248
uint32_t SizeOfStackReserve
Definition: COFF.h:564
std::vector< Relocation > Relocations
Definition: COFFYAML.h:71
Aggressively trim working set. This is deprecated and must be 0.
Definition: COFF.h:139
DLLCharacteristics
Definition: COFF.h:617
uint32_t FileAlignment
Definition: COFF.h:550
uint16_t MajorOperatingSystemVersion
Definition: COFF.h:551
RelocationTypesARM64
Definition: COFF.h:383
An unsigned 4-byte integer.
Definition: COFF.h:256
External symbol in dmert public lib.
Definition: COFF.h:237
std::vector< Section > Sections
Definition: COFFYAML.h:100
Big endian: the MSB precedes the LSB in memory.
Definition: COFF.h:161
ASLR with 64 bit address space.
Definition: COFF.h:619
COFFYAML::COMDATType SelectionType
Definition: COFFYAML.cpp:312
The file does not contain base relocations and must be loaded at its preferred base.
Definition: COFF.h:129
uint32_t AddressOfEntryPoint
Definition: COFF.h:545
COFF::MachineTypes Machine
Definition: COFFYAML.cpp:363
Does not use structured exception handling (SEH).
Definition: COFF.h:630
uint32_t SizeOfHeapCommit
Definition: COFF.h:567
SectionCharacteristics
Definition: COFF.h:284
RelocationTypeAMD64
Definition: COFF.h:345
uint16_t MinorOperatingSystemVersion
Definition: COFF.h:552
COFF::WindowsSubsystem Subsystem
Definition: COFFYAML.cpp:392
Image can handle > 2GiB addresses.
Definition: COFF.h:141
Line number, reformatted as symbol.
Definition: COFF.h:234
#define ECase(X)
Definition: COFFYAML.cpp:20
#define H(x, y, z)
Definition: MD5.cpp:57
An array of base type.
Definition: COFF.h:263
Member of enumeration.
Definition: COFF.h:224
Register variable.
Definition: COFF.h:212
No type information or unknown base type.
Definition: COFF.h:241
uint16_t Subsystem
Definition: COFF.h:561
uint16_t DLLCharacteristics
Definition: COFF.h:563
Little endian: the LSB precedes the MSB in memory.
Definition: COFF.h:144
A member of enumeration (a specific value).
Definition: COFF.h:252
Native Windows 9x driver.
Definition: COFF.h:605
uint32_t VirtualAddress
Definition: COFF.h:274
COFF line numbers have been stripped.
Definition: COFF.h:134
Device drivers and native Windows processes.
Definition: COFF.h:600
uint16_t MajorSubsystemVersion
Definition: COFF.h:555
Characteristics
Definition: COFF.h:124
yaml::BinaryRef SectionData
Definition: COFFYAML.h:67
The image file is a system file, not a user program.
Definition: COFF.h:154
Optional< COFF::AuxiliaryFunctionDefinition > FunctionDefinition
Definition: COFFYAML.h:81
COFFYAML::AuxSymbolType AuxType
Definition: COFFYAML.cpp:345
std::vector< CodeViewYAML::LeafRecord > DebugT
Definition: COFFYAML.h:69
A 4-byte signed integer.
Definition: COFF.h:246
Optional< COFF::AuxiliaryCLRToken > CLRToken
Definition: COFFYAML.h:86
Image supports Control Flow Guard.
Definition: COFF.h:636
An enumerated type.
Definition: COFF.h:251
#define NC
Definition: regutils.h:42
An EFI driver with run-time services.
Definition: COFF.h:610
uint32_t RelativeVirtualAddress
Definition: COFF.h:574
uint32_t VirtualSize
Definition: COFF.h:273
SymbolStorageClass
Storage class tells where and what the symbol represents.
Definition: COFF.h:204
".bb" or ".eb" - beginning or end of block
Definition: COFF.h:228
A 2-byte signed integer.
Definition: COFF.h:244
A byte; unsigned 1-byte integer.
Definition: COFF.h:253
Function argument.
Definition: COFF.h:217
If the image is on removable media, fully load it and copy it to swap.
Definition: COFF.h:150
Optional< COFF::DataDirectory > DataDirectories[COFF::NUM_DATA_DIRECTORIES]
Definition: COFFYAML.h:94
If the image is on network media, fully load it and copy it to swap.
Definition: COFF.h:152
The file is valid and can be run.
Definition: COFF.h:131
A natural integer type on the target.
Definition: COFF.h:245
The OS/2 character subsytem.
Definition: COFF.h:603
COFF symbol table entries for local symbols have been removed.
Definition: COFF.h:137
DLL can be relocated at load time.
Definition: COFF.h:621
Optional< COFF::AuxiliaryWeakExternal > WeakExternal
Definition: COFFYAML.h:83
COFFYAML::WeakExternalCharacteristics Characteristics
Definition: COFFYAML.cpp:323
This file should only be run on a uniprocessor machine.
Definition: COFF.h:158
RelocationTypesARM
Definition: COFF.h:365
A 4-byte floating-point number.
Definition: COFF.h:247
A word; unsigned 2-byte integer.
Definition: COFF.h:254
An unknown subsystem.
Definition: COFF.h:599
COMDATType
Definition: COFF.h:403
uint32_t SizeOfStackCommit
Definition: COFF.h:565
The Windows character subsystem.
Definition: COFF.h:602
uint8_t StorageClass
Definition: COFF.h:193
std::vector< CodeViewYAML::YAMLDebugSubsection > DebugS
Definition: COFFYAML.h:68
uint16_t MinorImageVersion
Definition: COFF.h:554
LLVM Value Representation.
Definition: Value.h:73
std::vector< Symbol > Symbols
Definition: COFFYAML.h:101
A character (signed byte).
Definition: COFF.h:243
RelocType Type
Definition: COFFYAML.cpp:383
uint16_t MajorImageVersion
Definition: COFF.h:553
SymbolComplexType
Definition: COFF.h:259
#define BCase(X)
Definition: COFFYAML.cpp:240
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
COFF::SymbolComplexType ComplexType
Definition: COFFYAML.h:80
Optional< CodeViewYAML::DebugHSection > DebugH
Definition: COFFYAML.h:70
Optional< PEHeader > OptionalHeader
Definition: COFFYAML.h:98
uint32_t Characteristics
Definition: COFF.h:281
Optional< COFF::AuxiliarySectionDefinition > SectionDefinition
Definition: COFFYAML.h:85
A function that returns a base type.
Definition: COFF.h:262