X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fgdbtypes.c;h=2a51372a0372468ea12889f068dbf2b7c92dc1e4;hb=f9a8785566fcd9b36f8e504346f70bc3d5b6cf82;hp=d8229309dc8ad6a4620142a38e18162cc3219720;hpb=2062087b358cc5320d52b32c50866dbd08fb2631;p=binutils-gdb.git diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index d8229309dc8..2a51372a037 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -1,6 +1,6 @@ /* Support routines for manipulating internal types for GDB. - Copyright (C) 1992-2020 Free Software Foundation, Inc. + Copyright (C) 1992-2022 Free Software Foundation, Inc. Contributed by Cygnus Support, using pieces from other GDB modules. @@ -37,16 +37,25 @@ #include "cp-support.h" #include "bcache.h" #include "dwarf2/loc.h" +#include "dwarf2/read.h" #include "gdbcore.h" #include "floatformat.h" +#include "f-lang.h" #include +#include "gmp-utils.h" + +/* The value of an invalid conversion badness. */ +#define INVALID_CONVERSION 100 + +static struct dynamic_prop_list * +copy_dynamic_prop_list (struct obstack *, struct dynamic_prop_list *); /* Initialize BADNESS constants. */ -const struct rank LENGTH_MISMATCH_BADNESS = {100,0}; +const struct rank LENGTH_MISMATCH_BADNESS = {INVALID_CONVERSION,0}; -const struct rank TOO_FEW_PARAMS_BADNESS = {100,0}; -const struct rank INCOMPATIBLE_TYPE_BADNESS = {100,0}; +const struct rank TOO_FEW_PARAMS_BADNESS = {INVALID_CONVERSION,0}; +const struct rank INCOMPATIBLE_TYPE_BADNESS = {INVALID_CONVERSION,0}; const struct rank EXACT_MATCH_BADNESS = {0,0}; @@ -79,6 +88,10 @@ const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN] = { &floatformat_ieee_double_big, &floatformat_ieee_double_little }; +const struct floatformat *floatformats_ieee_quad[BFD_ENDIAN_UNKNOWN] = { + &floatformat_ieee_quad_big, + &floatformat_ieee_quad_little +}; const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN] = { &floatformat_ieee_double_big, &floatformat_ieee_double_littlebyte_bigword @@ -99,10 +112,6 @@ const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN] = { &floatformat_ia64_spill_big, &floatformat_ia64_spill_little }; -const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN] = { - &floatformat_ia64_quad_big, - &floatformat_ia64_quad_little -}; const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN] = { &floatformat_vax_f, &floatformat_vax_f @@ -139,9 +148,9 @@ show_opaque_type_resolution (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { - fprintf_filtered (file, _("Resolution of opaque struct/class/union types " - "(if set before loading symbols) is %s.\n"), - value); + gdb_printf (file, _("Resolution of opaque struct/class/union types " + "(if set before loading symbols) is %s.\n"), + value); } /* A function to show whether C++ overload debugging is enabled. */ @@ -150,8 +159,8 @@ static void show_overload_debug (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { - fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"), - value); + gdb_printf (file, _("Debugging of C++ overloading is %s.\n"), + value); } /* A function to show the status of strict type checking. */ @@ -160,7 +169,7 @@ static void show_strict_type_checking (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { - fprintf_filtered (file, _("Strict type checking is %s.\n"), value); + gdb_printf (file, _("Strict type checking is %s.\n"), value); } @@ -181,8 +190,7 @@ alloc_type (struct objfile *objfile) struct main_type); OBJSTAT (objfile, n_types++); - TYPE_OBJFILE_OWNED (type) = 1; - TYPE_OWNER (type).objfile = objfile; + type->set_owner (objfile); /* Initialize the fields that might not be zero. */ @@ -208,8 +216,7 @@ alloc_type_arch (struct gdbarch *gdbarch) type = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct type); TYPE_MAIN_TYPE (type) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct main_type); - TYPE_OBJFILE_OWNED (type) = 0; - TYPE_OWNER (type).gdbarch = gdbarch; + type->set_owner (gdbarch); /* Initialize the fields that might not be zero. */ @@ -226,30 +233,29 @@ alloc_type_arch (struct gdbarch *gdbarch) struct type * alloc_type_copy (const struct type *type) { - if (TYPE_OBJFILE_OWNED (type)) - return alloc_type (TYPE_OWNER (type).objfile); + if (type->is_objfile_owned ()) + return alloc_type (type->objfile_owner ()); else - return alloc_type_arch (TYPE_OWNER (type).gdbarch); + return alloc_type_arch (type->arch_owner ()); } -/* If TYPE is gdbarch-associated, return that architecture. - If TYPE is objfile-associated, return that objfile's architecture. */ +/* See gdbtypes.h. */ -struct gdbarch * -get_type_arch (const struct type *type) +gdbarch * +type::arch () const { struct gdbarch *arch; - if (TYPE_OBJFILE_OWNED (type)) - arch = TYPE_OWNER (type).objfile->arch (); + if (this->is_objfile_owned ()) + arch = this->objfile_owner ()->arch (); else - arch = TYPE_OWNER (type).gdbarch; + arch = this->arch_owner (); /* The ARCH can be NULL if TYPE is associated with neither an objfile nor a gdbarch, however, this is very rare, and even then, in most cases - that get_type_arch is called, we assume that a non-NULL value is + that type::arch is called, we assume that a non-NULL value is returned. */ - gdb_assert (arch != NULL); + gdb_assert (arch != nullptr); return arch; } @@ -273,8 +279,7 @@ get_target_type (struct type *type) unsigned int type_length_units (struct type *type) { - struct gdbarch *arch = get_type_arch (type); - int unit_size = gdbarch_addressable_memory_unit_size (arch); + int unit_size = gdbarch_addressable_memory_unit_size (type->arch ()); return TYPE_LENGTH (type) / unit_size; } @@ -290,10 +295,10 @@ alloc_type_instance (struct type *oldtype) /* Allocate the structure. */ - if (! TYPE_OBJFILE_OWNED (oldtype)) - type = GDBARCH_OBSTACK_ZALLOC (get_type_arch (oldtype), struct type); + if (!oldtype->is_objfile_owned ()) + type = GDBARCH_OBSTACK_ZALLOC (oldtype->arch_owner (), struct type); else - type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack, + type = OBSTACK_ZALLOC (&oldtype->objfile_owner ()->objfile_obstack, struct type); TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype); @@ -309,14 +314,17 @@ alloc_type_instance (struct type *oldtype) static void smash_type (struct type *type) { - int objfile_owned = TYPE_OBJFILE_OWNED (type); - union type_owner owner = TYPE_OWNER (type); + bool objfile_owned = type->is_objfile_owned (); + objfile *objfile = type->objfile_owner (); + gdbarch *arch = type->arch_owner (); memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type)); /* Restore owner information. */ - TYPE_OBJFILE_OWNED (type) = objfile_owned; - TYPE_OWNER (type) = owner; + if (objfile_owned) + type->set_owner (objfile); + else + type->set_owner (arch); /* For now, delete the rings. */ TYPE_CHAIN (type) = type; @@ -368,8 +376,7 @@ make_pointer_type (struct type *type, struct type **typeptr) /* FIXME! Assumes the machine has only one representation for pointers! */ - TYPE_LENGTH (ntype) - = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT; + TYPE_LENGTH (ntype) = gdbarch_ptr_bit (type->arch ()) / TARGET_CHAR_BIT; ntype->set_code (TYPE_CODE_PTR); /* Mark pointers as unsigned. The target converts between pointers @@ -405,7 +412,7 @@ lookup_pointer_type (struct type *type) struct type * make_reference_type (struct type *type, struct type **typeptr, - enum type_code refcode) + enum type_code refcode) { struct type *ntype; /* New type */ struct type **reftype; @@ -414,7 +421,7 @@ make_reference_type (struct type *type, struct type **typeptr, 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)); + : TYPE_RVALUE_REFERENCE_TYPE (type)); if (ntype) { @@ -444,7 +451,7 @@ make_reference_type (struct type *type, struct type **typeptr, TYPE_TARGET_TYPE (ntype) = type; reftype = (refcode == TYPE_CODE_REF ? &TYPE_REFERENCE_TYPE (type) - : &TYPE_RVALUE_REFERENCE_TYPE (type)); + : &TYPE_RVALUE_REFERENCE_TYPE (type)); *reftype = ntype; @@ -452,8 +459,7 @@ make_reference_type (struct type *type, struct type **typeptr, references, and that it matches the (only) representation for pointers! */ - TYPE_LENGTH (ntype) = - gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT; + TYPE_LENGTH (ntype) = gdbarch_ptr_bit (type->arch ()) / TARGET_CHAR_BIT; ntype->set_code (refcode); *reftype = ntype; @@ -575,14 +581,14 @@ lookup_function_type_with_arguments (struct type *type, return fn; } -/* Identify address space identifier by name -- - return the integer flag defined in gdbtypes.h. */ +/* Identify address space identifier by name -- return a + type_instance_flags. */ -int -address_space_name_to_int (struct gdbarch *gdbarch, - const char *space_identifier) +type_instance_flags +address_space_name_to_type_instance_flags (struct gdbarch *gdbarch, + const char *space_identifier) { - int type_flags; + type_instance_flags type_flags; /* Check for known address space delimiters. */ if (!strcmp (space_identifier, "code")) @@ -590,7 +596,7 @@ address_space_name_to_int (struct gdbarch *gdbarch, else if (!strcmp (space_identifier, "data")) return TYPE_INSTANCE_FLAG_DATA_SPACE; else if (gdbarch_address_class_name_to_type_flags_p (gdbarch) - && gdbarch_address_class_name_to_type_flags (gdbarch, + && gdbarch_address_class_name_to_type_flags (gdbarch, space_identifier, &type_flags)) return type_flags; @@ -598,18 +604,19 @@ address_space_name_to_int (struct gdbarch *gdbarch, error (_("Unknown address space specifier: \"%s\""), space_identifier); } -/* Identify address space identifier by integer flag as defined in - gdbtypes.h -- return the string version of the adress space name. */ +/* Identify address space identifier by type_instance_flags and return + the string version of the adress space name. */ const char * -address_space_int_to_name (struct gdbarch *gdbarch, int space_flag) +address_space_type_instance_flags_to_name (struct gdbarch *gdbarch, + type_instance_flags space_flag) { if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE) return "code"; else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE) return "data"; else if ((space_flag & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL) - && gdbarch_address_class_type_flags_to_name_p (gdbarch)) + && gdbarch_address_class_type_flags_to_name_p (gdbarch)) return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag); else return NULL; @@ -621,7 +628,7 @@ address_space_int_to_name (struct gdbarch *gdbarch, int space_flag) STORAGE must be in the same obstack as TYPE. */ static struct type * -make_qualified_type (struct type *type, int new_flags, +make_qualified_type (struct type *type, type_instance_flags new_flags, struct type *storage) { struct type *ntype; @@ -629,7 +636,7 @@ make_qualified_type (struct type *type, int new_flags, ntype = type; do { - if (TYPE_INSTANCE_FLAGS (ntype) == new_flags) + if (ntype->instance_flags () == new_flags) return ntype; ntype = TYPE_CHAIN (ntype); } @@ -644,7 +651,7 @@ make_qualified_type (struct type *type, int new_flags, as TYPE. Otherwise, we can't link it into TYPE's cv chain: if one objfile is freed and the other kept, we'd have dangling pointers. */ - gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage)); + gdb_assert (type->objfile_owner () == storage->objfile_owner ()); ntype = storage; TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type); @@ -661,7 +668,7 @@ make_qualified_type (struct type *type, int new_flags, TYPE_CHAIN (type) = ntype; /* Now set the instance flags and return the new type. */ - TYPE_INSTANCE_FLAGS (ntype) = new_flags; + ntype->set_instance_flags (new_flags); /* Set length of new type to that of the original type. */ TYPE_LENGTH (ntype) = TYPE_LENGTH (type); @@ -679,13 +686,14 @@ make_qualified_type (struct type *type, int new_flags, representations. */ struct type * -make_type_with_address_space (struct type *type, int space_flag) +make_type_with_address_space (struct type *type, + type_instance_flags space_flag) { - int new_flags = ((TYPE_INSTANCE_FLAGS (type) - & ~(TYPE_INSTANCE_FLAG_CODE_SPACE - | TYPE_INSTANCE_FLAG_DATA_SPACE - | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)) - | space_flag); + type_instance_flags new_flags = ((type->instance_flags () + & ~(TYPE_INSTANCE_FLAG_CODE_SPACE + | TYPE_INSTANCE_FLAG_DATA_SPACE + | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)) + | space_flag); return make_qualified_type (type, new_flags, NULL); } @@ -709,9 +717,9 @@ make_cv_type (int cnst, int voltl, { struct type *ntype; /* New type */ - int new_flags = (TYPE_INSTANCE_FLAGS (type) - & ~(TYPE_INSTANCE_FLAG_CONST - | TYPE_INSTANCE_FLAG_VOLATILE)); + type_instance_flags new_flags = (type->instance_flags () + & ~(TYPE_INSTANCE_FLAG_CONST + | TYPE_INSTANCE_FLAG_VOLATILE)); if (cnst) new_flags |= TYPE_INSTANCE_FLAG_CONST; @@ -733,7 +741,7 @@ make_cv_type (int cnst, int voltl, can't have inter-objfile pointers. The only thing to do is to leave stub types as stub types, and look them up afresh by name each time you encounter them. */ - gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type)); + gdb_assert ((*typeptr)->objfile_owner () == type->objfile_owner ()); } ntype = make_qualified_type (type, new_flags, @@ -751,7 +759,7 @@ struct type * make_restrict_type (struct type *type) { return make_qualified_type (type, - (TYPE_INSTANCE_FLAGS (type) + (type->instance_flags () | TYPE_INSTANCE_FLAG_RESTRICT), NULL); } @@ -762,7 +770,7 @@ struct type * make_unqualified_type (struct type *type) { return make_qualified_type (type, - (TYPE_INSTANCE_FLAGS (type) + (type->instance_flags () & ~(TYPE_INSTANCE_FLAG_CONST | TYPE_INSTANCE_FLAG_VOLATILE | TYPE_INSTANCE_FLAG_RESTRICT)), @@ -775,7 +783,7 @@ struct type * make_atomic_type (struct type *type) { return make_qualified_type (type, - (TYPE_INSTANCE_FLAGS (type) + (type->instance_flags () | TYPE_INSTANCE_FLAG_ATOMIC), NULL); } @@ -799,7 +807,7 @@ replace_type (struct type *ntype, struct type *type) the assignment of one type's main type structure to the other will produce a type with references to objects (names; field lists; etc.) allocated on an objfile other than its own. */ - gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (type)); + gdb_assert (ntype->objfile_owner () == type->objfile_owner ()); *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type); @@ -823,7 +831,7 @@ replace_type (struct type *ntype, struct type *type) /* Assert that the two types have equivalent instance qualifiers. This should be true for at least all of our debug readers. */ - gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type)); + gdb_assert (ntype->instance_flags () == type->instance_flags ()); } /* Implement direct support for MEMBER_TYPE in GNU C++. @@ -948,9 +956,17 @@ create_range_type (struct type *result_type, struct type *index_type, result_type->set_bounds (bounds); - if (low_bound->kind () == PROP_CONST && low_bound->const_val () >= 0) + if (index_type->code () == TYPE_CODE_FIXED_POINT) + result_type->set_is_unsigned (index_type->is_unsigned ()); + /* Note that the signed-ness of a range type can't simply be copied + from the underlying type. Consider a case where the underlying + type is 'int', but the range type can hold 0..65535, and where + the range is further specified to fit into 16 bits. In this + case, if we copy the underlying type's sign, then reading some + range values will cause an unwanted sign extension. So, we have + some heuristics here instead. */ + else if (low_bound->kind () == PROP_CONST && low_bound->const_val () >= 0) result_type->set_is_unsigned (true); - /* Ada allows the declaration of range types whose upper bound is less than the lower bound, so checking the lower bound is not enough. Make sure we do not mark a range type whose upper bound @@ -958,8 +974,8 @@ create_range_type (struct type *result_type, struct type *index_type, if (high_bound->kind () == PROP_CONST && high_bound->const_val () < 0) result_type->set_is_unsigned (false); - TYPE_ENDIANITY_NOT_DEFAULT (result_type) - = TYPE_ENDIANITY_NOT_DEFAULT (index_type); + result_type->set_endianity_is_not_default + (index_type->endianity_is_not_default ()); return result_type; } @@ -1024,111 +1040,186 @@ has_static_range (const struct range_bounds *bounds) && bounds->stride.kind () == PROP_CONST); } +/* See gdbtypes.h. */ + +gdb::optional +get_discrete_low_bound (struct type *type) +{ + type = check_typedef (type); + switch (type->code ()) + { + case TYPE_CODE_RANGE: + { + /* This function only works for ranges with a constant low bound. */ + if (type->bounds ()->low.kind () != PROP_CONST) + return {}; -/* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type - TYPE. + LONGEST low = type->bounds ()->low.const_val (); - Return 1 if type is a range type with two defined, constant bounds. - Else, return 0 if it is discrete (and bounds will fit in LONGEST). - Else, return -1. */ + if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ENUM) + { + gdb::optional low_pos + = discrete_position (TYPE_TARGET_TYPE (type), low); -int -get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) + if (low_pos.has_value ()) + low = *low_pos; + } + + return low; + } + + case TYPE_CODE_ENUM: + { + if (type->num_fields () > 0) + { + /* The enums may not be sorted by value, so search all + entries. */ + LONGEST low = type->field (0).loc_enumval (); + + for (int i = 0; i < type->num_fields (); i++) + { + if (type->field (i).loc_enumval () < low) + low = type->field (i).loc_enumval (); + } + + /* Set unsigned indicator if warranted. */ + if (low >= 0) + type->set_is_unsigned (true); + + return low; + } + else + return 0; + } + + case TYPE_CODE_BOOL: + return 0; + + case TYPE_CODE_INT: + if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */ + return {}; + + if (!type->is_unsigned ()) + return -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1)); + + /* fall through */ + case TYPE_CODE_CHAR: + return 0; + + default: + return {}; + } +} + +/* See gdbtypes.h. */ + +gdb::optional +get_discrete_high_bound (struct type *type) { type = check_typedef (type); switch (type->code ()) { case TYPE_CODE_RANGE: - /* This function currently only works for ranges with two defined, - constant bounds. */ - if (type->bounds ()->low.kind () != PROP_CONST - || type->bounds ()->high.kind () != PROP_CONST) - return -1; + { + /* This function only works for ranges with a constant high bound. */ + if (type->bounds ()->high.kind () != PROP_CONST) + return {}; - *lowp = type->bounds ()->low.const_val (); - *highp = type->bounds ()->high.const_val (); + LONGEST high = type->bounds ()->high.const_val (); + + if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ENUM) + { + gdb::optional high_pos + = discrete_position (TYPE_TARGET_TYPE (type), high); + + if (high_pos.has_value ()) + high = *high_pos; + } + + return high; + } - if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ENUM) - { - if (!discrete_position (TYPE_TARGET_TYPE (type), *lowp, lowp) - || ! discrete_position (TYPE_TARGET_TYPE (type), *highp, highp)) - return 0; - } - return 1; case TYPE_CODE_ENUM: - if (type->num_fields () > 0) - { - /* The enums may not be sorted by value, so search all - entries. */ - int i; + { + if (type->num_fields () > 0) + { + /* The enums may not be sorted by value, so search all + entries. */ + LONGEST high = type->field (0).loc_enumval (); - *lowp = *highp = TYPE_FIELD_ENUMVAL (type, 0); - for (i = 0; i < type->num_fields (); i++) - { - if (TYPE_FIELD_ENUMVAL (type, i) < *lowp) - *lowp = TYPE_FIELD_ENUMVAL (type, i); - if (TYPE_FIELD_ENUMVAL (type, i) > *highp) - *highp = TYPE_FIELD_ENUMVAL (type, i); - } + for (int i = 0; i < type->num_fields (); i++) + { + if (type->field (i).loc_enumval () > high) + high = type->field (i).loc_enumval (); + } + + return high; + } + else + return -1; + } - /* Set unsigned indicator if warranted. */ - if (*lowp >= 0) - type->set_is_unsigned (true); - } - else - { - *lowp = 0; - *highp = -1; - } - return 0; case TYPE_CODE_BOOL: - *lowp = 0; - *highp = 1; - return 0; + return 1; + case TYPE_CODE_INT: if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */ - return -1; + return {}; + if (!type->is_unsigned ()) { - *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1)); - *highp = -*lowp - 1; - return 0; + LONGEST low = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1)); + return -low - 1; } + /* fall through */ case TYPE_CODE_CHAR: - *lowp = 0; - /* This round-about calculation is to avoid shifting by - TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work - if TYPE_LENGTH (type) == sizeof (LONGEST). */ - *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1); - *highp = (*highp - 1) | *highp; - return 0; + { + /* This round-about calculation is to avoid shifting by + TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work + if TYPE_LENGTH (type) == sizeof (LONGEST). */ + LONGEST high = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1); + return (high - 1) | high; + } + default: - return -1; + return {}; } } -/* Assuming TYPE is a simple, non-empty array type, compute its upper - and lower bound. Save the low bound into LOW_BOUND if not NULL. - Save the high bound into HIGH_BOUND if not NULL. +/* See gdbtypes.h. */ - Return 1 if the operation was successful. Return zero otherwise, - in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified. */ +bool +get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) +{ + gdb::optional low = get_discrete_low_bound (type); + if (!low.has_value ()) + return false; -int + gdb::optional high = get_discrete_high_bound (type); + if (!high.has_value ()) + return false; + + *lowp = *low; + *highp = *high; + + return true; +} + +/* See gdbtypes.h */ + +bool get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound) { struct type *index = type->index_type (); LONGEST low = 0; LONGEST high = 0; - int res; if (index == NULL) - return 0; + return false; - res = get_discrete_bounds (index, &low, &high); - if (res == -1) - return 0; + if (!get_discrete_bounds (index, &low, &high)) + return false; if (low_bound) *low_bound = low; @@ -1136,7 +1227,7 @@ get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound) if (high_bound) *high_bound = high; - return 1; + return true; } /* Assuming that TYPE is a discrete type and VAL is a valid integer @@ -1153,8 +1244,8 @@ get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound) in which case the value of POS is unmodified. */ -int -discrete_position (struct type *type, LONGEST val, LONGEST *pos) +gdb::optional +discrete_position (struct type *type, LONGEST val) { if (type->code () == TYPE_CODE_RANGE) type = TYPE_TARGET_TYPE (type); @@ -1164,21 +1255,16 @@ discrete_position (struct type *type, LONGEST val, LONGEST *pos) int i; for (i = 0; i < type->num_fields (); i += 1) - { - if (val == TYPE_FIELD_ENUMVAL (type, i)) - { - *pos = i; - return 1; - } - } + { + if (val == type->field (i).loc_enumval ()) + return i; + } + /* Invalid enumeration value. */ - return 0; + return {}; } else - { - *pos = val; - return 1; - } + return val; } /* If the array TYPE has static bounds calculate and update its @@ -1201,16 +1287,11 @@ update_static_array_size (struct type *type) int stride; struct type *element_type; - /* If the array itself doesn't provide a stride value then take - whatever stride the range provides. Don't update BIT_STRIDE as - we don't want to place the stride value from the range into this - arrays bit size field. */ - stride = TYPE_FIELD_BITSIZE (type, 0); - if (stride == 0) - stride = range_type->bit_stride (); + stride = type->bit_stride (); - if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0) + if (!get_discrete_bounds (range_type, &low_bound, &high_bound)) low_bound = high_bound = 0; + element_type = check_typedef (TYPE_TARGET_TYPE (type)); /* Be careful when setting the array length. Ada arrays can be empty arrays with the high_bound being smaller than the low_bound. @@ -1233,6 +1314,20 @@ update_static_array_size (struct type *type) TYPE_LENGTH (type) = TYPE_LENGTH (element_type) * (high_bound - low_bound + 1); + /* If this array's element is itself an array with a bit stride, + then we want to update this array's bit stride to reflect the + size of the sub-array. Otherwise, we'll end up using the + wrong size when trying to find elements of the outer + array. */ + if (element_type->code () == TYPE_CODE_ARRAY + && TYPE_LENGTH (element_type) != 0 + && TYPE_FIELD_BITSIZE (element_type, 0) != 0 + && get_array_bounds (element_type, &low_bound, &high_bound) + && high_bound >= low_bound) + TYPE_FIELD_BITSIZE (type, 0) + = ((high_bound - low_bound + 1) + * TYPE_FIELD_BITSIZE (element_type, 0)); + return true; } @@ -1297,11 +1392,11 @@ create_array_type_with_stride (struct type *result_type, if (!update_static_array_size (result_type)) { /* This type is dynamic and its length needs to be computed - on demand. In the meantime, avoid leaving the TYPE_LENGTH - undefined by setting it to zero. Although we are not expected - to trust TYPE_LENGTH in this case, setting the size to zero - allows us to avoid allocating objects of random sizes in case - we accidently do. */ + on demand. In the meantime, avoid leaving the TYPE_LENGTH + undefined by setting it to zero. Although we are not expected + to trust TYPE_LENGTH in this case, setting the size to zero + allows us to avoid allocating objects of random sizes in case + we accidently do. */ TYPE_LENGTH (result_type) = 0; } @@ -1331,10 +1426,11 @@ lookup_array_range_type (struct type *element_type, struct type *index_type; struct type *range_type; - if (TYPE_OBJFILE_OWNED (element_type)) - index_type = objfile_type (TYPE_OWNER (element_type).objfile)->builtin_int; + if (element_type->is_objfile_owned ()) + index_type = objfile_type (element_type->objfile_owner ())->builtin_int; else - index_type = builtin_type (get_type_arch (element_type))->builtin_int; + index_type = builtin_type (element_type->arch_owner ())->builtin_int; + range_type = create_static_range_type (NULL, index_type, low_bound, high_bound); @@ -1392,8 +1488,9 @@ create_set_type (struct type *result_type, struct type *domain_type) { LONGEST low_bound, high_bound, bit_length; - if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0) + if (!get_discrete_bounds (domain_type, &low_bound, &high_bound)) low_bound = high_bound = 0; + bit_length = high_bound - low_bound + 1; TYPE_LENGTH (result_type) = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT; @@ -1412,7 +1509,6 @@ void make_vector_type (struct type *array_type) { struct type *inner_array, *elt_type; - int flags; /* Find the innermost array type, in case the array is multi-dimensional. */ @@ -1423,7 +1519,8 @@ make_vector_type (struct type *array_type) elt_type = TYPE_TARGET_TYPE (inner_array); if (elt_type->code () == TYPE_CODE_INT) { - flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_INSTANCE_FLAG_NOTTEXT; + type_instance_flags flags + = elt_type->instance_flags () | TYPE_INSTANCE_FLAG_NOTTEXT; elt_type = make_qualified_type (elt_type, flags, NULL); TYPE_TARGET_TYPE (inner_array) = elt_type; } @@ -1517,8 +1614,7 @@ smash_to_memberptr_type (struct type *type, struct type *self_type, set_type_self_type (type, self_type); /* Assume that a data member pointer is the same size as a normal pointer. */ - TYPE_LENGTH (type) - = gdbarch_ptr_bit (get_type_arch (to_type)) / TARGET_CHAR_BIT; + TYPE_LENGTH (type) = gdbarch_ptr_bit (to_type->arch ()) / TARGET_CHAR_BIT; } /* Smash TYPE to be a type of pointer to methods type TO_TYPE. @@ -1581,7 +1677,7 @@ type_name_or_error (struct type *type) return name; name = saved_type->name (); - objfile = TYPE_OBJFILE (saved_type); + objfile = saved_type->objfile_owner (); error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"), name ? name : "", objfile ? objfile_name (objfile) : ""); @@ -1600,8 +1696,8 @@ lookup_typename (const struct language_defn *language, sym = lookup_symbol_in_language (name, block, VAR_DOMAIN, language->la_language, NULL).symbol; - if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF) - return SYMBOL_TYPE (sym); + if (sym != NULL && sym->aclass () == LOC_TYPEDEF) + return sym->type (); if (noerr) return NULL; @@ -1648,12 +1744,12 @@ lookup_struct (const char *name, const struct block *block) { error (_("No struct type named %s."), name); } - if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_STRUCT) + if (sym->type ()->code () != TYPE_CODE_STRUCT) { error (_("This context has class, union or enum %s, not a struct."), name); } - return (SYMBOL_TYPE (sym)); + return (sym->type ()); } /* Lookup a union type named "union NAME", @@ -1670,7 +1766,7 @@ lookup_union (const char *name, const struct block *block) if (sym == NULL) error (_("No union type named %s."), name); - t = SYMBOL_TYPE (sym); + t = sym->type (); if (t->code () == TYPE_CODE_UNION) return t; @@ -1693,12 +1789,12 @@ lookup_enum (const char *name, const struct block *block) { error (_("No enum type named %s."), name); } - if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_ENUM) + if (sym->type ()->code () != TYPE_CODE_ENUM) { error (_("This context has class, struct or union %s, not an enum."), name); } - return (SYMBOL_TYPE (sym)); + return (sym->type ()); } /* Lookup a template type named "template NAME", @@ -1723,12 +1819,12 @@ lookup_template_type (const char *name, struct type *type, { error (_("No template type named %s."), name); } - if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_STRUCT) + if (sym->type ()->code () != TYPE_CODE_STRUCT) { error (_("This context has class, union or enum %s, not a struct."), name); } - return (SYMBOL_TYPE (sym)); + return (sym->type ()); } /* See gdbtypes.h. */ @@ -1757,19 +1853,19 @@ lookup_struct_elt (struct type *type, const char *name, int noerr) for (i = type->num_fields () - 1; i >= TYPE_N_BASECLASSES (type); i--) { - const char *t_field_name = TYPE_FIELD_NAME (type, i); + const char *t_field_name = type->field (i).name (); if (t_field_name && (strcmp_iw (t_field_name, name) == 0)) { - return {&type->field (i), TYPE_FIELD_BITPOS (type, i)}; + return {&type->field (i), type->field (i).loc_bitpos ()}; } - else if (!t_field_name || *t_field_name == '\0') + else if (!t_field_name || *t_field_name == '\0') { struct_elt elt = lookup_struct_elt (type->field (i).type (), name, 1); if (elt.field != NULL) { - elt.offset += TYPE_FIELD_BITPOS (type, i); + elt.offset += type->field (i).loc_bitpos (); return elt; } } @@ -1802,11 +1898,10 @@ lookup_struct_elt_type (struct type *type, const char *name, int noerr) return NULL; } -/* Store in *MAX the largest number representable by unsigned integer type - TYPE. */ +/* Return the largest number representable by unsigned integer type TYPE. */ -void -get_unsigned_type_max (struct type *type, ULONGEST *max) +ULONGEST +get_unsigned_type_max (struct type *type) { unsigned int n; @@ -1816,7 +1911,7 @@ get_unsigned_type_max (struct type *type, ULONGEST *max) /* Written this way to avoid overflow. */ n = TYPE_LENGTH (type) * TARGET_CHAR_BIT; - *max = ((((ULONGEST) 1 << (n - 1)) - 1) << 1) | 1; + return ((((ULONGEST) 1 << (n - 1)) - 1) << 1) | 1; } /* Store in *MIN, *MAX the smallest and largest numbers representable by @@ -1836,6 +1931,21 @@ get_signed_type_minmax (struct type *type, LONGEST *min, LONGEST *max) *max = ((ULONGEST) 1 << (n - 1)) - 1; } +/* Return the largest value representable by pointer type TYPE. */ + +CORE_ADDR +get_pointer_type_max (struct type *type) +{ + unsigned int n; + + type = check_typedef (type); + gdb_assert (type->code () == TYPE_CODE_PTR); + gdb_assert (TYPE_LENGTH (type) <= sizeof (CORE_ADDR)); + + n = TYPE_LENGTH (type) * TARGET_CHAR_BIT; + return ((((CORE_ADDR) 1 << (n - 1)) - 1) << 1) | 1; +} + /* Internal routine called by TYPE_VPTR_FIELDNO to return the value of cplus_stuff.vptr_fieldno. @@ -1915,7 +2025,7 @@ get_vptr_fieldno (struct type *type, struct type **basetypep) int i; /* We must start at zero in case the first (and only) baseclass - is virtual (and hence we cannot share the table pointer). */ + is virtual (and hence we cannot share the table pointer). */ for (i = 0; i < TYPE_N_BASECLASSES (type); i++) { struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i)); @@ -1927,7 +2037,7 @@ get_vptr_fieldno (struct type *type, struct type **basetypep) { /* If the type comes from a different objfile we can't cache it, it may have a different lifetime. PR 2384 */ - if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype)) + if (type->objfile_owner () == basetype->objfile_owner ()) { set_type_vptr_fieldno (type, fieldno); set_type_vptr_basetype (type, basetype); @@ -2050,7 +2160,7 @@ is_dynamic_type_internal (struct type *type, int top_level) return 1; /* If the field is at a fixed offset, then it is not dynamic. */ - if (TYPE_FIELD_LOC_KIND (type, i) != FIELD_LOC_KIND_DWARF_BLOCK) + if (type->field (i).loc_kind () != FIELD_LOC_KIND_DWARF_BLOCK) continue; /* Do not consider C++ virtual base types to be dynamic due to the field's offset being dynamic; these are @@ -2079,26 +2189,42 @@ static struct type *resolve_dynamic_type_internal /* Given a dynamic range type (dyn_range_type) and a stack of struct property_addr_info elements, return a static version - of that type. */ + of that type. + + When RESOLVE_P is true then the returned static range is created by + actually evaluating any dynamic properties within the range type, while + when RESOLVE_P is false the returned static range has all of the bounds + and stride information set to undefined. The RESOLVE_P set to false + case will be used when evaluating a dynamic array that is not + allocated, or not associated, i.e. the bounds information might not be + initialized yet. + + RANK is the array rank for which we are resolving this range, and is a + zero based count. The rank should never be negative. +*/ static struct type * resolve_dynamic_range (struct type *dyn_range_type, - struct property_addr_info *addr_stack) + struct property_addr_info *addr_stack, + int rank, bool resolve_p = true) { CORE_ADDR value; struct type *static_range_type, *static_target_type; struct dynamic_prop low_bound, high_bound, stride; gdb_assert (dyn_range_type->code () == TYPE_CODE_RANGE); + gdb_assert (rank >= 0); const struct dynamic_prop *prop = &dyn_range_type->bounds ()->low; - if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) + if (resolve_p && dwarf2_evaluate_property (prop, NULL, addr_stack, &value, + { (CORE_ADDR) rank })) low_bound.set_const_val (value); else low_bound.set_undefined (); prop = &dyn_range_type->bounds ()->high; - if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) + if (resolve_p && dwarf2_evaluate_property (prop, NULL, addr_stack, &value, + { (CORE_ADDR) rank })) { high_bound.set_const_val (value); @@ -2111,7 +2237,8 @@ resolve_dynamic_range (struct type *dyn_range_type, bool byte_stride_p = dyn_range_type->bounds ()->flag_is_byte_stride; prop = &dyn_range_type->bounds ()->stride; - if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) + if (resolve_p && dwarf2_evaluate_property (prop, NULL, addr_stack, &value, + { (CORE_ADDR) rank })) { stride.set_const_val (value); @@ -2119,7 +2246,7 @@ resolve_dynamic_range (struct type *dyn_range_type, I really don't think this is going to work with current GDB, the array indexing code in GDB seems to be pretty heavily tied to byte offsets right now. Assuming 8 bits in a byte. */ - struct gdbarch *gdbarch = get_type_arch (dyn_range_type); + struct gdbarch *gdbarch = dyn_range_type->arch (); int unit_size = gdbarch_addressable_memory_unit_size (gdbarch); if (!byte_stride_p && (value % (unit_size * 8)) != 0) error (_("bit strides that are not a multiple of the byte size " @@ -2142,13 +2269,29 @@ resolve_dynamic_range (struct type *dyn_range_type, return static_range_type; } -/* Resolves dynamic bound values of an array or string type TYPE to static - ones. ADDR_STACK is a stack of struct property_addr_info to be used if - needed during the dynamic resolution. */ +/* Helper function for resolve_dynamic_array_or_string. This function + resolves the properties for a single array at RANK within a nested array + of arrays structure. The RANK value is greater than or equal to 0, and + starts at it's maximum value and goes down by 1 for each recursive call + to this function. So, for a 3-dimensional array, the first call to this + function has RANK == 2, then we call ourselves recursively with RANK == + 1, than again with RANK == 0, and at that point we should return. + + TYPE is updated as the dynamic properties are resolved, and so, should + be a copy of the dynamic type, rather than the original dynamic type + itself. + + ADDR_STACK is a stack of struct property_addr_info to be used if needed + during the dynamic resolution. + + When RESOLVE_P is true then the dynamic properties of TYPE are + evaluated, otherwise the dynamic properties of TYPE are not evaluated, + instead we assume the array is not allocated/associated yet. */ static struct type * -resolve_dynamic_array_or_string (struct type *type, - struct property_addr_info *addr_stack) +resolve_dynamic_array_or_string_1 (struct type *type, + struct property_addr_info *addr_stack, + int rank, bool resolve_p) { CORE_ADDR value; struct type *elt_type; @@ -2162,31 +2305,53 @@ resolve_dynamic_array_or_string (struct type *type, gdb_assert (type->code () == TYPE_CODE_ARRAY || type->code () == TYPE_CODE_STRING); - type = copy_type (type); - - elt_type = type; - range_type = check_typedef (elt_type->index_type ()); - range_type = resolve_dynamic_range (range_type, addr_stack); - - /* Resolve allocated/associated here before creating a new array type, which - will update the length of the array accordingly. */ + /* As the rank is a zero based count we expect this to never be + negative. */ + gdb_assert (rank >= 0); + + /* Resolve the allocated and associated properties before doing anything + else. If an array is not allocated or not associated then (at least + for Fortran) there is no guarantee that the data to define the upper + bound, lower bound, or stride will be correct. If RESOLVE_P is + already false at this point then this is not the first dimension of + the array and a more outer dimension has already marked this array as + not allocated/associated, as such we just ignore this property. This + is fine as GDB only checks the allocated/associated on the outer most + dimension of the array. */ prop = TYPE_ALLOCATED_PROP (type); - if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) - prop->set_const_val (value); + if (prop != NULL && resolve_p + && dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) + { + prop->set_const_val (value); + if (value == 0) + resolve_p = false; + } prop = TYPE_ASSOCIATED_PROP (type); - if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) - prop->set_const_val (value); + if (prop != NULL && resolve_p + && dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) + { + prop->set_const_val (value); + if (value == 0) + resolve_p = false; + } - ary_dim = check_typedef (TYPE_TARGET_TYPE (elt_type)); + range_type = check_typedef (type->index_type ()); + range_type + = resolve_dynamic_range (range_type, addr_stack, rank, resolve_p); + ary_dim = check_typedef (TYPE_TARGET_TYPE (type)); if (ary_dim != NULL && ary_dim->code () == TYPE_CODE_ARRAY) - elt_type = resolve_dynamic_array_or_string (ary_dim, addr_stack); + { + ary_dim = copy_type (ary_dim); + elt_type = resolve_dynamic_array_or_string_1 (ary_dim, addr_stack, + rank - 1, resolve_p); + } else elt_type = TYPE_TARGET_TYPE (type); prop = type->dyn_prop (DYN_PROP_BYTE_STRIDE); - if (prop != NULL) + if (prop != NULL && resolve_p) { if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) { @@ -2206,7 +2371,98 @@ resolve_dynamic_array_or_string (struct type *type, bit_stride = TYPE_FIELD_BITSIZE (type, 0); return create_array_type_with_stride (type, elt_type, range_type, NULL, - bit_stride); + bit_stride); +} + +/* Resolve an array or string type with dynamic properties, return a new + type with the dynamic properties resolved to actual values. The + ADDR_STACK represents the location of the object being resolved. */ + +static struct type * +resolve_dynamic_array_or_string (struct type *type, + struct property_addr_info *addr_stack) +{ + CORE_ADDR value; + int rank = 0; + + /* For dynamic type resolution strings can be treated like arrays of + characters. */ + gdb_assert (type->code () == TYPE_CODE_ARRAY + || type->code () == TYPE_CODE_STRING); + + type = copy_type (type); + + /* Resolve the rank property to get rank value. */ + struct dynamic_prop *prop = TYPE_RANK_PROP (type); + if (dwarf2_evaluate_property (prop, nullptr, addr_stack, &value)) + { + prop->set_const_val (value); + rank = value; + + if (rank == 0) + { + /* Rank is zero, if a variable is passed as an argument to a + function. In this case the resolved type should not be an + array, but should instead be that of an array element. */ + struct type *dynamic_array_type = type; + type = copy_type (TYPE_TARGET_TYPE (dynamic_array_type)); + struct dynamic_prop_list *prop_list + = TYPE_MAIN_TYPE (dynamic_array_type)->dyn_prop_list; + if (prop_list != nullptr) + { + struct obstack *obstack + = &type->objfile_owner ()->objfile_obstack; + TYPE_MAIN_TYPE (type)->dyn_prop_list + = copy_dynamic_prop_list (obstack, prop_list); + } + return type; + } + else if (type->code () == TYPE_CODE_STRING && rank != 1) + { + /* What would this even mean? A string with a dynamic rank + greater than 1. */ + error (_("unable to handle string with dynamic rank greater than 1")); + } + else if (rank > 1) + { + /* Arrays with dynamic rank are initially just an array type + with a target type that is the array element. + + However, now we know the rank of the array we need to build + the array of arrays structure that GDB expects, that is we + need an array type that has a target which is an array type, + and so on, until eventually, we have the element type at the + end of the chain. Create all the additional array types here + by copying the top level array type. */ + struct type *element_type = TYPE_TARGET_TYPE (type); + struct type *rank_type = type; + for (int i = 1; i < rank; i++) + { + TYPE_TARGET_TYPE (rank_type) = copy_type (rank_type); + rank_type = TYPE_TARGET_TYPE (rank_type); + } + TYPE_TARGET_TYPE (rank_type) = element_type; + } + } + else + { + rank = 1; + + for (struct type *tmp_type = check_typedef (TYPE_TARGET_TYPE (type)); + tmp_type->code () == TYPE_CODE_ARRAY; + tmp_type = check_typedef (TYPE_TARGET_TYPE (tmp_type))) + ++rank; + } + + /* The rank that we calculated above is actually a count of the number of + ranks. However, when we resolve the type of each individual array + rank we should actually use a rank "offset", e.g. an array with a rank + count of 1 (calculated above) will use the rank offset 0 in order to + resolve the details of the first array dimension. As a result, we + reduce the rank by 1 here. */ + --rank; + + return resolve_dynamic_array_or_string_1 (type, addr_stack, rank, true); } /* Resolve dynamic bounds of members of the union TYPE to static @@ -2321,7 +2577,7 @@ compute_variant_fields_inner (struct type *type, { int idx = part.discriminant_index; - if (TYPE_FIELD_LOC_KIND (type, idx) != FIELD_LOC_KIND_BITPOS) + if (type->field (idx).loc_kind () != FIELD_LOC_KIND_BITPOS) error (_("Cannot determine struct field location" " (invalid location kind)")); @@ -2331,7 +2587,7 @@ compute_variant_fields_inner (struct type *type, else { CORE_ADDR addr = (addr_stack->addr - + (TYPE_FIELD_BITPOS (type, idx) + + (type->field (idx).loc_bitpos () / TARGET_CHAR_BIT)); LONGEST bitsize = TYPE_FIELD_BITSIZE (type, idx); @@ -2342,7 +2598,7 @@ compute_variant_fields_inner (struct type *type, gdb_byte bits[sizeof (ULONGEST)]; read_memory (addr, bits, size); - LONGEST bitpos = (TYPE_FIELD_BITPOS (type, idx) + LONGEST bitpos = (type->field (idx).loc_bitpos () % TARGET_CHAR_BIT); discr_value = unpack_bits_as_long (type->field (idx).type (), @@ -2421,7 +2677,6 @@ resolve_dynamic_struct (struct type *type, unsigned resolved_type_bit_length = 0; gdb_assert (type->code () == TYPE_CODE_STRUCT); - gdb_assert (type->num_fields () > 0); resolved_type = copy_type (type); @@ -2440,9 +2695,10 @@ resolve_dynamic_struct (struct type *type, ((struct field *) TYPE_ALLOC (resolved_type, resolved_type->num_fields () * sizeof (struct field))); - memcpy (resolved_type->fields (), - type->fields (), - resolved_type->num_fields () * sizeof (struct field)); + if (type->num_fields () > 0) + memcpy (resolved_type->fields (), + type->fields (), + resolved_type->num_fields () * sizeof (struct field)); } for (i = 0; i < resolved_type->num_fields (); ++i) @@ -2453,21 +2709,21 @@ resolve_dynamic_struct (struct type *type, if (field_is_static (&resolved_type->field (i))) continue; - if (TYPE_FIELD_LOC_KIND (resolved_type, i) == FIELD_LOC_KIND_DWARF_BLOCK) + if (resolved_type->field (i).loc_kind () == FIELD_LOC_KIND_DWARF_BLOCK) { struct dwarf2_property_baton baton; baton.property_type = lookup_pointer_type (resolved_type->field (i).type ()); - baton.locexpr = *TYPE_FIELD_DWARF_BLOCK (resolved_type, i); + baton.locexpr = *resolved_type->field (i).loc_dwarf_block (); struct dynamic_prop prop; prop.set_locexpr (&baton); CORE_ADDR addr; if (dwarf2_evaluate_property (&prop, nullptr, addr_stack, &addr, - true)) - SET_FIELD_BITPOS (resolved_type->field (i), - TARGET_CHAR_BIT * (addr - addr_stack->addr)); + {addr_stack->addr})) + resolved_type->field (i).set_loc_bitpos + (TARGET_CHAR_BIT * (addr - addr_stack->addr)); } /* As we know this field is not a static field, the field's @@ -2477,24 +2733,25 @@ resolve_dynamic_struct (struct type *type, that verification indicates a bug in our code, the error is not severe enough to suggest to the user he stops his debugging session because of it. */ - if (TYPE_FIELD_LOC_KIND (resolved_type, i) != FIELD_LOC_KIND_BITPOS) + if (resolved_type->field (i).loc_kind () != FIELD_LOC_KIND_BITPOS) error (_("Cannot determine struct field location" " (invalid location kind)")); pinfo.type = check_typedef (resolved_type->field (i).type ()); + size_t offset = resolved_type->field (i).loc_bitpos () / TARGET_CHAR_BIT; pinfo.valaddr = addr_stack->valaddr; - pinfo.addr - = (addr_stack->addr - + (TYPE_FIELD_BITPOS (resolved_type, i) / TARGET_CHAR_BIT)); + if (!pinfo.valaddr.empty ()) + pinfo.valaddr = pinfo.valaddr.slice (offset); + pinfo.addr = addr_stack->addr + offset; pinfo.next = addr_stack; resolved_type->field (i).set_type (resolve_dynamic_type_internal (resolved_type->field (i).type (), &pinfo, 0)); - gdb_assert (TYPE_FIELD_LOC_KIND (resolved_type, i) + gdb_assert (resolved_type->field (i).loc_kind () == FIELD_LOC_KIND_BITPOS); - new_bit_length = TYPE_FIELD_BITPOS (resolved_type, i); + new_bit_length = resolved_type->field (i).loc_bitpos (); if (TYPE_FIELD_BITSIZE (resolved_type, i) != 0) new_bit_length += TYPE_FIELD_BITSIZE (resolved_type, i); else @@ -2593,7 +2850,12 @@ resolve_dynamic_type_internal (struct type *type, break; case TYPE_CODE_RANGE: - resolved_type = resolve_dynamic_range (type, addr_stack); + /* Pass 0 for the rank value here, which indicates this is a + range for the first rank of an array. The assumption is that + this rank value is not actually required for the resolution of + the dynamic range, otherwise, we'd be resolving this range + within the context of a dynamic array. */ + resolved_type = resolve_dynamic_range (type, addr_stack, 0); break; case TYPE_CODE_UNION: @@ -2619,7 +2881,16 @@ resolve_dynamic_type_internal (struct type *type, prop = TYPE_DATA_LOCATION (resolved_type); if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) - prop->set_const_val (value); + { + /* Start of Fortran hack. See comment in f-lang.h for what is going + on here.*/ + if (current_language->la_language == language_fortran + && resolved_type->code () == TYPE_CODE_ARRAY) + value = fortran_adjust_dynamic_array_base_address_hack (resolved_type, + value); + /* End of Fortran hack. */ + prop->set_const_val (value); + } return resolved_type; } @@ -2647,7 +2918,7 @@ type::dyn_prop (dynamic_prop_node_kind prop_kind) const while (node != NULL) { if (node->prop_kind == prop_kind) - return &node->prop; + return &node->prop; node = node->next; } return NULL; @@ -2660,9 +2931,9 @@ type::add_dyn_prop (dynamic_prop_node_kind prop_kind, dynamic_prop prop) { struct dynamic_prop_list *temp; - gdb_assert (TYPE_OBJFILE_OWNED (this)); + gdb_assert (this->is_objfile_owned ()); - temp = XOBNEW (&TYPE_OBJFILE (this)->objfile_obstack, + temp = XOBNEW (&this->objfile_owner ()->objfile_obstack, struct dynamic_prop_list); temp->prop_kind = prop_kind; temp->prop = prop; @@ -2734,12 +3005,13 @@ struct type * check_typedef (struct type *type) { struct type *orig_type = type; - /* While we're removing typedefs, we don't want to lose qualifiers. - E.g., const/volatile. */ - int instance_flags = TYPE_INSTANCE_FLAGS (type); gdb_assert (type); + /* While we're removing typedefs, we don't want to lose qualifiers. + E.g., const/volatile. */ + type_instance_flags instance_flags = type->instance_flags (); + while (type->code () == TYPE_CODE_TYPEDEF) { if (!TYPE_TARGET_TYPE (type)) @@ -2762,9 +3034,9 @@ check_typedef (struct type *type) } sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol; if (sym) - TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym); + TYPE_TARGET_TYPE (type) = sym->type (); else /* TYPE_CODE_UNDEF */ - TYPE_TARGET_TYPE (type) = alloc_type_arch (get_type_arch (type)); + TYPE_TARGET_TYPE (type) = alloc_type_arch (type->arch ()); } type = TYPE_TARGET_TYPE (type); @@ -2780,10 +3052,13 @@ check_typedef (struct type *type) outer cast in a chain of casting win), instead of assuming "it can't happen". */ { - const int ALL_SPACES = (TYPE_INSTANCE_FLAG_CODE_SPACE - | TYPE_INSTANCE_FLAG_DATA_SPACE); - const int ALL_CLASSES = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL; - int new_instance_flags = TYPE_INSTANCE_FLAGS (type); + const type_instance_flags ALL_SPACES + = (TYPE_INSTANCE_FLAG_CODE_SPACE + | TYPE_INSTANCE_FLAG_DATA_SPACE); + const type_instance_flags ALL_CLASSES + = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL; + + type_instance_flags new_instance_flags = type->instance_flags (); /* Treat code vs data spaces and address classes separately. */ if ((instance_flags & ALL_SPACES) != 0) @@ -2827,10 +3102,8 @@ check_typedef (struct type *type) TYPE's objfile is pointless, too, since you'll have to move over any other types NEWTYPE refers to, which could be an unbounded amount of stuff. */ - if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type)) - type = make_qualified_type (newtype, - TYPE_INSTANCE_FLAGS (type), - type); + if (newtype->objfile_owner () == type->objfile_owner ()) + type = make_qualified_type (newtype, type->instance_flags (), type); else type = newtype; } @@ -2841,7 +3114,7 @@ check_typedef (struct type *type) { const char *name = type->name (); /* FIXME: shouldn't we look in STRUCT_DOMAIN and/or VAR_DOMAIN - as appropriate? */ + as appropriate? */ struct symbol *sym; if (name == NULL) @@ -2851,17 +3124,16 @@ check_typedef (struct type *type) } sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol; if (sym) - { - /* Same as above for opaque types, we can replace the stub - with the complete type only if they are in the same - objfile. */ - if (TYPE_OBJFILE (SYMBOL_TYPE (sym)) == TYPE_OBJFILE (type)) - type = make_qualified_type (SYMBOL_TYPE (sym), - TYPE_INSTANCE_FLAGS (type), - type); + { + /* Same as above for opaque types, we can replace the stub + with the complete type only if they are in the same + objfile. */ + if (sym->type ()->objfile_owner () == type->objfile_owner ()) + type = make_qualified_type (sym->type (), + type->instance_flags (), type); else - type = SYMBOL_TYPE (sym); - } + type = sym->type (); + } } if (type->target_is_stub ()) @@ -2894,7 +3166,7 @@ check_typedef (struct type *type) occurs, silently return a void type. */ static struct type * -safe_parse_type (struct gdbarch *gdbarch, char *p, int length) +safe_parse_type (struct gdbarch *gdbarch, const char *p, int length) { struct ui_file *saved_gdb_stderr; struct type *type = NULL; /* Initialize to keep gcc happy. */ @@ -2932,11 +3204,11 @@ safe_parse_type (struct gdbarch *gdbarch, char *p, int length) static void check_stub_method (struct type *type, int method_id, int signature_id) { - struct gdbarch *gdbarch = get_type_arch (type); + struct gdbarch *gdbarch = type->arch (); struct fn_field *f; char *mangled_name = gdb_mangle_name (type, method_id, signature_id); - char *demangled_name = gdb_demangle (mangled_name, - DMGL_PARAMS | DMGL_ANSI); + gdb::unique_xmalloc_ptr demangled_name + = gdb_demangle (mangled_name, DMGL_PARAMS | DMGL_ANSI); char *argtypetext, *p; int depth = 0, argcount = 1; struct field *argtypes; @@ -2944,7 +3216,7 @@ check_stub_method (struct type *type, int method_id, int signature_id) /* Make sure we got back a function string that we can use. */ if (demangled_name) - p = strchr (demangled_name, '('); + p = strchr (demangled_name.get (), '('); else p = NULL; @@ -3001,7 +3273,7 @@ check_stub_method (struct type *type, int method_id, int signature_id) if (depth <= 0 && (*p == ',' || *p == ')')) { /* Avoid parsing of ellipsis, they will be handled below. - Also avoid ``void'' as above. */ + Also avoid ``void'' as above. */ if (strncmp (argtypetext, "...", p - argtypetext) != 0 && strncmp (argtypetext, "void", p - argtypetext) != 0) { @@ -3035,8 +3307,6 @@ check_stub_method (struct type *type, int method_id, int signature_id) argtypes, argcount, p[-2] == '.'); mtype->set_is_stub (false); TYPE_FN_FIELD_STUB (f, signature_id) = 0; - - xfree (demangled_name); } /* This is the external interface to check_stub_method, above. This @@ -3106,14 +3376,17 @@ set_type_code (struct type *type, enum type_code code) case TYPE_CODE_STRUCT: case TYPE_CODE_UNION: case TYPE_CODE_NAMESPACE: - INIT_CPLUS_SPECIFIC (type); - break; + INIT_CPLUS_SPECIFIC (type); + break; case TYPE_CODE_FLT: - TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT; - break; + TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT; + break; case TYPE_CODE_FUNC: INIT_FUNC_SPECIFIC (type); break; + case TYPE_CODE_FIXED_POINT: + INIT_FIXED_POINT_SPECIFIC (type); + break; } } @@ -3191,6 +3464,10 @@ init_integer_type (struct objfile *objfile, if (unsigned_p) t->set_is_unsigned (true); + TYPE_SPECIFIC_FIELD (t) = TYPE_SPECIFIC_INT; + TYPE_MAIN_TYPE (t)->type_specific.int_stuff.bit_size = bit; + TYPE_MAIN_TYPE (t)->type_specific.int_stuff.bit_offset = 0; + return t; } @@ -3225,6 +3502,10 @@ init_boolean_type (struct objfile *objfile, if (unsigned_p) t->set_is_unsigned (true); + TYPE_SPECIFIC_FIELD (t) = TYPE_SPECIFIC_INT; + TYPE_MAIN_TYPE (t)->type_specific.int_stuff.bit_size = bit; + TYPE_MAIN_TYPE (t)->type_specific.int_stuff.bit_offset = 0; + return t; } @@ -3268,6 +3549,15 @@ init_decfloat_type (struct objfile *objfile, int bit, const char *name) return t; } +/* Return true if init_complex_type can be called with TARGET_TYPE. */ + +bool +can_create_complex_type (struct type *target_type) +{ + return (target_type->code () == TYPE_CODE_INT + || target_type->code () == TYPE_CODE_FLT); +} + /* Allocate a TYPE_CODE_COMPLEX type structure. NAME is the type name. TARGET_TYPE is the component type. */ @@ -3276,12 +3566,11 @@ init_complex_type (const char *name, struct type *target_type) { struct type *t; - gdb_assert (target_type->code () == TYPE_CODE_INT - || target_type->code () == TYPE_CODE_FLT); + gdb_assert (can_create_complex_type (target_type)); if (TYPE_MAIN_TYPE (target_type)->flds_bnds.complex_type == nullptr) { - if (name == nullptr) + if (name == nullptr && target_type->name () != nullptr) { char *new_name = (char *) TYPE_ALLOC (target_type, @@ -3321,6 +3610,24 @@ init_pointer_type (struct objfile *objfile, return t; } +/* Allocate a TYPE_CODE_FIXED_POINT type structure associated with OBJFILE. + BIT is the pointer type size in bits. + UNSIGNED_P should be nonzero if the type is unsigned. + NAME is the type name. */ + +struct type * +init_fixed_point_type (struct objfile *objfile, + int bit, int unsigned_p, const char *name) +{ + struct type *t; + + t = init_type (objfile, TYPE_CODE_FIXED_POINT, bit, name); + if (unsigned_p) + t->set_is_unsigned (true); + + return t; +} + /* See gdbtypes.h. */ unsigned @@ -3342,8 +3649,7 @@ type_align (struct type *type) return raw_align; /* Allow the architecture to provide an alignment. */ - struct gdbarch *arch = get_type_arch (type); - ULONGEST align = gdbarch_type_align (arch, type); + ULONGEST align = gdbarch_type_align (type->arch (), type); if (align != 0) return align; @@ -3467,6 +3773,7 @@ is_integral_type (struct type *t) t = check_typedef (t); return ((t != NULL) + && !is_fixed_point_type (t) && ((t->code () == TYPE_CODE_INT) || (t->code () == TYPE_CODE_ENUM) || (t->code () == TYPE_CODE_FLAGS) @@ -3492,6 +3799,9 @@ is_scalar_type (struct type *type) { type = check_typedef (type); + if (is_fixed_point_type (type)) + return 0; /* Implemented as a scalar, but more like a floating point. */ + switch (type->code ()) { case TYPE_CODE_ARRAY: @@ -3524,9 +3834,11 @@ is_scalar_type_recursive (struct type *t) LONGEST low_bound, high_bound; struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t)); - get_discrete_bounds (t->index_type (), &low_bound, &high_bound); - - return high_bound == low_bound && is_scalar_type_recursive (elt_type); + if (get_discrete_bounds (t->index_type (), &low_bound, &high_bound)) + return (high_bound == low_bound + && is_scalar_type_recursive (elt_type)); + else + return 0; } /* Are we dealing with a struct with one element? */ else if (t->code () == TYPE_CODE_STRUCT && t->num_fields () == 1) @@ -3552,7 +3864,7 @@ int class_or_union_p (const struct type *t) { return (t->code () == TYPE_CODE_STRUCT - || t->code () == TYPE_CODE_UNION); + || t->code () == TYPE_CODE_UNION); } /* A helper function which returns true if types A and B represent the @@ -3694,7 +4006,7 @@ is_unique_ancestor (struct type *base, struct value *val) int offset = -1; return is_unique_ancestor_worker (base, value_type (val), &offset, - value_contents_for_printing (val), + value_contents_for_printing (val).data (), value_embedded_offset (val), value_address (val), val) == 1; } @@ -3704,11 +4016,11 @@ is_unique_ancestor (struct type *base, struct value *val) enum bfd_endian type_byte_order (const struct type *type) { - bfd_endian byteorder = gdbarch_byte_order (get_type_arch (type)); - if (TYPE_ENDIANITY_NOT_DEFAULT (type)) + bfd_endian byteorder = gdbarch_byte_order (type->arch ()); + if (type->endianity_is_not_default ()) { if (byteorder == BFD_ENDIAN_BIG) - return BFD_ENDIAN_LITTLE; + return BFD_ENDIAN_LITTLE; else { gdb_assert (byteorder == BFD_ENDIAN_LITTLE); @@ -3719,6 +4031,17 @@ type_byte_order (const struct type *type) return byteorder; } +/* See gdbtypes.h. */ + +bool +is_nocall_function (const struct type *type) +{ + gdb_assert (type->code () == TYPE_CODE_FUNC + || type->code () == TYPE_CODE_METHOD); + + return TYPE_CALLING_CONVENTION (type) == DW_CC_nocall; +} + /* Overload resolution. */ @@ -3771,8 +4094,14 @@ compare_badness (const badness_vector &a, const badness_vector &b) { int i; int tmp; - short found_pos = 0; /* any positives in c? */ - short found_neg = 0; /* any negatives in c? */ + /* Any positives in comparison? */ + bool found_pos = false; + /* Any negatives in comparison? */ + bool found_neg = false; + /* Did A have any INVALID_CONVERSION entries. */ + bool a_invalid = false; + /* Did B have any INVALID_CONVERSION entries. */ + bool b_invalid = false; /* differing sizes => incomparable */ if (a.size () != b.size ()) @@ -3783,12 +4112,27 @@ compare_badness (const badness_vector &a, const badness_vector &b) { tmp = compare_ranks (b[i], a[i]); if (tmp > 0) - found_pos = 1; + found_pos = true; else if (tmp < 0) - found_neg = 1; + found_neg = true; + if (a[i].rank >= INVALID_CONVERSION) + a_invalid = true; + if (b[i].rank >= INVALID_CONVERSION) + b_invalid = true; } - if (found_pos) + /* B will only be considered better than or incomparable to A if + they both have invalid entries, or if neither does. That is, if + A has only valid entries, and B has an invalid entry, then A will + be considered better than B, even if B happens to be better for + some parameter. */ + if (a_invalid != b_invalid) + { + if (a_invalid) + return 3; /* A > B */ + return 2; /* A < B */ + } + else if (found_pos) { if (found_neg) return 1; /* incomparable */ @@ -3899,6 +4243,10 @@ types_equal (struct type *a, struct type *b) if (b->code () == TYPE_CODE_TYPEDEF) b = check_typedef (b); + /* Check if identical after resolving typedefs. */ + if (a == b) + return true; + /* If after resolving typedefs a and b are not of the same type code then they are not equal. */ if (a->code () != b->code ()) @@ -3910,7 +4258,7 @@ types_equal (struct type *a, struct type *b) if (a->code () == TYPE_CODE_PTR || a->code () == TYPE_CODE_REF) return types_equal (TYPE_TARGET_TYPE (a), - TYPE_TARGET_TYPE (b)); + TYPE_TARGET_TYPE (b)); /* Well, damnit, if the names are exactly the same, I'll say they are exactly the same. This happens when we generate method @@ -3921,10 +4269,6 @@ types_equal (struct type *a, struct type *b) && strcmp (a->name (), b->name ()) == 0) return true; - /* Check if identical after resolving typedefs. */ - if (a == b) - return true; - /* Two function types are equal if their argument and return types are equal. */ if (a->code () == TYPE_CODE_FUNC) @@ -3991,11 +4335,11 @@ check_types_equal (struct type *type1, struct type *type2, || TYPE_LENGTH (type1) != TYPE_LENGTH (type2) || type1->is_unsigned () != type2->is_unsigned () || type1->has_no_signedness () != type2->has_no_signedness () - || TYPE_ENDIANITY_NOT_DEFAULT (type1) != TYPE_ENDIANITY_NOT_DEFAULT (type2) + || type1->endianity_is_not_default () != type2->endianity_is_not_default () || type1->has_varargs () != type2->has_varargs () - || TYPE_VECTOR (type1) != TYPE_VECTOR (type2) + || type1->is_vector () != type2->is_vector () || TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2) - || TYPE_INSTANCE_FLAGS (type1) != TYPE_INSTANCE_FLAGS (type2) + || type1->instance_flags () != type2->instance_flags () || type1->num_fields () != type2->num_fields ()) return false; @@ -4020,37 +4364,37 @@ check_types_equal (struct type *type1, struct type *type2, if (FIELD_ARTIFICIAL (*field1) != FIELD_ARTIFICIAL (*field2) || FIELD_BITSIZE (*field1) != FIELD_BITSIZE (*field2) - || FIELD_LOC_KIND (*field1) != FIELD_LOC_KIND (*field2)) + || field1->loc_kind () != field2->loc_kind ()) return false; - if (!compare_maybe_null_strings (FIELD_NAME (*field1), - FIELD_NAME (*field2))) + if (!compare_maybe_null_strings (field1->name (), field2->name ())) return false; - switch (FIELD_LOC_KIND (*field1)) + switch (field1->loc_kind ()) { case FIELD_LOC_KIND_BITPOS: - if (FIELD_BITPOS (*field1) != FIELD_BITPOS (*field2)) + if (field1->loc_bitpos () != field2->loc_bitpos ()) return false; break; case FIELD_LOC_KIND_ENUMVAL: - if (FIELD_ENUMVAL (*field1) != FIELD_ENUMVAL (*field2)) + if (field1->loc_enumval () != field2->loc_enumval ()) return false; - break; + /* Don't compare types of enum fields, because they don't + have a type. */ + continue; case FIELD_LOC_KIND_PHYSADDR: - if (FIELD_STATIC_PHYSADDR (*field1) - != FIELD_STATIC_PHYSADDR (*field2)) + if (field1->loc_physaddr () != field2->loc_physaddr ()) return false; break; case FIELD_LOC_KIND_PHYSNAME: - if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1), - FIELD_STATIC_PHYSNAME (*field2))) + if (!compare_maybe_null_strings (field1->loc_physname (), + field2->loc_physname ())) return false; break; case FIELD_LOC_KIND_DWARF_BLOCK: { struct dwarf2_locexpr_baton *block1, *block2; - block1 = FIELD_DWARF_BLOCK (*field1); - block2 = FIELD_DWARF_BLOCK (*field2); + block1 = field1->loc_dwarf_block (); + block2 = field2->loc_dwarf_block (); if (block1->per_cu != block2->per_cu || block1->size != block2->size || memcmp (block1->data, block2->data, block1->size) != 0) @@ -4060,7 +4404,7 @@ check_types_equal (struct type *type1, struct type *type2, default: internal_error (__FILE__, __LINE__, _("Unsupported field kind " "%d by check_types_equal"), - FIELD_LOC_KIND (*field1)); + field1->loc_kind ()); } worklist->emplace_back (field1->type (), field2->type ()); @@ -4122,7 +4466,7 @@ types_deeply_equal (struct type *type1, struct type *type2) if (type1 == type2) return true; - gdb::bcache cache (nullptr, nullptr); + gdb::bcache cache; worklist.emplace_back (type1, type2); return check_types_worklist (&worklist, &cache); } @@ -4329,7 +4673,7 @@ rank_one_type_parm_int (struct type *parm, struct type *arg, struct value *value case TYPE_CODE_CHAR: case TYPE_CODE_RANGE: case TYPE_CODE_BOOL: - if (TYPE_DECLARED_CLASS (arg)) + if (arg->is_declared_class ()) return INCOMPATIBLE_TYPE_BADNESS; return INTEGER_PROMOTION_BADNESS; case TYPE_CODE_FLT: @@ -4353,7 +4697,7 @@ rank_one_type_parm_enum (struct type *parm, struct type *arg, struct value *valu case TYPE_CODE_RANGE: case TYPE_CODE_BOOL: case TYPE_CODE_ENUM: - if (TYPE_DECLARED_CLASS (parm) || TYPE_DECLARED_CLASS (arg)) + if (parm->is_declared_class () || arg->is_declared_class ()) return INCOMPATIBLE_TYPE_BADNESS; return INTEGER_CONVERSION_BADNESS; case TYPE_CODE_FLT: @@ -4373,7 +4717,7 @@ rank_one_type_parm_char (struct type *parm, struct type *arg, struct value *valu case TYPE_CODE_RANGE: case TYPE_CODE_BOOL: case TYPE_CODE_ENUM: - if (TYPE_DECLARED_CLASS (arg)) + if (arg->is_declared_class ()) return INCOMPATIBLE_TYPE_BADNESS; return INTEGER_CONVERSION_BADNESS; case TYPE_CODE_FLT: @@ -4547,7 +4891,8 @@ rank_one_type_parm_set (struct type *parm, struct type *arg, struct value *value * Return 0 if they are identical types; * Otherwise, return an integer which corresponds to how compatible * PARM is to ARG. The higher the return value, the worse the match. - * Generally the "bad" conversions are all uniformly assigned a 100. */ + * Generally the "bad" conversions are all uniformly assigned + * INVALID_CONVERSION. */ struct rank rank_one_type (struct type *parm, struct type *arg, struct value *value) @@ -4588,7 +4933,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); @@ -4609,16 +4954,18 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value) if (TYPE_IS_REFERENCE (arg)) return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL), - REFERENCE_SEE_THROUGH_BADNESS)); + REFERENCE_SEE_THROUGH_BADNESS)); if (TYPE_IS_REFERENCE (parm)) return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL), - REFERENCE_SEE_THROUGH_BADNESS)); + REFERENCE_SEE_THROUGH_BADNESS)); if (overload_debug) - /* Debugging only. */ - fprintf_filtered (gdb_stderr, - "------ Arg is %s [%d], parm is %s [%d]\n", - arg->name (), arg->code (), - parm->name (), parm->code ()); + { + /* Debugging only. */ + gdb_printf (gdb_stderr, + "------ Arg is %s [%d], parm is %s [%d]\n", + arg->name (), arg->code (), + parm->name (), parm->code ()); + } /* x -> y means arg of type x being supplied for parameter of type y. */ @@ -4666,12 +5013,12 @@ print_bit_vector (B_TYPE *bits, int nbits) { if ((bitno % 8) == 0) { - puts_filtered (" "); + gdb_puts (" "); } if (B_TST (bits, bitno)) - printf_filtered (("1")); + gdb_printf (("1")); else - printf_filtered (("0")); + gdb_printf (("0")); } } @@ -4688,8 +5035,9 @@ print_args (struct field *args, int nargs, int spaces) for (i = 0; i < nargs; i++) { - printfi_filtered (spaces, "[%d] name '%s'\n", i, - args[i].name != NULL ? args[i].name : ""); + gdb_printf + ("%*s[%d] name '%s'\n", spaces, "", i, + args[i].name () != NULL ? args[i].name () : ""); recursive_dump_type (args[i].type (), spaces + 2); } } @@ -4703,8 +5051,8 @@ field_is_static (struct field *f) have a dedicated flag that would be set for static fields when the type is being created. But in practice, checking the field loc_kind should give us an accurate answer. */ - return (FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSNAME - || FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSADDR); + return (f->loc_kind () == FIELD_LOC_KIND_PHYSNAME + || f->loc_kind () == FIELD_LOC_KIND_PHYSADDR); } static void @@ -4714,65 +5062,61 @@ dump_fn_fieldlists (struct type *type, int spaces) int overload_idx; struct fn_field *f; - printfi_filtered (spaces, "fn_fieldlists "); - gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout); - printf_filtered ("\n"); + gdb_printf ("%*sfn_fieldlists %s\n", spaces, "", + host_address_to_string (TYPE_FN_FIELDLISTS (type))); for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++) { f = TYPE_FN_FIELDLIST1 (type, method_idx); - printfi_filtered (spaces + 2, "[%d] name '%s' (", - method_idx, - TYPE_FN_FIELDLIST_NAME (type, method_idx)); - gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx), - gdb_stdout); - printf_filtered (_(") length %d\n"), - TYPE_FN_FIELDLIST_LENGTH (type, method_idx)); + gdb_printf + ("%*s[%d] name '%s' (%s) length %d\n", spaces + 2, "", + method_idx, + TYPE_FN_FIELDLIST_NAME (type, method_idx), + host_address_to_string (TYPE_FN_FIELDLIST_NAME (type, method_idx)), + TYPE_FN_FIELDLIST_LENGTH (type, method_idx)); for (overload_idx = 0; overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx); overload_idx++) { - printfi_filtered (spaces + 4, "[%d] physname '%s' (", - overload_idx, - TYPE_FN_FIELD_PHYSNAME (f, overload_idx)); - gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx), - gdb_stdout); - printf_filtered (")\n"); - printfi_filtered (spaces + 8, "type "); - gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx), - gdb_stdout); - printf_filtered ("\n"); + gdb_printf + ("%*s[%d] physname '%s' (%s)\n", + spaces + 4, "", overload_idx, + TYPE_FN_FIELD_PHYSNAME (f, overload_idx), + host_address_to_string (TYPE_FN_FIELD_PHYSNAME (f, + overload_idx))); + gdb_printf + ("%*stype %s\n", spaces + 8, "", + host_address_to_string (TYPE_FN_FIELD_TYPE (f, overload_idx))); recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx), spaces + 8 + 2); - printfi_filtered (spaces + 8, "args "); - gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx), - gdb_stdout); - printf_filtered ("\n"); + gdb_printf + ("%*sargs %s\n", spaces + 8, "", + host_address_to_string (TYPE_FN_FIELD_ARGS (f, overload_idx))); print_args (TYPE_FN_FIELD_ARGS (f, overload_idx), TYPE_FN_FIELD_TYPE (f, overload_idx)->num_fields (), spaces + 8 + 2); - printfi_filtered (spaces + 8, "fcontext "); - gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx), - gdb_stdout); - printf_filtered ("\n"); - - printfi_filtered (spaces + 8, "is_const %d\n", - TYPE_FN_FIELD_CONST (f, overload_idx)); - printfi_filtered (spaces + 8, "is_volatile %d\n", - TYPE_FN_FIELD_VOLATILE (f, overload_idx)); - printfi_filtered (spaces + 8, "is_private %d\n", - TYPE_FN_FIELD_PRIVATE (f, overload_idx)); - printfi_filtered (spaces + 8, "is_protected %d\n", - TYPE_FN_FIELD_PROTECTED (f, overload_idx)); - printfi_filtered (spaces + 8, "is_stub %d\n", - TYPE_FN_FIELD_STUB (f, overload_idx)); - printfi_filtered (spaces + 8, "defaulted %d\n", - TYPE_FN_FIELD_DEFAULTED (f, overload_idx)); - printfi_filtered (spaces + 8, "is_deleted %d\n", - TYPE_FN_FIELD_DELETED (f, overload_idx)); - printfi_filtered (spaces + 8, "voffset %u\n", - TYPE_FN_FIELD_VOFFSET (f, overload_idx)); + gdb_printf + ("%*sfcontext %s\n", spaces + 8, "", + host_address_to_string (TYPE_FN_FIELD_FCONTEXT (f, + overload_idx))); + + gdb_printf ("%*sis_const %d\n", spaces + 8, "", + TYPE_FN_FIELD_CONST (f, overload_idx)); + gdb_printf ("%*sis_volatile %d\n", spaces + 8, "", + TYPE_FN_FIELD_VOLATILE (f, overload_idx)); + gdb_printf ("%*sis_private %d\n", spaces + 8, "", + TYPE_FN_FIELD_PRIVATE (f, overload_idx)); + gdb_printf ("%*sis_protected %d\n", spaces + 8, "", + TYPE_FN_FIELD_PROTECTED (f, overload_idx)); + gdb_printf ("%*sis_stub %d\n", spaces + 8, "", + TYPE_FN_FIELD_STUB (f, overload_idx)); + gdb_printf ("%*sdefaulted %d\n", spaces + 8, "", + TYPE_FN_FIELD_DEFAULTED (f, overload_idx)); + gdb_printf ("%*sis_deleted %d\n", spaces + 8, "", + TYPE_FN_FIELD_DELETED (f, overload_idx)); + gdb_printf ("%*svoffset %u\n", spaces + 8, "", + TYPE_FN_FIELD_VOFFSET (f, overload_idx)); } } } @@ -4780,54 +5124,49 @@ dump_fn_fieldlists (struct type *type, int spaces) static void print_cplus_stuff (struct type *type, int spaces) { - printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type)); - printfi_filtered (spaces, "vptr_basetype "); - gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout); - puts_filtered ("\n"); + gdb_printf ("%*svptr_fieldno %d\n", spaces, "", + TYPE_VPTR_FIELDNO (type)); + gdb_printf ("%*svptr_basetype %s\n", spaces, "", + host_address_to_string (TYPE_VPTR_BASETYPE (type))); if (TYPE_VPTR_BASETYPE (type) != NULL) recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2); - printfi_filtered (spaces, "n_baseclasses %d\n", - TYPE_N_BASECLASSES (type)); - printfi_filtered (spaces, "nfn_fields %d\n", - TYPE_NFN_FIELDS (type)); + gdb_printf ("%*sn_baseclasses %d\n", spaces, "", + TYPE_N_BASECLASSES (type)); + gdb_printf ("%*snfn_fields %d\n", spaces, "", + TYPE_NFN_FIELDS (type)); if (TYPE_N_BASECLASSES (type) > 0) { - printfi_filtered (spaces, "virtual_field_bits (%d bits at *", - TYPE_N_BASECLASSES (type)); - gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type), - gdb_stdout); - printf_filtered (")"); + gdb_printf + ("%*svirtual_field_bits (%d bits at *%s)", + spaces, "", TYPE_N_BASECLASSES (type), + host_address_to_string (TYPE_FIELD_VIRTUAL_BITS (type))); print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type), TYPE_N_BASECLASSES (type)); - puts_filtered ("\n"); + gdb_puts ("\n"); } if (type->num_fields () > 0) { if (TYPE_FIELD_PRIVATE_BITS (type) != NULL) { - printfi_filtered (spaces, - "private_field_bits (%d bits at *", - type->num_fields ()); - gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type), - gdb_stdout); - printf_filtered (")"); + gdb_printf + ("%*sprivate_field_bits (%d bits at *%s)", + spaces, "", type->num_fields (), + host_address_to_string (TYPE_FIELD_PRIVATE_BITS (type))); print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type), type->num_fields ()); - puts_filtered ("\n"); + gdb_puts ("\n"); } if (TYPE_FIELD_PROTECTED_BITS (type) != NULL) { - printfi_filtered (spaces, - "protected_field_bits (%d bits at *", - type->num_fields ()); - gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type), - gdb_stdout); - printf_filtered (")"); + gdb_printf + ("%*sprotected_field_bits (%d bits at *%s", + spaces, "", type->num_fields (), + host_address_to_string (TYPE_FIELD_PROTECTED_BITS (type))); print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type), type->num_fields ()); - puts_filtered ("\n"); + gdb_puts ("\n"); } } if (TYPE_NFN_FIELDS (type) > 0) @@ -4835,8 +5174,8 @@ print_cplus_stuff (struct type *type, int spaces) dump_fn_fieldlists (type, spaces); } - printfi_filtered (spaces, "calling_convention %d\n", - TYPE_CPLUS_CALLING_CONVENTION (type)); + gdb_printf ("%*scalling_convention %d\n", spaces, "", + TYPE_CPLUS_CALLING_CONVENTION (type)); } /* Print the contents of the TYPE's type_specific union, assuming that @@ -4848,14 +5187,24 @@ print_gnat_stuff (struct type *type, int spaces) struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type); if (descriptive_type == NULL) - printfi_filtered (spaces + 2, "no descriptive type\n"); + gdb_printf ("%*sno descriptive type\n", spaces + 2, ""); else { - printfi_filtered (spaces + 2, "descriptive type\n"); + gdb_printf ("%*sdescriptive type\n", spaces + 2, ""); recursive_dump_type (descriptive_type, spaces + 4); } } +/* Print the contents of the TYPE's type_specific union, assuming that + its type-specific kind is TYPE_SPECIFIC_FIXED_POINT. */ + +static void +print_fixed_point_type_info (struct type *type, int spaces) +{ + gdb_printf ("%*sscaling factor: %s\n", spaces + 2, "", + type->fixed_point_scaling_factor ().str ().c_str ()); +} + static struct obstack dont_print_type_obstack; /* Print the dynamic_prop PROP. */ @@ -4866,14 +5215,14 @@ dump_dynamic_prop (dynamic_prop const& prop) switch (prop.kind ()) { case PROP_CONST: - printf_filtered ("%s", plongest (prop.const_val ())); + gdb_printf ("%s", plongest (prop.const_val ())); break; case PROP_UNDEFINED: - printf_filtered ("(undefined)"); + gdb_printf ("(undefined)"); break; case PROP_LOCEXPR: case PROP_LOCLIST: - printf_filtered ("(dynamic)"); + gdb_printf ("(dynamic)"); break; default: gdb_assert_not_reached ("unhandled prop kind"); @@ -4902,9 +5251,9 @@ recursive_dump_type (struct type *type, int spaces) { if (type == first_dont_print[i]) { - printfi_filtered (spaces, "type node "); - gdb_print_host_address (type, gdb_stdout); - printf_filtered (_(" \n")); + gdb_printf ("%*stype node %s", spaces, "", + host_address_to_string (type)); + gdb_printf (_(" \n")); return; } } @@ -4912,227 +5261,234 @@ recursive_dump_type (struct type *type, int spaces) obstack_ptr_grow (&dont_print_type_obstack, type); } - printfi_filtered (spaces, "type node "); - gdb_print_host_address (type, gdb_stdout); - printf_filtered ("\n"); - printfi_filtered (spaces, "name '%s' (", - type->name () ? type->name () : ""); - gdb_print_host_address (type->name (), gdb_stdout); - printf_filtered (")\n"); - printfi_filtered (spaces, "code 0x%x ", type->code ()); + gdb_printf ("%*stype node %s\n", spaces, "", + host_address_to_string (type)); + gdb_printf ("%*sname '%s' (%s)\n", spaces, "", + type->name () ? type->name () : "", + host_address_to_string (type->name ())); + gdb_printf ("%*scode 0x%x ", spaces, "", type->code ()); switch (type->code ()) { case TYPE_CODE_UNDEF: - printf_filtered ("(TYPE_CODE_UNDEF)"); + gdb_printf ("(TYPE_CODE_UNDEF)"); break; case TYPE_CODE_PTR: - printf_filtered ("(TYPE_CODE_PTR)"); + gdb_printf ("(TYPE_CODE_PTR)"); break; case TYPE_CODE_ARRAY: - printf_filtered ("(TYPE_CODE_ARRAY)"); + gdb_printf ("(TYPE_CODE_ARRAY)"); break; case TYPE_CODE_STRUCT: - printf_filtered ("(TYPE_CODE_STRUCT)"); + gdb_printf ("(TYPE_CODE_STRUCT)"); break; case TYPE_CODE_UNION: - printf_filtered ("(TYPE_CODE_UNION)"); + gdb_printf ("(TYPE_CODE_UNION)"); break; case TYPE_CODE_ENUM: - printf_filtered ("(TYPE_CODE_ENUM)"); + gdb_printf ("(TYPE_CODE_ENUM)"); break; case TYPE_CODE_FLAGS: - printf_filtered ("(TYPE_CODE_FLAGS)"); + gdb_printf ("(TYPE_CODE_FLAGS)"); break; case TYPE_CODE_FUNC: - printf_filtered ("(TYPE_CODE_FUNC)"); + gdb_printf ("(TYPE_CODE_FUNC)"); break; case TYPE_CODE_INT: - printf_filtered ("(TYPE_CODE_INT)"); + gdb_printf ("(TYPE_CODE_INT)"); break; case TYPE_CODE_FLT: - printf_filtered ("(TYPE_CODE_FLT)"); + gdb_printf ("(TYPE_CODE_FLT)"); break; case TYPE_CODE_VOID: - printf_filtered ("(TYPE_CODE_VOID)"); + gdb_printf ("(TYPE_CODE_VOID)"); break; case TYPE_CODE_SET: - printf_filtered ("(TYPE_CODE_SET)"); + gdb_printf ("(TYPE_CODE_SET)"); break; case TYPE_CODE_RANGE: - printf_filtered ("(TYPE_CODE_RANGE)"); + gdb_printf ("(TYPE_CODE_RANGE)"); break; case TYPE_CODE_STRING: - printf_filtered ("(TYPE_CODE_STRING)"); + gdb_printf ("(TYPE_CODE_STRING)"); break; case TYPE_CODE_ERROR: - printf_filtered ("(TYPE_CODE_ERROR)"); + gdb_printf ("(TYPE_CODE_ERROR)"); break; case TYPE_CODE_MEMBERPTR: - printf_filtered ("(TYPE_CODE_MEMBERPTR)"); + gdb_printf ("(TYPE_CODE_MEMBERPTR)"); break; case TYPE_CODE_METHODPTR: - printf_filtered ("(TYPE_CODE_METHODPTR)"); + gdb_printf ("(TYPE_CODE_METHODPTR)"); break; case TYPE_CODE_METHOD: - printf_filtered ("(TYPE_CODE_METHOD)"); + gdb_printf ("(TYPE_CODE_METHOD)"); break; case TYPE_CODE_REF: - printf_filtered ("(TYPE_CODE_REF)"); + gdb_printf ("(TYPE_CODE_REF)"); break; case TYPE_CODE_CHAR: - printf_filtered ("(TYPE_CODE_CHAR)"); + gdb_printf ("(TYPE_CODE_CHAR)"); break; case TYPE_CODE_BOOL: - printf_filtered ("(TYPE_CODE_BOOL)"); + gdb_printf ("(TYPE_CODE_BOOL)"); break; case TYPE_CODE_COMPLEX: - printf_filtered ("(TYPE_CODE_COMPLEX)"); + gdb_printf ("(TYPE_CODE_COMPLEX)"); break; case TYPE_CODE_TYPEDEF: - printf_filtered ("(TYPE_CODE_TYPEDEF)"); + gdb_printf ("(TYPE_CODE_TYPEDEF)"); break; case TYPE_CODE_NAMESPACE: - printf_filtered ("(TYPE_CODE_NAMESPACE)"); + gdb_printf ("(TYPE_CODE_NAMESPACE)"); + break; + case TYPE_CODE_FIXED_POINT: + gdb_printf ("(TYPE_CODE_FIXED_POINT)"); break; default: - printf_filtered ("(UNKNOWN TYPE CODE)"); + gdb_printf ("(UNKNOWN TYPE CODE)"); break; } - puts_filtered ("\n"); - printfi_filtered (spaces, "length %s\n", pulongest (TYPE_LENGTH (type))); - if (TYPE_OBJFILE_OWNED (type)) - { - printfi_filtered (spaces, "objfile "); - gdb_print_host_address (TYPE_OWNER (type).objfile, gdb_stdout); - } + gdb_puts ("\n"); + gdb_printf ("%*slength %s\n", spaces, "", + pulongest (TYPE_LENGTH (type))); + if (type->is_objfile_owned ()) + gdb_printf ("%*sobjfile %s\n", spaces, "", + host_address_to_string (type->objfile_owner ())); else - { - printfi_filtered (spaces, "gdbarch "); - gdb_print_host_address (TYPE_OWNER (type).gdbarch, gdb_stdout); - } - printf_filtered ("\n"); - printfi_filtered (spaces, "target_type "); - gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout); - printf_filtered ("\n"); + gdb_printf ("%*sgdbarch %s\n", spaces, "", + host_address_to_string (type->arch_owner ())); + gdb_printf ("%*starget_type %s\n", spaces, "", + host_address_to_string (TYPE_TARGET_TYPE (type))); if (TYPE_TARGET_TYPE (type) != NULL) { recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2); } - printfi_filtered (spaces, "pointer_type "); - gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout); - printf_filtered ("\n"); - printfi_filtered (spaces, "reference_type "); - gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout); - printf_filtered ("\n"); - printfi_filtered (spaces, "type_chain "); - gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout); - printf_filtered ("\n"); - printfi_filtered (spaces, "instance_flags 0x%x", - TYPE_INSTANCE_FLAGS (type)); + gdb_printf ("%*spointer_type %s\n", spaces, "", + host_address_to_string (TYPE_POINTER_TYPE (type))); + gdb_printf ("%*sreference_type %s\n", spaces, "", + host_address_to_string (TYPE_REFERENCE_TYPE (type))); + gdb_printf ("%*stype_chain %s\n", spaces, "", + host_address_to_string (TYPE_CHAIN (type))); + gdb_printf ("%*sinstance_flags 0x%x", spaces, "", + (unsigned) type->instance_flags ()); if (TYPE_CONST (type)) { - puts_filtered (" TYPE_CONST"); + gdb_puts (" TYPE_CONST"); } if (TYPE_VOLATILE (type)) { - puts_filtered (" TYPE_VOLATILE"); + gdb_puts (" TYPE_VOLATILE"); } if (TYPE_CODE_SPACE (type)) { - puts_filtered (" TYPE_CODE_SPACE"); + gdb_puts (" TYPE_CODE_SPACE"); } if (TYPE_DATA_SPACE (type)) { - puts_filtered (" TYPE_DATA_SPACE"); + gdb_puts (" TYPE_DATA_SPACE"); } if (TYPE_ADDRESS_CLASS_1 (type)) { - puts_filtered (" TYPE_ADDRESS_CLASS_1"); + gdb_puts (" TYPE_ADDRESS_CLASS_1"); } if (TYPE_ADDRESS_CLASS_2 (type)) { - puts_filtered (" TYPE_ADDRESS_CLASS_2"); + gdb_puts (" TYPE_ADDRESS_CLASS_2"); } if (TYPE_RESTRICT (type)) { - puts_filtered (" TYPE_RESTRICT"); + gdb_puts (" TYPE_RESTRICT"); } if (TYPE_ATOMIC (type)) { - puts_filtered (" TYPE_ATOMIC"); + gdb_puts (" TYPE_ATOMIC"); } - puts_filtered ("\n"); + gdb_puts ("\n"); - printfi_filtered (spaces, "flags"); + gdb_printf ("%*sflags", spaces, ""); if (type->is_unsigned ()) { - puts_filtered (" TYPE_UNSIGNED"); + gdb_puts (" TYPE_UNSIGNED"); } if (type->has_no_signedness ()) { - puts_filtered (" TYPE_NOSIGN"); + gdb_puts (" TYPE_NOSIGN"); } - if (TYPE_ENDIANITY_NOT_DEFAULT (type)) + if (type->endianity_is_not_default ()) { - puts_filtered (" TYPE_ENDIANITY_NOT_DEFAULT"); + gdb_puts (" TYPE_ENDIANITY_NOT_DEFAULT"); } if (type->is_stub ()) { - puts_filtered (" TYPE_STUB"); + gdb_puts (" TYPE_STUB"); } if (type->target_is_stub ()) { - puts_filtered (" TYPE_TARGET_STUB"); + gdb_puts (" TYPE_TARGET_STUB"); } if (type->is_prototyped ()) { - puts_filtered (" TYPE_PROTOTYPED"); + gdb_puts (" TYPE_PROTOTYPED"); } if (type->has_varargs ()) { - puts_filtered (" TYPE_VARARGS"); + gdb_puts (" TYPE_VARARGS"); } /* This is used for things like AltiVec registers on ppc. Gcc emits an attribute for the array type, which tells whether or not we have a vector, instead of a regular array. */ - if (TYPE_VECTOR (type)) + if (type->is_vector ()) { - puts_filtered (" TYPE_VECTOR"); + gdb_puts (" TYPE_VECTOR"); } - if (TYPE_FIXED_INSTANCE (type)) + if (type->is_fixed_instance ()) { - puts_filtered (" TYPE_FIXED_INSTANCE"); + gdb_puts (" TYPE_FIXED_INSTANCE"); } - if (TYPE_STUB_SUPPORTED (type)) + if (type->stub_is_supported ()) { - puts_filtered (" TYPE_STUB_SUPPORTED"); + gdb_puts (" TYPE_STUB_SUPPORTED"); } if (TYPE_NOTTEXT (type)) { - puts_filtered (" TYPE_NOTTEXT"); + gdb_puts (" TYPE_NOTTEXT"); } - puts_filtered ("\n"); - printfi_filtered (spaces, "nfields %d ", type->num_fields ()); - gdb_print_host_address (type->fields (), gdb_stdout); - puts_filtered ("\n"); + gdb_puts ("\n"); + gdb_printf ("%*snfields %d ", spaces, "", type->num_fields ()); + if (TYPE_ASSOCIATED_PROP (type) != nullptr + || TYPE_ALLOCATED_PROP (type) != nullptr) + { + gdb_printf ("%*s", spaces, ""); + if (TYPE_ASSOCIATED_PROP (type) != nullptr) + { + gdb_printf ("associated "); + dump_dynamic_prop (*TYPE_ASSOCIATED_PROP (type)); + } + if (TYPE_ALLOCATED_PROP (type) != nullptr) + { + if (TYPE_ASSOCIATED_PROP (type) != nullptr) + gdb_printf (" "); + gdb_printf ("allocated "); + dump_dynamic_prop (*TYPE_ALLOCATED_PROP (type)); + } + gdb_printf ("\n"); + } + gdb_printf ("%s\n", host_address_to_string (type->fields ())); for (idx = 0; idx < type->num_fields (); idx++) { if (type->code () == TYPE_CODE_ENUM) - printfi_filtered (spaces + 2, - "[%d] enumval %s type ", - idx, plongest (TYPE_FIELD_ENUMVAL (type, idx))); + gdb_printf ("%*s[%d] enumval %s type ", spaces + 2, "", + idx, plongest (type->field (idx).loc_enumval ())); else - printfi_filtered (spaces + 2, - "[%d] bitpos %s bitsize %d type ", - idx, plongest (TYPE_FIELD_BITPOS (type, idx)), - TYPE_FIELD_BITSIZE (type, idx)); - gdb_print_host_address (type->field (idx).type (), gdb_stdout); - printf_filtered (" name '%s' (", - TYPE_FIELD_NAME (type, idx) != NULL - ? TYPE_FIELD_NAME (type, idx) - : ""); - gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout); - printf_filtered (")\n"); + gdb_printf ("%*s[%d] bitpos %s bitsize %d type ", spaces + 2, "", + idx, plongest (type->field (idx).loc_bitpos ()), + TYPE_FIELD_BITSIZE (type, idx)); + gdb_printf ("%s name '%s' (%s)\n", + host_address_to_string (type->field (idx).type ()), + type->field (idx).name () != NULL + ? type->field (idx).name () + : "", + host_address_to_string (type->field (idx).name ())); if (type->field (idx).type () != NULL) { recursive_dump_type (type->field (idx).type (), spaces + 4); @@ -5140,51 +5496,63 @@ recursive_dump_type (struct type *type, int spaces) } if (type->code () == TYPE_CODE_RANGE) { - printfi_filtered (spaces, "low "); + gdb_printf ("%*slow ", spaces, ""); dump_dynamic_prop (type->bounds ()->low); - printf_filtered (" high "); + gdb_printf (" high "); dump_dynamic_prop (type->bounds ()->high); - printf_filtered ("\n"); + gdb_printf ("\n"); } switch (TYPE_SPECIFIC_FIELD (type)) { case TYPE_SPECIFIC_CPLUS_STUFF: - printfi_filtered (spaces, "cplus_stuff "); - gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), - gdb_stdout); - puts_filtered ("\n"); + gdb_printf ("%*scplus_stuff %s\n", spaces, "", + host_address_to_string (TYPE_CPLUS_SPECIFIC (type))); print_cplus_stuff (type, spaces); break; case TYPE_SPECIFIC_GNAT_STUFF: - printfi_filtered (spaces, "gnat_stuff "); - gdb_print_host_address (TYPE_GNAT_SPECIFIC (type), gdb_stdout); - puts_filtered ("\n"); + gdb_printf ("%*sgnat_stuff %s\n", spaces, "", + host_address_to_string (TYPE_GNAT_SPECIFIC (type))); print_gnat_stuff (type, spaces); break; case TYPE_SPECIFIC_FLOATFORMAT: - printfi_filtered (spaces, "floatformat "); + gdb_printf ("%*sfloatformat ", spaces, ""); if (TYPE_FLOATFORMAT (type) == NULL || TYPE_FLOATFORMAT (type)->name == NULL) - puts_filtered ("(null)"); + gdb_puts ("(null)"); else - puts_filtered (TYPE_FLOATFORMAT (type)->name); - puts_filtered ("\n"); + gdb_puts (TYPE_FLOATFORMAT (type)->name); + gdb_puts ("\n"); break; case TYPE_SPECIFIC_FUNC: - printfi_filtered (spaces, "calling_convention %d\n", - TYPE_CALLING_CONVENTION (type)); + gdb_printf ("%*scalling_convention %d\n", spaces, "", + TYPE_CALLING_CONVENTION (type)); /* tail_call_list is not printed. */ break; case TYPE_SPECIFIC_SELF_TYPE: - printfi_filtered (spaces, "self_type "); - gdb_print_host_address (TYPE_SELF_TYPE (type), gdb_stdout); - puts_filtered ("\n"); + gdb_printf ("%*sself_type %s\n", spaces, "", + host_address_to_string (TYPE_SELF_TYPE (type))); break; + + case TYPE_SPECIFIC_FIXED_POINT: + gdb_printf ("%*sfixed_point_info ", spaces, ""); + print_fixed_point_type_info (type, spaces); + gdb_puts ("\n"); + break; + + case TYPE_SPECIFIC_INT: + if (type->bit_size_differs_p ()) + { + unsigned bit_size = type->bit_size (); + unsigned bit_off = type->bit_offset (); + gdb_printf ("%*s bit size = %u, bit offset = %u\n", spaces, "", + bit_size, bit_off); + } + break; } if (spaces == 0) @@ -5224,13 +5592,13 @@ type_pair_eq (const void *item_lhs, const void *item_rhs) types without duplicates. We use OBJFILE's obstack, because OBJFILE is about to be deleted. */ -htab_t +htab_up create_copied_types_hash (struct objfile *objfile) { - return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq, - NULL, &objfile->objfile_obstack, - hashtab_obstack_allocate, - dummy_obstack_deallocate); + return htab_up (htab_create_alloc_ex (1, type_pair_hash, type_pair_eq, + NULL, &objfile->objfile_obstack, + hashtab_obstack_allocate, + dummy_obstack_deallocate)); } /* Recursively copy (deep copy) a dynamic attribute list of a type. */ @@ -5271,12 +5639,12 @@ copy_type_recursive (struct objfile *objfile, void **slot; struct type *new_type; - if (! TYPE_OBJFILE_OWNED (type)) + if (!type->is_objfile_owned ()) return type; /* This type shouldn't be pointing to any types in other objfiles; if it did, the type might disappear unexpectedly. */ - gdb_assert (TYPE_OBJFILE (type) == objfile); + gdb_assert (type->objfile_owner () == objfile); struct type_pair pair (type, nullptr); @@ -5284,7 +5652,7 @@ copy_type_recursive (struct objfile *objfile, if (*slot != NULL) return ((struct type_pair *) *slot)->newobj; - new_type = alloc_type_arch (get_type_arch (type)); + new_type = alloc_type_arch (type->arch ()); /* We must add the new type to the hash table immediately, in case we encounter this type again during a recursive call below. */ @@ -5296,13 +5664,13 @@ copy_type_recursive (struct objfile *objfile, /* Copy the common fields of types. For the main type, we simply copy the entire thing and then update specific fields as needed. */ *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type); - TYPE_OBJFILE_OWNED (new_type) = 0; - TYPE_OWNER (new_type).gdbarch = get_type_arch (type); + + new_type->set_owner (type->arch ()); if (type->name ()) new_type->set_name (xstrdup (type->name ())); - TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type); + new_type->set_instance_flags (type->instance_flags ()); TYPE_LENGTH (new_type) = TYPE_LENGTH (type); /* Copy the fields. */ @@ -5324,32 +5692,33 @@ copy_type_recursive (struct objfile *objfile, new_type->field (i).set_type (copy_type_recursive (objfile, type->field (i).type (), copied_types)); - if (TYPE_FIELD_NAME (type, i)) - TYPE_FIELD_NAME (new_type, i) = - xstrdup (TYPE_FIELD_NAME (type, i)); - switch (TYPE_FIELD_LOC_KIND (type, i)) + if (type->field (i).name ()) + new_type->field (i).set_name (xstrdup (type->field (i).name ())); + + switch (type->field (i).loc_kind ()) { case FIELD_LOC_KIND_BITPOS: - SET_FIELD_BITPOS (new_type->field (i), - TYPE_FIELD_BITPOS (type, i)); + new_type->field (i).set_loc_bitpos (type->field (i).loc_bitpos ()); break; case FIELD_LOC_KIND_ENUMVAL: - SET_FIELD_ENUMVAL (new_type->field (i), - TYPE_FIELD_ENUMVAL (type, i)); + new_type->field (i).set_loc_enumval (type->field (i).loc_enumval ()); break; case FIELD_LOC_KIND_PHYSADDR: - SET_FIELD_PHYSADDR (new_type->field (i), - TYPE_FIELD_STATIC_PHYSADDR (type, i)); + new_type->field (i).set_loc_physaddr + (type->field (i).loc_physaddr ()); break; case FIELD_LOC_KIND_PHYSNAME: - SET_FIELD_PHYSNAME (new_type->field (i), - xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type, - i))); + new_type->field (i).set_loc_physname + (xstrdup (type->field (i).loc_physname ())); break; + case FIELD_LOC_KIND_DWARF_BLOCK: + new_type->field (i).set_loc_dwarf_block + (type->field (i).loc_dwarf_block ()); + break; default: internal_error (__FILE__, __LINE__, _("Unexpected type field location kind: %d"), - TYPE_FIELD_LOC_KIND (type, i)); + type->field (i).loc_kind ()); } } } @@ -5358,7 +5727,7 @@ copy_type_recursive (struct objfile *objfile, if (type->code () == TYPE_CODE_RANGE) { range_bounds *bounds - = ((struct range_bounds *) TYPE_ALLOC + = ((struct range_bounds *) TYPE_ALLOC (new_type, sizeof (struct range_bounds))); *bounds = *type->bounds (); @@ -5408,6 +5777,17 @@ copy_type_recursive (struct objfile *objfile, copy_type_recursive (objfile, TYPE_SELF_TYPE (type), copied_types)); break; + case TYPE_SPECIFIC_FIXED_POINT: + INIT_FIXED_POINT_SPECIFIC (new_type); + new_type->fixed_point_info ().scaling_factor + = type->fixed_point_info ().scaling_factor; + break; + case TYPE_SPECIFIC_INT: + TYPE_SPECIFIC_FIELD (new_type) = TYPE_SPECIFIC_INT; + TYPE_MAIN_TYPE (new_type)->type_specific.int_stuff + = TYPE_MAIN_TYPE (type)->type_specific.int_stuff; + break; + default: gdb_assert_not_reached ("bad type_specific_kind"); } @@ -5426,16 +5806,16 @@ copy_type (const struct type *type) { struct type *new_type; - gdb_assert (TYPE_OBJFILE_OWNED (type)); + gdb_assert (type->is_objfile_owned ()); new_type = alloc_type_copy (type); - TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type); + new_type->set_instance_flags (type->instance_flags ()); TYPE_LENGTH (new_type) = TYPE_LENGTH (type); memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type), sizeof (struct main_type)); if (type->main_type->dyn_prop_list != NULL) new_type->main_type->dyn_prop_list - = copy_dynamic_prop_list (&TYPE_OBJFILE (type) -> objfile_obstack, + = copy_dynamic_prop_list (&type->objfile_owner ()->objfile_obstack, type->main_type->dyn_prop_list); return new_type; @@ -5595,14 +5975,14 @@ append_flags_type_field (struct type *type, int start_bitpos, int nr_bits, gdb_assert (type->code () == TYPE_CODE_FLAGS); gdb_assert (type->num_fields () + 1 <= type_bitsize); gdb_assert (start_bitpos >= 0 && start_bitpos < type_bitsize); - gdb_assert (nr_bits >= 1 && nr_bits <= type_bitsize); + gdb_assert (nr_bits >= 1 && (start_bitpos + nr_bits) <= type_bitsize); gdb_assert (name != NULL); - TYPE_FIELD_NAME (type, field_nr) = xstrdup (name); + type->set_num_fields (type->num_fields () + 1); + type->field (field_nr).set_name (xstrdup (name)); type->field (field_nr).set_type (field_type); - SET_FIELD_BITPOS (type->field (field_nr), start_bitpos); + type->field (field_nr).set_loc_bitpos (start_bitpos); TYPE_FIELD_BITSIZE (type, field_nr) = nr_bits; - type->set_num_fields (type->num_fields () + 1); } /* Special version of append_flags_type_field to add a flag field. @@ -5612,10 +5992,8 @@ append_flags_type_field (struct type *type, int start_bitpos, int nr_bits, void append_flags_type_flag (struct type *type, int bitpos, const char *name) { - struct gdbarch *gdbarch = get_type_arch (type); - append_flags_type_field (type, bitpos, 1, - builtin_type (gdbarch)->builtin_bool, + builtin_type (type->arch ())->builtin_bool, name); } @@ -5651,7 +6029,7 @@ append_composite_type_field_raw (struct type *t, const char *name, f = &t->field (t->num_fields () - 1); memset (f, 0, sizeof f[0]); f[0].set_type (field); - FIELD_NAME (f[0]) = name; + f[0].set_name (name); return f; } @@ -5674,21 +6052,19 @@ append_composite_type_field_aligned (struct type *t, const char *name, TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field); if (t->num_fields () > 1) { - SET_FIELD_BITPOS (f[0], - (FIELD_BITPOS (f[-1]) - + (TYPE_LENGTH (f[-1].type ()) - * TARGET_CHAR_BIT))); + f->set_loc_bitpos + (f[-1].loc_bitpos () + (TYPE_LENGTH (f[-1].type ()) * TARGET_CHAR_BIT)); if (alignment) { int left; alignment *= TARGET_CHAR_BIT; - left = FIELD_BITPOS (f[0]) % alignment; + left = f[0].loc_bitpos () % alignment; if (left) { - SET_FIELD_BITPOS (f[0], FIELD_BITPOS (f[0]) + (alignment - left)); + f->set_loc_bitpos (f[0].loc_bitpos () + (alignment - left)); TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT; } } @@ -5705,6 +6081,87 @@ append_composite_type_field (struct type *t, const char *name, append_composite_type_field_aligned (t, name, field, 0); } + + +/* We manage the lifetimes of fixed_point_type_info objects by + attaching them to the objfile. Currently, these objects are + modified during construction, and GMP does not provide a way to + hash the contents of an mpq_t; so it's a bit of a pain to hash-cons + them. If we did do this, they could be moved to the per-BFD and + shared across objfiles. */ +typedef std::vector> + fixed_point_type_storage; + +/* Key used for managing the storage of fixed-point type info. */ +static const struct objfile_key + fixed_point_objfile_key; + +/* See gdbtypes.h. */ + +void +allocate_fixed_point_type_info (struct type *type) +{ + std::unique_ptr up (new fixed_point_type_info); + fixed_point_type_info *info; + + if (type->is_objfile_owned ()) + { + fixed_point_type_storage *storage + = fixed_point_objfile_key.get (type->objfile_owner ()); + if (storage == nullptr) + storage = fixed_point_objfile_key.emplace (type->objfile_owner ()); + info = up.get (); + storage->push_back (std::move (up)); + } + else + { + /* We just leak the memory, because that's what we do generally + for non-objfile-attached types. */ + info = up.release (); + } + + type->set_fixed_point_info (info); +} + +/* See gdbtypes.h. */ + +bool +is_fixed_point_type (struct type *type) +{ + while (check_typedef (type)->code () == TYPE_CODE_RANGE) + type = TYPE_TARGET_TYPE (check_typedef (type)); + type = check_typedef (type); + + return type->code () == TYPE_CODE_FIXED_POINT; +} + +/* See gdbtypes.h. */ + +struct type * +type::fixed_point_type_base_type () +{ + struct type *type = this; + + while (check_typedef (type)->code () == TYPE_CODE_RANGE) + type = TYPE_TARGET_TYPE (check_typedef (type)); + type = check_typedef (type); + + gdb_assert (type->code () == TYPE_CODE_FIXED_POINT); + return type; +} + +/* See gdbtypes.h. */ + +const gdb_mpq & +type::fixed_point_scaling_factor () +{ + struct type *type = this->fixed_point_type_base_type (); + + return type->fixed_point_info ().scaling_factor; +} + + + static struct gdbarch_data *gdbtypes_data; const struct builtin_type * @@ -5778,7 +6235,7 @@ gdbtypes_post_init (struct gdbarch *gdbarch) builtin_type->builtin_string = arch_type (gdbarch, TYPE_CODE_STRING, TARGET_CHAR_BIT, "string"); builtin_type->builtin_bool - = arch_type (gdbarch, TYPE_CODE_BOOL, TARGET_CHAR_BIT, "bool"); + = arch_boolean_type (gdbarch, TARGET_CHAR_BIT, 1, "bool"); /* The following three are about decimal floating point types, which are 32-bits, 64-bits and 128-bits respectively. */ @@ -5822,10 +6279,14 @@ gdbtypes_post_init (struct gdbarch *gdbarch) = arch_integer_type (gdbarch, 128, 0, "int128_t"); builtin_type->builtin_uint128 = arch_integer_type (gdbarch, 128, 1, "uint128_t"); - TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8) |= - TYPE_INSTANCE_FLAG_NOTTEXT; - TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8) |= - TYPE_INSTANCE_FLAG_NOTTEXT; + + builtin_type->builtin_int8->set_instance_flags + (builtin_type->builtin_int8->instance_flags () + | TYPE_INSTANCE_FLAG_NOTTEXT); + + builtin_type->builtin_uint8->set_instance_flags + (builtin_type->builtin_uint8->instance_flags () + | TYPE_INSTANCE_FLAG_NOTTEXT); /* Wide character types. */ builtin_type->builtin_char16 @@ -5934,10 +6395,12 @@ objfile_type (struct objfile *objfile) objfile_type->nodebug_text_symbol = init_type (objfile, TYPE_CODE_FUNC, TARGET_CHAR_BIT, ""); + objfile_type->nodebug_text_gnu_ifunc_symbol = init_type (objfile, TYPE_CODE_FUNC, TARGET_CHAR_BIT, ""); - TYPE_GNU_IFUNC (objfile_type->nodebug_text_gnu_ifunc_symbol) = 1; + objfile_type->nodebug_text_gnu_ifunc_symbol->set_is_gnu_ifunc (true); + objfile_type->nodebug_got_plt_symbol = init_pointer_type (objfile, gdbarch_addr_bit (gdbarch), "", @@ -5976,6 +6439,17 @@ objfile_type (struct objfile *objfile) return objfile_type; } +/* See gdbtypes.h. */ + +CORE_ADDR +call_site::pc () const +{ + compunit_symtab *cust = this->per_objfile->get_symtab (this->per_cu); + CORE_ADDR delta + = this->per_objfile->objfile->section_offsets[cust->block_line_section ()]; + return m_unrelocated_pc + delta; +} + void _initialize_gdbtypes (); void _initialize_gdbtypes ()