Addition of S_POGODATA field to PDB for better PGO analysis

[cbalacha]

Summary

Working on adding components to improve Profile Guided Optimization operations and am looking to propose a feature addition to the LLVM ASM Printer to allow S_POGODATA to be added to the PDB files to allow users who perform PGO to better understand its effects on a function level when looking at the PDB. This is what currently exists in the Microsoft Visual C++ compiler and I hope to enable clang to match the same on windows.
As per the publically available PDB GitHub info for Code View Info:microsoft-pdb/cvinfo.h at master · microsoft/microsoft-pdb · GitHub
S_POGODATA structure is defined by:

typedef struct POGOINFO {
unsigned short reclen; // Record length
unsigned short rectyp; // S_POGODATA

unsigned long   invocations;        // Number of times function was called
__int64         dynCount;           // Dynamic instruction count
unsigned long   numInstrs;          // Static instruction count
unsigned long   staInstLive;        // Final static instruction count (post inlining)
} POGOINFO;

My hope is to update the CodeViewDebug::emitDebugInfoForFunction method to access the per function information and emit the record into the PDB.
RFC at : https://discourse.llvm.org/t/rfc-addition-of-s-pogodata-field-to-pdb-for-better-pgo-analysis/63066

[cbalacha]

Removed trailing white spaces from diff

[cbalacha]

removed yet another trailing white space

[cbalacha]

redo patch with latest code

llvm/include/llvm/CodeGen/AsmPrinter.h

public:
   //===------------------------------------------------------------------===//
   // Coarse grained IR lowering routines.
   //===------------------------------------------------------------------===//
 
   /// This should be called when a new MachineFunction is being processed from
   /// runOnMachineFunction.
   virtual void SetupMachineFunction(MachineFunction &MF);
 
+  /// This method computes and updates a functions instruction counts
+  void UpdateFunctionInstructionCounts(Function &F);
+
   /// This method emits the body and trailer for a function.
   void emitFunctionBody();
 
   void emitCFIInstruction(const MachineInstr &MI);
 
   void emitFrameAlloc(const MachineInstr &MI);
 
   void emitStackSizeSection(const MachineFunction &MF);

llvm/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h

if (auto EC = Reader->readObject(ValuePtr))
       return EC;
     Value = *ValuePtr;
     return Error::success();
   }
 
   template <typename T> Error mapInteger(T &Value, const Twine &Comment = "") {
     if (isStreaming()) {
       emitComment(Comment);
-      Streamer->emitIntValue((int)Value, sizeof(T));
+      Streamer->emitIntValue((uint64_t)Value, sizeof(T));
       incrStreamedLen(sizeof(T));
       return Error::success();
     }
 
     if (isWriting())
       return Writer->writeInteger(Value);
 
     return Reader->readInteger(Value);

llvm/include/llvm/DebugInfo/CodeView/CodeViewSymbols.def

 
 CV_SYMBOL(S_DEFRANGE_HLSL  , 0x1150)
 CV_SYMBOL(S_GDATA_HLSL     , 0x1151)
 CV_SYMBOL(S_LDATA_HLSL     , 0x1152)
 CV_SYMBOL(S_LOCAL_DPC_GROUPSHARED, 0x1154)
 CV_SYMBOL(S_DEFRANGE_DPC_PTR_TAG, 0x1157)
 CV_SYMBOL(S_DPC_SYM_TAG_MAP, 0x1158)
 CV_SYMBOL(S_ARMSWITCHTABLE , 0x1159)
-CV_SYMBOL(S_POGODATA       , 0x115c)
 CV_SYMBOL(S_INLINESITE2    , 0x115d)
 CV_SYMBOL(S_MOD_TYPEREF    , 0x115f)
 CV_SYMBOL(S_REF_MINIPDB    , 0x1160)
 CV_SYMBOL(S_PDBMAP         , 0x1161)
 CV_SYMBOL(S_GDATA_HLSL32   , 0x1162)
 CV_SYMBOL(S_LDATA_HLSL32   , 0x1163)
 CV_SYMBOL(S_GDATA_HLSL32_EX, 0x1164)
 CV_SYMBOL(S_LDATA_HLSL32_EX, 0x1165)

 SYMBOL_RECORD(S_EXPORT        , 0x1138, ExportSym)
 
 SYMBOL_RECORD(S_LPROC32       , 0x110f, ProcSym)
 SYMBOL_RECORD_ALIAS(S_GPROC32       , 0x1110, GlobalProcSym, ProcSym)
 SYMBOL_RECORD_ALIAS(S_LPROC32_ID     , 0x1146, ProcIdSym, ProcSym)
 SYMBOL_RECORD_ALIAS(S_GPROC32_ID     , 0x1147, GlobalProcIdSym, ProcSym)
 SYMBOL_RECORD_ALIAS(S_LPROC32_DPC    , 0x1155, DPCProcSym, ProcSym)
 SYMBOL_RECORD_ALIAS(S_LPROC32_DPC_ID , 0x1156, DPCProcIdSym, ProcSym)
+SYMBOL_RECORD(S_POGODATA      , 0x115c, PgoSym)
 
 SYMBOL_RECORD(S_REGISTER      , 0x1106, RegisterSym)
 SYMBOL_RECORD(S_PUB32         , 0x110e, PublicSym32)
 
 SYMBOL_RECORD(S_PROCREF       , 0x1125, ProcRefSym)
 SYMBOL_RECORD_ALIAS(S_LPROCREF, 0x1127, LocalProcRef, ProcRefSym)
 
 

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

return decodeFramePtrReg(
         EncodedFramePtrReg((uint32_t(Flags) >> 16U) & 0x3U), CPU);
   }
 
   uint32_t RecordOffset = 0;
 
 private:
 };
 
+// S_POGODATA
+class PgoSym : public SymbolRecord {
+public:
+  explicit PgoSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
+  explicit PgoSym(uint32_t RecordOffset)
+      : SymbolRecord(SymbolRecordKind::PgoSym),
+        RecordOffset(RecordOffset) {}
+
+  uint32_t FunctionEntryCount = 0;
+  uint64_t DynamicInstrCount = 0;
+  uint32_t StaticInstrCount = 0;
+  uint32_t LiveInstrCount = 0;
+
+  uint32_t RecordOffset = 0;
+
+private:
+};
+
 // S_CALLSITEINFO
 class CallSiteInfoSym : public SymbolRecord {
   static constexpr uint32_t RelocationOffset = 4;
 
 public:
   explicit CallSiteInfoSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit CallSiteInfoSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::CallSiteInfoSym) {}

llvm/include/llvm/IR/FixedMetadataKinds.def

 LLVM_FIXED_MD_KIND(MD_callback, "callback", 26)
 LLVM_FIXED_MD_KIND(MD_preserve_access_index, "llvm.preserve.access.index", 27)
 LLVM_FIXED_MD_KIND(MD_vcall_visibility, "vcall_visibility", 28)
 LLVM_FIXED_MD_KIND(MD_noundef, "noundef", 29)
 LLVM_FIXED_MD_KIND(MD_annotation, "annotation", 30)
 LLVM_FIXED_MD_KIND(MD_nosanitize, "nosanitize", 31)
 LLVM_FIXED_MD_KIND(MD_func_sanitize, "func_sanitize", 32)
 LLVM_FIXED_MD_KIND(MD_exclude, "exclude", 33)
+LLVM_FIXED_MD_KIND(MD_instrcount, "instrcount", 34)

llvm/include/llvm/IR/Function.h

public:
 
   // Provide fast operand accessors.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// Returns the number of non-debug IR instructions in this function.
   /// This is equivalent to the sum of the sizes of each basic block contained
   /// within this function.
   unsigned getInstructionCount() const;
   
   /// Returns the FunctionType for me.
   FunctionType *getFunctionType() const {
     return cast<FunctionType>(getValueType());
   }
 
   /// Returns the type of the ret val.
   Type *getReturnType() const { return getFunctionType()->getReturnType(); }
 
public:
   public:
     ProfileCount(uint64_t Count, ProfileCountType PCT)
         : Count(Count), PCT(PCT) {}
     uint64_t getCount() const { return Count; }
     ProfileCountType getType() const { return PCT; }
     bool isSynthetic() const { return PCT == PCT_Synthetic; }
   };
 
+  /// Class to represent function instruction counts.
+  ///
+  /// This class owns the state and values for the 
+  /// dynamic, static and live instruction of a function. 
+  class FunctionInstructionCounts {
+  private:
+    uint64_t DynInstCount = 0;
+    uint32_t LiveInstCount = 0;
+    uint32_t StaticInstCount = 0;
+  public:
+    FunctionInstructionCounts(uint64_t DynInstCount, uint32_t LiveInstCount,
+                              uint32_t StaticInstCount)
+        : DynInstCount(DynInstCount), LiveInstCount(LiveInstCount),
+          StaticInstCount(StaticInstCount) {}
+    uint64_t getDynInstCount() const { return DynInstCount; }
+    uint32_t getLiveInstCount() const { return LiveInstCount; }
+    uint32_t getStaticInstCount() const { return StaticInstCount; }
+  };
+
+  /// Set the various function instruction counts.
+  ///
+  /// This invloves setting the dynamic, static and 
+  /// live instruction counts per function.
+  void setFunctionInstructionCounts(uint64_t DynInstCount,
+                                    uint32_t LiveInstCount,
+                     uint32_t StaticInstCount);
+
+  /// Get the various function instruction counts.
+  Optional<FunctionInstructionCounts> getFunctionInstructionCounts() const;
+
   /// Set the entry count for this function.
   ///
   /// Entry count is the number of times this function was executed based on
   /// pgo data. \p Imports points to a set of GUIDs that needs to
   /// be imported by the function for sample PGO, to enable the same inlines as
   /// the profiled optimized binary.
   void setEntryCount(ProfileCount Count,
                      const DenseSet<GlobalValue::GUID> *Imports = nullptr);

llvm/include/llvm/IR/MDBuilder.h

public:
 
   /// Return metadata containing the entry \p Count for a function, a boolean
   /// \Synthetic indicating whether the counts were synthetized, and the
   /// GUIDs stored in \p Imports that need to be imported for sample PGO, to
   /// enable the same inlines as the profiled optimized binary
   MDNode *createFunctionEntryCount(uint64_t Count, bool Synthetic,
                                    const DenseSet<GlobalValue::GUID> *Imports);
 
+  /// Return metadata containing a function's instruction counts: Dynamic
+  /// Instruction Count, Live Instruction Count and Static Instruction Count.
+  MDNode *createFunctionInstructionCounts(uint64_t DynInstCount,
+                                          uint32_t LiveInstCount,
+                                          uint32_t StaticInstCount);
+
   /// Return metadata containing the section prefix for a function.
   MDNode *createFunctionSectionPrefix(StringRef Prefix);
 
   /// Return metadata containing the pseudo probe descriptor for a function.
   MDNode *createPseudoProbeDesc(uint64_t GUID, uint64_t Hash, Function *F);
 
   //===------------------------------------------------------------------===//
   // Range metadata.

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 #include "llvm/Config/config.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Comdat.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Dominators.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/BranchProbabilityInfo.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GCStrategy.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalIFunc.h"
 #include "llvm/IR/GlobalObject.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Instruction.h"

 
 MCSymbol *AsmPrinter::getMBBExceptionSym(const MachineBasicBlock &MBB) {
   auto Res = MBBSectionExceptionSyms.try_emplace(MBB.getSectionIDNum());
   if (Res.second)
     Res.first->second = createTempSymbol("exception");
   return Res.first->second;
 }
 
+
+void AsmPrinter::UpdateFunctionInstructionCounts(Function &F) {
+  uint32_t StaticInstCount = 0;
+  uint32_t LiveInstCount = 0;
+  uint64_t DynInstCount = 0;
+  uint32_t BlockInstrCount = 0;
+
+  /// Attempting to retrive machine block frequency using
+  /// LazyMachineBlockFrequencyInfo from getAnalysis API results in some
+  /// functions not holding any valid MBFI value.
+  /// TODO:Implement means to compute instruction count and frequency at the
+  /// Machine Basic Block level to account for lowered instruction count diff.
+
+  LoopInfo LI{DominatorTree(F)};
+  BranchProbabilityInfo NBPI(F, LI);
+  BlockFrequencyInfo NBFI(F, NBPI, LI);
+  for (auto &BB : F) {
+    auto BFICount = NBFI.getBlockProfileCount(&BB);
+    BlockInstrCount = std::distance(BB.instructionsWithoutDebug().begin(),
+                                    BB.instructionsWithoutDebug().end());
+    if (BFICount.hasValue() && BFICount.getValue() > 0) {
+      DynInstCount += BlockInstrCount * BFICount.getValue();
+      LiveInstCount += BlockInstrCount;
+    }
+    StaticInstCount += BlockInstrCount;
+  }
+  F.setFunctionInstructionCounts(DynInstCount, LiveInstCount, StaticInstCount);
+}
+
 void AsmPrinter::SetupMachineFunction(MachineFunction &MF) {
   this->MF = &MF;
   const Function &F = MF.getFunction();
-
+  UpdateFunctionInstructionCounts(MF.getFunction());
   // Record that there are split-stack functions, so we will emit a special
   // section to tell the linker.
   if (MF.shouldSplitStack()) {
     HasSplitStack = true;
 
     if (!MF.getFrameInfo().needsSplitStackProlog())
       HasNoSplitStack = true;
   } else

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols);
     OS.AddComment("Flags");
     OS.emitInt8(0);
     // Emit the function display name as a null-terminated string.
     OS.AddComment("Function name");
     // Truncate the name so we won't overflow the record length field.
     emitNullTerminatedSymbolName(OS, FuncName);
     endSymbolRecord(ProcRecordEnd);
 
+    // Only display S_POGODATA if entry count or DnyCounts are non 0
+    if (GV->getFunctionInstructionCounts().hasValue() &&
+        GV->getFunctionInstructionCounts().getValue().getDynInstCount() > 0) {
+        MCSymbol *PgoEnd = beginSymbolRecord(SymbolKind::S_POGODATA);
+        OS.AddComment("Function Entry Count");
+        OS.emitInt32(GV->getEntryCount()->getCount());
+        OS.AddComment("Dynamic Instruction Count");
+        OS.emitInt64(
+            GV->getFunctionInstructionCounts().getValue().getDynInstCount());
+        OS.AddComment("Static Instruction Count");
+        OS.emitInt32(
+            GV->getFunctionInstructionCounts().getValue().getStaticInstCount());
+        OS.AddComment("Live Instruction Count");
+        OS.emitInt32(
+            GV->getFunctionInstructionCounts().getValue().getLiveInstCount());
+        endSymbolRecord(PgoEnd);
+    }
     MCSymbol *FrameProcEnd = beginSymbolRecord(SymbolKind::S_FRAMEPROC);
     // Subtract out the CSR size since MSVC excludes that and we include it.
     OS.AddComment("FrameSize");
     OS.emitInt32(FI.FrameSize - FI.CSRSize);
     OS.AddComment("Padding");
     OS.emitInt32(0);
     OS.AddComment("Offset of padding");
     OS.emitInt32(0);

llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp

W.printEnum("LocalFramePtrReg",
               uint16_t(FrameProc.getLocalFramePtrReg(CompilationCPUType)),
               getRegisterNames(CompilationCPUType));
   W.printEnum("ParamFramePtrReg",
               uint16_t(FrameProc.getParamFramePtrReg(CompilationCPUType)),
               getRegisterNames(CompilationCPUType));
   return Error::success();
 }
 
+Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, PgoSym &Pgo) {
+  W.printHex("FunctionEntryCount", Pgo.FunctionEntryCount);
+  W.printHex("DynamicInstrCount", Pgo.DynamicInstrCount);
+  W.printHex("StaticInstrCount", Pgo.StaticInstrCount);
+  W.printHex("LiveInstrCount", Pgo.LiveInstrCount);
+  return Error::success();
+}
+
 Error CVSymbolDumperImpl::visitKnownRecord(
     CVSymbol &CVR, HeapAllocationSiteSym &HeapAllocSite) {
   StringRef LinkageName;
   if (ObjDelegate) {
     ObjDelegate->printRelocatedField("CodeOffset",
                                      HeapAllocSite.getRelocationOffset(),
                                      HeapAllocSite.CodeOffset, &LinkageName);
   }

llvm/lib/DebugInfo/CodeView/SymbolRecordMapping.cpp

Error SymbolRecordMapping::visitKnownRecord(CVSymbol &CVR,
   error(IO.mapInteger(FrameProc.BytesOfCalleeSavedRegisters));
   error(IO.mapInteger(FrameProc.OffsetOfExceptionHandler));
   error(IO.mapInteger(FrameProc.SectionIdOfExceptionHandler));
   error(IO.mapEnum(FrameProc.Flags));
 
   return Error::success();
 }
 
+Error SymbolRecordMapping::visitKnownRecord(CVSymbol &CVR, PgoSym &Pgo) {
+  error(IO.mapInteger(Pgo.FunctionEntryCount));
+  error(IO.mapInteger(Pgo.DynamicInstrCount));
+  error(IO.mapInteger(Pgo.StaticInstrCount));
+  error(IO.mapInteger(Pgo.LiveInstrCount));
+  return Error::success();
+}
+
 Error SymbolRecordMapping::visitKnownRecord(
     CVSymbol &CVR, HeapAllocationSiteSym &HeapAllocSite) {
 
   error(IO.mapInteger(HeapAllocSite.CodeOffset));
   error(IO.mapInteger(HeapAllocSite.Segment));
   error(IO.mapInteger(HeapAllocSite.CallInstructionSize));
   error(IO.mapInteger(HeapAllocSite.Type));
 

llvm/lib/DebugInfo/CodeView/TypeIndexDiscovery.cpp

static bool discoverTypeIndices(ArrayRef<uint8_t> Content, SymbolKind Kind,
   case SymbolKind::S_LABEL32:
   case SymbolKind::S_OBJNAME:
   case SymbolKind::S_COMPILE:
   case SymbolKind::S_COMPILE2:
   case SymbolKind::S_COMPILE3:
   case SymbolKind::S_ENVBLOCK:
   case SymbolKind::S_BLOCK32:
   case SymbolKind::S_FRAMEPROC:
+  case SymbolKind::S_POGODATA:
   case SymbolKind::S_THUNK32:
   case SymbolKind::S_FRAMECOOKIE:
   case SymbolKind::S_UNAMESPACE:
     break;
   // Scope ending symbols.
   case SymbolKind::S_END:
   case SymbolKind::S_INLINESITE_END:
   case SymbolKind::S_PROC_ID_END:

llvm/lib/IR/Function.cpp

 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <string>
 
 using namespace llvm;
 using ProfileCount = Function::ProfileCount;
-
+using FunctionInstructionCounts = Function::FunctionInstructionCounts;
 // Explicit instantiations of SymbolTableListTraits since some of the methods
 // are not in the public header file...
 template class llvm::SymbolTableListTraits<BasicBlock>;
 
 static cl::opt<unsigned> NonGlobalValueMaxNameSize(
     "non-global-value-max-name-size", cl::Hidden, cl::init(1024),
     cl::desc("Maximum size for the name of non-global values."));
 

 void Function::setValueSubclassDataBit(unsigned Bit, bool On) {
   assert(Bit < 16 && "SubclassData contains only 16 bits");
   if (On)
     setValueSubclassData(getSubclassDataFromValue() | (1 << Bit));
   else
     setValueSubclassData(getSubclassDataFromValue() & ~(1 << Bit));
 }
 
+void Function::setFunctionInstructionCounts(uint64_t DynInstCount,
+                                            uint32_t LiveInstCount,
+                                  uint32_t StaticInstCount) {
+  MDBuilder MDB(getContext());
+    setMetadata(LLVMContext::MD_instrcount,
+              MDB.createFunctionInstructionCounts(DynInstCount, LiveInstCount,
+                                           StaticInstCount));
+  }
+
+Optional<FunctionInstructionCounts>
+  Function::getFunctionInstructionCounts() const {
+    MDNode *MD = getMetadata(LLVMContext::MD_instrcount);
+    if (MD && MD->getOperand(0))
+      if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0))) {
+        if (MDS->getString().equals("function_instruction_counts")) {
+          ConstantInt *CIDIC = mdconst::extract<ConstantInt>(MD->getOperand(1));
+          uint64_t DynInstCount = CIDIC->getValue().getZExtValue();
+          ConstantInt *CILIC = mdconst::extract<ConstantInt>(MD->getOperand(2));
+          uint32_t LiveInstCount = CILIC->getValue().getZExtValue();
+          ConstantInt *CISIC = mdconst::extract<ConstantInt>(MD->getOperand(3));
+          uint32_t StaticInstCount = CISIC->getValue().getZExtValue();
+          return FunctionInstructionCounts(DynInstCount, LiveInstCount,
+                                           StaticInstCount);
+        } 
+      }
+    return None;
+  }
+
 void Function::setEntryCount(ProfileCount Count,
                              const DenseSet<GlobalValue::GUID> *S) {
 #if !defined(NDEBUG)
   auto PrevCount = getEntryCount();
   assert(!PrevCount || PrevCount->getType() == Count.getType());
 #endif
 
   auto ImportGUIDs = getImportGUIDs();

llvm/lib/IR/MDBuilder.cpp

if (Imports) {
     SmallVector<GlobalValue::GUID, 2> OrderID(Imports->begin(), Imports->end());
     llvm::sort(OrderID);
     for (auto ID : OrderID)
       Ops.push_back(createConstant(ConstantInt::get(Int64Ty, ID)));
   }
   return MDNode::get(Context, Ops);
 }
 
+MDNode *MDBuilder::createFunctionInstructionCounts(uint64_t DynInstCount,
+                                                   uint32_t LiveInstCount,
+                                                   uint32_t StaticInstCount) {
+  SmallVector<Metadata *, 8> Ops;
+  Type *Int64Ty = Type::getInt64Ty(Context);
+  Ops.push_back(createString("function_instruction_counts"));
+  Ops.push_back(createConstant(ConstantInt::get(Int64Ty, DynInstCount)));
+  Type *Int32Ty = Type::getInt32Ty(Context);
+  Ops.push_back(createConstant(ConstantInt::get(Int32Ty, LiveInstCount)));
+  Ops.push_back(createConstant(ConstantInt::get(Int32Ty, StaticInstCount)));
+
+  return MDNode::get(Context, Ops);
+}
+
 MDNode *MDBuilder::createFunctionSectionPrefix(StringRef Prefix) {
   return MDNode::get(Context,
                      {createString("function_section_prefix"),
                       createString(Prefix)});
 }
 
 MDNode *MDBuilder::createRange(const APInt &Lo, const APInt &Hi) {
   assert(Lo.getBitWidth() == Hi.getBitWidth() && "Mismatched bitwidths!");

llvm/lib/ObjectYAML/CodeViewYAMLSymbols.cpp

template <> void SymbolRecordImpl<FrameProcSym>::map(IO &IO) {
   IO.mapRequired("BytesOfCalleeSavedRegisters",
                  Symbol.BytesOfCalleeSavedRegisters);
   IO.mapRequired("OffsetOfExceptionHandler", Symbol.OffsetOfExceptionHandler);
   IO.mapRequired("SectionIdOfExceptionHandler",
                  Symbol.SectionIdOfExceptionHandler);
   IO.mapRequired("Flags", Symbol.Flags);
 }
 
+template <> void SymbolRecordImpl<PgoSym>::map(IO &IO) {
+  IO.mapRequired("FunctionEntryCount", Symbol.FunctionEntryCount);
+  IO.mapRequired("DynamicInstrCount", Symbol.DynamicInstrCount);
+  IO.mapRequired("StaticInstrCount", Symbol.StaticInstrCount);
+  IO.mapRequired("LiveInstrCount", Symbol.LiveInstrCount);
+}
+
 template <> void SymbolRecordImpl<CallSiteInfoSym>::map(IO &IO) {
   IO.mapOptional("Offset", Symbol.CodeOffset, 0U);
   IO.mapOptional("Segment", Symbol.Segment, uint16_t(0));
   IO.mapRequired("Type", Symbol.Type);
 }
 
 template <> void SymbolRecordImpl<FileStaticSym>::map(IO &IO) {
   IO.mapRequired("Index", Symbol.Index);

llvm/tools/llvm-pdbutil/MinimalSymbolDumper.cpp

P.formatLine(
       "local fp reg = {0}, param fp reg = {1}",
       formatRegisterId(FP.getLocalFramePtrReg(CompilationCPU), CompilationCPU),
       formatRegisterId(FP.getParamFramePtrReg(CompilationCPU), CompilationCPU));
   P.formatLine("flags = {0}",
                formatFrameProcedureOptions(P.getIndentLevel() + 9, FP.Flags));
   return Error::success();
 }
 
+Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, PgoSym &PGO) {
+  AutoIndent Indent(P, 7);
+  P.formatLine("Call Count = {0}, Dynamic Instruction Count = {1}",
+               PGO.FunctionEntryCount, PGO.DynamicInstrCount);
+  P.formatLine("Live Instruction Count = {0}, Static Instruction Count = {1}",
+               PGO.LiveInstrCount, PGO.StaticInstrCount);
+  return Error::success();
+}
+
 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
                                             HeapAllocationSiteSym &HAS) {
   AutoIndent Indent(P, 7);
   P.formatLine("type = {0}, addr = {1} call size = {2}", typeIndex(HAS.Type),
                formatSegmentOffset(HAS.Segment, HAS.CodeOffset),
                HAS.CallInstructionSize);
   return Error::success();
 }