e0a9be9f41
This reapplies #175292 with the fixed test. The original test used integer types with different bit widths on different platforms. ----- Original message: This allows expressions that use these conversions to be executed when JIT is not available.
284 lines
9.5 KiB
Python
284 lines
9.5 KiB
Python
"""
|
|
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")
|