/* Support routines for decoding "stabs" debugging information format.
- Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
- 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+ Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+ 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
Free Software Foundation, Inc.
This file is part of GDB.
static struct field *read_args (char **, int, struct objfile *, int *, int *);
-static void add_undefined_type (struct type *);
+static void add_undefined_type (struct type *, int[2]);
static int
read_cpp_abbrev (struct field_info *, char **, struct type *,
static int undef_types_length;
static struct symbol *current_symbol = NULL;
+/* Make a list of nameless types that are undefined.
+ This happens when another type is referenced by its number
+ before this type is actually defined. For instance "t(0,1)=k(0,2)"
+ and type (0,2) is defined only later. */
+
+struct nat
+{
+ int typenums[2];
+ struct type *type;
+};
+static struct nat *noname_undefs;
+static int noname_undefs_allocated;
+static int noname_undefs_length;
+
/* Check for and handle cretinous stabs symbol name continuation! */
#define STABS_CONTINUE(pp,objfile) \
do { \
case 'r':
{
double d = atof (p);
- char *dbl_valu;
+ gdb_byte *dbl_valu;
/* FIXME-if-picky-about-floating-accuracy: Should be using
target arithmetic to get the value. real.c in GCC
SYMBOL_TYPE (sym) = lookup_fundamental_type (objfile,
FT_DBL_PREC_FLOAT);
- dbl_valu = (char *)
+ dbl_valu =
obstack_alloc (&objfile->objfile_obstack,
TYPE_LENGTH (SYMBOL_TYPE (sym)));
store_typed_floating (dbl_valu, SYMBOL_TYPE (sym), d);
break;
case 't':
+ /* In Ada, there is no distinction between typedef and non-typedef;
+ any type declaration implicitly has the equivalent of a typedef,
+ and thus 't' is in fact equivalent to 'Tt'.
+
+ Therefore, for Ada units, we check the character immediately
+ before the 't', and if we do not find a 'T', then make sure to
+ create the associated symbol in the STRUCT_DOMAIN ('t' definitions
+ will be stored in the VAR_DOMAIN). If the symbol was indeed
+ defined as 'Tt' then the STRUCT_DOMAIN symbol will be created
+ elsewhere, so we don't need to take care of that.
+
+ This is important to do, because of forward references:
+ The cleanup of undefined types stored in undef_types only uses
+ STRUCT_DOMAIN symbols to perform the replacement. */
+ synonym = (SYMBOL_LANGUAGE (sym) == language_ada && p[-2] != 'T');
+
/* Typedef */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
}
add_symbol_to_list (sym, &file_symbols);
+
+ if (synonym)
+ {
+ /* Create the STRUCT_DOMAIN clone. */
+ struct symbol *struct_sym = (struct symbol *)
+ obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
+
+ *struct_sym = *sym;
+ SYMBOL_CLASS (struct_sym) = LOC_TYPEDEF;
+ SYMBOL_VALUE (struct_sym) = valu;
+ SYMBOL_DOMAIN (struct_sym) = STRUCT_DOMAIN;
+ if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
+ TYPE_NAME (SYMBOL_TYPE (sym))
+ = obconcat (&objfile->objfile_obstack, "", "",
+ DEPRECATED_SYMBOL_NAME (sym));
+ add_symbol_to_list (struct_sym, &file_symbols);
+ }
+
break;
case 'T':
doesn't get patched up by the time we're done
reading. */
if (TYPE_CODE (type) == TYPE_CODE_UNDEF)
- add_undefined_type (type);
+ add_undefined_type (type, typenums);
return type;
}
INIT_CPLUS_SPECIFIC (type);
TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
- add_undefined_type (type);
+ add_undefined_type (type, typenums);
return type;
}
memtype = read_type (pp, objfile);
type = dbx_alloc_type (typenums, objfile);
- smash_to_member_type (type, domain, memtype);
+ smash_to_memberptr_type (type, domain, memtype);
}
else
/* type attribute */
return_type = read_type (pp, objfile);
args = read_args (pp, ';', objfile, &nargs, &varargs);
+ if (args == NULL)
+ return error_type (pp, objfile);
type = dbx_alloc_type (typenums, objfile);
smash_to_method_type (type, domain, return_type, args,
nargs, varargs);
}
/* Read in an argument list. This is a list of types, separated by commas
- and terminated with END. Return the list of types read in, or (struct type
- **)-1 if there is an error. */
+ and terminated with END. Return the list of types read in, or NULL
+ if there is an error. */
static struct field *
read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
{
if (**pp != ',')
/* Invalid argument list: no ','. */
- return (struct field *) -1;
+ return NULL;
(*pp)++;
STABS_CONTINUE (pp, objfile);
types[n++] = read_type (pp, objfile);
\f
-/* What about types defined as forward references inside of a small lexical
- scope? */
-/* Add a type to the list of undefined types to be checked through
- once this file has been read in. */
+/* Add {TYPE, TYPENUMS} to the NONAME_UNDEFS vector.
+ See add_undefined_type for more details. */
static void
-add_undefined_type (struct type *type)
+add_undefined_type_noname (struct type *type, int typenums[2])
+{
+ struct nat nat;
+
+ nat.typenums[0] = typenums [0];
+ nat.typenums[1] = typenums [1];
+ nat.type = type;
+
+ if (noname_undefs_length == noname_undefs_allocated)
+ {
+ noname_undefs_allocated *= 2;
+ noname_undefs = (struct nat *)
+ xrealloc ((char *) noname_undefs,
+ noname_undefs_allocated * sizeof (struct nat));
+ }
+ noname_undefs[noname_undefs_length++] = nat;
+}
+
+/* Add TYPE to the UNDEF_TYPES vector.
+ See add_undefined_type for more details. */
+
+static void
+add_undefined_type_1 (struct type *type)
{
if (undef_types_length == undef_types_allocated)
{
undef_types[undef_types_length++] = type;
}
+/* What about types defined as forward references inside of a small lexical
+ scope? */
+/* Add a type to the list of undefined types to be checked through
+ once this file has been read in.
+
+ In practice, we actually maintain two such lists: The first list
+ (UNDEF_TYPES) is used for types whose name has been provided, and
+ concerns forward references (eg 'xs' or 'xu' forward references);
+ the second list (NONAME_UNDEFS) is used for types whose name is
+ unknown at creation time, because they were referenced through
+ their type number before the actual type was declared.
+ This function actually adds the given type to the proper list. */
+
+static void
+add_undefined_type (struct type *type, int typenums[2])
+{
+ if (TYPE_TAG_NAME (type) == NULL)
+ add_undefined_type_noname (type, typenums);
+ else
+ add_undefined_type_1 (type);
+}
+
+/* Try to fix all undefined types pushed on the UNDEF_TYPES vector. */
+
+void
+cleanup_undefined_types_noname (void)
+{
+ int i;
+
+ for (i = 0; i < noname_undefs_length; i++)
+ {
+ struct nat nat = noname_undefs[i];
+ struct type **type;
+
+ type = dbx_lookup_type (nat.typenums);
+ if (nat.type != *type && TYPE_CODE (*type) != TYPE_CODE_UNDEF)
+ replace_type (nat.type, *type);
+ }
+
+ noname_undefs_length = 0;
+}
+
/* Go through each undefined type, see if it's still undefined, and fix it
up if possible. We have two kinds of undefined types:
TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
yet defined at the time a pointer to it was made.
Fix: Do a full lookup on the struct/union tag. */
+
void
-cleanup_undefined_types (void)
+cleanup_undefined_types_1 (void)
{
struct type **type;
undef_types_length = 0;
}
+/* Try to fix all the undefined types we ecountered while processing
+ this unit. */
+
+void
+cleanup_undefined_types (void)
+{
+ cleanup_undefined_types_1 ();
+ cleanup_undefined_types_noname ();
+}
+
/* Scan through all of the global symbols defined in the object file,
assigning values to the debugging symbols that need to be assigned
to. Get these symbols from the minimal symbol table. */
undef_types_length = 0;
undef_types = (struct type **)
xmalloc (undef_types_allocated * sizeof (struct type *));
+
+ noname_undefs_allocated = 20;
+ noname_undefs_length = 0;
+ noname_undefs = (struct nat *)
+ xmalloc (noname_undefs_allocated * sizeof (struct nat));
}
projects / deliverable / binutils-gdb.git / blobdiff