import lldb.formatters.Logger # C++ STL formatters for LLDB # As there are many versions of the libstdc++, you are encouraged to look at the STL # implementation for your platform before relying on these formatters to do the right # thing for your setup def ForwardListSummaryProvider(valobj, dict): list_capping_size = valobj.GetTarget().GetMaximumNumberOfChildrenToDisplay() text = "size=" + str(valobj.GetNumChildren()) if valobj.GetNumChildren() > list_capping_size: return "(capped) " + text else: return text def StdOptionalSummaryProvider(valobj, dict): has_value = valobj.GetNumChildren() > 0 # We add wrapping spaces for consistency with the libcxx formatter return " Has Value=" + ("true" if has_value else "false") + " " class StdOptionalSynthProvider: def __init__(self, valobj, dict): self.valobj = valobj def update(self): try: self.payload = self.valobj.GetChildMemberWithName("_M_payload") self.value = self.payload.GetChildMemberWithName("_M_payload") self.has_value = ( self.payload.GetChildMemberWithName("_M_engaged").GetValueAsUnsigned(0) != 0 ) except: self.has_value = False return False def num_children(self): return 1 if self.has_value else 0 def get_child_index(self, name): return 0 def get_child_at_index(self, index): # some versions of libstdcpp have an additional _M_value child with the actual value possible_value = self.value.GetChildMemberWithName("_M_value") if possible_value.IsValid(): return possible_value.Clone("Value") return self.value.Clone("Value") """ This formatter can be applied to all unordered map-like structures (unordered_map, unordered_multimap, unordered_set, unordered_multiset) """ class StdUnorderedMapSynthProvider: def __init__(self, valobj, dict): self.valobj = valobj self.count = None self.kind = self.get_object_kind(valobj) def get_object_kind(self, valobj): type_name = valobj.GetTypeName() return "set" if "set" in type_name else "map" def extract_type(self): type = self.valobj.GetType() # type of std::pair is the first template # argument type of the 4th template argument to std::map and # 3rd template argument for std::set. That's why # we need to know kind of the object template_arg_num = 4 if self.kind == "map" else 3 allocator_type = type.GetTemplateArgumentType(template_arg_num) data_type = allocator_type.GetTemplateArgumentType(0) return data_type def update(self): # preemptively setting this to None - we might end up changing our mind # later self.count = None try: self.head = self.valobj.GetChildMemberWithName("_M_h") self.before_begin = self.head.GetChildMemberWithName("_M_before_begin") self.next = self.before_begin.GetChildMemberWithName("_M_nxt") self.data_type = self.extract_type() self.skip_size = self.next.GetType().GetByteSize() self.data_size = self.data_type.GetByteSize() if (not self.data_type.IsValid()) or (not self.next.IsValid()): self.count = 0 except: self.count = 0 return False def get_child_index(self, name): try: return int(name.lstrip("[").rstrip("]")) except: return -1 def get_child_at_index(self, index): logger = lldb.formatters.Logger.Logger() logger >> "Being asked to fetch child[" + str(index) + "]" if index < 0: return None if index >= self.num_children(): return None try: offset = index current = self.next while offset > 0: current = current.GetChildMemberWithName("_M_nxt") offset = offset - 1 return current.CreateChildAtOffset( "[" + str(index) + "]", self.skip_size, self.data_type ) except: logger >> "Cannot get child" return None def num_children(self): if self.count is None: self.count = self.num_children_impl() return self.count def num_children_impl(self): logger = lldb.formatters.Logger.Logger() try: count = self.head.GetChildMemberWithName( "_M_element_count" ).GetValueAsUnsigned(0) return count except: logger >> "Could not determine the size" return 0 class AbstractListSynthProvider: def __init__(self, valobj, dict, has_prev): """ :param valobj: The value object of the list :param dict: A dict with metadata provided by LLDB :param has_prev: Whether the list supports a 'prev' pointer besides a 'next' one """ logger = lldb.formatters.Logger.Logger() self.valobj = valobj self.count = None self.has_prev = has_prev self.list_capping_size = ( self.valobj.GetTarget().GetMaximumNumberOfChildrenToDisplay() ) logger >> "Providing synthetic children for a list named " + str( valobj.GetName() ) def next_node(self, node): logger = lldb.formatters.Logger.Logger() return node.GetChildMemberWithName("_M_next") def is_valid(self, node): logger = lldb.formatters.Logger.Logger() valid = self.value(self.next_node(node)) != self.get_end_of_list_address() if valid: logger >> "%s is valid" % str(self.valobj.GetName()) else: logger >> "synthetic value is not valid" return valid def value(self, node): logger = lldb.formatters.Logger.Logger() value = node.GetValueAsUnsigned() logger >> "synthetic value for {}: {}".format(str(self.valobj.GetName()), value) return value # Floyd's cycle-finding algorithm # try to detect if this list has a loop def has_loop(self): global _list_uses_loop_detector logger = lldb.formatters.Logger.Logger() if not _list_uses_loop_detector: logger >> "Asked not to use loop detection" return False slow = self.next fast1 = self.next fast2 = self.next while self.is_valid(slow): slow_value = self.value(slow) fast1 = self.next_node(fast2) fast2 = self.next_node(fast1) if self.value(fast1) == slow_value or self.value(fast2) == slow_value: return True slow = self.next_node(slow) return False def num_children(self): logger = lldb.formatters.Logger.Logger() if self.count is None: # libstdc++ 6.0.21 added dedicated count field. count_child = self.node.GetChildMemberWithName("_M_data") if count_child and count_child.IsValid(): self.count = count_child.GetValueAsUnsigned(0) if self.count is None: self.count = self.num_children_impl() return self.count def num_children_impl(self): logger = lldb.formatters.Logger.Logger() try: # After a std::list has been initialized, both next and prev will # be non-NULL next_val = self.next.GetValueAsUnsigned(0) if next_val == 0: return 0 if self.has_loop(): return 0 if self.has_prev: prev_val = self.prev.GetValueAsUnsigned(0) if prev_val == 0: return 0 if next_val == self.node_address: return 0 if next_val == prev_val: return 1 size = 1 current = self.next while ( current.GetChildMemberWithName("_M_next").GetValueAsUnsigned(0) != self.get_end_of_list_address() ): current = current.GetChildMemberWithName("_M_next") if not current.IsValid(): break size = size + 1 if size >= self.list_capping_size: break return size except: logger >> "Error determining the size" return 0 def get_child_index(self, name): logger = lldb.formatters.Logger.Logger() try: return int(name.lstrip("[").rstrip("]")) except: return -1 def get_child_at_index(self, index): logger = lldb.formatters.Logger.Logger() logger >> "Fetching child " + str(index) if index < 0: return None if index >= self.num_children(): return None try: offset = index current = self.next while offset > 0: current = current.GetChildMemberWithName("_M_next") offset = offset - 1 # C++ lists store the data of a node after its pointers. In the case of a forward list, there's just one pointer (next), and # in the case of a double-linked list, there's an additional pointer (prev). return current.CreateChildAtOffset( "[" + str(index) + "]", (2 if self.has_prev else 1) * current.GetType().GetByteSize(), self.data_type, ) except: return None def extract_type(self): logger = lldb.formatters.Logger.Logger() list_type = self.valobj.GetType().GetUnqualifiedType() if list_type.IsReferenceType(): list_type = list_type.GetDereferencedType() if list_type.GetNumberOfTemplateArguments() > 0: return list_type.GetTemplateArgumentType(0) return lldb.SBType() def update(self): logger = lldb.formatters.Logger.Logger() # preemptively setting this to None - we might end up changing our mind # later self.count = None try: self.impl = self.valobj.GetChildMemberWithName("_M_impl") self.data_type = self.extract_type() if (not self.data_type.IsValid()) or (not self.impl.IsValid()): self.count = 0 elif not self.updateNodes(): self.count = 0 else: self.data_size = self.data_type.GetByteSize() except: self.count = 0 return False """ Method is used to extract the list pointers into the variables (e.g self.node, self.next, and optionally to self.prev) and is mandatory to be overriden in each AbstractListSynthProvider subclass. This should return True or False depending on wheter it found valid data. """ def updateNodes(self): raise NotImplementedError def has_children(self): return True """ Method is used to identify if a node traversal has reached its end and is mandatory to be overriden in each AbstractListSynthProvider subclass """ def get_end_of_list_address(self): raise NotImplementedError class StdForwardListSynthProvider(AbstractListSynthProvider): def __init__(self, valobj, dict): has_prev = False super().__init__(valobj, dict, has_prev) def updateNodes(self): self.node = self.impl.GetChildMemberWithName("_M_head") self.next = self.node.GetChildMemberWithName("_M_next") if (not self.node.IsValid()) or (not self.next.IsValid()): return False return True def get_end_of_list_address(self): return 0 class StdListSynthProvider(AbstractListSynthProvider): def __init__(self, valobj, dict): has_prev = True super().__init__(valobj, dict, has_prev) def updateNodes(self): self.node_address = self.valobj.AddressOf().GetValueAsUnsigned(0) self.node = self.impl.GetChildMemberWithName("_M_node") self.prev = self.node.GetChildMemberWithName("_M_prev") self.next = self.node.GetChildMemberWithName("_M_next") if ( self.node_address == 0 or (not self.node.IsValid()) or (not self.next.IsValid()) or (not self.prev.IsValid()) ): return False return True def get_end_of_list_address(self): return self.node_address class StdVectorSynthProvider: class StdVectorImplementation(object): def __init__(self, valobj): self.valobj = valobj self.count = None def num_children(self): if self.count is None: self.count = self.num_children_impl() return self.count def num_children_impl(self): try: 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 # uninitialized 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 # if we have a struct (or other data type that the compiler pads to native word size) # this check might fail, unless the sizeof() we get is itself incremented to take the # padding bytes into account - on current clang it looks like # this is the case num_children = finish_val - start_val if (num_children % self.data_size) != 0: return 0 else: num_children = num_children // self.data_size return num_children except: return 0 def get_child_at_index(self, index): logger = lldb.formatters.Logger.Logger() logger >> "Retrieving child " + str(index) if index < 0: return None if index >= self.num_children(): return None try: offset = index * self.data_size return self.start.CreateChildAtOffset( "[" + str(index) + "]", offset, self.data_type ) except: return None def update(self): # preemptively setting this to None - we might end up changing our # mind later self.count = None try: 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() # if any of these objects is invalid, it means there is no # point in trying to fetch anything if ( self.start.IsValid() and self.finish.IsValid() and self.end.IsValid() and self.data_type.IsValid() ): self.count = None else: self.count = 0 except: self.count = 0 return False class StdVBoolImplementation(object): def __init__(self, valobj, bool_type): self.valobj = valobj self.bool_type = bool_type self.valid = False def num_children(self): if self.valid: start = self.start_p.GetValueAsUnsigned(0) finish = self.finish_p.GetValueAsUnsigned(0) offset = self.offset.GetValueAsUnsigned(0) if finish >= start: return (finish - start) * 8 + offset return 0 def get_child_at_index(self, index): if index >= self.num_children(): return None element_type = self.start_p.GetType().GetPointeeType() element_bits = 8 * element_type.GetByteSize() element_offset = (index // element_bits) * element_type.GetByteSize() bit_offset = index % element_bits element = self.start_p.CreateChildAtOffset( "[" + str(index) + "]", element_offset, element_type ) bit = element.GetValueAsUnsigned(0) & (1 << bit_offset) if bit != 0: value_expr = "(bool)true" else: value_expr = "(bool)false" return self.valobj.CreateValueFromExpression("[%d]" % index, value_expr) def update(self): try: m_impl = self.valobj.GetChildMemberWithName("_M_impl") self.m_start = m_impl.GetChildMemberWithName("_M_start") self.m_finish = m_impl.GetChildMemberWithName("_M_finish") self.start_p = self.m_start.GetChildMemberWithName("_M_p") self.finish_p = self.m_finish.GetChildMemberWithName("_M_p") self.offset = self.m_finish.GetChildMemberWithName("_M_offset") if ( self.offset.IsValid() and self.start_p.IsValid() and self.finish_p.IsValid() ): self.valid = True else: self.valid = False except: self.valid = False return False def __init__(self, valobj, dict): logger = lldb.formatters.Logger.Logger() first_template_arg_type = valobj.GetType().GetTemplateArgumentType(0) if str(first_template_arg_type.GetName()) == "bool": self.impl = self.StdVBoolImplementation(valobj, first_template_arg_type) else: self.impl = self.StdVectorImplementation(valobj) logger >> "Providing synthetic children for a vector named " + str( valobj.GetName() ) def num_children(self): return self.impl.num_children() def get_child_index(self, name): try: return int(name.lstrip("[").rstrip("]")) except: return -1 def get_child_at_index(self, index): return self.impl.get_child_at_index(index) def update(self): return self.impl.update() def has_children(self): return True """ This formatter can be applied to all map-like structures (map, multimap, set, multiset) """ class StdMapLikeSynthProvider: def __init__(self, valobj, dict): logger = lldb.formatters.Logger.Logger() self.valobj = valobj self.count = None self.kind = self.get_object_kind(valobj) ( logger >> "Providing synthetic children for a " + self.kind + " named " + str(valobj.GetName()) ) def get_object_kind(self, valobj): type_name = valobj.GetTypeName() for kind in ["multiset", "multimap", "set", "map"]: if kind in type_name: return kind return type_name # we need this function as a temporary workaround for rdar://problem/10801549 # which prevents us from extracting the std::pair SBType out of the template # arguments for _Rep_Type _M_t in the object itself - because we have to make up the # typename and then find it, we may hit the situation were std::string has multiple # names but only one is actually referenced in the debug information. hence, we need # to replace the longer versions of std::string with the shorter one in order to be able # to find the type name def fixup_class_name(self, class_name): logger = lldb.formatters.Logger.Logger() if ( class_name == "std::basic_string, std::allocator >" ): return "std::basic_string", True if ( class_name == "basic_string, std::allocator >" ): return "std::basic_string", True if ( class_name == "std::basic_string, std::allocator >" ): return "std::basic_string", True if ( class_name == "basic_string, std::allocator >" ): return "std::basic_string", True return class_name, False def update(self): logger = lldb.formatters.Logger.Logger() # preemptively setting this to None - we might end up changing our mind # later self.count = None try: # we will set this to True if we find out that discovering a node in the object takes more steps than the overall size of the RB tree # if this gets set to True, then we will merrily return None for # any child from that moment on self.garbage = False self.Mt = self.valobj.GetChildMemberWithName("_M_t") self.Mimpl = self.Mt.GetChildMemberWithName("_M_impl") self.Mheader = self.Mimpl.GetChildMemberWithName("_M_header") if not self.Mheader.IsValid(): self.count = 0 else: map_type = self.valobj.GetType() if map_type.IsReferenceType(): logger >> "Dereferencing type" map_type = map_type.GetDereferencedType() # Get the type of std::pair. It is the first template # argument type of the 4th template argument to std::map. allocator_type = map_type.GetTemplateArgumentType(3) self.data_type = allocator_type.GetTemplateArgumentType(0) if not self.data_type: # GCC does not emit DW_TAG_template_type_parameter for # std::allocator<...>. For such a case, get the type of # std::pair from a member of std::map. rep_type = self.valobj.GetChildMemberWithName("_M_t").GetType() self.data_type = ( rep_type.GetTypedefedType().GetTemplateArgumentType(1) ) # from libstdc++ implementation of _M_root for rbtree self.Mroot = self.Mheader.GetChildMemberWithName("_M_parent") self.data_size = self.data_type.GetByteSize() self.skip_size = self.Mheader.GetType().GetByteSize() except: self.count = 0 return False def num_children(self): logger = lldb.formatters.Logger.Logger() if self.count is None: self.count = self.num_children_impl() return self.count def num_children_impl(self): logger = lldb.formatters.Logger.Logger() try: root_ptr_val = self.node_ptr_value(self.Mroot) if root_ptr_val == 0: return 0 count = self.Mimpl.GetChildMemberWithName( "_M_node_count" ).GetValueAsUnsigned(0) logger >> "I have " + str(count) + " children available" return count except: return 0 def get_child_index(self, name): logger = lldb.formatters.Logger.Logger() try: return int(name.lstrip("[").rstrip("]")) except: return -1 def get_child_at_index(self, index): logger = lldb.formatters.Logger.Logger() logger >> "Being asked to fetch child[" + str(index) + "]" if index < 0: return None if index >= self.num_children(): return None if self.garbage: logger >> "Returning None since we are a garbage tree" return None try: 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 ) except: return None # utility functions def node_ptr_value(self, node): logger = lldb.formatters.Logger.Logger() return node.GetValueAsUnsigned(0) def right(self, node): logger = lldb.formatters.Logger.Logger() return node.GetChildMemberWithName("_M_right") def left(self, node): logger = lldb.formatters.Logger.Logger() return node.GetChildMemberWithName("_M_left") def parent(self, node): logger = lldb.formatters.Logger.Logger() return node.GetChildMemberWithName("_M_parent") # from libstdc++ implementation of iterator for rbtree def increment_node(self, node): logger = lldb.formatters.Logger.Logger() max_steps = self.num_children() if self.node_ptr_value(self.right(node)) != 0: x = self.right(node) max_steps -= 1 while self.node_ptr_value(self.left(x)) != 0: x = self.left(x) max_steps -= 1 logger >> str(max_steps) + " more to go before giving up" if max_steps <= 0: self.garbage = True return None return x else: x = node y = self.parent(x) max_steps -= 1 while self.node_ptr_value(x) == self.node_ptr_value(self.right(y)): x = y y = self.parent(y) max_steps -= 1 logger >> str(max_steps) + " more to go before giving up" if max_steps <= 0: self.garbage = True return None if self.node_ptr_value(self.right(x)) != self.node_ptr_value(y): x = y return x def has_children(self): return True _list_uses_loop_detector = True class StdDequeSynthProvider: def __init__(self, valobj, d): self.valobj = valobj self.pointer_size = self.valobj.GetProcess().GetAddressByteSize() self.count = None self.block_size = -1 self.element_size = -1 self.find_block_size() def find_block_size(self): # in order to use the deque we must have the block size, or else # it's impossible to know what memory addresses are valid self.element_type = self.valobj.GetType().GetTemplateArgumentType(0) if not self.element_type.IsValid(): return self.element_size = self.element_type.GetByteSize() # The block size (i.e. number of elements per subarray) is defined in # this piece of code, so we need to replicate it. # # #define _GLIBCXX_DEQUE_BUF_SIZE 512 # # return (__size < _GLIBCXX_DEQUE_BUF_SIZE # ? size_t(_GLIBCXX_DEQUE_BUF_SIZE / __size) : size_t(1)); if self.element_size < 512: self.block_size = 512 // self.element_size else: self.block_size = 1 def num_children(self): if self.count is None: return 0 return self.count def has_children(self): return True def get_child_index(self, name): try: return int(name.lstrip("[").rstrip("]")) except: return -1 def get_child_at_index(self, index): if index < 0 or self.count is None: return None if index >= self.num_children(): return None try: name = "[" + str(index) + "]" # We first look for the element in the first subarray, # which might be incomplete. if index < self.first_node_size: # The following statement is valid because self.first_elem is the pointer # to the first element return self.first_elem.CreateChildAtOffset( name, index * self.element_size, self.element_type ) # Now the rest of the subarrays except for maybe the last one # are going to be complete, so the final expression is simpler i, j = divmod(index - self.first_node_size, self.block_size) # We first move to the beginning of the node/subarray were our element is node = self.start_node.CreateChildAtOffset( "", (1 + i) * self.valobj.GetProcess().GetAddressByteSize(), self.element_type.GetPointerType(), ) return node.CreateChildAtOffset( name, j * self.element_size, self.element_type ) except: return None def update(self): logger = lldb.formatters.Logger.Logger() self.count = 0 try: # A deque is effectively a two-dim array, with fixed width. # However, only a subset of this memory contains valid data # since a deque may have some slack at the front and back in # order to have O(1) insertion at both ends. # The rows in active use are delimited by '_M_start' and # '_M_finish'. # # To find the elements that are actually constructed, the 'start' # variable tells which element in this NxM array is the 0th # one. if self.block_size < 0 or self.element_size < 0: return False count = 0 impl = self.valobj.GetChildMemberWithName("_M_impl") # we calculate the size of the first node (i.e. first internal array) self.start = impl.GetChildMemberWithName("_M_start") self.start_node = self.start.GetChildMemberWithName("_M_node") first_node_address = self.start_node.GetValueAsUnsigned(0) first_node_last_elem = self.start.GetChildMemberWithName( "_M_last" ).GetValueAsUnsigned(0) self.first_elem = self.start.GetChildMemberWithName("_M_cur") first_node_first_elem = self.first_elem.GetValueAsUnsigned(0) finish = impl.GetChildMemberWithName("_M_finish") last_node_address = finish.GetChildMemberWithName( "_M_node" ).GetValueAsUnsigned(0) last_node_first_elem = finish.GetChildMemberWithName( "_M_first" ).GetValueAsUnsigned(0) last_node_last_elem = finish.GetChildMemberWithName( "_M_cur" ).GetValueAsUnsigned(0) if ( first_node_first_elem == 0 or first_node_last_elem == 0 or first_node_first_elem > first_node_last_elem ): return False if ( last_node_first_elem == 0 or last_node_last_elem == 0 or last_node_first_elem > last_node_last_elem ): return False if last_node_address == first_node_address: self.first_node_size = ( last_node_last_elem - first_node_first_elem ) // self.element_size count += self.first_node_size else: self.first_node_size = ( first_node_last_elem - first_node_first_elem ) // self.element_size count += self.first_node_size # we calculate the size of the last node finish = impl.GetChildMemberWithName("_M_finish") last_node_address = finish.GetChildMemberWithName( "_M_node" ).GetValueAsUnsigned(0) count += ( last_node_last_elem - last_node_first_elem ) // self.element_size # we calculate the size of the intermediate nodes num_intermediate_nodes = ( last_node_address - first_node_address - 1 ) // self.valobj.GetProcess().GetAddressByteSize() count += self.block_size * num_intermediate_nodes self.count = count except: pass return False def VariantSummaryProvider(valobj, dict): raw_obj = valobj.GetNonSyntheticValue() index_obj = raw_obj.GetChildMemberWithName("_M_index") data_obj = raw_obj.GetChildMemberWithName("_M_u") if not (index_obj and index_obj.IsValid() and data_obj and data_obj.IsValid()): return "" def get_variant_npos_value(index_byte_size): if index_byte_size == 1: return 0xFF elif index_byte_size == 2: return 0xFFFF else: return 0xFFFFFFFF npos_value = get_variant_npos_value(index_obj.GetByteSize()) index = index_obj.GetValueAsUnsigned(0) if index == npos_value: return " No Value" # Invalid index can happen when the variant is not initialized yet. template_arg_count = data_obj.GetType().GetNumberOfTemplateArguments() if index >= template_arg_count: return " " active_type = data_obj.GetType().GetTemplateArgumentType(index) return f" Active Type = {active_type.GetDisplayTypeName()} " class VariantSynthProvider: def __init__(self, valobj, dict): self.raw_obj = valobj.GetNonSyntheticValue() self.is_valid = False self.index = None self.data_obj = None def update(self): try: self.index = self.raw_obj.GetChildMemberWithName( "_M_index" ).GetValueAsSigned(-1) self.is_valid = self.index != -1 self.data_obj = self.raw_obj.GetChildMemberWithName("_M_u") except: self.is_valid = False return False def has_children(self): return True def num_children(self): return 1 if self.is_valid else 0 def get_child_index(self, name): return 0 def get_child_at_index(self, index): if not self.is_valid: return None cur = 0 node = self.data_obj while cur < self.index: node = node.GetChildMemberWithName("_M_rest") cur += 1 # _M_storage's type depends on variant field's type "_Type". # 1. if '_Type' is literal type: _Type _M_storage. # 2. otherwise, __gnu_cxx::__aligned_membuf<_Type> _M_storage. # # For 2. we have to cast it to underlying template _Type. value = node.GetChildMemberWithName("_M_first").GetChildMemberWithName( "_M_storage" ) template_type = value.GetType().GetTemplateArgumentType(0) # Literal type will return None for GetTemplateArgumentType(0) if ( template_type and "__gnu_cxx::__aligned_membuf" in value.GetType().GetDisplayTypeName() and template_type.IsValid() ): value = value.Cast(template_type) if value.IsValid(): return value.Clone("Value") return None