X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbtypes.c;h=31c1a7b732b1627077a3b1dcd566875b4e8b1829;hb=be09caf15d3d57da2173d26abdb0bf92ef90f28f;hp=db470dafacc919bf260a9a7bc469ebcf35578154;hpb=ef0bd2046f58fac69577892c2d3b44b20d027476;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index db470dafac..31c1a7b732 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -116,16 +116,15 @@ const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = { /* Should opaque types be resolved? */ -static int opaque_type_resolution = 1; +static bool opaque_type_resolution = true; -/* A flag to enable printing of debugging information of C++ - overloading. */ +/* See gdbtypes.h. */ unsigned int overload_debug = 0; /* A flag to enable strict type checking. */ -static int strict_type_checking = 1; +static bool strict_type_checking = true; /* A function to show whether opaque types are resolved. */ @@ -574,7 +573,8 @@ lookup_function_type_with_arguments (struct type *type, return the integer flag defined in gdbtypes.h. */ int -address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier) +address_space_name_to_int (struct gdbarch *gdbarch, + const char *space_identifier) { int type_flags; @@ -900,7 +900,8 @@ operator== (const range_bounds &l, const range_bounds &r) return (FIELD_EQ (low) && FIELD_EQ (high) && FIELD_EQ (flag_upper_bound_is_count) - && FIELD_EQ (flag_bound_evaluated)); + && FIELD_EQ (flag_bound_evaluated) + && FIELD_EQ (bias)); #undef FIELD_EQ } @@ -911,8 +912,14 @@ operator== (const range_bounds &l, const range_bounds &r) struct type * create_range_type (struct type *result_type, struct type *index_type, const struct dynamic_prop *low_bound, - const struct dynamic_prop *high_bound) + const struct dynamic_prop *high_bound, + LONGEST bias) { + /* The INDEX_TYPE should be a type capable of holding the upper and lower + bounds, as such a zero sized, or void type makes no sense. */ + gdb_assert (TYPE_CODE (index_type) != TYPE_CODE_VOID); + gdb_assert (TYPE_LENGTH (index_type) > 0); + if (result_type == NULL) result_type = alloc_type_copy (index_type); TYPE_CODE (result_type) = TYPE_CODE_RANGE; @@ -926,6 +933,7 @@ create_range_type (struct type *result_type, struct type *index_type, TYPE_ZALLOC (result_type, sizeof (struct range_bounds)); TYPE_RANGE_DATA (result_type)->low = *low_bound; TYPE_RANGE_DATA (result_type)->high = *high_bound; + TYPE_RANGE_DATA (result_type)->bias = bias; if (low_bound->kind == PROP_CONST && low_bound->data.const_val >= 0) TYPE_UNSIGNED (result_type) = 1; @@ -962,7 +970,7 @@ create_static_range_type (struct type *result_type, struct type *index_type, high.kind = PROP_CONST; high.data.const_val = high_bound; - result_type = create_range_type (result_type, index_type, &low, &high); + result_type = create_range_type (result_type, index_type, &low, &high, 0); return result_type; } @@ -1528,7 +1536,7 @@ lookup_unsigned_typename (const struct language_defn *language, strcpy (uns, "unsigned "); strcpy (uns + 9, name); - return lookup_typename (language, gdbarch, uns, (struct block *) NULL, 0); + return lookup_typename (language, gdbarch, uns, NULL, 0); } struct type * @@ -1540,11 +1548,11 @@ lookup_signed_typename (const struct language_defn *language, strcpy (uns, "signed "); strcpy (uns + 7, name); - t = lookup_typename (language, gdbarch, uns, (struct block *) NULL, 1); + t = lookup_typename (language, gdbarch, uns, NULL, 1); /* If we don't find "signed FOO" just try again with plain "FOO". */ if (t != NULL) return t; - return lookup_typename (language, gdbarch, name, (struct block *) NULL, 0); + return lookup_typename (language, gdbarch, name, NULL, 0); } /* Lookup a structure type named "struct NAME", @@ -1618,7 +1626,7 @@ lookup_enum (const char *name, const struct block *block) visible in lexical block BLOCK. */ struct type * -lookup_template_type (char *name, struct type *type, +lookup_template_type (const char *name, struct type *type, const struct block *block) { struct symbol *sym; @@ -2009,9 +2017,10 @@ resolve_dynamic_range (struct type *dyn_range_type, static_target_type = resolve_dynamic_type_internal (TYPE_TARGET_TYPE (dyn_range_type), addr_stack, 0); + LONGEST bias = TYPE_RANGE_DATA (dyn_range_type)->bias; static_range_type = create_range_type (copy_type (dyn_range_type), static_target_type, - &low_bound, &high_bound); + &low_bound, &high_bound, bias); TYPE_RANGE_DATA (static_range_type)->flag_bound_evaluated = 1; return static_range_type; } @@ -2064,10 +2073,7 @@ resolve_dynamic_array (struct type *type, prop = get_dyn_prop (DYN_PROP_BYTE_STRIDE, type); if (prop != NULL) { - int prop_eval_ok - = dwarf2_evaluate_property (prop, NULL, addr_stack, &value); - - if (prop_eval_ok) + if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value)) { remove_dyn_prop (DYN_PROP_BYTE_STRIDE, type); bit_stride = (unsigned int) (value * 8); @@ -2571,15 +2577,14 @@ safe_parse_type (struct gdbarch *gdbarch, char *p, int length) gdb_stderr = &null_stream; /* Call parse_and_eval_type() without fear of longjmp()s. */ - TRY + try { type = parse_and_eval_type (p, length); } - CATCH (except, RETURN_MASK_ERROR) + catch (const gdb_exception_error &except) { type = builtin_type (gdbarch)->builtin_void; } - END_CATCH /* Stop suppressing error messages. */ gdb_stderr = saved_gdb_stderr; @@ -2728,7 +2733,7 @@ check_stub_method_group (struct type *type, int method_id) } } -/* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */ +/* Ensure it is in .rodata (if available) by working around GCC PR 44690. */ const struct cplus_struct_type cplus_struct_default = { }; void @@ -3015,16 +3020,12 @@ type_align (struct type *type) case TYPE_CODE_STRUCT: case TYPE_CODE_UNION: { - if (TYPE_NFIELDS (type) == 0) - { - /* An empty struct has alignment 1. */ - align = 1; - break; - } + int number_of_non_static_fields = 0; for (unsigned i = 0; i < TYPE_NFIELDS (type); ++i) { if (!field_is_static (&TYPE_FIELD (type, i))) { + number_of_non_static_fields++; ULONGEST f_align = type_align (TYPE_FIELD_TYPE (type, i)); if (f_align == 0) { @@ -3036,6 +3037,10 @@ type_align (struct type *type) align = f_align; } } + /* A struct with no fields, or with only static fields has an + alignment of 1. */ + if (number_of_non_static_fields == 0) + align = 1; } break; @@ -3611,6 +3616,7 @@ check_types_equal (struct type *type1, struct type *type2, || TYPE_LENGTH (type1) != TYPE_LENGTH (type2) || TYPE_UNSIGNED (type1) != TYPE_UNSIGNED (type2) || TYPE_NOSIGN (type1) != TYPE_NOSIGN (type2) + || TYPE_ENDIANITY_NOT_DEFAULT (type1) != TYPE_ENDIANITY_NOT_DEFAULT (type2) || TYPE_VARARGS (type1) != TYPE_VARARGS (type2) || TYPE_VECTOR (type1) != TYPE_VECTOR (type2) || TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2) @@ -4591,7 +4597,7 @@ recursive_dump_type (struct type *type, int spaces) break; } puts_filtered ("\n"); - printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type)); + printfi_filtered (spaces, "length %s\n", pulongest (TYPE_LENGTH (type))); if (TYPE_OBJFILE_OWNED (type)) { printfi_filtered (spaces, "objfile "); @@ -4664,6 +4670,10 @@ recursive_dump_type (struct type *type, int spaces) { puts_filtered (" TYPE_NOSIGN"); } + if (TYPE_ENDIANITY_NOT_DEFAULT (type)) + { + puts_filtered (" TYPE_ENDIANITY_NOT_DEFAULT"); + } if (TYPE_STUB (type)) { puts_filtered (" TYPE_STUB"); @@ -5359,6 +5369,9 @@ gdbtypes_post_init (struct gdbarch *gdbarch) builtin_type->builtin_unsigned_long_long = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch), 1, "unsigned long long"); + builtin_type->builtin_half + = arch_float_type (gdbarch, gdbarch_half_bit (gdbarch), + "half", gdbarch_half_format (gdbarch)); builtin_type->builtin_float = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), "float", gdbarch_float_format (gdbarch)); @@ -5458,14 +5471,15 @@ gdbtypes_post_init (struct gdbarch *gdbarch) /* This set of objfile-based types is intended to be used by symbol readers as basic types. */ -static const struct objfile_data *objfile_type_data; +static const struct objfile_key> + objfile_type_data; const struct objfile_type * objfile_type (struct objfile *objfile) { struct gdbarch *gdbarch; - struct objfile_type *objfile_type - = (struct objfile_type *) objfile_data (objfile, objfile_type_data); + struct objfile_type *objfile_type = objfile_type_data.get (objfile); if (objfile_type) return objfile_type; @@ -5570,7 +5584,7 @@ objfile_type (struct objfile *objfile) = init_integer_type (objfile, gdbarch_addr_bit (gdbarch), 1, "__CORE_ADDR"); - set_objfile_data (objfile, objfile_type_data, objfile_type); + objfile_type_data.set (objfile, objfile_type); return objfile_type; } @@ -5578,7 +5592,6 @@ void _initialize_gdbtypes (void) { gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init); - objfile_type_data = register_objfile_data (); add_setshow_zuinteger_cmd ("overload", no_class, &overload_debug, _("Set debugging of C++ overloading."), @@ -5609,3 +5622,21 @@ _initialize_gdbtypes (void) show_strict_type_checking, &setchecklist, &showchecklist); } + +/* See gdbtypes.h. */ +enum bfd_endian +type_byte_order (const struct type *type) +{ + bfd_endian byteorder = gdbarch_byte_order (get_type_arch (type)); + if (TYPE_ENDIANITY_NOT_DEFAULT (type)) + { + if (byteorder == BFD_ENDIAN_BIG) + return BFD_ENDIAN_LITTLE; + else if (byteorder == BFD_ENDIAN_LITTLE) + return BFD_ENDIAN_BIG; + else + return BFD_ENDIAN_UNKNOWN; + } + + return byteorder; +}