forked from OSchip/llvm-project
531 lines
18 KiB
Python
531 lines
18 KiB
Python
"""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):
|
|
|
|
mydir = TestBase.compute_mydir(__file__)
|
|
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.assertTrue(
|
|
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.assertTrue(
|
|
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.assertTrue(
|
|
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.assertTrue(
|
|
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.assertTrue(
|
|
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.assertTrue(
|
|
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.assertTrue(
|
|
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.assertTrue(
|
|
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.assertTrue(
|
|
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])
|
|
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.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))
|