[PDB] Print section contributions and section map

[zturner]

Summary

I'm not sure how to interpret either of these arrays, but at least we understand the format.

I suspect that the section map is used for determining RVAs of relocated fields, but I don't know how to do the calculation, and none of the fields of OMFSegMapDesc are documented in Microsoft headers (aside from printing their values, which is how I arrived at the layout) so the meaning is unclear.

[zturner]

So apparently entries in the SectionMap correspond to the symbols of type COFF Group and Section. For example, if you look at the Entry field in the section map which has Section=2, and then you go up to the Symbol section and look for all the COFF Group entries with Segment=2 and add up their lengths, you will see that they match. I'm still not sure what to use the fields of the section map entries for though. I assume those Flags are important, but unfortunately they are undocumented.

[zturner]

Also print out image section characteristics of the COFF Group and COFF Section symbols that appear in the modules' symbol tables.

[rnk]

include/llvm/DebugInfo/CodeView/EnumTables.h

28

These shouldn't live in headers, they'll be duplicated in all TUs that use them. Probably the best way to expose this would be to declare a function that returns an ArrayRef of register names, and then implement that in the .cpp file, given that we don't want to duplicate the size of the array in the header. Keep the prototypes in the SymbolDumper.h header.

include/llvm/DebugInfo/PDB/Raw/RawTypes.h

32

Is Contr short for Contribution? Maybe Contrib instead of Contr?

45

This isn't "standard layout" unfortunately:
http://en.cppreference.com/w/cpp/concept/StandardLayoutType

ASan actually has a mode that inserts additional padding between fields of non-standard layout types, but it was never productionized. Instead of using inheritance, I'd have the first member be the normal SectionContrib type.

[zturner]

Updated based on suggestions

[ruiu]

tools/llvm-pdbdump/llvm-pdbdump.cpp

143

section-contribs?

510

I'd do s/contr/contrib/g to all files in this patch.

519

Define this class outside of this function.

Also this class definition made me think of the visitor design choice. Currently visitor's callback is a class with visit() member function. But it can be just a std::function, no? We can create a lambda here and pass it to visitSectionContributions function.

540

Why do you have to call flush?

[zturner]

tools/llvm-pdbdump/llvm-pdbdump.cpp

510

A little tricky since that will catch Contrib too, but anyway I'll fix up the rest of the instances.

519

The problem is we don't know whether it will be called back with a SectionContrib or a SectionContrib2. If it were possible to make a "multi lambda" or something that supported overloads, then yes we could do that. Of course, I could raise the logic outside and use a switch statement, but in general I like the pattern of handling variant-data with a visitor.

Is there a reason to prefer defining the class outside the function? This is effectively a lambda with an overload, so just like your lambda would be scoped to the function, I wrote the class the same way.

540

Not strictly necessary, other dump functions do this as well, I guess because it's nice to be able to see the output in a debugger if you're stepping through

[ruiu]

tools/llvm-pdbdump/llvm-pdbdump.cpp

519

OK, if there's a chance for the class to have more than two callback functions, using a class makes sense to me. But currently it has only one callback function, so I'd do with a simple lambda rather than a class to avoid overdesining. I guess it's your call.

No particular reason to not avoid defining classes inside functions, but it is at least rather unusual in LLVM. If it is a deliberate choice and if you like this, it's OK to me.

[zturner]

tools/llvm-pdbdump/llvm-pdbdump.cpp

519

It already has 2 functions. visit is overloaded to take a const SectionContrib & and a const SectionContrib2 &. See below this function, where the overload delegates to this version of the function and then prints out additional data.

[zturner]

Figured out the flags and documented the field descriptions, also cleaned up enum tables and made them more consistent.

[rnk]

lgtm with nits

include/llvm/DebugInfo/PDB/Raw/DbiStream.h

74

s/Contr/Contrib/?

lib/DebugInfo/PDB/Raw/EnumTables.cpp

32–34

A less fragile way to do this is to declare it like:

ArrayRef<EnumEntry<uint16_t>> llvm::pdb::getOMFSegMapDescFlagNames() { ...

[ruiu]

LGTM

[majnemer]

test/DebugInfo/PDB/pdbdump-headers.test

1189

Can we pretty print these flags?

[zturner]

test/DebugInfo/PDB/pdbdump-headers.test

1189

Already done in this revision (see llvm-pdbdump.cpp), I just forgot to update the test. It's working locally.

[Eugene.Zelenko]

Committed in r271488.

include/llvm/DebugInfo/CodeView/EnumTables.h

+//===- EnumTables.h Enum to string conversion tables ------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_CODEVIEW_ENUMTABLES_H
+#define LLVM_DEBUGINFO_CODEVIEW_ENUMTABLES_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/DebugInfo/CodeView/CodeView.h"
+#include "llvm/Support/COFF.h"
+#include "llvm/Support/ScopedPrinter.h"
+
+#include <stdint.h>
+
+namespace llvm {
+namespace codeview {
+ArrayRef<EnumEntry<SymbolKind>> getSymbolTypeNames();
+ArrayRef<EnumEntry<uint16_t>> getRegisterNames();
+ArrayRef<EnumEntry<uint8_t>> getProcSymFlagNames();
+ArrayRef<EnumEntry<uint16_t>> getLocalFlagNames();
+ArrayRef<EnumEntry<uint32_t>> getFrameCookieKindNames();
+ArrayRef<EnumEntry<SourceLanguage>> getSourceLanguageNames();
+ArrayRef<EnumEntry<uint32_t>> getCompileSym2FlagNames();
+ArrayRef<EnumEntry<uint32_t>> getCompileSym3FlagNames();
+ArrayRef<EnumEntry<unsigned>> getCPUTypeNames();
+ArrayRef<EnumEntry<uint32_t>> getFrameProcSymFlagNames();
+ArrayRef<EnumEntry<uint16_t>> getExportSymFlagNames();
+ArrayRef<EnumEntry<uint8_t>> getThunkOrdinalNames();
+ArrayRef<EnumEntry<uint16_t>> getTrampolineNames();
+ArrayRef<EnumEntry<COFF::SectionCharacteristics>>
+getImageSectionCharacteristicNames();
+} // namespace codeview
+} // namespace llvm
+
+#endif // LLVM_DEBUGINFO_CODEVIEW_ENUMTABLES_H

include/llvm/DebugInfo/CodeView/StreamReader.h

public:
   Error readBytes(ArrayRef<uint8_t> &Buffer, uint32_t Size);
   Error readInteger(uint16_t &Dest);
   Error readInteger(uint32_t &Dest);
   Error readZeroString(StringRef &Dest);
   Error readFixedString(StringRef &Dest, uint32_t Length);
   Error readStreamRef(StreamRef &Ref);
   Error readStreamRef(StreamRef &Ref, uint32_t Length);
 
+  template <typename T> Error readEnum(T &Dest) {
+    typename std::underlying_type<T>::type N;
+    if (auto EC = readInteger(N))
+      return EC;
+    Dest = static_cast<T>(N);
+    return Error::success();
+  }
+
   template <typename T> Error readObject(const T *&Dest) {
     ArrayRef<uint8_t> Buffer;
     if (auto EC = readBytes(Buffer, sizeof(T)))
       return EC;
     Dest = reinterpret_cast<const T *>(Buffer.data());
     return Error::success();
   }
 

include/llvm/DebugInfo/PDB/Raw/DbiStream.h

 
 #include "llvm/DebugInfo/CodeView/StreamArray.h"
 #include "llvm/DebugInfo/CodeView/StreamRef.h"
 #include "llvm/DebugInfo/PDB/PDBTypes.h"
 #include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
 #include "llvm/DebugInfo/PDB/Raw/NameHashTable.h"
 #include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
+#include "llvm/DebugInfo/PDB/Raw/RawTypes.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace pdb {
 class PDBFile;
+class ISectionContribVisitor;
 
 class DbiStream {
   struct HeaderInfo;
 
 public:
   DbiStream(PDBFile &File);
   ~DbiStream();
   Error reload();
public:
   uint16_t getBuildMinorVersion() const;
 
   uint32_t getPdbDllVersion() const;
 
   uint32_t getSymRecordStreamIndex() const;
 
   PDB_Machine getMachineType() const;
 
+  uint32_t getDebugStreamIndex(DbgHeaderType Type) const;
+
   ArrayRef<ModuleInfoEx> modules() const;
 
-  uint32_t getDebugStreamIndex(DbgHeaderType Type) const;
+  codeview::FixedStreamArray<SecMapEntry> getSectionMap() const;
+  void visitSectionContributions(ISectionContribVisitor &Visitor) const;
 
 private:
+  Error initializeSectionContributionData();
+  Error initializeSectionMapData();
   Error initializeFileInfo();
 
   PDBFile &Pdb;
   MappedBlockStream Stream;
 
   std::vector<ModuleInfoEx> ModuleInfos;
   NameHashTable ECNames;
 
   codeview::StreamRef ModInfoSubstream;
   codeview::StreamRef SecContrSubstream;
   codeview::StreamRef SecMapSubstream;
   codeview::StreamRef FileInfoSubstream;
   codeview::StreamRef TypeServerMapSubstream;
   codeview::StreamRef ECSubstream;
 
   codeview::FixedStreamArray<support::ulittle16_t> DbgStreams;
 
+  PdbRaw_DbiSecContribVer SectionContribVersion;
+  codeview::FixedStreamArray<SectionContrib> SectionContribs;
+  codeview::FixedStreamArray<SectionContrib2> SectionContribs2;
+  codeview::FixedStreamArray<SecMapEntry> SectionMap;
+
   const HeaderInfo *Header;
 };
 }
 }
 
 #endif

include/llvm/DebugInfo/PDB/Raw/EnumTables.h

+//===- EnumTables.h - Enum to string conversion tables ----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_RAW_ENUMTABLES_H
+#define LLVM_DEBUGINFO_PDB_RAW_ENUMTABLES_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/ScopedPrinter.h"
+
+namespace llvm {
+namespace pdb {
+ArrayRef<EnumEntry<uint16_t>> getOMFSegMapDescFlagNames();
+}
+}
+
+#endif // LLVM_DEBUGINFO_PDB_RAW_ENUMTABLES_H

include/llvm/DebugInfo/PDB/Raw/ISectionContribVisitor.h

+//===- ISectionContribVisitor.h ---------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_RAW_ISECTIONCONTRIBVISITOR_H
+#define LLVM_DEBUGINFO_PDB_RAW_ISECTIONCONTRIBVISITOR_H
+
+namespace llvm {
+namespace pdb {
+struct SectionContrib;
+struct SectionContrib2;
+
+class ISectionContribVisitor {
+public:
+  virtual ~ISectionContribVisitor() {}
+
+  virtual void visit(const SectionContrib &C) = 0;
+  virtual void visit(const SectionContrib2 &C) = 0;
+};
+} // namespace pdb
+} // namespace llvm
+
+#endif // LLVM_DEBUGINFO_PDB_RAW_ISECTIONCONTRIBVISITOR_H

include/llvm/DebugInfo/PDB/Raw/PublicsStream.h

 #ifndef LLVM_DEBUGINFO_PDB_RAW_PUBLICSSTREAM_H
 #define LLVM_DEBUGINFO_PDB_RAW_PUBLICSSTREAM_H
 
 #include "llvm/DebugInfo/CodeView/StreamArray.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/PDB/PDBTypes.h"
 #include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
+#include "llvm/DebugInfo/PDB/Raw/RawTypes.h"
 
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace pdb {
 class DbiStream;
 class PDBFile;
 

include/llvm/DebugInfo/PDB/Raw/RawConstants.h

-//===- PDBRawConstants.h ----------------------------------------*- C++ -*-===//
+//===- RawConstants.h -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_RAW_PDBRAWCONSTANTS_H
 #define LLVM_DEBUGINFO_PDB_RAW_PDBRAWCONSTANTS_H
 
-#include "llvm/Support/Endian.h"
+#include "llvm/DebugInfo/CodeView/CodeView.h"
 
 #include <cstdint>
 
 namespace llvm {
 namespace pdb {
 
 enum PdbRaw_ImplVer : uint32_t {
   PdbImplVC2 = 19941610,

 enum PdbRaw_TpiVer : uint32_t {
   PdbTpiV40 = 19950410,
   PdbTpiV41 = 19951122,
   PdbTpiV50 = 19961031,
   PdbTpiV70 = 19990903,
   PdbTpiV80 = 20040203,
 };
 
+enum PdbRaw_DbiSecContribVer : uint32_t {
+  DbiSecContribVer60 = 0xeffe0000 + 19970605,
+  DbiSecContribV2 = 0xeffe0000 + 20140516
+};
+
 enum SpecialStream : uint32_t {
   // Stream 0 contains the copy of previous version of the MSF directory.
   // We are not currently using it, but technically if we find the main
   // MSF is corrupted, we could fallback to it.
   OldMSFDirectory = 0,
 
   StreamPDB = 1,
   StreamTPI = 2,
enum class DbgHeaderType : uint16_t {
   TokenRidMap,
   Xdata,
   Pdata,
   NewFPO,
   SectionHdrOrig,
   Max
 };
 
-// This struct is defined as "SO" in langapi/include/pdb.h.
-struct SectionOffset {
-  support::ulittle32_t Off;
-  support::ulittle16_t Isect;
-  char Padding[2];
-};
-
-// This is HRFile.
-struct PSHashRecord {
-  support::ulittle32_t Off; // Offset in the symbol record stream
-  support::ulittle32_t CRef;
+enum class OMFSegDescFlags : uint16_t {
+  Read = 1 << 0,              // Segment is readable.
+  Write = 1 << 1,             // Segment is writable.
+  Execute = 1 << 2,           // Segment is executable.
+  AddressIs32Bit = 1 << 3,    // Descriptor describes a 32-bit linear address.
+  IsSelector = 1 << 8,        // Frame represents a selector.
+  IsAbsoluteAddress = 1 << 9, // Frame represents an absolute address.
+  IsGroup = 1 << 10           // If set, descriptor represents a group.
 };
 
 } // end namespace pdb
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_RAW_PDBRAWCONSTANTS_H

include/llvm/DebugInfo/PDB/Raw/RawTypes.h

+//===- RawTypes.h -----------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_RAW_RAWTYPES_H
+#define LLVM_DEBUGINFO_PDB_RAW_RAWTYPES_H
+
+#include "llvm/Support/Endian.h"
+
+namespace llvm {
+namespace pdb {
+// This struct is defined as "SO" in langapi/include/pdb.h.
+struct SectionOffset {
+  support::ulittle32_t Off;
+  support::ulittle16_t Isect;
+  char Padding[2];
+};
+
+// This is HRFile.
+struct PSHashRecord {
+  support::ulittle32_t Off; // Offset in the symbol record stream
+  support::ulittle32_t CRef;
+};
+
+// This struct is defined as `SC` in include/dbicommon.h
+struct SectionContrib {
+  support::ulittle16_t ISect;
+  char Padding[2];
+  support::little32_t Off;
+  support::little32_t Size;
+  support::ulittle32_t Characteristics;
+  support::ulittle16_t Imod;
+  char Padding2[2];
+  support::ulittle32_t DataCrc;
+  support::ulittle32_t RelocCrc;
+};
+
+// This struct is defined as `SC2` in include/dbicommon.h
+struct SectionContrib2 {
+  // To guarantee SectionContrib2 is standard layout, we cannot use inheritance.
+  SectionContrib Base;
+  support::ulittle32_t ISectCoff;
+};
+
+// This corresponds to the `OMFSegMap` structure.
+struct SecMapHeader {
+  support::ulittle16_t SecCount;    // Number of segment descriptors in table
+  support::ulittle16_t SecCountLog; // Number of logical segment descriptors
+};
+
+// This corresponds to the `OMFSegMapDesc` structure.  The definition is not
+// present in the reference implementation, but the layout is derived from
+// code that accesses the fields.
+struct SecMapEntry {
+  support::ulittle16_t Flags; // Descriptor flags.  See OMFSegDescFlags
+  support::ulittle16_t Ovl;   // Logical overlay number.
+  support::ulittle16_t Group; // Group index into descriptor array.
+  support::ulittle16_t Frame;
+  support::ulittle16_t SecName;       // Byte index of the segment or group name
+                                      // in the sstSegName table, or 0xFFFF.
+  support::ulittle16_t ClassName;     // Byte index of the class name in the
+                                      // sstSegName table, or 0xFFFF.
+  support::ulittle32_t Offset;        // Byte offset of the logical segment
+                                      // within the specified physical segment.
+                                      // If group is set in flags, offset is the
+                                      // offset of the group.
+  support::ulittle32_t SecByteLength; // Byte count of the segment or group.
+};
+
+} // namespace pdb
+} // namespace llvm
+
+#endif

lib/DebugInfo/CodeView/CMakeLists.txt

 add_llvm_library(LLVMDebugInfoCodeView
   ByteStream.cpp
   CodeViewError.cpp
+  EnumTables.cpp
   FieldListRecordBuilder.cpp
   Line.cpp
   ListRecordBuilder.cpp
   MemoryTypeTableBuilder.cpp
   MethodListRecordBuilder.cpp
   RecordSerialization.cpp
   StreamReader.cpp
   SymbolDumper.cpp

lib/DebugInfo/CodeView/EnumTables.cpp

+//===- EnumTables.cpp - Enum to string conversion tables --------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/CodeView/EnumTables.h"
+
+using namespace llvm;
+using namespace codeview;
+
+#define CV_ENUM_CLASS_ENT(enum_class, enum)                                    \
+  { #enum, std::underlying_type < enum_class > ::type(enum_class::enum) }
+
+#define CV_ENUM_ENT(ns, enum)                                                  \
+  { #enum, ns::enum }
+
+static const EnumEntry<SymbolKind> SymbolTypeNames[] = {
+#define CV_SYMBOL(enum, val) {#enum, enum},
+#include "llvm/DebugInfo/CodeView/CVSymbolTypes.def"
+#undef CV_SYMBOL
+};
+
+static const EnumEntry<uint16_t> RegisterNames[] = {
+    CV_ENUM_CLASS_ENT(RegisterId, Unknown),
+    CV_ENUM_CLASS_ENT(RegisterId, VFrame),
+    CV_ENUM_CLASS_ENT(RegisterId, AL),
+    CV_ENUM_CLASS_ENT(RegisterId, CL),
+    CV_ENUM_CLASS_ENT(RegisterId, DL),
+    CV_ENUM_CLASS_ENT(RegisterId, BL),
+    CV_ENUM_CLASS_ENT(RegisterId, AH),
+    CV_ENUM_CLASS_ENT(RegisterId, CH),
+    CV_ENUM_CLASS_ENT(RegisterId, DH),
+    CV_ENUM_CLASS_ENT(RegisterId, BH),
+    CV_ENUM_CLASS_ENT(RegisterId, AX),
+    CV_ENUM_CLASS_ENT(RegisterId, CX),
+    CV_ENUM_CLASS_ENT(RegisterId, DX),
+    CV_ENUM_CLASS_ENT(RegisterId, BX),
+    CV_ENUM_CLASS_ENT(RegisterId, SP),
+    CV_ENUM_CLASS_ENT(RegisterId, BP),
+    CV_ENUM_CLASS_ENT(RegisterId, SI),
+    CV_ENUM_CLASS_ENT(RegisterId, DI),
+    CV_ENUM_CLASS_ENT(RegisterId, EAX),
+    CV_ENUM_CLASS_ENT(RegisterId, ECX),
+    CV_ENUM_CLASS_ENT(RegisterId, EDX),
+    CV_ENUM_CLASS_ENT(RegisterId, EBX),
+    CV_ENUM_CLASS_ENT(RegisterId, ESP),
+    CV_ENUM_CLASS_ENT(RegisterId, EBP),
+    CV_ENUM_CLASS_ENT(RegisterId, ESI),
+    CV_ENUM_CLASS_ENT(RegisterId, EDI),
+    CV_ENUM_CLASS_ENT(RegisterId, ES),
+    CV_ENUM_CLASS_ENT(RegisterId, CS),
+    CV_ENUM_CLASS_ENT(RegisterId, SS),
+    CV_ENUM_CLASS_ENT(RegisterId, DS),
+    CV_ENUM_CLASS_ENT(RegisterId, FS),
+    CV_ENUM_CLASS_ENT(RegisterId, GS),
+    CV_ENUM_CLASS_ENT(RegisterId, IP),
+    CV_ENUM_CLASS_ENT(RegisterId, RAX),
+    CV_ENUM_CLASS_ENT(RegisterId, RBX),
+    CV_ENUM_CLASS_ENT(RegisterId, RCX),
+    CV_ENUM_CLASS_ENT(RegisterId, RDX),
+    CV_ENUM_CLASS_ENT(RegisterId, RSI),
+    CV_ENUM_CLASS_ENT(RegisterId, RDI),
+    CV_ENUM_CLASS_ENT(RegisterId, RBP),
+    CV_ENUM_CLASS_ENT(RegisterId, RSP),
+    CV_ENUM_CLASS_ENT(RegisterId, R8),
+    CV_ENUM_CLASS_ENT(RegisterId, R9),
+    CV_ENUM_CLASS_ENT(RegisterId, R10),
+    CV_ENUM_CLASS_ENT(RegisterId, R11),
+    CV_ENUM_CLASS_ENT(RegisterId, R12),
+    CV_ENUM_CLASS_ENT(RegisterId, R13),
+    CV_ENUM_CLASS_ENT(RegisterId, R14),
+    CV_ENUM_CLASS_ENT(RegisterId, R15),
+};
+
+static const EnumEntry<uint8_t> ProcSymFlagNames[] = {
+    CV_ENUM_CLASS_ENT(ProcSymFlags, HasFP),
+    CV_ENUM_CLASS_ENT(ProcSymFlags, HasIRET),
+    CV_ENUM_CLASS_ENT(ProcSymFlags, HasFRET),
+    CV_ENUM_CLASS_ENT(ProcSymFlags, IsNoReturn),
+    CV_ENUM_CLASS_ENT(ProcSymFlags, IsUnreachable),
+    CV_ENUM_CLASS_ENT(ProcSymFlags, HasCustomCallingConv),
+    CV_ENUM_CLASS_ENT(ProcSymFlags, IsNoInline),
+    CV_ENUM_CLASS_ENT(ProcSymFlags, HasOptimizedDebugInfo),
+};
+
+static const EnumEntry<uint16_t> LocalFlags[] = {
+    CV_ENUM_CLASS_ENT(LocalSymFlags, IsParameter),
+    CV_ENUM_CLASS_ENT(LocalSymFlags, IsAddressTaken),
+    CV_ENUM_CLASS_ENT(LocalSymFlags, IsCompilerGenerated),
+    CV_ENUM_CLASS_ENT(LocalSymFlags, IsAggregate),
+    CV_ENUM_CLASS_ENT(LocalSymFlags, IsAggregated),
+    CV_ENUM_CLASS_ENT(LocalSymFlags, IsAliased),
+    CV_ENUM_CLASS_ENT(LocalSymFlags, IsAlias),
+    CV_ENUM_CLASS_ENT(LocalSymFlags, IsReturnValue),
+    CV_ENUM_CLASS_ENT(LocalSymFlags, IsOptimizedOut),
+    CV_ENUM_CLASS_ENT(LocalSymFlags, IsEnregisteredGlobal),
+    CV_ENUM_CLASS_ENT(LocalSymFlags, IsEnregisteredStatic),
+};
+
+static const EnumEntry<uint32_t> FrameCookieKinds[] = {
+    CV_ENUM_CLASS_ENT(FrameCookieKind, Copy),
+    CV_ENUM_CLASS_ENT(FrameCookieKind, XorStackPointer),
+    CV_ENUM_CLASS_ENT(FrameCookieKind, XorFramePointer),
+    CV_ENUM_CLASS_ENT(FrameCookieKind, XorR13),
+};
+
+static const EnumEntry<codeview::SourceLanguage> SourceLanguages[] = {
+    CV_ENUM_ENT(SourceLanguage, C),       CV_ENUM_ENT(SourceLanguage, Cpp),
+    CV_ENUM_ENT(SourceLanguage, Fortran), CV_ENUM_ENT(SourceLanguage, Masm),
+    CV_ENUM_ENT(SourceLanguage, Pascal),  CV_ENUM_ENT(SourceLanguage, Basic),
+    CV_ENUM_ENT(SourceLanguage, Cobol),   CV_ENUM_ENT(SourceLanguage, Link),
+    CV_ENUM_ENT(SourceLanguage, Cvtres),  CV_ENUM_ENT(SourceLanguage, Cvtpgd),
+    CV_ENUM_ENT(SourceLanguage, CSharp),  CV_ENUM_ENT(SourceLanguage, VB),
+    CV_ENUM_ENT(SourceLanguage, ILAsm),   CV_ENUM_ENT(SourceLanguage, Java),
+    CV_ENUM_ENT(SourceLanguage, JScript), CV_ENUM_ENT(SourceLanguage, MSIL),
+    CV_ENUM_ENT(SourceLanguage, HLSL),
+};
+
+static const EnumEntry<uint32_t> CompileSym2FlagNames[] = {
+    CV_ENUM_CLASS_ENT(CompileSym2Flags, EC),
+    CV_ENUM_CLASS_ENT(CompileSym2Flags, NoDbgInfo),
+    CV_ENUM_CLASS_ENT(CompileSym2Flags, LTCG),
+    CV_ENUM_CLASS_ENT(CompileSym2Flags, NoDataAlign),
+    CV_ENUM_CLASS_ENT(CompileSym2Flags, ManagedPresent),
+    CV_ENUM_CLASS_ENT(CompileSym2Flags, SecurityChecks),
+    CV_ENUM_CLASS_ENT(CompileSym2Flags, HotPatch),
+    CV_ENUM_CLASS_ENT(CompileSym2Flags, CVTCIL),
+    CV_ENUM_CLASS_ENT(CompileSym2Flags, MSILModule),
+};
+
+static const EnumEntry<uint32_t> CompileSym3FlagNames[] = {
+    CV_ENUM_CLASS_ENT(CompileSym3Flags, EC),
+    CV_ENUM_CLASS_ENT(CompileSym3Flags, NoDbgInfo),
+    CV_ENUM_CLASS_ENT(CompileSym3Flags, LTCG),
+    CV_ENUM_CLASS_ENT(CompileSym3Flags, NoDataAlign),
+    CV_ENUM_CLASS_ENT(CompileSym3Flags, ManagedPresent),
+    CV_ENUM_CLASS_ENT(CompileSym3Flags, SecurityChecks),
+    CV_ENUM_CLASS_ENT(CompileSym3Flags, HotPatch),
+    CV_ENUM_CLASS_ENT(CompileSym3Flags, CVTCIL),
+    CV_ENUM_CLASS_ENT(CompileSym3Flags, MSILModule),
+    CV_ENUM_CLASS_ENT(CompileSym3Flags, Sdl),
+    CV_ENUM_CLASS_ENT(CompileSym3Flags, PGO),
+    CV_ENUM_CLASS_ENT(CompileSym3Flags, Exp),
+};
+
+static const EnumEntry<unsigned> CPUTypeNames[] = {
+    CV_ENUM_CLASS_ENT(CPUType, Intel8080),
+    CV_ENUM_CLASS_ENT(CPUType, Intel8086),
+    CV_ENUM_CLASS_ENT(CPUType, Intel80286),
+    CV_ENUM_CLASS_ENT(CPUType, Intel80386),
+    CV_ENUM_CLASS_ENT(CPUType, Intel80486),
+    CV_ENUM_CLASS_ENT(CPUType, Pentium),
+    CV_ENUM_CLASS_ENT(CPUType, PentiumPro),
+    CV_ENUM_CLASS_ENT(CPUType, Pentium3),
+    CV_ENUM_CLASS_ENT(CPUType, MIPS),
+    CV_ENUM_CLASS_ENT(CPUType, MIPS16),
+    CV_ENUM_CLASS_ENT(CPUType, MIPS32),
+    CV_ENUM_CLASS_ENT(CPUType, MIPS64),
+    CV_ENUM_CLASS_ENT(CPUType, MIPSI),
+    CV_ENUM_CLASS_ENT(CPUType, MIPSII),
+    CV_ENUM_CLASS_ENT(CPUType, MIPSIII),
+    CV_ENUM_CLASS_ENT(CPUType, MIPSIV),
+    CV_ENUM_CLASS_ENT(CPUType, MIPSV),
+    CV_ENUM_CLASS_ENT(CPUType, M68000),
+    CV_ENUM_CLASS_ENT(CPUType, M68010),
+    CV_ENUM_CLASS_ENT(CPUType, M68020),
+    CV_ENUM_CLASS_ENT(CPUType, M68030),
+    CV_ENUM_CLASS_ENT(CPUType, M68040),
+    CV_ENUM_CLASS_ENT(CPUType, Alpha),
+    CV_ENUM_CLASS_ENT(CPUType, Alpha21164),
+    CV_ENUM_CLASS_ENT(CPUType, Alpha21164A),
+    CV_ENUM_CLASS_ENT(CPUType, Alpha21264),
+    CV_ENUM_CLASS_ENT(CPUType, Alpha21364),
+    CV_ENUM_CLASS_ENT(CPUType, PPC601),
+    CV_ENUM_CLASS_ENT(CPUType, PPC603),
+    CV_ENUM_CLASS_ENT(CPUType, PPC604),
+    CV_ENUM_CLASS_ENT(CPUType, PPC620),
+    CV_ENUM_CLASS_ENT(CPUType, PPCFP),
+    CV_ENUM_CLASS_ENT(CPUType, PPCBE),
+    CV_ENUM_CLASS_ENT(CPUType, SH3),
+    CV_ENUM_CLASS_ENT(CPUType, SH3E),
+    CV_ENUM_CLASS_ENT(CPUType, SH3DSP),
+    CV_ENUM_CLASS_ENT(CPUType, SH4),
+    CV_ENUM_CLASS_ENT(CPUType, SHMedia),
+    CV_ENUM_CLASS_ENT(CPUType, ARM3),
+    CV_ENUM_CLASS_ENT(CPUType, ARM4),
+    CV_ENUM_CLASS_ENT(CPUType, ARM4T),
+    CV_ENUM_CLASS_ENT(CPUType, ARM5),
+    CV_ENUM_CLASS_ENT(CPUType, ARM5T),
+    CV_ENUM_CLASS_ENT(CPUType, ARM6),
+    CV_ENUM_CLASS_ENT(CPUType, ARM_XMAC),
+    CV_ENUM_CLASS_ENT(CPUType, ARM_WMMX),
+    CV_ENUM_CLASS_ENT(CPUType, ARM7),
+    CV_ENUM_CLASS_ENT(CPUType, Omni),
+    CV_ENUM_CLASS_ENT(CPUType, Ia64),
+    CV_ENUM_CLASS_ENT(CPUType, Ia64_2),
+    CV_ENUM_CLASS_ENT(CPUType, CEE),
+    CV_ENUM_CLASS_ENT(CPUType, AM33),
+    CV_ENUM_CLASS_ENT(CPUType, M32R),
+    CV_ENUM_CLASS_ENT(CPUType, TriCore),
+    CV_ENUM_CLASS_ENT(CPUType, X64),
+    CV_ENUM_CLASS_ENT(CPUType, EBC),
+    CV_ENUM_CLASS_ENT(CPUType, Thumb),
+    CV_ENUM_CLASS_ENT(CPUType, ARMNT),
+    CV_ENUM_CLASS_ENT(CPUType, D3D11_Shader),
+};
+
+static const EnumEntry<uint32_t> FrameProcSymFlagNames[] = {
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasAlloca),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasSetJmp),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasLongJmp),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasInlineAssembly),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasExceptionHandling),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, MarkedInline),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasStructuredExceptionHandling),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, Naked),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, SecurityChecks),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, AsynchronousExceptionHandling),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, NoStackOrderingForSecurityChecks),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, Inlined),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, StrictSecurityChecks),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, SafeBuffers),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, ProfileGuidedOptimization),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, ValidProfileCounts),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, OptimizedForSpeed),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, GuardCfg),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, GuardCfw),
+};
+
+static const EnumEntry<uint16_t> ExportSymFlagNames[] = {
+    CV_ENUM_CLASS_ENT(ExportFlags, IsConstant),
+    CV_ENUM_CLASS_ENT(ExportFlags, IsData),
+    CV_ENUM_CLASS_ENT(ExportFlags, IsPrivate),
+    CV_ENUM_CLASS_ENT(ExportFlags, HasNoName),
+    CV_ENUM_CLASS_ENT(ExportFlags, HasExplicitOrdinal),
+    CV_ENUM_CLASS_ENT(ExportFlags, IsForwarder),
+};
+
+static const EnumEntry<uint8_t> ThunkOrdinalNames[] = {
+    CV_ENUM_CLASS_ENT(ThunkOrdinal, Standard),
+    CV_ENUM_CLASS_ENT(ThunkOrdinal, ThisAdjustor),
+    CV_ENUM_CLASS_ENT(ThunkOrdinal, Vcall),
+    CV_ENUM_CLASS_ENT(ThunkOrdinal, Pcode),
+    CV_ENUM_CLASS_ENT(ThunkOrdinal, UnknownLoad),
+    CV_ENUM_CLASS_ENT(ThunkOrdinal, TrampIncremental),
+    CV_ENUM_CLASS_ENT(ThunkOrdinal, BranchIsland),
+};
+
+static const EnumEntry<uint16_t> TrampolineNames[] = {
+    CV_ENUM_CLASS_ENT(TrampolineType, TrampIncremental),
+    CV_ENUM_CLASS_ENT(TrampolineType, BranchIsland),
+};
+
+static const EnumEntry<COFF::SectionCharacteristics>
+    ImageSectionCharacteristicNames[] = {
+        CV_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NOLOAD),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NO_PAD),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_CNT_CODE),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_CNT_INITIALIZED_DATA),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_CNT_UNINITIALIZED_DATA),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_LNK_OTHER),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_LNK_INFO),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_LNK_REMOVE),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_LNK_COMDAT),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_GPREL),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_PURGEABLE),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_16BIT),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_LOCKED),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_PRELOAD),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1BYTES),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2BYTES),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4BYTES),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8BYTES),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_16BYTES),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_32BYTES),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_64BYTES),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_128BYTES),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_256BYTES),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_512BYTES),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1024BYTES),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2048BYTES),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4096BYTES),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8192BYTES),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_LNK_NRELOC_OVFL),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_DISCARDABLE),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_CACHED),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_PAGED),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_SHARED),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_EXECUTE),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_READ),
+        CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_WRITE)};
+
+namespace llvm {
+namespace codeview {
+ArrayRef<EnumEntry<SymbolKind>> getSymbolTypeNames() {
+  return makeArrayRef(SymbolTypeNames);
+}
+
+ArrayRef<EnumEntry<uint16_t>> getRegisterNames() {
+  return makeArrayRef(RegisterNames);
+}
+
+ArrayRef<EnumEntry<uint8_t>> getProcSymFlagNames() {
+  return makeArrayRef(ProcSymFlagNames);
+}
+ArrayRef<EnumEntry<uint16_t>> getLocalFlagNames() {
+  return makeArrayRef(LocalFlags);
+}
+ArrayRef<EnumEntry<uint32_t>> getFrameCookieKindNames() {
+  return makeArrayRef(FrameCookieKinds);
+}
+ArrayRef<EnumEntry<SourceLanguage>> getSourceLanguageNames() {
+  return makeArrayRef(SourceLanguages);
+}
+ArrayRef<EnumEntry<uint32_t>> getCompileSym2FlagNames() {
+  return makeArrayRef(CompileSym2FlagNames);
+}
+ArrayRef<EnumEntry<uint32_t>> getCompileSym3FlagNames() {
+  return makeArrayRef(CompileSym3FlagNames);
+}
+ArrayRef<EnumEntry<unsigned>> getCPUTypeNames() {
+  return makeArrayRef(CPUTypeNames);
+}
+ArrayRef<EnumEntry<uint32_t>> getFrameProcSymFlagNames() {
+  return makeArrayRef(FrameProcSymFlagNames);
+}
+ArrayRef<EnumEntry<uint16_t>> getExportSymFlagNames() {
+  return makeArrayRef(ExportSymFlagNames);
+}
+ArrayRef<EnumEntry<uint8_t>> getThunkOrdinalNames() {
+  return makeArrayRef(ThunkOrdinalNames);
+}
+ArrayRef<EnumEntry<uint16_t>> getTrampolineNames() {
+  return makeArrayRef(TrampolineNames);
+}
+ArrayRef<EnumEntry<COFF::SectionCharacteristics>>
+getImageSectionCharacteristicNames() {
+  return makeArrayRef(ImageSectionCharacteristicNames);
+}
+}
+}

lib/DebugInfo/CodeView/SymbolDumper.cpp

 //===-- SymbolDumper.cpp - CodeView symbol info dumper ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/CodeView/SymbolDumper.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h"
+#include "llvm/DebugInfo/CodeView/EnumTables.h"
 #include "llvm/DebugInfo/CodeView/SymbolDumpDelegate.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeDumper.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 #include <system_error>
 
 using namespace llvm;
 using namespace llvm::codeview;
 
-static const EnumEntry<SymbolKind> SymbolTypeNames[] = {
-#define CV_SYMBOL(enum, val) {#enum, enum},
-#include "llvm/DebugInfo/CodeView/CVSymbolTypes.def"
-};
-
 namespace {
-#define CV_ENUM_CLASS_ENT(enum_class, enum)                                    \
-  { #enum, std::underlying_type < enum_class > ::type(enum_class::enum) }
-
-#define CV_ENUM_ENT(ns, enum)                                                  \
-  { #enum, ns::enum }
-
-static const EnumEntry<uint16_t> RegisterNames[] = {
-    CV_ENUM_CLASS_ENT(RegisterId, Unknown),
-    CV_ENUM_CLASS_ENT(RegisterId, VFrame),
-    CV_ENUM_CLASS_ENT(RegisterId, AL),
-    CV_ENUM_CLASS_ENT(RegisterId, CL),
-    CV_ENUM_CLASS_ENT(RegisterId, DL),
-    CV_ENUM_CLASS_ENT(RegisterId, BL),
-    CV_ENUM_CLASS_ENT(RegisterId, AH),
-    CV_ENUM_CLASS_ENT(RegisterId, CH),
-    CV_ENUM_CLASS_ENT(RegisterId, DH),
-    CV_ENUM_CLASS_ENT(RegisterId, BH),
-    CV_ENUM_CLASS_ENT(RegisterId, AX),
-    CV_ENUM_CLASS_ENT(RegisterId, CX),
-    CV_ENUM_CLASS_ENT(RegisterId, DX),
-    CV_ENUM_CLASS_ENT(RegisterId, BX),
-    CV_ENUM_CLASS_ENT(RegisterId, SP),
-    CV_ENUM_CLASS_ENT(RegisterId, BP),
-    CV_ENUM_CLASS_ENT(RegisterId, SI),
-    CV_ENUM_CLASS_ENT(RegisterId, DI),
-    CV_ENUM_CLASS_ENT(RegisterId, EAX),
-    CV_ENUM_CLASS_ENT(RegisterId, ECX),
-    CV_ENUM_CLASS_ENT(RegisterId, EDX),
-    CV_ENUM_CLASS_ENT(RegisterId, EBX),
-    CV_ENUM_CLASS_ENT(RegisterId, ESP),
-    CV_ENUM_CLASS_ENT(RegisterId, EBP),
-    CV_ENUM_CLASS_ENT(RegisterId, ESI),
-    CV_ENUM_CLASS_ENT(RegisterId, EDI),
-    CV_ENUM_CLASS_ENT(RegisterId, ES),
-    CV_ENUM_CLASS_ENT(RegisterId, CS),
-    CV_ENUM_CLASS_ENT(RegisterId, SS),
-    CV_ENUM_CLASS_ENT(RegisterId, DS),
-    CV_ENUM_CLASS_ENT(RegisterId, FS),
-    CV_ENUM_CLASS_ENT(RegisterId, GS),
-    CV_ENUM_CLASS_ENT(RegisterId, IP),
-    CV_ENUM_CLASS_ENT(RegisterId, RAX),
-    CV_ENUM_CLASS_ENT(RegisterId, RBX),
-    CV_ENUM_CLASS_ENT(RegisterId, RCX),
-    CV_ENUM_CLASS_ENT(RegisterId, RDX),
-    CV_ENUM_CLASS_ENT(RegisterId, RSI),
-    CV_ENUM_CLASS_ENT(RegisterId, RDI),
-    CV_ENUM_CLASS_ENT(RegisterId, RBP),
-    CV_ENUM_CLASS_ENT(RegisterId, RSP),
-    CV_ENUM_CLASS_ENT(RegisterId, R8),
-    CV_ENUM_CLASS_ENT(RegisterId, R9),
-    CV_ENUM_CLASS_ENT(RegisterId, R10),
-    CV_ENUM_CLASS_ENT(RegisterId, R11),
-    CV_ENUM_CLASS_ENT(RegisterId, R12),
-    CV_ENUM_CLASS_ENT(RegisterId, R13),
-    CV_ENUM_CLASS_ENT(RegisterId, R14),
-    CV_ENUM_CLASS_ENT(RegisterId, R15),
-};
-
-static const EnumEntry<uint8_t> ProcSymFlagNames[] = {
-    CV_ENUM_CLASS_ENT(ProcSymFlags, HasFP),
-    CV_ENUM_CLASS_ENT(ProcSymFlags, HasIRET),
-    CV_ENUM_CLASS_ENT(ProcSymFlags, HasFRET),
-    CV_ENUM_CLASS_ENT(ProcSymFlags, IsNoReturn),
-    CV_ENUM_CLASS_ENT(ProcSymFlags, IsUnreachable),
-    CV_ENUM_CLASS_ENT(ProcSymFlags, HasCustomCallingConv),
-    CV_ENUM_CLASS_ENT(ProcSymFlags, IsNoInline),
-    CV_ENUM_CLASS_ENT(ProcSymFlags, HasOptimizedDebugInfo),
-};
-
-static const EnumEntry<uint16_t> LocalFlags[] = {
-    CV_ENUM_CLASS_ENT(LocalSymFlags, IsParameter),
-    CV_ENUM_CLASS_ENT(LocalSymFlags, IsAddressTaken),
-    CV_ENUM_CLASS_ENT(LocalSymFlags, IsCompilerGenerated),
-    CV_ENUM_CLASS_ENT(LocalSymFlags, IsAggregate),
-    CV_ENUM_CLASS_ENT(LocalSymFlags, IsAggregated),
-    CV_ENUM_CLASS_ENT(LocalSymFlags, IsAliased),
-    CV_ENUM_CLASS_ENT(LocalSymFlags, IsAlias),
-    CV_ENUM_CLASS_ENT(LocalSymFlags, IsReturnValue),
-    CV_ENUM_CLASS_ENT(LocalSymFlags, IsOptimizedOut),
-    CV_ENUM_CLASS_ENT(LocalSymFlags, IsEnregisteredGlobal),
-    CV_ENUM_CLASS_ENT(LocalSymFlags, IsEnregisteredStatic),
-};
-
-static const EnumEntry<uint32_t> FrameCookieKinds[] = {
-    CV_ENUM_CLASS_ENT(FrameCookieKind, Copy),
-    CV_ENUM_CLASS_ENT(FrameCookieKind, XorStackPointer),
-    CV_ENUM_CLASS_ENT(FrameCookieKind, XorFramePointer),
-    CV_ENUM_CLASS_ENT(FrameCookieKind, XorR13),
-};
-
-static const EnumEntry<codeview::SourceLanguage> SourceLanguages[] = {
-    CV_ENUM_ENT(SourceLanguage, C),       CV_ENUM_ENT(SourceLanguage, Cpp),
-    CV_ENUM_ENT(SourceLanguage, Fortran), CV_ENUM_ENT(SourceLanguage, Masm),
-    CV_ENUM_ENT(SourceLanguage, Pascal),  CV_ENUM_ENT(SourceLanguage, Basic),
-    CV_ENUM_ENT(SourceLanguage, Cobol),   CV_ENUM_ENT(SourceLanguage, Link),
-    CV_ENUM_ENT(SourceLanguage, Cvtres),  CV_ENUM_ENT(SourceLanguage, Cvtpgd),
-    CV_ENUM_ENT(SourceLanguage, CSharp),  CV_ENUM_ENT(SourceLanguage, VB),
-    CV_ENUM_ENT(SourceLanguage, ILAsm),   CV_ENUM_ENT(SourceLanguage, Java),
-    CV_ENUM_ENT(SourceLanguage, JScript), CV_ENUM_ENT(SourceLanguage, MSIL),
-    CV_ENUM_ENT(SourceLanguage, HLSL),
-};
-
-static const EnumEntry<uint32_t> CompileSym2FlagNames[] = {
-    CV_ENUM_CLASS_ENT(CompileSym2Flags, EC),
-    CV_ENUM_CLASS_ENT(CompileSym2Flags, NoDbgInfo),
-    CV_ENUM_CLASS_ENT(CompileSym2Flags, LTCG),
-    CV_ENUM_CLASS_ENT(CompileSym2Flags, NoDataAlign),
-    CV_ENUM_CLASS_ENT(CompileSym2Flags, ManagedPresent),
-    CV_ENUM_CLASS_ENT(CompileSym2Flags, SecurityChecks),
-    CV_ENUM_CLASS_ENT(CompileSym2Flags, HotPatch),
-    CV_ENUM_CLASS_ENT(CompileSym2Flags, CVTCIL),
-    CV_ENUM_CLASS_ENT(CompileSym2Flags, MSILModule),
-};
-
-static const EnumEntry<uint32_t> CompileSym3FlagNames[] = {
-    CV_ENUM_CLASS_ENT(CompileSym3Flags, EC),
-    CV_ENUM_CLASS_ENT(CompileSym3Flags, NoDbgInfo),
-    CV_ENUM_CLASS_ENT(CompileSym3Flags, LTCG),
-    CV_ENUM_CLASS_ENT(CompileSym3Flags, NoDataAlign),
-    CV_ENUM_CLASS_ENT(CompileSym3Flags, ManagedPresent),
-    CV_ENUM_CLASS_ENT(CompileSym3Flags, SecurityChecks),
-    CV_ENUM_CLASS_ENT(CompileSym3Flags, HotPatch),
-    CV_ENUM_CLASS_ENT(CompileSym3Flags, CVTCIL),
-    CV_ENUM_CLASS_ENT(CompileSym3Flags, MSILModule),
-    CV_ENUM_CLASS_ENT(CompileSym3Flags, Sdl),
-    CV_ENUM_CLASS_ENT(CompileSym3Flags, PGO),
-    CV_ENUM_CLASS_ENT(CompileSym3Flags, Exp),
-};
-
-static const EnumEntry<unsigned> CPUTypeNames[] = {
-    CV_ENUM_CLASS_ENT(CPUType, Intel8080),
-    CV_ENUM_CLASS_ENT(CPUType, Intel8086),
-    CV_ENUM_CLASS_ENT(CPUType, Intel80286),
-    CV_ENUM_CLASS_ENT(CPUType, Intel80386),
-    CV_ENUM_CLASS_ENT(CPUType, Intel80486),
-    CV_ENUM_CLASS_ENT(CPUType, Pentium),
-    CV_ENUM_CLASS_ENT(CPUType, PentiumPro),
-    CV_ENUM_CLASS_ENT(CPUType, Pentium3),
-    CV_ENUM_CLASS_ENT(CPUType, MIPS),
-    CV_ENUM_CLASS_ENT(CPUType, MIPS16),
-    CV_ENUM_CLASS_ENT(CPUType, MIPS32),
-    CV_ENUM_CLASS_ENT(CPUType, MIPS64),
-    CV_ENUM_CLASS_ENT(CPUType, MIPSI),
-    CV_ENUM_CLASS_ENT(CPUType, MIPSII),
-    CV_ENUM_CLASS_ENT(CPUType, MIPSIII),
-    CV_ENUM_CLASS_ENT(CPUType, MIPSIV),
-    CV_ENUM_CLASS_ENT(CPUType, MIPSV),
-    CV_ENUM_CLASS_ENT(CPUType, M68000),
-    CV_ENUM_CLASS_ENT(CPUType, M68010),
-    CV_ENUM_CLASS_ENT(CPUType, M68020),
-    CV_ENUM_CLASS_ENT(CPUType, M68030),
-    CV_ENUM_CLASS_ENT(CPUType, M68040),
-    CV_ENUM_CLASS_ENT(CPUType, Alpha),
-    CV_ENUM_CLASS_ENT(CPUType, Alpha21164),
-    CV_ENUM_CLASS_ENT(CPUType, Alpha21164A),
-    CV_ENUM_CLASS_ENT(CPUType, Alpha21264),
-    CV_ENUM_CLASS_ENT(CPUType, Alpha21364),
-    CV_ENUM_CLASS_ENT(CPUType, PPC601),
-    CV_ENUM_CLASS_ENT(CPUType, PPC603),
-    CV_ENUM_CLASS_ENT(CPUType, PPC604),
-    CV_ENUM_CLASS_ENT(CPUType, PPC620),
-    CV_ENUM_CLASS_ENT(CPUType, PPCFP),
-    CV_ENUM_CLASS_ENT(CPUType, PPCBE),
-    CV_ENUM_CLASS_ENT(CPUType, SH3),
-    CV_ENUM_CLASS_ENT(CPUType, SH3E),
-    CV_ENUM_CLASS_ENT(CPUType, SH3DSP),
-    CV_ENUM_CLASS_ENT(CPUType, SH4),
-    CV_ENUM_CLASS_ENT(CPUType, SHMedia),
-    CV_ENUM_CLASS_ENT(CPUType, ARM3),
-    CV_ENUM_CLASS_ENT(CPUType, ARM4),
-    CV_ENUM_CLASS_ENT(CPUType, ARM4T),
-    CV_ENUM_CLASS_ENT(CPUType, ARM5),
-    CV_ENUM_CLASS_ENT(CPUType, ARM5T),
-    CV_ENUM_CLASS_ENT(CPUType, ARM6),
-    CV_ENUM_CLASS_ENT(CPUType, ARM_XMAC),
-    CV_ENUM_CLASS_ENT(CPUType, ARM_WMMX),
-    CV_ENUM_CLASS_ENT(CPUType, ARM7),
-    CV_ENUM_CLASS_ENT(CPUType, Omni),
-    CV_ENUM_CLASS_ENT(CPUType, Ia64),
-    CV_ENUM_CLASS_ENT(CPUType, Ia64_2),
-    CV_ENUM_CLASS_ENT(CPUType, CEE),
-    CV_ENUM_CLASS_ENT(CPUType, AM33),
-    CV_ENUM_CLASS_ENT(CPUType, M32R),
-    CV_ENUM_CLASS_ENT(CPUType, TriCore),
-    CV_ENUM_CLASS_ENT(CPUType, X64),
-    CV_ENUM_CLASS_ENT(CPUType, EBC),
-    CV_ENUM_CLASS_ENT(CPUType, Thumb),
-    CV_ENUM_CLASS_ENT(CPUType, ARMNT),
-    CV_ENUM_CLASS_ENT(CPUType, D3D11_Shader),
-};
-
-static const EnumEntry<uint32_t> FrameProcSymFlags[] = {
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasAlloca),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasSetJmp),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasLongJmp),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasInlineAssembly),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasExceptionHandling),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, MarkedInline),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasStructuredExceptionHandling),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, Naked),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, SecurityChecks),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, AsynchronousExceptionHandling),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, NoStackOrderingForSecurityChecks),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, Inlined),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, StrictSecurityChecks),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, SafeBuffers),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, ProfileGuidedOptimization),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, ValidProfileCounts),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, OptimizedForSpeed),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, GuardCfg),
-    CV_ENUM_CLASS_ENT(FrameProcedureOptions, GuardCfw),
-};
-
-static const EnumEntry<uint16_t> ExportSymFlags[] = {
-    CV_ENUM_CLASS_ENT(ExportFlags, IsConstant),
-    CV_ENUM_CLASS_ENT(ExportFlags, IsData),
-    CV_ENUM_CLASS_ENT(ExportFlags, IsPrivate),
-    CV_ENUM_CLASS_ENT(ExportFlags, HasNoName),
-    CV_ENUM_CLASS_ENT(ExportFlags, HasExplicitOrdinal),
-    CV_ENUM_CLASS_ENT(ExportFlags, IsForwarder),
-};
-
-static const EnumEntry<uint8_t> ThunkOrdinalNames[] = {
-    CV_ENUM_CLASS_ENT(ThunkOrdinal, Standard),
-    CV_ENUM_CLASS_ENT(ThunkOrdinal, ThisAdjustor),
-    CV_ENUM_CLASS_ENT(ThunkOrdinal, Vcall),
-    CV_ENUM_CLASS_ENT(ThunkOrdinal, Pcode),
-    CV_ENUM_CLASS_ENT(ThunkOrdinal, UnknownLoad),
-    CV_ENUM_CLASS_ENT(ThunkOrdinal, TrampIncremental),
-    CV_ENUM_CLASS_ENT(ThunkOrdinal, BranchIsland),
-};
-
-static const EnumEntry<uint16_t> TrampolineNames[] = {
-    CV_ENUM_CLASS_ENT(TrampolineType, TrampIncremental),
-    CV_ENUM_CLASS_ENT(TrampolineType, BranchIsland),
-};
-
 /// Use this private dumper implementation to keep implementation details about
 /// the visitor out of SymbolDumper.h.
 class CVSymbolDumperImpl : public CVSymbolVisitor<CVSymbolDumperImpl> {
 public:
   CVSymbolDumperImpl(CVTypeDumper &CVTD, SymbolDumpDelegate *ObjDelegate,
                      ScopedPrinter &W, bool PrintRecordBytes)
       : CVSymbolVisitor(ObjDelegate), CVTD(CVTD), ObjDelegate(ObjDelegate),
         W(W), PrintRecordBytes(PrintRecordBytes), InFunctionScope(false) {}

 void CVSymbolDumperImpl::visitThunk32Sym(SymbolKind Kind, Thunk32Sym &Thunk) {
   DictScope S(W, "Thunk32");
   W.printNumber("Parent", Thunk.Header.Parent);
   W.printNumber("End", Thunk.Header.End);
   W.printNumber("Next", Thunk.Header.Next);
   W.printNumber("Off", Thunk.Header.Off);
   W.printNumber("Seg", Thunk.Header.Seg);
   W.printNumber("Len", Thunk.Header.Len);
-  W.printEnum("Ordinal", Thunk.Header.Ord, makeArrayRef(ThunkOrdinalNames));
+  W.printEnum("Ordinal", Thunk.Header.Ord, getThunkOrdinalNames());
 }
 
 void CVSymbolDumperImpl::visitTrampolineSym(SymbolKind Kind,
                                             TrampolineSym &Tramp) {
   DictScope S(W, "Trampoline");
-  W.printEnum("Type", Tramp.Header.Type, makeArrayRef(TrampolineNames));
+  W.printEnum("Type", Tramp.Header.Type, getTrampolineNames());
   W.printNumber("Size", Tramp.Header.Size);
   W.printNumber("ThunkOff", Tramp.Header.ThunkOff);
   W.printNumber("TargetOff", Tramp.Header.TargetOff);
   W.printNumber("ThunkSection", Tramp.Header.ThunkSection);
   W.printNumber("TargetSection", Tramp.Header.TargetSection);
 }
 
 void CVSymbolDumperImpl::visitSectionSym(SymbolKind Kind, SectionSym &Section) {
   DictScope S(W, "Section");
   W.printNumber("SectionNumber", Section.Header.SectionNumber);
   W.printNumber("Alignment", Section.Header.Alignment);
   W.printNumber("Reserved", Section.Header.Reserved);
   W.printNumber("Rva", Section.Header.Rva);
   W.printNumber("Length", Section.Header.Length);
-  W.printHex("Characteristics", Section.Header.Characteristics);
+  W.printFlags("Characteristics", Section.Header.Characteristics,
+               getImageSectionCharacteristicNames(),
+               COFF::SectionCharacteristics(0x00F00000));
+
   W.printString("Name", Section.Name);
 }
 
 void CVSymbolDumperImpl::visitCoffGroupSym(SymbolKind Kind,
                                            CoffGroupSym &CoffGroup) {
   DictScope S(W, "COFF Group");
   W.printNumber("Size", CoffGroup.Header.Size);
-  W.printHex("Characteristics", CoffGroup.Header.Characteristics);
+  W.printFlags("Characteristics", CoffGroup.Header.Characteristics,
+               getImageSectionCharacteristicNames(),
+               COFF::SectionCharacteristics(0x00F00000));
   W.printNumber("Offset", CoffGroup.Header.Offset);
   W.printNumber("Segment", CoffGroup.Header.Segment);
   W.printString("Name", CoffGroup.Name);
 }
 
 void CVSymbolDumperImpl::visitBPRelativeSym(SymbolKind Kind,
                                             BPRelativeSym &BPRel) {
   DictScope S(W, "BPRelativeSym");
void CVSymbolDumperImpl::visitEnvBlockSym(SymbolKind Kind,
   }
 }
 
 void CVSymbolDumperImpl::visitFileStaticSym(SymbolKind Kind,
                                             FileStaticSym &FileStatic) {
   DictScope S(W, "FileStatic");
   W.printNumber("Index", FileStatic.Header.Index);
   W.printNumber("ModFilenameOffset", FileStatic.Header.ModFilenameOffset);
-  W.printFlags("Flags", uint16_t(FileStatic.Header.Flags),
-               makeArrayRef(LocalFlags));
+  W.printFlags("Flags", uint16_t(FileStatic.Header.Flags), getLocalFlagNames());
   W.printString("Name", FileStatic.Name);
 }
 
 void CVSymbolDumperImpl::visitExportSym(SymbolKind Kind, ExportSym &Export) {
   DictScope S(W, "Export");
   W.printNumber("Ordinal", Export.Header.Ordinal);
-  W.printFlags("Flags", Export.Header.Flags, makeArrayRef(ExportSymFlags));
+  W.printFlags("Flags", Export.Header.Flags, getExportSymFlagNames());
   W.printString("Name", Export.Name);
 }
 
 void CVSymbolDumperImpl::visitCompile2Sym(SymbolKind Kind,
                                           Compile2Sym &Compile2) {
   DictScope S(W, "CompilerFlags2");
 
   W.printEnum("Language", Compile2.Header.getLanguage(),
-              makeArrayRef(SourceLanguages));
+              getSourceLanguageNames());
   W.printFlags("Flags", Compile2.Header.flags & ~0xff,
-               makeArrayRef(CompileSym2FlagNames));
-  W.printEnum("Machine", unsigned(Compile2.Header.Machine),
-              makeArrayRef(CPUTypeNames));
+               getCompileSym2FlagNames());
+  W.printEnum("Machine", unsigned(Compile2.Header.Machine), getCPUTypeNames());
   std::string FrontendVersion;
   {
     raw_string_ostream Out(FrontendVersion);
     Out << Compile2.Header.VersionFrontendMajor << '.'
         << Compile2.Header.VersionFrontendMinor << '.'
         << Compile2.Header.VersionFrontendBuild;
   }
   std::string BackendVersion;
   {
     raw_string_ostream Out(BackendVersion);
     Out << Compile2.Header.VersionBackendMajor << '.'
         << Compile2.Header.VersionBackendMinor << '.'
         << Compile2.Header.VersionBackendBuild;
   }
   W.printString("FrontendVersion", FrontendVersion);
   W.printString("BackendVersion", BackendVersion);
   W.printString("VersionName", Compile2.Version);
 }
 
 void CVSymbolDumperImpl::visitCompile3Sym(SymbolKind Kind,
                                           Compile3Sym &Compile3) {
   DictScope S(W, "CompilerFlags3");
 
   W.printEnum("Language", Compile3.Header.getLanguage(),
-              makeArrayRef(SourceLanguages));
+              getSourceLanguageNames());
   W.printFlags("Flags", Compile3.Header.flags & ~0xff,
-               makeArrayRef(CompileSym3FlagNames));
-  W.printEnum("Machine", unsigned(Compile3.Header.Machine),
-              makeArrayRef(CPUTypeNames));
+               getCompileSym3FlagNames());
+  W.printEnum("Machine", unsigned(Compile3.Header.Machine), getCPUTypeNames());
   std::string FrontendVersion;
   {
     raw_string_ostream Out(FrontendVersion);
     Out << Compile3.Header.VersionFrontendMajor << '.'
         << Compile3.Header.VersionFrontendMinor << '.'
         << Compile3.Header.VersionFrontendBuild << '.'
         << Compile3.Header.VersionFrontendQFE;
   }
void CVSymbolDumperImpl::visitFrameCookieSym(SymbolKind Kind,
   StringRef LinkageName;
   if (ObjDelegate) {
     ObjDelegate->printRelocatedField(
         "CodeOffset", FrameCookie.getRelocationOffset(),
         FrameCookie.Header.CodeOffset, &LinkageName);
   }
   W.printHex("Register", FrameCookie.Header.Register);
   W.printEnum("CookieKind", uint16_t(FrameCookie.Header.CookieKind),
-              makeArrayRef(FrameCookieKinds));
+              getFrameCookieKindNames());
 }
 
 void CVSymbolDumperImpl::visitFrameProcSym(SymbolKind Kind,
                                            FrameProcSym &FrameProc) {
   DictScope S(W, "FrameProc");
 
   W.printHex("TotalFrameBytes", FrameProc.Header.TotalFrameBytes);
   W.printHex("PaddingFrameBytes", FrameProc.Header.PaddingFrameBytes);
   W.printHex("OffsetToPadding", FrameProc.Header.OffsetToPadding);
   W.printHex("BytesOfCalleeSavedRegisters",
              FrameProc.Header.BytesOfCalleeSavedRegisters);
   W.printHex("OffsetOfExceptionHandler",
              FrameProc.Header.OffsetOfExceptionHandler);
   W.printHex("SectionIdOfExceptionHandler",
              FrameProc.Header.SectionIdOfExceptionHandler);
-  W.printFlags("Flags", FrameProc.Header.Flags,
-               makeArrayRef(FrameProcSymFlags));
+  W.printFlags("Flags", FrameProc.Header.Flags, getFrameProcSymFlagNames());
 }
 
 void CVSymbolDumperImpl::visitHeapAllocationSiteSym(
     SymbolKind Kind, HeapAllocationSiteSym &HeapAllocSite) {
   DictScope S(W, "HeapAllocationSite");
 
   StringRef LinkageName;
   if (ObjDelegate) {
for (auto &Annotation : InlineSite.annotations()) {
     }
   }
 }
 
 void CVSymbolDumperImpl::visitRegisterSym(SymbolKind Kind,
                                           RegisterSym &Register) {
   DictScope S(W, "RegisterSym");
   W.printNumber("Type", Register.Header.Index);
-  W.printEnum("Seg", uint16_t(Register.Header.Register),
-              makeArrayRef(RegisterNames));
+  W.printEnum("Seg", uint16_t(Register.Header.Register), getRegisterNames());
   W.printString("Name", Register.Name);
 }
 
 void CVSymbolDumperImpl::visitPublicSym32(SymbolKind Kind,
                                           PublicSym32 &Public) {
   DictScope S(W, "PublicSym");
   W.printNumber("Type", Public.Header.Index);
   W.printNumber("Seg", Public.Header.Seg);
void CVSymbolDumperImpl::visitLabelSym(SymbolKind Kind, LabelSym &Label) {
 
   StringRef LinkageName;
   if (ObjDelegate) {
     ObjDelegate->printRelocatedField("CodeOffset", Label.getRelocationOffset(),
                                      Label.Header.CodeOffset, &LinkageName);
   }
   W.printHex("Segment", Label.Header.Segment);
   W.printHex("Flags", Label.Header.Flags);
-  W.printFlags("Flags", Label.Header.Flags, makeArrayRef(ProcSymFlagNames));
+  W.printFlags("Flags", Label.Header.Flags, getProcSymFlagNames());
   W.printString("DisplayName", Label.Name);
   if (!LinkageName.empty())
     W.printString("LinkageName", LinkageName);
 }
 
 void CVSymbolDumperImpl::visitLocalSym(SymbolKind Kind, LocalSym &Local) {
   DictScope S(W, "Local");
 
   CVTD.printTypeIndex("Type", Local.Header.Type);
-  W.printFlags("Flags", uint16_t(Local.Header.Flags), makeArrayRef(LocalFlags));
+  W.printFlags("Flags", uint16_t(Local.Header.Flags), getLocalFlagNames());
   W.printString("VarName", Local.Name);
 }
 
 void CVSymbolDumperImpl::visitObjNameSym(SymbolKind Kind, ObjNameSym &ObjName) {
   DictScope S(W, "ObjectName");
 
   W.printHex("Signature", ObjName.Header.Signature);
   W.printString("ObjectName", ObjName.Name);
void CVSymbolDumperImpl::visitProcSym(SymbolKind Kind, ProcSym &Proc) {
   W.printHex("DbgEnd", Proc.Header.DbgEnd);
   CVTD.printTypeIndex("FunctionType", Proc.Header.FunctionType);
   if (ObjDelegate) {
     ObjDelegate->printRelocatedField("CodeOffset", Proc.getRelocationOffset(),
                                      Proc.Header.CodeOffset, &LinkageName);
   }
   W.printHex("Segment", Proc.Header.Segment);
   W.printFlags("Flags", static_cast<uint8_t>(Proc.Header.Flags),
-               makeArrayRef(ProcSymFlagNames));
+               getProcSymFlagNames());
   W.printString("DisplayName", Proc.Name);
   if (!LinkageName.empty())
     W.printString("LinkageName", LinkageName);
 }
 
 void CVSymbolDumperImpl::visitScopeEndSym(SymbolKind Kind,
                                           ScopeEndSym &ScopeEnd) {
   if (Kind == SymbolKind::S_END)
void CVSymbolDumperImpl::visitUDTSym(SymbolKind Kind, UDTSym &UDT) {
   DictScope S(W, "UDT");
   CVTD.printTypeIndex("Type", UDT.Header.Type);
   W.printString("UDTName", UDT.Name);
 }
 
 void CVSymbolDumperImpl::visitUnknownSymbol(SymbolKind Kind,
                                             ArrayRef<uint8_t> Data) {
   DictScope S(W, "UnknownSym");
-  W.printEnum("Kind", uint16_t(Kind), makeArrayRef(SymbolTypeNames));
+  W.printEnum("Kind", uint16_t(Kind), getSymbolTypeNames());
   W.printNumber("Length", uint32_t(Data.size()));
 }
 
 bool CVSymbolDumper::dump(const CVRecord<SymbolKind> &Record) {
   CVSymbolDumperImpl Dumper(CVTD, ObjDelegate.get(), W, PrintRecordBytes);
   Dumper.visitSymbolRecord(Record);
   return !Dumper.hadError();
 }
 
 bool CVSymbolDumper::dump(const CVSymbolArray &Symbols) {
   CVSymbolDumperImpl Dumper(CVTD, ObjDelegate.get(), W, PrintRecordBytes);
   Dumper.visitSymbolStream(Symbols);
   return !Dumper.hadError();
 }

lib/DebugInfo/PDB/CMakeLists.txt

add_pdb_impl_folder(DIA
     DIA/DIASourceFile.cpp
     )
 
     set(LIBPDB_ADDITIONAL_HEADER_DIRS "${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/PDB/DIA")
 endif()
 
 add_pdb_impl_folder(Raw
   Raw/DbiStream.cpp
+  Raw/EnumTables.cpp
   Raw/InfoStream.cpp
   Raw/MappedBlockStream.cpp
   Raw/ModInfo.cpp
   Raw/ModStream.cpp
   Raw/NameHashTable.cpp
   Raw/NameMap.cpp
   Raw/PDBFile.cpp
   Raw/PublicsStream.cpp

lib/DebugInfo/PDB/Raw/DbiStream.cpp

 //===- DbiStream.cpp - PDB Dbi Stream (Stream 3) Access -------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include "llvm/DebugInfo/PDB/Raw/DbiStream.h"
 
 #include "llvm/DebugInfo/CodeView/StreamArray.h"
 #include "llvm/DebugInfo/CodeView/StreamReader.h"
+#include "llvm/DebugInfo/PDB/Raw/ISectionContribVisitor.h"
 #include "llvm/DebugInfo/PDB/Raw/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
 #include "llvm/DebugInfo/PDB/Raw/NameHashTable.h"
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
+#include "llvm/DebugInfo/PDB/Raw/RawTypes.h"
 
 using namespace llvm;
+using namespace llvm::codeview;
 using namespace llvm::pdb;
 using namespace llvm::support;
 
 namespace {
 // Some of the values are stored in bitfields.  Since this needs to be portable
 // across compilers and architectures (big / little endian in particular) we
 // can't use the actual structures below, but must instead do the shifting
 // and masking ourselves.  The struct definitions are provided for reference.
struct DbiStream::HeaderInfo {
   little32_t OptionalDbgHdrSize;  // Size of DbgHeader info
   little32_t ECSubstreamSize;     // Size of EC stream (what is EC?)
   ulittle16_t Flags;              // See DbiFlags enum.
   ulittle16_t MachineType;        // See PDB_MachineType enum.
 
   ulittle32_t Reserved; // Pad to 64 bytes
 };
 
+template <typename ContribType>
+Error loadSectionContribs(FixedStreamArray<ContribType> &Output,
+                          StreamReader &Reader) {
+  if (Reader.bytesRemaining() % sizeof(ContribType) != 0)
+    return make_error<RawError>(
+        raw_error_code::corrupt_file,
+        "Invalid number of bytes of section contributions");
+
+  uint32_t Count = Reader.bytesRemaining() / sizeof(ContribType);
+  if (auto EC = Reader.readArray(Output, Count))
+    return EC;
+  return Error::success();
+}
+
 DbiStream::DbiStream(PDBFile &File)
     : Pdb(File), Stream(StreamDBI, File), Header(nullptr) {
   static_assert(sizeof(HeaderInfo) == 64, "Invalid HeaderInfo size!");
 }
 
 DbiStream::~DbiStream() {}
 
 Error DbiStream::reload() {
-  codeview::StreamReader Reader(Stream);
+  StreamReader Reader(Stream);
 
   if (Stream.getLength() < sizeof(HeaderInfo))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "DBI Stream does not contain a header.");
   if (auto EC = Reader.readObject(Header))
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "DBI Stream does not contain a header.");
 
   if (Header->VersionSignature != -1)
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Invalid DBI version signature.");
 
   // Require at least version 7, which should be present in all PDBs
   // produced in the last decade and allows us to avoid having to
   // special case all kinds of complicated arcane formats.
   if (Header->VersionHeader < PdbDbiV70)
-    return make_error<RawError>(raw_error_code::corrupt_file,
+    return make_error<RawError>(raw_error_code::feature_unsupported,
                                 "Unsupported DBI version.");
 
   auto InfoStream = Pdb.getPDBInfoStream();
   if (auto EC = InfoStream.takeError())
     return EC;
 
   if (Header->Age != InfoStream.get().getAge())
     return make_error<RawError>(raw_error_code::corrupt_file,
if (Header->FileInfoSize % sizeof(uint32_t) != 0)
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "DBI file info substream not aligned.");
   if (Header->TypeServerSize % sizeof(uint32_t) != 0)
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "DBI type server substream not aligned.");
 
   // Since each ModInfo in the stream is a variable length, we have to iterate
   // them to know how many there actually are.
-  codeview::VarStreamArray<ModInfo> ModInfoArray;
+  VarStreamArray<ModInfo> ModInfoArray;
   if (auto EC = Reader.readArray(ModInfoArray, Header->ModiSubstreamSize))
     return EC;
   for (auto &Info : ModInfoArray) {
     ModuleInfos.emplace_back(Info);
   }
 
   if (auto EC = Reader.readStreamRef(SecContrSubstream,
                                      Header->SecContrSubstreamSize))
     return EC;
   if (auto EC = Reader.readStreamRef(SecMapSubstream, Header->SectionMapSize))
     return EC;
   if (auto EC = Reader.readStreamRef(FileInfoSubstream, Header->FileInfoSize))
     return EC;
   if (auto EC =
           Reader.readStreamRef(TypeServerMapSubstream, Header->TypeServerSize))
     return EC;
   if (auto EC = Reader.readStreamRef(ECSubstream, Header->ECSubstreamSize))
     return EC;
   if (auto EC = Reader.readArray(DbgStreams, Header->OptionalDbgHdrSize /
                                                  sizeof(ulittle16_t)))
     return EC;
 
+  if (auto EC = initializeSectionContributionData())
+    return EC;
+
+  if (auto EC = initializeSectionMapData())
+    return EC;
+
   if (auto EC = initializeFileInfo())
     return EC;
 
   if (Reader.bytesRemaining() > 0)
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "Found unexpected bytes in DBI Stream.");
 
-  codeview::StreamReader ECReader(ECSubstream);
+  StreamReader ECReader(ECSubstream);
   if (auto EC = ECNames.load(ECReader))
     return EC;
 
   return Error::success();
 }
 
 PdbRaw_DbiVer DbiStream::getDbiVersion() const {
   uint32_t Value = Header->VersionHeader;

 }
 
 PDB_Machine DbiStream::getMachineType() const {
   uint16_t Machine = Header->MachineType;
   return static_cast<PDB_Machine>(Machine);
 }
 
 ArrayRef<ModuleInfoEx> DbiStream::modules() const { return ModuleInfos; }
+codeview::FixedStreamArray<SecMapEntry> DbiStream::getSectionMap() const {
+  return SectionMap;
+}
+
+void llvm::pdb::DbiStream::visitSectionContributions(
+    ISectionContribVisitor &Visitor) const {
+  if (SectionContribVersion == DbiSecContribVer60) {
+    for (auto &SC : SectionContribs)
+      Visitor.visit(SC);
+  } else if (SectionContribVersion == DbiSecContribV2) {
+    for (auto &SC : SectionContribs2)
+      Visitor.visit(SC);
+  }
+}
+
+Error DbiStream::initializeSectionContributionData() {
+  StreamReader SCReader(SecContrSubstream);
+  if (auto EC = SCReader.readEnum(SectionContribVersion))
+    return EC;
+
+  if (SectionContribVersion == DbiSecContribVer60)
+    return loadSectionContribs<SectionContrib>(SectionContribs, SCReader);
+  if (SectionContribVersion == DbiSecContribV2)
+    return loadSectionContribs<SectionContrib2>(SectionContribs2, SCReader);
+
+  return make_error<RawError>(raw_error_code::feature_unsupported,
+                              "Unsupported DBI Section Contribution version");
+}
+
+Error DbiStream::initializeSectionMapData() {
+  StreamReader SMReader(SecMapSubstream);
+  const SecMapHeader *Header;
+  if (auto EC = SMReader.readObject(Header))
+    return EC;
+  if (auto EC = SMReader.readArray(SectionMap, Header->SecCount))
+    return EC;
+  return Error::success();
+}
 
 Error DbiStream::initializeFileInfo() {
   struct FileInfoSubstreamHeader {
     ulittle16_t NumModules;     // Total # of modules, should match number of
                                 // records in the ModuleInfo substream.
     ulittle16_t NumSourceFiles; // Total # of source files.  This value is not
                                 // accurate because PDB actually supports more
                                 // than 64k source files, so we ignore it and
                                 // compute the value from other stream fields.
   };
 
   // The layout of the FileInfoSubstream is like this:
   // struct {
   //   ulittle16_t NumModules;
   //   ulittle16_t NumSourceFiles;
   //   ulittle16_t ModIndices[NumModules];
   //   ulittle16_t ModFileCounts[NumModules];
   //   ulittle32_t FileNameOffsets[NumSourceFiles];
   //   char Names[][NumSourceFiles];
   // };
   // with the caveat that `NumSourceFiles` cannot be trusted, so
   // it is computed by summing `ModFileCounts`.
   //
   const FileInfoSubstreamHeader *FH;
-  codeview::StreamReader FISR(FileInfoSubstream);
+  StreamReader FISR(FileInfoSubstream);
   if (auto EC = FISR.readObject(FH))
     return EC;
 
   // The number of modules in the stream should be the same as reported by
   // the FileInfoSubstreamHeader.
   if (FH->NumModules != ModuleInfos.size())
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "FileInfo substream count doesn't match DBI.");
 
-  codeview::FixedStreamArray<ulittle16_t> ModIndexArray;
-  codeview::FixedStreamArray<ulittle16_t> ModFileCountArray;
-  codeview::FixedStreamArray<little32_t> FileNameOffsets;
+  FixedStreamArray<ulittle16_t> ModIndexArray;
+  FixedStreamArray<ulittle16_t> ModFileCountArray;
+  FixedStreamArray<little32_t> FileNameOffsets;
 
   // First is an array of `NumModules` module indices.  This is not used for the
   // same reason that `NumSourceFiles` is not used.  It's an array of uint16's,
   // but it's possible there are more than 64k source files, which would imply
   // more than 64k modules (e.g. object files) as well.  So we ignore this
   // field.
   if (auto EC = FISR.readArray(ModIndexArray, ModuleInfos.size()))
     return EC;
Error DbiStream::initializeFileInfo() {
   // when reading from the file on 64-bit systems, we continue to ignore that
   // field in `ModInfo`, and instead build a vector of StringRefs and stores
   // them in `ModuleInfoEx`.  The value written to and read from the file is
   // not used anyway, it is only there as a way to store the offsets for the
   // purposes of later accessing the names at runtime.
   if (auto EC = FISR.readArray(FileNameOffsets, NumSourceFiles))
     return EC;
 
-  codeview::StreamRef NamesBufferRef;
+  StreamRef NamesBufferRef;
   if (auto EC = FISR.readStreamRef(NamesBufferRef))
     return EC;
-  codeview::StreamReader Names(NamesBufferRef);
+  StreamReader Names(NamesBufferRef);
 
   // We go through each ModuleInfo, determine the number N of source files for
   // that module, and then get the next N offsets from the Offsets array, using
   // them to get the corresponding N names from the Names buffer and associating
   // each one with the corresponding module.
   uint32_t NextFileIndex = 0;
   for (size_t I = 0; I < ModuleInfos.size(); ++I) {
     uint32_t NumFiles = ModFileCountArray[I];

lib/DebugInfo/PDB/Raw/EnumTables.cpp

+//===- EnumTables.cpp - Enum to string conversion tables --------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/PDB/Raw/EnumTables.h"
+#include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
+
+using namespace llvm;
+using namespace llvm::pdb;
+
+#define PDB_ENUM_CLASS_ENT(enum_class, enum)                                   \
+  { #enum, std::underlying_type < enum_class > ::type(enum_class::enum) }
+
+#define PDB_ENUM_ENT(ns, enum)                                                 \
+  { #enum, ns::enum }
+
+static const EnumEntry<uint16_t> OMFSegMapDescFlagNames[] = {
+    PDB_ENUM_CLASS_ENT(OMFSegDescFlags, Read),
+    PDB_ENUM_CLASS_ENT(OMFSegDescFlags, Write),
+    PDB_ENUM_CLASS_ENT(OMFSegDescFlags, Execute),
+    PDB_ENUM_CLASS_ENT(OMFSegDescFlags, AddressIs32Bit),
+    PDB_ENUM_CLASS_ENT(OMFSegDescFlags, IsSelector),
+    PDB_ENUM_CLASS_ENT(OMFSegDescFlags, IsAbsoluteAddress),
+    PDB_ENUM_CLASS_ENT(OMFSegDescFlags, IsGroup),
+};
+
+namespace llvm {
+namespace pdb {
+ArrayRef<EnumEntry<uint16_t>> getOMFSegMapDescFlagNames() {
+  return makeArrayRef(OMFSegMapDescFlagNames);
+}
+}
+}
 No newline at end of file

lib/DebugInfo/PDB/Raw/ModStream.cpp

if (auto EC = Reader.readInteger(SymbolSubstreamSig))
     return EC;
   if (auto EC = Reader.readArray(SymbolsSubstream, SymbolSize - 4))
     return EC;
 
   if (auto EC = Reader.readStreamRef(LinesSubstream, C11Size))
     return EC;
   if (auto EC = Reader.readStreamRef(C13LinesSubstream, C13Size))
     return EC;
+  ArrayRef<uint8_t> LineBytes;
+  codeview::StreamReader LinesReader(C13LinesSubstream);
+  if (auto EC = LinesReader.readBytes(LineBytes, C13LinesSubstream.getLength()))
+    return EC;
 
   uint32_t GlobalRefsSize;
   if (auto EC = Reader.readInteger(GlobalRefsSize))
     return EC;
   if (auto EC = Reader.readStreamRef(GlobalRefsSubstream, GlobalRefsSize))
     return EC;
   if (Reader.bytesRemaining() > 0)
     return llvm::make_error<RawError>(raw_error_code::corrupt_file,

test/DebugInfo/PDB/pdbdump-headers.test

 ; EMPTY-NEXT:         }
 ; EMPTY-NEXT:         {
 ; EMPTY-NEXT:           Section {
 ; EMPTY-NEXT:             SectionNumber: 1
 ; EMPTY-NEXT:             Alignment: 12
 ; EMPTY-NEXT:             Reserved: 0
 ; EMPTY-NEXT:             Rva: 4096
 ; EMPTY-NEXT:             Length: 4122
-; EMPTY-NEXT:             Characteristics: 0x60000020
+; EMPTY-NEXT:             Characteristics [ (0x60000020)
+; EMPTY-NEXT:               IMAGE_SCN_CNT_CODE (0x20)
+; EMPTY-NEXT:               IMAGE_SCN_MEM_EXECUTE (0x20000000)
+; EMPTY-NEXT:               IMAGE_SCN_MEM_READ (0x40000000)
+; EMPTY-NEXT:             ]
 ; EMPTY-NEXT:             Name: .text
 ; EMPTY-NEXT:           }
 ; EMPTY-NEXT:           Bytes (
 ; EMPTY-NEXT:             0000: 01000C00 00100000 1A100000 20000060  |............ ..`|
 ; EMPTY-NEXT:             0010: 2E746578 74000000                    |.text...|
 ; EMPTY-NEXT:           )
 ; EMPTY-NEXT:         }
 ; EMPTY-NEXT:         {
 ; EMPTY-NEXT:           COFF Group {
 ; EMPTY-NEXT:             Size: 4122
-; EMPTY-NEXT:             Characteristics: 0x60000020
+; EMPTY-NEXT:             Characteristics [ (0x60000020)
+; EMPTY-NEXT:               IMAGE_SCN_CNT_CODE (0x20)
+; EMPTY-NEXT:               IMAGE_SCN_MEM_EXECUTE (0x20000000)
+; EMPTY-NEXT:               IMAGE_SCN_MEM_READ (0x40000000)
+; EMPTY-NEXT:             ]
 ; EMPTY-NEXT:             Offset: 0
 ; EMPTY-NEXT:             Segment: 1
 ; EMPTY-NEXT:             Name: .text$mn
 ; EMPTY-NEXT:           }
 ; EMPTY-NEXT:           Bytes (
 ; EMPTY-NEXT:             0000: 1A100000 20000060 00000000 01002E74  |.... ..`.......t|
 ; EMPTY-NEXT:             0010: 65787424 6D6E0000                    |ext$mn..|
 ; EMPTY-NEXT:           )
 ; EMPTY-NEXT:         }
 ; EMPTY-NEXT:         {
 ; EMPTY-NEXT:           Section {
 ; EMPTY-NEXT:             SectionNumber: 2
 ; EMPTY-NEXT:             Alignment: 12
 ; EMPTY-NEXT:             Reserved: 0
 ; EMPTY-NEXT:             Rva: 12288
 ; EMPTY-NEXT:             Length: 690
-; EMPTY-NEXT:             Characteristics: 0x40000040
+; EMPTY-NEXT:             Characteristics [ (0x40000040)
+; EMPTY-NEXT:               IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; EMPTY-NEXT:               IMAGE_SCN_MEM_READ (0x40000000)
+; EMPTY-NEXT:             ]
 ; EMPTY-NEXT:             Name: .rdata
 ; EMPTY-NEXT:           }
 ; EMPTY-NEXT:           Bytes (
 ; EMPTY-NEXT:             0000: 02000C00 00300000 B2020000 40000040  |.....0......@..@|
 ; EMPTY-NEXT:             0010: 2E726461 74610000                    |.rdata..|
 ; EMPTY-NEXT:           )
 ; EMPTY-NEXT:         }
 ; EMPTY-NEXT:         {
 ; EMPTY-NEXT:           COFF Group {
 ; EMPTY-NEXT:             Size: 323
-; EMPTY-NEXT:             Characteristics: 0x40000040
+; EMPTY-NEXT:             Characteristics [ (0x40000040)
+; EMPTY-NEXT:               IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; EMPTY-NEXT:               IMAGE_SCN_MEM_READ (0x40000000)
+; EMPTY-NEXT:             ]
 ; EMPTY-NEXT:             Offset: 0
 ; EMPTY-NEXT:             Segment: 2
 ; EMPTY-NEXT:             Name: .rdata
 ; EMPTY-NEXT:           }
 ; EMPTY-NEXT:           Bytes (
 ; EMPTY-NEXT:             0000: 43010000 40000040 00000000 02002E72  |C...@..@.......r|
 ; EMPTY-NEXT:             0010: 64617461 00000000                    |data....|
 ; EMPTY-NEXT:           )
 ; EMPTY-NEXT:         }
 ; EMPTY-NEXT:         {
 ; EMPTY-NEXT:           COFF Group {
 ; EMPTY-NEXT:             Size: 0
-; EMPTY-NEXT:             Characteristics: 0x40000040
+; EMPTY-NEXT:             Characteristics [ (0x40000040)
+; EMPTY-NEXT:               IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; EMPTY-NEXT:               IMAGE_SCN_MEM_READ (0x40000000)
+; EMPTY-NEXT:             ]
 ; EMPTY-NEXT:             Offset: 323
 ; EMPTY-NEXT:             Segment: 2
 ; EMPTY-NEXT:             Name: .edata
 ; EMPTY-NEXT:           }
 ; EMPTY-NEXT:           Bytes (
 ; EMPTY-NEXT:             0000: 00000000 40000040 43010000 02002E65  |....@..@C......e|
 ; EMPTY-NEXT:             0010: 64617461 00000000                    |data....|
 ; EMPTY-NEXT:           )
 ; EMPTY-NEXT:         }
 ; EMPTY-NEXT:         {
 ; EMPTY-NEXT:           COFF Group {
 ; EMPTY-NEXT:             Size: 366
-; EMPTY-NEXT:             Characteristics: 0x40000040
+; EMPTY-NEXT:             Characteristics [ (0x40000040)
+; EMPTY-NEXT:               IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; EMPTY-NEXT:               IMAGE_SCN_MEM_READ (0x40000000)
+; EMPTY-NEXT:             ]
 ; EMPTY-NEXT:             Offset: 324
 ; EMPTY-NEXT:             Segment: 2
 ; EMPTY-NEXT:             Name: .rdata$debug
 ; EMPTY-NEXT:           }
 ; EMPTY-NEXT:           Bytes (
 ; EMPTY-NEXT:             0000: 6E010000 40000040 44010000 02002E72  |n...@..@D......r|
 ; EMPTY-NEXT:             0010: 64617461 24646562 75670000           |data$debug..|
 ; EMPTY-NEXT:           )
 ; EMPTY-NEXT:         }
 ; EMPTY-NEXT:         {
 ; EMPTY-NEXT:           Section {
 ; EMPTY-NEXT:             SectionNumber: 3
 ; EMPTY-NEXT:             Alignment: 12
 ; EMPTY-NEXT:             Reserved: 0
 ; EMPTY-NEXT:             Rva: 16384
 ; EMPTY-NEXT:             Length: 4
-; EMPTY-NEXT:             Characteristics: 0xC0000040
+; EMPTY-NEXT:             Characteristics [ (0xC0000040)
+; EMPTY-NEXT:               IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; EMPTY-NEXT:               IMAGE_SCN_MEM_READ (0x40000000)
+; EMPTY-NEXT:               IMAGE_SCN_MEM_WRITE (0x80000000)
+; EMPTY-NEXT:             ]
 ; EMPTY-NEXT:             Name: .data
 ; EMPTY-NEXT:           }
 ; EMPTY-NEXT:           Bytes (
 ; EMPTY-NEXT:             0000: 03000C00 00400000 04000000 400000C0  |.....@......@...|
 ; EMPTY-NEXT:             0010: 2E646174 61000000                    |.data...|
 ; EMPTY-NEXT:           )
 ; EMPTY-NEXT:         }
 ; EMPTY-NEXT:         {
 ; EMPTY-NEXT:           COFF Group {
 ; EMPTY-NEXT:             Size: 4
-; EMPTY-NEXT:             Characteristics: 0xC0000080
+; EMPTY-NEXT:             Characteristics [ (0xC0000080)
+; EMPTY-NEXT:               IMAGE_SCN_CNT_UNINITIALIZED_DATA (0x80)
+; EMPTY-NEXT:               IMAGE_SCN_MEM_READ (0x40000000)
+; EMPTY-NEXT:               IMAGE_SCN_MEM_WRITE (0x80000000)
+; EMPTY-NEXT:             ]
 ; EMPTY-NEXT:             Offset: 0
 ; EMPTY-NEXT:             Segment: 3
 ; EMPTY-NEXT:             Name: .bss
 ; EMPTY-NEXT:           }
 ; EMPTY-NEXT:           Bytes (
 ; EMPTY-NEXT:             0000: 04000000 800000C0 00000000 03002E62  |...............b|
 ; EMPTY-NEXT:             0010: 73730000                             |ss..|
 ; EMPTY-NEXT:           )
 ; EMPTY-NEXT:         }
 ; EMPTY-NEXT:         {
 ; EMPTY-NEXT:           Section {
 ; EMPTY-NEXT:             SectionNumber: 4
 ; EMPTY-NEXT:             Alignment: 12
 ; EMPTY-NEXT:             Reserved: 0
 ; EMPTY-NEXT:             Rva: 20480
 ; EMPTY-NEXT:             Length: 8
-; EMPTY-NEXT:             Characteristics: 0x42000040
+; EMPTY-NEXT:             Characteristics [ (0x42000040)
+; EMPTY-NEXT:               IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; EMPTY-NEXT:               IMAGE_SCN_MEM_DISCARDABLE (0x2000000)
+; EMPTY-NEXT:               IMAGE_SCN_MEM_READ (0x40000000)
+; EMPTY-NEXT:             ]
 ; EMPTY-NEXT:             Name: .reloc
 ; EMPTY-NEXT:           }
 ; EMPTY-NEXT:           Bytes (
 ; EMPTY-NEXT:             0000: 04000C00 00500000 08000000 40000042  |.....P......@..B|
 ; EMPTY-NEXT:             0010: 2E72656C 6F630000                    |.reloc..|
 ; EMPTY-NEXT:           )
 ; EMPTY-NEXT:         }
 ; EMPTY-NEXT:       ]

 ; ALL:         }
 ; ALL:         {
 ; ALL:           Section {
 ; ALL:             SectionNumber: 1
 ; ALL:             Alignment: 12
 ; ALL:             Reserved: 0
 ; ALL:             Rva: 4096
 ; ALL:             Length: 4122
-; ALL:             Characteristics: 0x60000020
+; ALL:             Characteristics [ (0x60000020)
+; ALL:               IMAGE_SCN_CNT_CODE (0x20)
+; ALL:               IMAGE_SCN_MEM_EXECUTE (0x20000000)
+; ALL:               IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:             ]
 ; ALL:             Name: .text
 ; ALL:           }
 ; ALL:         }
 ; ALL:         {
 ; ALL:           COFF Group {
 ; ALL:             Size: 4122
-; ALL:             Characteristics: 0x60000020
+; ALL:             Characteristics [ (0x60000020)
+; ALL:               IMAGE_SCN_CNT_CODE (0x20)
+; ALL:               IMAGE_SCN_MEM_EXECUTE (0x20000000)
+; ALL:               IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:             ]
 ; ALL:             Offset: 0
 ; ALL:             Segment: 1
 ; ALL:             Name: .text$mn
 ; ALL:           }
 ; ALL:         }
 ; ALL:         {
 ; ALL:           Section {
 ; ALL:             SectionNumber: 2
 ; ALL:             Alignment: 12
 ; ALL:             Reserved: 0
 ; ALL:             Rva: 12288
 ; ALL:             Length: 690
-; ALL:             Characteristics: 0x40000040
+; ALL:             Characteristics [ (0x40000040)
+; ALL:               IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; ALL:               IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:             ]
 ; ALL:             Name: .rdata
 ; ALL:           }
 ; ALL:         }
 ; ALL:         {
 ; ALL:           COFF Group {
 ; ALL:             Size: 323
-; ALL:             Characteristics: 0x40000040
+; ALL:             Characteristics [ (0x40000040)
+; ALL:               IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; ALL:               IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:             ]
 ; ALL:             Offset: 0
 ; ALL:             Segment: 2
 ; ALL:             Name: .rdata
 ; ALL:           }
 ; ALL:         }
 ; ALL:         {
 ; ALL:           COFF Group {
 ; ALL:             Size: 0
-; ALL:             Characteristics: 0x40000040
+; ALL:             Characteristics [ (0x40000040)
+; ALL:               IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; ALL:               IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:             ]
 ; ALL:             Offset: 323
 ; ALL:             Segment: 2
 ; ALL:             Name: .edata
 ; ALL:           }
 ; ALL:         }
 ; ALL:         {
 ; ALL:           COFF Group {
 ; ALL:             Size: 366
-; ALL:             Characteristics: 0x40000040
+; ALL:             Characteristics [ (0x40000040)
+; ALL:               IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; ALL:               IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:             ]
 ; ALL:             Offset: 324
 ; ALL:             Segment: 2
 ; ALL:             Name: .rdata$debug
 ; ALL:           }
 ; ALL:         }
 ; ALL:         {
 ; ALL:           Section {
 ; ALL:             SectionNumber: 3
 ; ALL:             Alignment: 12
 ; ALL:             Reserved: 0
 ; ALL:             Rva: 16384
 ; ALL:             Length: 4
-; ALL:             Characteristics: 0xC0000040
+; ALL:             Characteristics [ (0xC0000040)
+; ALL:               IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; ALL:               IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:               IMAGE_SCN_MEM_WRITE (0x80000000)
+; ALL:             ]
 ; ALL:             Name: .data
 ; ALL:           }
 ; ALL:         }
 ; ALL:         {
 ; ALL:           COFF Group {
 ; ALL:             Size: 4
-; ALL:             Characteristics: 0xC0000080
+; ALL:             Characteristics [ (0xC0000080)
+; ALL:               IMAGE_SCN_CNT_UNINITIALIZED_DATA (0x80)
+; ALL:               IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:               IMAGE_SCN_MEM_WRITE (0x80000000)
+; ALL:             ]
 ; ALL:             Offset: 0
 ; ALL:             Segment: 3
 ; ALL:             Name: .bss
 ; ALL:           }
 ; ALL:         }
 ; ALL:         {
 ; ALL:           Section {
 ; ALL:             SectionNumber: 4
 ; ALL:             Alignment: 12
 ; ALL:             Reserved: 0
 ; ALL:             Rva: 20480
 ; ALL:             Length: 8
-; ALL:             Characteristics: 0x42000040
+; ALL:             Characteristics [ (0x42000040)
+; ALL:               IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; ALL:               IMAGE_SCN_MEM_DISCARDABLE (0x2000000)
+; ALL:               IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:             ]
 ; ALL:             Name: .reloc
 ; ALL:           }
 ; ALL:         }
 ; ALL:       ]
 ; ALL:     }
 ; ALL:   ]
 ; ALL: }
+; ALL: Section Contributions [
+; ALL:   Contribution {
+; ALL:     ISect: 1
+; ALL:     Off: 0
+; ALL:     Size: 10
+; ALL:     Characteristics [ (0x60000020)
+; ALL:       IMAGE_SCN_CNT_CODE (0x20)
+; ALL:       IMAGE_SCN_MEM_EXECUTE (0x20000000)
+; ALL:       IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:     ]
+; ALL:     Module {
+; ALL:       Index: 1
+; ALL:       Name: * Linker *
+; ALL:     }
+; ALL:     Data CRC: 0
+; ALL:     Reloc CRC: 0
+; ALL:   }
+; ALL:   Contribution {
+; ALL:     ISect: 1
+; ALL:     Off: 16
+; ALL:     Size: 10
+; ALL:     Characteristics [ (0x60500020)
+; ALL:       IMAGE_SCN_ALIGN_16BYTES (0x500000)
+; ALL:       IMAGE_SCN_CNT_CODE (0x20)
+; ALL:       IMAGE_SCN_MEM_EXECUTE (0x20000000)
+; ALL:       IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:     ]
+; ALL:     Module {
+; ALL:       Index: 0
+; ALL:       Name: d:\src\llvm\test\DebugInfo\PDB\Inputs\empty.obj
+; ALL:     }
+; ALL:     Data CRC: 3617027124
+; ALL:     Reloc CRC: 0
+; ALL:   }
+; ALL:   Contribution {
+; ALL:     ISect: 2
+; ALL:     Off: 0
+; ALL:     Size: 56
+; ALL:     Characteristics [ (0x40000040)
+; ALL:       IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; ALL:       IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:     ]
+; ALL:     Module {
+; ALL:       Index: 1
+; ALL:       Name: * Linker *
+; ALL:     }
+; ALL:     Data CRC: 0
+; ALL:     Reloc CRC: 0
+; ALL:   }
+; ALL:   Contribution {
+; ALL:     ISect: 2
+; ALL:     Off: 324
+; ALL:     Size: 72
+; ALL:     Characteristics [ (0x40300040)
+; ALL:       IMAGE_SCN_ALIGN_4BYTES (0x300000)
+; ALL:       IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; ALL:       IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:     ]
+; ALL:     Module {
+; ALL:       Index: 1
+; ALL:       Name: * Linker *
+; ALL:     }
+; ALL:     Data CRC: 0
+; ALL:     Reloc CRC: 0
+; ALL:   }
+; ALL:   Contribution {
+; ALL:     ISect: 2
+; ALL:     Off: 396
+; ALL:     Size: 20
+; ALL:     Characteristics [ (0x40300040)
+; ALL:       IMAGE_SCN_ALIGN_4BYTES (0x300000)
+; ALL:       IMAGE_SCN_CNT_INITIALIZED_DATA (0x40)
+; ALL:       IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:     ]
+; ALL:     Module {
+; ALL:       Index: 1
+; ALL:       Name: * Linker *
+; ALL:     }
+; ALL:     Data CRC: 0
+; ALL:     Reloc CRC: 0
+; ALL:   }
+; ALL:   Contribution {
+; ALL:     ISect: 3
+; ALL:     Off: 0
+; ALL:     Size: 4
+; ALL:     Characteristics [ (0xC0300080)
+; ALL:       IMAGE_SCN_ALIGN_4BYTES (0x300000)
+; ALL:       IMAGE_SCN_CNT_UNINITIALIZED_DATA (0x80)
+; ALL:       IMAGE_SCN_MEM_READ (0x40000000)
+; ALL:       IMAGE_SCN_MEM_WRITE (0x80000000)
+; ALL:     ]
+; ALL:     Module {
+; ALL:       Index: 0
+; ALL:       Name: d:\src\llvm\test\DebugInfo\PDB\Inputs\empty.obj
+; ALL:     }
+; ALL:     Data CRC: 0
+; ALL:     Reloc CRC: 0
+; ALL:   }
+; ALL: ]
+; ALL: Section Map [
+; ALL:   Entry {
+; ALL:     Flags: 269
+; ALL:     Ovl: 0
+; ALL:     Group: 0
+; ALL:     Frame: 1
+; ALL:     SecName: 65535
+; ALL:     ClassName: 65535
+; ALL:     Offset: 0
+; ALL:     SecByteLength: 4122
+; ALL:   }
+; ALL:   Entry {
+; ALL:     Flags: 265
+; ALL:     Ovl: 0
+; ALL:     Group: 0
+; ALL:     Frame: 2
+; ALL:     SecName: 65535
+; ALL:     ClassName: 65535
+; ALL:     Offset: 0
+; ALL:     SecByteLength: 690
+; ALL:   }
+; ALL:   Entry {
+; ALL:     Flags: 267
+; ALL:     Ovl: 0
+; ALL:     Group: 0
+; ALL:     Frame: 3
+; ALL:     SecName: 65535
+; ALL:     ClassName: 65535
+; ALL:     Offset: 0
+; ALL:     SecByteLength: 4
+; ALL:   }
+; ALL:   Entry {
+; ALL:     Flags: 265
+; ALL:     Ovl: 0
+; ALL:     Group: 0
+; ALL:     Frame: 4
+; ALL:     SecName: 65535
+; ALL:     ClassName: 65535
+; ALL:     Offset: 0
+; ALL:     SecByteLength: 8
+; ALL:   }
+; ALL:   Entry {
+; ALL:     Flags: 520
+; ALL:     Ovl: 0
+; ALL:     Group: 0
+; ALL:     Frame: 0
+; ALL:     SecName: 65535
+; ALL:     ClassName: 65535
+; ALL:     Offset: 0
+; ALL:     SecByteLength: 4294967295
+; ALL:   }
+; ALL: ]
 ; ALL: Publics Stream {
 ; ALL:   Stream number: 7
 ; ALL:   SymHash: 556
 ; ALL:   AddrMap: 8
 ; ALL:   Number of buckets: 2
 ; ALL:   Hash Buckets: [0, 12]
 ; ALL:   Address Map: [36, 0]
 ; ALL:   Thunk Map: [4112]

tools/llvm-pdbdump/llvm-pdbdump.cpp

 #include "TypeDumper.h"
 #include "VariableDumper.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Config/config.h"
+#include "llvm/DebugInfo/CodeView/EnumTables.h"
 #include "llvm/DebugInfo/CodeView/StreamReader.h"
 #include "llvm/DebugInfo/CodeView/SymbolDumper.h"
 #include "llvm/DebugInfo/CodeView/TypeDumper.h"
 #include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
 #include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
 #include "llvm/DebugInfo/PDB/PDB.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolThunk.h"
 #include "llvm/DebugInfo/PDB/Raw/DbiStream.h"
+#include "llvm/DebugInfo/PDB/Raw/EnumTables.h"
+#include "llvm/DebugInfo/PDB/Raw/ISectionContribVisitor.h"
 #include "llvm/DebugInfo/PDB/Raw/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Raw/ModInfo.h"
 #include "llvm/DebugInfo/PDB/Raw/ModStream.h"
 #include "llvm/DebugInfo/PDB/Raw/NameHashTable.h"
 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Raw/PublicsStream.h"
 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
 #include "llvm/DebugInfo/PDB/Raw/RawSession.h"
 #include "llvm/DebugInfo/PDB/Raw/TpiStream.h"
+#include "llvm/Support/COM.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 
-#if defined(HAVE_DIA_SDK)
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-#include <Windows.h>
-#endif
-
 using namespace llvm;
 using namespace llvm::pdb;
 
 namespace opts {
 
 enum class PDB_DumpType { ByType, ByObjFile, Both };
 
 cl::list<std::string> InputFilenames(cl::Positional,
cl::opt<bool> DumpModules("raw-modules", cl::desc("dump compiland information"),
                           cl::cat(NativeOptions));
 cl::opt<bool> DumpModuleFiles("raw-module-files",
                               cl::desc("dump file information"),
                               cl::cat(NativeOptions));
 cl::opt<bool> DumpModuleSyms("raw-module-syms", cl::desc("dump module symbols"),
                              cl::cat(NativeOptions));
 cl::opt<bool> DumpPublics("raw-publics", cl::desc("dump Publics stream data"),
                           cl::cat(NativeOptions));
+cl::opt<bool> DumpSectionContribs("raw-section-contribs",
+                                  cl::desc("dump section contributions"),
+                                  cl::cat(NativeOptions));
+cl::opt<bool> DumpSectionMap("raw-section-map", cl::desc("dump section map"),
+                             cl::cat(NativeOptions));
 cl::opt<bool>
     DumpSymRecordBytes("raw-sym-record-bytes",
                        cl::desc("dump CodeView symbol record raw bytes"),
                        cl::cat(NativeOptions));
 cl::opt<bool>
     RawAll("raw-all",
            cl::desc("Implies most other options in 'Native Options' category"),
            cl::cat(NativeOptions));
for (auto &Modi : DS.modules()) {
           return make_error<RawError>(raw_error_code::corrupt_file,
                                       "DBI stream contained corrupt record");
       }
     }
   }
   return Error::success();
 }
 
+static Error dumpSectionContribs(ScopedPrinter &P, PDBFile &File) {
+  if (!opts::DumpSectionContribs)
+    return Error::success();
+
+  auto DbiS = File.getPDBDbiStream();
+  if (auto EC = DbiS.takeError())
+    return EC;
+  DbiStream &DS = DbiS.get();
+  ListScope L(P, "Section Contributions");
+  class Visitor : public ISectionContribVisitor {
+  public:
+    Visitor(ScopedPrinter &P, DbiStream &DS) : P(P), DS(DS) {}
+    void visit(const SectionContrib &SC) override {
+      DictScope D(P, "Contribution");
+      P.printNumber("ISect", SC.ISect);
+      P.printNumber("Off", SC.Off);
+      P.printNumber("Size", SC.Size);
+      P.printFlags("Characteristics", SC.Characteristics,
+                   codeview::getImageSectionCharacteristicNames(),
+                   COFF::SectionCharacteristics(0x00F00000));
+      {
+        DictScope DD(P, "Module");
+        P.printNumber("Index", SC.Imod);
+        auto M = DS.modules();
+        if (M.size() > SC.Imod) {
+          P.printString("Name", M[SC.Imod].Info.getModuleName());
+        }
+      }
+      P.printNumber("Data CRC", SC.DataCrc);
+      P.printNumber("Reloc CRC", SC.RelocCrc);
+      P.flush();
+    }
+    void visit(const SectionContrib2 &SC) override {
+      visit(SC.Base);
+      P.printNumber("ISect Coff", SC.ISectCoff);
+      P.flush();
+    }
+
+  private:
+    ScopedPrinter &P;
+    DbiStream &DS;
+  };
+  Visitor V(P, DS);
+  DS.visitSectionContributions(V);
+  return Error::success();
+}
+
+static Error dumpSectionMap(ScopedPrinter &P, PDBFile &File) {
+  if (!opts::DumpSectionMap)
+    return Error::success();
+
+  auto DbiS = File.getPDBDbiStream();
+  if (auto EC = DbiS.takeError())
+    return EC;
+  DbiStream &DS = DbiS.get();
+  ListScope L(P, "Section Map");
+  for (auto &M : DS.getSectionMap()) {
+    DictScope D(P, "Entry");
+    P.printFlags("Flags", M.Flags, getOMFSegMapDescFlagNames());
+    P.printNumber("Flags", M.Flags);
+    P.printNumber("Ovl", M.Ovl);
+    P.printNumber("Group", M.Group);
+    P.printNumber("Frame", M.Frame);
+    P.printNumber("SecName", M.SecName);
+    P.printNumber("ClassName", M.ClassName);
+    P.printNumber("Offset", M.Offset);
+    P.printNumber("SecByteLength", M.SecByteLength);
+    P.flush();
+  }
+  return Error::success();
+}
+
 static Error dumpTpiStream(ScopedPrinter &P, PDBFile &File,
                            codeview::CVTypeDumper &TD, uint32_t StreamIdx) {
   assert(StreamIdx == StreamTPI || StreamIdx == StreamIPI);
 
   bool DumpRecordBytes = false;
   bool DumpRecords = false;
   StringRef Label;
   StringRef VerLabel;
static Error dumpStructure(RawSession &RS) {
   if (auto EC = dumpTpiStream(P, File, TD, StreamTPI))
     return EC;
   if (auto EC = dumpTpiStream(P, File, TD, StreamIPI))
     return EC;
 
   if (auto EC = dumpDbiStream(P, File, TD))
     return EC;
 
+  if (auto EC = dumpSectionContribs(P, File))
+    return EC;
+
+  if (auto EC = dumpSectionMap(P, File))
+    return EC;
+
   if (auto EC = dumpPublicsStream(P, File, TD))
     return EC;
+
   return Error::success();
 }
 
 bool isRawDumpEnabled() {
   if (opts::DumpHeaders)
     return true;
   if (opts::DumpModules)
     return true;
bool isRawDumpEnabled() {
   if (opts::DumpTpiRecordBytes)
     return true;
   if (opts::DumpTpiRecords)
     return true;
   if (opts::DumpIpiRecords)
     return true;
   if (opts::DumpIpiRecordBytes)
     return true;
+  if (opts::DumpSectionContribs)
+    return true;
+  if (opts::DumpSectionMap)
+    return true;
   return false;
 }
 
 static void dumpInput(StringRef Path) {
   std::unique_ptr<IPDBSession> Session;
   if (isRawDumpEnabled()) {
     ExitOnErr(loadDataForPDB(PDB_ReaderType::Raw, Path, Session));
 
if (opts::RawAll) {
     opts::DumpModules = true;
     opts::DumpModuleFiles = true;
     opts::DumpModuleSyms = true;
     opts::DumpPublics = true;
     opts::DumpStreamSummary = true;
     opts::DumpStreamBlocks = true;
     opts::DumpTpiRecords = true;
     opts::DumpIpiRecords = true;
+    opts::DumpSectionMap = true;
+    opts::DumpSectionContribs = true;
   }
 
   // When adding filters for excluded compilands and types, we need to remember
   // that these are regexes.  So special characters such as * and \ need to be
   // escaped in the regex.  In the case of a literal \, this means it needs to
   // be escaped again in the C++.  So matching a single \ in the input requires
   // 4 \es in the C++.
   if (opts::ExcludeCompilerGenerated) {
     opts::ExcludeTypes.push_back("__vc_attributes");
     opts::ExcludeCompilands.push_back("\\* Linker \\*");
   }
   if (opts::ExcludeSystemLibraries) {
     opts::ExcludeCompilands.push_back(
         "f:\\\\binaries\\\\Intermediate\\\\vctools\\\\crt_bld");
     opts::ExcludeCompilands.push_back("f:\\\\dd\\\\vctools\\\\crt");
     opts::ExcludeCompilands.push_back("d:\\\\th.obj.x86fre\\\\minkernel");
   }
 
-#if defined(HAVE_DIA_SDK)
-  CoInitializeEx(nullptr, COINIT_MULTITHREADED);
-#endif
+  llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);
 
   std::for_each(opts::InputFilenames.begin(), opts::InputFilenames.end(),
                 dumpInput);
 
-#if defined(HAVE_DIA_SDK)
-  CoUninitialize();
-#endif
   outs().flush();
   return 0;
 }