[codeview] Decode and dump FP regs from S_FRAMEPROC records

[rnk]

Summary

There are two registers encoded in the S_FRAMEPROC flags: one for locals
and one for parameters. The encoding is described by the
ExpandEncodedBasePointerReg function in cvinfo.h. Two bits are used to
indicate one of four possible values:

0: no register - Used when there are no variables.
1: SP / standard - Variables are stored relative to the standard SP
   for the ISA.
2: FP - Variables are addressed relative to the ISA frame
   pointer, i.e. EBP on x86. If realignment is required, parameters
   use this. If a dynamic alloca is used, locals will be EBP relative.
3: Alternative - Variables are stored relative to some alternative
   third callee-saved register. This is required to address highly
   aligned locals when there are dynamic stack adjustments. In this
   case, both the incoming SP saved in the standard FP and the current
   SP are at some dynamic offset from the locals. LLVM uses ESI in
   this case, MSVC uses EBX.

Most of the changes in this patch are to pass around the CPU so that we
can decode these into real, named architectural registers.

[rnk]

Actually +@zturner this time.

[zturner]

llvm/include/llvm/DebugInfo/CodeView/SymbolRecord.h

796 ↗

(On Diff #164759)

Can you add an llvm_unreachable() here?

803–804 ↗

(On Diff #164759)

And here.

llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp

63 ↗

(On Diff #164759)

Having the Optional<> seems kinda lame. I think in other places that require "state" in order to dump we just assume that the thing we need is going to be there. Can we just default it to x86 if it's not present?

430–433 ↗

(On Diff #164759)

I keep seeing FP and reading "floating point". Is there any other abbreviation that can remove this ambiguity?

llvm/tools/llvm-readobj/COFFDumper.cpp

1154–1155 ↗

(On Diff #164759)

Yea, so in the minimal symbol dumper we default to X64 if we don't see it. Can we just do the same thing here and remove the Optional?

[rnk]

llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp

63 ↗

(On Diff #164759)

Sure. I feel like I was OCD at first, and then I was lazy for the minimal symbol dumper, but what the heck, less states is better.

430–433 ↗

(On Diff #164759)

Yeah, that's pretty bad. getLocalFramePtrReg?

[rnk]

• use less ambiguous name
• pick a default CPU type for simplicity

lld/trunk/test/COFF/pdb-procid-remapping.test

 # RUN: yaml2obj < %p/Inputs/pdb1.yaml > %t1.obj
 # RUN: yaml2obj < %p/Inputs/pdb2.yaml > %t2.obj
 # RUN: lld-link /debug /pdb:%t.pdb /dll /out:%t.dll /entry:main /nodefaultlib \
 # RUN:   %t1.obj %t2.obj
 
 # RUN: llvm-pdbutil dump -symbols %t.pdb | FileCheck %s
 
 CHECK:                                Symbols
 CHECK-NEXT: ============================================================
 CHECK-LABEL:    Mod 0000 |
 CHECK:                92 | S_GPROC32 [size = 44] `main`
 CHECK-NEXT:                parent = 0, end = 168, addr = 0001:0000, code size = 14
 CHECK-NEXT:                type = `0x1004 (int (<no type>))`, debug start = 4, debug end = 9, flags = none
 CHECK-NEXT:          136 | S_FRAMEPROC [size = 32]
 CHECK-NEXT:                size = 40, padding size = 0, offset to padding = 0
 CHECK-NEXT:                bytes of callee saved registers = 0, exception handler addr = 0000:0000
+CHECK-NEXT:                local fp reg = NONE, param fp reg = NONE
 CHECK-NEXT:                flags = has async eh | opt speed
 CHECK-NEXT:          168 | S_END [size = 4]
 CHECK-LABEL:    Mod 0001 |
 CHECK:                92 | S_GPROC32 [size = 44] `foo`
 CHECK-NEXT:                parent = 0, end = 168, addr = 0001:0016, code size = 6
 CHECK-NEXT:                type = `0x1001 (int ())`, debug start = 0, debug end = 5, flags = none
 CHECK-NEXT:          136 | S_FRAMEPROC [size = 32]
 CHECK-NEXT:                size = 0, padding size = 0, offset to padding = 0
 CHECK-NEXT:                bytes of callee saved registers = 0, exception handler addr = 0000:0000
+CHECK-NEXT:                local fp reg = NONE, param fp reg = NONE
 CHECK-NEXT:                flags = has async eh | opt speed
 CHECK-NEXT:          168 | S_END [size = 4]
 CHECK-LABEL:    Mod 0002 |
 CHECK:                 4 | S_OBJNAME [size = 20] sig=0, `* Linker *`

llvm/trunk/include/llvm/DebugInfo/CodeView/CodeView.h

enum class FrameProcedureOptions : uint32_t {
   HasStructuredExceptionHandling = 0x00000040,
   Naked = 0x00000080,
   SecurityChecks = 0x00000100,
   AsynchronousExceptionHandling = 0x00000200,
   NoStackOrderingForSecurityChecks = 0x00000400,
   Inlined = 0x00000800,
   StrictSecurityChecks = 0x00001000,
   SafeBuffers = 0x00002000,
+  EncodedLocalBasePointerMask = 0x0000C000,
+  EncodedParamBasePointerMask = 0x00030000,
   ProfileGuidedOptimization = 0x00040000,
   ValidProfileCounts = 0x00080000,
   OptimizedForSpeed = 0x00100000,
   GuardCfg = 0x00200000,
   GuardCfw = 0x00400000
 };
 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(FrameProcedureOptions)
 

llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolDumper.h

 namespace codeview {
 class TypeCollection;
 
 /// Dumper for CodeView symbol streams found in COFF object files and PDB files.
 class CVSymbolDumper {
 public:
   CVSymbolDumper(ScopedPrinter &W, TypeCollection &Types,
                  CodeViewContainer Container,
-                 std::unique_ptr<SymbolDumpDelegate> ObjDelegate,
+                 std::unique_ptr<SymbolDumpDelegate> ObjDelegate, CPUType CPU,
                  bool PrintRecordBytes)
       : W(W), Types(Types), Container(Container),
-        ObjDelegate(std::move(ObjDelegate)),
+        ObjDelegate(std::move(ObjDelegate)), CompilationCPUType(CPU),
         PrintRecordBytes(PrintRecordBytes) {}
 
   /// Dumps one type record.  Returns false if there was a type parsing error,
   /// and true otherwise.  This should be called in order, since the dumper
   /// maintains state about previous records which are necessary for cross
   /// type references.
   Error dump(CVRecord<SymbolKind> &Record);
 
   /// Dumps the type records in Data. Returns false if there was a type stream
   /// parse error, and true otherwise.
   Error dump(const CVSymbolArray &Symbols);
 
+  CPUType getCompilationCPUType() const { return CompilationCPUType; }
+
 private:
   ScopedPrinter &W;
   TypeCollection &Types;
   CodeViewContainer Container;
   std::unique_ptr<SymbolDumpDelegate> ObjDelegate;
-
+  CPUType CompilationCPUType;
   bool PrintRecordBytes;
 };
 } // end namespace codeview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_SYMBOLDUMPER_H

llvm/trunk/include/llvm/DebugInfo/CodeView/SymbolRecord.h

public:
   uint32_t TotalFrameBytes;
   uint32_t PaddingFrameBytes;
   uint32_t OffsetToPadding;
   uint32_t BytesOfCalleeSavedRegisters;
   uint32_t OffsetOfExceptionHandler;
   uint16_t SectionIdOfExceptionHandler;
   FrameProcedureOptions Flags;
 
+  /// Extract the register this frame uses to refer to local variables.
+  RegisterId getLocalFramePtrReg(CPUType CPU) const {
+    return decodeFramePtrReg((uint32_t(Flags) >> 14U) & 0x3U, CPU);
+  }
+
+  /// Extract the register this frame uses to refer to parameters.
+  RegisterId getParamFramePtrReg(CPUType CPU) const {
+    return decodeFramePtrReg((uint32_t(Flags) >> 16U) & 0x3U, CPU);
+  }
+
   uint32_t RecordOffset;
+
+private:
+  static RegisterId decodeFramePtrReg(uint32_t EncodedReg, CPUType CPU) {
+    assert(EncodedReg < 4);
+    switch (CPU) {
+    // FIXME: Add ARM and AArch64 variants here.
+    default:
+      break;
+    case CPUType::Intel8080:
+    case CPUType::Intel8086:
+    case CPUType::Intel80286:
+    case CPUType::Intel80386:
+    case CPUType::Intel80486:
+    case CPUType::Pentium:
+    case CPUType::PentiumPro:
+    case CPUType::Pentium3:
+      switch (EncodedReg) {
+      case 0: return RegisterId::NONE;
+      case 1: return RegisterId::VFRAME;
+      case 2: return RegisterId::EBP;
+      case 3: return RegisterId::EBX;
+      }
+      llvm_unreachable("bad encoding");
+    case CPUType::X64:
+      switch (EncodedReg) {
+      case 0: return RegisterId::NONE;
+      case 1: return RegisterId::RSP;
+      case 2: return RegisterId::RBP;
+      case 3: return RegisterId::R13;
+      }
+      llvm_unreachable("bad encoding");
+    }
+    return RegisterId::NONE;
+  }
 };
 
 // S_CALLSITEINFO
 class CallSiteInfoSym : public SymbolRecord {
   static constexpr uint32_t RelocationOffset = 4;
 
 public:
   explicit CallSiteInfoSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}

llvm/trunk/lib/DebugInfo/CodeView/EnumTables.cpp

static const EnumEntry<uint32_t> FrameProcSymFlagNames[] = {
     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, EncodedLocalBasePointerMask),
+    CV_ENUM_CLASS_ENT(FrameProcedureOptions, EncodedParamBasePointerMask),
     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<uint32_t> ModuleSubstreamKindNames[] = {

llvm/trunk/lib/DebugInfo/CodeView/SymbolDumper.cpp

 using namespace llvm::codeview;
 
 namespace {
 /// Use this private dumper implementation to keep implementation details about
 /// the visitor out of SymbolDumper.h.
 class CVSymbolDumperImpl : public SymbolVisitorCallbacks {
 public:
   CVSymbolDumperImpl(TypeCollection &Types, SymbolDumpDelegate *ObjDelegate,
-                     ScopedPrinter &W, bool PrintRecordBytes)
-      : Types(Types), ObjDelegate(ObjDelegate), W(W),
+                     ScopedPrinter &W, CPUType CPU, bool PrintRecordBytes)
+      : Types(Types), ObjDelegate(ObjDelegate), W(W), CompilationCPUType(CPU),
         PrintRecordBytes(PrintRecordBytes), InFunctionScope(false) {}
 
 /// CVSymbolVisitor overrides.
 #define SYMBOL_RECORD(EnumName, EnumVal, Name)                                 \
   Error visitKnownRecord(CVSymbol &CVR, Name &Record) override;
 #define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
 
   Error visitSymbolBegin(CVSymbol &Record) override;
   Error visitSymbolEnd(CVSymbol &Record) override;
   Error visitUnknownSymbol(CVSymbol &Record) override;
 
+  CPUType getCompilationCPUType() const { return CompilationCPUType; }
+
 private:
   void printLocalVariableAddrRange(const LocalVariableAddrRange &Range,
                                    uint32_t RelocationOffset);
   void printLocalVariableAddrGap(ArrayRef<LocalVariableAddrGap> Gaps);
   void printTypeIndex(StringRef FieldName, TypeIndex TI);
 
   TypeCollection &Types;
   SymbolDumpDelegate *ObjDelegate;
   ScopedPrinter &W;
 
+  /// Save the machine or CPU type when dumping a compile symbols.
+  CPUType CompilationCPUType = CPUType::X64;
+
   bool PrintRecordBytes;
   bool InFunctionScope;
 };
 }
 
 static StringRef getSymbolKindName(SymbolKind Kind) {
   switch (Kind) {
 #define SYMBOL_RECORD(EnumName, EnumVal, Name)                                 \
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, ExportSym &Export) {
   return Error::success();
 }
 
 Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
                                            Compile2Sym &Compile2) {
   W.printEnum("Language", Compile2.getLanguage(), getSourceLanguageNames());
   W.printFlags("Flags", Compile2.getFlags(), getCompileSym2FlagNames());
   W.printEnum("Machine", unsigned(Compile2.Machine), getCPUTypeNames());
+  CompilationCPUType = Compile2.Machine;
   std::string FrontendVersion;
   {
     raw_string_ostream Out(FrontendVersion);
     Out << Compile2.VersionFrontendMajor << '.' << Compile2.VersionFrontendMinor
         << '.' << Compile2.VersionFrontendBuild;
   }
   std::string BackendVersion;
   {
     raw_string_ostream Out(BackendVersion);
     Out << Compile2.VersionBackendMajor << '.' << Compile2.VersionBackendMinor
         << '.' << Compile2.VersionBackendBuild;
   }
   W.printString("FrontendVersion", FrontendVersion);
   W.printString("BackendVersion", BackendVersion);
   W.printString("VersionName", Compile2.Version);
   return Error::success();
 }
 
 Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
                                            Compile3Sym &Compile3) {
   W.printEnum("Language", Compile3.getLanguage(), getSourceLanguageNames());
   W.printFlags("Flags", Compile3.getFlags(), getCompileSym3FlagNames());
   W.printEnum("Machine", unsigned(Compile3.Machine), getCPUTypeNames());
+  CompilationCPUType = Compile3.Machine;
   std::string FrontendVersion;
   {
     raw_string_ostream Out(FrontendVersion);
     Out << Compile3.VersionFrontendMajor << '.' << Compile3.VersionFrontendMinor
         << '.' << Compile3.VersionFrontendBuild << '.'
         << Compile3.VersionFrontendQFE;
   }
   std::string BackendVersion;
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
   W.printHex("OffsetToPadding", FrameProc.OffsetToPadding);
   W.printHex("BytesOfCalleeSavedRegisters",
              FrameProc.BytesOfCalleeSavedRegisters);
   W.printHex("OffsetOfExceptionHandler", FrameProc.OffsetOfExceptionHandler);
   W.printHex("SectionIdOfExceptionHandler",
              FrameProc.SectionIdOfExceptionHandler);
   W.printFlags("Flags", static_cast<uint32_t>(FrameProc.Flags),
                getFrameProcSymFlagNames());
+  W.printEnum("LocalFramePtrReg",
+              uint16_t(FrameProc.getLocalFramePtrReg(CompilationCPUType)),
+              getRegisterNames());
+  W.printEnum("ParamFramePtrReg",
+              uint16_t(FrameProc.getParamFramePtrReg(CompilationCPUType)),
+              getRegisterNames());
   return Error::success();
 }
 
 Error CVSymbolDumperImpl::visitKnownRecord(
     CVSymbol &CVR, HeapAllocationSiteSym &HeapAllocSite) {
   StringRef LinkageName;
   if (ObjDelegate) {
     ObjDelegate->printRelocatedField("CodeOffset",

 Error CVSymbolDumperImpl::visitUnknownSymbol(CVSymbol &CVR) {
   W.printNumber("Length", CVR.length());
   return Error::success();
 }
 
 Error CVSymbolDumper::dump(CVRecord<SymbolKind> &Record) {
   SymbolVisitorCallbackPipeline Pipeline;
   SymbolDeserializer Deserializer(ObjDelegate.get(), Container);
-  CVSymbolDumperImpl Dumper(Types, ObjDelegate.get(), W, PrintRecordBytes);
+  CVSymbolDumperImpl Dumper(Types, ObjDelegate.get(), W, CompilationCPUType,
+                            PrintRecordBytes);
 
   Pipeline.addCallbackToPipeline(Deserializer);
   Pipeline.addCallbackToPipeline(Dumper);
   CVSymbolVisitor Visitor(Pipeline);
-  return Visitor.visitSymbolRecord(Record);
+  auto Err = Visitor.visitSymbolRecord(Record);
+  CompilationCPUType = Dumper.getCompilationCPUType();
+  return Err;
 }
 
 Error CVSymbolDumper::dump(const CVSymbolArray &Symbols) {
   SymbolVisitorCallbackPipeline Pipeline;
   SymbolDeserializer Deserializer(ObjDelegate.get(), Container);
-  CVSymbolDumperImpl Dumper(Types, ObjDelegate.get(), W, PrintRecordBytes);
+  CVSymbolDumperImpl Dumper(Types, ObjDelegate.get(), W, CompilationCPUType,
+                            PrintRecordBytes);
 
   Pipeline.addCallbackToPipeline(Deserializer);
   Pipeline.addCallbackToPipeline(Dumper);
   CVSymbolVisitor Visitor(Pipeline);
-  return Visitor.visitSymbolStream(Symbols);
+  auto Err = Visitor.visitSymbolStream(Symbols);
+  CompilationCPUType = Dumper.getCompilationCPUType();
+  return Err;
 }

llvm/trunk/test/DebugInfo/PDB/pdbdump-headers.test

 ALL-NEXT:          frontend = 18.0.31101.0, backend = 18.0.31101.0
 ALL-NEXT:          flags = security checks
 ALL-NEXT:    120 | S_GPROC32 [size = 44] `main`
 ALL-NEXT:          parent = 0, end = 196, addr = 0001:0016, code size = 10
 ALL-NEXT:          type = `0x1001 (int ())`, debug start = 3, debug end = 8, flags = has fp
 ALL-NEXT:    164 | S_FRAMEPROC [size = 32]
 ALL-NEXT:          size = 0, padding size = 0, offset to padding = 0
 ALL-NEXT:          bytes of callee saved registers = 0, exception handler addr = 0000:0000
+ALL-NEXT:          local fp reg = EBP, param fp reg = EBP
 ALL-NEXT:          flags = has async eh | opt speed
 ALL-NEXT:    196 | S_END [size = 4]
 ALL-NEXT:    200 | S_BUILDINFO [size = 8] BuildId = `0x100E`
 ALL-NEXT:   Mod 0001 | `* Linker *`:
 ALL-NEXT:          4 | S_OBJNAME [size = 20] sig=0, `* Linker *`
 ALL-NEXT:         24 | S_COMPILE3 [size = 48]
 ALL-NEXT:              machine = intel 80386, Ver = Microsoft (R) LINK, language = link
 ALL-NEXT:              frontend = 0.0.0.0, backend = 12.0.31101.0

llvm/trunk/tools/llvm-pdbutil/MinimalSymbolDumper.h

 
 private:
   std::string typeOrIdIndex(codeview::TypeIndex TI, bool IsType) const;
 
   std::string typeIndex(codeview::TypeIndex TI) const;
   std::string idIndex(codeview::TypeIndex TI) const;
 
   LinePrinter &P;
+
+  /// Dumping certain records requires knowing what machine this is. The
+  /// S_COMPILE3 record will tell us, but if we don't see one, default to X64.
+  codeview::CPUType CompilationCPU = codeview::CPUType::X64;
+
   bool RecordBytes;
   const SymbolGroup *SymGroup = nullptr;
   codeview::LazyRandomTypeCollection &Ids;
   codeview::LazyRandomTypeCollection &Types;
 };
 } // namespace pdb
 } // namespace llvm
 
-#endif
+#endif
 

llvm/trunk/tools/llvm-pdbutil/MinimalSymbolDumper.cpp

Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, ExportSym &Export) {
   return Error::success();
 }
 
 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
                                             Compile2Sym &Compile2) {
   AutoIndent Indent(P, 7);
   SourceLanguage Lang = static_cast<SourceLanguage>(
       Compile2.Flags & CompileSym2Flags::SourceLanguageMask);
+  CompilationCPU = Compile2.Machine;
   P.formatLine("machine = {0}, ver = {1}, language = {2}",
                formatMachineType(Compile2.Machine), Compile2.Version,
                formatSourceLanguage(Lang));
   P.formatLine("frontend = {0}.{1}.{2}, backend = {3}.{4}.{5}",
                Compile2.VersionFrontendMajor, Compile2.VersionFrontendMinor,
                Compile2.VersionFrontendBuild, Compile2.VersionBackendMajor,
                Compile2.VersionBackendMinor, Compile2.VersionBackendBuild);
   P.formatLine("flags = {0}",
                formatCompileSym2Flags(P.getIndentLevel() + 9, Compile2.Flags));
   P.formatLine(
       "extra strings = {0}",
       typesetStringList(P.getIndentLevel() + 9 + 2, Compile2.ExtraStrings));
   return Error::success();
 }
 
 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
                                             Compile3Sym &Compile3) {
   AutoIndent Indent(P, 7);
   SourceLanguage Lang = static_cast<SourceLanguage>(
       Compile3.Flags & CompileSym3Flags::SourceLanguageMask);
+  CompilationCPU = Compile3.Machine;
   P.formatLine("machine = {0}, Ver = {1}, language = {2}",
                formatMachineType(Compile3.Machine), Compile3.Version,
                formatSourceLanguage(Lang));
   P.formatLine("frontend = {0}.{1}.{2}.{3}, backend = {4}.{5}.{6}.{7}",
                Compile3.VersionFrontendMajor, Compile3.VersionFrontendMinor,
                Compile3.VersionFrontendBuild, Compile3.VersionFrontendQFE,
                Compile3.VersionBackendMajor, Compile3.VersionBackendMinor,
                Compile3.VersionBackendBuild, Compile3.VersionBackendQFE);
Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, FrameProcSym &FP) {
   AutoIndent Indent(P, 7);
   P.formatLine("size = {0}, padding size = {1}, offset to padding = {2}",
                FP.TotalFrameBytes, FP.PaddingFrameBytes, FP.OffsetToPadding);
   P.formatLine("bytes of callee saved registers = {0}, exception handler addr "
                "= {1}",
                FP.BytesOfCalleeSavedRegisters,
                formatSegmentOffset(FP.SectionIdOfExceptionHandler,
                                    FP.OffsetOfExceptionHandler));
+  P.formatLine("local fp reg = {0}, param fp reg = {1}",
+               formatRegisterId(FP.getLocalFPReg(CompilationCPU)),
+               formatRegisterId(FP.getParamFPReg(CompilationCPU)));
   P.formatLine("flags = {0}",
                formatFrameProcedureOptions(P.getIndentLevel() + 9, FP.Flags));
   return Error::success();
 }
 
 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
                                             HeapAllocationSiteSym &HAS) {
   AutoIndent Indent(P, 7);

llvm/trunk/tools/llvm-readobj/COFFDumper.cpp

private:
   const llvm::object::COFFObjectFile *Obj;
   bool RelocCached = false;
   RelocMapTy RelocMap;
 
   DebugChecksumsSubsectionRef CVFileChecksumTable;
 
   DebugStringTableSubsectionRef CVStringTable;
 
+  /// Track the compilation CPU type. S_COMPILE3 symbol records typically come
+  /// first, but if we don't see one, just assume an X64 CPU type. It is common.
+  CPUType CompilationCPUType = CPUType::X64;
+
   ScopedPrinter &Writer;
   BinaryByteStream TypeContents;
   LazyRandomTypeCollection Types;
 };
 
 class COFFObjectDumpDelegate : public SymbolDumpDelegate {
 public:
   COFFObjectDumpDelegate(COFFDumper &CD, const SectionRef &SR,

 void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
                                                 const SectionRef &Section,
                                                 StringRef SectionContents) {
   ArrayRef<uint8_t> BinaryData(Subsection.bytes_begin(),
                                Subsection.bytes_end());
   auto CODD = llvm::make_unique<COFFObjectDumpDelegate>(*this, Section, Obj,
                                                         SectionContents);
   CVSymbolDumper CVSD(W, Types, CodeViewContainer::ObjectFile, std::move(CODD),
-                      opts::CodeViewSubsectionBytes);
+                      CompilationCPUType, opts::CodeViewSubsectionBytes);
   CVSymbolArray Symbols;
   BinaryStreamReader Reader(BinaryData, llvm::support::little);
   if (auto EC = Reader.readArray(Symbols, Reader.getLength())) {
     consumeError(std::move(EC));
     W.flush();
     error(object_error::parse_failed);
   }
 
   if (auto EC = CVSD.dump(Symbols)) {
     W.flush();
     error(std::move(EC));
   }
+  CompilationCPUType = CVSD.getCompilationCPUType();
   W.flush();
 }
 
 void COFFDumper::printCodeViewFileChecksums(StringRef Subsection) {
   BinaryStreamRef Stream(Subsection, llvm::support::little);
   DebugChecksumsSubsectionRef Checksums;
   error(Checksums.initialize(Stream));