Index: llvm/include/llvm/Passes/StandardInstrumentations.h =================================================================== --- llvm/include/llvm/Passes/StandardInstrumentations.h +++ llvm/include/llvm/Passes/StandardInstrumentations.h @@ -15,6 +15,7 @@ #ifndef LLVM_PASSES_STANDARDINSTRUMENTATIONS_H #define LLVM_PASSES_STANDARDINSTRUMENTATIONS_H +#include "llvm/ADT/DenseSet.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringRef.h" #include "llvm/IR/BasicBlock.h" @@ -23,6 +24,7 @@ #include "llvm/IR/ValueHandle.h" #include "llvm/Support/CommandLine.h" +#include #include #include @@ -124,6 +126,35 @@ void registerCallbacks(PassInstrumentationCallbacks &PIC); }; +// Print IR on crash. +class PrintCrashIRInstrumentation { +public: + PrintCrashIRInstrumentation() + : SavedIR("*** Dump of IR Before Last Pass Unknown ***") {} + ~PrintCrashIRInstrumentation(); + void registerCallbacks(PassInstrumentationCallbacks &PIC); + void reportCrashIR(); + +protected: + std::string SavedIR; + +private: + // All of the crash reporters that will report on a crash. + static DenseSet *CrashReporters; + // Crash handler registered when print-on-crash is specified. + static void SignalHandler(void *); + // Exception-safe locking + class MtxLock { + public: + MtxLock() { Mtx.lock(); } + ~MtxLock() { Mtx.unlock(); } + + protected: + // Avoid races when creating/destroying the crash IR printers. + static std::mutex Mtx; + }; +}; + /// This class provides an interface to register all the standard pass /// instrumentations and manages their state (if any). class StandardInstrumentations { @@ -132,6 +163,7 @@ TimePassesHandler TimePasses; OptNoneInstrumentation OptNone; PreservedCFGCheckerInstrumentation PreservedCFGChecker; + PrintCrashIRInstrumentation PrintCrashIR; public: StandardInstrumentations(bool DebugLogging) : PrintPass(DebugLogging) {} @@ -140,6 +172,7 @@ TimePassesHandler &getTimePasses() { return TimePasses; } }; + } // namespace llvm #endif Index: llvm/lib/Passes/PassBuilder.cpp =================================================================== --- llvm/lib/Passes/PassBuilder.cpp +++ llvm/lib/Passes/PassBuilder.cpp @@ -404,6 +404,18 @@ AnalysisKey NoOpFunctionAnalysis::Key; AnalysisKey NoOpLoopAnalysis::Key; +// A pass for testing -print-on-crash. +// DO NOT USE THIS EXCEPT FOR TESTING! +class TriggerCrashPass : public PassInfoMixin { +public: + PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM); +}; + +// DO NOT USE THIS EXCEPT FOR TESTING! +PreservedAnalyses TriggerCrashPass::run(Function &, FunctionAnalysisManager &) { + __builtin_trap(); +} + } // namespace void PassBuilder::invokePeepholeEPCallbacks( Index: llvm/lib/Passes/PassRegistry.def =================================================================== --- llvm/lib/Passes/PassRegistry.def +++ llvm/lib/Passes/PassRegistry.def @@ -271,6 +271,7 @@ FUNCTION_PASS("spec-phis", SpeculateAroundPHIsPass()) FUNCTION_PASS("sroa", SROA()) FUNCTION_PASS("tailcallelim", TailCallElimPass()) +FUNCTION_PASS("trigger-crash", TriggerCrashPass()) FUNCTION_PASS("vector-combine", VectorCombinePass()) FUNCTION_PASS("verify", VerifierPass()) FUNCTION_PASS("verify", DominatorTreeVerifierPass()) Index: llvm/lib/Passes/StandardInstrumentations.cpp =================================================================== --- llvm/lib/Passes/StandardInstrumentations.cpp +++ llvm/lib/Passes/StandardInstrumentations.cpp @@ -15,6 +15,7 @@ #include "llvm/Passes/StandardInstrumentations.h" #include "llvm/ADT/Any.h" #include "llvm/ADT/Optional.h" +#include "llvm/ADT/SmallString.h" #include "llvm/Analysis/CallGraphSCCPass.h" #include "llvm/Analysis/LazyCallGraph.h" #include "llvm/Analysis/LoopInfo.h" @@ -23,9 +24,12 @@ #include "llvm/IR/Module.h" #include "llvm/IR/PassInstrumentation.h" #include "llvm/Support/CommandLine.h" +#include "llvm/Support/CrashRecoveryContext.h" #include "llvm/Support/Debug.h" #include "llvm/Support/FormatVariadic.h" +#include "llvm/Support/Signals.h" #include "llvm/Support/raw_ostream.h" +#include #include using namespace llvm; @@ -51,6 +55,12 @@ cl::desc("Print all pass management debugging information. " "`-debug-pass-manager` must also be specified")); +// An option to print the IR that was being processed when a pass crashes. +static cl::opt + PrintCrashIR("print-on-crash", + cl::desc("Print the last form of the IR before crash"), + cl::init(false), cl::Hidden); + namespace { /// Extracting Module out of \p IR unit. Also fills a textual description @@ -501,6 +511,69 @@ }); } +std::mutex PrintCrashIRInstrumentation::MtxLock::Mtx; +DenseSet + *PrintCrashIRInstrumentation::CrashReporters = nullptr; + +void PrintCrashIRInstrumentation::reportCrashIR() { dbgs() << SavedIR; } + +void PrintCrashIRInstrumentation::SignalHandler(void *) { + // Called by signal handlers so do not lock here + // Are any of PrintCrashIRInstrumentation objects still alive? + if (!CrashReporters) + return; + + assert(PrintCrashIR && "Did not expect to get here without option set."); + for (auto I : *CrashReporters) + I->reportCrashIR(); +} + +PrintCrashIRInstrumentation::~PrintCrashIRInstrumentation() { + if (!PrintCrashIR) + return; + + MtxLock Lock; + assert(CrashReporters && "Expected CrashReporters to be set"); + + // Was this registered? + DenseSet::iterator I = + CrashReporters->find(this); + if (I == CrashReporters->end()) + return; + CrashReporters->erase(I); + if (!CrashReporters->empty()) + return; + delete CrashReporters; + CrashReporters = nullptr; +} + +void PrintCrashIRInstrumentation::registerCallbacks( + PassInstrumentationCallbacks &PIC) { + if (!PrintCrashIR) + return; + + { + MtxLock Lock; + if (!CrashReporters) { + CrashReporters = new DenseSet(); + sys::AddSignalHandler(SignalHandler, nullptr); + } + CrashReporters->insert(this); + } + PIC.registerBeforePassCallback([this](StringRef PassID, Any IR) { + assert((MtxLock(), CrashReporters && CrashReporters->find(this) != + CrashReporters->end()) && + "Expected CrashReporters to be set and containing this"); + SavedIR.clear(); + SmallString<80> Banner = + formatv("*** Dump of {0}IR Before Last Pass {1} Started ***", + llvm::forcePrintModuleIR() ? "Module " : "", PassID); + raw_string_ostream OS(SavedIR); + unwrapAndPrint(OS, IR, Banner, llvm::forcePrintModuleIR()); + return true; + }); +} + void StandardInstrumentations::registerCallbacks( PassInstrumentationCallbacks &PIC) { PrintIR.registerCallbacks(PIC); @@ -508,4 +581,5 @@ TimePasses.registerCallbacks(PIC); OptNone.registerCallbacks(PIC); PreservedCFGChecker.registerCallbacks(PIC); + PrintCrashIR.registerCallbacks(PIC); } Index: llvm/test/Other/print-on-crash.ll =================================================================== --- /dev/null +++ llvm/test/Other/print-on-crash.ll @@ -0,0 +1,29 @@ +; A test that the hidden option -print-on-crash properly sets a signal handler +; which gets called when a pass crashes. The trigger-crash pass calls +; __builtin_trap. + +; RUN: not --crash opt -print-on-crash -passes=trigger-crash < %s 2>&1 | FileCheck %s --check-prefix=CHECK_SIMPLE + +; A test that the signal handler set by the hidden option -print-on-crash +; is not called when no pass crashes. + +; RUN: opt -print-on-crash -passes="default" < %s 2>&1 | FileCheck %s --check-prefix=CHECK_NO_CRASH + +; RUN: not --crash opt -print-on-crash -print-module-scope -passes=trigger-crash < %s 2>&1 | FileCheck %s --check-prefix=CHECK_MODULE + +; The input corresponds to "int main() { return 0; }" but is irrelevant. + +; CHECK_SIMPLE: *** Dump of IR Before Last Pass {{.*}} Started *** +; CHECK_SIMPLE: @main +; CHECK_SIMPLE: entry: +; CHECK_NO_CRASH-NOT: *** Dump of IR +; CHECK_MODULE: *** Dump of Module IR Before Last Pass {{.*}} Started *** +; CHECK_MODULE: ; ModuleID = {{.*}} + +define i32 @main() { +entry: + %retval = alloca i32, align 4 + store i32 0, i32* %retval, align 4 + ret i32 0 +} +