FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

* gdbtypes.h (TYPE_OBJFILE_OWNED, TYPE_OWNER): New macros.

Browse source 
(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.
This commit is contained in:
Ulrich Weigand 2009-07-02 12:55:30 +00:00
parent 209bd28e8b
commit e9bb382b83
21 changed files with 695 additions and 527 deletions
Download patch file Download diff file Expand all files Collapse all files

95
gdb/ChangeLog
View file

@ -1,3 +1,98 @@
2009-07-02 Ulrich Weigand <uweigand@de.ibm.com>
* 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 <uweigand@de.ibm.com> 2009-07-02 Ulrich Weigand <uweigand@de.ibm.com>
* i386-tdep.h (struct gdbarch_tdep): Add i386_eflags_type and * i386-tdep.h (struct gdbarch_tdep): Add i386_eflags_type and

105
gdb/ada-lang.c
View file

@ -1608,7 +1608,6 @@ ada_type_of_array (struct value *arr, int bounds)
struct type *elt_type; struct type *elt_type;
int arity; int arity;
struct value *descriptor; struct value *descriptor;
struct objfile *objf = TYPE_OBJFILE (value_type (arr));
elt_type = ada_array_element_type (value_type (arr), -1); elt_type = ada_array_element_type (value_type (arr), -1);
arity = ada_array_arity (value_type (arr)); arity = ada_array_arity (value_type (arr));
@ -1621,8 +1620,8 @@ ada_type_of_array (struct value *arr, int bounds)
return NULL; return NULL;
while (arity > 0) while (arity > 0)
{ {
struct type *range_type = alloc_type (objf); struct type *range_type = alloc_type_copy (value_type (arr));
struct type *array_type = alloc_type (objf); struct type *array_type = alloc_type_copy (value_type (arr));
struct value *low = desc_one_bound (descriptor, arity, 0); struct value *low = desc_one_bound (descriptor, arity, 0);
struct value *high = desc_one_bound (descriptor, arity, 1); struct value *high = desc_one_bound (descriptor, arity, 1);
arity -= 1; arity -= 1;
@ -1729,7 +1728,7 @@ packed_array_type (struct type *type, long *elt_bits)
if (TYPE_CODE (type) != TYPE_CODE_ARRAY) if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
return type; 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)), new_elt_type = packed_array_type (ada_check_typedef (TYPE_TARGET_TYPE (type)),
elt_bits); elt_bits);
create_array_type (new_type, new_elt_type, TYPE_INDEX_TYPE (type)); 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. */ /* A record type with no fields. */
static struct type * 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_CODE (type) = TYPE_CODE_STRUCT;
TYPE_NFIELDS (type) = 0; TYPE_NFIELDS (type) = 0;
TYPE_FIELDS (type) = NULL; TYPE_FIELDS (type) = NULL;
@ -6724,7 +6723,7 @@ ada_template_to_fixed_record_type_1 (struct type *type,
nfields++; nfields++;
} }
rtype = alloc_type (TYPE_OBJFILE (type)); rtype = alloc_type_copy (type);
TYPE_CODE (rtype) = TYPE_CODE_STRUCT; TYPE_CODE (rtype) = TYPE_CODE_STRUCT;
INIT_CPLUS_SPECIFIC (rtype); INIT_CPLUS_SPECIFIC (rtype);
TYPE_NFIELDS (rtype) = nfields; TYPE_NFIELDS (rtype) = nfields;
@ -6934,7 +6933,7 @@ template_to_static_fixed_type (struct type *type0)
new_type = static_unwrap_type (field_type); new_type = static_unwrap_type (field_type);
if (type == type0 && new_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); TYPE_CODE (type) = TYPE_CODE (type0);
INIT_CPLUS_SPECIFIC (type); INIT_CPLUS_SPECIFIC (type);
TYPE_NFIELDS (type) = nfields; TYPE_NFIELDS (type) = nfields;
@ -6979,7 +6978,7 @@ to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr,
else else
dval = dval0; dval = dval0;
rtype = alloc_type (TYPE_OBJFILE (type)); rtype = alloc_type_copy (type);
TYPE_CODE (rtype) = TYPE_CODE_STRUCT; TYPE_CODE (rtype) = TYPE_CODE_STRUCT;
INIT_CPLUS_SPECIFIC (rtype); INIT_CPLUS_SPECIFIC (rtype);
TYPE_NFIELDS (rtype) = nfields; 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)); value_type (dval), value_contents (dval));
if (which < 0) if (which < 0)
return empty_record (TYPE_OBJFILE (var_type)); return empty_record (var_type);
else if (is_dynamic_field (var_type, which)) else if (is_dynamic_field (var_type, which))
return to_fixed_record_type return to_fixed_record_type
(TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (var_type, which)), (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) if (elt_type0 == elt_type && !packed_array_p)
result = type0; result = type0;
else else
result = create_array_type (alloc_type (TYPE_OBJFILE (type0)), result = create_array_type (alloc_type_copy (type0),
elt_type, TYPE_INDEX_TYPE (type0)); elt_type, TYPE_INDEX_TYPE (type0));
} }
else else
@ -7190,7 +7189,7 @@ to_fixed_array_type (struct type *type0, struct value *dval,
struct type *range_type = struct type *range_type =
to_fixed_range_type (TYPE_FIELD_NAME (index_type_desc, i), to_fixed_range_type (TYPE_FIELD_NAME (index_type_desc, i),
dval, TYPE_INDEX_TYPE (elt_type0)); 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); result, range_type);
elt_type0 = TYPE_TARGET_TYPE (elt_type0); 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) if (L < INT_MIN || U > INT_MAX)
return raw_type; return raw_type;
else else
return create_range_type (alloc_type (TYPE_OBJFILE (orig_type)), return create_range_type (alloc_type_copy (orig_type), raw_type,
raw_type,
discrete_type_low_bound (raw_type), discrete_type_low_bound (raw_type),
discrete_type_high_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)), type = create_range_type (alloc_type_copy (orig_type), base_type, L, U);
base_type, L, U);
TYPE_NAME (type) = name; TYPE_NAME (type) = name;
return type; return type;
} }
@ -11160,48 +11157,42 @@ ada_language_arch_info (struct gdbarch *gdbarch,
lai->primitive_type_vector lai->primitive_type_vector
= GDBARCH_OBSTACK_CALLOC (gdbarch, nr_ada_primitive_types + 1, = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_ada_primitive_types + 1,
struct type *); 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] = lai->primitive_type_vector [ada_primitive_type_int]
lookup_pointer_type (init_type (TYPE_CODE_VOID, 1, 0, "void", = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
(struct objfile *) NULL)); 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]) TYPE_NAME (lai->primitive_type_vector [ada_primitive_type_system_address])
= "system__address"; = "system__address";

2
gdb/arm-tdep.c
View file

@ -1601,7 +1601,7 @@ arm_ext_type (struct gdbarch *gdbarch)
if (!tdep->arm_ext_type) if (!tdep->arm_ext_type)
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); floatformats_arm_ext);
return tdep->arm_ext_type; return tdep->arm_ext_type;

82
gdb/f-lang.c
View file

@ -355,60 +355,50 @@ build_fortran_types (struct gdbarch *gdbarch)
struct builtin_f_type *builtin_f_type struct builtin_f_type *builtin_f_type
= GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_f_type); = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_f_type);
builtin_f_type->builtin_void = builtin_f_type->builtin_void
init_type (TYPE_CODE_VOID, 1, = arch_type (gdbarch, TYPE_CODE_VOID, 1, "VOID");
0,
"VOID", (struct objfile *) NULL);
builtin_f_type->builtin_character = builtin_f_type->builtin_character
init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, = arch_integer_type (gdbarch, TARGET_CHAR_BIT, 0, "character");
0,
"character", (struct objfile *) NULL);
builtin_f_type->builtin_logical_s1 = builtin_f_type->builtin_logical_s1
init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT, = arch_boolean_type (gdbarch, TARGET_CHAR_BIT, 1, "logical*1");
TYPE_FLAG_UNSIGNED,
"logical*1", (struct objfile *) NULL);
builtin_f_type->builtin_integer_s2 = builtin_f_type->builtin_integer_s2
init_type (TYPE_CODE_INT, = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch), 0,
gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, "integer*2");
0, "integer*2", (struct objfile *) NULL);
builtin_f_type->builtin_logical_s2 = builtin_f_type->builtin_logical_s2
init_type (TYPE_CODE_BOOL, = arch_boolean_type (gdbarch, gdbarch_short_bit (gdbarch), 1,
gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, "logical*2");
TYPE_FLAG_UNSIGNED, "logical*2", (struct objfile *) NULL);
builtin_f_type->builtin_integer = builtin_f_type->builtin_integer
init_type (TYPE_CODE_INT, = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 0,
gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, "integer");
0, "integer", (struct objfile *) NULL);
builtin_f_type->builtin_logical = builtin_f_type->builtin_logical
init_type (TYPE_CODE_BOOL, = arch_boolean_type (gdbarch, gdbarch_int_bit (gdbarch), 1,
gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, "logical*4");
TYPE_FLAG_UNSIGNED, "logical*4", (struct objfile *) NULL);
builtin_f_type->builtin_real = builtin_f_type->builtin_real
init_float_type (gdbarch_float_bit (gdbarch), = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
"real", NULL); "real", NULL);
builtin_f_type->builtin_real_s8 = builtin_f_type->builtin_real_s8
init_float_type (gdbarch_double_bit (gdbarch), = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
"real*8", NULL); "real*8", NULL);
builtin_f_type->builtin_real_s16 = builtin_f_type->builtin_real_s16
init_float_type (gdbarch_long_double_bit (gdbarch), = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
"real*16", NULL); "real*16", NULL);
builtin_f_type->builtin_complex_s8 = builtin_f_type->builtin_complex_s8
init_complex_type ("complex*8", = arch_complex_type (gdbarch, "complex*8",
builtin_f_type->builtin_real); builtin_f_type->builtin_real);
builtin_f_type->builtin_complex_s16 = builtin_f_type->builtin_complex_s16
init_complex_type ("complex*16", = arch_complex_type (gdbarch, "complex*16",
builtin_f_type->builtin_real_s8); builtin_f_type->builtin_real_s8);
builtin_f_type->builtin_complex_s32 = builtin_f_type->builtin_complex_s32
init_complex_type ("complex*32", = arch_complex_type (gdbarch, "complex*32",
builtin_f_type->builtin_real_s16); builtin_f_type->builtin_real_s16);
return builtin_f_type; return builtin_f_type;
} }

689
gdb/gdbtypes.c
View file

@ -119,41 +119,89 @@ static void dump_fn_fieldlists (struct type *, int);
static void print_cplus_stuff (struct type *, int); static void print_cplus_stuff (struct type *, int);
/* Alloc a new type structure and fill it with some defaults. If /* Allocate a new OBJFILE-associated type structure and fill it
OBJFILE is non-NULL, then allocate the space for the type structure with some defaults. Space for the type structure is allocated
in that objfile's objfile_obstack. Otherwise allocate the new type on the objfile's objfile_obstack. */
structure by xmalloc () (for permanent types). */
struct type * struct type *
alloc_type (struct objfile *objfile) alloc_type (struct objfile *objfile)
{ {
struct type *type; struct type *type;
/* Alloc the structure and start off with all fields zeroed. */ gdb_assert (objfile != NULL);
if (objfile == NULL) /* Alloc the structure and start off with all fields zeroed. */
{ type = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct type);
type = XZALLOC (struct type); TYPE_MAIN_TYPE (type) = OBSTACK_ZALLOC (&objfile->objfile_obstack,
TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type); struct main_type);
} OBJSTAT (objfile, n_types++);
else
{ TYPE_OBJFILE_OWNED (type) = 1;
type = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct type); TYPE_OWNER (type).objfile = objfile;
TYPE_MAIN_TYPE (type) = OBSTACK_ZALLOC (&objfile->objfile_obstack,
struct main_type);
OBJSTAT (objfile, n_types++);
}
/* Initialize the fields that might not be zero. */ /* Initialize the fields that might not be zero. */
TYPE_CODE (type) = TYPE_CODE_UNDEF; TYPE_CODE (type) = TYPE_CODE_UNDEF;
TYPE_OBJFILE (type) = objfile;
TYPE_VPTR_FIELDNO (type) = -1; TYPE_VPTR_FIELDNO (type) = -1;
TYPE_CHAIN (type) = type; /* Chain back to itself. */ TYPE_CHAIN (type) = type; /* Chain back to itself. */
return type; 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, /* Alloc a new type instance structure, fill it with some defaults,
and point it at OLDTYPE. Allocate the new type instance from the and point it at OLDTYPE. Allocate the new type instance from the
same place as OLDTYPE. */ same place as OLDTYPE. */
@ -165,7 +213,7 @@ alloc_type_instance (struct type *oldtype)
/* Allocate the structure. */ /* Allocate the structure. */
if (TYPE_OBJFILE (oldtype) == NULL) if (! TYPE_OBJFILE_OWNED (oldtype))
type = XZALLOC (struct type); type = XZALLOC (struct type);
else else
type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack, 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 /* 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 static void
smash_type (struct type *type) 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)); 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. */ /* For now, delete the rings. */
TYPE_CHAIN (type) = type; TYPE_CHAIN (type) = type;
@ -200,7 +255,6 @@ struct type *
make_pointer_type (struct type *type, struct type **typeptr) make_pointer_type (struct type *type, struct type **typeptr)
{ {
struct type *ntype; /* New type */ struct type *ntype; /* New type */
struct objfile *objfile;
struct type *chain; struct type *chain;
ntype = TYPE_POINTER_TYPE (type); 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. */ if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
{ {
ntype = alloc_type (TYPE_OBJFILE (type)); ntype = alloc_type_copy (type);
if (typeptr) if (typeptr)
*typeptr = ntype; *typeptr = ntype;
} }
else /* We have storage, but need to reset it. */ else /* We have storage, but need to reset it. */
{ {
ntype = *typeptr; ntype = *typeptr;
objfile = TYPE_OBJFILE (ntype);
chain = TYPE_CHAIN (ntype); chain = TYPE_CHAIN (ntype);
smash_type (ntype); smash_type (ntype);
TYPE_CHAIN (ntype) = chain; TYPE_CHAIN (ntype) = chain;
TYPE_OBJFILE (ntype) = objfile;
} }
TYPE_TARGET_TYPE (ntype) = type; TYPE_TARGET_TYPE (ntype) = type;
@ -280,7 +332,6 @@ struct type *
make_reference_type (struct type *type, struct type **typeptr) make_reference_type (struct type *type, struct type **typeptr)
{ {
struct type *ntype; /* New type */ struct type *ntype; /* New type */
struct objfile *objfile;
struct type *chain; struct type *chain;
ntype = TYPE_REFERENCE_TYPE (type); 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. */ if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
{ {
ntype = alloc_type (TYPE_OBJFILE (type)); ntype = alloc_type_copy (type);
if (typeptr) if (typeptr)
*typeptr = ntype; *typeptr = ntype;
} }
else /* We have storage, but need to reset it. */ else /* We have storage, but need to reset it. */
{ {
ntype = *typeptr; ntype = *typeptr;
objfile = TYPE_OBJFILE (ntype);
chain = TYPE_CHAIN (ntype); chain = TYPE_CHAIN (ntype);
smash_type (ntype); smash_type (ntype);
TYPE_CHAIN (ntype) = chain; TYPE_CHAIN (ntype) = chain;
TYPE_OBJFILE (ntype) = objfile;
} }
TYPE_TARGET_TYPE (ntype) = type; TYPE_TARGET_TYPE (ntype) = type;
@ -355,20 +404,17 @@ struct type *
make_function_type (struct type *type, struct type **typeptr) make_function_type (struct type *type, struct type **typeptr)
{ {
struct type *ntype; /* New type */ struct type *ntype; /* New type */
struct objfile *objfile;
if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */ if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
{ {
ntype = alloc_type (TYPE_OBJFILE (type)); ntype = alloc_type_copy (type);
if (typeptr) if (typeptr)
*typeptr = ntype; *typeptr = ntype;
} }
else /* We have storage, but need to reset it. */ else /* We have storage, but need to reset it. */
{ {
ntype = *typeptr; ntype = *typeptr;
objfile = TYPE_OBJFILE (ntype);
smash_type (ntype); smash_type (ntype);
TYPE_OBJFILE (ntype) = objfile;
} }
TYPE_TARGET_TYPE (ntype) = type; TYPE_TARGET_TYPE (ntype) = type;
@ -614,7 +660,7 @@ lookup_memberptr_type (struct type *type, struct type *domain)
{ {
struct type *mtype; struct type *mtype;
mtype = alloc_type (TYPE_OBJFILE (type)); mtype = alloc_type_copy (type);
smash_to_memberptr_type (mtype, domain, type); smash_to_memberptr_type (mtype, domain, type);
return mtype; return mtype;
} }
@ -626,7 +672,7 @@ lookup_methodptr_type (struct type *to_type)
{ {
struct type *mtype; struct type *mtype;
mtype = alloc_type (TYPE_OBJFILE (to_type)); mtype = alloc_type_copy (to_type);
TYPE_TARGET_TYPE (mtype) = to_type; TYPE_TARGET_TYPE (mtype) = to_type;
TYPE_DOMAIN_TYPE (mtype) = TYPE_DOMAIN_TYPE (to_type); TYPE_DOMAIN_TYPE (mtype) = TYPE_DOMAIN_TYPE (to_type);
TYPE_LENGTH (mtype) = cplus_method_ptr_size (to_type); TYPE_LENGTH (mtype) = cplus_method_ptr_size (to_type);
@ -645,8 +691,10 @@ allocate_stub_method (struct type *type)
{ {
struct type *mtype; struct type *mtype;
mtype = init_type (TYPE_CODE_METHOD, 1, TYPE_FLAG_STUB, NULL, mtype = alloc_type_copy (type);
TYPE_OBJFILE (type)); TYPE_CODE (mtype) = TYPE_CODE_METHOD;
TYPE_LENGTH (mtype) = 1;
TYPE_STUB (mtype) = 1;
TYPE_TARGET_TYPE (mtype) = type; TYPE_TARGET_TYPE (mtype) = type;
/* _DOMAIN_TYPE (mtype) = unknown yet */ /* _DOMAIN_TYPE (mtype) = unknown yet */
return mtype; return mtype;
@ -667,7 +715,7 @@ create_range_type (struct type *result_type, struct type *index_type,
int low_bound, int high_bound) int low_bound, int high_bound)
{ {
if (result_type == NULL) 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_CODE (result_type) = TYPE_CODE_RANGE;
TYPE_TARGET_TYPE (result_type) = index_type; TYPE_TARGET_TYPE (result_type) = index_type;
if (TYPE_STUB (index_type)) if (TYPE_STUB (index_type))
@ -775,9 +823,8 @@ create_array_type (struct type *result_type,
LONGEST low_bound, high_bound; LONGEST low_bound, high_bound;
if (result_type == NULL) if (result_type == NULL)
{ result_type = alloc_type_copy (range_type);
result_type = alloc_type (TYPE_OBJFILE (range_type));
}
TYPE_CODE (result_type) = TYPE_CODE_ARRAY; TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
TYPE_TARGET_TYPE (result_type) = element_type; TYPE_TARGET_TYPE (result_type) = element_type;
if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0) 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) create_set_type (struct type *result_type, struct type *domain_type)
{ {
if (result_type == NULL) if (result_type == NULL)
{ result_type = alloc_type_copy (domain_type);
result_type = alloc_type (TYPE_OBJFILE (domain_type));
}
TYPE_CODE (result_type) = TYPE_CODE_SET; TYPE_CODE (result_type) = TYPE_CODE_SET;
TYPE_NFIELDS (result_type) = 1; TYPE_NFIELDS (result_type) = 1;
TYPE_FIELDS (result_type) = TYPE_ZALLOC (result_type, sizeof (struct field)); 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; 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 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
and any array types nested inside it. */ and any array types nested inside it. */
@ -960,12 +973,7 @@ void
smash_to_memberptr_type (struct type *type, struct type *domain, smash_to_memberptr_type (struct type *type, struct type *domain,
struct type *to_type) struct type *to_type)
{ {
struct objfile *objfile;
objfile = TYPE_OBJFILE (type);
smash_type (type); smash_type (type);
TYPE_OBJFILE (type) = objfile;
TYPE_TARGET_TYPE (type) = to_type; TYPE_TARGET_TYPE (type) = to_type;
TYPE_DOMAIN_TYPE (type) = domain; TYPE_DOMAIN_TYPE (type) = domain;
/* Assume that a data member pointer is the same size as a normal /* 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, struct type *to_type, struct field *args,
int nargs, int varargs) int nargs, int varargs)
{ {
struct objfile *objfile;
objfile = TYPE_OBJFILE (type);
smash_type (type); smash_type (type);
TYPE_OBJFILE (type) = objfile;
TYPE_TARGET_TYPE (type) = to_type; TYPE_TARGET_TYPE (type) = to_type;
TYPE_DOMAIN_TYPE (type) = domain; TYPE_DOMAIN_TYPE (type) = domain;
TYPE_FIELDS (type) = args; TYPE_FIELDS (type) = args;
@ -1380,7 +1383,7 @@ check_typedef (struct type *type)
if (sym) if (sym)
TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym); TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
else /* TYPE_CODE_UNDEF */ 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); type = TYPE_TARGET_TYPE (type);
} }
@ -1702,11 +1705,10 @@ allocate_cplus_struct_type (struct type *type)
/* Helper function to initialize the standard scalar types. /* Helper function to initialize the standard scalar types.
If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy of If NAME is non-NULL, then we make a copy of the string pointed
the string pointed to by name in the objfile_obstack for that to by name in the objfile_obstack for that objfile, and initialize
objfile, and initialize the type name to that copy. There are the type name to that copy. There are places (mipsread.c in particular),
places (mipsread.c in particular, where init_type is called with a where init_type is called with a NULL value for NAME). */
NULL value for NAME). */
struct type * struct type *
init_type (enum type_code code, int length, int flags, 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) if (flags & TYPE_FLAG_FIXED_INSTANCE)
TYPE_FIXED_INSTANCE (type) = 1; TYPE_FIXED_INSTANCE (type) = 1;
if ((name != NULL) && (objfile != NULL)) if (name)
{ TYPE_NAME (type) = obsavestring (name, strlen (name),
TYPE_NAME (type) = obsavestring (name, strlen (name), &objfile->objfile_obstack);
&objfile->objfile_obstack);
}
else
{
TYPE_NAME (type) = name;
}
/* C++ fancies. */ /* C++ fancies. */
@ -1767,67 +1763,6 @@ init_type (enum type_code code, int length, int flags,
return type; 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 int
can_dereference (struct type *t) can_dereference (struct type *t)
{ {
@ -2671,8 +2606,16 @@ recursive_dump_type (struct type *type, int spaces)
} }
puts_filtered ("\n"); puts_filtered ("\n");
printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type)); printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
printfi_filtered (spaces, "objfile "); if (TYPE_OBJFILE_OWNED (type))
gdb_print_host_address (TYPE_OBJFILE (type), gdb_stdout); {
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"); printf_filtered ("\n");
printfi_filtered (spaces, "target_type "); printfi_filtered (spaces, "target_type ");
gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout); gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
@ -2903,7 +2846,7 @@ copy_type_recursive (struct objfile *objfile,
void **slot; void **slot;
struct type *new_type; struct type *new_type;
if (TYPE_OBJFILE (type) == NULL) if (! TYPE_OBJFILE_OWNED (type))
return type; return type;
/* This type shouldn't be pointing to any types in other objfiles; /* 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) if (*slot != NULL)
return ((struct type_pair *) *slot)->new; 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 must add the new type to the hash table immediately, in case
we encounter this type again during a recursive call below. */ 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 common fields of types. For the main type, we simply
copy the entire thing and then update specific fields as needed. */ copy the entire thing and then update specific fields as needed. */
*TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type); *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)) if (TYPE_NAME (type))
TYPE_NAME (new_type) = xstrdup (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; 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_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
TYPE_LENGTH (new_type) = TYPE_LENGTH (type); TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type), memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
@ -3029,8 +2973,84 @@ copy_type (const struct type *type)
return new_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 * struct type *
init_float_type (int bit, char *name, const struct floatformat **floatformats) 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 *
arch_float_type (struct gdbarch *gdbarch,
int bit, char *name, const struct floatformat **floatformats)
{ {
struct type *t; struct type *t;
@ -3042,21 +3062,124 @@ init_float_type (int bit, char *name, const struct floatformat **floatformats)
} }
gdb_assert (bit >= 0); 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; TYPE_FLOATFORMAT (t) = floatformats;
return t; 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 * 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; struct type *t;
t = init_type (TYPE_CODE_COMPLEX, 2 * TYPE_LENGTH (target_type), t = arch_type (gdbarch, TYPE_CODE_COMPLEX,
0, name, (struct objfile *) NULL); 2 * TYPE_LENGTH (target_type), name);
TYPE_TARGET_TYPE (t) = target_type; TYPE_TARGET_TYPE (t) = target_type;
return t; 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; static struct gdbarch_data *gdbtypes_data;
const struct builtin_type * const struct builtin_type *
@ -3072,162 +3195,112 @@ gdbtypes_post_init (struct gdbarch *gdbarch)
= GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type); = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
/* Basic types. */ /* Basic types. */
builtin_type->builtin_void = builtin_type->builtin_void
init_type (TYPE_CODE_VOID, 1, = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
0, builtin_type->builtin_char
"void", (struct objfile *) NULL); = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
builtin_type->builtin_char = !gdbarch_char_signed (gdbarch), "char");
init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, builtin_type->builtin_signed_char
(TYPE_FLAG_NOSIGN = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
| (gdbarch_char_signed (gdbarch) ? 0 : TYPE_FLAG_UNSIGNED)), 0, "signed char");
"char", (struct objfile *) NULL); builtin_type->builtin_unsigned_char
builtin_type->builtin_signed_char = = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, 1, "unsigned char");
0, builtin_type->builtin_short
"signed char", (struct objfile *) NULL); = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
builtin_type->builtin_unsigned_char = 0, "short");
init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, builtin_type->builtin_unsigned_short
TYPE_FLAG_UNSIGNED, = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
"unsigned char", (struct objfile *) NULL); 1, "unsigned short");
builtin_type->builtin_short = builtin_type->builtin_int
init_type (TYPE_CODE_INT, = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, 0, "int");
0, "short", (struct objfile *) NULL); builtin_type->builtin_unsigned_int
builtin_type->builtin_unsigned_short = = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
init_type (TYPE_CODE_INT, 1, "unsigned int");
gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, builtin_type->builtin_long
TYPE_FLAG_UNSIGNED, "unsigned short", = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
(struct objfile *) NULL); 0, "long");
builtin_type->builtin_int = builtin_type->builtin_unsigned_long
init_type (TYPE_CODE_INT, = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, 1, "unsigned long");
0, "int", (struct objfile *) NULL); builtin_type->builtin_long_long
builtin_type->builtin_unsigned_int = = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
init_type (TYPE_CODE_INT, 0, "long long");
gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, builtin_type->builtin_unsigned_long_long
TYPE_FLAG_UNSIGNED, "unsigned int", = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
(struct objfile *) NULL); 1, "unsigned long long");
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_float builtin_type->builtin_float
= init_float_type (gdbarch_float_bit (gdbarch), = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
"float", gdbarch_float_format (gdbarch)); "float", gdbarch_float_format (gdbarch));
builtin_type->builtin_double builtin_type->builtin_double
= init_float_type (gdbarch_double_bit (gdbarch), = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
"double", gdbarch_double_format (gdbarch)); "double", gdbarch_double_format (gdbarch));
builtin_type->builtin_long_double 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)); "long double", gdbarch_long_double_format (gdbarch));
builtin_type->builtin_complex 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 builtin_type->builtin_double_complex
= init_complex_type ("double complex", builtin_type->builtin_double); = arch_complex_type (gdbarch, "double complex",
builtin_type->builtin_string = builtin_type->builtin_double);
init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT, builtin_type->builtin_string
0, = arch_type (gdbarch, TYPE_CODE_STRING, 1, "string");
"string", (struct objfile *) NULL); builtin_type->builtin_bool
builtin_type->builtin_bool = = arch_type (gdbarch, TYPE_CODE_BOOL, 1, "bool");
init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
0,
"bool", (struct objfile *) NULL);
/* The following three are about decimal floating point types, which /* The following three are about decimal floating point types, which
are 32-bits, 64-bits and 128-bits respectively. */ are 32-bits, 64-bits and 128-bits respectively. */
builtin_type->builtin_decfloat builtin_type->builtin_decfloat
= init_type (TYPE_CODE_DECFLOAT, 32 / 8, = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 32 / 8, "_Decimal32");
0,
"_Decimal32", (struct objfile *) NULL);
builtin_type->builtin_decdouble builtin_type->builtin_decdouble
= init_type (TYPE_CODE_DECFLOAT, 64 / 8, = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 64 / 8, "_Decimal64");
0,
"_Decimal64", (struct objfile *) NULL);
builtin_type->builtin_declong builtin_type->builtin_declong
= init_type (TYPE_CODE_DECFLOAT, 128 / 8, = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 128 / 8, "_Decimal128");
0,
"_Decimal128", (struct objfile *) NULL);
/* "True" character types. */ /* "True" character types. */
builtin_type->builtin_true_char = builtin_type->builtin_true_char
init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT, = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "true character");
0, builtin_type->builtin_true_unsigned_char
"true character", (struct objfile *) NULL); = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "true character");
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);
/* Fixed-size integer types. */ /* Fixed-size integer types. */
builtin_type->builtin_int0 = builtin_type->builtin_int0
init_type (TYPE_CODE_INT, 0 / 8, = arch_integer_type (gdbarch, 0, 0, "int0_t");
0, builtin_type->builtin_int8
"int0_t", (struct objfile *) NULL); = arch_integer_type (gdbarch, 8, 0, "int8_t");
builtin_type->builtin_int8 = builtin_type->builtin_uint8
init_type (TYPE_CODE_INT, 8 / 8, = arch_integer_type (gdbarch, 8, 1, "uint8_t");
TYPE_FLAG_NOTTEXT, builtin_type->builtin_int16
"int8_t", (struct objfile *) NULL); = arch_integer_type (gdbarch, 16, 0, "int16_t");
builtin_type->builtin_uint8 = builtin_type->builtin_uint16
init_type (TYPE_CODE_INT, 8 / 8, = arch_integer_type (gdbarch, 16, 1, "uint16_t");
TYPE_FLAG_UNSIGNED | TYPE_FLAG_NOTTEXT, builtin_type->builtin_int32
"uint8_t", (struct objfile *) NULL); = arch_integer_type (gdbarch, 32, 0, "int32_t");
builtin_type->builtin_int16 = builtin_type->builtin_uint32
init_type (TYPE_CODE_INT, 16 / 8, = arch_integer_type (gdbarch, 32, 1, "uint32_t");
0, builtin_type->builtin_int64
"int16_t", (struct objfile *) NULL); = arch_integer_type (gdbarch, 64, 0, "int64_t");
builtin_type->builtin_uint16 = builtin_type->builtin_uint64
init_type (TYPE_CODE_INT, 16 / 8, = arch_integer_type (gdbarch, 64, 1, "uint64_t");
TYPE_FLAG_UNSIGNED, builtin_type->builtin_int128
"uint16_t", (struct objfile *) NULL); = arch_integer_type (gdbarch, 128, 0, "int128_t");
builtin_type->builtin_int32 = builtin_type->builtin_uint128
init_type (TYPE_CODE_INT, 32 / 8, = arch_integer_type (gdbarch, 128, 1, "uint128_t");
0, TYPE_NOTTEXT (builtin_type->builtin_int8) = 1;
"int32_t", (struct objfile *) NULL); TYPE_NOTTEXT (builtin_type->builtin_uint8) = 1;
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);
/* Default data/code pointer types. */ /* Default data/code pointer types. */
builtin_type->builtin_data_ptr = builtin_type->builtin_data_ptr
make_pointer_type (builtin_type->builtin_void, NULL); = lookup_pointer_type (builtin_type->builtin_void);
builtin_type->builtin_func_ptr = builtin_type->builtin_func_ptr
lookup_pointer_type (lookup_function_type (builtin_type->builtin_void)); = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
/* This type represents a GDB internal function. */ /* This type represents a GDB internal function. */
builtin_type->internal_fn = builtin_type->internal_fn
init_type (TYPE_CODE_INTERNAL_FUNCTION, 0, 0, = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0,
"<internal function>", NULL); "<internal function>");
return builtin_type; return builtin_type;
} }

56
gdb/gdbtypes.h
View file

@ -270,6 +270,14 @@ enum type_instance_flag_value
#define TYPE_NOTTEXT(t) (TYPE_MAIN_TYPE (t)->flag_nottext) #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 /* Constant type. If this is set, the corresponding type has a
* const modifier. * const modifier.
*/ */
@ -356,6 +364,7 @@ struct main_type
unsigned int flag_stub_supported : 1; unsigned int flag_stub_supported : 1;
unsigned int flag_nottext : 1; unsigned int flag_nottext : 1;
unsigned int flag_fixed_instance : 1; unsigned int flag_fixed_instance : 1;
unsigned int flag_objfile_owned : 1;
/* Number of fields described for this type. This field appears at /* Number of fields described for this type. This field appears at
this location because it packs nicely here. */ 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 major overhaul of the internal type system, it can't be avoided
for now. */ 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 a pointer type, describes the type of object pointed to.
For an array type, describes the type of the elements. 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 so you only have to call check_typedef once. Since allocate_value
calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe. */ calls check_typedef, TYPE_LENGTH (VALUE_TYPE (X)) is safe. */
#define TYPE_LENGTH(thistype) (thistype)->length #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 /* 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)). */ type, you need to do TYPE_CODE (check_type (this_type)). */
#define TYPE_CODE(thistype) TYPE_MAIN_TYPE(thistype)->code #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. */ the same as for the type structure. */
#define TYPE_ALLOC(t,size) \ #define TYPE_ALLOC(t,size) \
(TYPE_OBJFILE (t) != NULL \ (TYPE_OBJFILE_OWNED (t) \
? obstack_alloc (&TYPE_OBJFILE (t) -> objfile_obstack, size) \ ? obstack_alloc (&TYPE_OBJFILE (t) -> objfile_obstack, size) \
: xmalloc (size)) : xmalloc (size))
#define TYPE_ZALLOC(t,size) \ #define TYPE_ZALLOC(t,size) \
(TYPE_OBJFILE (t) != NULL \ (TYPE_OBJFILE_OWNED (t) \
? memset (obstack_alloc (&TYPE_OBJFILE (t)->objfile_obstack, size), \ ? memset (obstack_alloc (&TYPE_OBJFILE (t)->objfile_obstack, size), \
0, size) \ 0, size) \
: xzalloc (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 (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 *, extern struct type *init_type (enum type_code, int, int, char *,
struct objfile *); 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 /* 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 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 type has its size set to the largest field. A struct type has each
field packed against the previous. */ 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, extern void append_composite_type_field (struct type *t, char *name,
struct type *field); struct type *field);
extern void append_composite_type_field_aligned (struct type *t, 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); int alignment);
/* Helper functions to construct a bit flags type. An initially empty /* 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(). */ 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 append_flags_type_flag (struct type *type, int bitpos, char *name);
extern void make_vector_type (struct type *array_type); 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_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 *lookup_reference_type (struct type *);
extern struct type *make_reference_type (struct type *, struct type **); extern struct type *make_reference_type (struct type *, struct type **);

7
gdb/gnu-v3-abi.c
View file

@ -128,9 +128,7 @@ build_gdb_vtable_type (struct gdbarch *arch)
/* ARCH can't give us the true ptrdiff_t type, so we guess. */ /* ARCH can't give us the true ptrdiff_t type, so we guess. */
struct type *ptrdiff_type struct type *ptrdiff_type
= init_type (TYPE_CODE_INT, = arch_integer_type (arch, gdbarch_ptr_bit (arch), 0, "ptrdiff_t");
gdbarch_ptr_bit (arch) / TARGET_CHAR_BIT, 0,
"ptrdiff_t", 0);
/* We assume no padding is necessary, since GDB doesn't know /* We assume no padding is necessary, since GDB doesn't know
anything about alignment at the moment. If this assumption bites 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. */ /* We assumed in the allocation above that there were four fields. */
gdb_assert (field == (field_list + 4)); 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_NFIELDS (t) = field - field_list;
TYPE_FIELDS (t) = field_list; TYPE_FIELDS (t) = field_list;
TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable"; TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable";
INIT_CPLUS_SPECIFIC (t);
return t; return t;
} }

12
gdb/i386-tdep.c
View file

@ -2004,7 +2004,7 @@ i386_eflags_type (struct gdbarch *gdbarch)
{ {
struct type *type; 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, 0, "CF");
append_flags_type_flag (type, 1, NULL); append_flags_type_flag (type, 1, NULL);
append_flags_type_flag (type, 2, "PF"); append_flags_type_flag (type, 2, "PF");
@ -2038,7 +2038,7 @@ i386_mxcsr_type (struct gdbarch *gdbarch)
{ {
struct type *type; 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, 0, "IE");
append_flags_type_flag (type, 1, "DE"); append_flags_type_flag (type, 1, "DE");
append_flags_type_flag (type, 2, "ZE"); append_flags_type_flag (type, 2, "ZE");
@ -2067,7 +2067,7 @@ i387_ext_type (struct gdbarch *gdbarch)
if (!tdep->i387_ext_type) if (!tdep->i387_ext_type)
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); floatformats_i387_ext);
return tdep->i387_ext_type; return tdep->i387_ext_type;
@ -2096,7 +2096,8 @@ i386_mmx_type (struct gdbarch *gdbarch)
struct type *t; 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, "uint64", bt->builtin_int64);
append_composite_type_field (t, "v2_int32", append_composite_type_field (t, "v2_int32",
@ -2139,7 +2140,8 @@ i386_sse_type (struct gdbarch *gdbarch)
struct type *t; 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", append_composite_type_field (t, "v4_float",
init_vector_type (bt->builtin_float, 4)); init_vector_type (bt->builtin_float, 4));
append_composite_type_field (t, "v2_double", append_composite_type_field (t, "v2_double",

2
gdb/ia64-tdep.c
View file

@ -303,7 +303,7 @@ ia64_ext_type (struct gdbarch *gdbarch)
if (!tdep->ia64_ext_type) if (!tdep->ia64_ext_type)
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); floatformats_ia64_ext);
return tdep->ia64_ext_type; return tdep->ia64_ext_type;

20
gdb/jv-lang.c
View file

@ -296,7 +296,7 @@ type_from_class (struct gdbarch *gdbarch, struct value *clas)
/* Do not use the "fake" dynamics objfile to own dynamically generated /* Do not use the "fake" dynamics objfile to own dynamically generated
types, as it does not provide an architecture, and it would not help types, as it does not provide an architecture, and it would not help
manage the lifetime of these types anyway. */ manage the lifetime of these types anyway. */
type = alloc_type (NULL); type = alloc_type_arch (gdbarch);
TYPE_CODE (type) = TYPE_CODE_STRUCT; TYPE_CODE (type) = TYPE_CODE_STRUCT;
INIT_CPLUS_SPECIFIC (type); INIT_CPLUS_SPECIFIC (type);
@ -1170,23 +1170,23 @@ build_java_types (struct gdbarch *gdbarch)
= GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_java_type); = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_java_type);
builtin_java_type->builtin_int 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 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 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 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 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 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 builtin_java_type->builtin_float
= init_float_type (32, "float", NULL); = arch_float_type (gdbarch, 32, "float", NULL);
builtin_java_type->builtin_double builtin_java_type->builtin_double
= init_float_type (64, "double", NULL); = arch_float_type (gdbarch, 64, "double", NULL);
builtin_java_type->builtin_void 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; return builtin_java_type;
} }

51
gdb/linux-tdep.c
View file

@ -33,43 +33,40 @@ linux_get_siginfo_type (struct gdbarch *gdbarch)
struct type *siginfo_type, *sifields_type; struct type *siginfo_type, *sifields_type;
struct type *type; struct type *type;
int_type = init_type (TYPE_CODE_INT, int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0, "int");
0, "int", NULL); uint_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
uint_type = init_type (TYPE_CODE_INT, 1, "unsigned int");
gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
0, "unsigned int", NULL); 0, "long");
long_type = init_type (TYPE_CODE_INT,
gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT,
0, "long", NULL);
void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void); void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
/* sival_t */ /* 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"); TYPE_NAME (sigval_type) = xstrdup ("sigval_t");
append_composite_type_field (sigval_type, "sival_int", int_type); append_composite_type_field (sigval_type, "sival_int", int_type);
append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type); append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
/* __pid_t */ /* __pid_t */
pid_type = init_type (TYPE_CODE_TYPEDEF, TYPE_LENGTH (int_type), pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF, TYPE_LENGTH (int_type),
TYPE_FLAG_TARGET_STUB, NULL, NULL); xstrdup ("__pid_t"));
TYPE_NAME (pid_type) = xstrdup ("__pid_t");
TYPE_TARGET_TYPE (pid_type) = int_type; TYPE_TARGET_TYPE (pid_type) = int_type;
TYPE_TARGET_STUB (pid_type) = 1;
/* __uid_t */ /* __uid_t */
uid_type = init_type (TYPE_CODE_TYPEDEF, TYPE_LENGTH (uint_type), uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF, TYPE_LENGTH (uint_type),
TYPE_FLAG_TARGET_STUB, NULL, NULL); xstrdup ("__uid_t"));
TYPE_NAME (uid_type) = xstrdup ("__uid_t");
TYPE_TARGET_TYPE (uid_type) = uint_type; TYPE_TARGET_TYPE (uid_type) = uint_type;
TYPE_TARGET_STUB (uid_type) = 1;
/* __clock_t */ /* __clock_t */
clock_type = init_type (TYPE_CODE_TYPEDEF, TYPE_LENGTH (long_type), clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF, TYPE_LENGTH (long_type),
TYPE_FLAG_TARGET_STUB, NULL, NULL); xstrdup ("__clock_t"));
TYPE_NAME (clock_type) = xstrdup ("__clock_t");
TYPE_TARGET_TYPE (clock_type) = long_type; TYPE_TARGET_TYPE (clock_type) = long_type;
TYPE_TARGET_STUB (clock_type) = 1;
/* _sifields */ /* _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; const int si_max_size = 128;
@ -86,27 +83,27 @@ linux_get_siginfo_type (struct gdbarch *gdbarch)
} }
/* _kill */ /* _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_pid", pid_type);
append_composite_type_field (type, "si_uid", uid_type); append_composite_type_field (type, "si_uid", uid_type);
append_composite_type_field (sifields_type, "_kill", type); append_composite_type_field (sifields_type, "_kill", type);
/* _timer */ /* _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_tid", int_type);
append_composite_type_field (type, "si_overrun", int_type); append_composite_type_field (type, "si_overrun", int_type);
append_composite_type_field (type, "si_sigval", sigval_type); append_composite_type_field (type, "si_sigval", sigval_type);
append_composite_type_field (sifields_type, "_timer", type); append_composite_type_field (sifields_type, "_timer", type);
/* _rt */ /* _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_pid", pid_type);
append_composite_type_field (type, "si_uid", uid_type); append_composite_type_field (type, "si_uid", uid_type);
append_composite_type_field (type, "si_sigval", sigval_type); append_composite_type_field (type, "si_sigval", sigval_type);
append_composite_type_field (sifields_type, "_rt", type); append_composite_type_field (sifields_type, "_rt", type);
/* _sigchld */ /* _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_pid", pid_type);
append_composite_type_field (type, "si_uid", uid_type); append_composite_type_field (type, "si_uid", uid_type);
append_composite_type_field (type, "si_status", int_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); append_composite_type_field (sifields_type, "_sigchld", type);
/* _sigfault */ /* _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 (type, "si_addr", void_ptr_type);
append_composite_type_field (sifields_type, "_sigfault", type); append_composite_type_field (sifields_type, "_sigfault", type);
/* _sigpoll */ /* _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_band", long_type);
append_composite_type_field (type, "si_fd", int_type); append_composite_type_field (type, "si_fd", int_type);
append_composite_type_field (sifields_type, "_sigpoll", type); append_composite_type_field (sifields_type, "_sigpoll", type);
/* struct siginfo */ /* 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"); TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
append_composite_type_field (siginfo_type, "si_signo", int_type); append_composite_type_field (siginfo_type, "si_signo", int_type);
append_composite_type_field (siginfo_type, "si_errno", int_type); append_composite_type_field (siginfo_type, "si_errno", int_type);

30
gdb/m2-lang.c
View file

@ -406,26 +406,16 @@ build_m2_types (struct gdbarch *gdbarch)
= GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_m2_type); = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_m2_type);
/* Modula-2 "pervasive" types. NOTE: these can be redefined!!! */ /* Modula-2 "pervasive" types. NOTE: these can be redefined!!! */
builtin_m2_type->builtin_int = builtin_m2_type->builtin_int
init_type (TYPE_CODE_INT, = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 0, "INTEGER");
gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, builtin_m2_type->builtin_card
0, "INTEGER", (struct objfile *) NULL); = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "CARDINAL");
builtin_m2_type->builtin_card = builtin_m2_type->builtin_real
init_type (TYPE_CODE_INT, = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), "REAL", NULL);
gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, builtin_m2_type->builtin_char
TYPE_FLAG_UNSIGNED, = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "CHAR");
"CARDINAL", (struct objfile *) NULL); builtin_m2_type->builtin_bool
builtin_m2_type->builtin_real = = arch_boolean_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "BOOLEAN");
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);
return builtin_m2_type; return builtin_m2_type;
} }

29
gdb/m32c-tdep.c
View file

@ -192,34 +192,33 @@ make_types (struct gdbarch *arch)
/* The builtin_type_mumble variables are sometimes uninitialized when /* The builtin_type_mumble variables are sometimes uninitialized when
this is called, so we avoid using them. */ this is called, so we avoid using them. */
tdep->voyd = init_type (TYPE_CODE_VOID, 1, 0, "void", NULL); tdep->voyd = arch_type (arch, TYPE_CODE_VOID, 1, "void");
tdep->ptr_voyd = init_type (TYPE_CODE_PTR, gdbarch_ptr_bit (arch) / 8, tdep->ptr_voyd
TYPE_FLAG_UNSIGNED, NULL, NULL); = arch_type (arch, TYPE_CODE_PTR, gdbarch_ptr_bit (arch), NULL);
TYPE_TARGET_TYPE (tdep->ptr_voyd) = tdep->voyd; TYPE_TARGET_TYPE (tdep->ptr_voyd) = tdep->voyd;
TYPE_UNSIGNED (tdep->ptr_voyd) = 1;
tdep->func_voyd = lookup_function_type (tdep->voyd); tdep->func_voyd = lookup_function_type (tdep->voyd);
sprintf (type_name, "%s_data_addr_t", sprintf (type_name, "%s_data_addr_t",
gdbarch_bfd_arch_info (arch)->printable_name); gdbarch_bfd_arch_info (arch)->printable_name);
tdep->data_addr_reg_type tdep->data_addr_reg_type
= init_type (TYPE_CODE_PTR, data_addr_reg_bits / 8, = arch_type (arch, TYPE_CODE_PTR, data_addr_reg_bits, xstrdup (type_name));
TYPE_FLAG_UNSIGNED, xstrdup (type_name), NULL);
TYPE_TARGET_TYPE (tdep->data_addr_reg_type) = tdep->voyd; 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", sprintf (type_name, "%s_code_addr_t",
gdbarch_bfd_arch_info (arch)->printable_name); gdbarch_bfd_arch_info (arch)->printable_name);
tdep->code_addr_reg_type tdep->code_addr_reg_type
= init_type (TYPE_CODE_PTR, code_addr_reg_bits / 8, = arch_type (arch, TYPE_CODE_PTR, code_addr_reg_bits, xstrdup (type_name));
TYPE_FLAG_UNSIGNED, xstrdup (type_name), NULL);
TYPE_TARGET_TYPE (tdep->code_addr_reg_type) = tdep->func_voyd; TYPE_TARGET_TYPE (tdep->code_addr_reg_type) = tdep->func_voyd;
TYPE_UNSIGNED (tdep->code_addr_reg_type) = 1;
tdep->uint8 = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED, tdep->uint8 = arch_integer_type (arch, 8, 1, "uint8_t");
"uint8_t", NULL); tdep->uint16 = arch_integer_type (arch, 16, 1, "uint16_t");
tdep->uint16 = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED, tdep->int8 = arch_integer_type (arch, 8, 0, "int8_t");
"uint16_t", NULL); tdep->int16 = arch_integer_type (arch, 16, 0, "int16_t");
tdep->int8 = init_type (TYPE_CODE_INT, 1, 0, "int8_t", NULL); tdep->int32 = arch_integer_type (arch, 32, 0, "int32_t");
tdep->int16 = init_type (TYPE_CODE_INT, 2, 0, "int16_t", NULL); tdep->int64 = arch_integer_type (arch, 64, 0, "int64_t");
tdep->int32 = init_type (TYPE_CODE_INT, 4, 0, "int32_t", NULL);
tdep->int64 = init_type (TYPE_CODE_INT, 8, 0, "int64_t", NULL);
} }

4
gdb/m68k-tdep.c
View file

@ -81,7 +81,7 @@ m68k_ps_type (struct gdbarch *gdbarch)
{ {
struct type *type; 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, 0, "C");
append_flags_type_flag (type, 1, "V"); append_flags_type_flag (type, 1, "V");
append_flags_type_flag (type, 2, "Z"); append_flags_type_flag (type, 2, "Z");
@ -108,7 +108,7 @@ m68881_ext_type (struct gdbarch *gdbarch)
if (!tdep->m68881_ext_type) if (!tdep->m68881_ext_type)
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); floatformats_m68881_ext);
return tdep->m68881_ext_type; return tdep->m68881_ext_type;

6
gdb/rs6000-tdep.c
View file

@ -2264,7 +2264,8 @@ rs6000_builtin_type_vec64 (struct gdbarch *gdbarch)
struct type *t; 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, "uint64", bt->builtin_int64);
append_composite_type_field (t, "v2_float", append_composite_type_field (t, "v2_float",
init_vector_type (bt->builtin_float, 2)); init_vector_type (bt->builtin_float, 2));
@ -2307,7 +2308,8 @@ rs6000_builtin_type_vec128 (struct gdbarch *gdbarch)
struct type *t; 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, "uint128", bt->builtin_uint128);
append_composite_type_field (t, "v4_float", append_composite_type_field (t, "v4_float",
init_vector_type (bt->builtin_float, 4)); init_vector_type (bt->builtin_float, 4));

6
gdb/scm-lang.c
View file

@ -278,10 +278,8 @@ build_scm_types (struct gdbarch *gdbarch)
struct builtin_scm_type *builtin_scm_type struct builtin_scm_type *builtin_scm_type
= GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_scm_type); = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_scm_type);
builtin_scm_type->builtin_scm = builtin_scm_type->builtin_scm
init_type (TYPE_CODE_INT, = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 0, "SCM");
gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
0, "SCM", (struct objfile *) NULL);
return builtin_scm_type; return builtin_scm_type;
} }

4
gdb/sparc-tdep.c
View file

@ -294,7 +294,7 @@ sparc_psr_type (struct gdbarch *gdbarch)
{ {
struct type *type; 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, 5, "ET");
append_flags_type_flag (type, 6, "PS"); append_flags_type_flag (type, 6, "PS");
append_flags_type_flag (type, 7, "S"); append_flags_type_flag (type, 7, "S");
@ -316,7 +316,7 @@ sparc_fsr_type (struct gdbarch *gdbarch)
{ {
struct type *type; 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, 0, "NXA");
append_flags_type_flag (type, 1, "DZA"); append_flags_type_flag (type, 1, "DZA");
append_flags_type_flag (type, 2, "UFA"); append_flags_type_flag (type, 2, "UFA");

6
gdb/sparc64-tdep.c
View file

@ -132,7 +132,7 @@ sparc64_pstate_type (struct gdbarch *gdbarch)
{ {
struct type *type; 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, 0, "AG");
append_flags_type_flag (type, 1, "IE"); append_flags_type_flag (type, 1, "IE");
append_flags_type_flag (type, 2, "PRIV"); append_flags_type_flag (type, 2, "PRIV");
@ -159,7 +159,7 @@ sparc64_fsr_type (struct gdbarch *gdbarch)
{ {
struct type *type; 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, 0, "NXA");
append_flags_type_flag (type, 1, "DZA"); append_flags_type_flag (type, 1, "DZA");
append_flags_type_flag (type, 2, "UFA"); append_flags_type_flag (type, 2, "UFA");
@ -192,7 +192,7 @@ sparc64_fprs_type (struct gdbarch *gdbarch)
{ {
struct type *type; 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, 0, "DL");
append_flags_type_flag (type, 1, "DU"); append_flags_type_flag (type, 1, "DU");
append_flags_type_flag (type, 2, "FEF"); append_flags_type_flag (type, 2, "FEF");

3
gdb/spu-tdep.c
View file

@ -64,7 +64,8 @@ spu_builtin_type_vec128 (struct gdbarch *gdbarch)
const struct builtin_type *bt = builtin_type (gdbarch); const struct builtin_type *bt = builtin_type (gdbarch);
struct type *t; 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, "uint128", bt->builtin_int128);
append_composite_type_field (t, "v2_int64", append_composite_type_field (t, "v2_int64",
init_vector_type (bt->builtin_int64, 2)); init_vector_type (bt->builtin_int64, 2));

8
gdb/target-descriptions.c
View file

@ -488,15 +488,15 @@ tdesc_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *tdesc_type)
return builtin_type (gdbarch)->builtin_data_ptr; return builtin_type (gdbarch)->builtin_data_ptr;
case TDESC_TYPE_IEEE_SINGLE: 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); floatformats_ieee_single);
case TDESC_TYPE_IEEE_DOUBLE: 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); floatformats_ieee_double);
case TDESC_TYPE_ARM_FPA_EXT: 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); floatformats_arm_ext);
/* Types defined by a target feature. */ /* 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; struct tdesc_type_field *f;
int ix; 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); TYPE_NAME (type) = xstrdup (tdesc_type->name);
for (ix = 0; for (ix = 0;

5
gdb/xtensa-tdep.c
View file

@ -281,9 +281,8 @@ xtensa_register_type (struct gdbarch *gdbarch, int regnum)
tp->size = size; tp->size = size;
sprintf (name, "int%d", size * 8); sprintf (name, "int%d", size * 8);
tp->virtual_type = init_type (TYPE_CODE_INT, size, tp->virtual_type
TYPE_FLAG_UNSIGNED, name, = arch_integer_type (gdbarch, size * 8, 1, xstrdup (name));
NULL);
} }
reg->ctype = tp->virtual_type; reg->ctype = tp->virtual_type;