2c2eb5e670
The new FreeBSDRemote plugin has reached feature parity on i386 and amd64 targets. Use it by default on these architectures, while allowing the use of the legacy plugin via FREEBSD_LEGACY_PLUGIN envvar. Revisit the method of switching plugins. Apparently, the return value of PlatformFreeBSD::CanDebugProcess() is what really decides whether the legacy or the new plugin is used. Update the test status. Reenable the tests that were previously disabled on FreeBSD and do not cause hangs or are irrelevant to FreeBSD. Mark all tests that fail reliably as expectedFailure. For now, tests that are flaky (i.e. produce unstable results) are left enabled and cause unpredictable test failures. Differential Revision: https://reviews.llvm.org/D90757
296 lines
9.7 KiB
Python
296 lines
9.7 KiB
Python
"""
|
|
Test using LLDB data formatters with frozen objects coming from the expression parser.
|
|
"""
|
|
|
|
|
|
|
|
import lldb
|
|
from lldbsuite.test.decorators import *
|
|
from lldbsuite.test.lldbtest import *
|
|
from lldbsuite.test import lldbutil
|
|
|
|
|
|
class ExprFormattersTestCase(TestBase):
|
|
|
|
mydir = TestBase.compute_mydir(__file__)
|
|
|
|
def setUp(self):
|
|
# Call super's setUp().
|
|
TestBase.setUp(self)
|
|
# Find the line number to break for main.cpp.
|
|
self.line = line_number('main.cpp',
|
|
'// Stop here')
|
|
|
|
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
|
|
@skipIfTargetAndroid() # skipping to avoid crashing the test runner
|
|
@expectedFailureAndroid('llvm.org/pr24691') # we hit an assertion in clang
|
|
def test(self):
|
|
"""Test expr + formatters for good interoperability."""
|
|
self.build()
|
|
|
|
# This is the function to remove the custom formats in order to have a
|
|
# clean slate for the next test case.
|
|
def cleanup():
|
|
self.runCmd('type summary clear', check=False)
|
|
self.runCmd('type synthetic clear', check=False)
|
|
|
|
# Execute the cleanup function during test case tear down.
|
|
self.addTearDownHook(cleanup)
|
|
|
|
"""Test expr + formatters for good interoperability."""
|
|
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
|
|
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self, "main.cpp", self.line, loc_exact=True)
|
|
|
|
self.runCmd("run", RUN_SUCCEEDED)
|
|
self.runCmd("command script import formatters.py")
|
|
self.runCmd("command script import foosynth.py")
|
|
|
|
if self.TraceOn():
|
|
self.runCmd("frame variable foo1 --show-types")
|
|
self.runCmd("frame variable foo1.b --show-types")
|
|
self.runCmd("frame variable foo1.b.b_ref --show-types")
|
|
|
|
self.filecheck("expression --show-types -- *(new_foo(47))", __file__,
|
|
'-check-prefix=EXPR-TYPES-NEW-FOO')
|
|
# EXPR-TYPES-NEW-FOO: (foo) ${{.*}} = {
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (int) a = 47
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (int *) a_ptr = 0x
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (bar) b = {
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (int) i = 94
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (int *) i_ptr = 0x
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (baz) b = {
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (int) h = 97
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (int) k = 99
|
|
# EXPR-TYPES-NEW-FOO-NEXT: }
|
|
# EXPR-TYPES-NEW-FOO-NEXT: (baz &) b_ref = 0x
|
|
# EXPR-TYPES-NEW-FOO-NEXT: }
|
|
# EXPR-TYPES-NEW-FOO-NEXT: }
|
|
|
|
|
|
self.runCmd("type summary add -F formatters.foo_SummaryProvider3 foo")
|
|
self.filecheck("expression foo1", __file__, '-check-prefix=EXPR-FOO1opts')
|
|
# EXPR-FOO1opts: (foo) $
|
|
# EXPR-FOO1opts-SAME: a = 12
|
|
# EXPR-FOO1opts-SAME: a_ptr = {{[0-9]+}} -> 13
|
|
# EXPR-FOO1opts-SAME: i = 24
|
|
# EXPR-FOO1opts-SAME: i_ptr = {{[0-9]+}} -> 25
|
|
# EXPR-FOO1opts-SAME: b_ref = {{[0-9]+}}
|
|
# EXPR-FOO1opts-SAME: h = 27
|
|
# EXPR-FOO1opts-SAME: k = 29
|
|
# EXPR-FOO1opts-SAME: WITH_OPTS
|
|
|
|
self.runCmd("type summary delete foo")
|
|
|
|
self.runCmd("type summary add -F formatters.foo_SummaryProvider foo")
|
|
|
|
self.expect("expression new_int(12)",
|
|
substrs=['(int *) $', ' = 0x'])
|
|
|
|
self.runCmd(
|
|
"type summary add -s \"${var%pointer} -> ${*var%decimal}\" \"int *\"")
|
|
|
|
self.expect("expression new_int(12)",
|
|
substrs=['(int *) $', '= 0x', ' -> 12'])
|
|
|
|
self.expect("expression foo1.a_ptr",
|
|
substrs=['(int *) $', '= 0x', ' -> 13'])
|
|
|
|
self.filecheck("expression foo1", __file__, '-check-prefix=EXPR-FOO1')
|
|
# EXPR-FOO1: (foo) $
|
|
# EXPR-FOO1-SAME: a = 12
|
|
# EXPR-FOO1-SAME: a_ptr = {{[0-9]+}} -> 13
|
|
# EXPR-FOO1-SAME: i = 24
|
|
# EXPR-FOO1-SAME: i_ptr = {{[0-9]+}} -> 25
|
|
# EXPR-FOO1-SAME: b_ref = {{[0-9]+}}
|
|
# EXPR-FOO1-SAME: h = 27
|
|
# EXPR-FOO1-SAME: k = 29
|
|
|
|
self.filecheck("expression --ptr-depth=1 -- new_foo(47)", __file__,
|
|
'-check-prefix=EXPR-PTR-DEPTH1')
|
|
# EXPR-PTR-DEPTH1: (foo *) $
|
|
# EXPR-PTR-DEPTH1-SAME: a = 47
|
|
# EXPR-PTR-DEPTH1-SAME: a_ptr = {{[0-9]+}} -> 48
|
|
# EXPR-PTR-DEPTH1-SAME: i = 94
|
|
# EXPR-PTR-DEPTH1-SAME: i_ptr = {{[0-9]+}} -> 95
|
|
|
|
self.filecheck("expression foo2", __file__, '-check-prefix=EXPR-FOO2')
|
|
# EXPR-FOO2: (foo) $
|
|
# EXPR-FOO2-SAME: a = 121
|
|
# EXPR-FOO2-SAME: a_ptr = {{[0-9]+}} -> 122
|
|
# EXPR-FOO2-SAME: i = 242
|
|
# EXPR-FOO2-SAME: i_ptr = {{[0-9]+}} -> 243
|
|
# EXPR-FOO2-SAME: h = 245
|
|
# EXPR-FOO2-SAME: k = 247
|
|
|
|
object_name = self.res.GetOutput()
|
|
object_name = object_name[7:]
|
|
object_name = object_name[0:object_name.find(' =')]
|
|
|
|
self.filecheck("frame variable foo2", __file__, '-check-prefix=VAR-FOO2')
|
|
# VAR-FOO2: (foo) foo2
|
|
# VAR-FOO2-SAME: a = 121
|
|
# VAR-FOO2-SAME: a_ptr = {{[0-9]+}} -> 122
|
|
# VAR-FOO2-SAME: i = 242
|
|
# VAR-FOO2-SAME: i_ptr = {{[0-9]+}} -> 243
|
|
# VAR-FOO2-SAME: h = 245
|
|
# VAR-FOO2-SAME: k = 247
|
|
|
|
# The object is the same as foo2, so use the EXPR-FOO2 checks.
|
|
self.filecheck("expression $" + object_name, __file__,
|
|
'-check-prefix=EXPR-FOO2')
|
|
|
|
self.runCmd("type summary delete foo")
|
|
self.runCmd(
|
|
"type synthetic add --python-class foosynth.FooSyntheticProvider foo")
|
|
|
|
self.expect("expression --show-types -- $" + object_name,
|
|
substrs=['(foo) $', ' = {', '(int) *i_ptr = 243'])
|
|
|
|
self.runCmd("n")
|
|
self.runCmd("n")
|
|
|
|
self.runCmd("type synthetic delete foo")
|
|
self.runCmd("type summary add -F formatters.foo_SummaryProvider foo")
|
|
|
|
self.expect(
|
|
"expression foo2",
|
|
substrs=[
|
|
'(foo) $',
|
|
'a = 7777',
|
|
'a_ptr = ',
|
|
' -> 122',
|
|
'i = 242',
|
|
'i_ptr = ',
|
|
' -> 8888'])
|
|
|
|
self.expect("expression $" + object_name + '.a',
|
|
substrs=['7777'])
|
|
|
|
self.expect("expression *$" + object_name + '.b.i_ptr',
|
|
substrs=['8888'])
|
|
|
|
self.expect(
|
|
"expression $" +
|
|
object_name,
|
|
substrs=[
|
|
'(foo) $',
|
|
'a = 121',
|
|
'a_ptr = ',
|
|
' -> 122',
|
|
'i = 242',
|
|
'i_ptr = ',
|
|
' -> 8888',
|
|
'h = 245',
|
|
'k = 247'])
|
|
|
|
self.runCmd("type summary delete foo")
|
|
self.runCmd(
|
|
"type synthetic add --python-class foosynth.FooSyntheticProvider foo")
|
|
|
|
self.expect("expression --show-types -- $" + object_name,
|
|
substrs=['(foo) $', ' = {', '(int) *i_ptr = 8888'])
|
|
|
|
self.runCmd("n")
|
|
|
|
self.runCmd("type synthetic delete foo")
|
|
self.runCmd("type summary add -F formatters.foo_SummaryProvider foo")
|
|
|
|
self.expect(
|
|
"expression $" +
|
|
object_name,
|
|
substrs=[
|
|
'(foo) $',
|
|
'a = 121',
|
|
'a_ptr = ',
|
|
' -> 122',
|
|
'i = 242',
|
|
'i_ptr = ',
|
|
' -> 8888',
|
|
'k = 247'])
|
|
|
|
process = self.dbg.GetSelectedTarget().GetProcess()
|
|
thread = process.GetThreadAtIndex(0)
|
|
frame = thread.GetSelectedFrame()
|
|
|
|
frozen = frame.EvaluateExpression("$" + object_name + ".a_ptr")
|
|
|
|
a_data = frozen.GetPointeeData()
|
|
|
|
error = lldb.SBError()
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
0) == 122,
|
|
'*a_ptr = 122')
|
|
|
|
ret = line_number("main.cpp", "Done initializing")
|
|
self.runCmd("thread until " + str(ret))
|
|
|
|
self.expect("frame variable numbers",
|
|
substrs=['1', '2', '3', '4', '5'])
|
|
|
|
self.expect("expression numbers",
|
|
substrs=['1', '2', '3', '4', '5'])
|
|
|
|
frozen = frame.EvaluateExpression("&numbers")
|
|
|
|
a_data = frozen.GetPointeeData(0, 1)
|
|
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
0) == 1,
|
|
'numbers[0] == 1')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
4) == 2,
|
|
'numbers[1] == 2')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
8) == 3,
|
|
'numbers[2] == 3')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
12) == 4,
|
|
'numbers[3] == 4')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
16) == 5,
|
|
'numbers[4] == 5')
|
|
|
|
frozen = frame.EvaluateExpression("numbers")
|
|
|
|
a_data = frozen.GetData()
|
|
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
0) == 1,
|
|
'numbers[0] == 1')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
4) == 2,
|
|
'numbers[1] == 2')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
8) == 3,
|
|
'numbers[2] == 3')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
12) == 4,
|
|
'numbers[3] == 4')
|
|
self.assertTrue(
|
|
a_data.GetUnsignedInt32(
|
|
error,
|
|
16) == 5,
|
|
'numbers[4] == 5')
|