#include "defs.h"
#include "gdb_string.h"
#include "bfd.h"
-#include "obstack.h"
+#include "gdb_obstack.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "expression.h"
attach_fields_to_type (struct field_info *, struct type *, struct objfile *);
static struct type *read_struct_type (char **, struct type *,
+ enum type_code,
struct objfile *);
static struct type *read_array_type (char **, struct type *,
struct objfile *);
-static struct type **read_args (char **, int, struct objfile *);
+static struct field *read_args (char **, int, struct objfile *, int *, int *);
static int
read_cpp_abbrev (struct field_info *, char **, struct type *,
*(pp) = next_symbol_text (objfile); \
} while (0)
\f
-/* FIXME: These probably should be our own types (like rs6000_builtin_type
- has its own types) rather than builtin_type_*. */
-static struct type **os9k_type_vector[] =
-{
- 0,
- &builtin_type_int,
- &builtin_type_char,
- &builtin_type_long,
- &builtin_type_short,
- &builtin_type_unsigned_char,
- &builtin_type_unsigned_short,
- &builtin_type_unsigned_long,
- &builtin_type_unsigned_int,
- &builtin_type_float,
- &builtin_type_double,
- &builtin_type_void,
- &builtin_type_long_double
-};
-
-static void os9k_init_type_vector (struct type **);
-
-static void
-os9k_init_type_vector (struct type **tv)
-{
- unsigned int i;
- for (i = 0; i < sizeof (os9k_type_vector) / sizeof (struct type **); i++)
- tv[i] = (os9k_type_vector[i] == 0 ? 0 : *(os9k_type_vector[i]));
-}
+#if 0 /* OBSOLETE OS9K */
+// OBSOLETE /* FIXME: These probably should be our own types (like rs6000_builtin_type
+// OBSOLETE has its own types) rather than builtin_type_*. */
+// OBSOLETE static struct type **os9k_type_vector[] =
+// OBSOLETE {
+// OBSOLETE 0,
+// OBSOLETE &builtin_type_int,
+// OBSOLETE &builtin_type_char,
+// OBSOLETE &builtin_type_long,
+// OBSOLETE &builtin_type_short,
+// OBSOLETE &builtin_type_unsigned_char,
+// OBSOLETE &builtin_type_unsigned_short,
+// OBSOLETE &builtin_type_unsigned_long,
+// OBSOLETE &builtin_type_unsigned_int,
+// OBSOLETE &builtin_type_float,
+// OBSOLETE &builtin_type_double,
+// OBSOLETE &builtin_type_void,
+// OBSOLETE &builtin_type_long_double
+// OBSOLETE };
+// OBSOLETE
+// OBSOLETE static void os9k_init_type_vector (struct type **);
+// OBSOLETE
+// OBSOLETE static void
+// OBSOLETE os9k_init_type_vector (struct type **tv)
+// OBSOLETE {
+// OBSOLETE unsigned int i;
+// OBSOLETE for (i = 0; i < sizeof (os9k_type_vector) / sizeof (struct type **); i++)
+// OBSOLETE tv[i] = (os9k_type_vector[i] == 0 ? 0 : *(os9k_type_vector[i]));
+// OBSOLETE }
+#endif /* OBSOLETE OS9K */
/* Look up a dbx type-number pair. Return the address of the slot
where the type for that number-pair is stored.
memset (&type_vector[old_len], 0,
(type_vector_length - old_len) * sizeof (struct type *));
- if (os9k_stabs)
- /* Deal with OS9000 fundamental types. */
- os9k_init_type_vector (type_vector);
+#if 0 /* OBSOLETE OS9K */
+// OBSOLETE if (os9k_stabs)
+// OBSOLETE /* Deal with OS9000 fundamental types. */
+// OBSOLETE os9k_init_type_vector (type_vector);
+#endif /* OBSOLETE OS9K */
}
return (&type_vector[index]);
}
break;
case 't':
+ /* Typedef */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
/* For a nameless type, we don't want a create a symbol, thus we
}
#endif
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
- if (os9k_stabs)
- add_symbol_to_list (sym, &global_symbols);
- else
+#if 0 /* OBSOLETE OS9K */
+// OBSOLETE if (os9k_stabs)
+// OBSOLETE add_symbol_to_list (sym, &global_symbols);
+// OBSOLETE else
+#endif /* OBSOLETE OS9K */
add_symbol_to_list (sym, &local_symbols);
break;
/* Used to distinguish string and bitstring from char-array and set. */
int is_string = 0;
+ /* Used to distinguish vector from array. */
+ int is_vector = 0;
+
/* Read type number if present. The type number may be omitted.
for instance in a two-dimensional array declared with type
"ar1;1;10;ar1;1;10;4". */
the related problems with unnecessarily stubbed types;
someone motivated should attempt to clean up the issue
here as well. Once a type pointed to has been created it
- should not be modified. */
+ should not be modified.
+
+ Well, it's not *absolutely* wrong. Constructing recursive
+ types (trees, linked lists) necessarily entails modifying
+ types after creating them. Constructing any loop structure
+ entails side effects. The Dwarf 2 reader does handle this
+ more gracefully (it never constructs more than once
+ instance of a type object, so it doesn't have to copy type
+ objects wholesale), but it still mutates type objects after
+ other folks have references to them.
+
+ Keep in mind that this circularity/mutation issue shows up
+ at the source language level, too: C's "incomplete types",
+ for example. So the proper cleanup, I think, would be to
+ limit GDB's type smashing to match exactly those required
+ by the source language. So GDB could have a
+ "complete_this_type" function, but never create unnecessary
+ copies of a type otherwise. */
replace_type (type, xtype);
TYPE_NAME (type) = NULL;
TYPE_TAG_NAME (type) = NULL;
forward-referenced), and we must change it to a pointer, function,
reference, or whatever, *in-place*. */
- case '*':
+ case '*': /* Pointer to another type */
type1 = read_type (pp, objfile);
type = make_pointer_type (type1, dbx_lookup_type (typenums));
break;
break;
case 'f': /* Function returning another type */
- if (os9k_stabs && **pp == '(')
- {
- /* Function prototype; parse it.
- We must conditionalize this on os9k_stabs because otherwise
- it could be confused with a Sun-style (1,3) typenumber
- (I think). */
- struct type *t;
- ++*pp;
- while (**pp != ')')
- {
- t = read_type (pp, objfile);
- if (**pp == ',')
- ++ * pp;
- }
- }
+#if 0 /* OBSOLETE OS9K */
+// OBSOLETE if (os9k_stabs && **pp == '(')
+// OBSOLETE {
+// OBSOLETE /* Function prototype; parse it.
+// OBSOLETE We must conditionalize this on os9k_stabs because otherwise
+// OBSOLETE it could be confused with a Sun-style (1,3) typenumber
+// OBSOLETE (I think). */
+// OBSOLETE struct type *t;
+// OBSOLETE ++*pp;
+// OBSOLETE while (**pp != ')')
+// OBSOLETE {
+// OBSOLETE t = read_type (pp, objfile);
+// OBSOLETE if (**pp == ',')
+// OBSOLETE ++ * pp;
+// OBSOLETE }
+// OBSOLETE }
+#endif /* OBSOLETE OS9K */
+
type1 = read_type (pp, objfile);
type = make_function_type (type1, dbx_lookup_type (typenums));
break;
}
case 'k': /* Const qualifier on some type (Sun) */
- case 'c': /* Const qualifier on some type (OS9000) */
- /* Because 'c' means other things to AIX and 'k' is perfectly good,
- only accept 'c' in the os9k_stabs case. */
- if (type_descriptor == 'c' && !os9k_stabs)
- return error_type (pp, objfile);
+#if 0 /* OBSOLETE OS9K */
+// OBSOLETE /* ezannoni 2002-07-16: This can be safely deleted, because 'c'
+// OBSOLETE means complex type in AIX stabs, while it means const qualifier
+// OBSOLETE in os9k stabs. Obviously we were supporting only the os9k meaning.
+// OBSOLETE We were erroring out if we were reading AIX stabs. Right now the
+// OBSOLETE erroring out will happen in the default clause of the switch. */
+// OBSOLETE case 'c': /* Const qualifier on some type (OS9000) */
+// OBSOLETE /* Because 'c' means other things to AIX and 'k' is perfectly good,
+// OBSOLETE only accept 'c' in the os9k_stabs case. */
+// OBSOLETE if (type_descriptor == 'c' && !os9k_stabs)
+// OBSOLETE return error_type (pp, objfile);
+#endif /* OBSOLETE OS9K */
type = read_type (pp, objfile);
type = make_cv_type (1, TYPE_VOLATILE (type), type,
dbx_lookup_type (typenums));
break;
case 'B': /* Volatile qual on some type (Sun) */
- case 'i': /* Volatile qual on some type (OS9000) */
- /* Because 'i' means other things to AIX and 'B' is perfectly good,
- only accept 'i' in the os9k_stabs case. */
- if (type_descriptor == 'i' && !os9k_stabs)
- return error_type (pp, objfile);
+#if 0 /* OBSOLETE OS9K */
+// OBSOLETE /* ezannoni 2002-07-16: This can be safely deleted, because 'i'
+// OBSOLETE means imported type in AIX stabs, while it means volatile qualifier
+// OBSOLETE in os9k stabs. Obviously we were supporting only the os9k meaning.
+// OBSOLETE We were erroring out if we were reading AIX stabs. Right now the
+// OBSOLETE erroring out will happen in the default clause of the switch. */
+// OBSOLETE case 'i': /* Volatile qual on some type (OS9000) */
+// OBSOLETE /* Because 'i' means other things to AIX and 'B' is perfectly good,
+// OBSOLETE only accept 'i' in the os9k_stabs case. */
+// OBSOLETE if (type_descriptor == 'i' && !os9k_stabs)
+// OBSOLETE return error_type (pp, objfile);
+#endif /* OBSOLETE OS9K */
type = read_type (pp, objfile);
type = make_cv_type (TYPE_CONST (type), 1, type,
dbx_lookup_type (typenums));
switch (*attr)
{
- case 's':
+ case 's': /* Size attribute */
type_size = atoi (attr + 1);
if (type_size <= 0)
type_size = -1;
break;
- case 'S':
+ case 'S': /* String attribute */
+ /* FIXME: check to see if following type is array? */
is_string = 1;
break;
+ case 'V': /* Vector attribute */
+ /* FIXME: check to see if following type is array? */
+ is_vector = 1;
+ break;
+
default:
/* Ignore unrecognized type attributes, so future compilers
can invent new ones. */
{
struct type *domain = read_type (pp, objfile);
struct type *return_type;
- struct type **args;
+ struct field *args;
+ int nargs, varargs;
if (**pp != ',')
/* Invalid member type data format. */
++(*pp);
return_type = read_type (pp, objfile);
- args = read_args (pp, ';', objfile);
+ args = read_args (pp, ';', objfile, &nargs, &varargs);
type = dbx_alloc_type (typenums, objfile);
- smash_to_method_type (type, domain, return_type, args);
+ smash_to_method_type (type, domain, return_type, args,
+ nargs, varargs);
}
break;
break;
case 'b':
- if (os9k_stabs)
- /* Const and volatile qualified type. */
- type = read_type (pp, objfile);
- else
+#if 0 /* OBSOLETE OS9K */
+// OBSOLETE if (os9k_stabs)
+// OBSOLETE /* Const and volatile qualified type. */
+// OBSOLETE type = read_type (pp, objfile);
+// OBSOLETE else
+#endif /* OBSOLETE OS9K */
{
/* Sun ACC builtin int type */
type = read_sun_builtin_type (pp, typenums, objfile);
case 's': /* Struct type */
case 'u': /* Union type */
- type = dbx_alloc_type (typenums, objfile);
- switch (type_descriptor)
- {
- case 's':
- TYPE_CODE (type) = TYPE_CODE_STRUCT;
- break;
- case 'u':
- TYPE_CODE (type) = TYPE_CODE_UNION;
- break;
- }
- type = read_struct_type (pp, type, objfile);
- break;
+ {
+ enum type_code type_code = TYPE_CODE_UNDEF;
+ type = dbx_alloc_type (typenums, objfile);
+ switch (type_descriptor)
+ {
+ case 's':
+ type_code = TYPE_CODE_STRUCT;
+ break;
+ case 'u':
+ type_code = TYPE_CODE_UNION;
+ break;
+ }
+ type = read_struct_type (pp, type, type_code, objfile);
+ break;
+ }
case 'a': /* Array type */
if (**pp != 'r')
type = read_array_type (pp, type, objfile);
if (is_string)
TYPE_CODE (type) = TYPE_CODE_STRING;
+ if (is_vector)
+ TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
break;
- case 'S':
+ case 'S': /* Set or bitstring type */
type1 = read_type (pp, objfile);
type = create_set_type ((struct type *) NULL, type1);
if (is_string)
while (**pp != ';' && **pp != '\0')
{
- if (os9k_stabs && **pp == ',')
- break;
+#if 0 /* OBSOLETE OS9K */
+// OBSOLETE if (os9k_stabs && **pp == ',')
+// OBSOLETE break;
+#endif /* OBSOLETE OS9K */
STABS_CONTINUE (pp, objfile);
/* Get space to record the next field's data. */
new = (struct nextfield *) xmalloc (sizeof (struct nextfield));
}
if (p[0] == ':' && p[1] == ':')
{
- /* chill the list of fields: the last entry (at the head) is a
- partially constructed entry which we now scrub. */
+ /* (OBSOLETE) chill (OBSOLETE) the list of fields: the last
+ entry (at the head) is a partially constructed entry which we
+ now scrub. */
fip->list = fip->list->next;
}
return 1;
return 1;
}
+
+static struct complaint multiply_defined_struct =
+{"struct/union type gets multiply defined: %s%s", 0, 0};
+
+
+/* Complain that the compiler has emitted more than one definition for the
+ structure type TYPE. */
+static void
+complain_about_struct_wipeout (struct type *type)
+{
+ char *name = "";
+ char *kind = "";
+
+ if (TYPE_TAG_NAME (type))
+ {
+ name = TYPE_TAG_NAME (type);
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_STRUCT: kind = "struct "; break;
+ case TYPE_CODE_UNION: kind = "union "; break;
+ case TYPE_CODE_ENUM: kind = "enum "; break;
+ default: kind = "";
+ }
+ }
+ else if (TYPE_NAME (type))
+ {
+ name = TYPE_NAME (type);
+ kind = "";
+ }
+ else
+ {
+ name = "<unknown>";
+ kind = "";
+ }
+
+ complain (&multiply_defined_struct, kind, name);
+}
+
+
/* Read the description of a structure (or union type) and return an object
describing the type.
*/
static struct type *
-read_struct_type (char **pp, struct type *type, struct objfile *objfile)
+read_struct_type (char **pp, struct type *type, enum type_code type_code,
+ struct objfile *objfile)
{
struct cleanup *back_to;
struct field_info fi;
fi.list = NULL;
fi.fnlist = NULL;
+ /* When describing struct/union/class types in stabs, G++ always drops
+ all qualifications from the name. So if you've got:
+ struct A { ... struct B { ... }; ... };
+ then G++ will emit stabs for `struct A::B' that call it simply
+ `struct B'. Obviously, if you've got a real top-level definition for
+ `struct B', or other nested definitions, this is going to cause
+ problems.
+
+ Obviously, GDB can't fix this by itself, but it can at least avoid
+ scribbling on existing structure type objects when new definitions
+ appear. */
+ if (! (TYPE_CODE (type) == TYPE_CODE_UNDEF
+ || TYPE_STUB (type)))
+ {
+ complain_about_struct_wipeout (type);
+
+ /* It's probably best to return the type unchanged. */
+ return type;
+ }
+
back_to = make_cleanup (null_cleanup, 0);
INIT_CPLUS_SPECIFIC (type);
+ TYPE_CODE (type) = type_code;
TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
/* First comes the total size in bytes. */
type = error_type (pp, objfile);
}
- /* Fix up any cv-qualified versions of this type. */
- finish_cv_type (type);
do_cleanups (back_to);
return (type);
}
Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
for these, produce a type like float[][]. */
- if (os9k_stabs)
- index_type = builtin_type_int;
- else
+#if 0 /* OBSOLETE OS9K */
+// OBSOLETE if (os9k_stabs)
+// OBSOLETE index_type = builtin_type_int;
+// OBSOLETE else
+#endif /* OBSOLETE OS9K */
{
index_type = read_type (pp, objfile);
if (**pp != ';')
(*pp)++;
adjustable = 1;
}
- lower = read_huge_number (pp, os9k_stabs ? ',' : ';', &nbits);
+#if 0 /* OBSOLETE OS9K */
+// OBSOLETE lower = read_huge_number (pp, os9k_stabs ? ',' : ';', &nbits);
+#else /* OBSOLETE OS9K */
+ lower = read_huge_number (pp, ';', &nbits);
+#endif /* OBSOLETE OS9K */
+
if (nbits != 0)
return error_type (pp, objfile);
osyms = *symlist;
o_nsyms = osyms ? osyms->nsyms : 0;
- if (os9k_stabs)
- {
- /* Size. Perhaps this does not have to be conditionalized on
- os9k_stabs (assuming the name of an enum constant can't start
- with a digit). */
- read_huge_number (pp, 0, &nbits);
- if (nbits != 0)
- return error_type (pp, objfile);
- }
+#if 0 /* OBSOLETE OS9K */
+// OBSOLETE if (os9k_stabs)
+// OBSOLETE {
+// OBSOLETE /* Size. Perhaps this does not have to be conditionalized on
+// OBSOLETE os9k_stabs (assuming the name of an enum constant can't start
+// OBSOLETE with a digit). */
+// OBSOLETE read_huge_number (pp, 0, &nbits);
+// OBSOLETE if (nbits != 0)
+// OBSOLETE return error_type (pp, objfile);
+// OBSOLETE }
+#endif /* OBSOLETE OS9K */
/* The aix4 compiler emits an extra field before the enum members;
my guess is it's a type of some sort. Just ignore it. */
p++;
}
- if (os9k_stabs)
- upper_limit = ULONG_MAX / radix;
- else
+#if 0 /* OBSOLETE OS9K */
+// OBSOLETE if (os9k_stabs)
+// OBSOLETE upper_limit = ULONG_MAX / radix;
+// OBSOLETE else
+#endif /* OBSOLETE OS9K */
upper_limit = LONG_MAX / radix;
while ((c = *p++) >= '0' && c < ('0' + radix))
else if (self_subrange && n2 == 0 && n3 == 127)
return init_type (TYPE_CODE_INT, 1, 0, NULL, objfile);
- else if (current_symbol && SYMBOL_LANGUAGE (current_symbol) == language_chill
- && !self_subrange)
- goto handle_true_range;
+#if 0
+ /* OBSOLETE else if (current_symbol && SYMBOL_LANGUAGE (current_symbol) == language_chill */
+ /* OBSOLETE && !self_subrange) */
+ /* OBSOLETE goto handle_true_range; */
+#endif
/* We used to do this only for subrange of self or subrange of int. */
else if (n2 == 0)
and terminated with END. Return the list of types read in, or (struct type
**)-1 if there is an error. */
-static struct type **
-read_args (char **pp, int end, struct objfile *objfile)
+static struct field *
+read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
+ int *varargsp)
{
/* FIXME! Remove this arbitrary limit! */
- struct type *types[1024], **rval; /* allow for fns of 1023 parameters */
- int n = 0;
+ struct type *types[1024]; /* allow for fns of 1023 parameters */
+ int n = 0, i;
+ struct field *rval;
while (**pp != end)
{
if (**pp != ',')
/* Invalid argument list: no ','. */
- return (struct type **) -1;
+ return (struct field *) -1;
(*pp)++;
STABS_CONTINUE (pp, objfile);
types[n++] = read_type (pp, objfile);
}
(*pp)++; /* get past `end' (the ':' character) */
- if (n == 1)
- {
- rval = (struct type **) xmalloc (2 * sizeof (struct type *));
- }
- else if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID)
- {
- rval = (struct type **) xmalloc ((n + 1) * sizeof (struct type *));
- memset (rval + n, 0, sizeof (struct type *));
- }
+ if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID)
+ *varargsp = 1;
else
{
- rval = (struct type **) xmalloc (n * sizeof (struct type *));
+ n--;
+ *varargsp = 0;
}
- memcpy (rval, types, n * sizeof (struct type *));
+
+ rval = (struct field *) xmalloc (n * sizeof (struct field));
+ memset (rval, 0, n * sizeof (struct field));
+ for (i = 0; i < n; i++)
+ rval[i].type = types[i];
+ *nargsp = n;
return rval;
}
\f
&& (TYPE_CODE (SYMBOL_TYPE (sym)) ==
TYPE_CODE (*type))
&& STREQ (SYMBOL_NAME (sym), typename))
- {
- memcpy (*type, SYMBOL_TYPE (sym),
- sizeof (struct type));
- }
+ replace_type (*type, SYMBOL_TYPE (sym));
}
}
}
/* FIXME: If common_block_name is not already NULL, we should complain(). */
common_block_name = NULL;
- os9k_stabs = 0;
+#if 0 /* OBSOLETE OS9K */
+// OBSOLETE os9k_stabs = 0;
+#endif /* OBSOLETE OS9K */
}
/* Call after end_symtab() */