From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 26460 invoked by alias); 6 Jun 2016 19:23:06 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 26369 invoked by uid 89); 6 Jun 2016 19:23:05 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.7 required=5.0 tests=AWL,BAYES_00,FREEMAIL_FROM,KAM_STOCKGEN,RCVD_IN_DNSWL_LOW,SPF_PASS autolearn=no version=3.3.2 spammy=REF, OBJECT, 55,6, sk:!type_i X-HELO: mail-lf0-f67.google.com Received: from mail-lf0-f67.google.com (HELO mail-lf0-f67.google.com) (209.85.215.67) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-GCM-SHA256 encrypted) ESMTPS; Mon, 06 Jun 2016 19:22:58 +0000 Received: by mail-lf0-f67.google.com with SMTP id j198so78683lfe.0 for ; Mon, 06 Jun 2016 12:22:57 -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=8OOa1MJYpjHh78DtC8q/2FmaAv3sF0NkWLeQ7bQoqvg=; b=a/9vZrEKcSAuIXIWT7LLGmx4BvVIz049xQuOrDNvqY9G/PxeDjmfz1qHvcyQbDschk UQ/U0KP2JauPyvvoDLQKPwRvdcsQhbHD/KfzKTgPRzbYXKXJIQtfSRSOQfmUvuoCGLRn qB31dFQetQZzQeaM8+Fv+RgHWg/u+mHc08wHc/uEXCCVStdMJ41L/3S0Aa+DVKfkFknH wics8bLWHRUR6u0J/p5i0AkbASlyyYJOOIushlf8wJF2Of8erI8DZNE/HiAOsdgRUV8x cZ0FhOYJqhcvF/Od2uDXMFyMjHz6HDzOvPs7lbhfLthbsbl7e8B0ig+eTpKdtOvuXl7K RmxA== X-Gm-Message-State: ALyK8tK560phbZjxKRsHmr83J8qKpLlnxoTMX/MN+wIoJMZIbN/OA1Nsm4pUfuS6VAbZoA== X-Received: by 10.25.73.137 with SMTP id w131mr1505678lfa.22.1465240974126; Mon, 06 Jun 2016 12:22:54 -0700 (PDT) Received: from localhost.localdomain (broadband-90-154-70-138.nationalcablenetworks.ru. [90.154.70.138]) by smtp.gmail.com with ESMTPSA id jv7sm1970253lbc.4.2016.06.06.12.22.53 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 06 Jun 2016 12:22:53 -0700 (PDT) From: Artemiy Volkov To: gdb-patches@sourceware.org Cc: palves@redhat.com, keiths@redhat.com, Artemiy Volkov Subject: [PATCH v5 09/11] [PR gdb/14441] gdb: convert lvalue reference type check to general reference type check Date: Mon, 06 Jun 2016 19:23:00 -0000 Message-Id: <20160606192225.12384-10-artemiyv@acm.org> In-Reply-To: <20160606192225.12384-1-artemiyv@acm.org> References: <1458593958-25656-1-git-send-email-artemiyv@acm.org> <20160606192225.12384-1-artemiyv@acm.org> X-IsSubscribed: yes X-SW-Source: 2016-06/txt/msg00105.txt.bz2 In almost all contexts (except for overload resolution rules and expression semantics), lvalue and rvalue references are equivalent. That means that in all but these cases we can replace a TYPE_CODE_REF check to a TYPE_IS_REFERENCE check and, for switch statements, add a case label for a rvalue reference type next to a case label for an lvalue reference type. This patch does exactly that. gdb/ChangeLog: 2016-06-06 Artemiy Volkov PR gdb/14441 * aarch64-tdep.c (aarch64_type_align) (aarch64_extract_return_value, aarch64_store_return_value): Change lvalue reference type checks to general reference type checks. * amd64-tdep.c (amd64_classify): Likewise. * amd64-windows-tdep.c (amd64_windows_passed_by_integer_register): Likewise. * arm-tdep.c (arm_type_align, arm_extract_return_value) (arm_store_return_value): Likewise. * ax-gdb.c (gen_fetch, gen_cast): Likewise. * c-typeprint.c (c_print_type): Likewise. * c-varobj.c (adjust_value_for_child_access, c_value_of_variable) (cplus_number_of_children, cplus_describe_child): Likewise. * compile/compile-c-symbols.c (generate_vla_size): Likewise. * completer.c (expression_completer): Likewise. * cp-support.c (make_symbol_overload_list_adl_namespace): Likewise. * darwin-nat-info.c (info_mach_region_command): Likewise. * dwarf2loc.c (entry_data_value_coerce_ref) (value_of_dwarf_reg_entry): Likewise. * eval.c (ptrmath_type_p, evaluate_subexp_standard) (evaluate_subexp_for_address, evaluate_subexp_for_sizeof): Likewise. * findvar.c (extract_typed_address, store_typed_address): Likewise. * gdbtypes.c (rank_one_type): Likewise. * hppa-tdep.c (hppa64_integral_or_pointer_p): Likewise. * infcall.c (value_arg_coerce): Likewise. * language.c (pointer_type): Likewise. * m32c-tdep.c (m32c_reg_arg_type, m32c_m16c_address_to_pointer): Likewise. * m88k-tdep.c (m88k_integral_or_pointer_p): Likewise. * mn10300-tdep.c (mn10300_type_align): Likewise. * msp430-tdep.c (msp430_push_dummy_call): Likewise. * ppc-sysv-tdep.c (do_ppc_sysv_return_value) (ppc64_sysv_abi_push_param, ppc64_sysv_abi_return_value): Likewise. * printcmd.c (print_formatted, x_command): Likewise. * python/py-type.c (typy_get_composite, typy_template_argument): Likewise. * python/py-value.c (valpy_referenced_value) (valpy_get_dynamic_type, value_has_field): Likewise. * s390-linux-tdep.c (s390_function_arg_integer): Likewise. * sparc-tdep.c (sparc_integral_or_pointer_p): Likewise. * sparc64-tdep.c (sparc64_integral_or_pointer_p): Likewise. * spu-tdep.c (spu_scalar_value_p): Likewise. * symtab.c (lookup_symbol_aux): Likewise. * typeprint.c (whatis_exp, print_type_scalar): Likewise. * valarith.c (binop_types_user_defined_p, unop_user_defined_p): Likewise. * valops.c (value_cast_pointers, value_cast) (value_reinterpret_cast, value_dynamic_cast, value_addr, typecmp) (value_struct_elt, value_struct_elt_bitpos) (value_find_oload_method_list, find_overload_match) (value_rtti_indirect_type): Likewise. * valprint.c (val_print_scalar_type_p, generic_val_print): Likewise. * value.c (value_actual_type, value_as_address, unpack_long) (pack_long, pack_unsigned_long, coerce_ref_if_computed) (coerce_ref): Likewise. * varobj.c (varobj_get_value_type): Likewise. --- gdb/aarch64-tdep.c | 5 +++-- gdb/amd64-tdep.c | 2 +- gdb/amd64-windows-tdep.c | 1 + gdb/arm-tdep.c | 5 +++-- gdb/ax-gdb.c | 2 ++ gdb/c-varobj.c | 10 ++++----- gdb/compile/compile-c-symbols.c | 2 +- gdb/completer.c | 3 +-- gdb/cp-support.c | 2 +- gdb/darwin-nat-info.c | 2 +- gdb/dwarf2loc.c | 4 ++-- gdb/eval.c | 14 ++++++------- gdb/findvar.c | 6 ++---- gdb/gdbtypes.c | 5 +++-- gdb/hppa-tdep.c | 1 + gdb/infcall.c | 3 ++- gdb/language.c | 3 +-- gdb/m32c-tdep.c | 8 +++----- gdb/m88k-tdep.c | 1 + gdb/mn10300-tdep.c | 1 + gdb/msp430-tdep.c | 2 +- gdb/ppc-sysv-tdep.c | 7 +++---- gdb/printcmd.c | 2 +- gdb/python/py-type.c | 5 ++--- gdb/python/py-value.c | 6 +++--- gdb/s390-linux-tdep.c | 2 +- gdb/sparc-tdep.c | 1 + gdb/sparc64-tdep.c | 1 + gdb/spu-tdep.c | 1 + gdb/symtab.c | 3 +-- gdb/typeprint.c | 4 ++-- gdb/valarith.c | 6 +++--- gdb/valops.c | 45 ++++++++++++++++++----------------------- gdb/valprint.c | 5 +++-- gdb/value.c | 12 ++++++----- gdb/varobj.c | 2 +- 36 files changed, 93 insertions(+), 91 deletions(-) diff --git a/gdb/aarch64-tdep.c b/gdb/aarch64-tdep.c index 88fcf4b..59638c4 100644 --- a/gdb/aarch64-tdep.c +++ b/gdb/aarch64-tdep.c @@ -882,6 +882,7 @@ aarch64_type_align (struct type *t) case TYPE_CODE_RANGE: case TYPE_CODE_BITSTRING: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: case TYPE_CODE_CHAR: case TYPE_CODE_BOOL: return TYPE_LENGTH (t); @@ -1599,7 +1600,7 @@ aarch64_extract_return_value (struct type *type, struct regcache *regs, || TYPE_CODE (type) == TYPE_CODE_CHAR || TYPE_CODE (type) == TYPE_CODE_BOOL || TYPE_CODE (type) == TYPE_CODE_PTR - || TYPE_CODE (type) == TYPE_CODE_REF + || TYPE_IS_REFERENCE (type) || TYPE_CODE (type) == TYPE_CODE_ENUM) { /* If the the type is a plain integer, then the access is @@ -1737,7 +1738,7 @@ aarch64_store_return_value (struct type *type, struct regcache *regs, || TYPE_CODE (type) == TYPE_CODE_CHAR || TYPE_CODE (type) == TYPE_CODE_BOOL || TYPE_CODE (type) == TYPE_CODE_PTR - || TYPE_CODE (type) == TYPE_CODE_REF + || TYPE_IS_REFERENCE (type) || TYPE_CODE (type) == TYPE_CODE_ENUM) { if (TYPE_LENGTH (type) <= X_REGISTER_SIZE) diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c index 6289d21..c689148 100644 --- a/gdb/amd64-tdep.c +++ b/gdb/amd64-tdep.c @@ -673,7 +673,7 @@ amd64_classify (struct type *type, enum amd64_reg_class theclass[2]) if ((code == TYPE_CODE_INT || code == TYPE_CODE_ENUM || code == TYPE_CODE_BOOL || code == TYPE_CODE_RANGE || code == TYPE_CODE_CHAR - || code == TYPE_CODE_PTR || code == TYPE_CODE_REF) + || code == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type)) && (len == 1 || len == 2 || len == 4 || len == 8)) theclass[0] = AMD64_INTEGER; diff --git a/gdb/amd64-windows-tdep.c b/gdb/amd64-windows-tdep.c index 1bec6de..e9ff49f 100644 --- a/gdb/amd64-windows-tdep.c +++ b/gdb/amd64-windows-tdep.c @@ -55,6 +55,7 @@ amd64_windows_passed_by_integer_register (struct type *type) case TYPE_CODE_CHAR: case TYPE_CODE_PTR: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: case TYPE_CODE_STRUCT: case TYPE_CODE_UNION: return (TYPE_LENGTH (type) == 1 diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c index 278f639..7e23ed1 100644 --- a/gdb/arm-tdep.c +++ b/gdb/arm-tdep.c @@ -3343,6 +3343,7 @@ arm_type_align (struct type *t) case TYPE_CODE_SET: case TYPE_CODE_RANGE: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: case TYPE_CODE_CHAR: case TYPE_CODE_BOOL: return TYPE_LENGTH (t); @@ -7899,7 +7900,7 @@ arm_extract_return_value (struct type *type, struct regcache *regs, || TYPE_CODE (type) == TYPE_CODE_CHAR || TYPE_CODE (type) == TYPE_CODE_BOOL || TYPE_CODE (type) == TYPE_CODE_PTR - || TYPE_CODE (type) == TYPE_CODE_REF + || TYPE_IS_REFERENCE (type) || TYPE_CODE (type) == TYPE_CODE_ENUM) { /* If the type is a plain integer, then the access is @@ -8104,7 +8105,7 @@ arm_store_return_value (struct type *type, struct regcache *regs, || TYPE_CODE (type) == TYPE_CODE_CHAR || TYPE_CODE (type) == TYPE_CODE_BOOL || TYPE_CODE (type) == TYPE_CODE_PTR - || TYPE_CODE (type) == TYPE_CODE_REF + || TYPE_IS_REFERENCE (type) || TYPE_CODE (type) == TYPE_CODE_ENUM) { if (TYPE_LENGTH (type) <= 4) diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c index 7c6cb64..7ec01e7 100644 --- a/gdb/ax-gdb.c +++ b/gdb/ax-gdb.c @@ -491,6 +491,7 @@ gen_fetch (struct agent_expr *ax, struct type *type) { case TYPE_CODE_PTR: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: case TYPE_CODE_ENUM: case TYPE_CODE_INT: case TYPE_CODE_CHAR: @@ -1001,6 +1002,7 @@ gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type) { case TYPE_CODE_PTR: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: /* It's implementation-defined, and I'll bet this is what GCC does. */ break; diff --git a/gdb/c-varobj.c b/gdb/c-varobj.c index 48e16f9..f7bdee0 100644 --- a/gdb/c-varobj.c +++ b/gdb/c-varobj.c @@ -78,7 +78,7 @@ adjust_value_for_child_access (struct value **value, to us, is already supposed to be reference-stripped. */ - gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF); + gdb_assert (!TYPE_IS_REFERENCE (*type)); /* Pointers to structures are treated just like structures when accessing children. Don't @@ -489,7 +489,7 @@ c_value_of_variable (const struct varobj *var, struct type *type = get_type (var); /* Strip top-level references. */ - while (TYPE_CODE (type) == TYPE_CODE_REF) + while (TYPE_IS_REFERENCE (type)) type = check_typedef (TYPE_TARGET_TYPE (type)); switch (TYPE_CODE (type)) @@ -586,7 +586,7 @@ cplus_number_of_children (const struct varobj *var) if (opts.objectprint) { value = var->value; - lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF + lookup_actual_type = (TYPE_IS_REFERENCE (var->type) || TYPE_CODE (var->type) == TYPE_CODE_PTR); } adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type); @@ -623,7 +623,7 @@ cplus_number_of_children (const struct varobj *var) const struct varobj *parent = var->parent; value = parent->value; - lookup_actual_type = (TYPE_CODE (parent->type) == TYPE_CODE_REF + lookup_actual_type = (TYPE_IS_REFERENCE (parent->type) || TYPE_CODE (parent->type) == TYPE_CODE_PTR); } adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type); @@ -728,7 +728,7 @@ cplus_describe_child (const struct varobj *parent, int index, var = (CPLUS_FAKE_CHILD (parent)) ? parent->parent : parent; if (opts.objectprint) - lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF + lookup_actual_type = (TYPE_IS_REFERENCE (var->type) || TYPE_CODE (var->type) == TYPE_CODE_PTR); value = var->value; type = varobj_get_value_type (var); diff --git a/gdb/compile/compile-c-symbols.c b/gdb/compile/compile-c-symbols.c index dcd530d..c06687f 100644 --- a/gdb/compile/compile-c-symbols.c +++ b/gdb/compile/compile-c-symbols.c @@ -593,7 +593,7 @@ generate_vla_size (struct compile_c_instance *compiler, { type = check_typedef (type); - if (TYPE_CODE (type) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (type)) type = check_typedef (TYPE_TARGET_TYPE (type)); switch (TYPE_CODE (type)) diff --git a/gdb/completer.c b/gdb/completer.c index 5c3b3fc..ec0f65d 100644 --- a/gdb/completer.c +++ b/gdb/completer.c @@ -610,8 +610,7 @@ expression_completer (struct cmd_list_element *ignore, for (;;) { type = check_typedef (type); - if (TYPE_CODE (type) != TYPE_CODE_PTR - && TYPE_CODE (type) != TYPE_CODE_REF) + if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type)) break; type = TYPE_TARGET_TYPE (type); } diff --git a/gdb/cp-support.c b/gdb/cp-support.c index a917ede..eb02c02 100644 --- a/gdb/cp-support.c +++ b/gdb/cp-support.c @@ -1284,7 +1284,7 @@ make_symbol_overload_list_adl_namespace (struct type *type, int i, prefix_len; while (TYPE_CODE (type) == TYPE_CODE_PTR - || TYPE_CODE (type) == TYPE_CODE_REF + || TYPE_IS_REFERENCE (type) || TYPE_CODE (type) == TYPE_CODE_ARRAY || TYPE_CODE (type) == TYPE_CODE_TYPEDEF) { diff --git a/gdb/darwin-nat-info.c b/gdb/darwin-nat-info.c index 314d265..4b4059a 100644 --- a/gdb/darwin-nat-info.c +++ b/gdb/darwin-nat-info.c @@ -732,7 +732,7 @@ info_mach_region_command (char *exp, int from_tty) expr = parse_expression (exp); val = evaluate_expression (expr); - if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (value_type (val))) { val = value_ind (val); } diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c index adb0ac2..cd7a683 100644 --- a/gdb/dwarf2loc.c +++ b/gdb/dwarf2loc.c @@ -1343,7 +1343,7 @@ entry_data_value_coerce_ref (const struct value *value) struct type *checked_type = check_typedef (value_type (value)); struct value *target_val; - if (TYPE_CODE (checked_type) != TYPE_CODE_REF) + if (!TYPE_IS_REFERENCE (checked_type)) return NULL; target_val = (struct value *) value_computed_closure (value); @@ -1418,7 +1418,7 @@ value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame, TYPE_CODE_REF with non-entry data value would give current value - not the entry value. */ - if (TYPE_CODE (checked_type) != TYPE_CODE_REF + if (!TYPE_IS_REFERENCE (checked_type) || TYPE_TARGET_TYPE (checked_type) == NULL) return outer_val; diff --git a/gdb/eval.c b/gdb/eval.c index 182a6c3..b73eb7f 100644 --- a/gdb/eval.c +++ b/gdb/eval.c @@ -640,7 +640,7 @@ static int ptrmath_type_p (const struct language_defn *lang, struct type *type) { type = check_typedef (type); - if (TYPE_CODE (type) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (type)) type = TYPE_TARGET_TYPE (type); switch (TYPE_CODE (type)) @@ -2510,7 +2510,7 @@ evaluate_subexp_standard (struct type *expect_type, { type = check_typedef (value_type (arg1)); if (TYPE_CODE (type) == TYPE_CODE_PTR - || TYPE_CODE (type) == TYPE_CODE_REF + || TYPE_IS_REFERENCE (type) /* In C you can dereference an array to get the 1st elt. */ || TYPE_CODE (type) == TYPE_CODE_ARRAY ) @@ -2788,7 +2788,7 @@ evaluate_subexp_standard (struct type *expect_type, { struct type *type = value_type (result); - if (TYPE_CODE (check_typedef (type)) != TYPE_CODE_REF) + if (!TYPE_IS_REFERENCE (type)) { type = lookup_lvalue_reference_type (type); result = allocate_value (type); @@ -2891,7 +2891,7 @@ evaluate_subexp_for_address (struct expression *exp, int *pos, /* C++: The "address" of a reference should yield the address * of the object pointed to. Let value_addr() deal with it. */ - if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var))) goto default_case; (*pos) += 4; @@ -2930,7 +2930,7 @@ evaluate_subexp_for_address (struct expression *exp, int *pos, { struct type *type = check_typedef (value_type (x)); - if (TYPE_CODE (type) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (type)) return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)), not_lval); else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x)) @@ -3020,7 +3020,7 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos, val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS); type = check_typedef (value_type (val)); if (TYPE_CODE (type) != TYPE_CODE_PTR - && TYPE_CODE (type) != TYPE_CODE_REF + && !TYPE_IS_REFERENCE (type) && TYPE_CODE (type) != TYPE_CODE_ARRAY) error (_("Attempt to take contents of a non-pointer value.")); type = TYPE_TARGET_TYPE (type); @@ -3092,7 +3092,7 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos, the size of the referenced type." */ type = check_typedef (type); if (exp->language_defn->la_language == language_cplus - && TYPE_CODE (type) == TYPE_CODE_REF) + && (TYPE_IS_REFERENCE (type))) type = check_typedef (TYPE_TARGET_TYPE (type)); return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type)); } diff --git a/gdb/findvar.c b/gdb/findvar.c index a39d897..b9b8d05 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -169,8 +169,7 @@ extract_long_unsigned_integer (const gdb_byte *addr, int orig_len, CORE_ADDR extract_typed_address (const gdb_byte *buf, struct type *type) { - if (TYPE_CODE (type) != TYPE_CODE_PTR - && TYPE_CODE (type) != TYPE_CODE_REF) + if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type)) internal_error (__FILE__, __LINE__, _("extract_typed_address: " "type is not a pointer or reference")); @@ -242,8 +241,7 @@ store_unsigned_integer (gdb_byte *addr, int len, void store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr) { - if (TYPE_CODE (type) != TYPE_CODE_PTR - && TYPE_CODE (type) != TYPE_CODE_REF) + if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type)) internal_error (__FILE__, __LINE__, _("store_typed_address: " "type is not a pointer or reference")); diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index ed31303..3058504 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -3511,10 +3511,11 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value) /* See through references, since we can almost make non-references references. */ - if (TYPE_CODE (arg) == TYPE_CODE_REF) + + if (TYPE_IS_REFERENCE (arg)) return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL), REFERENCE_CONVERSION_BADNESS)); - if (TYPE_CODE (parm) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (parm)) return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL), REFERENCE_CONVERSION_BADNESS)); if (overload_debug) diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c index f879a25..49445a8 100644 --- a/gdb/hppa-tdep.c +++ b/gdb/hppa-tdep.c @@ -898,6 +898,7 @@ hppa64_integral_or_pointer_p (const struct type *type) } case TYPE_CODE_PTR: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: return (TYPE_LENGTH (type) == 8); default: break; diff --git a/gdb/infcall.c b/gdb/infcall.c index ad2512a..5a2a4a7 100644 --- a/gdb/infcall.c +++ b/gdb/infcall.c @@ -158,10 +158,11 @@ value_arg_coerce (struct gdbarch *gdbarch, struct value *arg, switch (TYPE_CODE (type)) { case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: { struct value *new_value; - if (TYPE_CODE (arg_type) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (arg_type)) return value_cast_pointers (type, arg, 0); /* Cast the value to the reference's target type, and then diff --git a/gdb/language.c b/gdb/language.c index 8469754..15ee998 100644 --- a/gdb/language.c +++ b/gdb/language.c @@ -410,8 +410,7 @@ language_info (int quietly) int pointer_type (struct type *type) { - return TYPE_CODE (type) == TYPE_CODE_PTR || - TYPE_CODE (type) == TYPE_CODE_REF; + return TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type); } diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c index 59927a6..7f38a67 100644 --- a/gdb/m32c-tdep.c +++ b/gdb/m32c-tdep.c @@ -2030,7 +2030,7 @@ m32c_reg_arg_type (struct type *type) return (code == TYPE_CODE_INT || code == TYPE_CODE_ENUM || code == TYPE_CODE_PTR - || code == TYPE_CODE_REF + || TYPE_IS_REFERENCE (type) || code == TYPE_CODE_BOOL || code == TYPE_CODE_CHAR); } @@ -2452,8 +2452,7 @@ m32c_m16c_address_to_pointer (struct gdbarch *gdbarch, { enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); enum type_code target_code; - gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR || - TYPE_CODE (type) == TYPE_CODE_REF); + gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type)); target_code = TYPE_CODE (TYPE_TARGET_TYPE (type)); @@ -2532,8 +2531,7 @@ m32c_m16c_pointer_to_address (struct gdbarch *gdbarch, CORE_ADDR ptr; enum type_code target_code; - gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR || - TYPE_CODE (type) == TYPE_CODE_REF); + gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type)); ptr = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order); diff --git a/gdb/m88k-tdep.c b/gdb/m88k-tdep.c index 1a3c2cd..2a90a3a 100644 --- a/gdb/m88k-tdep.c +++ b/gdb/m88k-tdep.c @@ -165,6 +165,7 @@ m88k_integral_or_pointer_p (const struct type *type) return 1; case TYPE_CODE_PTR: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: { /* Allow only 32-bit pointers. */ return (TYPE_LENGTH (type) == 4); diff --git a/gdb/mn10300-tdep.c b/gdb/mn10300-tdep.c index 9ef88a8..c0c4c35 100644 --- a/gdb/mn10300-tdep.c +++ b/gdb/mn10300-tdep.c @@ -96,6 +96,7 @@ mn10300_type_align (struct type *type) case TYPE_CODE_FLT: case TYPE_CODE_PTR: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: return TYPE_LENGTH (type); case TYPE_CODE_COMPLEX: diff --git a/gdb/msp430-tdep.c b/gdb/msp430-tdep.c index 84189dc..1d878d5 100644 --- a/gdb/msp430-tdep.c +++ b/gdb/msp430-tdep.c @@ -768,7 +768,7 @@ msp430_push_dummy_call (struct gdbarch *gdbarch, struct value *function, if (code_model == MSP_LARGE_CODE_MODEL && (TYPE_CODE (arg_type) == TYPE_CODE_PTR - || TYPE_CODE (arg_type) == TYPE_CODE_REF + || TYPE_IS_REFERENCE (arg_type) || TYPE_CODE (arg_type) == TYPE_CODE_STRUCT || TYPE_CODE (arg_type) == TYPE_CODE_UNION)) { diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c index 140d993..20e2a40 100644 --- a/gdb/ppc-sysv-tdep.c +++ b/gdb/ppc-sysv-tdep.c @@ -805,7 +805,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, || TYPE_CODE (type) == TYPE_CODE_CHAR || TYPE_CODE (type) == TYPE_CODE_BOOL || TYPE_CODE (type) == TYPE_CODE_PTR - || TYPE_CODE (type) == TYPE_CODE_REF + || TYPE_IS_REFERENCE (type) || TYPE_CODE (type) == TYPE_CODE_ENUM) && TYPE_LENGTH (type) <= tdep->wordsize) { @@ -1493,7 +1493,7 @@ ppc64_sysv_abi_push_param (struct gdbarch *gdbarch, || TYPE_CODE (type) == TYPE_CODE_BOOL || TYPE_CODE (type) == TYPE_CODE_CHAR || TYPE_CODE (type) == TYPE_CODE_PTR - || TYPE_CODE (type) == TYPE_CODE_REF) + || TYPE_IS_REFERENCE (type)) && TYPE_LENGTH (type) <= tdep->wordsize) { ULONGEST word = 0; @@ -1999,8 +1999,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function, } /* All pointers live in r3. */ - if (TYPE_CODE (valtype) == TYPE_CODE_PTR - || TYPE_CODE (valtype) == TYPE_CODE_REF) + if (TYPE_CODE (valtype) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (valtype)) { int regnum = tdep->ppc_gp0_regnum + 3; diff --git a/gdb/printcmd.c b/gdb/printcmd.c index f5c4211..8e6a1d8 100644 --- a/gdb/printcmd.c +++ b/gdb/printcmd.c @@ -1449,7 +1449,7 @@ x_command (char *exp, int from_tty) *exp = 0; old_chain = make_cleanup (free_current_contents, &expr); val = evaluate_expression (expr); - if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (value_type (val))) val = coerce_ref (val); /* In rvalue contexts, such as this, functions are coerced into pointers to functions. This makes "x/i main" work. */ diff --git a/gdb/python/py-type.c b/gdb/python/py-type.c index 259bb70..835f1e4 100644 --- a/gdb/python/py-type.c +++ b/gdb/python/py-type.c @@ -486,8 +486,7 @@ typy_get_composite (struct type *type) } END_CATCH - if (TYPE_CODE (type) != TYPE_CODE_PTR - && TYPE_CODE (type) != TYPE_CODE_REF) + if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type)) break; type = TYPE_TARGET_TYPE (type); } @@ -967,7 +966,7 @@ typy_template_argument (PyObject *self, PyObject *args) TRY { type = check_typedef (type); - if (TYPE_CODE (type) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (type)) type = check_typedef (TYPE_TARGET_TYPE (type)); } CATCH (except, RETURN_MASK_ALL) diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c index a422796..ee17ebf 100644 --- a/gdb/python/py-value.c +++ b/gdb/python/py-value.c @@ -217,6 +217,7 @@ valpy_referenced_value (PyObject *self, PyObject *args) res_val = value_ind (self_val); break; case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: res_val = coerce_ref (self_val); break; default: @@ -370,8 +371,7 @@ valpy_get_dynamic_type (PyObject *self, void *closure) type = value_type (val); type = check_typedef (type); - if (((TYPE_CODE (type) == TYPE_CODE_PTR) - || (TYPE_CODE (type) == TYPE_CODE_REF)) + if (((TYPE_CODE (type) == TYPE_CODE_PTR) || TYPE_IS_REFERENCE (type)) && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT)) { struct value *target; @@ -1031,7 +1031,7 @@ enum valpy_opcode /* If TYPE is a reference, return the target; otherwise return TYPE. */ #define STRIP_REFERENCE(TYPE) \ - ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE)) + (TYPE_IS_REFERENCE (TYPE) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE)) /* Helper for valpy_binop. Returns a value object which is the result of applying the operation specified by OPCODE to the given diff --git a/gdb/s390-linux-tdep.c b/gdb/s390-linux-tdep.c index 2106333..cc08f61 100644 --- a/gdb/s390-linux-tdep.c +++ b/gdb/s390-linux-tdep.c @@ -3148,7 +3148,7 @@ s390_function_arg_integer (struct type *type) || code == TYPE_CODE_CHAR || code == TYPE_CODE_BOOL || code == TYPE_CODE_PTR - || code == TYPE_CODE_REF) + || TYPE_IS_REFERENCE (type)) return 1; return ((code == TYPE_CODE_UNION || code == TYPE_CODE_STRUCT) diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c index 5a8acce..d85902a 100644 --- a/gdb/sparc-tdep.c +++ b/gdb/sparc-tdep.c @@ -225,6 +225,7 @@ sparc_integral_or_pointer_p (const struct type *type) return (len == 1 || len == 2 || len == 4 || len == 8); case TYPE_CODE_PTR: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: /* Allow either 32-bit or 64-bit pointers. */ return (len == 4 || len == 8); default: diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c index 5e8f17d..382fbc5 100644 --- a/gdb/sparc64-tdep.c +++ b/gdb/sparc64-tdep.c @@ -67,6 +67,7 @@ sparc64_integral_or_pointer_p (const struct type *type) return 1; case TYPE_CODE_PTR: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: { int len = TYPE_LENGTH (type); gdb_assert (len == 8); diff --git a/gdb/spu-tdep.c b/gdb/spu-tdep.c index ea3229c..eb9a16d 100644 --- a/gdb/spu-tdep.c +++ b/gdb/spu-tdep.c @@ -1338,6 +1338,7 @@ spu_scalar_value_p (struct type *type) case TYPE_CODE_BOOL: case TYPE_CODE_PTR: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: return TYPE_LENGTH (type) <= 16; default: diff --git a/gdb/symtab.c b/gdb/symtab.c index f7a207a..b332670 100644 --- a/gdb/symtab.c +++ b/gdb/symtab.c @@ -2179,8 +2179,7 @@ lookup_symbol_aux (const char *name, const struct block *block, /* I'm not really sure that type of this can ever be typedefed; just be safe. */ t = check_typedef (t); - if (TYPE_CODE (t) == TYPE_CODE_PTR - || TYPE_CODE (t) == TYPE_CODE_REF) + if (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t)) t = TYPE_TARGET_TYPE (t); if (TYPE_CODE (t) != TYPE_CODE_STRUCT diff --git a/gdb/typeprint.c b/gdb/typeprint.c index 48a809b..366654e 100644 --- a/gdb/typeprint.c +++ b/gdb/typeprint.c @@ -463,8 +463,7 @@ whatis_exp (char *exp, int show) get_user_print_options (&opts); if (opts.objectprint) { - if (((TYPE_CODE (type) == TYPE_CODE_PTR) - || (TYPE_CODE (type) == TYPE_CODE_REF)) + if (((TYPE_CODE (type) == TYPE_CODE_PTR) || TYPE_IS_REFERENCE (type)) && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT)) real_type = value_rtti_indirect_type (val, &full, &top, &using_enc); else if (TYPE_CODE (type) == TYPE_CODE_STRUCT) @@ -581,6 +580,7 @@ print_type_scalar (struct type *type, LONGEST val, struct ui_file *stream) case TYPE_CODE_METHODPTR: case TYPE_CODE_METHOD: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: case TYPE_CODE_NAMESPACE: error (_("internal error: unhandled type in print_type_scalar")); break; diff --git a/gdb/valarith.c b/gdb/valarith.c index 254d998..337be9e 100644 --- a/gdb/valarith.c +++ b/gdb/valarith.c @@ -247,11 +247,11 @@ binop_types_user_defined_p (enum exp_opcode op, return 0; type1 = check_typedef (type1); - if (TYPE_CODE (type1) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (type1)) type1 = check_typedef (TYPE_TARGET_TYPE (type1)); type2 = check_typedef (type2); - if (TYPE_CODE (type2) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (type2)) type2 = check_typedef (TYPE_TARGET_TYPE (type2)); return (TYPE_CODE (type1) == TYPE_CODE_STRUCT @@ -285,7 +285,7 @@ unop_user_defined_p (enum exp_opcode op, struct value *arg1) if (op == UNOP_ADDR) return 0; type1 = check_typedef (value_type (arg1)); - if (TYPE_CODE (type1) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (type1)) type1 = check_typedef (TYPE_TARGET_TYPE (type1)); return TYPE_CODE (type1) == TYPE_CODE_STRUCT; } diff --git a/gdb/valops.c b/gdb/valops.c index c2fc0db..f1b6c5f 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -317,7 +317,7 @@ value_cast_pointers (struct type *type, struct value *arg2, { struct value *v2; - if (TYPE_CODE (type2) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (type2)) v2 = coerce_ref (arg2); else v2 = value_ind (arg2); @@ -360,24 +360,20 @@ value_cast (struct type *type, struct value *arg2) if (value_type (arg2) == type) return arg2; - code1 = TYPE_CODE (check_typedef (type)); - /* Check if we are casting struct reference to struct reference. */ - if (code1 == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (check_typedef (type))) { /* We dereference type; then we recurse and finally we generate value of the given reference. Nothing wrong with that. */ struct type *t1 = check_typedef (type); struct type *dereftype = check_typedef (TYPE_TARGET_TYPE (t1)); - struct value *val = value_cast (dereftype, arg2); + struct value *val = value_cast (dereftype, arg2); return value_ref (val, TYPE_CODE (t1)); } - code2 = TYPE_CODE (check_typedef (value_type (arg2))); - - if (code2 == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (check_typedef (value_type (arg2)))) /* We deref the value and then do the cast. */ return value_cast (type, coerce_ref (arg2)); @@ -388,7 +384,7 @@ value_cast (struct type *type, struct value *arg2) /* You can't cast to a reference type. See value_cast_pointers instead. */ - gdb_assert (code1 != TYPE_CODE_REF); + gdb_assert (!TYPE_IS_REFERENCE (type)); /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT, @@ -591,8 +587,8 @@ value_reinterpret_cast (struct type *type, struct value *arg) dest_type = type; /* If we are casting to a reference type, transform - reinterpret_cast(V) to *reinterpret_cast(&V). */ - if (TYPE_CODE (real_type) == TYPE_CODE_REF) + reinterpret_cast(V) to *reinterpret_cast(&V). */ + if (TYPE_IS_REFERENCE (real_type)) { is_ref = 1; arg = value_addr (arg); @@ -730,10 +726,10 @@ value_dynamic_cast (struct type *type, struct value *arg) struct type *class_type, *rtti_type; struct value *result, *tem, *original_arg = arg; CORE_ADDR addr; - int is_ref = TYPE_CODE (resolved_type) == TYPE_CODE_REF; + int is_ref = TYPE_IS_REFERENCE (resolved_type); if (TYPE_CODE (resolved_type) != TYPE_CODE_PTR - && TYPE_CODE (resolved_type) != TYPE_CODE_REF) + && !TYPE_IS_REFERENCE (resolved_type)) error (_("Argument to dynamic_cast must be a pointer or reference type")); if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_VOID && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_STRUCT) @@ -1468,7 +1464,7 @@ value_addr (struct value *arg1) struct value *arg2; struct type *type = check_typedef (value_type (arg1)); - if (TYPE_CODE (type) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (type)) { if (value_bits_synthetic_pointer (arg1, value_embedded_offset (arg1), TARGET_CHAR_BIT * TYPE_LENGTH (type))) @@ -1734,7 +1730,7 @@ typecmp (int staticp, int varargs, int nargs, tt1 = check_typedef (t1[i].type); tt2 = check_typedef (value_type (t2[i])); - if (TYPE_CODE (tt1) == TYPE_CODE_REF + if (TYPE_IS_REFERENCE (tt1) /* We should be doing hairy argument matching, as below. */ && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2))) @@ -1752,14 +1748,13 @@ typecmp (int staticp, int varargs, int nargs, char *>, and properly access map["hello"], because the argument to [] will be a reference to a pointer to a char, and the argument will be a pointer to a char. */ - while (TYPE_CODE(tt1) == TYPE_CODE_REF - || TYPE_CODE (tt1) == TYPE_CODE_PTR) + while (TYPE_IS_REFERENCE (tt1) || TYPE_CODE (tt1) == TYPE_CODE_PTR) { tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) ); } while (TYPE_CODE(tt2) == TYPE_CODE_ARRAY || TYPE_CODE(tt2) == TYPE_CODE_PTR - || TYPE_CODE(tt2) == TYPE_CODE_REF) + || TYPE_IS_REFERENCE (tt2)) { tt2 = check_typedef (TYPE_TARGET_TYPE(tt2)); } @@ -2151,7 +2146,7 @@ value_struct_elt (struct value **argp, struct value **args, /* Follow pointers until we get to a non-pointer. */ - while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF) + while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t)) { *argp = value_ind (*argp); /* Don't coerce fn pointer to fn and then back again! */ @@ -2238,7 +2233,7 @@ value_struct_elt_bitpos (struct value **argp, int bitpos, struct type *ftype, t = check_typedef (value_type (*argp)); - while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF) + while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t)) { *argp = value_ind (*argp); if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC) @@ -2399,7 +2394,7 @@ value_find_oload_method_list (struct value **argp, const char *method, t = check_typedef (value_type (*argp)); /* Code snarfed from value_struct_elt. */ - while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF) + while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t)) { *argp = value_ind (*argp); /* Don't coerce fn pointer to fn and then back again! */ @@ -2808,7 +2803,7 @@ find_overload_match (struct value **args, int nargs, if (TYPE_CODE (temp_type) != TYPE_CODE_PTR && (TYPE_CODE (objtype) == TYPE_CODE_PTR - || TYPE_CODE (objtype) == TYPE_CODE_REF)) + || TYPE_IS_REFERENCE (objtype))) { temp = value_addr (temp); } @@ -3604,7 +3599,7 @@ value_rtti_indirect_type (struct value *v, int *full, type = value_type (v); type = check_typedef (type); - if (TYPE_CODE (type) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (type)) target = coerce_ref (v); else if (TYPE_CODE (type) == TYPE_CODE_PTR) { @@ -3637,8 +3632,8 @@ value_rtti_indirect_type (struct value *v, int *full, target_type = value_type (target); 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_lvalue_reference_type (real_type); + if (TYPE_IS_REFERENCE (type)) + real_type = lookup_reference_type (real_type, TYPE_CODE (type)); else if (TYPE_CODE (type) == TYPE_CODE_PTR) real_type = lookup_pointer_type (real_type); else diff --git a/gdb/valprint.c b/gdb/valprint.c index 64407e8..af58b15 100644 --- a/gdb/valprint.c +++ b/gdb/valprint.c @@ -280,7 +280,7 @@ int val_print_scalar_type_p (struct type *type) { type = check_typedef (type); - while (TYPE_CODE (type) == TYPE_CODE_REF) + while (TYPE_IS_REFERENCE (type)) { type = TYPE_TARGET_TYPE (type); type = check_typedef (type); @@ -534,7 +534,7 @@ get_value_addr_contents (struct value *deref_val) } } -/* generic_val_print helper for TYPE_CODE_REF. */ +/* generic_val_print helper for TYPE_CODE_{RVALUE_,}REF. */ static void generic_val_print_ref (struct type *type, const gdb_byte *valaddr, @@ -934,6 +934,7 @@ generic_val_print (struct type *type, const gdb_byte *valaddr, break; case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: generic_val_print_ref (type, valaddr, embedded_offset, stream, recurse, original_value, options); break; diff --git a/gdb/value.c b/gdb/value.c index 35fb503..e6a8e49 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -1202,8 +1202,7 @@ value_actual_type (struct value *value, int resolve_simple_types, { /* If result's target type is TYPE_CODE_STRUCT, proceed to fetch its rtti type. */ - if ((TYPE_CODE (result) == TYPE_CODE_PTR - || TYPE_CODE (result) == TYPE_CODE_REF) + if ((TYPE_CODE (result) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (result)) && TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (result))) == TYPE_CODE_STRUCT && !value_optimized_out (value)) @@ -2887,7 +2886,7 @@ value_as_address (struct value *val) ABI-specific code is a more reasonable place to handle it. */ if (TYPE_CODE (value_type (val)) != TYPE_CODE_PTR - && TYPE_CODE (value_type (val)) != TYPE_CODE_REF + && !TYPE_IS_REFERENCE (value_type (val)) && gdbarch_integer_to_address_p (gdbarch)) return gdbarch_integer_to_address (gdbarch, value_type (val), value_contents (val)); @@ -2944,6 +2943,7 @@ unpack_long (struct type *type, const gdb_byte *valaddr) case TYPE_CODE_PTR: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure whether we want this to be true eventually. */ return extract_typed_address (valaddr, type); @@ -3544,6 +3544,7 @@ pack_long (gdb_byte *buf, struct type *type, LONGEST num) break; case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: case TYPE_CODE_PTR: store_typed_address (buf, type, (CORE_ADDR) num); break; @@ -3580,6 +3581,7 @@ pack_unsigned_long (gdb_byte *buf, struct type *type, ULONGEST num) break; case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: case TYPE_CODE_PTR: store_typed_address (buf, type, (CORE_ADDR) num); break; @@ -3787,7 +3789,7 @@ coerce_ref_if_computed (const struct value *arg) { const struct lval_funcs *funcs; - if (TYPE_CODE (check_typedef (value_type (arg))) != TYPE_CODE_REF) + if (!TYPE_IS_REFERENCE (check_typedef (value_type (arg)))) return NULL; if (value_lval_const (arg) != lval_computed) @@ -3829,7 +3831,7 @@ coerce_ref (struct value *arg) if (retval) return retval; - if (TYPE_CODE (value_type_arg_tmp) != TYPE_CODE_REF) + if (!TYPE_IS_REFERENCE (value_type_arg_tmp)) return arg; enc_type = check_typedef (value_enclosing_type (arg)); diff --git a/gdb/varobj.c b/gdb/varobj.c index 6f56cba..2917432 100644 --- a/gdb/varobj.c +++ b/gdb/varobj.c @@ -2176,7 +2176,7 @@ varobj_get_value_type (const struct varobj *var) type = check_typedef (type); - if (TYPE_CODE (type) == TYPE_CODE_REF) + if (TYPE_IS_REFERENCE (type)) type = get_target_type (type); type = check_typedef (type); -- 2.8.3