On 10/08/20 09:45 -0400, Andres Rodriguez wrote:
*ping*
As it says at https://gcc.gnu.org/lists.html all patches for libstdc++
need to be sent to the libstdc++ mailing as well as the gcc-patches
list. Otherwise I won't see them, and everybody else will ignore them.
On Tue, Aug 4, 2020 at 10:51 AM Andres Rodriguez <andre...@gmail.com> wrote:
On binaries compiled against gcc5 the impl_type parameter is None,
which results in an exception being raised by is_specialization_of()
These versions of std::unique_ptr have the tuple as a root element.
The unique_ptr implementation in GCC 5 should already be handled by
the second branch which handles a tuple member:
if is_specialization_of(impl_type, '__uniq_ptr_data') \
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" %
impl_type)
We have a test that's supposed to verify that printing the old
unique_ptr implementation still works:
https://gcc.gnu.org/git/?p=gcc.git;a=blob;f=libstdc%2B%2B-v3/testsuite/libstdc%2B%2B-prettyprinters/compat.cc;h=f1c3b599634af2eb0a5a0889c528d9de2d21aacd;hb=HEAD
So the right fix is to work out why that branch isn't taken, and fix
it, not add a kluge.
If impl_type is None that means the .tag field is missing, which seems
to be because the _M_t member is declared using the __tuple_type
typedef, rather than std::tuple itself.
That's fixed by the attached patch.
Tested x86_64-linux, pushed to master. I'll backport it to the
branches too.
commit ed11f7e84bcae89f486f5023e566726a7faa7dd4
Author: Jonathan Wakely <jwak...@redhat.com>
Date: Mon Aug 10 18:44:06 2020
libstdc++: Fix compatibility support in unique_ptr pretty printer
The support for the old std::unique_ptr implementation was failing,
because it tried to work on a typedef instead of the underlying type.
The test supposed to verify the support worked wasn't using a typedef,
so didn't notice the problem.
libstdc++-v3/ChangeLog:
* python/libstdcxx/v6/printers.py (UniquePointerPrinter.__init__):
Use gdb.Type.strip_typedefs().
* testsuite/libstdc++-prettyprinters/compat.cc: Use a typedef in
the emulated old type.
diff --git a/libstdc++-v3/python/libstdcxx/v6/printers.py b/libstdc++-v3/python/libstdcxx/v6/printers.py
index 0bf307b8e5f..c0f061f79c1 100644
--- a/libstdc++-v3/python/libstdcxx/v6/printers.py
+++ b/libstdc++-v3/python/libstdcxx/v6/printers.py
@@ -245,7 +245,7 @@ class UniquePointerPrinter:
def __init__ (self, typename, val):
self.val = val
- impl_type = val.type.fields()[0].type.tag
+ 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'):
@@ -253,7 +253,7 @@ class UniquePointerPrinter:
elif is_specialization_of(impl_type, 'tuple'):
tuple_member = val['_M_t']
else:
- raise ValueError("Unsupported implementation for unique_ptr: %s" % impl_type)
+ raise ValueError("Unsupported implementation for unique_ptr: %s" % str(impl_type))
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]
@@ -262,7 +262,7 @@ class UniquePointerPrinter:
elif head_field.is_base_class:
self.pointer = tuple_member.cast(head_field.type)
else:
- raise ValueError("Unsupported implementation for tuple in unique_ptr: %s" % impl_type)
+ raise ValueError("Unsupported implementation for tuple in unique_ptr: %s" % str(impl_type))
def children (self):
return SmartPtrIterator(self.pointer)
diff --git a/libstdc++-v3/testsuite/libstdc++-prettyprinters/compat.cc b/libstdc++-v3/testsuite/libstdc++-prettyprinters/compat.cc
index f1c3b599634..c681becf8b9 100644
--- a/libstdc++-v3/testsuite/libstdc++-prettyprinters/compat.cc
+++ b/libstdc++-v3/testsuite/libstdc++-prettyprinters/compat.cc
@@ -53,7 +53,9 @@ namespace std
{
unique_ptr(T* p) { _M_t._M_head_impl = p; }
- tuple<T*, D> _M_t;
+ using __tuple_type = tuple<T*, D>;
+
+ __tuple_type _M_t;
};
// Old representation of std::optional, before GCC 9
