[codeview] Add support for new type records.

This adds support for parsing and dumping the following
symbol types:

S_LPROCREF
S_ENVBLOCK
S_COMPILE2
S_REGISTER
S_COFFGROUP
S_SECTION
S_THUNK32
S_TRAMPOLINE

As of this patch, the test PDB files no longer have any unknown
symbol types.

llvm-svn: 270628

3 files changed, 246 insertions, 64 deletions

diff --git a/llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp b/llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp
index 60a3b8156b6..989772b8fb2 100644
--- a/llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp
+++ b/llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp
@@ -34,6 +34,58 @@ namespace {
 #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),
@@ -78,6 +130,18 @@ static const EnumEntry<codeview::SourceLanguage> SourceLanguages[] = {
     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),
@@ -177,6 +241,21 @@ static const EnumEntry<uint32_t> FrameProcSymFlags[] = {
     CV_ENUM_CLASS_ENT(FrameProcedureOptions, GuardCfw),
 };
 
+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> {
@@ -254,6 +333,49 @@ void CVSymbolDumperImpl::visitBlockSym(SymbolKind Kind, BlockSym &Block) {
   W.printString("LinkageName", LinkageName);
 }
 
+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));
+}
+
+void CVSymbolDumperImpl::visitTrampolineSym(SymbolKind Kind,
+                                            TrampolineSym &Tramp) {
+  DictScope S(W, "Trampoline");
+  W.printEnum("Type", Tramp.Header.Type, makeArrayRef(TrampolineNames));
+  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.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.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");
@@ -287,9 +409,59 @@ void CVSymbolDumperImpl::visitCallSiteInfoSym(SymbolKind Kind,
     W.printString("LinkageName", LinkageName);
 }
 
+void CVSymbolDumperImpl::visitEnvBlockSym(SymbolKind Kind,
+                                          EnvBlockSym &EnvBlock) {
+  DictScope S(W, "EnvBlock");
+
+  W.printNumber("Reserved", EnvBlock.Header.Reserved);
+  ListScope L(W, "Entries");
+  for (auto Entry : EnvBlock.Fields) {
+    W.printString(Entry);
+  }
+}
+
+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.printString("Name", FileStatic.Name);
+}
+
+void CVSymbolDumperImpl::visitCompile2Sym(SymbolKind Kind,
+                                          Compile2Sym &Compile2) {
+  DictScope S(W, "CompilerFlags2");
+
+  W.printEnum("Language", Compile2.Header.getLanguage(),
+              makeArrayRef(SourceLanguages));
+  W.printFlags("Flags", Compile2.Header.flags & ~0xff,
+               makeArrayRef(CompileSym2FlagNames));
+  W.printEnum("Machine", unsigned(Compile2.Header.Machine),
+              makeArrayRef(CPUTypeNames));
+  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, "CompilerFlags");
+  DictScope S(W, "CompilerFlags3");
 
   W.printEnum("Language", Compile3.Header.getLanguage(),
               makeArrayRef(SourceLanguages));
@@ -537,6 +709,15 @@ void CVSymbolDumperImpl::visitInlineSiteSym(SymbolKind Kind,
   }
 }
 
+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.printString("Name", Register.Name);
+}
+
 void CVSymbolDumperImpl::visitPublicSym32(SymbolKind Kind,
                                           PublicSym32 &Public) {
   DictScope S(W, "PublicSym");
diff --git a/llvm/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp b/llvm/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp
index 1bc81d82c95..bba5b0f94dc 100644
--- a/llvm/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp
+++ b/llvm/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp
@@ -534,8 +534,8 @@ uint32_t DIARawSymbol::getLiveRangeStartRelativeVirtualAddress() const {
       Symbol, &IDiaSymbol::get_liveRangeStartRelativeVirtualAddress);
 }
 
-PDB_RegisterId DIARawSymbol::getLocalBasePointerRegisterId() const {
-  return PrivateGetDIAValue<DWORD, PDB_RegisterId>(
+codeview::RegisterId DIARawSymbol::getLocalBasePointerRegisterId() const {
+  return PrivateGetDIAValue<DWORD, codeview::RegisterId>(
       Symbol, &IDiaSymbol::get_localBasePointerRegisterId);
 }
 
@@ -596,9 +596,9 @@ uint32_t DIARawSymbol::getRank() const {
   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_rank);
 }
 
-PDB_RegisterId DIARawSymbol::getRegisterId() const {
-  return PrivateGetDIAValue<DWORD, PDB_RegisterId>(Symbol,
-                                                   &IDiaSymbol::get_registerId);
+codeview::RegisterId DIARawSymbol::getRegisterId() const {
+  return PrivateGetDIAValue<DWORD, codeview::RegisterId>(
+      Symbol, &IDiaSymbol::get_registerId);
 }
 
 uint32_t DIARawSymbol::getRegisterType() const {
@@ -751,8 +751,8 @@ PDB_Machine DIARawSymbol::getMachineType() const {
                                                 &IDiaSymbol::get_machineType);
 }
 
-PDB_ThunkOrdinal DIARawSymbol::getThunkOrdinal() const {
-  return PrivateGetDIAValue<DWORD, PDB_ThunkOrdinal>(
+codeview::ThunkOrdinal DIARawSymbol::getThunkOrdinal() const {
+  return PrivateGetDIAValue<DWORD, codeview::ThunkOrdinal>(
       Symbol, &IDiaSymbol::get_thunkOrdinal);
 }
 
diff --git a/llvm/lib/DebugInfo/PDB/PDBExtras.cpp b/llvm/lib/DebugInfo/PDB/PDBExtras.cpp
index ebad9a072a5..b7eee6e5394 100644
--- a/llvm/lib/DebugInfo/PDB/PDBExtras.cpp
+++ b/llvm/lib/DebugInfo/PDB/PDBExtras.cpp
@@ -90,55 +90,56 @@ raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_DataKind &Data) {
   return OS;
 }
 
-raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_RegisterId &Reg) {
+raw_ostream &llvm::pdb::operator<<(raw_ostream &OS,
+                                   const codeview::RegisterId &Reg) {
   switch (Reg) {
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, AL, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, CL, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, DL, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, BL, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, AH, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, CH, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, DH, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, BH, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, AX, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, CX, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, DX, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, BX, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, SP, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, BP, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, SI, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, DI, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, EAX, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, ECX, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, EDX, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, EBX, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, ESP, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, EBP, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, ESI, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, EDI, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, ES, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, CS, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, SS, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, DS, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, FS, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, GS, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, IP, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RAX, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RBX, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RCX, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RDX, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RSI, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RDI, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RBP, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RSP, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R8, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R9, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R10, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R11, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R12, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R13, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R14, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R15, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, AL, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, CL, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, DL, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, BL, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, AH, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, CH, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, DH, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, BH, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, AX, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, CX, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, DX, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, BX, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, SP, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, BP, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, SI, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, DI, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, EAX, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, ECX, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, EDX, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, EBX, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, ESP, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, EBP, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, ESI, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, EDI, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, ES, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, CS, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, SS, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, DS, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, FS, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, GS, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, IP, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RAX, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RBX, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RCX, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RDX, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RSI, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RDI, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RBP, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RSP, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R8, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R9, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R10, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R11, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R12, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R13, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R14, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R15, OS)
   default:
     OS << static_cast<int>(Reg);
   }
@@ -164,15 +165,15 @@ raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_LocType &Loc) {
 }
 
 raw_ostream &llvm::pdb::operator<<(raw_ostream &OS,
-                                   const PDB_ThunkOrdinal &Thunk) {
+                                   const codeview::ThunkOrdinal &Thunk) {
   switch (Thunk) {
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, BranchIsland, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, Pcode, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, Standard, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, ThisAdjustor, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, TrampIncremental, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, UnknownLoad, OS)
-    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, Vcall, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::ThunkOrdinal, BranchIsland, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::ThunkOrdinal, Pcode, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::ThunkOrdinal, Standard, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::ThunkOrdinal, ThisAdjustor, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::ThunkOrdinal, TrampIncremental, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::ThunkOrdinal, UnknownLoad, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(codeview::ThunkOrdinal, Vcall, OS)
   }
   return OS;
 }