X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbtypes.c;h=dd2ef96a16d0aa11a6882d476e0b720b9697a126;hb=f699aaba87de29fe9764fb96f625962f4e3a5921;hp=f415773dfcc42fee175c0a6e7c4877597eb9382b;hpb=323427d1cbb214ea9710ff62581b5635bebb32f3;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index f415773dfc..dd2ef96a16 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, 2008, 2009 Free Software Foundation, Inc. + Copyright (C) 1992-2013 Free Software Foundation, Inc. Contributed by Cygnus Support, using pieces from other GDB modules. @@ -34,27 +33,40 @@ #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" +#include "cp-support.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_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}; +const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS = {3,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 @@ -96,38 +108,37 @@ const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN] = { &floatformat_vax_d }; const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = { - &floatformat_ibm_long_double, - &floatformat_ibm_long_double + &floatformat_ibm_long_double_big, + &floatformat_ibm_long_double_little }; -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; +/* Should opaque types be resolved? */ + +static int opaque_type_resolution = 1; + +/* A flag to enable printing of debugging information of C++ + overloading. */ + +unsigned int overload_debug = 0; -/* Platform-neutral void type. */ -struct type *builtin_type_void; +/* A flag to enable strict type checking. */ -/* Platform-neutral character types. */ -struct type *builtin_type_true_char; -struct type *builtin_type_true_unsigned_char; +static int strict_type_checking = 1; +/* A function to show whether opaque types are resolved. */ -int opaque_type_resolution = 1; static void 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); } -int overload_debug = 0; +/* A function to show whether C++ overload debugging is enabled. */ + static void show_overload_debug (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) @@ -136,53 +147,98 @@ show_overload_debug (struct ui_file *file, int from_tty, value); } -struct extra - { - char str[128]; - int len; - }; /* Maximum extension is 128! FIXME */ - -static void print_bit_vector (B_TYPE *, int); -static void print_arg_types (struct field *, int, int); -static void dump_fn_fieldlists (struct type *, int); -static void print_cplus_stuff (struct type *, int); +/* A function to show the status of strict type checking. */ +static void +show_strict_type_checking (struct ui_file *file, int from_tty, + struct cmd_list_element *c, const char *value) +{ + fprintf_filtered (file, _("Strict type checking is %s.\n"), value); +} -/* 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 = XZALLOC (struct type); - TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type); - } - else - { - type = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct type); - TYPE_MAIN_TYPE (type) = OBSTACK_ZALLOC (&objfile->objfile_obstack, - struct main_type); - OBJSTAT (objfile, n_types++); - } + 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; } +/* 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. */ @@ -194,7 +250,7 @@ alloc_type_instance (struct type *oldtype) /* Allocate the structure. */ - if (TYPE_OBJFILE (oldtype) == NULL) + if (! TYPE_OBJFILE_OWNED (oldtype)) type = XZALLOC (struct type); else type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack, @@ -208,12 +264,20 @@ alloc_type_instance (struct type *oldtype) } /* 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; @@ -229,7 +293,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); @@ -248,28 +311,25 @@ 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; TYPE_POINTER_TYPE (type) = ntype; - /* FIXME! Assume the machine has only one representation for - pointers! */ + /* FIXME! Assumes 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 @@ -277,9 +337,6 @@ make_pointer_type (struct type *type, struct type **typeptr) gdbarch_address_to_pointer. */ TYPE_UNSIGNED (ntype) = 1; - if (!TYPE_POINTER_TYPE (type)) /* Remember it, if don't have one. */ - TYPE_POINTER_TYPE (type) = ntype; - /* Update the length of all the other variants of this type. */ chain = TYPE_CHAIN (ntype); while (chain != ntype) @@ -309,7 +366,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); @@ -328,18 +384,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; @@ -349,7 +403,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. */ @@ -378,18 +433,16 @@ lookup_reference_type (struct type *type) /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points to a pointer to memory where the function type should be stored. If *TYPEPTR is zero, update it to point to the - function type we return. We allocate new memory from OBJFILE if needed; use - NULL for permanent types. */ + function type we return. We allocate new memory if needed. */ struct type * -make_function_type (struct type *type, struct type **typeptr, - struct objfile *objfile) +make_function_type (struct type *type, struct type **typeptr) { struct type *ntype; /* New type */ if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */ { - ntype = alloc_type (objfile); + ntype = alloc_type_copy (type); if (typeptr) *typeptr = ntype; } @@ -397,7 +450,6 @@ make_function_type (struct type *type, struct type **typeptr, { ntype = *typeptr; smash_type (ntype); - TYPE_OBJFILE (ntype) = objfile; } TYPE_TARGET_TYPE (ntype) = type; @@ -405,26 +457,65 @@ 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; } - /* Given a type TYPE, return a type of functions that return that type. May need to construct such a type if this is the first use. */ struct type * lookup_function_type (struct type *type) { - return make_function_type (type, (struct type **) 0, TYPE_OBJFILE (type)); + return make_function_type (type, (struct type **) 0); +} + +/* Given a type TYPE and argument types, return the appropriate + function type. If the final type in PARAM_TYPES is NULL, make a + varargs function. */ + +struct type * +lookup_function_type_with_arguments (struct type *type, + int nparams, + struct type **param_types) +{ + struct type *fn = make_function_type (type, (struct type **) 0); + int i; + + if (nparams > 0) + { + if (param_types[nparams - 1] == NULL) + { + --nparams; + TYPE_VARARGS (fn) = 1; + } + else if (TYPE_CODE (check_typedef (param_types[nparams - 1])) + == TYPE_CODE_VOID) + { + --nparams; + /* Caller should have ensured this. */ + gdb_assert (nparams == 0); + TYPE_PROTOTYPED (fn) = 1; + } + } + + TYPE_NFIELDS (fn) = nparams; + TYPE_FIELDS (fn) = TYPE_ZALLOC (fn, nparams * sizeof (struct field)); + for (i = 0; i < nparams; ++i) + TYPE_FIELD_TYPE (fn, i) = param_types[i]; + + return fn; } /* Identify address space identifier by name -- return the integer flag defined in gdbtypes.h. */ -extern int -address_space_name_to_int (char *space_identifier) + +int +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_INSTANCE_FLAG_CODE_SPACE; @@ -443,9 +534,8 @@ 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_INSTANCE_FLAG_CODE_SPACE) return "code"; else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE) @@ -523,7 +613,6 @@ 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_INSTANCE_FLAG_CODE_SPACE | TYPE_INSTANCE_FLAG_DATA_SPACE @@ -544,17 +633,17 @@ make_type_with_address_space (struct type *type, int space_flag) in the same objfile. Otherwise, allocate fresh memory for the new type whereever TYPE lives. If TYPEPTR is non-zero, set it to the new type we construct. */ + struct type * make_cv_type (int cnst, int voltl, struct type *type, 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_INSTANCE_FLAG_CONST | TYPE_INSTANCE_FLAG_VOLATILE)); + & ~(TYPE_INSTANCE_FLAG_CONST + | TYPE_INSTANCE_FLAG_VOLATILE)); if (cnst) new_flags |= TYPE_INSTANCE_FLAG_CONST; @@ -588,6 +677,17 @@ make_cv_type (int cnst, int voltl, return ntype; } +/* Make a 'restrict'-qualified version of TYPE. */ + +struct type * +make_restrict_type (struct type *type) +{ + return make_qualified_type (type, + (TYPE_INSTANCE_FLAGS (type) + | TYPE_INSTANCE_FLAG_RESTRICT), + NULL); +} + /* Replace the contents of ntype with the type *type. This changes the contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus the changes are propogated to all types in the TYPE_CHAIN. @@ -597,6 +697,7 @@ make_cv_type (int cnst, int voltl, smashing is ugly, and needs to be replaced with something more controlled. TYPE_MAIN_TYPE is a step in this direction; it's not clear if more steps are needed. */ + void replace_type (struct type *ntype, struct type *type) { @@ -643,7 +744,7 @@ 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; } @@ -655,11 +756,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 (to_type); - TYPE_CODE (mtype) = TYPE_CODE_METHODPTR; + mtype = alloc_type_copy (to_type); + smash_to_methodptr_type (mtype, to_type); return mtype; } @@ -674,8 +772,10 @@ 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; @@ -693,20 +793,18 @@ 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_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) = TYPE_ZALLOC (result_type, - TYPE_NFIELDS (result_type) - * sizeof (struct field)); + 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; @@ -734,16 +832,16 @@ 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. */ @@ -785,6 +883,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. @@ -804,9 +946,8 @@ 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) @@ -826,13 +967,25 @@ create_array_type (struct type *result_type, 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_TARGET_STUB (result_type) = 1; return result_type; } +struct type * +lookup_array_range_type (struct type *element_type, + LONGEST low_bound, LONGEST 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 create_array_type (NULL, element_type, range_type); +} + /* Create a string type using either a blank type supplied in RESULT_TYPE, or creating a new type. String types are similar enough to array of char types that we can use create_array_type to @@ -846,13 +999,10 @@ 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); @@ -860,13 +1010,24 @@ create_string_type (struct type *result_type, return result_type; } +struct type * +lookup_string_range_type (struct type *string_char_type, + LONGEST low_bound, LONGEST 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) = TYPE_ZALLOC (result_type, sizeof (struct field)); @@ -874,6 +1035,7 @@ create_set_type (struct type *result_type, struct type *domain_type) 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; @@ -887,39 +1049,6 @@ create_set_type (struct type *result_type, struct type *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_ZALLOC (type, nfields * sizeof (struct field)); - - return type; -} - /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE and any array types nested inside it. */ @@ -938,7 +1067,7 @@ 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; } @@ -950,11 +1079,8 @@ 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; } @@ -974,20 +1100,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'. @@ -1000,12 +1138,7 @@ 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; @@ -1019,7 +1152,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) @@ -1031,68 +1164,89 @@ 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; + struct type *type; sym = lookup_symbol (name, block, VAR_DOMAIN, 0); - 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)); + if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF) + return SYMBOL_TYPE (sym); + + type = language_lookup_primitive_type_by_name (language, gdbarch, name); + if (type) + return type; + + 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, const struct block *block) { struct symbol *sym; @@ -1114,7 +1268,7 @@ 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, const struct block *block) { struct symbol *sym; struct type *t; @@ -1129,24 +1283,16 @@ lookup_union (char *name, struct block *block) 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; - /* If we get here, it's not a union. */ error (_("This context has class, struct or enum %s, not a union."), name); } - /* Lookup an enum type named "enum NAME", visible in lexical block BLOCK. */ struct type * -lookup_enum (char *name, struct block *block) +lookup_enum (const char *name, const struct block *block) { struct symbol *sym; @@ -1168,15 +1314,16 @@ lookup_enum (char *name, struct block *block) struct type * lookup_template_type (char *name, struct type *type, - struct block *block) + const struct block *block) { 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); @@ -1208,6 +1355,7 @@ struct type * lookup_struct_elt_type (struct type *type, char *name, int noerr) { int i; + char *typename; for (;;) { @@ -1221,17 +1369,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; @@ -1244,12 +1390,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. */ @@ -1269,14 +1423,9 @@ 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); } /* Lookup the vptr basetype/fieldno values for TYPE. @@ -1286,7 +1435,8 @@ lookup_struct_elt_type (struct type *type, char *name, int noerr) 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 or incomplete. */ @@ -1311,7 +1461,7 @@ get_vptr_fieldno (struct type *type, struct type **basetypep) if (fieldno >= 0) { /* If the type comes from a different objfile we can't cache - it, it may have a different lifetime. PR 2384 */ + it, it may have a different lifetime. PR 2384 */ if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype)) { TYPE_VPTR_FIELDNO (type) = fieldno; @@ -1334,63 +1484,47 @@ get_vptr_fieldno (struct type *type, struct type **basetypep) } } -/* 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++) - { - 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; - } - } - } - return 0; -} - static void 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); @@ -1398,13 +1532,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 @@ -1414,19 +1548,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); 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 @@ -1438,12 +1595,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); @@ -1460,7 +1618,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; } @@ -1469,26 +1629,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); 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); } @@ -1501,7 +1663,7 @@ 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 @@ -1512,16 +1674,34 @@ check_typedef (struct type *type) 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 int low_bound = TYPE_LOW_BOUND (range_type); - const int high_bound = TYPE_HIGH_BOUND (range_type); - int nb_elements; - + 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) - nb_elements = 0; + len = 0; else - nb_elements = high_bound - low_bound + 1; - - TYPE_LENGTH (type) = nb_elements * TYPE_LENGTH (target_type); + { + /* 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) @@ -1530,27 +1710,37 @@ check_typedef (struct type *type) 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); @@ -1572,10 +1762,11 @@ 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, - DMGL_PARAMS | DMGL_ANSI); + char *demangled_name = gdb_demangle (mangled_name, + DMGL_PARAMS | DMGL_ANSI); char *argtypetext, *p; int depth = 0, argcount = 1; struct field *argtypes; @@ -1632,7 +1823,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) @@ -1645,7 +1836,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; @@ -1726,30 +1917,47 @@ 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 it is used to initialize the type name. + Note that NAME is not copied; it is required to have a lifetime at + least as long as OBJFILE. */ struct type * init_type (enum type_code code, int length, int flags, - char *name, struct objfile *objfile) + const char *name, struct objfile *objfile) { struct type *type; @@ -1778,94 +1986,36 @@ init_type (enum type_code code, int length, int flags, TYPE_VECTOR (type) = 1; if (flags & TYPE_FLAG_STUB_SUPPORTED) TYPE_STUB_SUPPORTED (type) = 1; - if (flags & TYPE_FLAG_NOTTEXT) - TYPE_NOTTEXT (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 != NULL) && (objfile != NULL)) - { - TYPE_NAME (type) = obsavestring (name, strlen (name), - &objfile->objfile_obstack); - } - else - { - TYPE_NAME (type) = name; - } + TYPE_NAME (type) = name; /* C++ fancies. */ if (name && strcmp (name, "char") == 0) TYPE_NOSIGN (type) = 1; - if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION - || code == TYPE_CODE_NAMESPACE) + switch (code) { - INIT_CPLUS_SPECIFIC (type); + 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; } - -/* Helper function. Create an empty composite type. */ - -struct type * -init_composite_type (char *name, enum type_code code) -{ - 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; -} - -/* Helper function. Append a field to a composite type. */ - -void -append_composite_type_field_aligned (struct type *t, char *name, - struct type *field, int alignment) -{ - 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) - { - 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) - { - FIELD_BITPOS (f[0]) = (FIELD_BITPOS (f[-1]) - + (TYPE_LENGTH (FIELD_TYPE (f[-1])) - * TARGET_CHAR_BIT)); - - if (alignment) - { - int left = FIELD_BITPOS (f[0]) % (alignment * TARGET_CHAR_BIT); - if (left) - { - FIELD_BITPOS (f[0]) += left; - TYPE_LENGTH (t) += left / TARGET_CHAR_BIT; - } - } - } - } -} - -void -append_composite_type_field (struct type *t, char *name, - struct type *field) -{ - append_composite_type_field_aligned (t, name, field, 0); -} + +/* Queries on types. */ int can_dereference (struct type *t) @@ -1893,36 +2043,251 @@ is_integral_type (struct type *t) || (TYPE_CODE (t) == TYPE_CODE_BOOL))); } -/* 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. */ +/* Return true if TYPE is scalar. */ + +static int +is_scalar_type (struct type *type) +{ + CHECK_TYPEDEF (type); + + switch (TYPE_CODE (type)) + { + case TYPE_CODE_ARRAY: + case TYPE_CODE_STRUCT: + case TYPE_CODE_UNION: + case TYPE_CODE_SET: + case TYPE_CODE_STRING: + return 0; + default: + return 1; + } +} + +/* 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_ancestor (struct type *base, struct type *dclass) +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) + { + 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; +} + +/* 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. */ + +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)))); +} + +/* If BASE is an ancestor of DCLASS return the distance between them. + otherwise return -1; + eg: + + 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 + + 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: + + distance_to_ancestor (A, D, 1) = -1. */ + +static int +distance_to_ancestor (struct type *base, struct type *dclass, int public) { int i; + int d; 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; + if (class_types_same_p (base, dclass)) + return 0; for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++) - if (is_ancestor (base, TYPE_BASECLASS (dclass, i))) - return 1; + { + if (public && ! BASETYPE_VIA_PUBLIC (dclass, i)) + continue; - return 0; + d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), public); + if (d >= 0) + return 1 + d; + } + + 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 +is_ancestor (struct type *base, struct type *dclass) +{ + 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_public_ancestor (struct type *base, struct type *dclass) +{ + return distance_to_ancestor (base, dclass, 1) >= 0; +} + +/* A helper function for is_unique_ancestor. */ + +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, count = 0; + + CHECK_TYPEDEF (base); + CHECK_TYPEDEF (dclass); + + for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i) + { + struct type *iter; + int this_offset; + + iter = check_typedef (TYPE_BASECLASS (dclass, i)); + + 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; +} + +/* Overload resolution. */ + +/* Return the sum of the rank of A with the rank of B. */ + +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; -/* Functions for overload resolution begin here */ + /* 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 @@ -1945,7 +2310,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) @@ -1976,14 +2341,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. @@ -1993,13 +2358,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; @@ -2044,25 +2412,91 @@ 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. */ + +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; + + /* Two function types are equal if their argument and return types + are equal. */ + if (TYPE_CODE (a) == TYPE_CODE_FUNC) + { + int i; + + if (TYPE_NFIELDS (a) != TYPE_NFIELDS (b)) + return 0; + + if (!types_equal (TYPE_TARGET_TYPE (a), TYPE_TARGET_TYPE (b))) + return 0; + + for (i = 0; i < TYPE_NFIELDS (a); ++i) + if (!types_equal (TYPE_FIELD_TYPE (a, i), TYPE_FIELD_TYPE (b, i))) + return 0; + + 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) @@ -2070,29 +2504,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, @@ -2100,7 +2519,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)) { @@ -2108,23 +2527,49 @@ 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) + { + if (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; + } + else + { + /* If type checking is disabled, allow the conversion. */ + if (!strict_type_checking) + return NS_INTEGER_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; } @@ -2134,7 +2579,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; } @@ -2142,7 +2587,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; } @@ -2156,9 +2601,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; } @@ -2170,14 +2615,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 { @@ -2185,16 +2632,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), @@ -2260,19 +2709,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: @@ -2297,15 +2746,25 @@ rank_one_type (struct type *parm, struct type *arg) case TYPE_CODE_BOOL: switch (TYPE_CODE (arg)) { + /* n3290 draft, section 4.12.1 (conv.bool): + + "A prvalue of arithmetic, unscoped enumeration, pointer, or + pointer to member type can be converted to a prvalue of type + bool. A zero value, null pointer value, or null member pointer + value is converted to false; any other value is converted to + true. A prvalue of type std::nullptr_t can be converted to a + prvalue of type bool; the resulting value is false." */ case TYPE_CODE_INT: case TYPE_CODE_CHAR: - case TYPE_CODE_RANGE: case TYPE_CODE_ENUM: case TYPE_CODE_FLT: + case TYPE_CODE_MEMBERPTR: case TYPE_CODE_PTR: - return BOOLEAN_CONVERSION_BADNESS; + return BOOL_CONVERSION_BADNESS; + case TYPE_CODE_RANGE: + return INCOMPATIBLE_TYPE_BADNESS; case TYPE_CODE_BOOL: - return 0; + return EXACT_MATCH_BADNESS; default: return INCOMPATIBLE_TYPE_BADNESS; } @@ -2317,7 +2776,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: @@ -2336,19 +2795,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; @@ -2392,7 +2852,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; } @@ -2403,8 +2863,9 @@ rank_one_type (struct type *parm, struct type *arg) } /* switch (TYPE_CODE (arg)) */ } - -/* End of functions for overload resolution */ +/* End of functions for overload resolution. */ + +/* Routines to pretty-print types. */ static void print_bit_vector (B_TYPE *bits, int nbits) @@ -2447,9 +2908,7 @@ field_is_static (struct field *f) 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 (at least as long as - we assume that DWARF block locations are not going to be used - for static fields). FIXME? */ + 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); } @@ -2529,8 +2988,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 *", @@ -2576,6 +3033,17 @@ 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_gnat_stuff (struct type *type, int spaces) +{ + struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type); + + recursive_dump_type (descriptive_type, spaces + 2); +} + static struct obstack dont_print_type_obstack; void @@ -2587,7 +3055,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); @@ -2665,9 +3133,6 @@ recursive_dump_type (struct type *type, int spaces) case TYPE_CODE_STRING: printf_filtered ("(TYPE_CODE_STRING)"); break; - case TYPE_CODE_BITSTRING: - printf_filtered ("(TYPE_CODE_BITSTRING)"); - break; case TYPE_CODE_ERROR: printf_filtered ("(TYPE_CODE_ERROR)"); break; @@ -2695,12 +3160,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; @@ -2710,8 +3169,16 @@ recursive_dump_type (struct type *type, int spaces) } puts_filtered ("\n"); printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type)); - 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); @@ -2755,6 +3222,10 @@ recursive_dump_type (struct type *type, int spaces) { puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2"); } + if (TYPE_RESTRICT (type)) + { + puts_filtered (" TYPE_FLAG_RESTRICT"); + } puts_filtered ("\n"); printfi_filtered (spaces, "flags"); @@ -2815,10 +3286,15 @@ recursive_dump_type (struct type *type, int spaces) 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 +3307,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,59 +3325,60 @@ 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); } - + /* Trivial helpers for the libiberty hash table, for mapping one type to another. */ @@ -2905,6 +3391,7 @@ static hashval_t type_pair_hash (const void *item) { const struct type_pair *pair = item; + return htab_hash_pointer (pair->old); } @@ -2912,6 +3399,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 +3430,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,11 +3442,12 @@ 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 = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair)); + stored + = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair)); stored->old = type; stored->new = new_type; *slot = stored; @@ -2966,7 +3455,8 @@ copy_type_recursive (struct objfile *objfile, /* Copy the common fields of types. For the main type, we simply copy the entire thing and then update specific fields as needed. */ *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type); - TYPE_OBJFILE (new_type) = NULL; + 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)); @@ -3001,6 +3491,10 @@ copy_type_recursive (struct objfile *objfile, 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)); @@ -3018,6 +3512,13 @@ copy_type_recursive (struct objfile *objfile, } } + /* 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) = @@ -3039,7 +3540,6 @@ 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); @@ -3057,9 +3557,9 @@ copy_type (const struct type *type) { struct type *new_type; - gdb_assert (TYPE_OBJFILE (type) != NULL); + gdb_assert (TYPE_OBJFILE_OWNED (type)); - new_type = alloc_type (TYPE_OBJFILE (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), @@ -3067,9 +3567,89 @@ copy_type (const struct type *type) return new_type; } + +/* Helper functions to initialize architecture-specific types. */ -static struct type * -build_flt (int bit, char *name, const struct floatformat **floatformats) +/* 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; @@ -3081,134 +3661,412 @@ 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. */ -const struct builtin_type * -builtin_type (struct gdbarch *gdbarch) +struct type * +arch_complex_type (struct gdbarch *gdbarch, + char *name, struct type *target_type) { - return gdbarch_data (gdbarch, gdbtypes_data); + struct type *t; + + 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. */ -static struct type * -build_complex (int bit, char *name, struct type *target_type) +struct type * +arch_flags_type (struct gdbarch *gdbarch, char *name, int length) { - struct type *t; - if (bit <= 0 || target_type == builtin_type_error) + 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) { - gdb_assert (builtin_type_error != NULL); - return builtin_type_error; + TYPE_FIELD_NAME (type, bitpos) = xstrdup (name); + SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), bitpos); } - t = init_type (TYPE_CODE_COMPLEX, 2 * bit / TARGET_CHAR_BIT, - 0, name, (struct objfile *) NULL); - TYPE_TARGET_TYPE (t) = target_type; + else + { + /* Don't show this field to the user. */ + SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), -1); + } +} + +/* 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; + + 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) + { + 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; + } + } + } + } +} + +/* 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 * 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_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, - "_Decimal32", (struct objfile *) NULL); + = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 32 / 8, "_Decimal32"); builtin_type->builtin_decdouble - = init_type (TYPE_CODE_DECFLOAT, 64 / 8, - 0, - "_Decimal64", (struct objfile *) NULL); + = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 64 / 8, "_Decimal64"); builtin_type->builtin_declong - = init_type (TYPE_CODE_DECFLOAT, 128 / 8, - 0, - "_Decimal128", (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, + ""); + + return builtin_type; +} + +/* This set of objfile-based types is intended to be used by symbol + readers as basic types. */ - /* Pointer/Address 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, @@ -3232,142 +4090,54 @@ 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); +extern initialize_file_ftype _initialize_gdbtypes; + 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); - - builtin_type_void = - init_type (TYPE_CODE_VOID, 1, - 0, - "void", (struct objfile *) NULL); - builtin_type_true_char = - init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, - "true character", (struct objfile *) NULL); - builtin_type_true_unsigned_char = - init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "true character", (struct objfile *) NULL); - - 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_setshow_zuinteger_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); + + /* Add an option to permit non-strict type checking. */ + add_setshow_boolean_cmd ("type", class_support, + &strict_type_checking, + _("Set strict type checking."), + _("Show strict type checking."), + NULL, NULL, + show_strict_type_checking, + &setchecklist, &showchecklist); }