| 1 |
# DExTer : Debugging Experience Tester |
| 2 |
# ~~~~~~ ~ ~~ ~ ~~ |
| 3 |
# |
| 4 |
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 5 |
# See https://llvm.org/LICENSE.txt for license information. |
| 6 |
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 7 |
"""Conditional Controller Class for DExTer.-""" |
| 8 |
|
| 9 |
|
| 10 |
import os |
| 11 |
import time |
| 12 |
from collections import defaultdict |
| 13 |
from itertools import chain |
| 14 |
|
| 15 |
from dex.debugger.DebuggerControllers.ControllerHelpers import ( |
| 16 |
in_source_file, |
| 17 |
update_step_watches, |
| 18 |
) |
| 19 |
from dex.debugger.DebuggerControllers.DebuggerControllerBase import ( |
| 20 |
DebuggerControllerBase, |
| 21 |
) |
| 22 |
from dex.debugger.DebuggerBase import DebuggerBase |
| 23 |
from dex.utils.Exceptions import DebuggerException |
| 24 |
from dex.utils.Timeout import Timeout |
| 25 |
from dex.dextIR import LocIR |
| 26 |
|
| 27 |
class BreakpointRange: |
| 28 |
"""A range of breakpoints and a set of conditions. |
| 29 |
|
| 30 |
The leading breakpoint (on line `range_from`) is always active. |
| 31 |
|
| 32 |
When the leading breakpoint is hit the trailing range should be activated |
| 33 |
when `expression` evaluates to any value in `values`. If there are no |
| 34 |
conditions (`expression` is None) then the trailing breakpoint range should |
| 35 |
always be activated upon hitting the leading breakpoint. |
| 36 |
|
| 37 |
Args: |
| 38 |
expression: None for no conditions, or a str expression to compare |
| 39 |
against `values`. |
| 40 |
|
| 41 |
hit_count: None for no limit, or int to set the number of times the |
| 42 |
leading breakpoint is triggered before it is removed. |
| 43 |
""" |
| 44 |
|
| 45 |
def __init__( |
| 46 |
self, |
| 47 |
expression: str, |
| 48 |
path: str, |
| 49 |
range_from: int, |
| 50 |
range_to: int, |
| 51 |
values: list, |
| 52 |
hit_count: int, |
| 53 |
finish_on_remove: bool, |
| 54 |
is_continue: bool = False, |
| 55 |
function: str = None, |
| 56 |
addr: str = None, |
| 57 |
): |
| 58 |
self.expression = expression |
| 59 |
self.path = path |
| 60 |
self.range_from = range_from |
| 61 |
self.range_to = range_to |
| 62 |
self.conditional_values = values |
| 63 |
self.max_hit_count = hit_count |
| 64 |
self.current_hit_count = 0 |
| 65 |
self.finish_on_remove = finish_on_remove |
| 66 |
self.is_continue = is_continue |
| 67 |
self.function = function |
| 68 |
self.addr = addr |
| 69 |
|
| 70 |
def limit_steps( |
| 71 |
expression: str, |
| 72 |
path: str, |
| 73 |
range_from: int, |
| 74 |
range_to: int, |
| 75 |
values: list, |
| 76 |
hit_count: int, |
| 77 |
): |
| 78 |
return BreakpointRange( |
| 79 |
expression, |
| 80 |
path, |
| 81 |
range_from, |
| 82 |
range_to, |
| 83 |
values, |
| 84 |
hit_count, |
| 85 |
False, |
| 86 |
) |
| 87 |
|
| 88 |
def finish_test( |
| 89 |
expression: str, path: str, on_line: int, values: list, hit_count: int |
| 90 |
): |
| 91 |
return BreakpointRange( |
| 92 |
expression, |
| 93 |
path, |
| 94 |
on_line, |
| 95 |
on_line, |
| 96 |
values, |
| 97 |
hit_count, |
| 98 |
True, |
| 99 |
) |
| 100 |
|
| 101 |
def continue_from_to( |
| 102 |
expression: str, |
| 103 |
path: str, |
| 104 |
from_line: int, |
| 105 |
to_line: int, |
| 106 |
values: list, |
| 107 |
hit_count: int, |
| 108 |
): |
| 109 |
return BreakpointRange( |
| 110 |
expression, |
| 111 |
path, |
| 112 |
from_line, |
| 113 |
to_line, |
| 114 |
values, |
| 115 |
hit_count, |
| 116 |
finish_on_remove=False, |
| 117 |
is_continue=True, |
| 118 |
) |
| 119 |
|
| 120 |
def step_function(function: str, path: str, hit_count: int): |
| 121 |
return BreakpointRange( |
| 122 |
None, |
| 123 |
path, |
| 124 |
None, |
| 125 |
None, |
| 126 |
None, |
| 127 |
hit_count, |
| 128 |
finish_on_remove=False, |
| 129 |
is_continue=False, |
| 130 |
function=function, |
| 131 |
) |
| 132 |
|
| 133 |
def has_conditions(self): |
| 134 |
return self.expression is not None |
| 135 |
|
| 136 |
def get_conditional_expression_list(self): |
| 137 |
conditional_list = [] |
| 138 |
for value in self.conditional_values: |
| 139 |
# (<expression>) == (<value>) |
| 140 |
conditional_expression = "({}) == ({})".format(self.expression, value) |
| 141 |
conditional_list.append(conditional_expression) |
| 142 |
return conditional_list |
| 143 |
|
| 144 |
def add_hit(self): |
| 145 |
self.current_hit_count += 1 |
| 146 |
|
| 147 |
def should_be_removed(self): |
| 148 |
if self.max_hit_count is None: |
| 149 |
return False |
| 150 |
return self.current_hit_count >= self.max_hit_count |
| 151 |
|
| 152 |
|
| 153 |
class ConditionalController(DebuggerControllerBase): |
| 154 |
def __init__(self, context, step_collection): |
| 155 |
self._bp_ranges = None |
| 156 |
self._watches = set() |
| 157 |
self._step_index = 0 |
| 158 |
self._pause_between_steps = context.options.pause_between_steps |
| 159 |
self._max_steps = context.options.max_steps |
| 160 |
# Map {id: BreakpointRange} |
| 161 |
self._leading_bp_handles = {} |
| 162 |
super(ConditionalController, self).__init__(context, step_collection) |
| 163 |
self._build_bp_ranges() |
| 164 |
|
| 165 |
def _build_bp_ranges(self): |
| 166 |
commands = self.step_collection.commands |
| 167 |
self._bp_ranges = [] |
| 168 |
|
| 169 |
cond_controller_cmds = ["DexLimitSteps", "DexStepFunction", "DexContinue"] |
| 170 |
if not any(c in commands for c in cond_controller_cmds): |
| 171 |
raise DebuggerException( |
| 172 |
f"No conditional commands {cond_controller_cmds}, cannot conditionally step." |
| 173 |
) |
| 174 |
|
| 175 |
if "DexLimitSteps" in commands: |
| 176 |
for c in commands["DexLimitSteps"]: |
| 177 |
bpr = BreakpointRange.limit_steps( |
| 178 |
c.expression, |
| 179 |
c.path, |
| 180 |
c.from_line, |
| 181 |
c.to_line, |
| 182 |
c.values, |
| 183 |
c.hit_count, |
| 184 |
) |
| 185 |
self._bp_ranges.append(bpr) |
| 186 |
if "DexFinishTest" in commands: |
| 187 |
for c in commands["DexFinishTest"]: |
| 188 |
bpr = BreakpointRange.finish_test( |
| 189 |
c.expression, c.path, c.on_line, c.values, c.hit_count + 1 |
| 190 |
) |
| 191 |
self._bp_ranges.append(bpr) |
| 192 |
if "DexContinue" in commands: |
| 193 |
for c in commands["DexContinue"]: |
| 194 |
bpr = BreakpointRange.continue_from_to( |
| 195 |
c.expression, c.path, c.from_line, c.to_line, c.values, c.hit_count |
| 196 |
) |
| 197 |
self._bp_ranges.append(bpr) |
| 198 |
if "DexStepFunction" in commands: |
| 199 |
for c in commands["DexStepFunction"]: |
| 200 |
bpr = BreakpointRange.step_function( |
| 201 |
c.get_function(), c.path, c.hit_count |
| 202 |
) |
| 203 |
self._bp_ranges.append(bpr) |
| 204 |
|
| 205 |
def _set_leading_bps(self): |
| 206 |
# Set a leading breakpoint for each BreakpointRange, building a |
| 207 |
# map of {leading bp id: BreakpointRange}. |
| 208 |
for bpr in self._bp_ranges: |
| 209 |
if bpr.has_conditions(): |
| 210 |
# Add a conditional breakpoint for each condition. |
| 211 |
for cond_expr in bpr.get_conditional_expression_list(): |
| 212 |
id = self.debugger.add_conditional_breakpoint( |
| 213 |
bpr.path, bpr.range_from, cond_expr |
| 214 |
) |
| 215 |
self._leading_bp_handles[id] = bpr |
| 216 |
elif bpr.function is not None: |
| 217 |
id = self.debugger.add_function_breakpoint(bpr.function) |
| 218 |
self._leading_bp_handles[id] = bpr |
| 219 |
else: |
| 220 |
# Add an unconditional breakpoint. |
| 221 |
id = self.debugger.add_breakpoint(bpr.path, bpr.range_from) |
| 222 |
self._leading_bp_handles[id] = bpr |
| 223 |
|
| 224 |
def _run_debugger_custom(self, cmdline): |
| 225 |
# TODO: Add conditional and unconditional breakpoint support to dbgeng. |
| 226 |
if self.debugger.get_name() == "dbgeng": |
| 227 |
raise DebuggerException( |
| 228 |
"DexLimitSteps commands are not supported by dbgeng" |
| 229 |
) |
| 230 |
|
| 231 |
self.step_collection.clear_steps() |
| 232 |
self._set_leading_bps() |
| 233 |
|
| 234 |
for command_obj in chain.from_iterable(self.step_collection.commands.values()): |
| 235 |
self._watches.update(command_obj.get_watches()) |
| 236 |
|
| 237 |
self.debugger.launch(cmdline) |
| 238 |
time.sleep(self._pause_between_steps) |
| 239 |
|
| 240 |
exit_desired = False |
| 241 |
timed_out = False |
| 242 |
total_timeout = Timeout(self.context.options.timeout_total) |
| 243 |
|
| 244 |
step_function_backtraces: list[list[str]] = [] |
| 245 |
self.instr_bp_ids = set() |
| 246 |
|
| 247 |
while not self.debugger.is_finished: |
| 248 |
breakpoint_timeout = Timeout(self.context.options.timeout_breakpoint) |
| 249 |
while self.debugger.is_running and not timed_out: |
| 250 |
# Check to see whether we've timed out while we're waiting. |
| 251 |
if total_timeout.timed_out(): |
| 252 |
self.context.logger.error( |
| 253 |
"Debugger session has been " |
| 254 |
f"running for {total_timeout.elapsed}s, timeout reached!" |
| 255 |
) |
| 256 |
timed_out = True |
| 257 |
if breakpoint_timeout.timed_out(): |
| 258 |
self.context.logger.error( |
| 259 |
f"Debugger session has not " |
| 260 |
f"hit a breakpoint for {breakpoint_timeout.elapsed}s, timeout " |
| 261 |
"reached!" |
| 262 |
) |
| 263 |
timed_out = True |
| 264 |
|
| 265 |
if timed_out or self.debugger.is_finished: |
| 266 |
break |
| 267 |
|
| 268 |
step_info = self.debugger.get_step_info(self._watches, self._step_index) |
| 269 |
backtrace = None |
| 270 |
if step_info.current_frame: |
| 271 |
backtrace = [f.function for f in step_info.frames] |
| 272 |
|
| 273 |
record_step = False |
| 274 |
debugger_continue = False |
| 275 |
bp_to_delete = [] |
| 276 |
for bp_id in self.debugger.get_triggered_breakpoint_ids(): |
| 277 |
try: |
| 278 |
# See if this is one of our leading breakpoints. |
| 279 |
bpr = self._leading_bp_handles[bp_id] |
| 280 |
record_step = True |
| 281 |
except KeyError: |
| 282 |
# This is a trailing bp. Mark it for removal. |
| 283 |
bp_to_delete.append(bp_id) |
| 284 |
if bp_id in self.instr_bp_ids: |
| 285 |
self.instr_bp_ids.remove(bp_id) |
| 286 |
else: |
| 287 |
record_step = True |
| 288 |
continue |
| 289 |
|
| 290 |
bpr.add_hit() |
| 291 |
if bpr.should_be_removed(): |
| 292 |
if bpr.finish_on_remove: |
| 293 |
exit_desired = True |
| 294 |
bp_to_delete.append(bp_id) |
| 295 |
del self._leading_bp_handles[bp_id] |
| 296 |
|
| 297 |
if bpr.function is not None: |
| 298 |
if step_info.frames: |
| 299 |
# Add this backtrace to the stack. While the current |
| 300 |
# backtrace matches the top of the stack we'll step, |
| 301 |
# and while there's a backtrace in the stack that |
| 302 |
# is a subset of the current backtrace we'll step-out. |
| 303 |
if ( |
| 304 |
len(step_function_backtraces) == 0 |
| 305 |
or backtrace != step_function_backtraces[-1] |
| 306 |
): |
| 307 |
step_function_backtraces.append(backtrace) |
| 308 |
|
| 309 |
# Add an address breakpoint so we don't fall out |
| 310 |
# the end of nested DexStepFunctions with a DexContinue. |
| 311 |
addr = self.debugger.get_pc(frame_idx=1) |
| 312 |
instr_id = self.debugger.add_instruction_breakpoint(addr) |
| 313 |
# Note the breakpoint so we don't log the source location |
| 314 |
# it in the trace later. |
| 315 |
self.instr_bp_ids.add(instr_id) |
| 316 |
|
| 317 |
elif bpr.is_continue: |
| 318 |
debugger_continue = True |
| 319 |
if bpr.range_to is not None: |
| 320 |
self.debugger.add_breakpoint(bpr.path, bpr.range_to) |
| 321 |
|
| 322 |
else: |
| 323 |
# Add a range of trailing breakpoints covering the lines |
| 324 |
# requested in the DexLimitSteps command. Ignore first line as |
| 325 |
# that's covered by the leading bp we just hit and include the |
| 326 |
# final line. |
| 327 |
for line in range(bpr.range_from + 1, bpr.range_to + 1): |
| 328 |
id = self.debugger.add_breakpoint(bpr.path, line) |
| 329 |
|
| 330 |
# Remove any trailing or expired leading breakpoints we just hit. |
| 331 |
self.debugger.delete_breakpoints(bp_to_delete) |
| 332 |
|
| 333 |
debugger_next = False |
| 334 |
debugger_out = False |
| 335 |
if not debugger_continue and step_info.current_frame and step_info.frames: |
| 336 |
while len(step_function_backtraces) > 0: |
| 337 |
match_subtrace = False # Backtrace contains a target trace. |
| 338 |
match_trace = False # Backtrace matches top of target stack. |
| 339 |
|
| 340 |
# The top of the step_function_backtraces stack contains a |
| 341 |
# backtrace that we want to step through. Check if the |
| 342 |
# current backtrace ("backtrace") either matches that trace |
| 343 |
# or otherwise contains it. |
| 344 |
target_backtrace = step_function_backtraces[-1] |
| 345 |
if len(backtrace) >= len(target_backtrace): |
| 346 |
match_trace = len(backtrace) == len(target_backtrace) |
| 347 |
# Check if backtrace contains target_backtrace, matching |
| 348 |
# from the end (bottom of call stack) backwards. |
| 349 |
match_subtrace = ( |
| 350 |
backtrace[-len(target_backtrace) :] == target_backtrace |
| 351 |
) |
| 352 |
|
| 353 |
if match_trace: |
| 354 |
# We want to step through this function; do so and |
| 355 |
# log the steps in the step trace. |
| 356 |
debugger_next = True |
| 357 |
record_step = True |
| 358 |
break |
| 359 |
elif match_subtrace: |
| 360 |
# There's a function we care about buried in the |
| 361 |
# current backtrace. Step-out until we get to it. |
| 362 |
debugger_out = True |
| 363 |
break |
| 364 |
else: |
| 365 |
# Drop backtraces that are not match_subtraces of the current |
| 366 |
# backtrace; the functions we wanted to step through |
| 367 |
# there are no longer reachable. |
| 368 |
step_function_backtraces.pop() |
| 369 |
|
| 370 |
if record_step and step_info.current_frame: |
| 371 |
self._step_index += 1 |
| 372 |
# Record the step. |
| 373 |
update_step_watches( |
| 374 |
step_info, self._watches, self.step_collection.commands |
| 375 |
) |
| 376 |
self.step_collection.new_step(self.context, step_info) |
| 377 |
|
| 378 |
if exit_desired: |
| 379 |
break |
| 380 |
elif debugger_next: |
| 381 |
self.debugger.step_next() |
| 382 |
elif debugger_out: |
| 383 |
self.debugger.step_out() |
| 384 |
else: |
| 385 |
self.debugger.go() |
| 386 |
time.sleep(self._pause_between_steps) |