From patchwork Fri Mar 10 20:04:37 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Keith Seitz X-Patchwork-Id: 19514 Received: (qmail 79392 invoked by alias); 10 Mar 2017 20:04:51 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 79309 invoked by uid 89); 10 Mar 2017 20:04:50 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.9 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RP_MATCHES_RCVD, SPF_HELO_PASS autolearn=ham version=3.3.2 spammy=UD:gdbtypes.h, gdbtypesh, gdbtypes.h X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 10 Mar 2017 20:04:48 +0000 Received: from int-mx14.intmail.prod.int.phx2.redhat.com (int-mx14.intmail.prod.int.phx2.redhat.com [10.5.11.27]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id B47594E4CD for ; Fri, 10 Mar 2017 20:04:48 +0000 (UTC) Received: from valrhona.uglyboxes.com (ovpn04.gateway.prod.ext.phx2.redhat.com [10.5.9.4]) by int-mx14.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id v2AK4lWv029240 for ; Fri, 10 Mar 2017 15:04:48 -0500 From: Keith Seitz To: gdb-patches@sourceware.org Subject: [PATCH v6 02/11] Change {lookup,make}_reference_type API Date: Fri, 10 Mar 2017 12:04:37 -0800 Message-Id: <1489176286-27973-3-git-send-email-keiths@redhat.com> In-Reply-To: <1489176286-27973-1-git-send-email-keiths@redhat.com> References: <1489176286-27973-1-git-send-email-keiths@redhat.com> X-IsSubscribed: yes Parameterize lookup_reference_type() and make_reference_type() by the kind of reference type we want to look up. Create two wrapper functions lookup_{lvalue,rvalue}_reference_type() for lookup_reference_type() to simplify the API. Change all callers to use the new API. There are no changes to this patch from v5. gdb/Changelog PR gdb/14441 From Artemiy Volkov * dwarf2read.c (read_tag_reference_type): Use lookup_lvalue_reference_type() instead of lookup_reference_type(). * eval.c (evaluate_subexp_standard): Likewise. * f-exp.y: Likewise. * gdbtypes.c (make_reference_type, lookup_reference_type): Generalize with rvalue reference types. (lookup_lvalue_reference_type, lookup_rvalue_reference_type): New convenience wrappers for lookup_reference_type(). * gdbtypes.h (make_reference_type, lookup_reference_type): Add a reference kind parameter. (lookup_lvalue_reference_type, lookup_rvalue_reference_type): Add wrappers for lookup_reference_type(). * guile/scm-type.c (gdbscm_type_reference): Use lookup_lvalue_reference_type() instead of lookup_reference_type(). * guile/scm-value.c (gdbscm_value_dynamic_type): Likewise. * parse.c (follow_types): Likewise. * python/py-type.c (typy_reference, typy_lookup_type): Likewise. * python/py-value.c (valpy_get_dynamic_type, valpy_getitem): Likewise. * python/py-xmethods.c (gdbpy_get_xmethod_result_type) (gdbpy_invoke_xmethod): Likewise. * stabsread.c: Provide extra argument to make_reference_type() call. * valops.c (value_ref, value_rtti_indirect_type): Use lookup_lvalue_reference_type() instead of lookup_reference_type(). --- gdb/ChangeLog | 30 ++++++++++++++++++++++++++++++ gdb/dwarf2read.c | 2 +- gdb/eval.c | 2 +- gdb/f-exp.y | 2 +- gdb/gdbtypes.c | 42 +++++++++++++++++++++++++++++++++--------- gdb/gdbtypes.h | 8 ++++++-- gdb/guile/scm-type.c | 2 +- gdb/guile/scm-value.c | 2 +- gdb/parse.c | 2 +- gdb/python/py-type.c | 4 ++-- gdb/python/py-value.c | 5 +++-- gdb/python/py-xmethods.c | 4 ++-- gdb/stabsread.c | 3 ++- gdb/valops.c | 4 ++-- 14 files changed, 86 insertions(+), 26 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 7f2e2e5..0ec9777 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -2,6 +2,36 @@ PR gdb/14441 From Artemiy Volkov + * dwarf2read.c (read_tag_reference_type): Use + lookup_lvalue_reference_type() instead of lookup_reference_type(). + * eval.c (evaluate_subexp_standard): Likewise. + * f-exp.y: Likewise. + * gdbtypes.c (make_reference_type, lookup_reference_type): + Generalize with rvalue reference types. + (lookup_lvalue_reference_type, lookup_rvalue_reference_type): New + convenience wrappers for lookup_reference_type(). + * gdbtypes.h (make_reference_type, lookup_reference_type): Add a + reference kind parameter. + (lookup_lvalue_reference_type, lookup_rvalue_reference_type): Add + wrappers for lookup_reference_type(). + * guile/scm-type.c (gdbscm_type_reference): Use + lookup_lvalue_reference_type() instead of lookup_reference_type(). + * guile/scm-value.c (gdbscm_value_dynamic_type): Likewise. + * parse.c (follow_types): Likewise. + * python/py-type.c (typy_reference, typy_lookup_type): Likewise. + * python/py-value.c (valpy_get_dynamic_type, valpy_getitem): + Likewise. + * python/py-xmethods.c (gdbpy_get_xmethod_result_type) + (gdbpy_invoke_xmethod): Likewise. + * stabsread.c: Provide extra argument to make_reference_type() + call. + * valops.c (value_ref, value_rtti_indirect_type): Use + lookup_lvalue_reference_type() instead of lookup_reference_type(). + +2017-MM-DD Keith Seitz + + PR gdb/14441 + From Artemiy Volkov * gdbtypes.h (enum type_code) : New constant. (TYPE_IS_REFERENCE): New macro. (struct type): Add rvalue_reference_type field. diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index 40b99d9..f3a8cc6 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -14584,7 +14584,7 @@ read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu) if (type) return type; - type = lookup_reference_type (target_type); + type = lookup_lvalue_reference_type (target_type); attr = dwarf2_attr (die, DW_AT_byte_size, cu); if (attr) { diff --git a/gdb/eval.c b/gdb/eval.c index 76d7f73..61d8d19 100644 --- a/gdb/eval.c +++ b/gdb/eval.c @@ -2771,7 +2771,7 @@ evaluate_subexp_standard (struct type *expect_type, if (TYPE_CODE (check_typedef (type)) != TYPE_CODE_REF) { - type = lookup_reference_type (type); + type = lookup_lvalue_reference_type (type); result = allocate_value (type); } } diff --git a/gdb/f-exp.y b/gdb/f-exp.y index a791d2c..49d797d 100644 --- a/gdb/f-exp.y +++ b/gdb/f-exp.y @@ -513,7 +513,7 @@ ptype : typebase follow_type = lookup_pointer_type (follow_type); break; case tp_reference: - follow_type = lookup_reference_type (follow_type); + follow_type = lookup_lvalue_reference_type (follow_type); break; case tp_array: array_size = pop_type_int (); diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index 5e5db27..60cef68 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -384,15 +384,21 @@ lookup_pointer_type (struct type *type) /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points to a pointer to memory where the reference type should be stored. If *TYPEPTR is zero, update it to point to the reference - type we return. We allocate new memory if needed. */ + type we return. We allocate new memory if needed. REFCODE denotes + the kind of reference type to lookup (lvalue or rvalue reference). */ struct type * -make_reference_type (struct type *type, struct type **typeptr) +make_reference_type (struct type *type, struct type **typeptr, + enum type_code refcode) { struct type *ntype; /* New type */ + struct type **reftype; struct type *chain; - ntype = TYPE_REFERENCE_TYPE (type); + gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF); + + ntype = (refcode == TYPE_CODE_REF ? TYPE_REFERENCE_TYPE (type) + : TYPE_RVALUE_REFERENCE_TYPE (type)); if (ntype) { @@ -421,7 +427,10 @@ make_reference_type (struct type *type, struct type **typeptr) } TYPE_TARGET_TYPE (ntype) = type; - TYPE_REFERENCE_TYPE (type) = ntype; + reftype = (refcode == TYPE_CODE_REF ? &TYPE_REFERENCE_TYPE (type) + : &TYPE_RVALUE_REFERENCE_TYPE (type)); + + *reftype = ntype; /* FIXME! Assume the machine has only one representation for references, and that it matches the (only) representation for @@ -429,10 +438,9 @@ make_reference_type (struct type *type, struct type **typeptr) TYPE_LENGTH (ntype) = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT; - TYPE_CODE (ntype) = TYPE_CODE_REF; + TYPE_CODE (ntype) = refcode; - if (!TYPE_REFERENCE_TYPE (type)) /* Remember it, if don't have one. */ - TYPE_REFERENCE_TYPE (type) = ntype; + *reftype = ntype; /* Update the length of all the other variants of this type. */ chain = TYPE_CHAIN (ntype); @@ -449,9 +457,25 @@ make_reference_type (struct type *type, struct type **typeptr) details. */ struct type * -lookup_reference_type (struct type *type) +lookup_reference_type (struct type *type, enum type_code refcode) +{ + return make_reference_type (type, (struct type **) 0, refcode); +} + +/* Lookup the lvalue reference type for the type TYPE. */ + +struct type * +lookup_lvalue_reference_type (struct type *type) +{ + return lookup_reference_type (type, TYPE_CODE_REF); +} + +/* Lookup the rvalue reference type for the type TYPE. */ + +struct type * +lookup_rvalue_reference_type (struct type *type) { - return make_reference_type (type, (struct type **) 0); + return lookup_reference_type (type, TYPE_CODE_RVALUE_REF); } /* Lookup a function type that returns type TYPE. TYPEPTR, if diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index 7d107fa..4abeaf3 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -1714,9 +1714,13 @@ extern void append_flags_type_flag (struct type *type, int bitpos, extern void make_vector_type (struct type *array_type); extern struct type *init_vector_type (struct type *elt_type, int n); -extern struct type *lookup_reference_type (struct type *); +extern struct type *lookup_reference_type (struct type *, enum type_code); +extern struct type *lookup_lvalue_reference_type (struct type *); +extern struct type *lookup_rvalue_reference_type (struct type *); -extern struct type *make_reference_type (struct type *, struct type **); + +extern struct type *make_reference_type (struct type *, struct type **, + enum type_code); extern struct type *make_cv_type (int, int, struct type *, struct type **); diff --git a/gdb/guile/scm-type.c b/gdb/guile/scm-type.c index 42a8ad2..9f1a216 100644 --- a/gdb/guile/scm-type.c +++ b/gdb/guile/scm-type.c @@ -832,7 +832,7 @@ gdbscm_type_reference (SCM self) TRY { - type = lookup_reference_type (type); + type = lookup_lvalue_reference_type (type); } CATCH (except, RETURN_MASK_ALL) { diff --git a/gdb/guile/scm-value.c b/gdb/guile/scm-value.c index ebccfb6..8c06b39 100644 --- a/gdb/guile/scm-value.c +++ b/gdb/guile/scm-value.c @@ -591,7 +591,7 @@ gdbscm_value_dynamic_type (SCM self) if (was_pointer) type = lookup_pointer_type (type); else - type = lookup_reference_type (type); + type = lookup_lvalue_reference_type (type); } } else if (TYPE_CODE (type) == TYPE_CODE_STRUCT) diff --git a/gdb/parse.c b/gdb/parse.c index 9f89b1e..d864970 100644 --- a/gdb/parse.c +++ b/gdb/parse.c @@ -1686,7 +1686,7 @@ follow_types (struct type *follow_type) make_addr_space = 0; break; case tp_reference: - follow_type = lookup_reference_type (follow_type); + follow_type = lookup_lvalue_reference_type (follow_type); if (make_const) follow_type = make_cv_type (make_const, TYPE_VOLATILE (follow_type), diff --git a/gdb/python/py-type.c b/gdb/python/py-type.c index d3506ca..c4d5917 100644 --- a/gdb/python/py-type.c +++ b/gdb/python/py-type.c @@ -626,7 +626,7 @@ typy_reference (PyObject *self, PyObject *args) TRY { - type = lookup_reference_type (type); + type = lookup_lvalue_reference_type (type); } CATCH (except, RETURN_MASK_ALL) { @@ -786,7 +786,7 @@ typy_lookup_type (struct demangle_component *demangled, switch (demangled_type) { case DEMANGLE_COMPONENT_REFERENCE: - rtype = lookup_reference_type (type); + rtype = lookup_lvalue_reference_type (type); break; case DEMANGLE_COMPONENT_POINTER: rtype = lookup_pointer_type (type); diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c index eb3d307..399978a 100644 --- a/gdb/python/py-value.c +++ b/gdb/python/py-value.c @@ -369,7 +369,7 @@ valpy_get_dynamic_type (PyObject *self, void *closure) if (was_pointer) type = lookup_pointer_type (type); else - type = lookup_reference_type (type); + type = lookup_lvalue_reference_type (type); } } else if (TYPE_CODE (type) == TYPE_CODE_STRUCT) @@ -741,7 +741,8 @@ valpy_getitem (PyObject *self, PyObject *key) if (TYPE_CODE (val_type) == TYPE_CODE_PTR) res_val = value_cast (lookup_pointer_type (base_class_type), tmp); else if (TYPE_CODE (val_type) == TYPE_CODE_REF) - res_val = value_cast (lookup_reference_type (base_class_type), tmp); + res_val = value_cast (lookup_lvalue_reference_type (base_class_type), + tmp); else res_val = value_cast (base_class_type, tmp); } diff --git a/gdb/python/py-xmethods.c b/gdb/python/py-xmethods.c index d293c71..8a9bb9b 100644 --- a/gdb/python/py-xmethods.c +++ b/gdb/python/py-xmethods.c @@ -466,7 +466,7 @@ gdbpy_get_xmethod_result_type (const struct extension_language_defn *extlang, } else if (TYPE_CODE (obj_type) == TYPE_CODE_REF) { - struct type *this_ref = lookup_reference_type (this_type); + struct type *this_ref = lookup_lvalue_reference_type (this_type); if (!types_equal (obj_type, this_ref)) obj = value_cast (this_ref, obj); @@ -554,7 +554,7 @@ gdbpy_invoke_xmethod (const struct extension_language_defn *extlang, } else if (TYPE_CODE (obj_type) == TYPE_CODE_REF) { - struct type *this_ref = lookup_reference_type (this_type); + struct type *this_ref = lookup_lvalue_reference_type (this_type); if (!types_equal (obj_type, this_ref)) obj = value_cast (this_ref, obj); diff --git a/gdb/stabsread.c b/gdb/stabsread.c index da7241a..1412202 100644 --- a/gdb/stabsread.c +++ b/gdb/stabsread.c @@ -1794,7 +1794,8 @@ again: case '&': /* Reference to another type */ type1 = read_type (pp, objfile); - type = make_reference_type (type1, dbx_lookup_type (typenums, objfile)); + type = make_reference_type (type1, dbx_lookup_type (typenums, objfile), + TYPE_CODE_REF); break; case 'f': /* Function returning another type */ diff --git a/gdb/valops.c b/gdb/valops.c index fa25ff9..d218c92 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -1536,7 +1536,7 @@ value_ref (struct value *arg1) return arg1; arg2 = value_addr (arg1); - deprecated_set_value_type (arg2, lookup_reference_type (type)); + deprecated_set_value_type (arg2, lookup_lvalue_reference_type (type)); return arg2; } @@ -3639,7 +3639,7 @@ value_rtti_indirect_type (struct value *v, int *full, real_type = make_cv_type (TYPE_CONST (target_type), TYPE_VOLATILE (target_type), real_type, NULL); if (TYPE_CODE (type) == TYPE_CODE_REF) - real_type = lookup_reference_type (real_type); + real_type = lookup_lvalue_reference_type (real_type); else if (TYPE_CODE (type) == TYPE_CODE_PTR) real_type = lookup_pointer_type (real_type); else