forked from OSchip/llvm-project
72 lines
3.1 KiB
Python
72 lines
3.1 KiB
Python
class StdVectorSynthProvider:
|
|
|
|
def __init__(self, valobj, dict):
|
|
self.valobj = valobj;
|
|
self.update() # initialize this provider
|
|
|
|
def num_children(self):
|
|
start_val = self.start.GetValueAsUnsigned(0) # read _M_start
|
|
finish_val = self.finish.GetValueAsUnsigned(0) # read _M_finish
|
|
end_val = self.end.GetValueAsUnsigned(0) # read _M_end_of_storage
|
|
|
|
# Before a vector has been constructed, it will contain bad values
|
|
# so we really need to be careful about the length we return since
|
|
# unitialized data can cause us to return a huge number. We need
|
|
# to also check for any of the start, finish or end of storage values
|
|
# being zero (NULL). If any are, then this vector has not been
|
|
# initialized yet and we should return zero
|
|
|
|
# Make sure nothing is NULL
|
|
if start_val == 0 or finish_val == 0 or end_val == 0:
|
|
return 0
|
|
# Make sure start is less than finish
|
|
if start_val >= finish_val:
|
|
return 0
|
|
# Make sure finish is less than or equal to end of storage
|
|
if finish_val > end_val:
|
|
return 0
|
|
|
|
# pointer arithmetic: (_M_finish - _M_start) would return the number of
|
|
# items of type T contained in the vector. because Python has no way to know
|
|
# that we want to subtract two pointers instead of two integers, we have to divide
|
|
# by sizeof(T) to be equivalent to the C++ pointer expression
|
|
num_children = (finish_val-start_val)/self.data_size
|
|
return num_children
|
|
|
|
# we assume we are getting children named [0] thru [N-1]
|
|
# if for some reason our child name is not in this format,
|
|
# do not bother to show it, and return an invalid value
|
|
def get_child_index(self,name):
|
|
try:
|
|
return int(name.lstrip('[').rstrip(']'))
|
|
except:
|
|
return -1;
|
|
|
|
def get_child_at_index(self,index):
|
|
# LLDB itself should never query for children < 0, but this might come
|
|
# from someone asking for a nonexisting child and getting -1 as index
|
|
if index < 0:
|
|
return None
|
|
if index >= self.num_children():
|
|
return None;
|
|
# *(_M_start + index), or equivalently _M_start[index] is C++ code to
|
|
# read the index-th item of the vector. in Python we must make an offset
|
|
# that is index * sizeof(T), and then grab the value at that offset from
|
|
# _M_start
|
|
offset = index * self.data_size # index * sizeof(T)
|
|
return self.start.CreateChildAtOffset('['+str(index)+']',offset,self.data_type) # *(_M_start + index)
|
|
|
|
# an std::vector contains an object named _M_impl, which in turn contains
|
|
# three pointers, _M_start, _M_end and _M_end_of_storage. _M_start points to the
|
|
# beginning of the data area, _M_finish points to where the current vector elements
|
|
# finish, and _M_end_of_storage is the end of the currently alloc'ed memory portion
|
|
# (to allow resizing, a vector may allocate more memory than required)
|
|
def update(self):
|
|
impl = self.valobj.GetChildMemberWithName('_M_impl')
|
|
self.start = impl.GetChildMemberWithName('_M_start')
|
|
self.finish = impl.GetChildMemberWithName('_M_finish')
|
|
self.end = impl.GetChildMemberWithName('_M_end_of_storage')
|
|
self.data_type = self.start.GetType().GetPointeeType() # _M_start is defined as a T*
|
|
self.data_size = self.data_type.GetByteSize() # sizeof(T)
|
|
|