They originated in dbxread.c of gdb-4.2, and were split out to
make xcoffread.c more maintainable by sharing code. */
-#include <stdio.h>
#include "defs.h"
#include "obstack.h"
#include "symtab.h"
+#include "gdbtypes.h"
#include "breakpoint.h"
#include "gdbcore.h" /* for bfd stuff for symfile.h */
#include "symfile.h" /* Needed for "struct complaint" */
-#include "aout/stab_gnu.h" /* We always use GNU stabs, not native */
+#include "objfiles.h"
+#include "aout/stab_gnu.h" /* We always use GNU stabs, not native */
#include <string.h>
#include <ctype.h>
#include "buildsym.h" /* Our own declarations */
#undef EXTERN
-extern void qsort ();
-extern double atof ();
+static void
+patch_block_stabs PARAMS ((struct pending *, struct pending_stabs *,
+ struct objfile *));
-/* Things we export from outside, and probably shouldn't. FIXME. */
-extern void new_object_header_files ();
-extern char *next_symbol_text ();
-extern int hashname ();
-extern void patch_block_stabs (); /* AIX xcoffread.c */
-extern struct type *builtin_type (); /* AIX xcoffread.c */
-\f
+static void
+read_huge_number PARAMS ((char **, int, long *, int *));
+
+struct type *
+dbx_alloc_type PARAMS ((int [2], struct objfile *));
+
+static int
+compare_line_numbers PARAMS ((const void *, const void *));
+
+static struct blockvector *
+make_blockvector PARAMS ((struct objfile *));
+
+static void
+fix_common_block PARAMS ((struct symbol *, int));
+
+static void
+cleanup_undefined_types PARAMS ((void));
-static void cleanup_undefined_types ();
-static void fix_common_block ();
+static struct type *
+read_range_type PARAMS ((char **, int [2], struct objfile *));
+
+static struct type *
+read_enum_type PARAMS ((char **, struct type *, struct objfile *));
+
+static struct type *
+read_struct_type PARAMS ((char **, struct type *, struct objfile *));
+
+static struct type *
+read_array_type PARAMS ((char **, struct type *, struct objfile *));
+
+static struct type **
+read_args PARAMS ((char **, int, struct objfile *));
+
+\f
static const char vptr_name[] = { '_','v','p','t','r',CPLUS_MARKER,'\0' };
static const char vb_name[] = { '_','v','b',CPLUS_MARKER,'\0' };
struct complaint range_type_base_complaint =
{"base type %d of range type is not defined", 0, 0};
+
+struct complaint reg_value_complaint =
+ {"register number too large in symbol %s", 0, 0};
+\f
+int
+hashname (name)
+ char *name;
+{
+ register char *p = name;
+ register int total = p[0];
+ register int c;
+
+ c = p[1];
+ total += c << 2;
+ if (c)
+ {
+ c = p[2];
+ total += c << 4;
+ if (c)
+ total += p[3] << 6;
+ }
+
+ /* Ensure result is positive. */
+ if (total < 0) total += (1000 << 6);
+ return total % HASHSIZE;
+}
+
\f
/* Look up a dbx type-number pair. Return the address of the slot
where the type for that number-pair is stored.
register int filenum = typenums[0], index = typenums[1];
unsigned old_len;
+ if (filenum == -1) /* -1,-1 is for temporary types. */
+ return 0;
+
if (filenum < 0 || filenum >= n_this_object_header_files)
error ("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
filenum, index, symnum);
while (index >= type_vector_length)
type_vector_length *= 2;
type_vector = (struct type **)
- xrealloc (type_vector,
+ xrealloc ((char *) type_vector,
(type_vector_length * sizeof (struct type *)));
bzero (&type_vector[old_len],
(type_vector_length - old_len) * sizeof (struct type *));
while (index >= f->length)
f->length *= 2;
f->vector = (struct type **)
- xrealloc (f->vector, f->length * sizeof (struct type *));
+ xrealloc ((char *) f->vector, f->length * sizeof (struct type *));
bzero (&f->vector[f_orig_length],
(f->length - f_orig_length) * sizeof (struct type *));
}
}
}
-/* Create a type object. Occaisionally used when you need a type
- which isn't going to be given a type number. */
-
-struct type *
-dbx_create_type ()
-{
- register struct type *type =
- (struct type *) obstack_alloc (symbol_obstack, sizeof (struct type));
-
- bzero (type, sizeof (struct type));
- TYPE_VPTR_FIELDNO (type) = -1;
- TYPE_VPTR_BASETYPE (type) = 0;
- return type;
-}
-
/* Make sure there is a type allocated for type numbers TYPENUMS
and return the type object.
This can create an empty (zeroed) type object.
put into the type vector, and so may not be referred to by number. */
struct type *
-dbx_alloc_type (typenums)
+dbx_alloc_type (typenums, objfile)
int typenums[2];
+ struct objfile *objfile;
{
register struct type **type_addr;
- register struct type *type;
- if (typenums[0] != -1)
- {
- type_addr = dbx_lookup_type (typenums);
- type = *type_addr;
- }
- else
- {
- type_addr = 0;
- type = 0;
- }
+ if (typenums[0] == -1)
+ return alloc_type (objfile);
+
+ type_addr = dbx_lookup_type (typenums);
/* If we are referring to a type not known at all yet,
allocate an empty type for it.
We will fill it in later if we find out how. */
- if (type == 0)
- {
- type = dbx_create_type ();
- if (type_addr)
- *type_addr = type;
- }
-
- return type;
+ if (*type_addr == 0)
+ *type_addr = alloc_type (objfile);
+
+ return *type_addr;
}
\f
/* maintain the lists of symbols and blocks */
for (next = free_pendings; next; next = next1)
{
next1 = next->next;
- free (next);
+ free ((PTR)next);
}
free_pendings = 0;
for (bnext = pending_blocks; bnext; bnext = bnext1)
{
bnext1 = bnext->next;
- free (bnext);
+ free ((PTR)bnext);
}
#endif
pending_blocks = 0;
for (next = file_symbols; next; next = next1)
{
next1 = next->next;
- free (next);
+ free ((PTR)next);
}
file_symbols = 0;
for (next = global_symbols; next; next = next1)
{
next1 = next->next;
- free (next);
+ free ((PTR)next);
}
global_symbols = 0;
}
Put the block on the list of pending blocks. */
void
-finish_block (symbol, listhead, old_blocks, start, end)
+finish_block (symbol, listhead, old_blocks, start, end, objfile)
struct symbol *symbol;
struct pending **listhead;
struct pending_block *old_blocks;
CORE_ADDR start, end;
+ struct objfile *objfile;
{
register struct pending *next, *next1;
register struct block *block;
i += next->nsyms, next = next->next)
/*EMPTY*/;
- block = (struct block *) obstack_alloc (symbol_obstack,
+ block = (struct block *) obstack_alloc (&objfile -> symbol_obstack,
(sizeof (struct block) + ((i - 1) * sizeof (struct symbol *))));
/* Copy the symbols into the block. */
/* Allocate in the symbol_obstack to save time.
It wastes a little space. */
pblock = (struct pending_block *)
- obstack_alloc (symbol_obstack,
+ obstack_alloc (&objfile -> symbol_obstack,
sizeof (struct pending_block));
pblock->block = block;
if (opblock)
}
}
-struct blockvector *
-make_blockvector ()
+static struct blockvector *
+make_blockvector (objfile)
+ struct objfile *objfile;
{
register struct pending_block *next;
register struct blockvector *blockvector;
for (next = pending_blocks, i = 0; next; next = next->next, i++);
blockvector = (struct blockvector *)
- obstack_alloc (symbol_obstack,
+ obstack_alloc (&objfile -> symbol_obstack,
(sizeof (struct blockvector)
+ (i - 1) * sizeof (struct block *)));
if (BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i-1))
> BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i))) {
complain (&blockvector_complaint,
- BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i)));
+ (char *) BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i)));
}
}
#endif
current_subfile = subfile;
/* Save its name and compilation directory name */
- subfile->name = obsavestring (name, strlen (name));
+ subfile->name = strdup (name);
if (dirname == NULL)
subfile->dirname = NULL;
else
- subfile->dirname = obsavestring (dirname, strlen (dirname));
+ subfile->dirname = strdup (dirname);
/* Initialize line-number recording for this subfile. */
subfile->line_vector = 0;
if (current_subfile == 0 || current_subfile->name == 0)
abort ();
tem->name = current_subfile->name;
- tem->prev_index = header_file_prev_index;
}
char *
name = link->name;
subfile_stack = link->next;
- header_file_prev_index = link->prev_index;
- free (link);
+ free ((PTR)link);
return name;
}
{
subfile->line_vector_length *= 2;
subfile->line_vector = (struct linetable *)
- xrealloc (subfile->line_vector, (sizeof (struct linetable)
+ xrealloc ((char *) subfile->line_vector, (sizeof (struct linetable)
+ subfile->line_vector_length * sizeof (struct linetable_entry)));
}
/* Needed in order to sort line tables from IBM xcoff files. Sigh! */
-/* static */
-int
-compare_line_numbers (ln1, ln2)
- struct linetable_entry *ln1, *ln2;
+static int
+compare_line_numbers (ln1p, ln2p)
+ const PTR ln1p;
+ const PTR ln2p;
{
- return ln1->line - ln2->line;
+ return (((struct linetable_entry *) ln1p) -> line -
+ ((struct linetable_entry *) ln2p) -> line);
}
+
\f
/* Start a new symtab for a new source file.
This is called when a dbx symbol of type N_SO is seen;
file_symbols = 0;
global_symbols = 0;
global_stabs = 0; /* AIX COFF */
- file_stabs = 0; /* AIX COFF */
within_function = 0;
/* Context stack is initially empty. Allocate first one with room for
}
context_stack_depth = 0;
- new_object_header_files ();
+ /* Leave FILENUM of 0 free for builtin types and this file's types. */
+ n_this_object_header_files = 1;
type_vector_length = 0;
type_vector = (struct type **) 0;
start_subfile (name, dirname);
}
+/* for all the stabs in a given stab vector, build appropriate types
+ and fix their symbols in given symbol vector. */
+
+static void
+patch_block_stabs (symbols, stabs, objfile)
+ struct pending *symbols;
+ struct pending_stabs *stabs;
+ struct objfile *objfile;
+{
+ int ii;
+
+ if (stabs)
+ {
+
+ /* for all the stab entries, find their corresponding symbols and
+ patch their types! */
+
+ for (ii = 0; ii < stabs->count; ++ii)
+ {
+ char *name = stabs->stab[ii];
+ char *pp = (char*) strchr (name, ':');
+ struct symbol *sym = find_symbol_in_list (symbols, name, pp-name);
+ if (!sym)
+ {
+#ifndef IBM6000_TARGET
+ printf ("ERROR! stab symbol not found!\n"); /* FIXME */
+#endif
+ }
+ else
+ {
+ pp += 2;
+ if (*(pp-1) == 'F' || *(pp-1) == 'f')
+ {
+ SYMBOL_TYPE (sym) =
+ lookup_function_type (read_type (&pp, objfile));
+ }
+ else
+ {
+ SYMBOL_TYPE (sym) = read_type (&pp, objfile);
+ }
+ }
+ }
+ }
+}
+
/* Finish the symbol definitions for one main source file,
close off all the lexical contexts for that file
(creating struct block's for them), then make the struct symtab
cstk = &context_stack[context_stack_depth];
/* Make a block for the local symbols within. */
finish_block (cstk->name, &local_symbols, cstk->old_blocks,
- cstk->start_addr, end_addr);
+ cstk->start_addr, end_addr, objfile);
/* Debug: if context stack still has something in it, we are in
trouble. */
file_symbols is still good). */
cleanup_undefined_types ();
- /* Hooks for xcoffread.c */
- if (file_stabs) {
- patch_block_stabs (file_symbols, file_stabs);
- free (file_stabs);
- file_stabs = 0;
- }
-
if (global_stabs) {
- patch_block_stabs (global_symbols, global_stabs);
- free (global_stabs);
+ patch_block_stabs (global_symbols, global_stabs, objfile);
+ free ((PTR)global_stabs);
global_stabs = 0;
}
blockvector = NULL;
} else {
/* Define the STATIC_BLOCK and GLOBAL_BLOCK, and build the blockvector. */
- finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr);
- finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr);
- blockvector = make_blockvector ();
+ finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr, objfile);
+ finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr, objfile);
+ blockvector = make_blockvector (objfile);
}
+#ifdef PROCESS_LINENUMBER_HOOK
+ PROCESS_LINENUMBER_HOOK (); /* Needed for aixcoff. */
+#endif
+
/* Now create the symtab objects proper, one for each subfile. */
/* (The main file is the last one on the chain.) */
for (subfile = subfiles; subfile; subfile = nextsub)
{
+ int linetablesize;
/* If we have blocks of symbols, make a symtab.
Otherwise, just ignore this file and any line number info in it. */
symtab = 0;
if (blockvector) {
if (subfile->line_vector) {
/* First, shrink the linetable to make more memory. */
+ linetablesize = sizeof (struct linetable) +
+ subfile->line_vector->nitems * sizeof (struct linetable_entry);
subfile->line_vector = (struct linetable *)
- xrealloc (subfile->line_vector, (sizeof (struct linetable)
- + subfile->line_vector->nitems * sizeof (struct linetable_entry)));
+ xrealloc ((char *) subfile->line_vector, linetablesize);
if (sort_linevec)
qsort (subfile->line_vector->item, subfile->line_vector->nitems,
/* Fill in its components. */
symtab->blockvector = blockvector;
- symtab->linetable = subfile->line_vector;
+ if (subfile->line_vector)
+ {
+ /* Reallocate the line table on the symbol obstack */
+ symtab->linetable = (struct linetable *)
+ obstack_alloc (&objfile -> symbol_obstack, linetablesize);
+ memcpy (symtab->linetable, subfile->line_vector, linetablesize);
+ }
+ else
+ {
+ symtab->linetable = NULL;
+ }
symtab->dirname = subfile->dirname;
symtab->free_code = free_linetable;
symtab->free_ptr = 0;
- /* Link the new symtab into the list of such. */
- symtab->next = symtab_list;
- symtab_list = symtab;
- } else {
- /* No blocks for this file. Delete any line number info we have
- for it. */
- if (subfile->line_vector)
- free (subfile->line_vector);
+#ifdef IBM6000_TARGET
+ /* In case we need to duplicate symbol tables (to represent include
+ files), and in case our system needs relocation, we want to
+ relocate the main symbol table node only (for the main file,
+ not for the include files). */
+
+ symtab->nonreloc = TRUE;
+#endif
}
+ if (subfile->line_vector)
+ free ((PTR)subfile->line_vector);
nextsub = subfile->next;
- free (subfile);
+ free ((PTR)subfile);
}
+#ifdef IBM6000_TARGET
+ /* all include symbol tables are non-relocatable, except the main source
+ file's. */
+ if (symtab)
+ symtab->nonreloc = FALSE;
+#endif
+
if (type_vector)
free ((char *) type_vector);
type_vector = 0;
{
context_stack_size *= 2;
context_stack = (struct context_stack *)
- xrealloc (context_stack,
- (context_stack_size
- * sizeof (struct context_stack)));
+ xrealloc ((char *) context_stack,
+ (context_stack_size * sizeof (struct context_stack)));
}
new = &context_stack[context_stack_depth++];
/* 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 misc function list. */
+ to. Get these symbols from the minimal symbol table. */
void
-scan_file_globals ()
+scan_file_globals (objfile)
+ struct objfile *objfile;
{
int hash;
- int mf;
+ struct minimal_symbol *msymbol;
+ struct symbol *sym, *prev;
- for (mf = 0; mf < misc_function_count; mf++)
+ for (msymbol = objfile -> msymbols; msymbol -> name != NULL; msymbol++)
{
- char *namestring = misc_function_vector[mf].name;
- struct symbol *sym, *prev;
-
QUIT;
prev = (struct symbol *) 0;
/* Get the hash index and check all the symbols
under that hash index. */
- hash = hashname (namestring);
+ hash = hashname (msymbol -> name);
for (sym = global_sym_chain[hash]; sym;)
{
- if (*namestring == SYMBOL_NAME (sym)[0]
- && !strcmp(namestring + 1, SYMBOL_NAME (sym) + 1))
+ if (*(msymbol -> name) == SYMBOL_NAME (sym)[0]
+ && !strcmp(msymbol -> name + 1, SYMBOL_NAME (sym) + 1))
{
/* Splice this symbol out of the hash chain and
assign the value we have to it. */
/* Note: this code might be executed several times for
the same symbol if there are multiple references. */
if (SYMBOL_CLASS (sym) == LOC_BLOCK)
- fix_common_block (sym, misc_function_vector[mf].address);
+ fix_common_block (sym, msymbol -> address);
else
- SYMBOL_VALUE_ADDRESS (sym) = misc_function_vector[mf].address;
+ SYMBOL_VALUE_ADDRESS (sym) = msymbol -> address;
if (prev)
sym = SYMBOL_VALUE_CHAIN (prev);
/* ARGSUSED */
struct symbol *
-define_symbol (valu, string, desc, type)
+define_symbol (valu, string, desc, type, objfile)
unsigned int valu;
char *string;
int desc;
int type;
+ struct objfile *objfile;
{
register struct symbol *sym;
char *p = (char *) strchr (string, ':');
int deftype;
int synonym = 0;
register int i;
+ struct type *temptype;
+
+#ifdef IBM6000_TARGET
+ /* We would like to eliminate nameless symbols, but keep their types.
+ E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
+ to type 2, but, should not creat a symbol to address that type. Since
+ the symbol will be nameless, there is no way any user can refer to it. */
+
+ int nameless;
+#endif
/* Ignore syms with empty names. */
if (string[0] == 0)
if (p == 0)
return 0;
- sym = (struct symbol *)obstack_alloc (symbol_obstack, sizeof (struct symbol));
+#ifdef IBM6000_TARGET
+ /* If a nameless stab entry, all we need is the type, not the symbol.
+ e.g. ":t10=*2" */
+ nameless = (p == string);
+#endif
+
+ sym = (struct symbol *)obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol));
if (processing_gcc_compilation) {
/* GCC 2.x puts the line number in desc. SunOS apparently puts in the
switch (string[1])
{
case 't':
- SYMBOL_NAME (sym) = "this";
+ SYMBOL_NAME (sym) = obsavestring ("this", strlen ("this"),
+ &objfile -> symbol_obstack);
break;
case 'v': /* $vtbl_ptr_type */
/* Was: SYMBOL_NAME (sym) = "vptr"; */
goto normal;
case 'e':
- SYMBOL_NAME (sym) = "eh_throw";
+ SYMBOL_NAME (sym) = obsavestring ("eh_throw", strlen ("eh_throw"),
+ &objfile -> symbol_obstack);
break;
case '_':
{
normal:
SYMBOL_NAME (sym)
- = (char *) obstack_alloc (symbol_obstack, ((p - string) + 1));
+ = (char *) obstack_alloc (&objfile -> symbol_obstack, ((p - string) + 1));
/* Open-coded bcopy--saves function call time. */
{
register char *p1 = string;
Handle Sun-style local fortran array types 'ar...' .
(gnu@cygnus.com) -- this strchr() handles them properly?
(tiemann@cygnus.com) -- 'C' is for catch. */
+
+#ifdef IBM6000_TARGET
+
+ /* 'R' is for register parameters. */
+
+ if (!strchr ("cfFGpPrStTvVXCR", *p))
+#else
+
if (!strchr ("cfFGpPrStTvVXC", *p))
+#endif
deftype = 'l';
else
deftype = *p++;
double d = atof (p);
char *dbl_valu;
- SYMBOL_TYPE (sym) = builtin_type_double;
- dbl_valu =
- (char *) obstack_alloc (symbol_obstack, sizeof (double));
+ SYMBOL_TYPE (sym) = lookup_fundamental_type (objfile,
+ FT_DBL_PREC_FLOAT);
+ dbl_valu = (char *)
+ obstack_alloc (&objfile -> type_obstack,
+ sizeof (double));
memcpy (dbl_valu, &d, sizeof (double));
SWAP_TARGET_AND_HOST (dbl_valu, sizeof (double));
SYMBOL_VALUE_BYTES (sym) = dbl_valu;
break;
case 'i':
{
- SYMBOL_TYPE (sym) = builtin_type_int;
+ SYMBOL_TYPE (sym) = lookup_fundamental_type (objfile,
+ FT_INTEGER);
SYMBOL_VALUE (sym) = atoi (p);
SYMBOL_CLASS (sym) = LOC_CONST;
}
{
p++;
SYMBOL_TYPE (sym)
- = lookup_pointer_type (lookup_function_type (read_type (&p)));
+ = lookup_pointer_type (lookup_function_type (read_type (&p, objfile)));
}
+
+#ifdef IBM6000_TARGET
+ else if (deftype == 'R')
+ SYMBOL_TYPE (sym) = read_type (&p, objfile);
+#endif
+
else
{
struct type *type_read;
{
p += 1;
type_synonym_name = obsavestring (SYMBOL_NAME (sym),
- strlen (SYMBOL_NAME (sym)));
+ strlen (SYMBOL_NAME (sym)),
+ &objfile -> symbol_obstack);
}
/* Here we save the name of the symbol for read_range_type, which
save away the name so that far away from here in read_range_type,
we can examine it to decide between "int" and "long". FIXME. */
long_kludge_name = SYMBOL_NAME (sym);
- type_read = read_type (&p);
+
+ type_read = read_type (&p, objfile);
if ((deftype == 'F' || deftype == 'f')
&& TYPE_CODE (type_read) != TYPE_CODE_FUNC)
#if 0
/* This code doesn't work -- it needs to realloc and can't. */
struct type *new = (struct type *)
- obstack_alloc (symbol_obstack, sizeof (struct type));
+ obstack_alloc (&objfile -> type_obstack,
+ sizeof (struct type));
/* Generate a template for the type of this function. The
types of the arguments will be added as we read the symbol
table. */
*new = *lookup_function_type (type_read);
SYMBOL_TYPE(sym) = new;
+ TYPE_OBJFILE (new) = objfile;
in_function_type = new;
#else
SYMBOL_TYPE (sym) = lookup_function_type (type_read);
be passed on an integer boundary, don't believe it! Offset the
parameter's address to the tail-end of that integer. */
- if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (builtin_type_int)
- && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
- && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (builtin_type_int)) {
- SYMBOL_VALUE (sym) += TYPE_LENGTH (builtin_type_int)
- - TYPE_LENGTH (SYMBOL_TYPE (sym));
- }
+ temptype = lookup_fundamental_type (objfile, FT_INTEGER);
+ if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
+ && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
+ && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (temptype))
+ {
+ SYMBOL_VALUE (sym) += TYPE_LENGTH (temptype)
+ - TYPE_LENGTH (SYMBOL_TYPE (sym));
+ }
break;
#else /* no BELIEVE_PCC_PROMOTION_TYPE. */
/* If PCC says a parameter is a short or a char,
it is really an int. */
- if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (builtin_type_int)
- && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT) {
- SYMBOL_TYPE (sym) = TYPE_UNSIGNED (SYMBOL_TYPE (sym))?
- builtin_type_unsigned_int:
- builtin_type_int;
+ temptype = lookup_fundamental_type (objfile, FT_INTEGER);
+ if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
+ && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
+ {
+ SYMBOL_TYPE (sym) = TYPE_UNSIGNED (SYMBOL_TYPE (sym))
+ ? lookup_fundamental_type (objfile, FT_UNSIGNED_INTEGER)
+ : temptype;
}
break;
#endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
case 'P':
+ /* Parameter which is in a register. */
SYMBOL_CLASS (sym) = LOC_REGPARM;
SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
+ if (SYMBOL_VALUE (sym) >= NUM_REGS)
+ {
+ complain (®_value_complaint, SYMBOL_NAME (sym));
+ SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */
+ }
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
add_symbol_to_list (sym, &local_symbols);
break;
+#ifdef IBM6000_TARGET
+ case 'R':
+#endif
case 'r':
+ /* Register variable (either global or local). */
SYMBOL_CLASS (sym) = LOC_REGISTER;
SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
+ if (SYMBOL_VALUE (sym) >= NUM_REGS)
+ {
+ complain (®_value_complaint, SYMBOL_NAME (sym));
+ SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */
+ }
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
- add_symbol_to_list (sym, &local_symbols);
+ if (within_function)
+ add_symbol_to_list (sym, &local_symbols);
+ else
+ add_symbol_to_list (sym, &file_symbols);
break;
case 'S':
break;
case 't':
+#ifdef IBM6000_TARGET
+ /* For a nameless type, we don't want a create a symbol, thus we
+ did not use `sym'. Return without further processing. */
+
+ if (nameless) return NULL;
+#endif
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
SYMBOL_VALUE (sym) = valu;
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
- if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0
- && (TYPE_FLAGS (SYMBOL_TYPE (sym)) & TYPE_FLAG_PERM) == 0)
- TYPE_NAME (SYMBOL_TYPE (sym)) =
- obsavestring (SYMBOL_NAME (sym),
- strlen (SYMBOL_NAME (sym)));
- /* C++ vagaries: we may have a type which is derived from
- a base type which did not have its name defined when the
- derived class was output. We fill in the derived class's
- base part member's name here in that case. */
- else if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
+ /* C++ vagaries: we may have a type which is derived from
+ a base type which did not have its name defined when the
+ derived class was output. We fill in the derived class's
+ base part member's name here in that case. */
+ if (TYPE_NAME (SYMBOL_TYPE (sym)) != NULL)
+ if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
|| TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION)
&& TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)))
{
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
SYMBOL_VALUE (sym) = valu;
SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
- if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0
- && (TYPE_FLAGS (SYMBOL_TYPE (sym)) & TYPE_FLAG_PERM) == 0)
+ if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
TYPE_NAME (SYMBOL_TYPE (sym))
- = obconcat ("",
+ = obconcat (&objfile -> type_obstack, "",
(TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_ENUM
? "enum "
: (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
if (synonym)
{
- register struct symbol *typedef_sym
- = (struct symbol *) obstack_alloc (symbol_obstack, sizeof (struct symbol));
+ register struct symbol *typedef_sym = (struct symbol *)
+ obstack_alloc (&objfile -> type_obstack,
+ sizeof (struct symbol));
SYMBOL_NAME (typedef_sym) = SYMBOL_NAME (sym);
SYMBOL_TYPE (typedef_sym) = SYMBOL_TYPE (sym);
{
undef_types_allocated *= 2;
undef_types = (struct type **)
- xrealloc (undef_types,
+ xrealloc ((char *) undef_types,
undef_types_allocated * sizeof (struct type *));
}
undef_types[undef_types_length++] = type;
follows the =. */
struct type *
-read_type (pp)
+read_type (pp, objfile)
register char **pp;
+ struct objfile *objfile;
{
register struct type *type = 0;
struct type *type1;
or this is a forward reference to it. dbx_alloc_type handles
both cases. */
if (**pp != '=')
- return dbx_alloc_type (typenums);
+ return dbx_alloc_type (typenums, objfile);
/* Type is being defined here. */
#if 0 /* Callers aren't prepared for a NULL result! FIXME -- metin! */
}
to = type_name = (char *)
- obstack_alloc (symbol_obstack,
+ obstack_alloc (&objfile -> type_obstack,
(strlen (prefix) +
((char *) strchr (*pp, ':') - (*pp)) + 1));
&& (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
&& !strcmp (SYMBOL_NAME (sym), type_name_only))
{
- obstack_free (symbol_obstack, type_name);
+ obstack_free (&objfile -> type_obstack, type_name);
type = SYMBOL_TYPE (sym);
return type;
}
structure for it, and keep track of it so we can
fill in the rest of the fields when we get the full
type. */
- type = dbx_alloc_type (typenums);
+ type = dbx_alloc_type (typenums, objfile);
TYPE_CODE (type) = code;
TYPE_NAME (type) = type_name;
INIT_CPLUS_SPECIFIC(type);
after_digits:
if (type == 0)
- type = builtin_type_void;
+ type = lookup_fundamental_type (objfile, FT_VOID);
if (typenums[0] != -1)
*dbx_lookup_type (typenums) = type;
break;
+ /* In the following types, we must be sure to overwrite any existing
+ type that the typenums refer to, rather than allocating a new one
+ and making the typenums point to the new one. This is because there
+ may already be pointers to the existing type (if it had been
+ forward-referenced), and we must change it to a pointer, function,
+ reference, or whatever, *in-place*. */
+
case '*':
- type1 = read_type (pp);
-/* FIXME -- we should be doing smash_to_XXX types here. */
-#if 0
- /* postponed type decoration should be allowed. */
- if (typenums[1] > 0 && typenums[1] < type_vector_length &&
- (type = type_vector[typenums[1]])) {
- smash_to_pointer_type (type, type1);
+ type1 = read_type (pp, objfile);
+ type = make_pointer_type (type1, dbx_lookup_type (typenums));
break;
- }
-#endif
- type = lookup_pointer_type (type1);
- if (typenums[0] != -1)
- *dbx_lookup_type (typenums) = type;
+
+ case '&': /* Reference to another type */
+ type1 = read_type (pp, objfile);
+ type = make_reference_type (type1, dbx_lookup_type (typenums));
+ break;
+
+ case 'f': /* Function returning another type */
+ type1 = read_type (pp, objfile);
+ type = make_function_type (type1, dbx_lookup_type (typenums));
break;
- case '@':
+/* FIXME -- we should be doing smash_to_XXX types here. */
+ case '@': /* Member (class & variable) type */
{
- struct type *domain = read_type (pp);
+ struct type *domain = read_type (pp, objfile);
struct type *memtype;
if (**pp != ',')
return error_type (pp);
++*pp;
- memtype = read_type (pp);
- type = dbx_alloc_type (typenums);
+ memtype = read_type (pp, objfile);
+ type = dbx_alloc_type (typenums, objfile);
smash_to_member_type (type, domain, memtype);
}
break;
- case '#':
+ case '#': /* Method (class & fn) type */
if ((*pp)[0] == '#')
{
/* We'll get the parameter types from the name. */
struct type *return_type;
*pp += 1;
- return_type = read_type (pp);
+ return_type = read_type (pp, objfile);
if (*(*pp)++ != ';')
- complain (&invalid_member_complaint, symnum);
+ complain (&invalid_member_complaint, (char *) symnum);
type = allocate_stub_method (return_type);
if (typenums[0] != -1)
*dbx_lookup_type (typenums) = type;
}
else
{
- struct type *domain = read_type (pp);
+ struct type *domain = read_type (pp, objfile);
struct type *return_type;
struct type **args;
error ("invalid member type data format, at symtab pos %d.",
symnum);
- return_type = read_type (pp);
- args = read_args (pp, ';');
- type = dbx_alloc_type (typenums);
+ return_type = read_type (pp, objfile);
+ args = read_args (pp, ';', objfile);
+ type = dbx_alloc_type (typenums, objfile);
smash_to_method_type (type, domain, return_type, args);
}
break;
- case '&':
- type1 = read_type (pp);
- type = lookup_reference_type (type1);
- if (typenums[0] != -1)
- *dbx_lookup_type (typenums) = type;
- break;
-
- case 'f':
- type1 = read_type (pp);
- type = lookup_function_type (type1);
- if (typenums[0] != -1)
- *dbx_lookup_type (typenums) = type;
- break;
-
- case 'r':
- type = read_range_type (pp, typenums);
+ case 'r': /* Range type */
+ type = read_range_type (pp, typenums, objfile);
if (typenums[0] != -1)
*dbx_lookup_type (typenums) = type;
break;
- case 'e':
- type = dbx_alloc_type (typenums);
- type = read_enum_type (pp, type);
+ case 'e': /* Enumeration type */
+ type = dbx_alloc_type (typenums, objfile);
+ type = read_enum_type (pp, type, objfile);
*dbx_lookup_type (typenums) = type;
break;
- case 's':
- type = dbx_alloc_type (typenums);
- TYPE_NAME (type) = type_synonym_name;
+ case 's': /* Struct type */
+ type = dbx_alloc_type (typenums, objfile);
+ if (!TYPE_NAME (type))
+ TYPE_NAME (type) = type_synonym_name;
type_synonym_name = 0;
- type = read_struct_type (pp, type);
+ type = read_struct_type (pp, type, objfile);
break;
- case 'u':
- type = dbx_alloc_type (typenums);
- TYPE_NAME (type) = type_synonym_name;
+ case 'u': /* Union type */
+ type = dbx_alloc_type (typenums, objfile);
+ if (!TYPE_NAME (type))
+ TYPE_NAME (type) = type_synonym_name;
type_synonym_name = 0;
- type = read_struct_type (pp, type);
+ type = read_struct_type (pp, type, objfile);
TYPE_CODE (type) = TYPE_CODE_UNION;
break;
- case 'a':
+ case 'a': /* Array type */
if (**pp != 'r')
return error_type (pp);
++*pp;
- type = dbx_alloc_type (typenums);
- type = read_array_type (pp, type);
+ type = dbx_alloc_type (typenums, objfile);
+ type = read_array_type (pp, type, objfile);
break;
default:
if (type == 0)
abort ();
-#if 0
- /* If this is an overriding temporary alteration for a header file's
- contents, and this type number is unknown in the global definition,
- put this type into the global definition at this type number. */
- if (header_file_prev_index >= 0)
- {
- register struct type **tp
- = explicit_lookup_type (header_file_prev_index, typenums[1]);
- if (*tp == 0)
- *tp = type;
- }
-#endif
return type;
}
\f
/* Read the description of a structure (or union type)
and return an object describing the type. */
-struct type *
-read_struct_type (pp, type)
+static struct type *
+read_struct_type (pp, type, objfile)
char **pp;
register struct type *type;
+ struct objfile *objfile;
{
/* Total number of methods defined in this class.
If the class defines two `f' methods, and one `g' method,
n_baseclasses = read_number (pp, ',');
TYPE_FIELD_VIRTUAL_BITS (type) =
- (B_TYPE *) obstack_alloc (symbol_obstack, B_BYTES (n_baseclasses));
+ (B_TYPE *) obstack_alloc (&objfile -> type_obstack,
+ B_BYTES (n_baseclasses));
B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), n_baseclasses);
for (i = 0; i < n_baseclasses; i++)
this baseclass. Always zero in the absence of
multiple inheritance. */
offset = read_number (pp, ',');
- baseclass = read_type (pp);
+ baseclass = read_type (pp, objfile);
*pp += 1; /* skip trailing ';' */
/* Make this baseclass visible for structure-printing purposes. */
break;
}
*pp = p + 1;
- context = read_type (pp);
+ context = read_type (pp, objfile);
name = type_name_no_tag (context);
if (name == 0)
{
- complain (&invalid_cpp_type_complaint, symnum);
- TYPE_NAME (context) = name;
+ complain (&invalid_cpp_type_complaint, (char *) symnum);
+ name = "FOO";
}
- list->field.name = obconcat (prefix, name, "");
+ list->field.name = obconcat (&objfile -> type_obstack,
+ prefix, name, "");
p = ++(*pp);
if (p[-1] != ':')
complain (&invalid_cpp_abbrev_complaint, *pp);
- list->field.type = read_type (pp);
+ list->field.type = read_type (pp, objfile);
(*pp)++; /* Skip the comma. */
list->field.bitpos = read_number (pp, ';');
/* This field is unpacked. */
}
while (*p != ':') p++;
- list->field.name = obsavestring (*pp, p - *pp);
+ list->field.name = obsavestring (*pp, p - *pp,
+ &objfile -> type_obstack);
/* C++: Check to see if we have hit the methods yet. */
if (p[1] == ':')
else /* normal dbx-style format. */
list->visibility = 2; /* public */
- list->field.type = read_type (pp);
+ list->field.type = read_type (pp, objfile);
if (**pp == ':')
{
/* Static class member. */
if ((list->field.bitsize == 8 * TYPE_LENGTH (list->field.type)
|| (TYPE_CODE (list->field.type) == TYPE_CODE_ENUM
&& (list->field.bitsize
- == 8 * TYPE_LENGTH (builtin_type_int))
+ == 8 * TYPE_LENGTH (lookup_fundamental_type (objfile, FT_INTEGER)))
)
)
&&
for this class's virtual functions. */
TYPE_NFIELDS (type) = nfields;
- TYPE_FIELDS (type) = (struct field *) obstack_alloc (symbol_obstack,
- sizeof (struct field) * nfields);
+ TYPE_FIELDS (type) = (struct field *)
+ obstack_alloc (&objfile -> type_obstack, sizeof (struct field) * nfields);
if (non_public_fields)
{
ALLOCATE_CPLUS_STRUCT_TYPE (type);
TYPE_FIELD_PRIVATE_BITS (type) =
- (B_TYPE *) obstack_alloc (symbol_obstack, B_BYTES (nfields));
+ (B_TYPE *) obstack_alloc (&objfile -> type_obstack,
+ B_BYTES (nfields));
B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
TYPE_FIELD_PROTECTED_BITS (type) =
- (B_TYPE *) obstack_alloc (symbol_obstack, B_BYTES (nfields));
+ (B_TYPE *) obstack_alloc (&objfile -> type_obstack,
+ B_BYTES (nfields));
B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
}
At the end, we see a semicolon instead of a field.
For the case of overloaded operators, the format is
- OPERATOR::*.methods, where OPERATOR is the string "operator",
+ op$::*.methods, where $ is the CPLUS_MARKER (usually '$'),
`*' holds the place for an operator name (such as `+=')
and `.' marks the end of the operator name. */
if (p[1] == ':')
*pp = p + 1;
}
else
+ {
main_fn_name = savestring (*pp, p - *pp);
- /* Skip past '::'. */
- *pp = p + 2;
+ /* Skip past '::'. */
+ *pp = p + 2;
+ }
new_mainlist->fn_fieldlist.name = main_fn_name;
do
{
if (**pp == '\\') *pp = next_symbol_text ();
- new_sublist->fn_field.type = read_type (pp);
+ new_sublist->fn_field.type = read_type (pp, objfile);
if (**pp != ':')
/* Invalid symtab info for method. */
return error_type (pp);
case '.':
break;
default:
- complain(&const_vol_complaint, **pp);
+ complain (&const_vol_complaint, (char *) (long) **pp);
break;
}
/* Figure out from whence this virtual function came.
It may belong to virtual function table of
one of its baseclasses. */
- look_ahead_type = read_type (pp);
+ look_ahead_type = read_type (pp, objfile);
if (**pp == ':')
{ /* g++ version 1 overloaded methods. */ }
else
default:
/* error */
- complain (&member_fn_complaint, (*pp)[-1]);
+ complain (&member_fn_complaint, (char *) (long) (*pp)[-1]);
/* Fall through into normal member function. */
case '.':
*pp += 1;
new_mainlist->fn_fieldlist.fn_fields =
- (struct fn_field *) obstack_alloc (symbol_obstack,
+ (struct fn_field *) obstack_alloc (&objfile -> type_obstack,
sizeof (struct fn_field) * length);
for (i = length; (i--, sublist); sublist = sublist->next)
new_mainlist->fn_fieldlist.fn_fields[i] = sublist->fn_field;
mainlist = new_mainlist;
nfn_fields++;
total_length += length;
+ if (**pp == '\\') *pp = next_symbol_text ();
}
while (**pp != ';');
}
if (nfn_fields)
{
- TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
- obstack_alloc (symbol_obstack,
- sizeof (struct fn_fieldlist) * nfn_fields);
+ TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
+ obstack_alloc (&objfile -> type_obstack,
+ sizeof (struct fn_fieldlist) * nfn_fields);
TYPE_NFN_FIELDS (type) = nfn_fields;
TYPE_NFN_FIELDS_TOTAL (type) = total_length;
}
TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type, i));
}
- for (n = nfn_fields; mainlist; mainlist = mainlist->next)
- TYPE_FN_FIELDLISTS (type)[--n] = mainlist->fn_fieldlist;
+ for (n = nfn_fields; mainlist; mainlist = mainlist->next) {
+ --n; /* Circumvent Sun3 compiler bug */
+ TYPE_FN_FIELDLISTS (type)[n] = mainlist->fn_fieldlist;
+ }
if (**pp == '~')
{
for the derived classes, but for the fact that by then,
we don't remember who needs what. */
+#if 0
int predicted_fieldno = -1;
+#endif
/* Now we must record the virtual function table pointer's
field information. */
}
#endif
- t = read_type (pp);
+ t = read_type (pp, objfile);
p = (*pp)++;
while (*p != '\0' && *p != ';')
p++;
and create and return a suitable type object.
Also creates a range type which represents the bounds of that
array. */
-struct type *
-read_array_type (pp, type)
+static struct type *
+read_array_type (pp, type, objfile)
register char **pp;
register struct type *type;
+ struct objfile *objfile;
{
struct type *index_type, *element_type, *range_type;
int lower, upper;
Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
for these, produce a type like float[][]. */
- index_type = read_type (pp);
+ index_type = read_type (pp, objfile);
if (**pp != ';')
/* Improper format of array type decl. */
return error_type (pp);
}
upper = read_number (pp, ';');
- element_type = read_type (pp);
+ element_type = read_type (pp, objfile);
if (adjustable)
{
{
/* Create range type. */
- range_type = (struct type *) obstack_alloc (symbol_obstack,
- sizeof (struct type));
+ range_type = (struct type *)
+ obstack_alloc (&objfile -> type_obstack, sizeof (struct type));
+ bzero (range_type, sizeof (struct type));
+ TYPE_OBJFILE (range_type) = objfile;
TYPE_CODE (range_type) = TYPE_CODE_RANGE;
TYPE_TARGET_TYPE (range_type) = index_type;
TYPE_NFIELDS (range_type) = 2;
TYPE_FIELDS (range_type) =
- (struct field *) obstack_alloc (symbol_obstack,
+ (struct field *) obstack_alloc (&objfile -> type_obstack,
2 * sizeof (struct field));
TYPE_FIELD_BITPOS (range_type, 0) = lower;
TYPE_FIELD_BITPOS (range_type, 1) = upper;
TYPE_LENGTH (type) = (upper - lower + 1) * TYPE_LENGTH (element_type);
TYPE_NFIELDS (type) = 1;
TYPE_FIELDS (type) =
- (struct field *) obstack_alloc (symbol_obstack,
+ (struct field *) obstack_alloc (&objfile -> type_obstack,
sizeof (struct field));
TYPE_FIELD_TYPE (type, 0) = range_type;
and create and return a suitable type object.
Also defines the symbols that represent the values of the type. */
-struct type *
-read_enum_type (pp, type)
+static struct type *
+read_enum_type (pp, type, objfile)
register char **pp;
register struct type *type;
+ struct objfile *objfile;
{
register char *p;
char *name;
struct pending *osyms, *syms;
int o_nsyms;
+#if 0
+ /* FIXME! The stabs produced by Sun CC merrily define things that ought
+ to be file-scope, between N_FN entries, using N_LSYM. What's a mother
+ to do? For now, force all enum values to file scope. */
if (within_function)
symlist = &local_symbols;
else
+#endif
symlist = &file_symbols;
osyms = *symlist;
o_nsyms = osyms ? osyms->nsyms : 0;
/* Read the value-names and their values.
The input syntax is NAME:VALUE,NAME:VALUE, and so on.
- A semicolon or comman instead of a NAME means the end. */
+ A semicolon or comma instead of a NAME means the end. */
while (**pp && **pp != ';' && **pp != ',')
{
/* Check for and handle cretinous dbx symbol name continuation! */
p = *pp;
while (*p != ':') p++;
- name = obsavestring (*pp, p - *pp);
+ name = obsavestring (*pp, p - *pp, &objfile -> symbol_obstack);
*pp = p + 1;
n = read_number (pp, ',');
- sym = (struct symbol *) obstack_alloc (symbol_obstack, sizeof (struct symbol));
+ sym = (struct symbol *) obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol));
bzero (sym, sizeof (struct symbol));
SYMBOL_NAME (sym) = name;
SYMBOL_CLASS (sym) = LOC_CONST;
TYPE_LENGTH (type) = sizeof (int);
TYPE_CODE (type) = TYPE_CODE_ENUM;
TYPE_NFIELDS (type) = nsyms;
- TYPE_FIELDS (type) = (struct field *) obstack_alloc (symbol_obstack, sizeof (struct field) * nsyms);
+ TYPE_FIELDS (type) = (struct field *)
+ obstack_alloc (&objfile -> type_obstack,
+ sizeof (struct field) * nsyms);
/* Find the symbols for the values and put them into the type.
The symbols can be found in the symlist that we put them on
If encounter garbage, set *BITS to -1. */
-void
+static void
read_huge_number (pp, end, valu, bits)
char **pp;
int end;
}
}
-#define MAX_OF_C_TYPE(t) ((1 << (sizeof (t)*8 - 1)) - 1)
-#define MIN_OF_C_TYPE(t) (-(1 << (sizeof (t)*8 - 1)))
-
-struct type *
-read_range_type (pp, typenums)
+static struct type *
+read_range_type (pp, typenums, objfile)
char **pp;
int typenums[2];
+ struct objfile *objfile;
{
int rangenums[2];
long n2, n3;
/* Check for "long long". */
if (got_signed && nbits == TARGET_LONG_LONG_BIT)
- return builtin_type_long_long;
+ return (lookup_fundamental_type (objfile, FT_LONG_LONG));
if (got_unsigned && nbits == TARGET_LONG_LONG_BIT)
- return builtin_type_unsigned_long_long;
+ return (lookup_fundamental_type (objfile, FT_UNSIGNED_LONG_LONG));
if (got_signed || got_unsigned)
{
- result_type = (struct type *) obstack_alloc (symbol_obstack,
- sizeof (struct type));
+ result_type = (struct type *)
+ obstack_alloc (&objfile -> type_obstack,
+ sizeof (struct type));
bzero (result_type, sizeof (struct type));
+ TYPE_OBJFILE (result_type) = objfile;
TYPE_LENGTH (result_type) = nbits / TARGET_CHAR_BIT;
TYPE_CODE (result_type) = TYPE_CODE_INT;
if (got_unsigned)
/* A type defined as a subrange of itself, with bounds both 0, is void. */
if (self_subrange && n2 == 0 && n3 == 0)
- return builtin_type_void;
+ return (lookup_fundamental_type (objfile, FT_VOID));
/* If n3 is zero and n2 is not, we want a floating type,
and n2 is the width in bytes.
if (n3 == 0 && n2 > 0)
{
if (n2 == sizeof (float))
- return builtin_type_float;
- return builtin_type_double;
+ return (lookup_fundamental_type (objfile, FT_FLOAT));
+ return (lookup_fundamental_type (objfile, FT_DBL_PREC_FLOAT));
}
/* If the upper bound is -1, it must really be an unsigned int. */
long_kludge_name && ((long_kludge_name[0] == 'u' /* unsigned */ &&
long_kludge_name[9] == 'l' /* long */)
|| (long_kludge_name[0] == 'l' /* long unsigned */)))
- return builtin_type_unsigned_long;
+ return (lookup_fundamental_type (objfile, FT_UNSIGNED_LONG));
else
- return builtin_type_unsigned_int;
+ return (lookup_fundamental_type (objfile, FT_UNSIGNED_INTEGER));
}
/* Special case: char is defined (Who knows why) as a subrange of
itself with range 0-127. */
else if (self_subrange && n2 == 0 && n3 == 127)
- return builtin_type_char;
+ return (lookup_fundamental_type (objfile, FT_CHAR));
/* Assumptions made here: Subrange of self is equivalent to subrange
of int. FIXME: Host and target type-sizes assumed the same. */
some type to a builtin type with ==. Fix it! */
else if (n2 == 0
&& (self_subrange ||
- *dbx_lookup_type (rangenums) == builtin_type_int))
+ *dbx_lookup_type (rangenums) == lookup_fundamental_type (objfile, FT_INTEGER)))
{
/* an unsigned type */
#ifdef LONG_LONG
if (n3 == - sizeof (long long))
- return builtin_type_unsigned_long_long;
+ return (lookup_fundamental_type (objfile, FT_UNSIGNED_LONG_LONG));
#endif
/* FIXME -- the only way to distinguish `unsigned int' from `unsigned
long' is to look at its name! */
long_kludge_name && ((long_kludge_name[0] == 'u' /* unsigned */ &&
long_kludge_name[9] == 'l' /* long */)
|| (long_kludge_name[0] == 'l' /* long unsigned */)))
- return builtin_type_unsigned_long;
+ return (lookup_fundamental_type (objfile, FT_UNSIGNED_LONG));
if (n3 == (unsigned int)~0L)
- return builtin_type_unsigned_int;
+ return (lookup_fundamental_type (objfile, FT_UNSIGNED_INTEGER));
if (n3 == (unsigned short)~0L)
- return builtin_type_unsigned_short;
+ return (lookup_fundamental_type (objfile, FT_UNSIGNED_SHORT));
if (n3 == (unsigned char)~0L)
- return builtin_type_unsigned_char;
+ return (lookup_fundamental_type (objfile, FT_UNSIGNED_CHAR));
}
#ifdef LONG_LONG
else if (n3 == 0 && n2 == -sizeof (long long))
- return builtin_type_long_long;
+ return (lookup_fundamental_type (objfile, FT_LONG_LONG));
#endif
else if (n2 == -n3 -1)
{
/* a signed type */
/* FIXME -- the only way to distinguish `int' from `long' is to look
at its name! */
- if ((n3 == (1 << (8 * sizeof (long) - 1)) - 1) &&
+ if ((n3 ==(long)(((unsigned long)1 << (8 * sizeof (long) - 1)) - 1)) &&
long_kludge_name && long_kludge_name[0] == 'l' /* long */)
- return builtin_type_long;
- if (n3 == (1 << (8 * sizeof (int) - 1)) - 1)
- return builtin_type_int;
- if (n3 == (1 << (8 * sizeof (short) - 1)) - 1)
- return builtin_type_short;
- if (n3 == (1 << (8 * sizeof (char) - 1)) - 1)
- return builtin_type_char;
+ return (lookup_fundamental_type (objfile, FT_LONG));
+ if (n3 == (long)(((unsigned long)1 << (8 * sizeof (int) - 1)) - 1))
+ return (lookup_fundamental_type (objfile, FT_INTEGER));
+ if (n3 == ( 1 << (8 * sizeof (short) - 1)) - 1)
+ return (lookup_fundamental_type (objfile, FT_SHORT));
+ if (n3 == ( 1 << (8 * sizeof (char) - 1)) - 1)
+ return (lookup_fundamental_type (objfile, FT_CHAR));
}
/* We have a real range type on our hands. Allocate space and
if (self_subrange)
return error_type (pp);
- result_type = (struct type *) obstack_alloc (symbol_obstack,
- sizeof (struct type));
+ result_type = (struct type *)
+ obstack_alloc (&objfile -> type_obstack, sizeof (struct type));
bzero (result_type, sizeof (struct type));
+ TYPE_OBJFILE (result_type) = objfile;
TYPE_CODE (result_type) = TYPE_CODE_RANGE;
TYPE_TARGET_TYPE (result_type) = *dbx_lookup_type(rangenums);
if (TYPE_TARGET_TYPE (result_type) == 0) {
- complain (&range_type_base_complaint, rangenums[1]);
- TYPE_TARGET_TYPE (result_type) = builtin_type_int;
+ complain (&range_type_base_complaint, (char *) rangenums[1]);
+ TYPE_TARGET_TYPE (result_type) = lookup_fundamental_type (objfile, FT_INTEGER);
}
TYPE_NFIELDS (result_type) = 2;
TYPE_FIELDS (result_type) =
- (struct field *) obstack_alloc (symbol_obstack,
- 2 * sizeof (struct field));
+ (struct field *) obstack_alloc (&objfile -> type_obstack,
+ 2 * sizeof (struct field));
bzero (TYPE_FIELDS (result_type), 2 * sizeof (struct field));
TYPE_FIELD_BITPOS (result_type, 0) = n2;
TYPE_FIELD_BITPOS (result_type, 1) = n3;
/* 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. */
-struct type **
-read_args (pp, end)
+static struct type **
+read_args (pp, end, objfile)
char **pp;
int end;
+ struct objfile *objfile;
{
/* FIXME! Remove this arbitrary limit! */
struct type *types[1024], **rval; /* allow for fns of 1023 parameters */
if (**pp == '\\')
*pp = next_symbol_text ();
- types[n++] = read_type (pp);
+ types[n++] = read_type (pp, objfile);
}
*pp += 1; /* get past `end' (the ':' character) */