[lit][libcxx] Add a --run-with-debugger/--gdb flag

[arichardson]

Summary

This flag can be used to run libc++/libunwind/libc++abi tests under GDB to
make it easier to debug test failures. We use this approach in our CHERI
Jenkins setup to ensure that crashing test cases include a backtrace in
the Jenkins JUnit test result viewer.
This uses the --wrapper-command executor flag added in D88899.

[arichardson]

needs rebasing.

libcxx/utils/libcxx/test/config.py

def configure_substitutions(self):
         sub.append(('%{link_libcxxabi}', pipes.quote(self.cxx.link_libcxxabi_flag)))
         codesign_ident = self.get_lit_conf('llvm_codesign_identity', '')
         env_vars = ' '.join('%s=%s' % (k, pipes.quote(v)) for (k, v) in self.exec_env.items())
         exec_args = [
             '--execdir %T',
             '--codesign_identity "{}"'.format(codesign_ident),
             '--env {}'.format(env_vars)
         ]
+        # The exec_nowrapper substitution is used for configuration checks.
+        sub.append(('%{exec_nowrapper}', '{} {} -- '.format(self.executor, ' '.join(exec_args))))
+        if self.lit_config.run_with_debugger:
+            exec_args.append("--wrapper-command")
+            exec_args.append(pipes.quote(' '.join(map(pipes.quote, self.lit_config.debugger_args))))
         sub.append(('%{exec}', '{} {} -- '.format(self.executor, ' '.join(exec_args))))
         if self.get_lit_conf('libcxx_gdb'):
             sub.append(('%{libcxx_gdb}', self.get_lit_conf('libcxx_gdb')))
 
     def configure_triple(self):
         # Get or infer the target triple.
         target_triple = self.get_lit_conf('target_triple')
 

libcxx/utils/libcxx/test/dsl.py

with open(test.getSourcePath(), 'w') as source:
       source.write(program)
     try:
       _, _, exitCode, _ = _executeScriptInternal(test, [
         "%{cxx} %s %{flags} %{compile_flags} %{link_flags} -o %t.exe",
       ])
       if exitCode != 0:
         return None
 
+      # Note: We use exec_nowrapper here to avoid running the configuration
+      # tests under GDB/valgrind/etc.
       out, err, exitCode, _ = _executeScriptInternal(test, [
-        "%{{exec}} %t.exe {}".format(' '.join(args))
+        "%{{exec_nowrapper}} %t.exe {}".format(' '.join(args))
       ])
       if exitCode != 0:
         return None
 
       actualOut = re.search("command output:\n(.+)\n$", out, flags=re.DOTALL)
       actualOut = actualOut.group(1) if actualOut else ""
       return actualOut
 

llvm/utils/lit/lit/LitConfig.py

 from __future__ import absolute_import
+
 import inspect
 import os
-import platform
 import sys
 
 import lit.Test
-import lit.formats
 import lit.TestingConfig
+import lit.formats
 import lit.util
 
+
 # LitConfig must be a new style class for properties to work
 class LitConfig(object):
     """LitConfig - Configuration data for a 'lit' test runner instance, shared
     across all tests.
 
     The LitConfig object is also used to communicate with client configuration
     files, it is always passed in as the global variable 'lit' so that
     configuration files can access common functionality and internal components
     easily.
     """
 
     def __init__(self, progname, path, quiet,
                  useValgrind, valgrindLeakCheck, valgrindArgs,
                  noExecute, debug, isWindows,
                  params, config_prefix = None,
                  maxIndividualTestTime = 0,
                  parallelism_groups = {},
+                 run_with_debugger = None,
                  echo_all_commands = False):
         # The name of the test runner.
         self.progname = progname
         # The items to add to the PATH environment variable.
         self.path = [str(p) for p in path]
         self.quiet = bool(quiet)
         self.useValgrind = bool(useValgrind)
         self.valgrindLeakCheck = bool(valgrindLeakCheck)
def __init__(self, progname, path, quiet,
                                  '--error-exitcode=123']
             if self.valgrindLeakCheck:
                 self.valgrindArgs.append('--leak-check=full')
             else:
                 # The default is 'summary'.
                 self.valgrindArgs.append('--leak-check=no')
             self.valgrindArgs.extend(self.valgrindUserArgs)
 
+        self.run_with_debugger = run_with_debugger is not None
+        self.debugger_args = []
+        if self.run_with_debugger:
+            if run_with_debugger == 'gdb':
+                # We use "thread apply all bt" instead of "bt" to ensure that a
+                # successful exit doesn't cause GDB to return a non-zero exit code
+                # due the program no longer existing when "bt" is executed.
+                self.debugger_args = ["gdb", "--quiet", "--batch", "--return-child-result",
+                                      "-ex=r", "-ex=thread apply all bt", "--args"]
+            else:
+                raise ValueError("Unsupported debugger: " + run_with_debugger)
         self.maxIndividualTestTime = maxIndividualTestTime
         self.parallelism_groups = parallelism_groups
         self.echo_all_commands = echo_all_commands
 
     @property
     def maxIndividualTestTime(self):
         """
             Interface for getting maximum time to spend executing

llvm/utils/lit/lit/cl_arguments.py

debug_group.add_argument("--show-suites",
             help="Show discovered test suites and exit",
             action="store_true")
     debug_group.add_argument("--show-tests",
             help="Show all discovered tests and exit",
             action="store_true")
     debug_group.add_argument("--show-used-features",
             help="Show all features used in the test suite (in XFAIL, UNSUPPORTED and REQUIRES) and exit",
             action="store_true")
+    # TODO: Also support lldb
+    debug_group.add_argument("--run-with-debugger",
+             help="Run tests with gdb and print a backtrace on crash. "
+                  "This is currently only supported for libc++/libunwind.",
+             choices=("gdb", ))
+    debug_group.add_argument("--gdb",
+             dest="run_with_debugger",
+             help="This is an alias for --run-with-debugger=gdb.",
+             action="store_const", const="gdb")
 
     # LIT is special: environment variables override command line arguments.
     env_args = shlex.split(os.environ.get("LIT_OPTS", ""))
     args = sys.argv[1:] + env_args
     opts = parser.parse_args(args)
 
     # Validate command line options
     if opts.echoAllCommands:

llvm/utils/lit/lit/main.py

lit_config = lit.LitConfig.LitConfig(
         useValgrind=opts.useValgrind,
         valgrindLeakCheck=opts.valgrindLeakCheck,
         valgrindArgs=opts.valgrindArgs,
         noExecute=opts.noExecute,
         debug=opts.debug,
         isWindows=is_windows,
         params=params,
         config_prefix=opts.configPrefix,
+        run_with_debugger=opts.run_with_debugger,
         echo_all_commands=opts.echoAllCommands)
 
     discovered_tests = lit.discovery.find_tests_for_inputs(lit_config, opts.test_paths)
     if not discovered_tests:
         sys.stderr.write('error: did not discover any tests for provided path(s)\n')
         sys.exit(2)
 
     if opts.show_suites or opts.show_tests: