emit bitcode to file when Verifier fails

[vtjnash]

Summary

Sometimes we get bug reports from the Verifier triggering, but need to rest of the module context to see what might have happened (for example https://github.com/JuliaLang/julia/issues/31156). This tries to automatically dump it to a file before killing the process, so that the information is preserved if you want it.

Tested with this:

$ cat broken.ll 
define void @"broken\\bad/filename"(i64) {
top:
  br label %top
}

$ opt -disable-verify -verify broken.ll
Entry block to function must not have predecessors!
label %top
in function broken\bad/filename
LLVM ERROR: Broken function found, compilation aborted!
Broken bitcode dumped to "llvm-broken_bad_filename-2f459a.ll"

[vtjnash]

formatting

[loladiro]

Should probably be an optional feature to the verifier pass, like FatalErrors?

[vtjnash]

I thought about that, but I didn't think it felt like it needed to. If the cwd is readonly, it'll just silently turn itself off.

llvm/lib/IR/Verifier.cpp

 void Verifier::verifySourceDebugInfo(const DICompileUnit &U, const DIFile &F) {
   bool HasSource = F.getSource().hasValue();
   if (!HasSourceDebugInfo.count(&U))
     HasSourceDebugInfo[&U] = HasSource;
   AssertDI(HasSource == HasSourceDebugInfo[&U],
            "inconsistent use of embedded source");
 }
 
+static void report_broken(Module *M, Function *F) {
+  std::string message = F ? "Broken function found, compilation aborted!"
+                          : "Broken module found, compilation aborted!";
+  if (!M) {
+    M = new Module(F->getName(), F->getContext());
+    M->getFunctionList().push_back(F);
+  }
+  int FD;
+  SmallString<128> GeneratedUniqPath;
+  // Create a template based on some characteristics of the failure,
+  // mangled and chopped to be safe for most file systems
+  std::string Pattern(
+      (F && F->hasName() ? F->getName() : M->getName()).slice(0, 32));
+  auto isunsafe = [](unsigned char C) {
+    return !(('A' <= C && C <= 'Z') || ('a' <= C && C <= 'z') ||
+             ('0' <= C && C <= '9') || C == '-' || C == '_');
+  };
+  std::replace_if(Pattern.begin(), Pattern.end(), isunsafe, '_');
+  Pattern = "llvm-" + Pattern + "-%%%%%%.ll";
+  if (!sys::fs::createUniqueFile(Pattern, FD, GeneratedUniqPath)) {
+    raw_fd_ostream OS(FD, true, false);
+    // We'd like to use this, but linking can't handle it,
+    // so instead, we'll use the text format.
+    // WriteBitcodeToFile(*M, OS);
+    M->print(OS, nullptr, true, true);
+    message += "\nBroken bitcode dumped to \"";
+    message += GeneratedUniqPath;
+    message += "\"";
+  }
+  report_fatal_error(message);
+}
+
+static void report_broken(Function &F) { report_broken(F.getParent(), &F); }
+
+static void report_broken(Module &M) { report_broken(&M, nullptr); }
+
 //===----------------------------------------------------------------------===//
 //  Implement the public interfaces to this file...
 //===----------------------------------------------------------------------===//
 
 bool llvm::verifyFunction(const Function &f, raw_ostream *OS) {
   Function &F = const_cast<Function &>(f);
 
   // Don't use a raw_null_ostream.  Printing IR is expensive.
struct VerifierLegacyPass : public FunctionPass {
   bool doInitialization(Module &M) override {
     V = std::make_unique<Verifier>(
         &dbgs(), /*ShouldTreatBrokenDebugInfoAsError=*/false, M);
     return false;
   }
 
   bool runOnFunction(Function &F) override {
     if (!V->verify(F) && FatalErrors) {
-      errs() << "in function " << F.getName() << '\n'; 
-      report_fatal_error("Broken function found, compilation aborted!");
+      errs() << "in function " << F.getName() << '\n';
+      report_broken(F);
     }
     return false;
   }
 
   bool doFinalization(Module &M) override {
     bool HasErrors = false;
     for (Function &F : M)
       if (F.isDeclaration())
         HasErrors |= !V->verify(F);
 
     HasErrors |= !V->verify();
     if (FatalErrors && (HasErrors || V->hasBrokenDebugInfo()))
-      report_fatal_error("Broken module found, compilation aborted!");
+      report_broken(M);
     return false;
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 };
 

 VerifierAnalysis::Result VerifierAnalysis::run(Function &F,
                                                FunctionAnalysisManager &) {
   return { llvm::verifyFunction(F, &dbgs()), false };
 }
 
 PreservedAnalyses VerifierPass::run(Module &M, ModuleAnalysisManager &AM) {
   auto Res = AM.getResult<VerifierAnalysis>(M);
   if (FatalErrors && (Res.IRBroken || Res.DebugInfoBroken))
-    report_fatal_error("Broken module found, compilation aborted!");
+    report_broken(M);
 
   return PreservedAnalyses::all();
 }
 
 PreservedAnalyses VerifierPass::run(Function &F, FunctionAnalysisManager &AM) {
   auto res = AM.getResult<VerifierAnalysis>(F);
   if (res.IRBroken && FatalErrors)
-    report_fatal_error("Broken function found, compilation aborted!");
+    report_broken(F);
 
   return PreservedAnalyses::all();
 }