X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbtypes.c;h=c1af73164c57253a72b62bd47e7f5760f173c6f4;hb=a0c758791c4504adb6af48e7cd9044521f8cd90b;hp=c9cae4cda8dea919329cee7c2e65fd33736f97b2;hpb=72367fb45badc6ee3fe515b31348266310bff371;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index c9cae4cda8..c1af73164c 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -1,6 +1,6 @@ /* Support routines for manipulating internal types for GDB. - Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002 - Free Software Foundation, Inc. + Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, + 2004 Free Software Foundation, Inc. Contributed by Cygnus Support, using pieces from other GDB modules. This file is part of GDB. @@ -60,6 +60,7 @@ struct type *builtin_type_long_double; struct type *builtin_type_complex; struct type *builtin_type_double_complex; struct type *builtin_type_string; +struct type *builtin_type_int0; struct type *builtin_type_int8; struct type *builtin_type_uint8; struct type *builtin_type_int16; @@ -93,11 +94,11 @@ 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[BFD_ENDIAN_UNKNOWN]; struct type *builtin_type_ieee_single_big; struct type *builtin_type_ieee_single_little; +struct type *builtin_type_ieee_double[BFD_ENDIAN_UNKNOWN]; struct type *builtin_type_ieee_double_big; struct type *builtin_type_ieee_double_little; struct type *builtin_type_ieee_double_littlebyte_bigword; @@ -106,10 +107,13 @@ 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[BFD_ENDIAN_UNKNOWN]; struct type *builtin_type_arm_ext_big; struct type *builtin_type_arm_ext_littlebyte_bigword; +struct type *builtin_type_ia64_spill[BFD_ENDIAN_UNKNOWN]; struct type *builtin_type_ia64_spill_big; struct type *builtin_type_ia64_spill_little; +struct type *builtin_type_ia64_quad[BFD_ENDIAN_UNKNOWN]; struct type *builtin_type_ia64_quad_big; struct type *builtin_type_ia64_quad_little; struct type *builtin_type_void_data_ptr; @@ -118,7 +122,22 @@ 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 { @@ -126,11 +145,6 @@ struct extra int len; }; /* maximum extension is 128! FIXME */ -static void add_name (struct extra *, char *); -static void add_mangled_type (struct extra *, struct type *); -#if 0 -static void cfront_mangle_name (struct type *, int, int); -#endif 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); @@ -140,13 +154,13 @@ static void virtual_base_list_aux (struct type *dclass); /* 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 type_obstack. Otherwise allocate the new type structure + in that objfile's objfile_obstack. Otherwise allocate the new type structure by xmalloc () (for permanent types). */ struct type * alloc_type (struct objfile *objfile) { - register struct type *type; + struct type *type; /* Alloc the structure and start off with all fields zeroed. */ @@ -158,10 +172,10 @@ alloc_type (struct objfile *objfile) } else { - type = obstack_alloc (&objfile->type_obstack, + type = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type)); memset (type, 0, sizeof (struct type)); - TYPE_MAIN_TYPE (type) = obstack_alloc (&objfile->type_obstack, + TYPE_MAIN_TYPE (type) = obstack_alloc (&objfile->objfile_obstack, sizeof (struct main_type)); OBJSTAT (objfile, n_types++); } @@ -195,7 +209,7 @@ alloc_type_instance (struct type *oldtype) } else { - type = obstack_alloc (&TYPE_OBJFILE (oldtype)->type_obstack, + type = obstack_alloc (&TYPE_OBJFILE (oldtype)->objfile_obstack, sizeof (struct type)); memset (type, 0, sizeof (struct type)); } @@ -227,7 +241,7 @@ smash_type (struct type *type) struct type * make_pointer_type (struct type *type, struct type **typeptr) { - register struct type *ntype; /* New type */ + struct type *ntype; /* New type */ struct objfile *objfile; ntype = TYPE_POINTER_TYPE (type); @@ -294,7 +308,7 @@ lookup_pointer_type (struct type *type) struct type * make_reference_type (struct type *type, struct type **typeptr) { - register struct type *ntype; /* New type */ + struct type *ntype; /* New type */ struct objfile *objfile; ntype = TYPE_REFERENCE_TYPE (type); @@ -356,7 +370,7 @@ lookup_reference_type (struct type *type) struct type * make_function_type (struct type *type, struct type **typeptr) { - register struct type *ntype; /* New type */ + struct type *ntype; /* New type */ struct objfile *objfile; if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */ @@ -410,13 +424,13 @@ 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 gdbtypes.h -- return the string version of the adress space name. */ -extern char * +const char * address_space_int_to_name (int space_flag) { struct gdbarch *gdbarch = current_gdbarch; @@ -432,9 +446,11 @@ 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. */ -struct type * + 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, struct type *storage) { @@ -452,6 +468,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; @@ -469,6 +491,9 @@ make_qualified_type (struct type *type, int new_flags, /* Now set the instance flags and return the new type. */ TYPE_INSTANCE_FLAGS (ntype) = new_flags; + /* Set length of new type to that of the original type. */ + TYPE_LENGTH (ntype) = TYPE_LENGTH (type); + return ntype; } @@ -497,16 +522,17 @@ 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) { - register struct type *ntype; /* New type */ - register struct type *tmp_type = type; /* tmp type */ + struct type *ntype; /* New type */ + struct type *tmp_type = type; /* tmp type */ struct objfile *objfile; int new_flags = (TYPE_INSTANCE_FLAGS (type) @@ -520,20 +546,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); @@ -556,10 +581,32 @@ make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr) void replace_type (struct type *ntype, struct type *type) { - struct type *cv_chain, *as_chain, *ptr, *ref; + 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 + type on the variant chain. */ + chain = ntype; + do { + /* Assert that this element of the chain has no address-class bits + set in its flags. Such type variants might have type lengths + which are supposed to be different from the non-address-class + variants. This assertion shouldn't ever be triggered because + symbol readers which do construct address-class variants don't + call replace_type(). */ + gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0); + + TYPE_LENGTH (ntype) = TYPE_LENGTH (type); + chain = TYPE_CHAIN (chain); + } while (ntype != chain); + /* Assert that the two types have equivalent instance qualifiers. This should be true for at least all of our debug readers. */ gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type)); @@ -573,7 +620,7 @@ replace_type (struct type *ntype, struct type *type) struct type * lookup_member_type (struct type *type, struct type *domain) { - register struct type *mtype; + struct type *mtype; mtype = alloc_type (TYPE_OBJFILE (type)); smash_to_member_type (mtype, domain, type); @@ -637,7 +684,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 @@ -759,8 +806,12 @@ create_array_type (struct type *result_type, struct type *element_type, struct type * create_string_type (struct type *result_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, - *current_language->string_char_type, + string_char_type, range_type); TYPE_CODE (result_type) = TYPE_CODE_STRING; return (result_type); @@ -864,34 +915,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) { @@ -922,26 +945,6 @@ 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 @@ -1000,7 +1003,7 @@ smash_to_method_type (struct type *type, struct type *domain, "union ", or "enum ". If the type has a NULL name, return NULL. */ char * -type_name_no_tag (register const struct type *type) +type_name_no_tag (const struct type *type) { if (TYPE_TAG_NAME (type) != NULL) return TYPE_TAG_NAME (type); @@ -1011,24 +1014,6 @@ type_name_no_tag (register const struct type *type) return TYPE_NAME (type); } -/* Lookup a primitive type named NAME. - Return zero if NAME is not a primitive type. */ - -struct type * -lookup_primitive_typename (char *name) -{ - struct type **const *p; - - for (p = current_language->la_builtin_type_vector; *p != NULL; p++) - { - if (STREQ (TYPE_NAME (**p), name)) - { - return (**p); - } - } - return (NULL); -} - /* 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. */ @@ -1036,13 +1021,15 @@ lookup_primitive_typename (char *name) struct type * lookup_typename (char *name, struct block *block, int noerr) { - register struct symbol *sym; - register struct type *tmp; + struct symbol *sym; + struct type *tmp; - sym = lookup_symbol (name, block, VAR_NAMESPACE, 0, (struct symtab **) NULL); + sym = lookup_symbol (name, block, VAR_DOMAIN, 0, (struct symtab **) NULL); if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF) { - tmp = lookup_primitive_typename (name); + tmp = language_lookup_primitive_type_by_name (current_language, + current_gdbarch, + name); if (tmp) { return (tmp); @@ -1053,7 +1040,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)); @@ -1090,18 +1077,18 @@ lookup_signed_typename (char *name) struct type * lookup_struct (char *name, struct block *block) { - register struct symbol *sym; + struct symbol *sym; - sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0, + sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0, (struct symtab **) NULL); 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)); } @@ -1112,14 +1099,14 @@ lookup_struct (char *name, struct block *block) struct type * lookup_union (char *name, struct block *block) { - register struct symbol *sym; + struct symbol *sym; struct type *t; - sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0, + sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0, (struct symtab **) NULL); if (sym == NULL) - error ("No union type named %s.", name); + error (_("No union type named %s."), name); t = SYMBOL_TYPE (sym); @@ -1134,7 +1121,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); } @@ -1144,17 +1131,17 @@ lookup_union (char *name, struct block *block) struct type * lookup_enum (char *name, struct block *block) { - register struct symbol *sym; + struct symbol *sym; - sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0, + sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0, (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)); } @@ -1172,15 +1159,15 @@ lookup_template_type (char *name, struct type *type, struct block *block) strcat (nam, TYPE_NAME (type)); strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */ - sym = lookup_symbol (nam, block, VAR_NAMESPACE, 0, (struct symtab **) NULL); + sym = lookup_symbol (nam, block, VAR_DOMAIN, 0, (struct symtab **) NULL); 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)); } @@ -1216,7 +1203,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 @@ -1228,7 +1215,7 @@ lookup_struct_elt_type (struct type *type, char *name, int noerr) char *typename; typename = type_name_no_tag (type); - if (typename != NULL && STREQ (typename, name)) + if (typename != NULL && strcmp (typename, name) == 0) return type; } #endif @@ -1266,7 +1253,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 */ } @@ -1328,6 +1315,12 @@ get_destructor_fn_field (struct type *t, int *method_indexp, int *field_indexp) 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. If this is a stubbed struct (i.e. declared as struct foo *), see if @@ -1341,8 +1334,10 @@ get_destructor_fn_field (struct type *t, int *method_indexp, int *field_indexp) This used to be coded as a macro, but I don't think it is called often enough to merit such treatment. */ -struct deprecated_complaint stub_noname_complaint = -{"stub type has NULL name", 0, 0}; +/* 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. */ struct type * check_typedef (struct type *type) @@ -1364,15 +1359,15 @@ check_typedef (struct type *type) name = type_name_no_tag (type); /* FIXME: shouldn't we separately check the TYPE_NAME and the - TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE + 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). */ if (name == NULL) { - complain (&stub_noname_complaint); + stub_noname_complaint (); return type; } - sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, + sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0, (struct symtab **) NULL); if (sym) TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym); @@ -1396,28 +1391,44 @@ check_typedef (struct type *type) struct type *newtype; if (name == NULL) { - complain (&stub_noname_complaint); + stub_noname_complaint (); 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) { 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_NAMESPACE and/or VAR_NAMESPACE + 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) { - complain (&stub_noname_complaint); + stub_noname_complaint (); return type; } - sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, (struct symtab **) NULL); + sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0, (struct symtab **) NULL); if (sym) make_cv_type (is_const, is_volatile, SYMBOL_TYPE (sym), &type); } @@ -1455,206 +1466,10 @@ check_typedef (struct type *type) return type; } -/* New code added to support parsing of Cfront stabs strings */ -#define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; } -#define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; } - -static void -add_name (struct extra *pextras, char *n) -{ - int nlen; - - if ((nlen = (n ? strlen (n) : 0)) == 0) - return; - sprintf (pextras->str + pextras->len, "%d%s", nlen, n); - pextras->len = strlen (pextras->str); -} - -static void -add_mangled_type (struct extra *pextras, struct type *t) -{ - enum type_code tcode; - int tlen, tflags; - char *tname; - - tcode = TYPE_CODE (t); - tlen = TYPE_LENGTH (t); - tflags = TYPE_FLAGS (t); - tname = TYPE_NAME (t); - /* args of "..." seem to get mangled as "e" */ - - switch (tcode) - { - case TYPE_CODE_INT: - if (tflags == 1) - ADD_EXTRA ('U'); - switch (tlen) - { - case 1: - ADD_EXTRA ('c'); - break; - case 2: - ADD_EXTRA ('s'); - break; - case 4: - { - char *pname; - if ((pname = strrchr (tname, 'l'), pname) && !strcmp (pname, "long")) - { - ADD_EXTRA ('l'); - } - else - { - ADD_EXTRA ('i'); - } - } - break; - default: - { - - static struct deprecated_complaint msg = - {"Bad int type code length x%x\n", 0, 0}; - - complain (&msg, tlen); - - } - } - break; - case TYPE_CODE_FLT: - switch (tlen) - { - case 4: - ADD_EXTRA ('f'); - break; - case 8: - ADD_EXTRA ('d'); - break; - case 16: - ADD_EXTRA ('r'); - break; - default: - { - static struct deprecated_complaint msg = - {"Bad float type code length x%x\n", 0, 0}; - complain (&msg, tlen); - } - } - break; - case TYPE_CODE_REF: - ADD_EXTRA ('R'); - /* followed by what it's a ref to */ - break; - case TYPE_CODE_PTR: - ADD_EXTRA ('P'); - /* followed by what it's a ptr to */ - break; - case TYPE_CODE_TYPEDEF: - { - static struct deprecated_complaint msg = - {"Typedefs in overloaded functions not yet supported\n", 0, 0}; - complain (&msg); - } - /* followed by type bytes & name */ - break; - case TYPE_CODE_FUNC: - ADD_EXTRA ('F'); - /* followed by func's arg '_' & ret types */ - break; - case TYPE_CODE_VOID: - ADD_EXTRA ('v'); - break; - case TYPE_CODE_METHOD: - ADD_EXTRA ('M'); - /* followed by name of class and func's arg '_' & ret types */ - add_name (pextras, tname); - ADD_EXTRA ('F'); /* then mangle function */ - break; - case TYPE_CODE_STRUCT: /* C struct */ - case TYPE_CODE_UNION: /* C union */ - case TYPE_CODE_ENUM: /* Enumeration type */ - /* followed by name of type */ - add_name (pextras, tname); - break; - - /* errors possible types/not supported */ - case TYPE_CODE_CHAR: - case TYPE_CODE_ARRAY: /* Array type */ - case TYPE_CODE_MEMBER: /* Member type */ - case TYPE_CODE_BOOL: - case TYPE_CODE_COMPLEX: /* Complex float */ - case TYPE_CODE_UNDEF: - case TYPE_CODE_SET: /* Pascal sets */ - case TYPE_CODE_RANGE: - case TYPE_CODE_STRING: - case TYPE_CODE_BITSTRING: - case TYPE_CODE_ERROR: - default: - { - static struct deprecated_complaint msg = - {"Unknown type code x%x\n", 0, 0}; - complain (&msg, tcode); - } - } - if (TYPE_TARGET_TYPE (t)) - add_mangled_type (pextras, TYPE_TARGET_TYPE (t)); -} - -#if 0 -void -cfront_mangle_name (struct type *type, int i, int j) -{ - struct fn_field *f; - char *mangled_name = gdb_mangle_name (type, i, j); - - f = TYPE_FN_FIELDLIST1 (type, i); /* moved from below */ - - /* kludge to support cfront methods - gdb expects to find "F" for - ARM_mangled names, so when we mangle, we have to add it here */ - if (ARM_DEMANGLING) - { - int k; - char *arm_mangled_name; - struct fn_field *method = &f[j]; - char *field_name = TYPE_FN_FIELDLIST_NAME (type, i); - char *physname = TYPE_FN_FIELD_PHYSNAME (f, j); - char *newname = type_name_no_tag (type); - - struct type *ftype = TYPE_FN_FIELD_TYPE (f, j); - int nargs = TYPE_NFIELDS (ftype); /* number of args */ - struct extra extras, *pextras = &extras; - INIT_EXTRA - - if (TYPE_FN_FIELD_STATIC_P (f, j)) /* j for sublist within this list */ - ADD_EXTRA ('S') - ADD_EXTRA ('F') - /* add args here! */ - if (nargs <= 1) /* no args besides this */ - ADD_EXTRA ('v') - else - { - for (k = 1; k < nargs; k++) - { - struct type *t; - t = TYPE_FIELD_TYPE (ftype, k); - add_mangled_type (pextras, t); - } - } - ADD_EXTRA ('\0') - printf ("add_mangled_type: %s\n", extras.str); /* FIXME */ - xasprintf (&arm_mangled_name, "%s%s", mangled_name, extras.str); - xfree (mangled_name); - mangled_name = arm_mangled_name; - } -} -#endif /* 0 */ - -#undef ADD_EXTRA -/* End of new code added to support parsing of Cfront stabs strings */ - /* Parse a type expression in the string [P..P+LENGTH). If an error occurs, silently return builtin_type_void. */ -struct type * +static struct type * safe_parse_type (char *p, int length) { struct ui_file *saved_gdb_stderr; @@ -1704,7 +1519,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; @@ -1853,7 +1668,7 @@ allocate_cplus_struct_type (struct type *type) /* 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 type_obstack for that objfile, + 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). */ @@ -1861,7 +1676,7 @@ struct type * init_type (enum type_code code, int length, int flags, char *name, struct objfile *objfile) { - register struct type *type; + struct type *type; type = alloc_type (objfile); TYPE_CODE (type) = code; @@ -1870,7 +1685,7 @@ init_type (enum type_code code, int length, int flags, char *name, if ((name != NULL) && (objfile != NULL)) { TYPE_NAME (type) = - obsavestring (name, strlen (name), &objfile->type_obstack); + obsavestring (name, strlen (name), &objfile->objfile_obstack); } else { @@ -1879,7 +1694,11 @@ init_type (enum type_code code, int length, int flags, char *name, /* C++ fancies. */ - if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION) + if (name && strcmp (name, "char") == 0) + TYPE_FLAGS (type) |= TYPE_FLAG_NOSIGN; + + if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION + || code == TYPE_CODE_NAMESPACE) { INIT_CPLUS_SPECIFIC (type); } @@ -1952,12 +1771,12 @@ append_composite_type_field (struct type *t, char *name, struct type *field) struct type * lookup_fundamental_type (struct objfile *objfile, int typeid) { - register struct type **typep; - register int nbytes; + struct type **typep; + int nbytes; 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 @@ -1967,7 +1786,7 @@ lookup_fundamental_type (struct objfile *objfile, int typeid) { nbytes = FT_NUM_MEMBERS * sizeof (struct type *); objfile->fundamental_types = (struct type **) - obstack_alloc (&objfile->type_obstack, nbytes); + obstack_alloc (&objfile->objfile_obstack, nbytes); memset ((char *) objfile->fundamental_types, 0, nbytes); OBJSTAT (objfile, n_types += FT_NUM_MEMBERS); } @@ -2008,24 +1827,6 @@ is_integral_type (struct type *t) || (TYPE_CODE (t) == TYPE_CODE_BOOL))); } -/* (OBSOLETE) Chill (OBSOLETE) varying string and arrays are - represented as follows: - - struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data}; - - Return true if TYPE is such a (OBSOLETE) Chill (OBSOLETE) varying - type. */ - -/* OBSOLETE int */ -/* OBSOLETE chill_varying_type (struct type *type) */ -/* OBSOLETE { */ -/* OBSOLETE if (TYPE_CODE (type) != TYPE_CODE_STRUCT */ -/* OBSOLETE || TYPE_NFIELDS (type) != 2 */ -/* OBSOLETE || strcmp (TYPE_FIELD_NAME (type, 0), "__var_length") != 0) */ -/* OBSOLETE return 0; */ -/* OBSOLETE return 1; */ -/* OBSOLETE } */ - /* 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 @@ -2065,7 +1866,7 @@ has_vtable (struct type *dclass) /* In the HP ANSI C++ runtime model, a class has a vtable only if it has virtual functions or virtual bases. */ - register int i; + int i; if (TYPE_CODE (dclass) != TYPE_CODE_CLASS) return 0; @@ -2108,7 +1909,7 @@ primary_base_class (struct type *dclass) is the first directly inherited, non-virtual base class that requires a virtual table */ - register int i; + int i; if (TYPE_CODE (dclass) != TYPE_CODE_CLASS) return NULL; @@ -2137,7 +1938,7 @@ static void virtual_base_list_aux (struct type *dclass) { struct vbase *tmp_vbase; - register int i; + int i; if (TYPE_CODE (dclass) != TYPE_CODE_CLASS) return; @@ -2194,9 +1995,9 @@ virtual_base_list_aux (struct type *dclass) struct type ** virtual_base_list (struct type *dclass) { - register struct vbase *tmp_vbase; - register struct vbase *tmp_vbase_2; - register int i; + struct vbase *tmp_vbase; + struct vbase *tmp_vbase_2; + int i; int count; struct type **vbase_array; @@ -2231,8 +2032,8 @@ virtual_base_list (struct type *dclass) int virtual_base_list_length (struct type *dclass) { - register int i; - register struct vbase *tmp_vbase; + int i; + struct vbase *tmp_vbase; current_vbase_list = NULL; virtual_base_list_aux (dclass); @@ -2249,8 +2050,8 @@ virtual_base_list_length (struct type *dclass) int virtual_base_list_length_skip_primaries (struct type *dclass) { - register int i; - register struct vbase *tmp_vbase; + int i; + struct vbase *tmp_vbase; struct type *primary; primary = TYPE_RUNTIME_PTR (dclass) ? TYPE_PRIMARY_BASE (dclass) : NULL; @@ -2278,8 +2079,8 @@ virtual_base_list_length_skip_primaries (struct type *dclass) int virtual_base_index (struct type *base, struct type *dclass) { - register struct type *vbase; - register int i; + struct type *vbase; + int i; if ((TYPE_CODE (dclass) != TYPE_CODE_CLASS) || (TYPE_CODE (base) != TYPE_CODE_CLASS)) @@ -2308,8 +2109,8 @@ virtual_base_index (struct type *base, struct type *dclass) int virtual_base_index_skip_primaries (struct type *base, struct type *dclass) { - register struct type *vbase; - register int i, j; + struct type *vbase; + int i, j; struct type *primary; if ((TYPE_CODE (dclass) != TYPE_CODE_CLASS) || @@ -2464,6 +2265,43 @@ rank_function (struct type **parms, int nparms, struct type **args, int nargs) return bv; } +/* Compare the names of two integer types, assuming that any sign + qualifiers have been checked already. We do it this way because + there may be an "int" in the name of one of the types. */ + +static int +integer_types_same_name_p (const char *first, const char *second) +{ + int first_p, second_p; + + /* If both are shorts, return 1; if neither is a short, keep checking. */ + first_p = (strstr (first, "short") != NULL); + second_p = (strstr (second, "short") != NULL); + if (first_p && second_p) + return 1; + if (first_p || second_p) + return 0; + + /* Likewise for long. */ + first_p = (strstr (first, "long") != NULL); + second_p = (strstr (second, "long") != NULL); + if (first_p && second_p) + return 1; + if (first_p || second_p) + return 0; + + /* Likewise for char. */ + first_p = (strstr (first, "char") != NULL); + second_p = (strstr (second, "char") != NULL); + if (first_p && second_p) + return 1; + if (first_p || second_p) + return 0; + + /* They must both be ints. */ + return 1; +} + /* 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 @@ -2574,43 +2412,47 @@ rank_one_type (struct type *parm, struct type *arg) if (TYPE_NOSIGN (arg)) /* plain char -> plain char */ return 0; else - return INTEGER_COERCION_BADNESS; /* signed/unsigned char -> plain char */ + return INTEGER_CONVERSION_BADNESS; /* signed/unsigned char -> plain char */ } else if (TYPE_UNSIGNED (parm)) { if (TYPE_UNSIGNED (arg)) { - if (!strcmp_iw (TYPE_NAME (parm), TYPE_NAME (arg))) - return 0; /* unsigned int -> unsigned int, or unsigned long -> unsigned long */ - else if (!strcmp_iw (TYPE_NAME (arg), "int") && !strcmp_iw (TYPE_NAME (parm), "long")) + /* unsigned int -> unsigned int, or unsigned long -> unsigned long */ + if (integer_types_same_name_p (TYPE_NAME (parm), TYPE_NAME (arg))) + return 0; + 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 */ else - return INTEGER_COERCION_BADNESS; /* unsigned long -> unsigned int */ + return INTEGER_CONVERSION_BADNESS; /* unsigned long -> unsigned int */ } else { - if (!strcmp_iw (TYPE_NAME (arg), "long") && !strcmp_iw (TYPE_NAME (parm), "int")) - return INTEGER_COERCION_BADNESS; /* signed long -> unsigned int */ + if (integer_types_same_name_p (TYPE_NAME (arg), "long") + && integer_types_same_name_p (TYPE_NAME (parm), "int")) + return INTEGER_CONVERSION_BADNESS; /* signed long -> unsigned int */ else return INTEGER_CONVERSION_BADNESS; /* signed int/long -> unsigned int/long */ } } else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg)) { - if (!strcmp_iw (TYPE_NAME (parm), TYPE_NAME (arg))) + if (integer_types_same_name_p (TYPE_NAME (parm), TYPE_NAME (arg))) return 0; - else if (!strcmp_iw (TYPE_NAME (arg), "int") && !strcmp_iw (TYPE_NAME (parm), "long")) + else if (integer_types_same_name_p (TYPE_NAME (arg), "int") + && integer_types_same_name_p (TYPE_NAME (parm), "long")) return INTEGER_PROMOTION_BADNESS; else - return INTEGER_COERCION_BADNESS; + return INTEGER_CONVERSION_BADNESS; } else - return INTEGER_COERCION_BADNESS; + return INTEGER_CONVERSION_BADNESS; } else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm)) return INTEGER_PROMOTION_BADNESS; else - return INTEGER_COERCION_BADNESS; + return INTEGER_CONVERSION_BADNESS; case TYPE_CODE_ENUM: case TYPE_CODE_CHAR: case TYPE_CODE_RANGE: @@ -2632,7 +2474,7 @@ rank_one_type (struct type *parm, struct type *arg) case TYPE_CODE_RANGE: case TYPE_CODE_BOOL: case TYPE_CODE_ENUM: - return INTEGER_COERCION_BADNESS; + return INTEGER_CONVERSION_BADNESS; case TYPE_CODE_FLT: return INT_FLOAT_CONVERSION_BADNESS; default: @@ -2645,12 +2487,12 @@ rank_one_type (struct type *parm, struct type *arg) case TYPE_CODE_RANGE: case TYPE_CODE_BOOL: case TYPE_CODE_ENUM: - return INTEGER_COERCION_BADNESS; + return INTEGER_CONVERSION_BADNESS; case TYPE_CODE_FLT: return INT_FLOAT_CONVERSION_BADNESS; case TYPE_CODE_INT: if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm)) - return INTEGER_COERCION_BADNESS; + return INTEGER_CONVERSION_BADNESS; else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm)) return INTEGER_PROMOTION_BADNESS; /* >>> !! else fall through !! <<< */ @@ -2662,7 +2504,7 @@ rank_one_type (struct type *parm, struct type *arg) if (TYPE_NOSIGN (arg)) return 0; else - return INTEGER_COERCION_BADNESS; + return INTEGER_CONVERSION_BADNESS; } else if (TYPE_UNSIGNED (parm)) { @@ -2674,7 +2516,7 @@ rank_one_type (struct type *parm, struct type *arg) else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg)) return 0; else - return INTEGER_COERCION_BADNESS; + return INTEGER_CONVERSION_BADNESS; default: return INCOMPATIBLE_TYPE_BADNESS; } @@ -2687,7 +2529,7 @@ rank_one_type (struct type *parm, struct type *arg) case TYPE_CODE_RANGE: case TYPE_CODE_BOOL: case TYPE_CODE_ENUM: - return INTEGER_COERCION_BADNESS; + return INTEGER_CONVERSION_BADNESS; case TYPE_CODE_FLT: return INT_FLOAT_CONVERSION_BADNESS; default: @@ -2817,13 +2659,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")); } } @@ -2860,7 +2698,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); @@ -2980,7 +2818,7 @@ print_bound_type (int bt) printf_filtered ("(BOUND_SIMPLE)"); break; default: - printf_filtered ("(unknown bound type)"); + printf_filtered (_("(unknown bound type)")); break; } } @@ -3010,7 +2848,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; } } @@ -3104,6 +2942,9 @@ recursive_dump_type (struct type *type, int spaces) case TYPE_CODE_TEMPLATE_ARG: printf_filtered ("(TYPE_CODE_TEMPLATE_ARG)"); break; + case TYPE_CODE_NAMESPACE: + printf_filtered ("(TYPE_CODE_NAMESPACE)"); + break; default: printf_filtered ("(UNKNOWN TYPE CODE)"); break; @@ -3260,7 +3101,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; @@ -3370,57 +3211,19 @@ build_gdbtypes (void) init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT, 0, "string", (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 */ - 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. */ @@ -3454,9 +3257,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. */ @@ -3499,68 +3300,267 @@ build_gdbtypes (void) "__bfd_vma", (struct objfile *) NULL); } +static struct gdbarch_data *gdbtypes_data; + +const struct builtin_type * +builtin_type (struct gdbarch *gdbarch) +{ + return gdbarch_data (gdbarch, gdbtypes_data); +} + + +static struct type * +build_flt (int bit, char *name, const struct floatformat *floatformat) +{ + struct type *t; + if (bit <= 0 || floatformat == NULL) + { + gdb_assert (builtin_type_error != NULL); + return builtin_type_error; + } + t = init_type (TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, + 0, name, (struct objfile *) NULL); + TYPE_FLOATFORMAT (t) = floatformat; + return t; +} + +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) +{ + 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 + | (TARGET_CHAR_SIGNED ? 0 : TYPE_FLAG_UNSIGNED)), + "char", (struct objfile *) NULL); + builtin_type->builtin_true_char = + init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT, + 0, + "true character", (struct objfile *) NULL); + builtin_type->builtin_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, TARGET_SHORT_BIT / TARGET_CHAR_BIT, + 0, + "short", (struct objfile *) NULL); + builtin_type->builtin_unsigned_short = + init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, + "unsigned short", (struct objfile *) NULL); + builtin_type->builtin_int = + init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT, + 0, + "int", (struct objfile *) NULL); + builtin_type->builtin_unsigned_int = + init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, + "unsigned int", (struct objfile *) NULL); + builtin_type->builtin_long = + init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT, + 0, + "long", (struct objfile *) NULL); + builtin_type->builtin_unsigned_long = + init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, + "unsigned long", (struct objfile *) NULL); + builtin_type->builtin_long_long = + init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, + 0, + "long long", (struct objfile *) NULL); + builtin_type->builtin_unsigned_long_long = + 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 + = 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_bool = + init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT, + 0, + "bool", (struct objfile *) NULL); + + /* Pointer/Address types. */ + + /* NOTE: on some targets, addresses and pointers are not necessarily + the same --- for example, on the D10V, pointers are 16 bits long, + but addresses are 32 bits long. See doc/gdbint.texinfo, + ``Pointers Are Not Always Addresses''. + + The upshot is: + - gdb's `struct type' always describes the target's + representation. + - gdb's `struct value' objects should always hold values in + target form. + - gdb's CORE_ADDR values are addresses in the unified virtual + address space that the assembler and linker work with. Thus, + since target_read_memory takes a CORE_ADDR as an argument, it + can access any memory on the target, even if the processor has + separate code and data address spaces. + + So, for example: + - If v is a value holding a D10V code pointer, its contents are + in target form: a big-endian address left-shifted two bits. + - 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. */ + 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, TARGET_ADDR_BIT / 8, + TYPE_FLAG_UNSIGNED, + "__CORE_ADDR", (struct objfile *) NULL); + + return builtin_type; +} + extern void _initialize_gdbtypes (void); void _initialize_gdbtypes (void) { struct cmd_list_element *c; + + 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. */ - register_gdbarch_swap (&builtin_type_void, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_char, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_short, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_int, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_long, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_long_long, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_signed_char, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_unsigned_char, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_unsigned_short, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_unsigned_int, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_unsigned_long, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_unsigned_long_long, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_float, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_double, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_long_double, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_complex, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_double_complex, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_string, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_int8, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_uint8, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_int16, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_uint16, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_int32, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_uint32, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_int64, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_uint64, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_int128, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_uint128, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v4sf, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v4si, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v16qi, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v8qi, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v8hi, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v4hi, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v2si, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v2_double, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v4_float, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v2_int64, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v4_int32, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v8_int16, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v16_int8, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v2_float, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v2_int32, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v8_int8, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_v4_int16, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_vec128, sizeof (struct type *), NULL); - register_gdbarch_swap (&builtin_type_vec128i, sizeof (struct type *), NULL); - REGISTER_GDBARCH_SWAP (builtin_type_void_data_ptr); - REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr); - REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR); - REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma); - register_gdbarch_swap (NULL, 0, build_gdbtypes); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_char); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_short); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_int); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long_long); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_signed_char); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_char); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_short); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_int); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_long); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_unsigned_long_long); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_float); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_double); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_long_double); + 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_v4sf); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4si); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v16qi); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8qi); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8hi); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4hi); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2si); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_double); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_float); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_int64); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v4_int32); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v8_int16); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v16_int8); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_float); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_v2_int32); + 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_void_data_ptr); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR); + DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma); + deprecated_register_gdbarch_swap (NULL, 0, build_gdbtypes); /* Note: These types do not need to be swapped - they are target neutral. */ @@ -3572,6 +3572,14 @@ _initialize_gdbtypes (void) 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_single[BFD_ENDIAN_BIG] + = build_flt (floatformat_ieee_single_big.totalsize, + "builtin_type_ieee_single_big", + &floatformat_ieee_single_big); + builtin_type_ieee_single[BFD_ENDIAN_LITTLE] + = build_flt (floatformat_ieee_single_little.totalsize, + "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); @@ -3580,6 +3588,14 @@ _initialize_gdbtypes (void) 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[BFD_ENDIAN_BIG] + = build_flt (floatformat_ieee_double_big.totalsize, + "builtin_type_ieee_double_big", + &floatformat_ieee_double_big); + builtin_type_ieee_double[BFD_ENDIAN_LITTLE] + = build_flt (floatformat_ieee_double_little.totalsize, + "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); @@ -3612,6 +3628,14 @@ _initialize_gdbtypes (void) 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_arm_ext[BFD_ENDIAN_BIG] + = build_flt (floatformat_arm_ext_big.totalsize, + "builtin_type_arm_ext_big", + &floatformat_arm_ext_big); + builtin_type_arm_ext[BFD_ENDIAN_LITTLE] + = build_flt (floatformat_arm_ext_littlebyte_bigword.totalsize, + "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); @@ -3620,6 +3644,14 @@ _initialize_gdbtypes (void) 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_spill[BFD_ENDIAN_BIG] + = build_flt (floatformat_ia64_spill_big.totalsize, + "builtin_type_ia64_spill_big", + &floatformat_ia64_spill_big); + builtin_type_ia64_spill[BFD_ENDIAN_LITTLE] + = build_flt (floatformat_ia64_spill_little.totalsize, + "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); @@ -3628,11 +3660,20 @@ _initialize_gdbtypes (void) 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; - - 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\n\ - is displayed.", &setdebuglist), - &showdebuglist); + builtin_type_ia64_quad[BFD_ENDIAN_BIG] + = build_flt (floatformat_ia64_quad_big.totalsize, + "builtin_type_ia64_quad_big", + &floatformat_ia64_quad_big); + builtin_type_ia64_quad[BFD_ENDIAN_LITTLE] + = build_flt (floatformat_ia64_quad_little.totalsize, + "builtin_type_ia64_quad_little", + &floatformat_ia64_quad_little); + + 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); }