lldb.formatters.cpp.gnu

+ 1 import re + 2 import lldb.formatters.Logger + 3 + 4 # C++ STL formatters for LLDB + 5 # These formatters are based upon the version of the GNU libstdc++ + 6 # as it ships with Mac OS X 10.6.8 thru 10.8.0 + 7 # You are encouraged to look at the STL implementation for your platform + 8 # before relying on these formatters to do the right thing for your setup + 9 +

10 -class StdListSynthProvider: +

11 +

12 - def __init__(self, valobj, dict): +

13 logger = lldb.formatters.Logger.Logger() + 14 self.valobj = valobj + 15 self.count = None + 16 logger >> "Providing synthetic children for a map named " + str(valobj.GetName()) +

17 +

18 - def next_node(self,node): +

19 logger = lldb.formatters.Logger.Logger() + 20 return node.GetChildMemberWithName('_M_next') +

21 +

22 - def is_valid(self,node): +

23 logger = lldb.formatters.Logger.Logger() + 24 return self.value(self.next_node(node)) != self.node_address +

25 +

26 - def value(self,node): +

27 logger = lldb.formatters.Logger.Logger() + 28 return node.GetValueAsUnsigned() +

29 + 30 # Floyd's cycle-finding algorithm + 31 # try to detect if this list has a loop +

32 - def has_loop(self): +

33 global _list_uses_loop_detector + 34 logger = lldb.formatters.Logger.Logger() + 35 if _list_uses_loop_detector == False: + 36 logger >> "Asked not to use loop detection" + 37 return False + 38 slow = self.next + 39 fast1 = self.next + 40 fast2 = self.next + 41 while self.is_valid(slow): + 42 slow_value = self.value(slow) + 43 fast1 = self.next_node(fast2) + 44 fast2 = self.next_node(fast1) + 45 if self.value(fast1) == slow_value or self.value(fast2) == slow_value: + 46 return True + 47 slow = self.next_node(slow) + 48 return False +

49 +

50 - def num_children(self): +

51 global _list_capping_size + 52 logger = lldb.formatters.Logger.Logger() + 53 if self.count == None: + 54 self.count = self.num_children_impl() + 55 if self.count > _list_capping_size: + 56 self.count = _list_capping_size + 57 return self.count +

58 +

59 - def num_children_impl(self): +

60 logger = lldb.formatters.Logger.Logger() + 61 global _list_capping_size + 62 try: + 63 next_val = self.next.GetValueAsUnsigned(0) + 64 prev_val = self.prev.GetValueAsUnsigned(0) + 65 # After a std::list has been initialized, both next and prev will be non-NULL + 66 if next_val == 0 or prev_val == 0: + 67 return 0 + 68 if next_val == self.node_address: + 69 return 0 + 70 if next_val == prev_val: + 71 return 1 + 72 if self.has_loop(): + 73 return 0 + 74 size = 2 + 75 current = self.next + 76 while current.GetChildMemberWithName('_M_next').GetValueAsUnsigned(0) != self.node_address: + 77 size = size + 1 + 78 current = current.GetChildMemberWithName('_M_next') + 79 if size > _list_capping_size: + 80 return _list_capping_size + 81 return (size - 1) + 82 except: + 83 return 0; +

84 +

85 - def get_child_index(self,name): +

86 logger = lldb.formatters.Logger.Logger() + 87 try: + 88 return int(name.lstrip('[').rstrip(']')) + 89 except: + 90 return -1 +

91 +

92 - def get_child_at_index(self,index): +

93 logger = lldb.formatters.Logger.Logger() + 94 logger >> "Fetching child " + str(index) + 95 if index < 0: + 96 return None; + 97 if index >= self.num_children(): + 98 return None; + 99 try: +100 offset = index +101 current = self.next +102 while offset > 0: +103 current = current.GetChildMemberWithName('_M_next') +104 offset = offset - 1 +105 return current.CreateChildAtOffset('['+str(index)+']',2*current.GetType().GetByteSize(),self.data_type) +106 except: +107 return None +

108 +

109 - def extract_type(self): +

110 logger = lldb.formatters.Logger.Logger() +111 list_type = self.valobj.GetType().GetUnqualifiedType() +112 if list_type.IsReferenceType(): +113 list_type = list_type.GetDereferencedType() +114 if list_type.GetNumberOfTemplateArguments() > 0: +115 data_type = list_type.GetTemplateArgumentType(0) +116 else: +117 data_type = None +118 return data_type +

119 +

120 - def update(self): +

121 logger = lldb.formatters.Logger.Logger() +122 # preemptively setting this to None - we might end up changing our mind later +123 self.count = None +124 try: +125 impl = self.valobj.GetChildMemberWithName('_M_impl') +126 node = impl.GetChildMemberWithName('_M_node') +127 self.node_address = self.valobj.AddressOf().GetValueAsUnsigned(0) +128 self.next = node.GetChildMemberWithName('_M_next') +129 self.prev = node.GetChildMemberWithName('_M_prev') +130 self.data_type = self.extract_type() +131 self.data_size = self.data_type.GetByteSize() +132 except: +133 pass +

134 +

135 - def has_children(self): +

136 return True +

137 +

138 -class StdVectorSynthProvider: +

139 +

140 - def __init__(self, valobj, dict): +

141 logger = lldb.formatters.Logger.Logger() +142 self.count = None +143 self.valobj = valobj +144 logger >> "Providing synthetic children for a map named " + str(valobj.GetName()) +

145 +

146 - def num_children(self): +

147 logger = lldb.formatters.Logger.Logger() +148 if self.count == None: +149 self.count = self.num_children_impl() +150 return self.count +

151 +

152 - def is_valid_pointer(ptr,process): +

153 logger = lldb.formatters.Logger.Logger() +154 error = lldb.SBError() +155 process.ReadMemory(ptr,1,error) +156 return False if error.Fail() else True +

157 +

158 - def num_children_impl(self): +

159 logger = lldb.formatters.Logger.Logger() +160 try: +161 start_val = self.start.GetValueAsUnsigned(0) +162 finish_val = self.finish.GetValueAsUnsigned(0) +163 end_val = self.end.GetValueAsUnsigned(0) +164 # Before a vector has been constructed, it will contain bad values +165 # so we really need to be careful about the length we return since +166 # uninitialized data can cause us to return a huge number. We need +167 # to also check for any of the start, finish or end of storage values +168 # being zero (NULL). If any are, then this vector has not been +169 # initialized yet and we should return zero +170 +171 # Make sure nothing is NULL +172 if start_val == 0 or finish_val == 0 or end_val == 0: +173 return 0 +174 # Make sure start is less than finish +175 if start_val >= finish_val: +176 return 0 +177 # Make sure finish is less than or equal to end of storage +178 if finish_val > end_val: +179 return 0 +180 +181 # if we have a struct (or other data type that the compiler pads to native word size) +182 # this check might fail, unless the sizeof() we get is itself incremented to take the +183 # padding bytes into account - on current clang it looks like this is the case +184 num_children = (finish_val-start_val) +185 if (num_children % self.data_size) != 0: +186 return 0 +187 else: +188 num_children = num_children/self.data_size +189 return num_children +190 except: +191 return 0; +

192 +

193 - def get_child_index(self,name): +

194 logger = lldb.formatters.Logger.Logger() +195 try: +196 return int(name.lstrip('[').rstrip(']')) +197 except: +198 return -1 +

199 +

200 - def get_child_at_index(self,index): +

201 logger = lldb.formatters.Logger.Logger() +202 logger >> "Retrieving child " + str(index) +203 if index < 0: +204 return None; +205 if index >= self.num_children(): +206 return None; +207 try: +208 offset = index * self.data_size +209 return self.start.CreateChildAtOffset('['+str(index)+']',offset,self.data_type) +210 except: +211 return None +

212 +

213 - def update(self): +

214 logger = lldb.formatters.Logger.Logger() +215 # preemptively setting this to None - we might end up changing our mind later +216 self.count = None +217 try: +218 impl = self.valobj.GetChildMemberWithName('_M_impl') +219 self.start = impl.GetChildMemberWithName('_M_start') +220 self.finish = impl.GetChildMemberWithName('_M_finish') +221 self.end = impl.GetChildMemberWithName('_M_end_of_storage') +222 self.data_type = self.start.GetType().GetPointeeType() +223 self.data_size = self.data_type.GetByteSize() +224 # if any of these objects is invalid, it means there is no point in trying to fetch anything +225 if self.start.IsValid() and self.finish.IsValid() and self.end.IsValid() and self.data_type.IsValid(): +226 self.count = None +227 else: +228 self.count = 0 +229 except: +230 pass +

231 +232 +

233 - def has_children(self): +

234 return True +

235 +236 +

237 -class StdMapSynthProvider: +

238 +

239 - def __init__(self, valobj, dict): +

240 logger = lldb.formatters.Logger.Logger() +241 self.valobj = valobj; +242 self.count = None +243 logger >> "Providing synthetic children for a map named " + str(valobj.GetName()) +

244 +245 # we need this function as a temporary workaround for rdar://problem/10801549 +246 # which prevents us from extracting the std::pair<K,V> SBType out of the template +247 # arguments for _Rep_Type _M_t in the map itself - because we have to make up the +248 # typename and then find it, we may hit the situation were std::string has multiple +249 # names but only one is actually referenced in the debug information. hence, we need +250 # to replace the longer versions of std::string with the shorter one in order to be able +251 # to find the type name +

252 - def fixup_class_name(self, class_name): +

253 logger = lldb.formatters.Logger.Logger() +254 if class_name == 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >': +255 return 'std::basic_string<char>',True +256 if class_name == 'basic_string<char, std::char_traits<char>, std::allocator<char> >': +257 return 'std::basic_string<char>',True +258 if class_name == 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >': +259 return 'std::basic_string<char>',True +260 if class_name == 'basic_string<char, std::char_traits<char>, std::allocator<char> >': +261 return 'std::basic_string<char>',True +262 return class_name,False +

263 +

264 - def update(self): +

265 logger = lldb.formatters.Logger.Logger() +266 # preemptively setting this to None - we might end up changing our mind later +267 self.count = None +268 try: +269 # we will set this to True if we find out that discovering a node in the map takes more steps than the overall size of the RB tree +270 # if this gets set to True, then we will merrily return None for any child from that moment on +271 self.garbage = False +272 self.Mt = self.valobj.GetChildMemberWithName('_M_t') +273 self.Mimpl = self.Mt.GetChildMemberWithName('_M_impl') +274 self.Mheader = self.Mimpl.GetChildMemberWithName('_M_header') +275 +276 map_type = self.valobj.GetType() +277 if map_type.IsReferenceType(): +278 logger >> "Dereferencing type" +279 map_type = map_type.GetDereferencedType() +280 +281 map_arg_0 = str(map_type.GetTemplateArgumentType(0).GetName()) +282 map_arg_1 = str(map_type.GetTemplateArgumentType(1).GetName()) +283 +284 logger >> "map has args " + str(map_arg_0) + " and " + str(map_arg_1) +285 +286 map_arg_0,fixed_0 = self.fixup_class_name(map_arg_0) +287 map_arg_1,fixed_1 = self.fixup_class_name(map_arg_1) +288 +289 logger >> "arg_0 has become: " + str(map_arg_0) + " (fixed: " + str(fixed_0) + ")" +290 logger >> "arg_1 has become: " + str(map_arg_1) + " (fixed: " + str(fixed_1) + ")" +291 +292 # HACK: this is related to the above issue with the typename for std::string +293 # being shortened by clang - the changes to typename display and searching to honor +294 # namespaces make it so that we go looking for std::pair<const std::basic_string<char>, ...> +295 # but when we find a type for this, we then compare it against the fully-qualified +296 # std::pair<const std::basic_string<char, std::char_traits... and of course fail +297 # the way to bypass this problem is to avoid using the std:: prefix in this specific case +298 if fixed_0 or fixed_1: +299 map_arg_type = "pair<const " + map_arg_0 + ", " + map_arg_1 +300 else: +301 map_arg_type = "std::pair<const " + map_arg_0 + ", " + map_arg_1 +302 +303 if map_arg_1[-1] == '>': +304 map_arg_type = map_arg_type + " >" +305 else: +306 map_arg_type = map_arg_type + ">" +307 +308 logger >> "final contents datatype is: " + str(map_arg_type) +309 +310 self.data_type = self.valobj.GetTarget().FindFirstType(map_arg_type) +311 +312 logger >> "and the SBType is: " + str(self.data_type) +313 +314 # from libstdc++ implementation of _M_root for rbtree +315 self.Mroot = self.Mheader.GetChildMemberWithName('_M_parent') +316 self.data_size = self.data_type.GetByteSize() +317 self.skip_size = self.Mheader.GetType().GetByteSize() +318 except: +319 pass +

320 +

321 - def num_children(self): +

322 global _map_capping_size +323 logger = lldb.formatters.Logger.Logger() +324 if self.count == None: +325 self.count = self.num_children_impl() +326 if self.count > _map_capping_size: +327 self.count = _map_capping_size +328 return self.count +

329 +

330 - def num_children_impl(self): +

331 logger = lldb.formatters.Logger.Logger() +332 try: +333 root_ptr_val = self.node_ptr_value(self.Mroot) +334 if root_ptr_val == 0: +335 return 0; +336 count = self.Mimpl.GetChildMemberWithName('_M_node_count').GetValueAsUnsigned(0) +337 logger >> "I have " + str(count) + " children available" +338 return count +339 except: +340 return 0; +

341 +

342 - def get_child_index(self,name): +

343 logger = lldb.formatters.Logger.Logger() +344 try: +345 return int(name.lstrip('[').rstrip(']')) +346 except: +347 return -1 +

348 +

349 - def get_child_at_index(self,index): +

350 logger = lldb.formatters.Logger.Logger() +351 logger >> "Being asked to fetch child[" + str(index) + "]" +352 if index < 0: +353 return None +354 if index >= self.num_children(): +355 return None; +356 if self.garbage: +357 logger >> "Returning None since we are a garbage tree" +358 return None +359 try: +360 offset = index +361 current = self.left(self.Mheader); +362 while offset > 0: +363 current = self.increment_node(current) +364 offset = offset - 1; +365 # skip all the base stuff and get at the data +366 return current.CreateChildAtOffset('['+str(index)+']',self.skip_size,self.data_type) +367 except: +368 return None +

369 +370 # utility functions +

371 - def node_ptr_value(self,node): +

372 logger = lldb.formatters.Logger.Logger() +373 return node.GetValueAsUnsigned(0) +

374 +

375 - def right(self,node): +

376 logger = lldb.formatters.Logger.Logger() +377 return node.GetChildMemberWithName("_M_right"); +

378 +

379 - def left(self,node): +

380 logger = lldb.formatters.Logger.Logger() +381 return node.GetChildMemberWithName("_M_left"); +

382 +

383 - def parent(self,node): +

384 logger = lldb.formatters.Logger.Logger() +385 return node.GetChildMemberWithName("_M_parent"); +

386 +387 # from libstdc++ implementation of iterator for rbtree +

388 - def increment_node(self,node): +

389 logger = lldb.formatters.Logger.Logger() +390 max_steps = self.num_children() +391 if self.node_ptr_value(self.right(node)) != 0: +392 x = self.right(node); +393 max_steps -= 1 +394 while self.node_ptr_value(self.left(x)) != 0: +395 x = self.left(x); +396 max_steps -= 1 +397 logger >> str(max_steps) + " more to go before giving up" +398 if max_steps <= 0: +399 self.garbage = True +400 return None +401 return x; +402 else: +403 x = node; +404 y = self.parent(x) +405 max_steps -= 1 +406 while(self.node_ptr_value(x) == self.node_ptr_value(self.right(y))): +407 x = y; +408 y = self.parent(y); +409 max_steps -= 1 +410 logger >> str(max_steps) + " more to go before giving up" +411 if max_steps <= 0: +412 self.garbage = True +413 return None +414 if self.node_ptr_value(self.right(x)) != self.node_ptr_value(y): +415 x = y; +416 return x; +

417 +

418 - def has_children(self): +

419 return True +

420 +421 _map_capping_size = 255 +422 _list_capping_size = 255 +423 _list_uses_loop_detector = True +424 +

Source Code for Module lldb.formatters.cpp.gnu_libstdcpp