# 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 Visual Studio debugger via DTE.""" import abc import imp import os import sys from dex.debugger.DebuggerBase import DebuggerBase from dex.dextIR import FrameIR, LocIR, StepIR, StopReason, ValueIR from dex.dextIR import StackFrame, SourceLocation, ProgramState from dex.utils.Exceptions import Error, LoadDebuggerException from dex.utils.ReturnCode import ReturnCode def _load_com_module(): try: module_info = imp.find_module( 'ComInterface', [os.path.join(os.path.dirname(__file__), 'windows')]) return imp.load_module('ComInterface', *module_info) except ImportError as e: raise LoadDebuggerException(e, sys.exc_info()) class VisualStudio(DebuggerBase, metaclass=abc.ABCMeta): # pylint: disable=abstract-method # Constants for results of Debugger.CurrentMode # (https://msdn.microsoft.com/en-us/library/envdte.debugger.currentmode.aspx) dbgDesignMode = 1 dbgBreakMode = 2 dbgRunMode = 3 def __init__(self, *args): self.com_module = None self._debugger = None self._solution = None self._fn_step = None self._fn_go = None super(VisualStudio, self).__init__(*args) 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()) 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): if self._interface: self._interface.Quit() @property def _project_file(self): return self.context.options.executable @abc.abstractproperty def _dte_version(self): pass @property def _location(self): #TODO: Find a better way of determining path, line and column info # that doesn't require reading break points. This method requires # all lines to have a break point on them. bp = self._debugger.BreakpointLastHit return { 'path': getattr(bp, 'File', None), 'lineno': getattr(bp, 'FileLine', None), 'column': getattr(bp, 'FileColumn', None) } @property def _mode(self): return self._debugger.CurrentMode def _load_interface(self): self.com_module = _load_com_module() return self.com_module.DTE(self._dte_version) @property def version(self): try: return self._interface.Version except AttributeError: return None def clear_breakpoints(self): for bp in self._debugger.Breakpoints: bp.Delete() def _add_breakpoint(self, file_, line): self._debugger.Breakpoints.Add('', file_, line) def _add_conditional_breakpoint(self, file_, line, condition): column = 1 self._debugger.Breakpoints.Add('', file_, line, column, condition) def _delete_conditional_breakpoint(self, file_, line, condition): for bp in self._debugger.Breakpoints: for bound_bp in bp.Children: if (bound_bp.File == file_ and bound_bp.FileLine == line and bound_bp.Condition == condition): bp.Delete() break def launch(self): self._fn_go() def step(self): self._fn_step() def go(self) -> ReturnCode: self._fn_go() return ReturnCode.OK def set_current_stack_frame(self, idx: int = 0): thread = self._debugger.CurrentThread stack_frames = thread.StackFrames try: stack_frame = stack_frames[idx] self._debugger.CurrentStackFrame = stack_frame.raw except IndexError: raise Error('attempted to access stack frame {} out of {}' .format(idx, len(stack_frames))) def _get_step_info(self, watches, step_index): thread = self._debugger.CurrentThread stackframes = thread.StackFrames frames = [] state_frames = [] for idx, sf in enumerate(stackframes): frame = FrameIR( function=self._sanitize_function_name(sf.FunctionName), is_inlined=sf.FunctionName.startswith('[Inline Frame]'), loc=LocIR(path=None, lineno=None, column=None)) fname = frame.function or '' # pylint: disable=no-member if any(name in fname for name in self.frames_below_main): break state_frame = StackFrame(function=frame.function, is_inlined=frame.is_inlined, watches={}) for watch in watches: state_frame.watches[watch] = self.evaluate_expression( watch, idx) state_frames.append(state_frame) frames.append(frame) loc = LocIR(**self._location) if frames: frames[0].loc = loc state_frames[0].location = SourceLocation(**self._location) reason = StopReason.BREAKPOINT if loc.path is None: # pylint: disable=no-member reason = StopReason.STEP program_state = ProgramState(frames=state_frames) return StepIR( step_index=step_index, frames=frames, stop_reason=reason, program_state=program_state) @property def is_running(self): return self._mode == VisualStudio.dbgRunMode @property def is_finished(self): return self._mode == VisualStudio.dbgDesignMode @property def frames_below_main(self): return [ '[Inline Frame] invoke_main', '__scrt_common_main_seh', '__tmainCRTStartup', 'mainCRTStartup' ] def evaluate_expression(self, expression, frame_idx=0) -> ValueIR: self.set_current_stack_frame(frame_idx) result = self._debugger.GetExpression(expression) self.set_current_stack_frame(0) value = result.Value is_optimized_away = any(s in value for s in [ 'Variable is optimized away and not available', 'Value is not available, possibly due to optimization', ]) is_irretrievable = any(s in value for s in [ '???', '', ]) # an optimized away value is still counted as being able to be # evaluated. could_evaluate = (result.IsValidValue or is_optimized_away or is_irretrievable) return ValueIR( expression=expression, value=value, type_name=result.Type, error_string=None, is_optimized_away=is_optimized_away, could_evaluate=could_evaluate, is_irretrievable=is_irretrievable, )