[Dexter] Add DexLimitSteps command and ConditionalController implementation

[TWeaver]

Summary

• Adds DexLimitSteps Command.
• Add ConditionalController, a new DebuggerController type.
• 5 regression tests
• documentation

THE PROBLEM

The default operating behaviour of dexter would step onto every line and gather step information for each of them. This means that, given a large enough test program, dexter would take an undesirable amount of time to run.

This is because dexter would set a break point on every line of the program, step onto each line, repeatedly if within a loop, and attempt to gather step information. Even if no step information is required for a line, the debugger would halt, context switch to dexter, dexter would then attempt to get step info and then move onto the next line.

This is a problem when we have tight loops for example that run thousands of iterations. With an unoptimized binary dexter, a for loop with 100 iterations could take as long as 20/30 seconds to complete.

The debugging information for that for loop shouldn't change during each iteration, so why gather step info for every iteration?

THE SOLUTION

Allow test writers to specify a range of lines in a test program that dexter will conditionally gather step information for. The condition will be predicated on a variable value at run time. If I have a loop counter variable ix, and ix increments up to 100, then specify a range of lines within the loop that we gather step information only when ix is equal to 50, 65 and 90.

Using the DexLimitSteps command, test writers can now write tests that have this behaviour.

DexLimitSteps('ix', 50, 65, 90, from_line='start_of_for', to_line'end_of_for')

This expresses that the test write wishes to only gather step information on the range of lines from start_of_for TO end_of_for when the loop counter variable 'ix' is equal to 50, 65, 90.

Without a DexLimitSteps command to specify a conditional range of lines to step on, the default behaviour would dumbly gather step information for all 100 iterations of the for loop. This is costly in time.

THE IMPLEMENTATION

Given a DexLimitSteps command within a test suite, we then have to 'control' the debugger to carry out these instructions. The old 'default' behaviour that is now encapsulated in the 'DefaultController' of dexter would require heavy modification to work with both behaviours. Much simpler then to create a new class that can carry out the conditional stepping behaviour we desire.

Drum roll please, presenting the 'ConditionalController'

The conditional controller's job is to 'control/pull the strings' of the debugger in order to carry out conditional stepping behaviour. For every 'DexLimitSteps' command in your test program it creates a conditional break point at the start of the range you defined with "from_line='from', to_line='to'".

There maybe multiple conditional breakpoints on a single line, each one testing a different condition for each variable and value combination specified by the 'DexLimitSteps' commands in the test. The conditional checking is handled by the debugger implementation natively as context switching back to dexter to check them on each iteration is slow.

When a conditional break point is hit, we get a list of all the conditional ranges that start on that line. It's not currently possible to check which break point was last hit for both the VS Debugger and LLDB, so instead we have to recheck that the conditionals were hit. As one or more conditional range can start on the same line, we need to check which conditions are true in Dexter in order to set the correct ranges, this is handled my _conditional_met(), probably the hackiest part of this implementation, recommendations on how to spruce this part up are welcomed.

Remember that we only set a conditional break point on the first line on a range. If a conditional bp fires, we then set a range of unconditional break points through out the rest of the range of 'from_line='from' TO to_line='to'. We gather step information for the line the conditional was hit and then continue execution up to the next break point.

Any non-conditional break points on a line we breaked on get deleted immediately before we continue execution.

All this boils down to is a set of lines in a program that the conditional controller gathers step information for IFF the value of a variable is equal to an expected value at runtime.

[TWeaver]

missing note, dbgeng does not support the new DexLimitSteps commands as of right now.

We do have Visual Studio and LLDB support though.

[echristo]

This all seems like a good idea, but I don't know dexter so.. :)

[TWeaver]

@echristo thanks for your interest. do you need any further clarification on what dexter does or how this patch fits in with the existing behaviour?

[jmorse]

One nit inline; on the broader topic of review, we've (Sony) been reviewing things like this internally first. I guess we should move all of that to phab seeing how the code lives in the monorepo now.

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

116

AFAIUI "LoadDebugger.." is more about config and loading time errors, do we have a better exception class for "stuff that broke while we were running?"

[TWeaver]

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

116

good point, this is copy pasta from add_breakpoint() tbh.

We have DebuggerException('your message here').

Should be able to drop in and replace LoadDebuggerException with no issues.

This also raises questions around the validity of the LoadDebuggerException raised in add_breakpoint too. If my memory serves then the original default debugger behaviour would set breakpoints during the initialisation phase, hence why this Load error is here... An issue of the behaviour of debugger control seeping into the debugger features/functionality.

Given that add_breakpoint could potentially be called from many different controllers it'd make sense to move the LoadDebuggerException out to the DefaultController and a raise a DebuggerException instead.

[jmorse]

(Inline):

Given that add_breakpoint could potentially be called from many different controllers it'd make sense to move the LoadDebuggerException out to the DefaultController and a raise a DebuggerException instead.

Cool -- LGTM with that twiddled. Best to leave it a day or so in case there's more interest from elsewhere; and we'll move to fully phab reviews to include more people in the process.

[TWeaver]

removed and replaced LoadDebuggerException with DebuggerException in LLDB.

Moved LoadDebuggerException out to DefaultController.

[TWeaver]

Landed in commit rG81e836a5a675f6a3d9d35560fddbbb87fdf66201

[aprantl]

There's a bunch of dexter test failures that popped up on the bots today: http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/20274/

Could they be related to this change?

[TWeaver]

@aprantl I'll take a look, thanks for pointing them out.

[TWeaver]

seems I've made a more mundane error of committing a diff file as part of my patch. this has been reverted for now.

I'll continue looking into the test failures.

[TWeaver]

Hi Adrian (@aprantl)

I've been unable to reproduce the errors seen in job 20274.

This and another Dexter commit was built and tested in job 20264. 20264 had tests failures too, but not the same failures seen in 20274.

http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/20264/

by job 20269 the CI pipeline went green with no test failures. No intermediate jobs between 20269 and 20264 showed the dexter-test failures.

In fact, the only job I can find that has the failures is the job you originally linked, 20274. 20275, the job afterwards is also green and doesn't contain any commits in a relevant area, AFAIK. This is quite perplexing as I would expect, given no other changes to dexter, we'd still be seeing the test failures introduced in 20274.

I'm also unable to reproduce the failures on my local machine, even with a build at the point of introducing my patch, a build at the point the CI encountered the failures and a build afterwards but before I reverted.

As such, I'm not sure what to chalk this up to other than some transient error in the CI perhaps.

I did go down one rabbit hole to try and find some answers but came back with nothing concrete; job 20274 contains a patch that adds a new diagnostic warning to DiagnosticsSemaKind.td, you can see the diff at the following link:

https://reviews.llvm.org/D79895

Given that the tests are failing on an assertion in clang/include/clang/Basic/Diagnostics.h, it could be that some 'strange' and 'unexpected' behavior during tablegenning of the aforementioned .td file may have caused the failures we've seen, and that it's a coincidence that this aligned with my patches being introduced.

I've checked the logs for the 20274 build and taken a look at the table gen lines and found nothing suspicious, but this is the only explanation that has any kind of link to the failing job that I can find, so that's all I can offer I'm afraid.

Not a particularly satisfying answer, so you have my apologies on that, but, as said, I can't reproduce and neither does the CI atm, so it seems the failure was temporary.

Hope this helps,
Tom W

[aprantl]

It looks like the bots recovered by now, which makes it likely to have been an unrelated clang regression. Thanks for checking!

[TWeaver]

recommitted rGc6aa829644f30d5590451b892918298f8117c985

[MaskRay]

debuginfo-tests/dexter/Commands.md

178

There is an extra , (in ],[)

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

121

range(bp_count) is more common

debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_check_json_step_count.cpp

1

In most other places a file level comment does not start with Purpose:. I think you may consider deleting Purpose:

Comments probably should start with /// to make them stand out from RUN/CHECK lines and avoid future enhanced FileCheck diagnostics (If a check prefix appears in the comment without a punctuation (:), a future FileCheck might warn/error. /// can suppress the diagnostic)

19

DexLimitSteps appears to affect DexExpectWatchValue above it, but the interaction is not very clear...

debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_expect_loop.cpp

20

DexLimitSteps seems to take effect on nearby DexExpectWatchValue, right?

But how they interact isn't very clear from the documentation...

[MaskRay]

debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_check_json_step_count.cpp

9

I think it would be clearer if you expand the output:

[0, "main", "{{.*}}limit_steps_check_json_step_count.cpp", [[#@LINE+5]], 15, "StopReason.BREAKPOINT", "StepKind.FUNC", []]
[1, "main", "{{.*}}limit_steps_check_json_step_count.cpp", [[#@LINE+4]], 15, "StopReason.BREAKPOINT", "StepKind.FUNC", []]
[2, "main", "{{.*}}limit_steps_check_json_step_count.cpp", [[#@LINE+3]], 15, "StopReason.BREAKPOINT", "StepKind.FUNC", []]

debuginfo-tests/dexter/Commands.md

 [TODO]
 
 
+----
+## DexLimitSteps
+    DexLimitSteps(expr, *values [, **from_line=1],[,**to_line=Max]
+                  [,**on_line])
+
+    Args:
+        expr (str): variable or value to compare.
+
+    Arg list:
+        values (str): At least one potential value the expr may evaluate to.
+
+    Keyword args:
+        from_line (int): Define the start of the limited step range.
+        to_line (int): Define the end of the limited step range.
+        on_line (int): Define a range with length 1 starting and ending on the
+                       same line.
+
+### Description
+Define a limited stepping range that is predicated on a condition. When
+'(expr) == (values[n])', set a range of temporary, unconditional break points within
+the test file defined by the range from_line and to_line or on_line.
+
+The condition is only evaluated on the line 'from_line' or 'on_line'. If the
+condition is not true at the start of the range, the whole range is ignored.
+
+DexLimitSteps commands are useful for reducing the amount of steps gathered in
+large test cases that would normally take much longer to complete.
+
 ----
 ## DexLabel
     DexLabel(name)

debuginfo-tests/dexter/dex/command/ParseCommand.py

 from dex.command.commands.DexExpectWatchType import DexExpectWatchType
 from dex.command.commands.DexExpectWatchValue import DexExpectWatchValue
 from dex.command.commands.DexLabel import DexLabel
+from dex.command.commands.DexLimitSteps import DexLimitSteps
 from dex.command.commands.DexUnreachable import DexUnreachable
 from dex.command.commands.DexWatch import DexWatch
 from dex.utils import Timer

       DexExpectWatchType.get_name() : DexExpectWatchType,
       DexExpectWatchValue.get_name() : DexExpectWatchValue,
       DexLabel.get_name() : DexLabel,
+      DexLimitSteps.get_name() : DexLimitSteps,
       DexUnreachable.get_name() : DexUnreachable,
       DexWatch.get_name() : DexWatch
     }

debuginfo-tests/dexter/dex/command/commands/DexLimitSteps.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
+"""A Command that enables test writers to specify a limited number of break
+points using an start condition and range.
+"""
+
+from dex.command.CommandBase import CommandBase
+
+class DexLimitSteps(CommandBase):
+    def __init__(self, *args, **kwargs):
+        self.expression = args[0]
+        self.values = [str(arg) for arg in args[1:]]
+        try:
+            on_line = kwargs.pop('on_line')
+            self.from_line = on_line
+            self.to_line = on_line
+        except KeyError:
+            self.from_line = kwargs.pop('from_line', 1)
+            self.to_line = kwargs.pop('to_line', 999999)
+        if kwargs:
+            raise TypeError('unexpected named args: {}'.format(
+                ', '.join(kwargs)))
+        super(DexLimitSteps, self).__init__()
+
+    def resolve_label(self, label_line_pair):
+        label, lineno = label_line_pair
+        if isinstance(self.from_line, str):
+            if self.from_line == label:
+                self.from_line = lineno
+        if isinstance(self.to_line, str):
+            if self.to_line == label:
+                self.to_line = lineno
+
+    def has_labels(self):
+        return len(self.get_label_args()) > 0
+
+    def get_label_args(self):
+        return [label for label in (self.from_line, self.to_line)
+                      if isinstance(label, str)]
+
+    def eval(self):
+        raise NotImplementedError('DexLimitSteps commands cannot be evaled.')
+
+    @staticmethod
+    def get_name():
+        return __class__.__name__
+
+    @staticmethod
+    def get_subcommands() -> dict:
+        return None

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

     def add_breakpoint(self, file_, line):
         pass
 
+    @abc.abstractmethod
+    def add_conditional_breakpoint(self, file_, line, condition):
+        pass
+
+    @abc.abstractmethod
+    def delete_conditional_breakpoint(self, file_, line, condition):
+        pass
+
     @abc.abstractmethod
     def launch(self):
         pass

debuginfo-tests/dexter/dex/debugger/DebuggerControllers/ConditionalController.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
+"""Conditional Controller Class for DExTer.-"""
+
+
+import os
+import time
+from collections import defaultdict
+from itertools import chain
+
+from dex.debugger.DebuggerControllers.ControllerHelpers import in_source_file, update_step_watches
+from dex.debugger.DebuggerControllers.DebuggerControllerBase import DebuggerControllerBase
+from dex.debugger.DebuggerBase import DebuggerBase
+from dex.utils.Exceptions import DebuggerException
+
+
+class ConditionalBpRange:
+    """Represents a conditional range of breakpoints within a source file descending from
+    one line to another."""
+
+    def __init__(self, expression: str, path: str, range_from: int, range_to: int, values: list):
+        self.expression = expression
+        self.path = path
+        self.range_from = range_from
+        self.range_to = range_to
+        self.conditional_values = values
+
+    def get_conditional_expression_list(self):
+        conditional_list = []
+        for value in self.conditional_values:
+            # (<expression>) == (<value>)
+            conditional_expression = '({}) == ({})'.format(self.expression, value)
+            conditional_list.append(conditional_expression)
+        return conditional_list
+
+
+class ConditionalController(DebuggerControllerBase):
+    def __init__(self, context, step_collection):
+      self.context = context
+      self.step_collection = step_collection
+      self._conditional_bps = None
+      self._watches = set()
+      self._step_index = 0
+      self._build_conditional_bps()
+      self._path_and_line_to_conditional_bp = defaultdict(list)
+      self._pause_between_steps = context.options.pause_between_steps
+      self._max_steps = context.options.max_steps
+
+    def _build_conditional_bps(self):
+        commands = self.step_collection.commands
+        self._conditional_bps = []
+        try:
+            limit_commands = commands['DexLimitSteps']
+            for lc in limit_commands:
+                conditional_bp = ConditionalBpRange(
+                  lc.expression,
+                  lc.path,
+                  lc.from_line,
+                  lc.to_line,
+                  lc.values)
+                self._conditional_bps.append(conditional_bp)
+        except KeyError:
+            raise DebuggerException('Missing DexLimitSteps commands, cannot conditionally step.')
+
+    def _set_conditional_bps(self):
+        # When we break in the debugger we need a quick and easy way to look up
+        # which conditional bp we've breaked on.
+        for cbp in self._conditional_bps:
+            conditional_bp_list = self._path_and_line_to_conditional_bp[(cbp.path, cbp.range_from)]
+            conditional_bp_list.append(cbp)
+
+        # Set break points only on the first line of any conditional range, we'll set
+        # more break points for a range when the condition is satisfied.
+        for cbp in self._conditional_bps:
+            for cond_expr in cbp.get_conditional_expression_list():
+                self.debugger.add_conditional_breakpoint(cbp.path, cbp.range_from, cond_expr)
+
+    def _conditional_met(self, cbp):
+        for cond_expr in cbp.get_conditional_expression_list():
+            valueIR = self.debugger.evaluate_expression(cond_expr)
+            if valueIR.type_name == 'bool' and valueIR.value == 'true':
+                return True
+        return False
+
+    def _run_debugger_custom(self):
+        # TODO: Add conditional and unconditional breakpoint support to dbgeng.
+        if self.debugger.get_name() == 'dbgeng':
+            raise DebuggerException('DexLimitSteps commands are not supported by dbgeng')
+
+        self.step_collection.clear_steps()
+        self._set_conditional_bps()
+
+        for command_obj in chain.from_iterable(self.step_collection.commands.values()):
+            self._watches.update(command_obj.get_watches())
+
+        self.debugger.launch()
+        time.sleep(self._pause_between_steps) 
+        while not self.debugger.is_finished:
+            while self.debugger.is_running:
+                pass
+
+            step_info = self.debugger.get_step_info(self._watches, self._step_index)
+            if step_info.current_frame:
+                self._step_index += 1
+                update_step_watches(step_info, self._watches, self.step_collection.commands)
+                self.step_collection.new_step(self.context, step_info)
+
+                loc = step_info.current_location
+                conditional_bp_key = (loc.path, loc.lineno)
+                if conditional_bp_key in self._path_and_line_to_conditional_bp:
+
+                    conditional_bps = self._path_and_line_to_conditional_bp[conditional_bp_key]
+                    for cbp in conditional_bps:
+                        if self._conditional_met(cbp):
+                            # Unconditional range should ignore first line as that's the
+                            # conditional bp we just hit and should be inclusive of final line
+                            for line in range(cbp.range_from + 1, cbp.range_to + 1):
+                                self.debugger.add_conditional_breakpoint(cbp.path, line, condition='')
+
+            # Clear any uncondtional break points at this loc.
+            self.debugger.delete_conditional_breakpoint(file_=loc.path, line=loc.lineno, condition='')
+            self.debugger.go()
+            time.sleep(self._pause_between_steps)

debuginfo-tests/dexter/dex/debugger/DebuggerControllers/ControllerHelpers.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
+
+import os
+from itertools import chain
+
+def in_source_file(source_files, step_info):
+    if not step_info.current_frame:
+        return False
+    if not step_info.current_location.path:
+        return False
+    if not os.path.exists(step_info.current_location.path):
+        return False
+    return any(os.path.samefile(step_info.current_location.path, f) \
+               for f in source_files)
+
+def update_step_watches(step_info, watches, commands):
+    watch_cmds = ['DexUnreachable', 'DexExpectStepOrder']
+    towatch = chain.from_iterable(commands[x]
+                                  for x in watch_cmds
+                                  if x in commands)
+    try:
+        # Iterate over all watches of the types named in watch_cmds
+        for watch in towatch:
+            loc = step_info.current_location
+            if (os.path.exists(loc.path)
+                    and os.path.samefile(watch.path, loc.path)
+                    and watch.lineno == loc.lineno):
+                result = watch.eval(step_info)
+                step_info.watches.update(result)
+                break
+    except KeyError:
+        pass

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

 # 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
-"""Default class for controlling debuggers."""
+"""Abstract Base class for controlling debuggers."""
 
 import abc
 

debuginfo-tests/dexter/dex/debugger/DebuggerControllers/DefaultController.py

 # 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
-"""Base class for controlling debuggers."""
+"""Default class for controlling debuggers."""
 
 from itertools import chain
 import os
 import time
 
 from dex.debugger.DebuggerControllers.DebuggerControllerBase import DebuggerControllerBase
-from dex.utils.Exceptions import DebuggerException
+from dex.debugger.DebuggerControllers.ControllerHelpers import in_source_file, update_step_watches
+from dex.utils.Exceptions import DebuggerException, LoadDebuggerException
 
 class DefaultController(DebuggerControllerBase):
     def __init__(self, context, step_collection):
         self.context = context
         self.step_collection = step_collection
+        self.source_files = self.context.options.source_files
         self.watches = set()
         self.step_index = 0
 
-    def _update_step_watches(self, step_info):
-        watch_cmds = ['DexUnreachable', 'DexExpectStepOrder']
-        towatch = chain.from_iterable(self.step_collection.commands[x]
-                                      for x in watch_cmds
-                                      if x in self.step_collection.commands)
-        try:
-            # Iterate over all watches of the types named in watch_cmds
-            for watch in towatch:
-                loc = step_info.current_location
-                if (os.path.exists(loc.path)
-                        and os.path.samefile(watch.path, loc.path)
-                        and watch.lineno == loc.lineno):
-                    result = watch.eval(step_info)
-                    step_info.watches.update(result)
-                    break
-        except KeyError:
-            pass
-
     def _break_point_all_lines(self):
         for s in self.context.options.source_files:
             with open(s, 'r') as fp:
                 num_lines = len(fp.readlines())
             for line in range(1, num_lines + 1):
-                self.debugger.add_breakpoint(s, line)
-
-    def _in_source_file(self, step_info):
-        if not step_info.current_frame:
-            return False
-        if not step_info.current_location.path:
-            return False
-        if not os.path.exists(step_info.current_location.path):
-            return False
-        return any(os.path.samefile(step_info.current_location.path, f) \
-                   for f in self.context.options.source_files)
+                try:
+                   self.debugger.add_breakpoint(s, line)
+                except DebuggerException:
+                   raise LoadDebuggerException(DebuggerException.msg)
 
     def _run_debugger_custom(self):
         self.step_collection.debugger = self.debugger.debugger_info
         self._break_point_all_lines()
-
         self.debugger.launch()
 
         for command_obj in chain.from_iterable(self.step_collection.commands.values()):

             step_info = self.debugger.get_step_info(self.watches, self.step_index)
 
             if step_info.current_frame:
-                self._update_step_watches(step_info)
+                update_step_watches(step_info, self.watches, self.step_collection.commands)
                 self.step_collection.new_step(self.context, step_info)
 
-            if self._in_source_file(step_info):
+            if in_source_file(self.source_files, step_info):
                 self.debugger.step()
             else:
                 self.debugger.go()

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

             self.client.Control.RemoveBreakpoint(x)
 
     def add_breakpoint(self, file_, line):
-        # This is something to implement in the future -- as it stands, Dexter
-        # doesn't test for such things as "I can set a breakpoint on this line".
-        # This is only called AFAICT right now to ensure we break on every step.
+        # Breakpoint setting/deleting is not supported by dbgeng at this moment
+        # but is something that should be considered in the future.
+        # TODO: this method is called in the DefaultController but has no effect.
         pass
 
+    def add_conditional_breakpoint(self, file_, line, condition):
+        # breakpoint setting/deleting is not supported by dbgeng at this moment
+        # but is something that should be considered in the future.
+        raise NotImplementedError('add_conditional_breakpoint is not yet implemented by dbgeng')
+
+    def delete_conditional_breakpoint(self, file_, line, condition):
+        # 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):
         # We are, by this point, already launched.
         self.step_info = probe_process.probe_state(self.client)

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

 
     def add_breakpoint(self, file_, line):
         if not self._target.BreakpointCreateByLocation(file_, line):
-            raise LoadDebuggerException(
+            raise DebuggerException(
                 'could not add breakpoint [{}:{}]'.format(file_, line))
 
+    def add_conditional_breakpoint(self, file_, line, condition):
+        bp = self._target.BreakpointCreateByLocation(file_, line)
+        if bp:
+            bp.SetCondition(condition)
+        else:
+            raise DebuggerException(
+                  'could not add breakpoint [{}:{}]'.format(file_, line))
+
+    def delete_conditional_breakpoint(self, file_, line, condition):
+        bp_count = self._target.GetNumBreakpoints()
+        bps = [self._target.GetBreakpointAtIndex(ix) for ix in range(0, bp_count)]
+
+        for bp in bps:
+            bp_cond = bp.GetCondition()
+            bp_cond = bp_cond if bp_cond is not None else ''
+
+            if bp_cond != condition:
+                continue
+
+            # If one of the bound bp locations for this bp is bound to the same
+            # line in file_ above, then delete the entire parent bp and all
+            # bp locs.
+            # https://lldb.llvm.org/python_reference/lldb.SBBreakpoint-class.html
+            for breakpoint_location in bp:
+                sb_address = breakpoint_location.GetAddress()
+
+                sb_line_entry = sb_address.GetLineEntry()
+                bl_line = sb_line_entry.GetLine()
+
+                sb_file_entry = sb_line_entry.GetFileSpec()
+                bl_dir = sb_file_entry.GetDirectory()
+                bl_file_name = sb_file_entry.GetFilename()
+
+                bl_file_path = os.path.join(bl_dir, bl_file_name)
+
+                if bl_file_path == file_ and bl_line == line:
+                    self._target.BreakpointDelete(bp.GetID())
+                    break
+
     def launch(self):
         self._process = self._target.LaunchSimple(None, None, os.getcwd())
         if not self._process or self._process.GetNumThreads() == 0:

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

 
     @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),

     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.step()
+        self._fn_go()
 
     def step(self):
         self._fn_step()

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

 from dex.command.ParseCommand import get_command_infos
 from dex.debugger.Debuggers import run_debugger_subprocess
 from dex.debugger.DebuggerControllers.DefaultController import DefaultController
+from dex.debugger.DebuggerControllers.ConditionalController import ConditionalController
 from dex.dextIR.DextIR import DextIR
 from dex.heuristic import Heuristic
 from dex.tools import TestToolBase

             executable_path=self.context.options.executable,
             source_paths=self.context.options.source_files,
             dexter_version=self.context.version)
+
         step_collection.commands = get_command_infos(
             self.context.options.source_files)
-        debugger_controller = DefaultController(self.context, step_collection)
+
+        if 'DexLimitSteps' in step_collection.commands:
+            debugger_controller = ConditionalController(self.context, step_collection)
+        else:
+            debugger_controller = DefaultController(self.context, step_collection)
+
         return debugger_controller
 
     def _get_steps(self, builderIR):

debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_check_json_step_count.cpp

+// Purpose:
+//      Check number of step lines are correctly reported in json output.
+//
+// REQUIRES: system-linux
+//
+// RUN: %dexter_regression_test --verbose -- %s | FileCheck %s
+// CHECK: limit_steps_check_json_step_count.cpp
+// CHECK: ## BEGIN ##
+// CHECK-COUNT-3: json_step_count.cpp",
+
+int main() {
+  int result = 0;
+  for(int ix = 0; ix != 10; ++ix) {
+    int index = ix;
+    result += index; // DexLabel('check')
+  }
+}
+
+// DexExpectWatchValue('index', 2, 7, 9, on_line='check')
+// DexLimitSteps('ix', 2, 7, 9, on_line='check')

debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_expect_loop.cpp

+// Purpose:
+//      Check the DexLimit steps only gathers step info for 2 iterations of a
+//      for loop.
+//
+// REQUIRES: system-linux
+//
+// RUN: %dexter_regression_test -- %s | FileCheck %s
+// CHECK: limit_steps_expect_loop.cpp:
+
+int main(const int argc, const char * argv[]) {
+  unsigned int sum = 1;
+  for(unsigned int ix = 0; ix != 5; ++ix) {
+    unsigned thing_to_add = ix + ix - ix;   // DexLabel('start')
+    sum += ix;                              // DexLabel('end')
+  }
+  return sum;
+}
+
+// DexLimitSteps('ix', 0, 3, from_line='start', to_line='end')
+// DexExpectWatchValue('ix', 0, 3, from_line='start', to_line='end')

debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_expect_value.cpp

+// Purpose:
+//      Ensure that limited stepping breaks for all expected values.
+//
+// REQUIRES: system-linux
+//
+// RUN: %dexter_regression_test -- %s | FileCheck %s
+// CHECK: limit_steps_expect_value.cpp
+
+int main() {
+  int i = 0;
+  i = 1;    // DexLabel('from')
+  i = 2;
+  i = 3;
+  return 0; // DexLabel('long_range')
+}
+
+// DexLimitSteps('i', '0', from_line='from', to_line='long_range')
+// DexExpectWatchValue('i', 0, 1, 2, 3, from_line='from', to_line='long_range')

debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_overlapping_ranges.cpp

+// Purpose:
+//      Ensure that multiple overlapping \DexLimitSteps ranges do not interfere.
+//
+// REQUIRES: system-linux
+//
+// RUN: %dexter_regression_test -- %s | FileCheck %s
+// CHECK: limit_steps_overlapping_ranges.cpp
+
+int main() {
+  int val1;
+  int val2;
+  int placeholder;
+  for (int ix = 0; ix != 10; ++ix) {
+    placeholder=val1+val2;   // DexLabel('from')
+    if (ix == 0) {
+      val1 = ix;
+      val2 = ix;             // DexLabel('val1_check')
+      placeholder=val1+val2; // DexLabel('val1_check_to')
+    }
+    else if (ix == 2) {
+      val2 = ix;
+      val1 = ix;             // DexLabel('val2_check')
+      placeholder=val1+val2; // DexLabel('val2_check_to')
+    }
+    placeholder=val1+val2;   // DexLabel('to')
+  }
+  return val1 + val2;
+}
+
+// DexExpectWatchValue('ix', 0, 2, 5, from_line='from', to_line='to')
+// DexExpectWatchValue('val1', 0, from_line='val1_check', to_line='val1_check_to')
+// DexExpectWatchValue('val2', 2, from_line='val2_check', to_line='val2_check_to')
+
+// DexLimitSteps('ix', 5, from_line='from', to_line='to')
+// DexLimitSteps('val1', 0, from_line='val1_check', to_line='val1_check_to')
+// DexLimitSteps('val2', 2, from_line='val2_check', to_line='val2_check_to')

debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_same_line_conditional.cpp

+// Purpose:
+//      Test that LimitStep commands can exist on the same from line.
+//
+// REQUIRES: system-linux
+//
+// RUN: %dexter_regression_test -- %s | FileCheck %s
+// CHECK: limit_steps_same_line_conditional.cpp
+
+int main() {
+  int val1 = 0;
+
+  int placeholder;
+  for(int ix = 0; ix != 4; ++ix) {
+    val1 = ix;
+    placeholder = ix;    // DexLabel('from')
+    placeholder = ix;
+    val1 += 2;           // DexLabel('to')
+    placeholder = ix;    // DexLabel('extended_to')
+  }
+  return val1 + placeholder;
+}
+
+// DexExpectWatchValue('val1', 0, 1, 3, from_line='from', to_line='extended_to')
+
+// DexLimitSteps('ix', 0, from_line='from', to_line='to')
+// DexLimitSteps('ix', 1, from_line='from', to_line='extended_to')