X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbtypes.c;h=622eff08bc20f70b107eea0b1d752052b3b71e14;hb=2117c711ae07700adb57ea5b5ca61e4c32d7e3d2;hp=cb25e71fc7c5c5d02727290ea4196b70573176b2;hpb=a6fb9c08a9ac65df98ca8829f43083feda19a6fe;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index cb25e71fc7..622eff08bc 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -1,6 +1,6 @@ /* Support routines for manipulating internal types for GDB. - Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. + Copyright (C) 1992-2014 Free Software Foundation, Inc. Contributed by Cygnus Support, using pieces from other GDB modules. @@ -20,7 +20,7 @@ along with this program. If not, see . */ #include "defs.h" -#include "gdb_string.h" +#include #include "bfd.h" #include "symtab.h" #include "symfile.h" @@ -37,6 +37,9 @@ #include "gdb_assert.h" #include "hashtab.h" #include "exceptions.h" +#include "cp-support.h" +#include "bcache.h" +#include "dwarf2loc.h" /* Initialize BADNESS constants. */ @@ -54,11 +57,12 @@ const struct rank INTEGER_CONVERSION_BADNESS = {2,0}; const struct rank FLOAT_CONVERSION_BADNESS = {2,0}; const struct rank INT_FLOAT_CONVERSION_BADNESS = {2,0}; const struct rank VOID_PTR_CONVERSION_BADNESS = {2,0}; -const struct rank BOOL_PTR_CONVERSION_BADNESS = {3,0}; +const struct rank BOOL_CONVERSION_BADNESS = {3,0}; const struct rank BASE_CONVERSION_BADNESS = {2,0}; const struct rank REFERENCE_CONVERSION_BADNESS = {2,0}; const struct rank NULL_POINTER_CONVERSION_BADNESS = {2,0}; const struct rank NS_POINTER_CONVERSION_BADNESS = {10,0}; +const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS = {3,0}; /* Floatformat pairs. */ const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN] = { @@ -106,12 +110,25 @@ const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN] = { &floatformat_vax_d }; const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = { - &floatformat_ibm_long_double, - &floatformat_ibm_long_double + &floatformat_ibm_long_double_big, + &floatformat_ibm_long_double_little }; +/* Should opaque types be resolved? */ + +static int opaque_type_resolution = 1; + +/* A flag to enable printing of debugging information of C++ + overloading. */ + +unsigned int overload_debug = 0; + +/* A flag to enable strict type checking. */ + +static int strict_type_checking = 1; + +/* A function to show whether opaque types are resolved. */ -int opaque_type_resolution = 1; static void show_opaque_type_resolution (struct ui_file *file, int from_tty, struct cmd_list_element *c, @@ -122,7 +139,8 @@ show_opaque_type_resolution (struct ui_file *file, int from_tty, value); } -int overload_debug = 0; +/* A function to show whether C++ overload debugging is enabled. */ + static void show_overload_debug (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) @@ -131,18 +149,16 @@ show_overload_debug (struct ui_file *file, int from_tty, value); } -struct extra - { - char str[128]; - int len; - }; /* Maximum extension is 128! FIXME */ - -static void print_bit_vector (B_TYPE *, int); -static void print_arg_types (struct field *, int, int); -static void dump_fn_fieldlists (struct type *, int); -static void print_cplus_stuff (struct type *, int); +/* A function to show the status of strict type checking. */ +static void +show_strict_type_checking (struct ui_file *file, int from_tty, + struct cmd_list_element *c, const char *value) +{ + fprintf_filtered (file, _("Strict type checking is %s.\n"), value); +} + /* Allocate a new OBJFILE-associated type structure and fill it with some defaults. Space for the type structure is allocated on the objfile's objfile_obstack. */ @@ -185,8 +201,8 @@ alloc_type_arch (struct gdbarch *gdbarch) /* Alloc the structure and start off with all fields zeroed. */ - type = XZALLOC (struct type); - TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type); + type = XCNEW (struct type); + TYPE_MAIN_TYPE (type) = XCNEW (struct main_type); TYPE_OBJFILE_OWNED (type) = 0; TYPE_OWNER (type).gdbarch = gdbarch; @@ -225,6 +241,20 @@ get_type_arch (const struct type *type) return TYPE_OWNER (type).gdbarch; } +/* See gdbtypes.h. */ + +struct type * +get_target_type (struct type *type) +{ + if (type != NULL) + { + type = TYPE_TARGET_TYPE (type); + if (type != NULL) + type = check_typedef (type); + } + + return type; +} /* Alloc a new type instance structure, fill it with some defaults, and point it at OLDTYPE. Allocate the new type instance from the @@ -238,7 +268,7 @@ alloc_type_instance (struct type *oldtype) /* Allocate the structure. */ if (! TYPE_OBJFILE_OWNED (oldtype)) - type = XZALLOC (struct type); + type = XCNEW (struct type); else type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack, struct type); @@ -252,6 +282,7 @@ alloc_type_instance (struct type *oldtype) /* Clear all remnants of the previous type at TYPE, in preparation for replacing it with something else. Preserve owner information. */ + static void smash_type (struct type *type) { @@ -312,8 +343,7 @@ make_pointer_type (struct type *type, struct type **typeptr) TYPE_TARGET_TYPE (ntype) = type; TYPE_POINTER_TYPE (type) = ntype; - /* FIXME! Assume the machine has only one representation for - pointers! */ + /* FIXME! Assumes the machine has only one representation for pointers! */ TYPE_LENGTH (ntype) = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT; @@ -324,9 +354,6 @@ make_pointer_type (struct type *type, struct type **typeptr) gdbarch_address_to_pointer. */ TYPE_UNSIGNED (ntype) = 1; - if (!TYPE_POINTER_TYPE (type)) /* Remember it, if don't have one. */ - TYPE_POINTER_TYPE (type) = ntype; - /* Update the length of all the other variants of this type. */ chain = TYPE_CHAIN (ntype); while (chain != ntype) @@ -452,7 +479,6 @@ make_function_type (struct type *type, struct type **typeptr) return ntype; } - /* Given a type TYPE, return a type of functions that return that type. May need to construct such a type if this is the first use. */ @@ -474,10 +500,21 @@ lookup_function_type_with_arguments (struct type *type, struct type *fn = make_function_type (type, (struct type **) 0); int i; - if (nparams > 0 && param_types[nparams - 1] == NULL) + if (nparams > 0) { - --nparams; - TYPE_VARARGS (fn) = 1; + if (param_types[nparams - 1] == NULL) + { + --nparams; + TYPE_VARARGS (fn) = 1; + } + else if (TYPE_CODE (check_typedef (param_types[nparams - 1])) + == TYPE_CODE_VOID) + { + --nparams; + /* Caller should have ensured this. */ + gdb_assert (nparams == 0); + TYPE_PROTOTYPED (fn) = 1; + } } TYPE_NFIELDS (fn) = nparams; @@ -490,7 +527,8 @@ lookup_function_type_with_arguments (struct type *type, /* Identify address space identifier by name -- return the integer flag defined in gdbtypes.h. */ -extern int + +int address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier) { int type_flags; @@ -612,6 +650,7 @@ make_type_with_address_space (struct type *type, int space_flag) in the same objfile. Otherwise, allocate fresh memory for the new type whereever TYPE lives. If TYPEPTR is non-zero, set it to the new type we construct. */ + struct type * make_cv_type (int cnst, int voltl, struct type *type, @@ -655,6 +694,17 @@ make_cv_type (int cnst, int voltl, return ntype; } +/* Make a 'restrict'-qualified version of TYPE. */ + +struct type * +make_restrict_type (struct type *type) +{ + return make_qualified_type (type, + (TYPE_INSTANCE_FLAGS (type) + | TYPE_INSTANCE_FLAG_RESTRICT), + NULL); +} + /* Replace the contents of ntype with the type *type. This changes the contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus the changes are propogated to all types in the TYPE_CHAIN. @@ -664,6 +714,7 @@ make_cv_type (int cnst, int voltl, smashing is ugly, and needs to be replaced with something more controlled. TYPE_MAIN_TYPE is a step in this direction; it's not clear if more steps are needed. */ + void replace_type (struct type *ntype, struct type *type) { @@ -942,7 +993,7 @@ create_array_type (struct type *result_type, struct type * lookup_array_range_type (struct type *element_type, - int low_bound, int high_bound) + LONGEST low_bound, LONGEST high_bound) { struct gdbarch *gdbarch = get_type_arch (element_type); struct type *index_type = builtin_type (gdbarch)->builtin_int; @@ -978,7 +1029,7 @@ create_string_type (struct type *result_type, struct type * lookup_string_range_type (struct type *string_char_type, - int low_bound, int high_bound) + LONGEST low_bound, LONGEST high_bound) { struct type *result_type; @@ -1153,7 +1204,8 @@ type_name_no_tag_or_error (struct type *type) name = type_name_no_tag (saved_type); objfile = TYPE_OBJFILE (saved_type); error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"), - name ? name : "", objfile ? objfile->name : ""); + name ? name : "", + objfile ? objfile_name (objfile) : ""); } /* Lookup a typedef or primitive type named NAME, visible in lexical @@ -1212,7 +1264,7 @@ lookup_signed_typename (const struct language_defn *language, visible in lexical block BLOCK. */ struct type * -lookup_struct (const char *name, struct block *block) +lookup_struct (const char *name, const struct block *block) { struct symbol *sym; @@ -1234,7 +1286,7 @@ lookup_struct (const char *name, struct block *block) visible in lexical block BLOCK. */ struct type * -lookup_union (const char *name, struct block *block) +lookup_union (const char *name, const struct block *block) { struct symbol *sym; struct type *t; @@ -1254,12 +1306,11 @@ lookup_union (const char *name, struct block *block) name); } - /* Lookup an enum type named "enum NAME", visible in lexical block BLOCK. */ struct type * -lookup_enum (const char *name, struct block *block) +lookup_enum (const char *name, const struct block *block) { struct symbol *sym; @@ -1281,7 +1332,7 @@ lookup_enum (const char *name, struct block *block) struct type * lookup_template_type (char *name, struct type *type, - struct block *block) + const struct block *block) { struct symbol *sym; char *nam = (char *) @@ -1319,7 +1370,7 @@ lookup_template_type (char *name, struct type *type, If NAME is the name of a baseclass type, return that type. */ struct type * -lookup_struct_elt_type (struct type *type, char *name, int noerr) +lookup_struct_elt_type (struct type *type, const char *name, int noerr) { int i; char *typename; @@ -1395,6 +1446,40 @@ lookup_struct_elt_type (struct type *type, char *name, int noerr) error (_("Type %s has no component named %s."), typename, name); } +/* Store in *MAX the largest number representable by unsigned integer type + TYPE. */ + +void +get_unsigned_type_max (struct type *type, ULONGEST *max) +{ + unsigned int n; + + CHECK_TYPEDEF (type); + gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && TYPE_UNSIGNED (type)); + gdb_assert (TYPE_LENGTH (type) <= sizeof (ULONGEST)); + + /* Written this way to avoid overflow. */ + n = TYPE_LENGTH (type) * TARGET_CHAR_BIT; + *max = ((((ULONGEST) 1 << (n - 1)) - 1) << 1) | 1; +} + +/* Store in *MIN, *MAX the smallest and largest numbers representable by + signed integer type TYPE. */ + +void +get_signed_type_minmax (struct type *type, LONGEST *min, LONGEST *max) +{ + unsigned int n; + + CHECK_TYPEDEF (type); + gdb_assert (TYPE_CODE (type) == TYPE_CODE_INT && !TYPE_UNSIGNED (type)); + gdb_assert (TYPE_LENGTH (type) <= sizeof (LONGEST)); + + n = TYPE_LENGTH (type) * TARGET_CHAR_BIT; + *min = -((ULONGEST) 1 << (n - 1)); + *max = ((ULONGEST) 1 << (n - 1)) - 1; +} + /* Lookup the vptr basetype/fieldno values for TYPE. If found store vptr_basetype in *BASETYPEP if non-NULL, and return vptr_fieldno. Also, if found and basetype is from the same objfile, @@ -1732,8 +1817,8 @@ check_stub_method (struct type *type, int method_id, int signature_id) struct gdbarch *gdbarch = get_type_arch (type); struct fn_field *f; char *mangled_name = gdb_mangle_name (type, method_id, signature_id); - char *demangled_name = cplus_demangle (mangled_name, - DMGL_PARAMS | DMGL_ANSI); + char *demangled_name = gdb_demangle (mangled_name, + DMGL_PARAMS | DMGL_ANSI); char *argtypetext, *p; int depth = 0, argcount = 1; struct field *argtypes; @@ -1906,6 +1991,7 @@ const struct gnat_aux_type gnat_aux_default = /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF, and allocate the associated gnat-specific data. The gnat-specific data is also initialized to gnat_aux_default. */ + void allocate_gnat_aux_type (struct type *type) { @@ -1915,17 +2001,15 @@ allocate_gnat_aux_type (struct type *type) *(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default; } - /* Helper function to initialize the standard scalar types. - If NAME is non-NULL, then we make a copy of the string pointed - to by name in the objfile_obstack for that objfile, and initialize - the type name to that copy. There are places (mipsread.c in particular), - where init_type is called with a NULL value for NAME). */ + If NAME is non-NULL, then it is used to initialize the type name. + Note that NAME is not copied; it is required to have a lifetime at + least as long as OBJFILE. */ struct type * init_type (enum type_code code, int length, int flags, - char *name, struct objfile *objfile) + const char *name, struct objfile *objfile) { struct type *type; @@ -1959,9 +2043,7 @@ init_type (enum type_code code, int length, int flags, if (flags & TYPE_FLAG_GNU_IFUNC) TYPE_GNU_IFUNC (type) = 1; - if (name) - TYPE_NAME (type) = obsavestring (name, strlen (name), - &objfile->objfile_obstack); + TYPE_NAME (type) = name; /* C++ fancies. */ @@ -1984,6 +2066,8 @@ init_type (enum type_code code, int length, int flags, } return type; } + +/* Queries on types. */ int can_dereference (struct type *t) @@ -2025,7 +2109,6 @@ is_scalar_type (struct type *type) case TYPE_CODE_UNION: case TYPE_CODE_SET: case TYPE_CODE_STRING: - case TYPE_CODE_BITSTRING: return 0; default: return 1; @@ -2218,6 +2301,7 @@ is_unique_ancestor (struct type *base, struct value *val) } +/* Overload resolution. */ /* Return the sum of the rank of A with the rank of B. */ @@ -2383,7 +2467,7 @@ integer_types_same_name_p (const char *first, const char *second) /* Compares type A to type B returns 1 if the represent the same type 0 otherwise. */ -static int +int types_equal (struct type *a, struct type *b) { /* Identical type pointers. */ @@ -2425,9 +2509,238 @@ types_equal (struct type *a, struct type *b) if (a == b) return 1; + /* Two function types are equal if their argument and return types + are equal. */ + if (TYPE_CODE (a) == TYPE_CODE_FUNC) + { + int i; + + if (TYPE_NFIELDS (a) != TYPE_NFIELDS (b)) + return 0; + + if (!types_equal (TYPE_TARGET_TYPE (a), TYPE_TARGET_TYPE (b))) + return 0; + + for (i = 0; i < TYPE_NFIELDS (a); ++i) + if (!types_equal (TYPE_FIELD_TYPE (a, i), TYPE_FIELD_TYPE (b, i))) + return 0; + + return 1; + } + return 0; } + +/* Deep comparison of types. */ + +/* An entry in the type-equality bcache. */ + +typedef struct type_equality_entry +{ + struct type *type1, *type2; +} type_equality_entry_d; + +DEF_VEC_O (type_equality_entry_d); + +/* A helper function to compare two strings. Returns 1 if they are + the same, 0 otherwise. Handles NULLs properly. */ + +static int +compare_maybe_null_strings (const char *s, const char *t) +{ + if (s == NULL && t != NULL) + return 0; + else if (s != NULL && t == NULL) + return 0; + else if (s == NULL && t== NULL) + return 1; + return strcmp (s, t) == 0; +} + +/* A helper function for check_types_worklist that checks two types for + "deep" equality. Returns non-zero if the types are considered the + same, zero otherwise. */ + +static int +check_types_equal (struct type *type1, struct type *type2, + VEC (type_equality_entry_d) **worklist) +{ + CHECK_TYPEDEF (type1); + CHECK_TYPEDEF (type2); + + if (type1 == type2) + return 1; + + if (TYPE_CODE (type1) != TYPE_CODE (type2) + || TYPE_LENGTH (type1) != TYPE_LENGTH (type2) + || TYPE_UNSIGNED (type1) != TYPE_UNSIGNED (type2) + || TYPE_NOSIGN (type1) != TYPE_NOSIGN (type2) + || TYPE_VARARGS (type1) != TYPE_VARARGS (type2) + || TYPE_VECTOR (type1) != TYPE_VECTOR (type2) + || TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2) + || TYPE_INSTANCE_FLAGS (type1) != TYPE_INSTANCE_FLAGS (type2) + || TYPE_NFIELDS (type1) != TYPE_NFIELDS (type2)) + return 0; + + if (!compare_maybe_null_strings (TYPE_TAG_NAME (type1), + TYPE_TAG_NAME (type2))) + return 0; + if (!compare_maybe_null_strings (TYPE_NAME (type1), TYPE_NAME (type2))) + return 0; + + if (TYPE_CODE (type1) == TYPE_CODE_RANGE) + { + if (memcmp (TYPE_RANGE_DATA (type1), TYPE_RANGE_DATA (type2), + sizeof (*TYPE_RANGE_DATA (type1))) != 0) + return 0; + } + else + { + int i; + + for (i = 0; i < TYPE_NFIELDS (type1); ++i) + { + const struct field *field1 = &TYPE_FIELD (type1, i); + const struct field *field2 = &TYPE_FIELD (type2, i); + struct type_equality_entry entry; + + if (FIELD_ARTIFICIAL (*field1) != FIELD_ARTIFICIAL (*field2) + || FIELD_BITSIZE (*field1) != FIELD_BITSIZE (*field2) + || FIELD_LOC_KIND (*field1) != FIELD_LOC_KIND (*field2)) + return 0; + if (!compare_maybe_null_strings (FIELD_NAME (*field1), + FIELD_NAME (*field2))) + return 0; + switch (FIELD_LOC_KIND (*field1)) + { + case FIELD_LOC_KIND_BITPOS: + if (FIELD_BITPOS (*field1) != FIELD_BITPOS (*field2)) + return 0; + break; + case FIELD_LOC_KIND_ENUMVAL: + if (FIELD_ENUMVAL (*field1) != FIELD_ENUMVAL (*field2)) + return 0; + break; + case FIELD_LOC_KIND_PHYSADDR: + if (FIELD_STATIC_PHYSADDR (*field1) + != FIELD_STATIC_PHYSADDR (*field2)) + return 0; + break; + case FIELD_LOC_KIND_PHYSNAME: + if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1), + FIELD_STATIC_PHYSNAME (*field2))) + return 0; + break; + case FIELD_LOC_KIND_DWARF_BLOCK: + { + struct dwarf2_locexpr_baton *block1, *block2; + + block1 = FIELD_DWARF_BLOCK (*field1); + block2 = FIELD_DWARF_BLOCK (*field2); + if (block1->per_cu != block2->per_cu + || block1->size != block2->size + || memcmp (block1->data, block2->data, block1->size) != 0) + return 0; + } + break; + default: + internal_error (__FILE__, __LINE__, _("Unsupported field kind " + "%d by check_types_equal"), + FIELD_LOC_KIND (*field1)); + } + + entry.type1 = FIELD_TYPE (*field1); + entry.type2 = FIELD_TYPE (*field2); + VEC_safe_push (type_equality_entry_d, *worklist, &entry); + } + } + + if (TYPE_TARGET_TYPE (type1) != NULL) + { + struct type_equality_entry entry; + + if (TYPE_TARGET_TYPE (type2) == NULL) + return 0; + + entry.type1 = TYPE_TARGET_TYPE (type1); + entry.type2 = TYPE_TARGET_TYPE (type2); + VEC_safe_push (type_equality_entry_d, *worklist, &entry); + } + else if (TYPE_TARGET_TYPE (type2) != NULL) + return 0; + + return 1; +} + +/* Check types on a worklist for equality. Returns zero if any pair + is not equal, non-zero if they are all considered equal. */ + +static int +check_types_worklist (VEC (type_equality_entry_d) **worklist, + struct bcache *cache) +{ + while (!VEC_empty (type_equality_entry_d, *worklist)) + { + struct type_equality_entry entry; + int added; + entry = *VEC_last (type_equality_entry_d, *worklist); + VEC_pop (type_equality_entry_d, *worklist); + + /* If the type pair has already been visited, we know it is + ok. */ + bcache_full (&entry, sizeof (entry), cache, &added); + if (!added) + continue; + + if (check_types_equal (entry.type1, entry.type2, worklist) == 0) + return 0; + } + + return 1; +} + +/* Return non-zero if types TYPE1 and TYPE2 are equal, as determined by a + "deep comparison". Otherwise return zero. */ + +int +types_deeply_equal (struct type *type1, struct type *type2) +{ + volatile struct gdb_exception except; + int result = 0; + struct bcache *cache; + VEC (type_equality_entry_d) *worklist = NULL; + struct type_equality_entry entry; + + gdb_assert (type1 != NULL && type2 != NULL); + + /* Early exit for the simple case. */ + if (type1 == type2) + return 1; + + cache = bcache_xmalloc (NULL, NULL); + + entry.type1 = type1; + entry.type2 = type2; + VEC_safe_push (type_equality_entry_d, worklist, &entry); + + TRY_CATCH (except, RETURN_MASK_ALL) + { + result = check_types_worklist (&worklist, cache); + } + /* check_types_worklist calls several nested helper functions, + some of which can raise a GDB Exception, so we just check + and rethrow here. If there is a GDB exception, a comparison + is not capable (or trusted), so exit. */ + bcache_xfree (cache); + VEC_free (type_equality_entry_d, worklist); + /* Rethrow if there was a problem. */ + if (except.reason < 0) + throw_exception (except); + + return result; +} + /* 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 @@ -2498,12 +2811,20 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value) case TYPE_CODE_FUNC: return rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL); case TYPE_CODE_INT: - if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT - && value_as_long (value) == 0) + if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT) { - /* Null pointer conversion: allow it to be cast to a pointer. - [4.10.1 of C++ standard draft n3290] */ - return NULL_POINTER_CONVERSION_BADNESS; + if (value_as_long (value) == 0) + { + /* Null pointer conversion: allow it to be cast to a pointer. + [4.10.1 of C++ standard draft n3290] */ + return NULL_POINTER_CONVERSION_BADNESS; + } + else + { + /* If type checking is disabled, allow the conversion. */ + if (!strict_type_checking) + return NS_INTEGER_POINTER_CONVERSION_BADNESS; + } } /* fall through */ case TYPE_CODE_ENUM: @@ -2687,14 +3008,23 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value) case TYPE_CODE_BOOL: switch (TYPE_CODE (arg)) { + /* n3290 draft, section 4.12.1 (conv.bool): + + "A prvalue of arithmetic, unscoped enumeration, pointer, or + pointer to member type can be converted to a prvalue of type + bool. A zero value, null pointer value, or null member pointer + value is converted to false; any other value is converted to + true. A prvalue of type std::nullptr_t can be converted to a + prvalue of type bool; the resulting value is false." */ case TYPE_CODE_INT: case TYPE_CODE_CHAR: - case TYPE_CODE_RANGE: case TYPE_CODE_ENUM: case TYPE_CODE_FLT: - return INCOMPATIBLE_TYPE_BADNESS; + case TYPE_CODE_MEMBERPTR: case TYPE_CODE_PTR: - return BOOL_PTR_CONVERSION_BADNESS; + return BOOL_CONVERSION_BADNESS; + case TYPE_CODE_RANGE: + return INCOMPATIBLE_TYPE_BADNESS; case TYPE_CODE_BOOL: return EXACT_MATCH_BADNESS; default: @@ -2795,8 +3125,9 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value) } /* switch (TYPE_CODE (arg)) */ } - /* End of functions for overload resolution. */ + +/* Routines to pretty-print types. */ static void print_bit_vector (B_TYPE *bits, int nbits) @@ -3064,9 +3395,6 @@ recursive_dump_type (struct type *type, int spaces) case TYPE_CODE_STRING: printf_filtered ("(TYPE_CODE_STRING)"); break; - case TYPE_CODE_BITSTRING: - printf_filtered ("(TYPE_CODE_BITSTRING)"); - break; case TYPE_CODE_ERROR: printf_filtered ("(TYPE_CODE_ERROR)"); break; @@ -3156,6 +3484,10 @@ recursive_dump_type (struct type *type, int spaces) { puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2"); } + if (TYPE_RESTRICT (type)) + { + puts_filtered (" TYPE_FLAG_RESTRICT"); + } puts_filtered ("\n"); printfi_filtered (spaces, "flags"); @@ -3308,7 +3640,7 @@ recursive_dump_type (struct type *type, int spaces) if (spaces == 0) obstack_free (&dont_print_type_obstack, NULL); } - + /* Trivial helpers for the libiberty hash table, for mapping one type to another. */ @@ -3402,7 +3734,7 @@ copy_type_recursive (struct objfile *objfile, int i, nfields; nfields = TYPE_NFIELDS (type); - TYPE_FIELDS (new_type) = XCALLOC (nfields, struct field); + TYPE_FIELDS (new_type) = XCNEWVEC (struct field, nfields); for (i = 0; i < nfields; i++) { TYPE_FIELD_ARTIFICIAL (new_type, i) = @@ -3497,12 +3829,12 @@ copy_type (const struct type *type) return new_type; } - - + /* Helper functions to initialize architecture-specific types. */ /* Allocate a type structure associated with GDBARCH and set its CODE, LENGTH, and NAME fields. */ + struct type * arch_type (struct gdbarch *gdbarch, enum type_code code, int length, char *name) @@ -3522,6 +3854,7 @@ arch_type (struct gdbarch *gdbarch, /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH. BIT is the type size in bits. If UNSIGNED_P is non-zero, set the type's TYPE_UNSIGNED flag. NAME is the type name. */ + struct type * arch_integer_type (struct gdbarch *gdbarch, int bit, int unsigned_p, char *name) @@ -3540,6 +3873,7 @@ arch_integer_type (struct gdbarch *gdbarch, /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH. BIT is the type size in bits. If UNSIGNED_P is non-zero, set the type's TYPE_UNSIGNED flag. NAME is the type name. */ + struct type * arch_character_type (struct gdbarch *gdbarch, int bit, int unsigned_p, char *name) @@ -3556,6 +3890,7 @@ arch_character_type (struct gdbarch *gdbarch, /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH. BIT is the type size in bits. If UNSIGNED_P is non-zero, set the type's TYPE_UNSIGNED flag. NAME is the type name. */ + struct type * arch_boolean_type (struct gdbarch *gdbarch, int bit, int unsigned_p, char *name) @@ -3573,6 +3908,7 @@ arch_boolean_type (struct gdbarch *gdbarch, BIT is the type size in bits; if BIT equals -1, the size is determined by the floatformat. NAME is the type name. Set the TYPE_FLOATFORMAT from FLOATFORMATS. */ + struct type * arch_float_type (struct gdbarch *gdbarch, int bit, char *name, const struct floatformat **floatformats) @@ -3594,6 +3930,7 @@ arch_float_type (struct gdbarch *gdbarch, /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH. NAME is the type name. TARGET_TYPE is the component float type. */ + struct type * arch_complex_type (struct gdbarch *gdbarch, char *name, struct type *target_type) @@ -3608,6 +3945,7 @@ arch_complex_type (struct gdbarch *gdbarch, /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH. NAME is the type name. LENGTH is the size of the flag word in bytes. */ + struct type * arch_flags_type (struct gdbarch *gdbarch, char *name, int length) { @@ -3624,6 +3962,7 @@ arch_flags_type (struct gdbarch *gdbarch, char *name, int length) /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at position BITPOS is called NAME. */ + void append_flags_type_flag (struct type *type, int bitpos, char *name) { @@ -3645,6 +3984,7 @@ append_flags_type_flag (struct type *type, int bitpos, char *name) /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as specified by CODE) associated with GDBARCH. NAME is the type name. */ + struct type * arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code) { @@ -3660,6 +4000,7 @@ arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code) /* Add new field with name NAME and type FIELD to composite type T. Do not set the field's position or adjust the type's length; the caller should do so. Return the new field. */ + struct field * append_composite_type_field_raw (struct type *t, char *name, struct type *field) @@ -3678,6 +4019,7 @@ append_composite_type_field_raw (struct type *t, char *name, /* Add new field with name NAME and type FIELD to composite type T. ALIGNMENT (if non-zero) specifies the minimum field alignment. */ + void append_composite_type_field_aligned (struct type *t, char *name, struct type *field, int alignment) @@ -3717,6 +4059,7 @@ append_composite_type_field_aligned (struct type *t, char *name, } /* Add new field with name NAME and type FIELD to composite type T. */ + void append_composite_type_field (struct type *t, char *name, struct type *field) @@ -3724,7 +4067,6 @@ append_composite_type_field (struct type *t, char *name, append_composite_type_field_aligned (t, name, field, 0); } - static struct gdbarch_data *gdbtypes_data; const struct builtin_type * @@ -3861,7 +4203,6 @@ gdbtypes_post_init (struct gdbarch *gdbarch) return builtin_type; } - /* This set of objfile-based types is intended to be used by symbol readers as basic types. */ @@ -3990,9 +4331,7 @@ objfile_type (struct objfile *objfile) "", objfile); /* 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 same. The upshot is: - gdb's `struct type' always describes the target's @@ -4005,12 +4344,6 @@ objfile_type (struct objfile *objfile) 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, objfile_type->builtin_core_addr is a bit odd: it's a target type for a value the target will never see. It's only used to hold the values of (typeless) linker symbols, which @@ -4025,22 +4358,22 @@ objfile_type (struct objfile *objfile) return objfile_type; } +extern initialize_file_ftype _initialize_gdbtypes; -extern void _initialize_gdbtypes (void); void _initialize_gdbtypes (void) { gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init); objfile_type_data = register_objfile_data (); - add_setshow_zinteger_cmd ("overload", no_class, &overload_debug, - _("Set debugging of C++ overloading."), - _("Show debugging of C++ overloading."), - _("When enabled, ranking of the " - "functions is displayed."), - NULL, - show_overload_debug, - &setdebuglist, &showdebuglist); + add_setshow_zuinteger_cmd ("overload", no_class, &overload_debug, + _("Set debugging of C++ overloading."), + _("Show debugging of C++ overloading."), + _("When enabled, ranking of the " + "functions is displayed."), + NULL, + show_overload_debug, + &setdebuglist, &showdebuglist); /* Add user knob for controlling resolution of opaque types. */ add_setshow_boolean_cmd ("opaque-type-resolution", class_support, @@ -4052,4 +4385,13 @@ _initialize_gdbtypes (void) NULL, NULL, show_opaque_type_resolution, &setlist, &showlist); + + /* Add an option to permit non-strict type checking. */ + add_setshow_boolean_cmd ("type", class_support, + &strict_type_checking, + _("Set strict type checking."), + _("Show strict type checking."), + NULL, NULL, + show_strict_type_checking, + &setchecklist, &showchecklist); }