[PassManager] Add pretty stack entries before P->run() call.

[fhahn]

Summary

This patch adds PrettyStackEntries before running passes. The entries
include the pass name and the IR unit the pass runs on.

The information is used the print additional information when a pass
crashes, including the name and a reference to the IR unit on which it
crashed. This is similar to the behavior of the legacy pass manager.

The improved stack trace now includes:

Stack dump:
0. Program arguments: bin/opt -loop-vectorize -force-vector-width=4 crash.ll

1. Running pass 'ModuleToFunctionPassAdaptor' on module 'crash.ll'
2. Running pass 'LoopVectorizePass' on function '@a'

[myhsu]

I think this is a really neat feature :-)
Please remember to fix the clang-format errors.

llvm/lib/IR/PassManager.cpp

166

I don't think MF->getName() should be commented

[fhahn]

Fix formatting, replace commented out code with explanation why the code doesn't call MF->getName().

[fhahn]

llvm/lib/IR/PassManager.cpp

166

Ah thanks, I forgot about that. Replaced with a comment.

[aeubanks]

Definitely seems good.
This should be added for all adaptors (module->cgscc,module->function,cgscc->function,function->loop) and pass managers (loop/cgscc are implemented separately)
PassManager.h/cpp, LoopPassManager.h/cpp, CGSCCPassManager.h/cpp

Could be tested with the crash pass that was supposed to be landed in https://reviews.llvm.org/D86657, which needs to be relanded

llvm/lib/IR/PassManager.cpp

177–180

We'll either have a Loop, Function, SCC, or Module (MachineFunction doesn't work yet, but I guess it doesn't hurt to add)
See StandardInstrumentations.cpp for similar code

[fhahn]

In D120993#3361927, @aeubanks wrote:

Definitely seems good.
This should be added for all adaptors (module->cgscc,module->function,cgscc->function,function->loop) and pass managers (loop/cgscc are implemented separately)
PassManager.h/cpp, LoopPassManager.h/cpp, CGSCCPassManager.h/cpp

Could be tested with the crash pass that was supposed to be landed in https://reviews.llvm.org/D86657, which needs to be relanded

I added the missing implementations and added crashing passes for all of them.

[aeubanks]

llvm/lib/Passes/PassBuilder.cpp

395

CrashingCGSCCPass

llvm/test/Other/crash-module.ll

8

this is failing on windows, I don't think we need to be so strict on checking this line

[fhahn]

Fix CGSCC template arg, do not check specific arguments in test.

[fhahn]

llvm/lib/Passes/PassBuilder.cpp

395

Thanks, that should bet tied now.

llvm/test/Other/crash-module.ll

8

Was the issue that part after Program arguments:? I dropped that from the checks.

[aeubanks]

llvm/lib/Transforms/Scalar/LoopPassManager.cpp

297

this might be UAF if L is deleted in the loop pass before we crash (see runAfterPassInvalidated below where we don't reference L for this reason), but given that this is for crash stack traces, it probably doesn't matter

llvm/test/Other/crash-module.ll

8

the presubmit said the test was failing, likely due to opt vs opt.exe, but I didn't look too closely
I think this works

[fhahn]

Reduce size of class, relax check lines to account for stack dump not always being printed.

[fhahn]

Rebase

[nikic]

FYI it looks like this isn't as free as I would have expected: http://llvm-compile-time-tracker.com/compare.php?from=338dfcd60f843082bb589b287d890dbd9394eb82&to=128745cc2681c284bc6d0150a319673a6d6e8424&stat=instructions

[fhahn]

In D120993#3370083, @nikic wrote:

FYI it looks like this isn't as free as I would have expected: http://llvm-compile-time-tracker.com/compare.php?from=338dfcd60f843082bb589b287d890dbd9394eb82&to=128745cc2681c284bc6d0150a319673a6d6e8424&stat=instructions

Yeah that's not great. I'll revert it in a bit and check if there's anything in particular that's very expensive.

[aeubanks]

In D120993#3370129, @fhahn wrote:

In D120993#3370083, @nikic wrote:

FYI it looks like this isn't as free as I would have expected: http://llvm-compile-time-tracker.com/compare.php?from=338dfcd60f843082bb589b287d890dbd9394eb82&to=128745cc2681c284bc6d0150a319673a6d6e8424&stat=instructions

Yeah that's not great. I'll revert it in a bit and check if there's anything in particular that's very expensive.

If I had to guess, it might be eagerly retrieving loop names or cgscc names since they can be pretty big if the scc contains a lot of functions or if the loop has a lot of blocks
we could start without the cgscc name and using the function name for loop passes

[myhsu]

In D120993#3370129, @fhahn wrote:

In D120993#3370083, @nikic wrote:

FYI it looks like this isn't as free as I would have expected: http://llvm-compile-time-tracker.com/compare.php?from=338dfcd60f843082bb589b287d890dbd9394eb82&to=128745cc2681c284bc6d0150a319673a6d6e8424&stat=instructions

Yeah that's not great. I'll revert it in a bit and check if there's anything in particular that's very expensive.

My ballpark guess is that the whole SIGINFO printing feature is kinda expensive, since we're forced to load GlobalSigInfoGenerationCounter every time, but the feature is actually never used upstream.

[fhahn]

In D120993#3370296, @aeubanks wrote:

In D120993#3370129, @fhahn wrote:

In D120993#3370083, @nikic wrote:

FYI it looks like this isn't as free as I would have expected: http://llvm-compile-time-tracker.com/compare.php?from=338dfcd60f843082bb589b287d890dbd9394eb82&to=128745cc2681c284bc6d0150a319673a6d6e8424&stat=instructions

Yeah that's not great. I'll revert it in a bit and check if there's anything in particular that's very expensive.

If I had to guess, it might be eagerly retrieving loop names or cgscc names since they can be pretty big if the scc contains a lot of functions or if the loop has a lot of blocks
we could start without the cgscc name and using the function name for loop passes

I tried splitting off the loop & CGSCC handling into separate classes that only take pointers to Loop/ SCC. The compile-time impact is better, but still noticeable (worst config: +0.17% on ReleastThinLTO - https://llvm-compile-time-tracker.com/compare.php?from=af98b0af6705df3859ee3c98525b57025d40d9e8&to=bc328a534f528fbf8d7a37eaf08e70bd78b75896&stat=instructions)

[dexonsmith]

In D120993#3372697, @fhahn wrote:

In D120993#3370296, @aeubanks wrote:

In D120993#3370129, @fhahn wrote:

In D120993#3370083, @nikic wrote:

FYI it looks like this isn't as free as I would have expected: http://llvm-compile-time-tracker.com/compare.php?from=338dfcd60f843082bb589b287d890dbd9394eb82&to=128745cc2681c284bc6d0150a319673a6d6e8424&stat=instructions

Yeah that's not great. I'll revert it in a bit and check if there's anything in particular that's very expensive.

If I had to guess, it might be eagerly retrieving loop names or cgscc names since they can be pretty big if the scc contains a lot of functions or if the loop has a lot of blocks
we could start without the cgscc name and using the function name for loop passes

I tried splitting off the loop & CGSCC handling into separate classes that only take pointers to Loop/ SCC. The compile-time impact is better, but still noticeable (worst config: +0.17% on ReleastThinLTO - https://llvm-compile-time-tracker.com/compare.php?from=af98b0af6705df3859ee3c98525b57025d40d9e8&to=bc328a534f528fbf8d7a37eaf08e70bd78b75896&stat=instructions)

A few ideas that might be worth considering (if they help), if you can't get it as cheap as it should be:

1. Add a -cc1 option to clang for whether to add pretty stack tracing; turn it on by default, but have the driver pass -skip-pretty-stack-traces-in-passes=true to turn it off in release builds (checking NDEBUG, like -discard-value-names=true or whatever it is).
2. Land it but only handle the passes where the granularity is coarse enough that it's "cheap" (e.g., maybe just module/cgscc/function passes?).
3. Both: check for everything by default, but have the driver pass a -cc1 option that turns off the expensive ones.

llvm/include/llvm/IR/PassManager.h

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassInstrumentation.h"
 #include "llvm/IR/PassManagerInternal.h"
+#include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/TypeName.h"
 #include <cassert>
 #include <cstring>
 #include <iterator>
 #include <list>
 #include <memory>
+#include <string>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 
 /// A special type used by analysis passes to provide an address that

 } // namespace detail
 
 // Forward declare the pass instrumentation analysis explicitly queried in
 // generic PassManager code.
 // FIXME: figure out a way to move PassInstrumentationAnalysis into its own
 // header.
 class PassInstrumentationAnalysis;
 
+class MachineFunction;
+class Loop;
+
+/// Add stack entry with the pass name and the IR unit it runs on.
+class NewPassManagerPrettyStackEntry : public PrettyStackTraceEntry {
+  enum class EntryTy {
+    Module,
+    CGSCC,
+    MachineFunction,
+    Loop,
+    Value,
+  };
+
+  union {
+    Module *M;
+    MachineFunction *MF;
+    Value *V;
+    StringRef LoopName;
+    std::string CGSCCName;
+  };
+  StringRef PassName;
+  EntryTy E;
+
+public:
+  NewPassManagerPrettyStackEntry(StringRef PassName, Module &M)
+      : M(&M), PassName(PassName), E(EntryTy::Module) {}
+  NewPassManagerPrettyStackEntry(StringRef PassName, MachineFunction &MF)
+      : MF(&MF), PassName(PassName), E(EntryTy::MachineFunction) {}
+  NewPassManagerPrettyStackEntry(StringRef PassName, Value &V)
+      : V(&V), PassName(PassName), E(EntryTy::Value) {}
+  NewPassManagerPrettyStackEntry(StringRef PassName, StringRef LoopName)
+      : LoopName(LoopName), PassName(PassName), E(EntryTy::Loop) {}
+  NewPassManagerPrettyStackEntry(StringRef PassName, std::string CGSCCName)
+      : CGSCCName(CGSCCName), PassName(PassName), E(EntryTy::CGSCC) {}
+
+  ~NewPassManagerPrettyStackEntry() override {
+    if (E == EntryTy::CGSCC)
+      CGSCCName.~basic_string();
+  }
+
+  /// print - Emit information about this stack frame to OS.
+  void print(raw_ostream &OS) const override;
+};
+
 /// Manages a sequence of passes over a particular unit of IR.
 ///
 /// A pass manager contains a sequence of passes to run over a particular unit
 /// of IR (e.g. Functions, Modules). It is itself a valid pass over that unit of
 /// IR, and when run over some given IR will run each of its contained passes in
 /// sequence. Pass managers are the primary and most basic building block of a
 /// pass pipeline.
 ///
for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx) {
       // pass, skip its execution completely if asked to (callback returns
       // false).
       if (!PI.runBeforePass<IRUnitT>(*P, IR))
         continue;
 
       PreservedAnalyses PassPA;
       {
         TimeTraceScope TimeScope(P->name(), IR.getName());
+        NewPassManagerPrettyStackEntry StackEntry(P->name(), IR);
         PassPA = P->run(IR, AM, ExtraArgs...);
       }
 
       // Call onto PassInstrumentation's AfterPass callbacks immediately after
       // running the pass.
       PI.runAfterPass<IRUnitT>(*P, IR, PassPA);
 
       // Update the analysis manager as each pass runs and potentially

llvm/include/llvm/Transforms/Scalar/LoopPassManager.h

Optional<PreservedAnalyses> LoopPassManager::runSinglePass(
   // Check the PassInstrumentation's BeforePass callbacks before running the
   // pass, skip its execution completely if asked to (callback returns false).
   if (!PI.runBeforePass<Loop>(*Pass, L))
     return None;
 
   PreservedAnalyses PA;
   {
     TimeTraceScope TimeScope(Pass->name(), IR.getName());
+    NewPassManagerPrettyStackEntry StackEntry(Pass->name(), L.getName());
     PA = Pass->run(IR, AM, AR, U);
   }
 
   // do not pass deleted Loop into the instrumentation
   if (U.skipCurrentLoop())
     PI.runAfterPassInvalidated<IRUnitT>(*Pass, PA);
   else
     PI.runAfterPass<Loop>(*Pass, L, PA);

llvm/lib/Analysis/CGSCCPassManager.cpp

for (auto &Pass : Passes) {
     // Check the PassInstrumentation's BeforePass callbacks before running the
     // pass, skip its execution completely if asked to (callback returns false).
     if (!PI.runBeforePass(*Pass, *C))
       continue;
 
     PreservedAnalyses PassPA;
     {
       TimeTraceScope TimeScope(Pass->name());
+      NewPassManagerPrettyStackEntry StackEntry(Pass->name(), C->getName());
       PassPA = Pass->run(*C, AM, G, UR);
     }
 
     if (UR.InvalidatedSCCs.count(C))
       PI.runAfterPassInvalidated<LazyCallGraph::SCC>(*Pass, PassPA);
     else
       PI.runAfterPass<LazyCallGraph::SCC>(*Pass, *C, PassPA);
 

llvm/lib/IR/PassManager.cpp

for (Function &F : M) {
     // pass, skip its execution completely if asked to (callback returns
     // false).
     if (!PI.runBeforePass<Function>(*Pass, F))
       continue;
 
     PreservedAnalyses PassPA;
     {
       TimeTraceScope TimeScope(Pass->name(), F.getName());
+      NewPassManagerPrettyStackEntry StackEntry(Pass->name(), F);
       PassPA = Pass->run(F, FAM);
     }
 
     PI.runAfterPass(*Pass, F, PassPA);
 
     // We know that the function pass couldn't have invalidated any other
     // function's analyses (that's the contract of a function pass), so
     // directly handle the function analysis manager's invalidation here.
PreservedAnalyses ModuleToFunctionPassAdaptor::run(Module &M,
   PA.preserveSet<AllAnalysesOn<Function>>();
   PA.preserve<FunctionAnalysisManagerModuleProxy>();
   return PA;
 }
 
 AnalysisSetKey CFGAnalyses::SetKey;
 
 AnalysisSetKey PreservedAnalyses::AllAnalysesKey;
+
+void NewPassManagerPrettyStackEntry::print(raw_ostream &OS) const {
+  OS << "Running pass '" << PassName << "'";
+
+  if (E == EntryTy::Module) {
+    OS << " on module '" << M->getModuleIdentifier() << "'.\n";
+    return;
+  }
+
+  if (E == EntryTy::MachineFunction) {
+    // Printing the machine function's name would require pulling in
+    // llvm/Codegen/MachineFunction.h
+    OS << " on machine function \n";
+    return;
+  }
+
+  if (E == EntryTy::Loop) {
+    OS << " on loop '" << LoopName << "'.\n";
+    return;
+  }
+
+  if (E == EntryTy::CGSCC) {
+    OS << " on CGSCC '" << CGSCCName << "'.\n";
+    return;
+  }
+
+  assert(E == EntryTy::Value && "unexpected stack entry type");
+
+  OS << " on ";
+  if (isa<Function>(V))
+    OS << "function";
+  else if (isa<BasicBlock>(V))
+    OS << "basic block";
+  else
+    OS << "value";
+
+  OS << " '";
+  V->printAsOperand(OS, /*PrintType=*/false);
+  OS << "'\n";
+}

llvm/lib/Passes/PassBuilder.cpp

 /// We currently only use this for --print-before/after.
 bool shouldPopulateClassToPassNames() {
   return PrintPipelinePasses || !printBeforePasses().empty() ||
          !printAfterPasses().empty();
 }
 
 } // namespace
 
+/// Passes to test crash handling.
+/// DO NOT USE THIS EXCEPT FOR TESTING!
+struct CrashingFunctionPass : public PassInfoMixin<CrashingFunctionPass> {
+  PreservedAnalyses run(Function &, FunctionAnalysisManager &) {
+    llvm_unreachable("");
+  }
+};
+struct CrashingModulePass : public PassInfoMixin<CrashingModulePass> {
+  PreservedAnalyses run(Module &, ModuleAnalysisManager &) {
+    llvm_unreachable("");
+  }
+};
+struct CrashingLoopPass : public PassInfoMixin<CrashingLoopPass> {
+  PreservedAnalyses run(Loop &, LoopAnalysisManager &,
+                        LoopStandardAnalysisResults &, LPMUpdater &) {
+    llvm_unreachable("");
+  }
+};
+struct CrashingCGSCCPass : public PassInfoMixin<CrashingCGSCCPass> {
+  PreservedAnalyses run(LazyCallGraph::SCC &, CGSCCAnalysisManager &,
+                        LazyCallGraph &, CGSCCUpdateResult &) {
+    llvm_unreachable("");
+  }
+};
+
 PassBuilder::PassBuilder(TargetMachine *TM, PipelineTuningOptions PTO,
                          Optional<PGOOptions> PGOOpt,
                          PassInstrumentationCallbacks *PIC)
     : TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC) {
   if (TM)
     TM->registerPassBuilderCallbacks(*this);
   if (PIC && shouldPopulateClassToPassNames()) {
 #define MODULE_PASS(NAME, CREATE_PASS)                                         \

llvm/lib/Passes/PassRegistry.def

 MODULE_PASS("attributor", AttributorPass())
 MODULE_PASS("annotation2metadata", Annotation2MetadataPass())
 MODULE_PASS("openmp-opt", OpenMPOptPass())
 MODULE_PASS("called-value-propagation", CalledValuePropagationPass())
 MODULE_PASS("canonicalize-aliases", CanonicalizeAliasesPass())
 MODULE_PASS("cg-profile", CGProfilePass())
 MODULE_PASS("check-debugify", NewPMCheckDebugifyPass())
 MODULE_PASS("constmerge", ConstantMergePass())
+MODULE_PASS("crash-module", CrashingModulePass())
 MODULE_PASS("cross-dso-cfi", CrossDSOCFIPass())
 MODULE_PASS("deadargelim", DeadArgumentEliminationPass())
 MODULE_PASS("debugify", NewPMDebugifyPass())
 MODULE_PASS("elim-avail-extern", EliminateAvailableExternallyPass())
 MODULE_PASS("extract-blocks", BlockExtractorPass())
 MODULE_PASS("forceattrs", ForceFunctionAttrsPass())
 MODULE_PASS("function-import", FunctionImportPass())
 MODULE_PASS("function-specialization", FunctionSpecializationPass())

 CGSCC_ANALYSIS("fam-proxy", FunctionAnalysisManagerCGSCCProxy())
 CGSCC_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC))
 #undef CGSCC_ANALYSIS
 
 #ifndef CGSCC_PASS
 #define CGSCC_PASS(NAME, CREATE_PASS)
 #endif
 CGSCC_PASS("argpromotion", ArgumentPromotionPass())
+CGSCC_PASS("crash-cgscc", CrashingCGSCCPass())
 CGSCC_PASS("invalidate<all>", InvalidateAllAnalysesPass())
 CGSCC_PASS("function-attrs", PostOrderFunctionAttrsPass())
 CGSCC_PASS("attributor-cgscc", AttributorCGSCCPass())
 CGSCC_PASS("openmp-opt-cgscc", OpenMPOptCGSCCPass())
 CGSCC_PASS("coro-split", CoroSplitPass())
 CGSCC_PASS("no-op-cgscc", NoOpCGSCCPass())
 #undef CGSCC_PASS
 

 FUNCTION_PASS("callsite-splitting", CallSiteSplittingPass())
 FUNCTION_PASS("consthoist", ConstantHoistingPass())
 FUNCTION_PASS("constraint-elimination", ConstraintEliminationPass())
 FUNCTION_PASS("chr", ControlHeightReductionPass())
 FUNCTION_PASS("coro-early", CoroEarlyPass())
 FUNCTION_PASS("coro-elide", CoroElidePass())
 FUNCTION_PASS("coro-cleanup", CoroCleanupPass())
 FUNCTION_PASS("correlated-propagation", CorrelatedValuePropagationPass())
+FUNCTION_PASS("crash-function", CrashingFunctionPass())
 FUNCTION_PASS("dce", DCEPass())
 FUNCTION_PASS("dfa-jump-threading", DFAJumpThreadingPass())
 FUNCTION_PASS("div-rem-pairs", DivRemPairsPass())
 FUNCTION_PASS("dse", DSEPass())
 FUNCTION_PASS("dot-cfg", CFGPrinterPass())
 FUNCTION_PASS("dot-cfg-only", CFGOnlyPrinterPass())
 FUNCTION_PASS("dot-dom", DomTreePrinterPass())
 FUNCTION_PASS("dot-dom-only", DomTreeOnlyPrinterPass())

 LOOP_ANALYSIS("iv-users", IVUsersAnalysis())
 LOOP_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC))
 #undef LOOP_ANALYSIS
 
 #ifndef LOOP_PASS
 #define LOOP_PASS(NAME, CREATE_PASS)
 #endif
 LOOP_PASS("canon-freeze", CanonicalizeFreezeInLoopsPass())
+LOOP_PASS("crash-loop", CrashingLoopPass())
 LOOP_PASS("dot-ddg", DDGDotPrinterPass())
 LOOP_PASS("invalidate<all>", InvalidateAllAnalysesPass())
 LOOP_PASS("licm", LICMPass())
 LOOP_PASS("loop-idiom", LoopIdiomRecognizePass())
 LOOP_PASS("loop-instsimplify", LoopInstSimplifyPass())
 LOOP_PASS("loop-rotate", LoopRotatePass())
 LOOP_PASS("no-op-loop", NoOpLoopPass())
 LOOP_PASS("print", PrintLoopPass(dbgs()))

llvm/lib/Transforms/Scalar/LoopPassManager.cpp

#endif
     // pass, skip its execution completely if asked to (callback returns
     // false).
     if (!PI.runBeforePass<Loop>(*Pass, *L))
       continue;
 
     PreservedAnalyses PassPA;
     {
       TimeTraceScope TimeScope(Pass->name());
+      NewPassManagerPrettyStackEntry StackEntry(Pass->name(), L->getName());
       PassPA = Pass->run(*L, LAM, LAR, Updater);
     }
 
     // Do not pass deleted Loop into the instrumentation.
     if (Updater.skipCurrentLoop())
       PI.runAfterPassInvalidated<Loop>(*Pass, PassPA);
     else
       PI.runAfterPass<Loop>(*Pass, *L, PassPA);

llvm/test/Other/crash-cgscc.ll

+; REQUIRES: asserts
+
+; RUN: not --crash opt -passes=crash-cgscc %s 2> %t
+; RUN: FileCheck --input-file=%t %s
+
+; CHECK:      Stack dump:
+; CHECK-NEXT: 0.    Program arguments:
+; CHECK-NEXT: 1.    Running pass 'ModuleToPostOrderCGSCCPassAdaptor' on module
+; CHECK-NEXT: 2.    Running pass 'CrashingCGSCCPass' on CGSCC '(foo)'.
+
+define void @foo() {
+  ret void
+}

llvm/test/Other/crash-function.ll

+; REQUIRES: asserts
+
+; RUN: not --crash opt -passes=crash-function %s 2> %t
+; RUN: FileCheck --input-file=%t %s
+
+; CHECK:      Stack dump:
+; CHECK-NEXT: 0.  Program arguments:
+; CHECK-NEXT: 1.  Running pass 'ModuleToFunctionPassAdaptor' on module
+; CHECK-NEXT: 2.  Running pass 'PassManager<llvm::Function>' on function '@foo'
+; CHECK-NEXT: 3.  Running pass 'CrashingFunctionPass' on function '@foo'
+
+define void @foo() {
+  ret void
+}

llvm/test/Other/crash-loop.ll

+; REQUIRES: asserts
+
+; RUN: not --crash opt -passes=crash-loop %s 2> %t
+; RUN: FileCheck --input-file=%t %s
+
+; CHECK:      Stack dump:
+; CHECK-NEXT: 0.  Program arguments:
+; CHECK-NEXT: 1.  Running pass 'ModuleToFunctionPassAdaptor' on module
+; CHECK-NEXT: 2.  Running pass 'PassManager<llvm::Function>' on function '@foo'
+; CHECK-NEXT: 3.  Running pass 'FunctionToLoopPassAdaptor' on function '@foo'
+; CHECK-NEXT: 4.  Running pass 'PassManager<llvm::Loop, llvm::LoopAnalysisManager, llvm::LoopStandardAnalysisResults &, llvm::LPMUpdater &>' on loop 'loop.header'.
+; CHECK-NEXT: 5.  Running pass 'CrashingLoopPass' on loop 'loop.header'.
+
+define void @foo() {
+entry:
+  br label %loop.header
+
+loop.header:
+  br label %loop.header
+}

llvm/test/Other/crash-module.ll

+; REQUIRES: asserts
+
+; RUN: not --crash opt -passes=crash-module %s 2> %t
+; RUN: FileCheck --input-file=%t %s
+
+; CHECK:      Stack dump:
+; CHECK-NEXT: 0. Program arguments:
+; CHECK-NEXT: 1. Running pass 'CrashingModulePass' on module
+
+define void @foo() {
+  ret void
+}