[Reproducers] Support capturing a reproducer without an explicit path.

[JDevlieghere]

Summary

Tablegen doesn't support options that serve both as flags and as arguments taking a value. I noticed this when doing the tablegen rewrite, but forgot that that affected my reproducer flags. This patch adds another flag, namely --capture-path that allows the user to explicitly specify a path for the reproducer. In reality I expect this to be mostly used for testing, but it could be useful regardless.

include/lldb/API/SBReproducer.h

 
 namespace lldb {
 
 /// The SBReproducer class is special because it bootstraps the capture and
 /// replay of SB API calls. As a result we cannot rely on any other SB objects
 /// in the interface or implementation of this class.
 class LLDB_API SBReproducer {
 public:
+  static const char *Capture();
   static const char *Capture(const char *path);
   static const char *Replay(const char *path);
 };
 
 } // namespace lldb
 
 #endif

lit/Reproducer/Functionalities/TestDataFormatter.test

 # UNSUPPORTED: system-windows, system-freebsd
 
 # This tests that data formatters continue to work when replaying a reproducer.
 
 # RUN: rm -rf %t.repro
 # RUN: %clangxx %S/Inputs/foo.cpp -g -o %t.out
 
-# RUN: %lldb -x -b -s %S/Inputs/DataFormatter.in --capture %t.repro %t.out | FileCheck %s
+# RUN: %lldb -x -b -s %S/Inputs/DataFormatter.in --capture --capture-path %t.repro %t.out | FileCheck %s
 # RUN: %lldb --replay %t.repro | FileCheck %s
 
 # CHECK: stop reason = breakpoint 1.1
 # CHECK: (Foo) foo = (m_i = 0, m_d = 0)
 # CHECK: stop reason = step over
 # CHECK: (Foo) foo = (m_i = 1, m_d = 2)
 # CHECK: Process {{.*}} resuming
 # CHECK: Process {{.*}} exited with status = 0

lit/Reproducer/Functionalities/TestImageList.test

 # UNSUPPORTED: system-windows, system-freebsd
 
 # This tests that image list works when replaying. We arbitrarily assume
 # there's at least two entries and compare that they're identical.
 
 # RUN: %clang %S/Inputs/stepping.c -g -o %t.out
 
 # RUN: rm -rf %t.txt
 
 # RUN: echo "CAPTURE" >> %t.txt
-# RUN: %lldb -x -b  --capture %t.repro \
+# RUN: %lldb -x -b  --capture --capture-path %t.repro \
 # RUN:    -o 'run' \
 # RUN:    -o 'image list' \
 # RUN:    -o 'reproducer generate' \
 # RUN:    %t.out >> %t.txt 2>&1
 
 # RUN: echo "REPLAY" >> %t.txt
 # RUN: %lldb -x -b --replay %t.repro >> %t.txt 2>&1
 

lit/Reproducer/Functionalities/TestStepping.test

 # UNSUPPORTED: system-windows, system-freebsd
 
 # This tests that stepping continues to work when replaying a reproducer.
 
+# RUN: rm -rf %t.repro
 # RUN: %clang %S/Inputs/stepping.c -O0 -g -o %t.out
 # RUN: grep -v '#' %s > %t.in
 
-# RUN: %lldb -x -b -s %t.in --capture %t.repro %t.out | FileCheck %s --check-prefix CHECK
+# RUN: %lldb -x -b -s %t.in --capture --capture-path %t.repro %t.out | FileCheck %s --check-prefix CHECK
 # RUN: %lldb --replay %t.repro | FileCheck %s --check-prefix CHECK
 
 # Set breakpoints in a,b and c and verify we stop there when stepping.
 
 breakpoint set -f stepping.c -l 28
 # CHECK: Breakpoint 1: {{.*}} stepping.c:28
 
 breakpoint set -f stepping.c -l 10

lit/Reproducer/Modules/TestModuleCXX.test

 # REQUIRES: system-darwin
 
 # Start fresh.
+# RUN: rm -rf %t.repro
 # RUN: rm -rf %t.root
 # RUN: rm -rf %t.clang-cache
 # RUN: rm -rf %t.lldb-cache
 
 # Create a temporary root we can remove later.
 # RUN: mkdir -p %t.root
 # RUN: mkdir -p %t.clang-cache
 # RUN: mkdir -p %t.lldb-cache
 # RUN: cp %S/Inputs/main.cpp %t.root
 # RUN: cp %S/Inputs/Foo.h %t.root
 # RUN: cp %S/Inputs/Bar.h %t.root
 # RUN: cp %S/Inputs/module.modulemap %t.root
 
 # Compile the test case form the temporary root.
 # RUN: %clang %t.root/main.cpp -g -fmodules -fcxx-modules -fmodules-cache-path=%t.clang-cache -o %t.root/a.out
 
 # Capture the debug session.
-# RUN: %lldb -x -b -o 'settings set symbols.clang-modules-cache-path %t.lldb-cache' -s %S/Inputs/ModuleCXX.in --capture %t.repro %t.root/a.out | FileCheck %s --check-prefix CAPTURE
+# RUN: %lldb -x -b -o 'settings set symbols.clang-modules-cache-path %t.lldb-cache' -s %S/Inputs/ModuleCXX.in --capture --capture-path %t.repro %t.root/a.out | FileCheck %s --check-prefix CAPTURE
 # CAPTURE: (success = 0)
 
 # RUN: cat %t.repro/files.yaml | FileCheck %s --check-prefix YAML
 # YAML-DAG: Foo.h
 # YAML-DAG: Bar.h
 # YAML-DAG: module.modulemap
 
 # Remove the temporary root.
 # RUN: rm -rf %t.root
 # RUN: rm -rf %t.clang-cache
 # RUN: rm -rf %t.lldb-cache
 
 # Replay the debug session.
 # RUN: %lldb -x -b -o 'settings set symbols.clang-modules-cache-path %t.lldb-cache' -s %S/Inputs/ModuleCXX.in --replay %t.repro %t.root/a.out | FileCheck %s --check-prefix REPLAY
 # REPLAY: (success = 0)

lit/Reproducer/TestDriverOptions.test

 # Check that errors are propagated to the driver.
+#
+# RUN: not %lldb --capture --capture-path %t/bogus/bogus 2>&1 | FileCheck %s --check-prefix INVALID-CAPTURE
+# RUN: not %lldb --replay %t/bogus/bogus  2>&1 | FileCheck %s --check-prefix INVALID-REPLAY
+#
+# INVALID-CAPTURE: unable to create reproducer directory
+# INVALID-REPLAY: unable to load reproducer index
 
-# RUN: not %lldb --capture %t/bogus/bogus 2>&1 | FileCheck %s --check-prefix CAPTURE
-# RUN: not %lldb --replay %t/bogus/bogus  2>&1 | FileCheck %s --check-prefix REPLAY
-
-# CAPTURE: unable to create reproducer directory
-# REPLAY: unable to load reproducer index
+# Check that all option combination work as expected.
+#
+# RUN: %lldb --capture --capture-path %t.repro -b -o 'reproducer status' 2>&1 | FileCheck %s --check-prefix NO-WARNING --check-prefix STATUS-CAPTURE
+# RUN: %lldb --capture -b -o 'reproducer status' 2>&1 | FileCheck %s --check-prefix NO-WARNING --check-prefix STATUS-CAPTURE
+# RUN: %lldb --capture-path %t.repro -b -o 'reproducer status' 2>&1 | FileCheck %s --check-prefix WARNING --check-prefix STATUS-CAPTURE
+#
+# NO-WARNING-NOT: warning: -capture-path specified without -capture
+# WARNING: warning: -capture-path specified without -capture
+# STATUS-CAPTURE: Reproducer is in capture mode.

lit/Reproducer/TestFileRepro.test

 # REQUIRES: system-darwin
 
 # This tests the replaying of GDB remote packets.
 #
 # We issue the same commands and ensure the output is identical to the original
 # process. To ensure we're not actually running the original binary we check
 # that the string "testing" is not printed.
 
+# RUN: rm -rf %t.repro
 # RUN: %clang %S/Inputs/simple.c -g -o %t.out
-# RUN: %lldb -x -b -s %S/Inputs/FileCapture.in --capture %t.repro %t.out | FileCheck %s --check-prefix CHECK --check-prefix CAPTURE
+# RUN: %lldb -x -b -s %S/Inputs/FileCapture.in --capture --capture-path %t.repro %t.out | FileCheck %s --check-prefix CHECK --check-prefix CAPTURE
 # RUN: rm %t.out
 # RUN: %lldb --replay %t.repro | FileCheck %s --check-prefix CHECK --check-prefix REPLAY
 
 # CAPTURE: testing
 # REPLAY-NOT: testing
 
 # CHECK: Process {{.*}} exited
 
 # CAPTURE: Reproducer is in capture mode.
 # CAPTURE: Reproducer written

lit/Reproducer/TestGDBRemoteRepro.test

 # UNSUPPORTED: system-windows, system-freebsd
 
 # This tests the replaying of GDB remote packets.
 #
 # We issue the same commands and ensure the output is identical to the original
 # process. To ensure we're not actually running the original binary we check
 # that the string "testing" is not printed.
 
+# RUN: rm -rf %t.repro
 # RUN: %clang %S/Inputs/simple.c -g -o %t.out
-# RUN: %lldb -x -b -s %S/Inputs/GDBRemoteCapture.in --capture %t.repro %t.out | FileCheck %s --check-prefix CHECK --check-prefix CAPTURE
+# RUN: %lldb -x -b -s %S/Inputs/GDBRemoteCapture.in --capture --capture-path %t.repro %t.out | FileCheck %s --check-prefix CHECK --check-prefix CAPTURE
 # RUN: %lldb --replay %t.repro | FileCheck %s --check-prefix CHECK --check-prefix REPLAY
 
 # CHECK: Breakpoint 1
 # CHECK: Process {{.*}} stopped
 # CHECK: Process {{.*}} launched
 # CHECK: thread {{.*}} stop reason = breakpoint
 # CHECK: frame {{.*}} simple.c
 
 # CAPTURE: testing
 # REPLAY-NOT: testing
 
 # CHECK: Process {{.*}} resuming
 # CHECK: Process {{.*}} exited
 
 # CAPTURE: Reproducer is in capture mode.
 # CAPTURE: Reproducer written

source/API/SBReproducer.cpp

LLDB_REGISTER_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
                                 GetWatchpointEventTypeFromEvent,
                                 (const lldb::SBEvent &));
     LLDB_REGISTER_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,
                                 GetWatchpointFromEvent,
                                 (const lldb::SBEvent &));
   }
 }
 
+const char *SBReproducer::Capture() {
+  static std::string error;
+  if (auto e = Reproducer::Initialize(ReproducerMode::Capture, llvm::None)) {
+    error = llvm::toString(std::move(e));
+    return error.c_str();
+  }
+  return nullptr;
+}
+
 const char *SBReproducer::Capture(const char *path) {
   static std::string error;
   if (auto e =
           Reproducer::Initialize(ReproducerMode::Capture, FileSpec(path))) {
     error = llvm::toString(std::move(e));
     return error.c_str();
   }
   return nullptr;

tools/driver/Driver.cpp

in the order provided on the command line.
 
     lldb -O 'settings set stop-disassembly-count 20' -o 'run' -o 'bt'
     lldb -S /source/before/file -s /source/after/file
     lldb -K /source/before/crash -k /source/after/crash
   )___";
   llvm::outs() << examples;
 }
 
+llvm::Optional<int> InitializeReproducer(opt::InputArgList &input_args) {
+  if (auto *replay_path = input_args.getLastArg(OPT_replay)) {
+    if (const char *error = SBReproducer::Replay(replay_path->getValue())) {
+      WithColor::error() << "reproducer replay failed: " << error << '\n';
+      return 1;
+    }
+    return 0;
+  }
+
+  bool capture = input_args.hasArg(OPT_capture);
+  auto *capture_path = input_args.getLastArg(OPT_capture_path);
+
+  if (capture || capture_path) {
+    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 {
+      const char *error = SBReproducer::Capture();
+      if (error) {
+        WithColor::error() << "reproducer capture failed: " << error << '\n';
+        return 1;
+      }
+    }
+  }
+
+  return llvm::None;
+}
+
 int
 #ifdef _MSC_VER
 wmain(int argc, wchar_t const *wargv[])
 #else
 main(int argc, char const *argv[])
 #endif
 {
 #ifdef _MSC_VER
if (input_args.hasArg(OPT_help)) {
     return 0;
   }
 
   for (auto *arg : input_args.filtered(OPT_UNKNOWN)) {
     WithColor::warning() << "ignoring unknown option: " << arg->getSpelling()
                          << '\n';
   }
 
-  if (auto *arg = input_args.getLastArg(OPT_capture)) {
-    auto arg_value = arg->getValue();
-    const char *error = SBReproducer::Capture(arg_value);
-    if (error) {
-      WithColor::error() << "reproducer capture failed: " << error << '\n';
-      return 1;
-    }
-  }
-
-  if (auto *arg = input_args.getLastArg(OPT_replay)) {
-    auto arg_value = arg->getValue();
-    const char *error = SBReproducer::Replay(arg_value);
-    if (error) {
-      WithColor::error() << "reproducer replay failed: " << error << '\n';
-      return 1;
-    }
-    return 0;
+  if (auto exit_code = InitializeReproducer(input_args)) {
+    return *exit_code;
   }
 
   SBError error = SBDebugger::InitializeWithErrorHandling();
   if (error.Fail()) {
     WithColor::error() << "initialization failed: " << error.GetCString()
                        << '\n';
     return 1;
   }

tools/driver/Options.td

def: Separate<["-"], "a">,
   HelpText<"Alias for --arch">;
 
 def debug: F<"debug">,
   HelpText<"Tells the debugger to print out extra information for debugging itself.">;
 def: Flag<["-"], "d">,
   Alias<debug>,
   HelpText<"Alias for --debug">;
 
-def capture: Separate<["--", "-"], "capture">,
+def capture: F<"capture">,
+  HelpText<"Tells the debugger to capture a reproducer.">;
+def capture_path: Separate<["--", "-"], "capture-path">,
   MetaVarName<"<filename>">,
-  HelpText<"Tells the debugger to capture a reproducer to <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 REM : R<["--"], "">;