[llvm-profdata] Improve error messaging when merging mismatched profile data

[slingn]

Summary

This change tries to make the root cause of instrumented profile data merge failures clearer.

Previous:

$ llvm-profdata merge test_0.profraw test_1.profraw -o test_merged.profdata
test_1.profraw: foo: Function count mismatch
test_1.profraw: bar: Function count mismatch
test_1.profraw: baz: Function count mismatch
...

Changed:

$ llvm-profdata merge test_0.profraw test_1.profraw -o test_merged.profdata
test_1.profraw: foo: Function basic block count change detected (counter mismatch)
Make sure that all profile data to be merged is generated from the same binary.
test_1.profraw: bar: Function basic block count change detected (counter mismatch)
test_1.profraw: baz: Function basic block count change detected (counter mismatch)
...

[dnovillo]

LGTM

tools/llvm-profdata/llvm-profdata.cpp

48

Could you commit pure clang-format changes separately? No need to have these reviewed.

lib/ProfileData/InstrProf.cpp

case instrprof_error::too_large:
       return "Too much profile data";
     case instrprof_error::truncated:
       return "Truncated profile data";
     case instrprof_error::malformed:
       return "Malformed instrumentation profile data";
     case instrprof_error::unknown_function:
       return "No profile data available for function";
     case instrprof_error::hash_mismatch:
-      return "Function hash mismatch";
+      return "Function control flow change detected (hash mismatch)";
     case instrprof_error::count_mismatch:
-      return "Function count mismatch";
+      return "Function basic block count change detected (counter mismatch)";
     case instrprof_error::counter_overflow:
       return "Counter overflow";
     case instrprof_error::value_site_count_mismatch:
-      return "Function's value site counts mismatch";
+      return "Function value site count change detected (counter mismatch)";
     }
     llvm_unreachable("A value of instrprof_error has no message.");
   }
 };
 }
 
 static ManagedStatic<InstrProfErrorCategoryType> ErrorCategory;
 

test/tools/llvm-profdata/count-mismatch.proftext

 # Make sure we don't try to combine counters with the same function
 # name and a matching hash if the number of counters differs
 
 # RUN: llvm-profdata merge %s -o %t.profdata 2>&1 | FileCheck -check-prefix=MERGE_ERRS %s
 # RUN: llvm-profdata show %t.profdata -all-functions -counts > %t.out
 # RUN: FileCheck %s -input-file %t.out
 foo
 1024
 4
 1
 2
 4
 8
 
 # The hash matches, but we can't combine these because the number of
 # counters differs.
-# MERGE_ERRS: count-mismatch.proftext: foo: Function count mismatch
+# MERGE_ERRS: count-mismatch.proftext: foo: Function basic block count change detected (counter mismatch)
+# MERGE_ERRS: Make sure that all profile data to be merged is generated from the same binary.
 foo
 1024
 3
 2
 4
 8
 
 # This one does match, so it should combine with the first just fine.

tools/llvm-profdata/llvm-profdata.cpp

 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 
+#include <set>
+
 using namespace llvm;
 
 static void exitWithError(const Twine &Message,
                           StringRef Whence = "",
                           StringRef Hint = "") {
   errs() << "error: ";
   if (!Whence.empty())
     errs() << Whence << ": ";
   errs() << Message << "\n";
   if (!Hint.empty())
     errs() << Hint << "\n";
   ::exit(1);
 }
 
-static void exitWithErrorCode(const std::error_code &Error, StringRef Whence = "") {
+static void exitWithErrorCode(const std::error_code &Error,
+                              StringRef Whence = "") {
   if (Error.category() == instrprof_category()) {
     instrprof_error instrError = static_cast<instrprof_error>(Error.value());
     if (instrError == instrprof_error::unrecognized_format) {
       // Hint for common error of forgetting -sample for sample profiles.
       exitWithError(Error.message(), Whence,
                     "Perhaps you forgot to use the -sample option?");
     }
   }
   exitWithError(Error.message(), Whence);
 }
 
 namespace {
     enum ProfileKinds { instr, sample };
 }
 
+static void handleMergeWriterError(std::error_code &Error,
+                                   StringRef WhenceFile = "",
+                                   StringRef WhenceFunction = "",
+                                   bool ShowHint = true)
+{
+  if (!WhenceFile.empty())
+    errs() << WhenceFile << ": ";
+  if (!WhenceFunction.empty())
+    errs() << WhenceFunction << ": ";
+  errs() << Error.message() << "\n";
+
+  if (ShowHint) {
+    StringRef Hint = "";
+    if (Error.category() == instrprof_category()) {
+      instrprof_error instrError = static_cast<instrprof_error>(Error.value());
+      if (instrError == instrprof_error::count_mismatch) {
+        Hint = "Make sure that all profile data to be merged is generated " \
+               "from the same binary.";
+      }
+    }
+
+    if (!Hint.empty())
+      errs() << Hint << "\n";
+  }
+}
+
 static void mergeInstrProfile(const cl::list<std::string> &Inputs,
                               StringRef OutputFilename) {
   if (OutputFilename.compare("-") == 0)
     exitWithError("Cannot write indexed profdata format to stdout.");
 
   std::error_code EC;
   raw_fd_ostream Output(OutputFilename.data(), EC, sys::fs::F_None);
   if (EC)
     exitWithErrorCode(EC, OutputFilename);
 
   InstrProfWriter Writer;
+  std::set<std::error_code> WriterErrorCodes;
   for (const auto &Filename : Inputs) {
     auto ReaderOrErr = InstrProfReader::create(Filename);
     if (std::error_code ec = ReaderOrErr.getError())
       exitWithErrorCode(ec, Filename);
 
     auto Reader = std::move(ReaderOrErr.get());
-    for (auto &I : *Reader)
-      if (std::error_code EC = Writer.addRecord(std::move(I)))
-        errs() << Filename << ": " << I.Name << ": " << EC.message() << "\n";
+    for (auto &I : *Reader) {
+      if (std::error_code EC = Writer.addRecord(std::move(I))) {
+        // Only show hint the first time an error occurs.
+        bool firstTime = WriterErrorCodes.insert(EC).second;
+        handleMergeWriterError(EC, Filename, I.Name, firstTime);
+      }
+    }
     if (Reader->hasError())
       exitWithErrorCode(Reader->getError(), Filename);
   }
   Writer.write(Output);
 }
 
 static void mergeSampleProfile(const cl::list<std::string> &Inputs,
                                StringRef OutputFilename,