/* Read a symbol table in ECOFF format (Third-Eye).
- Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
- 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009, 2010,
- 2011 Free Software Foundation, Inc.
+ Copyright (C) 1986-2016 Free Software Foundation, Inc.
Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
#include "symtab.h"
#include "gdbtypes.h"
#include "gdbcore.h"
+#include "filenames.h"
#include "objfiles.h"
#include "gdb_obstack.h"
#include "buildsym.h"
#include "stabsread.h"
#include "complaints.h"
#include "demangle.h"
-#include "gdb_assert.h"
+#include "gdb-demangle.h"
#include "block.h"
#include "dictionary.h"
#include "mdebugread.h"
-#include "gdb_stat.h"
-#include "gdb_string.h"
+#include <sys/stat.h>
#include "psympriv.h"
+#include "source.h"
#include "bfd.h"
case the symbol's ELF section could not be represented in ECOFF. */
#define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
&& bfd_get_section_by_name (bfd, ".mdebug") != NULL)
+
+/* The objfile we are currently reading. */
+
+static struct objfile *mdebugread_objfile;
+
\f
/* We put a pointer to this structure in the read_symtab_private field
static struct block *new_block (enum block_type);
-static struct symtab *new_symtab (const char *, int, struct objfile *);
+static struct compunit_symtab *new_symtab (const char *, int, struct objfile *);
static struct linetable *new_linetable (int);
static struct type *parse_type (int, union aux_ext *, unsigned int, int *,
int, char *);
-static struct symbol *mylookup_symbol (char *, struct block *, domain_enum,
- enum address_class);
+static struct symbol *mylookup_symbol (char *, const struct block *,
+ domain_enum, enum address_class);
static void sort_blocks (struct symtab *);
static struct partial_symtab *new_psymtab (char *, struct objfile *);
-static void psymtab_to_symtab_1 (struct partial_symtab *, const char *);
+static void psymtab_to_symtab_1 (struct objfile *objfile,
+ struct partial_symtab *, const char *);
static void add_block (struct block *, struct symtab *);
static char *mdebug_next_symbol_text (struct objfile *);
\f
-/* Exported procedure: Builds a symtab from the PST partial one.
- Restores the environment in effect when PST was created, delegates
+/* Exported procedure: Builds a symtab from the partial symtab SELF.
+ Restores the environment in effect when SELF was created, delegates
most of the work to an ancillary procedure, and sorts
- and reorders the symtab list at the end. */
+ and reorders the symtab list at the end. SELF is not NULL. */
static void
-mdebug_psymtab_to_symtab (struct partial_symtab *pst)
+mdebug_read_symtab (struct partial_symtab *self, struct objfile *objfile)
{
- if (!pst)
- return;
-
if (info_verbose)
{
- printf_filtered (_("Reading in symbols for %s..."), pst->filename);
+ printf_filtered (_("Reading in symbols for %s..."), self->filename);
gdb_flush (gdb_stdout);
}
next_symbol_text_func = mdebug_next_symbol_text;
- psymtab_to_symtab_1 (pst, pst->filename);
+ psymtab_to_symtab_1 (objfile, self, self->filename);
/* Match with global symbols. This only needs to be done once,
after all of the symtabs and dependencies have been read in. */
- scan_file_globals (pst->objfile);
+ scan_file_globals (objfile);
if (info_verbose)
printf_filtered (_("done.\n"));
info->fdr = (FDR *) obstack_alloc (&objfile->objfile_obstack,
(info->symbolic_header.ifdMax
* sizeof (FDR)));
- fdr_src = info->external_fdr;
+ fdr_src = (char *) info->external_fdr;
fdr_end = (fdr_src
+ info->symbolic_header.ifdMax * swap->external_fdr_size);
fdr_ptr = info->fdr;
static void
push_parse_stack (void)
{
- struct parse_stack *new;
+ struct parse_stack *newobj;
/* Reuse frames if possible. */
if (top_stack && top_stack->prev)
- new = top_stack->prev;
+ newobj = top_stack->prev;
else
- new = (struct parse_stack *) xzalloc (sizeof (struct parse_stack));
+ newobj = XCNEW (struct parse_stack);
/* Initialize new frame with previous content. */
if (top_stack)
{
- struct parse_stack *prev = new->prev;
+ struct parse_stack *prev = newobj->prev;
- *new = *top_stack;
- top_stack->prev = new;
- new->prev = prev;
- new->next = top_stack;
+ *newobj = *top_stack;
+ top_stack->prev = newobj;
+ newobj->prev = prev;
+ newobj->next = top_stack;
}
- top_stack = new;
+ top_stack = newobj;
}
/* Exit a lexical context. */
};
-/* The pending information is kept for an entire object file, and used
- to be in the deprecated_sym_private field. I took it out when I
- split mdebugread from mipsread, because this might not be the only
- type of symbols read from an object file. Instead, we allocate the
- pending information table when we create the partial symbols, and
- we store a pointer to the single table in each psymtab. */
+/* The pending information is kept for an entire object file. We
+ allocate the pending information table when we create the partial
+ symbols, and we store a pointer to the single table in each
+ psymtab. */
static struct mdebug_pending **pending_list;
if (!p)
{
p = ((struct mdebug_pending *)
- obstack_alloc (¤t_objfile->objfile_obstack,
+ obstack_alloc (&mdebugread_objfile->objfile_obstack,
sizeof (struct mdebug_pending)));
p->s = sh;
p->t = t;
/* Parsing Routines proper. */
+static void
+reg_value_complaint (int regnum, int num_regs, const char *sym)
+{
+ complaint (&symfile_complaints,
+ _("bad register number %d (max %d) in symbol %s"),
+ regnum, num_regs - 1, sym);
+}
+
/* Parse a single symbol. Mostly just make up a GDB symbol for it.
For blocks, procedures and types we open a new lexical context.
This is basically just a big switch on the symbol's type. Argument
static int
mdebug_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
{
- return gdbarch_ecoff_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
+ int regno = gdbarch_ecoff_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
+
+ if (regno < 0
+ || regno >= (gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch)))
+ {
+ reg_value_complaint (regno,
+ gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch),
+ SYMBOL_PRINT_NAME (sym));
+
+ regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless. */
+ }
+
+ return regno;
}
static const struct symbol_register_ops mdebug_register_funcs = {
mdebug_reg_to_regnum
};
+/* The "aclass" indices for computed symbols. */
+
+static int mdebug_register_index;
+static int mdebug_regparm_index;
+
+/* Common code for symbols describing data. */
+
+static void
+add_data_symbol (SYMR *sh, union aux_ext *ax, int bigend,
+ struct symbol *s, int aclass_index, struct block *b,
+ struct objfile *objfile, char *name)
+{
+ SYMBOL_DOMAIN (s) = VAR_DOMAIN;
+ SYMBOL_ACLASS_INDEX (s) = aclass_index;
+ add_symbol (s, top_stack->cur_st, b);
+
+ /* 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) = 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. */
+}
+
static int
parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
struct section_offsets *section_offsets, struct objfile *objfile)
struct type *t;
struct field *f;
int count = 1;
- enum address_class class;
TIR tir;
long svalue = sh->value;
int bitsize;
break;
case stGlobal: /* External symbol, goes into global block. */
- class = LOC_STATIC;
- b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
+ b = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (top_stack->cur_st),
GLOBAL_BLOCK);
s = new_symbol (name);
SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
- goto data;
+ add_data_symbol (sh, ax, bigend, s, LOC_STATIC, b, objfile, name);
+ break;
case stStatic: /* Static data, goes into current block. */
- class = LOC_STATIC;
b = top_stack->cur_block;
s = new_symbol (name);
if (SC_IS_COMMON (sh->sc))
}
else
SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
- goto data;
+ add_data_symbol (sh, ax, bigend, s, LOC_STATIC, b, objfile, name);
+ break;
case stLocal: /* Local variable, goes into current block. */
b = top_stack->cur_block;
s = new_symbol (name);
SYMBOL_VALUE (s) = svalue;
if (sh->sc == scRegister)
- {
- class = LOC_REGISTER;
- SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
- }
- else
- class = LOC_LOCAL;
-
- data: /* Common code for symbols describing data. */
- SYMBOL_DOMAIN (s) = VAR_DOMAIN;
- SYMBOL_CLASS (s) = class;
- add_symbol (s, top_stack->cur_st, b);
-
- /* 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) = objfile_type (objfile)->nodebug_data_symbol;
+ add_data_symbol (sh, ax, bigend, s, mdebug_register_index,
+ b, objfile, name);
else
- SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
- /* Value of a data symbol is its memory address. */
+ add_data_symbol (sh, ax, bigend, s, LOC_LOCAL,
+ b, objfile, name);
break;
case stParam: /* Arg to procedure, goes into current
{
case scRegister:
/* Pass by value in register. */
- SYMBOL_CLASS (s) = LOC_REGISTER;
- SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
+ SYMBOL_ACLASS_INDEX (s) = mdebug_register_index;
break;
case scVar:
/* Pass by reference on stack. */
- SYMBOL_CLASS (s) = LOC_REF_ARG;
+ SYMBOL_ACLASS_INDEX (s) = LOC_REF_ARG;
break;
case scVarRegister:
/* Pass by reference in register. */
- SYMBOL_CLASS (s) = LOC_REGPARM_ADDR;
- SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
+ SYMBOL_ACLASS_INDEX (s) = mdebug_regparm_index;
break;
default:
/* Pass by value on stack. */
- SYMBOL_CLASS (s) = LOC_ARG;
+ SYMBOL_ACLASS_INDEX (s) = LOC_ARG;
break;
}
SYMBOL_VALUE (s) = svalue;
case stLabel: /* label, goes into current block. */
s = new_symbol (name);
SYMBOL_DOMAIN (s) = VAR_DOMAIN; /* So that it can be used */
- SYMBOL_CLASS (s) = LOC_LABEL; /* but not misused. */
+ SYMBOL_ACLASS_INDEX (s) = LOC_LABEL; /* but not misused. */
SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int;
add_symbol (s, top_stack->cur_st, top_stack->cur_block);
}
s = new_symbol (name);
SYMBOL_DOMAIN (s) = VAR_DOMAIN;
- SYMBOL_CLASS (s) = LOC_BLOCK;
+ SYMBOL_ACLASS_INDEX (s) = LOC_BLOCK;
/* Type of the return value. */
if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
t = objfile_type (objfile)->builtin_int;
b = top_stack->cur_block;
if (sh->st == stProc)
{
- struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
+ const struct blockvector *bv
+ = SYMTAB_BLOCKVECTOR (top_stack->cur_st);
/* The next test should normally be true, but provides a
hook for nested functions (which we don't want to make
tsym.st);
}
}
- end_of_fields:;
+ end_of_fields:
/* In an stBlock, there is no way to distinguish structs,
unions, and enums at this point. This is a bug in the
if (sh->iss == 0 || name[0] == '.' || name[0] == '\0')
TYPE_TAG_NAME (t) = NULL;
else
- TYPE_TAG_NAME (t) = obconcat (¤t_objfile->objfile_obstack,
+ TYPE_TAG_NAME (t) = obconcat (&mdebugread_objfile->objfile_obstack,
name, (char *) NULL);
TYPE_CODE (t) = type_code;
if (tsym.st != stMember)
break;
- SET_FIELD_BITPOS (*f, tsym.value);
+ SET_FIELD_ENUMVAL (*f, tsym.value);
FIELD_TYPE (*f) = t;
FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss;
FIELD_BITSIZE (*f) = 0;
- enum_sym = ((struct symbol *)
- obstack_alloc (¤t_objfile->objfile_obstack,
- sizeof (struct symbol)));
- memset (enum_sym, 0, sizeof (struct symbol));
+ enum_sym = allocate_symbol (mdebugread_objfile);
SYMBOL_SET_LINKAGE_NAME
- (enum_sym, obsavestring (f->name, strlen (f->name),
- ¤t_objfile->objfile_obstack));
- SYMBOL_CLASS (enum_sym) = LOC_CONST;
+ (enum_sym,
+ (char *) obstack_copy0 (&mdebugread_objfile->objfile_obstack,
+ f->name, strlen (f->name)));
+ SYMBOL_ACLASS_INDEX (enum_sym) = LOC_CONST;
SYMBOL_TYPE (enum_sym) = t;
SYMBOL_DOMAIN (enum_sym) = VAR_DOMAIN;
SYMBOL_VALUE (enum_sym) = tsym.value;
s = new_symbol (name);
SYMBOL_DOMAIN (s) = STRUCT_DOMAIN;
- SYMBOL_CLASS (s) = LOC_TYPEDEF;
+ SYMBOL_ACLASS_INDEX (s) = LOC_TYPEDEF;
SYMBOL_VALUE (s) = 0;
SYMBOL_TYPE (s) = t;
add_symbol (s, top_stack->cur_st, top_stack->cur_block);
top_stack->blocktype == stStaticProc))
{
/* Finished with procedure */
- struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
+ const struct blockvector *bv
+ = SYMTAB_BLOCKVECTOR (top_stack->cur_st);
struct mdebug_extra_func_info *e;
struct block *b = top_stack->cur_block;
struct type *ftype = top_stack->cur_type;
/* Make up special symbol to contain procedure specific info. */
s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
- SYMBOL_CLASS (s) = LOC_CONST;
- SYMBOL_TYPE (s) = objfile_type (current_objfile)->builtin_void;
+ SYMBOL_ACLASS_INDEX (s) = LOC_CONST;
+ SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->builtin_void;
e = ((struct mdebug_extra_func_info *)
- obstack_alloc (¤t_objfile->objfile_obstack,
+ obstack_alloc (&mdebugread_objfile->objfile_obstack,
sizeof (struct mdebug_extra_func_info)));
memset (e, 0, sizeof (struct mdebug_extra_func_info));
SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
if (nparams > 0)
{
- struct dict_iterator iter;
+ struct block_iterator iter;
TYPE_NFIELDS (ftype) = nparams;
TYPE_FIELDS (ftype) = (struct field *)
break;
s = new_symbol (name);
SYMBOL_DOMAIN (s) = VAR_DOMAIN;
- SYMBOL_CLASS (s) = LOC_TYPEDEF;
+ SYMBOL_ACLASS_INDEX (s) = LOC_TYPEDEF;
SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block;
SYMBOL_TYPE (s) = t;
add_symbol (s, top_stack->cur_st, top_stack->cur_block);
basic_type (int bt, struct objfile *objfile)
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
- struct type **map_bt = objfile_data (objfile, basic_type_data);
+ struct type **map_bt
+ = (struct type **) objfile_data (objfile, basic_type_data);
struct type *tp;
if (bt >= btMax)
break;
case btAdr:
- tp = init_type (TYPE_CODE_PTR, 4, TYPE_FLAG_UNSIGNED,
- "adr_32", objfile);
- TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void;
+ tp = init_pointer_type (objfile, 32, "adr_32",
+ objfile_type (objfile)->builtin_void);
break;
case btChar:
- tp = init_type (TYPE_CODE_INT, 1, 0,
- "char", objfile);
+ tp = init_integer_type (objfile, 8, 0, "char");
+ TYPE_NOSIGN (tp) = 1;
break;
case btUChar:
- tp = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
- "unsigned char", objfile);
+ tp = init_integer_type (objfile, 8, 1, "unsigned char");
break;
case btShort:
- tp = init_type (TYPE_CODE_INT, 2, 0,
- "short", objfile);
+ tp = init_integer_type (objfile, 16, 0, "short");
break;
case btUShort:
- tp = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
- "unsigned short", objfile);
+ tp = init_integer_type (objfile, 16, 1, "unsigned short");
break;
case btInt:
- tp = init_type (TYPE_CODE_INT, 4, 0,
- "int", objfile);
+ tp = init_integer_type (objfile, 32, 0, "int");
break;
case btUInt:
- tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
- "unsigned int", objfile);
+ tp = init_integer_type (objfile, 32, 1, "unsigned int");
break;
case btLong:
- tp = init_type (TYPE_CODE_INT, 4, 0,
- "long", objfile);
+ tp = init_integer_type (objfile, 32, 0, "long");
break;
case btULong:
- tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
- "unsigned long", objfile);
+ tp = init_integer_type (objfile, 32, 1, "unsigned long");
break;
case btFloat:
- tp = init_type (TYPE_CODE_FLT,
- gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
- "float", objfile);
+ tp = init_float_type (objfile, gdbarch_float_bit (gdbarch),
+ "float", gdbarch_float_format (gdbarch));
break;
case btDouble:
- tp = init_type (TYPE_CODE_FLT,
- gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
- "double", objfile);
+ tp = init_float_type (objfile, gdbarch_double_bit (gdbarch),
+ "double", gdbarch_double_format (gdbarch));
break;
case btComplex:
- tp = init_type (TYPE_CODE_COMPLEX,
- 2 * gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
- "complex", objfile);
- TYPE_TARGET_TYPE (tp) = basic_type (btFloat, objfile);
+ tp = init_complex_type (objfile, "complex",
+ basic_type (btFloat, objfile));
break;
case btDComplex:
- tp = init_type (TYPE_CODE_COMPLEX,
- 2 * gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
- "double complex", objfile);
- TYPE_TARGET_TYPE (tp) = basic_type (btDouble, objfile);
+ tp = init_complex_type (objfile, "double complex",
+ basic_type (btFloat, objfile));
break;
case btFixedDec:
/* We use TYPE_CODE_INT to print these as integers. Does this do any
good? Would we be better off with TYPE_CODE_ERROR? Should
TYPE_CODE_ERROR print things in hex if it knows the size? */
- tp = init_type (TYPE_CODE_INT,
- gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, 0,
- "fixed decimal", objfile);
+ tp = init_integer_type (objfile, gdbarch_int_bit (gdbarch), 0,
+ "fixed decimal");
break;
case btFloatDec:
- tp = init_type (TYPE_CODE_ERROR,
- gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
- "floating decimal", objfile);
+ tp = init_type (objfile, TYPE_CODE_ERROR,
+ gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT,
+ "floating decimal");
break;
case btString:
/* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
FIXME. */
- tp = init_type (TYPE_CODE_STRING, 1, 0,
- "string", objfile);
+ tp = init_type (objfile, TYPE_CODE_STRING, 1, "string");
break;
case btVoid:
break;
case btLong64:
- tp = init_type (TYPE_CODE_INT, 8, 0,
- "long", objfile);
+ tp = init_integer_type (objfile, 64, 0, "long");
break;
case btULong64:
- tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
- "unsigned long", objfile);
+ tp = init_integer_type (objfile, 64, 1, "unsigned long");
break;
case btLongLong64:
- tp = init_type (TYPE_CODE_INT, 8, 0,
- "long long", objfile);
+ tp = init_integer_type (objfile, 64, 0, "long long");
break;
case btULongLong64:
- tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
- "unsigned long long", objfile);
+ tp = init_integer_type (objfile, 64, 1, "unsigned long long");
break;
case btAdr64:
- tp = init_type (TYPE_CODE_PTR, 8, TYPE_FLAG_UNSIGNED,
- "adr_64", objfile);
- TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void;
+ tp = init_pointer_type (objfile, 64, "adr_64",
+ objfile_type (objfile)->builtin_void);
break;
case btInt64:
- tp = init_type (TYPE_CODE_INT, 8, 0,
- "int", objfile);
+ tp = init_integer_type (objfile, 64, 0, "int");
break;
case btUInt64:
- tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
- "unsigned int", objfile);
+ tp = init_integer_type (objfile, 64, 1, "unsigned int");
break;
default:
/* Handle undefined types, they have indexNil. */
if (aux_index == indexNil)
- return basic_type (btInt, current_objfile);
+ return basic_type (btInt, mdebugread_objfile);
/* Handle corrupt aux indices. */
if (aux_index >= (debug_info->fdr + fd)->caux)
{
index_complaint (sym_name);
- return basic_type (btInt, current_objfile);
+ return basic_type (btInt, mdebugread_objfile);
}
ax += aux_index;
/* Use aux as a type information record, map its basic type. */
(*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
- tp = basic_type (t->bt, current_objfile);
+ tp = basic_type (t->bt, mdebugread_objfile);
if (tp == NULL)
{
/* Cannot use builtin types -- build our own. */
break;
default:
basic_type_complaint (t->bt, sym_name);
- return basic_type (btInt, current_objfile);
+ return basic_type (btInt, mdebugread_objfile);
}
}
as short and unsigned short types with a field width of 8.
Enum types also have a field width which we ignore for now. */
if (t->bt == btShort && width == 8)
- tp = basic_type (btChar, current_objfile);
+ tp = basic_type (btChar, mdebugread_objfile);
else if (t->bt == btUShort && width == 8)
- tp = basic_type (btUChar, current_objfile);
+ tp = basic_type (btUChar, mdebugread_objfile);
else if (t->bt == btEnum)
;
else
{
complaint (&symfile_complaints,
_("unable to cross ref btIndirect for %s"), sym_name);
- return basic_type (btInt, current_objfile);
+ return basic_type (btInt, mdebugread_objfile);
}
xref_fh = get_rfd (fd, rf);
xref_fd = xref_fh - debug_info->fdr;
/* Try to cross reference this type, build new type on failure. */
ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
if (tp == (struct type *) NULL)
- tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
+ tp = init_type (mdebugread_objfile, type_code, 0, NULL);
/* DEC c89 produces cross references to qualified aggregate types,
dereference them. */
else if (TYPE_TAG_NAME (tp) == NULL
|| strcmp (TYPE_TAG_NAME (tp), name) != 0)
TYPE_TAG_NAME (tp)
- = obsavestring (name, strlen (name),
- ¤t_objfile->objfile_obstack);
+ = ((const char *)
+ obstack_copy0 (&mdebugread_objfile->objfile_obstack,
+ name, strlen (name)));
}
}
/* Try to cross reference this type, build new type on failure. */
ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
if (tp == (struct type *) NULL)
- tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
+ tp = init_type (mdebugread_objfile, type_code, 0, NULL);
/* Make sure that TYPE_CODE(tp) has an expected type code.
Any type may be returned from cross_ref if file indirect entries
}
if (TYPE_NAME (tp) == NULL
|| strcmp (TYPE_NAME (tp), name) != 0)
- TYPE_NAME (tp) = obsavestring (name, strlen (name),
- ¤t_objfile->objfile_obstack);
+ TYPE_NAME (tp)
+ = ((const char *)
+ obstack_copy0 (&mdebugread_objfile->objfile_obstack,
+ name, strlen (name)));
}
}
if (t->bt == btTypedef)
{
complaint (&symfile_complaints,
_("unable to cross ref btTypedef for %s"), sym_name);
- tp = basic_type (btInt, current_objfile);
+ tp = basic_type (btInt, mdebugread_objfile);
}
}
complaint (&symfile_complaints,
_("illegal array index type for %s, assuming int"),
sym_name);
- indx = objfile_type (current_objfile)->builtin_int;
+ indx = objfile_type (mdebugread_objfile)->builtin_int;
}
/* Get the bounds, and create the array type. */
ax++;
rf = AUX_GET_WIDTH (bigend, ax); /* bit size of array element */
- range = create_range_type ((struct type *) NULL, indx,
- lower, upper);
+ range = create_static_range_type ((struct type *) NULL, indx,
+ lower, upper);
t = create_array_type ((struct type *) NULL, *tpp, range);
to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol
in question, or NULL to use top_stack->cur_block. */
-static void parse_procedure (PDR *, struct symtab *, struct partial_symtab *);
-
static void
-parse_procedure (PDR *pr, struct symtab *search_symtab,
+parse_procedure (PDR *pr, struct compunit_symtab *search_symtab,
struct partial_symtab *pst)
{
struct symbol *s, *i;
- struct block *b;
+ const struct block *b;
char *sh_name;
/* Simple rule to find files linked "-x". */
#else
s = mylookup_symbol
(sh_name,
- BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK),
+ BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (search_symtab),
+ STATIC_BLOCK),
VAR_DOMAIN,
LOC_BLOCK);
#endif
if (processing_gcc_compilation == 0
&& found_ecoff_debugging_info == 0
&& TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID)
- SYMBOL_TYPE (s) = objfile_type (pst->objfile)->nodebug_text_symbol;
+ SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->nodebug_text_symbol;
}
/* Parse the external symbol ES. Just call parse_symbol() after
struct objfile *objfile)
{
int section;
- asection *bfd_section;
switch (storage_class)
{
case scText:
section = SECT_OFF_TEXT (objfile);
- bfd_section = bfd_get_section_by_name (cur_bfd, ".text");
break;
case scData:
section = SECT_OFF_DATA (objfile);
- bfd_section = bfd_get_section_by_name (cur_bfd, ".data");
break;
case scBss:
section = SECT_OFF_BSS (objfile);
- bfd_section = bfd_get_section_by_name (cur_bfd, ".bss");
break;
case scSData:
section = get_section_index (objfile, ".sdata");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".sdata");
break;
case scSBss:
section = get_section_index (objfile, ".sbss");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".sbss");
break;
case scRData:
section = get_section_index (objfile, ".rdata");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".rdata");
break;
case scInit:
section = get_section_index (objfile, ".init");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".init");
break;
case scXData:
section = get_section_index (objfile, ".xdata");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".xdata");
break;
case scPData:
section = get_section_index (objfile, ".pdata");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".pdata");
break;
case scFini:
section = get_section_index (objfile, ".fini");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".fini");
break;
case scRConst:
section = get_section_index (objfile, ".rconst");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".rconst");
break;
#ifdef scTlsData
case scTlsData:
section = get_section_index (objfile, ".tlsdata");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsdata");
break;
#endif
#ifdef scTlsBss
case scTlsBss:
section = get_section_index (objfile, ".tlsbss");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsbss");
break;
#endif
default:
/* This kind of symbol is not associated to a section. */
section = -1;
- bfd_section = NULL;
}
prim_record_minimal_symbol_and_info (name, address, ms_type,
- section, bfd_section, objfile);
+ section, objfile);
}
/* Master parsing procedure for first-pass reading of file symbols
SYMR sh;
struct partial_symtab *pst;
int textlow_not_set = 1;
- int past_first_source_file = 0;
/* List of current psymtab's include files. */
- char **psymtab_include_list;
+ const char **psymtab_include_list;
int includes_allocated;
int includes_used;
EXTR *extern_tab;
includes_allocated = 30;
includes_used = 0;
- psymtab_include_list = (char **) alloca (includes_allocated *
- sizeof (char *));
+ psymtab_include_list = (const char **) alloca (includes_allocated *
+ sizeof (const char *));
next_symbol_text_func = mdebug_next_symbol_text;
dependencies_allocated = 30;
(struct partial_symtab **) alloca (dependencies_allocated *
sizeof (struct partial_symtab *));
- last_source_file = NULL;
+ set_last_source_file (NULL);
/*
* Big plan:
/* Allocate the map FDR -> PST.
Minor hack: -O3 images might claim some global data belongs
to FDR -1. We`ll go along with that. */
- fdr_to_pst = (struct pst_map *)
- xzalloc ((hdr->ifdMax + 1) * sizeof *fdr_to_pst);
+ fdr_to_pst = XCNEWVEC (struct pst_map, hdr->ifdMax + 1);
old_chain = make_cleanup (xfree, fdr_to_pst);
fdr_to_pst++;
{
hdr->ifdMax * sizeof (struct mdebug_pending *));
/* Pass 0 over external syms: swap them in. */
- ext_block = (EXTR *) xmalloc (hdr->iextMax * sizeof (EXTR));
+ ext_block = XNEWVEC (EXTR, hdr->iextMax);
make_cleanup (xfree, ext_block);
ext_out = (char *) debug_info->external_ext;
{
case stProc:
/* Beginnning of Procedure */
- svalue += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
break;
case stStaticProc:
/* Load time only static procs */
ms_type = mst_file_text;
- svalue += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
break;
case stGlobal:
/* External symbol */
else if (SC_IS_DATA (ext_in->asym.sc))
{
ms_type = mst_data;
- svalue += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
}
else if (SC_IS_BSS (ext_in->asym.sc))
{
ms_type = mst_bss;
- svalue += ANOFFSET (objfile->section_offsets,
- SECT_OFF_BSS (objfile));
}
else if (SC_IS_SBSS (ext_in->asym.sc))
{
ms_type = mst_bss;
- svalue += ANOFFSET (objfile->section_offsets,
- get_section_index (objfile, ".sbss"));
}
else
ms_type = mst_abs;
continue;
ms_type = mst_file_text;
- svalue += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
}
else if (SC_IS_DATA (ext_in->asym.sc))
{
continue;
ms_type = mst_file_data;
- svalue += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
}
else if (SC_IS_BSS (ext_in->asym.sc))
{
continue;
ms_type = mst_file_bss;
- svalue += ANOFFSET (objfile->section_offsets,
- SECT_OFF_BSS (objfile));
}
else if (SC_IS_SBSS (ext_in->asym.sc))
{
continue;
ms_type = mst_file_bss;
- svalue += ANOFFSET (objfile->section_offsets, sbss_sect_index);
}
else
ms_type = mst_abs;
}
else
textlow = 0;
- pst = start_psymtab_common (objfile, objfile->section_offsets,
+ pst = start_psymtab_common (objfile,
fdr_name (fh),
textlow,
objfile->global_psymbols.next,
PENDING_LIST (pst) = pending_list;
/* The way to turn this into a symtab is to call... */
- pst->read_symtab = mdebug_psymtab_to_symtab;
+ pst->read_symtab = mdebug_read_symtab;
/* Set up language for the pst.
The language from the FDR is used if it is unambigious (e.g. cfront
for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
{
int type_code;
- char *namestring;
+ const char *namestring;
(*swap_sym_in) (cur_bfd,
(((char *) debug_info->external_sym)
CORE_ADDR procaddr;
long isym;
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
if (sh.st == stStaticProc)
{
namestring = debug_info->ss + fh->issBase + sh.iss;
mst_file_text, sh.sc,
objfile);
}
+ sh.value += ANOFFSET (objfile->section_offsets,
+ SECT_OFF_TEXT (objfile));
procaddr = sh.value;
isym = AUX_GET_ISYM (fh->fBigendian,
case scPData:
case scXData:
namestring = debug_info->ss + fh->issBase + sh.iss;
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
record_minimal_symbol (namestring, sh.value,
mst_file_data, sh.sc,
objfile);
+ sh.value += ANOFFSET (objfile->section_offsets,
+ SECT_OFF_DATA (objfile));
break;
default:
/* FIXME! Shouldn't this use cases for bss,
then have the default be abs? */
namestring = debug_info->ss + fh->issBase + sh.iss;
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_BSS (objfile));
record_minimal_symbol (namestring, sh.value,
mst_file_bss, sh.sc,
objfile);
+ sh.value += ANOFFSET (objfile->section_offsets,
+ SECT_OFF_BSS (objfile));
break;
}
}
/* Concatinate stabstring2 with stabstring1. */
if (stabstring
&& stabstring != debug_info->ss + fh->issBase + sh.iss)
- stabstring = xrealloc (stabstring, len + len2 + 1);
+ stabstring
+ = (char *) xrealloc (stabstring, len + len2 + 1);
else
{
- stabstring = xmalloc (len + len2 + 1);
+ stabstring = (char *) xmalloc (len + len2 + 1);
strcpy (stabstring, stabstring1);
}
strcpy (stabstring + len, stabstring2);
case N_ABS | N_EXT:
record_it:
- continue;
+ continue;
/* Standard, local, non-debugger, symbols. */
case N_SO:
{
- CORE_ADDR valu;
static int prev_so_symnum = -10;
- static int first_so_symnum;
- char *p;
- int prev_textlow_not_set;
-
- valu = sh.value + ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
-
- prev_textlow_not_set = textlow_not_set;
+ const char *p;
/* A zero value is probably an indication for the
- SunPRO 3.0 compiler. end_psymtab explicitly tests
+ SunPRO 3.0 compiler. dbx_end_psymtab explicitly tests
for zero, so don't relocate it. */
if (sh.value == 0
&& gdbarch_sofun_address_maybe_missing (gdbarch))
- {
- textlow_not_set = 1;
- valu = 0;
- }
+ textlow_not_set = 1;
else
textlow_not_set = 0;
- past_first_source_file = 1;
-
if (prev_so_symnum != symnum - 1)
{ /* Here if prev stab wasn't N_SO. */
- first_so_symnum = symnum;
-
if (pst)
{
pst = (struct partial_symtab *) 0;
the second the file name. If pst exists, is
empty, and has a filename ending in '/', we assume
the previous N_SO was a directory name. */
-
- p = strrchr (namestring, '/');
- if (p && *(p + 1) == '\000')
+ p = lbasename (namestring);
+ if (p != namestring && *p == '\000')
continue; /* Simply ignore directory
name SOs. */
work (I suppose the psymtab_include_list could be
hashed or put in a binary tree, if profiling shows
this is a major hog). */
- if (pst && strcmp (namestring, pst->filename) == 0)
+ if (pst && filename_cmp (namestring, pst->filename) == 0)
continue;
{
int i;
for (i = 0; i < includes_used; i++)
- if (strcmp (namestring,
- psymtab_include_list[i]) == 0)
+ if (filename_cmp (namestring,
+ psymtab_include_list[i]) == 0)
{
i = -1;
break;
psymtab_include_list[includes_used++] = namestring;
if (includes_used >= includes_allocated)
{
- char **orig = psymtab_include_list;
+ const char **orig = psymtab_include_list;
- psymtab_include_list = (char **)
+ psymtab_include_list = (const char **)
alloca ((includes_allocated *= 2) *
- sizeof (char *));
+ sizeof (const char *));
memcpy (psymtab_include_list, orig,
- includes_used * sizeof (char *));
+ includes_used * sizeof (const char *));
}
continue;
}
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_STATIC,
&objfile->static_psymbols,
- 0, sh.value,
+ sh.value,
psymtab_language, objfile);
continue;
case 'G':
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_STATIC,
&objfile->global_psymbols,
- 0, sh.value,
+ sh.value,
psymtab_language, objfile);
continue;
add_psymbol_to_list (namestring, p - namestring, 1,
STRUCT_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- sh.value, 0,
- psymtab_language, objfile);
+ 0, psymtab_language, objfile);
if (p[2] == 't')
{
/* Also a typedef with the same name. */
p - namestring, 1,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- sh.value, 0,
- psymtab_language,
+ 0, psymtab_language,
objfile);
p += 1;
}
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- sh.value, 0,
- psymtab_language, objfile);
+ 0, psymtab_language, objfile);
}
check_enum:
/* If this is an enumerated type, we need to add
add_psymbol_to_list (p, q - p, 1,
VAR_DOMAIN, LOC_CONST,
&objfile->static_psymbols,
- 0, 0, psymtab_language,
+ 0, psymtab_language,
objfile);
/* Point past the name. */
p = q;
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_CONST,
&objfile->static_psymbols,
- sh.value, 0, psymtab_language,
- objfile);
+ 0, psymtab_language, objfile);
continue;
case 'f':
if (! pst)
{
int name_len = p - namestring;
- char *name = xmalloc (name_len + 1);
+ char *name = (char *) xmalloc (name_len + 1);
memcpy (name, namestring, name_len);
name[name_len] = '\0';
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->static_psymbols,
- 0, sh.value,
+ sh.value,
psymtab_language, objfile);
continue;
if (! pst)
{
int name_len = p - namestring;
- char *name = xmalloc (name_len + 1);
+ char *name = (char *) xmalloc (name_len + 1);
memcpy (name, namestring, name_len);
name[name_len] = '\0';
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->global_psymbols,
- 0, sh.value,
+ sh.value,
psymtab_language, objfile);
continue;
case N_ENDM:
/* Solaris 2 end of module, finish current partial
- symbol table. END_PSYMTAB will set
+ symbol table. dbx_end_psymtab will set
pst->texthigh to the proper value, which is
necessary if a module compiled without
debugging info follows this module. */
for (cur_sdx = 0; cur_sdx < fh->csym;)
{
char *name;
- enum address_class class;
+ enum address_class theclass;
+ CORE_ADDR minsym_value;
(*swap_sym_in) (cur_bfd,
((char *) debug_info->external_sym
name = debug_info->ss + fh->issBase + sh.iss;
+ minsym_value = sh.value;
+
switch (sh.sc)
{
case scText:
int new_sdx;
case stStaticProc:
- prim_record_minimal_symbol_and_info (name, sh.value,
+ prim_record_minimal_symbol_and_info (name, minsym_value,
mst_file_text,
SECT_OFF_TEXT (objfile),
- NULL, objfile);
+ objfile);
/* FALLTHROUGH */
add_psymbol_to_list (name, strlen (name), 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->global_psymbols,
- 0, sh.value, psymtab_language, objfile);
+ sh.value, psymtab_language, objfile);
else
add_psymbol_to_list (name, strlen (name), 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->static_psymbols,
- 0, sh.value, psymtab_language, objfile);
+ sh.value, psymtab_language, objfile);
procaddr = sh.value;
case stStatic: /* Variable */
if (SC_IS_DATA (sh.sc))
- prim_record_minimal_symbol_and_info (name, sh.value,
+ prim_record_minimal_symbol_and_info (name, minsym_value,
mst_file_data,
SECT_OFF_DATA (objfile),
- NULL,
objfile);
else
- prim_record_minimal_symbol_and_info (name, sh.value,
+ prim_record_minimal_symbol_and_info (name, minsym_value,
mst_file_bss,
SECT_OFF_BSS (objfile),
- NULL,
objfile);
- class = LOC_STATIC;
+ theclass = LOC_STATIC;
break;
case stIndirect: /* Irix5 forward declaration */
structs from alpha and mips cc. */
if (sh.iss == 0 || has_opaque_xref (fh, &sh))
goto skip;
- class = LOC_TYPEDEF;
+ theclass = LOC_TYPEDEF;
break;
case stConstant: /* Constant decl */
- class = LOC_CONST;
+ theclass = LOC_CONST;
break;
case stUnion:
add_psymbol_to_list (name, strlen (name), 1,
STRUCT_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- 0, (CORE_ADDR) 0,
- psymtab_language, objfile);
+ 0, psymtab_language, objfile);
}
handle_psymbol_enumerators (objfile, fh, sh.st, sh.value);
}
/* Use this gdb symbol. */
add_psymbol_to_list (name, strlen (name), 1,
- VAR_DOMAIN, class,
+ VAR_DOMAIN, theclass,
&objfile->static_psymbols,
- 0, sh.value, psymtab_language, objfile);
+ sh.value, psymtab_language, objfile);
skip:
cur_sdx++; /* Go to next file symbol. */
}
PST_PRIVATE (save_pst)->extern_tab = ext_ptr;
for (; --cur_sdx >= 0; ext_ptr++)
{
- enum address_class class;
+ enum address_class theclass;
SYMR *psh;
char *name;
CORE_ADDR svalue;
Ignore them, as parse_external will ignore them too. */
continue;
case stLabel:
- class = LOC_LABEL;
+ theclass = LOC_LABEL;
break;
default:
unknown_ext_complaint (debug_info->ssext + psh->iss);
if (SC_IS_COMMON (psh->sc))
continue;
- class = LOC_STATIC;
+ theclass = LOC_STATIC;
break;
}
name = debug_info->ssext + psh->iss;
add_psymbol_to_list (name, strlen (name), 1,
- VAR_DOMAIN, class,
+ VAR_DOMAIN, theclass,
&objfile->global_psymbols,
- 0, svalue,
- psymtab_language, objfile);
+ svalue, psymtab_language, objfile);
}
}
- /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
+ /* Link pst to FDR. dbx_end_psymtab returns NULL if the psymtab was
empty and put on the free list. */
- fdr_to_pst[f_idx].pst = end_psymtab (save_pst,
- psymtab_include_list, includes_used,
- -1, save_pst->texthigh,
- dependency_list, dependencies_used, textlow_not_set);
+ fdr_to_pst[f_idx].pst
+ = dbx_end_psymtab (objfile, save_pst,
+ psymtab_include_list, includes_used,
+ -1, save_pst->texthigh,
+ dependency_list, dependencies_used,
+ textlow_not_set);
includes_used = 0;
dependencies_used = 0;
in psymtabs, just in symtabs. */
add_psymbol_to_list (name, strlen (name), 1,
VAR_DOMAIN, LOC_CONST,
- &objfile->static_psymbols, 0,
- (CORE_ADDR) 0, psymtab_language, objfile);
+ &objfile->static_psymbols,
+ 0, psymtab_language, objfile);
ext_sym += external_sym_size;
}
}
The flow of control and even the memory allocation differs. FIXME. */
static void
-psymtab_to_symtab_1 (struct partial_symtab *pst, const char *filename)
+psymtab_to_symtab_1 (struct objfile *objfile,
+ struct partial_symtab *pst, const char *filename)
{
bfd_size_type external_sym_size;
bfd_size_type external_pdr_size;
void (*swap_sym_in) (bfd *, void *, SYMR *);
void (*swap_pdr_in) (bfd *, void *, PDR *);
int i;
- struct symtab *st = NULL;
+ struct compunit_symtab *cust = NULL;
FDR *fh;
struct linetable *lines;
CORE_ADDR lowest_pdr_addr = 0;
int last_symtab_ended = 0;
+ struct section_offsets *section_offsets = objfile->section_offsets;
if (pst->readin)
return;
gdb_flush (gdb_stdout);
}
/* We only pass the filename for debug purposes. */
- psymtab_to_symtab_1 (pst->dependencies[i],
+ psymtab_to_symtab_1 (objfile, pst->dependencies[i],
pst->dependencies[i]->filename);
}
external_pdr_size = debug_swap->external_pdr_size;
swap_sym_in = debug_swap->swap_sym_in;
swap_pdr_in = debug_swap->swap_pdr_in;
- current_objfile = pst->objfile;
+ mdebugread_objfile = objfile;
cur_fd = FDR_IDX (pst);
fh = ((cur_fd == -1)
? (FDR *) NULL
if (processing_gcc_compilation != 0)
{
- struct gdbarch *gdbarch = get_objfile_arch (pst->objfile);
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
/* This symbol table contains stabs-in-ecoff entries. */
if (fh->csym <= 2) /* FIXME, this blows psymtab->symtab ptr. */
{
- current_objfile = NULL;
+ mdebugread_objfile = NULL;
return;
}
for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
would otherwise be ended twice, once in
process_one_symbol, and once after this loop. */
if (type_code == N_SO
- && last_source_file
+ && get_last_source_file ()
&& previous_stab_code != (unsigned char) N_SO
&& *name == '\000')
{
- valu += ANOFFSET (pst->section_offsets,
- SECT_OFF_TEXT (pst->objfile));
+ valu += ANOFFSET (section_offsets,
+ SECT_OFF_TEXT (objfile));
previous_stab_code = N_SO;
- st = end_symtab (valu, pst->objfile,
- SECT_OFF_TEXT (pst->objfile));
+ cust = end_symtab (valu, SECT_OFF_TEXT (objfile));
end_stabs ();
last_symtab_ended = 1;
}
{
last_symtab_ended = 0;
process_one_symbol (type_code, 0, valu, name,
- pst->section_offsets, pst->objfile);
+ section_offsets, objfile);
}
}
/* Similarly a hack. */
else if (name[0] == '#')
{
process_one_symbol (N_SLINE, 0, valu, name,
- pst->section_offsets, pst->objfile);
+ section_offsets, objfile);
}
if (type_code == N_FUN)
{
procedure specific info. */
struct mdebug_extra_func_info *e =
((struct mdebug_extra_func_info *)
- obstack_alloc (¤t_objfile->objfile_obstack,
+ obstack_alloc (&mdebugread_objfile->objfile_obstack,
sizeof (struct mdebug_extra_func_info)));
struct symbol *s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
memset (e, 0, sizeof (struct mdebug_extra_func_info));
SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
- SYMBOL_CLASS (s) = LOC_CONST;
- SYMBOL_TYPE (s) = objfile_type (pst->objfile)->builtin_void;
+ SYMBOL_ACLASS_INDEX (s) = LOC_CONST;
+ SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_void;
SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
e->pdr.framereg = -1;
add_symbol_to_list (s, &local_symbols);
else
{
/* Handle encoded stab line number. */
- valu += ANOFFSET (pst->section_offsets,
- SECT_OFF_TEXT (pst->objfile));
+ valu += ANOFFSET (section_offsets,
+ SECT_OFF_TEXT (objfile));
record_line (current_subfile, sh.index,
gdbarch_addr_bits_remove (gdbarch, valu));
}
if (! last_symtab_ended)
{
- st = end_symtab (pst->texthigh, pst->objfile,
- SECT_OFF_TEXT (pst->objfile));
+ cust = end_symtab (pst->texthigh, SECT_OFF_TEXT (objfile));
end_stabs ();
}
PDR *pdr_in;
PDR *pdr_in_end;
- pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
+ pr_block = XNEWVEC (PDR, fh->cpd);
old_chain = make_cleanup (xfree, pr_block);
pdr_ptr = ((char *) debug_info->external_pdr
pdr_in = pr_block;
pdr_in_end = pdr_in + fh->cpd;
for (; pdr_in < pdr_in_end; pdr_in++)
- parse_procedure (pdr_in, st, pst);
+ parse_procedure (pdr_in, cust, pst);
do_cleanups (old_chain);
}
{
/* This symbol table contains ordinary ecoff entries. */
- int maxlines;
+ int maxlines, size;
EXTR *ext_ptr;
if (fh == 0)
{
maxlines = 0;
- st = new_symtab ("unknown", 0, pst->objfile);
+ cust = new_symtab ("unknown", 0, objfile);
}
else
{
maxlines = 2 * fh->cline;
- st = new_symtab (pst->filename, maxlines, pst->objfile);
+ cust = new_symtab (pst->filename, maxlines, objfile);
/* The proper language was already determined when building
the psymtab, use it. */
- st->language = PST_PRIVATE (pst)->pst_language;
+ COMPUNIT_FILETABS (cust)->language = PST_PRIVATE (pst)->pst_language;
}
- psymtab_language = st->language;
+ psymtab_language = COMPUNIT_FILETABS (cust)->language;
- lines = LINETABLE (st);
+ lines = SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust));
/* Get a new lexical context. */
push_parse_stack ();
- top_stack->cur_st = st;
- top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (st),
- STATIC_BLOCK);
+ top_stack->cur_st = COMPUNIT_FILETABS (cust);
+ top_stack->cur_block
+ = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), STATIC_BLOCK);
BLOCK_START (top_stack->cur_block) = pst->textlow;
BLOCK_END (top_stack->cur_block) = 0;
top_stack->blocktype = stFile;
c = parse_symbol (&sh,
debug_info->external_aux + fh->iauxBase,
sym_ptr, fh->fBigendian,
- pst->section_offsets, pst->objfile);
+ section_offsets, objfile);
sym_ptr += c * external_sym_size;
}
PDR *pdr_in;
PDR *pdr_in_end;
- pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
+ pr_block = XNEWVEC (PDR, fh->cpd);
old_chain = make_cleanup (xfree, pr_block);
pdr_in = pr_block;
pdr_in_end = pdr_in + fh->cpd;
for (; pdr_in < pdr_in_end; pdr_in++)
- parse_procedure (pdr_in, 0, pst);
+ parse_procedure (pdr_in, NULL, pst);
do_cleanups (old_chain);
}
}
- LINETABLE (st) = lines;
+ size = lines->nitems;
+ if (size > 1)
+ --size;
+ SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust))
+ = ((struct linetable *)
+ obstack_copy (&mdebugread_objfile->objfile_obstack,
+ lines, (sizeof (struct linetable)
+ + size * sizeof (lines->item))));
+ xfree (lines);
/* .. and our share of externals.
XXX use the global list to speed up things here. How?
FIXME, Maybe quit once we have found the right number of ext's? */
- top_stack->cur_st = st;
+ top_stack->cur_st = COMPUNIT_FILETABS (cust);
top_stack->cur_block
- = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
+ = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (top_stack->cur_st),
GLOBAL_BLOCK);
top_stack->blocktype = stFile;
ext_ptr = PST_PRIVATE (pst)->extern_tab;
for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++)
parse_external (ext_ptr, fh->fBigendian,
- pst->section_offsets, pst->objfile);
+ section_offsets, objfile);
/* If there are undefined symbols, tell the user.
The alpha has an undefined symbol for every symbol that is
if (info_verbose && n_undef_symbols)
{
printf_filtered (_("File %s contains %d unresolved references:"),
- st->filename, n_undef_symbols);
+ symtab_to_filename_for_display
+ (COMPUNIT_FILETABS (cust)),
+ n_undef_symbols);
printf_filtered ("\n\t%4d variables\n\t%4d "
"procedures\n\t%4d labels\n",
n_undef_vars, n_undef_procs, n_undef_labels);
}
pop_parse_stack ();
- st->primary = 1;
-
- sort_blocks (st);
+ sort_blocks (COMPUNIT_FILETABS (cust));
}
/* Now link the psymtab and the symtab. */
- pst->symtab = st;
+ pst->compunit_symtab = cust;
- current_objfile = NULL;
+ mdebugread_objfile = NULL;
}
\f
/* Ancillary parsing procedures. */
int xref_fd;
struct mdebug_pending *pend;
- *tpp = (struct type *) NULL;
+ *tpp = NULL;
(*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
}
/* mips cc uses a rf of -1 for opaque struct definitions.
- Set TYPE_FLAG_STUB for these types so that check_typedef will
+ Set TYPE_STUB for these types so that check_typedef will
resolve them if the struct gets defined in another compilation unit. */
if (rf == -1)
{
*pname = "<undefined>";
- *tpp = init_type (type_code, 0, TYPE_FLAG_STUB,
- (char *) NULL, current_objfile);
+ *tpp = init_type (mdebugread_objfile, type_code, 0, NULL);
+ TYPE_STUB (*tpp) = 1;
return result;
}
switch (tir.bt)
{
case btVoid:
- *tpp = init_type (type_code, 0, 0, (char *) NULL,
- current_objfile);
+ *tpp = init_type (mdebugread_objfile, type_code, 0, NULL);
*pname = "<undefined>";
break;
complaint (&symfile_complaints,
_("illegal bt %d in forward typedef for %s"), tir.bt,
sym_name);
- *tpp = init_type (type_code, 0, 0, (char *) NULL,
- current_objfile);
+ *tpp = init_type (mdebugread_objfile, type_code, 0, NULL);
break;
}
return result;
has not been parsed yet.
Initialize the type only, it will be filled in when
it's definition is parsed. */
- *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
+ *tpp = init_type (mdebugread_objfile, type_code, 0, NULL);
}
add_pending (fh, esh, *tpp);
}
keeping the symtab sorted. */
static struct symbol *
-mylookup_symbol (char *name, struct block *block,
- domain_enum domain, enum address_class class)
+mylookup_symbol (char *name, const struct block *block,
+ domain_enum domain, enum address_class theclass)
{
- struct dict_iterator iter;
+ struct block_iterator iter;
int inc;
struct symbol *sym;
{
if (SYMBOL_LINKAGE_NAME (sym)[0] == inc
&& SYMBOL_DOMAIN (sym) == domain
- && SYMBOL_CLASS (sym) == class
+ && SYMBOL_CLASS (sym) == theclass
&& strcmp (SYMBOL_LINKAGE_NAME (sym), name) == 0)
return sym;
}
block = BLOCK_SUPERBLOCK (block);
if (block)
- return mylookup_symbol (name, block, domain, class);
+ return mylookup_symbol (name, block, domain, theclass);
return 0;
}
static void
add_symbol (struct symbol *s, struct symtab *symtab, struct block *b)
{
- SYMBOL_SYMTAB (s) = symtab;
+ symbol_set_symtab (s, symtab);
dict_add_symbol (BLOCK_DICT (b), s);
}
static void
add_block (struct block *b, struct symtab *s)
{
- struct blockvector *bv = BLOCKVECTOR (s);
+ /* Cast away "const", but that's ok because we're building the
+ symtab and blockvector here. */
+ struct blockvector *bv = (struct blockvector *) SYMTAB_BLOCKVECTOR (s);
bv = (struct blockvector *) xrealloc ((void *) bv,
(sizeof (struct blockvector)
+ BLOCKVECTOR_NBLOCKS (bv)
* sizeof (bv->block)));
- if (bv != BLOCKVECTOR (s))
- BLOCKVECTOR (s) = bv;
+ if (bv != SYMTAB_BLOCKVECTOR (s))
+ SYMTAB_BLOCKVECTOR (s) = bv;
BLOCKVECTOR_BLOCK (bv, BLOCKVECTOR_NBLOCKS (bv)++) = b;
}
static void
sort_blocks (struct symtab *s)
{
- struct blockvector *bv = BLOCKVECTOR (s);
+ /* We have to cast away const here, but this is ok because we're
+ constructing the blockvector in this code. */
+ struct blockvector *bv = (struct blockvector *) SYMTAB_BLOCKVECTOR (s);
- if (BLOCKVECTOR_NBLOCKS (bv) <= 2)
+ if (BLOCKVECTOR_NBLOCKS (bv) <= FIRST_LOCAL_BLOCK)
{
/* Cosmetic */
if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) == 0)
* are very different. It would be nice to find a reliable test
* to detect -O3 images in advance.
*/
- if (BLOCKVECTOR_NBLOCKS (bv) > 3)
+ if (BLOCKVECTOR_NBLOCKS (bv) > FIRST_LOCAL_BLOCK + 1)
qsort (&BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK),
BLOCKVECTOR_NBLOCKS (bv) - FIRST_LOCAL_BLOCK,
sizeof (struct block *),
/* Allocate a new symtab for NAME. Needs an estimate of how many
linenumbers MAXLINES we'll put in it. */
-static struct symtab *
+static struct compunit_symtab *
new_symtab (const char *name, int maxlines, struct objfile *objfile)
{
- struct symtab *s = allocate_symtab (name, objfile);
+ struct compunit_symtab *cust = allocate_compunit_symtab (objfile, name);
+ struct symtab *symtab;
+ struct blockvector *bv;
+
+ add_compunit_symtab_to_objfile (cust);
+ symtab = allocate_symtab (cust, name);
- LINETABLE (s) = new_linetable (maxlines);
+ SYMTAB_LINETABLE (symtab) = new_linetable (maxlines);
/* All symtabs must have at least two blocks. */
- BLOCKVECTOR (s) = new_bvect (2);
- BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK)
- = new_block (NON_FUNCTION_BLOCK);
- BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)
- = new_block (NON_FUNCTION_BLOCK);
- BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) =
- BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
-
- s->free_code = free_linetable;
- s->debugformat = "ECOFF";
- return (s);
+ bv = new_bvect (2);
+ BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = new_block (NON_FUNCTION_BLOCK);
+ BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = new_block (NON_FUNCTION_BLOCK);
+ BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
+ BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
+ COMPUNIT_BLOCKVECTOR (cust) = bv;
+
+ COMPUNIT_DEBUGFORMAT (cust) = "ECOFF";
+ return cust;
}
/* Allocate a new partial_symtab NAME. */
struct partial_symtab *psymtab;
psymtab = allocate_psymtab (name, objfile);
- psymtab->section_offsets = objfile->section_offsets;
/* Keep a backpointer to the file's symbols. */
PENDING_LIST (psymtab) = pending_list;
/* The way to turn this into a symtab is to call... */
- psymtab->read_symtab = mdebug_psymtab_to_symtab;
+ psymtab->read_symtab = mdebug_read_symtab;
return (psymtab);
}
{
struct linetable *l;
- size = (size - 1) * sizeof (l->item) + sizeof (struct linetable);
+ if (size > 1)
+ --size;
+ size = size * sizeof (l->item) + sizeof (struct linetable);
l = (struct linetable *) xmalloc (size);
l->nitems = 0;
return l;
/* FIXME: carlton/2003-09-11: This should use allocate_block to
allocate the block. Which, in turn, suggests that the block
should be allocated on an obstack. */
- struct block *retval = xzalloc (sizeof (struct block));
+ struct block *retval = XCNEW (struct block);
if (type == FUNCTION_BLOCK)
BLOCK_DICT (retval) = dict_create_linear_expandable ();
static struct symbol *
new_symbol (char *name)
{
- struct symbol *s = ((struct symbol *)
- obstack_alloc (¤t_objfile->objfile_obstack,
- sizeof (struct symbol)));
+ struct symbol *s = allocate_symbol (mdebugread_objfile);
- memset (s, 0, sizeof (*s));
- SYMBOL_SET_LANGUAGE (s, psymtab_language);
- SYMBOL_SET_NAMES (s, name, strlen (name), 1, current_objfile);
+ SYMBOL_SET_LANGUAGE (s, psymtab_language,
+ &mdebugread_objfile->objfile_obstack);
+ SYMBOL_SET_NAMES (s, name, strlen (name), 1, mdebugread_objfile);
return s;
}
{
struct type *t;
- t = alloc_type (current_objfile);
+ t = alloc_type (mdebugread_objfile);
TYPE_NAME (t) = name;
INIT_CPLUS_SPECIFIC (t);
return t;
_initialize_mdebugread (void)
{
basic_type_data = register_objfile_data ();
+
+ mdebug_register_index
+ = register_symbol_register_impl (LOC_REGISTER, &mdebug_register_funcs);
+ mdebug_regparm_index
+ = register_symbol_register_impl (LOC_REGPARM_ADDR, &mdebug_register_funcs);
}
projects / deliverable / binutils-gdb.git / blobdiff