[InstrProf] Emit warnings when correlating lightweight profiles

[ellis]

Summary

Emit warnings when InstrProfCorrelator finds problems with debug info for lightweight instrumentation profile correlation. To prevent excessive printing, only emit the first 5 warnings.

In addition, remove a diagnostic about missing debug info in InstrProfiling.cpp. Some compiler-generated functions, e.g., __clang_call_terminate, does not emit debug info and will fail a build if -Werror is used. This warning is not actionable by the user and I have not seen non-compiler-generated functions fail this test.

[smeenai]

Is it possible to add a test case?

[phosek]

llvm/lib/ProfileData/InstrProfCorrelator.cpp

268

Could this be controlled by an option, with default value being 5, rather than hardcoding the value here?

[ellis]

Add flag ---max-debug-info-correlation-warnings and a test

[smeenai]

LGTM ... this seems like a straightforward enough improvement.

llvm/tools/llvm-profdata/llvm-profdata.cpp

3002

For these sorts of flags, 0 usually means unlimited, and it might be good to follow that pattern here. E.g. see --error-limit in LLD (and I'm pretty sure Clang works the same way).

[ellis]

Use 0 to mean unlimited warnings

compiler-rt/test/profile/Linux/instrprof-debug-info-correlate-warnings.c

+// Disable full debug info and verify that we get warnings during merging
+
+// RUN: %clang_pgogen -o %t -gline-tables-only -mllvm --debug-info-correlate -mllvm --disable-vp=true %S/../Inputs/instrprof-debug-info-correlate-main.cpp %S/../Inputs/instrprof-debug-info-correlate-foo.cpp
+// RUN: env LLVM_PROFILE_FILE=%t.proflite %run %t
+// RUN: llvm-profdata merge -o %t.profdata --debug-info=%t %t.proflite --max-debug-info-correlation-warnings=2 2>&1 >/dev/null | FileCheck %s --check-prefixes=CHECK,LIMIT --implicit-check-not=warning
+// RUN: llvm-profdata merge -o %t.profdata --debug-info=%t %t.proflite --max-debug-info-correlation-warnings=0 2>&1 >/dev/null | FileCheck %s --check-prefixes=CHECK,NOLIMIT --implicit-check-not=warning
+
+// CHECK: warning: Could not find address of function
+// CHECK: warning: Could not find address of function
+// NOLIMIT: warning: Could not find address of function
+// NOLIMIT: warning: Could not find address of function
+// NOLIMIT: warning: Could not find address of function
+// LIMIT: warning: Suppressed 3 additional warnings

llvm/include/llvm/ProfileData/InstrProfCorrelator.h

 /// to their functions.
 class InstrProfCorrelator {
 public:
   static llvm::Expected<std::unique_ptr<InstrProfCorrelator>>
   get(StringRef DebugInfoFilename);
 
   /// Construct a ProfileData vector used to correlate raw instrumentation data
   /// to their functions.
-  virtual Error correlateProfileData() = 0;
+  /// \param MaxWarnings the maximum number of warnings to emit (0 = no limit)
+  virtual Error correlateProfileData(int MaxWarnings) = 0;
 
   /// Process debug info and dump the correlation data.
-  virtual Error dumpYaml(raw_ostream &OS) = 0;
+  /// \param MaxWarnings the maximum number of warnings to emit (0 = no limit)
+  virtual Error dumpYaml(int MaxWarnings, raw_ostream &OS) = 0;
 
   /// Return the number of ProfileData elements.
   std::optional<size_t> getDataSize() const;
 
   /// Return a pointer to the names string that this class constructs.
   const char *getNamesPointer() const { return Names.c_str(); }
 
   /// Return the number of bytes in the names string.
public:
 
   static llvm::Expected<std::unique_ptr<InstrProfCorrelatorImpl<IntPtrT>>>
   get(std::unique_ptr<InstrProfCorrelator::Context> Ctx,
       const object::ObjectFile &Obj);
 
 protected:
   std::vector<RawInstrProf::ProfileData<IntPtrT>> Data;
 
-  Error correlateProfileData() override;
+  Error correlateProfileData(int MaxWarnings) override;
   virtual void correlateProfileDataImpl(
+      int MaxWarnings,
       InstrProfCorrelator::CorrelationData *Data = nullptr) = 0;
 
-  Error dumpYaml(raw_ostream &OS) override;
+  Error dumpYaml(int MaxWarnings, raw_ostream &OS) override;
 
   void addProbe(StringRef FunctionName, uint64_t CFGHash, IntPtrT CounterOffset,
                 IntPtrT FunctionPtr, uint32_t NumCounters);
 
 private:
   InstrProfCorrelatorImpl(InstrProfCorrelatorKind Kind,
                           std::unique_ptr<InstrProfCorrelator::Context> Ctx)
       : InstrProfCorrelator(Kind, std::move(Ctx)){};
private:
   ///         DW_AT_name  ("CFG Hash")
   ///         DW_AT_const_value (12345678)
   ///       DW_TAG_LLVM_annotation
   ///         DW_AT_name  ("Num Counters")
   ///         DW_AT_const_value (2)
   ///       NULL
   ///     NULL
   /// \endcode
+  /// \param MaxWarnings the maximum number of warnings to emit (0 = no limit)
+  /// \param Data if provided, populate with the correlation data found
   void correlateProfileDataImpl(
+      int MaxWarnings,
       InstrProfCorrelator::CorrelationData *Data = nullptr) override;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_PROFILEDATA_INSTRPROFCORRELATOR_H

llvm/lib/ProfileData/InstrProfCorrelator.cpp

 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFLocationExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/WithColor.h"
 #include <optional>
 
 #define DEBUG_TYPE "correlator"
 
 using namespace llvm;
 
 /// Get the __llvm_prf_cnts section.
 Expected<object::SectionRef> getCountersSection(const object::ObjectFile &Obj) {
return std::make_unique<DwarfInstrProfCorrelator<IntPtrT>>(std::move(DICtx),
                                                                std::move(Ctx));
   }
   return make_error<InstrProfError>(
       instrprof_error::unable_to_correlate_profile,
       "unsupported debug info format (only DWARF is supported)");
 }
 
 template <class IntPtrT>
-Error InstrProfCorrelatorImpl<IntPtrT>::correlateProfileData() {
+Error InstrProfCorrelatorImpl<IntPtrT>::correlateProfileData(int MaxWarnings) {
   assert(Data.empty() && Names.empty() && NamesVec.empty());
-  correlateProfileDataImpl();
+  correlateProfileDataImpl(MaxWarnings);
   if (Data.empty() || NamesVec.empty())
     return make_error<InstrProfError>(
         instrprof_error::unable_to_correlate_profile,
         "could not find any profile metadata in debug info");
   auto Result =
       collectPGOFuncNameStrings(NamesVec, /*doCompression=*/false, Names);
   CounterOffsets.clear();
   NamesVec.clear();
template <> struct yaml::MappingTraits<InstrProfCorrelator::Probe> {
   }
 };
 
 template <> struct yaml::SequenceElementTraits<InstrProfCorrelator::Probe> {
   static const bool flow = false;
 };
 
 template <class IntPtrT>
-Error InstrProfCorrelatorImpl<IntPtrT>::dumpYaml(raw_ostream &OS) {
+Error InstrProfCorrelatorImpl<IntPtrT>::dumpYaml(int MaxWarnings,
+                                                 raw_ostream &OS) {
   InstrProfCorrelator::CorrelationData Data;
-  correlateProfileDataImpl(&Data);
+  correlateProfileDataImpl(MaxWarnings, &Data);
   if (Data.Probes.empty())
     return make_error<InstrProfError>(
         instrprof_error::unable_to_correlate_profile,
         "could not find any profile metadata in debug info");
   yaml::Output YamlOS(OS);
   YamlOS << Data;
   return Error::success();
 }
if (!Die.hasChildren())
     return false;
   if (const char *Name = Die.getName(DINameKind::ShortName))
     return StringRef(Name).startswith(getInstrProfCountersVarPrefix());
   return false;
 }
 
 template <class IntPtrT>
 void DwarfInstrProfCorrelator<IntPtrT>::correlateProfileDataImpl(
-    InstrProfCorrelator::CorrelationData *Data) {
+    int MaxWarnings, InstrProfCorrelator::CorrelationData *Data) {
+  bool UnlimitedWarnings = (MaxWarnings == 0);
+  // -N suppressed warnings means we can emit up to N (unsuppressed) warnings
+  int NumSuppressedWarnings = -MaxWarnings;
   auto maybeAddProbe = [&](DWARFDie Die) {
     if (!isDIEOfProbe(Die))
       return;
     std::optional<const char *> FunctionName;
     std::optional<uint64_t> CFGHash;
     std::optional<uint64_t> CounterPtr = getLocation(Die);
     auto FnDie = Die.getParent();
     auto FunctionPtr = dwarf::toAddress(FnDie.find(dwarf::DW_AT_low_pc));
for (const DWARFDie &Child : Die.children()) {
                      InstrProfCorrelator::CFGHashAttributeName) == 0) {
         CFGHash = AnnotationFormValue->getAsUnsignedConstant();
       } else if (AnnotationName.compare(
                      InstrProfCorrelator::NumCountersAttributeName) == 0) {
         NumCounters = AnnotationFormValue->getAsUnsignedConstant();
       }
     }
     if (!FunctionName || !CFGHash || !CounterPtr || !NumCounters) {
-      LLVM_DEBUG(dbgs() << "Incomplete DIE for probe\n\tFunctionName: "
-                        << FunctionName << "\n\tCFGHash: " << CFGHash
-                        << "\n\tCounterPtr: " << CounterPtr
-                        << "\n\tNumCounters: " << NumCounters);
+      if (UnlimitedWarnings || ++NumSuppressedWarnings < 1) {
+        WithColor::warning()
+            << "Incomplete DIE for function " << FunctionName
+            << ": CFGHash=" << CFGHash << "  CounterPtr=" << CounterPtr
+            << "  NumCounters=" << NumCounters << "\n";
         LLVM_DEBUG(Die.dump(dbgs()));
+      }
       return;
     }
     uint64_t CountersStart = this->Ctx->CountersSectionStart;
     uint64_t CountersEnd = this->Ctx->CountersSectionEnd;
     if (*CounterPtr < CountersStart || *CounterPtr >= CountersEnd) {
-      LLVM_DEBUG(
-          dbgs() << "CounterPtr out of range for probe\n\tFunction Name: "
-                 << FunctionName << "\n\tExpected: [0x"
-                 << Twine::utohexstr(CountersStart) << ", 0x"
-                 << Twine::utohexstr(CountersEnd) << ")\n\tActual: 0x"
-                 << Twine::utohexstr(*CounterPtr));
+      if (UnlimitedWarnings || ++NumSuppressedWarnings < 1) {
+        WithColor::warning()
+            << format("CounterPtr out of range for function %s: Actual=0x%x "
+                      "Expected=[0x%x, 0x%x)\n",
+                      *FunctionName, *CounterPtr, CountersStart, CountersEnd);
         LLVM_DEBUG(Die.dump(dbgs()));
+      }
       return;
     }
-    if (!FunctionPtr) {
-      LLVM_DEBUG(dbgs() << "Could not find address of " << *FunctionName
-                        << "\n");
+    if (!FunctionPtr && (UnlimitedWarnings || ++NumSuppressedWarnings < 1)) {
+      WithColor::warning() << format("Could not find address of function %s\n",
+                                     *FunctionName);
       LLVM_DEBUG(Die.dump(dbgs()));
     }
     IntPtrT CounterOffset = *CounterPtr - CountersStart;
     if (Data) {
       InstrProfCorrelator::Probe P;
       P.FunctionName = *FunctionName;
       if (auto Name = FnDie.getName(DINameKind::LinkageName))
         P.LinkageName = Name;
auto maybeAddProbe = [&](DWARFDie Die) {
     }
   };
   for (auto &CU : DICtx->normal_units())
     for (const auto &Entry : CU->dies())
       maybeAddProbe(DWARFDie(CU.get(), &Entry));
   for (auto &CU : DICtx->dwo_units())
     for (const auto &Entry : CU->dies())
       maybeAddProbe(DWARFDie(CU.get(), &Entry));
+
+  if (!UnlimitedWarnings && NumSuppressedWarnings > 0)
+    WithColor::warning() << format("Suppressed %d additional warnings\n",
+                                   NumSuppressedWarnings);
 }

llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp

if (auto *SP = Fn->getSubprogram()) {
       auto *DICounter = DB.createGlobalVariableExpression(
           SP, CounterPtr->getName(), /*LinkageName=*/StringRef(), SP->getFile(),
           /*LineNo=*/0, DB.createUnspecifiedType("Profile Data Type"),
           CounterPtr->hasLocalLinkage(), /*IsDefined=*/true, /*Expr=*/nullptr,
           /*Decl=*/nullptr, /*TemplateParams=*/nullptr, /*AlignInBits=*/0,
           Annotations);
       CounterPtr->addDebugInfo(DICounter);
       DB.finalize();
-    } else {
-      std::string Msg = ("Missing debug info for function " + Fn->getName() +
-                         "; required for profile correlation.")
-                            .str();
-      Ctx.diagnose(
-          DiagnosticInfoPGOProfile(M->getName().data(), Msg, DS_Warning));
     }
   }
 
   auto *Int8PtrTy = Type::getInt8PtrTy(Ctx);
   // Allocate statically the array of pointers to value profile nodes for
   // the current function.
   Constant *ValuesPtrExpr = ConstantPointerNull::get(Int8PtrTy);
   uint64_t NS = 0;

llvm/tools/llvm-profdata/llvm-profdata.cpp

if (Error E = Writer.write(Output))
       warn(std::move(E));
   }
 }
 
 static void
 mergeInstrProfile(const WeightedFileVector &Inputs, StringRef DebugInfoFilename,
                   SymbolRemapper *Remapper, StringRef OutputFilename,
                   ProfileFormat OutputFormat, uint64_t TraceReservoirSize,
-                  uint64_t MaxTraceLength, bool OutputSparse,
-                  unsigned NumThreads, FailureMode FailMode,
+                  uint64_t MaxTraceLength, int MaxDbgCorrelationWarnings,
+                  bool OutputSparse, unsigned NumThreads, FailureMode FailMode,
                   const StringRef ProfiledBinary) {
   if (OutputFormat == PF_Compact_Binary)
     exitWithError("Compact Binary is deprecated");
   if (OutputFormat != PF_Binary && OutputFormat != PF_Ext_Binary &&
       OutputFormat != PF_Text)
     exitWithError("unknown format is specified");
 
   std::unique_ptr<InstrProfCorrelator> Correlator;
   if (!DebugInfoFilename.empty()) {
     if (auto Err =
             InstrProfCorrelator::get(DebugInfoFilename).moveInto(Correlator))
       exitWithError(std::move(Err), DebugInfoFilename);
-    if (auto Err = Correlator->correlateProfileData())
+    if (auto Err = Correlator->correlateProfileData(MaxDbgCorrelationWarnings))
       exitWithError(std::move(Err), DebugInfoFilename);
   }
 
   std::mutex ErrorLock;
   SmallSet<instrprof_error, 4> WriterErrorCodes;
 
   // If NumThreads is not specified, auto-detect a good default.
   if (NumThreads == 0)
cl::opt<SampleProfileLayout> ProfileLayout(
       cl::values(
           clEnumValN(SPL_Nest, "nest",
                      "Nested profile, the input should be CS flat profile"),
           clEnumValN(SPL_Flat, "flat",
                      "Profile with nested inlinee flatten out")));
   cl::opt<std::string> DebugInfoFilename(
       "debug-info", cl::init(""),
       cl::desc("Use the provided debug info to correlate the raw profile."));
+  cl::opt<unsigned> MaxDbgCorrelationWarnings(
+      "max-debug-info-correlation-warnings",
+      cl::desc("The maximum number of warnings to emit when correlating "
+               "profile from debug info (0 = no limit)"),
+      cl::init(5));
   cl::opt<std::string> ProfiledBinary(
       "profiled-binary", cl::init(""),
       cl::desc("Path to binary from which the profile was collected."));
   cl::opt<bool> DropProfileSymbolList(
       "drop-profile-symbol-list", cl::init(false), cl::Hidden,
       cl::desc("Drop the profile symbol list when merging AutoFDO profiles "
                "(only meaningful for -sample)"));
   // WARNING: This reservoir size value is propagated to any input indexed
supplementInstrProfile(WeightedInputs, SupplInstrWithSample, OutputFilename,
                            ZeroCounterThreshold, InstrProfColdThreshold);
     return 0;
   }
 
   if (ProfileKind == instr)
     mergeInstrProfile(WeightedInputs, DebugInfoFilename, Remapper.get(),
                       OutputFilename, OutputFormat,
                       TemporalProfTraceReservoirSize,
-                      TemporalProfMaxTraceLength, OutputSparse, NumThreads,
-                      FailureMode, ProfiledBinary);
+                      TemporalProfMaxTraceLength, MaxDbgCorrelationWarnings,
+                      OutputSparse, NumThreads, FailureMode, ProfiledBinary);
   else
     mergeSampleProfile(WeightedInputs, Remapper.get(), OutputFilename,
                        OutputFormat, ProfileSymbolListFile, CompressAllSections,
                        UseMD5, GenPartialProfile, ProfileLayout,
                        SampleMergeColdContext, SampleTrimColdContext,
                        SampleColdContextFrameDepth, FailureMode,
                        DropProfileSymbolList, OutputSizeLimit);
   return 0;
static int showMemProfProfile(const std::string &Filename,
 
   Reader->printYAML(OS);
   return 0;
 }
 
 static int showDebugInfoCorrelation(const std::string &Filename,
                                     bool ShowDetailedSummary,
                                     bool ShowProfileSymbolList,
+                                    int MaxDbgCorrelationWarnings,
                                     ShowFormat SFormat, raw_fd_ostream &OS) {
   if (SFormat == ShowFormat::Json)
     exitWithError("JSON output is not supported for debug info correlation");
   std::unique_ptr<InstrProfCorrelator> Correlator;
   if (auto Err = InstrProfCorrelator::get(Filename).moveInto(Correlator))
     exitWithError(std::move(Err), Filename);
   if (SFormat == ShowFormat::Yaml) {
-    if (auto Err = Correlator->dumpYaml(OS))
+    if (auto Err = Correlator->dumpYaml(MaxDbgCorrelationWarnings, OS))
       exitWithError(std::move(Err), Filename);
     return 0;
   }
 
-  if (auto Err = Correlator->correlateProfileData())
+  if (auto Err = Correlator->correlateProfileData(MaxDbgCorrelationWarnings))
     exitWithError(std::move(Err), Filename);
 
   InstrProfSymtab Symtab;
   if (auto Err = Symtab.create(
           StringRef(Correlator->getNamesPointer(), Correlator->getNamesSize())))
     exitWithError(std::move(Err), Filename);
 
   if (ShowProfileSymbolList)
cl::opt<bool> ShowBinaryIds("binary-ids", cl::init(false),
                               cl::desc("Show binary ids in the profile. "));
   cl::opt<bool> ShowTemporalProfTraces(
       "temporal-profile-traces",
       cl::desc("Show temporal profile traces in the profile."));
   cl::opt<std::string> DebugInfoFilename(
       "debug-info", cl::init(""),
       cl::desc("Read and extract profile metadata from debug info and show "
                "the functions it found."));
+  cl::opt<unsigned> MaxDbgCorrelationWarnings(
+      "max-debug-info-correlation-warnings",
+      cl::desc("The maximum number of warnings to emit when correlating "
+               "profile from debug info (0 = no limit)"),
+      cl::init(5));
   cl::opt<bool> ShowCovered(
       "covered", cl::init(false),
       cl::desc("Show only the functions that have been executed."));
   cl::opt<std::string> ProfiledBinary(
       "profiled-binary", cl::init(""),
       cl::desc("Path to binary from which the profile was collected."));
   cl::opt<bool> ShowProfileVersion("profile-version", cl::init(false),
                                    cl::desc("Show profile version. "));
static int show_main(int argc, const char *argv[]) {
   if (EC)
     exitWithErrorCode(EC, OutputFilename);
 
   if (ShowAllFunctions && !ShowFunction.empty())
     WithColor::warning() << "-function argument ignored: showing all functions\n";
 
   if (!DebugInfoFilename.empty())
     return showDebugInfoCorrelation(DebugInfoFilename, ShowDetailedSummary,
-                                    ShowProfileSymbolList, SFormat, OS);
+                                    ShowProfileSymbolList,
+                                    MaxDbgCorrelationWarnings, SFormat, OS);
 
   if (ProfileKind == instr)
     return showInstrProfile(
         Filename, ShowCounts, TopNFunctions, ShowIndirectCallTargets,
         ShowMemOPSizes, ShowDetailedSummary, DetailedSummaryCutoffs,
         ShowAllFunctions, ShowCS, ValueCutoff, OnlyListBelow, ShowFunction,
         TextFormat, ShowBinaryIds, ShowCovered, ShowProfileVersion,
         ShowTemporalProfTraces, SFormat, OS);