mirror of
https://github.com/llvm/llvm-project.git
synced 2025-05-03 08:16:06 +00:00
263 lines
9.9 KiB
Python
263 lines
9.9 KiB
Python
"""
|
|
Test SBAddressRange APIs.
|
|
"""
|
|
|
|
import lldb
|
|
from lldbsuite.test.lldbtest import *
|
|
|
|
|
|
class AddressRangeTestCase(TestBase):
|
|
NO_DEBUG_INFO_TESTCASE = True
|
|
|
|
def setUp(self):
|
|
TestBase.setUp(self)
|
|
|
|
self.build()
|
|
exe = self.getBuildArtifact("a.out")
|
|
|
|
self.target = self.dbg.CreateTarget(exe)
|
|
self.assertTrue(self.target, VALID_TARGET)
|
|
self.launch_info = self.target.GetLaunchInfo()
|
|
self.launch_info.SetWorkingDirectory(self.get_process_working_directory())
|
|
|
|
self.bp1 = self.target.BreakpointCreateByName("main", "a.out")
|
|
self.bp2 = self.target.BreakpointCreateByName("foo", "a.out")
|
|
self.bp3 = self.target.BreakpointCreateByName("bar", "a.out")
|
|
|
|
self.assertTrue(self.bp1.IsValid())
|
|
self.assertTrue(self.bp2.IsValid())
|
|
self.assertTrue(self.bp3.IsValid())
|
|
|
|
self.addr1 = self.bp1.GetLocationAtIndex(0).GetAddress()
|
|
self.addr2 = self.bp2.GetLocationAtIndex(0).GetAddress()
|
|
self.addr3 = self.bp3.GetLocationAtIndex(0).GetAddress()
|
|
|
|
self.assertTrue(self.addr1.IsValid())
|
|
self.assertTrue(self.addr2.IsValid())
|
|
self.assertTrue(self.addr3.IsValid())
|
|
|
|
def test_address_range_default(self):
|
|
"""Testing default constructor."""
|
|
empty_range = lldb.SBAddressRange()
|
|
self.assertEqual(empty_range.IsValid(), False)
|
|
|
|
def test_address_range_construction(self):
|
|
"""Make sure the construction and getters work."""
|
|
range = lldb.SBAddressRange(self.addr1, 8)
|
|
self.assertEqual(range.IsValid(), True)
|
|
self.assertEqual(range.GetBaseAddress(), self.addr1)
|
|
self.assertEqual(range.GetByteSize(), 8)
|
|
|
|
def test_address_range_clear(self):
|
|
"""Make sure the clear method works."""
|
|
range = lldb.SBAddressRange(self.addr1, 8)
|
|
self.assertEqual(range.IsValid(), True)
|
|
self.assertEqual(range.GetBaseAddress(), self.addr1)
|
|
self.assertEqual(range.GetByteSize(), 8)
|
|
|
|
range.Clear()
|
|
self.assertEqual(range.IsValid(), False)
|
|
|
|
def test_function(self):
|
|
"""Make sure the range works in SBFunction APIs."""
|
|
|
|
# Setup breakpoints in main
|
|
loc = self.bp1.GetLocationAtIndex(0)
|
|
loc_addr = loc.GetAddress()
|
|
func = loc_addr.GetFunction()
|
|
ranges = func.GetRanges()
|
|
self.assertEqual(ranges.GetSize(), 1)
|
|
|
|
range = ranges.GetAddressRangeAtIndex(0)
|
|
self.assertEqual(
|
|
range.GetByteSize(),
|
|
func.GetEndAddress().GetOffset() - func.GetStartAddress().GetOffset(),
|
|
)
|
|
self.assertEqual(
|
|
range.GetBaseAddress().GetOffset(),
|
|
func.GetStartAddress().GetOffset(),
|
|
)
|
|
|
|
def test_block(self):
|
|
"""Make sure the range works in SBBlock APIs."""
|
|
loc = self.bp1.GetLocationAtIndex(0)
|
|
loc_addr = loc.GetAddress()
|
|
block = loc_addr.GetBlock()
|
|
|
|
ranges = block.GetRanges()
|
|
self.assertEqual(ranges.GetSize(), 1)
|
|
|
|
range = ranges.GetAddressRangeAtIndex(0)
|
|
self.assertEqual(
|
|
range.GetByteSize(),
|
|
block.GetRangeEndAddress(0).GetOffset()
|
|
- block.GetRangeStartAddress(0).GetOffset(),
|
|
)
|
|
self.assertEqual(
|
|
range.GetBaseAddress().GetOffset(),
|
|
block.GetRangeStartAddress(0).GetOffset(),
|
|
)
|
|
|
|
def test_address_range_list(self):
|
|
"""Make sure the SBAddressRangeList works by adding and getting ranges."""
|
|
range1 = lldb.SBAddressRange(self.addr1, 8)
|
|
range2 = lldb.SBAddressRange(self.addr2, 16)
|
|
range3 = lldb.SBAddressRange(self.addr3, 32)
|
|
|
|
range_list = lldb.SBAddressRangeList()
|
|
self.assertEqual(range_list.GetSize(), 0)
|
|
|
|
range_list.Append(range1)
|
|
range_list.Append(range2)
|
|
range_list.Append(range3)
|
|
self.assertEqual(range_list.GetSize(), 3)
|
|
self.assertRaises(IndexError, lambda: range_list[3])
|
|
|
|
range1_copy = range_list.GetAddressRangeAtIndex(0)
|
|
self.assertEqual(range1.GetByteSize(), range1_copy.GetByteSize())
|
|
self.assertEqual(
|
|
range1.GetBaseAddress().GetOffset(),
|
|
range1_copy.GetBaseAddress().GetOffset(),
|
|
)
|
|
|
|
range2_copy = range_list.GetAddressRangeAtIndex(1)
|
|
self.assertEqual(range2.GetByteSize(), range2_copy.GetByteSize())
|
|
self.assertEqual(
|
|
range2.GetBaseAddress().GetOffset(),
|
|
range2_copy.GetBaseAddress().GetOffset(),
|
|
)
|
|
|
|
range3_copy = range_list.GetAddressRangeAtIndex(2)
|
|
self.assertEqual(range3.GetByteSize(), range3_copy.GetByteSize())
|
|
self.assertEqual(
|
|
range3.GetBaseAddress().GetOffset(),
|
|
range3_copy.GetBaseAddress().GetOffset(),
|
|
)
|
|
|
|
range_list.Clear()
|
|
self.assertEqual(range_list.GetSize(), 0)
|
|
|
|
def test_address_range_list_len(self):
|
|
"""Make sure the len() operator works."""
|
|
range = lldb.SBAddressRange(self.addr1, 8)
|
|
|
|
range_list = lldb.SBAddressRangeList()
|
|
self.assertEqual(len(range_list), 0)
|
|
|
|
range_list.Append(range)
|
|
self.assertEqual(len(range_list), 1)
|
|
|
|
def test_address_range_list_iterator(self):
|
|
"""Make sure the SBAddressRangeList iterator works."""
|
|
range1 = lldb.SBAddressRange(self.addr1, 8)
|
|
range2 = lldb.SBAddressRange(self.addr2, 16)
|
|
range3 = lldb.SBAddressRange(self.addr3, 32)
|
|
|
|
range_list = lldb.SBAddressRangeList()
|
|
range_list.Append(range1)
|
|
range_list.Append(range2)
|
|
range_list.Append(range3)
|
|
self.assertEqual(range_list.GetSize(), 3)
|
|
|
|
# Test the iterator
|
|
for range in range_list:
|
|
self.assertTrue(range.IsValid())
|
|
|
|
def test_address_range_print_invalid(self):
|
|
"""Make sure the SBAddressRange can be printed when invalid."""
|
|
range = lldb.SBAddressRange()
|
|
self.assertEqual(str(range), "[0xffffffffffffffff-0xffffffffffffffff)")
|
|
|
|
def test_address_range_print_resolved(self):
|
|
"""Make sure the SBAddressRange can be printed when resolved."""
|
|
lldb.target = self.target
|
|
error = lldb.SBError()
|
|
process = self.target.Launch(self.launch_info, error)
|
|
self.assertTrue(error.Success(), "Make sure process launched successfully")
|
|
self.assertTrue(process, PROCESS_IS_VALID)
|
|
self.assertState(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
|
|
script = (
|
|
"script "
|
|
+ "bp = lldb.target.GetBreakpointAtIndex(0);"
|
|
+ "loc = bp.GetLocationAtIndex(0);"
|
|
+ "loc_addr = loc.GetAddress();"
|
|
+ "func = loc_addr.GetFunction();"
|
|
+ "range = func.GetRanges().GetAddressRangeAtIndex(0);"
|
|
+ "print(range)"
|
|
)
|
|
|
|
interp = self.dbg.GetCommandInterpreter()
|
|
result = lldb.SBCommandReturnObject()
|
|
interp.HandleCommand(script, result, False)
|
|
self.assertTrue(result.Succeeded(), "script command succeeded")
|
|
# [0x1000-0x2000] // Resolved with target or addresses without sections
|
|
self.assertRegex(result.GetOutput(), "^\[0x[0-9a-f]+\-0x[0-9a-f]+\)")
|
|
process.Kill()
|
|
|
|
def test_address_range_print_no_section_resolved(self):
|
|
"""Make sure the SBAddressRange can be printed with no secion."""
|
|
lldb.target = self.target
|
|
error = lldb.SBError()
|
|
process = self.target.Launch(self.launch_info, error)
|
|
self.assertTrue(error.Success(), "Make sure process launched successfully")
|
|
self.assertTrue(process, PROCESS_IS_VALID)
|
|
self.assertState(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
|
|
|
|
loc = self.bp1.GetLocationAtIndex(0)
|
|
loc_addr = loc.GetAddress()
|
|
func = loc_addr.GetFunction()
|
|
range = func.GetRanges().GetAddressRangeAtIndex(0)
|
|
|
|
addr = lldb.SBAddress()
|
|
addr.SetAddress(lldb.SBSection(), range.GetBaseAddress().GetOffset())
|
|
self.assertFalse(addr.GetSection().IsValid())
|
|
range = lldb.SBAddressRange(addr, range.GetByteSize())
|
|
|
|
range_str = str(range)
|
|
# [0x1000-0x2000] // Resolved with target or addresses without sections
|
|
self.assertRegex(range_str, "^\[0x[0-9a-f]+\-0x[0-9a-f]+\)$")
|
|
process.Kill()
|
|
|
|
def test_address_range_print_not_resolved(self):
|
|
"""Make sure the SBAddressRange can be printed when not resolved."""
|
|
range = lldb.SBAddressRange(self.addr1, 8)
|
|
range_str = str(range)
|
|
# a.out[0x1000-0x2000] // Without target
|
|
self.assertRegex(range_str, "^a.out\[0x[0-9a-f]+\-0x[0-9a-f]+\)$")
|
|
|
|
def test_address_range_list_print(self):
|
|
"""Make sure the SBAddressRangeList can be printed."""
|
|
range1 = lldb.SBAddressRange(self.addr1, 8)
|
|
range2 = lldb.SBAddressRange(self.addr2, 16)
|
|
range3 = lldb.SBAddressRange(self.addr3, 32)
|
|
self.dbg.SetAsync(True)
|
|
|
|
range_list = lldb.SBAddressRangeList()
|
|
self.assertEqual(range_list.GetSize(), 0)
|
|
|
|
range_list.Append(range1)
|
|
range_list.Append(range2)
|
|
range_list.Append(range3)
|
|
self.assertEqual(range_list.GetSize(), 3)
|
|
|
|
range_list_str = str(range_list)
|
|
self.assertTrue(range_list_str.startswith("["))
|
|
self.assertGreater(range_list_str.count(","), 1)
|
|
self.assertTrue(range_list_str.endswith("]"))
|
|
|
|
def test_address_range_list_indexing(self):
|
|
"""Make sure the SBAddressRangeList can be printed."""
|
|
range1 = lldb.SBAddressRange(self.addr1, 8)
|
|
range2 = lldb.SBAddressRange(self.addr2, 16)
|
|
range_list = lldb.SBAddressRangeList()
|
|
range_list.Append(range1)
|
|
range_list.Append(range2)
|
|
|
|
self.assertEqual(range_list.GetSize(), 2)
|
|
self.assertRaises(IndexError, lambda: range_list[2])
|
|
self.assertRaises(TypeError, lambda: range_list["0"])
|
|
self.assertEqual(range_list[0], range1)
|
|
self.assertEqual(range_list[1], range2)
|
|
self.assertEqual(range_list[-1], range2)
|
|
self.assertEqual(range_list[-2], range1)
|