* gdbtypes.h (struct builtin_type): Remove builtin_core_addr,
authorUlrich Weigand <uweigand@de.ibm.com>
Mon, 29 Jun 2009 13:18:37 +0000 (13:18 +0000)
committerUlrich Weigand <uweigand@de.ibm.com>
Mon, 29 Jun 2009 13:18:37 +0000 (13:18 +0000)
nodebug_text_symbol, nodebug_data_symbol, nodebug_unknown_symbol,
and nodebug_tls_symbol members.
(struct objfile_type): New data structure.
(objfile_type): Add prototype.
* gdbtypes.c (gdbtypes_post_init): Remove initialization code
for types no longer in struct builtin_type.
(objfile_type_data): New static variable.
(_initialize_gdbtypes): Initialize it.
(objfile_type): New function.

* gdbtypes.h (builtin_type_error): Remove.
* gdbtypes.c (build_complex): Do not use builtin_type_error.
* symtab.c (builtin_type_error): Remove.
(_initialize_symtab): Remove initialization.

* stabsread.c (dbx_lookup_type, define_symbol, error_type,
rs6000_builtin_type, read_range_type): Use per-objfile types
instead of global or per-architecture builtin types.
* coffread.c (decode_type): Likewise.
* dwarf2read.c (read_array_type, read_tag_string_type,
new_symbol, die_type): Likewise.
* mdebugread.c (parse_symbol, basic_type, upgrade_type,
parse_procedure, psymtab_to_symtab_1): Likewise.
* xcoffread.c (process_xcoff_symbol): Likewise.
* parse.c (write_exp_msymbol): Likewise.

* stabsread.c (rs6000_builtin_type_data): New static variable.
(_initialize_stabsread): Initialize it.
(rs6000_builtin_type): Add OBJFILE argument.  Allocate builtin
types per-objfile instead of globally.

* stabsread.c (dbx_lookup_type): Add OBJFILE argument.  Use it
instead of current_objfile; pass it to rs6000_builtin_type.
(dbx_alloc_type, read_type, read_range_type): Update calls.
(cleanup_undefined_types_noname): Add OBJFILE argument and
pass it to dbx_lookup_type.
(cleanup_undefined_types): Add OBJFILE argument and pass it
to cleanup_undefined_types_noname.
* stabsread.h (cleanup_undefined_types): Add OBJFILE argument.
* buildsym.c (end_symtab): Update call.

12 files changed:
gdb/ChangeLog
gdb/buildsym.c
gdb/coffread.c
gdb/dwarf2read.c
gdb/gdbtypes.c
gdb/gdbtypes.h
gdb/mdebugread.c
gdb/parse.c
gdb/stabsread.c
gdb/stabsread.h
gdb/symtab.c
gdb/xcoffread.c

index 9652e9264bccfed0be184e3fc2ff2706a2ba9c89..4d0b20186f51d0fa0f297c8af4b84f5fbde0ad72 100644 (file)
@@ -1,3 +1,47 @@
+2009-06-29  Ulrich Weigand  <uweigand@de.ibm.com>
+
+       * gdbtypes.h (struct builtin_type): Remove builtin_core_addr,
+       nodebug_text_symbol, nodebug_data_symbol, nodebug_unknown_symbol,
+       and nodebug_tls_symbol members.
+       (struct objfile_type): New data structure.
+       (objfile_type): Add prototype.
+       * gdbtypes.c (gdbtypes_post_init): Remove initialization code
+       for types no longer in struct builtin_type.
+       (objfile_type_data): New static variable.
+       (_initialize_gdbtypes): Initialize it.
+       (objfile_type): New function.
+
+       * gdbtypes.h (builtin_type_error): Remove.
+       * gdbtypes.c (build_complex): Do not use builtin_type_error.
+       * symtab.c (builtin_type_error): Remove.
+       (_initialize_symtab): Remove initialization.
+
+       * stabsread.c (dbx_lookup_type, define_symbol, error_type,
+       rs6000_builtin_type, read_range_type): Use per-objfile types
+       instead of global or per-architecture builtin types.
+       * coffread.c (decode_type): Likewise.
+       * dwarf2read.c (read_array_type, read_tag_string_type,
+       new_symbol, die_type): Likewise.
+       * mdebugread.c (parse_symbol, basic_type, upgrade_type,
+       parse_procedure, psymtab_to_symtab_1): Likewise.
+       * xcoffread.c (process_xcoff_symbol): Likewise.
+       * parse.c (write_exp_msymbol): Likewise.
+
+       * stabsread.c (rs6000_builtin_type_data): New static variable.
+       (_initialize_stabsread): Initialize it.
+       (rs6000_builtin_type): Add OBJFILE argument.  Allocate builtin
+       types per-objfile instead of globally.
+
+       * stabsread.c (dbx_lookup_type): Add OBJFILE argument.  Use it
+       instead of current_objfile; pass it to rs6000_builtin_type.
+       (dbx_alloc_type, read_type, read_range_type): Update calls.
+       (cleanup_undefined_types_noname): Add OBJFILE argument and
+       pass it to dbx_lookup_type.
+       (cleanup_undefined_types): Add OBJFILE argument and pass it
+       to cleanup_undefined_types_noname.
+       * stabsread.h (cleanup_undefined_types): Add OBJFILE argument.
+       * buildsym.c (end_symtab): Update call.
+
 2009-06-29  Ulrich Weigand  <uweigand@de.ibm.com>
 
        * darwin-nat-info.c (darwin_debug_regions_recurse): Use
index 71bd8f4c43a00e68e215fb6bb5e24f3d87fe00a6..e1d24614ed16f63b9ec44d8300b5741f7522fd56 100644 (file)
@@ -997,7 +997,7 @@ end_symtab (CORE_ADDR end_addr, struct objfile *objfile, int section)
      are no-ops.  FIXME: Is this handled right in case of QUIT?  Can
      we make this cleaner?  */
 
-  cleanup_undefined_types ();
+  cleanup_undefined_types (objfile);
   finish_global_stabs (objfile);
 
   if (pending_blocks == NULL
index ee8b3806cc02df38339ebd1a3ddb490135d8d6c9..888f8b4be5afcfce3fd26d700b048462b83330e3 100644 (file)
@@ -1713,7 +1713,7 @@ decode_type (struct coff_symbol *cs, unsigned int c_type,
          *dim = 0;
 
          base_type = decode_type (cs, new_c_type, aux, objfile);
-         index_type = builtin_type_int32;
+         index_type = objfile_type (objfile)->builtin_int;
          range_type =
            create_range_type ((struct type *) NULL, index_type, 0, n - 1);
          type =
@@ -1777,39 +1777,39 @@ decode_base_type (struct coff_symbol *cs, unsigned int c_type,
     {
     case T_NULL:
       /* shows up with "void (*foo)();" structure members */
-      return builtin_type (gdbarch)->builtin_void;
+      return objfile_type (objfile)->builtin_void;
 
 #ifdef T_VOID
     case T_VOID:
       /* Intel 960 COFF has this symbol and meaning.  */
-      return builtin_type (gdbarch)->builtin_void;
+      return objfile_type (objfile)->builtin_void;
 #endif
 
     case T_CHAR:
-      return builtin_type (gdbarch)->builtin_char;
+      return objfile_type (objfile)->builtin_char;
 
     case T_SHORT:
-      return builtin_type (gdbarch)->builtin_short;
+      return objfile_type (objfile)->builtin_short;
 
     case T_INT:
-      return builtin_type (gdbarch)->builtin_int;
+      return objfile_type (objfile)->builtin_int;
 
     case T_LONG:
       if (cs->c_sclass == C_FIELD
          && aux->x_sym.x_misc.x_lnsz.x_size
             > gdbarch_long_bit (gdbarch))
-       return builtin_type (gdbarch)->builtin_long_long;
+       return objfile_type (objfile)->builtin_long_long;
       else
-       return builtin_type (gdbarch)->builtin_long;
+       return objfile_type (objfile)->builtin_long;
 
     case T_FLOAT:
-      return builtin_type (gdbarch)->builtin_float;
+      return objfile_type (objfile)->builtin_float;
 
     case T_DOUBLE:
-      return builtin_type (gdbarch)->builtin_double;
+      return objfile_type (objfile)->builtin_double;
 
     case T_LNGDBL:
-      return builtin_type (gdbarch)->builtin_long_double;
+      return objfile_type (objfile)->builtin_long_double;
 
     case T_STRUCT:
       if (cs->c_naux != 1)
@@ -1890,24 +1890,24 @@ decode_base_type (struct coff_symbol *cs, unsigned int c_type,
       break;
 
     case T_UCHAR:
-      return builtin_type (gdbarch)->builtin_unsigned_char;
+      return objfile_type (objfile)->builtin_unsigned_char;
 
     case T_USHORT:
-      return builtin_type (gdbarch)->builtin_unsigned_short;
+      return objfile_type (objfile)->builtin_unsigned_short;
 
     case T_UINT:
-      return builtin_type (gdbarch)->builtin_unsigned_int;
+      return objfile_type (objfile)->builtin_unsigned_int;
 
     case T_ULONG:
       if (cs->c_sclass == C_FIELD
          && aux->x_sym.x_misc.x_lnsz.x_size
             > gdbarch_long_bit (gdbarch))
-       return builtin_type (gdbarch)->builtin_unsigned_long_long;
+       return objfile_type (objfile)->builtin_unsigned_long_long;
       else
-       return builtin_type (gdbarch)->builtin_unsigned_long;
+       return objfile_type (objfile)->builtin_unsigned_long;
     }
   complaint (&symfile_complaints, _("Unexpected type for symbol %s"), cs->c_name);
-  return builtin_type (gdbarch)->builtin_void;
+  return objfile_type (objfile)->builtin_void;
 }
 \f
 /* This page contains subroutines of read_type.  */
index fe1f384f510ab83ba468bfece5c7bac127ce87d6..4b52b6a805759ef2983ed68bda36ee3997369084 100644 (file)
@@ -4830,7 +4830,7 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu)
      arrays with unspecified length.  */
   if (die->child == NULL)
     {
-      index_type = builtin_type_int32;
+      index_type = objfile_type (objfile)->builtin_int;
       range_type = create_range_type (NULL, index_type, 0, -1);
       type = create_array_type (NULL, element_type, range_type);
       return set_die_type (die, type, cu);
@@ -5270,7 +5270,7 @@ read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
         }
     }
 
-  index_type = builtin_type_int32;
+  index_type = objfile_type (objfile)->builtin_int;
   range_type = create_range_type (NULL, index_type, 1, length);
   char_type = language_string_char_type (cu->language_defn, gdbarch);
   type = create_string_type (NULL, char_type, range_type);
@@ -7735,7 +7735,6 @@ static struct symbol *
 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
 {
   struct objfile *objfile = cu->objfile;
-  struct gdbarch *gdbarch = get_objfile_arch (objfile);
   struct symbol *sym = NULL;
   char *name;
   struct attribute *attr = NULL;
@@ -7840,7 +7839,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
             to something sensible.  */
          if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
            SYMBOL_TYPE (sym)
-             = builtin_type (gdbarch)->nodebug_data_symbol;
+             = objfile_type (objfile)->nodebug_data_symbol;
 
          attr = dwarf2_attr (die, DW_AT_const_value, cu);
          if (attr)
@@ -8148,7 +8147,6 @@ dwarf2_const_value_data (struct attribute *attr,
 static struct type *
 die_type (struct die_info *die, struct dwarf2_cu *cu)
 {
-  struct gdbarch *gdbarch = get_objfile_arch (cu->objfile);
   struct type *type;
   struct attribute *type_attr;
   struct die_info *type_die;
@@ -8157,7 +8155,7 @@ die_type (struct die_info *die, struct dwarf2_cu *cu)
   if (!type_attr)
     {
       /* A missing DW_AT_type represents a void type.  */
-      return builtin_type (gdbarch)->builtin_void;
+      return objfile_type (cu->objfile)->builtin_void;
     }
   else
     type_die = follow_die_ref (die, type_attr, &cu);
index 005a29d1dad332c2bcd3c7c6ed71fea580354f8a..07e92cb49c7ebab30c7f15c1815991881ca61bbe 100644 (file)
@@ -3070,11 +3070,6 @@ static struct type *
 build_complex (int bit, char *name, struct type *target_type)
 {
   struct type *t;
-  if (bit <= 0 || target_type == builtin_type_error)
-    {
-      gdb_assert (builtin_type_error != NULL);
-      return builtin_type_error;
-    }
   t = init_type (TYPE_CODE_COMPLEX, 2 * bit / TARGET_CHAR_BIT,
                 0, name, (struct objfile *) NULL);
   TYPE_TARGET_TYPE (t) = target_type;
@@ -3087,6 +3082,7 @@ gdbtypes_post_init (struct gdbarch *gdbarch)
   struct builtin_type *builtin_type
     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
 
+  /* Basic types.  */
   builtin_type->builtin_void =
     init_type (TYPE_CODE_VOID, 1,
               0,
@@ -3179,7 +3175,130 @@ gdbtypes_post_init (struct gdbarch *gdbarch)
               0,
               "_Decimal128", (struct objfile *) NULL);
 
-  /* Pointer/Address types.  */
+  /* 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));
+
+  return builtin_type;
+}
+
+
+/* This set of objfile-based types is intended to be used by symbol
+   readers as basic types.  */
+
+static const struct objfile_data *objfile_type_data;
+
+const struct objfile_type *
+objfile_type (struct objfile *objfile)
+{
+  struct gdbarch *gdbarch;
+  struct objfile_type *objfile_type
+    = objfile_data (objfile, objfile_type_data);
+
+  if (objfile_type)
+    return objfile_type;
+
+  objfile_type = OBSTACK_CALLOC (&objfile->objfile_obstack,
+                                1, struct objfile_type);
+
+  /* Use the objfile architecture to determine basic type properties.  */
+  gdbarch = get_objfile_arch (objfile);
+
+  /* Basic types.  */
+  objfile_type->builtin_void
+    = init_type (TYPE_CODE_VOID, 1,
+                0,
+                "void", objfile);
+
+  objfile_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", objfile);
+  objfile_type->builtin_signed_char
+    = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+                0,
+                "signed char", objfile);
+  objfile_type->builtin_unsigned_char
+    = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+                TYPE_FLAG_UNSIGNED,
+                "unsigned char", objfile);
+  objfile_type->builtin_short
+    = init_type (TYPE_CODE_INT,
+                gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
+                0, "short", objfile);
+  objfile_type->builtin_unsigned_short
+    = init_type (TYPE_CODE_INT,
+                gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
+                TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
+  objfile_type->builtin_int
+    = init_type (TYPE_CODE_INT,
+                gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
+                0, "int", objfile);
+  objfile_type->builtin_unsigned_int
+    = init_type (TYPE_CODE_INT,
+                gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
+                TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
+  objfile_type->builtin_long
+    = init_type (TYPE_CODE_INT,
+                gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
+                0, "long", objfile);
+  objfile_type->builtin_unsigned_long
+    = init_type (TYPE_CODE_INT,
+                gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
+                TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
+  objfile_type->builtin_long_long
+    = init_type (TYPE_CODE_INT,
+                gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
+                0, "long long", objfile);
+  objfile_type->builtin_unsigned_long_long
+    = init_type (TYPE_CODE_INT,
+                gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
+                TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
+
+  objfile_type->builtin_float
+    = init_type (TYPE_CODE_FLT,
+                gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT,
+                0, "float", objfile);
+  TYPE_FLOATFORMAT (objfile_type->builtin_float)
+    = gdbarch_float_format (gdbarch);
+  objfile_type->builtin_double
+    = init_type (TYPE_CODE_FLT,
+                gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT,
+                0, "double", objfile);
+  TYPE_FLOATFORMAT (objfile_type->builtin_double)
+    = gdbarch_double_format (gdbarch);
+  objfile_type->builtin_long_double
+    = init_type (TYPE_CODE_FLT,
+                gdbarch_long_double_bit (gdbarch) / TARGET_CHAR_BIT,
+                0, "long double", objfile);
+  TYPE_FLOATFORMAT (objfile_type->builtin_long_double)
+    = gdbarch_long_double_format (gdbarch);
+
+  /* This type represents a type that was unrecognized in symbol read-in.  */
+  objfile_type->builtin_error
+    = init_type (TYPE_CODE_ERROR, 0, 0, "<unknown type>", objfile);
+
+  /* The following set of types is used for symbols with no
+     debug information.  */
+  objfile_type->nodebug_text_symbol
+    = init_type (TYPE_CODE_FUNC, 1, 0,
+                "<text variable, no debug info>", objfile);
+  TYPE_TARGET_TYPE (objfile_type->nodebug_text_symbol)
+    = objfile_type->builtin_int;
+  objfile_type->nodebug_data_symbol
+    = init_type (TYPE_CODE_INT,
+                gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
+                "<data variable, no debug info>", objfile);
+  objfile_type->nodebug_unknown_symbol
+    = init_type (TYPE_CODE_INT, 1, 0,
+                "<variable (not text or data), no debug info>", objfile);
+  objfile_type->nodebug_tls_symbol
+    = init_type (TYPE_CODE_INT,
+                gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
+                "<thread local variable, no debug info>", objfile);
 
   /* NOTE: on some targets, addresses and pointers are not necessarily
      the same --- for example, on the D10V, pointers are 16 bits long,
@@ -3203,49 +3322,27 @@ gdbtypes_post_init (struct gdbarch *gdbarch)
      - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
        sizeof (void *) == 2 on the target.
 
-     In this context, builtin_type->CORE_ADDR is a bit odd: it's a
-     target type for a value the target will never see.  It's only
-     used to hold the values of (typeless) linker symbols, which are
-     indeed in the unified virtual address space.  */
-
-  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_core_addr =
-    init_type (TYPE_CODE_INT, 
-              gdbarch_addr_bit (gdbarch) / 8,
-              TYPE_FLAG_UNSIGNED,
-              "__CORE_ADDR", (struct objfile *) NULL);
+     In this context, objfile_type->builtin_core_addr is a bit odd:
+     it's a target type for a value the target will never see.  It's
+     only used to hold the values of (typeless) linker symbols, which
+     are indeed in the unified virtual address space.  */
 
+  objfile_type->builtin_core_addr
+    = init_type (TYPE_CODE_INT,
+                gdbarch_addr_bit (gdbarch) / 8,
+                TYPE_FLAG_UNSIGNED, "__CORE_ADDR", objfile);
 
-  /* The following set of types is used for symbols with no
-     debug information.  */
-  builtin_type->nodebug_text_symbol =
-    init_type (TYPE_CODE_FUNC, 1, 0, 
-              "<text variable, no debug info>", NULL);
-  TYPE_TARGET_TYPE (builtin_type->nodebug_text_symbol) =
-    builtin_type->builtin_int;
-  builtin_type->nodebug_data_symbol =
-    init_type (TYPE_CODE_INT, 
-              gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
-              "<data variable, no debug info>", NULL);
-  builtin_type->nodebug_unknown_symbol =
-    init_type (TYPE_CODE_INT, 1, 0,
-              "<variable (not text or data), no debug info>", NULL);
-  builtin_type->nodebug_tls_symbol =
-    init_type (TYPE_CODE_INT, 
-              gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
-              "<thread local variable, no debug info>", NULL);
-
-  return builtin_type;
+  set_objfile_data (objfile, objfile_type_data, objfile_type);
+  return objfile_type;
 }
 
+
 extern void _initialize_gdbtypes (void);
 void
 _initialize_gdbtypes (void)
 {
   gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
+  objfile_type_data = register_objfile_data ();
 
   /* FIXME: The following types are architecture-neutral.  However,
      they contain pointer_type and reference_type fields potentially
index c5175efb5f9bcbe2e4397e6ea5713040109b14dd..7ef8ca2ab84fd92f7cb5562c4c78a5a28f30b0ab 100644 (file)
@@ -957,7 +957,34 @@ extern void allocate_cplus_struct_type (struct type *);
 
 struct builtin_type
 {
-  /* Address/pointer types.  */
+  /* Integral types.  */
+
+  /* Implicit size/sign (based on the the architecture's ABI).  */
+  struct type *builtin_void;
+  struct type *builtin_char;
+  struct type *builtin_short;
+  struct type *builtin_int;
+  struct type *builtin_long;
+  struct type *builtin_signed_char;
+  struct type *builtin_unsigned_char;
+  struct type *builtin_unsigned_short;
+  struct type *builtin_unsigned_int;
+  struct type *builtin_unsigned_long;
+  struct type *builtin_float;
+  struct type *builtin_double;
+  struct type *builtin_long_double;
+  struct type *builtin_complex;
+  struct type *builtin_double_complex;
+  struct type *builtin_string;
+  struct type *builtin_bool;
+  struct type *builtin_long_long;
+  struct type *builtin_unsigned_long_long;
+  struct type *builtin_decfloat;
+  struct type *builtin_decdouble;
+  struct type *builtin_declong;
+
+
+  /* Pointer types.  */
 
   /* `pointer to data' type.  Some target platforms use an implicitly
      {sign,zero} -extended 32-bit ABI pointer on a 64-bit ISA.  */
@@ -972,47 +999,48 @@ struct builtin_type
      However, all function pointer types are interconvertible, so void
      (*) () can server as a generic function pointer.  */
   struct type *builtin_func_ptr;
+};
 
-  /* The target CPU's address type.  This is the ISA address size.  */
-  struct type *builtin_core_addr;
-
-
-  /* Types used for symbols with no debug information.  */
-  struct type *nodebug_text_symbol;
-  struct type *nodebug_data_symbol;
-  struct type *nodebug_unknown_symbol;
-  struct type *nodebug_tls_symbol;
+/* Return the type table for the specified architecture.  */
+extern const struct builtin_type *builtin_type (struct gdbarch *gdbarch);
 
 
-  /* Integral types.  */
+/* Per-objfile types used by symbol readers.  */
 
-  /* Implicit size/sign (based on the the architecture's ABI).  */
+struct objfile_type
+{
+  /* Basic types based on the objfile architecture.  */
   struct type *builtin_void;
   struct type *builtin_char;
   struct type *builtin_short;
   struct type *builtin_int;
   struct type *builtin_long;
+  struct type *builtin_long_long;
   struct type *builtin_signed_char;
   struct type *builtin_unsigned_char;
   struct type *builtin_unsigned_short;
   struct type *builtin_unsigned_int;
   struct type *builtin_unsigned_long;
+  struct type *builtin_unsigned_long_long;
   struct type *builtin_float;
   struct type *builtin_double;
   struct type *builtin_long_double;
-  struct type *builtin_complex;
-  struct type *builtin_double_complex;
-  struct type *builtin_string;
-  struct type *builtin_bool;
-  struct type *builtin_long_long;
-  struct type *builtin_unsigned_long_long;
-  struct type *builtin_decfloat;
-  struct type *builtin_decdouble;
-  struct type *builtin_declong;
+
+  /* This type is used to represent symbol addresses.  */
+  struct type *builtin_core_addr;
+
+  /* This type represents a type that was unrecognized in symbol read-in.  */
+  struct type *builtin_error;
+
+  /* Types used for symbols with no debug information.  */
+  struct type *nodebug_text_symbol;
+  struct type *nodebug_data_symbol;
+  struct type *nodebug_unknown_symbol;
+  struct type *nodebug_tls_symbol;
 };
 
-/* Return the type table for the specified architecture.  */
-extern const struct builtin_type *builtin_type (struct gdbarch *gdbarch);
+/* Return the type table for the specified objfile.  */
+extern const struct objfile_type *objfile_type (struct objfile *objfile);
 
  
 /* Explicit sizes - see C9X <intypes.h> for naming scheme.  The "int0"
@@ -1064,14 +1092,6 @@ extern struct type *builtin_type_true_char;
 extern struct type *builtin_type_true_unsigned_char;
 
 
-/* This type represents a type that was unrecognized in symbol
-   read-in.  */
-extern struct type *builtin_type_error;
-
-
-/* RTTI for C++ */
-/* extern struct type *builtin_type_cxx_typeinfo; */
-
 /* Maximum and minimum values of built-in types */
 
 #define        MAX_OF_TYPE(t)  \
index 65d6d0bd43edb6b1862b085313a39fd9240b6439..aac82e9ab7a7c8e29283678fba3ef8a6db3312c2 100644 (file)
@@ -636,7 +636,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       /* Type could be missing if file is compiled without debugging info.  */
       if (SC_IS_UNDEF (sh->sc)
          || sh->sc == scNil || sh->index == indexNil)
-       SYMBOL_TYPE (s) = builtin_type (gdbarch)->nodebug_data_symbol;
+       SYMBOL_TYPE (s) = objfile_type (objfile)->nodebug_data_symbol;
       else
        SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
       /* Value of a data symbol is its memory address */
@@ -685,7 +685,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       SYMBOL_DOMAIN (s) = VAR_DOMAIN;  /* so that it can be used */
       SYMBOL_CLASS (s) = LOC_LABEL;    /* but not misused */
       SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
-      SYMBOL_TYPE (s) = builtin_type (gdbarch)->builtin_int;
+      SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int;
       add_symbol (s, top_stack->cur_st, top_stack->cur_block);
       break;
 
@@ -728,7 +728,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       SYMBOL_CLASS (s) = LOC_BLOCK;
       /* Type of the return value */
       if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
-       t = builtin_type (gdbarch)->builtin_int;
+       t = objfile_type (objfile)->builtin_int;
       else
        {
          t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name);
@@ -1138,7 +1138,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
          s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
          SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
          SYMBOL_CLASS (s) = LOC_CONST;
-         SYMBOL_TYPE (s) = builtin_type_void;
+         SYMBOL_TYPE (s) = objfile_type (current_objfile)->builtin_void;
          e = ((struct mdebug_extra_func_info *)
               obstack_alloc (&current_objfile->objfile_obstack,
                              sizeof (struct mdebug_extra_func_info)));
@@ -1359,13 +1359,13 @@ basic_type (int bt, struct objfile *objfile)
   switch (bt)
     {
     case btNil:
-      tp = builtin_type_void;
+      tp = objfile_type (objfile)->builtin_void;
       break;
 
     case btAdr:
       tp = init_type (TYPE_CODE_PTR, 4, TYPE_FLAG_UNSIGNED,
                      "adr_32", objfile);
-      TYPE_TARGET_TYPE (tp) = builtin_type_void;
+      TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void;
       break;
 
     case btChar:
@@ -1457,7 +1457,7 @@ basic_type (int bt, struct objfile *objfile)
       break;
 
     case btVoid:
-      tp = builtin_type_void;
+      tp = objfile_type (objfile)->builtin_void;
       break;
 
     case btLong64:
@@ -1483,7 +1483,7 @@ basic_type (int bt, struct objfile *objfile)
     case btAdr64:
       tp = init_type (TYPE_CODE_PTR, 8, TYPE_FLAG_UNSIGNED,
                      "adr_64", objfile);
-      TYPE_TARGET_TYPE (tp) = builtin_type_void;
+      TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void;
       break;
 
     case btInt64:
@@ -1849,7 +1849,7 @@ upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
        {
          complaint (&symfile_complaints,
                     _("illegal array index type for %s, assuming int"), sym_name);
-         indx = builtin_type_int32;
+         indx = objfile_type (current_objfile)->builtin_int;
        }
 
       /* Get the bounds, and create the array type.  */
@@ -1918,7 +1918,6 @@ static void
 parse_procedure (PDR *pr, struct symtab *search_symtab,
                 struct partial_symtab *pst)
 {
-  struct gdbarch *gdbarch = get_objfile_arch (pst->objfile);
   struct symbol *s, *i;
   struct block *b;
   char *sh_name;
@@ -2002,7 +2001,7 @@ parse_procedure (PDR *pr, struct symtab *search_symtab,
       SYMBOL_CLASS (s) = LOC_BLOCK;
       /* Donno its type, hope int is ok */
       SYMBOL_TYPE (s)
-       = lookup_function_type (builtin_type (gdbarch)->builtin_int);
+       = lookup_function_type (objfile_type (pst->objfile)->builtin_int);
       add_symbol (s, top_stack->cur_st, top_stack->cur_block);
       /* Wont have symbols for this one */
       b = new_block (2);
@@ -2057,7 +2056,7 @@ parse_procedure (PDR *pr, struct symtab *search_symtab,
   if (processing_gcc_compilation == 0
       && found_ecoff_debugging_info == 0
       && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID)
-    SYMBOL_TYPE (s) = builtin_type (gdbarch)->nodebug_text_symbol;
+    SYMBOL_TYPE (s) = objfile_type (pst->objfile)->nodebug_text_symbol;
 }
 
 /* Parse the external symbol ES. Just call parse_symbol() after
@@ -4043,7 +4042,7 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
                  memset (e, 0, sizeof (struct mdebug_extra_func_info));
                  SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
                  SYMBOL_CLASS (s) = LOC_CONST;
-                 SYMBOL_TYPE (s) = builtin_type_void;
+                 SYMBOL_TYPE (s) = objfile_type (pst->objfile)->builtin_void;
                  SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
                  e->pdr.framereg = -1;
                  add_symbol_to_list (s, &local_symbols);
index 5de3bc7202329dc600924ca821346db0f5ceb0e5..de4cd6cec774dd8bb939f2f29e471b9cc8c6a377 100644 (file)
@@ -489,7 +489,7 @@ write_exp_msymbol (struct minimal_symbol *msymbol)
 
   write_exp_elt_opcode (OP_LONG);
   /* Let's make the type big enough to hold a 64-bit address.  */
-  write_exp_elt_type (builtin_type (gdbarch)->builtin_core_addr);
+  write_exp_elt_type (objfile_type (objfile)->builtin_core_addr);
   write_exp_elt_longcst ((LONGEST) addr);
   write_exp_elt_opcode (OP_LONG);
 
@@ -497,7 +497,7 @@ write_exp_msymbol (struct minimal_symbol *msymbol)
     {
       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
       write_exp_elt_objfile (objfile);
-      write_exp_elt_type (builtin_type (gdbarch)->nodebug_tls_symbol);
+      write_exp_elt_type (objfile_type (objfile)->nodebug_tls_symbol);
       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
       return;
     }
@@ -508,18 +508,18 @@ write_exp_msymbol (struct minimal_symbol *msymbol)
     case mst_text:
     case mst_file_text:
     case mst_solib_trampoline:
-      write_exp_elt_type (builtin_type (gdbarch)->nodebug_text_symbol);
+      write_exp_elt_type (objfile_type (objfile)->nodebug_text_symbol);
       break;
 
     case mst_data:
     case mst_file_data:
     case mst_bss:
     case mst_file_bss:
-      write_exp_elt_type (builtin_type (gdbarch)->nodebug_data_symbol);
+      write_exp_elt_type (objfile_type (objfile)->nodebug_data_symbol);
       break;
 
     default:
-      write_exp_elt_type (builtin_type (gdbarch)->nodebug_unknown_symbol);
+      write_exp_elt_type (objfile_type (objfile)->nodebug_unknown_symbol);
       break;
     }
   write_exp_elt_opcode (UNOP_MEMVAL);
index ed670968963410078b8d9259a5ec36d275d12ff9..624a4c0f30b6d73544d3cca58221b304ff08e651 100644 (file)
@@ -114,7 +114,7 @@ static struct type *read_sun_floating_type (char **, int[2],
 
 static struct type *read_enum_type (char **, struct type *, struct objfile *);
 
-static struct type *rs6000_builtin_type (int);
+static struct type *rs6000_builtin_type (int, struct objfile *);
 
 static int
 read_member_functions (struct field_info *, char **, struct type *,
@@ -218,7 +218,7 @@ static int noname_undefs_length;
    or for associating a new type with the pair.  */
 
 static struct type **
-dbx_lookup_type (int typenums[2])
+dbx_lookup_type (int typenums[2], struct objfile *objfile)
 {
   int filenum = typenums[0];
   int index = typenums[1];
@@ -249,7 +249,7 @@ dbx_lookup_type (int typenums[2])
             this will do the right thing.  */
          static struct type *temp_type;
 
-         temp_type = rs6000_builtin_type (index);
+         temp_type = rs6000_builtin_type (index, objfile);
          return &temp_type;
        }
 
@@ -280,18 +280,18 @@ dbx_lookup_type (int typenums[2])
     {
       real_filenum = this_object_header_files[filenum];
 
-      if (real_filenum >= N_HEADER_FILES (current_objfile))
+      if (real_filenum >= N_HEADER_FILES (objfile))
        {
-         static struct type **temp_type_p;
+         static struct type *temp_type;
 
          warning (_("GDB internal error: bad real_filenum"));
 
        error_return:
-         temp_type_p = &builtin_type_error;
-         return temp_type_p;
+         temp_type = objfile_type (objfile)->builtin_error;
+         return &temp_type;
        }
 
-      f = HEADER_FILES (current_objfile) + real_filenum;
+      f = HEADER_FILES (objfile) + real_filenum;
 
       f_orig_length = f->length;
       if (index >= f_orig_length)
@@ -325,7 +325,7 @@ dbx_alloc_type (int typenums[2], struct objfile *objfile)
       return (alloc_type (objfile));
     }
 
-  type_addr = dbx_lookup_type (typenums);
+  type_addr = dbx_lookup_type (typenums, objfile);
 
   /* If we are referring to a type not known at all yet,
      allocate an empty type for it.
@@ -772,7 +772,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
               target arithmetic to get the value.  real.c in GCC
               probably has the necessary code.  */
 
-           dbl_type = builtin_type (gdbarch)->builtin_double;
+           dbl_type = objfile_type (objfile)->builtin_double;
            dbl_valu =
              obstack_alloc (&objfile->objfile_obstack,
                             TYPE_LENGTH (dbl_type));
@@ -792,7 +792,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
               types; other languages probably should have at least
               unsigned as well as signed constants.  */
 
-           SYMBOL_TYPE (sym) = builtin_type (gdbarch)->builtin_long;
+           SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_long;
            SYMBOL_VALUE (sym) = atoi (p);
            SYMBOL_CLASS (sym) = LOC_CONST;
          }
@@ -903,7 +903,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
                 it back into builtin_int here.
                 FIXME: Do we need a new builtin_promoted_int_arg ?  */
              if (TYPE_CODE (ptype) == TYPE_CODE_VOID)
-               ptype = builtin_type (gdbarch)->builtin_int;
+               ptype = objfile_type (objfile)->builtin_int;
              TYPE_FIELD_TYPE (ftype, nparams) = ptype;
              TYPE_FIELD_ARTIFICIAL (ftype, nparams++) = 0;
            }
@@ -995,8 +995,8 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
            {
              SYMBOL_TYPE (sym) =
                TYPE_UNSIGNED (SYMBOL_TYPE (sym))
-               ? builtin_type (gdbarch)->builtin_unsigned_int
-               : builtin_type (gdbarch)->builtin_int;
+               ? objfile_type (objfile)->builtin_unsigned_int
+               : objfile_type (objfile)->builtin_int;
            }
          break;
        }
@@ -1401,7 +1401,7 @@ error_type (char **pp, struct objfile *objfile)
          break;
        }
     }
-  return (builtin_type_error);
+  return objfile_type (objfile)->builtin_error;
 }
 \f
 
@@ -1577,7 +1577,7 @@ again:
                  obstack_free (&objfile->objfile_obstack, type_name);
                  type = SYMBOL_TYPE (sym);
                  if (typenums[0] != -1)
-                   *dbx_lookup_type (typenums) = type;
+                   *dbx_lookup_type (typenums, objfile) = type;
                  return type;
                }
            }
@@ -1672,17 +1672,18 @@ again:
 
     case '*':                  /* Pointer to another type */
       type1 = read_type (pp, objfile);
-      type = make_pointer_type (type1, dbx_lookup_type (typenums));
+      type = make_pointer_type (type1, dbx_lookup_type (typenums, objfile));
       break;
 
     case '&':                  /* Reference to another type */
       type1 = read_type (pp, objfile);
-      type = make_reference_type (type1, dbx_lookup_type (typenums));
+      type = make_reference_type (type1, dbx_lookup_type (typenums, objfile));
       break;
 
     case 'f':                  /* Function returning another type */
       type1 = read_type (pp, objfile);
-      type = make_function_type (type1, dbx_lookup_type (typenums), objfile);
+      type = make_function_type (type1, dbx_lookup_type (typenums, objfile),
+                                objfile);
       break;
 
     case 'g':                   /* Prototyped function.  (Sun)  */
@@ -1705,8 +1706,8 @@ again:
         const char *type_start = (*pp) - 1;
         struct type *return_type = read_type (pp, objfile);
         struct type *func_type
-          = make_function_type (return_type, dbx_lookup_type (typenums),
-                               objfile);
+          = make_function_type (return_type,
+                               dbx_lookup_type (typenums, objfile), objfile);
         struct type_list {
           struct type *type;
           struct type_list *next;
@@ -1762,13 +1763,13 @@ again:
     case 'k':                  /* Const qualifier on some type (Sun) */
       type = read_type (pp, objfile);
       type = make_cv_type (1, TYPE_VOLATILE (type), type,
-                          dbx_lookup_type (typenums));
+                          dbx_lookup_type (typenums, objfile));
       break;
 
     case 'B':                  /* Volatile qual on some type (Sun) */
       type = read_type (pp, objfile);
       type = make_cv_type (TYPE_CONST (type), 1, type,
-                          dbx_lookup_type (typenums));
+                          dbx_lookup_type (typenums, objfile));
       break;
 
     case '@':
@@ -1842,7 +1843,7 @@ again:
                       symnum);
          type = allocate_stub_method (return_type);
          if (typenums[0] != -1)
-           *dbx_lookup_type (typenums) = type;
+           *dbx_lookup_type (typenums, objfile) = type;
        }
       else
        {
@@ -1870,7 +1871,7 @@ again:
     case 'r':                  /* Range type */
       type = read_range_type (pp, typenums, type_size, objfile);
       if (typenums[0] != -1)
-       *dbx_lookup_type (typenums) = type;
+       *dbx_lookup_type (typenums, objfile) = type;
       break;
 
     case 'b':
@@ -1878,21 +1879,21 @@ again:
          /* Sun ACC builtin int type */
          type = read_sun_builtin_type (pp, typenums, objfile);
          if (typenums[0] != -1)
-           *dbx_lookup_type (typenums) = type;
+           *dbx_lookup_type (typenums, objfile) = type;
        }
       break;
 
     case 'R':                  /* Sun ACC builtin float type */
       type = read_sun_floating_type (pp, typenums, objfile);
       if (typenums[0] != -1)
-       *dbx_lookup_type (typenums) = type;
+       *dbx_lookup_type (typenums, objfile) = type;
       break;
 
     case 'e':                  /* Enumeration type */
       type = dbx_alloc_type (typenums, objfile);
       type = read_enum_type (pp, type, objfile);
       if (typenums[0] != -1)
-       *dbx_lookup_type (typenums) = type;
+       *dbx_lookup_type (typenums, objfile) = type;
       break;
 
     case 's':                  /* Struct type */
@@ -1932,7 +1933,7 @@ again:
       if (is_string)
        TYPE_CODE (type) = TYPE_CODE_BITSTRING;
       if (typenums[0] != -1)
-       *dbx_lookup_type (typenums) = type;
+       *dbx_lookup_type (typenums, objfile) = type;
       break;
 
     default:
@@ -1957,20 +1958,31 @@ again:
 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
    Return the proper type node for a given builtin type number. */
 
+static const struct objfile_data *rs6000_builtin_type_data;
+
 static struct type *
-rs6000_builtin_type (int typenum)
+rs6000_builtin_type (int typenum, struct objfile *objfile)
 {
+  struct type **negative_types = objfile_data (objfile, rs6000_builtin_type_data);
+
   /* We recognize types numbered from -NUMBER_RECOGNIZED to -1.  */
 #define NUMBER_RECOGNIZED 34
-  /* This includes an empty slot for type number -0.  */
-  static struct type *negative_types[NUMBER_RECOGNIZED + 1];
   struct type *rettype = NULL;
 
   if (typenum >= 0 || typenum < -NUMBER_RECOGNIZED)
     {
       complaint (&symfile_complaints, _("Unknown builtin type %d"), typenum);
-      return builtin_type_error;
+      return objfile_type (objfile)->builtin_error;
     }
+
+  if (!negative_types)
+    {
+      /* This includes an empty slot for type number -0.  */
+      negative_types = OBSTACK_CALLOC (&objfile->objfile_obstack,
+                                      NUMBER_RECOGNIZED + 1, struct type *);
+      set_objfile_data (objfile, rs6000_builtin_type_data, negative_types);
+    }
+
   if (negative_types[-typenum] != NULL)
     return negative_types[-typenum];
 
@@ -1990,129 +2002,129 @@ rs6000_builtin_type (int typenum)
          is other than 32 bits, then it should use a new negative type
          number (or avoid negative type numbers for that case).
          See stabs.texinfo.  */
-      rettype = init_type (TYPE_CODE_INT, 4, 0, "int", NULL);
+      rettype = init_type (TYPE_CODE_INT, 4, 0, "int", objfile);
       break;
     case 2:
-      rettype = init_type (TYPE_CODE_INT, 1, 0, "char", NULL);
+      rettype = init_type (TYPE_CODE_INT, 1, 0, "char", objfile);
       break;
     case 3:
-      rettype = init_type (TYPE_CODE_INT, 2, 0, "short", NULL);
+      rettype = init_type (TYPE_CODE_INT, 2, 0, "short", objfile);
       break;
     case 4:
-      rettype = init_type (TYPE_CODE_INT, 4, 0, "long", NULL);
+      rettype = init_type (TYPE_CODE_INT, 4, 0, "long", objfile);
       break;
     case 5:
       rettype = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
-                          "unsigned char", NULL);
+                          "unsigned char", objfile);
       break;
     case 6:
-      rettype = init_type (TYPE_CODE_INT, 1, 0, "signed char", NULL);
+      rettype = init_type (TYPE_CODE_INT, 1, 0, "signed char", objfile);
       break;
     case 7:
       rettype = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
-                          "unsigned short", NULL);
+                          "unsigned short", objfile);
       break;
     case 8:
       rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
-                          "unsigned int", NULL);
+                          "unsigned int", objfile);
       break;
     case 9:
       rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
-                          "unsigned", NULL);
+                          "unsigned", objfile);
     case 10:
       rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
-                          "unsigned long", NULL);
+                          "unsigned long", objfile);
       break;
     case 11:
-      rettype = init_type (TYPE_CODE_VOID, 1, 0, "void", NULL);
+      rettype = init_type (TYPE_CODE_VOID, 1, 0, "void", objfile);
       break;
     case 12:
       /* IEEE single precision (32 bit).  */
-      rettype = init_type (TYPE_CODE_FLT, 4, 0, "float", NULL);
+      rettype = init_type (TYPE_CODE_FLT, 4, 0, "float", objfile);
       break;
     case 13:
       /* IEEE double precision (64 bit).  */
-      rettype = init_type (TYPE_CODE_FLT, 8, 0, "double", NULL);
+      rettype = init_type (TYPE_CODE_FLT, 8, 0, "double", objfile);
       break;
     case 14:
       /* This is an IEEE double on the RS/6000, and different machines with
          different sizes for "long double" should use different negative
          type numbers.  See stabs.texinfo.  */
-      rettype = init_type (TYPE_CODE_FLT, 8, 0, "long double", NULL);
+      rettype = init_type (TYPE_CODE_FLT, 8, 0, "long double", objfile);
       break;
     case 15:
-      rettype = init_type (TYPE_CODE_INT, 4, 0, "integer", NULL);
+      rettype = init_type (TYPE_CODE_INT, 4, 0, "integer", objfile);
       break;
     case 16:
       rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
-                          "boolean", NULL);
+                          "boolean", objfile);
       break;
     case 17:
-      rettype = init_type (TYPE_CODE_FLT, 4, 0, "short real", NULL);
+      rettype = init_type (TYPE_CODE_FLT, 4, 0, "short real", objfile);
       break;
     case 18:
-      rettype = init_type (TYPE_CODE_FLT, 8, 0, "real", NULL);
+      rettype = init_type (TYPE_CODE_FLT, 8, 0, "real", objfile);
       break;
     case 19:
-      rettype = init_type (TYPE_CODE_ERROR, 0, 0, "stringptr", NULL);
+      rettype = init_type (TYPE_CODE_ERROR, 0, 0, "stringptr", objfile);
       break;
     case 20:
       rettype = init_type (TYPE_CODE_CHAR, 1, TYPE_FLAG_UNSIGNED,
-                          "character", NULL);
+                          "character", objfile);
       break;
     case 21:
       rettype = init_type (TYPE_CODE_BOOL, 1, TYPE_FLAG_UNSIGNED,
-                          "logical*1", NULL);
+                          "logical*1", objfile);
       break;
     case 22:
       rettype = init_type (TYPE_CODE_BOOL, 2, TYPE_FLAG_UNSIGNED,
-                          "logical*2", NULL);
+                          "logical*2", objfile);
       break;
     case 23:
       rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
-                          "logical*4", NULL);
+                          "logical*4", objfile);
       break;
     case 24:
       rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
-                          "logical", NULL);
+                          "logical", objfile);
       break;
     case 25:
       /* Complex type consisting of two IEEE single precision values.  */
-      rettype = init_type (TYPE_CODE_COMPLEX, 8, 0, "complex", NULL);
+      rettype = init_type (TYPE_CODE_COMPLEX, 8, 0, "complex", objfile);
       TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 4, 0, "float",
-                                             NULL);
+                                             objfile);
       break;
     case 26:
       /* Complex type consisting of two IEEE double precision values.  */
       rettype = init_type (TYPE_CODE_COMPLEX, 16, 0, "double complex", NULL);
       TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 8, 0, "double",
-                                             NULL);
+                                             objfile);
       break;
     case 27:
-      rettype = init_type (TYPE_CODE_INT, 1, 0, "integer*1", NULL);
+      rettype = init_type (TYPE_CODE_INT, 1, 0, "integer*1", objfile);
       break;
     case 28:
-      rettype = init_type (TYPE_CODE_INT, 2, 0, "integer*2", NULL);
+      rettype = init_type (TYPE_CODE_INT, 2, 0, "integer*2", objfile);
       break;
     case 29:
-      rettype = init_type (TYPE_CODE_INT, 4, 0, "integer*4", NULL);
+      rettype = init_type (TYPE_CODE_INT, 4, 0, "integer*4", objfile);
       break;
     case 30:
-      rettype = init_type (TYPE_CODE_CHAR, 2, 0, "wchar", NULL);
+      rettype = init_type (TYPE_CODE_CHAR, 2, 0, "wchar", objfile);
       break;
     case 31:
-      rettype = init_type (TYPE_CODE_INT, 8, 0, "long long", NULL);
+      rettype = init_type (TYPE_CODE_INT, 8, 0, "long long", objfile);
       break;
     case 32:
       rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
-                          "unsigned long long", NULL);
+                          "unsigned long long", objfile);
       break;
     case 33:
       rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
-                          "logical*8", NULL);
+                          "logical*8", objfile);
       break;
     case 34:
-      rettype = init_type (TYPE_CODE_INT, 8, 0, "integer*8", NULL);
+      rettype = init_type (TYPE_CODE_INT, 8, 0, "integer*8", objfile);
       break;
     }
   negative_types[-typenum] = rettype;
@@ -4062,9 +4074,9 @@ read_range_type (char **pp, int typenums[2], int type_size,
 handle_true_range:
 
   if (self_subrange)
-    index_type = builtin_type (gdbarch)->builtin_int;
+    index_type = objfile_type (objfile)->builtin_int;
   else
-    index_type = *dbx_lookup_type (rangenums);
+    index_type = *dbx_lookup_type (rangenums, objfile);
   if (index_type == NULL)
     {
       /* Does this actually ever happen?  Is that why we are worrying
@@ -4073,7 +4085,7 @@ handle_true_range:
       complaint (&symfile_complaints,
                 _("base type %d of range type is not defined"), rangenums[1]);
 
-      index_type = builtin_type (gdbarch)->builtin_int;
+      index_type = objfile_type (objfile)->builtin_int;
     }
 
   result_type = create_range_type ((struct type *) NULL, index_type, n2, n3);
@@ -4293,7 +4305,7 @@ add_undefined_type (struct type *type, int typenums[2])
 /* Try to fix all undefined types pushed on the UNDEF_TYPES vector.  */
 
 static void
-cleanup_undefined_types_noname (void)
+cleanup_undefined_types_noname (struct objfile *objfile)
 {
   int i;
 
@@ -4302,7 +4314,7 @@ cleanup_undefined_types_noname (void)
       struct nat nat = noname_undefs[i];
       struct type **type;
 
-      type = dbx_lookup_type (nat.typenums);
+      type = dbx_lookup_type (nat.typenums, objfile);
       if (nat.type != *type && TYPE_CODE (*type) != TYPE_CODE_UNDEF)
         {
           /* The instance flags of the undefined type are still unset,
@@ -4415,10 +4427,10 @@ cleanup_undefined_types_1 (void)
    this unit.  */
 
 void
-cleanup_undefined_types (void)
+cleanup_undefined_types (struct objfile *objfile)
 {
   cleanup_undefined_types_1 ();
-  cleanup_undefined_types_noname ();
+  cleanup_undefined_types_noname (objfile);
 }
 
 /* Scan through all of the global symbols defined in the object file,
@@ -4650,6 +4662,8 @@ find_name_end (char *name)
 void
 _initialize_stabsread (void)
 {
+  rs6000_builtin_type_data = register_objfile_data ();
+
   undef_types_allocated = 20;
   undef_types_length = 0;
   undef_types = (struct type **)
index 0097a4e6c4c90f4c7d664fcaadd37940e2336da8..83458d1e13afa40489ea51650e5ce28796e28f8f 100644 (file)
@@ -129,7 +129,7 @@ EXTERN int n_this_object_header_files;
 
 EXTERN int n_allocated_this_object_header_files;
 
-extern void cleanup_undefined_types (void);
+extern void cleanup_undefined_types (struct objfile *);
 
 extern long read_number (char **, int);
 
index f677ed0aeb5a0c4a96aac71043283688f973ac91..e6211a096ce95ef74bc6babe71529a9515188ec4 100644 (file)
@@ -146,9 +146,6 @@ multiple_symbols_select_mode (void)
   return multiple_symbols_mode;
 }
 
-/* The single non-language-specific builtin type */
-struct type *builtin_type_error;
-
 /* Block in which the most recently searched-for symbol was found.
    Might be better to make this a parameter to lookup_symbol and
    value_of_this. */
@@ -4779,9 +4776,5 @@ Show how the debugger handles ambiguities in expressions."), _("\
 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
                         NULL, NULL, &setlist, &showlist);
 
-  /* Initialize the one built-in type that isn't language dependent... */
-  builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0,
-                                 "<unknown type>", (struct objfile *) NULL);
-
   observer_attach_executable_changed (symtab_observer_executable_changed);
 }
index cdb8a2061b58b1c9d448a0b6327902d5bcd50ec0..c56ab86d48f1be3e18cdba47db7385277923d95b 100644 (file)
@@ -1454,7 +1454,6 @@ read_xcoff_symtab (struct partial_symtab *pst)
 static struct symbol *
 process_xcoff_symbol (struct coff_symbol *cs, struct objfile *objfile)
 {
-  struct gdbarch *gdbarch = get_objfile_arch (objfile);
   struct symbol onesymbol;
   struct symbol *sym = &onesymbol;
   struct symbol *sym2 = NULL;
@@ -1494,7 +1493,7 @@ process_xcoff_symbol (struct coff_symbol *cs, struct objfile *objfile)
          patch_block_stabs (), unless the file was compiled without -g.  */
 
       SYMBOL_SET_LINKAGE_NAME (sym, SYMNAME_ALLOC (name, symname_alloced));
-      SYMBOL_TYPE (sym) = builtin_type (gdbarch)->nodebug_text_symbol;
+      SYMBOL_TYPE (sym) = objfile_type (objfile)->nodebug_text_symbol;
 
       SYMBOL_CLASS (sym) = LOC_BLOCK;
       SYMBOL_DUP (sym, sym2);
@@ -1507,7 +1506,7 @@ process_xcoff_symbol (struct coff_symbol *cs, struct objfile *objfile)
   else
     {
       /* In case we can't figure out the type, provide default. */
-      SYMBOL_TYPE (sym) = builtin_type (gdbarch)->nodebug_data_symbol;
+      SYMBOL_TYPE (sym) = objfile_type (objfile)->nodebug_data_symbol;
 
       switch (cs->c_sclass)
        {