X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbtypes.c;h=f43983a072aecc0b80ae44166c8eb944ddb31434;hb=053cb41bd346a104eefeda533bc1388812e7fdf6;hp=d954bd55aa768ddba5b97e2a1cc203eaa5217464;hpb=54a5b07d668e9320efb1ada27582f859ccfaaaf3;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index d954bd55aa..f43983a072 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -1,6 +1,8 @@ /* Support routines for manipulating internal types for GDB. - Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, - 2004 Free Software Foundation, Inc. + + Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, + 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. + Contributed by Cygnus Support, using pieces from other GDB modules. This file is part of GDB. @@ -17,8 +19,8 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ #include "defs.h" #include "gdb_string.h" @@ -37,6 +39,7 @@ #include "wrapper.h" #include "cp-abi.h" #include "gdb_assert.h" +#include "hashtab.h" /* These variables point to the objects representing the predefined C data types. */ @@ -94,32 +97,80 @@ struct type *builtin_type_v8hi; struct type *builtin_type_v4hi; struct type *builtin_type_v2si; struct type *builtin_type_vec64; -struct type *builtin_type_vec64i; struct type *builtin_type_vec128; -struct type *builtin_type_vec128i; -struct type *builtin_type_ieee_single_big; -struct type *builtin_type_ieee_single_little; -struct type *builtin_type_ieee_double_big; -struct type *builtin_type_ieee_double_little; -struct type *builtin_type_ieee_double_littlebyte_bigword; + +/* Floatformat pairs. */ +const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN] = { + &floatformat_ieee_single_big, + &floatformat_ieee_single_little +}; +const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN] = { + &floatformat_ieee_double_big, + &floatformat_ieee_double_little +}; +const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN] = { + &floatformat_ieee_double_big, + &floatformat_ieee_double_littlebyte_bigword +}; +const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN] = { + &floatformat_i387_ext, + &floatformat_i387_ext +}; +const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN] = { + &floatformat_m68881_ext, + &floatformat_m68881_ext +}; +const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN] = { + &floatformat_arm_ext_big, + &floatformat_arm_ext_littlebyte_bigword +}; +const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN] = { + &floatformat_ia64_spill_big, + &floatformat_ia64_spill_little +}; +const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN] = { + &floatformat_ia64_quad_big, + &floatformat_ia64_quad_little +}; +const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN] = { + &floatformat_vax_f, + &floatformat_vax_f +}; +const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN] = { + &floatformat_vax_d, + &floatformat_vax_d +}; + +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_i960_ext; -struct type *builtin_type_m88110_ext; -struct type *builtin_type_m88110_harris_ext; -struct type *builtin_type_arm_ext_big; -struct type *builtin_type_arm_ext_littlebyte_bigword; -struct type *builtin_type_ia64_spill_big; -struct type *builtin_type_ia64_spill_little; -struct type *builtin_type_ia64_quad_big; -struct type *builtin_type_ia64_quad_little; +struct type *builtin_type_arm_ext; +struct type *builtin_type_ia64_spill; +struct type *builtin_type_ia64_quad; + struct type *builtin_type_void_data_ptr; struct type *builtin_type_void_func_ptr; struct type *builtin_type_CORE_ADDR; struct type *builtin_type_bfd_vma; 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"), + value); +} + int overload_debug = 0; +static void +show_overload_debug (struct ui_file *file, int from_tty, + struct cmd_list_element *c, const char *value) +{ + fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"), value); +} struct extra { @@ -225,6 +276,7 @@ make_pointer_type (struct type *type, struct type **typeptr) { struct type *ntype; /* New type */ struct objfile *objfile; + struct type *chain; ntype = TYPE_POINTER_TYPE (type); @@ -250,7 +302,9 @@ make_pointer_type (struct type *type, struct type **typeptr) { ntype = *typeptr; objfile = TYPE_OBJFILE (ntype); + chain = TYPE_CHAIN (ntype); smash_type (ntype); + TYPE_CHAIN (ntype) = chain; TYPE_OBJFILE (ntype) = objfile; } @@ -270,6 +324,14 @@ make_pointer_type (struct type *type, struct type **typeptr) 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) + { + TYPE_LENGTH (chain) = TYPE_LENGTH (ntype); + chain = TYPE_CHAIN (chain); + } + return ntype; } @@ -406,7 +468,7 @@ address_space_name_to_int (char *space_identifier) &type_flags)) return type_flags; else - error ("Unknown address space specifier: \"%s\"", space_identifier); + error (_("Unknown address space specifier: \"%s\""), space_identifier); } /* Identify address space identifier by integer flag as defined in @@ -428,7 +490,9 @@ address_space_int_to_name (int space_flag) } /* Create a new type with instance flags NEW_FLAGS, based on TYPE. - If STORAGE is non-NULL, create the new type instance there. */ + + If STORAGE is non-NULL, create the new type instance there. + STORAGE must be in the same obstack as TYPE. */ static struct type * make_qualified_type (struct type *type, int new_flags, @@ -448,6 +512,12 @@ make_qualified_type (struct type *type, int new_flags, ntype = alloc_type_instance (type); else { + /* If STORAGE was provided, it had better be in the same objfile as + TYPE. Otherwise, we can't link it into TYPE's cv chain: if one + objfile is freed and the other kept, we'd have dangling + pointers. */ + gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage)); + ntype = storage; TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type); TYPE_CHAIN (ntype) = ntype; @@ -496,11 +566,12 @@ make_type_with_address_space (struct type *type, int space_flag) CNST is a flag for setting the const attribute VOLTL is a flag for setting the volatile attribute TYPE is the base type whose variant we are creating. - TYPEPTR, if nonzero, points - to a pointer to memory where the reference type should be stored. - If *TYPEPTR is zero, update it to point to the reference type we return. - We allocate new memory if needed. */ + If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to + storage to hold the new qualified type; *TYPEPTR and TYPE must be + 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) { @@ -519,20 +590,19 @@ make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr) if (typeptr && *typeptr != NULL) { - /* Objfile is per-core-type. This const-qualified type had best - belong to the same objfile as the type it is qualifying, unless - we are overwriting a stub type, in which case the safest thing - to do is to copy the core type into the new objfile. */ + /* TYPE and *TYPEPTR must be in the same objfile. We can't have + a C-V variant chain that threads across objfiles: if one + objfile gets freed, then the other has a broken C-V chain. - gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type) - || TYPE_STUB (*typeptr)); - if (TYPE_OBJFILE (*typeptr) != TYPE_OBJFILE (type)) - { - TYPE_MAIN_TYPE (*typeptr) - = TYPE_ALLOC (*typeptr, sizeof (struct main_type)); - *TYPE_MAIN_TYPE (*typeptr) - = *TYPE_MAIN_TYPE (type); - } + This code used to try to copy over the main type from TYPE to + *TYPEPTR if they were in different objfiles, but that's + wrong, too: TYPE may have a field list or member function + lists, which refer to types of their own, etc. etc. The + whole shebang would need to be copied over recursively; you + can't have inter-objfile pointers. The only thing to do is + to leave stub types as stub types, and look them up afresh by + name each time you encounter them. */ + gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type)); } ntype = make_qualified_type (type, new_flags, typeptr ? *typeptr : NULL); @@ -557,6 +627,12 @@ replace_type (struct type *ntype, struct type *type) { struct type *chain; + /* These two types had better be in the same objfile. Otherwise, + the assignment of one type's main type structure to the other + will produce a type with references to objects (names; field + lists; etc.) allocated on an objfile other than its own. */ + gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype)); + *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type); /* The type length is not a part of the main type. Update it for each @@ -571,7 +647,7 @@ replace_type (struct type *ntype, struct type *type) call replace_type(). */ gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0); - TYPE_LENGTH (ntype) = TYPE_LENGTH (type); + TYPE_LENGTH (chain) = TYPE_LENGTH (type); chain = TYPE_CHAIN (chain); } while (ntype != chain); @@ -586,15 +662,30 @@ replace_type (struct type *ntype, struct type *type) of the aggregate that the member belongs to. */ struct type * -lookup_member_type (struct type *type, struct type *domain) +lookup_memberptr_type (struct type *type, struct type *domain) { struct type *mtype; mtype = alloc_type (TYPE_OBJFILE (type)); - smash_to_member_type (mtype, domain, type); + smash_to_memberptr_type (mtype, domain, type); return (mtype); } +/* Return a pointer-to-method type, for a method of type TO_TYPE. */ + +struct type * +lookup_methodptr_type (struct type *to_type) +{ + struct type *mtype; + + mtype = alloc_type (TYPE_OBJFILE (to_type)); + TYPE_TARGET_TYPE (mtype) = to_type; + TYPE_DOMAIN_TYPE (mtype) = TYPE_DOMAIN_TYPE (to_type); + TYPE_LENGTH (mtype) = cplus_method_ptr_size (); + TYPE_CODE (mtype) = TYPE_CODE_METHODPTR; + return mtype; +} + /* Allocate a stub method whose return type is TYPE. This apparently happens for speed of symbol reading, since parsing out the arguments to the method is cpu-intensive, the way we are doing @@ -652,7 +743,7 @@ create_range_type (struct type *result_type, struct type *index_type, } /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE. - Return 1 of type is a range type, 0 if it is discrete (and bounds + Return 1 if type is a range type, 0 if it is discrete (and bounds will fit in LONGEST), or -1 otherwise. */ int @@ -815,6 +906,39 @@ 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_ALLOC (type, nfields * sizeof (struct field)); + memset (TYPE_FIELDS (type), 0, nfields * sizeof (struct field)); + + return type; +} + /* Construct and return a type of the form: struct NAME { ELT_TYPE ELT_NAME[N]; } We use these types for SIMD registers. For example, the type of @@ -883,34 +1007,6 @@ build_builtin_type_vec64 (void) return t; } -static struct type * -build_builtin_type_vec64i (void) -{ - /* Construct a type for the 64 bit registers. The type we're - building is this: */ -#if 0 - union __gdb_builtin_type_vec64i - { - int64_t uint64; - int32_t v2_int32[2]; - int16_t v4_int16[4]; - int8_t v8_int8[8]; - }; -#endif - - struct type *t; - - t = init_composite_type ("__gdb_builtin_type_vec64i", TYPE_CODE_UNION); - append_composite_type_field (t, "uint64", builtin_type_int64); - append_composite_type_field (t, "v2_int32", builtin_type_v2_int32); - append_composite_type_field (t, "v4_int16", builtin_type_v4_int16); - append_composite_type_field (t, "v8_int8", builtin_type_v8_int8); - - TYPE_FLAGS (t) |= TYPE_FLAG_VECTOR; - TYPE_NAME (t) = "builtin_type_vec64i"; - return t; -} - static struct type * build_builtin_type_vec128 (void) { @@ -941,39 +1037,20 @@ build_builtin_type_vec128 (void) return t; } -static struct type * -build_builtin_type_vec128i (void) -{ - /* 128-bit Intel SIMD registers */ - struct type *t; - - t = init_composite_type ("__gdb_builtin_type_vec128i", TYPE_CODE_UNION); - append_composite_type_field (t, "v4_float", builtin_type_v4_float); - append_composite_type_field (t, "v2_double", builtin_type_v2_double); - append_composite_type_field (t, "v16_int8", builtin_type_v16_int8); - append_composite_type_field (t, "v8_int16", builtin_type_v8_int16); - append_composite_type_field (t, "v4_int32", builtin_type_v4_int32); - append_composite_type_field (t, "v2_int64", builtin_type_v2_int64); - append_composite_type_field (t, "uint128", builtin_type_int128); - - TYPE_FLAGS (t) |= TYPE_FLAG_VECTOR; - TYPE_NAME (t) = "builtin_type_vec128i"; - return t; -} - -/* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE. - A MEMBER is a wierd thing -- it amounts to a typed offset into - a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't - include the offset (that's the value of the MEMBER itself), but does - include the structure type into which it points (for some reason). +/* Smash TYPE to be a type of pointers to members of DOMAIN with type + TO_TYPE. A member pointer is a wierd thing -- it amounts to a + typed offset into a struct, e.g. "an int at offset 8". A MEMBER + TYPE doesn't include the offset (that's the value of the MEMBER + itself), but does include the structure type into which it points + (for some reason). 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_member_type (struct type *type, struct type *domain, - struct type *to_type) +smash_to_memberptr_type (struct type *type, struct type *domain, + struct type *to_type) { struct objfile *objfile; @@ -983,8 +1060,10 @@ smash_to_member_type (struct type *type, struct type *domain, TYPE_OBJFILE (type) = objfile; TYPE_TARGET_TYPE (type) = to_type; TYPE_DOMAIN_TYPE (type) = domain; - TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */ - TYPE_CODE (type) = TYPE_CODE_MEMBER; + /* Assume that a data member pointer is the same size as a normal + pointer. */ + TYPE_LENGTH (type) = TARGET_PTR_BIT / TARGET_CHAR_BIT; + TYPE_CODE (type) = TYPE_CODE_MEMBERPTR; } /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE. @@ -1056,7 +1135,7 @@ lookup_typename (char *name, struct block *block, int noerr) } else { - error ("No type named %s.", name); + error (_("No type named %s."), name); } } return (SYMBOL_TYPE (sym)); @@ -1100,11 +1179,11 @@ lookup_struct (char *name, struct block *block) if (sym == NULL) { - error ("No struct type named %s.", name); + error (_("No struct type named %s."), name); } if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT) { - error ("This context has class, union or enum %s, not a struct.", name); + error (_("This context has class, union or enum %s, not a struct."), name); } return (SYMBOL_TYPE (sym)); } @@ -1122,7 +1201,7 @@ lookup_union (char *name, struct block *block) (struct symtab **) NULL); if (sym == NULL) - error ("No union type named %s.", name); + error (_("No union type named %s."), name); t = SYMBOL_TYPE (sym); @@ -1137,7 +1216,7 @@ lookup_union (char *name, struct block *block) return (t); /* If we get here, it's not a union */ - error ("This context has class, struct or enum %s, not a union.", name); + error (_("This context has class, struct or enum %s, not a union."), name); } @@ -1153,11 +1232,11 @@ lookup_enum (char *name, struct block *block) (struct symtab **) NULL); if (sym == NULL) { - error ("No enum type named %s.", name); + error (_("No enum type named %s."), name); } if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM) { - error ("This context has class, struct or union %s, not an enum.", name); + error (_("This context has class, struct or union %s, not an enum."), name); } return (SYMBOL_TYPE (sym)); } @@ -1179,11 +1258,11 @@ lookup_template_type (char *name, struct type *type, struct block *block) if (sym == NULL) { - error ("No template type named %s.", name); + error (_("No template type named %s."), name); } if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT) { - error ("This context has class, union or enum %s, not a struct.", name); + error (_("This context has class, union or enum %s, not a struct."), name); } return (SYMBOL_TYPE (sym)); } @@ -1219,7 +1298,7 @@ lookup_struct_elt_type (struct type *type, char *name, int noerr) gdb_flush (gdb_stdout); fprintf_unfiltered (gdb_stderr, "Type "); type_print (type, "", gdb_stderr, -1); - error (" is not a structure or union type."); + error (_(" is not a structure or union type.")); } #if 0 @@ -1251,7 +1330,7 @@ lookup_struct_elt_type (struct type *type, char *name, int noerr) { struct type *t; - t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, noerr); + t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1); if (t != NULL) { return t; @@ -1269,7 +1348,7 @@ lookup_struct_elt_type (struct type *type, char *name, int noerr) type_print (type, "", gdb_stderr, -1); fprintf_unfiltered (gdb_stderr, " has no component named "); fputs_filtered (name, gdb_stderr); - error ("."); + error ((".")); return (struct type *) -1; /* For lint */ } @@ -1334,7 +1413,7 @@ get_destructor_fn_field (struct type *t, int *method_indexp, int *field_indexp) static void stub_noname_complaint (void) { - complaint (&symfile_complaints, "stub type has NULL name"); + complaint (&symfile_complaints, _("stub type has NULL name")); } /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989. @@ -1411,8 +1490,24 @@ check_typedef (struct type *type) return type; } newtype = lookup_transparent_type (name); + if (newtype) - make_cv_type (is_const, is_volatile, newtype, &type); + { + /* If the resolved type and the stub are in the same objfile, + then replace the stub type with the real deal. But if + they're in separate objfiles, leave the stub alone; we'll + just look up the transparent type every time we call + check_typedef. We can't create pointers between types + allocated to different objfiles, since they may have + different lifetimes. Trying to copy NEWTYPE over to TYPE's + objfile is pointless, too, since you'll have to move over any + other types NEWTYPE refers to, which could be an unbounded + amount of stuff. */ + if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type)) + make_cv_type (is_const, is_volatile, newtype, &type); + else + type = newtype; + } } /* Otherwise, rely on the stub flag being set for opaque/stubbed types */ else if (TYPE_STUB (type) && !currently_reading_symtab) @@ -1430,7 +1525,15 @@ check_typedef (struct type *type) } sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0, (struct symtab **) NULL); if (sym) - make_cv_type (is_const, is_volatile, SYMBOL_TYPE (sym), &type); + { + /* Same as above for opaque types, we can replace the stub + with the complete type only if they are int the same + objfile. */ + if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type)) + make_cv_type (is_const, is_volatile, SYMBOL_TYPE (sym), &type); + else + type = SYMBOL_TYPE (sym); + } } if (TYPE_TARGET_STUB (type)) @@ -1519,7 +1622,7 @@ check_stub_method (struct type *type, int method_id, int signature_id) p = NULL; if (demangled_name == NULL || p == NULL) - error ("Internal: Cannot demangle mangled name `%s'.", mangled_name); + error (_("Internal: Cannot demangle mangled name `%s'."), mangled_name); /* Now, read in the parameters that define this type. */ p += 1; @@ -1776,7 +1879,7 @@ lookup_fundamental_type (struct objfile *objfile, int typeid) if (typeid < 0 || typeid >= FT_NUM_MEMBERS) { - error ("internal error - invalid fundamental type id %d", typeid); + error (_("internal error - invalid fundamental type id %d"), typeid); } /* If this is the first time we need a fundamental type for this objfile @@ -1822,6 +1925,7 @@ is_integral_type (struct type *t) ((t != NULL) && ((TYPE_CODE (t) == TYPE_CODE_INT) || (TYPE_CODE (t) == TYPE_CODE_ENUM) + || (TYPE_CODE (t) == TYPE_CODE_FLAGS) || (TYPE_CODE (t) == TYPE_CODE_CHAR) || (TYPE_CODE (t) == TYPE_CODE_RANGE) || (TYPE_CODE (t) == TYPE_CODE_BOOL))); @@ -2374,6 +2478,7 @@ rank_one_type (struct type *parm, struct type *arg) return rank_one_type (TYPE_TARGET_TYPE (parm), arg); case TYPE_CODE_INT: case TYPE_CODE_ENUM: + case TYPE_CODE_FLAGS: case TYPE_CODE_CHAR: case TYPE_CODE_RANGE: case TYPE_CODE_BOOL: @@ -2454,6 +2559,7 @@ rank_one_type (struct type *parm, struct type *arg) else return INTEGER_CONVERSION_BADNESS; case TYPE_CODE_ENUM: + case TYPE_CODE_FLAGS: case TYPE_CODE_CHAR: case TYPE_CODE_RANGE: case TYPE_CODE_BOOL: @@ -2604,7 +2710,7 @@ rank_one_type (struct type *parm, struct type *arg) return INCOMPATIBLE_TYPE_BADNESS; } break; - case TYPE_CODE_MEMBER: + case TYPE_CODE_MEMBERPTR: switch (TYPE_CODE (arg)) { default: @@ -2659,13 +2765,9 @@ print_bit_vector (B_TYPE *bits, int nbits) puts_filtered (" "); } if (B_TST (bits, bitno)) - { - printf_filtered ("1"); - } + printf_filtered (("1")); else - { - printf_filtered ("0"); - } + printf_filtered (("0")); } } @@ -2702,7 +2804,7 @@ dump_fn_fieldlists (struct type *type, int spaces) TYPE_FN_FIELDLIST_NAME (type, method_idx)); gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx), gdb_stdout); - printf_filtered (") length %d\n", + printf_filtered (_(") length %d\n"), TYPE_FN_FIELDLIST_LENGTH (type, method_idx)); for (overload_idx = 0; overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx); @@ -2822,7 +2924,7 @@ print_bound_type (int bt) printf_filtered ("(BOUND_SIMPLE)"); break; default: - printf_filtered ("(unknown bound type)"); + printf_filtered (_("(unknown bound type)")); break; } } @@ -2852,7 +2954,7 @@ recursive_dump_type (struct type *type, int spaces) { printfi_filtered (spaces, "type node "); gdb_print_host_address (type, gdb_stdout); - printf_filtered (" \n"); + printf_filtered (_(" \n")); return; } } @@ -2892,6 +2994,9 @@ recursive_dump_type (struct type *type, int spaces) case TYPE_CODE_ENUM: printf_filtered ("(TYPE_CODE_ENUM)"); break; + case TYPE_CODE_FLAGS: + printf_filtered ("(TYPE_CODE_FLAGS)"); + break; case TYPE_CODE_FUNC: printf_filtered ("(TYPE_CODE_FUNC)"); break; @@ -2919,8 +3024,11 @@ recursive_dump_type (struct type *type, int spaces) case TYPE_CODE_ERROR: printf_filtered ("(TYPE_CODE_ERROR)"); break; - case TYPE_CODE_MEMBER: - printf_filtered ("(TYPE_CODE_MEMBER)"); + case TYPE_CODE_MEMBERPTR: + printf_filtered ("(TYPE_CODE_MEMBERPTR)"); + break; + case TYPE_CODE_METHODPTR: + printf_filtered ("(TYPE_CODE_METHODPTR)"); break; case TYPE_CODE_METHOD: printf_filtered ("(TYPE_CODE_METHOD)"); @@ -3089,11 +3197,26 @@ recursive_dump_type (struct type *type, int spaces) case TYPE_CODE_FLT: printfi_filtered (spaces, "floatformat "); - if (TYPE_FLOATFORMAT (type) == NULL - || TYPE_FLOATFORMAT (type)->name == NULL) + if (TYPE_FLOATFORMAT (type) == NULL) puts_filtered ("(null)"); else - puts_filtered (TYPE_FLOATFORMAT (type)->name); + { + 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; @@ -3105,7 +3228,7 @@ recursive_dump_type (struct type *type, int spaces) gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout); if (TYPE_CPLUS_SPECIFIC (type) != NULL) { - printf_filtered (" (unknown data form)"); + printf_filtered (_(" (unknown data form)")); } printf_filtered ("\n"); break; @@ -3115,7 +3238,165 @@ recursive_dump_type (struct type *type, int spaces) obstack_free (&dont_print_type_obstack, NULL); } -static void build_gdbtypes (void); +/* Trivial helpers for the libiberty hash table, for mapping one + type to another. */ + +struct type_pair +{ + struct type *old, *new; +}; + +static hashval_t +type_pair_hash (const void *item) +{ + const struct type_pair *pair = item; + return htab_hash_pointer (pair->old); +} + +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; +} + +/* Allocate the hash table used by copy_type_recursive to walk + types without duplicates. We use OBJFILE's obstack, because + OBJFILE is about to be deleted. */ + +htab_t +create_copied_types_hash (struct objfile *objfile) +{ + return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq, + NULL, &objfile->objfile_obstack, + hashtab_obstack_allocate, + dummy_obstack_deallocate); +} + +/* Recursively copy (deep copy) TYPE, if it is associated with OBJFILE. + Return a new type allocated using malloc, a saved type if we have already + visited TYPE (using COPIED_TYPES), or TYPE if it is not associated with + OBJFILE. */ + +struct type * +copy_type_recursive (struct objfile *objfile, struct type *type, + htab_t copied_types) +{ + struct type_pair *stored, pair; + void **slot; + struct type *new_type; + + if (TYPE_OBJFILE (type) == NULL) + return type; + + /* This type shouldn't be pointing to any types in other objfiles; if + it did, the type might disappear unexpectedly. */ + gdb_assert (TYPE_OBJFILE (type) == objfile); + + pair.old = type; + slot = htab_find_slot (copied_types, &pair, INSERT); + if (*slot != NULL) + return ((struct type_pair *) *slot)->new; + + new_type = alloc_type (NULL); + + /* We must add the new type to the hash table immediately, in case + we encounter this type again during a recursive call below. */ + stored = xmalloc (sizeof (struct type_pair)); + stored->old = type; + stored->new = new_type; + *slot = stored; + + /* Copy the common fields of types. */ + TYPE_CODE (new_type) = TYPE_CODE (type); + TYPE_ARRAY_UPPER_BOUND_TYPE (new_type) = TYPE_ARRAY_UPPER_BOUND_TYPE (type); + TYPE_ARRAY_LOWER_BOUND_TYPE (new_type) = TYPE_ARRAY_LOWER_BOUND_TYPE (type); + if (TYPE_NAME (type)) + TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type)); + if (TYPE_TAG_NAME (type)) + TYPE_TAG_NAME (new_type) = xstrdup (TYPE_TAG_NAME (type)); + TYPE_FLAGS (new_type) = TYPE_FLAGS (type); + TYPE_VPTR_FIELDNO (new_type) = TYPE_VPTR_FIELDNO (type); + + TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type); + TYPE_LENGTH (new_type) = TYPE_LENGTH (type); + + /* Copy the fields. */ + TYPE_NFIELDS (new_type) = TYPE_NFIELDS (type); + if (TYPE_NFIELDS (type)) + { + int i, nfields; + + nfields = TYPE_NFIELDS (type); + TYPE_FIELDS (new_type) = xmalloc (sizeof (struct field) * nfields); + for (i = 0; i < nfields; i++) + { + TYPE_FIELD_ARTIFICIAL (new_type, i) = TYPE_FIELD_ARTIFICIAL (type, i); + TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i); + if (TYPE_FIELD_TYPE (type, i)) + TYPE_FIELD_TYPE (new_type, i) + = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i), + copied_types); + if (TYPE_FIELD_NAME (type, i)) + TYPE_FIELD_NAME (new_type, i) = xstrdup (TYPE_FIELD_NAME (type, i)); + if (TYPE_FIELD_STATIC_HAS_ADDR (type, i)) + SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i), + TYPE_FIELD_STATIC_PHYSADDR (type, i)); + else if (TYPE_FIELD_STATIC (type, i)) + SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i), + xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type, i))); + else + { + TYPE_FIELD_BITPOS (new_type, i) = TYPE_FIELD_BITPOS (type, i); + TYPE_FIELD_STATIC_KIND (new_type, i) = 0; + } + } + } + + /* Copy pointers to other types. */ + if (TYPE_TARGET_TYPE (type)) + TYPE_TARGET_TYPE (new_type) = copy_type_recursive (objfile, + TYPE_TARGET_TYPE (type), + copied_types); + if (TYPE_VPTR_BASETYPE (type)) + TYPE_VPTR_BASETYPE (new_type) = copy_type_recursive (objfile, + TYPE_VPTR_BASETYPE (type), + copied_types); + /* Maybe copy the type_specific bits. + + NOTE drow/2005-12-09: We do not copy the C++-specific bits like + base classes and methods. There's no fundamental reason why we + can't, but at the moment it is not needed. */ + + if (TYPE_CODE (type) == TYPE_CODE_FLT) + TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type); + else if (TYPE_CODE (type) == TYPE_CODE_STRUCT + || TYPE_CODE (type) == TYPE_CODE_UNION + || TYPE_CODE (type) == TYPE_CODE_TEMPLATE + || TYPE_CODE (type) == TYPE_CODE_NAMESPACE) + INIT_CPLUS_SPECIFIC (new_type); + + return new_type; +} + +static struct type * +build_flt (int bit, char *name, const struct floatformat **floatformats) +{ + struct type *t; + + if (bit == -1) + { + gdb_assert (floatformats != NULL); + gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL); + bit = floatformats[0]->totalsize; + } + gdb_assert (bit >= 0); + + t = init_type (TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, 0, name, NULL); + TYPE_FLOATFORMAT (t) = floatformats; + return t; +} + static void build_gdbtypes (void) { @@ -3172,35 +3453,14 @@ build_gdbtypes (void) init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, TYPE_FLAG_UNSIGNED, "unsigned long long", (struct objfile *) NULL); - builtin_type_float = - init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT, - 0, - "float", (struct objfile *) NULL); -/* vinschen@redhat.com 2002-02-08: - The below lines are disabled since they are doing the wrong - thing for non-multiarch targets. They are setting the correct - type of floats for the target but while on multiarch targets - this is done everytime the architecture changes, it's done on - non-multiarch targets only on startup, leaving the wrong values - in even if the architecture changes (eg. from big-endian to - little-endian). */ -#if 0 - TYPE_FLOATFORMAT (builtin_type_float) = TARGET_FLOAT_FORMAT; -#endif - builtin_type_double = - init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, - 0, - "double", (struct objfile *) NULL); -#if 0 - TYPE_FLOATFORMAT (builtin_type_double) = TARGET_DOUBLE_FORMAT; -#endif - builtin_type_long_double = - init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT, - 0, - "long double", (struct objfile *) NULL); -#if 0 - TYPE_FLOATFORMAT (builtin_type_long_double) = TARGET_LONG_DOUBLE_FORMAT; -#endif + + builtin_type_float = build_flt (TARGET_FLOAT_BIT, "float", + TARGET_FLOAT_FORMAT); + builtin_type_double = build_flt (TARGET_DOUBLE_BIT, "double", + TARGET_DOUBLE_FORMAT); + builtin_type_long_double = build_flt (TARGET_LONG_DOUBLE_BIT, "long double", + TARGET_LONG_DOUBLE_FORMAT); + builtin_type_complex = init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT, 0, @@ -3215,61 +3475,19 @@ build_gdbtypes (void) init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT, 0, "string", (struct objfile *) NULL); - 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, - 0, - "int8_t", (struct objfile *) NULL); - builtin_type_uint8 = - init_type (TYPE_CODE_INT, 8 / 8, - TYPE_FLAG_UNSIGNED, - "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_bool = init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT, 0, "bool", (struct objfile *) NULL); /* Add user knob for controlling resolution of opaque types */ - deprecated_add_show_from_set - (add_set_cmd ("opaque-type-resolution", class_support, var_boolean, (char *) &opaque_type_resolution, - "Set resolution of opaque struct/class/union types (if set before loading symbols).", - &setlist), - &showlist); + 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, + show_opaque_type_resolution, + &setlist, &showlist); opaque_type_resolution = 1; /* Build SIMD types. */ @@ -3303,9 +3521,7 @@ build_gdbtypes (void) /* Vector types. */ builtin_type_vec64 = build_builtin_type_vec64 (); - builtin_type_vec64i = build_builtin_type_vec64i (); builtin_type_vec128 = build_builtin_type_vec128 (); - builtin_type_vec128i = build_builtin_type_vec128i (); /* Pointer/Address types. */ @@ -3356,6 +3572,22 @@ builtin_type (struct gdbarch *gdbarch) return gdbarch_data (gdbarch, gdbtypes_data); } + +static struct type * +build_complex (int bit, char *name, struct type *target_type) +{ + struct type *t; + if (bit <= 0 || target_type == builtin_type_error) + { + gdb_assert (builtin_type_error != NULL); + return builtin_type_error; + } + t = init_type (TYPE_CODE_COMPLEX, 2 * bit / TARGET_CHAR_BIT, + 0, name, (struct objfile *) NULL); + TYPE_TARGET_TYPE (t) = target_type; + return t; +} + static void * gdbtypes_post_init (struct gdbarch *gdbarch) { @@ -3415,79 +3647,25 @@ gdbtypes_post_init (struct gdbarch *gdbarch) init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, TYPE_FLAG_UNSIGNED, "unsigned long long", (struct objfile *) NULL); - builtin_type->builtin_float = - init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT, - 0, - "float", (struct objfile *) NULL); - TYPE_FLOATFORMAT (builtin_type->builtin_float) = TARGET_FLOAT_FORMAT; - builtin_type->builtin_double = - init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, - 0, - "double", (struct objfile *) NULL); - TYPE_FLOATFORMAT (builtin_type->builtin_double) = TARGET_DOUBLE_FORMAT; - builtin_type->builtin_long_double = - init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT, - 0, - "long double", (struct objfile *) NULL); - TYPE_FLOATFORMAT (builtin_type->builtin_long_double) = TARGET_LONG_DOUBLE_FORMAT; - builtin_type->builtin_complex = - init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT, - 0, - "complex", (struct objfile *) NULL); - TYPE_TARGET_TYPE (builtin_type->builtin_complex) = builtin_type->builtin_float; - builtin_type->builtin_double_complex = - init_type (TYPE_CODE_COMPLEX, 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, - 0, - "double complex", (struct objfile *) NULL); - TYPE_TARGET_TYPE (builtin_type->builtin_double_complex) = builtin_type->builtin_double; + builtin_type->builtin_float + = build_flt (gdbarch_float_bit (gdbarch), "float", + gdbarch_float_format (gdbarch)); + builtin_type->builtin_double + = build_flt (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)); + builtin_type->builtin_complex + = build_complex (gdbarch_float_bit (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_int0 = - init_type (TYPE_CODE_INT, 0 / 8, - 0, - "int0_t", (struct objfile *) NULL); - builtin_type->builtin_int8 = - init_type (TYPE_CODE_INT, 8 / 8, - 0, - "int8_t", (struct objfile *) NULL); - builtin_type->builtin_uint8 = - init_type (TYPE_CODE_INT, 8 / 8, - TYPE_FLAG_UNSIGNED, - "uint8_t", (struct objfile *) NULL); - builtin_type->builtin_int16 = - init_type (TYPE_CODE_INT, 16 / 8, - 0, - "int16_t", (struct objfile *) NULL); - builtin_type->builtin_uint16 = - init_type (TYPE_CODE_INT, 16 / 8, - TYPE_FLAG_UNSIGNED, - "uint16_t", (struct objfile *) NULL); - builtin_type->builtin_int32 = - init_type (TYPE_CODE_INT, 32 / 8, - 0, - "int32_t", (struct objfile *) NULL); - builtin_type->builtin_uint32 = - init_type (TYPE_CODE_INT, 32 / 8, - TYPE_FLAG_UNSIGNED, - "uint32_t", (struct objfile *) NULL); - builtin_type->builtin_int64 = - init_type (TYPE_CODE_INT, 64 / 8, - 0, - "int64_t", (struct objfile *) NULL); - builtin_type->builtin_uint64 = - init_type (TYPE_CODE_INT, 64 / 8, - TYPE_FLAG_UNSIGNED, - "uint64_t", (struct objfile *) NULL); - builtin_type->builtin_int128 = - init_type (TYPE_CODE_INT, 128 / 8, - 0, - "int128_t", (struct objfile *) NULL); - builtin_type->builtin_uint128 = - init_type (TYPE_CODE_INT, 128 / 8, - TYPE_FLAG_UNSIGNED, - "uint128_t", (struct objfile *) NULL); builtin_type->builtin_bool = init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT, 0, @@ -3538,13 +3716,68 @@ void _initialize_gdbtypes (void) { struct cmd_list_element *c; + + /* FIXME: Why don't the following types need to be arch-swapped? + See the comment at the top of the calls to + DEPRECATED_REGISTER_GDBARCH_SWAP below. */ + 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, + 0, + "int8_t", (struct objfile *) NULL); + builtin_type_uint8 = + init_type (TYPE_CODE_INT, 8 / 8, + TYPE_FLAG_UNSIGNED, + "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); + build_gdbtypes (); gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init); /* FIXME - For the moment, handle types by swapping them in and out. Should be using the per-architecture data-pointer and a large - struct. */ + struct. + + Note that any type T that we might create a 'T *' type for must + be arch-swapped: we cache a type's 'T *' type in the pointer_type + field, so if we change architectures but don't swap T, then + lookup_pointer_type will start handing out pointer types made for + a different architecture. */ DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void); DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_char); DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_short); @@ -3563,16 +3796,6 @@ _initialize_gdbtypes (void) DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_complex); DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_double_complex); DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_string); - DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int8); - DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_uint8); - DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int16); - DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_uint16); - DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int32); - DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_uint32); - DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int64); - DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_uint64); - DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int128); - DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_uint128); DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4sf); DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4si); DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v16qi); @@ -3591,7 +3814,6 @@ _initialize_gdbtypes (void) DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8_int8); DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_int16); DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_vec128); - DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_vec128i); DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_data_ptr); DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr); DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR); @@ -3599,75 +3821,28 @@ _initialize_gdbtypes (void) deprecated_register_gdbarch_swap (NULL, 0, build_gdbtypes); /* Note: These types do not need to be swapped - they are target - neutral. */ - builtin_type_ieee_single_big = - init_type (TYPE_CODE_FLT, floatformat_ieee_single_big.totalsize / 8, - 0, "builtin_type_ieee_single_big", NULL); - TYPE_FLOATFORMAT (builtin_type_ieee_single_big) = &floatformat_ieee_single_big; - builtin_type_ieee_single_little = - init_type (TYPE_CODE_FLT, floatformat_ieee_single_little.totalsize / 8, - 0, "builtin_type_ieee_single_little", NULL); - TYPE_FLOATFORMAT (builtin_type_ieee_single_little) = &floatformat_ieee_single_little; - builtin_type_ieee_double_big = - init_type (TYPE_CODE_FLT, floatformat_ieee_double_big.totalsize / 8, - 0, "builtin_type_ieee_double_big", NULL); - TYPE_FLOATFORMAT (builtin_type_ieee_double_big) = &floatformat_ieee_double_big; - builtin_type_ieee_double_little = - init_type (TYPE_CODE_FLT, floatformat_ieee_double_little.totalsize / 8, - 0, "builtin_type_ieee_double_little", NULL); - TYPE_FLOATFORMAT (builtin_type_ieee_double_little) = &floatformat_ieee_double_little; - builtin_type_ieee_double_littlebyte_bigword = - init_type (TYPE_CODE_FLT, floatformat_ieee_double_littlebyte_bigword.totalsize / 8, - 0, "builtin_type_ieee_double_littlebyte_bigword", NULL); - TYPE_FLOATFORMAT (builtin_type_ieee_double_littlebyte_bigword) = &floatformat_ieee_double_littlebyte_bigword; - builtin_type_i387_ext = - init_type (TYPE_CODE_FLT, floatformat_i387_ext.totalsize / 8, - 0, "builtin_type_i387_ext", NULL); - TYPE_FLOATFORMAT (builtin_type_i387_ext) = &floatformat_i387_ext; - builtin_type_m68881_ext = - init_type (TYPE_CODE_FLT, floatformat_m68881_ext.totalsize / 8, - 0, "builtin_type_m68881_ext", NULL); - TYPE_FLOATFORMAT (builtin_type_m68881_ext) = &floatformat_m68881_ext; - builtin_type_i960_ext = - init_type (TYPE_CODE_FLT, floatformat_i960_ext.totalsize / 8, - 0, "builtin_type_i960_ext", NULL); - TYPE_FLOATFORMAT (builtin_type_i960_ext) = &floatformat_i960_ext; - builtin_type_m88110_ext = - init_type (TYPE_CODE_FLT, floatformat_m88110_ext.totalsize / 8, - 0, "builtin_type_m88110_ext", NULL); - TYPE_FLOATFORMAT (builtin_type_m88110_ext) = &floatformat_m88110_ext; - builtin_type_m88110_harris_ext = - init_type (TYPE_CODE_FLT, floatformat_m88110_harris_ext.totalsize / 8, - 0, "builtin_type_m88110_harris_ext", NULL); - TYPE_FLOATFORMAT (builtin_type_m88110_harris_ext) = &floatformat_m88110_harris_ext; - builtin_type_arm_ext_big = - init_type (TYPE_CODE_FLT, floatformat_arm_ext_big.totalsize / 8, - 0, "builtin_type_arm_ext_big", NULL); - TYPE_FLOATFORMAT (builtin_type_arm_ext_big) = &floatformat_arm_ext_big; - builtin_type_arm_ext_littlebyte_bigword = - init_type (TYPE_CODE_FLT, floatformat_arm_ext_littlebyte_bigword.totalsize / 8, - 0, "builtin_type_arm_ext_littlebyte_bigword", NULL); - TYPE_FLOATFORMAT (builtin_type_arm_ext_littlebyte_bigword) = &floatformat_arm_ext_littlebyte_bigword; - builtin_type_ia64_spill_big = - init_type (TYPE_CODE_FLT, floatformat_ia64_spill_big.totalsize / 8, - 0, "builtin_type_ia64_spill_big", NULL); - TYPE_FLOATFORMAT (builtin_type_ia64_spill_big) = &floatformat_ia64_spill_big; - builtin_type_ia64_spill_little = - init_type (TYPE_CODE_FLT, floatformat_ia64_spill_little.totalsize / 8, - 0, "builtin_type_ia64_spill_little", NULL); - TYPE_FLOATFORMAT (builtin_type_ia64_spill_little) = &floatformat_ia64_spill_little; - builtin_type_ia64_quad_big = - init_type (TYPE_CODE_FLT, floatformat_ia64_quad_big.totalsize / 8, - 0, "builtin_type_ia64_quad_big", NULL); - TYPE_FLOATFORMAT (builtin_type_ia64_quad_big) = &floatformat_ia64_quad_big; - builtin_type_ia64_quad_little = - init_type (TYPE_CODE_FLT, floatformat_ia64_quad_little.totalsize / 8, - 0, "builtin_type_ia64_quad_little", NULL); - TYPE_FLOATFORMAT (builtin_type_ia64_quad_little) = &floatformat_ia64_quad_little; - - deprecated_add_show_from_set - (add_set_cmd ("overload", no_class, var_zinteger, (char *) &overload_debug, - "Set debugging of C++ overloading.\n\ -When enabled, ranking of the functions is displayed.", &setdebuglist), - &showdebuglist); + neutral. FIXME: Are you sure? See the comment above the calls + to DEPRECATED_REGISTER_GDBARCH_SWAP above. */ + builtin_type_ieee_single + = build_flt (-1, "builtin_type_ieee_single", floatformats_ieee_single); + builtin_type_ieee_double + = build_flt (-1, "builtin_type_ieee_double", floatformats_ieee_double); + builtin_type_i387_ext + = build_flt (-1, "builtin_type_i387_ext", floatformats_i387_ext); + builtin_type_m68881_ext + = build_flt (-1, "builtin_type_m68881_ext", floatformats_m68881_ext); + builtin_type_arm_ext + = build_flt (-1, "builtin_type_arm_ext", floatformats_arm_ext); + builtin_type_ia64_spill + = build_flt (-1, "builtin_type_ia64_spill", floatformats_ia64_spill); + builtin_type_ia64_quad + = build_flt (-1, "builtin_type_ia64_quad", floatformats_ia64_quad); + + add_setshow_zinteger_cmd ("overload", no_class, &overload_debug, _("\ +Set debugging of C++ overloading."), _("\ +Show debugging of C++ overloading."), _("\ +When enabled, ranking of the functions is displayed."), + NULL, + show_overload_debug, + &setdebuglist, &showdebuglist); }