From patchwork Mon Mar 21 20:59:09 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Artemiy Volkov X-Patchwork-Id: 11457 Received: (qmail 75838 invoked by alias); 21 Mar 2016 21:02:24 -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 75734 invoked by uid 89); 21 Mar 2016 21:02:23 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.5 required=5.0 tests=AWL, BAYES_00, FREEMAIL_FROM, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=ham version=3.3.2 spammy= X-HELO: mail-lb0-f195.google.com Received: from mail-lb0-f195.google.com (HELO mail-lb0-f195.google.com) (209.85.217.195) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-GCM-SHA256 encrypted) ESMTPS; Mon, 21 Mar 2016 21:02:16 +0000 Received: by mail-lb0-f195.google.com with SMTP id bc4so12052891lbc.0 for ; Mon, 21 Mar 2016 14:02:16 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references; bh=dga18wwkyk59XZVQc8FbOdAy6ktsnfYzby/NWLxOkWo=; b=Uw9HGYYVmV56yqYsVUvBeNTeuYw0S45d6ymsad0KOm3rvINVcTFTRISJ9qSxs0MD6l PYM1oLXAwGVrzuHe+6hqqQGji77YdP6q/orr7ekN6veSx438D+sC/QQk/HURZj7xKb1X uNFA2bCwEHN6mgsntrD4G3SJ8sCqOwNZeufrhAQdPRUQHPgXuYBMl3FUx1vLsQqUhJPR UoPNMaC1PXKK2Ijx1ysMQOuFp4wnTRcBC+0iYFuz0HNQQgGbNAVeduenuT+EoVPs4p0i orLL8c7DE/GYsyOZmtHYzc9fF31iKEiFzDN//rkvbkFzpXE+8+xNXkzb2iW7Zbvek5kc JCug== X-Gm-Message-State: AD7BkJLtTr5kuWQqOLImId05wzKW82yIYjSLhWyePs2KfpiTdLXZARnXKVSWOAaiWJxOZA== X-Received: by 10.112.135.39 with SMTP id pp7mr9376379lbb.43.1458594133401; Mon, 21 Mar 2016 14:02:13 -0700 (PDT) Received: from arch.smware.local (broadband-90-154-70-182.nationalcablenetworks.ru. [90.154.70.182]) by smtp.gmail.com with ESMTPSA id 40sm4730939lfp.41.2016.03.21.14.02.12 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 21 Mar 2016 14:02:12 -0700 (PDT) From: Artemiy Volkov To: gdb-patches@sourceware.org Cc: keiths@redhat.com, palves@redhat.com, Artemiy Volkov Subject: [PATCH v4 02/11] [PR gdb/14441] gdb: gdbtypes: change {lookup, make}_reference_type() API Date: Mon, 21 Mar 2016 13:59:09 -0700 Message-Id: <1458593958-25656-3-git-send-email-artemiyv@acm.org> In-Reply-To: <1458593958-25656-1-git-send-email-artemiyv@acm.org> References: <1457147955-21871-1-git-send-email-artemiyv@acm.org> <1458593958-25656-1-git-send-email-artemiyv@acm.org> 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. gdb/Changelog: 2016-03-21 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/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 ++-- 13 files changed, 56 insertions(+), 26 deletions(-) diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index dcd49e3..cf8ce53 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -14337,7 +14337,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 78ad946..8969f49 100644 --- a/gdb/eval.c +++ b/gdb/eval.c @@ -2789,7 +2789,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 4faac32..8948578 100644 --- a/gdb/f-exp.y +++ b/gdb/f-exp.y @@ -567,7 +567,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 65758bf..391fd28 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 6842052..1614d16 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -1727,9 +1727,13 @@ extern void append_flags_type_flag (struct type *type, int bitpos, char *name); 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 2acdfad..888624d 100644 --- a/gdb/guile/scm-type.c +++ b/gdb/guile/scm-type.c @@ -854,7 +854,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 1cdf953..fff3817 100644 --- a/gdb/guile/scm-value.c +++ b/gdb/guile/scm-value.c @@ -601,7 +601,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 4191fc6..06f7bcd 100644 --- a/gdb/parse.c +++ b/gdb/parse.c @@ -1695,7 +1695,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 03cc8d9..6103a2b 100644 --- a/gdb/python/py-type.c +++ b/gdb/python/py-type.c @@ -667,7 +667,7 @@ typy_reference (PyObject *self, PyObject *args) TRY { - type = lookup_reference_type (type); + type = lookup_lvalue_reference_type (type); } CATCH (except, RETURN_MASK_ALL) { @@ -827,7 +827,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 7dba0ad..be08231 100644 --- a/gdb/python/py-value.c +++ b/gdb/python/py-value.c @@ -376,7 +376,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) @@ -766,7 +766,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 58bb783..d70cdd1 100644 --- a/gdb/python/py-xmethods.c +++ b/gdb/python/py-xmethods.c @@ -550,7 +550,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); @@ -636,7 +636,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 74260b7..60691a1 100644 --- a/gdb/stabsread.c +++ b/gdb/stabsread.c @@ -1772,7 +1772,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 5a244a9..1aafb5a 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -1508,7 +1508,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; } @@ -3616,7 +3616,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