Drop additional parameter and rely on gen_crash_diag

bd1976bris · bd1976bris · commit bf6fbe279d4e · 2025-05-21T21:14:52.000+01:00
diff --git a/clang/tools/clang-repl/ClangRepl.cpp b/clang/tools/clang-repl/ClangRepl.cpp
@@ -55,7 +55,7 @@ static void LLVMErrorHandler(void *UserData, const char *Message,
 
   // Run the interrupt handlers to make sure any special cleanups get done, in
   // particular that we remove files registered with RemoveFileOnSignal.
-  llvm::sys::RunInterruptHandlers(/*IsUsageError=*/false);
+  llvm::sys::RunInterruptHandlers(/*GenCrashDiag=*/false);
 
   // We cannot recover from llvm errors.  When reporting a fatal error, exit
   // with status 70 to generate crash diagnostics.  For BSD systems this is
diff --git a/clang/tools/driver/cc1_main.cpp b/clang/tools/driver/cc1_main.cpp
@@ -72,7 +72,7 @@ static void LLVMErrorHandler(void *UserData, const char *Message,
 
   // Run the interrupt handlers to make sure any special cleanups get done, in
   // particular that we remove files registered with RemoveFileOnSignal.
-  llvm::sys::RunInterruptHandlers(/*IsUsageError=*/false);
+  llvm::sys::RunInterruptHandlers(/*GenCrashDiag=*/false);
 
   // We cannot recover from llvm errors.  When reporting a fatal error, exit
   // with status 70 to generate crash diagnostics.  For BSD systems this is
diff --git a/llvm/include/llvm/Support/Error.h b/llvm/include/llvm/Support/Error.h
@@ -742,8 +742,7 @@ template <class T> class [[nodiscard]] Expected {
 /// @deprecated Use reportFatalInternalError() or reportFatalUsageError()
 /// instead.
 [[noreturn]] LLVM_ABI void report_fatal_error(Error Err,
-                                              bool GenCrashDiag = true,
-                                              bool IsUsageError = false);
+                                              bool GenCrashDiag = true);
 
 /// Report a fatal error that indicates a bug in LLVM.
 /// See ErrorHandling.h for details.
diff --git a/llvm/include/llvm/Support/ErrorHandling.h b/llvm/include/llvm/Support/ErrorHandling.h
@@ -61,14 +61,11 @@ struct ScopedFatalErrorHandler {
 /// @deprecated Use reportFatalInternalError() or reportFatalUsageError()
 /// instead.
 [[noreturn]] LLVM_ABI void report_fatal_error(const char *reason,
-                                              bool gen_crash_diag = true,
-                                              bool is_usage_error = false);
+                                              bool gen_crash_diag = true);
 [[noreturn]] LLVM_ABI void report_fatal_error(StringRef reason,
-                                              bool gen_crash_diag = true,
-                                              bool is_usage_error = false);
+                                              bool gen_crash_diag = true);
 [[noreturn]] LLVM_ABI void report_fatal_error(const Twine &reason,
-                                              bool gen_crash_diag = true,
-                                              bool is_usage_error = false);
+                                              bool gen_crash_diag = true);
 
 /// Report a fatal error that likely indicates a bug in LLVM. It serves a
 /// similar purpose as an assertion, but is always enabled, regardless of the
diff --git a/llvm/include/llvm/Support/Signals.h b/llvm/include/llvm/Support/Signals.h
@@ -26,7 +26,7 @@ namespace sys {
 
 /// This function runs all the registered interrupt handlers, including the
 /// removal of files registered by RemoveFileOnSignal.
-LLVM_ABI void RunInterruptHandlers(bool IsUsageError);
+LLVM_ABI void RunInterruptHandlers(bool GenCrashDiag);
 
 /// This function registers signal handlers to ensure that if a signal gets
 /// delivered that the named file is removed.
@@ -58,7 +58,7 @@ LLVM_ABI void DisableSystemDialogsOnCrash();
 LLVM_ABI void PrintStackTrace(raw_ostream &OS, int Depth = 0);
 
 // Run all registered signal handlers.
-LLVM_ABI void RunSignalHandlers(bool IsUsageError);
+LLVM_ABI void RunSignalHandlers(bool GenCrashDiag);
 
 using SignalHandlerCallback = void (*)(void *, bool);
 
diff --git a/llvm/lib/Support/Debug.cpp b/llvm/lib/Support/Debug.cpp
@@ -148,7 +148,7 @@ void llvm::initDebugOptions() {
 }
 
 // Signal handlers - dump debug output on termination.
-static void debug_user_sig_handler(void *Cookie, bool /*IsUsageError*/) {
+static void debug_user_sig_handler(void *Cookie, bool /*GenCrashDiag*/) {
   // This is a bit sneaky.  Since this is under #ifndef NDEBUG, we
   // know that debug mode is enabled and dbgs() really is a
   // circular_raw_ostream.  If NDEBUG is defined, then dbgs() ==
diff --git a/llvm/lib/Support/Error.cpp b/llvm/lib/Support/Error.cpp
@@ -164,24 +164,22 @@ Error createStringError(std::string &&Msg, std::error_code EC) {
   return make_error<StringError>(Msg, EC);
 }
 
-void report_fatal_error(Error Err, bool GenCrashDiag, bool IsUsageError) {
+void report_fatal_error(Error Err, bool GenCrashDiag) {
   assert(Err && "report_fatal_error called with success value");
   std::string ErrMsg;
   {
     raw_string_ostream ErrStream(ErrMsg);
     logAllUnhandledErrors(std::move(Err), ErrStream);
   }
-  report_fatal_error(Twine(ErrMsg), GenCrashDiag, IsUsageError);
+  report_fatal_error(Twine(ErrMsg), GenCrashDiag);
 }
 
 void reportFatalInternalError(Error Err) {
-  report_fatal_error(std::move(Err), /*GenCrashDiag=*/true,
-                     /*IsUsageError=*/false);
+  report_fatal_error(std::move(Err), /*GenCrashDiag=*/true);
 }
 
 void reportFatalUsageError(Error Err) {
-  report_fatal_error(std::move(Err), /*GenCrashDiag=*/false,
-                     /*IsUsageError=*/true);
+  report_fatal_error(std::move(Err), /*GenCrashDiag=*/false);
 }
 
 } // end namespace llvm
diff --git a/llvm/lib/Support/ErrorHandling.cpp b/llvm/lib/Support/ErrorHandling.cpp
@@ -80,18 +80,15 @@ void llvm::remove_fatal_error_handler() {
   ErrorHandlerUserData = nullptr;
 }
 
-void llvm::report_fatal_error(const char *Reason, bool GenCrashDiag,
-                              bool IsUsageError) {
-  report_fatal_error(Twine(Reason), GenCrashDiag, IsUsageError);
+void llvm::report_fatal_error(const char *Reason, bool GenCrashDiag) {
+  report_fatal_error(Twine(Reason), GenCrashDiag);
 }
 
-void llvm::report_fatal_error(StringRef Reason, bool GenCrashDiag,
-                              bool IsUsageError) {
-  report_fatal_error(Twine(Reason), GenCrashDiag, IsUsageError);
+void llvm::report_fatal_error(StringRef Reason, bool GenCrashDiag) {
+  report_fatal_error(Twine(Reason), GenCrashDiag);
 }
 
-void llvm::report_fatal_error(const Twine &Reason, bool GenCrashDiag,
-                              bool IsUsageError) {
+void llvm::report_fatal_error(const Twine &Reason, bool GenCrashDiag) {
   llvm::fatal_error_handler_t handler = nullptr;
   void* handlerData = nullptr;
   {
@@ -121,7 +118,7 @@ void llvm::report_fatal_error(const Twine &Reason, bool GenCrashDiag,
   // If we reached here, we are failing ungracefully. Run the interrupt handlers
   // to make sure any special cleanups get done, in particular that we remove
   // files registered with RemoveFileOnSignal.
-  sys::RunInterruptHandlers(IsUsageError);
+  sys::RunInterruptHandlers(GenCrashDiag);
 
   if (GenCrashDiag)
     abort();
@@ -130,27 +127,27 @@ void llvm::report_fatal_error(const Twine &Reason, bool GenCrashDiag,
 }
 
 void llvm::reportFatalInternalError(const char *reason) {
-  report_fatal_error(reason, /*gen_crash_diag=*/true, /*is_usage_error=*/false);
+  report_fatal_error(reason, /*gen_crash_diag=*/true);
 }
 
 void llvm::reportFatalInternalError(StringRef reason) {
-  report_fatal_error(reason, /*gen_crash_diag=*/true, /*is_usage_error=*/false);
+  report_fatal_error(reason, /*gen_crash_diag=*/true);
 }
 
 void llvm::reportFatalInternalError(const Twine &reason) {
-  report_fatal_error(reason, /*gen_crash_diag=*/true, /*is_usage_error=*/false);
+  report_fatal_error(reason, /*gen_crash_diag=*/true);
 }
 
 void llvm::reportFatalUsageError(const char *reason) {
-  report_fatal_error(reason, /*gen_crash_diag=*/false, /*is_usage_error=*/true);
+  report_fatal_error(reason, /*gen_crash_diag=*/false);
 }
 
 void llvm::reportFatalUsageError(StringRef reason) {
-  report_fatal_error(reason, /*gen_crash_diag=*/false, /*is_usage_error=*/true);
+  report_fatal_error(reason, /*gen_crash_diag=*/false);
 }
 
 void llvm::reportFatalUsageError(const Twine &reason) {
-  report_fatal_error(reason, /*gen_crash_diag=*/false, /*is_usage_error=*/true);
+  report_fatal_error(reason, /*gen_crash_diag=*/false);
 }
 
 void llvm::install_bad_alloc_error_handler(fatal_error_handler_t handler,
diff --git a/llvm/lib/Support/PrettyStackTrace.cpp b/llvm/lib/Support/PrettyStackTrace.cpp
@@ -150,8 +150,8 @@ alignas(CrashHandlerString) static CrashHandlerStringStorage
 
 /// This callback is run if a fatal signal is delivered to the process, it
 /// prints the pretty stack trace.
-static void CrashHandler(void *, bool IsUsageError) {
-  if (IsUsageError)
+static void CrashHandler(void *, bool GenCrashDiag) {
+  if (!GenCrashDiag)
     return;
 
   errs() << BugReportMsg ;
diff --git a/llvm/lib/Support/Signals.cpp b/llvm/lib/Support/Signals.cpp
@@ -95,13 +95,13 @@ CallBacksToRun() {
 }
 
 // Signal-safe.
-void sys::RunSignalHandlers(bool IsUsageError) {
+void sys::RunSignalHandlers(bool GenCrashDiag) {
   for (CallbackAndCookie &RunMe : CallBacksToRun()) {
     auto Expected = CallbackAndCookie::Status::Initialized;
     auto Desired = CallbackAndCookie::Status::Executing;
     if (!RunMe.Flag.compare_exchange_strong(Expected, Desired))
       continue;
-    (*RunMe.Callback)(RunMe.Cookie, IsUsageError);
+    (*RunMe.Callback)(RunMe.Cookie, GenCrashDiag);
     RunMe.Callback = nullptr;
     RunMe.Cookie = nullptr;
     RunMe.Flag.store(CallbackAndCookie::Status::Empty);
diff --git a/llvm/lib/Support/Windows/Signals.inc b/llvm/lib/Support/Windows/Signals.inc
@@ -611,7 +611,7 @@ void llvm::sys::AddSignalHandler(sys::SignalHandlerCallback FnPtr,
   LeaveCriticalSection(&CriticalSection);
 }
 
-static void Cleanup(bool ExecuteSignalHandlers, bool IsUsageError) {
+static void Cleanup(bool ExecuteSignalHandlers, bool GenCrashDiag) {
   if (CleanupExecuted)
     return;
 
@@ -629,18 +629,18 @@ static void Cleanup(bool ExecuteSignalHandlers, bool IsUsageError) {
     }
 
   if (ExecuteSignalHandlers)
-    llvm::sys::RunSignalHandlers(IsUsageError);
+    llvm::sys::RunSignalHandlers(GenCrashDiag);
 
   LeaveCriticalSection(&CriticalSection);
 }
 
-void llvm::sys::RunInterruptHandlers(bool IsUsageError) {
+void llvm::sys::RunInterruptHandlers(bool GenCrashDiag) {
   // The interrupt handler may be called from an interrupt, but it may also be
   // called manually (such as the case of report_fatal_error with no registered
   // error handler). We must ensure that the critical section is properly
   // initialized.
   InitializeThreading();
-  Cleanup(true, IsUsageError);
+  Cleanup(true, GenCrashDiag);
 }
 
 /// Find the Windows Registry Key for a given location.
@@ -847,7 +847,7 @@ void sys::CleanupOnSignal(uintptr_t Context) {
 }
 
 static LONG WINAPI LLVMUnhandledExceptionFilter(LPEXCEPTION_POINTERS ep) {
-  Cleanup(/*ExecuteSignalHandlers=*/true, /*IsUsageError=*/false);
+  Cleanup(/*ExecuteSignalHandlers=*/true, /*GenCrashDiag=*/false);
 
   // Write out the exception code.
   if (ep && ep->ExceptionRecord)
@@ -887,7 +887,7 @@ static BOOL WINAPI LLVMConsoleCtrlHandler(DWORD dwCtrlType) {
   // This function is only ever called when a CTRL-C or similar control signal
   // is fired. Killing a process in this way is normal, so don't trigger the
   // signal handlers.
-  Cleanup(/*ExecuteSignalHandlers=*/false, /*IsUsageError=*/false);
+  Cleanup(/*ExecuteSignalHandlers=*/false, /*GenCrashDiag=*/false);
 
   // If an interrupt function has been set, go and run one it; otherwise,
   // the process dies.
diff --git a/llvm/lib/TableGen/Error.cpp b/llvm/lib/TableGen/Error.cpp
@@ -43,7 +43,7 @@ static void PrintMessage(ArrayRef<SMLoc> Loc, SourceMgr::DiagKind Kind,
 // Run file cleanup handlers and then exit fatally (with non-zero exit code).
 [[noreturn]] inline static void fatal_exit() {
   // The following call runs the file cleanup handlers.
-  sys::RunInterruptHandlers(/*IsUsageError=*/false);
+  sys::RunInterruptHandlers(/*GenCrashDiag=*/false);
   std::exit(1);
 }
 

Original file line number	Diff line number	Diff line change
`@@ -148,7 +148,7 @@ void llvm::initDebugOptions() {`
`148`	`148`	`}`
`149`	`149`
`150`	`150`	`// Signal handlers - dump debug output on termination.`
`151`		`-static void debug_user_sig_handler(void Cookie, bool /IsUsageError*/) {`
	`151`	`+static void debug_user_sig_handler(void Cookie, bool /GenCrashDiag*/) {`
`152`	`152`	`// This is a bit sneaky. Since this is under #ifndef NDEBUG, we`
`153`	`153`	`// know that debug mode is enabled and dbgs() really is a`
`154`	`154`	`// circular_raw_ostream. If NDEBUG is defined, then dbgs() ==`
Original file line number	Diff line number	Diff line change
`@@ -164,24 +164,22 @@ Error createStringError(std::string &&Msg, std::error_code EC) {`
`164`	`164`	`return make_error<StringError>(Msg, EC);`
`165`	`165`	`}`
`166`	`166`
`167`		`-void report_fatal_error(Error Err, bool GenCrashDiag, bool IsUsageError) {`
	`167`	`+void report_fatal_error(Error Err, bool GenCrashDiag) {`
`168`	`168`	`assert(Err && "report_fatal_error called with success value");`
`169`	`169`	`std::string ErrMsg;`
`170`	`170`	`{`
`171`	`171`	`raw_string_ostream ErrStream(ErrMsg);`
`172`	`172`	`logAllUnhandledErrors(std::move(Err), ErrStream);`
`173`	`173`	`}`
`174`		`- report_fatal_error(Twine(ErrMsg), GenCrashDiag, IsUsageError);`
	`174`	`+ report_fatal_error(Twine(ErrMsg), GenCrashDiag);`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`void reportFatalInternalError(Error Err) {`
`178`		`- report_fatal_error(std::move(Err), /GenCrashDiag=/true,`
`179`		`- /IsUsageError=/false);`
	`178`	`+ report_fatal_error(std::move(Err), /GenCrashDiag=/true);`
`180`	`179`	`}`
`181`	`180`
`182`	`181`	`void reportFatalUsageError(Error Err) {`
`183`		`- report_fatal_error(std::move(Err), /GenCrashDiag=/false,`
`184`		`- /IsUsageError=/true);`
	`182`	`+ report_fatal_error(std::move(Err), /GenCrashDiag=/false);`
`185`	`183`	`}`
`186`	`184`
`187`	`185`	`} // end namespace llvm`
Original file line number	Diff line number	Diff line change
`@@ -80,18 +80,15 @@ void llvm::remove_fatal_error_handler() {`
`80`	`80`	`ErrorHandlerUserData = nullptr;`
`81`	`81`	`}`
`82`	`82`
`83`		`-void llvm::report_fatal_error(const char *Reason, bool GenCrashDiag,`
`84`		`- bool IsUsageError) {`
`85`		`- report_fatal_error(Twine(Reason), GenCrashDiag, IsUsageError);`
	`83`	`+void llvm::report_fatal_error(const char *Reason, bool GenCrashDiag) {`
	`84`	`+ report_fatal_error(Twine(Reason), GenCrashDiag);`
`86`	`85`	`}`
`87`	`86`
`88`		`-void llvm::report_fatal_error(StringRef Reason, bool GenCrashDiag,`
`89`		`- bool IsUsageError) {`
`90`		`- report_fatal_error(Twine(Reason), GenCrashDiag, IsUsageError);`
	`87`	`+void llvm::report_fatal_error(StringRef Reason, bool GenCrashDiag) {`
	`88`	`+ report_fatal_error(Twine(Reason), GenCrashDiag);`
`91`	`89`	`}`
`92`	`90`
`93`		`-void llvm::report_fatal_error(const Twine &Reason, bool GenCrashDiag,`
`94`		`- bool IsUsageError) {`
	`91`	`+void llvm::report_fatal_error(const Twine &Reason, bool GenCrashDiag) {`
`95`	`92`	`llvm::fatal_error_handler_t handler = nullptr;`
`96`	`93`	`void* handlerData = nullptr;`
`97`	`94`	`{`
`@@ -121,7 +118,7 @@ void llvm::report_fatal_error(const Twine &Reason, bool GenCrashDiag,`
`121`	`118`	`// If we reached here, we are failing ungracefully. Run the interrupt handlers`
`122`	`119`	`// to make sure any special cleanups get done, in particular that we remove`
`123`	`120`	`// files registered with RemoveFileOnSignal.`
`124`		`- sys::RunInterruptHandlers(IsUsageError);`
	`121`	`+ sys::RunInterruptHandlers(GenCrashDiag);`
`125`	`122`
`126`	`123`	`if (GenCrashDiag)`
`127`	`124`	`abort();`
`@@ -130,27 +127,27 @@ void llvm::report_fatal_error(const Twine &Reason, bool GenCrashDiag,`
`130`	`127`	`}`
`131`	`128`
`132`	`129`	`void llvm::reportFatalInternalError(const char *reason) {`
`133`		`- report_fatal_error(reason, /gen_crash_diag=/true, /is_usage_error=/false);`
	`130`	`+ report_fatal_error(reason, /gen_crash_diag=/true);`
`134`	`131`	`}`
`135`	`132`
`136`	`133`	`void llvm::reportFatalInternalError(StringRef reason) {`
`137`		`- report_fatal_error(reason, /gen_crash_diag=/true, /is_usage_error=/false);`
	`134`	`+ report_fatal_error(reason, /gen_crash_diag=/true);`
`138`	`135`	`}`
`139`	`136`
`140`	`137`	`void llvm::reportFatalInternalError(const Twine &reason) {`
`141`		`- report_fatal_error(reason, /gen_crash_diag=/true, /is_usage_error=/false);`
	`138`	`+ report_fatal_error(reason, /gen_crash_diag=/true);`
`142`	`139`	`}`
`143`	`140`
`144`	`141`	`void llvm::reportFatalUsageError(const char *reason) {`
`145`		`- report_fatal_error(reason, /gen_crash_diag=/false, /is_usage_error=/true);`
	`142`	`+ report_fatal_error(reason, /gen_crash_diag=/false);`
`146`	`143`	`}`
`147`	`144`
`148`	`145`	`void llvm::reportFatalUsageError(StringRef reason) {`
`149`		`- report_fatal_error(reason, /gen_crash_diag=/false, /is_usage_error=/true);`
	`146`	`+ report_fatal_error(reason, /gen_crash_diag=/false);`
`150`	`147`	`}`
`151`	`148`
`152`	`149`	`void llvm::reportFatalUsageError(const Twine &reason) {`
`153`		`- report_fatal_error(reason, /gen_crash_diag=/false, /is_usage_error=/true);`
	`150`	`+ report_fatal_error(reason, /gen_crash_diag=/false);`
`154`	`151`	`}`
`155`	`152`
`156`	`153`	`void llvm::install_bad_alloc_error_handler(fatal_error_handler_t handler,`