[Reproducers] Add --reproducer-no-generate-on-signal to avoid installing the signal handler.

[JDevlieghere]

Summary

There are bugs where you don't want the signal handler to trigger, most notably when that will cause another crash. Examples of this are lldb running out of memory or a bug in the reproducer generation code. This adds an escape hatch trough a (developer oriented) flag to not install the signal handler.

rdar://problem/65149595

[JDevlieghere]

Detach flag name from implementation.

[teemperor]

LGTM, thanks!

lldb/test/Shell/Reproducer/TestCrash.test

 # This tests that a reproducer is generated when LLDB crashes.
 
 # Start clean.
 # RUN: rm -rf %t.repro
 
 # RUN: %lldb -b --capture --capture-path %t.repro -o 'reproducer xcrash -s SIGSEGV' | FileCheck %s
 # RUN: %lldb -b --capture --capture-path %t.repro -o 'reproducer xcrash -s SIGILL' | FileCheck %s
 
 # CHECK: ********************
 # CHECK: Crash reproducer for
 # CHECK: Reproducer written to
 # CHECK: ********************
+
+# RUN: %lldb -b --capture --capture-path %t.repro --reproducer-no-generate-on-signal -o 'reproducer xcrash -s SIGSEGV' | FileCheck %s --check-prefix NOHANDLER
+
+# NOHANDLER-NOT: Crash reproducer
+# NOHANDLER-NOT: Reproducer written

lldb/tools/driver/Driver.cpp

in the order provided on the command line.
     lldb -S /source/before/file -s /source/after/file
     lldb -K /source/before/crash -k /source/after/crash
 
   Note: In REPL mode no file is loaded, so commands specified to run after
   loading the file (via -o or -s) will be ignored.)___";
   llvm::outs() << examples << '\n';
 }
 
-llvm::Optional<int> InitializeReproducer(opt::InputArgList &input_args) {
+llvm::Optional<int> InitializeReproducer(llvm::StringRef argv0,
+                                         opt::InputArgList &input_args) {
   if (auto *replay_path = input_args.getLastArg(OPT_replay)) {
     const bool no_version_check = input_args.hasArg(OPT_no_version_check);
     if (const char *error =
             SBReproducer::Replay(replay_path->getValue(), no_version_check)) {
       WithColor::error() << "reproducer replay failed: " << error << '\n';
       return 1;
     }
     return 0;
   }
 
   bool capture = input_args.hasArg(OPT_capture);
   bool generate_on_exit = input_args.hasArg(OPT_generate_on_exit);
   auto *capture_path = input_args.getLastArg(OPT_capture_path);
 
   if (generate_on_exit && !capture) {
     WithColor::warning()
         << "-reproducer-generate-on-exit specified without -capture\n";
   }
 
   if (capture || capture_path) {
+    // Register the reproducer signal handler.
+    if (!input_args.hasArg(OPT_no_generate_on_signal)) {
+      llvm::sys::AddSignalHandler(reproducer_handler,
+                                  const_cast<char *>(argv0.data()));
+    }
+
     if (capture_path) {
       if (!capture)
         WithColor::warning() << "-capture-path specified without -capture\n";
       if (const char *error = SBReproducer::Capture(capture_path->getValue())) {
         WithColor::error() << "reproducer capture failed: " << error << '\n';
         return 1;
       }
     } else {
if (input_args.hasArg(OPT_UNKNOWN)) {
     for (auto *arg : input_args.filtered(OPT_UNKNOWN)) {
       WithColor::error() << "unknown option: " << arg->getSpelling() << '\n';
     }
     llvm::errs() << "Use '" << argv0
                  << " --help' for a complete list of options.\n";
     return 1;
   }
 
-  if (auto exit_code = InitializeReproducer(input_args)) {
+  if (auto exit_code = InitializeReproducer(argv[0], input_args)) {
     return *exit_code;
   }
 
-  // Register the reproducer signal handler.
-  llvm::sys::AddSignalHandler(reproducer_handler, const_cast<char *>(argv[0]));
-
   SBError error = SBDebugger::InitializeWithErrorHandling();
   if (error.Fail()) {
     WithColor::error() << "initialization failed: " << error.GetCString()
                        << '\n';
     return 1;
   }
   SBHostOS::ThreadCreated("<lldb.driver.main-thread>");
 

lldb/tools/driver/Options.td

 def capture_path: Separate<["--", "-"], "capture-path">,
   MetaVarName<"<filename>">,
   HelpText<"Tells the debugger to use the given filename for the reproducer.">;
 def replay: Separate<["--", "-"], "replay">,
   MetaVarName<"<filename>">,
   HelpText<"Tells the debugger to replay a reproducer from <filename>.">;
 def no_version_check: F<"reproducer-no-version-check">,
   HelpText<"Disable the reproducer version check.">;
+def no_generate_on_signal: F<"reproducer-no-generate-on-signal">,
+  HelpText<"Don't generate reproducer when a signal is received.">;
 def generate_on_exit: F<"reproducer-generate-on-exit">,
   HelpText<"Generate reproducer on exit.">;
 
 def REM : R<["--"], "">;