mirror of
https://github.com/intel/llvm.git
synced 2026-01-18 07:57:36 +08:00
4570d3eba0
This has led to many test suite failures because of copy and paste where new test cases were based off of other test cases and the "mydir" variable wasn't updated. Now you can call your superclasses "compute_mydir()" function with "__file__" as the sole argument and the relative path will be computed for you. llvm-svn: 196985
344 lines
14 KiB
Python
344 lines
14 KiB
Python
"""Test the SBData APIs."""
|
|
|
|
import os
|
|
import unittest2
|
|
import lldb
|
|
import pexpect
|
|
from lldbtest import *
|
|
from math import fabs
|
|
import lldbutil
|
|
|
|
class SBDataAPICase(TestBase):
|
|
|
|
mydir = TestBase.compute_mydir(__file__)
|
|
|
|
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
|
|
@python_api_test
|
|
@dsym_test
|
|
def test_with_dsym_and_run_command(self):
|
|
"""Test the SBData APIs."""
|
|
self.buildDsym()
|
|
self.data_api()
|
|
|
|
@python_api_test
|
|
@dwarf_test
|
|
def test_with_dwarf_and_run_command(self):
|
|
"""Test the SBData APIs."""
|
|
self.buildDwarf()
|
|
self.data_api()
|
|
|
|
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 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))
|
|
|
|
def data_api(self):
|
|
"""Test the SBData APIs."""
|
|
self.runCmd("file 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 = process.GetThreadAtIndex(0)
|
|
|
|
frame = thread.GetSelectedFrame()
|
|
if self.TraceOn():
|
|
print frame
|
|
foobar = frame.FindVariable('foobar')
|
|
self.assertTrue(foobar.IsValid())
|
|
if self.TraceOn():
|
|
print foobar
|
|
|
|
data = foobar.GetPointeeData(0, 2)
|
|
|
|
if self.TraceOn():
|
|
print data
|
|
|
|
offset = 0
|
|
error = lldb.SBError()
|
|
|
|
self.assert_data(data.GetUnsignedInt32, offset, 1)
|
|
offset += 4
|
|
low = data.GetSignedInt16(error, offset)
|
|
self.assertTrue(error.Success())
|
|
offset += 2
|
|
high = data.GetSignedInt16(error, offset)
|
|
self.assertTrue(error.Success())
|
|
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.assertTrue(error.Success())
|
|
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()
|
|
|
|
if self.TraceOn():
|
|
print data
|
|
|
|
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())
|
|
if self.TraceOn():
|
|
print new_foobar
|
|
|
|
data = new_foobar.GetData()
|
|
|
|
if self.TraceOn():
|
|
print data
|
|
|
|
self.assertTrue(data.uint32[0] == 8, 'then foo[1].a == 8')
|
|
self.assertTrue(data.uint32[1] == 7, 'then foo[1].b == 7')
|
|
self.assertTrue(fabs(data.float[2] - 3.14) < 1, 'foo[1].c == 3.14') # exploiting that sizeof(uint32) == sizeof(float)
|
|
|
|
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.assertTrue(error.Success())
|
|
|
|
data = new_foobar.GetData()
|
|
|
|
if self.TraceOn():
|
|
print data
|
|
|
|
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.assertTrue(error.Success())
|
|
|
|
self.runCmd("n")
|
|
|
|
barfoo = frame.FindVariable('barfoo')
|
|
|
|
data = barfoo.GetData()
|
|
|
|
if self.TraceOn():
|
|
print barfoo
|
|
|
|
if self.TraceOn():
|
|
print data
|
|
|
|
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.assertTrue(error.Success())
|
|
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.assertTrue(error.Success())
|
|
|
|
new_object = barfoo.CreateValueFromData("new_object",data,barfoo.GetType().GetBasicType(lldb.eBasicTypeInt))
|
|
|
|
if self.TraceOn():
|
|
print new_object
|
|
|
|
self.assertTrue(new_object.GetLoadAddress() == 0xFFFFFFFFFFFFFFFF, 'GetLoadAddress() == invalid')
|
|
self.assertTrue(new_object.AddressOf().IsValid() == False, 'AddressOf() == invalid')
|
|
self.assertTrue(new_object.GetAddress().IsValid() == False, 'GetAddress() == invalid')
|
|
|
|
self.assertTrue(new_object.GetValue() == "1", 'new_object == 1')
|
|
|
|
data.SetData(error, 'A\0\0\0', data.GetByteOrder(), data.GetAddressByteSize())
|
|
self.assertTrue(error.Success())
|
|
|
|
data2 = lldb.SBData()
|
|
data2.SetData(error, 'BCD', data.GetByteOrder(), data.GetAddressByteSize())
|
|
self.assertTrue(error.Success())
|
|
|
|
data.Append(data2)
|
|
|
|
if self.TraceOn():
|
|
print data
|
|
|
|
# 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.assertTrue(len(data2.uint8) == len(hello_str))
|
|
self.assertTrue(data2.uint8[0] == 104, 'h == 104')
|
|
self.assertTrue(data2.uint8[1] == 101, 'e == 101')
|
|
self.assertTrue(data2.uint8[2] == 108, 'l == 108')
|
|
self.assert_data(data2.GetUnsignedInt8, 3, 108) # l
|
|
self.assertTrue(data2.uint8[4] == 111, 'o == 111')
|
|
self.assert_data(data2.GetUnsignedInt8, 5, 33) # !
|
|
|
|
data2 = lldb.SBData.CreateDataFromUInt64Array(process.GetByteOrder(),process.GetAddressByteSize(),[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.assertTrue(data2.uint64s == [1,2,3,4,5], 'read_data_helper failure: data2 == [1,2,3,4,5]')
|
|
|
|
data2 = lldb.SBData.CreateDataFromSInt32Array(process.GetByteOrder(),process.GetAddressByteSize(),[2, -2])
|
|
self.assertTrue(data2.sint32[0:2] == [2,-2], 'signed32 data2 = [2,-2]')
|
|
|
|
data2.Append(lldb.SBData.CreateDataFromSInt64Array(process.GetByteOrder(),process.GetAddressByteSize(),[2, -2]))
|
|
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]')
|
|
|
|
data2 = lldb.SBData.CreateDataFromUInt32Array(process.GetByteOrder(),process.GetAddressByteSize(),[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)
|
|
|
|
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.assertTrue(error.Success())
|
|
self.assertTrue( fabs(data2.GetDouble(error,8) - 6.28) < 0.5, 'double data2[1] = 6.28')
|
|
self.assertTrue(error.Success())
|
|
self.assertTrue( fabs(data2.GetDouble(error,16) - 2.71) < 0.5, 'double data2[2] = 2.71')
|
|
self.assertTrue(error.Success())
|
|
|
|
data2 = lldb.SBData()
|
|
|
|
data2.SetDataFromCString(hello_str)
|
|
self.assertTrue(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.assertTrue(data2.uint64[0] == 1, 'read_data_helper failure: set data2[0] = 1')
|
|
self.assertTrue(data2.uint64[1] == 2, 'read_data_helper failure: set data2[1] = 2')
|
|
self.assertTrue(data2.uint64[2] == 3, 'read_data_helper failure: set data2[2] = 3')
|
|
self.assertTrue(data2.uint64[3] == 4, 'read_data_helper failure: set data2[3] = 4')
|
|
self.assertTrue(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.GetSignedInt32, 0, 2)
|
|
self.assert_data(data2.GetSignedInt32, 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.assertTrue(data2.uint32[0] == 1, 'read_data_helper failure: set 32-bit data2[0] = 1')
|
|
self.assertTrue(data2.uint32[1] == 2, 'read_data_helper failure: set 32-bit data2[1] = 2')
|
|
self.assertTrue(data2.uint32[2] == 3, 'read_data_helper failure: set 32-bit data2[2] = 3')
|
|
self.assertTrue(data2.uint32[3] == 4, 'read_data_helper failure: set 32-bit data2[3] = 4')
|
|
self.assertTrue(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')
|
|
|
|
if __name__ == '__main__':
|
|
import atexit
|
|
lldb.SBDebugger.Initialize()
|
|
atexit.register(lambda: lldb.SBDebugger.Terminate())
|
|
unittest2.main()
|