Remove arch_type

This removes arch_type, replacing all uses with the new type
allocator.

Reviewed-By: Simon Marchi <simon.marchi@efficios.com>

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 624584e8ee53f9d3021a8855bfba9918794d8137..2e99dfa0c6f1cf6d7f884baa5b90b1d54cd7e84d 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -13556,6 +13556,7 @@ public:
       lai->add_primitive_type (t);
     };
 
+    type_allocator alloc (gdbarch);
     add (arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
                            0, "integer"));
     add (arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
@@ -13584,8 +13585,8 @@ public:
     add (builtin->builtin_void);
 
     struct type *system_addr_ptr
-      = lookup_pointer_type (arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT,
-                                       "void"));
+      = lookup_pointer_type (alloc.new_type (TYPE_CODE_VOID, TARGET_CHAR_BIT,
+                                            "void"));
     system_addr_ptr->set_name ("system__address");
     add (system_addr_ptr);
 

diff --git a/gdb/amdgpu-tdep.c b/gdb/amdgpu-tdep.c
index d681d9d6a504d2c835383f9ab280b51a59fbe585..1077fab5c65e6c1015317d5c3b24191e07ad7fa1 100644 (file)
--- a/gdb/amdgpu-tdep.c
+++ b/gdb/amdgpu-tdep.c
@@ -749,8 +749,9 @@ amd_dbgapi_register_type_to_gdb_type (const amd_dbgapi_register_type &type,
        const auto &enum_type
          = static_cast<const amd_dbgapi_register_type_enum &> (type);
        struct type *gdb_type
-         = arch_type (gdbarch, TYPE_CODE_ENUM, enum_type.bit_size (),
-                      enum_type.name ().c_str ());
+         = (type_allocator (gdbarch)
+            .new_type (TYPE_CODE_ENUM, enum_type.bit_size (),
+                       enum_type.name ().c_str ()));
 
        gdb_type->set_num_fields (enum_type.size ());
        gdb_type->set_fields

diff --git a/gdb/avr-tdep.c b/gdb/avr-tdep.c
index ba98fbf6f82b897f45b347f465f50d9dcdfe421e..f9f498bfed2e59581142b126e47f4cf719f0e7c5 100644 (file)
--- a/gdb/avr-tdep.c
+++ b/gdb/avr-tdep.c
@@ -1473,8 +1473,8 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   /* Create a type for PC.  We can't use builtin types here, as they may not
      be defined.  */
-  tdep->void_type = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT,
-                              "void");
+  type_allocator alloc (gdbarch);
+  tdep->void_type = alloc.new_type (TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
   tdep->func_void_type = make_function_type (tdep->void_type, NULL);
   tdep->pc_type = arch_pointer_type (gdbarch, 4 * TARGET_CHAR_BIT, NULL,
                                     tdep->func_void_type);

diff --git a/gdb/f-lang.c b/gdb/f-lang.c
index e1eb47577d6cb3f16bd006322c3544489ed86256..3bf33d020c6a01a3a50791399044552fa88651d4 100644 (file)
--- a/gdb/f-lang.c
+++ b/gdb/f-lang.c
@@ -1727,8 +1727,10 @@ build_fortran_types (struct gdbarch *gdbarch)
 
   builtin_f_type->builtin_void = builtin_type (gdbarch)->builtin_void;
 
+  type_allocator alloc (gdbarch);
+
   builtin_f_type->builtin_character
-    = arch_type (gdbarch, TYPE_CODE_CHAR, TARGET_CHAR_BIT, "character");
+    = alloc.new_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT, "character");
 
   builtin_f_type->builtin_logical_s1
     = arch_boolean_type (gdbarch, TARGET_CHAR_BIT, 1, "logical*1");
@@ -1774,7 +1776,7 @@ build_fortran_types (struct gdbarch *gdbarch)
                         "real*16", gdbarch_long_double_format (gdbarch));
   else
     builtin_f_type->builtin_real_s16
-      = arch_type (gdbarch, TYPE_CODE_ERROR, 128, "real*16");
+      = alloc.new_type (TYPE_CODE_ERROR, 128, "real*16");
 
   builtin_f_type->builtin_complex
     = init_complex_type ("complex*4", builtin_f_type->builtin_real);
@@ -1784,7 +1786,7 @@ build_fortran_types (struct gdbarch *gdbarch)
 
   if (builtin_f_type->builtin_real_s16->code () == TYPE_CODE_ERROR)
     builtin_f_type->builtin_complex_s16
-      = arch_type (gdbarch, TYPE_CODE_ERROR, 256, "complex*16");
+      = alloc.new_type (TYPE_CODE_ERROR, 256, "complex*16");
   else
     builtin_f_type->builtin_complex_s16
       = init_complex_type ("complex*16", builtin_f_type->builtin_real_s16);

diff --git a/gdb/fbsd-tdep.c b/gdb/fbsd-tdep.c
index 3a7cb9b14ead21ec76bbb58e9d3e79dfb5eb7338..236a9f4d6152891ae993e8a840a2561d7f79b761 100644 (file)
--- a/gdb/fbsd-tdep.c
+++ b/gdb/fbsd-tdep.c
@@ -1609,15 +1609,17 @@ fbsd_get_siginfo_type (struct gdbarch *gdbarch)
   append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
 
   /* __pid_t */
-  pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
-                       int32_type->length () * TARGET_CHAR_BIT, "__pid_t");
+  type_allocator alloc (gdbarch);
+  pid_type = alloc.new_type (TYPE_CODE_TYPEDEF,
+                            int32_type->length () * TARGET_CHAR_BIT,
+                            "__pid_t");
   pid_type->set_target_type (int32_type);
   pid_type->set_target_is_stub (true);
 
   /* __uid_t */
-  uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
-                       uint32_type->length () * TARGET_CHAR_BIT,
-                       "__uid_t");
+  uid_type = alloc.new_type (TYPE_CODE_TYPEDEF,
+                            uint32_type->length () * TARGET_CHAR_BIT,
+                            "__uid_t");
   uid_type->set_target_type (uint32_type);
   pid_type->set_target_is_stub (true);
 

diff --git a/gdb/ft32-tdep.c b/gdb/ft32-tdep.c
index 7a69da61fdb47fa0f75860493b8216b8bc9a493f..7182185313f9807ea588e048ee96de1bd7285412 100644 (file)
--- a/gdb/ft32-tdep.c
+++ b/gdb/ft32-tdep.c
@@ -573,7 +573,8 @@ ft32_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   /* Create a type for PC.  We can't use builtin types here, as they may not
      be defined.  */
-  void_type = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
+  type_allocator alloc (gdbarch);
+  void_type = alloc.new_type (TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
   func_void_type = make_function_type (void_type, NULL);
   tdep->pc_type = arch_pointer_type (gdbarch, 4 * TARGET_CHAR_BIT, NULL,
                                     func_void_type);

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 3d1d9239758734a05e7e425f8c033d15a7e3c5b5..f52899e0a5e2453ce4012981efd88287e28e75a1 100644 (file)
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -5786,26 +5786,6 @@ copy_type (const struct type *type)
 \f
 /* 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 bit, const char *name)
-{
-  struct type *type;
-
-  type = type_allocator (gdbarch).new_type ();
-  set_type_code (type, code);
-  gdb_assert ((bit % TARGET_CHAR_BIT) == 0);
-  type->set_length (bit / TARGET_CHAR_BIT);
-
-  if (name)
-    type->set_name (gdbarch_obstack_strdup (gdbarch, 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.  */
@@ -5816,7 +5796,7 @@ arch_integer_type (struct gdbarch *gdbarch,
 {
   struct type *t;
 
-  t = arch_type (gdbarch, TYPE_CODE_INT, bit, name);
+  t = type_allocator (gdbarch).new_type (TYPE_CODE_INT, bit, name);
   if (unsigned_p)
     t->set_is_unsigned (true);
 
@@ -5833,7 +5813,7 @@ arch_character_type (struct gdbarch *gdbarch,
 {
   struct type *t;
 
-  t = arch_type (gdbarch, TYPE_CODE_CHAR, bit, name);
+  t = type_allocator (gdbarch).new_type (TYPE_CODE_CHAR, bit, name);
   if (unsigned_p)
     t->set_is_unsigned (true);
 
@@ -5850,7 +5830,7 @@ arch_boolean_type (struct gdbarch *gdbarch,
 {
   struct type *t;
 
-  t = arch_type (gdbarch, TYPE_CODE_BOOL, bit, name);
+  t = type_allocator (gdbarch).new_type (TYPE_CODE_BOOL, bit, name);
   if (unsigned_p)
     t->set_is_unsigned (true);
 
@@ -5871,7 +5851,7 @@ arch_float_type (struct gdbarch *gdbarch,
   struct type *t;
 
   bit = verify_floatformat (bit, fmt);
-  t = arch_type (gdbarch, TYPE_CODE_FLT, bit, name);
+  t = type_allocator (gdbarch).new_type (TYPE_CODE_FLT, bit, name);
   TYPE_FLOATFORMAT (t) = fmt;
 
   return t;
@@ -5885,7 +5865,7 @@ arch_decfloat_type (struct gdbarch *gdbarch, int bit, const char *name)
 {
   struct type *t;
 
-  t = arch_type (gdbarch, TYPE_CODE_DECFLOAT, bit, name);
+  t = type_allocator (gdbarch).new_type (TYPE_CODE_DECFLOAT, bit, name);
   return t;
 }
 
@@ -5900,7 +5880,7 @@ arch_pointer_type (struct gdbarch *gdbarch,
 {
   struct type *t;
 
-  t = arch_type (gdbarch, TYPE_CODE_PTR, bit, name);
+  t = type_allocator (gdbarch).new_type (TYPE_CODE_PTR, bit, name);
   t->set_target_type (target_type);
   t->set_is_unsigned (true);
   return t;
@@ -5914,7 +5894,7 @@ arch_flags_type (struct gdbarch *gdbarch, const char *name, int bit)
 {
   struct type *type;
 
-  type = arch_type (gdbarch, TYPE_CODE_FLAGS, bit, name);
+  type = type_allocator (gdbarch).new_type (TYPE_CODE_FLAGS, bit, name);
   type->set_is_unsigned (true);
   type->set_num_fields (0);
   /* Pre-allocate enough space assuming every field is one bit.  */
@@ -5970,7 +5950,7 @@ arch_composite_type (struct gdbarch *gdbarch, const char *name,
   struct type *t;
 
   gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION);
-  t = arch_type (gdbarch, code, 0, NULL);
+  t = type_allocator (gdbarch).new_type (code, 0, NULL);
   t->set_name (name);
   INIT_CPLUS_SPECIFIC (t);
   return t;
@@ -6134,9 +6114,11 @@ create_gdbtypes_data (struct gdbarch *gdbarch)
 {
   struct builtin_type *builtin_type = new struct builtin_type;
 
+  type_allocator alloc (gdbarch);
+
   /* Basic types.  */
   builtin_type->builtin_void
-    = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
+    = alloc.new_type (TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
   builtin_type->builtin_char
     = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
                         !gdbarch_char_signed (gdbarch), "char");
@@ -6191,7 +6173,7 @@ create_gdbtypes_data (struct gdbarch *gdbarch)
   builtin_type->builtin_double_complex
     = init_complex_type ("double complex", builtin_type->builtin_double);
   builtin_type->builtin_string
-    = arch_type (gdbarch, TYPE_CODE_STRING, TARGET_CHAR_BIT, "string");
+    = alloc.new_type (TYPE_CODE_STRING, TARGET_CHAR_BIT, "string");
   builtin_type->builtin_bool
     = arch_boolean_type (gdbarch, TARGET_CHAR_BIT, 1, "bool");
 
@@ -6265,12 +6247,12 @@ create_gdbtypes_data (struct gdbarch *gdbarch)
 
   /* This type represents a GDB internal function.  */
   builtin_type->internal_fn
-    = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0,
-                "<internal function>");
+    = alloc.new_type (TYPE_CODE_INTERNAL_FUNCTION, 0,
+                     "<internal function>");
 
   /* This type represents an xmethod.  */
   builtin_type->xmethod
-    = arch_type (gdbarch, TYPE_CODE_XMETHOD, 0, "<xmethod>");
+    = alloc.new_type (TYPE_CODE_XMETHOD, 0, "<xmethod>");
 
   return builtin_type;
 }

diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index c052b74d1f30af5696975d37dc3464eacdf877d6..657c04be56e9abe09194167cd4e9571779622e47 100644 (file)
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -2316,8 +2316,6 @@ extern struct type *init_fixed_point_type (struct objfile *, int, int,
                                           const char *);
 
 /* Helper functions to construct architecture-owned types.  */
-extern struct type *arch_type (struct gdbarch *, enum type_code, int,
-                              const char *);
 extern struct type *arch_integer_type (struct gdbarch *, int, int,
                                       const char *);
 extern struct type *arch_character_type (struct gdbarch *, int, int,

diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
index 6d1a36623f8df70762aa53495157806652e082c2..a3e2d73f10a424c4d21ce44de8df92ae1050ba89 100644 (file)
--- a/gdb/gnu-v3-abi.c
+++ b/gdb/gnu-v3-abi.c
@@ -125,6 +125,8 @@ get_gdb_vtable_type (struct gdbarch *arch)
   struct type *ptr_to_void_fn_type
     = builtin_type (arch)->builtin_func_ptr;
 
+  type_allocator alloc (arch);
+
   /* ARCH can't give us the true ptrdiff_t type, so we guess.  */
   struct type *ptrdiff_type
     = arch_integer_type (arch, gdbarch_ptr_bit (arch), 0, "ptrdiff_t");
@@ -170,7 +172,7 @@ get_gdb_vtable_type (struct gdbarch *arch)
   /* We assumed in the allocation above that there were four fields.  */
   gdb_assert (field == (field_list + 4));
 
-  t = arch_type (arch, TYPE_CODE_STRUCT, offset * TARGET_CHAR_BIT, NULL);
+  t = alloc.new_type (TYPE_CODE_STRUCT, offset * TARGET_CHAR_BIT, NULL);
   t->set_num_fields (field - field_list);
   t->set_fields (field_list);
   t->set_name ("gdb_gnu_v3_abi_vtable");
@@ -1053,7 +1055,8 @@ build_std_type_info_type (struct gdbarch *arch)
 
   gdb_assert (field == (field_list + 2));
 
-  t = arch_type (arch, TYPE_CODE_STRUCT, offset * TARGET_CHAR_BIT, NULL);
+  t = type_allocator (arch).new_type (TYPE_CODE_STRUCT,
+                                     offset * TARGET_CHAR_BIT, nullptr);
   t->set_num_fields (field - field_list);
   t->set_fields (field_list);
   t->set_name ("gdb_gnu_v3_type_info");

diff --git a/gdb/linux-tdep.c b/gdb/linux-tdep.c
index 3eaa5f3358484a7837f86c2b74d164a3c8fe6984..67adf123090fddd8e31fb6c78f230da99213aeb2 100644 (file)
--- a/gdb/linux-tdep.c
+++ b/gdb/linux-tdep.c
@@ -275,6 +275,8 @@ linux_get_siginfo_type_with_fields (struct gdbarch *gdbarch,
   if (linux_gdbarch_data->siginfo_type != NULL)
     return linux_gdbarch_data->siginfo_type;
 
+  type_allocator alloc (gdbarch);
+
   int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
                                0, "int");
   uint_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
@@ -292,21 +294,23 @@ linux_get_siginfo_type_with_fields (struct gdbarch *gdbarch,
   append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
 
   /* __pid_t */
-  pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
-                       int_type->length () * TARGET_CHAR_BIT, "__pid_t");
+  pid_type = alloc.new_type (TYPE_CODE_TYPEDEF,
+                            int_type->length () * TARGET_CHAR_BIT,
+                            "__pid_t");
   pid_type->set_target_type (int_type);
   pid_type->set_target_is_stub (true);
 
   /* __uid_t */
-  uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
-                       uint_type->length () * TARGET_CHAR_BIT, "__uid_t");
+  uid_type = alloc.new_type (TYPE_CODE_TYPEDEF,
+                            uint_type->length () * TARGET_CHAR_BIT,
+                            "__uid_t");
   uid_type->set_target_type (uint_type);
   uid_type->set_target_is_stub (true);
 
   /* __clock_t */
-  clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
-                         long_type->length () * TARGET_CHAR_BIT,
-                         "__clock_t");
+  clock_type = alloc.new_type (TYPE_CODE_TYPEDEF,
+                              long_type->length () * TARGET_CHAR_BIT,
+                              "__clock_t");
   clock_type->set_target_type (long_type);
   clock_type->set_target_is_stub (true);
 

diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c
index 2899c9aef900b969af9b9f906eb122c0b2e09147..e500ba88a429d501b28a775c25b46bb078a494a8 100644 (file)
--- a/gdb/m32c-tdep.c
+++ b/gdb/m32c-tdep.c
@@ -185,7 +185,8 @@ make_types (struct gdbarch *arch)
 
   /* The builtin_type_mumble variables are sometimes uninitialized when
      this is called, so we avoid using them.  */
-  tdep->voyd = arch_type (arch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
+  type_allocator alloc (arch);
+  tdep->voyd = alloc.new_type (TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
   tdep->ptr_voyd
     = arch_pointer_type (arch, gdbarch_ptr_bit (arch), NULL, tdep->voyd);
   tdep->func_voyd = lookup_function_type (tdep->voyd);

diff --git a/gdb/netbsd-tdep.c b/gdb/netbsd-tdep.c
index 05f8d27f32d7c7d11af341e72665eeb12e147ca6..ed60200f958bbd8662775e59d46511295c411307 100644 (file)
--- a/gdb/netbsd-tdep.c
+++ b/gdb/netbsd-tdep.c
@@ -414,24 +414,28 @@ nbsd_get_siginfo_type (struct gdbarch *gdbarch)
   size_t char_bits = gdbarch_addressable_memory_unit_size (gdbarch) * 8;
 
   /* pid_t */
-  type *pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
-                             int32_type->length () * char_bits, "pid_t");
+  type_allocator alloc (gdbarch);
+  type *pid_type = alloc.new_type (TYPE_CODE_TYPEDEF,
+                                  int32_type->length () * char_bits,
+                                  "pid_t");
   pid_type->set_target_type (int32_type);
 
   /* uid_t */
-  type *uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
-                             uint32_type->length () * char_bits, "uid_t");
+  type *uid_type = alloc.new_type (TYPE_CODE_TYPEDEF,
+                                  uint32_type->length () * char_bits,
+                                  "uid_t");
   uid_type->set_target_type (uint32_type);
 
   /* clock_t */
-  type *clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
-                               int_type->length () * char_bits, "clock_t");
+  type *clock_type = alloc.new_type (TYPE_CODE_TYPEDEF,
+                                    int_type->length () * char_bits,
+                                    "clock_t");
   clock_type->set_target_type (int_type);
 
   /* lwpid_t */
-  type *lwpid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
-                               int32_type->length () * char_bits,
-                               "lwpid_t");
+  type *lwpid_type = alloc.new_type (TYPE_CODE_TYPEDEF,
+                                    int32_type->length () * char_bits,
+                                    "lwpid_t");
   lwpid_type->set_target_type (int32_type);
 
   /* union sigval */

diff --git a/gdb/rl78-tdep.c b/gdb/rl78-tdep.c
index 1af78d9c652f7d99a8ea7f009f22259bc54645ac..1177215490f9dbdc6ad6a9db857e125b80fa5abb 100644 (file)
--- a/gdb/rl78-tdep.c
+++ b/gdb/rl78-tdep.c
@@ -1409,8 +1409,8 @@ rl78_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   tdep->elf_flags = elf_flags;
 
   /* Initialize types.  */
-  tdep->rl78_void = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT,
-                              "void");
+  type_allocator alloc (gdbarch);
+  tdep->rl78_void = alloc.new_type (TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
   tdep->rl78_uint8 = arch_integer_type (gdbarch, 8, 1, "uint8_t");
   tdep->rl78_int8 = arch_integer_type (gdbarch, 8, 0, "int8_t");
   tdep->rl78_uint16 = arch_integer_type (gdbarch, 16, 1, "uint16_t");

diff --git a/gdb/target-descriptions.c b/gdb/target-descriptions.c
index c62d4368d6bc6ef767d86b036f837fd188645851..7af3875b48bc6ae6abf099d5e80aac1d9a78ab2e 100644 (file)
--- a/gdb/target-descriptions.c
+++ b/gdb/target-descriptions.c
@@ -284,8 +284,9 @@ make_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *ttype)
 
     void make_gdb_type_enum (const tdesc_type_with_fields *e)
     {
-      m_type = arch_type (m_gdbarch, TYPE_CODE_ENUM, e->size * TARGET_CHAR_BIT,
-                         e->name.c_str ());
+      m_type = (type_allocator (m_gdbarch)
+               .new_type (TYPE_CODE_ENUM, e->size * TARGET_CHAR_BIT,
+                          e->name.c_str ()));
 
       m_type->set_is_unsigned (true);
 

diff --git a/gdb/windows-tdep.c b/gdb/windows-tdep.c
index 97199527c8befae6c1a16a9e65099994da25cf31..5a58aa379536a20a2b0a3bd8ba8d3de88c48388a 100644 (file)
--- a/gdb/windows-tdep.c
+++ b/gdb/windows-tdep.c
@@ -214,6 +214,8 @@ windows_get_tlb_type (struct gdbarch *gdbarch)
   if (windows_gdbarch_data->tib_ptr_type != nullptr)
     return windows_gdbarch_data->tib_ptr_type;
 
+  type_allocator alloc (gdbarch);
+
   dword_ptr_type = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch),
                                 1, "DWORD_PTR");
   dword32_type = arch_integer_type (gdbarch, 32,
@@ -243,9 +245,9 @@ windows_get_tlb_type (struct gdbarch *gdbarch)
   seh_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
   seh_type->set_name (xstrdup ("seh"));
 
-  seh_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
-                           void_ptr_type->length () * TARGET_CHAR_BIT,
-                           NULL);
+  seh_ptr_type = alloc.new_type (TYPE_CODE_PTR,
+                                void_ptr_type->length () * TARGET_CHAR_BIT,
+                                NULL);
   seh_ptr_type->set_target_type (seh_type);
 
   append_composite_type_field (seh_type, "next_seh", seh_ptr_type);
@@ -264,9 +266,9 @@ windows_get_tlb_type (struct gdbarch *gdbarch)
   append_composite_type_field (peb_ldr_type, "in_init_order", list_type);
   append_composite_type_field (peb_ldr_type, "entry_in_progress",
                               void_ptr_type);
-  peb_ldr_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
-                               void_ptr_type->length () * TARGET_CHAR_BIT,
-                               NULL);
+  peb_ldr_ptr_type = alloc.new_type (TYPE_CODE_PTR,
+                                    void_ptr_type->length () * TARGET_CHAR_BIT,
+                                    NULL);
   peb_ldr_ptr_type->set_target_type (peb_ldr_type);
 
   /* struct UNICODE_STRING */
@@ -334,9 +336,9 @@ windows_get_tlb_type (struct gdbarch *gdbarch)
   append_composite_type_field (peb_type, "sub_system_data", void_ptr_type);
   append_composite_type_field (peb_type, "process_heap", void_ptr_type);
   append_composite_type_field (peb_type, "fast_peb_lock", void_ptr_type);
-  peb_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
-                           void_ptr_type->length () * TARGET_CHAR_BIT,
-                           NULL);
+  peb_ptr_type = alloc.new_type (TYPE_CODE_PTR,
+                                void_ptr_type->length () * TARGET_CHAR_BIT,
+                                NULL);
   peb_ptr_type->set_target_type (peb_type);
 
 
@@ -378,9 +380,9 @@ windows_get_tlb_type (struct gdbarch *gdbarch)
   /* uint32_t last_error_number;               %fs:0x0034 */
   append_composite_type_field (tib_type, "last_error_number", dword_ptr_type);
 
-  tib_ptr_type = arch_type (gdbarch, TYPE_CODE_PTR,
-                           void_ptr_type->length () * TARGET_CHAR_BIT,
-                           NULL);
+  tib_ptr_type = alloc.new_type (TYPE_CODE_PTR,
+                                void_ptr_type->length () * TARGET_CHAR_BIT,
+                                NULL);
   tib_ptr_type->set_target_type (tib_type);
 
   windows_gdbarch_data->tib_ptr_type = tib_ptr_type;
@@ -742,7 +744,7 @@ create_enum (struct gdbarch *gdbarch, int bit, const char *name,
   struct type *type;
   int i;
 
-  type = arch_type (gdbarch, TYPE_CODE_ENUM, bit, name);
+  type = type_allocator (gdbarch).new_type (TYPE_CODE_ENUM, bit, name);
   type->set_num_fields (count);
   type->set_fields
     ((struct field *) TYPE_ZALLOC (type, sizeof (struct field) * count));

diff --git a/gdb/z80-tdep.c b/gdb/z80-tdep.c
index fb4077088eb93f8f4a01cc20941b54e0cb64c8ba..78b3827b54d29900dc4c1790cb9a07f9f95ece40 100644 (file)
--- a/gdb/z80-tdep.c
+++ b/gdb/z80-tdep.c
@@ -1139,8 +1139,9 @@ z80_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   /* Create a type for PC.  We can't use builtin types here, as they may not
      be defined.  */
-  tdep->void_type = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT,
-                              "void");
+  type_allocator alloc (gdbarch);
+  tdep->void_type = alloc.new_type (TYPE_CODE_VOID, TARGET_CHAR_BIT,
+                                   "void");
   tdep->func_void_type = make_function_type (tdep->void_type, NULL);
   tdep->pc_type = arch_pointer_type (gdbarch,
                                     tdep->addr_length * TARGET_CHAR_BIT,