From e9bb382b835d19c078eca9908ec6fe66f7af67fa Mon Sep 17 00:00:00 2001 From: Ulrich Weigand Date: Thu, 2 Jul 2009 12:55:30 +0000 Subject: [PATCH] * gdbtypes.h (TYPE_OBJFILE_OWNED, TYPE_OWNER): New macros. (TYPE_OBJFILE, TYPE_ALLOC, TYPE_ZALLOC): Reimplement. (alloc_type_arch): Add prototype. (alloc_type_copy): Likewise. (get_type_arch): Likewise. (arch_type): Likewise. (arch_integer_type): Likewise. (arch_character_type): Likewise. (arch_boolean_type): Likewise. (init_float_type): Remove, replace by ... (arch_float_type): ... this. (init_complex_type): Remove, replace by ... (arch_complex_type): ... this. (init_flags_type): Remove, replace by ... (arch_flags_type): ... this. (init_composite_type): Remove, replace by ... (arch_composite_type): ... this. * gdbtypes.c (alloc_type): No longer support NULL objfile. (init_type): Likewise. (alloc_type_arch): New function. (alloc_type_copy): New function. (get_type_arch): New function. (smash_type): Preserve type ownership information. (make_pointer_type, make_reference_type, make_function_type, smash_to_memberptr_type, smash_to_method_type): No longer preserve OBJFILE across smash_type calls. (make_pointer_type, make_reference_type, make_function_type, lookup_memberptr_type, lookup_methodptr_type, allocate_stub_method, create_range_type, create_array_type, create_set_type, copy_type): Use alloc_type_copy when allocating types. (check_typedef): Use alloc_type_arch. (copy_type_recursive): Likewise. Preserve type ownership data after copying type. (recursive_dump_type): Dump type ownership data. (alloc_type_instance): Update type ownership check. (copy_type, copy_type_recursive): Likewise. (arch_type): New function. (arch_integer_type): Likewise. (arch_character_type): Likewise. (arch_boolean_type): Likewise. (init_float_type): Remove, replace by ... (arch_float_type): ... this. (init_complex_type): Remove, replace by ... (arch_complex_type): ... this. (init_flags_type): Remove, replace by ... (arch_flags_type): ... this. (append_flags_type_flag): Move down. (init_composite_type): Remove, replace by ... (arch_composite_type): ... this. (append_composite_type_field_aligned, append_composite_type_field): Move down. * gdbarch.c (gdbtypes_post_init): Allocate all types using per-architecture routines. * ada-lang.c (ada_language_arch_info): Likewise. * f-lang.c (build_fortran_types): Likewise. * jv-lang.c (build_java_types): Likewise. * m2-lang.c (build_m2_types): Likewise. * scm-lang.c (build_scm_types): Likewise. * ada-lang.c (ada_type_of_array): Use alloc_type_copy. (packed_array_type): Likewise. (ada_template_to_fixed_record_type_1): Likewise. (template_to_static_fixed_type): Likewise. (to_record_with_fixed_variant_part): Likewise. (to_fixed_variant_branch_type): Likewise. (to_fixed_array_type): Likewise. (to_fixed_range_type): Likewise. (empty_record): Use type instead of objfile argument. Use alloc_type_copy. (to_fixed_variant_branch_type): Update call to empty_record. * jv-lang.c (type_from_class): Use alloc_type_arch. * arm-tdep.c (arm_ext_type): Allocate per-architecture type. * i386-tdep.c (i386_eflags_type, i386_mxcsr_type, i387_ext_type, i386_mmx_type, i386_sse_type): Likewise. * ia64-tdep.c (ia64_ext_type): Likewise. * m32c-tdep.c (make_types): Likewise. * m68k-tdep.c (m68k_ps_type, m68881_ext_type): Likewise. * rs6000-tdep.c (rs6000_builtin_type_vec64, rs6000_builtin_type_vec128): Likewise. * sparc-tdep.c (sparc_psr_type, sparc_fsr_type): Likewise. * sparc64-tdep.c (sparc64_pstate_type, sparc64_fsr_type, sparc64_fprs_type): Likewise. * spu-tdep.c (spu_builtin_type_vec128): Likewise. * xtensa-tdep.c (xtensa_register_type): Likewise. * linux-tdep.c (linux_get_siginfo_type): Likewise. * target-descriptions.c (tdesc_gdb_type): Likewise. * gnu-v3-abi.c (build_gdb_vtable_type): Likewise. --- gdb/ChangeLog | 95 ++++++ gdb/ada-lang.c | 107 +++--- gdb/arm-tdep.c | 2 +- gdb/f-lang.c | 98 +++--- gdb/gdbtypes.c | 687 +++++++++++++++++++++----------------- gdb/gdbtypes.h | 56 +++- gdb/gnu-v3-abi.c | 7 +- gdb/i386-tdep.c | 12 +- gdb/ia64-tdep.c | 2 +- gdb/jv-lang.c | 20 +- gdb/linux-tdep.c | 51 ++- gdb/m2-lang.c | 30 +- gdb/m32c-tdep.c | 31 +- gdb/m68k-tdep.c | 4 +- gdb/rs6000-tdep.c | 6 +- gdb/scm-lang.c | 6 +- gdb/sparc-tdep.c | 4 +- gdb/sparc64-tdep.c | 6 +- gdb/spu-tdep.c | 3 +- gdb/target-descriptions.c | 8 +- gdb/xtensa-tdep.c | 5 +- 21 files changed, 704 insertions(+), 536 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index f95d74b7f8a..8bead7a0856 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,98 @@ +2009-07-02 Ulrich Weigand + + * gdbtypes.h (TYPE_OBJFILE_OWNED, TYPE_OWNER): New macros. + (TYPE_OBJFILE, TYPE_ALLOC, TYPE_ZALLOC): Reimplement. + (alloc_type_arch): Add prototype. + (alloc_type_copy): Likewise. + (get_type_arch): Likewise. + (arch_type): Likewise. + (arch_integer_type): Likewise. + (arch_character_type): Likewise. + (arch_boolean_type): Likewise. + (init_float_type): Remove, replace by ... + (arch_float_type): ... this. + (init_complex_type): Remove, replace by ... + (arch_complex_type): ... this. + (init_flags_type): Remove, replace by ... + (arch_flags_type): ... this. + (init_composite_type): Remove, replace by ... + (arch_composite_type): ... this. + + * gdbtypes.c (alloc_type): No longer support NULL objfile. + (init_type): Likewise. + (alloc_type_arch): New function. + (alloc_type_copy): New function. + (get_type_arch): New function. + + (smash_type): Preserve type ownership information. + (make_pointer_type, make_reference_type, make_function_type, + smash_to_memberptr_type, smash_to_method_type): No longer + preserve OBJFILE across smash_type calls. + (make_pointer_type, make_reference_type, make_function_type, + lookup_memberptr_type, lookup_methodptr_type, allocate_stub_method, + create_range_type, create_array_type, create_set_type, copy_type): + Use alloc_type_copy when allocating types. + (check_typedef): Use alloc_type_arch. + (copy_type_recursive): Likewise. Preserve type ownership data + after copying type. + (recursive_dump_type): Dump type ownership data. + (alloc_type_instance): Update type ownership check. + (copy_type, copy_type_recursive): Likewise. + + (arch_type): New function. + (arch_integer_type): Likewise. + (arch_character_type): Likewise. + (arch_boolean_type): Likewise. + (init_float_type): Remove, replace by ... + (arch_float_type): ... this. + (init_complex_type): Remove, replace by ... + (arch_complex_type): ... this. + (init_flags_type): Remove, replace by ... + (arch_flags_type): ... this. + (append_flags_type_flag): Move down. + (init_composite_type): Remove, replace by ... + (arch_composite_type): ... this. + (append_composite_type_field_aligned, + append_composite_type_field): Move down. + + * gdbarch.c (gdbtypes_post_init): Allocate all types + using per-architecture routines. + * ada-lang.c (ada_language_arch_info): Likewise. + * f-lang.c (build_fortran_types): Likewise. + * jv-lang.c (build_java_types): Likewise. + * m2-lang.c (build_m2_types): Likewise. + * scm-lang.c (build_scm_types): Likewise. + + * ada-lang.c (ada_type_of_array): Use alloc_type_copy. + (packed_array_type): Likewise. + (ada_template_to_fixed_record_type_1): Likewise. + (template_to_static_fixed_type): Likewise. + (to_record_with_fixed_variant_part): Likewise. + (to_fixed_variant_branch_type): Likewise. + (to_fixed_array_type): Likewise. + (to_fixed_range_type): Likewise. + (empty_record): Use type instead of objfile argument. + Use alloc_type_copy. + (to_fixed_variant_branch_type): Update call to empty_record. + * jv-lang.c (type_from_class): Use alloc_type_arch. + + * arm-tdep.c (arm_ext_type): Allocate per-architecture type. + * i386-tdep.c (i386_eflags_type, i386_mxcsr_type, i387_ext_type, + i386_mmx_type, i386_sse_type): Likewise. + * ia64-tdep.c (ia64_ext_type): Likewise. + * m32c-tdep.c (make_types): Likewise. + * m68k-tdep.c (m68k_ps_type, m68881_ext_type): Likewise. + * rs6000-tdep.c (rs6000_builtin_type_vec64, + rs6000_builtin_type_vec128): Likewise. + * sparc-tdep.c (sparc_psr_type, sparc_fsr_type): Likewise. + * sparc64-tdep.c (sparc64_pstate_type, sparc64_fsr_type, + sparc64_fprs_type): Likewise. + * spu-tdep.c (spu_builtin_type_vec128): Likewise. + * xtensa-tdep.c (xtensa_register_type): Likewise. + * linux-tdep.c (linux_get_siginfo_type): Likewise. + * target-descriptions.c (tdesc_gdb_type): Likewise. + * gnu-v3-abi.c (build_gdb_vtable_type): Likewise. + 2009-07-02 Ulrich Weigand * i386-tdep.h (struct gdbarch_tdep): Add i386_eflags_type and diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index d5078ce294e..4185c4f5590 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -1608,7 +1608,6 @@ ada_type_of_array (struct value *arr, int bounds) struct type *elt_type; int arity; struct value *descriptor; - struct objfile *objf = TYPE_OBJFILE (value_type (arr)); elt_type = ada_array_element_type (value_type (arr), -1); arity = ada_array_arity (value_type (arr)); @@ -1621,8 +1620,8 @@ ada_type_of_array (struct value *arr, int bounds) return NULL; while (arity > 0) { - struct type *range_type = alloc_type (objf); - struct type *array_type = alloc_type (objf); + struct type *range_type = alloc_type_copy (value_type (arr)); + struct type *array_type = alloc_type_copy (value_type (arr)); struct value *low = desc_one_bound (descriptor, arity, 0); struct value *high = desc_one_bound (descriptor, arity, 1); arity -= 1; @@ -1729,7 +1728,7 @@ packed_array_type (struct type *type, long *elt_bits) if (TYPE_CODE (type) != TYPE_CODE_ARRAY) return type; - new_type = alloc_type (TYPE_OBJFILE (type)); + new_type = alloc_type_copy (type); new_elt_type = packed_array_type (ada_check_typedef (TYPE_TARGET_TYPE (type)), elt_bits); create_array_type (new_type, new_elt_type, TYPE_INDEX_TYPE (type)); @@ -6665,9 +6664,9 @@ variant_field_index (struct type *type) /* A record type with no fields. */ static struct type * -empty_record (struct objfile *objfile) +empty_record (struct type *template) { - struct type *type = alloc_type (objfile); + struct type *type = alloc_type_copy (template); TYPE_CODE (type) = TYPE_CODE_STRUCT; TYPE_NFIELDS (type) = 0; TYPE_FIELDS (type) = NULL; @@ -6724,7 +6723,7 @@ ada_template_to_fixed_record_type_1 (struct type *type, nfields++; } - rtype = alloc_type (TYPE_OBJFILE (type)); + rtype = alloc_type_copy (type); TYPE_CODE (rtype) = TYPE_CODE_STRUCT; INIT_CPLUS_SPECIFIC (rtype); TYPE_NFIELDS (rtype) = nfields; @@ -6934,7 +6933,7 @@ template_to_static_fixed_type (struct type *type0) new_type = static_unwrap_type (field_type); if (type == type0 && new_type != field_type) { - TYPE_TARGET_TYPE (type0) = type = alloc_type (TYPE_OBJFILE (type0)); + TYPE_TARGET_TYPE (type0) = type = alloc_type_copy (type0); TYPE_CODE (type) = TYPE_CODE (type0); INIT_CPLUS_SPECIFIC (type); TYPE_NFIELDS (type) = nfields; @@ -6979,7 +6978,7 @@ to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr, else dval = dval0; - rtype = alloc_type (TYPE_OBJFILE (type)); + rtype = alloc_type_copy (type); TYPE_CODE (rtype) = TYPE_CODE_STRUCT; INIT_CPLUS_SPECIFIC (rtype); TYPE_NFIELDS (rtype) = nfields; @@ -7099,7 +7098,7 @@ to_fixed_variant_branch_type (struct type *var_type0, const gdb_byte *valaddr, value_type (dval), value_contents (dval)); if (which < 0) - return empty_record (TYPE_OBJFILE (var_type)); + return empty_record (var_type); else if (is_dynamic_field (var_type, which)) return to_fixed_record_type (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (var_type, which)), @@ -7158,7 +7157,7 @@ to_fixed_array_type (struct type *type0, struct value *dval, if (elt_type0 == elt_type && !packed_array_p) result = type0; else - result = create_array_type (alloc_type (TYPE_OBJFILE (type0)), + result = create_array_type (alloc_type_copy (type0), elt_type, TYPE_INDEX_TYPE (type0)); } else @@ -7190,7 +7189,7 @@ to_fixed_array_type (struct type *type0, struct value *dval, struct type *range_type = to_fixed_range_type (TYPE_FIELD_NAME (index_type_desc, i), dval, TYPE_INDEX_TYPE (elt_type0)); - result = create_array_type (alloc_type (TYPE_OBJFILE (elt_type0)), + result = create_array_type (alloc_type_copy (elt_type0), result, range_type); elt_type0 = TYPE_TARGET_TYPE (elt_type0); } @@ -9710,8 +9709,7 @@ to_fixed_range_type (char *name, struct value *dval, struct type *orig_type) if (L < INT_MIN || U > INT_MAX) return raw_type; else - return create_range_type (alloc_type (TYPE_OBJFILE (orig_type)), - raw_type, + return create_range_type (alloc_type_copy (orig_type), raw_type, discrete_type_low_bound (raw_type), discrete_type_high_bound (raw_type)); } @@ -9774,8 +9772,7 @@ to_fixed_range_type (char *name, struct value *dval, struct type *orig_type) } } - type = create_range_type (alloc_type (TYPE_OBJFILE (orig_type)), - base_type, L, U); + type = create_range_type (alloc_type_copy (orig_type), base_type, L, U); TYPE_NAME (type) = name; return type; } @@ -11160,48 +11157,42 @@ ada_language_arch_info (struct gdbarch *gdbarch, lai->primitive_type_vector = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_ada_primitive_types + 1, struct type *); - lai->primitive_type_vector [ada_primitive_type_int] = - init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "integer", (struct objfile *) NULL); - lai->primitive_type_vector [ada_primitive_type_long] = - init_type (TYPE_CODE_INT, - gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "long_integer", (struct objfile *) NULL); - lai->primitive_type_vector [ada_primitive_type_short] = - init_type (TYPE_CODE_INT, - gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "short_integer", (struct objfile *) NULL); - lai->string_char_type = - lai->primitive_type_vector [ada_primitive_type_char] = - init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, "character", (struct objfile *) NULL); - lai->primitive_type_vector [ada_primitive_type_float] = - init_float_type (gdbarch_float_bit (gdbarch), - "float", NULL); - lai->primitive_type_vector [ada_primitive_type_double] = - init_float_type (gdbarch_double_bit (gdbarch), - "long_float", NULL); - lai->primitive_type_vector [ada_primitive_type_long_long] = - init_type (TYPE_CODE_INT, - gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "long_long_integer", (struct objfile *) NULL); - lai->primitive_type_vector [ada_primitive_type_long_double] = - init_float_type (gdbarch_double_bit (gdbarch), - "long_long_float", NULL); - lai->primitive_type_vector [ada_primitive_type_natural] = - init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "natural", (struct objfile *) NULL); - lai->primitive_type_vector [ada_primitive_type_positive] = - init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "positive", (struct objfile *) NULL); - lai->primitive_type_vector [ada_primitive_type_void] = builtin->builtin_void; - - lai->primitive_type_vector [ada_primitive_type_system_address] = - lookup_pointer_type (init_type (TYPE_CODE_VOID, 1, 0, "void", - (struct objfile *) NULL)); + + lai->primitive_type_vector [ada_primitive_type_int] + = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), + 0, "integer"); + lai->primitive_type_vector [ada_primitive_type_long] + = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), + 0, "long_integer"); + lai->primitive_type_vector [ada_primitive_type_short] + = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch), + 0, "short_integer"); + lai->string_char_type + = lai->primitive_type_vector [ada_primitive_type_char] + = arch_integer_type (gdbarch, TARGET_CHAR_BIT, 0, "character"); + lai->primitive_type_vector [ada_primitive_type_float] + = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), + "float", NULL); + lai->primitive_type_vector [ada_primitive_type_double] + = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch), + "long_float", NULL); + lai->primitive_type_vector [ada_primitive_type_long_long] + = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch), + 0, "long_long_integer"); + lai->primitive_type_vector [ada_primitive_type_long_double] + = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch), + "long_long_float", NULL); + lai->primitive_type_vector [ada_primitive_type_natural] + = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), + 0, "natural"); + lai->primitive_type_vector [ada_primitive_type_positive] + = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), + 0, "positive"); + lai->primitive_type_vector [ada_primitive_type_void] + = builtin->builtin_void; + + lai->primitive_type_vector [ada_primitive_type_system_address] + = lookup_pointer_type (arch_type (gdbarch, TYPE_CODE_VOID, 1, "void")); TYPE_NAME (lai->primitive_type_vector [ada_primitive_type_system_address]) = "system__address"; diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c index e0a92a5b085..20f0aabea12 100644 --- a/gdb/arm-tdep.c +++ b/gdb/arm-tdep.c @@ -1601,7 +1601,7 @@ arm_ext_type (struct gdbarch *gdbarch) if (!tdep->arm_ext_type) tdep->arm_ext_type - = init_float_type (-1, "builtin_type_arm_ext", + = arch_float_type (gdbarch, -1, "builtin_type_arm_ext", floatformats_arm_ext); return tdep->arm_ext_type; diff --git a/gdb/f-lang.c b/gdb/f-lang.c index 7adb48b8a86..19c13168d0a 100644 --- a/gdb/f-lang.c +++ b/gdb/f-lang.c @@ -355,60 +355,50 @@ build_fortran_types (struct gdbarch *gdbarch) struct builtin_f_type *builtin_f_type = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_f_type); - builtin_f_type->builtin_void = - init_type (TYPE_CODE_VOID, 1, - 0, - "VOID", (struct objfile *) NULL); - - builtin_f_type->builtin_character = - init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, - "character", (struct objfile *) NULL); - - builtin_f_type->builtin_logical_s1 = - init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "logical*1", (struct objfile *) NULL); - - builtin_f_type->builtin_integer_s2 = - init_type (TYPE_CODE_INT, - gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "integer*2", (struct objfile *) NULL); - - builtin_f_type->builtin_logical_s2 = - init_type (TYPE_CODE_BOOL, - gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "logical*2", (struct objfile *) NULL); - - builtin_f_type->builtin_integer = - init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "integer", (struct objfile *) NULL); - - builtin_f_type->builtin_logical = - init_type (TYPE_CODE_BOOL, - gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "logical*4", (struct objfile *) NULL); - - builtin_f_type->builtin_real = - init_float_type (gdbarch_float_bit (gdbarch), - "real", NULL); - builtin_f_type->builtin_real_s8 = - init_float_type (gdbarch_double_bit (gdbarch), - "real*8", NULL); - builtin_f_type->builtin_real_s16 = - init_float_type (gdbarch_long_double_bit (gdbarch), - "real*16", NULL); - - builtin_f_type->builtin_complex_s8 = - init_complex_type ("complex*8", - builtin_f_type->builtin_real); - builtin_f_type->builtin_complex_s16 = - init_complex_type ("complex*16", - builtin_f_type->builtin_real_s8); - builtin_f_type->builtin_complex_s32 = - init_complex_type ("complex*32", - builtin_f_type->builtin_real_s16); + builtin_f_type->builtin_void + = arch_type (gdbarch, TYPE_CODE_VOID, 1, "VOID"); + + builtin_f_type->builtin_character + = arch_integer_type (gdbarch, TARGET_CHAR_BIT, 0, "character"); + + builtin_f_type->builtin_logical_s1 + = arch_boolean_type (gdbarch, TARGET_CHAR_BIT, 1, "logical*1"); + + builtin_f_type->builtin_integer_s2 + = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch), 0, + "integer*2"); + + builtin_f_type->builtin_logical_s2 + = arch_boolean_type (gdbarch, gdbarch_short_bit (gdbarch), 1, + "logical*2"); + + builtin_f_type->builtin_integer + = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 0, + "integer"); + + builtin_f_type->builtin_logical + = arch_boolean_type (gdbarch, gdbarch_int_bit (gdbarch), 1, + "logical*4"); + + builtin_f_type->builtin_real + = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), + "real", NULL); + builtin_f_type->builtin_real_s8 + = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch), + "real*8", NULL); + builtin_f_type->builtin_real_s16 + = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch), + "real*16", NULL); + + builtin_f_type->builtin_complex_s8 + = arch_complex_type (gdbarch, "complex*8", + builtin_f_type->builtin_real); + builtin_f_type->builtin_complex_s16 + = arch_complex_type (gdbarch, "complex*16", + builtin_f_type->builtin_real_s8); + builtin_f_type->builtin_complex_s32 + = arch_complex_type (gdbarch, "complex*32", + builtin_f_type->builtin_real_s16); return builtin_f_type; } diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index 307ec0248a5..da2db2ed137 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -119,41 +119,89 @@ static void dump_fn_fieldlists (struct type *, int); static void print_cplus_stuff (struct type *, int); -/* Alloc a new type structure and fill it with some defaults. If - OBJFILE is non-NULL, then allocate the space for the type structure - in that objfile's objfile_obstack. Otherwise allocate the new type - structure by xmalloc () (for permanent types). */ +/* Allocate a new OBJFILE-associated type structure and fill it + with some defaults. Space for the type structure is allocated + on the objfile's objfile_obstack. */ struct type * alloc_type (struct objfile *objfile) { struct type *type; + gdb_assert (objfile != NULL); + /* Alloc the structure and start off with all fields zeroed. */ + type = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct type); + TYPE_MAIN_TYPE (type) = OBSTACK_ZALLOC (&objfile->objfile_obstack, + struct main_type); + OBJSTAT (objfile, n_types++); - if (objfile == NULL) - { - type = XZALLOC (struct type); - TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type); - } - else - { - type = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct type); - TYPE_MAIN_TYPE (type) = OBSTACK_ZALLOC (&objfile->objfile_obstack, - struct main_type); - OBJSTAT (objfile, n_types++); - } + TYPE_OBJFILE_OWNED (type) = 1; + TYPE_OWNER (type).objfile = objfile; /* Initialize the fields that might not be zero. */ TYPE_CODE (type) = TYPE_CODE_UNDEF; - TYPE_OBJFILE (type) = objfile; TYPE_VPTR_FIELDNO (type) = -1; TYPE_CHAIN (type) = type; /* Chain back to itself. */ return type; } +/* Allocate a new GDBARCH-associated type structure and fill it + with some defaults. Space for the type structure is allocated + on the heap. */ + +struct type * +alloc_type_arch (struct gdbarch *gdbarch) +{ + struct type *type; + + gdb_assert (gdbarch != NULL); + + /* Alloc the structure and start off with all fields zeroed. */ + + type = XZALLOC (struct type); + TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type); + + TYPE_OBJFILE_OWNED (type) = 0; + TYPE_OWNER (type).gdbarch = gdbarch; + + /* Initialize the fields that might not be zero. */ + + TYPE_CODE (type) = TYPE_CODE_UNDEF; + TYPE_VPTR_FIELDNO (type) = -1; + TYPE_CHAIN (type) = type; /* Chain back to itself. */ + + return type; +} + +/* If TYPE is objfile-associated, allocate a new type structure + associated with the same objfile. If TYPE is gdbarch-associated, + allocate a new type structure associated with the same gdbarch. */ + +struct type * +alloc_type_copy (const struct type *type) +{ + if (TYPE_OBJFILE_OWNED (type)) + return alloc_type (TYPE_OWNER (type).objfile); + else + return alloc_type_arch (TYPE_OWNER (type).gdbarch); +} + +/* If TYPE is gdbarch-associated, return that architecture. + If TYPE is objfile-associated, return that objfile's architecture. */ + +struct gdbarch * +get_type_arch (const struct type *type) +{ + if (TYPE_OBJFILE_OWNED (type)) + return get_objfile_arch (TYPE_OWNER (type).objfile); + else + return TYPE_OWNER (type).gdbarch; +} + + /* Alloc a new type instance structure, fill it with some defaults, and point it at OLDTYPE. Allocate the new type instance from the same place as OLDTYPE. */ @@ -165,7 +213,7 @@ alloc_type_instance (struct type *oldtype) /* Allocate the structure. */ - if (TYPE_OBJFILE (oldtype) == NULL) + if (! TYPE_OBJFILE_OWNED (oldtype)) type = XZALLOC (struct type); else type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack, @@ -179,12 +227,19 @@ alloc_type_instance (struct type *oldtype) } /* Clear all remnants of the previous type at TYPE, in preparation for - replacing it with something else. */ + replacing it with something else. Preserve owner information. */ static void smash_type (struct type *type) { + int objfile_owned = TYPE_OBJFILE_OWNED (type); + union type_owner owner = TYPE_OWNER (type); + memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type)); + /* Restore owner information. */ + TYPE_OBJFILE_OWNED (type) = objfile_owned; + TYPE_OWNER (type) = owner; + /* For now, delete the rings. */ TYPE_CHAIN (type) = type; @@ -200,7 +255,6 @@ struct type * make_pointer_type (struct type *type, struct type **typeptr) { struct type *ntype; /* New type */ - struct objfile *objfile; struct type *chain; ntype = TYPE_POINTER_TYPE (type); @@ -219,18 +273,16 @@ make_pointer_type (struct type *type, struct type **typeptr) if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */ { - ntype = alloc_type (TYPE_OBJFILE (type)); + ntype = alloc_type_copy (type); if (typeptr) *typeptr = ntype; } else /* We have storage, but need to reset it. */ { ntype = *typeptr; - objfile = TYPE_OBJFILE (ntype); chain = TYPE_CHAIN (ntype); smash_type (ntype); TYPE_CHAIN (ntype) = chain; - TYPE_OBJFILE (ntype) = objfile; } TYPE_TARGET_TYPE (ntype) = type; @@ -280,7 +332,6 @@ struct type * make_reference_type (struct type *type, struct type **typeptr) { struct type *ntype; /* New type */ - struct objfile *objfile; struct type *chain; ntype = TYPE_REFERENCE_TYPE (type); @@ -299,18 +350,16 @@ make_reference_type (struct type *type, struct type **typeptr) if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */ { - ntype = alloc_type (TYPE_OBJFILE (type)); + ntype = alloc_type_copy (type); if (typeptr) *typeptr = ntype; } else /* We have storage, but need to reset it. */ { ntype = *typeptr; - objfile = TYPE_OBJFILE (ntype); chain = TYPE_CHAIN (ntype); smash_type (ntype); TYPE_CHAIN (ntype) = chain; - TYPE_OBJFILE (ntype) = objfile; } TYPE_TARGET_TYPE (ntype) = type; @@ -355,20 +404,17 @@ struct type * make_function_type (struct type *type, struct type **typeptr) { struct type *ntype; /* New type */ - struct objfile *objfile; if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */ { - ntype = alloc_type (TYPE_OBJFILE (type)); + ntype = alloc_type_copy (type); if (typeptr) *typeptr = ntype; } else /* We have storage, but need to reset it. */ { ntype = *typeptr; - objfile = TYPE_OBJFILE (ntype); smash_type (ntype); - TYPE_OBJFILE (ntype) = objfile; } TYPE_TARGET_TYPE (ntype) = type; @@ -614,7 +660,7 @@ lookup_memberptr_type (struct type *type, struct type *domain) { struct type *mtype; - mtype = alloc_type (TYPE_OBJFILE (type)); + mtype = alloc_type_copy (type); smash_to_memberptr_type (mtype, domain, type); return mtype; } @@ -626,7 +672,7 @@ lookup_methodptr_type (struct type *to_type) { struct type *mtype; - mtype = alloc_type (TYPE_OBJFILE (to_type)); + mtype = alloc_type_copy (to_type); TYPE_TARGET_TYPE (mtype) = to_type; TYPE_DOMAIN_TYPE (mtype) = TYPE_DOMAIN_TYPE (to_type); TYPE_LENGTH (mtype) = cplus_method_ptr_size (to_type); @@ -645,8 +691,10 @@ allocate_stub_method (struct type *type) { struct type *mtype; - mtype = init_type (TYPE_CODE_METHOD, 1, TYPE_FLAG_STUB, NULL, - TYPE_OBJFILE (type)); + mtype = alloc_type_copy (type); + TYPE_CODE (mtype) = TYPE_CODE_METHOD; + TYPE_LENGTH (mtype) = 1; + TYPE_STUB (mtype) = 1; TYPE_TARGET_TYPE (mtype) = type; /* _DOMAIN_TYPE (mtype) = unknown yet */ return mtype; @@ -667,7 +715,7 @@ create_range_type (struct type *result_type, struct type *index_type, int low_bound, int high_bound) { if (result_type == NULL) - result_type = alloc_type (TYPE_OBJFILE (index_type)); + result_type = alloc_type_copy (index_type); TYPE_CODE (result_type) = TYPE_CODE_RANGE; TYPE_TARGET_TYPE (result_type) = index_type; if (TYPE_STUB (index_type)) @@ -775,9 +823,8 @@ create_array_type (struct type *result_type, LONGEST low_bound, high_bound; if (result_type == NULL) - { - result_type = alloc_type (TYPE_OBJFILE (range_type)); - } + result_type = alloc_type_copy (range_type); + TYPE_CODE (result_type) = TYPE_CODE_ARRAY; TYPE_TARGET_TYPE (result_type) = element_type; if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0) @@ -854,9 +901,8 @@ struct type * create_set_type (struct type *result_type, struct type *domain_type) { if (result_type == NULL) - { - result_type = alloc_type (TYPE_OBJFILE (domain_type)); - } + result_type = alloc_type_copy (domain_type); + TYPE_CODE (result_type) = TYPE_CODE_SET; TYPE_NFIELDS (result_type) = 1; TYPE_FIELDS (result_type) = TYPE_ZALLOC (result_type, sizeof (struct field)); @@ -877,39 +923,6 @@ create_set_type (struct type *result_type, struct type *domain_type) return result_type; } -void -append_flags_type_flag (struct type *type, int bitpos, char *name) -{ - gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS); - gdb_assert (bitpos < TYPE_NFIELDS (type)); - gdb_assert (bitpos >= 0); - - if (name) - { - TYPE_FIELD_NAME (type, bitpos) = xstrdup (name); - TYPE_FIELD_BITPOS (type, bitpos) = bitpos; - } - else - { - /* Don't show this field to the user. */ - TYPE_FIELD_BITPOS (type, bitpos) = -1; - } -} - -struct type * -init_flags_type (char *name, int length) -{ - int nfields = length * TARGET_CHAR_BIT; - struct type *type; - - type = init_type (TYPE_CODE_FLAGS, length, - TYPE_FLAG_UNSIGNED, name, NULL); - TYPE_NFIELDS (type) = nfields; - TYPE_FIELDS (type) = TYPE_ZALLOC (type, nfields * sizeof (struct field)); - - return type; -} - /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE and any array types nested inside it. */ @@ -960,12 +973,7 @@ void smash_to_memberptr_type (struct type *type, struct type *domain, struct type *to_type) { - struct objfile *objfile; - - objfile = TYPE_OBJFILE (type); - smash_type (type); - TYPE_OBJFILE (type) = objfile; TYPE_TARGET_TYPE (type) = to_type; TYPE_DOMAIN_TYPE (type) = domain; /* Assume that a data member pointer is the same size as a normal @@ -986,12 +994,7 @@ smash_to_method_type (struct type *type, struct type *domain, struct type *to_type, struct field *args, int nargs, int varargs) { - struct objfile *objfile; - - objfile = TYPE_OBJFILE (type); - smash_type (type); - TYPE_OBJFILE (type) = objfile; TYPE_TARGET_TYPE (type) = to_type; TYPE_DOMAIN_TYPE (type) = domain; TYPE_FIELDS (type) = args; @@ -1380,7 +1383,7 @@ check_typedef (struct type *type) if (sym) TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym); else /* TYPE_CODE_UNDEF */ - TYPE_TARGET_TYPE (type) = alloc_type (NULL); + TYPE_TARGET_TYPE (type) = alloc_type_arch (get_type_arch (type)); } type = TYPE_TARGET_TYPE (type); } @@ -1702,11 +1705,10 @@ 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 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 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). */ struct type * init_type (enum type_code code, int length, int flags, @@ -1744,15 +1746,9 @@ init_type (enum type_code code, int length, int flags, if (flags & TYPE_FLAG_FIXED_INSTANCE) TYPE_FIXED_INSTANCE (type) = 1; - if ((name != NULL) && (objfile != NULL)) - { - TYPE_NAME (type) = obsavestring (name, strlen (name), - &objfile->objfile_obstack); - } - else - { - TYPE_NAME (type) = name; - } + if (name) + TYPE_NAME (type) = obsavestring (name, strlen (name), + &objfile->objfile_obstack); /* C++ fancies. */ @@ -1767,67 +1763,6 @@ init_type (enum type_code code, int length, int flags, return type; } -/* Helper function. Create an empty composite type. */ - -struct type * -init_composite_type (char *name, enum type_code code) -{ - struct type *t; - gdb_assert (code == TYPE_CODE_STRUCT - || code == TYPE_CODE_UNION); - t = init_type (code, 0, 0, NULL, NULL); - TYPE_TAG_NAME (t) = name; - return t; -} - -/* Helper function. Append a field to a composite type. */ - -void -append_composite_type_field_aligned (struct type *t, char *name, - struct type *field, int alignment) -{ - struct field *f; - TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1; - TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t), - sizeof (struct field) * TYPE_NFIELDS (t)); - f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]); - memset (f, 0, sizeof f[0]); - FIELD_TYPE (f[0]) = field; - FIELD_NAME (f[0]) = name; - if (TYPE_CODE (t) == TYPE_CODE_UNION) - { - if (TYPE_LENGTH (t) < TYPE_LENGTH (field)) - TYPE_LENGTH (t) = TYPE_LENGTH (field); - } - else if (TYPE_CODE (t) == TYPE_CODE_STRUCT) - { - TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field); - if (TYPE_NFIELDS (t) > 1) - { - FIELD_BITPOS (f[0]) = (FIELD_BITPOS (f[-1]) - + (TYPE_LENGTH (FIELD_TYPE (f[-1])) - * TARGET_CHAR_BIT)); - - if (alignment) - { - int left = FIELD_BITPOS (f[0]) % (alignment * TARGET_CHAR_BIT); - if (left) - { - FIELD_BITPOS (f[0]) += left; - TYPE_LENGTH (t) += left / TARGET_CHAR_BIT; - } - } - } - } -} - -void -append_composite_type_field (struct type *t, char *name, - struct type *field) -{ - append_composite_type_field_aligned (t, name, field, 0); -} - int can_dereference (struct type *t) { @@ -2671,8 +2606,16 @@ recursive_dump_type (struct type *type, int spaces) } puts_filtered ("\n"); printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type)); - printfi_filtered (spaces, "objfile "); - gdb_print_host_address (TYPE_OBJFILE (type), gdb_stdout); + if (TYPE_OBJFILE_OWNED (type)) + { + printfi_filtered (spaces, "objfile "); + gdb_print_host_address (TYPE_OWNER (type).objfile, gdb_stdout); + } + else + { + printfi_filtered (spaces, "gdbarch "); + gdb_print_host_address (TYPE_OWNER (type).gdbarch, gdb_stdout); + } printf_filtered ("\n"); printfi_filtered (spaces, "target_type "); gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout); @@ -2903,7 +2846,7 @@ copy_type_recursive (struct objfile *objfile, void **slot; struct type *new_type; - if (TYPE_OBJFILE (type) == NULL) + if (! TYPE_OBJFILE_OWNED (type)) return type; /* This type shouldn't be pointing to any types in other objfiles; @@ -2915,7 +2858,7 @@ copy_type_recursive (struct objfile *objfile, if (*slot != NULL) return ((struct type_pair *) *slot)->new; - new_type = alloc_type (NULL); + new_type = alloc_type_arch (get_type_arch (type)); /* We must add the new type to the hash table immediately, in case we encounter this type again during a recursive call below. */ @@ -2927,7 +2870,8 @@ copy_type_recursive (struct objfile *objfile, /* Copy the common fields of types. For the main type, we simply copy the entire thing and then update specific fields as needed. */ *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type); - TYPE_OBJFILE (new_type) = NULL; + TYPE_OBJFILE_OWNED (new_type) = 0; + TYPE_OWNER (new_type).gdbarch = get_type_arch (type); if (TYPE_NAME (type)) TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type)); @@ -3018,9 +2962,9 @@ copy_type (const struct type *type) { struct type *new_type; - gdb_assert (TYPE_OBJFILE (type) != NULL); + gdb_assert (TYPE_OBJFILE_OWNED (type)); - new_type = alloc_type (TYPE_OBJFILE (type)); + new_type = alloc_type_copy (type); TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type); TYPE_LENGTH (new_type) = TYPE_LENGTH (type); memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type), @@ -3029,8 +2973,84 @@ 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) +{ + struct type *type; + + type = alloc_type_arch (gdbarch); + TYPE_CODE (type) = code; + TYPE_LENGTH (type) = length; + + if (name) + TYPE_NAME (type) = xstrdup (name); + + return type; +} + +/* Allocate a TYPE_CODE_INT type structure associated with GDBARCH. + BIT is the type size in bits. If UNSIGNED_P is non-zero, set + the type's TYPE_UNSIGNED flag. NAME is the type name. */ +struct type * +arch_integer_type (struct gdbarch *gdbarch, + int bit, int unsigned_p, char *name) +{ + struct type *t; + + t = arch_type (gdbarch, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name); + if (unsigned_p) + TYPE_UNSIGNED (t) = 1; + if (name && strcmp (name, "char") == 0) + TYPE_NOSIGN (t) = 1; + + return t; +} + +/* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH. + BIT is the type size in bits. If UNSIGNED_P is non-zero, set + the type's TYPE_UNSIGNED flag. NAME is the type name. */ +struct type * +arch_character_type (struct gdbarch *gdbarch, + int bit, int unsigned_p, char *name) +{ + struct type *t; + + t = arch_type (gdbarch, TYPE_CODE_CHAR, bit / TARGET_CHAR_BIT, name); + if (unsigned_p) + TYPE_UNSIGNED (t) = 1; + + return t; +} + +/* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH. + BIT is the type size in bits. If UNSIGNED_P is non-zero, set + the type's TYPE_UNSIGNED flag. NAME is the type name. */ +struct type * +arch_boolean_type (struct gdbarch *gdbarch, + int bit, int unsigned_p, char *name) +{ + struct type *t; + + t = arch_type (gdbarch, TYPE_CODE_BOOL, bit / TARGET_CHAR_BIT, name); + if (unsigned_p) + TYPE_UNSIGNED (t) = 1; + + return t; +} + +/* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH. + BIT is the type size in bits; if BIT equals -1, the size is + determined by the floatformat. NAME is the type name. Set the + TYPE_FLOATFORMAT from FLOATFORMATS. */ struct type * -init_float_type (int bit, char *name, const struct floatformat **floatformats) +arch_float_type (struct gdbarch *gdbarch, + int bit, char *name, const struct floatformat **floatformats) { struct type *t; @@ -3042,21 +3062,124 @@ init_float_type (int bit, char *name, const struct floatformat **floatformats) } gdb_assert (bit >= 0); - t = init_type (TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, 0, name, NULL); + t = arch_type (gdbarch, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name); TYPE_FLOATFORMAT (t) = floatformats; return t; } +/* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH. + NAME is the type name. TARGET_TYPE is the component float type. */ struct type * -init_complex_type (char *name, struct type *target_type) +arch_complex_type (struct gdbarch *gdbarch, + char *name, struct type *target_type) { struct type *t; - t = init_type (TYPE_CODE_COMPLEX, 2 * TYPE_LENGTH (target_type), - 0, name, (struct objfile *) NULL); + t = arch_type (gdbarch, TYPE_CODE_COMPLEX, + 2 * TYPE_LENGTH (target_type), name); TYPE_TARGET_TYPE (t) = target_type; return t; } +/* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH. + NAME is the type name. LENGTH is the number of flag bits. */ +struct type * +arch_flags_type (struct gdbarch *gdbarch, char *name, int length) +{ + int nfields = length * TARGET_CHAR_BIT; + struct type *type; + + type = arch_type (gdbarch, TYPE_CODE_FLAGS, length, name); + TYPE_UNSIGNED (type) = 1; + TYPE_NFIELDS (type) = nfields; + TYPE_FIELDS (type) = TYPE_ZALLOC (type, nfields * sizeof (struct field)); + + return type; +} + +/* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at + position BITPOS is called NAME. */ +void +append_flags_type_flag (struct type *type, int bitpos, char *name) +{ + gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS); + gdb_assert (bitpos < TYPE_NFIELDS (type)); + gdb_assert (bitpos >= 0); + + if (name) + { + TYPE_FIELD_NAME (type, bitpos) = xstrdup (name); + TYPE_FIELD_BITPOS (type, bitpos) = bitpos; + } + else + { + /* Don't show this field to the user. */ + TYPE_FIELD_BITPOS (type, bitpos) = -1; + } +} + +/* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as + specified by CODE) associated with GDBARCH. NAME is the type name. */ +struct type * +arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code) +{ + struct type *t; + gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION); + t = arch_type (gdbarch, code, 0, NULL); + TYPE_TAG_NAME (t) = name; + INIT_CPLUS_SPECIFIC (t); + return t; +} + +/* Add new field with name NAME and type FIELD to composite type T. + ALIGNMENT (if non-zero) specifies the minimum field alignment. */ +void +append_composite_type_field_aligned (struct type *t, char *name, + struct type *field, int alignment) +{ + struct field *f; + TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1; + TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t), + sizeof (struct field) * TYPE_NFIELDS (t)); + f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]); + memset (f, 0, sizeof f[0]); + FIELD_TYPE (f[0]) = field; + FIELD_NAME (f[0]) = name; + if (TYPE_CODE (t) == TYPE_CODE_UNION) + { + if (TYPE_LENGTH (t) < TYPE_LENGTH (field)) + TYPE_LENGTH (t) = TYPE_LENGTH (field); + } + else if (TYPE_CODE (t) == TYPE_CODE_STRUCT) + { + TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field); + if (TYPE_NFIELDS (t) > 1) + { + FIELD_BITPOS (f[0]) = (FIELD_BITPOS (f[-1]) + + (TYPE_LENGTH (FIELD_TYPE (f[-1])) + * TARGET_CHAR_BIT)); + + if (alignment) + { + int left = FIELD_BITPOS (f[0]) % (alignment * TARGET_CHAR_BIT); + if (left) + { + FIELD_BITPOS (f[0]) += left; + TYPE_LENGTH (t) += left / TARGET_CHAR_BIT; + } + } + } + } +} + +/* Add new field with name NAME and type FIELD to composite type T. */ +void +append_composite_type_field (struct type *t, char *name, + struct type *field) +{ + append_composite_type_field_aligned (t, name, field, 0); +} + + static struct gdbarch_data *gdbtypes_data; const struct builtin_type * @@ -3072,162 +3195,112 @@ gdbtypes_post_init (struct gdbarch *gdbarch) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type); /* Basic types. */ - builtin_type->builtin_void = - init_type (TYPE_CODE_VOID, 1, - 0, - "void", (struct objfile *) NULL); - builtin_type->builtin_char = - init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - (TYPE_FLAG_NOSIGN - | (gdbarch_char_signed (gdbarch) ? 0 : TYPE_FLAG_UNSIGNED)), - "char", (struct objfile *) NULL); - builtin_type->builtin_signed_char = - init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, - "signed char", (struct objfile *) NULL); - builtin_type->builtin_unsigned_char = - init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "unsigned char", (struct objfile *) NULL); - builtin_type->builtin_short = - init_type (TYPE_CODE_INT, - gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "short", (struct objfile *) NULL); - builtin_type->builtin_unsigned_short = - init_type (TYPE_CODE_INT, - gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "unsigned short", - (struct objfile *) NULL); - builtin_type->builtin_int = - init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "int", (struct objfile *) NULL); - builtin_type->builtin_unsigned_int = - init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "unsigned int", - (struct objfile *) NULL); - builtin_type->builtin_long = - init_type (TYPE_CODE_INT, - gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "long", (struct objfile *) NULL); - builtin_type->builtin_unsigned_long = - init_type (TYPE_CODE_INT, - gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "unsigned long", - (struct objfile *) NULL); - builtin_type->builtin_long_long = - init_type (TYPE_CODE_INT, - gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "long long", (struct objfile *) NULL); - builtin_type->builtin_unsigned_long_long = - init_type (TYPE_CODE_INT, - gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "unsigned long long", - (struct objfile *) NULL); + builtin_type->builtin_void + = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void"); + builtin_type->builtin_char + = arch_integer_type (gdbarch, TARGET_CHAR_BIT, + !gdbarch_char_signed (gdbarch), "char"); + builtin_type->builtin_signed_char + = arch_integer_type (gdbarch, TARGET_CHAR_BIT, + 0, "signed char"); + builtin_type->builtin_unsigned_char + = arch_integer_type (gdbarch, TARGET_CHAR_BIT, + 1, "unsigned char"); + builtin_type->builtin_short + = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch), + 0, "short"); + builtin_type->builtin_unsigned_short + = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch), + 1, "unsigned short"); + builtin_type->builtin_int + = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), + 0, "int"); + builtin_type->builtin_unsigned_int + = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), + 1, "unsigned int"); + builtin_type->builtin_long + = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), + 0, "long"); + builtin_type->builtin_unsigned_long + = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), + 1, "unsigned long"); + builtin_type->builtin_long_long + = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch), + 0, "long long"); + builtin_type->builtin_unsigned_long_long + = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch), + 1, "unsigned long long"); builtin_type->builtin_float - = init_float_type (gdbarch_float_bit (gdbarch), + = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), "float", gdbarch_float_format (gdbarch)); builtin_type->builtin_double - = init_float_type (gdbarch_double_bit (gdbarch), + = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch), "double", gdbarch_double_format (gdbarch)); builtin_type->builtin_long_double - = init_float_type (gdbarch_long_double_bit (gdbarch), + = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch), "long double", gdbarch_long_double_format (gdbarch)); builtin_type->builtin_complex - = init_complex_type ("complex", builtin_type->builtin_float); + = arch_complex_type (gdbarch, "complex", + builtin_type->builtin_float); builtin_type->builtin_double_complex - = init_complex_type ("double complex", builtin_type->builtin_double); - builtin_type->builtin_string = - init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, - "string", (struct objfile *) NULL); - builtin_type->builtin_bool = - init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, - "bool", (struct objfile *) NULL); + = arch_complex_type (gdbarch, "double complex", + builtin_type->builtin_double); + builtin_type->builtin_string + = arch_type (gdbarch, TYPE_CODE_STRING, 1, "string"); + builtin_type->builtin_bool + = arch_type (gdbarch, TYPE_CODE_BOOL, 1, "bool"); /* The following three are about decimal floating point types, which are 32-bits, 64-bits and 128-bits respectively. */ builtin_type->builtin_decfloat - = init_type (TYPE_CODE_DECFLOAT, 32 / 8, - 0, - "_Decimal32", (struct objfile *) NULL); + = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 32 / 8, "_Decimal32"); builtin_type->builtin_decdouble - = init_type (TYPE_CODE_DECFLOAT, 64 / 8, - 0, - "_Decimal64", (struct objfile *) NULL); + = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 64 / 8, "_Decimal64"); builtin_type->builtin_declong - = init_type (TYPE_CODE_DECFLOAT, 128 / 8, - 0, - "_Decimal128", (struct objfile *) NULL); + = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 128 / 8, "_Decimal128"); /* "True" character types. */ - builtin_type->builtin_true_char = - init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, - "true character", (struct objfile *) NULL); - builtin_type->builtin_true_unsigned_char = - init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "true character", (struct objfile *) NULL); + builtin_type->builtin_true_char + = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "true character"); + builtin_type->builtin_true_unsigned_char + = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "true character"); /* Fixed-size integer types. */ - builtin_type->builtin_int0 = - init_type (TYPE_CODE_INT, 0 / 8, - 0, - "int0_t", (struct objfile *) NULL); - builtin_type->builtin_int8 = - init_type (TYPE_CODE_INT, 8 / 8, - TYPE_FLAG_NOTTEXT, - "int8_t", (struct objfile *) NULL); - builtin_type->builtin_uint8 = - init_type (TYPE_CODE_INT, 8 / 8, - TYPE_FLAG_UNSIGNED | TYPE_FLAG_NOTTEXT, - "uint8_t", (struct objfile *) NULL); - builtin_type->builtin_int16 = - init_type (TYPE_CODE_INT, 16 / 8, - 0, - "int16_t", (struct objfile *) NULL); - builtin_type->builtin_uint16 = - init_type (TYPE_CODE_INT, 16 / 8, - TYPE_FLAG_UNSIGNED, - "uint16_t", (struct objfile *) NULL); - builtin_type->builtin_int32 = - init_type (TYPE_CODE_INT, 32 / 8, - 0, - "int32_t", (struct objfile *) NULL); - builtin_type->builtin_uint32 = - init_type (TYPE_CODE_INT, 32 / 8, - TYPE_FLAG_UNSIGNED, - "uint32_t", (struct objfile *) NULL); - builtin_type->builtin_int64 = - init_type (TYPE_CODE_INT, 64 / 8, - 0, - "int64_t", (struct objfile *) NULL); - builtin_type->builtin_uint64 = - init_type (TYPE_CODE_INT, 64 / 8, - TYPE_FLAG_UNSIGNED, - "uint64_t", (struct objfile *) NULL); - builtin_type->builtin_int128 = - init_type (TYPE_CODE_INT, 128 / 8, - 0, - "int128_t", (struct objfile *) NULL); - builtin_type->builtin_uint128 = - init_type (TYPE_CODE_INT, 128 / 8, - TYPE_FLAG_UNSIGNED, - "uint128_t", (struct objfile *) NULL); + builtin_type->builtin_int0 + = arch_integer_type (gdbarch, 0, 0, "int0_t"); + builtin_type->builtin_int8 + = arch_integer_type (gdbarch, 8, 0, "int8_t"); + builtin_type->builtin_uint8 + = arch_integer_type (gdbarch, 8, 1, "uint8_t"); + builtin_type->builtin_int16 + = arch_integer_type (gdbarch, 16, 0, "int16_t"); + builtin_type->builtin_uint16 + = arch_integer_type (gdbarch, 16, 1, "uint16_t"); + builtin_type->builtin_int32 + = arch_integer_type (gdbarch, 32, 0, "int32_t"); + builtin_type->builtin_uint32 + = arch_integer_type (gdbarch, 32, 1, "uint32_t"); + builtin_type->builtin_int64 + = arch_integer_type (gdbarch, 64, 0, "int64_t"); + builtin_type->builtin_uint64 + = arch_integer_type (gdbarch, 64, 1, "uint64_t"); + builtin_type->builtin_int128 + = arch_integer_type (gdbarch, 128, 0, "int128_t"); + builtin_type->builtin_uint128 + = arch_integer_type (gdbarch, 128, 1, "uint128_t"); + TYPE_NOTTEXT (builtin_type->builtin_int8) = 1; + TYPE_NOTTEXT (builtin_type->builtin_uint8) = 1; /* Default data/code pointer types. */ - 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_data_ptr + = lookup_pointer_type (builtin_type->builtin_void); + builtin_type->builtin_func_ptr + = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void)); /* This type represents a GDB internal function. */ - builtin_type->internal_fn = - init_type (TYPE_CODE_INTERNAL_FUNCTION, 0, 0, - "", NULL); + builtin_type->internal_fn + = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0, + ""); return builtin_type; } diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index e7b6272efa5..9d83bb32f5d 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -270,6 +270,14 @@ enum type_instance_flag_value #define TYPE_NOTTEXT(t) (TYPE_MAIN_TYPE (t)->flag_nottext) +/* Type owner. If TYPE_OBJFILE_OWNED is true, the type is owned by + the objfile retrieved as TYPE_OBJFILE. Otherweise, the type is + owned by an architecture; TYPE_OBJFILE is NULL in this case. */ + +#define TYPE_OBJFILE_OWNED(t) (TYPE_MAIN_TYPE (t)->flag_objfile_owned) +#define TYPE_OWNER(t) TYPE_MAIN_TYPE(t)->owner +#define TYPE_OBJFILE(t) (TYPE_OBJFILE_OWNED(t)? TYPE_OWNER(t).objfile : NULL) + /* Constant type. If this is set, the corresponding type has a * const modifier. */ @@ -356,6 +364,7 @@ struct main_type unsigned int flag_stub_supported : 1; unsigned int flag_nottext : 1; unsigned int flag_fixed_instance : 1; + unsigned int flag_objfile_owned : 1; /* Number of fields described for this type. This field appears at this location because it packs nicely here. */ @@ -407,7 +416,11 @@ struct main_type major overhaul of the internal type system, it can't be avoided for now. */ - struct objfile *objfile; + union type_owner + { + struct objfile *objfile; + struct gdbarch *gdbarch; + } owner; /* For a pointer type, describes the type of object pointed to. For an array type, describes the type of the elements. @@ -804,7 +817,6 @@ extern void allocate_cplus_struct_type (struct type *); so you only have to call check_typedef once. Since allocate_value calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe. */ #define TYPE_LENGTH(thistype) (thistype)->length -#define TYPE_OBJFILE(thistype) TYPE_MAIN_TYPE(thistype)->objfile /* Note that TYPE_CODE can be TYPE_CODE_TYPEDEF, so if you want the real type, you need to do TYPE_CODE (check_type (this_type)). */ #define TYPE_CODE(thistype) TYPE_MAIN_TYPE(thistype)->code @@ -1105,28 +1117,51 @@ extern const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN the same as for the type structure. */ #define TYPE_ALLOC(t,size) \ - (TYPE_OBJFILE (t) != NULL \ + (TYPE_OBJFILE_OWNED (t) \ ? obstack_alloc (&TYPE_OBJFILE (t) -> objfile_obstack, size) \ : xmalloc (size)) #define TYPE_ZALLOC(t,size) \ - (TYPE_OBJFILE (t) != NULL \ + (TYPE_OBJFILE_OWNED (t) \ ? memset (obstack_alloc (&TYPE_OBJFILE (t)->objfile_obstack, size), \ 0, size) \ : xzalloc (size)) +/* Use alloc_type to allocate a type owned by an objfile. + Use alloc_type_arch to allocate a type owned by an architecture. + Use alloc_type_copy to allocate a type with the same owner as a + pre-existing template type, no matter whether objfile or gdbarch. */ extern struct type *alloc_type (struct objfile *); +extern struct type *alloc_type_arch (struct gdbarch *); +extern struct type *alloc_type_copy (const struct type *); + +/* Return the type's architecture. For types owned by an architecture, + that architecture is returned. For types owned by an objfile, that + objfile's architecture is returned. */ +extern struct gdbarch *get_type_arch (const struct type *); +/* Helper function to construct objfile-owned types. */ extern struct type *init_type (enum type_code, int, int, char *, struct objfile *); +/* Helper functions to construct architecture-owned types. */ +extern struct type *arch_type (struct gdbarch *, enum type_code, int, char *); +extern struct type *arch_integer_type (struct gdbarch *, int, int, char *); +extern struct type *arch_character_type (struct gdbarch *, int, int, char *); +extern struct type *arch_boolean_type (struct gdbarch *, int, int, char *); +extern struct type *arch_float_type (struct gdbarch *, int, char *, + const struct floatformat **); +extern struct type *arch_complex_type (struct gdbarch *, char *, + struct type *); + /* Helper functions to construct a struct or record type. An - initially empty type is created using init_composite_type(). + initially empty type is created using arch_composite_type(). Fields are then added using append_struct_type_field(). A union type has its size set to the largest field. A struct type has each field packed against the previous. */ -extern struct type *init_composite_type (char *name, enum type_code code); +extern struct type *arch_composite_type (struct gdbarch *gdbarch, + char *name, enum type_code code); extern void append_composite_type_field (struct type *t, char *name, struct type *field); extern void append_composite_type_field_aligned (struct type *t, @@ -1135,18 +1170,15 @@ extern void append_composite_type_field_aligned (struct type *t, int alignment); /* Helper functions to construct a bit flags type. An initially empty - type is created using init_flag_type(). Flags are then added using + type is created using arch_flag_type(). Flags are then added using append_flag_type_flag(). */ -extern struct type *init_flags_type (char *name, int length); +extern struct type *arch_flags_type (struct gdbarch *gdbarch, + char *name, int length); extern void append_flags_type_flag (struct type *type, int bitpos, char *name); extern void make_vector_type (struct type *array_type); extern struct type *init_vector_type (struct type *elt_type, int n); -extern struct type *init_float_type (int bit, char *name, - const struct floatformat **floatformats); -extern struct type *init_complex_type (char *name, struct type *target_type); - extern struct type *lookup_reference_type (struct type *); extern struct type *make_reference_type (struct type *, struct type **); diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c index cc90c01c034..09c8e69f744 100644 --- a/gdb/gnu-v3-abi.c +++ b/gdb/gnu-v3-abi.c @@ -128,9 +128,7 @@ build_gdb_vtable_type (struct gdbarch *arch) /* ARCH can't give us the true ptrdiff_t type, so we guess. */ struct type *ptrdiff_type - = init_type (TYPE_CODE_INT, - gdbarch_ptr_bit (arch) / TARGET_CHAR_BIT, 0, - "ptrdiff_t", 0); + = arch_integer_type (arch, gdbarch_ptr_bit (arch), 0, "ptrdiff_t"); /* We assume no padding is necessary, since GDB doesn't know anything about alignment at the moment. If this assumption bites @@ -174,10 +172,11 @@ build_gdb_vtable_type (struct gdbarch *arch) /* We assumed in the allocation above that there were four fields. */ gdb_assert (field == (field_list + 4)); - t = init_type (TYPE_CODE_STRUCT, offset, 0, 0, 0); + t = arch_type (arch, TYPE_CODE_STRUCT, offset, NULL); TYPE_NFIELDS (t) = field - field_list; TYPE_FIELDS (t) = field_list; TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable"; + INIT_CPLUS_SPECIFIC (t); return t; } diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c index a5b1b497c8a..6b7560fa4ad 100644 --- a/gdb/i386-tdep.c +++ b/gdb/i386-tdep.c @@ -2004,7 +2004,7 @@ i386_eflags_type (struct gdbarch *gdbarch) { struct type *type; - type = init_flags_type ("builtin_type_i386_eflags", 4); + type = arch_flags_type (gdbarch, "builtin_type_i386_eflags", 4); append_flags_type_flag (type, 0, "CF"); append_flags_type_flag (type, 1, NULL); append_flags_type_flag (type, 2, "PF"); @@ -2038,7 +2038,7 @@ i386_mxcsr_type (struct gdbarch *gdbarch) { struct type *type; - type = init_flags_type ("builtin_type_i386_mxcsr", 4); + type = arch_flags_type (gdbarch, "builtin_type_i386_mxcsr", 4); append_flags_type_flag (type, 0, "IE"); append_flags_type_flag (type, 1, "DE"); append_flags_type_flag (type, 2, "ZE"); @@ -2067,7 +2067,7 @@ i387_ext_type (struct gdbarch *gdbarch) if (!tdep->i387_ext_type) tdep->i387_ext_type - = init_float_type (-1, "builtin_type_i387_ext", + = arch_float_type (gdbarch, -1, "builtin_type_i387_ext", floatformats_i387_ext); return tdep->i387_ext_type; @@ -2096,7 +2096,8 @@ i386_mmx_type (struct gdbarch *gdbarch) struct type *t; - t = init_composite_type ("__gdb_builtin_type_vec64i", TYPE_CODE_UNION); + t = arch_composite_type (gdbarch, + "__gdb_builtin_type_vec64i", TYPE_CODE_UNION); append_composite_type_field (t, "uint64", bt->builtin_int64); append_composite_type_field (t, "v2_int32", @@ -2139,7 +2140,8 @@ i386_sse_type (struct gdbarch *gdbarch) struct type *t; - t = init_composite_type ("__gdb_builtin_type_vec128i", TYPE_CODE_UNION); + t = arch_composite_type (gdbarch, + "__gdb_builtin_type_vec128i", TYPE_CODE_UNION); append_composite_type_field (t, "v4_float", init_vector_type (bt->builtin_float, 4)); append_composite_type_field (t, "v2_double", diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c index 6919650e113..d5daf5064cc 100644 --- a/gdb/ia64-tdep.c +++ b/gdb/ia64-tdep.c @@ -303,7 +303,7 @@ ia64_ext_type (struct gdbarch *gdbarch) if (!tdep->ia64_ext_type) tdep->ia64_ext_type - = init_float_type (128, "builtin_type_ia64_ext", + = arch_float_type (gdbarch, 128, "builtin_type_ia64_ext", floatformats_ia64_ext); return tdep->ia64_ext_type; diff --git a/gdb/jv-lang.c b/gdb/jv-lang.c index c885ec7325c..e1b6817a31b 100644 --- a/gdb/jv-lang.c +++ b/gdb/jv-lang.c @@ -296,7 +296,7 @@ type_from_class (struct gdbarch *gdbarch, struct value *clas) /* Do not use the "fake" dynamics objfile to own dynamically generated types, as it does not provide an architecture, and it would not help manage the lifetime of these types anyway. */ - type = alloc_type (NULL); + type = alloc_type_arch (gdbarch); TYPE_CODE (type) = TYPE_CODE_STRUCT; INIT_CPLUS_SPECIFIC (type); @@ -1170,23 +1170,23 @@ build_java_types (struct gdbarch *gdbarch) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_java_type); builtin_java_type->builtin_int - = init_type (TYPE_CODE_INT, 4, 0, "int", NULL); + = arch_integer_type (gdbarch, 32, 0, "int"); builtin_java_type->builtin_short - = init_type (TYPE_CODE_INT, 2, 0, "short", NULL); + = arch_integer_type (gdbarch, 16, 0, "short"); builtin_java_type->builtin_long - = init_type (TYPE_CODE_INT, 8, 0, "long", NULL); + = arch_integer_type (gdbarch, 64, 0, "long"); builtin_java_type->builtin_byte - = init_type (TYPE_CODE_INT, 1, 0, "byte", NULL); + = arch_integer_type (gdbarch, 8, 0, "byte"); builtin_java_type->builtin_boolean - = init_type (TYPE_CODE_BOOL, 1, 0, "boolean", NULL); + = arch_boolean_type (gdbarch, 8, 0, "boolean"); builtin_java_type->builtin_char - = init_type (TYPE_CODE_CHAR, 2, TYPE_FLAG_UNSIGNED, "char", NULL); + = arch_character_type (gdbarch, 16, 1, "char"); builtin_java_type->builtin_float - = init_float_type (32, "float", NULL); + = arch_float_type (gdbarch, 32, "float", NULL); builtin_java_type->builtin_double - = init_float_type (64, "double", NULL); + = arch_float_type (gdbarch, 64, "double", NULL); builtin_java_type->builtin_void - = init_type (TYPE_CODE_VOID, 1, 0, "void", NULL); + = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void"); return builtin_java_type; } diff --git a/gdb/linux-tdep.c b/gdb/linux-tdep.c index e18e134ed36..37770f5f5b9 100644 --- a/gdb/linux-tdep.c +++ b/gdb/linux-tdep.c @@ -33,43 +33,40 @@ linux_get_siginfo_type (struct gdbarch *gdbarch) struct type *siginfo_type, *sifields_type; struct type *type; - int_type = init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, - 0, "int", NULL); - uint_type = init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, - 0, "unsigned int", NULL); - long_type = init_type (TYPE_CODE_INT, - gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT, - 0, "long", NULL); + int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), + 0, "int"); + uint_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), + 1, "unsigned int"); + long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), + 0, "long"); void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void); /* sival_t */ - sigval_type = init_composite_type (NULL, TYPE_CODE_UNION); + sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION); TYPE_NAME (sigval_type) = xstrdup ("sigval_t"); append_composite_type_field (sigval_type, "sival_int", int_type); append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type); /* __pid_t */ - pid_type = init_type (TYPE_CODE_TYPEDEF, TYPE_LENGTH (int_type), - TYPE_FLAG_TARGET_STUB, NULL, NULL); - TYPE_NAME (pid_type) = xstrdup ("__pid_t"); + pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF, TYPE_LENGTH (int_type), + xstrdup ("__pid_t")); TYPE_TARGET_TYPE (pid_type) = int_type; + TYPE_TARGET_STUB (pid_type) = 1; /* __uid_t */ - uid_type = init_type (TYPE_CODE_TYPEDEF, TYPE_LENGTH (uint_type), - TYPE_FLAG_TARGET_STUB, NULL, NULL); - TYPE_NAME (uid_type) = xstrdup ("__uid_t"); + uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF, TYPE_LENGTH (uint_type), + xstrdup ("__uid_t")); TYPE_TARGET_TYPE (uid_type) = uint_type; + TYPE_TARGET_STUB (uid_type) = 1; /* __clock_t */ - clock_type = init_type (TYPE_CODE_TYPEDEF, TYPE_LENGTH (long_type), - TYPE_FLAG_TARGET_STUB, NULL, NULL); - TYPE_NAME (clock_type) = xstrdup ("__clock_t"); + clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF, TYPE_LENGTH (long_type), + xstrdup ("__clock_t")); TYPE_TARGET_TYPE (clock_type) = long_type; + TYPE_TARGET_STUB (clock_type) = 1; /* _sifields */ - sifields_type = init_composite_type (NULL, TYPE_CODE_UNION); + sifields_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION); { const int si_max_size = 128; @@ -86,27 +83,27 @@ linux_get_siginfo_type (struct gdbarch *gdbarch) } /* _kill */ - type = init_composite_type (NULL, TYPE_CODE_STRUCT); + type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); append_composite_type_field (type, "si_pid", pid_type); append_composite_type_field (type, "si_uid", uid_type); append_composite_type_field (sifields_type, "_kill", type); /* _timer */ - type = init_composite_type (NULL, TYPE_CODE_STRUCT); + type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); append_composite_type_field (type, "si_tid", int_type); append_composite_type_field (type, "si_overrun", int_type); append_composite_type_field (type, "si_sigval", sigval_type); append_composite_type_field (sifields_type, "_timer", type); /* _rt */ - type = init_composite_type (NULL, TYPE_CODE_STRUCT); + type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); append_composite_type_field (type, "si_pid", pid_type); append_composite_type_field (type, "si_uid", uid_type); append_composite_type_field (type, "si_sigval", sigval_type); append_composite_type_field (sifields_type, "_rt", type); /* _sigchld */ - type = init_composite_type (NULL, TYPE_CODE_STRUCT); + type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); append_composite_type_field (type, "si_pid", pid_type); append_composite_type_field (type, "si_uid", uid_type); append_composite_type_field (type, "si_status", int_type); @@ -115,18 +112,18 @@ linux_get_siginfo_type (struct gdbarch *gdbarch) append_composite_type_field (sifields_type, "_sigchld", type); /* _sigfault */ - type = init_composite_type (NULL, TYPE_CODE_STRUCT); + type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); append_composite_type_field (type, "si_addr", void_ptr_type); append_composite_type_field (sifields_type, "_sigfault", type); /* _sigpoll */ - type = init_composite_type (NULL, TYPE_CODE_STRUCT); + type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); append_composite_type_field (type, "si_band", long_type); append_composite_type_field (type, "si_fd", int_type); append_composite_type_field (sifields_type, "_sigpoll", type); /* struct siginfo */ - siginfo_type = init_composite_type (NULL, TYPE_CODE_STRUCT); + siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); TYPE_NAME (siginfo_type) = xstrdup ("siginfo"); append_composite_type_field (siginfo_type, "si_signo", int_type); append_composite_type_field (siginfo_type, "si_errno", int_type); diff --git a/gdb/m2-lang.c b/gdb/m2-lang.c index 14211494d4f..88c7e5e642a 100644 --- a/gdb/m2-lang.c +++ b/gdb/m2-lang.c @@ -406,26 +406,16 @@ build_m2_types (struct gdbarch *gdbarch) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_m2_type); /* Modula-2 "pervasive" types. NOTE: these can be redefined!!! */ - builtin_m2_type->builtin_int = - init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "INTEGER", (struct objfile *) NULL); - builtin_m2_type->builtin_card = - init_type (TYPE_CODE_INT, - gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "CARDINAL", (struct objfile *) NULL); - builtin_m2_type->builtin_real = - init_float_type (gdbarch_float_bit (gdbarch), "REAL", NULL); - builtin_m2_type->builtin_char = - init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "CHAR", (struct objfile *) NULL); - builtin_m2_type->builtin_bool = - init_type (TYPE_CODE_BOOL, - gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "BOOLEAN", (struct objfile *) NULL); + builtin_m2_type->builtin_int + = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 0, "INTEGER"); + builtin_m2_type->builtin_card + = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "CARDINAL"); + builtin_m2_type->builtin_real + = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), "REAL", NULL); + builtin_m2_type->builtin_char + = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "CHAR"); + builtin_m2_type->builtin_bool + = arch_boolean_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "BOOLEAN"); return builtin_m2_type; } diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c index a833ef43f70..b67169f6fa4 100644 --- a/gdb/m32c-tdep.c +++ b/gdb/m32c-tdep.c @@ -192,34 +192,33 @@ make_types (struct gdbarch *arch) /* The builtin_type_mumble variables are sometimes uninitialized when this is called, so we avoid using them. */ - tdep->voyd = init_type (TYPE_CODE_VOID, 1, 0, "void", NULL); - tdep->ptr_voyd = init_type (TYPE_CODE_PTR, gdbarch_ptr_bit (arch) / 8, - TYPE_FLAG_UNSIGNED, NULL, NULL); + tdep->voyd = arch_type (arch, TYPE_CODE_VOID, 1, "void"); + tdep->ptr_voyd + = arch_type (arch, TYPE_CODE_PTR, gdbarch_ptr_bit (arch), NULL); TYPE_TARGET_TYPE (tdep->ptr_voyd) = tdep->voyd; + TYPE_UNSIGNED (tdep->ptr_voyd) = 1; tdep->func_voyd = lookup_function_type (tdep->voyd); sprintf (type_name, "%s_data_addr_t", gdbarch_bfd_arch_info (arch)->printable_name); tdep->data_addr_reg_type - = init_type (TYPE_CODE_PTR, data_addr_reg_bits / 8, - TYPE_FLAG_UNSIGNED, xstrdup (type_name), NULL); + = arch_type (arch, TYPE_CODE_PTR, data_addr_reg_bits, xstrdup (type_name)); TYPE_TARGET_TYPE (tdep->data_addr_reg_type) = tdep->voyd; + TYPE_UNSIGNED (tdep->data_addr_reg_type) = 1; sprintf (type_name, "%s_code_addr_t", gdbarch_bfd_arch_info (arch)->printable_name); tdep->code_addr_reg_type - = init_type (TYPE_CODE_PTR, code_addr_reg_bits / 8, - TYPE_FLAG_UNSIGNED, xstrdup (type_name), NULL); + = arch_type (arch, TYPE_CODE_PTR, code_addr_reg_bits, xstrdup (type_name)); TYPE_TARGET_TYPE (tdep->code_addr_reg_type) = tdep->func_voyd; - - tdep->uint8 = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED, - "uint8_t", NULL); - tdep->uint16 = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED, - "uint16_t", NULL); - tdep->int8 = init_type (TYPE_CODE_INT, 1, 0, "int8_t", NULL); - tdep->int16 = init_type (TYPE_CODE_INT, 2, 0, "int16_t", NULL); - tdep->int32 = init_type (TYPE_CODE_INT, 4, 0, "int32_t", NULL); - tdep->int64 = init_type (TYPE_CODE_INT, 8, 0, "int64_t", NULL); + TYPE_UNSIGNED (tdep->code_addr_reg_type) = 1; + + tdep->uint8 = arch_integer_type (arch, 8, 1, "uint8_t"); + tdep->uint16 = arch_integer_type (arch, 16, 1, "uint16_t"); + tdep->int8 = arch_integer_type (arch, 8, 0, "int8_t"); + tdep->int16 = arch_integer_type (arch, 16, 0, "int16_t"); + tdep->int32 = arch_integer_type (arch, 32, 0, "int32_t"); + tdep->int64 = arch_integer_type (arch, 64, 0, "int64_t"); } diff --git a/gdb/m68k-tdep.c b/gdb/m68k-tdep.c index 0c551c6155d..213431f9f10 100644 --- a/gdb/m68k-tdep.c +++ b/gdb/m68k-tdep.c @@ -81,7 +81,7 @@ m68k_ps_type (struct gdbarch *gdbarch) { struct type *type; - type = init_flags_type ("builtin_type_m68k_ps", 4); + type = arch_flags_type (gdbarch, "builtin_type_m68k_ps", 4); append_flags_type_flag (type, 0, "C"); append_flags_type_flag (type, 1, "V"); append_flags_type_flag (type, 2, "Z"); @@ -108,7 +108,7 @@ m68881_ext_type (struct gdbarch *gdbarch) if (!tdep->m68881_ext_type) tdep->m68881_ext_type - = init_float_type (-1, "builtin_type_m68881_ext", + = arch_float_type (gdbarch, -1, "builtin_type_m68881_ext", floatformats_m68881_ext); return tdep->m68881_ext_type; diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c index 00b42d02375..36097e683ca 100644 --- a/gdb/rs6000-tdep.c +++ b/gdb/rs6000-tdep.c @@ -2264,7 +2264,8 @@ rs6000_builtin_type_vec64 (struct gdbarch *gdbarch) struct type *t; - t = init_composite_type ("__ppc_builtin_type_vec64", TYPE_CODE_UNION); + t = arch_composite_type (gdbarch, + "__ppc_builtin_type_vec64", TYPE_CODE_UNION); append_composite_type_field (t, "uint64", bt->builtin_int64); append_composite_type_field (t, "v2_float", init_vector_type (bt->builtin_float, 2)); @@ -2307,7 +2308,8 @@ rs6000_builtin_type_vec128 (struct gdbarch *gdbarch) struct type *t; - t = init_composite_type ("__ppc_builtin_type_vec128", TYPE_CODE_UNION); + t = arch_composite_type (gdbarch, + "__ppc_builtin_type_vec128", TYPE_CODE_UNION); append_composite_type_field (t, "uint128", bt->builtin_uint128); append_composite_type_field (t, "v4_float", init_vector_type (bt->builtin_float, 4)); diff --git a/gdb/scm-lang.c b/gdb/scm-lang.c index 66f293bd152..bc37c6f7e68 100644 --- a/gdb/scm-lang.c +++ b/gdb/scm-lang.c @@ -278,10 +278,8 @@ build_scm_types (struct gdbarch *gdbarch) struct builtin_scm_type *builtin_scm_type = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_scm_type); - builtin_scm_type->builtin_scm = - init_type (TYPE_CODE_INT, - gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT, - 0, "SCM", (struct objfile *) NULL); + builtin_scm_type->builtin_scm + = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 0, "SCM"); return builtin_scm_type; } diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c index f6dbf3f5aba..2b87d779cd3 100644 --- a/gdb/sparc-tdep.c +++ b/gdb/sparc-tdep.c @@ -294,7 +294,7 @@ sparc_psr_type (struct gdbarch *gdbarch) { struct type *type; - type = init_flags_type ("builtin_type_sparc_psr", 4); + type = arch_flags_type (gdbarch, "builtin_type_sparc_psr", 4); append_flags_type_flag (type, 5, "ET"); append_flags_type_flag (type, 6, "PS"); append_flags_type_flag (type, 7, "S"); @@ -316,7 +316,7 @@ sparc_fsr_type (struct gdbarch *gdbarch) { struct type *type; - type = init_flags_type ("builtin_type_sparc_fsr", 4); + type = arch_flags_type (gdbarch, "builtin_type_sparc_fsr", 4); append_flags_type_flag (type, 0, "NXA"); append_flags_type_flag (type, 1, "DZA"); append_flags_type_flag (type, 2, "UFA"); diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c index acfbace3eaf..47171a48e59 100644 --- a/gdb/sparc64-tdep.c +++ b/gdb/sparc64-tdep.c @@ -132,7 +132,7 @@ sparc64_pstate_type (struct gdbarch *gdbarch) { struct type *type; - type = init_flags_type ("builtin_type_sparc64_pstate", 8); + type = arch_flags_type (gdbarch, "builtin_type_sparc64_pstate", 8); append_flags_type_flag (type, 0, "AG"); append_flags_type_flag (type, 1, "IE"); append_flags_type_flag (type, 2, "PRIV"); @@ -159,7 +159,7 @@ sparc64_fsr_type (struct gdbarch *gdbarch) { struct type *type; - type = init_flags_type ("builtin_type_sparc64_fsr", 8); + type = arch_flags_type (gdbarch, "builtin_type_sparc64_fsr", 8); append_flags_type_flag (type, 0, "NXA"); append_flags_type_flag (type, 1, "DZA"); append_flags_type_flag (type, 2, "UFA"); @@ -192,7 +192,7 @@ sparc64_fprs_type (struct gdbarch *gdbarch) { struct type *type; - type = init_flags_type ("builtin_type_sparc64_fprs", 8); + type = arch_flags_type (gdbarch, "builtin_type_sparc64_fprs", 8); append_flags_type_flag (type, 0, "DL"); append_flags_type_flag (type, 1, "DU"); append_flags_type_flag (type, 2, "FEF"); diff --git a/gdb/spu-tdep.c b/gdb/spu-tdep.c index 4fa94ccc873..ac976a57d3c 100644 --- a/gdb/spu-tdep.c +++ b/gdb/spu-tdep.c @@ -64,7 +64,8 @@ spu_builtin_type_vec128 (struct gdbarch *gdbarch) const struct builtin_type *bt = builtin_type (gdbarch); struct type *t; - t = init_composite_type ("__spu_builtin_type_vec128", TYPE_CODE_UNION); + t = arch_composite_type (gdbarch, + "__spu_builtin_type_vec128", TYPE_CODE_UNION); append_composite_type_field (t, "uint128", bt->builtin_int128); append_composite_type_field (t, "v2_int64", init_vector_type (bt->builtin_int64, 2)); diff --git a/gdb/target-descriptions.c b/gdb/target-descriptions.c index 3d0c66b671b..741ea655b8a 100644 --- a/gdb/target-descriptions.c +++ b/gdb/target-descriptions.c @@ -488,15 +488,15 @@ tdesc_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *tdesc_type) return builtin_type (gdbarch)->builtin_data_ptr; case TDESC_TYPE_IEEE_SINGLE: - return init_float_type (-1, "builtin_type_ieee_single", + return arch_float_type (gdbarch, -1, "builtin_type_ieee_single", floatformats_ieee_single); case TDESC_TYPE_IEEE_DOUBLE: - return init_float_type (-1, "builtin_type_ieee_double", + return arch_float_type (gdbarch, -1, "builtin_type_ieee_double", floatformats_ieee_double); case TDESC_TYPE_ARM_FPA_EXT: - return init_float_type (-1, "builtin_type_arm_ext", + return arch_float_type (gdbarch, -1, "builtin_type_arm_ext", floatformats_arm_ext); /* Types defined by a target feature. */ @@ -517,7 +517,7 @@ tdesc_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *tdesc_type) struct tdesc_type_field *f; int ix; - type = init_composite_type (NULL, TYPE_CODE_UNION); + type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION); TYPE_NAME (type) = xstrdup (tdesc_type->name); for (ix = 0; diff --git a/gdb/xtensa-tdep.c b/gdb/xtensa-tdep.c index 7a965771870..e81b87e850d 100644 --- a/gdb/xtensa-tdep.c +++ b/gdb/xtensa-tdep.c @@ -281,9 +281,8 @@ xtensa_register_type (struct gdbarch *gdbarch, int regnum) tp->size = size; sprintf (name, "int%d", size * 8); - tp->virtual_type = init_type (TYPE_CODE_INT, size, - TYPE_FLAG_UNSIGNED, name, - NULL); + tp->virtual_type + = arch_integer_type (gdbarch, size * 8, 1, xstrdup (name)); } reg->ctype = tp->virtual_type; -- 2.30.2