* 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.

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;