From: Jonathan Wakely Date: Thu, 15 Dec 2016 12:45:42 +0000 (+0000) Subject: Add GDB XMethods for shared_ptr and unique_ptr X-Git-Tag: upstream/12.2.0~42482 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=0376e86bfc9cbf1fe7b15be65d4f8e183da6484a;p=platform%2Fupstream%2Fgcc.git Add GDB XMethods for shared_ptr and unique_ptr * python/libstdcxx/v6/xmethods.py (UniquePtrGetWorker.__init__): Use correct element type for unique_ptr. (UniquePtrGetWorker._supports, UniquePtrDerefWorker._supports): New functions to disable unsupported operators for unique_ptr. (UniquePtrSubscriptWorker): New worker for operator[]. (UniquePtrMethodsMatcher.__init__): Register UniquePtrSubscriptWorker. (UniquePtrMethodsMatcher.match): Call _supports on the chosen worker. (SharedPtrGetWorker, SharedPtrDerefWorker, SharedPtrSubscriptWorker) (SharedPtrUseCountWorker, SharedPtrUniqueWorker): New workers. (SharedPtrMethodsMatcher): New matcher for shared_ptr. (register_libstdcxx_xmethods): Register SharedPtrMethodsMatcher. * testsuite/libstdc++-xmethods/unique_ptr.cc: Test arrays. * testsuite/libstdc++-xmethods/shared_ptr.cc: New test. From-SVN: r243688 --- diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 20af4af..a881ee6 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,19 @@ +2016-12-15 Jonathan Wakely + + * python/libstdcxx/v6/xmethods.py (UniquePtrGetWorker.__init__): Use + correct element type for unique_ptr. + (UniquePtrGetWorker._supports, UniquePtrDerefWorker._supports): New + functions to disable unsupported operators for unique_ptr. + (UniquePtrSubscriptWorker): New worker for operator[]. + (UniquePtrMethodsMatcher.__init__): Register UniquePtrSubscriptWorker. + (UniquePtrMethodsMatcher.match): Call _supports on the chosen worker. + (SharedPtrGetWorker, SharedPtrDerefWorker, SharedPtrSubscriptWorker) + (SharedPtrUseCountWorker, SharedPtrUniqueWorker): New workers. + (SharedPtrMethodsMatcher): New matcher for shared_ptr. + (register_libstdcxx_xmethods): Register SharedPtrMethodsMatcher. + * testsuite/libstdc++-xmethods/unique_ptr.cc: Test arrays. + * testsuite/libstdc++-xmethods/shared_ptr.cc: New test. + 2016-12-14 François Dumont * include/bits/stl_tree.h diff --git a/libstdc++-v3/python/libstdcxx/v6/xmethods.py b/libstdc++-v3/python/libstdcxx/v6/xmethods.py index 045b661..1c9bf3a 100644 --- a/libstdc++-v3/python/libstdcxx/v6/xmethods.py +++ b/libstdc++-v3/python/libstdcxx/v6/xmethods.py @@ -565,8 +565,14 @@ 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->()" + def __init__(self, elem_type): - self._elem_type = elem_type + self._is_array = elem_type.code == gdb.TYPE_CODE_ARRAY + if self._is_array: + self._elem_type = elem_type.target() + else: + self._elem_type = elem_type def get_arg_types(self): return None @@ -574,6 +580,10 @@ class UniquePtrGetWorker(gdb.xmethod.XMethodWorker): def get_result_type(self, obj): return self._elem_type.pointer() + def _supports(self, method_name): + "operator-> is not supported for unique_ptr" + return method_name == 'get' or not self._is_array + def __call__(self, obj): impl_type = obj.dereference().type.fields()[0].type.tag if impl_type.startswith('std::__uniq_ptr_impl<'): # New implementation @@ -583,15 +593,40 @@ class UniquePtrGetWorker(gdb.xmethod.XMethodWorker): return None class UniquePtrDerefWorker(UniquePtrGetWorker): + "Implements std::unique_ptr::operator*()" + def __init__(self, elem_type): UniquePtrGetWorker.__init__(self, elem_type) def get_result_type(self, obj): return self._elem_type + def _supports(self, method_name): + "operator* is not supported for unique_ptr" + return not self._is_array + def __call__(self, obj): return UniquePtrGetWorker.__call__(self, obj).dereference() +class UniquePtrSubscriptWorker(UniquePtrGetWorker): + "Implements std::unique_ptr::operator[](size_t)" + + def __init__(self, elem_type): + UniquePtrGetWorker.__init__(self, elem_type) + + def get_arg_types(self): + return get_std_size_type() + + def get_result_type(self, obj, index): + return self._elem_type + + def _supports(self, method_name): + "operator[] is only supported for unique_ptr" + return self._is_array + + def __call__(self, obj, index): + return UniquePtrGetWorker.__call__(self, obj)[index] + class UniquePtrMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self): gdb.xmethod.XMethodMatcher.__init__(self, @@ -600,6 +635,7 @@ class UniquePtrMethodsMatcher(gdb.xmethod.XMethodMatcher): 'get': LibStdCxxXMethod('get', UniquePtrGetWorker), 'operator->': LibStdCxxXMethod('operator->', UniquePtrGetWorker), 'operator*': LibStdCxxXMethod('operator*', UniquePtrDerefWorker), + 'operator[]': LibStdCxxXMethod('operator[]', UniquePtrSubscriptWorker), } self.methods = [self._method_dict[m] for m in self._method_dict] @@ -609,7 +645,128 @@ class UniquePtrMethodsMatcher(gdb.xmethod.XMethodMatcher): method = self._method_dict.get(method_name) if method is None or not method.enabled: return None - return method.worker_class(class_type.template_argument(0)) + worker = method.worker_class(class_type.template_argument(0)) + if worker._supports(method_name): + return worker + return None + +# Xmethods for std::shared_ptr + +class SharedPtrGetWorker(gdb.xmethod.XMethodWorker): + "Implements std::shared_ptr::get() and std::shared_ptr::operator->()" + + def __init__(self, elem_type): + self._is_array = elem_type.code == gdb.TYPE_CODE_ARRAY + if self._is_array: + self._elem_type = elem_type.target() + else: + self._elem_type = elem_type + + def get_arg_types(self): + return None + + def get_result_type(self, obj): + return self._elem_type.pointer() + + def _supports(self, method_name): + "operator-> is not supported for shared_ptr" + return method_name == 'get' or not self._is_array + + def __call__(self, obj): + return obj['_M_ptr'] + +class SharedPtrDerefWorker(SharedPtrGetWorker): + "Implements std::shared_ptr::operator*()" + + def __init__(self, elem_type): + SharedPtrGetWorker.__init__(self, elem_type) + + def get_result_type(self, obj): + return self._elem_type + + def _supports(self, method_name): + "operator* is not supported for shared_ptr" + return not self._is_array + + def __call__(self, obj): + return SharedPtrGetWorker.__call__(self, obj).dereference() + +class SharedPtrSubscriptWorker(SharedPtrGetWorker): + "Implements std::shared_ptr::operator[](size_t)" + + def __init__(self, elem_type): + SharedPtrGetWorker.__init__(self, elem_type) + + def get_arg_types(self): + return get_std_size_type() + + def get_result_type(self, obj, index): + return self._elem_type + + def _supports(self, method_name): + "operator[] is only supported for shared_ptr" + return self._is_array + + def __call__(self, obj, index): + # Check bounds if _elem_type is an array of known bound + m = re.match('.*\[(\d+)]$', str(self._elem_type)) + if m and index >= int(m.group(1)): + raise IndexError('shared_ptr<%s> index "%d" should not be >= %d.' % + (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()" + + def __init__(self, elem_type): + SharedPtrUseCountWorker.__init__(self, elem_type) + + def get_arg_types(self): + return None + + def get_result_type(self, obj): + return gdb.lookup_type('long') + + def __call__(self, obj): + refcounts = ['_M_refcount']['_M_pi'] + return refcounts['_M_use_count'] if refcounts else 0 + +class SharedPtrUniqueWorker(SharedPtrUseCountWorker): + "Implements std::shared_ptr::unique()" + + def __init__(self, elem_type): + SharedPtrUseCountWorker.__init__(self, elem_type) + + def get_result_type(self, obj): + return gdb.lookup_type('bool') + + def __call__(self, obj): + return SharedPtrUseCountWorker.__call__(self, obj) == 1 + +class SharedPtrMethodsMatcher(gdb.xmethod.XMethodMatcher): + def __init__(self): + gdb.xmethod.XMethodMatcher.__init__(self, + matcher_name_prefix + 'shared_ptr') + self._method_dict = { + 'get': LibStdCxxXMethod('get', SharedPtrGetWorker), + 'operator->': LibStdCxxXMethod('operator->', SharedPtrGetWorker), + 'operator*': LibStdCxxXMethod('operator*', SharedPtrDerefWorker), + 'operator[]': LibStdCxxXMethod('operator[]', SharedPtrSubscriptWorker), + 'use_count': LibStdCxxXMethod('use_count', SharedPtrUseCountWorker), + 'unique': LibStdCxxXMethod('unique', SharedPtrUniqueWorker), + } + self.methods = [self._method_dict[m] for m in self._method_dict] + + def match(self, class_type, method_name): + if not re.match('^std::shared_ptr<.*>$', class_type.tag): + return None + method = self._method_dict.get(method_name) + if method is None or not method.enabled: + return None + worker = method.worker_class(class_type.template_argument(0)) + if worker._supports(method_name): + return worker + return None def register_libstdcxx_xmethods(locus): gdb.xmethod.register_xmethod_matcher(locus, ArrayMethodsMatcher()) @@ -634,3 +791,4 @@ def register_libstdcxx_xmethods(locus): gdb.xmethod.register_xmethod_matcher( locus, AssociativeContainerMethodsMatcher('unordered_multimap')) gdb.xmethod.register_xmethod_matcher(locus, UniquePtrMethodsMatcher()) + gdb.xmethod.register_xmethod_matcher(locus, SharedPtrMethodsMatcher()) diff --git a/libstdc++-v3/testsuite/libstdc++-xmethods/shared_ptr.cc b/libstdc++-v3/testsuite/libstdc++-xmethods/shared_ptr.cc new file mode 100644 index 0000000..c90dd01 --- /dev/null +++ b/libstdc++-v3/testsuite/libstdc++-xmethods/shared_ptr.cc @@ -0,0 +1,72 @@ +// { dg-do run { target c++11 } } +// { dg-options "-g -O0" } + +// Copyright (C) 2016 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include + +struct x_struct +{ + int y; +}; + +int +main () +{ + std::shared_ptr p(new int(10)); + + std::shared_ptr q(new x_struct{23}); + + std::shared_ptr r(new x_struct[2]{ {46}, {69} }); + + std::shared_ptr s(new x_struct[2]{ {92}, {115} }); + +// { dg-final { note-test *p 10 } } +// { dg-final { regexp-test p.get() 0x.* } } + +// { dg-final { whatis-test *p int } } +// { dg-final { whatis-test p.get() "int \*" } } + +// { dg-final { note-test *q {\{y = 23\}} } } +// { dg-final { regexp-test q.get() 0x.* } } +// { dg-final { note-test q->y 23 } } + +// { dg-final { whatis-test *q x_struct } } +// { dg-final { whatis-test q.get() "x_struct \*" } } +// { dg-final { whatis-test q->y int } } + +// { dg-final { note-test r\[1] {\{y = 69\}} } } +// { dg-final { regexp-test r.get() 0x.* } } +// { dg-final { note-test r\[1].y 69 } } + +// { dg-final { whatis-test r\[1] x_struct } } +// { dg-final { whatis-test r.get() "x_struct \*" } } +// { dg-final { whatis-test r\[1].y int } } + +// { dg-final { note-test s\[1] {\{y = 115\}} } } +// { dg-final { regexp-test s.get() 0x.* } } +// { dg-final { note-test s\[1].y 115 } } + +// { dg-final { whatis-test s\[1] x_struct } } +// { dg-final { whatis-test s.get() "x_struct \*" } } +// { dg-final { whatis-test s\[1].y int } } + + return 0; // Mark SPOT +} + +// { dg-final { gdb-test SPOT {} 1 } } diff --git a/libstdc++-v3/testsuite/libstdc++-xmethods/unique_ptr.cc b/libstdc++-v3/testsuite/libstdc++-xmethods/unique_ptr.cc index bb303a2..5559e27 100644 --- a/libstdc++-v3/testsuite/libstdc++-xmethods/unique_ptr.cc +++ b/libstdc++-v3/testsuite/libstdc++-xmethods/unique_ptr.cc @@ -28,13 +28,11 @@ struct x_struct int main () { - int *i = new int; - *i = 10; - std::unique_ptr p(i); + std::unique_ptr p(new int(10)); - x_struct *x = new x_struct; - x->y = 23; - std::unique_ptr q(x); + std::unique_ptr q(new x_struct{23}); + + std::unique_ptr r(new x_struct[2]{ {46}, {69} }); // { dg-final { note-test *p 10 } } // { dg-final { regexp-test p.get() 0x.* } } @@ -50,6 +48,15 @@ main () // { dg-final { whatis-test q.get() "x_struct \*" } } // { dg-final { whatis-test q->y int } } +// { dg-final { note-test r\[1] {\{y = 69\}} } } +// { dg-final { regexp-test r.get() 0x.* } } +// { dg-final { note-test r\[1].y 69 } } + +// { dg-final { whatis-test r\[1] x_struct } } +// { dg-final { whatis-test r.get() "x_struct \*" } } +// { dg-final { whatis-test r\[1].y int } } + + return 0; // Mark SPOT }