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

+  /// This method computes and updates a functions instruction counts
+  void UpdateFunctionInstructionCounts(Function &F);
+

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

-      Streamer->emitIntValue((int)Value, sizeof(T));
+      Streamer->emitIntValue((uint64_t)Value, sizeof(T));

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

-CV_SYMBOL(S_POGODATA       , 0x115c)
+SYMBOL_RECORD(S_POGODATA      , 0x115c, PgoSym)

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

+// 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:
+};
+

llvm/include/llvm/IR/FixedMetadataKinds.def

+LLVM_FIXED_MD_KIND(MD_instrcount, "instrcount", 39)
 No newline at end of file

llvm/include/llvm/IR/Function.h

+  /// 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;
+

llvm/include/llvm/IR/MDBuilder.h

+  /// 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);
+

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

-
+#include "llvm/IR/Dominators.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/BranchProbabilityInfo.h"
+
+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);
+}
+
+  UpdateFunctionInstructionCounts(MF.getFunction());

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

+    // 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);
+    }

llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp

+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();
+}
+

llvm/lib/DebugInfo/CodeView/SymbolRecordMapping.cpp

+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();
+}
+

llvm/lib/DebugInfo/CodeView/TypeIndexDiscovery.cpp

+  case SymbolKind::S_POGODATA:

llvm/lib/IR/Function.cpp

-
+using FunctionInstructionCounts = Function::FunctionInstructionCounts;
+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;
+  }
+

llvm/lib/IR/MDBuilder.cpp

+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);
+}
+

llvm/lib/ObjectYAML/CodeViewYAMLSymbols.cpp

+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);
+}
+

llvm/tools/llvm-pdbutil/MinimalSymbolDumper.cpp

+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();
+}
+