X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbtypes.c;h=0940fa597fbcd58640aeaa11de787a1a0fb2728a;hb=6390859caa7684ff195d57e9f5cc02eae89bdb95;hp=373b30a423d4cb7ca536e253e171fb517bc36d2f;hpb=a70b814420059e1f2de2130d532ddd7b2b2500fc;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index 373b30a423..0940fa597f 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -1,6 +1,6 @@ /* Support routines for manipulating internal types for GDB. - Copyright (C) 1992-2019 Free Software Foundation, Inc. + Copyright (C) 1992-2020 Free Software Foundation, Inc. Contributed by Cygnus Support, using pieces from other GDB modules. @@ -36,9 +36,10 @@ #include "hashtab.h" #include "cp-support.h" #include "bcache.h" -#include "dwarf2loc.h" +#include "dwarf2/loc.h" #include "gdbcore.h" #include "floatformat.h" +#include /* Initialize BADNESS constants. */ @@ -60,6 +61,7 @@ const struct rank VOID_PTR_CONVERSION_BADNESS = {2,0}; const struct rank BOOL_CONVERSION_BADNESS = {3,0}; const struct rank BASE_CONVERSION_BADNESS = {2,0}; const struct rank REFERENCE_CONVERSION_BADNESS = {2,0}; +const struct rank REFERENCE_SEE_THROUGH_BADNESS = {0,1}; const struct rank NULL_POINTER_CONVERSION_BADNESS = {2,0}; const struct rank NS_POINTER_CONVERSION_BADNESS = {10,0}; const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS = {3,0}; @@ -113,19 +115,22 @@ const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = { &floatformat_ibm_long_double_big, &floatformat_ibm_long_double_little }; +const struct floatformat *floatformats_bfloat16[BFD_ENDIAN_UNKNOWN] = { + &floatformat_bfloat16_big, + &floatformat_bfloat16_little +}; /* Should opaque types be resolved? */ -static int opaque_type_resolution = 1; +static bool opaque_type_resolution = true; -/* A flag to enable printing of debugging information of C++ - overloading. */ +/* See gdbtypes.h. */ unsigned int overload_debug = 0; /* A flag to enable strict type checking. */ -static int strict_type_checking = 1; +static bool strict_type_checking = true; /* A function to show whether opaque types are resolved. */ @@ -181,7 +186,7 @@ alloc_type (struct objfile *objfile) /* Initialize the fields that might not be zero. */ - TYPE_CODE (type) = TYPE_CODE_UNDEF; + type->set_code (TYPE_CODE_UNDEF); TYPE_CHAIN (type) = type; /* Chain back to itself. */ return type; @@ -208,7 +213,7 @@ alloc_type_arch (struct gdbarch *gdbarch) /* Initialize the fields that might not be zero. */ - TYPE_CODE (type) = TYPE_CODE_UNDEF; + type->set_code (TYPE_CODE_UNDEF); TYPE_CHAIN (type) = type; /* Chain back to itself. */ return type; @@ -236,7 +241,7 @@ get_type_arch (const struct type *type) struct gdbarch *arch; if (TYPE_OBJFILE_OWNED (type)) - arch = get_objfile_arch (TYPE_OWNER (type).objfile); + arch = TYPE_OWNER (type).objfile->arch (); else arch = TYPE_OWNER (type).gdbarch; @@ -365,12 +370,12 @@ make_pointer_type (struct type *type, struct type **typeptr) TYPE_LENGTH (ntype) = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT; - TYPE_CODE (ntype) = TYPE_CODE_PTR; + ntype->set_code (TYPE_CODE_PTR); /* Mark pointers as unsigned. The target converts between pointers and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and gdbarch_address_to_pointer. */ - TYPE_UNSIGNED (ntype) = 1; + ntype->set_is_unsigned (true); /* Update the length of all the other variants of this type. */ chain = TYPE_CHAIN (ntype); @@ -449,7 +454,7 @@ make_reference_type (struct type *type, struct type **typeptr, TYPE_LENGTH (ntype) = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT; - TYPE_CODE (ntype) = refcode; + ntype->set_code (refcode); *reftype = ntype; @@ -514,7 +519,7 @@ make_function_type (struct type *type, struct type **typeptr) TYPE_TARGET_TYPE (ntype) = type; TYPE_LENGTH (ntype) = 1; - TYPE_CODE (ntype) = TYPE_CODE_FUNC; + ntype->set_code (TYPE_CODE_FUNC); INIT_FUNC_SPECIFIC (ntype); @@ -547,36 +552,37 @@ lookup_function_type_with_arguments (struct type *type, if (param_types[nparams - 1] == NULL) { --nparams; - TYPE_VARARGS (fn) = 1; + fn->set_has_varargs (true); } - else if (TYPE_CODE (check_typedef (param_types[nparams - 1])) + else if (check_typedef (param_types[nparams - 1])->code () == TYPE_CODE_VOID) { --nparams; /* Caller should have ensured this. */ gdb_assert (nparams == 0); - TYPE_PROTOTYPED (fn) = 1; + fn->set_is_prototyped (true); } else - TYPE_PROTOTYPED (fn) = 1; + fn->set_is_prototyped (true); } - TYPE_NFIELDS (fn) = nparams; - TYPE_FIELDS (fn) - = (struct field *) TYPE_ZALLOC (fn, nparams * sizeof (struct field)); + fn->set_num_fields (nparams); + fn->set_fields + ((struct field *) TYPE_ZALLOC (fn, nparams * sizeof (struct field))); for (i = 0; i < nparams; ++i) - TYPE_FIELD_TYPE (fn, i) = param_types[i]; + fn->field (i).set_type (param_types[i]); 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, 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")) @@ -592,11 +598,12 @@ address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier) 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"; @@ -615,7 +622,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; @@ -623,7 +630,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); } @@ -655,7 +662,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); @@ -673,13 +680,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); } @@ -703,9 +711,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; @@ -745,7 +753,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); } @@ -756,7 +764,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)), @@ -769,7 +777,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); } @@ -817,7 +825,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++. @@ -859,9 +867,9 @@ allocate_stub_method (struct type *type) struct type *mtype; mtype = alloc_type_copy (type); - TYPE_CODE (mtype) = TYPE_CODE_METHOD; + mtype->set_code (TYPE_CODE_METHOD); TYPE_LENGTH (mtype) = 1; - TYPE_STUB (mtype) = 1; + mtype->set_is_stub (true); TYPE_TARGET_TYPE (mtype) = type; /* TYPE_SELF_TYPE (mtype) = unknown yet */ return mtype; @@ -872,19 +880,23 @@ allocate_stub_method (struct type *type) bool operator== (const dynamic_prop &l, const dynamic_prop &r) { - if (l.kind != r.kind) + if (l.kind () != r.kind ()) return false; - switch (l.kind) + switch (l.kind ()) { case PROP_UNDEFINED: return true; case PROP_CONST: - return l.data.const_val == r.data.const_val; + return l.const_val () == r.const_val (); case PROP_ADDR_OFFSET: case PROP_LOCEXPR: case PROP_LOCLIST: - return l.data.baton == r.data.baton; + return l.baton () == r.baton (); + case PROP_VARIANT_PARTS: + return l.variant_parts () == r.variant_parts (); + case PROP_TYPE: + return l.original_type () == r.original_type (); } gdb_assert_not_reached ("unhandled dynamic_prop kind"); @@ -900,7 +912,8 @@ operator== (const range_bounds &l, const range_bounds &r) return (FIELD_EQ (low) && FIELD_EQ (high) && FIELD_EQ (flag_upper_bound_is_count) - && FIELD_EQ (flag_bound_evaluated)); + && FIELD_EQ (flag_bound_evaluated) + && FIELD_EQ (bias)); #undef FIELD_EQ } @@ -911,35 +924,77 @@ operator== (const range_bounds &l, const range_bounds &r) struct type * create_range_type (struct type *result_type, struct type *index_type, const struct dynamic_prop *low_bound, - const struct dynamic_prop *high_bound) + const struct dynamic_prop *high_bound, + LONGEST bias) { + /* The INDEX_TYPE should be a type capable of holding the upper and lower + bounds, as such a zero sized, or void type makes no sense. */ + gdb_assert (index_type->code () != TYPE_CODE_VOID); + gdb_assert (TYPE_LENGTH (index_type) > 0); + if (result_type == NULL) result_type = alloc_type_copy (index_type); - TYPE_CODE (result_type) = TYPE_CODE_RANGE; + result_type->set_code (TYPE_CODE_RANGE); TYPE_TARGET_TYPE (result_type) = index_type; - if (TYPE_STUB (index_type)) - TYPE_TARGET_STUB (result_type) = 1; + if (index_type->is_stub ()) + result_type->set_target_is_stub (true); else TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type)); - TYPE_RANGE_DATA (result_type) = (struct range_bounds *) - TYPE_ZALLOC (result_type, sizeof (struct range_bounds)); - TYPE_RANGE_DATA (result_type)->low = *low_bound; - TYPE_RANGE_DATA (result_type)->high = *high_bound; - - if (low_bound->kind == PROP_CONST && low_bound->data.const_val >= 0) - TYPE_UNSIGNED (result_type) = 1; - + range_bounds *bounds + = (struct range_bounds *) TYPE_ZALLOC (result_type, sizeof (range_bounds)); + bounds->low = *low_bound; + bounds->high = *high_bound; + bounds->bias = bias; + bounds->stride.set_const_val (0); + + result_type->set_bounds (bounds); + + /* 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. */ + 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 is negative as unsigned. */ - if (high_bound->kind == PROP_CONST && high_bound->data.const_val < 0) - TYPE_UNSIGNED (result_type) = 0; + if (high_bound->kind () == PROP_CONST && high_bound->const_val () < 0) + result_type->set_is_unsigned (false); + + result_type->set_endianity_is_not_default + (index_type->endianity_is_not_default ()); return result_type; } +/* See gdbtypes.h. */ + +struct type * +create_range_type_with_stride (struct type *result_type, + struct type *index_type, + const struct dynamic_prop *low_bound, + const struct dynamic_prop *high_bound, + LONGEST bias, + const struct dynamic_prop *stride, + bool byte_stride_p) +{ + result_type = create_range_type (result_type, index_type, low_bound, + high_bound, bias); + + gdb_assert (stride != nullptr); + result_type->bounds ()->stride = *stride; + result_type->bounds ()->flag_is_byte_stride = byte_stride_p; + + return result_type; +} + + + /* Create a range type using either a blank type supplied in RESULT_TYPE, or creating a new type, inheriting the objfile from INDEX_TYPE. @@ -956,13 +1011,10 @@ create_static_range_type (struct type *result_type, struct type *index_type, { struct dynamic_prop low, high; - low.kind = PROP_CONST; - low.data.const_val = low_bound; - - high.kind = PROP_CONST; - high.data.const_val = high_bound; + low.set_const_val (low_bound); + high.set_const_val (high_bound); - result_type = create_range_type (result_type, index_type, &low, &high); + result_type = create_range_type (result_type, index_type, &low, &high, 0); return result_type; } @@ -970,37 +1022,56 @@ create_static_range_type (struct type *result_type, struct type *index_type, /* Predicate tests whether BOUNDS are static. Returns 1 if all bounds values are static, otherwise returns 0. */ -static int +static bool has_static_range (const struct range_bounds *bounds) { - return (bounds->low.kind == PROP_CONST - && bounds->high.kind == PROP_CONST); + /* If the range doesn't have a defined stride then its stride field will + be initialized to the constant 0. */ + return (bounds->low.kind () == PROP_CONST + && bounds->high.kind () == PROP_CONST + && bounds->stride.kind () == PROP_CONST); } /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type - TYPE. Return 1 if type is a range type, 0 if it is discrete (and - bounds will fit in LONGEST), or -1 otherwise. */ + TYPE. + + 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. */ int get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) { type = check_typedef (type); - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_RANGE: - *lowp = TYPE_LOW_BOUND (type); - *highp = TYPE_HIGH_BOUND (type); + /* 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; + + *lowp = type->bounds ()->low.const_val (); + *highp = type->bounds ()->high.const_val (); + + 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_NFIELDS (type) > 0) + if (type->num_fields () > 0) { /* The enums may not be sorted by value, so search all entries. */ int i; *lowp = *highp = TYPE_FIELD_ENUMVAL (type, 0); - for (i = 0; i < TYPE_NFIELDS (type); i++) + for (i = 0; i < type->num_fields (); i++) { if (TYPE_FIELD_ENUMVAL (type, i) < *lowp) *lowp = TYPE_FIELD_ENUMVAL (type, i); @@ -1010,9 +1081,7 @@ get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) /* Set unsigned indicator if warranted. */ if (*lowp >= 0) - { - TYPE_UNSIGNED (type) = 1; - } + type->set_is_unsigned (true); } else { @@ -1027,7 +1096,7 @@ get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) case TYPE_CODE_INT: if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */ return -1; - if (!TYPE_UNSIGNED (type)) + if (!type->is_unsigned ()) { *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1)); *highp = -*lowp - 1; @@ -1052,19 +1121,12 @@ get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) Save the high bound into HIGH_BOUND if not NULL. Return 1 if the operation was successful. Return zero otherwise, - in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified. - - We now simply use get_discrete_bounds call to get the values - of the low and high bounds. - get_discrete_bounds can return three values: - 1, meaning that index is a range, - 0, meaning that index is a discrete type, - or -1 for failure. */ + in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified. */ int get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound) { - struct type *index = TYPE_INDEX_TYPE (type); + struct type *index = type->index_type (); LONGEST low = 0; LONGEST high = 0; int res; @@ -1076,12 +1138,6 @@ get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound) if (res == -1) return 0; - /* Check if the array bounds are undefined. */ - if (res == 1 - && ((low_bound && TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type)) - || (high_bound && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type)))) - return 0; - if (low_bound) *low_bound = low; @@ -1108,11 +1164,14 @@ get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound) int discrete_position (struct type *type, LONGEST val, LONGEST *pos) { - if (TYPE_CODE (type) == TYPE_CODE_ENUM) + if (type->code () == TYPE_CODE_RANGE) + type = TYPE_TARGET_TYPE (type); + + if (type->code () == TYPE_CODE_ENUM) { int i; - for (i = 0; i < TYPE_NFIELDS (type); i += 1) + for (i = 0; i < type->num_fields (); i += 1) { if (val == TYPE_FIELD_ENUMVAL (type, i)) { @@ -1130,6 +1189,64 @@ discrete_position (struct type *type, LONGEST val, LONGEST *pos) } } +/* If the array TYPE has static bounds calculate and update its + size, then return true. Otherwise return false and leave TYPE + unchanged. */ + +static bool +update_static_array_size (struct type *type) +{ + gdb_assert (type->code () == TYPE_CODE_ARRAY); + + struct type *range_type = type->index_type (); + + if (type->dyn_prop (DYN_PROP_BYTE_STRIDE) == nullptr + && has_static_range (range_type->bounds ()) + && (!type_not_associated (type) + && !type_not_allocated (type))) + { + LONGEST low_bound, high_bound; + 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 (); + + if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0) + 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. + In such cases, the array length should be zero. */ + if (high_bound < low_bound) + TYPE_LENGTH (type) = 0; + else if (stride != 0) + { + /* Ensure that the type length is always positive, even in the + case where (for example in Fortran) we have a negative + stride. It is possible to have a single element array with a + negative stride in Fortran (this doesn't mean anything + special, it's still just a single element array) so do + consider that case when touching this code. */ + LONGEST element_count = std::abs (high_bound - low_bound + 1); + TYPE_LENGTH (type) + = ((std::abs (stride) * element_count) + 7) / 8; + } + else + TYPE_LENGTH (type) = + TYPE_LENGTH (element_type) * (high_bound - low_bound + 1); + + return true; + } + + return false; +} + /* Create an array type using either a blank type supplied in RESULT_TYPE, or creating a new type, inheriting the objfile from RANGE_TYPE. @@ -1160,44 +1277,32 @@ create_array_type_with_stride (struct type *result_type, unsigned int bit_stride) { if (byte_stride_prop != NULL - && byte_stride_prop->kind == PROP_CONST) + && byte_stride_prop->kind () == PROP_CONST) { /* The byte stride is actually not dynamic. Pretend we were called with bit_stride set instead of byte_stride_prop. This will give us the same result type, while avoiding the need to handle this as a special case. */ - bit_stride = byte_stride_prop->data.const_val * 8; + bit_stride = byte_stride_prop->const_val () * 8; byte_stride_prop = NULL; } if (result_type == NULL) result_type = alloc_type_copy (range_type); - TYPE_CODE (result_type) = TYPE_CODE_ARRAY; + result_type->set_code (TYPE_CODE_ARRAY); TYPE_TARGET_TYPE (result_type) = element_type; - if (byte_stride_prop == NULL - && has_static_range (TYPE_RANGE_DATA (range_type)) - && (!type_not_associated (result_type) - && !type_not_allocated (result_type))) - { - LONGEST low_bound, high_bound; - if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0) - low_bound = high_bound = 0; - element_type = check_typedef (element_type); - /* Be careful when setting the array length. Ada arrays can be - empty arrays with the high_bound being smaller than the low_bound. - In such cases, the array length should be zero. */ - if (high_bound < low_bound) - TYPE_LENGTH (result_type) = 0; - else if (bit_stride > 0) - TYPE_LENGTH (result_type) = - (bit_stride * (high_bound - low_bound + 1) + 7) / 8; - else - TYPE_LENGTH (result_type) = - TYPE_LENGTH (element_type) * (high_bound - low_bound + 1); - } - else + result_type->set_num_fields (1); + result_type->set_fields + ((struct field *) TYPE_ZALLOC (result_type, sizeof (struct field))); + result_type->set_index_type (range_type); + if (byte_stride_prop != NULL) + result_type->add_dyn_prop (DYN_PROP_BYTE_STRIDE, *byte_stride_prop); + else if (bit_stride > 0) + TYPE_FIELD_BITSIZE (result_type, 0) = bit_stride; + + 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 @@ -1208,18 +1313,9 @@ create_array_type_with_stride (struct type *result_type, TYPE_LENGTH (result_type) = 0; } - TYPE_NFIELDS (result_type) = 1; - TYPE_FIELDS (result_type) = - (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field)); - TYPE_INDEX_TYPE (result_type) = range_type; - if (byte_stride_prop != NULL) - add_dyn_prop (DYN_PROP_BYTE_STRIDE, *byte_stride_prop, result_type); - else if (bit_stride > 0) - TYPE_FIELD_BITSIZE (result_type, 0) = bit_stride; - /* TYPE_TARGET_STUB will take care of zero length arrays. */ if (TYPE_LENGTH (result_type) == 0) - TYPE_TARGET_STUB (result_type) = 1; + result_type->set_target_is_stub (true); return result_type; } @@ -1273,7 +1369,7 @@ create_string_type (struct type *result_type, result_type = create_array_type (result_type, string_char_type, range_type); - TYPE_CODE (result_type) = TYPE_CODE_STRING; + result_type->set_code (TYPE_CODE_STRING); return result_type; } @@ -1285,7 +1381,7 @@ lookup_string_range_type (struct type *string_char_type, result_type = lookup_array_range_type (string_char_type, low_bound, high_bound); - TYPE_CODE (result_type) = TYPE_CODE_STRING; + result_type->set_code (TYPE_CODE_STRING); return result_type; } @@ -1295,12 +1391,12 @@ create_set_type (struct type *result_type, struct type *domain_type) if (result_type == NULL) result_type = alloc_type_copy (domain_type); - TYPE_CODE (result_type) = TYPE_CODE_SET; - TYPE_NFIELDS (result_type) = 1; - TYPE_FIELDS (result_type) - = (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field)); + result_type->set_code (TYPE_CODE_SET); + result_type->set_num_fields (1); + result_type->set_fields + ((struct field *) TYPE_ZALLOC (result_type, sizeof (struct field))); - if (!TYPE_STUB (domain_type)) + if (!domain_type->is_stub ()) { LONGEST low_bound, high_bound, bit_length; @@ -1310,9 +1406,9 @@ create_set_type (struct type *result_type, struct type *domain_type) TYPE_LENGTH (result_type) = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT; if (low_bound >= 0) - TYPE_UNSIGNED (result_type) = 1; + result_type->set_is_unsigned (true); } - TYPE_FIELD_TYPE (result_type, 0) = domain_type; + result_type->field (0).set_type (domain_type); return result_type; } @@ -1324,23 +1420,23 @@ 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. */ inner_array = array_type; - while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY) + while (TYPE_TARGET_TYPE (inner_array)->code () == TYPE_CODE_ARRAY) inner_array = TYPE_TARGET_TYPE (inner_array); elt_type = TYPE_TARGET_TYPE (inner_array); - if (TYPE_CODE (elt_type) == TYPE_CODE_INT) + 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; } - TYPE_VECTOR (array_type) = 1; + array_type->set_is_vector (true); } struct type * @@ -1362,7 +1458,7 @@ init_vector_type (struct type *elt_type, int n) struct type * internal_type_self_type (struct type *type) { - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_METHODPTR: case TYPE_CODE_MEMBERPTR: @@ -1388,7 +1484,7 @@ internal_type_self_type (struct type *type) void set_type_self_type (struct type *type, struct type *self_type) { - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_METHODPTR: case TYPE_CODE_MEMBERPTR: @@ -1424,7 +1520,7 @@ smash_to_memberptr_type (struct type *type, struct type *self_type, struct type *to_type) { smash_type (type); - TYPE_CODE (type) = TYPE_CODE_MEMBERPTR; + type->set_code (TYPE_CODE_MEMBERPTR); TYPE_TARGET_TYPE (type) = to_type; set_type_self_type (type, self_type); /* Assume that a data member pointer is the same size as a normal @@ -1443,7 +1539,7 @@ void smash_to_methodptr_type (struct type *type, struct type *to_type) { smash_type (type); - TYPE_CODE (type) = TYPE_CODE_METHODPTR; + type->set_code (TYPE_CODE_METHODPTR); TYPE_TARGET_TYPE (type) = to_type; set_type_self_type (type, TYPE_SELF_TYPE (to_type)); TYPE_LENGTH (type) = cplus_method_ptr_size (to_type); @@ -1462,13 +1558,13 @@ smash_to_method_type (struct type *type, struct type *self_type, int nargs, int varargs) { smash_type (type); - TYPE_CODE (type) = TYPE_CODE_METHOD; + type->set_code (TYPE_CODE_METHOD); TYPE_TARGET_TYPE (type) = to_type; set_type_self_type (type, self_type); - TYPE_FIELDS (type) = args; - TYPE_NFIELDS (type) = nargs; + type->set_fields (args); + type->set_num_fields (nargs); if (varargs) - TYPE_VARARGS (type) = 1; + type->set_has_varargs (true); TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */ } @@ -1488,11 +1584,11 @@ type_name_or_error (struct type *type) type = check_typedef (type); - name = TYPE_NAME (type); + name = type->name (); if (name != NULL) return name; - name = TYPE_NAME (saved_type); + name = saved_type->name (); objfile = TYPE_OBJFILE (saved_type); error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"), name ? name : "", @@ -1505,7 +1601,7 @@ type_name_or_error (struct type *type) struct type * lookup_typename (const struct language_defn *language, - struct gdbarch *gdbarch, const char *name, + const char *name, const struct block *block, int noerr) { struct symbol *sym; @@ -1522,29 +1618,28 @@ lookup_typename (const struct language_defn *language, struct type * lookup_unsigned_typename (const struct language_defn *language, - struct gdbarch *gdbarch, const char *name) + const char *name) { char *uns = (char *) alloca (strlen (name) + 10); strcpy (uns, "unsigned "); strcpy (uns + 9, name); - return lookup_typename (language, gdbarch, uns, NULL, 0); + return lookup_typename (language, uns, NULL, 0); } struct type * -lookup_signed_typename (const struct language_defn *language, - struct gdbarch *gdbarch, const char *name) +lookup_signed_typename (const struct language_defn *language, const char *name) { struct type *t; char *uns = (char *) alloca (strlen (name) + 8); strcpy (uns, "signed "); strcpy (uns + 7, name); - t = lookup_typename (language, gdbarch, uns, NULL, 1); + t = lookup_typename (language, uns, NULL, 1); /* If we don't find "signed FOO" just try again with plain "FOO". */ if (t != NULL) return t; - return lookup_typename (language, gdbarch, name, NULL, 0); + return lookup_typename (language, name, NULL, 0); } /* Lookup a structure type named "struct NAME", @@ -1561,7 +1656,7 @@ lookup_struct (const char *name, const struct block *block) { error (_("No struct type named %s."), name); } - if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT) + if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_STRUCT) { error (_("This context has class, union or enum %s, not a struct."), name); @@ -1585,7 +1680,7 @@ lookup_union (const char *name, const struct block *block) t = SYMBOL_TYPE (sym); - if (TYPE_CODE (t) == TYPE_CODE_UNION) + if (t->code () == TYPE_CODE_UNION) return t; /* If we get here, it's not a union. */ @@ -1606,7 +1701,7 @@ lookup_enum (const char *name, const struct block *block) { error (_("No enum type named %s."), name); } - if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM) + if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_ENUM) { error (_("This context has class, struct or union %s, not an enum."), name); @@ -1618,16 +1713,16 @@ lookup_enum (const char *name, const struct block *block) visible in lexical block BLOCK. */ struct type * -lookup_template_type (char *name, struct type *type, +lookup_template_type (const char *name, struct type *type, const struct block *block) { struct symbol *sym; char *nam = (char *) - alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4); + alloca (strlen (name) + strlen (type->name ()) + 4); strcpy (nam, name); strcat (nam, "<"); - strcat (nam, TYPE_NAME (type)); + strcat (nam, type->name ()); strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */ sym = lookup_symbol (nam, block, VAR_DOMAIN, 0).symbol; @@ -1636,7 +1731,7 @@ lookup_template_type (char *name, struct type *type, { error (_("No template type named %s."), name); } - if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT) + if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_STRUCT) { error (_("This context has class, union or enum %s, not a struct."), name); @@ -1654,32 +1749,32 @@ lookup_struct_elt (struct type *type, const char *name, int noerr) for (;;) { type = check_typedef (type); - if (TYPE_CODE (type) != TYPE_CODE_PTR - && TYPE_CODE (type) != TYPE_CODE_REF) + if (type->code () != TYPE_CODE_PTR + && type->code () != TYPE_CODE_REF) break; type = TYPE_TARGET_TYPE (type); } - if (TYPE_CODE (type) != TYPE_CODE_STRUCT - && TYPE_CODE (type) != TYPE_CODE_UNION) + if (type->code () != TYPE_CODE_STRUCT + && type->code () != TYPE_CODE_UNION) { std::string type_name = type_to_string (type); error (_("Type %s is not a structure or union type."), type_name.c_str ()); } - for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--) + for (i = type->num_fields () - 1; i >= TYPE_N_BASECLASSES (type); i--) { const char *t_field_name = TYPE_FIELD_NAME (type, i); if (t_field_name && (strcmp_iw (t_field_name, name) == 0)) { - return {&TYPE_FIELD (type, i), TYPE_FIELD_BITPOS (type, i)}; + return {&type->field (i), TYPE_FIELD_BITPOS (type, i)}; } else if (!t_field_name || *t_field_name == '\0') { struct_elt elt - = lookup_struct_elt (TYPE_FIELD_TYPE (type, i), name, 1); + = lookup_struct_elt (type->field (i).type (), name, 1); if (elt.field != NULL) { elt.offset += TYPE_FIELD_BITPOS (type, i); @@ -1710,7 +1805,7 @@ lookup_struct_elt_type (struct type *type, const char *name, int noerr) { struct_elt elt = lookup_struct_elt (type, name, noerr); if (elt.field != NULL) - return FIELD_TYPE (*elt.field); + return elt.field->type (); else return NULL; } @@ -1724,7 +1819,7 @@ get_unsigned_type_max (struct type *type, ULONGEST *max) unsigned int n; type = check_typedef (type); - gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && TYPE_UNSIGNED (type)); + gdb_assert (type->code () == TYPE_CODE_INT && type->is_unsigned ()); gdb_assert (TYPE_LENGTH (type) <= sizeof (ULONGEST)); /* Written this way to avoid overflow. */ @@ -1741,7 +1836,7 @@ get_signed_type_minmax (struct type *type, LONGEST *min, LONGEST *max) unsigned int n; type = check_typedef (type); - gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && !TYPE_UNSIGNED (type)); + gdb_assert (type->code () == TYPE_CODE_INT && !type->is_unsigned ()); gdb_assert (TYPE_LENGTH (type) <= sizeof (LONGEST)); n = TYPE_LENGTH (type) * TARGET_CHAR_BIT; @@ -1760,8 +1855,8 @@ int internal_type_vptr_fieldno (struct type *type) { type = check_typedef (type); - gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT - || TYPE_CODE (type) == TYPE_CODE_UNION); + gdb_assert (type->code () == TYPE_CODE_STRUCT + || type->code () == TYPE_CODE_UNION); if (!HAVE_CPLUS_STRUCT (type)) return -1; return TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_fieldno; @@ -1773,8 +1868,8 @@ void set_type_vptr_fieldno (struct type *type, int fieldno) { type = check_typedef (type); - gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT - || TYPE_CODE (type) == TYPE_CODE_UNION); + gdb_assert (type->code () == TYPE_CODE_STRUCT + || type->code () == TYPE_CODE_UNION); if (!HAVE_CPLUS_STRUCT (type)) ALLOCATE_CPLUS_STRUCT_TYPE (type); TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_fieldno = fieldno; @@ -1787,8 +1882,8 @@ struct type * internal_type_vptr_basetype (struct type *type) { type = check_typedef (type); - gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT - || TYPE_CODE (type) == TYPE_CODE_UNION); + gdb_assert (type->code () == TYPE_CODE_STRUCT + || type->code () == TYPE_CODE_UNION); gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_CPLUS_STUFF); return TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_basetype; } @@ -1799,8 +1894,8 @@ void set_type_vptr_basetype (struct type *type, struct type *basetype) { type = check_typedef (type); - gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT - || TYPE_CODE (type) == TYPE_CODE_UNION); + gdb_assert (type->code () == TYPE_CODE_STRUCT + || type->code () == TYPE_CODE_UNION); if (!HAVE_CPLUS_STRUCT (type)) ALLOCATE_CPLUS_STRUCT_TYPE (type); TYPE_RAW_CPLUS_SPECIFIC (type)->vptr_basetype = basetype; @@ -1874,9 +1969,9 @@ stub_noname_complaint (void) static int array_type_has_dynamic_stride (struct type *type) { - struct dynamic_prop *prop = get_dyn_prop (DYN_PROP_BYTE_STRIDE, type); + struct dynamic_prop *prop = type->dyn_prop (DYN_PROP_BYTE_STRIDE); - return (prop != NULL && prop->kind != PROP_CONST); + return (prop != NULL && prop->kind () != PROP_CONST); } /* Worker for is_dynamic_type. */ @@ -1887,7 +1982,7 @@ is_dynamic_type_internal (struct type *type, int top_level) type = check_typedef (type); /* We only want to recognize references at the outermost level. */ - if (top_level && TYPE_CODE (type) == TYPE_CODE_REF) + if (top_level && type->code () == TYPE_CODE_REF) type = check_typedef (TYPE_TARGET_TYPE (type)); /* Types that have a dynamic TYPE_DATA_LOCATION are considered @@ -1907,7 +2002,14 @@ is_dynamic_type_internal (struct type *type, int top_level) if (TYPE_ALLOCATED_PROP (type)) return 1; - switch (TYPE_CODE (type)) + struct dynamic_prop *prop = type->dyn_prop (DYN_PROP_VARIANT_PARTS); + if (prop != nullptr && prop->kind () != PROP_TYPE) + return 1; + + if (TYPE_HAS_DYNAMIC_LENGTH (type)) + return 1; + + switch (type->code ()) { case TYPE_CODE_RANGE: { @@ -1916,16 +2018,19 @@ is_dynamic_type_internal (struct type *type, int top_level) dynamic when its subtype is dynamic, even if the bounds of the range type are static. It allows us to assume that the subtype of a static range type is also static. */ - return (!has_static_range (TYPE_RANGE_DATA (type)) + return (!has_static_range (type->bounds ()) || is_dynamic_type_internal (TYPE_TARGET_TYPE (type), 0)); } + case TYPE_CODE_STRING: + /* Strings are very much like an array of characters, and can be + treated as one here. */ case TYPE_CODE_ARRAY: { - gdb_assert (TYPE_NFIELDS (type) == 1); + gdb_assert (type->num_fields () == 1); /* The array is dynamic if either the bounds are dynamic... */ - if (is_dynamic_type_internal (TYPE_INDEX_TYPE (type), 0)) + if (is_dynamic_type_internal (type->index_type (), 0)) return 1; /* ... or the elements it contains have a dynamic contents... */ if (is_dynamic_type_internal (TYPE_TARGET_TYPE (type), 0)) @@ -1941,10 +2046,27 @@ is_dynamic_type_internal (struct type *type, int top_level) { int i; - for (i = 0; i < TYPE_NFIELDS (type); ++i) - if (!field_is_static (&TYPE_FIELD (type, i)) - && is_dynamic_type_internal (TYPE_FIELD_TYPE (type, i), 0)) + bool is_cplus = HAVE_CPLUS_STRUCT (type); + + for (i = 0; i < type->num_fields (); ++i) + { + /* Static fields can be ignored here. */ + if (field_is_static (&type->field (i))) + continue; + /* If the field has dynamic type, then so does TYPE. */ + if (is_dynamic_type_internal (type->field (i).type (), 0)) + 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) + continue; + /* Do not consider C++ virtual base types to be dynamic + due to the field's offset being dynamic; these are + handled via other means. */ + if (is_cplus && BASETYPE_VIA_VIRTUAL (type, i)) + continue; return 1; + } } break; } @@ -1973,56 +2095,68 @@ resolve_dynamic_range (struct type *dyn_range_type, { CORE_ADDR value; struct type *static_range_type, *static_target_type; - const struct dynamic_prop *prop; - struct dynamic_prop low_bound, high_bound; + struct dynamic_prop low_bound, high_bound, stride; - gdb_assert (TYPE_CODE (dyn_range_type) == TYPE_CODE_RANGE); + gdb_assert (dyn_range_type->code () == TYPE_CODE_RANGE); - prop = &TYPE_RANGE_DATA (dyn_range_type)->low; + const struct dynamic_prop *prop = &dyn_range_type->bounds ()->low; if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) - { - low_bound.kind = PROP_CONST; - low_bound.data.const_val = value; - } + 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)) { - low_bound.kind = PROP_UNDEFINED; - low_bound.data.const_val = 0; + high_bound.set_const_val (value); + + if (dyn_range_type->bounds ()->flag_upper_bound_is_count) + high_bound.set_const_val + (low_bound.const_val () + high_bound.const_val () - 1); } + else + high_bound.set_undefined (); - prop = &TYPE_RANGE_DATA (dyn_range_type)->high; + 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)) { - high_bound.kind = PROP_CONST; - high_bound.data.const_val = value; + stride.set_const_val (value); - if (TYPE_RANGE_DATA (dyn_range_type)->flag_upper_bound_is_count) - high_bound.data.const_val - = low_bound.data.const_val + high_bound.data.const_val - 1; + /* If we have a bit stride that is not an exact number of bytes then + 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); + 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 " + "are currently not supported")); } else { - high_bound.kind = PROP_UNDEFINED; - high_bound.data.const_val = 0; + stride.set_undefined (); + byte_stride_p = true; } static_target_type = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (dyn_range_type), addr_stack, 0); - static_range_type = create_range_type (copy_type (dyn_range_type), - static_target_type, - &low_bound, &high_bound); - TYPE_RANGE_DATA (static_range_type)->flag_bound_evaluated = 1; + LONGEST bias = dyn_range_type->bounds ()->bias; + static_range_type = create_range_type_with_stride + (copy_type (dyn_range_type), static_target_type, + &low_bound, &high_bound, bias, &stride, byte_stride_p); + static_range_type->bounds ()->flag_bound_evaluated = 1; return static_range_type; } -/* Resolves dynamic bound values of an array type TYPE to static ones. - ADDR_STACK is a stack of struct property_addr_info to be used - if needed during the dynamic resolution. */ +/* 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. */ static struct type * -resolve_dynamic_array (struct type *type, - struct property_addr_info *addr_stack) +resolve_dynamic_array_or_string (struct type *type, + struct property_addr_info *addr_stack) { CORE_ADDR value; struct type *elt_type; @@ -2031,45 +2165,40 @@ resolve_dynamic_array (struct type *type, struct dynamic_prop *prop; unsigned int bit_stride = 0; - gdb_assert (TYPE_CODE (type) == TYPE_CODE_ARRAY); + /* 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); elt_type = type; - range_type = check_typedef (TYPE_INDEX_TYPE (elt_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. */ prop = TYPE_ALLOCATED_PROP (type); if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) - { - TYPE_DYN_PROP_ADDR (prop) = value; - TYPE_DYN_PROP_KIND (prop) = PROP_CONST; - } + prop->set_const_val (value); + prop = TYPE_ASSOCIATED_PROP (type); if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) - { - TYPE_DYN_PROP_ADDR (prop) = value; - TYPE_DYN_PROP_KIND (prop) = PROP_CONST; - } + prop->set_const_val (value); ary_dim = check_typedef (TYPE_TARGET_TYPE (elt_type)); - if (ary_dim != NULL && TYPE_CODE (ary_dim) == TYPE_CODE_ARRAY) - elt_type = resolve_dynamic_array (ary_dim, addr_stack); + if (ary_dim != NULL && ary_dim->code () == TYPE_CODE_ARRAY) + elt_type = resolve_dynamic_array_or_string (ary_dim, addr_stack); else elt_type = TYPE_TARGET_TYPE (type); - prop = get_dyn_prop (DYN_PROP_BYTE_STRIDE, type); + prop = type->dyn_prop (DYN_PROP_BYTE_STRIDE); if (prop != NULL) { - int prop_eval_ok - = dwarf2_evaluate_property (prop, NULL, addr_stack, &value); - - if (prop_eval_ok) + if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) { - remove_dyn_prop (DYN_PROP_BYTE_STRIDE, type); + type->remove_dyn_prop (DYN_PROP_BYTE_STRIDE); bit_stride = (unsigned int) (value * 8); } else @@ -2078,7 +2207,7 @@ resolve_dynamic_array (struct type *type, if the DWARF info is not correct. Issue a warning, and assume no byte/bit stride (leave bit_stride = 0). */ warning (_("cannot determine array stride for type %s"), - TYPE_NAME (type) ? TYPE_NAME (type) : ""); + type->name () ? type->name () : ""); } } else @@ -2100,34 +2229,193 @@ resolve_dynamic_union (struct type *type, int i; unsigned int max_len = 0; - gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION); + gdb_assert (type->code () == TYPE_CODE_UNION); resolved_type = copy_type (type); - TYPE_FIELDS (resolved_type) - = (struct field *) TYPE_ALLOC (resolved_type, - TYPE_NFIELDS (resolved_type) - * sizeof (struct field)); - memcpy (TYPE_FIELDS (resolved_type), - TYPE_FIELDS (type), - TYPE_NFIELDS (resolved_type) * sizeof (struct field)); - for (i = 0; i < TYPE_NFIELDS (resolved_type); ++i) + resolved_type->set_fields + ((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)); + for (i = 0; i < resolved_type->num_fields (); ++i) { struct type *t; - if (field_is_static (&TYPE_FIELD (type, i))) + if (field_is_static (&type->field (i))) continue; - t = resolve_dynamic_type_internal (TYPE_FIELD_TYPE (resolved_type, i), + t = resolve_dynamic_type_internal (resolved_type->field (i).type (), addr_stack, 0); - TYPE_FIELD_TYPE (resolved_type, i) = t; - if (TYPE_LENGTH (t) > max_len) - max_len = TYPE_LENGTH (t); + resolved_type->field (i).set_type (t); + + struct type *real_type = check_typedef (t); + if (TYPE_LENGTH (real_type) > max_len) + max_len = TYPE_LENGTH (real_type); } TYPE_LENGTH (resolved_type) = max_len; return resolved_type; } +/* See gdbtypes.h. */ + +bool +variant::matches (ULONGEST value, bool is_unsigned) const +{ + for (const discriminant_range &range : discriminants) + if (range.contains (value, is_unsigned)) + return true; + return false; +} + +static void +compute_variant_fields_inner (struct type *type, + struct property_addr_info *addr_stack, + const variant_part &part, + std::vector &flags); + +/* A helper function to determine which variant fields will be active. + This handles both the variant's direct fields, and any variant + parts embedded in this variant. TYPE is the type we're examining. + ADDR_STACK holds information about the concrete object. VARIANT is + the current variant to be handled. FLAGS is where the results are + stored -- this function sets the Nth element in FLAGS if the + corresponding field is enabled. ENABLED is whether this variant is + enabled or not. */ + +static void +compute_variant_fields_recurse (struct type *type, + struct property_addr_info *addr_stack, + const variant &variant, + std::vector &flags, + bool enabled) +{ + for (int field = variant.first_field; field < variant.last_field; ++field) + flags[field] = enabled; + + for (const variant_part &new_part : variant.parts) + { + if (enabled) + compute_variant_fields_inner (type, addr_stack, new_part, flags); + else + { + for (const auto &sub_variant : new_part.variants) + compute_variant_fields_recurse (type, addr_stack, sub_variant, + flags, enabled); + } + } +} + +/* A helper function to determine which variant fields will be active. + This evaluates the discriminant, decides which variant (if any) is + active, and then updates FLAGS to reflect which fields should be + available. TYPE is the type we're examining. ADDR_STACK holds + information about the concrete object. VARIANT is the current + variant to be handled. FLAGS is where the results are stored -- + this function sets the Nth element in FLAGS if the corresponding + field is enabled. */ + +static void +compute_variant_fields_inner (struct type *type, + struct property_addr_info *addr_stack, + const variant_part &part, + std::vector &flags) +{ + /* Evaluate the discriminant. */ + gdb::optional discr_value; + if (part.discriminant_index != -1) + { + int idx = part.discriminant_index; + + if (TYPE_FIELD_LOC_KIND (type, idx) != FIELD_LOC_KIND_BITPOS) + error (_("Cannot determine struct field location" + " (invalid location kind)")); + + if (addr_stack->valaddr.data () != NULL) + discr_value = unpack_field_as_long (type, addr_stack->valaddr.data (), + idx); + else + { + CORE_ADDR addr = (addr_stack->addr + + (TYPE_FIELD_BITPOS (type, idx) + / TARGET_CHAR_BIT)); + + LONGEST bitsize = TYPE_FIELD_BITSIZE (type, idx); + LONGEST size = bitsize / 8; + if (size == 0) + size = TYPE_LENGTH (type->field (idx).type ()); + + gdb_byte bits[sizeof (ULONGEST)]; + read_memory (addr, bits, size); + + LONGEST bitpos = (TYPE_FIELD_BITPOS (type, idx) + % TARGET_CHAR_BIT); + + discr_value = unpack_bits_as_long (type->field (idx).type (), + bits, bitpos, bitsize); + } + } + + /* Go through each variant and see which applies. */ + const variant *default_variant = nullptr; + const variant *applied_variant = nullptr; + for (const auto &variant : part.variants) + { + if (variant.is_default ()) + default_variant = &variant; + else if (discr_value.has_value () + && variant.matches (*discr_value, part.is_unsigned)) + { + applied_variant = &variant; + break; + } + } + if (applied_variant == nullptr) + applied_variant = default_variant; + + for (const auto &variant : part.variants) + compute_variant_fields_recurse (type, addr_stack, variant, + flags, applied_variant == &variant); +} + +/* Determine which variant fields are available in TYPE. The enabled + fields are stored in RESOLVED_TYPE. ADDR_STACK holds information + about the concrete object. PARTS describes the top-level variant + parts for this type. */ + +static void +compute_variant_fields (struct type *type, + struct type *resolved_type, + struct property_addr_info *addr_stack, + const gdb::array_view &parts) +{ + /* Assume all fields are included by default. */ + std::vector flags (resolved_type->num_fields (), true); + + /* Now disable fields based on the variants that control them. */ + for (const auto &part : parts) + compute_variant_fields_inner (type, addr_stack, part, flags); + + resolved_type->set_num_fields + (std::count (flags.begin (), flags.end (), true)); + resolved_type->set_fields + ((struct field *) + TYPE_ALLOC (resolved_type, + resolved_type->num_fields () * sizeof (struct field))); + + int out = 0; + for (int i = 0; i < type->num_fields (); ++i) + { + if (!flags[i]) + continue; + + resolved_type->field (out) = type->field (i); + ++out; + } +} + /* Resolve dynamic bounds of members of the struct TYPE to static bounds. ADDR_STACK is a stack of struct property_addr_info to be used if needed during the dynamic resolution. */ @@ -2140,25 +2428,56 @@ resolve_dynamic_struct (struct type *type, int i; unsigned resolved_type_bit_length = 0; - gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT); - gdb_assert (TYPE_NFIELDS (type) > 0); + gdb_assert (type->code () == TYPE_CODE_STRUCT); + gdb_assert (type->num_fields () > 0); resolved_type = copy_type (type); - TYPE_FIELDS (resolved_type) - = (struct field *) TYPE_ALLOC (resolved_type, - TYPE_NFIELDS (resolved_type) - * sizeof (struct field)); - memcpy (TYPE_FIELDS (resolved_type), - TYPE_FIELDS (type), - TYPE_NFIELDS (resolved_type) * sizeof (struct field)); - for (i = 0; i < TYPE_NFIELDS (resolved_type); ++i) + + dynamic_prop *variant_prop = resolved_type->dyn_prop (DYN_PROP_VARIANT_PARTS); + if (variant_prop != nullptr && variant_prop->kind () == PROP_VARIANT_PARTS) + { + compute_variant_fields (type, resolved_type, addr_stack, + *variant_prop->variant_parts ()); + /* We want to leave the property attached, so that the Rust code + can tell whether the type was originally an enum. */ + variant_prop->set_original_type (type); + } + else + { + resolved_type->set_fields + ((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)); + } + + for (i = 0; i < resolved_type->num_fields (); ++i) { unsigned new_bit_length; struct property_addr_info pinfo; - if (field_is_static (&TYPE_FIELD (type, i))) + if (field_is_static (&resolved_type->field (i))) continue; + if (TYPE_FIELD_LOC_KIND (resolved_type, i) == 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); + + 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)); + } + /* As we know this field is not a static field, the field's field_loc_kind should be FIELD_LOC_KIND_BITPOS. Verify this is the case, but only trigger a simple error rather @@ -2166,20 +2485,20 @@ 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 (type, i) != FIELD_LOC_KIND_BITPOS) + if (TYPE_FIELD_LOC_KIND (resolved_type, i) != FIELD_LOC_KIND_BITPOS) error (_("Cannot determine struct field location" " (invalid location kind)")); - pinfo.type = check_typedef (TYPE_FIELD_TYPE (type, i)); + pinfo.type = check_typedef (resolved_type->field (i).type ()); pinfo.valaddr = addr_stack->valaddr; pinfo.addr = (addr_stack->addr + (TYPE_FIELD_BITPOS (resolved_type, i) / TARGET_CHAR_BIT)); pinfo.next = addr_stack; - TYPE_FIELD_TYPE (resolved_type, i) - = resolve_dynamic_type_internal (TYPE_FIELD_TYPE (resolved_type, i), - &pinfo, 0); + 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) == FIELD_LOC_KIND_BITPOS); @@ -2187,8 +2506,12 @@ resolve_dynamic_struct (struct type *type, if (TYPE_FIELD_BITSIZE (resolved_type, i) != 0) new_bit_length += TYPE_FIELD_BITSIZE (resolved_type, i); else - new_bit_length += (TYPE_LENGTH (TYPE_FIELD_TYPE (resolved_type, i)) - * TARGET_CHAR_BIT); + { + struct type *real_type + = check_typedef (resolved_type->field (i).type ()); + + new_bit_length += (TYPE_LENGTH (real_type) * TARGET_CHAR_BIT); + } /* Normally, we would use the position and size of the last field to determine the size of the enclosing structure. But GCC seems @@ -2223,14 +2546,20 @@ resolve_dynamic_type_internal (struct type *type, int top_level) { struct type *real_type = check_typedef (type); - struct type *resolved_type = type; + struct type *resolved_type = nullptr; struct dynamic_prop *prop; CORE_ADDR value; if (!is_dynamic_type_internal (real_type, top_level)) return type; - if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) + gdb::optional type_length; + prop = TYPE_DYNAMIC_LENGTH (type); + if (prop != NULL + && dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) + type_length = value; + + if (type->code () == TYPE_CODE_TYPEDEF) { resolved_type = copy_type (type); TYPE_TARGET_TYPE (resolved_type) @@ -2242,16 +2571,17 @@ resolve_dynamic_type_internal (struct type *type, /* Before trying to resolve TYPE, make sure it is not a stub. */ type = real_type; - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_REF: { struct property_addr_info pinfo; pinfo.type = check_typedef (TYPE_TARGET_TYPE (type)); - pinfo.valaddr = NULL; - if (addr_stack->valaddr != NULL) - pinfo.addr = extract_typed_address (addr_stack->valaddr, type); + pinfo.valaddr = {}; + if (addr_stack->valaddr.data () != NULL) + pinfo.addr = extract_typed_address (addr_stack->valaddr.data (), + type); else pinfo.addr = read_memory_typed_address (addr_stack->addr, type); pinfo.next = addr_stack; @@ -2263,8 +2593,11 @@ resolve_dynamic_type_internal (struct type *type, break; } + case TYPE_CODE_STRING: + /* Strings are very much like an array of characters, and can be + treated as one here. */ case TYPE_CODE_ARRAY: - resolved_type = resolve_dynamic_array (type, addr_stack); + resolved_type = resolve_dynamic_array_or_string (type, addr_stack); break; case TYPE_CODE_RANGE: @@ -2281,14 +2614,20 @@ resolve_dynamic_type_internal (struct type *type, } } + if (resolved_type == nullptr) + return type; + + if (type_length.has_value ()) + { + TYPE_LENGTH (resolved_type) = *type_length; + resolved_type->remove_dyn_prop (DYN_PROP_BYTE_SIZE); + } + /* Resolve data_location attribute. */ prop = TYPE_DATA_LOCATION (resolved_type); if (prop != NULL && dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) - { - TYPE_DYN_PROP_ADDR (prop) = value; - TYPE_DYN_PROP_KIND (prop) = PROP_CONST; - } + prop->set_const_val (value); return resolved_type; } @@ -2296,7 +2635,8 @@ resolve_dynamic_type_internal (struct type *type, /* See gdbtypes.h */ struct type * -resolve_dynamic_type (struct type *type, const gdb_byte *valaddr, +resolve_dynamic_type (struct type *type, + gdb::array_view valaddr, CORE_ADDR addr) { struct property_addr_info pinfo @@ -2307,10 +2647,10 @@ resolve_dynamic_type (struct type *type, const gdb_byte *valaddr, /* See gdbtypes.h */ -struct dynamic_prop * -get_dyn_prop (enum dynamic_prop_node_kind prop_kind, const struct type *type) +dynamic_prop * +type::dyn_prop (dynamic_prop_node_kind prop_kind) const { - struct dynamic_prop_list *node = TYPE_DYN_PROP_LIST (type); + dynamic_prop_list *node = this->main_type->dyn_prop_list; while (node != NULL) { @@ -2324,43 +2664,41 @@ get_dyn_prop (enum dynamic_prop_node_kind prop_kind, const struct type *type) /* See gdbtypes.h */ void -add_dyn_prop (enum dynamic_prop_node_kind prop_kind, struct dynamic_prop prop, - struct type *type) +type::add_dyn_prop (dynamic_prop_node_kind prop_kind, dynamic_prop prop) { struct dynamic_prop_list *temp; - gdb_assert (TYPE_OBJFILE_OWNED (type)); + gdb_assert (TYPE_OBJFILE_OWNED (this)); - temp = XOBNEW (&TYPE_OBJFILE (type)->objfile_obstack, + temp = XOBNEW (&TYPE_OBJFILE (this)->objfile_obstack, struct dynamic_prop_list); temp->prop_kind = prop_kind; temp->prop = prop; - temp->next = TYPE_DYN_PROP_LIST (type); + temp->next = this->main_type->dyn_prop_list; - TYPE_DYN_PROP_LIST (type) = temp; + this->main_type->dyn_prop_list = temp; } -/* Remove dynamic property from TYPE in case it exists. */ +/* See gdbtypes.h. */ void -remove_dyn_prop (enum dynamic_prop_node_kind prop_kind, - struct type *type) +type::remove_dyn_prop (dynamic_prop_node_kind kind) { struct dynamic_prop_list *prev_node, *curr_node; - curr_node = TYPE_DYN_PROP_LIST (type); + curr_node = this->main_type->dyn_prop_list; prev_node = NULL; while (NULL != curr_node) { - if (curr_node->prop_kind == prop_kind) + if (curr_node->prop_kind == kind) { /* Update the linked list but don't free anything. The property was allocated on objstack and it is not known if we are on top of it. Nevertheless, everything is released when the complete objstack is freed. */ if (NULL == prev_node) - TYPE_DYN_PROP_LIST (type) = curr_node->next; + this->main_type->dyn_prop_list = curr_node->next; else prev_node->next = curr_node->next; @@ -2404,13 +2742,14 @@ 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 (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) + /* 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)) { @@ -2422,7 +2761,7 @@ check_typedef (struct type *type) if (currently_reading_symtab) return make_qualified_type (type, instance_flags, NULL); - name = TYPE_NAME (type); + name = type->name (); /* FIXME: shouldn't we look in STRUCT_DOMAIN and/or VAR_DOMAIN as appropriate? */ if (name == NULL) @@ -2450,10 +2789,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) @@ -2475,7 +2817,7 @@ check_typedef (struct type *type) && opaque_type_resolution && !currently_reading_symtab) { - const char *name = TYPE_NAME (type); + const char *name = type->name (); struct type *newtype; if (name == NULL) @@ -2498,18 +2840,16 @@ check_typedef (struct type *type) 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); + type = make_qualified_type (newtype, type->instance_flags (), type); else type = newtype; } } /* Otherwise, rely on the stub flag being set for opaque/stubbed types. */ - else if (TYPE_STUB (type) && !currently_reading_symtab) + else if (type->is_stub () && !currently_reading_symtab) { - const char *name = TYPE_NAME (type); + const char *name = type->name (); /* FIXME: shouldn't we look in STRUCT_DOMAIN and/or VAR_DOMAIN as appropriate? */ struct symbol *sym; @@ -2525,28 +2865,30 @@ check_typedef (struct 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 (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type)) - type = make_qualified_type (SYMBOL_TYPE (sym), - TYPE_INSTANCE_FLAGS (type), - type); + if (TYPE_OBJFILE (SYMBOL_TYPE (sym)) == TYPE_OBJFILE (type)) + type = make_qualified_type (SYMBOL_TYPE (sym), + type->instance_flags (), type); else type = SYMBOL_TYPE (sym); } } - if (TYPE_TARGET_STUB (type)) + if (type->target_is_stub ()) { struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type)); - if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type)) + if (target_type->is_stub () || target_type->target_is_stub ()) { /* Nothing we can do. */ } - else if (TYPE_CODE (type) == TYPE_CODE_RANGE) + else if (type->code () == TYPE_CODE_RANGE) { TYPE_LENGTH (type) = TYPE_LENGTH (target_type); - TYPE_TARGET_STUB (type) = 0; + type->set_target_is_stub (false); } + else if (type->code () == TYPE_CODE_ARRAY + && update_static_array_size (type)) + type->set_target_is_stub (false); } type = make_qualified_type (type, instance_flags, NULL); @@ -2575,7 +2917,7 @@ safe_parse_type (struct gdbarch *gdbarch, char *p, int length) { type = parse_and_eval_type (p, length); } - catch (const gdb_exception_RETURN_MASK_ERROR &except) + catch (const gdb_exception_error &except) { type = builtin_type (gdbarch)->builtin_void; } @@ -2656,7 +2998,7 @@ check_stub_method (struct type *type, int method_id, int signature_id) argcount = 0; else { - argtypes[0].type = lookup_pointer_type (type); + argtypes[0].set_type (lookup_pointer_type (type)); argcount = 1; } @@ -2672,8 +3014,8 @@ check_stub_method (struct type *type, int method_id, int signature_id) if (strncmp (argtypetext, "...", p - argtypetext) != 0 && strncmp (argtypetext, "void", p - argtypetext) != 0) { - argtypes[argcount].type = - safe_parse_type (gdbarch, argtypetext, p - argtypetext); + argtypes[argcount].set_type + (safe_parse_type (gdbarch, argtypetext, p - argtypetext)); argcount += 1; } argtypetext = p + 1; @@ -2700,7 +3042,7 @@ check_stub_method (struct type *type, int method_id, int signature_id) We want a method (TYPE_CODE_METHOD). */ smash_to_method_type (mtype, type, TYPE_TARGET_TYPE (mtype), argtypes, argcount, p[-2] == '.'); - TYPE_STUB (mtype) = 0; + mtype->set_is_stub (false); TYPE_FN_FIELD_STUB (f, signature_id) = 0; xfree (demangled_name); @@ -2727,7 +3069,7 @@ check_stub_method_group (struct type *type, int method_id) } } -/* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */ +/* Ensure it is in .rodata (if available) by working around GCC PR 44690. */ const struct cplus_struct_type cplus_struct_default = { }; void @@ -2766,7 +3108,7 @@ allocate_gnat_aux_type (struct type *type) static void set_type_code (struct type *type, enum type_code code) { - TYPE_CODE (type) = code; + type->set_code (code); switch (code) { @@ -2808,7 +3150,7 @@ verify_floatformat (int bit, const struct floatformat *floatformat) const struct floatformat * floatformat_from_type (const struct type *type) { - gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT); + gdb_assert (type->code () == TYPE_CODE_FLT); gdb_assert (TYPE_FLOATFORMAT (type)); return TYPE_FLOATFORMAT (type); } @@ -2829,7 +3171,7 @@ init_type (struct objfile *objfile, enum type_code code, int bit, set_type_code (type, code); gdb_assert ((bit % TARGET_CHAR_BIT) == 0); TYPE_LENGTH (type) = bit / TARGET_CHAR_BIT; - TYPE_NAME (type) = name; + type->set_name (name); return type; } @@ -2856,7 +3198,11 @@ init_integer_type (struct objfile *objfile, t = init_type (objfile, TYPE_CODE_INT, bit, name); if (unsigned_p) - TYPE_UNSIGNED (t) = 1; + 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; } @@ -2873,7 +3219,7 @@ init_character_type (struct objfile *objfile, t = init_type (objfile, TYPE_CODE_CHAR, bit, name); if (unsigned_p) - TYPE_UNSIGNED (t) = 1; + t->set_is_unsigned (true); return t; } @@ -2890,7 +3236,11 @@ init_boolean_type (struct objfile *objfile, t = init_type (objfile, TYPE_CODE_BOOL, bit, name); if (unsigned_p) - TYPE_UNSIGNED (t) = 1; + 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; } @@ -2898,15 +3248,22 @@ init_boolean_type (struct objfile *objfile, /* Allocate a TYPE_CODE_FLT type structure associated with OBJFILE. BIT is the type size in bits; if BIT equals -1, the size is determined by the floatformat. NAME is the type name. Set the - TYPE_FLOATFORMAT from FLOATFORMATS. */ + TYPE_FLOATFORMAT from FLOATFORMATS. BYTE_ORDER is the byte order + to use. If it is BFD_ENDIAN_UNKNOWN (the default), then the byte + order of the objfile's architecture is used. */ struct type * init_float_type (struct objfile *objfile, int bit, const char *name, - const struct floatformat **floatformats) + const struct floatformat **floatformats, + enum bfd_endian byte_order) { - struct gdbarch *gdbarch = get_objfile_arch (objfile); - const struct floatformat *fmt = floatformats[gdbarch_byte_order (gdbarch)]; + if (byte_order == BFD_ENDIAN_UNKNOWN) + { + struct gdbarch *gdbarch = objfile->arch (); + byte_order = gdbarch_byte_order (gdbarch); + } + const struct floatformat *fmt = floatformats[byte_order]; struct type *t; bit = verify_floatformat (bit, fmt); @@ -2928,19 +3285,40 @@ init_decfloat_type (struct objfile *objfile, int bit, const char *name) return t; } -/* Allocate a TYPE_CODE_COMPLEX type structure associated with OBJFILE. - NAME is the type name. TARGET_TYPE is the component float type. */ +/* Allocate a TYPE_CODE_COMPLEX type structure. NAME is the type + name. TARGET_TYPE is the component type. */ struct type * -init_complex_type (struct objfile *objfile, - const char *name, struct type *target_type) +init_complex_type (const char *name, struct type *target_type) { struct type *t; - t = init_type (objfile, TYPE_CODE_COMPLEX, - 2 * TYPE_LENGTH (target_type) * TARGET_CHAR_BIT, name); - TYPE_TARGET_TYPE (t) = target_type; - return t; + gdb_assert (target_type->code () == TYPE_CODE_INT + || target_type->code () == TYPE_CODE_FLT); + + if (TYPE_MAIN_TYPE (target_type)->flds_bnds.complex_type == nullptr) + { + if (name == nullptr && target_type->name () != nullptr) + { + char *new_name + = (char *) TYPE_ALLOC (target_type, + strlen (target_type->name ()) + + strlen ("_Complex ") + 1); + strcpy (new_name, "_Complex "); + strcat (new_name, target_type->name ()); + name = new_name; + } + + t = alloc_type_copy (target_type); + set_type_code (t, TYPE_CODE_COMPLEX); + TYPE_LENGTH (t) = 2 * TYPE_LENGTH (target_type); + t->set_name (name); + + TYPE_TARGET_TYPE (t) = target_type; + TYPE_MAIN_TYPE (target_type)->flds_bnds.complex_type = t; + } + + return TYPE_MAIN_TYPE (target_type)->flds_bnds.complex_type; } /* Allocate a TYPE_CODE_PTR type structure associated with OBJFILE. @@ -2956,7 +3334,7 @@ init_pointer_type (struct objfile *objfile, t = init_type (objfile, TYPE_CODE_PTR, bit, name); TYPE_TARGET_TYPE (t) = target_type; - TYPE_UNSIGNED (t) = 1; + t->set_is_unsigned (true); return t; } @@ -2986,7 +3364,7 @@ type_align (struct type *type) if (align != 0) return align; - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_PTR: case TYPE_CODE_FUNC: @@ -3014,17 +3392,13 @@ type_align (struct type *type) case TYPE_CODE_STRUCT: case TYPE_CODE_UNION: { - if (TYPE_NFIELDS (type) == 0) + int number_of_non_static_fields = 0; + for (unsigned i = 0; i < type->num_fields (); ++i) { - /* An empty struct has alignment 1. */ - align = 1; - break; - } - for (unsigned i = 0; i < TYPE_NFIELDS (type); ++i) - { - if (!field_is_static (&TYPE_FIELD (type, i))) + if (!field_is_static (&type->field (i))) { - ULONGEST f_align = type_align (TYPE_FIELD_TYPE (type, i)); + number_of_non_static_fields++; + ULONGEST f_align = type_align (type->field (i).type ()); if (f_align == 0) { /* Don't pretend we know something we don't. */ @@ -3035,6 +3409,10 @@ type_align (struct type *type) align = f_align; } } + /* A struct with no fields, or with only static fields has an + alignment of 1. */ + if (number_of_non_static_fields == 0) + align = 1; } break; @@ -3096,8 +3474,8 @@ can_dereference (struct type *t) t = check_typedef (t); return (t != NULL - && TYPE_CODE (t) == TYPE_CODE_PTR - && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID); + && t->code () == TYPE_CODE_PTR + && TYPE_TARGET_TYPE (t)->code () != TYPE_CODE_VOID); } int @@ -3106,12 +3484,12 @@ is_integral_type (struct type *t) t = check_typedef (t); return ((t != NULL) - && ((TYPE_CODE (t) == TYPE_CODE_INT) - || (TYPE_CODE (t) == TYPE_CODE_ENUM) - || (TYPE_CODE (t) == TYPE_CODE_FLAGS) - || (TYPE_CODE (t) == TYPE_CODE_CHAR) - || (TYPE_CODE (t) == TYPE_CODE_RANGE) - || (TYPE_CODE (t) == TYPE_CODE_BOOL))); + && ((t->code () == TYPE_CODE_INT) + || (t->code () == TYPE_CODE_ENUM) + || (t->code () == TYPE_CODE_FLAGS) + || (t->code () == TYPE_CODE_CHAR) + || (t->code () == TYPE_CODE_RANGE) + || (t->code () == TYPE_CODE_BOOL))); } int @@ -3120,8 +3498,8 @@ is_floating_type (struct type *t) t = check_typedef (t); return ((t != NULL) - && ((TYPE_CODE (t) == TYPE_CODE_FLT) - || (TYPE_CODE (t) == TYPE_CODE_DECFLOAT))); + && ((t->code () == TYPE_CODE_FLT) + || (t->code () == TYPE_CODE_DECFLOAT))); } /* Return true if TYPE is scalar. */ @@ -3131,7 +3509,7 @@ is_scalar_type (struct type *type) { type = check_typedef (type); - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_ARRAY: case TYPE_CODE_STRUCT: @@ -3156,27 +3534,27 @@ is_scalar_type_recursive (struct type *t) if (is_scalar_type (t)) return 1; /* Are we dealing with an array or string of known dimensions? */ - else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY - || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1 - && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE) + else if ((t->code () == TYPE_CODE_ARRAY + || t->code () == TYPE_CODE_STRING) && t->num_fields () == 1 + && t->index_type ()->code () == TYPE_CODE_RANGE) { LONGEST low_bound, high_bound; struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t)); - get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound); + get_discrete_bounds (t->index_type (), &low_bound, &high_bound); return high_bound == low_bound && is_scalar_type_recursive (elt_type); } /* Are we dealing with a struct with one element? */ - else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1) - return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0)); - else if (TYPE_CODE (t) == TYPE_CODE_UNION) + else if (t->code () == TYPE_CODE_STRUCT && t->num_fields () == 1) + return is_scalar_type_recursive (t->field (0).type ()); + else if (t->code () == TYPE_CODE_UNION) { - int i, n = TYPE_NFIELDS (t); + int i, n = t->num_fields (); /* If all elements of the union are scalar, then the union is scalar. */ for (i = 0; i < n; i++) - if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i))) + if (!is_scalar_type_recursive (t->field (i).type ())) return 0; return 1; @@ -3190,8 +3568,8 @@ is_scalar_type_recursive (struct type *t) int class_or_union_p (const struct type *t) { - return (TYPE_CODE (t) == TYPE_CODE_STRUCT - || TYPE_CODE (t) == TYPE_CODE_UNION); + return (t->code () == TYPE_CODE_STRUCT + || t->code () == TYPE_CODE_UNION); } /* A helper function which returns true if types A and B represent the @@ -3202,8 +3580,8 @@ int class_types_same_p (const struct type *a, const struct type *b) { return (TYPE_MAIN_TYPE (a) == TYPE_MAIN_TYPE (b) - || (TYPE_NAME (a) && TYPE_NAME (b) - && !strcmp (TYPE_NAME (a), TYPE_NAME (b)))); + || (a->name () && b->name () + && !strcmp (a->name (), b->name ()))); } /* If BASE is an ancestor of DCLASS return the distance between them. @@ -3338,6 +3716,26 @@ is_unique_ancestor (struct type *base, struct value *val) value_address (val), val) == 1; } +/* See gdbtypes.h. */ + +enum bfd_endian +type_byte_order (const struct type *type) +{ + bfd_endian byteorder = gdbarch_byte_order (get_type_arch (type)); + if (type->endianity_is_not_default ()) + { + if (byteorder == BFD_ENDIAN_BIG) + return BFD_ENDIAN_LITTLE; + else + { + gdb_assert (byteorder == BFD_ENDIAN_LITTLE); + return BFD_ENDIAN_BIG; + } + } + + return byteorder; +} + /* Overload resolution. */ @@ -3513,21 +3911,21 @@ types_equal (struct type *a, struct type *b) return true; /* Resolve typedefs */ - if (TYPE_CODE (a) == TYPE_CODE_TYPEDEF) + if (a->code () == TYPE_CODE_TYPEDEF) a = check_typedef (a); - if (TYPE_CODE (b) == TYPE_CODE_TYPEDEF) + if (b->code () == TYPE_CODE_TYPEDEF) b = check_typedef (b); /* If after resolving typedefs a and b are not of the same type code then they are not equal. */ - if (TYPE_CODE (a) != TYPE_CODE (b)) + if (a->code () != b->code ()) return false; /* If a and b are both pointers types or both reference types then they are equal of the same type iff the objects they refer to are of the same type. */ - if (TYPE_CODE (a) == TYPE_CODE_PTR - || TYPE_CODE (a) == TYPE_CODE_REF) + if (a->code () == TYPE_CODE_PTR + || a->code () == TYPE_CODE_REF) return types_equal (TYPE_TARGET_TYPE (a), TYPE_TARGET_TYPE (b)); @@ -3536,8 +3934,8 @@ types_equal (struct type *a, struct type *b) stubs. The types won't point to the same address, but they really are the same. */ - if (TYPE_NAME (a) && TYPE_NAME (b) - && strcmp (TYPE_NAME (a), TYPE_NAME (b)) == 0) + if (a->name () && b->name () + && strcmp (a->name (), b->name ()) == 0) return true; /* Check if identical after resolving typedefs. */ @@ -3546,18 +3944,18 @@ types_equal (struct type *a, struct type *b) /* Two function types are equal if their argument and return types are equal. */ - if (TYPE_CODE (a) == TYPE_CODE_FUNC) + if (a->code () == TYPE_CODE_FUNC) { int i; - if (TYPE_NFIELDS (a) != TYPE_NFIELDS (b)) + if (a->num_fields () != b->num_fields ()) return false; if (!types_equal (TYPE_TARGET_TYPE (a), TYPE_TARGET_TYPE (b))) return false; - for (i = 0; i < TYPE_NFIELDS (a); ++i) - if (!types_equal (TYPE_FIELD_TYPE (a, i), TYPE_FIELD_TYPE (b, i))) + for (i = 0; i < a->num_fields (); ++i) + if (!types_equal (a->field (i).type (), b->field (i).type ())) return false; return true; @@ -3606,35 +4004,36 @@ check_types_equal (struct type *type1, struct type *type2, if (type1 == type2) return true; - if (TYPE_CODE (type1) != TYPE_CODE (type2) + if (type1->code () != type2->code () || TYPE_LENGTH (type1) != TYPE_LENGTH (type2) - || TYPE_UNSIGNED (type1) != TYPE_UNSIGNED (type2) - || TYPE_NOSIGN (type1) != TYPE_NOSIGN (type2) - || TYPE_VARARGS (type1) != TYPE_VARARGS (type2) - || TYPE_VECTOR (type1) != TYPE_VECTOR (type2) + || type1->is_unsigned () != type2->is_unsigned () + || type1->has_no_signedness () != type2->has_no_signedness () + || type1->endianity_is_not_default () != type2->endianity_is_not_default () + || type1->has_varargs () != type2->has_varargs () + || type1->is_vector () != type2->is_vector () || TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2) - || TYPE_INSTANCE_FLAGS (type1) != TYPE_INSTANCE_FLAGS (type2) - || TYPE_NFIELDS (type1) != TYPE_NFIELDS (type2)) + || type1->instance_flags () != type2->instance_flags () + || type1->num_fields () != type2->num_fields ()) return false; - if (!compare_maybe_null_strings (TYPE_NAME (type1), TYPE_NAME (type2))) + if (!compare_maybe_null_strings (type1->name (), type2->name ())) return false; - if (!compare_maybe_null_strings (TYPE_NAME (type1), TYPE_NAME (type2))) + if (!compare_maybe_null_strings (type1->name (), type2->name ())) return false; - if (TYPE_CODE (type1) == TYPE_CODE_RANGE) + if (type1->code () == TYPE_CODE_RANGE) { - if (*TYPE_RANGE_DATA (type1) != *TYPE_RANGE_DATA (type2)) + if (*type1->bounds () != *type2->bounds ()) return false; } else { int i; - for (i = 0; i < TYPE_NFIELDS (type1); ++i) + for (i = 0; i < type1->num_fields (); ++i) { - const struct field *field1 = &TYPE_FIELD (type1, i); - const struct field *field2 = &TYPE_FIELD (type2, i); + const struct field *field1 = &type1->field (i); + const struct field *field2 = &type2->field (i); if (FIELD_ARTIFICIAL (*field1) != FIELD_ARTIFICIAL (*field2) || FIELD_BITSIZE (*field1) != FIELD_BITSIZE (*field2) @@ -3681,7 +4080,7 @@ check_types_equal (struct type *type1, struct type *type2, FIELD_LOC_KIND (*field1)); } - worklist->emplace_back (FIELD_TYPE (*field1), FIELD_TYPE (*field2)); + worklist->emplace_back (field1->type (), field2->type ()); } } @@ -3704,11 +4103,11 @@ check_types_equal (struct type *type1, struct type *type2, static bool check_types_worklist (std::vector *worklist, - struct bcache *cache) + gdb::bcache *cache) { while (!worklist->empty ()) { - int added; + bool added; struct type_equality_entry entry = std::move (worklist->back ()); worklist->pop_back (); @@ -3740,7 +4139,7 @@ types_deeply_equal (struct type *type1, struct type *type2) if (type1 == type2) return true; - struct bcache cache (nullptr, nullptr); + gdb::bcache cache; worklist.emplace_back (type1, type2); return check_types_worklist (&worklist, &cache); } @@ -3753,8 +4152,8 @@ type_not_allocated (const struct type *type) { struct dynamic_prop *prop = TYPE_ALLOCATED_PROP (type); - return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST - && !TYPE_DYN_PROP_ADDR (prop)); + return (prop != nullptr && prop->kind () == PROP_CONST + && prop->const_val () == 0); } /* Associated status of type TYPE. Return zero if type TYPE is associated. @@ -3765,8 +4164,8 @@ type_not_associated (const struct type *type) { struct dynamic_prop *prop = TYPE_ASSOCIATED_PROP (type); - return (prop && TYPE_DYN_PROP_KIND (prop) == PROP_CONST - && !TYPE_DYN_PROP_ADDR (prop)); + return (prop != nullptr && prop->kind () == PROP_CONST + && prop->const_val () == 0); } /* rank_one_type helper for when PARM's type code is TYPE_CODE_PTR. */ @@ -3776,13 +4175,13 @@ rank_one_type_parm_ptr (struct type *parm, struct type *arg, struct value *value { struct rank rank = {0,0}; - switch (TYPE_CODE (arg)) + switch (arg->code ()) { case TYPE_CODE_PTR: /* Allowed pointer conversions are: (a) pointer to void-pointer conversion. */ - if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID) + if (TYPE_TARGET_TYPE (parm)->code () == TYPE_CODE_VOID) return VOID_PTR_CONVERSION_BADNESS; /* (b) pointer to ancestor-pointer conversion. */ @@ -3814,7 +4213,7 @@ rank_one_type_parm_ptr (struct type *parm, struct type *arg, struct value *value case TYPE_CODE_FUNC: return rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL); case TYPE_CODE_INT: - if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT) + if (value != NULL && value_type (value)->code () == TYPE_CODE_INT) { if (value_as_long (value) == 0) { @@ -3845,7 +4244,7 @@ rank_one_type_parm_ptr (struct type *parm, struct type *arg, struct value *value static struct rank rank_one_type_parm_array (struct type *parm, struct type *arg, struct value *value) { - switch (TYPE_CODE (arg)) + switch (arg->code ()) { case TYPE_CODE_PTR: case TYPE_CODE_ARRAY: @@ -3861,7 +4260,7 @@ rank_one_type_parm_array (struct type *parm, struct type *arg, struct value *val static struct rank rank_one_type_parm_func (struct type *parm, struct type *arg, struct value *value) { - switch (TYPE_CODE (arg)) + switch (arg->code ()) { case TYPE_CODE_PTR: /* funcptr -> func */ return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL); @@ -3875,33 +4274,33 @@ rank_one_type_parm_func (struct type *parm, struct type *arg, struct value *valu static struct rank rank_one_type_parm_int (struct type *parm, struct type *arg, struct value *value) { - switch (TYPE_CODE (arg)) + switch (arg->code ()) { case TYPE_CODE_INT: if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm)) { /* Deal with signed, unsigned, and plain chars and signed and unsigned ints. */ - if (TYPE_NOSIGN (parm)) + if (parm->has_no_signedness ()) { /* This case only for character types. */ - if (TYPE_NOSIGN (arg)) + if (arg->has_no_signedness ()) return EXACT_MATCH_BADNESS; /* plain char -> plain char */ else /* signed/unsigned char -> plain char */ return INTEGER_CONVERSION_BADNESS; } - else if (TYPE_UNSIGNED (parm)) + else if (parm->is_unsigned ()) { - if (TYPE_UNSIGNED (arg)) + if (arg->is_unsigned ()) { /* unsigned int -> unsigned int, or unsigned long -> unsigned long */ - if (integer_types_same_name_p (TYPE_NAME (parm), - TYPE_NAME (arg))) + if (integer_types_same_name_p (parm->name (), + arg->name ())) return EXACT_MATCH_BADNESS; - else if (integer_types_same_name_p (TYPE_NAME (arg), + else if (integer_types_same_name_p (arg->name (), "int") - && integer_types_same_name_p (TYPE_NAME (parm), + && integer_types_same_name_p (parm->name (), "long")) /* unsigned int -> unsigned long */ return INTEGER_PROMOTION_BADNESS; @@ -3911,9 +4310,9 @@ rank_one_type_parm_int (struct type *parm, struct type *arg, struct value *value } else { - if (integer_types_same_name_p (TYPE_NAME (arg), + if (integer_types_same_name_p (arg->name (), "long") - && integer_types_same_name_p (TYPE_NAME (parm), + && integer_types_same_name_p (parm->name (), "int")) /* signed long -> unsigned int */ return INTEGER_CONVERSION_BADNESS; @@ -3922,14 +4321,14 @@ rank_one_type_parm_int (struct type *parm, struct type *arg, struct value *value return INTEGER_CONVERSION_BADNESS; } } - else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg)) + else if (!arg->has_no_signedness () && !arg->is_unsigned ()) { - if (integer_types_same_name_p (TYPE_NAME (parm), - TYPE_NAME (arg))) + if (integer_types_same_name_p (parm->name (), + arg->name ())) return EXACT_MATCH_BADNESS; - else if (integer_types_same_name_p (TYPE_NAME (arg), + else if (integer_types_same_name_p (arg->name (), "int") - && integer_types_same_name_p (TYPE_NAME (parm), + && integer_types_same_name_p (parm->name (), "long")) return INTEGER_PROMOTION_BADNESS; else @@ -3964,7 +4363,7 @@ rank_one_type_parm_int (struct type *parm, struct type *arg, struct value *value static struct rank rank_one_type_parm_enum (struct type *parm, struct type *arg, struct value *value) { - switch (TYPE_CODE (arg)) + switch (arg->code ()) { case TYPE_CODE_INT: case TYPE_CODE_CHAR: @@ -3986,7 +4385,7 @@ rank_one_type_parm_enum (struct type *parm, struct type *arg, struct value *valu static struct rank rank_one_type_parm_char (struct type *parm, struct type *arg, struct value *value) { - switch (TYPE_CODE (arg)) + switch (arg->code ()) { case TYPE_CODE_RANGE: case TYPE_CODE_BOOL: @@ -4005,21 +4404,21 @@ rank_one_type_parm_char (struct type *parm, struct type *arg, struct value *valu case TYPE_CODE_CHAR: /* Deal with signed, unsigned, and plain chars for C++ and with int cases falling through from previous case. */ - if (TYPE_NOSIGN (parm)) + if (parm->has_no_signedness ()) { - if (TYPE_NOSIGN (arg)) + if (arg->has_no_signedness ()) return EXACT_MATCH_BADNESS; else return INTEGER_CONVERSION_BADNESS; } - else if (TYPE_UNSIGNED (parm)) + else if (parm->is_unsigned ()) { - if (TYPE_UNSIGNED (arg)) + if (arg->is_unsigned ()) return EXACT_MATCH_BADNESS; else return INTEGER_PROMOTION_BADNESS; } - else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg)) + else if (!arg->has_no_signedness () && !arg->is_unsigned ()) return EXACT_MATCH_BADNESS; else return INTEGER_CONVERSION_BADNESS; @@ -4033,7 +4432,7 @@ rank_one_type_parm_char (struct type *parm, struct type *arg, struct value *valu static struct rank rank_one_type_parm_range (struct type *parm, struct type *arg, struct value *value) { - switch (TYPE_CODE (arg)) + switch (arg->code ()) { case TYPE_CODE_INT: case TYPE_CODE_CHAR: @@ -4053,7 +4452,7 @@ rank_one_type_parm_range (struct type *parm, struct type *arg, struct value *val static struct rank rank_one_type_parm_bool (struct type *parm, struct type *arg, struct value *value) { - switch (TYPE_CODE (arg)) + switch (arg->code ()) { /* n3290 draft, section 4.12.1 (conv.bool): @@ -4084,7 +4483,7 @@ rank_one_type_parm_bool (struct type *parm, struct type *arg, struct value *valu static struct rank rank_one_type_parm_float (struct type *parm, struct type *arg, struct value *value) { - switch (TYPE_CODE (arg)) + switch (arg->code ()) { case TYPE_CODE_FLT: if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm)) @@ -4109,7 +4508,7 @@ rank_one_type_parm_float (struct type *parm, struct type *arg, struct value *val static struct rank rank_one_type_parm_complex (struct type *parm, struct type *arg, struct value *value) { - switch (TYPE_CODE (arg)) + switch (arg->code ()) { /* Strictly not needed for C++, but... */ case TYPE_CODE_FLT: return FLOAT_PROMOTION_BADNESS; @@ -4127,7 +4526,7 @@ rank_one_type_parm_struct (struct type *parm, struct type *arg, struct value *va { struct rank rank = {0, 0}; - switch (TYPE_CODE (arg)) + switch (arg->code ()) { case TYPE_CODE_STRUCT: /* Check for derivation */ @@ -4145,12 +4544,12 @@ rank_one_type_parm_struct (struct type *parm, struct type *arg, struct value *va static struct rank rank_one_type_parm_set (struct type *parm, struct type *arg, struct value *value) { - switch (TYPE_CODE (arg)) + switch (arg->code ()) { /* Not in C++ */ case TYPE_CODE_SET: - return rank_one_type (TYPE_FIELD_TYPE (parm, 0), - TYPE_FIELD_TYPE (arg, 0), NULL); + return rank_one_type (parm->field (0).type (), + arg->field (0).type (), NULL); default: return INCOMPATIBLE_TYPE_BADNESS; } @@ -4173,9 +4572,9 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value) struct rank rank = {0,0}; /* Resolve typedefs */ - if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF) + if (parm->code () == TYPE_CODE_TYPEDEF) parm = check_typedef (parm); - if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF) + if (arg->code () == TYPE_CODE_TYPEDEF) arg = check_typedef (arg); if (TYPE_IS_REFERENCE (parm) && value != NULL) @@ -4184,7 +4583,7 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value) { /* Rvalues should preferably bind to rvalue references or const lvalue references. */ - if (TYPE_CODE (parm) == TYPE_CODE_RVALUE_REF) + if (parm->code () == TYPE_CODE_RVALUE_REF) rank.subrank = REFERENCE_CONVERSION_RVALUE; else if (TYPE_CONST (TYPE_TARGET_TYPE (parm))) rank.subrank = REFERENCE_CONVERSION_CONST_LVALUE; @@ -4194,12 +4593,9 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value) } else { - /* Lvalues should prefer lvalue overloads. */ - if (TYPE_CODE (parm) == TYPE_CODE_RVALUE_REF) - { - rank.subrank = REFERENCE_CONVERSION_RVALUE; - return sum_ranks (rank, REFERENCE_CONVERSION_BADNESS); - } + /* It's illegal to pass an lvalue as an rvalue. */ + if (parm->code () == TYPE_CODE_RVALUE_REF) + return INCOMPATIBLE_TYPE_BADNESS; } } @@ -4209,7 +4605,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 (TYPE_CODE (parm) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (parm)) + if (parm->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (parm)) { t1 = TYPE_TARGET_TYPE (parm); t2 = TYPE_TARGET_TYPE (arg); @@ -4230,20 +4626,20 @@ 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_CONVERSION_BADNESS)); + REFERENCE_SEE_THROUGH_BADNESS)); if (TYPE_IS_REFERENCE (parm)) return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL), - REFERENCE_CONVERSION_BADNESS)); + REFERENCE_SEE_THROUGH_BADNESS)); if (overload_debug) /* Debugging only. */ - fprintf_filtered (gdb_stderr, + fprintf_filtered (gdb_stderr, "------ Arg is %s [%d], parm is %s [%d]\n", - TYPE_NAME (arg), TYPE_CODE (arg), - TYPE_NAME (parm), TYPE_CODE (parm)); + arg->name (), arg->code (), + parm->name (), parm->code ()); /* x -> y means arg of type x being supplied for parameter of type y. */ - switch (TYPE_CODE (parm)) + switch (parm->code ()) { case TYPE_CODE_PTR: return rank_one_type_parm_ptr (parm, arg, value); @@ -4271,7 +4667,7 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value) return rank_one_type_parm_set (parm, arg, value); default: return INCOMPATIBLE_TYPE_BADNESS; - } /* switch (TYPE_CODE (arg)) */ + } /* switch (arg->code ()) */ } /* End of functions for overload resolution. */ @@ -4311,7 +4707,7 @@ print_args (struct field *args, int nargs, int spaces) { printfi_filtered (spaces, "[%d] name '%s'\n", i, args[i].name != NULL ? args[i].name : ""); - recursive_dump_type (args[i].type, spaces + 2); + recursive_dump_type (args[i].type (), spaces + 2); } } } @@ -4371,7 +4767,7 @@ dump_fn_fieldlists (struct type *type, int spaces) gdb_stdout); printf_filtered ("\n"); print_args (TYPE_FN_FIELD_ARGS (f, overload_idx), - TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (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), @@ -4388,6 +4784,10 @@ dump_fn_fieldlists (struct type *type, int spaces) 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)); } @@ -4420,30 +4820,30 @@ print_cplus_stuff (struct type *type, int spaces) TYPE_N_BASECLASSES (type)); puts_filtered ("\n"); } - if (TYPE_NFIELDS (type) > 0) + if (type->num_fields () > 0) { if (TYPE_FIELD_PRIVATE_BITS (type) != NULL) { printfi_filtered (spaces, "private_field_bits (%d bits at *", - TYPE_NFIELDS (type)); + type->num_fields ()); gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type), gdb_stdout); printf_filtered (")"); print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type), - TYPE_NFIELDS (type)); + type->num_fields ()); puts_filtered ("\n"); } if (TYPE_FIELD_PROTECTED_BITS (type) != NULL) { printfi_filtered (spaces, "protected_field_bits (%d bits at *", - TYPE_NFIELDS (type)); + type->num_fields ()); gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type), gdb_stdout); printf_filtered (")"); print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type), - TYPE_NFIELDS (type)); + type->num_fields ()); puts_filtered ("\n"); } } @@ -4451,6 +4851,9 @@ 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)); } /* Print the contents of the TYPE's type_specific union, assuming that @@ -4472,6 +4875,29 @@ print_gnat_stuff (struct type *type, int spaces) static struct obstack dont_print_type_obstack; +/* Print the dynamic_prop PROP. */ + +static void +dump_dynamic_prop (dynamic_prop const& prop) +{ + switch (prop.kind ()) + { + case PROP_CONST: + printf_filtered ("%s", plongest (prop.const_val ())); + break; + case PROP_UNDEFINED: + printf_filtered ("(undefined)"); + break; + case PROP_LOCEXPR: + case PROP_LOCLIST: + printf_filtered ("(dynamic)"); + break; + default: + gdb_assert_not_reached ("unhandled prop kind"); + break; + } +} + void recursive_dump_type (struct type *type, int spaces) { @@ -4480,7 +4906,7 @@ recursive_dump_type (struct type *type, int spaces) if (spaces == 0) obstack_begin (&dont_print_type_obstack, 0); - if (TYPE_NFIELDS (type) > 0 + if (type->num_fields () > 0 || (HAVE_CPLUS_STRUCT (type) && TYPE_NFN_FIELDS (type) > 0)) { struct type **first_dont_print @@ -4507,11 +4933,11 @@ recursive_dump_type (struct type *type, int spaces) gdb_print_host_address (type, gdb_stdout); printf_filtered ("\n"); printfi_filtered (spaces, "name '%s' (", - TYPE_NAME (type) ? TYPE_NAME (type) : ""); - gdb_print_host_address (TYPE_NAME (type), gdb_stdout); + type->name () ? type->name () : ""); + gdb_print_host_address (type->name (), gdb_stdout); printf_filtered (")\n"); - printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type)); - switch (TYPE_CODE (type)) + printfi_filtered (spaces, "code 0x%x ", type->code ()); + switch (type->code ()) { case TYPE_CODE_UNDEF: printf_filtered ("(TYPE_CODE_UNDEF)"); @@ -4619,7 +5045,7 @@ recursive_dump_type (struct type *type, int spaces) gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout); printf_filtered ("\n"); printfi_filtered (spaces, "instance_flags 0x%x", - TYPE_INSTANCE_FLAGS (type)); + (unsigned) type->instance_flags ()); if (TYPE_CONST (type)) { puts_filtered (" TYPE_CONST"); @@ -4655,46 +5081,46 @@ recursive_dump_type (struct type *type, int spaces) puts_filtered ("\n"); printfi_filtered (spaces, "flags"); - if (TYPE_UNSIGNED (type)) + if (type->is_unsigned ()) { puts_filtered (" TYPE_UNSIGNED"); } - if (TYPE_NOSIGN (type)) + if (type->has_no_signedness ()) { puts_filtered (" TYPE_NOSIGN"); } - if (TYPE_STUB (type)) + if (type->endianity_is_not_default ()) + { + puts_filtered (" TYPE_ENDIANITY_NOT_DEFAULT"); + } + if (type->is_stub ()) { puts_filtered (" TYPE_STUB"); } - if (TYPE_TARGET_STUB (type)) + if (type->target_is_stub ()) { puts_filtered (" TYPE_TARGET_STUB"); } - if (TYPE_PROTOTYPED (type)) + if (type->is_prototyped ()) { puts_filtered (" TYPE_PROTOTYPED"); } - if (TYPE_INCOMPLETE (type)) - { - puts_filtered (" TYPE_INCOMPLETE"); - } - if (TYPE_VARARGS (type)) + if (type->has_varargs ()) { puts_filtered (" 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"); } - if (TYPE_FIXED_INSTANCE (type)) + if (type->is_fixed_instance ()) { puts_filtered (" TYPE_FIXED_INSTANCE"); } - if (TYPE_STUB_SUPPORTED (type)) + if (type->stub_is_supported ()) { puts_filtered (" TYPE_STUB_SUPPORTED"); } @@ -4703,12 +5129,12 @@ recursive_dump_type (struct type *type, int spaces) puts_filtered (" TYPE_NOTTEXT"); } puts_filtered ("\n"); - printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type)); - gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout); + printfi_filtered (spaces, "nfields %d ", type->num_fields ()); + gdb_print_host_address (type->fields (), gdb_stdout); puts_filtered ("\n"); - for (idx = 0; idx < TYPE_NFIELDS (type); idx++) + for (idx = 0; idx < type->num_fields (); idx++) { - if (TYPE_CODE (type) == TYPE_CODE_ENUM) + if (type->code () == TYPE_CODE_ENUM) printfi_filtered (spaces + 2, "[%d] enumval %s type ", idx, plongest (TYPE_FIELD_ENUMVAL (type, idx))); @@ -4717,26 +5143,25 @@ recursive_dump_type (struct type *type, int spaces) "[%d] bitpos %s bitsize %d type ", idx, plongest (TYPE_FIELD_BITPOS (type, idx)), TYPE_FIELD_BITSIZE (type, idx)); - gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout); + 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"); - if (TYPE_FIELD_TYPE (type, idx) != NULL) + if (type->field (idx).type () != NULL) { - recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4); + recursive_dump_type (type->field (idx).type (), spaces + 4); } } - if (TYPE_CODE (type) == TYPE_CODE_RANGE) + if (type->code () == TYPE_CODE_RANGE) { - printfi_filtered (spaces, "low %s%s high %s%s\n", - plongest (TYPE_LOW_BOUND (type)), - TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "", - plongest (TYPE_HIGH_BOUND (type)), - TYPE_HIGH_BOUND_UNDEFINED (type) - ? " (undefined)" : ""); + printfi_filtered (spaces, "low "); + dump_dynamic_prop (type->bounds ()->low); + printf_filtered (" high "); + dump_dynamic_prop (type->bounds ()->high); + printf_filtered ("\n"); } switch (TYPE_SPECIFIC_FIELD (type)) @@ -4777,6 +5202,16 @@ recursive_dump_type (struct type *type, int spaces) gdb_print_host_address (TYPE_SELF_TYPE (type), gdb_stdout); puts_filtered ("\n"); break; + + case TYPE_SPECIFIC_INT: + if (type->bit_size_differs_p ()) + { + unsigned bit_size = type->bit_size (); + unsigned bit_off = type->bit_offset (); + printfi_filtered (spaces, " bit size = %u, bit offset = %u\n", + bit_size, bit_off); + } + break; } if (spaces == 0) @@ -4816,13 +5251,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. */ @@ -4891,48 +5326,50 @@ copy_type_recursive (struct objfile *objfile, TYPE_OBJFILE_OWNED (new_type) = 0; TYPE_OWNER (new_type).gdbarch = get_type_arch (type); - if (TYPE_NAME (type)) - TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type)); + 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. */ - if (TYPE_NFIELDS (type)) + if (type->num_fields ()) { int i, nfields; - nfields = TYPE_NFIELDS (type); - TYPE_FIELDS (new_type) = (struct field *) - TYPE_ZALLOC (new_type, nfields * sizeof (struct field)); + nfields = type->num_fields (); + new_type->set_fields + ((struct field *) + TYPE_ZALLOC (new_type, nfields * sizeof (struct field))); + for (i = 0; i < nfields; i++) { TYPE_FIELD_ARTIFICIAL (new_type, i) = TYPE_FIELD_ARTIFICIAL (type, i); TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i); - if (TYPE_FIELD_TYPE (type, i)) - TYPE_FIELD_TYPE (new_type, i) - = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i), - copied_types); + if (type->field (i).type ()) + 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)) { case FIELD_LOC_KIND_BITPOS: - SET_FIELD_BITPOS (TYPE_FIELD (new_type, i), + SET_FIELD_BITPOS (new_type->field (i), TYPE_FIELD_BITPOS (type, i)); break; case FIELD_LOC_KIND_ENUMVAL: - SET_FIELD_ENUMVAL (TYPE_FIELD (new_type, i), + SET_FIELD_ENUMVAL (new_type->field (i), TYPE_FIELD_ENUMVAL (type, i)); break; case FIELD_LOC_KIND_PHYSADDR: - SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i), + SET_FIELD_PHYSADDR (new_type->field (i), TYPE_FIELD_STATIC_PHYSADDR (type, i)); break; case FIELD_LOC_KIND_PHYSNAME: - SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i), + SET_FIELD_PHYSNAME (new_type->field (i), xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type, i))); break; @@ -4945,17 +5382,20 @@ copy_type_recursive (struct objfile *objfile, } /* For range types, copy the bounds information. */ - if (TYPE_CODE (type) == TYPE_CODE_RANGE) + if (type->code () == TYPE_CODE_RANGE) { - TYPE_RANGE_DATA (new_type) = (struct range_bounds *) - TYPE_ALLOC (new_type, sizeof (struct range_bounds)); - *TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type); + range_bounds *bounds + = ((struct range_bounds *) TYPE_ALLOC + (new_type, sizeof (struct range_bounds))); + + *bounds = *type->bounds (); + new_type->set_bounds (bounds); } - if (TYPE_DYN_PROP_LIST (type) != NULL) - TYPE_DYN_PROP_LIST (new_type) + if (type->main_type->dyn_prop_list != NULL) + new_type->main_type->dyn_prop_list = copy_dynamic_prop_list (&objfile->objfile_obstack, - TYPE_DYN_PROP_LIST (type)); + type->main_type->dyn_prop_list); /* Copy pointers to other types. */ @@ -4995,6 +5435,12 @@ copy_type_recursive (struct objfile *objfile, copy_type_recursive (objfile, TYPE_SELF_TYPE (type), copied_types)); 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"); } @@ -5016,14 +5462,14 @@ copy_type (const struct type *type) gdb_assert (TYPE_OBJFILE_OWNED (type)); 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_DYN_PROP_LIST (type) != NULL) - TYPE_DYN_PROP_LIST (new_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, - TYPE_DYN_PROP_LIST (type)); + type->main_type->dyn_prop_list); return new_type; } @@ -5045,7 +5491,7 @@ arch_type (struct gdbarch *gdbarch, TYPE_LENGTH (type) = bit / TARGET_CHAR_BIT; if (name) - TYPE_NAME (type) = gdbarch_obstack_strdup (gdbarch, name); + type->set_name (gdbarch_obstack_strdup (gdbarch, name)); return type; } @@ -5062,7 +5508,7 @@ arch_integer_type (struct gdbarch *gdbarch, t = arch_type (gdbarch, TYPE_CODE_INT, bit, name); if (unsigned_p) - TYPE_UNSIGNED (t) = 1; + t->set_is_unsigned (true); return t; } @@ -5079,7 +5525,7 @@ arch_character_type (struct gdbarch *gdbarch, t = arch_type (gdbarch, TYPE_CODE_CHAR, bit, name); if (unsigned_p) - TYPE_UNSIGNED (t) = 1; + t->set_is_unsigned (true); return t; } @@ -5096,7 +5542,7 @@ arch_boolean_type (struct gdbarch *gdbarch, t = arch_type (gdbarch, TYPE_CODE_BOOL, bit, name); if (unsigned_p) - TYPE_UNSIGNED (t) = 1; + t->set_is_unsigned (true); return t; } @@ -5133,21 +5579,6 @@ arch_decfloat_type (struct gdbarch *gdbarch, int bit, const char *name) return t; } -/* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH. - NAME is the type name. TARGET_TYPE is the component float type. */ - -struct type * -arch_complex_type (struct gdbarch *gdbarch, - const char *name, struct type *target_type) -{ - struct type *t; - - t = arch_type (gdbarch, TYPE_CODE_COMPLEX, - 2 * TYPE_LENGTH (target_type) * TARGET_CHAR_BIT, name); - TYPE_TARGET_TYPE (t) = target_type; - return t; -} - /* Allocate a TYPE_CODE_PTR type structure associated with GDBARCH. BIT is the pointer type size in bits. NAME is the type name. TARGET_TYPE is the pointer target type. Always sets the pointer type's @@ -5161,7 +5592,7 @@ arch_pointer_type (struct gdbarch *gdbarch, t = arch_type (gdbarch, TYPE_CODE_PTR, bit, name); TYPE_TARGET_TYPE (t) = target_type; - TYPE_UNSIGNED (t) = 1; + t->set_is_unsigned (true); return t; } @@ -5174,11 +5605,11 @@ arch_flags_type (struct gdbarch *gdbarch, const char *name, int bit) struct type *type; type = arch_type (gdbarch, TYPE_CODE_FLAGS, bit, name); - TYPE_UNSIGNED (type) = 1; - TYPE_NFIELDS (type) = 0; + type->set_is_unsigned (true); + type->set_num_fields (0); /* Pre-allocate enough space assuming every field is one bit. */ - TYPE_FIELDS (type) - = (struct field *) TYPE_ZALLOC (type, bit * sizeof (struct field)); + type->set_fields + ((struct field *) TYPE_ZALLOC (type, bit * sizeof (struct field))); return type; } @@ -5192,19 +5623,19 @@ append_flags_type_field (struct type *type, int start_bitpos, int nr_bits, struct type *field_type, const char *name) { int type_bitsize = TYPE_LENGTH (type) * TARGET_CHAR_BIT; - int field_nr = TYPE_NFIELDS (type); + int field_nr = type->num_fields (); - gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS); - gdb_assert (TYPE_NFIELDS (type) + 1 <= type_bitsize); + 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 (name != NULL); TYPE_FIELD_NAME (type, field_nr) = xstrdup (name); - TYPE_FIELD_TYPE (type, field_nr) = field_type; - SET_FIELD_BITPOS (TYPE_FIELD (type, field_nr), start_bitpos); + type->field (field_nr).set_type (field_type); + SET_FIELD_BITPOS (type->field (field_nr), start_bitpos); TYPE_FIELD_BITSIZE (type, field_nr) = nr_bits; - ++TYPE_NFIELDS (type); + type->set_num_fields (type->num_fields () + 1); } /* Special version of append_flags_type_field to add a flag field. @@ -5232,7 +5663,7 @@ arch_composite_type (struct gdbarch *gdbarch, const char *name, gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION); t = arch_type (gdbarch, code, 0, NULL); - TYPE_NAME (t) = name; + t->set_name (name); INIT_CPLUS_SPECIFIC (t); return t; } @@ -5247,12 +5678,12 @@ append_composite_type_field_raw (struct type *t, const char *name, { struct field *f; - TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1; - TYPE_FIELDS (t) = XRESIZEVEC (struct field, TYPE_FIELDS (t), - TYPE_NFIELDS (t)); - f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]); + t->set_num_fields (t->num_fields () + 1); + t->set_fields (XRESIZEVEC (struct field, t->fields (), + t->num_fields ())); + f = &t->field (t->num_fields () - 1); memset (f, 0, sizeof f[0]); - FIELD_TYPE (f[0]) = field; + f[0].set_type (field); FIELD_NAME (f[0]) = name; return f; } @@ -5266,19 +5697,19 @@ append_composite_type_field_aligned (struct type *t, const char *name, { struct field *f = append_composite_type_field_raw (t, name, field); - if (TYPE_CODE (t) == TYPE_CODE_UNION) + if (t->code () == TYPE_CODE_UNION) { if (TYPE_LENGTH (t) < TYPE_LENGTH (field)) TYPE_LENGTH (t) = TYPE_LENGTH (field); } - else if (TYPE_CODE (t) == TYPE_CODE_STRUCT) + else if (t->code () == TYPE_CODE_STRUCT) { TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field); - if (TYPE_NFIELDS (t) > 1) + if (t->num_fields () > 1) { SET_FIELD_BITPOS (f[0], (FIELD_BITPOS (f[-1]) - + (TYPE_LENGTH (FIELD_TYPE (f[-1])) + + (TYPE_LENGTH (f[-1].type ()) * TARGET_CHAR_BIT))); if (alignment) @@ -5327,7 +5758,7 @@ gdbtypes_post_init (struct gdbarch *gdbarch) builtin_type->builtin_char = arch_integer_type (gdbarch, TARGET_CHAR_BIT, !gdbarch_char_signed (gdbarch), "char"); - TYPE_NOSIGN (builtin_type->builtin_char) = 1; + builtin_type->builtin_char->set_has_no_signedness (true); builtin_type->builtin_signed_char = arch_integer_type (gdbarch, TARGET_CHAR_BIT, 0, "signed char"); @@ -5358,9 +5789,15 @@ gdbtypes_post_init (struct gdbarch *gdbarch) builtin_type->builtin_unsigned_long_long = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch), 1, "unsigned long long"); + builtin_type->builtin_half + = arch_float_type (gdbarch, gdbarch_half_bit (gdbarch), + "half", gdbarch_half_format (gdbarch)); builtin_type->builtin_float = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), "float", gdbarch_float_format (gdbarch)); + builtin_type->builtin_bfloat16 + = arch_float_type (gdbarch, gdbarch_bfloat16_bit (gdbarch), + "bfloat16", gdbarch_bfloat16_format (gdbarch)); builtin_type->builtin_double = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch), "double", gdbarch_double_format (gdbarch)); @@ -5368,11 +5805,9 @@ gdbtypes_post_init (struct gdbarch *gdbarch) = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch), "long double", gdbarch_long_double_format (gdbarch)); builtin_type->builtin_complex - = arch_complex_type (gdbarch, "complex", - builtin_type->builtin_float); + = init_complex_type ("complex", builtin_type->builtin_float); builtin_type->builtin_double_complex - = arch_complex_type (gdbarch, "double complex", - builtin_type->builtin_double); + = init_complex_type ("double complex", builtin_type->builtin_double); builtin_type->builtin_string = arch_type (gdbarch, TYPE_CODE_STRING, TARGET_CHAR_BIT, "string"); builtin_type->builtin_bool @@ -5420,10 +5855,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 @@ -5457,14 +5896,15 @@ gdbtypes_post_init (struct gdbarch *gdbarch) /* This set of objfile-based types is intended to be used by symbol readers as basic types. */ -static const struct objfile_data *objfile_type_data; +static const struct objfile_key> + objfile_type_data; const struct objfile_type * objfile_type (struct objfile *objfile) { struct gdbarch *gdbarch; - struct objfile_type *objfile_type - = (struct objfile_type *) objfile_data (objfile, objfile_type_data); + struct objfile_type *objfile_type = objfile_type_data.get (objfile); if (objfile_type) return objfile_type; @@ -5473,7 +5913,7 @@ objfile_type (struct objfile *objfile) 1, struct objfile_type); /* Use the objfile architecture to determine basic type properties. */ - gdbarch = get_objfile_arch (objfile); + gdbarch = objfile->arch (); /* Basic types. */ objfile_type->builtin_void @@ -5481,7 +5921,7 @@ objfile_type (struct objfile *objfile) objfile_type->builtin_char = init_integer_type (objfile, TARGET_CHAR_BIT, !gdbarch_char_signed (gdbarch), "char"); - TYPE_NOSIGN (objfile_type->builtin_char) = 1; + objfile_type->builtin_char->set_has_no_signedness (true); objfile_type->builtin_signed_char = init_integer_type (objfile, TARGET_CHAR_BIT, 0, "signed char"); @@ -5531,10 +5971,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), "", @@ -5569,15 +6011,15 @@ objfile_type (struct objfile *objfile) = init_integer_type (objfile, gdbarch_addr_bit (gdbarch), 1, "__CORE_ADDR"); - set_objfile_data (objfile, objfile_type_data, objfile_type); + objfile_type_data.set (objfile, objfile_type); return objfile_type; } +void _initialize_gdbtypes (); void -_initialize_gdbtypes (void) +_initialize_gdbtypes () { gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init); - objfile_type_data = register_objfile_data (); add_setshow_zuinteger_cmd ("overload", no_class, &overload_debug, _("Set debugging of C++ overloading."),