* gdbtypes.h (TYPE_OBJFILE_OWNED, TYPE_OWNER): New macros.
authorUlrich Weigand <uweigand@de.ibm.com>
Thu, 2 Jul 2009 12:55:30 +0000 (12:55 +0000)
committerUlrich Weigand <uweigand@de.ibm.com>
Thu, 2 Jul 2009 12:55:30 +0000 (12:55 +0000)
(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:
gdb/ChangeLog
gdb/ada-lang.c
gdb/arm-tdep.c
gdb/f-lang.c
gdb/gdbtypes.c
gdb/gdbtypes.h
gdb/gnu-v3-abi.c
gdb/i386-tdep.c
gdb/ia64-tdep.c
gdb/jv-lang.c
gdb/linux-tdep.c
gdb/m2-lang.c
gdb/m32c-tdep.c
gdb/m68k-tdep.c
gdb/rs6000-tdep.c
gdb/scm-lang.c
gdb/sparc-tdep.c
gdb/sparc64-tdep.c
gdb/spu-tdep.c
gdb/target-descriptions.c
gdb/xtensa-tdep.c

index f95d74b7f8a20c7eed70a22170f89e9a5e2eaa3b..8bead7a085610a2d2506be47faaa3c0764372eff 100644 (file)
@@ -1,3 +1,98 @@
+2009-07-02  Ulrich Weigand  <uweigand@de.ibm.com>
+
+       * gdbtypes.h (TYPE_OBJFILE_OWNED, TYPE_OWNER): New macros.
+       (TYPE_OBJFILE, TYPE_ALLOC, TYPE_ZALLOC): Reimplement.
+       (alloc_type_arch): Add prototype.
+       (alloc_type_copy): Likewise.
+       (get_type_arch): Likewise.
+       (arch_type): Likewise.
+       (arch_integer_type): Likewise.
+       (arch_character_type): Likewise.
+       (arch_boolean_type): Likewise.
+       (init_float_type): Remove, replace by ...
+       (arch_float_type): ... this.
+       (init_complex_type): Remove, replace by ...
+       (arch_complex_type): ... this.
+       (init_flags_type): Remove, replace by ...
+       (arch_flags_type): ... this.
+       (init_composite_type): Remove, replace by ...
+       (arch_composite_type): ... this.
+
+       * gdbtypes.c (alloc_type): No longer support NULL objfile.
+       (init_type): Likewise.
+       (alloc_type_arch): New function.
+       (alloc_type_copy): New function.
+       (get_type_arch): New function.
+
+       (smash_type): Preserve type ownership information.
+       (make_pointer_type, make_reference_type, make_function_type,
+       smash_to_memberptr_type, smash_to_method_type): No longer
+       preserve OBJFILE across smash_type calls.
+       (make_pointer_type, make_reference_type, make_function_type,
+       lookup_memberptr_type, lookup_methodptr_type, allocate_stub_method,
+       create_range_type, create_array_type, create_set_type, copy_type):
+       Use alloc_type_copy when allocating types.
+       (check_typedef): Use alloc_type_arch.
+       (copy_type_recursive): Likewise.  Preserve type ownership data
+       after copying type.
+       (recursive_dump_type): Dump type ownership data.
+       (alloc_type_instance): Update type ownership check.
+       (copy_type, copy_type_recursive): Likewise.
+
+       (arch_type): New function.
+       (arch_integer_type): Likewise.
+       (arch_character_type): Likewise.
+       (arch_boolean_type): Likewise.
+       (init_float_type): Remove, replace by ...
+       (arch_float_type): ... this.
+       (init_complex_type): Remove, replace by ...
+       (arch_complex_type): ... this.
+       (init_flags_type): Remove, replace by ...
+       (arch_flags_type): ... this.
+       (append_flags_type_flag): Move down.
+       (init_composite_type): Remove, replace by ...
+       (arch_composite_type): ... this.
+       (append_composite_type_field_aligned,
+       append_composite_type_field): Move down.
+
+       * gdbarch.c (gdbtypes_post_init): Allocate all types
+       using per-architecture routines.
+       * ada-lang.c (ada_language_arch_info): Likewise.
+       * f-lang.c (build_fortran_types): Likewise.
+       * jv-lang.c (build_java_types): Likewise.
+       * m2-lang.c (build_m2_types): Likewise.
+       * scm-lang.c (build_scm_types): Likewise.
+
+       * ada-lang.c (ada_type_of_array): Use alloc_type_copy.
+       (packed_array_type): Likewise.
+       (ada_template_to_fixed_record_type_1): Likewise.
+       (template_to_static_fixed_type): Likewise.
+       (to_record_with_fixed_variant_part): Likewise.
+       (to_fixed_variant_branch_type): Likewise.
+       (to_fixed_array_type): Likewise.
+       (to_fixed_range_type): Likewise.
+       (empty_record): Use type instead of objfile argument.
+       Use alloc_type_copy.
+       (to_fixed_variant_branch_type): Update call to empty_record.
+       * jv-lang.c (type_from_class): Use alloc_type_arch.
+
+       * arm-tdep.c (arm_ext_type): Allocate per-architecture type.
+       * i386-tdep.c (i386_eflags_type, i386_mxcsr_type, i387_ext_type,
+       i386_mmx_type, i386_sse_type): Likewise.
+       * ia64-tdep.c (ia64_ext_type): Likewise.
+       * m32c-tdep.c (make_types): Likewise.
+       * m68k-tdep.c (m68k_ps_type, m68881_ext_type): Likewise.
+       * rs6000-tdep.c (rs6000_builtin_type_vec64,
+       rs6000_builtin_type_vec128): Likewise.
+       * sparc-tdep.c (sparc_psr_type, sparc_fsr_type): Likewise.
+       * sparc64-tdep.c (sparc64_pstate_type, sparc64_fsr_type,
+       sparc64_fprs_type): Likewise.
+       * spu-tdep.c (spu_builtin_type_vec128): Likewise.
+       * xtensa-tdep.c (xtensa_register_type): Likewise.
+       * linux-tdep.c (linux_get_siginfo_type): Likewise.
+       * target-descriptions.c (tdesc_gdb_type): Likewise.
+       * gnu-v3-abi.c (build_gdb_vtable_type): Likewise.
+
 2009-07-02  Ulrich Weigand  <uweigand@de.ibm.com>
 
        * i386-tdep.h (struct gdbarch_tdep): Add i386_eflags_type and
index d5078ce294e22a06c7844580ed2147008fc579a9..4185c4f559053688306ce125bb6ba688a8858f44 100644 (file)
@@ -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";
 
index e0a92a5b085a5d6d13e6772c00a3b3ea8c020480..20f0aabea12bdcacbc5eb8ddb3bdb68f478e1d42 100644 (file)
@@ -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;
index 7adb48b8a861861ec469d2b18d364aea80f8d866..19c13168d0a7650ac1a459e1ad5fe0b884890182 100644 (file)
@@ -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;
 }
index 307ec0248a5193e4f652c8fae69ecc6bfcb86c4a..da2db2ed137cfc1f7bc5346f88926b1d3b8ae983 100644 (file)
@@ -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;
 }
index e7b6272efa5a41cc3a44e6e87140454f71058cb4..9d83bb32f5dbb9ab947f6aacb8e8fc51af602bf0 100644 (file)
@@ -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 **);
index cc90c01c0340aba7c0cda6b9073e826d1fe6ef8e..09c8e69f7443a0389a43511321efe1e6b4850c15 100644 (file)
@@ -128,9 +128,7 @@ build_gdb_vtable_type (struct gdbarch *arch)
 
   /* ARCH can't give us the true ptrdiff_t type, so we guess.  */
   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;
 }
index a5b1b497c8a608f8a7a46f360332b9aa56478789..6b7560fa4ad851cb2341dad712007e6039c4bc2f 100644 (file)
@@ -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",
index 6919650e113d9e031cab27ab767da42d5e54d58b..d5daf5064cca5814eb00b84678b2c60cc211685f 100644 (file)
@@ -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;
index c885ec7325c97d33c82e3bd47791b4bbd97ebfab..e1b6817a31b51c7772c2ce7b19be537957ed5f12 100644 (file)
@@ -296,7 +296,7 @@ type_from_class (struct gdbarch *gdbarch, struct value *clas)
   /* Do not use the "fake" dynamics objfile to own dynamically generated
      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;
 }
index e18e134ed361afc648f886087cdb83e6a8a3ab44..37770f5f5b93fea2bbd097db60c0f5c6c6aa906d 100644 (file)
@@ -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);
index 14211494d4ff57fb9ba7325cacb28619d942cd57..88c7e5e642a5b8229eb27727b2ec2763ba1ec42a 100644 (file)
@@ -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;
 }
index a833ef43f703da311a3afd0791b4bede27dab04c..b67169f6fa40bf8a9e236fd23873300c4855e1bc 100644 (file)
@@ -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");
 }
 
 
index 0c551c6155d6a906c3aeece1432c06fff45e9713..213431f9f1018f89f24aff4eae9791dbf9fb335b 100644 (file)
@@ -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;
index 00b42d0237515d473904e52aefe2dca49867b902..36097e683ca42e00216972da4e3fd0b20a664dab 100644 (file)
@@ -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));
index 66f293bd152199ccf5a4d17689f5f7db486fe087..bc37c6f7e68697224e83ef3edd9a539bdc0371bf 100644 (file)
@@ -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;
 }
index f6dbf3f5aba011aa87bd1c61b13ecebf06ff2971..2b87d779cd35ba3da06482d89290c4d6e200b8d2 100644 (file)
@@ -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");
index acfbace3eaf20ce56e2b2fd3d60cb7d79143020e..47171a48e5919b18db9dab559510db636c7451d3 100644 (file)
@@ -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");
index 4fa94ccc8733c8ead8312a4f207187fd331f9175..ac976a57d3c18063ecd68a8aaf88dc7d73dc3f64 100644 (file)
@@ -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));
index 3d0c66b671b3029ded09d454e1ee5fb857a38732..741ea655b8ae60ed45a746f8ff0b0b72331f12c1 100644 (file)
@@ -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;
index 7a9657718707c38affa5bc331c6f9ffed217810d..e81b87e850dc32a3d1b6ee16aa9771b4c08ad883 100644 (file)
@@ -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;