From: Tom Tromey Date: Sat, 11 Sep 2021 19:58:04 +0000 (-0600) Subject: Change pointer_type to a method of struct type X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=809f3be12c0621cbf071c585da5638f6841c38b1;p=binutils-gdb.git Change pointer_type to a method of struct type I noticed that pointer_type is declared in language.h and defined in language.c. However, it really has to do with types, so it should have been in gdbtypes.h all along. This patch changes it to be a method on struct type. And, I went through uses of TYPE_IS_REFERENCE and updated many spots to use the new method as well. (I didn't update ones that were in arch-specific code, as I couldn't readily test that.) --- diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c index 009c128c83c..2eea12cfacd 100644 --- a/gdb/ax-gdb.c +++ b/gdb/ax-gdb.c @@ -961,7 +961,7 @@ static void gen_ptradd (struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2) { - gdb_assert (pointer_type (value1->type)); + gdb_assert (value1->type->is_pointer_or_reference ()); gdb_assert (value2->type->code () == TYPE_CODE_INT); gen_scale (ax, aop_mul, value1->type); @@ -977,7 +977,7 @@ static void gen_ptrsub (struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2) { - gdb_assert (pointer_type (value1->type)); + gdb_assert (value1->type->is_pointer_or_reference ()); gdb_assert (value2->type->code () == TYPE_CODE_INT); gen_scale (ax, aop_mul, value1->type); @@ -994,8 +994,8 @@ gen_ptrdiff (struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2, struct type *result_type) { - gdb_assert (pointer_type (value1->type)); - gdb_assert (pointer_type (value2->type)); + gdb_assert (value1->type->is_pointer_or_reference ()); + gdb_assert (value2->type->is_pointer_or_reference ()); if (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type)) != TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type))) @@ -1014,7 +1014,7 @@ gen_equal (struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2, struct type *result_type) { - if (pointer_type (value1->type) || pointer_type (value2->type)) + if (value1->type->is_pointer_or_reference () || value2->type->is_pointer_or_reference ()) ax_simple (ax, aop_equal); else gen_binop (ax, value, value1, value2, @@ -1028,7 +1028,7 @@ gen_less (struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2, struct type *result_type) { - if (pointer_type (value1->type) || pointer_type (value2->type)) + if (value1->type->is_pointer_or_reference () || value2->type->is_pointer_or_reference ()) ax_simple (ax, aop_less_unsigned); else gen_binop (ax, value, value1, value2, @@ -1095,7 +1095,7 @@ gen_deref (struct axs_value *value) { /* The caller should check the type, because several operators use this, and we don't know what error message to generate. */ - if (!pointer_type (value->type)) + if (!value->type->is_pointer_or_reference ()) internal_error (__FILE__, __LINE__, _("gen_deref: expected a pointer")); @@ -1401,7 +1401,7 @@ gen_struct_ref (struct agent_expr *ax, struct axs_value *value, /* Follow pointers until we reach a non-pointer. These aren't the C semantics, but they're what the normal GDB evaluator does, so we should at least be consistent. */ - while (pointer_type (value->type)) + while (value->type->is_pointer_or_reference ()) { require_rvalue (ax, value); gen_deref (value); @@ -2070,13 +2070,13 @@ gen_expr_binop_rest (struct expression *exp, { case BINOP_ADD: if (value1->type->code () == TYPE_CODE_INT - && pointer_type (value2->type)) + && value2->type->is_pointer_or_reference ()) { /* Swap the values and proceed normally. */ ax_simple (ax, aop_swap); gen_ptradd (ax, value, value2, value1); } - else if (pointer_type (value1->type) + else if (value1->type->is_pointer_or_reference () && value2->type->code () == TYPE_CODE_INT) gen_ptradd (ax, value, value1, value2); else @@ -2084,11 +2084,11 @@ gen_expr_binop_rest (struct expression *exp, aop_add, aop_add, 1, "addition"); break; case BINOP_SUB: - if (pointer_type (value1->type) + if (value1->type->is_pointer_or_reference () && value2->type->code () == TYPE_CODE_INT) gen_ptrsub (ax,value, value1, value2); - else if (pointer_type (value1->type) - && pointer_type (value2->type)) + else if (value1->type->is_pointer_or_reference () + && value2->type->is_pointer_or_reference ()) /* FIXME --- result type should be ptrdiff_t */ gen_ptrdiff (ax, value, value1, value2, builtin_type (ax->gdbarch)->builtin_long); @@ -2285,7 +2285,7 @@ gen_expr_unop (struct expression *exp, case UNOP_IND: lhs->generate_ax (exp, ax, value); gen_usual_unary (ax, value); - if (!pointer_type (value->type)) + if (!value->type->is_pointer_or_reference ()) error (_("Argument of unary `*' is not a pointer.")); gen_deref (value); break; diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c index 9c82869525f..d3071d1f5b9 100644 --- a/gdb/c-valprint.c +++ b/gdb/c-valprint.c @@ -486,7 +486,7 @@ c_value_print (struct value *val, struct ui_file *stream, type = check_typedef (value_type (val)); - if (type->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type)) + if (type->is_pointer_or_reference ()) { struct type *original_type = value_type (val); diff --git a/gdb/c-varobj.c b/gdb/c-varobj.c index f6db3a5d1ba..8056c1c9ec1 100644 --- a/gdb/c-varobj.c +++ b/gdb/c-varobj.c @@ -574,8 +574,7 @@ cplus_number_of_children (const struct varobj *var) if (opts.objectprint) { value = var->value.get (); - lookup_actual_type = (TYPE_IS_REFERENCE (var->type) - || var->type->code () == TYPE_CODE_PTR); + lookup_actual_type = var->type->is_pointer_or_reference (); } adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type); @@ -611,8 +610,7 @@ cplus_number_of_children (const struct varobj *var) const struct varobj *parent = var->parent; value = parent->value.get (); - lookup_actual_type = (TYPE_IS_REFERENCE (parent->type) - || parent->type->code () == TYPE_CODE_PTR); + lookup_actual_type = parent->type->is_pointer_or_reference (); } adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type); @@ -716,8 +714,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_IS_REFERENCE (var->type) - || var->type->code () == TYPE_CODE_PTR); + lookup_actual_type = var->type->is_pointer_or_reference (); value = var->value.get (); type = varobj_get_value_type (var); if (cfull_expression) diff --git a/gdb/completer.c b/gdb/completer.c index 40b976c8001..9444995575b 100644 --- a/gdb/completer.c +++ b/gdb/completer.c @@ -1134,7 +1134,7 @@ complete_expression (completion_tracker &tracker, for (;;) { type = check_typedef (type); - if (type->code () != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type)) + if (!type->is_pointer_or_reference ()) break; type = TYPE_TARGET_TYPE (type); } diff --git a/gdb/cp-support.c b/gdb/cp-support.c index 5bd8fd4e940..fb4c8364ae0 100644 --- a/gdb/cp-support.c +++ b/gdb/cp-support.c @@ -1335,8 +1335,7 @@ add_symbol_overload_list_adl_namespace (struct type *type, const char *type_name; int i, prefix_len; - while (type->code () == TYPE_CODE_PTR - || TYPE_IS_REFERENCE (type) + while (type->is_pointer_or_reference () || type->code () == TYPE_CODE_ARRAY || type->code () == TYPE_CODE_TYPEDEF) { diff --git a/gdb/eval.c b/gdb/eval.c index 5c348c34e66..1c5c8cf38af 100644 --- a/gdb/eval.c +++ b/gdb/eval.c @@ -1596,12 +1596,10 @@ eval_op_ind (struct type *expect_type, struct expression *exp, There is a risk that this dereference will have side-effects in the inferior, but being able to print accurate type information seems worth the risk. */ - if ((type->code () != TYPE_CODE_PTR - && !TYPE_IS_REFERENCE (type)) + if (!type->is_pointer_or_reference () || !is_dynamic_type (TYPE_TARGET_TYPE (type))) { - if (type->code () == TYPE_CODE_PTR - || TYPE_IS_REFERENCE (type) + if (type->is_pointer_or_reference () /* In C you can dereference an array to get the 1st elt. */ || type->code () == TYPE_CODE_ARRAY) return value_zero (TYPE_TARGET_TYPE (type), @@ -2706,8 +2704,7 @@ unop_ind_base_operation::evaluate_for_sizeof (struct expression *exp, value *val = std::get<0> (m_storage)->evaluate (nullptr, exp, EVAL_AVOID_SIDE_EFFECTS); struct type *type = check_typedef (value_type (val)); - if (type->code () != TYPE_CODE_PTR - && !TYPE_IS_REFERENCE (type) + if (!type->is_pointer_or_reference () && type->code () != TYPE_CODE_ARRAY) error (_("Attempt to take contents of a non-pointer value.")); type = TYPE_TARGET_TYPE (type); diff --git a/gdb/findvar.c b/gdb/findvar.c index fcd97191c14..56edbdba578 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -153,7 +153,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_CODE_PTR && !TYPE_IS_REFERENCE (type)) + if (!type->is_pointer_or_reference ()) internal_error (__FILE__, __LINE__, _("extract_typed_address: " "type is not a pointer or reference")); @@ -206,7 +206,7 @@ template void store_integer (gdb_byte *addr, int len, void store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr) { - if (type->code () != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type)) + if (!type->is_pointer_or_reference ()) 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 8fbc5d3a80b..67593dac055 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -4774,7 +4774,7 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value) struct type *t2 = arg; /* For pointers and references, compare target type. */ - if (parm->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (parm)) + if (parm->is_pointer_or_reference ()) { t1 = TYPE_TARGET_TYPE (parm); t2 = TYPE_TARGET_TYPE (arg); diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index bfb7f2965a6..2a641122aec 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -1355,6 +1355,12 @@ struct type return main_type->type_specific.int_stuff.bit_offset; } + /* Return true if this is a pointer or reference type. */ + bool is_pointer_or_reference () const + { + return this->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (this); + } + /* * Type that is a pointer to this type. NULL if no such pointer-to type is known yet. The debugger may add the address of such a type diff --git a/gdb/language.c b/gdb/language.c index 45ce2ebcc92..0354fb81865 100644 --- a/gdb/language.c +++ b/gdb/language.c @@ -388,14 +388,6 @@ language_info () } -/* Returns non-zero if the value is a pointer type. */ -int -pointer_type (struct type *type) -{ - return type->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type); -} - - /* This page contains functions that return info about (struct value) values used in GDB. */ diff --git a/gdb/language.h b/gdb/language.h index 40d22d20559..63d64b5b9da 100644 --- a/gdb/language.h +++ b/gdb/language.h @@ -774,10 +774,6 @@ extern enum language set_language (enum language); && ((c) < 0x7F || (c) >= 0xA0) \ && (!sevenbit_strings || (c) < 0x80)) -/* Type predicates */ - -extern int pointer_type (struct type *); - /* Error messages */ extern void range_error (const char *, ...) ATTRIBUTE_PRINTF (1, 2); diff --git a/gdb/python/py-type.c b/gdb/python/py-type.c index d82bdf84957..aa1553baf9e 100644 --- a/gdb/python/py-type.c +++ b/gdb/python/py-type.c @@ -470,7 +470,7 @@ typy_get_composite (struct type *type) GDB_PY_HANDLE_EXCEPTION (except); } - if (type->code () != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type)) + if (!type->is_pointer_or_reference ()) break; type = TYPE_TARGET_TYPE (type); } diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c index 26d5940f842..d45df5fd113 100644 --- a/gdb/python/py-value.c +++ b/gdb/python/py-value.c @@ -400,7 +400,7 @@ valpy_get_dynamic_type (PyObject *self, void *closure) type = value_type (val); type = check_typedef (type); - if (((type->code () == TYPE_CODE_PTR) || TYPE_IS_REFERENCE (type)) + if (type->is_pointer_or_reference () && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_STRUCT)) { struct value *target; @@ -851,7 +851,7 @@ value_has_field (struct value *v, PyObject *field) { val_type = value_type (v); val_type = check_typedef (val_type); - if (TYPE_IS_REFERENCE (val_type) || val_type->code () == TYPE_CODE_PTR) + if (val_type->is_pointer_or_reference ()) val_type = check_typedef (TYPE_TARGET_TYPE (val_type)); type_code = val_type->code (); diff --git a/gdb/symtab.c b/gdb/symtab.c index fa3f42207ec..a30d900cf8d 100644 --- a/gdb/symtab.c +++ b/gdb/symtab.c @@ -2068,7 +2068,7 @@ lookup_symbol_aux (const char *name, symbol_name_match_type match_type, /* I'm not really sure that type of this can ever be typedefed; just be safe. */ t = check_typedef (t); - if (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t)) + if (t->is_pointer_or_reference ()) t = TYPE_TARGET_TYPE (t); if (t->code () != TYPE_CODE_STRUCT diff --git a/gdb/typeprint.c b/gdb/typeprint.c index ed391411dfe..947109fa436 100644 --- a/gdb/typeprint.c +++ b/gdb/typeprint.c @@ -544,7 +544,7 @@ whatis_exp (const char *exp, int show) get_user_print_options (&opts); if (val != NULL && opts.objectprint) { - if (((type->code () == TYPE_CODE_PTR) || TYPE_IS_REFERENCE (type)) + if (type->is_pointer_or_reference () && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_STRUCT)) real_type = value_rtti_indirect_type (val, &full, &top, &using_enc); else if (type->code () == TYPE_CODE_STRUCT) diff --git a/gdb/valops.c b/gdb/valops.c index 50874a5f55d..67298604dd3 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -2335,7 +2335,7 @@ value_struct_elt (struct value **argp, /* Follow pointers until we get to a non-pointer. */ - while (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t)) + while (t->is_pointer_or_reference ()) { *argp = value_ind (*argp); /* Don't coerce fn pointer to fn and then back again! */ @@ -2422,7 +2422,7 @@ value_struct_elt_bitpos (struct value **argp, int bitpos, struct type *ftype, t = check_typedef (value_type (*argp)); - while (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t)) + while (t->is_pointer_or_reference ()) { *argp = value_ind (*argp); if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC) @@ -2575,7 +2575,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 (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t)) + while (t->is_pointer_or_reference ()) { *argp = value_ind (*argp); /* Don't coerce fn pointer to fn and then back again! */ @@ -2969,8 +2969,7 @@ find_overload_match (gdb::array_view args, struct type *objtype = check_typedef (obj_type); if (temp_type->code () != TYPE_CODE_PTR - && (objtype->code () == TYPE_CODE_PTR - || TYPE_IS_REFERENCE (objtype))) + && objtype->is_pointer_or_reference ()) { temp = value_addr (temp); } diff --git a/gdb/value.c b/gdb/value.c index 2cbaadc3641..3a2bc13985e 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -1182,7 +1182,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 ((result->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (result)) + if (result->is_pointer_or_reference () && (check_typedef (TYPE_TARGET_TYPE (result))->code () == TYPE_CODE_STRUCT) && !value_optimized_out (value)) @@ -2778,8 +2778,7 @@ value_as_address (struct value *val) converted to pointers; usually, the ABI doesn't either, but ABI-specific code is a more reasonable place to handle it. */ - if (value_type (val)->code () != TYPE_CODE_PTR - && !TYPE_IS_REFERENCE (value_type (val)) + if (!value_type (val)->is_pointer_or_reference () && gdbarch_integer_to_address_p (gdbarch)) return gdbarch_integer_to_address (gdbarch, value_type (val), value_contents (val)); @@ -3726,8 +3725,7 @@ readjust_indirect_value_type (struct value *value, struct type *enc_type, struct value *original_value, CORE_ADDR original_value_address) { - gdb_assert (original_type->code () == TYPE_CODE_PTR - || TYPE_IS_REFERENCE (original_type)); + gdb_assert (original_type->is_pointer_or_reference ()); struct type *original_target_type = TYPE_TARGET_TYPE (original_type); gdb::array_view view;