aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--gdb/ChangeLog95
-rw-r--r--gdb/ada-lang.c107
-rw-r--r--gdb/arm-tdep.c2
-rw-r--r--gdb/f-lang.c98
-rw-r--r--gdb/gdbtypes.c687
-rw-r--r--gdb/gdbtypes.h56
-rw-r--r--gdb/gnu-v3-abi.c7
-rw-r--r--gdb/i386-tdep.c12
-rw-r--r--gdb/ia64-tdep.c2
-rw-r--r--gdb/jv-lang.c20
-rw-r--r--gdb/linux-tdep.c51
-rw-r--r--gdb/m2-lang.c30
-rw-r--r--gdb/m32c-tdep.c31
-rw-r--r--gdb/m68k-tdep.c4
-rw-r--r--gdb/rs6000-tdep.c6
-rw-r--r--gdb/scm-lang.c6
-rw-r--r--gdb/sparc-tdep.c4
-rw-r--r--gdb/sparc64-tdep.c6
-rw-r--r--gdb/spu-tdep.c3
-rw-r--r--gdb/target-descriptions.c8
-rw-r--r--gdb/xtensa-tdep.c5
21 files changed, 704 insertions, 536 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index f95d74b..8bead7a 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,100 @@
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>
+
* i386-tdep.h (struct gdbarch_tdep): Add i386_eflags_type and
i386_mxcsr_type members.
(i386_eflags_type): Make into function.
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index d5078ce..4185c4f 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 e0a92a5..20f0aab 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 7adb48b..19c1316 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 307ec02..da2db2e 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,
- "<internal function>", NULL);
+ builtin_type->internal_fn
+ = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0,
+ "<internal function>");
return builtin_type;
}
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index e7b6272..9d83bb3 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 cc90c01..09c8e69 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 a5b1b49..6b7560f 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 6919650..d5daf50 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 c885ec7..e1b6817 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 e18e134..37770f5 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 1421149..88c7e5e 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 a833ef4..b67169f 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 0c551c6..213431f 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 00b42d0..36097e6 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 66f293b..bc37c6f 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 f6dbf3f..2b87d77 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 acfbace..47171a4 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 4fa94cc..ac976a5 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 3d0c66b..741ea65 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 7a96577..e81b87e 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;
generated by cgit v1.1 at 2024-11-24 04:03:48 +0000