[Dexter] Add target_run_args option

[StephenTozer]

Summary

Adds an option to Dexter that passes command line arguments to the debugged process, following (and in addition to) any arguments given by the DexCommandLine command.

[Orlando]

LGTM with test suggestion inline

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/target_run_args.c

6

Please can we have a DexCommandLine command in here too to test that the features compose?

[StephenTozer]

Added a test to check that --target-run-args and DexCommandLine compose - needs to be a separate test file because of a few necessary differences in the file, which can't be fixed by using sed in the RUN line.

[Orlando]

New test LGTM, thanks

cross-project-tests/debuginfo-tests/dexter/dex/debugger/Debuggers.py

parser.add_argument(
         metavar='<directory>',
         default=None,
         help='source root directory')
     parser.add_argument(
         '--debugger-use-relative-paths',
         action='store_true',
         default=False,
         help='pass the debugger paths relative to --source-root-dir')
+    parser.add_argument(
+        '--target-run-args',
+        type=str,
+        metavar='<flags>',
+        default='',
+        help='command line arguments for the test program, in addition to any '
+             'provided by DexCommandLine')
+
 
 def handle_debugger_tool_base_options(context, defaults):  # noqa
     options = context.options
 
     if options.lldb_executable is None:
         options.lldb_executable = defaults.lldb_executable
     else:
         if getattr(options, 'debugger', 'lldb') != 'lldb':

cross-project-tests/debuginfo-tests/dexter/dex/debugger/dbgeng/dbgeng.py

def get_triggered_breakpoint_ids(self):
       raise NotImplementedError('get_triggered_breakpoint_ids is not yet implemented by dbgeng')
 
     def delete_breakpoints(self, ids):
         # breakpoint setting/deleting is not supported by dbgeng at this moment
         # but is something that should be considered in the future.
         raise NotImplementedError('delete_conditional_breakpoint is not yet implemented by dbgeng')
 
     def launch(self, cmdline):
-        assert len(cmdline) == 0, "Command lines unimplemented for dbgeng right now"
+        assert len(cmdline) == 0 and not self.context.options.target_run_args, "Command lines unimplemented for dbgeng right now"
         # We are, by this point, already launched.
         self.step_info = probe_process.probe_state(self.client)
 
     def step(self):
         res = setup.step_once(self.client)
         if not res:
           self.finished = True
         self.step_info = res

cross-project-tests/debuginfo-tests/dexter/dex/debugger/lldb/LLDB.py

 # DExTer : Debugging Experience Tester
 # ~~~~~~   ~         ~~         ~   ~~
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 """Interface for communicating with the LLDB debugger via its python interface.
 """
 
 import imp
 import os
+import shlex
 from subprocess import CalledProcessError, check_output, STDOUT
 import sys
 
 from dex.debugger.DebuggerBase import DebuggerBase, watch_is_active
 from dex.dextIR import FrameIR, LocIR, StepIR, StopReason, ValueIR
 from dex.dextIR import StackFrame, SourceLocation, ProgramState
 from dex.utils.Exceptions import DebuggerException, LoadDebuggerException
 from dex.utils.ReturnCode import ReturnCode
def delete_breakpoints(self, ids):
             try:
                 del self._breakpoint_conditions[id]
             except KeyError:
                 # This must be an unconditional breakpoint.
                 pass
             self._target.BreakpointDelete(id)
 
     def launch(self, cmdline):
+        if self.context.options.target_run_args:
+          cmdline += shlex.split(self.context.options.target_run_args)
         self._process = self._target.LaunchSimple(cmdline, None, os.getcwd())
         if not self._process or self._process.GetNumThreads() == 0:
             raise DebuggerException('could not launch process')
         if self._process.GetNumThreads() != 1:
             raise DebuggerException('multiple threads not supported')
         self._thread = self._process.GetThreadAtIndex(0)
         assert self._thread, (self._process, self._thread)
 

cross-project-tests/debuginfo-tests/dexter/dex/debugger/visualstudio/VisualStudio.py

def _fetch_property(self, props, name):
         for x in range(1, num_props+1):
             item = props.Item(x)
             if item.Name == name:
                 return item
         assert False, "Couldn't find property {}".format(name)
 
     def launch(self, cmdline):
         cmdline_str = ' '.join(cmdline)
+        if self.context.options.target_run_args:
+          cmdline_str += f" {self.context.options.target_run_args}"
 
         # In a slightly baroque manner, lookup the VS project that runs when
         # you click "run", and set its command line options to the desired
         # command line options.
         startup_proj_name = str(self._fetch_property(self._interface.Solution.Properties, 'StartupProject'))
         project = self._fetch_property(self._interface.Solution, startup_proj_name)
         ActiveConfiguration = self._fetch_property(project.Properties, 'ActiveConfiguration').Object
         ActiveConfiguration.DebugSettings.CommandArguments = cmdline_str

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/target_run_args.c

+// The dbgeng driver doesn't support --target-run-args yet.
+// UNSUPPORTED: system-windows
+//
+// RUN: %dexter_regression_test --target-run-args "a b 'c d'" -- %s | FileCheck %s
+// CHECK: target_run_args.c:
+
+int main(int argc, const char **argv) {
+  if (argc == 4)
+    return 0; // DexLabel('retline')
+
+  return 1; // DexUnreachable()
+}
+
+// DexExpectWatchValue('argc', '4', on_line=ref('retline'))