| """ |
| Test the IR interpreter |
| """ |
| |
| |
| import lldb |
| from lldbsuite.test.decorators import * |
| from lldbsuite.test.lldbtest import * |
| from lldbsuite.test import lldbutil |
| |
| |
| class IRInterpreterTestCase(TestBase): |
| NO_DEBUG_INFO_TESTCASE = True |
| |
| def time_expression(self, expr, options): |
| start = time.time() |
| res = self.target.EvaluateExpression(expr, options) |
| return res, time.time() - start |
| |
| def test_interpreter_timeout(self): |
| """Test the timeout logic in the IRInterpreter.""" |
| self.build() |
| self.target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) |
| self.assertTrue(self.target, VALID_TARGET) |
| |
| # A non-trivial infinite loop. |
| inf_loop = "for (unsigned i = 0; i < 100; ++i) --i; 1" |
| timeout_error = "Reached timeout while interpreting expression" |
| options = lldb.SBExpressionOptions() |
| |
| # This is an IRInterpreter specific test, so disable the JIT. |
| options.SetAllowJIT(False) |
| |
| # We use a 500ms timeout. |
| options.SetTimeoutInMicroSeconds(500000) |
| res, duration_sec = self.time_expression(inf_loop, options) |
| self.assertIn(timeout_error, str(res.GetError())) |
| |
| # Depending on the machine load the expression might take quite some |
| # time, so give the time a generous upper bound. |
| self.assertLess(duration_sec, 15) |
| |
| # Try a simple one second timeout. |
| options.SetTimeoutInMicroSeconds(1000000) |
| res, duration_sec = self.time_expression(inf_loop, options) |
| self.assertIn(timeout_error, str(res.GetError())) |
| # Anything within 5% of 1s is fine, to account for machine differences. |
| self.assertGreaterEqual(duration_sec, 0.95) |
| self.assertLess(duration_sec, 30) |
| |
| def test_interpreter_interrupt(self): |
| """Test interrupting the IRInterpreter.""" |
| self.build() |
| self.target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) |
| self.assertTrue(self.target, VALID_TARGET) |
| |
| # A non-trivial infinite loop. |
| inf_loop = "for (unsigned i = 0; i < 100; ++i) --i; 1" |
| |
| options = lldb.SBExpressionOptions() |
| |
| # This is an IRInterpreter specific test, so disable the JIT. |
| options.SetAllowJIT(False) |
| |
| # Make sure we have a pretty long (10s) timeout so we have a chance to |
| # interrupt the interpreted expression. |
| options.SetTimeoutInMicroSeconds(10000000) |
| |
| self.dbg.RequestInterrupt() |
| |
| self.dbg.SetAsync(True) |
| res = self.target.EvaluateExpression(inf_loop, options) |
| self.dbg.SetAsync(False) |
| |
| # Be sure to turn this off again: |
| def cleanup(): |
| if self.dbg.InterruptRequested(): |
| self.dbg.CancelInterruptRequest() |
| |
| self.addTearDownHook(cleanup) |
| |
| interrupt_error = "Interrupted while interpreting expression" |
| self.assertIn(interrupt_error, str(res.GetError())) |
| |
| def setUp(self): |
| # Call super's setUp(). |
| TestBase.setUp(self) |
| # Find the line number to break for main.c. |
| self.line = line_number("main.c", "// Set breakpoint here") |
| |
| # Disable confirmation prompt to avoid infinite wait |
| self.runCmd("settings set auto-confirm true") |
| self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm")) |
| |
| def build_and_run(self): |
| """Test the IR interpreter""" |
| self.build() |
| |
| self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) |
| |
| lldbutil.run_break_set_by_file_and_line( |
| self, "main.c", self.line, num_expected_locations=1, loc_exact=False |
| ) |
| |
| self.runCmd("run", RUN_SUCCEEDED) |
| |
| @expectedFailureAll( |
| oslist=["windows"], |
| bugnumber="llvm.org/pr21765", |
| ) |
| @add_test_categories(["pyapi"]) |
| def test_ir_interpreter(self): |
| self.build_and_run() |
| |
| options = lldb.SBExpressionOptions() |
| options.SetLanguage(lldb.eLanguageTypeC_plus_plus) |
| |
| set_up_expressions = [ |
| "int $i = 9", |
| "int $j = 3", |
| "int $k = 5", |
| "unsigned long long $ull = -1", |
| "unsigned $u = -1", |
| ] |
| |
| expressions = [ |
| "$i + $j", |
| "$i - $j", |
| "$i * $j", |
| "$i / $j", |
| "$i % $k", |
| "$i << $j", |
| "$i & $j", |
| "$i | $j", |
| "$i ^ $j", |
| "($ull & -1) == $u", |
| ] |
| |
| for expression in set_up_expressions: |
| self.frame().EvaluateExpression(expression, options) |
| |
| func_call = "(int)getpid()" |
| if lldbplatformutil.getPlatform() == "windows": |
| func_call = "(int)GetCurrentProcessId()" |
| |
| for expression in expressions: |
| interp_expression = expression |
| jit_expression = func_call + "; " + expression |
| |
| for expression in expressions: |
| interp_expression = expression |
| jit_expression = "(int)getpid(); " + expression |
| |
| interp_result = ( |
| self.frame() |
| .EvaluateExpression(interp_expression, options) |
| .GetValueAsSigned() |
| ) |
| jit_result = ( |
| self.frame() |
| .EvaluateExpression(jit_expression, options) |
| .GetValueAsSigned() |
| ) |
| |
| self.assertEqual( |
| interp_result, jit_result, "While evaluating " + expression |
| ) |
| |
| def test_type_conversions(self): |
| target = self.dbg.GetDummyTarget() |
| short_val = target.EvaluateExpression("(short)-1") |
| self.assertEqual(short_val.GetValueAsSigned(), -1) |
| long_val = target.EvaluateExpression("(long) " + short_val.GetName()) |
| self.assertEqual(long_val.GetValueAsSigned(), -1) |
| |
| def test_fpconv(self): |
| self.build_and_run() |
| |
| interp_options = lldb.SBExpressionOptions() |
| interp_options.SetLanguage(lldb.eLanguageTypeC_plus_plus) |
| interp_options.SetAllowJIT(False) |
| |
| jit_options = lldb.SBExpressionOptions() |
| jit_options.SetLanguage(lldb.eLanguageTypeC_plus_plus) |
| jit_options.SetAllowJIT(True) |
| |
| set_up_expressions = [ |
| "int32_t $i = 3", |
| "int32_t $n = -3", |
| "uint32_t $u = 5", |
| "int64_t $l = -7", |
| "float $f = 9.0625", |
| "double $d = 13.75", |
| "float $nf = -11.25", |
| ] |
| |
| expressions = [ |
| "$i + $f", # sitofp i32 to float |
| "$d - $n", # sitofp i32 to double |
| "$u + $f", # uitofp i32 to float |
| "$u + $d", # uitofp i32 to double |
| "(int32_t)$d", # fptosi double to i32 |
| "(int32_t)$f", # fptosi float to i32 |
| "(int64_t)$d", # fptosi double to i64 |
| "(int16_t)$f", # fptosi float to i16 |
| "(int64_t)$nf", # fptosi float to i64 |
| "(uint16_t)$f", # fptoui float to i16 |
| "(uint32_t)$d", # fptoui double to i32 |
| "(uint64_t)$d", # fptoui double to i64 |
| "(float)$d", # fptrunc double to float |
| "(double)$f", # fpext float to double |
| "(double)$nf", # fpext float to double |
| ] |
| |
| for expression in set_up_expressions: |
| self.frame().EvaluateExpression(expression, interp_options) |
| |
| func_call = "(int)getpid()" |
| if lldbplatformutil.getPlatform() == "windows": |
| func_call = "(int)GetCurrentProcessId()" |
| |
| for expression in expressions: |
| interp_expression = expression |
| # Calling a function forces the expression to be executed with JIT. |
| jit_expression = func_call + "; " + expression |
| |
| interp_result = self.frame().EvaluateExpression( |
| interp_expression, interp_options |
| ) |
| jit_result = self.frame().EvaluateExpression(jit_expression, jit_options) |
| |
| self.assertEqual( |
| interp_result.GetValue(), |
| jit_result.GetValue(), |
| "Values match for " + expression, |
| ) |
| self.assertEqual( |
| interp_result.GetTypeName(), |
| jit_result.GetTypeName(), |
| "Types match for " + expression, |
| ) |
| |
| def test_fpconv_ub(self): |
| target = self.dbg.GetDummyTarget() |
| |
| set_up_expressions = [ |
| "float $f = 3e9", |
| "double $d = 1e20", |
| "float $nf = -1.5", |
| ] |
| |
| expressions = [ |
| ( |
| "(int32_t)$f", |
| "Conversion error: (float) 3.0E+9 cannot be converted to i32", |
| ), |
| ( |
| "(uint32_t)$nf", |
| "Conversion error: (float) -1.5 cannot be converted to unsigned i32", |
| ), |
| ( |
| "(int64_t)$d", |
| "Conversion error: (float) 1.0E+20 cannot be converted to i64", |
| ), |
| ( |
| "(uint64_t)$d", |
| "Conversion error: (float) 1.0E+20 cannot be converted to unsigned i64", |
| ), |
| ] |
| |
| for expression in set_up_expressions: |
| target.EvaluateExpression(expression) |
| |
| # The IR Interpreter returns an error if a value cannot be converted. |
| for expression in expressions: |
| result = target.EvaluateExpression(expression[0]) |
| self.assertIn(expression[1], str(result.GetError())) |
| |
| # The conversion should succeed if the destination type can represent the result. |
| self.expect_expr( |
| "(uint32_t)$f", result_type="uint32_t", result_value="3000000000" |
| ) |
| self.expect_expr("(int32_t)$nf", result_type="int32_t", result_value="-1") |
