[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

Can you add an llvm_unreachable() here?

803–804

And here.

llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp

63

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

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

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

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

Yeah, that's pretty bad. getLocalFramePtrReg?

[rnk]

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

lld/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/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/include/llvm/DebugInfo/CodeView/SymbolDumper.h

 //===-- SymbolDumper.h - 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.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_SYMBOLDUMPER_H
 #define LLVM_DEBUGINFO_CODEVIEW_SYMBOLDUMPER_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/DebugInfo/CodeView/SymbolDumpDelegate.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 
 namespace llvm {
 class ScopedPrinter;
 
 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,
-                 bool PrintRecordBytes)
+                 Optional<CPUType> CPU, bool PrintRecordBytes)
       : W(W), Types(Types), Container(Container),
-        ObjDelegate(std::move(ObjDelegate)),
+        ObjDelegate(std::move(ObjDelegate)), MaybeCPUType(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);
 
+  Optional<CPUType> maybeGetCPUType() const { return MaybeCPUType; }
+
 private:
   ScopedPrinter &W;
   TypeCollection &Types;
   CodeViewContainer Container;
   std::unique_ptr<SymbolDumpDelegate> ObjDelegate;
-
+  Optional<CPUType> MaybeCPUType;
   bool PrintRecordBytes;
 };
 } // end namespace codeview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_SYMBOLDUMPER_H

llvm/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 getLocalFPReg(CPUType CPU) const {
+    return decodeFPReg((uint32_t(Flags) >> 14U) & 0x3U, CPU);
+  }
+
+  /// Extract the register this frame uses to refer to parameters.
+  RegisterId getParamFPReg(CPUType CPU) const {
+    return decodeFPReg((uint32_t(Flags) >> 16U) & 0x3U, CPU);
+  }
+
   uint32_t RecordOffset;
+
+private:
+  static RegisterId decodeFPReg(uint32_t EncodedFPReg, CPUType CPU) {
+    assert(EncodedFPReg < 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 (EncodedFPReg) {
+      case 0: return RegisterId::NONE;
+      case 1: return RegisterId::VFRAME;
+      case 2: return RegisterId::EBP;
+      case 3: return RegisterId::EBX;
+      }
+    case CPUType::X64:
+      switch (EncodedFPReg) {
+      case 0: return RegisterId::NONE;
+      case 1: return RegisterId::RSP;
+      case 2: return RegisterId::RBP;
+      case 3: return RegisterId::R13;
+      }
+    }
+    return RegisterId::NONE;
+  }
 };
 
 // S_CALLSITEINFO
 class CallSiteInfoSym : public SymbolRecord {
   static constexpr uint32_t RelocationOffset = 4;
 
 public:
   explicit CallSiteInfoSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}

llvm/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/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, Optional<CPUType> CPU,
+                     bool PrintRecordBytes)
+      : Types(Types), ObjDelegate(ObjDelegate), W(W), MaybeCPUType(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;
 
+  Optional<CPUType> maybeGetCPUType() const { return MaybeCPUType; }
+
 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.
+  Optional<CPUType> MaybeCPUType;
+
   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());
+  MaybeCPUType = 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());
+  MaybeCPUType = 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());
+
+  // Look up the register names if we can.
+  if (MaybeCPUType) {
+    CPUType CPU = *MaybeCPUType;
+    W.printEnum("LocalFPReg", uint16_t(FrameProc.getLocalFPReg(CPU)),
+                getRegisterNames());
+    W.printEnum("ParamFPReg", uint16_t(FrameProc.getParamFPReg(CPU)),
+                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, MaybeCPUType,
+                            PrintRecordBytes);
 
   Pipeline.addCallbackToPipeline(Deserializer);
   Pipeline.addCallbackToPipeline(Dumper);
   CVSymbolVisitor Visitor(Pipeline);
-  return Visitor.visitSymbolRecord(Record);
+  auto Err = Visitor.visitSymbolRecord(Record);
+  if (auto CPU = Dumper.maybeGetCPUType())
+    MaybeCPUType = CPU;
+  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, MaybeCPUType,
+                            PrintRecordBytes);
 
   Pipeline.addCallbackToPipeline(Deserializer);
   Pipeline.addCallbackToPipeline(Dumper);
   CVSymbolVisitor Visitor(Pipeline);
-  return Visitor.visitSymbolStream(Symbols);
+  auto Err = Visitor.visitSymbolStream(Symbols);
+  if (auto CPU = Dumper.maybeGetCPUType())
+    MaybeCPUType = CPU;
+  return Err;
 }

llvm/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/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/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/tools/llvm-readobj/COFFDumper.cpp

private:
   const llvm::object::COFFObjectFile *Obj;
   bool RelocCached = false;
   RelocMapTy RelocMap;
 
   DebugChecksumsSubsectionRef CVFileChecksumTable;
 
   DebugStringTableSubsectionRef CVStringTable;
 
+  Optional<CPUType> MaybeCPUType;
+
   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);
+                      MaybeCPUType, 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));
   }
+  if (auto CPU = CVSD.maybeGetCPUType())
+    MaybeCPUType = CPU;
   W.flush();
 }
 
 void COFFDumper::printCodeViewFileChecksums(StringRef Subsection) {
   BinaryStreamRef Stream(Subsection, llvm::support::little);
   DebugChecksumsSubsectionRef Checksums;
   error(Checksums.initialize(Stream));