| """Check that compiler-generated register values work correctly""" |
| |
| import re |
| import lldb |
| from lldbsuite.test.decorators import * |
| from lldbsuite.test.lldbtest import * |
| from lldbsuite.test import lldbutil |
| |
| |
| def re_expr_equals(val_type, val): |
| # Match ({val_type}) ${sum_digits} = {val} |
| return re.compile(r"\(" + val_type + "\) \$\d+ = " + str(val)) |
| |
| |
| class RegisterVariableTestCase(TestBase): |
| @expectedFailureAll(compiler="clang", compiler_version=["<", "3.5"]) |
| @expectedFailureAll( |
| compiler="gcc", compiler_version=[">=", "4.8.2"], archs=["i386"] |
| ) |
| @expectedFailureAll(compiler="gcc", compiler_version=["<", "4.9"], archs=["x86_64"]) |
| def test_and_run_command(self): |
| """Test expressions on register values.""" |
| |
| # This test now ensures that each probable |
| # register variable location is actually a register, and |
| # if so, whether we can print out the variable there. |
| # It only requires one of them to be handled in a non-error |
| # way. |
| register_variables_count = 0 |
| |
| self.build() |
| exe = self.getBuildArtifact("a.out") |
| self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) |
| |
| # Break inside the main. |
| lldbutil.run_break_set_by_source_regexp(self, "break", num_expected_locations=3) |
| |
| #################### |
| # First breakpoint |
| |
| self.runCmd("run", RUN_SUCCEEDED) |
| |
| # The stop reason of the thread should be breakpoint. |
| self.expect( |
| "thread list", |
| STOPPED_DUE_TO_BREAKPOINT, |
| substrs=["stopped", "stop reason = breakpoint"], |
| ) |
| |
| # The breakpoint should have a hit count of 1. |
| lldbutil.check_breakpoint( |
| self, bpno=1, location_id=1, expected_location_hit_count=1 |
| ) |
| |
| # Try some variables that should be visible |
| frame = ( |
| self.dbg.GetSelectedTarget() |
| .GetProcess() |
| .GetSelectedThread() |
| .GetSelectedFrame() |
| ) |
| if self.is_variable_in_register(frame, "a"): |
| register_variables_count += 1 |
| self.expect( |
| "expr a", |
| VARIABLES_DISPLAYED_CORRECTLY, |
| patterns=[re_expr_equals("int", 2)], |
| ) |
| |
| if self.is_struct_pointer_in_register(frame, "b", self.TraceOn()): |
| register_variables_count += 1 |
| self.expect( |
| "expr b->m1", |
| VARIABLES_DISPLAYED_CORRECTLY, |
| patterns=[re_expr_equals("int", 3)], |
| ) |
| |
| ##################### |
| # Second breakpoint |
| |
| self.runCmd("continue") |
| |
| # The stop reason of the thread should be breakpoint. |
| self.expect( |
| "thread list", |
| STOPPED_DUE_TO_BREAKPOINT, |
| substrs=["stopped", "stop reason = breakpoint"], |
| ) |
| |
| # The breakpoint should have a hit count of 1. |
| lldbutil.check_breakpoint( |
| self, bpno=1, location_id=2, expected_location_hit_count=1 |
| ) |
| |
| # Try some variables that should be visible |
| frame = ( |
| self.dbg.GetSelectedTarget() |
| .GetProcess() |
| .GetSelectedThread() |
| .GetSelectedFrame() |
| ) |
| if self.is_struct_pointer_in_register(frame, "b", self.TraceOn()): |
| register_variables_count += 1 |
| self.expect( |
| "expr b->m2", |
| VARIABLES_DISPLAYED_CORRECTLY, |
| patterns=[re_expr_equals("int", 5)], |
| ) |
| |
| if self.is_variable_in_register(frame, "c"): |
| register_variables_count += 1 |
| self.expect( |
| "expr c", |
| VARIABLES_DISPLAYED_CORRECTLY, |
| patterns=[re_expr_equals("int", 5)], |
| ) |
| |
| ##################### |
| # Third breakpoint |
| |
| self.runCmd("continue") |
| |
| # The stop reason of the thread should be breakpoint. |
| self.expect( |
| "thread list", |
| STOPPED_DUE_TO_BREAKPOINT, |
| substrs=["stopped", "stop reason = breakpoint"], |
| ) |
| |
| # The breakpoint should have a hit count of 1. |
| lldbutil.check_breakpoint( |
| self, bpno=1, location_id=3, expected_location_hit_count=1 |
| ) |
| |
| # Try some variables that should be visible |
| frame = ( |
| self.dbg.GetSelectedTarget() |
| .GetProcess() |
| .GetSelectedThread() |
| .GetSelectedFrame() |
| ) |
| if self.is_variable_in_register(frame, "f"): |
| register_variables_count += 1 |
| self.expect( |
| "expr f", |
| VARIABLES_DISPLAYED_CORRECTLY, |
| patterns=[re_expr_equals("float", "3.1")], |
| ) |
| |
| # Validate that we verified at least one register variable |
| self.assertGreater( |
| register_variables_count, |
| 0, |
| "expected to verify at least one variable in a register", |
| ) |
| self.trace( |
| "executed {} expressions with values in registers".format( |
| register_variables_count |
| ) |
| ) |
| |
| self.runCmd("kill") |
| |
| def is_variable_in_register(self, frame, var_name): |
| # Ensure we can lookup the variable. |
| var = frame.FindVariable(var_name) |
| self.trace("\nchecking {}...".format(var_name)) |
| if var is None or not var.IsValid(): |
| self.trace("{} cannot be found".format(var_name)) |
| return False |
| |
| # Check that we can get its value. If not, this |
| # may be a variable that is just out of scope at this point. |
| value = var.GetValue() |
| self.trace("checking value...") |
| if value is None: |
| self.trace("value is invalid") |
| return False |
| else: |
| self.trace("value is {}".format(value)) |
| |
| # We have a variable and we can get its value. The variable is in a |
| # register if we cannot get an address for it, assuming it is not a |
| # struct pointer. (This is an approximation - compilers can do other |
| # things with spitting up a value into multiple parts of multiple |
| # registers, but what we're verifying here is much more than it was |
| # doing before). |
| var_addr = var.GetAddress() |
| self.trace("checking address...") |
| if var_addr.IsValid(): |
| # We have an address, it must not be in a register. |
| self.trace( |
| "var {} is not in a register: has a valid address {}".format( |
| var_name, var_addr |
| ) |
| ) |
| return False |
| else: |
| # We don't have an address but we can read the value. |
| # It is likely stored in a register. |
| self.trace( |
| "var {} is in a register (we don't have an address for it)".format( |
| var_name |
| ) |
| ) |
| return True |
| |
| def is_struct_pointer_in_register(self, frame, var_name, trace): |
| # Ensure we can lookup the variable. |
| var = frame.FindVariable(var_name) |
| if trace: |
| print("\nchecking {}...".format(var_name)) |
| |
| if var is None or not var.IsValid(): |
| self.trace("{} cannot be found".format(var_name)) |
| return False |
| |
| # Check that we can get its value. If not, this |
| # may be a variable that is just out of scope at this point. |
| value = var.GetValue() |
| self.trace("checking value...") |
| if value is None: |
| if trace: |
| print("value is invalid") |
| return False |
| else: |
| if trace: |
| print("value is {}".format(value)) |
| |
| var_loc = var.GetLocation() |
| if trace: |
| print("checking location: {}".format(var_loc)) |
| if var_loc is None or var_loc.startswith("0x"): |
| # The frame var is not in a register but rather a memory location. |
| self.trace("frame var {} is not in a register".format(var_name)) |
| return False |
| else: |
| self.trace("frame var {} is in a register".format(var_name)) |
| return True |
