From patchwork Tue Sep 12 11:45:08 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jonathan Wakely X-Patchwork-Id: 1832967 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=nLib71f3; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=patchwork.ozlabs.org) Received: from server2.sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4RlMGr386Cz1ygM for ; Tue, 12 Sep 2023 21:45:56 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 5C6B6385480D for ; Tue, 12 Sep 2023 11:45:54 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 5C6B6385480D DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1694519154; bh=XPqw5f+J3FZvwBy8oz2JTlffGHBw9/a462MWEhVJqr4=; h=To:Subject:Date:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=nLib71f3rYv9XHPFM37itR5xYZq/VI4RbPs68TlmNtLLYNgo7YV0/QUwVutyC2edD hwt9HOJIKv3mdeThaHY3ime6t82C4SYWKQWMxgTXoH6b6CrU5ytWUD4j0qX+SyyLBW 5ivwad3YRh0vfWCKyxdNXn6VNPozzrSQuaeGLGUs= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id 9F1303857727 for ; Tue, 12 Sep 2023 11:45:23 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 9F1303857727 Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-7-ulJeJVy8MpWmDZv8tTsfQw-1; Tue, 12 Sep 2023 07:45:21 -0400 X-MC-Unique: ulJeJVy8MpWmDZv8tTsfQw-1 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.rdu2.redhat.com [10.11.54.5]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 3133F803C96; Tue, 12 Sep 2023 11:45:21 +0000 (UTC) Received: from localhost (unknown [10.42.28.190]) by smtp.corp.redhat.com (Postfix) with ESMTP id 8F8167B62; Tue, 12 Sep 2023 11:45:20 +0000 (UTC) To: libstdc++@gcc.gnu.org, gcc-patches@gcc.gnu.org Subject: [committed] libstdc++: Format Python code according to PEP8 Date: Tue, 12 Sep 2023 12:45:08 +0100 Message-ID: <20230912114520.1978760-1-jwakely@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 3.1 on 10.11.54.5 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-35.9 required=5.0 tests=BAYES_00, DKIM_INVALID, DKIM_SIGNED, FILL_THIS_FORM, GIT_PATCH_0, KAM_DMARC_NONE, KAM_DMARC_STATUS, KAM_NUMSUBJECT, KAM_SHORT, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H4, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Jonathan Wakely via Gcc-patches From: Jonathan Wakely Reply-To: Jonathan Wakely Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" Tested x86_64-linux. Pushed to trunk. -- >8 -- These files were filtered through autopep8 to reformat them more conventionally. libstdc++-v3/ChangeLog: * python/libstdcxx/v6/printers.py: Reformat. * python/libstdcxx/v6/xmethods.py: Likewise. --- libstdc++-v3/python/libstdcxx/v6/printers.py | 651 +++++++++++-------- libstdc++-v3/python/libstdcxx/v6/xmethods.py | 58 +- 2 files changed, 446 insertions(+), 263 deletions(-) diff --git a/libstdc++-v3/python/libstdcxx/v6/printers.py b/libstdc++-v3/python/libstdcxx/v6/printers.py index 37a447b514b..c0056de2565 100644 --- a/libstdc++-v3/python/libstdcxx/v6/printers.py +++ b/libstdc++-v3/python/libstdcxx/v6/printers.py @@ -18,10 +18,12 @@ import gdb import itertools import re -import sys, os, errno +import sys +import os +import errno import datetime -### Python 2 + Python 3 compatibility code +# Python 2 + Python 3 compatibility code # Resources about compatibility: # @@ -38,7 +40,7 @@ import datetime # if sys.version_info[0] > 2: - ### Python 3 stuff + # Python 3 stuff Iterator = object # Python 3 folds these into the normal functions. imap = map @@ -47,7 +49,7 @@ if sys.version_info[0] > 2: long = int _utc_timezone = datetime.timezone.utc else: - ### Python 2 stuff + # Python 2 stuff class Iterator: """Compatibility mixin for iterators @@ -98,6 +100,8 @@ except ImportError: # Starting with the type ORIG, search for the member type NAME. This # handles searching upward through superclasses. This is needed to # work around http://sourceware.org/bugzilla/show_bug.cgi?id=13615. + + def find_type(orig, name): typ = orig.strip_typedefs() while True: @@ -116,8 +120,10 @@ def find_type(orig, name): else: raise ValueError("Cannot find type %s::%s" % (str(orig), name)) + _versioned_namespace = '__8::' + def lookup_templ_spec(templ, *args): """ Lookup template specialization templ @@ -139,6 +145,8 @@ def lookup_templ_spec(templ, *args): # Use this to find container node types instead of find_type, # see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91997 for details. + + def lookup_node_type(nodename, containertype): """ Lookup specialization of template NODENAME corresponding to CONTAINERTYPE. @@ -168,6 +176,7 @@ def lookup_node_type(nodename, containertype): pass return None + def is_member_of_namespace(typ, *namespaces): """ Test whether a type is a member of one of the specified namespaces. @@ -181,6 +190,7 @@ def is_member_of_namespace(typ, *namespaces): return True return False + def is_specialization_of(x, template_name): """ Test whether a type is a specialization of the named class template. @@ -195,12 +205,14 @@ def is_specialization_of(x, template_name): return re.match('^std::(%s)?%s<.*>$' % (_versioned_namespace, template_name), x) is not None return re.match('^std::%s<.*>$' % template_name, x) is not None + def strip_versioned_namespace(typename): global _versioned_namespace if _versioned_namespace: return typename.replace(_versioned_namespace, '') return typename + def strip_inline_namespaces(type_str): "Remove known inline namespaces from the canonical name of a type." type_str = strip_versioned_namespace(type_str) @@ -212,6 +224,7 @@ def strip_inline_namespaces(type_str): type_str = type_str.replace(fs_ns+'v1::', fs_ns) return type_str + def get_template_arg_list(type_obj): "Return a type's template arguments as a list" n = 0 @@ -223,6 +236,7 @@ def get_template_arg_list(type_obj): return template_args n += 1 + class SmartPtrIterator(Iterator): "An iterator for smart pointer types with a single 'child' value" @@ -238,28 +252,29 @@ class SmartPtrIterator(Iterator): self.val, val = None, self.val return ('get()', val) + class SharedPointerPrinter: "Print a shared_ptr, weak_ptr, atomic, or atomic" - def __init__ (self, typename, val): + def __init__(self, typename, val): self.typename = strip_versioned_namespace(typename) self.val = val self.pointer = val['_M_ptr'] - def children (self): + def children(self): return SmartPtrIterator(self.pointer) # Return the _Sp_counted_base<>* that holds the refcounts. - def _get_refcounts (self): + def _get_refcounts(self): if self.typename == 'std::atomic': # A tagged pointer is stored as uintptr_t. ptr_val = self.val['_M_refcount']['_M_val']['_M_i'] - ptr_val = ptr_val - (ptr_val % 2) # clear lock bit + ptr_val = ptr_val - (ptr_val % 2) # clear lock bit ptr_type = find_type(self.val['_M_refcount'].type, 'pointer') return ptr_val.cast(ptr_type) return self.val['_M_refcount']['_M_pi'] - def to_string (self): + def to_string(self): state = 'empty' refcounts = self._get_refcounts() targ = self.val.type.template_argument(0) @@ -271,19 +286,23 @@ class SharedPointerPrinter: if usecount == 0: state = 'expired, weak count %d' % weakcount else: - state = 'use count %d, weak count %d' % (usecount, weakcount - 1) + state = 'use count %d, weak count %d' % ( + usecount, weakcount - 1) return '%s<%s> (%s)' % (self.typename, targ, state) + def _tuple_impl_get(val): "Return the tuple element stored in a _Tuple_impl base class." bases = val.type.fields() if not bases[-1].is_base_class: - raise ValueError("Unsupported implementation for std::tuple: %s" % str(val.type)) + raise ValueError( + "Unsupported implementation for std::tuple: %s" % str(val.type)) # Get the _Head_base base class: head_base = val.cast(bases[-1].type) fields = head_base.type.fields() if len(fields) == 0: - raise ValueError("Unsupported implementation for std::tuple: %s" % str(val.type)) + raise ValueError( + "Unsupported implementation for std::tuple: %s" % str(val.type)) if fields[0].name == '_M_head_impl': # The tuple element is the _Head_base::_M_head_impl data member. return head_base['_M_head_impl'] @@ -292,7 +311,9 @@ def _tuple_impl_get(val): # Cast to that empty base class. return head_base.cast(fields[0].type) else: - raise ValueError("Unsupported implementation for std::tuple: %s" % str(val.type)) + raise ValueError( + "Unsupported implementation for std::tuple: %s" % str(val.type)) + def tuple_get(n, val): "Return the result of std::get(val) on a std::tuple" @@ -307,6 +328,7 @@ def tuple_get(n, val): n -= 1 return _tuple_impl_get(node) + def unique_ptr_get(val): "Return the result of val.get() on a std::unique_ptr" # std::unique_ptr contains a std::tuple, @@ -315,30 +337,34 @@ def unique_ptr_get(val): impl_type = val.type.fields()[0].type.strip_typedefs() # Check for new implementations first: if is_specialization_of(impl_type, '__uniq_ptr_data') \ - or is_specialization_of(impl_type, '__uniq_ptr_impl'): + or is_specialization_of(impl_type, '__uniq_ptr_impl'): tuple_member = val['_M_t']['_M_t'] elif is_specialization_of(impl_type, 'tuple'): tuple_member = val['_M_t'] else: - raise ValueError("Unsupported implementation for unique_ptr: %s" % str(impl_type)) + raise ValueError( + "Unsupported implementation for unique_ptr: %s" % str(impl_type)) return tuple_get(0, tuple_member) + class UniquePointerPrinter: "Print a unique_ptr" - def __init__ (self, typename, val): + def __init__(self, typename, val): self.val = val - def children (self): + def children(self): return SmartPtrIterator(unique_ptr_get(self.val)) - def to_string (self): + def to_string(self): return ('std::unique_ptr<%s>' % (str(self.val.type.template_argument(0)))) + def get_value_from_aligned_membuf(buf, valtype): """Returns the value held in a __gnu_cxx::__aligned_membuf.""" return buf['_M_storage'].address.cast(valtype.pointer()).dereference() + def get_value_from_list_node(node): """Returns the value held in an _List_node<_Val>""" try: @@ -354,6 +380,7 @@ def get_value_from_list_node(node): pass raise ValueError("Unsupported implementation for %s" % str(node.type)) + class StdListPrinter: "Print a std::list" @@ -391,6 +418,7 @@ class StdListPrinter: return 'empty %s' % (self.typename) return '%s' % (self.typename) + class NodeIteratorPrinter: def __init__(self, typename, val, contname, nodename): self.val = val @@ -404,12 +432,14 @@ class NodeIteratorPrinter: node = self.val['_M_node'].cast(self.nodetype.pointer()).dereference() return str(get_value_from_list_node(node)) + class StdListIteratorPrinter(NodeIteratorPrinter): "Print std::list::iterator" def __init__(self, typename, val): NodeIteratorPrinter.__init__(self, typename, val, 'list', '_List_node') + class StdFwdListIteratorPrinter(NodeIteratorPrinter): "Print std::forward_list::iterator" @@ -417,6 +447,7 @@ class StdFwdListIteratorPrinter(NodeIteratorPrinter): NodeIteratorPrinter.__init__(self, typename, val, 'forward_list', '_Fwd_list_node') + class StdSlistPrinter: "Print a __gnu_cxx::slist" @@ -450,6 +481,7 @@ class StdSlistPrinter: return 'empty __gnu_cxx::slist' return '__gnu_cxx::slist' + class StdSlistIteratorPrinter: "Print __gnu_cxx::slist::iterator" @@ -459,20 +491,22 @@ class StdSlistIteratorPrinter: def to_string(self): if not self.val['_M_node']: return 'non-dereferenceable iterator for __gnu_cxx::slist' - nodetype = lookup_node_type('__gnu_cxx::_Slist_node', self.val.type).pointer() + nodetype = lookup_node_type( + '__gnu_cxx::_Slist_node', self.val.type).pointer() return str(self.val['_M_node'].cast(nodetype).dereference()['_M_data']) + class StdVectorPrinter: "Print a std::vector" class _iterator(Iterator): - def __init__ (self, start, finish, bitvec): + def __init__(self, start, finish, bitvec): self.bitvec = bitvec if bitvec: - self.item = start['_M_p'] - self.so = 0 + self.item = start['_M_p'] + self.so = 0 self.finish = finish['_M_p'] - self.fo = finish['_M_offset'] + self.fo = finish['_M_offset'] itype = self.item.dereference().type self.isize = 8 * itype.sizeof else: @@ -519,20 +553,21 @@ class StdVectorPrinter: if self.is_bool: start = self.val['_M_impl']['_M_start']['_M_p'] finish = self.val['_M_impl']['_M_finish']['_M_p'] - fo = self.val['_M_impl']['_M_finish']['_M_offset'] + fo = self.val['_M_impl']['_M_finish']['_M_offset'] itype = start.dereference().type bl = 8 * itype.sizeof - length = bl * (finish - start) + fo + length = bl * (finish - start) + fo capacity = bl * (end - start) return ('%s of length %d, capacity %d' - % (self.typename, int (length), int (capacity))) + % (self.typename, int(length), int(capacity))) else: return ('%s of length %d, capacity %d' - % (self.typename, int (finish - start), int (end - start))) + % (self.typename, int(finish - start), int(end - start))) def display_hint(self): return 'array' + class StdVectorIteratorPrinter: "Print std::vector::iterator" @@ -544,6 +579,7 @@ class StdVectorIteratorPrinter: return 'non-dereferenceable iterator for std::vector' return str(self.val['_M_current'].dereference()) + class StdBitIteratorPrinter: "Print std::vector's _Bit_iterator and _Bit_const_iterator" @@ -555,6 +591,7 @@ class StdBitIteratorPrinter: return 'non-dereferenceable iterator for std::vector' return bool(self.val['_M_p'].dereference() & (1 << self.val['_M_offset'])) + class StdBitReferencePrinter: "Print std::vector::reference" @@ -566,51 +603,54 @@ class StdBitReferencePrinter: return 'invalid std::vector::reference' return bool(self.val['_M_p'].dereference() & (self.val['_M_mask'])) + class StdTuplePrinter: "Print a std::tuple" class _iterator(Iterator): @staticmethod - def _is_nonempty_tuple (nodes): - if len (nodes) == 2: - if is_specialization_of (nodes[1].type, '__tuple_base'): + def _is_nonempty_tuple(nodes): + if len(nodes) == 2: + if is_specialization_of(nodes[1].type, '__tuple_base'): return True - elif len (nodes) == 1: + elif len(nodes) == 1: return True - elif len (nodes) == 0: + elif len(nodes) == 0: return False - raise ValueError("Top of tuple tree does not consist of a single node.") + raise ValueError( + "Top of tuple tree does not consist of a single node.") - def __init__ (self, head): + def __init__(self, head): self.head = head # Set the base class as the initial head of the # tuple. - nodes = self.head.type.fields () - if self._is_nonempty_tuple (nodes): + nodes = self.head.type.fields() + if self._is_nonempty_tuple(nodes): # Set the actual head to the first pair. - self.head = self.head.cast (nodes[0].type) + self.head = self.head.cast(nodes[0].type) self.count = 0 - def __iter__ (self): + def __iter__(self): return self - def __next__ (self): + def __next__(self): # Check for further recursions in the inheritance tree. # For a GCC 5+ tuple self.head is None after visiting all nodes: if not self.head: raise StopIteration - nodes = self.head.type.fields () + nodes = self.head.type.fields() # For a GCC 4.x tuple there is a final node with no fields: - if len (nodes) == 0: + if len(nodes) == 0: raise StopIteration # Check that this iteration has an expected structure. - if len (nodes) > 2: - raise ValueError("Cannot parse more than 2 nodes in a tuple tree.") + if len(nodes) > 2: + raise ValueError( + "Cannot parse more than 2 nodes in a tuple tree.") - if len (nodes) == 1: + if len(nodes) == 1: # This is the last node of a GCC 5+ std::tuple. - impl = self.head.cast (nodes[0].type) + impl = self.head.cast(nodes[0].type) self.head = None else: # Either a node before the last node, or the last node of @@ -620,53 +660,55 @@ class StdTuplePrinter: # - Right node is the actual class contained in the tuple. # Process right node. - impl = self.head.cast (nodes[1].type) + impl = self.head.cast(nodes[1].type) # Process left node and set it as head. - self.head = self.head.cast (nodes[0].type) + self.head = self.head.cast(nodes[0].type) self.count = self.count + 1 # Finally, check the implementation. If it is # wrapped in _M_head_impl return that, otherwise return # the value "as is". - fields = impl.type.fields () - if len (fields) < 1 or fields[0].name != "_M_head_impl": + fields = impl.type.fields() + if len(fields) < 1 or fields[0].name != "_M_head_impl": return ('[%d]' % (self.count - 1), impl) else: return ('[%d]' % (self.count - 1), impl['_M_head_impl']) - def __init__ (self, typename, val): + def __init__(self, typename, val): self.typename = strip_versioned_namespace(typename) - self.val = val; + self.val = val - def children (self): - return self._iterator (self.val) + def children(self): + return self._iterator(self.val) - def to_string (self): - if len (self.val.type.fields ()) == 0: + def to_string(self): + if len(self.val.type.fields()) == 0: return 'empty %s' % (self.typename) return '%s containing' % (self.typename) + class StdStackOrQueuePrinter: "Print a std::stack or std::queue" - def __init__ (self, typename, val): + def __init__(self, typename, val): self.typename = strip_versioned_namespace(typename) self.visualizer = gdb.default_visualizer(val['c']) - def children (self): + def children(self): return self.visualizer.children() - def to_string (self): + def to_string(self): return '%s wrapping: %s' % (self.typename, self.visualizer.to_string()) - def display_hint (self): - if hasattr (self.visualizer, 'display_hint'): - return self.visualizer.display_hint () + def display_hint(self): + if hasattr(self.visualizer, 'display_hint'): + return self.visualizer.display_hint() return None + class RbtreeIterator(Iterator): """ Turn an RB-tree-based container (std::map, std::set etc.) into @@ -682,7 +724,7 @@ class RbtreeIterator(Iterator): return self def __len__(self): - return int (self.size) + return int(self.size) def __next__(self): if self.count == self.size: @@ -706,6 +748,7 @@ class RbtreeIterator(Iterator): self.node = node return result + def get_value_from_Rb_tree_node(node): """Returns the value held in an _Rb_tree_node<_Val>""" try: @@ -724,29 +767,32 @@ def get_value_from_Rb_tree_node(node): # This is a pretty printer for std::_Rb_tree_iterator (which is # std::map::iterator), and has nothing to do with the RbtreeIterator # class above. + + class StdRbtreeIteratorPrinter: "Print std::map::iterator, std::set::iterator, etc." - def __init__ (self, typename, val): + def __init__(self, typename, val): self.val = val nodetype = lookup_node_type('_Rb_tree_node', self.val.type) self.link_type = nodetype.pointer() - def to_string (self): + def to_string(self): if not self.val['_M_node']: return 'non-dereferenceable iterator for associative container' node = self.val['_M_node'].cast(self.link_type).dereference() return str(get_value_from_Rb_tree_node(node)) + class StdDebugIteratorPrinter: "Print a debug enabled version of an iterator" - def __init__ (self, typename, val): + def __init__(self, typename, val): self.val = val # Just strip away the encapsulating __gnu_debug::_Safe_iterator # and return the wrapped iterator value. - def to_string (self): + def to_string(self): base_type = gdb.lookup_type('__gnu_debug::_Safe_iterator_base') itype = self.val.type.template_argument(0) safe_seq = self.val.cast(base_type)['_M_sequence'] @@ -756,10 +802,12 @@ class StdDebugIteratorPrinter: return "invalid iterator" return str(self.val.cast(itype)) + def num_elements(num): """Return either "1 element" or "N elements" depending on the argument.""" return '1 element' if num == 1 else '%d elements' % num + class StdMapPrinter: "Print a std::map or std::multimap" @@ -786,21 +834,22 @@ class StdMapPrinter: self.count = self.count + 1 return result - def __init__ (self, typename, val): + def __init__(self, typename, val): self.typename = strip_versioned_namespace(typename) self.val = val - def to_string (self): + def to_string(self): return '%s with %s' % (self.typename, - num_elements(len(RbtreeIterator (self.val)))) + num_elements(len(RbtreeIterator(self.val)))) - def children (self): + def children(self): node = lookup_node_type('_Rb_tree_node', self.val.type).pointer() - return self._iter (RbtreeIterator (self.val), node) + return self._iter(RbtreeIterator(self.val), node) - def display_hint (self): + def display_hint(self): return 'map' + class StdSetPrinter: "Print a std::set or std::multiset" @@ -824,17 +873,18 @@ class StdSetPrinter: self.count = self.count + 1 return result - def __init__ (self, typename, val): + def __init__(self, typename, val): self.typename = strip_versioned_namespace(typename) self.val = val - def to_string (self): + def to_string(self): return '%s with %s' % (self.typename, - num_elements(len(RbtreeIterator (self.val)))) + num_elements(len(RbtreeIterator(self.val)))) - def children (self): + def children(self): node = lookup_node_type('_Rb_tree_node', self.val.type).pointer() - return self._iter (RbtreeIterator (self.val), node) + return self._iter(RbtreeIterator(self.val), node) + class StdBitsetPrinter: "Print a std::bitset" @@ -843,12 +893,12 @@ class StdBitsetPrinter: self.typename = strip_versioned_namespace(typename) self.val = val - def to_string (self): + def to_string(self): # If template_argument handled values, we could print the # size. Or we could use a regexp on the type. return '%s' % (self.typename) - def children (self): + def children(self): try: # An empty bitset may not have any members which will # result in an exception being thrown. @@ -862,7 +912,7 @@ class StdBitsetPrinter: # array. This depends on the template specialization used. # If it is a single long, convert to a single element list. if wtype.code == gdb.TYPE_CODE_ARRAY: - tsize = wtype.target ().sizeof + tsize = wtype.target().sizeof else: words = [words] tsize = wtype.sizeof @@ -882,6 +932,7 @@ class StdBitsetPrinter: byte = byte + 1 return result + class StdDequePrinter: "Print a std::deque" @@ -921,7 +972,7 @@ class StdDequePrinter: self.elttype = val.type.template_argument(0) size = self.elttype.sizeof if size < 512: - self.buffer_size = int (512 / size) + self.buffer_size = int(512 / size) else: self.buffer_size = 1 @@ -943,9 +994,10 @@ class StdDequePrinter: return self._iter(start['_M_node'], start['_M_cur'], start['_M_last'], end['_M_cur'], self.buffer_size) - def display_hint (self): + def display_hint(self): return 'array' + class StdDequeIteratorPrinter: "Print std::deque::iterator" @@ -957,6 +1009,7 @@ class StdDequeIteratorPrinter: return 'non-dereferenceable iterator for std::deque' return str(self.val['_M_cur'].dereference()) + class StdStringPrinter: "Print a std::basic_string of some kind" @@ -968,28 +1021,29 @@ class StdStringPrinter: # Make sure &string works, too. type = self.val.type if type.code == gdb.TYPE_CODE_REF: - type = type.target () + type = type.target() # Calculate the length of the string so that to_string returns # the string according to length, not according to first null # encountered. - ptr = self.val ['_M_dataplus']['_M_p'] + ptr = self.val['_M_dataplus']['_M_p'] if self.new_string: length = self.val['_M_string_length'] # https://sourceware.org/bugzilla/show_bug.cgi?id=17728 ptr = ptr.cast(ptr.type.strip_typedefs()) else: - realtype = type.unqualified ().strip_typedefs () - reptype = gdb.lookup_type (str (realtype) + '::_Rep').pointer () + realtype = type.unqualified().strip_typedefs() + reptype = gdb.lookup_type(str(realtype) + '::_Rep').pointer() header = ptr.cast(reptype) - 1 - length = header.dereference ()['_M_length'] + length = header.dereference()['_M_length'] if hasattr(ptr, "lazy_string"): - return ptr.lazy_string (length = length) - return ptr.string (length = length) + return ptr.lazy_string(length=length) + return ptr.string(length=length) - def display_hint (self): + def display_hint(self): return 'string' + def access_streambuf_ptrs(streambuf): "Access the streambuf put area pointers" pbase = streambuf['_M_out_beg'] @@ -997,6 +1051,7 @@ def access_streambuf_ptrs(streambuf): egptr = streambuf['_M_in_end'] return pbase, pptr, egptr + class StdStringBufPrinter: "Print a std::basic_stringbuf" @@ -1008,14 +1063,15 @@ class StdStringBufPrinter: # Logic from basic_stringbuf::_M_high_mark() if pptr: if not egptr or pptr > egptr: - return pbase.string(length = pptr - pbase) + return pbase.string(length=pptr - pbase) else: - return pbase.string(length = egptr - pbase) + return pbase.string(length=egptr - pbase) return self.val['_M_string'] def display_hint(self): return 'string' + class StdStringStreamPrinter: "Print a std::basic_stringstream" @@ -1041,8 +1097,9 @@ class StdStringStreamPrinter: return None return 'string' + class Tr1HashtableIterator(Iterator): - def __init__ (self, hashtable): + def __init__(self, hashtable): self.buckets = hashtable['_M_buckets'] self.bucket = 0 self.bucket_count = hashtable['_M_bucket_count'] @@ -1054,15 +1111,15 @@ class Tr1HashtableIterator(Iterator): break self.bucket = self.bucket + 1 - def __iter__ (self): + def __iter__(self): return self - def __next__ (self): + def __next__(self): if self.node == 0: raise StopIteration node = self.node.cast(self.node_type) result = node.dereference()['_M_v'] - self.node = node.dereference()['_M_next']; + self.node = node.dereference()['_M_next'] if self.node == 0: self.bucket = self.bucket + 1 while self.bucket != self.bucket_count: @@ -1072,6 +1129,7 @@ class Tr1HashtableIterator(Iterator): self.bucket = self.bucket + 1 return result + class StdHashtableIterator(Iterator): def __init__(self, hashtable): self.node = hashtable['_M_before_begin']['_M_nxt'] @@ -1093,76 +1151,81 @@ class StdHashtableIterator(Iterator): valptr = valptr.cast(elt.type.template_argument(0).pointer()) return valptr.dereference() + class Tr1UnorderedSetPrinter: "Print a std::unordered_set or tr1::unordered_set" - def __init__ (self, typename, val): + def __init__(self, typename, val): self.typename = strip_versioned_namespace(typename) self.val = val - def hashtable (self): + def hashtable(self): if self.typename.startswith('std::tr1'): return self.val return self.val['_M_h'] - def to_string (self): + def to_string(self): count = self.hashtable()['_M_element_count'] return '%s with %s' % (self.typename, num_elements(count)) @staticmethod - def format_count (i): + def format_count(i): return '[%d]' % i - def children (self): - counter = imap (self.format_count, itertools.count()) + def children(self): + counter = imap(self.format_count, itertools.count()) if self.typename.startswith('std::tr1'): - return izip (counter, Tr1HashtableIterator (self.hashtable())) - return izip (counter, StdHashtableIterator (self.hashtable())) + return izip(counter, Tr1HashtableIterator(self.hashtable())) + return izip(counter, StdHashtableIterator(self.hashtable())) + class Tr1UnorderedMapPrinter: "Print a std::unordered_map or tr1::unordered_map" - def __init__ (self, typename, val): + def __init__(self, typename, val): self.typename = strip_versioned_namespace(typename) self.val = val - def hashtable (self): + def hashtable(self): if self.typename.startswith('std::tr1'): return self.val return self.val['_M_h'] - def to_string (self): + def to_string(self): count = self.hashtable()['_M_element_count'] return '%s with %s' % (self.typename, num_elements(count)) @staticmethod - def flatten (list): + def flatten(list): for elt in list: for i in elt: yield i @staticmethod - def format_one (elt): + def format_one(elt): return (elt['first'], elt['second']) @staticmethod - def format_count (i): + def format_count(i): return '[%d]' % i - def children (self): - counter = imap (self.format_count, itertools.count()) + def children(self): + counter = imap(self.format_count, itertools.count()) # Map over the hash table and flatten the result. if self.typename.startswith('std::tr1'): - data = self.flatten (imap (self.format_one, Tr1HashtableIterator (self.hashtable()))) + data = self.flatten( + imap(self.format_one, Tr1HashtableIterator(self.hashtable()))) # Zip the two iterators together. - return izip (counter, data) - data = self.flatten (imap (self.format_one, StdHashtableIterator (self.hashtable()))) + return izip(counter, data) + data = self.flatten( + imap(self.format_one, StdHashtableIterator(self.hashtable()))) # Zip the two iterators together. - return izip (counter, data) + return izip(counter, data) - def display_hint (self): + def display_hint(self): return 'map' + class StdForwardListPrinter: "Print a std::forward_list" @@ -1199,10 +1262,11 @@ class StdForwardListPrinter: return 'empty %s' % self.typename return '%s' % self.typename + class SingleObjContainerPrinter(object): "Base class for printers of containers of single objects" - def __init__ (self, val, viz, hint = None): + def __init__(self, val, viz, hint=None): self.contained_value = val self.visualizer = viz self.hint = hint @@ -1216,10 +1280,10 @@ class SingleObjContainerPrinter(object): type) or str(type) class _contained(Iterator): - def __init__ (self, val): + def __init__(self, val): self.val = val - def __iter__ (self): + def __iter__(self): return self def __next__(self): @@ -1229,19 +1293,20 @@ class SingleObjContainerPrinter(object): self.val = None return ('[contained value]', retval) - def children (self): + def children(self): if self.contained_value is None: - return self._contained (None) - if hasattr (self.visualizer, 'children'): - return self.visualizer.children () - return self._contained (self.contained_value) + return self._contained(None) + if hasattr(self.visualizer, 'children'): + return self.visualizer.children() + return self._contained(self.contained_value) - def display_hint (self): + def display_hint(self): # if contained value is a map we want to display in the same way - if hasattr (self.visualizer, 'children') and hasattr (self.visualizer, 'display_hint'): - return self.visualizer.display_hint () + if hasattr(self.visualizer, 'children') and hasattr(self.visualizer, 'display_hint'): + return self.visualizer.display_hint() return self.hint + def function_pointer_to_name(f): "Find the name of the function referred to by the gdb.Value f, " " which should contain a function pointer from the program." @@ -1265,12 +1330,14 @@ def function_pointer_to_name(f): except: return None + class StdExpAnyPrinter(SingleObjContainerPrinter): "Print a std::any or std::experimental::any" - def __init__ (self, typename, val): + def __init__(self, typename, val): self.typename = strip_versioned_namespace(typename) - self.typename = re.sub('^std::experimental::fundamentals_v\d::', 'std::experimental::', self.typename, 1) + self.typename = re.sub( + '^std::experimental::fundamentals_v\d::', 'std::experimental::', self.typename, 1) self.val = val self.contained_type = None contained_value = None @@ -1279,11 +1346,13 @@ class StdExpAnyPrinter(SingleObjContainerPrinter): if mgr != 0: func = function_pointer_to_name(mgr) if not func: - raise ValueError("Invalid function pointer in %s" % (self.typename)) + raise ValueError( + "Invalid function pointer in %s" % (self.typename)) rx = r"""({0}::_Manager_\w+<.*>)::_S_manage\((enum )?{0}::_Op, (const {0}|{0} const) ?\*, (union )?{0}::_Arg ?\*\)""".format(typename) m = re.match(rx, func) if not m: - raise ValueError("Unknown manager function in %s" % self.typename) + raise ValueError( + "Unknown manager function in %s" % self.typename) mgrname = m.group(1) # FIXME need to expand 'std::string' so that gdb.lookup_type works @@ -1291,11 +1360,13 @@ class StdExpAnyPrinter(SingleObjContainerPrinter): # This lookup for std::string might return the __cxx11 version, # but that's not necessarily the one used by the std::any # manager function we're trying to find. - strings = {str(gdb.lookup_type('std::string').strip_typedefs())} + strings = { + str(gdb.lookup_type('std::string').strip_typedefs())} # So also consider all the other possible std::string types! s = 'basic_string, std::allocator >' - quals = ['std::', 'std::__cxx11::', 'std::' + _versioned_namespace] - strings |= {q+s for q in quals} # set of unique strings + quals = ['std::', 'std::__cxx11::', + 'std::' + _versioned_namespace] + strings |= {q+s for q in quals} # set of unique strings mgrtypes = [] for s in strings: try: @@ -1312,7 +1383,8 @@ class StdExpAnyPrinter(SingleObjContainerPrinter): # std::any in a single program. Can we do better? # Maybe find the address of each type's _S_manage and # compare to the address stored in _M_manager? - raise ValueError('Cannot uniquely determine std::string type used in std::any') + raise ValueError( + 'Cannot uniquely determine std::string type used in std::any') mgrtype = mgrtypes[0] else: mgrtype = gdb.lookup_type(mgrname) @@ -1323,27 +1395,31 @@ class StdExpAnyPrinter(SingleObjContainerPrinter): elif '::_Manager_external' in mgrname: valptr = self.val['_M_storage']['_M_ptr'] else: - raise ValueError("Unknown manager function in %s" % self.typename) - contained_value = valptr.cast(self.contained_type.pointer()).dereference() + raise ValueError( + "Unknown manager function in %s" % self.typename) + contained_value = valptr.cast( + self.contained_type.pointer()).dereference() visualizer = gdb.default_visualizer(contained_value) - super(StdExpAnyPrinter, self).__init__ (contained_value, visualizer) + super(StdExpAnyPrinter, self).__init__(contained_value, visualizer) - def to_string (self): + def to_string(self): if self.contained_type is None: return '%s [no contained value]' % self.typename desc = "%s containing " % self.typename - if hasattr (self.visualizer, 'children'): - return desc + self.visualizer.to_string () - valtype = self._recognize (self.contained_type) + if hasattr(self.visualizer, 'children'): + return desc + self.visualizer.to_string() + valtype = self._recognize(self.contained_type) return desc + strip_versioned_namespace(str(valtype)) + class StdExpOptionalPrinter(SingleObjContainerPrinter): "Print a std::optional or std::experimental::optional" - def __init__ (self, typename, val): - valtype = self._recognize (val.type.template_argument(0)) + def __init__(self, typename, val): + valtype = self._recognize(val.type.template_argument(0)) typename = strip_versioned_namespace(typename) - self.typename = re.sub('^std::(experimental::|)(fundamentals_v\d::|)(.*)', r'std::\1\3', typename, 1) + self.typename = re.sub( + '^std::(experimental::|)(fundamentals_v\d::|)(.*)', r'std::\1\3', typename, 1) payload = val['_M_payload'] if self.typename.startswith('std::experimental'): engaged = val['_M_engaged'] @@ -1356,19 +1432,21 @@ class StdExpOptionalPrinter(SingleObjContainerPrinter): contained_value = contained_value['_M_value'] except: pass - visualizer = gdb.default_visualizer (contained_value) + visualizer = gdb.default_visualizer(contained_value) if not engaged: contained_value = None - super (StdExpOptionalPrinter, self).__init__ (contained_value, visualizer) + super(StdExpOptionalPrinter, self).__init__( + contained_value, visualizer) - def to_string (self): + def to_string(self): if self.contained_value is None: return "%s [no contained value]" % self.typename - if hasattr (self.visualizer, 'children'): + if hasattr(self.visualizer, 'children'): return "%s containing %s" % (self.typename, self.visualizer.to_string()) return self.typename + class StdVariantPrinter(SingleObjContainerPrinter): "Print a std::variant" @@ -1383,9 +1461,11 @@ class StdVariantPrinter(SingleObjContainerPrinter): else: self.contained_type = alternatives[int(self.index)] addr = val['_M_u']['_M_first']['_M_storage'].address - contained_value = addr.cast(self.contained_type.pointer()).dereference() + contained_value = addr.cast( + self.contained_type.pointer()).dereference() visualizer = gdb.default_visualizer(contained_value) - super (StdVariantPrinter, self).__init__(contained_value, visualizer, 'array') + super(StdVariantPrinter, self).__init__( + contained_value, visualizer, 'array') def to_string(self): if self.contained_value is None: @@ -1395,18 +1475,21 @@ class StdVariantPrinter(SingleObjContainerPrinter): self.visualizer.to_string()) return "%s [index %d]" % (self.typename, self.index) + class StdNodeHandlePrinter(SingleObjContainerPrinter): "Print a container node handle" def __init__(self, typename, val): self.value_type = val.type.template_argument(1) nodetype = val.type.template_argument(2).template_argument(0) - self.is_rb_tree_node = is_specialization_of(nodetype.name, '_Rb_tree_node') + self.is_rb_tree_node = is_specialization_of( + nodetype.name, '_Rb_tree_node') self.is_map_node = val.type.template_argument(0) != self.value_type nodeptr = val['_M_ptr'] if nodeptr: if self.is_rb_tree_node: - contained_value = get_value_from_Rb_tree_node(nodeptr.dereference()) + contained_value = get_value_from_Rb_tree_node( + nodeptr.dereference()) else: contained_value = get_value_from_aligned_membuf(nodeptr['_M_storage'], self.value_type) @@ -1424,9 +1507,9 @@ class StdNodeHandlePrinter(SingleObjContainerPrinter): if not self.is_rb_tree_node: desc += 'unordered ' if self.is_map_node: - desc += 'map'; + desc += 'map' else: - desc += 'set'; + desc += 'set' if self.contained_value: desc += ' with element' @@ -1436,31 +1519,33 @@ class StdNodeHandlePrinter(SingleObjContainerPrinter): else: return 'empty %s' % desc + class StdExpStringViewPrinter: "Print a std::basic_string_view or std::experimental::basic_string_view" - def __init__ (self, typename, val): + def __init__(self, typename, val): self.val = val - def to_string (self): + def to_string(self): ptr = self.val['_M_str'] len = self.val['_M_len'] - if hasattr (ptr, "lazy_string"): - return ptr.lazy_string (length = len) - return ptr.string (length = len) + if hasattr(ptr, "lazy_string"): + return ptr.lazy_string(length=len) + return ptr.string(length=len) - def display_hint (self): + def display_hint(self): return 'string' + class StdExpPathPrinter: "Print a std::experimental::filesystem::path" - def __init__ (self, typename, val): + def __init__(self, typename, val): self.val = val self.typename = typename start = self.val['_M_cmpts']['_M_impl']['_M_start'] finish = self.val['_M_cmpts']['_M_impl']['_M_finish'] - self.num_cmpts = int (finish - start) + self.num_cmpts = int(finish - start) def _path_type(self): t = str(self.val['_M_type']) @@ -1470,8 +1555,8 @@ class StdExpPathPrinter: return "root-name" return None - def to_string (self): - path = "%s" % self.val ['_M_pathname'] + def to_string(self): + path = "%s" % self.val['_M_pathname'] if self.num_cmpts == 0: t = self._path_type() if t: @@ -1504,10 +1589,11 @@ class StdExpPathPrinter: def children(self): return self._iterator(self.val['_M_cmpts'], self.typename) + class StdPathPrinter: "Print a std::filesystem::path" - def __init__ (self, typename, val): + def __init__(self, typename, val): self.val = val self.typename = typename impl = unique_ptr_get(self.val['_M_cmpts']['_M_impl']) @@ -1525,8 +1611,8 @@ class StdPathPrinter: return "root-name" return None - def to_string (self): - path = "%s" % self.val ['_M_pathname'] + def to_string(self): + path = "%s" % self.val['_M_pathname'] if self.type != 0: t = self._path_type() if t: @@ -1609,27 +1695,29 @@ class StdPairPrinter: def to_string(self): return None + class StdCmpCatPrinter: "Print a comparison category object" - def __init__ (self, typename, val): + def __init__(self, typename, val): self.typename = typename[typename.rfind(':')+1:] self.val = val['_M_value'] - def to_string (self): + def to_string(self): if self.typename == 'strong_ordering' and self.val == 0: name = 'equal' else: - names = {2:'unordered', -1:'less', 0:'equivalent', 1:'greater'} + names = {2: 'unordered', -1: 'less', 0: 'equivalent', 1: 'greater'} name = names[int(self.val)] return 'std::{}::{}'.format(self.typename, name) + class StdErrorCodePrinter: "Print a std::error_code or std::error_condition" _system_is_posix = None # Whether std::system_category() use errno values. - def __init__ (self, typename, val): + def __init__(self, typename, val): self.val = val self.typename = strip_versioned_namespace(typename) # Do this only once ... @@ -1718,15 +1806,15 @@ class StdErrorCodePrinter: "Strip any nested-name-specifier from NAME to give an unqualified name" return name.split('::')[-1] - def to_string (self): + def to_string(self): value = self.val['_M_value'] cat = self.val['_M_cat'] name, alt_name, enum, is_errno = self._category_info(cat) if value == 0: - default_cats = { 'error_code' : 'system', - 'error_condition' : 'generic' } + default_cats = {'error_code': 'system', + 'error_condition': 'generic'} if name == default_cats[self._unqualified_name(self.typename)]: - return self.typename + ' = { }' # default-constructed value + return self.typename + ' = { }' # default-constructed value strval = str(value) if is_errno and value != 0: @@ -1747,24 +1835,24 @@ class StdErrorCodePrinter: class StdRegexStatePrinter: "Print a state node in the NFA for a std::regex" - def __init__ (self, typename, val): + def __init__(self, typename, val): self.val = val self.typename = typename - def to_string (self): + def to_string(self): opcode = str(self.val['_M_opcode']) if opcode: opcode = opcode[25:] next_id = self.val['_M_next'] - variants = {'repeat':'alt', 'alternative':'alt', - 'subexpr_begin':'subexpr', 'subexpr_end':'subexpr', - 'line_begin_assertion':None, 'line_end_assertion':None, - 'word_boundary':'neg', 'subexpr_lookahead':'neg', - 'backref':'backref_index', - 'match':None, 'accept':None, - 'dummy':None, 'unknown':None - } + variants = {'repeat': 'alt', 'alternative': 'alt', + 'subexpr_begin': 'subexpr', 'subexpr_end': 'subexpr', + 'line_begin_assertion': None, 'line_end_assertion': None, + 'word_boundary': 'neg', 'subexpr_lookahead': 'neg', + 'backref': 'backref_index', + 'match': None, 'accept': None, + 'dummy': None, 'unknown': None + } v = variants[opcode] s = "opcode={}, next={}".format(opcode, next_id) @@ -1772,6 +1860,7 @@ class StdRegexStatePrinter: s = "{}, {}={}".format(s, v, self.val['_M_' + v]) return "{%s}" % (s) + class StdSpanPrinter: "Print a std::span" @@ -1781,10 +1870,10 @@ class StdSpanPrinter: self.begin = begin self.size = size - def __iter__ (self): + def __iter__(self): return self - def __next__ (self): + def __next__(self): if self.count == self.size: raise StopIteration @@ -1809,6 +1898,7 @@ class StdSpanPrinter: def display_hint(self): return 'array' + class StdInitializerListPrinter: "Print a std::initializer_list" @@ -1826,6 +1916,7 @@ class StdInitializerListPrinter: def display_hint(self): return 'array' + class StdAtomicPrinter: "Print a std:atomic" @@ -1860,6 +1951,7 @@ class StdAtomicPrinter: val = self.val['_M_i'] return '%s<%s> = { %s }' % (self.typename, str(self.value_type), val) + class StdFormatArgsPrinter: "Print a std::basic_format_args" # TODO: add printer for basic_format_arg and print out children. @@ -1886,6 +1978,7 @@ class StdFormatArgsPrinter: size = self.val['_M_unpacked_size'] return "%s with %d arguments" % (typ, size) + def std_ratio_t_tuple(ratio_type): # TODO use reduced period i.e. duration::period period = self.val.type.template_argument(1) @@ -1893,6 +1986,7 @@ def std_ratio_t_tuple(ratio_type): den = period.template_argument(1) return (num, den) + class StdChronoDurationPrinter: "Print a std::chrono::duration" @@ -1950,18 +2044,18 @@ class StdChronoTimePointPrinter: return ('std::chrono::sys_time', 0) # XXX need to remove leap seconds from utc, gps, and tai if name == 'std::chrono::utc_clock': - return ('std::chrono::utc_time', None) # XXX + return ('std::chrono::utc_time', None) # XXX if name == 'std::chrono::gps_clock': - return ('std::chrono::gps_time', None) # XXX 315964809 + return ('std::chrono::gps_time', None) # XXX 315964809 if name == 'std::chrono::tai_clock': - return ('std::chrono::tai_time', None) # XXX -378691210 + return ('std::chrono::tai_time', None) # XXX -378691210 if name == 'std::filesystem::__file_clock': return ('std::chrono::file_time', 6437664000) if name == 'std::chrono::local_t': return ('std::chrono::local_time', 0) return ('{} time_point'.format(name), None) - def to_string(self, abbrev = False): + def to_string(self, abbrev=False): clock, offset = self._clock() d = self.val['__d'] r = d['__r'] @@ -1981,6 +2075,7 @@ class StdChronoTimePointPrinter: return s return '%s = { %s }' % (clock, s) + class StdChronoZonedTimePrinter: "Print a std::chrono::zoned_time" @@ -2002,6 +2097,7 @@ months = [None, 'January', 'February', 'March', 'April', 'May', 'June', weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] + class StdChronoCalendarPrinter: "Print a std::chrono::day, std::chrono::month, std::chrono::year etc." @@ -2064,6 +2160,7 @@ class StdChronoCalendarPrinter: h = -h return '{:02}:{:02}:{:02}{}'.format(h, m, s, fract) + class StdChronoTimeZonePrinter: "Print a chrono::time_zone or chrono::time_zone_link" @@ -2077,6 +2174,7 @@ class StdChronoTimeZonePrinter: str += ' -> %s' % (self.val['_M_target']) return str + class StdChronoLeapSecondPrinter: "Print a chrono::leap_second" @@ -2089,6 +2187,7 @@ class StdChronoLeapSecondPrinter: neg = '+-'[date < 0] return '%s %d (%c)' % (self.typename, abs(date), neg) + class StdChronoTzdbPrinter: "Print a chrono::tzdb" @@ -2099,6 +2198,7 @@ class StdChronoTzdbPrinter: def to_string(self): return '%s %s' % (self.typename, self.val['version']) + class StdChronoTimeZoneRulePrinter: "Print a chrono::time_zone rule" @@ -2110,17 +2210,18 @@ class StdChronoTimeZoneRulePrinter: on = self.val['on'] kind = on['kind'] month = months[on['month']] - suffixes = {1:'st', 2:'nd', 3:'rd', 21:'st', 22:'nd', 23:'rd', 31:'st'} + suffixes = {1: 'st', 2: 'nd', 3: 'rd', + 21: 'st', 22: 'nd', 23: 'rd', 31: 'st'} day = on['day_of_month'] ordinal_day = '{}{}'.format(day, suffixes.get(day, 'th')) - if kind == 0: # DayOfMonth - start = '{} {}{}'.format(month, ordinal_day) + if kind == 0: # DayOfMonth + start = '{} {}{}'.format(month, ordinal_day) else: weekday = weekdays[on['day_of_week']] - if kind == 1: # LastWeekDay + if kind == 1: # LastWeekDay start = 'last {} in {}'.format(weekday, month) else: - if kind == 2: # LessEq + if kind == 2: # LessEq direction = ('last', '<=') else: direction = ('first', '>=') @@ -2129,7 +2230,8 @@ class StdChronoTimeZoneRulePrinter: direction[1], month, ordinal_day) return 'time_zone rule {} from {} to {} starting on {}'.format( - self.val['name'], self.val['from'], self.val['to'], start) + self.val['name'], self.val['from'], self.val['to'], start) + class StdLocalePrinter: "Print a std::locale" @@ -2146,7 +2248,7 @@ class StdLocalePrinter: else: cats = gdb.parse_and_eval(self.typename + '::_S_categories') ncat = gdb.parse_and_eval(self.typename + '::_S_categories_size') - n = names[0].string(); + n = names[0].string() cat = cats[0].string() name = '{}={}'.format(cat, n) cat_names = {cat: n} @@ -2171,7 +2273,7 @@ class StdLocalePrinter: name = n1 other = n2 if other is not None: - cat = next(c for c,n in cat_names.items() if n == other) + cat = next(c for c, n in cat_names.items() if n == other) mod = ' with "{}={}"'.format(cat, other) return 'std::locale = "{}"{}'.format(name, mod) @@ -2190,13 +2292,15 @@ class RxPrinter(object): return None if value.type.code == gdb.TYPE_CODE_REF: - if hasattr(gdb.Value,"referenced_value"): + if hasattr(gdb.Value, "referenced_value"): value = value.referenced_value() return self.function(self.name, value) # A pretty-printer that conforms to the "PrettyPrinter" protocol from # gdb.printing. It can also be used directly as an old-style printer. + + class Printer(object): def __init__(self, name): super(Printer, self).__init__() @@ -2210,7 +2314,8 @@ class Printer(object): # A small sanity check. # FIXME if not self.compiled_rx.match(name): - raise ValueError('libstdc++ programming error: "%s" does not match' % name) + raise ValueError( + 'libstdc++ programming error: "%s" does not match' % name) printer = RxPrinter(name, function) self.subprinters.append(printer) self.lookup[name] = printer @@ -2219,7 +2324,8 @@ class Printer(object): def add_version(self, base, name, function): self.add(base + name, function) if _versioned_namespace and not '__cxx11' in base: - vbase = re.sub('^(std|__gnu_cxx)::', r'\g<0>%s' % _versioned_namespace, base) + vbase = re.sub('^(std|__gnu_cxx)::', r'\g<0>%s' % + _versioned_namespace, base) self.add(vbase + name, function) # Add a name using _GLIBCXX_BEGIN_NAMESPACE_CONTAINER. @@ -2231,10 +2337,10 @@ class Printer(object): def get_basic_type(type): # If it points to a reference, get the reference. if type.code == gdb.TYPE_CODE_REF: - type = type.target () + type = type.target() # Get the unqualified type, stripped of typedefs. - type = type.unqualified ().strip_typedefs () + type = type.unqualified().strip_typedefs() return type.tag @@ -2252,7 +2358,7 @@ class Printer(object): basename = match.group(1) if val.type.code == gdb.TYPE_CODE_REF: - if hasattr(gdb.Value,"referenced_value"): + if hasattr(gdb.Value, "referenced_value"): val = val.referenced_value() if basename in self.lookup: @@ -2261,8 +2367,10 @@ class Printer(object): # Cannot find a pretty printer. Return None. return None + libstdcxx_printer = None + class TemplateTypePrinter(object): r""" A type printer for class templates with default template arguments. @@ -2345,7 +2453,7 @@ class TemplateTypePrinter(object): if type_obj.code == gdb.TYPE_CODE_ARRAY: type_str = self._recognize_subtype(type_obj.target()) if str(type_obj.strip_typedefs()).endswith('[]'): - return type_str + '[]' # array of unknown bound + return type_str + '[]' # array of unknown bound return "%s[%d]" % (type_str, type_obj.range()[1] + 1) if type_obj.code == gdb.TYPE_CODE_REF: return self._recognize_subtype(type_obj.target()) + '&' @@ -2354,7 +2462,7 @@ class TemplateTypePrinter(object): return self._recognize_subtype(type_obj.target()) + '&&' type_str = gdb.types.apply_type_recognizers( - gdb.types.get_type_recognizers(), type_obj) + gdb.types.get_type_recognizers(), type_obj) if type_str: return type_str return str(type_obj) @@ -2363,6 +2471,7 @@ class TemplateTypePrinter(object): "Return a recognizer object for this type printer." return self._recognizer(self.name, self.defargs) + def add_one_template_type_printer(obj, name, defargs): r""" Add a type printer for a class template with default template arguments. @@ -2391,7 +2500,8 @@ def add_one_template_type_printer(obj, name, defargs): # Add second type printer for same type in versioned namespace: ns = 'std::' + _versioned_namespace # PR 86112 Cannot use dict comprehension here: - defargs = dict((n, d.replace('std::', ns)) for (n,d) in defargs.items()) + defargs = dict((n, d.replace('std::', ns)) + for (n, d) in defargs.items()) printer = TemplateTypePrinter(ns+name, defargs) gdb.types.register_type_printer(obj, printer) @@ -2399,6 +2509,7 @@ def add_one_template_type_printer(obj, name, defargs): printer = TemplateTypePrinter('std::__debug::'+name, defargs) gdb.types.register_type_printer(obj, printer) + class FilteringTypePrinter(object): r""" A type printer that uses typedef names for common template specializations. @@ -2421,7 +2532,7 @@ class FilteringTypePrinter(object): more quickly, without needing to do GDB type lookups. """ - def __init__(self, template, name, targ1 = None): + def __init__(self, template, name, targ1=None): self.template = template self.name = name self.targ1 = targ1 @@ -2475,7 +2586,8 @@ class FilteringTypePrinter(object): "Return a recognizer object for this type printer." return self._recognizer(self.template, self.name, self.targ1) -def add_one_type_printer(obj, template, name, targ1 = None): + +def add_one_type_printer(obj, template, name, targ1=None): printer = FilteringTypePrinter('std::' + template, 'std::' + name, targ1) gdb.types.register_type_printer(obj, printer) if _versioned_namespace and not '__cxx11' in template: @@ -2483,6 +2595,7 @@ def add_one_type_printer(obj, template, name, targ1 = None): printer = FilteringTypePrinter(ns + template, ns + name, targ1) gdb.types.register_type_printer(obj, printer) + def register_type_printers(obj): global _use_type_printing @@ -2496,11 +2609,13 @@ def register_type_printers(obj): ('u16', 'char16_t'), ('u32', 'char32_t')): add_one_type_printer(obj, 'basic_string', ch[0] + 'string', ch[1]) - add_one_type_printer(obj, '__cxx11::basic_string', ch[0] + 'string', ch[1]) + add_one_type_printer(obj, '__cxx11::basic_string', + ch[0] + 'string', ch[1]) # Typedefs for __cxx11::basic_string used to be in namespace __cxx11: add_one_type_printer(obj, '__cxx11::basic_string', '__cxx11::' + ch[0] + 'string', ch[1]) - add_one_type_printer(obj, 'basic_string_view', ch[0] + 'string_view', ch[1]) + add_one_type_printer(obj, 'basic_string_view', + ch[0] + 'string_view', ch[1]) # Add type printers for typedefs std::istream, std::wistream etc. for ch in (('', 'char'), ('w', 'wchar_t')): @@ -2516,9 +2631,11 @@ def register_type_printers(obj): # Add type printers for typedefs regex, wregex, cmatch, wcmatch etc. for abi in ('', '__cxx11::'): for ch in (('', 'char'), ('w', 'wchar_t')): - add_one_type_printer(obj, abi + 'basic_regex', abi + ch[0] + 'regex', ch[1]) + add_one_type_printer(obj, abi + 'basic_regex', + abi + ch[0] + 'regex', ch[1]) for ch in ('c', 's', 'wc', 'ws'): - add_one_type_printer(obj, abi + 'match_results', abi + ch + 'match') + add_one_type_printer( + obj, abi + 'match_results', abi + ch + 'match') for x in ('sub_match', 'regex_iterator', 'regex_token_iterator'): add_one_type_printer(obj, abi + x, abi + ch + x) @@ -2554,40 +2671,43 @@ def register_type_printers(obj): # Do not show defaulted template arguments in class templates. add_one_template_type_printer(obj, 'unique_ptr', - { 1: 'std::default_delete<{0}>' }) - add_one_template_type_printer(obj, 'deque', { 1: 'std::allocator<{0}>'}) - add_one_template_type_printer(obj, 'forward_list', { 1: 'std::allocator<{0}>'}) - add_one_template_type_printer(obj, 'list', { 1: 'std::allocator<{0}>'}) - add_one_template_type_printer(obj, '__cxx11::list', { 1: 'std::allocator<{0}>'}) - add_one_template_type_printer(obj, 'vector', { 1: 'std::allocator<{0}>'}) + {1: 'std::default_delete<{0}>'}) + add_one_template_type_printer(obj, 'deque', {1: 'std::allocator<{0}>'}) + add_one_template_type_printer( + obj, 'forward_list', {1: 'std::allocator<{0}>'}) + add_one_template_type_printer(obj, 'list', {1: 'std::allocator<{0}>'}) + add_one_template_type_printer( + obj, '__cxx11::list', {1: 'std::allocator<{0}>'}) + add_one_template_type_printer(obj, 'vector', {1: 'std::allocator<{0}>'}) add_one_template_type_printer(obj, 'map', - { 2: 'std::less<{0}>', - 3: 'std::allocator>' }) + {2: 'std::less<{0}>', + 3: 'std::allocator>'}) add_one_template_type_printer(obj, 'multimap', - { 2: 'std::less<{0}>', - 3: 'std::allocator>' }) + {2: 'std::less<{0}>', + 3: 'std::allocator>'}) add_one_template_type_printer(obj, 'set', - { 1: 'std::less<{0}>', 2: 'std::allocator<{0}>' }) + {1: 'std::less<{0}>', 2: 'std::allocator<{0}>'}) add_one_template_type_printer(obj, 'multiset', - { 1: 'std::less<{0}>', 2: 'std::allocator<{0}>' }) + {1: 'std::less<{0}>', 2: 'std::allocator<{0}>'}) add_one_template_type_printer(obj, 'unordered_map', - { 2: 'std::hash<{0}>', - 3: 'std::equal_to<{0}>', - 4: 'std::allocator>'}) + {2: 'std::hash<{0}>', + 3: 'std::equal_to<{0}>', + 4: 'std::allocator>'}) add_one_template_type_printer(obj, 'unordered_multimap', - { 2: 'std::hash<{0}>', - 3: 'std::equal_to<{0}>', - 4: 'std::allocator>'}) + {2: 'std::hash<{0}>', + 3: 'std::equal_to<{0}>', + 4: 'std::allocator>'}) add_one_template_type_printer(obj, 'unordered_set', - { 1: 'std::hash<{0}>', - 2: 'std::equal_to<{0}>', - 3: 'std::allocator<{0}>'}) + {1: 'std::hash<{0}>', + 2: 'std::equal_to<{0}>', + 3: 'std::allocator<{0}>'}) add_one_template_type_printer(obj, 'unordered_multiset', - { 1: 'std::hash<{0}>', - 2: 'std::equal_to<{0}>', - 3: 'std::allocator<{0}>'}) + {1: 'std::hash<{0}>', + 2: 'std::equal_to<{0}>', + 3: 'std::allocator<{0}>'}) -def register_libstdcxx_printers (obj): + +def register_libstdcxx_printers(obj): "Register libstdc++ pretty-printers with objfile Obj." global _use_gdb_pp @@ -2602,7 +2722,8 @@ def register_libstdcxx_printers (obj): register_type_printers(obj) -def build_libstdcxx_dictionary (): + +def build_libstdcxx_dictionary(): global libstdcxx_printer libstdcxx_printer = Printer("libstdc++-v6") @@ -2611,7 +2732,8 @@ def build_libstdcxx_dictionary (): # In order from: # http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01847.html libstdcxx_printer.add_version('std::', 'basic_string', StdStringPrinter) - libstdcxx_printer.add_version('std::__cxx11::', 'basic_string', StdStringPrinter) + libstdcxx_printer.add_version( + 'std::__cxx11::', 'basic_string', StdStringPrinter) libstdcxx_printer.add_container('std::', 'bitset', StdBitsetPrinter) libstdcxx_printer.add_container('std::', 'deque', StdDequePrinter) libstdcxx_printer.add_container('std::', 'list', StdListPrinter) @@ -2662,8 +2784,10 @@ def build_libstdcxx_dictionary (): libstdcxx_printer.add_container('std::', 'forward_list', StdForwardListPrinter) - libstdcxx_printer.add_version('std::tr1::', 'shared_ptr', SharedPointerPrinter) - libstdcxx_printer.add_version('std::tr1::', 'weak_ptr', SharedPointerPrinter) + libstdcxx_printer.add_version( + 'std::tr1::', 'shared_ptr', SharedPointerPrinter) + libstdcxx_printer.add_version( + 'std::tr1::', 'weak_ptr', SharedPointerPrinter) libstdcxx_printer.add_version('std::tr1::', 'unordered_map', Tr1UnorderedMapPrinter) libstdcxx_printer.add_version('std::tr1::', 'unordered_set', @@ -2676,11 +2800,15 @@ def build_libstdcxx_dictionary (): libstdcxx_printer.add_version('std::', 'initializer_list', StdInitializerListPrinter) libstdcxx_printer.add_version('std::', 'atomic', StdAtomicPrinter) - libstdcxx_printer.add_version('std::', 'basic_stringbuf', StdStringBufPrinter) - libstdcxx_printer.add_version('std::__cxx11::', 'basic_stringbuf', StdStringBufPrinter) + libstdcxx_printer.add_version( + 'std::', 'basic_stringbuf', StdStringBufPrinter) + libstdcxx_printer.add_version( + 'std::__cxx11::', 'basic_stringbuf', StdStringBufPrinter) for sstream in ('istringstream', 'ostringstream', 'stringstream'): - libstdcxx_printer.add_version('std::', 'basic_' + sstream, StdStringStreamPrinter) - libstdcxx_printer.add_version('std::__cxx11::', 'basic_' + sstream, StdStringStreamPrinter) + libstdcxx_printer.add_version( + 'std::', 'basic_' + sstream, StdStringStreamPrinter) + libstdcxx_printer.add_version( + 'std::__cxx11::', 'basic_' + sstream, StdStringStreamPrinter) libstdcxx_printer.add_version('std::chrono::', 'duration', StdChronoDurationPrinter) @@ -2735,16 +2863,17 @@ def build_libstdcxx_dictionary (): '_Node_handle', StdNodeHandlePrinter) # C++20 components - libstdcxx_printer.add_version('std::', 'partial_ordering', StdCmpCatPrinter) + libstdcxx_printer.add_version( + 'std::', 'partial_ordering', StdCmpCatPrinter) libstdcxx_printer.add_version('std::', 'weak_ordering', StdCmpCatPrinter) libstdcxx_printer.add_version('std::', 'strong_ordering', StdCmpCatPrinter) libstdcxx_printer.add_version('std::', 'span', StdSpanPrinter) libstdcxx_printer.add_version('std::', 'basic_format_args', StdFormatArgsPrinter) - for c in ['day','month','year','weekday','weekday_indexed','weekday_last', - 'month_day','month_day_last','month_weekday','month_weekday_last', - 'year_month','year_month_day','year_month_day_last', - 'year_month_weekday','year_month_weekday_last', 'hh_mm_ss']: + for c in ['day', 'month', 'year', 'weekday', 'weekday_indexed', 'weekday_last', + 'month_day', 'month_day_last', 'month_weekday', 'month_weekday_last', + 'year_month', 'year_month_day', 'year_month_day_last', + 'year_month_weekday', 'year_month_weekday_last', 'hh_mm_ss']: libstdcxx_printer.add_version('std::chrono::', c, StdChronoCalendarPrinter) libstdcxx_printer.add_version('std::chrono::', 'time_zone', @@ -2755,8 +2884,9 @@ def build_libstdcxx_dictionary (): StdChronoZonedTimePrinter) libstdcxx_printer.add_version('std::chrono::', 'leap_second', StdChronoLeapSecondPrinter) - libstdcxx_printer.add_version('std::chrono::', 'tzdb', StdChronoTzdbPrinter) - #libstdcxx_printer.add_version('std::chrono::(anonymous namespace)', 'Rule', + libstdcxx_printer.add_version( + 'std::chrono::', 'tzdb', StdChronoTzdbPrinter) + # libstdcxx_printer.add_version('std::chrono::(anonymous namespace)', 'Rule', # StdChronoTimeZoneRulePrinter) # Extensions. @@ -2780,11 +2910,11 @@ def build_libstdcxx_dictionary (): libstdcxx_printer.add_version('__gnu_cxx::', '__normal_iterator', StdVectorIteratorPrinter) libstdcxx_printer.add_container('std::', '_Bit_iterator', - StdBitIteratorPrinter) + StdBitIteratorPrinter) libstdcxx_printer.add_container('std::', '_Bit_const_iterator', - StdBitIteratorPrinter) + StdBitIteratorPrinter) libstdcxx_printer.add_container('std::', '_Bit_reference', - StdBitReferencePrinter) + StdBitReferencePrinter) libstdcxx_printer.add_version('__gnu_cxx::', '_Slist_iterator', StdSlistIteratorPrinter) libstdcxx_printer.add_container('std::', '_Fwd_list_iterator', @@ -2797,4 +2927,5 @@ def build_libstdcxx_dictionary (): libstdcxx_printer.add('__gnu_debug::_Safe_iterator', StdDebugIteratorPrinter) -build_libstdcxx_dictionary () + +build_libstdcxx_dictionary() diff --git a/libstdc++-v3/python/libstdcxx/v6/xmethods.py b/libstdc++-v3/python/libstdcxx/v6/xmethods.py index 18a165f425e..025b1b86ed0 100644 --- a/libstdc++-v3/python/libstdcxx/v6/xmethods.py +++ b/libstdc++-v3/python/libstdcxx/v6/xmethods.py @@ -21,12 +21,15 @@ import re matcher_name_prefix = 'libstdc++::' + def get_bool_type(): return gdb.lookup_type('bool') + def get_std_size_type(): return gdb.lookup_type('std::size_t') + class LibStdCxxXMethod(gdb.xmethod.XMethod): def __init__(self, name, worker_class): gdb.xmethod.XMethod.__init__(self, name) @@ -34,6 +37,7 @@ class LibStdCxxXMethod(gdb.xmethod.XMethod): # Xmethods for std::array + class ArrayWorkerBase(gdb.xmethod.XMethodWorker): def __init__(self, val_type, size): self._val_type = val_type @@ -43,6 +47,7 @@ class ArrayWorkerBase(gdb.xmethod.XMethodWorker): nullptr = gdb.parse_and_eval('(void *) 0') return nullptr.cast(self._val_type.pointer()).dereference() + class ArraySizeWorker(ArrayWorkerBase): def __init__(self, val_type, size): ArrayWorkerBase.__init__(self, val_type, size) @@ -56,6 +61,7 @@ class ArraySizeWorker(ArrayWorkerBase): def __call__(self, obj): return self._size + class ArrayEmptyWorker(ArrayWorkerBase): def __init__(self, val_type, size): ArrayWorkerBase.__init__(self, val_type, size) @@ -69,6 +75,7 @@ class ArrayEmptyWorker(ArrayWorkerBase): def __call__(self, obj): return (int(self._size) == 0) + class ArrayFrontWorker(ArrayWorkerBase): def __init__(self, val_type, size): ArrayWorkerBase.__init__(self, val_type, size) @@ -85,6 +92,7 @@ class ArrayFrontWorker(ArrayWorkerBase): else: return self.null_value() + class ArrayBackWorker(ArrayWorkerBase): def __init__(self, val_type, size): ArrayWorkerBase.__init__(self, val_type, size) @@ -101,6 +109,7 @@ class ArrayBackWorker(ArrayWorkerBase): else: return self.null_value() + class ArrayAtWorker(ArrayWorkerBase): def __init__(self, val_type, size): ArrayWorkerBase.__init__(self, val_type, size) @@ -117,6 +126,7 @@ class ArrayAtWorker(ArrayWorkerBase): ((int(index), self._size))) return obj['_M_elems'][index] + class ArraySubscriptWorker(ArrayWorkerBase): def __init__(self, val_type, size): ArrayWorkerBase.__init__(self, val_type, size) @@ -133,6 +143,7 @@ class ArraySubscriptWorker(ArrayWorkerBase): else: return self.null_value() + class ArrayMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self): gdb.xmethod.XMethodMatcher.__init__(self, @@ -162,6 +173,7 @@ class ArrayMethodsMatcher(gdb.xmethod.XMethodMatcher): # Xmethods for std::deque + class DequeWorkerBase(gdb.xmethod.XMethodWorker): def __init__(self, val_type): self._val_type = val_type @@ -179,6 +191,7 @@ class DequeWorkerBase(gdb.xmethod.XMethodWorker): index_node = first_node + int(idx) // self._bufsize return index_node[0][idx % self._bufsize] + class DequeEmptyWorker(DequeWorkerBase): def get_arg_types(self): return None @@ -190,6 +203,7 @@ class DequeEmptyWorker(DequeWorkerBase): return (obj['_M_impl']['_M_start']['_M_cur'] == obj['_M_impl']['_M_finish']['_M_cur']) + class DequeSizeWorker(DequeWorkerBase): def get_arg_types(self): return None @@ -200,6 +214,7 @@ class DequeSizeWorker(DequeWorkerBase): def __call__(self, obj): return self.size(obj) + class DequeFrontWorker(DequeWorkerBase): def get_arg_types(self): return None @@ -210,6 +225,7 @@ class DequeFrontWorker(DequeWorkerBase): def __call__(self, obj): return obj['_M_impl']['_M_start']['_M_cur'][0] + class DequeBackWorker(DequeWorkerBase): def get_arg_types(self): return None @@ -219,12 +235,13 @@ class DequeBackWorker(DequeWorkerBase): def __call__(self, obj): if (obj['_M_impl']['_M_finish']['_M_cur'] == - obj['_M_impl']['_M_finish']['_M_first']): + obj['_M_impl']['_M_finish']['_M_first']): prev_node = obj['_M_impl']['_M_finish']['_M_node'] - 1 return prev_node[0][self._bufsize - 1] else: return obj['_M_impl']['_M_finish']['_M_cur'][-1] + class DequeSubscriptWorker(DequeWorkerBase): def get_arg_types(self): return get_std_size_type() @@ -235,6 +252,7 @@ class DequeSubscriptWorker(DequeWorkerBase): def __call__(self, obj, subscript): return self.index(obj, subscript) + class DequeAtWorker(DequeWorkerBase): def get_arg_types(self): return get_std_size_type() @@ -248,7 +266,8 @@ class DequeAtWorker(DequeWorkerBase): raise IndexError('Deque index "%d" should not be >= %d.' % (int(index), deque_size)) else: - return self.index(obj, index) + return self.index(obj, index) + class DequeMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self): @@ -274,6 +293,7 @@ class DequeMethodsMatcher(gdb.xmethod.XMethodMatcher): # Xmethods for std::forward_list + class ForwardListWorkerBase(gdb.xmethod.XMethodMatcher): def __init__(self, val_type, node_type): self._val_type = val_type @@ -282,6 +302,7 @@ class ForwardListWorkerBase(gdb.xmethod.XMethodMatcher): def get_arg_types(self): return None + class ForwardListEmptyWorker(ForwardListWorkerBase): def get_result_type(self, obj): return get_bool_type() @@ -289,6 +310,7 @@ class ForwardListEmptyWorker(ForwardListWorkerBase): def __call__(self, obj): return obj['_M_impl']['_M_head']['_M_next'] == 0 + class ForwardListFrontWorker(ForwardListWorkerBase): def get_result_type(self, obj): return self._val_type @@ -298,6 +320,7 @@ class ForwardListFrontWorker(ForwardListWorkerBase): val_address = node['_M_storage']['_M_storage'].address return val_address.cast(self._val_type.pointer()).dereference() + class ForwardListMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self): matcher_name = matcher_name_prefix + 'forward_list' @@ -320,6 +343,7 @@ class ForwardListMethodsMatcher(gdb.xmethod.XMethodMatcher): # Xmethods for std::list + class ListWorkerBase(gdb.xmethod.XMethodWorker): def __init__(self, val_type, node_type): self._val_type = val_type @@ -337,6 +361,7 @@ class ListWorkerBase(gdb.xmethod.XMethodWorker): addr = node['_M_storage'].address return addr.cast(self._val_type.pointer()).dereference() + class ListEmptyWorker(ListWorkerBase): def get_result_type(self, obj): return get_bool_type() @@ -348,6 +373,7 @@ class ListEmptyWorker(ListWorkerBase): else: return False + class ListSizeWorker(ListWorkerBase): def get_result_type(self, obj): return get_std_size_type() @@ -361,6 +387,7 @@ class ListSizeWorker(ListWorkerBase): size += 1 return size + class ListFrontWorker(ListWorkerBase): def get_result_type(self, obj): return self._val_type @@ -369,6 +396,7 @@ class ListFrontWorker(ListWorkerBase): node = obj['_M_impl']['_M_node']['_M_next'].cast(self._node_type) return self.get_value_from_node(node) + class ListBackWorker(ListWorkerBase): def get_result_type(self, obj): return self._val_type @@ -377,6 +405,7 @@ class ListBackWorker(ListWorkerBase): prev_node = obj['_M_impl']['_M_node']['_M_prev'].cast(self._node_type) return self.get_value_from_node(prev_node) + class ListMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self): gdb.xmethod.XMethodMatcher.__init__(self, @@ -401,6 +430,7 @@ class ListMethodsMatcher(gdb.xmethod.XMethodMatcher): # Xmethods for std::vector + class VectorWorkerBase(gdb.xmethod.XMethodWorker): def __init__(self, val_type): self._val_type = val_type @@ -425,6 +455,7 @@ class VectorWorkerBase(gdb.xmethod.XMethodWorker): else: return obj['_M_impl']['_M_start'][index] + class VectorEmptyWorker(VectorWorkerBase): def get_arg_types(self): return None @@ -435,6 +466,7 @@ class VectorEmptyWorker(VectorWorkerBase): def __call__(self, obj): return int(self.size(obj)) == 0 + class VectorSizeWorker(VectorWorkerBase): def get_arg_types(self): return None @@ -445,6 +477,7 @@ class VectorSizeWorker(VectorWorkerBase): def __call__(self, obj): return self.size(obj) + class VectorFrontWorker(VectorWorkerBase): def get_arg_types(self): return None @@ -455,6 +488,7 @@ class VectorFrontWorker(VectorWorkerBase): def __call__(self, obj): return self.get(obj, 0) + class VectorBackWorker(VectorWorkerBase): def get_arg_types(self): return None @@ -465,6 +499,7 @@ class VectorBackWorker(VectorWorkerBase): def __call__(self, obj): return self.get(obj, int(self.size(obj)) - 1) + class VectorAtWorker(VectorWorkerBase): def get_arg_types(self): return get_std_size_type() @@ -479,6 +514,7 @@ class VectorAtWorker(VectorWorkerBase): ((int(index), size))) return self.get(obj, int(index)) + class VectorSubscriptWorker(VectorWorkerBase): def get_arg_types(self): return get_std_size_type() @@ -489,6 +525,7 @@ class VectorSubscriptWorker(VectorWorkerBase): def __call__(self, obj, subscript): return self.get(obj, int(subscript)) + class VectorMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self): gdb.xmethod.XMethodMatcher.__init__(self, @@ -514,6 +551,7 @@ class VectorMethodsMatcher(gdb.xmethod.XMethodMatcher): # Xmethods for associative containers + class AssociativeContainerWorkerBase(gdb.xmethod.XMethodWorker): def __init__(self, unordered): self._unordered = unordered @@ -527,6 +565,7 @@ class AssociativeContainerWorkerBase(gdb.xmethod.XMethodWorker): def get_arg_types(self): return None + class AssociativeContainerEmptyWorker(AssociativeContainerWorkerBase): def get_result_type(self, obj): return get_bool_type() @@ -534,6 +573,7 @@ class AssociativeContainerEmptyWorker(AssociativeContainerWorkerBase): def __call__(self, obj): return int(self.node_count(obj)) == 0 + class AssociativeContainerSizeWorker(AssociativeContainerWorkerBase): def get_result_type(self, obj): return get_std_size_type() @@ -541,6 +581,7 @@ class AssociativeContainerSizeWorker(AssociativeContainerWorkerBase): def __call__(self, obj): return self.node_count(obj) + class AssociativeContainerMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self, name): gdb.xmethod.XMethodMatcher.__init__(self, @@ -564,6 +605,7 @@ class AssociativeContainerMethodsMatcher(gdb.xmethod.XMethodMatcher): # Xmethods for std::unique_ptr + class UniquePtrGetWorker(gdb.xmethod.XMethodWorker): "Implements std::unique_ptr::get() and std::unique_ptr::operator->()" @@ -593,7 +635,7 @@ class UniquePtrGetWorker(gdb.xmethod.XMethodWorker): tuple_member = obj['_M_t'] else: return None - tuple_impl_type = tuple_member.type.fields()[0].type # _Tuple_impl + tuple_impl_type = tuple_member.type.fields()[0].type # _Tuple_impl tuple_head_type = tuple_impl_type.fields()[1].type # _Head_base head_field = tuple_head_type.fields()[0] if head_field.name == '_M_head_impl': @@ -603,6 +645,7 @@ class UniquePtrGetWorker(gdb.xmethod.XMethodWorker): else: return None + class UniquePtrDerefWorker(UniquePtrGetWorker): "Implements std::unique_ptr::operator*()" @@ -619,6 +662,7 @@ class UniquePtrDerefWorker(UniquePtrGetWorker): def __call__(self, obj): return UniquePtrGetWorker.__call__(self, obj).dereference() + class UniquePtrSubscriptWorker(UniquePtrGetWorker): "Implements std::unique_ptr::operator[](size_t)" @@ -638,6 +682,7 @@ class UniquePtrSubscriptWorker(UniquePtrGetWorker): def __call__(self, obj, index): return UniquePtrGetWorker.__call__(self, obj)[index] + class UniquePtrMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self): gdb.xmethod.XMethodMatcher.__init__(self, @@ -663,6 +708,7 @@ class UniquePtrMethodsMatcher(gdb.xmethod.XMethodMatcher): # Xmethods for std::shared_ptr + class SharedPtrGetWorker(gdb.xmethod.XMethodWorker): "Implements std::shared_ptr::get() and std::shared_ptr::operator->()" @@ -686,6 +732,7 @@ class SharedPtrGetWorker(gdb.xmethod.XMethodWorker): def __call__(self, obj): return obj['_M_ptr'] + class SharedPtrDerefWorker(SharedPtrGetWorker): "Implements std::shared_ptr::operator*()" @@ -702,6 +749,7 @@ class SharedPtrDerefWorker(SharedPtrGetWorker): def __call__(self, obj): return SharedPtrGetWorker.__call__(self, obj).dereference() + class SharedPtrSubscriptWorker(SharedPtrGetWorker): "Implements std::shared_ptr::operator[](size_t)" @@ -726,6 +774,7 @@ class SharedPtrSubscriptWorker(SharedPtrGetWorker): (self._elem_type, int(index), int(m.group(1)))) return SharedPtrGetWorker.__call__(self, obj)[index] + class SharedPtrUseCountWorker(gdb.xmethod.XMethodWorker): "Implements std::shared_ptr::use_count()" @@ -745,6 +794,7 @@ class SharedPtrUseCountWorker(gdb.xmethod.XMethodWorker): refcounts = obj['_M_refcount']['_M_pi'] return refcounts['_M_use_count'] if refcounts else 0 + class SharedPtrUniqueWorker(SharedPtrUseCountWorker): "Implements std::shared_ptr::unique()" @@ -757,6 +807,7 @@ class SharedPtrUniqueWorker(SharedPtrUseCountWorker): def __call__(self, obj): return SharedPtrUseCountWorker.__call__(self, obj) == 1 + class SharedPtrMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self): gdb.xmethod.XMethodMatcher.__init__(self, @@ -782,6 +833,7 @@ class SharedPtrMethodsMatcher(gdb.xmethod.XMethodMatcher): return worker return None + def register_libstdcxx_xmethods(locus): gdb.xmethod.register_xmethod_matcher(locus, ArrayMethodsMatcher()) gdb.xmethod.register_xmethod_matcher(locus, ForwardListMethodsMatcher())