X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbtypes.c;h=e3db1ed5c5d3317ccc88a6e3527ff5db14a6910b;hb=71bdabee218e22fa592ab679a2d1ee044e0f6e2c;hp=8d810977a7d0ebbbf87185ce313830f54af70ab0;hpb=b14d30e141e438bf7caebb1925569510eae049d7;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index 8d810977a7..e3db1ed5c5 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -1,7 +1,6 @@ /* Support routines for manipulating internal types for GDB. - Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, - 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. + Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. Contributed by Cygnus Support, using pieces from other GDB modules. @@ -34,27 +33,38 @@ #include "demangle.h" #include "complaints.h" #include "gdbcmd.h" -#include "wrapper.h" #include "cp-abi.h" #include "gdb_assert.h" #include "hashtab.h" +#include "exceptions.h" -/* These variables point to the objects - representing the predefined C data types. */ - -struct type *builtin_type_int0; -struct type *builtin_type_int8; -struct type *builtin_type_uint8; -struct type *builtin_type_int16; -struct type *builtin_type_uint16; -struct type *builtin_type_int32; -struct type *builtin_type_uint32; -struct type *builtin_type_int64; -struct type *builtin_type_uint64; -struct type *builtin_type_int128; -struct type *builtin_type_uint128; +/* Initialize BADNESS constants. */ + +const struct rank LENGTH_MISMATCH_BADNESS = {100,0}; + +const struct rank TOO_FEW_PARAMS_BADNESS = {100,0}; +const struct rank INCOMPATIBLE_TYPE_BADNESS = {100,0}; + +const struct rank EXACT_MATCH_BADNESS = {0,0}; + +const struct rank INTEGER_PROMOTION_BADNESS = {1,0}; +const struct rank FLOAT_PROMOTION_BADNESS = {1,0}; +const struct rank BASE_PTR_CONVERSION_BADNESS = {1,0}; +const struct rank INTEGER_CONVERSION_BADNESS = {2,0}; +const struct rank FLOAT_CONVERSION_BADNESS = {2,0}; +const struct rank INT_FLOAT_CONVERSION_BADNESS = {2,0}; +const struct rank VOID_PTR_CONVERSION_BADNESS = {2,0}; +const struct rank BOOL_PTR_CONVERSION_BADNESS = {3,0}; +const struct rank BASE_CONVERSION_BADNESS = {2,0}; +const struct rank REFERENCE_CONVERSION_BADNESS = {2,0}; +const struct rank NULL_POINTER_CONVERSION_BADNESS = {2,0}; +const struct rank NS_POINTER_CONVERSION_BADNESS = {10,0}; /* Floatformat pairs. */ +const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN] = { + &floatformat_ieee_half_big, + &floatformat_ieee_half_little +}; const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN] = { &floatformat_ieee_single_big, &floatformat_ieee_single_little @@ -100,14 +110,6 @@ const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = { &floatformat_ibm_long_double }; -struct type *builtin_type_ieee_single; -struct type *builtin_type_ieee_double; -struct type *builtin_type_i387_ext; -struct type *builtin_type_m68881_ext; -struct type *builtin_type_arm_ext; -struct type *builtin_type_ia64_spill; -struct type *builtin_type_ia64_quad; - int opaque_type_resolution = 1; static void @@ -115,8 +117,8 @@ show_opaque_type_resolution (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { - fprintf_filtered (file, _("\ -Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"), + fprintf_filtered (file, _("Resolution of opaque struct/class/union types " + "(if set before loading symbols) is %s.\n"), value); } @@ -141,45 +143,89 @@ static void dump_fn_fieldlists (struct type *, int); static void print_cplus_stuff (struct type *, int); -/* Alloc a new type structure and fill it with some defaults. If - OBJFILE is non-NULL, then allocate the space for the type structure - in that objfile's objfile_obstack. Otherwise allocate the new type - structure by xmalloc () (for permanent types). */ +/* Allocate a new OBJFILE-associated type structure and fill it + with some defaults. Space for the type structure is allocated + on the objfile's objfile_obstack. */ struct type * alloc_type (struct objfile *objfile) { struct type *type; + gdb_assert (objfile != NULL); + /* Alloc the structure and start off with all fields zeroed. */ + type = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct type); + TYPE_MAIN_TYPE (type) = OBSTACK_ZALLOC (&objfile->objfile_obstack, + struct main_type); + OBJSTAT (objfile, n_types++); - if (objfile == NULL) - { - type = xmalloc (sizeof (struct type)); - memset (type, 0, sizeof (struct type)); - TYPE_MAIN_TYPE (type) = xmalloc (sizeof (struct main_type)); - } - else - { - type = obstack_alloc (&objfile->objfile_obstack, - sizeof (struct type)); - memset (type, 0, sizeof (struct type)); - TYPE_MAIN_TYPE (type) = obstack_alloc (&objfile->objfile_obstack, - sizeof (struct main_type)); - OBJSTAT (objfile, n_types++); - } - memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type)); + TYPE_OBJFILE_OWNED (type) = 1; + TYPE_OWNER (type).objfile = objfile; + + /* Initialize the fields that might not be zero. */ + + TYPE_CODE (type) = TYPE_CODE_UNDEF; + TYPE_VPTR_FIELDNO (type) = -1; + TYPE_CHAIN (type) = type; /* Chain back to itself. */ + + return type; +} + +/* Allocate a new GDBARCH-associated type structure and fill it + with some defaults. Space for the type structure is allocated + on the heap. */ + +struct type * +alloc_type_arch (struct gdbarch *gdbarch) +{ + struct type *type; + + gdb_assert (gdbarch != NULL); + + /* Alloc the structure and start off with all fields zeroed. */ + + type = XZALLOC (struct type); + TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type); + + TYPE_OBJFILE_OWNED (type) = 0; + TYPE_OWNER (type).gdbarch = gdbarch; /* Initialize the fields that might not be zero. */ TYPE_CODE (type) = TYPE_CODE_UNDEF; - TYPE_OBJFILE (type) = objfile; TYPE_VPTR_FIELDNO (type) = -1; TYPE_CHAIN (type) = type; /* Chain back to itself. */ - return (type); + return type; +} + +/* If TYPE is objfile-associated, allocate a new type structure + associated with the same objfile. If TYPE is gdbarch-associated, + allocate a new type structure associated with the same gdbarch. */ + +struct type * +alloc_type_copy (const struct type *type) +{ + if (TYPE_OBJFILE_OWNED (type)) + return alloc_type (TYPE_OWNER (type).objfile); + else + return alloc_type_arch (TYPE_OWNER (type).gdbarch); +} + +/* If TYPE is gdbarch-associated, return that architecture. + If TYPE is objfile-associated, return that objfile's architecture. */ + +struct gdbarch * +get_type_arch (const struct type *type) +{ + if (TYPE_OBJFILE_OWNED (type)) + return get_objfile_arch (TYPE_OWNER (type).objfile); + else + return TYPE_OWNER (type).gdbarch; } + /* Alloc a new type instance structure, fill it with some defaults, and point it at OLDTYPE. Allocate the new type instance from the same place as OLDTYPE. */ @@ -191,31 +237,33 @@ alloc_type_instance (struct type *oldtype) /* Allocate the structure. */ - if (TYPE_OBJFILE (oldtype) == NULL) - { - type = xmalloc (sizeof (struct type)); - memset (type, 0, sizeof (struct type)); - } + if (! TYPE_OBJFILE_OWNED (oldtype)) + type = XZALLOC (struct type); else - { - type = obstack_alloc (&TYPE_OBJFILE (oldtype)->objfile_obstack, - sizeof (struct type)); - memset (type, 0, sizeof (struct type)); - } + type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack, + struct type); + TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype); TYPE_CHAIN (type) = type; /* Chain back to itself for now. */ - return (type); + return type; } /* Clear all remnants of the previous type at TYPE, in preparation for - replacing it with something else. */ + replacing it with something else. Preserve owner information. */ static void smash_type (struct type *type) { + int objfile_owned = TYPE_OBJFILE_OWNED (type); + union type_owner owner = TYPE_OWNER (type); + memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type)); + /* Restore owner information. */ + TYPE_OBJFILE_OWNED (type) = objfile_owned; + TYPE_OWNER (type) = owner; + /* For now, delete the rings. */ TYPE_CHAIN (type) = type; @@ -231,7 +279,6 @@ struct type * make_pointer_type (struct type *type, struct type **typeptr) { struct type *ntype; /* New type */ - struct objfile *objfile; struct type *chain; ntype = TYPE_POINTER_TYPE (type); @@ -250,18 +297,16 @@ make_pointer_type (struct type *type, struct type **typeptr) if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */ { - ntype = alloc_type (TYPE_OBJFILE (type)); + ntype = alloc_type_copy (type); if (typeptr) *typeptr = ntype; } else /* We have storage, but need to reset it. */ { ntype = *typeptr; - objfile = TYPE_OBJFILE (ntype); chain = TYPE_CHAIN (ntype); smash_type (ntype); TYPE_CHAIN (ntype) = chain; - TYPE_OBJFILE (ntype) = objfile; } TYPE_TARGET_TYPE (ntype) = type; @@ -270,14 +315,14 @@ make_pointer_type (struct type *type, struct type **typeptr) /* FIXME! Assume the machine has only one representation for pointers! */ - TYPE_LENGTH (ntype) = - gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT; + TYPE_LENGTH (ntype) + = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT; TYPE_CODE (ntype) = 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_FLAGS (ntype) |= TYPE_FLAG_UNSIGNED; + TYPE_UNSIGNED (ntype) = 1; if (!TYPE_POINTER_TYPE (type)) /* Remember it, if don't have one. */ TYPE_POINTER_TYPE (type) = ntype; @@ -311,7 +356,6 @@ struct type * make_reference_type (struct type *type, struct type **typeptr) { struct type *ntype; /* New type */ - struct objfile *objfile; struct type *chain; ntype = TYPE_REFERENCE_TYPE (type); @@ -330,18 +374,16 @@ make_reference_type (struct type *type, struct type **typeptr) if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */ { - ntype = alloc_type (TYPE_OBJFILE (type)); + ntype = alloc_type_copy (type); if (typeptr) *typeptr = ntype; } else /* We have storage, but need to reset it. */ { ntype = *typeptr; - objfile = TYPE_OBJFILE (ntype); chain = TYPE_CHAIN (ntype); smash_type (ntype); TYPE_CHAIN (ntype) = chain; - TYPE_OBJFILE (ntype) = objfile; } TYPE_TARGET_TYPE (ntype) = type; @@ -351,7 +393,8 @@ make_reference_type (struct type *type, struct type **typeptr) references, and that it matches the (only) representation for pointers! */ - TYPE_LENGTH (ntype) = gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT; + TYPE_LENGTH (ntype) = + gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT; TYPE_CODE (ntype) = TYPE_CODE_REF; if (!TYPE_REFERENCE_TYPE (type)) /* Remember it, if don't have one. */ @@ -386,20 +429,17 @@ struct type * make_function_type (struct type *type, struct type **typeptr) { struct type *ntype; /* New type */ - struct objfile *objfile; if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */ { - ntype = alloc_type (TYPE_OBJFILE (type)); + ntype = alloc_type_copy (type); if (typeptr) *typeptr = ntype; } else /* We have storage, but need to reset it. */ { ntype = *typeptr; - objfile = TYPE_OBJFILE (ntype); smash_type (ntype); - TYPE_OBJFILE (ntype) = objfile; } TYPE_TARGET_TYPE (ntype) = type; @@ -407,6 +447,8 @@ make_function_type (struct type *type, struct type **typeptr) TYPE_LENGTH (ntype) = 1; TYPE_CODE (ntype) = TYPE_CODE_FUNC; + INIT_FUNC_SPECIFIC (ntype); + return ntype; } @@ -423,15 +465,15 @@ lookup_function_type (struct type *type) /* Identify address space identifier by name -- return the integer flag defined in gdbtypes.h. */ extern int -address_space_name_to_int (char *space_identifier) +address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier) { - struct gdbarch *gdbarch = current_gdbarch; int type_flags; + /* Check for known address space delimiters. */ if (!strcmp (space_identifier, "code")) - return TYPE_FLAG_CODE_SPACE; + return TYPE_INSTANCE_FLAG_CODE_SPACE; else if (!strcmp (space_identifier, "data")) - return TYPE_FLAG_DATA_SPACE; + return TYPE_INSTANCE_FLAG_DATA_SPACE; else if (gdbarch_address_class_name_to_type_flags_p (gdbarch) && gdbarch_address_class_name_to_type_flags (gdbarch, space_identifier, @@ -445,14 +487,13 @@ address_space_name_to_int (char *space_identifier) gdbtypes.h -- return the string version of the adress space name. */ const char * -address_space_int_to_name (int space_flag) +address_space_int_to_name (struct gdbarch *gdbarch, int space_flag) { - struct gdbarch *gdbarch = current_gdbarch; - if (space_flag & TYPE_FLAG_CODE_SPACE) + if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE) return "code"; - else if (space_flag & TYPE_FLAG_DATA_SPACE) + else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE) return "data"; - else if ((space_flag & TYPE_FLAG_ADDRESS_CLASS_ALL) + else if ((space_flag & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL) && gdbarch_address_class_type_flags_to_name_p (gdbarch)) return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag); else @@ -471,11 +512,13 @@ make_qualified_type (struct type *type, int new_flags, struct type *ntype; ntype = type; - do { - if (TYPE_INSTANCE_FLAGS (ntype) == new_flags) - return ntype; - ntype = TYPE_CHAIN (ntype); - } while (ntype != type); + do + { + if (TYPE_INSTANCE_FLAGS (ntype) == new_flags) + return ntype; + ntype = TYPE_CHAIN (ntype); + } + while (ntype != type); /* Create a new type instance. */ if (storage == NULL) @@ -523,10 +566,10 @@ make_qualified_type (struct type *type, int new_flags, struct type * make_type_with_address_space (struct type *type, int space_flag) { - struct type *ntype; int new_flags = ((TYPE_INSTANCE_FLAGS (type) - & ~(TYPE_FLAG_CODE_SPACE | TYPE_FLAG_DATA_SPACE - | TYPE_FLAG_ADDRESS_CLASS_ALL)) + & ~(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); @@ -549,17 +592,16 @@ make_cv_type (int cnst, int voltl, struct type **typeptr) { struct type *ntype; /* New type */ - struct type *tmp_type = type; /* tmp type */ - struct objfile *objfile; int new_flags = (TYPE_INSTANCE_FLAGS (type) - & ~(TYPE_FLAG_CONST | TYPE_FLAG_VOLATILE)); + & ~(TYPE_INSTANCE_FLAG_CONST + | TYPE_INSTANCE_FLAG_VOLATILE)); if (cnst) - new_flags |= TYPE_FLAG_CONST; + new_flags |= TYPE_INSTANCE_FLAG_CONST; if (voltl) - new_flags |= TYPE_FLAG_VOLATILE; + new_flags |= TYPE_INSTANCE_FLAG_VOLATILE; if (typeptr && *typeptr != NULL) { @@ -612,18 +654,20 @@ replace_type (struct type *ntype, struct type *type) /* The type length is not a part of the main type. Update it for each type on the variant chain. */ chain = ntype; - do { - /* Assert that this element of the chain has no address-class bits - set in its flags. Such type variants might have type lengths - which are supposed to be different from the non-address-class - variants. This assertion shouldn't ever be triggered because - symbol readers which do construct address-class variants don't - call replace_type(). */ - gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0); - - TYPE_LENGTH (chain) = TYPE_LENGTH (type); - chain = TYPE_CHAIN (chain); - } while (ntype != chain); + do + { + /* Assert that this element of the chain has no address-class bits + set in its flags. Such type variants might have type lengths + which are supposed to be different from the non-address-class + variants. This assertion shouldn't ever be triggered because + symbol readers which do construct address-class variants don't + call replace_type(). */ + gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0); + + TYPE_LENGTH (chain) = TYPE_LENGTH (type); + chain = TYPE_CHAIN (chain); + } + while (ntype != chain); /* Assert that the two types have equivalent instance qualifiers. This should be true for at least all of our debug readers. */ @@ -640,9 +684,9 @@ lookup_memberptr_type (struct type *type, struct type *domain) { struct type *mtype; - mtype = alloc_type (TYPE_OBJFILE (type)); + mtype = alloc_type_copy (type); smash_to_memberptr_type (mtype, domain, type); - return (mtype); + return mtype; } /* Return a pointer-to-method type, for a method of type TO_TYPE. */ @@ -652,11 +696,8 @@ lookup_methodptr_type (struct type *to_type) { struct type *mtype; - mtype = alloc_type (TYPE_OBJFILE (to_type)); - TYPE_TARGET_TYPE (mtype) = to_type; - TYPE_DOMAIN_TYPE (mtype) = TYPE_DOMAIN_TYPE (to_type); - TYPE_LENGTH (mtype) = cplus_method_ptr_size (); - TYPE_CODE (mtype) = TYPE_CODE_METHODPTR; + mtype = alloc_type_copy (to_type); + smash_to_methodptr_type (mtype, to_type); return mtype; } @@ -671,11 +712,13 @@ allocate_stub_method (struct type *type) { struct type *mtype; - mtype = init_type (TYPE_CODE_METHOD, 1, TYPE_FLAG_STUB, NULL, - TYPE_OBJFILE (type)); + mtype = alloc_type_copy (type); + TYPE_CODE (mtype) = TYPE_CODE_METHOD; + TYPE_LENGTH (mtype) = 1; + TYPE_STUB (mtype) = 1; TYPE_TARGET_TYPE (mtype) = type; /* _DOMAIN_TYPE (mtype) = unknown yet */ - return (mtype); + return mtype; } /* Create a range type using either a blank type supplied in @@ -690,29 +733,25 @@ allocate_stub_method (struct type *type) struct type * create_range_type (struct type *result_type, struct type *index_type, - int low_bound, int high_bound) + LONGEST low_bound, LONGEST high_bound) { if (result_type == NULL) - { - result_type = alloc_type (TYPE_OBJFILE (index_type)); - } + result_type = alloc_type_copy (index_type); TYPE_CODE (result_type) = TYPE_CODE_RANGE; TYPE_TARGET_TYPE (result_type) = index_type; if (TYPE_STUB (index_type)) - TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB; + TYPE_TARGET_STUB (result_type) = 1; else TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type)); - TYPE_NFIELDS (result_type) = 2; - TYPE_FIELDS (result_type) = (struct field *) - TYPE_ALLOC (result_type, 2 * sizeof (struct field)); - memset (TYPE_FIELDS (result_type), 0, 2 * sizeof (struct field)); - TYPE_FIELD_BITPOS (result_type, 0) = low_bound; - TYPE_FIELD_BITPOS (result_type, 1) = high_bound; + TYPE_RANGE_DATA (result_type) = (struct range_bounds *) + TYPE_ZALLOC (result_type, sizeof (struct range_bounds)); + TYPE_LOW_BOUND (result_type) = low_bound; + TYPE_HIGH_BOUND (result_type) = high_bound; if (low_bound >= 0) - TYPE_FLAGS (result_type) |= TYPE_FLAG_UNSIGNED; + TYPE_UNSIGNED (result_type) = 1; - return (result_type); + return result_type; } /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type @@ -733,22 +772,22 @@ get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) if (TYPE_NFIELDS (type) > 0) { /* The enums may not be sorted by value, so search all - entries */ + entries. */ int i; - *lowp = *highp = TYPE_FIELD_BITPOS (type, 0); + *lowp = *highp = TYPE_FIELD_ENUMVAL (type, 0); for (i = 0; i < TYPE_NFIELDS (type); i++) { - if (TYPE_FIELD_BITPOS (type, i) < *lowp) - *lowp = TYPE_FIELD_BITPOS (type, i); - if (TYPE_FIELD_BITPOS (type, i) > *highp) - *highp = TYPE_FIELD_BITPOS (type, i); + if (TYPE_FIELD_ENUMVAL (type, i) < *lowp) + *lowp = TYPE_FIELD_ENUMVAL (type, i); + if (TYPE_FIELD_ENUMVAL (type, i) > *highp) + *highp = TYPE_FIELD_ENUMVAL (type, i); } /* Set unsigned indicator if warranted. */ if (*lowp >= 0) { - TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED; + TYPE_UNSIGNED (type) = 1; } } else @@ -784,6 +823,50 @@ get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) } } +/* Assuming TYPE is a simple, non-empty array type, compute its upper + and lower bound. Save the low bound into LOW_BOUND if not NULL. + Save the high bound into HIGH_BOUND if not NULL. + + 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. */ + +int +get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound) +{ + struct type *index = TYPE_INDEX_TYPE (type); + LONGEST low = 0; + LONGEST high = 0; + int res; + + if (index == NULL) + return 0; + + res = get_discrete_bounds (index, &low, &high); + 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; + + if (high_bound) + *high_bound = high; + + return 1; +} + /* Create an array type using either a blank type supplied in RESULT_TYPE, or creating a new type, inheriting the objfile from RANGE_TYPE. @@ -803,28 +886,44 @@ create_array_type (struct type *result_type, LONGEST low_bound, high_bound; if (result_type == NULL) - { - result_type = alloc_type (TYPE_OBJFILE (range_type)); - } + result_type = alloc_type_copy (range_type); + TYPE_CODE (result_type) = TYPE_CODE_ARRAY; TYPE_TARGET_TYPE (result_type) = element_type; if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0) low_bound = high_bound = 0; CHECK_TYPEDEF (element_type); - TYPE_LENGTH (result_type) = - TYPE_LENGTH (element_type) * (high_bound - low_bound + 1); + /* 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 + TYPE_LENGTH (result_type) = + TYPE_LENGTH (element_type) * (high_bound - low_bound + 1); TYPE_NFIELDS (result_type) = 1; TYPE_FIELDS (result_type) = - (struct field *) TYPE_ALLOC (result_type, sizeof (struct field)); - memset (TYPE_FIELDS (result_type), 0, sizeof (struct field)); - TYPE_FIELD_TYPE (result_type, 0) = range_type; + (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field)); + TYPE_INDEX_TYPE (result_type) = range_type; TYPE_VPTR_FIELDNO (result_type) = -1; - /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */ + /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */ if (TYPE_LENGTH (result_type) == 0) - TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB; + TYPE_TARGET_STUB (result_type) = 1; + + return result_type; +} + +struct type * +lookup_array_range_type (struct type *element_type, + int low_bound, int high_bound) +{ + struct gdbarch *gdbarch = get_type_arch (element_type); + struct type *index_type = builtin_type (gdbarch)->builtin_int; + struct type *range_type + = create_range_type (NULL, index_type, low_bound, high_bound); - return (result_type); + return create_array_type (NULL, element_type, range_type); } /* Create a string type using either a blank type supplied in @@ -840,82 +939,54 @@ create_array_type (struct type *result_type, type? */ struct type * -create_string_type (struct type *result_type, +create_string_type (struct type *result_type, + struct type *string_char_type, struct type *range_type) { - struct type *string_char_type; - - string_char_type = language_string_char_type (current_language, - current_gdbarch); result_type = create_array_type (result_type, string_char_type, range_type); TYPE_CODE (result_type) = TYPE_CODE_STRING; - return (result_type); + return result_type; +} + +struct type * +lookup_string_range_type (struct type *string_char_type, + int low_bound, int high_bound) +{ + struct type *result_type; + + result_type = lookup_array_range_type (string_char_type, + low_bound, high_bound); + TYPE_CODE (result_type) = TYPE_CODE_STRING; + return result_type; } struct type * create_set_type (struct type *result_type, struct type *domain_type) { if (result_type == NULL) - { - result_type = alloc_type (TYPE_OBJFILE (domain_type)); - } + 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_ALLOC (result_type, 1 * sizeof (struct field)); - memset (TYPE_FIELDS (result_type), 0, sizeof (struct field)); + TYPE_FIELDS (result_type) = TYPE_ZALLOC (result_type, sizeof (struct field)); if (!TYPE_STUB (domain_type)) { LONGEST low_bound, high_bound, bit_length; + if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0) low_bound = high_bound = 0; bit_length = high_bound - low_bound + 1; TYPE_LENGTH (result_type) = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT; if (low_bound >= 0) - TYPE_FLAGS (result_type) |= TYPE_FLAG_UNSIGNED; + TYPE_UNSIGNED (result_type) = 1; } TYPE_FIELD_TYPE (result_type, 0) = domain_type; - return (result_type); -} - -void -append_flags_type_flag (struct type *type, int bitpos, char *name) -{ - gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS); - gdb_assert (bitpos < TYPE_NFIELDS (type)); - gdb_assert (bitpos >= 0); - - if (name) - { - TYPE_FIELD_NAME (type, bitpos) = xstrdup (name); - TYPE_FIELD_BITPOS (type, bitpos) = bitpos; - } - else - { - /* Don't show this field to the user. */ - TYPE_FIELD_BITPOS (type, bitpos) = -1; - } -} - -struct type * -init_flags_type (char *name, int length) -{ - int nfields = length * TARGET_CHAR_BIT; - struct type *type; - - type = init_type (TYPE_CODE_FLAGS, length, - TYPE_FLAG_UNSIGNED, name, NULL); - TYPE_NFIELDS (type) = nfields; - TYPE_FIELDS (type) = TYPE_ALLOC (type, - nfields * sizeof (struct field)); - memset (TYPE_FIELDS (type), 0, nfields * sizeof (struct field)); - - return type; + return result_type; } /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE @@ -936,23 +1007,20 @@ make_vector_type (struct type *array_type) elt_type = TYPE_TARGET_TYPE (inner_array); if (TYPE_CODE (elt_type) == TYPE_CODE_INT) { - flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_FLAG_NOTTEXT; + flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_INSTANCE_FLAG_NOTTEXT; elt_type = make_qualified_type (elt_type, flags, NULL); TYPE_TARGET_TYPE (inner_array) = elt_type; } - TYPE_FLAGS (array_type) |= TYPE_FLAG_VECTOR; + TYPE_VECTOR (array_type) = 1; } struct type * init_vector_type (struct type *elt_type, int n) { struct type *array_type; - - array_type = create_array_type (0, elt_type, - create_range_type (0, - builtin_type_int32, - 0, n-1)); + + array_type = lookup_array_range_type (elt_type, 0, n - 1); make_vector_type (array_type); return array_type; } @@ -972,20 +1040,32 @@ void smash_to_memberptr_type (struct type *type, struct type *domain, struct type *to_type) { - struct objfile *objfile; - - objfile = TYPE_OBJFILE (type); - smash_type (type); - TYPE_OBJFILE (type) = objfile; TYPE_TARGET_TYPE (type) = to_type; TYPE_DOMAIN_TYPE (type) = domain; /* Assume that a data member pointer is the same size as a normal pointer. */ - TYPE_LENGTH (type) = gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT; + TYPE_LENGTH (type) + = gdbarch_ptr_bit (get_type_arch (to_type)) / TARGET_CHAR_BIT; TYPE_CODE (type) = TYPE_CODE_MEMBERPTR; } +/* Smash TYPE to be a type of pointer to methods type TO_TYPE. + + When "smashing" the type, we preserve the objfile that the old type + pointed to, since we aren't changing where the type is actually + allocated. */ + +void +smash_to_methodptr_type (struct type *type, struct type *to_type) +{ + smash_type (type); + TYPE_TARGET_TYPE (type) = to_type; + TYPE_DOMAIN_TYPE (type) = TYPE_DOMAIN_TYPE (to_type); + TYPE_LENGTH (type) = cplus_method_ptr_size (to_type); + TYPE_CODE (type) = TYPE_CODE_METHODPTR; +} + /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE. METHOD just means `function that gets an extra "this" argument'. @@ -998,18 +1078,13 @@ smash_to_method_type (struct type *type, struct type *domain, struct type *to_type, struct field *args, int nargs, int varargs) { - struct objfile *objfile; - - objfile = TYPE_OBJFILE (type); - smash_type (type); - TYPE_OBJFILE (type) = objfile; TYPE_TARGET_TYPE (type) = to_type; TYPE_DOMAIN_TYPE (type) = domain; TYPE_FIELDS (type) = args; TYPE_NFIELDS (type) = nargs; if (varargs) - TYPE_FLAGS (type) |= TYPE_FLAG_VARARGS; + TYPE_VARARGS (type) = 1; TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */ TYPE_CODE (type) = TYPE_CODE_METHOD; } @@ -1017,7 +1092,7 @@ smash_to_method_type (struct type *type, struct type *domain, /* Return a typename for a struct/union/enum type without "struct ", "union ", or "enum ". If the type has a NULL name, return NULL. */ -char * +const char * type_name_no_tag (const struct type *type) { if (TYPE_TAG_NAME (type) != NULL) @@ -1029,74 +1104,93 @@ type_name_no_tag (const struct type *type) return TYPE_NAME (type); } +/* A wrapper of type_name_no_tag which calls error if the type is anonymous. + Since GCC PR debug/47510 DWARF provides associated information to detect the + anonymous class linkage name from its typedef. + + Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will + apply it itself. */ + +const char * +type_name_no_tag_or_error (struct type *type) +{ + struct type *saved_type = type; + const char *name; + struct objfile *objfile; + + CHECK_TYPEDEF (type); + + name = type_name_no_tag (type); + if (name != NULL) + return name; + + name = type_name_no_tag (saved_type); + objfile = TYPE_OBJFILE (saved_type); + error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"), + name ? name : "", objfile ? objfile->name : ""); +} + /* Lookup a typedef or primitive type named NAME, visible in lexical block BLOCK. If NOERR is nonzero, return zero if NAME is not suitably defined. */ struct type * -lookup_typename (char *name, struct block *block, int noerr) +lookup_typename (const struct language_defn *language, + struct gdbarch *gdbarch, const char *name, + const struct block *block, int noerr) { struct symbol *sym; struct type *tmp; - sym = lookup_symbol (name, block, VAR_DOMAIN, 0, - (struct symtab **) NULL); - if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF) - { - tmp = language_lookup_primitive_type_by_name (current_language, - current_gdbarch, - name); - if (tmp) - { - return (tmp); - } - else if (!tmp && noerr) - { - return (NULL); - } - else - { - error (_("No type named %s."), name); - } - } - return (SYMBOL_TYPE (sym)); + sym = lookup_symbol (name, block, VAR_DOMAIN, 0); + if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF) + return SYMBOL_TYPE (sym); + + tmp = language_lookup_primitive_type_by_name (language, gdbarch, name); + if (tmp) + return tmp; + + if (noerr) + return NULL; + error (_("No type named %s."), name); } struct type * -lookup_unsigned_typename (char *name) +lookup_unsigned_typename (const struct language_defn *language, + struct gdbarch *gdbarch, const char *name) { char *uns = alloca (strlen (name) + 10); strcpy (uns, "unsigned "); strcpy (uns + 9, name); - return (lookup_typename (uns, (struct block *) NULL, 0)); + return lookup_typename (language, gdbarch, uns, (struct block *) NULL, 0); } struct type * -lookup_signed_typename (char *name) +lookup_signed_typename (const struct language_defn *language, + struct gdbarch *gdbarch, const char *name) { struct type *t; char *uns = alloca (strlen (name) + 8); strcpy (uns, "signed "); strcpy (uns + 7, name); - t = lookup_typename (uns, (struct block *) NULL, 1); + t = lookup_typename (language, gdbarch, uns, (struct block *) NULL, 1); /* If we don't find "signed FOO" just try again with plain "FOO". */ if (t != NULL) return t; - return lookup_typename (name, (struct block *) NULL, 0); + return lookup_typename (language, gdbarch, name, (struct block *) NULL, 0); } /* Lookup a structure type named "struct NAME", visible in lexical block BLOCK. */ struct type * -lookup_struct (char *name, struct block *block) +lookup_struct (const char *name, struct block *block) { struct symbol *sym; - sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0, - (struct symtab **) NULL); + sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0); if (sym == NULL) { @@ -1114,13 +1208,12 @@ lookup_struct (char *name, struct block *block) visible in lexical block BLOCK. */ struct type * -lookup_union (char *name, struct block *block) +lookup_union (const char *name, struct block *block) { struct symbol *sym; struct type *t; - sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0, - (struct symtab **) NULL); + sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0); if (sym == NULL) error (_("No union type named %s."), name); @@ -1128,14 +1221,7 @@ lookup_union (char *name, struct block *block) t = SYMBOL_TYPE (sym); if (TYPE_CODE (t) == TYPE_CODE_UNION) - return (t); - - /* C++ unions may come out with TYPE_CODE_CLASS, but we look at - * a further "declared_type" field to discover it is really a union. - */ - if (HAVE_CPLUS_STRUCT (t)) - if (TYPE_DECLARED_TYPE (t) == DECLARED_TYPE_UNION) - return (t); + return t; /* If we get here, it's not a union. */ error (_("This context has class, struct or enum %s, not a union."), @@ -1147,12 +1233,11 @@ lookup_union (char *name, struct block *block) visible in lexical block BLOCK. */ struct type * -lookup_enum (char *name, struct block *block) +lookup_enum (const char *name, struct block *block) { struct symbol *sym; - sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0, - (struct symtab **) NULL); + sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0); if (sym == NULL) { error (_("No enum type named %s."), name); @@ -1175,13 +1260,13 @@ lookup_template_type (char *name, struct type *type, struct symbol *sym; char *nam = (char *) alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4); + strcpy (nam, name); strcat (nam, "<"); strcat (nam, TYPE_NAME (type)); - strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */ + strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */ - sym = lookup_symbol (nam, block, VAR_DOMAIN, 0, - (struct symtab **) NULL); + sym = lookup_symbol (nam, block, VAR_DOMAIN, 0); if (sym == NULL) { @@ -1211,6 +1296,7 @@ struct type * lookup_struct_elt_type (struct type *type, char *name, int noerr) { int i; + char *typename; for (;;) { @@ -1224,17 +1310,15 @@ lookup_struct_elt_type (struct type *type, char *name, int noerr) if (TYPE_CODE (type) != TYPE_CODE_STRUCT && TYPE_CODE (type) != TYPE_CODE_UNION) { - target_terminal_ours (); - gdb_flush (gdb_stdout); - fprintf_unfiltered (gdb_stderr, "Type "); - type_print (type, "", gdb_stderr, -1); - error (_(" is not a structure or union type.")); + typename = type_to_string (type); + make_cleanup (xfree, typename); + error (_("Type %s is not a structure or union type."), typename); } #if 0 /* FIXME: This change put in by Michael seems incorrect for the case where the structure tag name is the same as the member name. - I.E. when doing "ptype bell->bar" for "struct foo { int bar; int + I.e. when doing "ptype bell->bar" for "struct foo { int bar; int foo; } bell;" Disabled by fnf. */ { char *typename; @@ -1247,12 +1331,20 @@ lookup_struct_elt_type (struct type *type, char *name, int noerr) for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--) { - char *t_field_name = TYPE_FIELD_NAME (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 (type, i); } + else if (!t_field_name || *t_field_name == '\0') + { + struct type *subtype + = lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name, 1); + + if (subtype != NULL) + return subtype; + } } /* OK, it's not in this class. Recursively check the baseclasses. */ @@ -1272,25 +1364,25 @@ lookup_struct_elt_type (struct type *type, char *name, int noerr) return NULL; } - target_terminal_ours (); - gdb_flush (gdb_stdout); - fprintf_unfiltered (gdb_stderr, "Type "); - type_print (type, "", gdb_stderr, -1); - fprintf_unfiltered (gdb_stderr, " has no component named "); - fputs_filtered (name, gdb_stderr); - error ((".")); - return (struct type *) -1; /* For lint */ + typename = type_to_string (type); + make_cleanup (xfree, typename); + error (_("Type %s has no component named %s."), typename, name); } -/* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE - valid. Callers should be aware that in some cases (for example, +/* Lookup the vptr basetype/fieldno values for TYPE. + If found store vptr_basetype in *BASETYPEP if non-NULL, and return + vptr_fieldno. Also, if found and basetype is from the same objfile, + cache the results. + If not found, return -1 and ignore BASETYPEP. + Callers should be aware that in some cases (for example, the type or one of its baseclasses is a stub type and we are - debugging a .o file), this function will not be able to find the + debugging a .o file, or the compiler uses DWARF-2 and is not GCC), + this function will not be able to find the virtual function table pointer, and vptr_fieldno will remain -1 and - vptr_basetype will remain NULL. */ + vptr_basetype will remain NULL or incomplete. */ -void -fill_in_vptr_fieldno (struct type *type) +int +get_vptr_fieldno (struct type *type, struct type **basetypep) { CHECK_TYPEDEF (type); @@ -1302,45 +1394,35 @@ fill_in_vptr_fieldno (struct type *type) is virtual (and hence we cannot share the table pointer). */ for (i = 0; i < TYPE_N_BASECLASSES (type); i++) { - struct type *baseclass = check_typedef (TYPE_BASECLASS (type, - i)); - fill_in_vptr_fieldno (baseclass); - if (TYPE_VPTR_FIELDNO (baseclass) >= 0) + struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i)); + int fieldno; + struct type *basetype; + + fieldno = get_vptr_fieldno (baseclass, &basetype); + if (fieldno >= 0) { - TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (baseclass); - TYPE_VPTR_BASETYPE (type) = TYPE_VPTR_BASETYPE (baseclass); - break; + /* If the type comes from a different objfile we can't cache + it, it may have a different lifetime. PR 2384 */ + if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype)) + { + TYPE_VPTR_FIELDNO (type) = fieldno; + TYPE_VPTR_BASETYPE (type) = basetype; + } + if (basetypep) + *basetypep = basetype; + return fieldno; } } - } -} - -/* Find the method and field indices for the destructor in class type T. - Return 1 if the destructor was found, otherwise, return 0. */ -int -get_destructor_fn_field (struct type *t, - int *method_indexp, - int *field_indexp) -{ - int i; - - for (i = 0; i < TYPE_NFN_FIELDS (t); i++) + /* Not found. */ + return -1; + } + else { - int j; - struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i); - - for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (t, i); j++) - { - if (is_destructor_name (TYPE_FN_FIELD_PHYSNAME (f, j)) != 0) - { - *method_indexp = i; - *field_indexp = j; - return 1; - } - } + if (basetypep) + *basetypep = TYPE_VPTR_BASETYPE (type); + return TYPE_VPTR_FIELDNO (type); } - return 0; } static void @@ -1349,29 +1431,41 @@ stub_noname_complaint (void) complaint (&symfile_complaints, _("stub type has NULL name")); } -/* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989. +/* Find the real type of TYPE. This function returns the real type, + after removing all layers of typedefs, and completing opaque or stub + types. Completion changes the TYPE argument, but stripping of + typedefs does not. + + Instance flags (e.g. const/volatile) are preserved as typedefs are + stripped. If necessary a new qualified form of the underlying type + is created. + + NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has + not been computed and we're either in the middle of reading symbols, or + there was no name for the typedef in the debug info. + + NOTE: Lookup of opaque types can throw errors for invalid symbol files. + QUITs in the symbol reading code can also throw. + Thus this function can throw an exception. + + If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of + the target type. If this is a stubbed struct (i.e. declared as struct foo *), see if - we can find a full definition in some other file. If so, copy this + we can find a full definition in some other file. If so, copy this definition, so we can use it in future. There used to be a comment (but not any code) that if we don't find a full definition, we'd set a flag so we don't spend time in the future checking the same type. That would be a mistake, though--we might load in more - symbols which contain a full definition for the type. - - This used to be coded as a macro, but I don't think it is called - often enough to merit such treatment. */ - -/* Find the real type of TYPE. This function returns the real type, - after removing all layers of typedefs and completing opaque or stub - types. Completion changes the TYPE argument, but stripping of - typedefs does not. */ + symbols which contain a full definition for the type. */ struct type * check_typedef (struct type *type) { struct type *orig_type = type; - int is_const, is_volatile; + /* 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); @@ -1379,13 +1473,13 @@ check_typedef (struct type *type) { if (!TYPE_TARGET_TYPE (type)) { - char *name; + const char *name; struct symbol *sym; /* It is dangerous to call lookup_symbol if we are currently reading a symtab. Infinite recursion is one danger. */ if (currently_reading_symtab) - return type; + return make_qualified_type (type, instance_flags, NULL); name = type_name_no_tag (type); /* FIXME: shouldn't we separately check the TYPE_NAME and @@ -1395,20 +1489,42 @@ check_typedef (struct type *type) if (name == NULL) { stub_noname_complaint (); - return type; + return make_qualified_type (type, instance_flags, NULL); } - sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0, - (struct symtab **) NULL); + sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0); if (sym) TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym); else /* TYPE_CODE_UNDEF */ - TYPE_TARGET_TYPE (type) = alloc_type (NULL); + TYPE_TARGET_TYPE (type) = alloc_type_arch (get_type_arch (type)); } type = TYPE_TARGET_TYPE (type); - } - is_const = TYPE_CONST (type); - is_volatile = TYPE_VOLATILE (type); + /* Preserve the instance flags as we traverse down the typedef chain. + + Handling address spaces/classes is nasty, what do we do if there's a + conflict? + E.g., what if an outer typedef marks the type as class_1 and an inner + typedef marks the type as class_2? + This is the wrong place to do such error checking. We leave it to + the code that created the typedef in the first place to flag the + error. We just pick the outer address space (akin to letting the + 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); + + /* Treat code vs data spaces and address classes separately. */ + if ((instance_flags & ALL_SPACES) != 0) + new_instance_flags &= ~ALL_SPACES; + if ((instance_flags & ALL_CLASSES) != 0) + new_instance_flags &= ~ALL_CLASSES; + + instance_flags |= new_instance_flags; + } + } /* If this is a struct/class/union with no fields, then check whether a full definition exists somewhere else. This is for @@ -1420,12 +1536,13 @@ check_typedef (struct type *type) && opaque_type_resolution && !currently_reading_symtab) { - char *name = type_name_no_tag (type); + const char *name = type_name_no_tag (type); struct type *newtype; + if (name == NULL) { stub_noname_complaint (); - return type; + return make_qualified_type (type, instance_flags, NULL); } newtype = lookup_transparent_type (name); @@ -1442,7 +1559,9 @@ 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)) - make_cv_type (is_const, is_volatile, newtype, &type); + type = make_qualified_type (newtype, + TYPE_INSTANCE_FLAGS (type), + type); else type = newtype; } @@ -1451,27 +1570,28 @@ check_typedef (struct type *type) types. */ else if (TYPE_STUB (type) && !currently_reading_symtab) { - char *name = type_name_no_tag (type); + const char *name = type_name_no_tag (type); /* FIXME: shouldn't we separately check the TYPE_NAME and the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN as appropriate? (this code was written before TYPE_NAME and TYPE_TAG_NAME were separate). */ struct symbol *sym; + if (name == NULL) { stub_noname_complaint (); - return type; + return make_qualified_type (type, instance_flags, NULL); } - sym = lookup_symbol (name, 0, STRUCT_DOMAIN, - 0, (struct symtab **) NULL); + sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0); if (sym) { /* Same as above for opaque types, we can replace the stub - with the complete type only if they are int the same + with the complete type only if they are in the same objfile. */ if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type)) - make_cv_type (is_const, is_volatile, - SYMBOL_TYPE (sym), &type); + type = make_qualified_type (SYMBOL_TYPE (sym), + TYPE_INSTANCE_FLAGS (type), + type); else type = SYMBOL_TYPE (sym); } @@ -1484,48 +1604,84 @@ check_typedef (struct type *type) if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type)) { - /* Empty. */ + /* Nothing we can do. */ } else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_NFIELDS (type) == 1 - && (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0)) + && (TYPE_CODE (range_type = TYPE_INDEX_TYPE (type)) == TYPE_CODE_RANGE)) { /* Now recompute the length of the array type, based on its - number of elements and the target type's length. */ - TYPE_LENGTH (type) = - ((TYPE_FIELD_BITPOS (range_type, 1) - - TYPE_FIELD_BITPOS (range_type, 0) + 1) - * TYPE_LENGTH (target_type)); - TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB; + number of elements and the target type's length. + Watch out for Ada null Ada arrays where the high bound + is smaller than the low bound. */ + const LONGEST low_bound = TYPE_LOW_BOUND (range_type); + const LONGEST high_bound = TYPE_HIGH_BOUND (range_type); + ULONGEST len; + + if (high_bound < low_bound) + len = 0; + else + { + /* For now, we conservatively take the array length to be 0 + if its length exceeds UINT_MAX. The code below assumes + that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1, + which is technically not guaranteed by C, but is usually true + (because it would be true if x were unsigned with its + high-order bit on). It uses the fact that + high_bound-low_bound is always representable in + ULONGEST and that if high_bound-low_bound+1 overflows, + it overflows to 0. We must change these tests if we + decide to increase the representation of TYPE_LENGTH + from unsigned int to ULONGEST. */ + ULONGEST ulow = low_bound, uhigh = high_bound; + ULONGEST tlen = TYPE_LENGTH (target_type); + + len = tlen * (uhigh - ulow + 1); + if (tlen == 0 || (len / tlen - 1 + ulow) != uhigh + || len > UINT_MAX) + len = 0; + } + TYPE_LENGTH (type) = len; + TYPE_TARGET_STUB (type) = 0; } else if (TYPE_CODE (type) == TYPE_CODE_RANGE) { TYPE_LENGTH (type) = TYPE_LENGTH (target_type); - TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB; + TYPE_TARGET_STUB (type) = 0; } } + + type = make_qualified_type (type, instance_flags, NULL); + /* Cache TYPE_LENGTH for future use. */ TYPE_LENGTH (orig_type) = TYPE_LENGTH (type); + return type; } /* Parse a type expression in the string [P..P+LENGTH). If an error - occurs, silently return builtin_type_void. */ + occurs, silently return a void type. */ static struct type * -safe_parse_type (char *p, int length) +safe_parse_type (struct gdbarch *gdbarch, char *p, int length) { struct ui_file *saved_gdb_stderr; - struct type *type; + struct type *type = NULL; /* Initialize to keep gcc happy. */ + volatile struct gdb_exception except; /* Suppress error messages. */ saved_gdb_stderr = gdb_stderr; gdb_stderr = ui_file_new (); /* Call parse_and_eval_type() without fear of longjmp()s. */ - if (!gdb_parse_and_eval_type (p, length, &type)) - type = builtin_type_void; + TRY_CATCH (except, RETURN_MASK_ERROR) + { + type = parse_and_eval_type (p, length); + } + + if (except.reason < 0) + type = builtin_type (gdbarch)->builtin_void; /* Stop suppressing error messages. */ ui_file_delete (gdb_stderr); @@ -1547,6 +1703,7 @@ safe_parse_type (char *p, int length) static void check_stub_method (struct type *type, int method_id, int signature_id) { + struct gdbarch *gdbarch = get_type_arch (type); struct fn_field *f; char *mangled_name = gdb_mangle_name (type, method_id, signature_id); char *demangled_name = cplus_demangle (mangled_name, @@ -1607,7 +1764,7 @@ check_stub_method (struct type *type, int method_id, int signature_id) argcount = 1; } - if (*p != ')') /* () means no args, skip while */ + if (*p != ')') /* () means no args, skip while. */ { depth = 0; while (*p) @@ -1620,7 +1777,7 @@ check_stub_method (struct type *type, int method_id, int signature_id) && strncmp (argtypetext, "void", p - argtypetext) != 0) { argtypes[argcount].type = - safe_parse_type (argtypetext, p - argtypetext); + safe_parse_type (gdbarch, argtypetext, p - argtypetext); argcount += 1; } argtypetext = p + 1; @@ -1646,10 +1803,10 @@ check_stub_method (struct type *type, int method_id, int signature_id) TYPE_DOMAIN_TYPE (mtype) = type; TYPE_FIELDS (mtype) = argtypes; TYPE_NFIELDS (mtype) = argcount; - TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB; + TYPE_STUB (mtype) = 0; TYPE_FN_FIELD_STUB (f, signature_id) = 0; if (p[-2] == '.') - TYPE_FLAGS (mtype) |= TYPE_FLAG_VARARGS; + TYPE_VARARGS (mtype) = 1; xfree (demangled_name); } @@ -1701,26 +1858,44 @@ check_stub_method_group (struct type *type, int method_id) } } -const struct cplus_struct_type cplus_struct_default; +/* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */ +const struct cplus_struct_type cplus_struct_default = { }; void allocate_cplus_struct_type (struct type *type) { - if (!HAVE_CPLUS_STRUCT (type)) - { - TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *) - TYPE_ALLOC (type, sizeof (struct cplus_struct_type)); - *(TYPE_CPLUS_SPECIFIC (type)) = cplus_struct_default; - } + if (HAVE_CPLUS_STRUCT (type)) + /* Structure was already allocated. Nothing more to do. */ + return; + + TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF; + TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *) + TYPE_ALLOC (type, sizeof (struct cplus_struct_type)); + *(TYPE_RAW_CPLUS_SPECIFIC (type)) = cplus_struct_default; +} + +const struct gnat_aux_type gnat_aux_default = + { NULL }; + +/* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF, + and allocate the associated gnat-specific data. The gnat-specific + data is also initialized to gnat_aux_default. */ +void +allocate_gnat_aux_type (struct type *type) +{ + TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF; + TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *) + TYPE_ALLOC (type, sizeof (struct gnat_aux_type)); + *(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default; } + /* Helper function to initialize the standard scalar types. - If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy of - the string pointed to by name in the objfile_obstack for that - objfile, and initialize the type name to that copy. There are - places (mipsread.c in particular, where init_type is called with a - NULL value for NAME). */ + If NAME is non-NULL, then we make a copy of the string pointed + to by name in the objfile_obstack for that objfile, and initialize + the type name to that copy. There are places (mipsread.c in particular), + where init_type is called with a NULL value for NAME). */ struct type * init_type (enum type_code code, int length, int flags, @@ -1731,188 +1906,330 @@ init_type (enum type_code code, int length, int flags, type = alloc_type (objfile); TYPE_CODE (type) = code; TYPE_LENGTH (type) = length; - TYPE_FLAGS (type) |= flags; - if ((name != NULL) && (objfile != NULL)) - { - TYPE_NAME (type) = obsavestring (name, strlen (name), - &objfile->objfile_obstack); - } - else - { - TYPE_NAME (type) = name; - } + + gdb_assert (!(flags & (TYPE_FLAG_MIN - 1))); + if (flags & TYPE_FLAG_UNSIGNED) + TYPE_UNSIGNED (type) = 1; + if (flags & TYPE_FLAG_NOSIGN) + TYPE_NOSIGN (type) = 1; + if (flags & TYPE_FLAG_STUB) + TYPE_STUB (type) = 1; + if (flags & TYPE_FLAG_TARGET_STUB) + TYPE_TARGET_STUB (type) = 1; + if (flags & TYPE_FLAG_STATIC) + TYPE_STATIC (type) = 1; + if (flags & TYPE_FLAG_PROTOTYPED) + TYPE_PROTOTYPED (type) = 1; + if (flags & TYPE_FLAG_INCOMPLETE) + TYPE_INCOMPLETE (type) = 1; + if (flags & TYPE_FLAG_VARARGS) + TYPE_VARARGS (type) = 1; + if (flags & TYPE_FLAG_VECTOR) + TYPE_VECTOR (type) = 1; + if (flags & TYPE_FLAG_STUB_SUPPORTED) + TYPE_STUB_SUPPORTED (type) = 1; + if (flags & TYPE_FLAG_FIXED_INSTANCE) + TYPE_FIXED_INSTANCE (type) = 1; + if (flags & TYPE_FLAG_GNU_IFUNC) + TYPE_GNU_IFUNC (type) = 1; + + if (name) + TYPE_NAME (type) = obsavestring (name, strlen (name), + &objfile->objfile_obstack); /* C++ fancies. */ if (name && strcmp (name, "char") == 0) - TYPE_FLAGS (type) |= TYPE_FLAG_NOSIGN; - - if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION - || code == TYPE_CODE_NAMESPACE) - { - INIT_CPLUS_SPECIFIC (type); + TYPE_NOSIGN (type) = 1; + + switch (code) + { + case TYPE_CODE_STRUCT: + case TYPE_CODE_UNION: + case TYPE_CODE_NAMESPACE: + INIT_CPLUS_SPECIFIC (type); + break; + case TYPE_CODE_FLT: + TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT; + break; + case TYPE_CODE_FUNC: + INIT_FUNC_SPECIFIC (type); + break; } - return (type); + return type; } -/* Helper function. Create an empty composite type. */ - -struct type * -init_composite_type (char *name, enum type_code code) +int +can_dereference (struct type *t) { - struct type *t; - gdb_assert (code == TYPE_CODE_STRUCT - || code == TYPE_CODE_UNION); - t = init_type (code, 0, 0, NULL, NULL); - TYPE_TAG_NAME (t) = name; - return t; + /* FIXME: Should we return true for references as well as + pointers? */ + CHECK_TYPEDEF (t); + return + (t != NULL + && TYPE_CODE (t) == TYPE_CODE_PTR + && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID); } -/* Helper function. Append a field to a composite type. */ +int +is_integral_type (struct type *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))); +} -void -append_composite_type_field (struct type *t, char *name, - struct type *field) +/* Return true if TYPE is scalar. */ + +static int +is_scalar_type (struct type *type) { - struct field *f; - TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1; - TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t), - sizeof (struct field) * TYPE_NFIELDS (t)); - f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]); - memset (f, 0, sizeof f[0]); - FIELD_TYPE (f[0]) = field; - FIELD_NAME (f[0]) = name; - if (TYPE_CODE (t) == TYPE_CODE_UNION) + CHECK_TYPEDEF (type); + + switch (TYPE_CODE (type)) { - if (TYPE_LENGTH (t) < TYPE_LENGTH (field)) - TYPE_LENGTH (t) = TYPE_LENGTH (field); + case TYPE_CODE_ARRAY: + case TYPE_CODE_STRUCT: + case TYPE_CODE_UNION: + case TYPE_CODE_SET: + case TYPE_CODE_STRING: + case TYPE_CODE_BITSTRING: + return 0; + default: + return 1; } - else if (TYPE_CODE (t) == TYPE_CODE_STRUCT) +} + +/* Return true if T is scalar, or a composite type which in practice has + the memory layout of a scalar type. E.g., an array or struct with only + one scalar element inside it, or a union with only scalar elements. */ + +int +is_scalar_type_recursive (struct type *t) +{ + CHECK_TYPEDEF (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) { - TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field); - if (TYPE_NFIELDS (t) > 1) - { - FIELD_BITPOS (f[0]) = (FIELD_BITPOS (f[-1]) - + TYPE_LENGTH (field) * TARGET_CHAR_BIT); - } + 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); + + 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) + { + int i, n = TYPE_NFIELDS (t); + + /* 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))) + return 0; + + return 1; + } + + return 0; } -/* Look up a fundamental type for the specified objfile. - May need to construct such a type if this is the first use. +/* A helper function which returns true if types A and B represent the + "same" class type. This is true if the types have the same main + type, or the same name. */ - Some object file formats (ELF, COFF, etc) do not define fundamental - types such as "int" or "double". Others (stabs for example), do - define fundamental types. +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)))); +} - For the formats which don't provide fundamental types, gdb can - create such types, using defaults reasonable for the current - language and the current target machine. +/* If BASE is an ancestor of DCLASS return the distance between them. + otherwise return -1; + eg: - NOTE: This routine is obsolescent. Each debugging format reader - should manage it's own fundamental types, either creating them from - suitable defaults or reading them from the debugging information, - whichever is appropriate. The DWARF reader has already been fixed - to do this. Once the other readers are fixed, this routine will go - away. Also note that fundamental types should be managed on a - compilation unit basis in a multi-language environment, not on a - linkage unit basis as is done here. */ + class A {}; + class B: public A {}; + class C: public B {}; + class D: C {}; + distance_to_ancestor (A, A, 0) = 0 + distance_to_ancestor (A, B, 0) = 1 + distance_to_ancestor (A, C, 0) = 2 + distance_to_ancestor (A, D, 0) = 3 -struct type * -lookup_fundamental_type (struct objfile *objfile, int typeid) -{ - struct type **typep; - int nbytes; + If PUBLIC is 1 then only public ancestors are considered, + and the function returns the distance only if BASE is a public ancestor + of DCLASS. + Eg: - if (typeid < 0 || typeid >= FT_NUM_MEMBERS) - { - error (_("internal error - invalid fundamental type id %d"), - typeid); - } + distance_to_ancestor (A, D, 1) = -1. */ - /* If this is the first time we need a fundamental type for this - objfile then we need to initialize the vector of type - pointers. */ +static int +distance_to_ancestor (struct type *base, struct type *dclass, int public) +{ + int i; + int d; - if (objfile->fundamental_types == NULL) - { - nbytes = FT_NUM_MEMBERS * sizeof (struct type *); - objfile->fundamental_types = (struct type **) - obstack_alloc (&objfile->objfile_obstack, nbytes); - memset ((char *) objfile->fundamental_types, 0, nbytes); - OBJSTAT (objfile, n_types += FT_NUM_MEMBERS); - } + CHECK_TYPEDEF (base); + CHECK_TYPEDEF (dclass); - /* Look for this particular type in the fundamental type vector. If - one is not found, create and install one appropriate for the - current language. */ + if (class_types_same_p (base, dclass)) + return 0; - typep = objfile->fundamental_types + typeid; - if (*typep == NULL) + for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++) { - *typep = create_fundamental_type (objfile, typeid); + if (public && ! BASETYPE_VIA_PUBLIC (dclass, i)) + continue; + + d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), public); + if (d >= 0) + return 1 + d; } - return (*typep); + return -1; } +/* Check whether BASE is an ancestor or base class or DCLASS + Return 1 if so, and 0 if not. + Note: If BASE and DCLASS are of the same type, this function + will return 1. So for some class A, is_ancestor (A, A) will + return 1. */ + int -can_dereference (struct type *t) +is_ancestor (struct type *base, struct type *dclass) { - /* FIXME: Should we return true for references as well as - pointers? */ - CHECK_TYPEDEF (t); - return - (t != NULL - && TYPE_CODE (t) == TYPE_CODE_PTR - && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID); + return distance_to_ancestor (base, dclass, 0) >= 0; } +/* Like is_ancestor, but only returns true when BASE is a public + ancestor of DCLASS. */ + int -is_integral_type (struct type *t) +is_public_ancestor (struct type *base, struct type *dclass) { - 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))); + return distance_to_ancestor (base, dclass, 1) >= 0; } -/* Check whether BASE is an ancestor or base class or DCLASS - Return 1 if so, and 0 if not. - Note: callers may want to check for identity of the types before - calling this function -- identical types are considered to satisfy - the ancestor relationship even if they're identical. */ +/* A helper function for is_unique_ancestor. */ -int -is_ancestor (struct type *base, struct type *dclass) +static int +is_unique_ancestor_worker (struct type *base, struct type *dclass, + int *offset, + const gdb_byte *valaddr, int embedded_offset, + CORE_ADDR address, struct value *val) { - int i; + int i, count = 0; CHECK_TYPEDEF (base); CHECK_TYPEDEF (dclass); - if (base == dclass) - return 1; - if (TYPE_NAME (base) && TYPE_NAME (dclass) - && !strcmp (TYPE_NAME (base), TYPE_NAME (dclass))) - return 1; + for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i) + { + struct type *iter; + int this_offset; - for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++) - if (is_ancestor (base, TYPE_BASECLASS (dclass, i))) - return 1; + iter = check_typedef (TYPE_BASECLASS (dclass, i)); - return 0; + this_offset = baseclass_offset (dclass, i, valaddr, embedded_offset, + address, val); + + if (class_types_same_p (base, iter)) + { + /* If this is the first subclass, set *OFFSET and set count + to 1. Otherwise, if this is at the same offset as + previous instances, do nothing. Otherwise, increment + count. */ + if (*offset == -1) + { + *offset = this_offset; + count = 1; + } + else if (this_offset == *offset) + { + /* Nothing. */ + } + else + ++count; + } + else + count += is_unique_ancestor_worker (base, iter, offset, + valaddr, + embedded_offset + this_offset, + address, val); + } + + return count; } + +/* Like is_ancestor, but only returns true if BASE is a unique base + class of the type of VAL. */ + +int +is_unique_ancestor (struct type *base, struct value *val) +{ + int offset = -1; + + return is_unique_ancestor_worker (base, value_type (val), &offset, + value_contents_for_printing (val), + value_embedded_offset (val), + value_address (val), val) == 1; +} + +/* Return the sum of the rank of A with the rank of B. */ -/* Functions for overload resolution begin here */ +struct rank +sum_ranks (struct rank a, struct rank b) +{ + struct rank c; + c.rank = a.rank + b.rank; + c.subrank = a.subrank + b.subrank; + return c; +} + +/* Compare rank A and B and return: + 0 if a = b + 1 if a is better than b + -1 if b is better than a. */ + +int +compare_ranks (struct rank a, struct rank b) +{ + if (a.rank == b.rank) + { + if (a.subrank == b.subrank) + return 0; + if (a.subrank < b.subrank) + return 1; + if (a.subrank > b.subrank) + return -1; + } + + if (a.rank < b.rank) + return 1; + + /* a.rank > b.rank */ + return -1; +} + +/* Functions for overload resolution begin here. */ /* Compare two badness vectors A and B and return the result. 0 => A and B are identical @@ -1935,7 +2252,7 @@ compare_badness (struct badness_vector *a, struct badness_vector *b) /* Subtract b from a */ for (i = 0; i < a->length; i++) { - tmp = a->rank[i] - b->rank[i]; + tmp = compare_ranks (b->rank[i], a->rank[i]); if (tmp > 0) found_pos = 1; else if (tmp < 0) @@ -1966,14 +2283,14 @@ compare_badness (struct badness_vector *a, struct badness_vector *b) struct badness_vector * rank_function (struct type **parms, int nparms, - struct type **args, int nargs) + struct value **args, int nargs) { int i; struct badness_vector *bv; int min_len = nparms < nargs ? nparms : nargs; bv = xmalloc (sizeof (struct badness_vector)); - bv->length = nargs + 1; /* add 1 for the length-match rank */ + bv->length = nargs + 1; /* add 1 for the length-match rank. */ bv->rank = xmalloc ((nargs + 1) * sizeof (int)); /* First compare the lengths of the supplied lists. @@ -1983,13 +2300,16 @@ rank_function (struct type **parms, int nparms, arguments and ellipsis parameter lists, we should consider those and rank the length-match more finely. */ - LENGTH_MATCH (bv) = (nargs != nparms) ? LENGTH_MISMATCH_BADNESS : 0; + LENGTH_MATCH (bv) = (nargs != nparms) + ? LENGTH_MISMATCH_BADNESS + : EXACT_MATCH_BADNESS; - /* Now rank all the parameters of the candidate function */ + /* Now rank all the parameters of the candidate function. */ for (i = 1; i <= min_len; i++) - bv->rank[i] = rank_one_type (parms[i-1], args[i-1]); + bv->rank[i] = rank_one_type (parms[i - 1], value_type (args[i - 1]), + args[i - 1]); - /* If more arguments than parameters, add dummy entries */ + /* If more arguments than parameters, add dummy entries. */ for (i = min_len + 1; i <= nargs; i++) bv->rank[i] = TOO_FEW_PARAMS_BADNESS; @@ -2034,25 +2354,72 @@ integer_types_same_name_p (const char *first, const char *second) return 1; } +/* Compares type A to type B returns 1 if the represent the same type + 0 otherwise. */ + +static int +types_equal (struct type *a, struct type *b) +{ + /* Identical type pointers. */ + /* However, this still doesn't catch all cases of same type for b + and a. The reason is that builtin types are different from + the same ones constructed from the object. */ + if (a == b) + return 1; + + /* Resolve typedefs */ + if (TYPE_CODE (a) == TYPE_CODE_TYPEDEF) + a = check_typedef (a); + if (TYPE_CODE (b) == 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)) + return 0; + + /* 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) + return types_equal (TYPE_TARGET_TYPE (a), + TYPE_TARGET_TYPE (b)); + + /* Well, damnit, if the names are exactly the same, I'll say they + are exactly the same. This happens when we generate method + 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) + return 1; + + /* Check if identical after resolving typedefs. */ + if (a == b) + return 1; + + return 0; +} + /* Compare one type (PARM) for compatibility with another (ARG). * PARM is intended to be the parameter type of a function; and * ARG is the supplied argument's type. This function tests if * the latter can be converted to the former. + * VALUE is the argument's value or NULL if none (or called recursively) * * Return 0 if they are identical types; * Otherwise, return an integer which corresponds to how compatible * PARM is to ARG. The higher the return value, the worse the match. * Generally the "bad" conversions are all uniformly assigned a 100. */ -int -rank_one_type (struct type *parm, struct type *arg) +struct rank +rank_one_type (struct type *parm, struct type *arg, struct value *value) { - /* Identical type pointers. */ - /* However, this still doesn't catch all cases of same type for arg - and param. The reason is that builtin types are different from - the same ones constructed from the object. */ - if (parm == arg) - return 0; + struct rank rank = {0,0}; + + if (types_equal (parm, arg)) + return EXACT_MATCH_BADNESS; /* Resolve typedefs */ if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF) @@ -2060,29 +2427,14 @@ rank_one_type (struct type *parm, struct type *arg) if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF) arg = check_typedef (arg); - /* - Well, damnit, if the names are exactly the same, I'll say they - are exactly the same. This happens when we generate method - stubs. The types won't point to the same address, but they - really are the same. - */ - - if (TYPE_NAME (parm) && TYPE_NAME (arg) - && !strcmp (TYPE_NAME (parm), TYPE_NAME (arg))) - return 0; - - /* Check if identical after resolving typedefs. */ - if (parm == arg) - return 0; - /* See through references, since we can almost make non-references references. */ if (TYPE_CODE (arg) == TYPE_CODE_REF) - return (rank_one_type (parm, TYPE_TARGET_TYPE (arg)) - + REFERENCE_CONVERSION_BADNESS); + return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL), + REFERENCE_CONVERSION_BADNESS)); if (TYPE_CODE (parm) == TYPE_CODE_REF) - return (rank_one_type (TYPE_TARGET_TYPE (parm), arg) - + REFERENCE_CONVERSION_BADNESS); + return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL), + REFERENCE_CONVERSION_BADNESS)); if (overload_debug) /* Debugging only. */ fprintf_filtered (gdb_stderr, @@ -2090,7 +2442,7 @@ rank_one_type (struct type *parm, struct type *arg) TYPE_NAME (arg), TYPE_CODE (arg), TYPE_NAME (parm), TYPE_CODE (parm)); - /* x -> y means arg of type x being supplied for parameter of type y */ + /* x -> y means arg of type x being supplied for parameter of type y. */ switch (TYPE_CODE (parm)) { @@ -2098,23 +2450,41 @@ rank_one_type (struct type *parm, struct type *arg) switch (TYPE_CODE (arg)) { case TYPE_CODE_PTR: + + /* Allowed pointer conversions are: + (a) pointer to void-pointer conversion. */ if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID) return VOID_PTR_CONVERSION_BADNESS; - else - return rank_one_type (TYPE_TARGET_TYPE (parm), - TYPE_TARGET_TYPE (arg)); + + /* (b) pointer to ancestor-pointer conversion. */ + rank.subrank = distance_to_ancestor (TYPE_TARGET_TYPE (parm), + TYPE_TARGET_TYPE (arg), + 0); + if (rank.subrank >= 0) + return sum_ranks (BASE_PTR_CONVERSION_BADNESS, rank); + + return INCOMPATIBLE_TYPE_BADNESS; case TYPE_CODE_ARRAY: - return rank_one_type (TYPE_TARGET_TYPE (parm), - TYPE_TARGET_TYPE (arg)); + if (types_equal (TYPE_TARGET_TYPE (parm), + TYPE_TARGET_TYPE (arg))) + return EXACT_MATCH_BADNESS; + return INCOMPATIBLE_TYPE_BADNESS; case TYPE_CODE_FUNC: - return rank_one_type (TYPE_TARGET_TYPE (parm), arg); + 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 + && value_as_long (value) == 0) + { + /* Null pointer conversion: allow it to be cast to a pointer. + [4.10.1 of C++ standard draft n3290] */ + return NULL_POINTER_CONVERSION_BADNESS; + } + /* fall through */ case TYPE_CODE_ENUM: case TYPE_CODE_FLAGS: case TYPE_CODE_CHAR: case TYPE_CODE_RANGE: case TYPE_CODE_BOOL: - return POINTER_CONVERSION_BADNESS; default: return INCOMPATIBLE_TYPE_BADNESS; } @@ -2124,7 +2494,7 @@ rank_one_type (struct type *parm, struct type *arg) case TYPE_CODE_PTR: case TYPE_CODE_ARRAY: return rank_one_type (TYPE_TARGET_TYPE (parm), - TYPE_TARGET_TYPE (arg)); + TYPE_TARGET_TYPE (arg), NULL); default: return INCOMPATIBLE_TYPE_BADNESS; } @@ -2132,7 +2502,7 @@ rank_one_type (struct type *parm, struct type *arg) switch (TYPE_CODE (arg)) { case TYPE_CODE_PTR: /* funcptr -> func */ - return rank_one_type (parm, TYPE_TARGET_TYPE (arg)); + return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL); default: return INCOMPATIBLE_TYPE_BADNESS; } @@ -2146,9 +2516,9 @@ rank_one_type (struct type *parm, struct type *arg) signed and unsigned ints. */ if (TYPE_NOSIGN (parm)) { - /* This case only for character types */ + /* This case only for character types. */ if (TYPE_NOSIGN (arg)) - return 0; /* plain char -> plain char */ + return EXACT_MATCH_BADNESS; /* plain char -> plain char */ else /* signed/unsigned char -> plain char */ return INTEGER_CONVERSION_BADNESS; } @@ -2160,14 +2530,16 @@ rank_one_type (struct type *parm, struct type *arg) unsigned long -> unsigned long */ if (integer_types_same_name_p (TYPE_NAME (parm), TYPE_NAME (arg))) - return 0; + return EXACT_MATCH_BADNESS; else if (integer_types_same_name_p (TYPE_NAME (arg), "int") && integer_types_same_name_p (TYPE_NAME (parm), "long")) - return INTEGER_PROMOTION_BADNESS; /* unsigned int -> unsigned long */ + /* unsigned int -> unsigned long */ + return INTEGER_PROMOTION_BADNESS; else - return INTEGER_CONVERSION_BADNESS; /* unsigned long -> unsigned int */ + /* unsigned long -> unsigned int */ + return INTEGER_CONVERSION_BADNESS; } else { @@ -2175,16 +2547,18 @@ rank_one_type (struct type *parm, struct type *arg) "long") && integer_types_same_name_p (TYPE_NAME (parm), "int")) - return INTEGER_CONVERSION_BADNESS; /* signed long -> unsigned int */ + /* signed long -> unsigned int */ + return INTEGER_CONVERSION_BADNESS; else - return INTEGER_CONVERSION_BADNESS; /* signed int/long -> unsigned int/long */ + /* signed int/long -> unsigned int/long */ + return INTEGER_CONVERSION_BADNESS; } } else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg)) { if (integer_types_same_name_p (TYPE_NAME (parm), TYPE_NAME (arg))) - return 0; + return EXACT_MATCH_BADNESS; else if (integer_types_same_name_p (TYPE_NAME (arg), "int") && integer_types_same_name_p (TYPE_NAME (parm), @@ -2250,19 +2624,19 @@ rank_one_type (struct type *parm, struct type *arg) if (TYPE_NOSIGN (parm)) { if (TYPE_NOSIGN (arg)) - return 0; + return EXACT_MATCH_BADNESS; else return INTEGER_CONVERSION_BADNESS; } else if (TYPE_UNSIGNED (parm)) { if (TYPE_UNSIGNED (arg)) - return 0; + return EXACT_MATCH_BADNESS; else return INTEGER_PROMOTION_BADNESS; } else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg)) - return 0; + return EXACT_MATCH_BADNESS; else return INTEGER_CONVERSION_BADNESS; default: @@ -2292,10 +2666,11 @@ rank_one_type (struct type *parm, struct type *arg) case TYPE_CODE_RANGE: case TYPE_CODE_ENUM: case TYPE_CODE_FLT: + return INCOMPATIBLE_TYPE_BADNESS; case TYPE_CODE_PTR: - return BOOLEAN_CONVERSION_BADNESS; + return BOOL_PTR_CONVERSION_BADNESS; case TYPE_CODE_BOOL: - return 0; + return EXACT_MATCH_BADNESS; default: return INCOMPATIBLE_TYPE_BADNESS; } @@ -2307,7 +2682,7 @@ rank_one_type (struct type *parm, struct type *arg) if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm)) return FLOAT_PROMOTION_BADNESS; else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm)) - return 0; + return EXACT_MATCH_BADNESS; else return FLOAT_CONVERSION_BADNESS; case TYPE_CODE_INT: @@ -2326,19 +2701,20 @@ rank_one_type (struct type *parm, struct type *arg) case TYPE_CODE_FLT: return FLOAT_PROMOTION_BADNESS; case TYPE_CODE_COMPLEX: - return 0; + return EXACT_MATCH_BADNESS; default: return INCOMPATIBLE_TYPE_BADNESS; } break; case TYPE_CODE_STRUCT: - /* currently same as TYPE_CODE_CLASS */ + /* currently same as TYPE_CODE_CLASS. */ switch (TYPE_CODE (arg)) { case TYPE_CODE_STRUCT: /* Check for derivation */ - if (is_ancestor (parm, arg)) - return BASE_CONVERSION_BADNESS; + rank.subrank = distance_to_ancestor (parm, arg, 0); + if (rank.subrank >= 0) + return sum_ranks (BASE_CONVERSION_BADNESS, rank); /* else fall through */ default: return INCOMPATIBLE_TYPE_BADNESS; @@ -2382,7 +2758,7 @@ rank_one_type (struct type *parm, struct type *arg) /* Not in C++ */ case TYPE_CODE_SET: return rank_one_type (TYPE_FIELD_TYPE (parm, 0), - TYPE_FIELD_TYPE (arg, 0)); + TYPE_FIELD_TYPE (arg, 0), NULL); default: return INCOMPATIBLE_TYPE_BADNESS; } @@ -2394,7 +2770,7 @@ rank_one_type (struct type *parm, struct type *arg) } -/* End of functions for overload resolution */ +/* End of functions for overload resolution. */ static void print_bit_vector (B_TYPE *bits, int nbits) @@ -2430,6 +2806,18 @@ print_arg_types (struct field *args, int nargs, int spaces) } } +int +field_is_static (struct field *f) +{ + /* "static" fields are the fields whose location is not relative + to the address of the enclosing struct. It would be nice to + have a dedicated flag that would be set for static fields when + the type is being created. But in practice, checking the field + loc_kind should give us an accurate answer. */ + return (FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSNAME + || FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSADDR); +} + static void dump_fn_fieldlists (struct type *type, int spaces) { @@ -2505,8 +2893,6 @@ print_cplus_stuff (struct type *type, int spaces) TYPE_N_BASECLASSES (type)); printfi_filtered (spaces, "nfn_fields %d\n", TYPE_NFN_FIELDS (type)); - printfi_filtered (spaces, "nfn_fields_total %d\n", - TYPE_NFN_FIELDS_TOTAL (type)); if (TYPE_N_BASECLASSES (type) > 0) { printfi_filtered (spaces, "virtual_field_bits (%d bits at *", @@ -2552,33 +2938,15 @@ print_cplus_stuff (struct type *type, int spaces) } } +/* Print the contents of the TYPE's type_specific union, assuming that + its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */ + static void -print_bound_type (int bt) +print_gnat_stuff (struct type *type, int spaces) { - switch (bt) - { - case BOUND_CANNOT_BE_DETERMINED: - printf_filtered ("(BOUND_CANNOT_BE_DETERMINED)"); - break; - case BOUND_BY_REF_ON_STACK: - printf_filtered ("(BOUND_BY_REF_ON_STACK)"); - break; - case BOUND_BY_VALUE_ON_STACK: - printf_filtered ("(BOUND_BY_VALUE_ON_STACK)"); - break; - case BOUND_BY_REF_IN_REG: - printf_filtered ("(BOUND_BY_REF_IN_REG)"); - break; - case BOUND_BY_VALUE_IN_REG: - printf_filtered ("(BOUND_BY_VALUE_IN_REG)"); - break; - case BOUND_SIMPLE: - printf_filtered ("(BOUND_SIMPLE)"); - break; - default: - printf_filtered (_("(unknown bound type)")); - break; - } + struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type); + + recursive_dump_type (descriptive_type, spaces + 2); } static struct obstack dont_print_type_obstack; @@ -2592,7 +2960,7 @@ recursive_dump_type (struct type *type, int spaces) obstack_begin (&dont_print_type_obstack, 0); if (TYPE_NFIELDS (type) > 0 - || (TYPE_CPLUS_SPECIFIC (type) && TYPE_NFN_FIELDS (type) > 0)) + || (HAVE_CPLUS_STRUCT (type) && TYPE_NFN_FIELDS (type) > 0)) { struct type **first_dont_print = (struct type **) obstack_base (&dont_print_type_obstack); @@ -2700,12 +3068,6 @@ recursive_dump_type (struct type *type, int spaces) case TYPE_CODE_TYPEDEF: printf_filtered ("(TYPE_CODE_TYPEDEF)"); break; - case TYPE_CODE_TEMPLATE: - printf_filtered ("(TYPE_CODE_TEMPLATE)"); - break; - case TYPE_CODE_TEMPLATE_ARG: - printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)"); - break; case TYPE_CODE_NAMESPACE: printf_filtered ("(TYPE_CODE_NAMESPACE)"); break; @@ -2715,16 +3077,16 @@ recursive_dump_type (struct type *type, int spaces) } puts_filtered ("\n"); printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type)); - printfi_filtered (spaces, "upper_bound_type 0x%x ", - TYPE_ARRAY_UPPER_BOUND_TYPE (type)); - print_bound_type (TYPE_ARRAY_UPPER_BOUND_TYPE (type)); - puts_filtered ("\n"); - printfi_filtered (spaces, "lower_bound_type 0x%x ", - TYPE_ARRAY_LOWER_BOUND_TYPE (type)); - print_bound_type (TYPE_ARRAY_LOWER_BOUND_TYPE (type)); - puts_filtered ("\n"); - printfi_filtered (spaces, "objfile "); - gdb_print_host_address (TYPE_OBJFILE (type), gdb_stdout); + if (TYPE_OBJFILE_OWNED (type)) + { + printfi_filtered (spaces, "objfile "); + gdb_print_host_address (TYPE_OWNER (type).objfile, gdb_stdout); + } + else + { + printfi_filtered (spaces, "gdbarch "); + gdb_print_host_address (TYPE_OWNER (type).gdbarch, gdb_stdout); + } printf_filtered ("\n"); printfi_filtered (spaces, "target_type "); gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout); @@ -2769,7 +3131,8 @@ recursive_dump_type (struct type *type, int spaces) puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2"); } puts_filtered ("\n"); - printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type)); + + printfi_filtered (spaces, "flags"); if (TYPE_UNSIGNED (type)) { puts_filtered (" TYPE_FLAG_UNSIGNED"); @@ -2809,16 +3172,33 @@ recursive_dump_type (struct type *type, int spaces) { puts_filtered (" TYPE_FLAG_VECTOR"); } + if (TYPE_FIXED_INSTANCE (type)) + { + puts_filtered (" TYPE_FIXED_INSTANCE"); + } + if (TYPE_STUB_SUPPORTED (type)) + { + puts_filtered (" TYPE_STUB_SUPPORTED"); + } + if (TYPE_NOTTEXT (type)) + { + puts_filtered (" TYPE_NOTTEXT"); + } puts_filtered ("\n"); printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type)); gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout); puts_filtered ("\n"); for (idx = 0; idx < TYPE_NFIELDS (type); idx++) { - printfi_filtered (spaces + 2, - "[%d] bitpos %d bitsize %d type ", - idx, TYPE_FIELD_BITPOS (type, idx), - TYPE_FIELD_BITSIZE (type, idx)); + if (TYPE_CODE (type) == TYPE_CODE_ENUM) + printfi_filtered (spaces + 2, + "[%d] enumval %s type ", + idx, plongest (TYPE_FIELD_ENUMVAL (type, idx))); + else + printfi_filtered (spaces + 2, + "[%d] bitpos %d bitsize %d type ", + idx, TYPE_FIELD_BITPOS (type, idx), + TYPE_FIELD_BITSIZE (type, idx)); gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout); printf_filtered (" name '%s' (", TYPE_FIELD_NAME (type, idx) != NULL @@ -2831,6 +3211,15 @@ recursive_dump_type (struct type *type, int spaces) recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4); } } + if (TYPE_CODE (type) == 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, "vptr_basetype "); gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout); puts_filtered ("\n"); @@ -2840,55 +3229,56 @@ recursive_dump_type (struct type *type, int spaces) } printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type)); - switch (TYPE_CODE (type)) - { - case TYPE_CODE_STRUCT: - printfi_filtered (spaces, "cplus_stuff "); - gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), - gdb_stdout); - puts_filtered ("\n"); - print_cplus_stuff (type, spaces); - break; - - case TYPE_CODE_FLT: - printfi_filtered (spaces, "floatformat "); - if (TYPE_FLOATFORMAT (type) == NULL) - puts_filtered ("(null)"); - else - { - puts_filtered ("{ "); - if (TYPE_FLOATFORMAT (type)[0] == NULL - || TYPE_FLOATFORMAT (type)[0]->name == NULL) - puts_filtered ("(null)"); - else - puts_filtered (TYPE_FLOATFORMAT (type)[0]->name); - puts_filtered (", "); - if (TYPE_FLOATFORMAT (type)[1] == NULL - || TYPE_FLOATFORMAT (type)[1]->name == NULL) - puts_filtered ("(null)"); - else - puts_filtered (TYPE_FLOATFORMAT (type)[1]->name); + switch (TYPE_SPECIFIC_FIELD (type)) + { + case TYPE_SPECIFIC_CPLUS_STUFF: + printfi_filtered (spaces, "cplus_stuff "); + gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), + gdb_stdout); + puts_filtered ("\n"); + print_cplus_stuff (type, spaces); + break; - puts_filtered (" }"); - } - puts_filtered ("\n"); - break; + case TYPE_SPECIFIC_GNAT_STUFF: + printfi_filtered (spaces, "gnat_stuff "); + gdb_print_host_address (TYPE_GNAT_SPECIFIC (type), gdb_stdout); + puts_filtered ("\n"); + print_gnat_stuff (type, spaces); + break; - default: - /* We have to pick one of the union types to be able print and - test the value. Pick cplus_struct_type, even though we know - it isn't any particular one. */ - printfi_filtered (spaces, "type_specific "); - gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout); - if (TYPE_CPLUS_SPECIFIC (type) != NULL) - { - printf_filtered (_(" (unknown data form)")); - } - printf_filtered ("\n"); - break; + case TYPE_SPECIFIC_FLOATFORMAT: + printfi_filtered (spaces, "floatformat "); + if (TYPE_FLOATFORMAT (type) == NULL) + puts_filtered ("(null)"); + else + { + puts_filtered ("{ "); + if (TYPE_FLOATFORMAT (type)[0] == NULL + || TYPE_FLOATFORMAT (type)[0]->name == NULL) + puts_filtered ("(null)"); + else + puts_filtered (TYPE_FLOATFORMAT (type)[0]->name); + + puts_filtered (", "); + if (TYPE_FLOATFORMAT (type)[1] == NULL + || TYPE_FLOATFORMAT (type)[1]->name == NULL) + puts_filtered ("(null)"); + else + puts_filtered (TYPE_FLOATFORMAT (type)[1]->name); + + puts_filtered (" }"); + } + puts_filtered ("\n"); + break; + case TYPE_SPECIFIC_FUNC: + printfi_filtered (spaces, "calling_convention %d\n", + TYPE_CALLING_CONVENTION (type)); + /* tail_call_list is not printed. */ + break; } + if (spaces == 0) obstack_free (&dont_print_type_obstack, NULL); } @@ -2905,6 +3295,7 @@ static hashval_t type_pair_hash (const void *item) { const struct type_pair *pair = item; + return htab_hash_pointer (pair->old); } @@ -2912,6 +3303,7 @@ static int type_pair_eq (const void *item_lhs, const void *item_rhs) { const struct type_pair *lhs = item_lhs, *rhs = item_rhs; + return lhs->old == rhs->old; } @@ -2942,7 +3334,7 @@ copy_type_recursive (struct objfile *objfile, void **slot; struct type *new_type; - if (TYPE_OBJFILE (type) == NULL) + if (! TYPE_OBJFILE_OWNED (type)) return type; /* This type shouldn't be pointing to any types in other objfiles; @@ -2954,39 +3346,37 @@ copy_type_recursive (struct objfile *objfile, if (*slot != NULL) return ((struct type_pair *) *slot)->new; - new_type = alloc_type (NULL); + new_type = alloc_type_arch (get_type_arch (type)); /* We must add the new type to the hash table immediately, in case we encounter this type again during a recursive call below. */ - stored = xmalloc (sizeof (struct type_pair)); + stored + = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair)); stored->old = type; stored->new = new_type; *slot = stored; - /* Copy the common fields of types. */ - TYPE_CODE (new_type) = TYPE_CODE (type); - TYPE_ARRAY_UPPER_BOUND_TYPE (new_type) = - TYPE_ARRAY_UPPER_BOUND_TYPE (type); - TYPE_ARRAY_LOWER_BOUND_TYPE (new_type) = - TYPE_ARRAY_LOWER_BOUND_TYPE (type); + /* Copy the common fields of types. For the main type, we simply + copy the entire thing and then update specific fields as needed. */ + *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type); + TYPE_OBJFILE_OWNED (new_type) = 0; + TYPE_OWNER (new_type).gdbarch = get_type_arch (type); + if (TYPE_NAME (type)) TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type)); if (TYPE_TAG_NAME (type)) TYPE_TAG_NAME (new_type) = xstrdup (TYPE_TAG_NAME (type)); - TYPE_FLAGS (new_type) = TYPE_FLAGS (type); - TYPE_VPTR_FIELDNO (new_type) = TYPE_VPTR_FIELDNO (type); TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type); TYPE_LENGTH (new_type) = TYPE_LENGTH (type); /* Copy the fields. */ - TYPE_NFIELDS (new_type) = TYPE_NFIELDS (type); if (TYPE_NFIELDS (type)) { int i, nfields; nfields = TYPE_NFIELDS (type); - TYPE_FIELDS (new_type) = xmalloc (sizeof (struct field) * nfields); + TYPE_FIELDS (new_type) = XCALLOC (nfields, struct field); for (i = 0; i < nfields; i++) { TYPE_FIELD_ARTIFICIAL (new_type, i) = @@ -2999,22 +3389,40 @@ copy_type_recursive (struct objfile *objfile, if (TYPE_FIELD_NAME (type, i)) TYPE_FIELD_NAME (new_type, i) = xstrdup (TYPE_FIELD_NAME (type, i)); - if (TYPE_FIELD_STATIC_HAS_ADDR (type, i)) - SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i), - TYPE_FIELD_STATIC_PHYSADDR (type, i)); - else if (TYPE_FIELD_STATIC (type, i)) - SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i), - xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type, - i))); - else + switch (TYPE_FIELD_LOC_KIND (type, i)) { - TYPE_FIELD_BITPOS (new_type, i) = - TYPE_FIELD_BITPOS (type, i); - TYPE_FIELD_STATIC_KIND (new_type, i) = 0; + case FIELD_LOC_KIND_BITPOS: + SET_FIELD_BITPOS (TYPE_FIELD (new_type, i), + TYPE_FIELD_BITPOS (type, i)); + break; + case FIELD_LOC_KIND_ENUMVAL: + SET_FIELD_ENUMVAL (TYPE_FIELD (new_type, i), + TYPE_FIELD_ENUMVAL (type, i)); + break; + case FIELD_LOC_KIND_PHYSADDR: + SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i), + TYPE_FIELD_STATIC_PHYSADDR (type, i)); + break; + case FIELD_LOC_KIND_PHYSNAME: + SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i), + xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type, + i))); + break; + default: + internal_error (__FILE__, __LINE__, + _("Unexpected type field location kind: %d"), + TYPE_FIELD_LOC_KIND (type, i)); } } } + /* For range types, copy the bounds information. */ + if (TYPE_CODE (type) == TYPE_CODE_RANGE) + { + TYPE_RANGE_DATA (new_type) = xmalloc (sizeof (struct range_bounds)); + *TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type); + } + /* Copy pointers to other types. */ if (TYPE_TARGET_TYPE (type)) TYPE_TARGET_TYPE (new_type) = @@ -3036,15 +3444,112 @@ copy_type_recursive (struct objfile *objfile, TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type); else if (TYPE_CODE (type) == TYPE_CODE_STRUCT || TYPE_CODE (type) == TYPE_CODE_UNION - || TYPE_CODE (type) == TYPE_CODE_TEMPLATE || TYPE_CODE (type) == TYPE_CODE_NAMESPACE) INIT_CPLUS_SPECIFIC (new_type); return new_type; } -static struct type * -build_flt (int bit, char *name, const struct floatformat **floatformats) +/* Make a copy of the given TYPE, except that the pointer & reference + types are not preserved. + + This function assumes that the given type has an associated objfile. + This objfile is used to allocate the new type. */ + +struct type * +copy_type (const struct type *type) +{ + struct type *new_type; + + gdb_assert (TYPE_OBJFILE_OWNED (type)); + + new_type = alloc_type_copy (type); + TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type); + TYPE_LENGTH (new_type) = TYPE_LENGTH (type); + memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type), + sizeof (struct main_type)); + + return new_type; +} + + +/* Helper functions to initialize architecture-specific types. */ + +/* Allocate a type structure associated with GDBARCH and set its + CODE, LENGTH, and NAME fields. */ +struct type * +arch_type (struct gdbarch *gdbarch, + enum type_code code, int length, char *name) +{ + struct type *type; + + type = alloc_type_arch (gdbarch); + TYPE_CODE (type) = code; + TYPE_LENGTH (type) = length; + + if (name) + TYPE_NAME (type) = xstrdup (name); + + return type; +} + +/* Allocate a TYPE_CODE_INT type structure associated with GDBARCH. + BIT is the type size in bits. If UNSIGNED_P is non-zero, set + the type's TYPE_UNSIGNED flag. NAME is the type name. */ +struct type * +arch_integer_type (struct gdbarch *gdbarch, + int bit, int unsigned_p, char *name) +{ + struct type *t; + + t = arch_type (gdbarch, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name); + if (unsigned_p) + TYPE_UNSIGNED (t) = 1; + if (name && strcmp (name, "char") == 0) + TYPE_NOSIGN (t) = 1; + + return t; +} + +/* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH. + BIT is the type size in bits. If UNSIGNED_P is non-zero, set + the type's TYPE_UNSIGNED flag. NAME is the type name. */ +struct type * +arch_character_type (struct gdbarch *gdbarch, + int bit, int unsigned_p, char *name) +{ + struct type *t; + + t = arch_type (gdbarch, TYPE_CODE_CHAR, bit / TARGET_CHAR_BIT, name); + if (unsigned_p) + TYPE_UNSIGNED (t) = 1; + + return t; +} + +/* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH. + BIT is the type size in bits. If UNSIGNED_P is non-zero, set + the type's TYPE_UNSIGNED flag. NAME is the type name. */ +struct type * +arch_boolean_type (struct gdbarch *gdbarch, + int bit, int unsigned_p, char *name) +{ + struct type *t; + + t = arch_type (gdbarch, TYPE_CODE_BOOL, bit / TARGET_CHAR_BIT, name); + if (unsigned_p) + TYPE_UNSIGNED (t) = 1; + + return t; +} + +/* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH. + 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. */ +struct type * +arch_float_type (struct gdbarch *gdbarch, + int bit, char *name, const struct floatformat **floatformats) { struct type *t; @@ -3056,33 +3561,150 @@ build_flt (int bit, char *name, const struct floatformat **floatformats) } gdb_assert (bit >= 0); - t = init_type (TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, 0, name, NULL); + t = arch_type (gdbarch, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name); TYPE_FLOATFORMAT (t) = floatformats; return t; } -static struct gdbarch_data *gdbtypes_data; +/* 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, + char *name, struct type *target_type) +{ + struct type *t; -const struct builtin_type * -builtin_type (struct gdbarch *gdbarch) + t = arch_type (gdbarch, TYPE_CODE_COMPLEX, + 2 * TYPE_LENGTH (target_type), name); + TYPE_TARGET_TYPE (t) = target_type; + return t; +} + +/* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH. + NAME is the type name. LENGTH is the size of the flag word in bytes. */ +struct type * +arch_flags_type (struct gdbarch *gdbarch, char *name, int length) { - return gdbarch_data (gdbarch, gdbtypes_data); + int nfields = length * TARGET_CHAR_BIT; + struct type *type; + + type = arch_type (gdbarch, TYPE_CODE_FLAGS, length, name); + TYPE_UNSIGNED (type) = 1; + TYPE_NFIELDS (type) = nfields; + TYPE_FIELDS (type) = TYPE_ZALLOC (type, nfields * sizeof (struct field)); + + return type; } +/* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at + position BITPOS is called NAME. */ +void +append_flags_type_flag (struct type *type, int bitpos, char *name) +{ + gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS); + gdb_assert (bitpos < TYPE_NFIELDS (type)); + gdb_assert (bitpos >= 0); + + if (name) + { + TYPE_FIELD_NAME (type, bitpos) = xstrdup (name); + SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), bitpos); + } + else + { + /* Don't show this field to the user. */ + SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), -1); + } +} -static struct type * -build_complex (int bit, char *name, struct type *target_type) +/* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as + specified by CODE) associated with GDBARCH. NAME is the type name. */ +struct type * +arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code) { struct type *t; - if (bit <= 0 || target_type == builtin_type_error) + + gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION); + t = arch_type (gdbarch, code, 0, NULL); + TYPE_TAG_NAME (t) = name; + INIT_CPLUS_SPECIFIC (t); + return t; +} + +/* Add new field with name NAME and type FIELD to composite type T. + Do not set the field's position or adjust the type's length; + the caller should do so. Return the new field. */ +struct field * +append_composite_type_field_raw (struct type *t, char *name, + struct type *field) +{ + struct field *f; + + TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1; + TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t), + sizeof (struct field) * TYPE_NFIELDS (t)); + f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]); + memset (f, 0, sizeof f[0]); + FIELD_TYPE (f[0]) = field; + FIELD_NAME (f[0]) = name; + return f; +} + +/* Add new field with name NAME and type FIELD to composite type T. + ALIGNMENT (if non-zero) specifies the minimum field alignment. */ +void +append_composite_type_field_aligned (struct type *t, char *name, + struct type *field, int alignment) +{ + struct field *f = append_composite_type_field_raw (t, name, field); + + if (TYPE_CODE (t) == TYPE_CODE_UNION) { - gdb_assert (builtin_type_error != NULL); - return builtin_type_error; + if (TYPE_LENGTH (t) < TYPE_LENGTH (field)) + TYPE_LENGTH (t) = TYPE_LENGTH (field); + } + else if (TYPE_CODE (t) == TYPE_CODE_STRUCT) + { + TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field); + if (TYPE_NFIELDS (t) > 1) + { + SET_FIELD_BITPOS (f[0], + (FIELD_BITPOS (f[-1]) + + (TYPE_LENGTH (FIELD_TYPE (f[-1])) + * TARGET_CHAR_BIT))); + + if (alignment) + { + int left; + + alignment *= TARGET_CHAR_BIT; + left = FIELD_BITPOS (f[0]) % alignment; + + if (left) + { + SET_FIELD_BITPOS (f[0], FIELD_BITPOS (f[0]) + (alignment - left)); + TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT; + } + } + } } - t = init_type (TYPE_CODE_COMPLEX, 2 * bit / TARGET_CHAR_BIT, - 0, name, (struct objfile *) NULL); - TYPE_TARGET_TYPE (t) = target_type; - return t; +} + +/* Add new field with name NAME and type FIELD to composite type T. */ +void +append_composite_type_field (struct type *t, char *name, + struct type *field) +{ + append_composite_type_field_aligned (t, name, field, 0); +} + + +static struct gdbarch_data *gdbtypes_data; + +const struct builtin_type * +builtin_type (struct gdbarch *gdbarch) +{ + return gdbarch_data (gdbarch, gdbtypes_data); } static void * @@ -3091,107 +3713,255 @@ gdbtypes_post_init (struct gdbarch *gdbarch) struct builtin_type *builtin_type = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type); - builtin_type->builtin_void = - init_type (TYPE_CODE_VOID, 1, - 0, - "void", (struct objfile *) NULL); - builtin_type->builtin_char = - init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - (TYPE_FLAG_NOSIGN - | (gdbarch_char_signed (gdbarch) ? 0 : TYPE_FLAG_UNSIGNED)), - "char", (struct objfile *) NULL); - builtin_type->builtin_true_char = - init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, - "true character", (struct objfile *) NULL); - builtin_type->builtin_true_unsigned_char = - init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "true character", (struct objfile *) NULL); - builtin_type->builtin_signed_char = - init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, - "signed char", (struct objfile *) NULL); - builtin_type->builtin_unsigned_char = - init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "unsigned char", (struct objfile *) NULL); - builtin_type->builtin_short = - init_type (TYPE_CODE_INT, - gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "short", (struct objfile *) NULL); - builtin_type->builtin_unsigned_short = - init_type (TYPE_CODE_INT, - gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "unsigned short", - (struct objfile *) NULL); - builtin_type->builtin_int = - init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "int", (struct objfile *) NULL); - builtin_type->builtin_unsigned_int = - init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "unsigned int", - (struct objfile *) NULL); - builtin_type->builtin_long = - init_type (TYPE_CODE_INT, - gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "long", (struct objfile *) NULL); - builtin_type->builtin_unsigned_long = - init_type (TYPE_CODE_INT, - gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "unsigned long", - (struct objfile *) NULL); - builtin_type->builtin_long_long = - init_type (TYPE_CODE_INT, - gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "long long", (struct objfile *) NULL); - builtin_type->builtin_unsigned_long_long = - init_type (TYPE_CODE_INT, - gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "unsigned long long", - (struct objfile *) NULL); + /* Basic types. */ + builtin_type->builtin_void + = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void"); + builtin_type->builtin_char + = arch_integer_type (gdbarch, TARGET_CHAR_BIT, + !gdbarch_char_signed (gdbarch), "char"); + builtin_type->builtin_signed_char + = arch_integer_type (gdbarch, TARGET_CHAR_BIT, + 0, "signed char"); + builtin_type->builtin_unsigned_char + = arch_integer_type (gdbarch, TARGET_CHAR_BIT, + 1, "unsigned char"); + builtin_type->builtin_short + = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch), + 0, "short"); + builtin_type->builtin_unsigned_short + = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch), + 1, "unsigned short"); + builtin_type->builtin_int + = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), + 0, "int"); + builtin_type->builtin_unsigned_int + = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), + 1, "unsigned int"); + builtin_type->builtin_long + = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), + 0, "long"); + builtin_type->builtin_unsigned_long + = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), + 1, "unsigned long"); + builtin_type->builtin_long_long + = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch), + 0, "long long"); + builtin_type->builtin_unsigned_long_long + = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch), + 1, "unsigned long long"); builtin_type->builtin_float - = build_flt (gdbarch_float_bit (gdbarch), "float", - gdbarch_float_format (gdbarch)); + = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), + "float", gdbarch_float_format (gdbarch)); builtin_type->builtin_double - = build_flt (gdbarch_double_bit (gdbarch), "double", - gdbarch_double_format (gdbarch)); + = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch), + "double", gdbarch_double_format (gdbarch)); builtin_type->builtin_long_double - = build_flt (gdbarch_long_double_bit (gdbarch), "long double", - gdbarch_long_double_format (gdbarch)); + = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch), + "long double", gdbarch_long_double_format (gdbarch)); builtin_type->builtin_complex - = build_complex (gdbarch_float_bit (gdbarch), "complex", - builtin_type->builtin_float); + = arch_complex_type (gdbarch, "complex", + builtin_type->builtin_float); builtin_type->builtin_double_complex - = build_complex (gdbarch_double_bit (gdbarch), "double complex", - builtin_type->builtin_double); - builtin_type->builtin_string = - init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, - "string", (struct objfile *) NULL); - builtin_type->builtin_bool = - init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, - "bool", (struct objfile *) NULL); + = arch_complex_type (gdbarch, "double complex", + builtin_type->builtin_double); + builtin_type->builtin_string + = arch_type (gdbarch, TYPE_CODE_STRING, 1, "string"); + builtin_type->builtin_bool + = arch_type (gdbarch, TYPE_CODE_BOOL, 1, "bool"); /* The following three are about decimal floating point types, which are 32-bits, 64-bits and 128-bits respectively. */ builtin_type->builtin_decfloat - = init_type (TYPE_CODE_DECFLOAT, 32 / 8, - 0, - "decimal float", (struct objfile *) NULL); + = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 32 / 8, "_Decimal32"); builtin_type->builtin_decdouble - = init_type (TYPE_CODE_DECFLOAT, 64 / 8, - 0, - "decimal double", (struct objfile *) NULL); + = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 64 / 8, "_Decimal64"); builtin_type->builtin_declong - = init_type (TYPE_CODE_DECFLOAT, 128 / 8, - 0, - "decimal long double", (struct objfile *) NULL); + = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 128 / 8, "_Decimal128"); + + /* "True" character types. */ + builtin_type->builtin_true_char + = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "true character"); + builtin_type->builtin_true_unsigned_char + = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "true character"); + + /* Fixed-size integer types. */ + builtin_type->builtin_int0 + = arch_integer_type (gdbarch, 0, 0, "int0_t"); + builtin_type->builtin_int8 + = arch_integer_type (gdbarch, 8, 0, "int8_t"); + builtin_type->builtin_uint8 + = arch_integer_type (gdbarch, 8, 1, "uint8_t"); + builtin_type->builtin_int16 + = arch_integer_type (gdbarch, 16, 0, "int16_t"); + builtin_type->builtin_uint16 + = arch_integer_type (gdbarch, 16, 1, "uint16_t"); + builtin_type->builtin_int32 + = arch_integer_type (gdbarch, 32, 0, "int32_t"); + builtin_type->builtin_uint32 + = arch_integer_type (gdbarch, 32, 1, "uint32_t"); + builtin_type->builtin_int64 + = arch_integer_type (gdbarch, 64, 0, "int64_t"); + builtin_type->builtin_uint64 + = arch_integer_type (gdbarch, 64, 1, "uint64_t"); + builtin_type->builtin_int128 + = 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; + + /* Wide character types. */ + builtin_type->builtin_char16 + = arch_integer_type (gdbarch, 16, 0, "char16_t"); + builtin_type->builtin_char32 + = arch_integer_type (gdbarch, 32, 0, "char32_t"); + + + /* Default data/code pointer types. */ + builtin_type->builtin_data_ptr + = lookup_pointer_type (builtin_type->builtin_void); + builtin_type->builtin_func_ptr + = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void)); + builtin_type->builtin_func_func + = lookup_function_type (builtin_type->builtin_func_ptr); + + /* This type represents a GDB internal function. */ + builtin_type->internal_fn + = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0, + ""); - /* Pointer/Address types. */ + return builtin_type; +} + + +/* 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; + +const struct objfile_type * +objfile_type (struct objfile *objfile) +{ + struct gdbarch *gdbarch; + struct objfile_type *objfile_type + = objfile_data (objfile, objfile_type_data); + + if (objfile_type) + return objfile_type; + + objfile_type = OBSTACK_CALLOC (&objfile->objfile_obstack, + 1, struct objfile_type); + + /* Use the objfile architecture to determine basic type properties. */ + gdbarch = get_objfile_arch (objfile); + + /* Basic types. */ + objfile_type->builtin_void + = init_type (TYPE_CODE_VOID, 1, + 0, + "void", objfile); + + objfile_type->builtin_char + = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, + (TYPE_FLAG_NOSIGN + | (gdbarch_char_signed (gdbarch) ? 0 : TYPE_FLAG_UNSIGNED)), + "char", objfile); + objfile_type->builtin_signed_char + = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, + 0, + "signed char", objfile); + objfile_type->builtin_unsigned_char + = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, + "unsigned char", objfile); + objfile_type->builtin_short + = init_type (TYPE_CODE_INT, + gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, + 0, "short", objfile); + objfile_type->builtin_unsigned_short + = init_type (TYPE_CODE_INT, + gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, "unsigned short", objfile); + objfile_type->builtin_int + = init_type (TYPE_CODE_INT, + gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, + 0, "int", objfile); + objfile_type->builtin_unsigned_int + = init_type (TYPE_CODE_INT, + gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, "unsigned int", objfile); + objfile_type->builtin_long + = init_type (TYPE_CODE_INT, + gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT, + 0, "long", objfile); + objfile_type->builtin_unsigned_long + = init_type (TYPE_CODE_INT, + gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, "unsigned long", objfile); + objfile_type->builtin_long_long + = init_type (TYPE_CODE_INT, + gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT, + 0, "long long", objfile); + objfile_type->builtin_unsigned_long_long + = init_type (TYPE_CODE_INT, + gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, "unsigned long long", objfile); + + objfile_type->builtin_float + = init_type (TYPE_CODE_FLT, + gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, + 0, "float", objfile); + TYPE_FLOATFORMAT (objfile_type->builtin_float) + = gdbarch_float_format (gdbarch); + objfile_type->builtin_double + = init_type (TYPE_CODE_FLT, + gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, + 0, "double", objfile); + TYPE_FLOATFORMAT (objfile_type->builtin_double) + = gdbarch_double_format (gdbarch); + objfile_type->builtin_long_double + = init_type (TYPE_CODE_FLT, + gdbarch_long_double_bit (gdbarch) / TARGET_CHAR_BIT, + 0, "long double", objfile); + TYPE_FLOATFORMAT (objfile_type->builtin_long_double) + = gdbarch_long_double_format (gdbarch); + + /* This type represents a type that was unrecognized in symbol read-in. */ + objfile_type->builtin_error + = init_type (TYPE_CODE_ERROR, 0, 0, "", objfile); + + /* The following set of types is used for symbols with no + debug information. */ + objfile_type->nodebug_text_symbol + = init_type (TYPE_CODE_FUNC, 1, 0, + "", objfile); + TYPE_TARGET_TYPE (objfile_type->nodebug_text_symbol) + = objfile_type->builtin_int; + objfile_type->nodebug_text_gnu_ifunc_symbol + = init_type (TYPE_CODE_FUNC, 1, TYPE_FLAG_GNU_IFUNC, + "", + objfile); + TYPE_TARGET_TYPE (objfile_type->nodebug_text_gnu_ifunc_symbol) + = objfile_type->nodebug_text_symbol; + objfile_type->nodebug_got_plt_symbol + = init_type (TYPE_CODE_PTR, gdbarch_addr_bit (gdbarch) / 8, 0, + "", + objfile); + TYPE_TARGET_TYPE (objfile_type->nodebug_got_plt_symbol) + = objfile_type->nodebug_text_symbol; + objfile_type->nodebug_data_symbol + = init_type (TYPE_CODE_INT, + gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0, + "", objfile); + objfile_type->nodebug_unknown_symbol + = init_type (TYPE_CODE_INT, 1, 0, + "", objfile); + objfile_type->nodebug_tls_symbol + = init_type (TYPE_CODE_INT, + gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0, + "", objfile); /* NOTE: on some targets, addresses and pointers are not necessarily the same --- for example, on the D10V, pointers are 16 bits long, @@ -3215,129 +3985,45 @@ gdbtypes_post_init (struct gdbarch *gdbarch) - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as sizeof (void *) == 2 on the target. - In this context, builtin_type->CORE_ADDR is a bit odd: it's a - target type for a value the target will never see. It's only - used to hold the values of (typeless) linker symbols, which are - indeed in the unified virtual address space. */ + In this context, objfile_type->builtin_core_addr is a bit odd: + it's a target type for a value the target will never see. It's + only used to hold the values of (typeless) linker symbols, which + are indeed in the unified virtual address space. */ - builtin_type->builtin_data_ptr = - make_pointer_type (builtin_type->builtin_void, NULL); - builtin_type->builtin_func_ptr = - lookup_pointer_type (lookup_function_type (builtin_type->builtin_void)); - builtin_type->builtin_core_addr = - init_type (TYPE_CODE_INT, - gdbarch_addr_bit (gdbarch) / 8, - TYPE_FLAG_UNSIGNED, - "__CORE_ADDR", (struct objfile *) NULL); + objfile_type->builtin_core_addr + = init_type (TYPE_CODE_INT, + gdbarch_addr_bit (gdbarch) / 8, + TYPE_FLAG_UNSIGNED, "__CORE_ADDR", objfile); - - /* The following set of types is used for symbols with no - debug information. */ - builtin_type->nodebug_text_symbol = - init_type (TYPE_CODE_FUNC, 1, 0, - "", NULL); - TYPE_TARGET_TYPE (builtin_type->nodebug_text_symbol) = - builtin_type->builtin_int; - builtin_type->nodebug_data_symbol = - init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0, - "", NULL); - builtin_type->nodebug_unknown_symbol = - init_type (TYPE_CODE_INT, 1, 0, - "", NULL); - builtin_type->nodebug_tls_symbol = - init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0, - "", NULL); - - return builtin_type; + set_objfile_data (objfile, objfile_type_data, objfile_type); + return objfile_type; } + extern void _initialize_gdbtypes (void); void _initialize_gdbtypes (void) { gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init); + objfile_type_data = register_objfile_data (); - /* FIXME: The following types are architecture-neutral. However, - they contain pointer_type and reference_type fields potentially - caching pointer or reference types that *are* architecture - dependent. */ - - builtin_type_int0 = - init_type (TYPE_CODE_INT, 0 / 8, - 0, - "int0_t", (struct objfile *) NULL); - builtin_type_int8 = - init_type (TYPE_CODE_INT, 8 / 8, - TYPE_FLAG_NOTTEXT, - "int8_t", (struct objfile *) NULL); - builtin_type_uint8 = - init_type (TYPE_CODE_INT, 8 / 8, - TYPE_FLAG_UNSIGNED | TYPE_FLAG_NOTTEXT, - "uint8_t", (struct objfile *) NULL); - builtin_type_int16 = - init_type (TYPE_CODE_INT, 16 / 8, - 0, - "int16_t", (struct objfile *) NULL); - builtin_type_uint16 = - init_type (TYPE_CODE_INT, 16 / 8, - TYPE_FLAG_UNSIGNED, - "uint16_t", (struct objfile *) NULL); - builtin_type_int32 = - init_type (TYPE_CODE_INT, 32 / 8, - 0, - "int32_t", (struct objfile *) NULL); - builtin_type_uint32 = - init_type (TYPE_CODE_INT, 32 / 8, - TYPE_FLAG_UNSIGNED, - "uint32_t", (struct objfile *) NULL); - builtin_type_int64 = - init_type (TYPE_CODE_INT, 64 / 8, - 0, - "int64_t", (struct objfile *) NULL); - builtin_type_uint64 = - init_type (TYPE_CODE_INT, 64 / 8, - TYPE_FLAG_UNSIGNED, - "uint64_t", (struct objfile *) NULL); - builtin_type_int128 = - init_type (TYPE_CODE_INT, 128 / 8, - 0, - "int128_t", (struct objfile *) NULL); - builtin_type_uint128 = - init_type (TYPE_CODE_INT, 128 / 8, - TYPE_FLAG_UNSIGNED, - "uint128_t", (struct objfile *) NULL); - - builtin_type_ieee_single = - build_flt (-1, "builtin_type_ieee_single", floatformats_ieee_single); - builtin_type_ieee_double = - build_flt (-1, "builtin_type_ieee_double", floatformats_ieee_double); - builtin_type_i387_ext = - build_flt (-1, "builtin_type_i387_ext", floatformats_i387_ext); - builtin_type_m68881_ext = - build_flt (-1, "builtin_type_m68881_ext", floatformats_m68881_ext); - builtin_type_arm_ext = - build_flt (-1, "builtin_type_arm_ext", floatformats_arm_ext); - builtin_type_ia64_spill = - build_flt (-1, "builtin_type_ia64_spill", floatformats_ia64_spill); - builtin_type_ia64_quad = - build_flt (-1, "builtin_type_ia64_quad", floatformats_ia64_quad); - - add_setshow_zinteger_cmd ("overload", no_class, &overload_debug, _("\ -Set debugging of C++ overloading."), _("\ -Show debugging of C++ overloading."), _("\ -When enabled, ranking of the functions is displayed."), + add_setshow_zinteger_cmd ("overload", no_class, &overload_debug, + _("Set debugging of C++ overloading."), + _("Show debugging of C++ overloading."), + _("When enabled, ranking of the " + "functions is displayed."), NULL, show_overload_debug, &setdebuglist, &showdebuglist); /* Add user knob for controlling resolution of opaque types. */ add_setshow_boolean_cmd ("opaque-type-resolution", class_support, - &opaque_type_resolution, _("\ -Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\ -Show resolution of opaque struct/class/union types (if set before loading symbols)."), NULL, - NULL, + &opaque_type_resolution, + _("Set resolution of opaque struct/class/union" + " types (if set before loading symbols)."), + _("Show resolution of opaque struct/class/union" + " types (if set before loading symbols)."), + NULL, NULL, show_opaque_type_resolution, &setlist, &showlist); }