#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 <iterator>
#include <list>
#include <memory>
+#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
// 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
PreservedAnalyses PassPA;
{
TimeTraceScope TimeScope(P->name(), IR.getName());
+ NewPassManagerPrettyStackEntry StackEntry(P->name(), IR);
PassPA = P->run(IR, AM, ExtraArgs...);
}
PreservedAnalyses PA;
{
TimeTraceScope TimeScope(Pass->name(), IR.getName());
+ NewPassManagerPrettyStackEntry StackEntry(Pass->name(), L.getName());
PA = Pass->run(IR, AM, AR, U);
}
PreservedAnalyses PassPA;
{
TimeTraceScope TimeScope(Pass->name());
+ NewPassManagerPrettyStackEntry StackEntry(Pass->name(), C->getName());
PassPA = Pass->run(*C, AM, G, UR);
}
PreservedAnalyses PassPA;
{
TimeTraceScope TimeScope(Pass->name(), F.getName());
+ NewPassManagerPrettyStackEntry StackEntry(Pass->name(), F);
PassPA = Pass->run(F, FAM);
}
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";
+}
} // 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)
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())
#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())
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())
#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())
PreservedAnalyses PassPA;
{
TimeTraceScope TimeScope(Pass->name());
+ NewPassManagerPrettyStackEntry StackEntry(Pass->name(), L->getName());
PassPA = Pass->run(*L, LAM, LAR, Updater);
}
--- /dev/null
+; 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
+}
--- /dev/null
+; 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
+}
--- /dev/null
+; 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
+}
--- /dev/null
+; 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
+}