New category "gnu-libstdc++" provides summary for std::string and synthetic children for types std::map, std::list and std::vector
The category is enabled by default. If you run into issues with it, disable it and the previous behavior of LLDB is restored
** This is a temporary solution. The general solution to having formatters pulled in at startup should involve going through the Platform.
Fixed an issue in type synthetic list where a category with synthetic providers in it was not shown if all the providers were regex-based
git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@137850 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/source/osxcpp.py b/source/osxcpp.py
new file mode 100644
index 0000000..b26503f
--- /dev/null
+++ b/source/osxcpp.py
@@ -0,0 +1,231 @@
+import re
+
+# C++ STL formatters for LLDB
+# These formatters are based upon the version of the STL that ships
+# with Mac OS X Snow Leopard 10.6.8 and OS X Lion 10.7.0
+# The STL implementation *might* change on other releases of Apple's
+# operating system and library infrastructure, and might be different on
+# other operating systems
+
+class StdListSynthProvider:
+
+ def __init__(self, valobj, dict):
+ self.valobj = valobj
+ self.update()
+
+ def num_children(self):
+ next_val = self.next.GetValueAsUnsigned(0)
+ prev_val = self.prev.GetValueAsUnsigned(0)
+ # After a std::list has been initialized, both next and prev will be non-NULL
+ if next_val == 0 or prev_val == 0:
+ return 0
+ if next_val == self.node_address:
+ return 0
+ if next_val == prev_val:
+ return 1
+ size = 2
+ current = self.next
+ while current.GetChildMemberWithName('_M_next').GetValueAsUnsigned(0) != self.node_address:
+ size = size + 1
+ current = current.GetChildMemberWithName('_M_next')
+ return (size - 1)
+
+ def get_child_index(self,name):
+ return int(name.lstrip('[').rstrip(']'))
+
+ def get_child_at_index(self,index):
+ if index >= self.num_children():
+ return None;
+ offset = index
+ current = self.next
+ while offset > 0:
+ current = current.GetChildMemberWithName('_M_next')
+ offset = offset - 1
+ return current.CreateChildAtOffset('['+str(index)+']',2*current.GetType().GetByteSize(),self.data_type)
+
+ def extract_type_name(self,name):
+ self.type_name = name[16:]
+ index = 2
+ count_of_template = 1
+ while index < len(self.type_name):
+ if self.type_name[index] == '<':
+ count_of_template = count_of_template + 1
+ elif self.type_name[index] == '>':
+ count_of_template = count_of_template - 1
+ elif self.type_name[index] == ',' and count_of_template == 1:
+ self.type_name = self.type_name[:index]
+ break
+ index = index + 1
+ self.type_name_nospaces = self.type_name.replace(", ", ",")
+
+ def update(self):
+ impl = self.valobj.GetChildMemberWithName('_M_impl')
+ node = impl.GetChildMemberWithName('_M_node')
+ self.extract_type_name(impl.GetType().GetName())
+ self.node_address = self.valobj.AddressOf().GetValueAsUnsigned(0)
+ self.next = node.GetChildMemberWithName('_M_next')
+ self.prev = node.GetChildMemberWithName('_M_prev')
+ self.data_type = node.GetTarget().FindFirstType(self.type_name)
+ # tries to fight against a difference in formatting type names between gcc and clang
+ if self.data_type.IsValid() == False:
+ self.data_type = node.GetTarget().FindFirstType(self.type_name_nospaces)
+ self.data_size = self.data_type.GetByteSize()
+
+class StdVectorSynthProvider:
+
+ def __init__(self, valobj, dict):
+ self.valobj = valobj;
+ self.update()
+
+ def num_children(self):
+ start_val = self.start.GetValueAsUnsigned(0)
+ finish_val = self.finish.GetValueAsUnsigned(0)
+ end_val = self.end.GetValueAsUnsigned(0)
+ # 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
+
+ num_children = (finish_val-start_val)/self.data_size
+ return num_children
+
+ def get_child_index(self,name):
+ return int(name.lstrip('[').rstrip(']'))
+
+ def get_child_at_index(self,index):
+ if index >= self.num_children():
+ return None;
+ offset = index * self.data_size
+ return self.start.CreateChildAtOffset('['+str(index)+']',offset,self.data_type)
+
+ 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()
+ self.data_size = self.data_type.GetByteSize()
+
+
+class StdMapSynthProvider:
+
+ def __init__(self, valobj, dict):
+ self.valobj = valobj;
+ self.update()
+
+ def update(self):
+ self.Mt = self.valobj.GetChildMemberWithName('_M_t')
+ self.Mimpl = self.Mt.GetChildMemberWithName('_M_impl')
+ self.Mheader = self.Mimpl.GetChildMemberWithName('_M_header')
+ # from libstdc++ implementation of _M_root for rbtree
+ self.Mroot = self.Mheader.GetChildMemberWithName('_M_parent')
+ # the stuff into the tree is actually a std::pair<const key, value>
+ # life would be much easier if gcc had a coherent way to print out
+ # template names in debug info
+ self.expand_clang_type_name()
+ self.expand_gcc_type_name()
+ self.data_type = self.Mt.GetTarget().FindFirstType(self.clang_type_name)
+ if self.data_type.IsValid() == False:
+ self.data_type = self.Mt.GetTarget().FindFirstType(self.gcc_type_name)
+ self.data_size = self.data_type.GetByteSize()
+ self.skip_size = self.Mheader.GetType().GetByteSize()
+
+ def expand_clang_type_name(self):
+ type_name = self.Mimpl.GetType().GetName()
+ index = type_name.find("std::pair<")
+ type_name = type_name[index+5:]
+ index = 6
+ template_count = 1
+ while index < len(type_name):
+ if type_name[index] == '<':
+ template_count = template_count + 1
+ elif type_name[index] == '>' and template_count == 1:
+ type_name = type_name[:index+1]
+ break
+ elif type_name[index] == '>':
+ template_count = template_count - 1
+ index = index + 1;
+ self.clang_type_name = type_name
+
+ def expand_gcc_type_name(self):
+ type_name = self.Mt.GetType().GetName()
+ index = type_name.find("std::pair<")
+ type_name = type_name[index+5:]
+ index = 6
+ template_count = 1
+ while index < len(type_name):
+ if type_name[index] == '<':
+ template_count = template_count + 1
+ elif type_name[index] == '>' and template_count == 1:
+ type_name = type_name[:index+1]
+ break
+ elif type_name[index] == '>':
+ template_count = template_count - 1
+ elif type_name[index] == ' ' and template_count == 1 and type_name[index-1] == ',':
+ type_name = type_name[0:index] + type_name[index+1:]
+ index = index - 1
+ index = index + 1;
+ self.gcc_type_name = type_name
+
+ def num_children(self):
+ root_ptr_val = self.node_ptr_value(self.Mroot)
+ if root_ptr_val == 0:
+ return 0;
+ return self.Mimpl.GetChildMemberWithName('_M_node_count').GetValueAsUnsigned(0)
+
+ def get_child_index(self,name):
+ return int(name.lstrip('[').rstrip(']'))
+
+ def get_child_at_index(self,index):
+ if index >= self.num_children():
+ return None;
+ offset = index
+ current = self.left(self.Mheader);
+ while offset > 0:
+ current = self.increment_node(current)
+ offset = offset - 1;
+ # skip all the base stuff and get at the data
+ return current.CreateChildAtOffset('['+str(index)+']',self.skip_size,self.data_type)
+
+ # utility functions
+ def node_ptr_value(self,node):
+ return node.GetValueAsUnsigned(0)
+
+ def right(self,node):
+ return node.GetChildMemberWithName("_M_right");
+
+ def left(self,node):
+ return node.GetChildMemberWithName("_M_left");
+
+ def parent(self,node):
+ return node.GetChildMemberWithName("_M_parent");
+
+ # from libstdc++ implementation of iterator for rbtree
+ def increment_node(self,node):
+ if self.node_ptr_value(self.right(node)) != 0:
+ x = self.right(node);
+ while self.node_ptr_value(self.left(x)) != 0:
+ x = self.left(x);
+ return x;
+ else:
+ x = node;
+ y = self.parent(x)
+ while(self.node_ptr_value(x) == self.node_ptr_value(self.right(y))):
+ x = y;
+ y = self.parent(y);
+ if self.node_ptr_value(self.right(x)) != self.node_ptr_value(y):
+ x = y;
+ return x;
+