[Dexter] Add option to pass a Visual Studio solution instead of a binary

[StephenTozer]

Summary

This patch allows a visual studio solution file to be passed directly into Dexter, instead of using a pre-built binary and a small internal solution file with template arguments. This is primarily to allow launching an application that has specific launch configuration requirements, without needing all the details of this configuration to be built directly into Dexter or adding a config file that simply duplicates existing settings in the VS solution.

[Orlando]

LGTM, just one inline question.

cross-project-tests/debuginfo-tests/dexter/dex/debugger/DebuggerControllers/DebuggerControllerBase.py

2–1

Is this (and the necessity for the new init_success attribute) a bug-fix?

[StephenTozer]

cross-project-tests/debuginfo-tests/dexter/dex/debugger/DebuggerControllers/DebuggerControllerBase.py

2–1

The current error handling approach seems somewhat unmaintained - it's hard to say whether this qualifies as a "bug fix" or just implementing error handling for the behaviour in this specific patch.

[Orlando]

cross-project-tests/debuginfo-tests/dexter/dex/debugger/DebuggerControllers/DebuggerControllerBase.py

2–1

What happens without this patch if the vs solution cannot be created (i.e. when _custom_init raises LoadDebuggerException)? I'm just trying to understand the impact of this part of the patch.

[StephenTozer]

The previous version of the patch made use of the existing _loading_error field in a way that was inconsistent with existing code; existing uses have been fixed up so that the field is used consistently.

In short summary, the field was assigned inconsistent value types - on initialization it is assigned an exception object directly, in all other assignments it is either None or the value of sys.exc_info(). This patch assigned an exception directly, consistent with the initial value, but it appears as though the initial assignment was never actually used (and would cause an error if it was). Also, while we would assign self._loading_error = sys.exc_info() when we encountered an error when initializing or entering the debugger, we only used the loading error during initialization, not afterwards (making the second assignment meaningless as well).

The fix for this is to set the value to None initially instead of a never-used exception object, and use the loading_error property consistently between initializing and entering the debugger.

[Orlando]

Do we need both _loading_error and init_success? I might be missing something but it looks like the property is_available (which uses _loading_error) currently covers the use case of init_success.

[StephenTozer]

In D110167#3050365, @Orlando wrote:

Do we need both _loading_error and init_success? I might be missing something but it looks like the property is_available (which uses _loading_error) currently covers the use case of init_success.

Probably not - it basically amounts to keeping state in the Debugger that records where we failed rather than just what the error was. With that said, I don't think we really use that at all right now, since error handling is just "Init -> Check for failure -> Setup -> Check for failure", so we could probably do fine without it.

[StephenTozer]

Remove init_success field.

[Orlando]

LGTM

cross-project-tests/debuginfo-tests/dexter/dex/builder/ParserOptions.py

build_group.add_argument('--binary',
                              metavar="<file>",
                              help='provide binary file instead of --builder')
 
     build_group.add_argument(
         '--builder',
         type=str,
         choices=sorted(_find_build_scripts().keys()),
         help='test builder to use')
+    build_group.add_argument('--vs-solution', metavar="<file>",
+        help='provide a path to an already existing visual studio solution.')
     parser.add_argument(
         '--cflags', type=str, default='', help='compiler flags')
     parser.add_argument('--ldflags', type=str, default='', help='linker flags')
 
 
 def handle_builder_tool_options(context: Context) -> str:
     return _find_build_scripts()[context.options.builder]

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

 import sys
 import traceback
 import unittest
 
 from types import SimpleNamespace
 from dex.command.CommandBase import StepExpectInfo
 from dex.dextIR import DebuggerIR, FrameIR, LocIR, StepIR, ValueIR
 from dex.utils.Exceptions import DebuggerException
-from dex.utils.Exceptions import NotYetLoadedDebuggerException
 from dex.utils.ReturnCode import ReturnCode
 
 def watch_is_active(watch_info: StepExpectInfo, path, frame_idx, line_no):
     _, watch_path, watch_frame_idx, watch_line_range = watch_info
     # If this watch should only be active for a specific file...
     if watch_path and os.path.isfile(watch_path):
         # If the current path does not match the expected file, this watch is
         # not active.
def __init__(self, context):
         self.context = context
         # Note: We can't already read values from options
         # as DebuggerBase is created before we initialize options
         # to read potential_debuggers.
         self.options = self.context.options
 
         self._interface = None
         self.has_loaded = False
-        self._loading_error = NotYetLoadedDebuggerException()
+        self._loading_error = None
         try:
             self._interface = self._load_interface()
             self.has_loaded = True
-            self._loading_error = None
         except DebuggerException:
             self._loading_error = sys.exc_info()
 
     def __enter__(self):
         try:
             self._custom_init()
             self.clear_breakpoints()
         except DebuggerException:

cross-project-tests/debuginfo-tests/dexter/dex/debugger/DebuggerControllers/DebuggerControllerBase.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
 """Abstract Base class for controlling debuggers."""
 
 import abc
 
 class DebuggerControllerBase(object, metaclass=abc.ABCMeta):
     @abc.abstractclassmethod
     def _run_debugger_custom(self):
         """Specify your own implementation of run_debugger_custom in your own
         controller.
         """
         pass
 
     def run_debugger(self, debugger):
         """Responsible for correctly launching and tearing down the debugger.
         """
         self.debugger = debugger
         with self.debugger:
+            if not self.debugger.loading_error:
                 self._run_debugger_custom()
+
         # We may need to pickle this debugger controller after running the
         # debugger. Debuggers are not picklable objects, so set to None.
         self.debugger = None

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

def __init__(self, *args):
         # Map {id: VSBreakpoint} where id is unique and VSBreakpoint identifies
         # a breakpoint in Visual Studio. There may be many ids mapped to a
         # single VSBreakpoint. Use self._vs_to_dex_ids to find (dexter)
         # breakpoints mapped to the same visual studio breakpoint.
         self._dex_id_to_vs = {}
 
         super(VisualStudio, self).__init__(*args)
 
+    def _create_solution(self):
+        self._solution.Create(self.context.working_directory.path,
+                              'DexterSolution')
+        try:
+            self._solution.AddFromFile(self._project_file)
+        except OSError:
+            raise LoadDebuggerException(
+                'could not debug the specified executable', sys.exc_info())
+
+    def _load_solution(self):
+        try:
+            self._solution.Open(self.context.options.vs_solution)
+        except:
+            raise LoadDebuggerException(
+                    'could not load specified vs solution at {}'.
+                    format(self.context.options.vs_solution), sys.exc_info())
+
     def _custom_init(self):
         try:
             self._debugger = self._interface.Debugger
             self._debugger.HexDisplayMode = False
 
             self._interface.MainWindow.Visible = (
                 self.context.options.show_debugger)
 
             self._solution = self._interface.Solution
-            self._solution.Create(self.context.working_directory.path,
-                                  'DexterSolution')
-
-            try:
-                self._solution.AddFromFile(self._project_file)
-            except OSError:
-                raise LoadDebuggerException(
-                    'could not debug the specified executable', sys.exc_info())
+            if self.context.options.vs_solution is None:
+                self._create_solution()
+            else:
+                self._load_solution()
 
             self._fn_step = self._debugger.StepInto
             self._fn_go = self._debugger.Go
 
         except AttributeError as e:
             raise LoadDebuggerException(str(e), sys.exc_info())
 
     def _custom_exit(self):

cross-project-tests/debuginfo-tests/dexter/dex/tools/TestToolBase.py

class TestToolBase(ToolBase):
 
     def handle_options(self, defaults):
         options = self.context.options
 
         if not options.builder and (options.cflags or options.ldflags):
             warn(self.context, '--cflags and --ldflags will be ignored when not'
                                ' using --builder')
 
-        if options.binary:
+        if options.vs_solution:
+            options.vs_solution = os.path.abspath(options.vs_solution)
+            if not os.path.isfile(options.vs_solution):
+                raise Error('<d>could not find VS solution file</> <r>"{}"</>'
+                            .format(options.vs_solution))
+        elif options.binary:
             options.binary = os.path.abspath(options.binary)
             if not os.path.isfile(options.binary):
                 raise Error('<d>could not find binary file</> <r>"{}"</>'
                             .format(options.binary))
         else:
             try:
                 self.build_script = handle_builder_tool_options(self.context)
             except ToolArgumentError as e:

cross-project-tests/debuginfo-tests/dexter/dex/tools/run_debugger_internal_/Tool.py

class Tool(ToolBase):
     def handle_options(self, defaults):
         with open(self.context.options.controller_path, 'rb') as fp:
             self.debugger_controller = pickle.load(fp)
         self.controller_path = self.context.options.controller_path   
         self.context = self.debugger_controller.context
         self.options = self.context.options
         Timer.display = self.options.time_report
 
+    def raise_debugger_error(self, action, debugger):
+        msg = '<d>could not {} {}</> ({})\n'.format(
+            action, debugger.name, debugger.loading_error)
+        if self.options.verbose:
+            msg = '{}\n    {}'.format(
+                msg, '    '.join(debugger.loading_error_trace))
+        raise Error(msg)
+
     def go(self) -> ReturnCode:
         with Timer('loading debugger'):
             debugger = Debuggers(self.context).load(self.options.debugger)
 
         with Timer('running debugger'):
             if not debugger.is_available:
-                msg = '<d>could not load {}</> ({})\n'.format(
-                    debugger.name, debugger.loading_error)
-                if self.options.verbose:
-                    msg = '{}\n    {}'.format(
-                        msg, '    '.join(debugger.loading_error_trace))
-                raise Error(msg)
+                self.raise_debugger_error('load', debugger)
 
             self.debugger_controller.run_debugger(debugger)
 
+            if debugger.loading_error:
+                self.raise_debugger_error('run', debugger)
+
         with open(self.controller_path, 'wb') as fp:
             pickle.dump(self.debugger_controller, fp)
         return ReturnCode.OK

cross-project-tests/debuginfo-tests/dexter/dex/tools/test/Tool.py

def add_tool_arguments(self, parser, defaults):
                             action="store_true",
                             help='calculate the average score of every test run')
         super(Tool, self).add_tool_arguments(parser, defaults)
 
     def _build_test_case(self):
         """Build an executable from the test source with the given --builder
         script and flags (--cflags, --ldflags) in the working directory.
         Or, if the --binary option has been given, copy the executable provided
-        into the working directory and rename it to match the --builder output.
+        into the working directory and rename it to match the --builder output
+        or skip if --vs-solution was passed on the command line.
         """
 
+        if self.context.options.vs_solution:
+            return
+
         options = self.context.options
         if options.binary:
             # Copy user's binary into the tmp working directory
             shutil.copy(options.binary, options.executable)
             builderIR = BuilderIR(
                 name='binary',
                 cflags=[options.binary],
                 ldflags='')