| """Test the SBData APIs.""" |
| |
| |
| from math import fabs |
| import lldb |
| from lldbsuite.test.decorators import * |
| from lldbsuite.test.lldbtest import * |
| from lldbsuite.test import lldbutil |
| |
| |
| class SBDataAPICase(TestBase): |
| NO_DEBUG_INFO_TESTCASE = True |
| |
| def setUp(self): |
| # Call super's setUp(). |
| TestBase.setUp(self) |
| # Find the line number to break on inside main.cpp. |
| self.line = line_number("main.cpp", "// set breakpoint here") |
| |
| def test_byte_order_and_address_byte_size(self): |
| """Test the SBData::SetData() to ensure the byte order and address |
| byte size are obeyed""" |
| addr_data = b"\x11\x22\x33\x44\x55\x66\x77\x88" |
| error = lldb.SBError() |
| data = lldb.SBData() |
| data.SetData(error, addr_data, lldb.eByteOrderBig, 4) |
| addr = data.GetAddress(error, 0) |
| self.assertEqual(addr, 0x11223344) |
| data.SetData(error, addr_data, lldb.eByteOrderBig, 8) |
| addr = data.GetAddress(error, 0) |
| self.assertEqual(addr, 0x1122334455667788) |
| data.SetData(error, addr_data, lldb.eByteOrderLittle, 4) |
| addr = data.GetAddress(error, 0) |
| self.assertEqual(addr, 0x44332211) |
| data.SetData(error, addr_data, lldb.eByteOrderLittle, 8) |
| addr = data.GetAddress(error, 0) |
| self.assertEqual(addr, 0x8877665544332211) |
| |
| def test_byte_order_and_address_byte_size_with_ownership(self): |
| """Test the SBData::SetDataWithOwnership() to ensure the byte order |
| and address byte size are obeyed even when source date is released""" |
| addr_data = b"\x11\x22\x33\x44\x55\x66\x77\x88" |
| error = lldb.SBError() |
| data = lldb.SBData() |
| data.SetDataWithOwnership(error, addr_data, lldb.eByteOrderBig, 8) |
| del addr_data |
| addr = data.GetAddress(error, 0) |
| self.assertEqual(addr, 0x1122334455667788) |
| |
| def test_with_run_command(self): |
| """Test the SBData APIs.""" |
| self.build() |
| self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) |
| |
| lldbutil.run_break_set_by_file_and_line( |
| self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True |
| ) |
| |
| 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"], |
| ) |
| |
| target = self.dbg.GetSelectedTarget() |
| |
| process = target.GetProcess() |
| |
| thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint) |
| self.assertIsNotNone(thread) |
| |
| frame = thread.GetSelectedFrame() |
| foobar = frame.FindVariable("foobar") |
| self.assertTrue(foobar.IsValid()) |
| data = foobar.GetPointeeData(0, 2) |
| offset = 0 |
| error = lldb.SBError() |
| |
| self.assert_data(data.GetUnsignedInt32, offset, 1) |
| offset += 4 |
| low = data.GetSignedInt16(error, offset) |
| self.assertSuccess(error) |
| offset += 2 |
| high = data.GetSignedInt16(error, offset) |
| self.assertSuccess(error) |
| offset += 2 |
| self.assertTrue( |
| (low == 9 and high == 0) or (low == 0 and high == 9), "foo[0].b == 9" |
| ) |
| self.assertTrue( |
| fabs(data.GetFloat(error, offset) - 3.14) < 1, "foo[0].c == 3.14" |
| ) |
| self.assertSuccess(error) |
| offset += 4 |
| self.assert_data(data.GetUnsignedInt32, offset, 8) |
| offset += 4 |
| self.assert_data(data.GetUnsignedInt32, offset, 5) |
| offset += 4 |
| |
| self.runCmd("n") |
| |
| offset = 16 |
| |
| self.assert_data(data.GetUnsignedInt32, offset, 5) |
| |
| data = foobar.GetPointeeData(1, 1) |
| |
| offset = 0 |
| |
| self.assert_data(data.GetSignedInt32, offset, 8) |
| offset += 4 |
| self.assert_data(data.GetSignedInt32, offset, 7) |
| offset += 8 |
| self.assertEqual( |
| data.GetUnsignedInt32(error, offset), 0, "do not read beyond end" |
| ) |
| self.assertTrue(not error.Success()) |
| error.Clear() # clear the error for the next test |
| |
| star_foobar = foobar.Dereference() |
| self.assertTrue(star_foobar.IsValid()) |
| |
| data = star_foobar.GetData() |
| |
| offset = 0 |
| self.assert_data(data.GetUnsignedInt32, offset, 1) |
| offset += 4 |
| self.assert_data(data.GetUnsignedInt32, offset, 9) |
| |
| foobar_addr = star_foobar.GetLoadAddress() |
| foobar_addr += 12 |
| |
| # http://llvm.org/bugs/show_bug.cgi?id=11579 |
| # lldb::SBValue::CreateValueFromAddress does not verify SBType::GetPointerType succeeds |
| # This should not crash LLDB. |
| nothing = foobar.CreateValueFromAddress( |
| "nothing", |
| foobar_addr, |
| star_foobar.GetType().GetBasicType(lldb.eBasicTypeInvalid), |
| ) |
| |
| new_foobar = foobar.CreateValueFromAddress( |
| "f00", foobar_addr, star_foobar.GetType() |
| ) |
| self.assertTrue(new_foobar.IsValid()) |
| data = new_foobar.GetData() |
| |
| self.assertEqual(data.uint32[0], 8, "then foo[1].a == 8") |
| self.assertEqual(data.uint32[1], 7, "then foo[1].b == 7") |
| # exploiting that sizeof(uint32) == sizeof(float) |
| self.assertTrue(fabs(data.float[2] - 3.14) < 1, "foo[1].c == 3.14") |
| |
| self.runCmd("n") |
| |
| offset = 0 |
| self.assert_data(data.GetUnsignedInt32, offset, 8) |
| offset += 4 |
| self.assert_data(data.GetUnsignedInt32, offset, 7) |
| offset += 4 |
| self.assertTrue( |
| fabs(data.GetFloat(error, offset) - 3.14) < 1, "foo[1].c == 3.14" |
| ) |
| self.assertSuccess(error) |
| |
| data = new_foobar.GetData() |
| |
| offset = 0 |
| self.assert_data(data.GetUnsignedInt32, offset, 8) |
| offset += 4 |
| self.assert_data(data.GetUnsignedInt32, offset, 7) |
| offset += 4 |
| self.assertTrue( |
| fabs(data.GetFloat(error, offset) - 6.28) < 1, "foo[1].c == 6.28" |
| ) |
| self.assertSuccess(error) |
| |
| self.runCmd("n") |
| |
| barfoo = frame.FindVariable("barfoo") |
| |
| data = barfoo.GetData() |
| offset = 0 |
| self.assert_data(data.GetUnsignedInt32, offset, 1) |
| offset += 4 |
| self.assert_data(data.GetUnsignedInt32, offset, 2) |
| offset += 4 |
| self.assertTrue(fabs(data.GetFloat(error, offset) - 3) < 1, "barfoo[0].c == 3") |
| self.assertSuccess(error) |
| offset += 4 |
| self.assert_data(data.GetUnsignedInt32, offset, 4) |
| offset += 4 |
| self.assert_data(data.GetUnsignedInt32, offset, 5) |
| offset += 4 |
| self.assertTrue(fabs(data.GetFloat(error, offset) - 6) < 1, "barfoo[1].c == 6") |
| self.assertSuccess(error) |
| |
| new_object = barfoo.CreateValueFromData( |
| "new_object", data, barfoo.GetType().GetBasicType(lldb.eBasicTypeInt) |
| ) |
| self.assertEqual(new_object.GetValue(), "1", "new_object == 1") |
| |
| if data.GetByteOrder() == lldb.eByteOrderBig: |
| data.SetData( |
| error, "\0\0\0A", data.GetByteOrder(), data.GetAddressByteSize() |
| ) |
| else: |
| data.SetData( |
| error, "A\0\0\0", data.GetByteOrder(), data.GetAddressByteSize() |
| ) |
| self.assertSuccess(error) |
| |
| data2 = lldb.SBData() |
| data2.SetData(error, "BCD", data.GetByteOrder(), data.GetAddressByteSize()) |
| self.assertSuccess(error) |
| |
| data.Append(data2) |
| |
| # this breaks on EBCDIC |
| offset = 0 |
| self.assert_data(data.GetUnsignedInt32, offset, 65) |
| offset += 4 |
| self.assert_data(data.GetUnsignedInt8, offset, 66) |
| offset += 1 |
| self.assert_data(data.GetUnsignedInt8, offset, 67) |
| offset += 1 |
| self.assert_data(data.GetUnsignedInt8, offset, 68) |
| offset += 1 |
| |
| # check the new API calls introduced per LLVM llvm.org/prenhancement request |
| # 11619 (Allow creating SBData values from arrays or primitives in |
| # Python) |
| |
| hello_str = "hello!" |
| data2 = lldb.SBData.CreateDataFromCString( |
| process.GetByteOrder(), process.GetAddressByteSize(), hello_str |
| ) |
| self.assertEqual(len(data2.uint8), len(hello_str)) |
| self.assertEqual(data2.uint8[0], 104, "h == 104") |
| self.assertEqual(data2.uint8[1], 101, "e == 101") |
| self.assertEqual(data2.uint8[2], 108, "l == 108") |
| self.assert_data(data2.GetUnsignedInt8, 3, 108) # l |
| self.assertEqual(data2.uint8[4], 111, "o == 111") |
| self.assert_data(data2.GetUnsignedInt8, 5, 33) # ! |
| |
| uint_lists = [[1, 2, 3, 4, 5], [int(i) for i in [1, 2, 3, 4, 5]]] |
| int_lists = [[2, -2], [int(i) for i in [2, -2]]] |
| |
| for l in uint_lists: |
| data2 = lldb.SBData.CreateDataFromUInt64Array( |
| process.GetByteOrder(), process.GetAddressByteSize(), l |
| ) |
| self.assert_data(data2.GetUnsignedInt64, 0, 1) |
| self.assert_data(data2.GetUnsignedInt64, 8, 2) |
| self.assert_data(data2.GetUnsignedInt64, 16, 3) |
| self.assert_data(data2.GetUnsignedInt64, 24, 4) |
| self.assert_data(data2.GetUnsignedInt64, 32, 5) |
| |
| self.assertEqual( |
| data2.uint64s, |
| [1, 2, 3, 4, 5], |
| "read_data_helper failure: data2 == [1,2,3,4,5]", |
| ) |
| |
| for l in int_lists: |
| data2 = lldb.SBData.CreateDataFromSInt32Array( |
| process.GetByteOrder(), process.GetAddressByteSize(), l |
| ) |
| self.assertEqual(data2.sint32[0:2], [2, -2], "signed32 data2 = [2,-2]") |
| |
| data2.Append( |
| lldb.SBData.CreateDataFromSInt64Array( |
| process.GetByteOrder(), process.GetAddressByteSize(), int_lists[0] |
| ) |
| ) |
| self.assert_data(data2.GetSignedInt32, 0, 2) |
| self.assert_data(data2.GetSignedInt32, 4, -2) |
| self.assertEqual(data2.sint64[1:3], [2, -2], "signed64 data2 = [2,-2]") |
| |
| for l in int_lists: |
| data2 = lldb.SBData.CreateDataFromSInt64Array( |
| process.GetByteOrder(), process.GetAddressByteSize(), l |
| ) |
| self.assert_data(data2.GetSignedInt64, 0, 2) |
| self.assert_data(data2.GetSignedInt64, 8, -2) |
| self.assertEqual(data2.sint64[0:2], [2, -2], "signed64 data2 = [2,-2]") |
| |
| for l in uint_lists: |
| data2 = lldb.SBData.CreateDataFromUInt32Array( |
| process.GetByteOrder(), process.GetAddressByteSize(), l |
| ) |
| self.assert_data(data2.GetUnsignedInt32, 0, 1) |
| self.assert_data(data2.GetUnsignedInt32, 4, 2) |
| self.assert_data(data2.GetUnsignedInt32, 8, 3) |
| self.assert_data(data2.GetUnsignedInt32, 12, 4) |
| self.assert_data(data2.GetUnsignedInt32, 16, 5) |
| |
| bool_list = [True, True, False, False, True, False] |
| |
| data2 = lldb.SBData.CreateDataFromSInt32Array( |
| process.GetByteOrder(), process.GetAddressByteSize(), bool_list |
| ) |
| self.assertEqual( |
| data2.sint32[0:6], [1, 1, 0, 0, 1, 0], "signed32 data2 = [1, 1, 0, 0, 1, 0]" |
| ) |
| |
| data2 = lldb.SBData.CreateDataFromUInt32Array( |
| process.GetByteOrder(), process.GetAddressByteSize(), bool_list |
| ) |
| self.assertEqual( |
| data2.uint32[0:6], |
| [1, 1, 0, 0, 1, 0], |
| "unsigned32 data2 = [1, 1, 0, 0, 1, 0]", |
| ) |
| |
| data2 = lldb.SBData.CreateDataFromSInt64Array( |
| process.GetByteOrder(), process.GetAddressByteSize(), bool_list |
| ) |
| self.assertEqual( |
| data2.sint64[0:6], [1, 1, 0, 0, 1, 0], "signed64 data2 = [1, 1, 0, 0, 1, 0]" |
| ) |
| |
| data2 = lldb.SBData.CreateDataFromUInt64Array( |
| process.GetByteOrder(), process.GetAddressByteSize(), bool_list |
| ) |
| self.assertEqual( |
| data2.uint64[0:6], [1, 1, 0, 0, 1, 0], "signed64 data2 = [1, 1, 0, 0, 1, 0]" |
| ) |
| |
| data2 = lldb.SBData.CreateDataFromDoubleArray( |
| process.GetByteOrder(), process.GetAddressByteSize(), [3.14, 6.28, 2.71] |
| ) |
| self.assertTrue( |
| fabs(data2.GetDouble(error, 0) - 3.14) < 0.5, "double data2[0] = 3.14" |
| ) |
| self.assertSuccess(error) |
| self.assertTrue( |
| fabs(data2.GetDouble(error, 8) - 6.28) < 0.5, "double data2[1] = 6.28" |
| ) |
| self.assertSuccess(error) |
| self.assertTrue( |
| fabs(data2.GetDouble(error, 16) - 2.71) < 0.5, "double data2[2] = 2.71" |
| ) |
| self.assertSuccess(error) |
| |
| data2 = lldb.SBData() |
| |
| data2.SetDataFromCString(hello_str) |
| self.assertEqual(len(data2.uint8), len(hello_str)) |
| self.assert_data(data2.GetUnsignedInt8, 0, 104) |
| self.assert_data(data2.GetUnsignedInt8, 1, 101) |
| self.assert_data(data2.GetUnsignedInt8, 2, 108) |
| self.assert_data(data2.GetUnsignedInt8, 3, 108) |
| self.assert_data(data2.GetUnsignedInt8, 4, 111) |
| self.assert_data(data2.GetUnsignedInt8, 5, 33) |
| |
| data2.SetDataFromUInt64Array([1, 2, 3, 4, 5, 2**63]) |
| self.assert_data(data2.GetUnsignedInt64, 0, 1) |
| self.assert_data(data2.GetUnsignedInt64, 8, 2) |
| self.assert_data(data2.GetUnsignedInt64, 16, 3) |
| self.assert_data(data2.GetUnsignedInt64, 24, 4) |
| self.assert_data(data2.GetUnsignedInt64, 32, 5) |
| self.assert_data(data2.GetUnsignedInt64, 40, 2**63) |
| |
| self.assertEqual( |
| data2.uint64[0], 1, "read_data_helper failure: set data2[0] = 1" |
| ) |
| self.assertEqual( |
| data2.uint64[1], 2, "read_data_helper failure: set data2[1] = 2" |
| ) |
| self.assertEqual( |
| data2.uint64[2], 3, "read_data_helper failure: set data2[2] = 3" |
| ) |
| self.assertEqual( |
| data2.uint64[3], 4, "read_data_helper failure: set data2[3] = 4" |
| ) |
| self.assertEqual( |
| data2.uint64[4], 5, "read_data_helper failure: set data2[4] = 5" |
| ) |
| |
| self.assertTrue( |
| data2.uint64[0:2] == [1, 2], |
| "read_data_helper failure: set data2[0:2] = [1,2]", |
| ) |
| |
| data2.SetDataFromSInt32Array([2, -2]) |
| self.assert_data(data2.GetSignedInt32, 0, 2) |
| self.assert_data(data2.GetSignedInt32, 4, -2) |
| |
| data2.SetDataFromSInt64Array([2, -2]) |
| self.assert_data(data2.GetSignedInt64, 0, 2) |
| self.assert_data(data2.GetSignedInt64, 8, -2) |
| |
| data2.SetDataFromUInt32Array([1, 2, 3, 4, 5]) |
| self.assert_data(data2.GetUnsignedInt32, 0, 1) |
| self.assert_data(data2.GetUnsignedInt32, 4, 2) |
| self.assert_data(data2.GetUnsignedInt32, 8, 3) |
| self.assert_data(data2.GetUnsignedInt32, 12, 4) |
| self.assert_data(data2.GetUnsignedInt32, 16, 5) |
| |
| self.assertEqual( |
| data2.uint32[0], 1, "read_data_helper failure: set 32-bit data2[0] = 1" |
| ) |
| self.assertEqual( |
| data2.uint32[1], 2, "read_data_helper failure: set 32-bit data2[1] = 2" |
| ) |
| self.assertEqual( |
| data2.uint32[2], 3, "read_data_helper failure: set 32-bit data2[2] = 3" |
| ) |
| self.assertEqual( |
| data2.uint32[3], 4, "read_data_helper failure: set 32-bit data2[3] = 4" |
| ) |
| self.assertEqual( |
| data2.uint32[4], 5, "read_data_helper failure: set 32-bit data2[4] = 5" |
| ) |
| |
| data2.SetDataFromDoubleArray([3.14, 6.28, 2.71]) |
| self.assertTrue( |
| fabs(data2.GetDouble(error, 0) - 3.14) < 0.5, "set double data2[0] = 3.14" |
| ) |
| self.assertTrue( |
| fabs(data2.GetDouble(error, 8) - 6.28) < 0.5, "set double data2[1] = 6.28" |
| ) |
| self.assertTrue( |
| fabs(data2.GetDouble(error, 16) - 2.71) < 0.5, "set double data2[2] = 2.71" |
| ) |
| |
| self.assertTrue( |
| fabs(data2.double[0] - 3.14) < 0.5, |
| "read_data_helper failure: set double data2[0] = 3.14", |
| ) |
| self.assertTrue( |
| fabs(data2.double[1] - 6.28) < 0.5, |
| "read_data_helper failure: set double data2[1] = 6.28", |
| ) |
| self.assertTrue( |
| fabs(data2.double[2] - 2.71) < 0.5, |
| "read_data_helper failure: set double data2[2] = 2.71", |
| ) |
| |
| def assert_data(self, func, arg, expected): |
| """Asserts func(SBError error, arg) == expected.""" |
| error = lldb.SBError() |
| result = func(error, arg) |
| if not error.Success(): |
| stream = lldb.SBStream() |
| error.GetDescription(stream) |
| self.assertTrue( |
| error.Success(), |
| "%s(error, %s) did not succeed: %s" |
| % (func.__name__, arg, stream.GetData()), |
| ) |
| self.assertTrue( |
| expected == result, |
| "%s(error, %s) == %s != %s" % (func.__name__, arg, result, expected), |
| ) |
