/* Read a symbol table in ECOFF format (Third-Eye).
- Copyright (C) 1986-2014 Free Software Foundation, Inc.
+ Copyright (C) 1986-2018 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 "filenames.h"
#include "objfiles.h"
#include "gdb_obstack.h"
-#include "buildsym.h"
+#include "buildsym-legacy.h"
#include "stabsread.h"
#include "complaints.h"
#include "demangle.h"
#include "expression.h"
-extern void _initialize_mdebugread (void);
-
/* Provide a way to test if we have both ECOFF and ELF symbol tables.
We use this define in order to know whether we should override a
symbol's ECOFF section with its ELF section. This is necessary in
static void
index_complaint (const char *arg1)
{
- complaint (&symfile_complaints, _("bad aux index at symbol %s"), arg1);
+ complaint (_("bad aux index at symbol %s"), arg1);
}
static void
unknown_ext_complaint (const char *arg1)
{
- complaint (&symfile_complaints, _("unknown external symbol %s"), arg1);
+ complaint (_("unknown external symbol %s"), arg1);
}
static void
basic_type_complaint (int arg1, const char *arg2)
{
- complaint (&symfile_complaints, _("cannot map ECOFF basic type 0x%x for %s"),
+ complaint (_("cannot map ECOFF basic type 0x%x for %s"),
arg1, arg2);
}
static void
bad_tag_guess_complaint (const char *arg1)
{
- complaint (&symfile_complaints,
- _("guessed tag type of %s incorrectly"), arg1);
+ complaint (_("guessed tag type of %s incorrectly"), arg1);
}
static void
bad_rfd_entry_complaint (const char *arg1, int arg2, int arg3)
{
- complaint (&symfile_complaints, _("bad rfd entry for %s: file %d, index %d"),
+ complaint (_("bad rfd entry for %s: file %d, index %d"),
arg1, arg2, arg3);
}
static void
unexpected_type_code_complaint (const char *arg1)
{
- complaint (&symfile_complaints, _("unexpected type code for %s"), arg1);
+ complaint (_("unexpected type code for %s"), arg1);
}
/* Macros and extra defs. */
/* Forward declarations. */
static int upgrade_type (int, struct type **, int, union aux_ext *,
- int, char *);
+ int, const char *);
-static void parse_partial_symbols (struct objfile *);
+static void parse_partial_symbols (minimal_symbol_reader &,
+ struct objfile *);
static int has_opaque_xref (FDR *, SYMR *);
static int cross_ref (int, union aux_ext *, struct type **, enum type_code,
- char **, int, char *);
+ const char **, int, const char *);
-static struct symbol *new_symbol (char *);
+static struct symbol *new_symbol (const char *);
static struct type *new_type (char *);
enum block_type { FUNCTION_BLOCK, NON_FUNCTION_BLOCK };
-static struct block *new_block (enum block_type);
+static struct block *new_block (enum block_type, enum language);
-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 blockvector *new_bvect (int);
static struct type *parse_type (int, union aux_ext *, unsigned int, int *,
- int, char *);
+ int, const char *);
-static struct symbol *mylookup_symbol (char *, const struct block *,
+static struct symbol *mylookup_symbol (const 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 struct partial_symtab *new_psymtab (const char *, struct objfile *);
static void psymtab_to_symtab_1 (struct objfile *objfile,
struct partial_symtab *, const char *);
static void handle_psymbol_enumerators (struct objfile *, FDR *, int,
CORE_ADDR);
-static char *mdebug_next_symbol_text (struct objfile *);
+static const char *mdebug_next_symbol_text (struct objfile *);
\f
/* Exported procedure: Builds a symtab from the partial symtab SELF.
Restores the environment in effect when SELF was created, delegates
/* Return a safer print NAME for a file descriptor. */
-static char *
+static const char *
fdr_name (FDR *f)
{
if (f->rss == -1)
different sections are relocated via the SECTION_OFFSETS. */
void
-mdebug_build_psymtabs (struct objfile *objfile,
+mdebug_build_psymtabs (minimal_symbol_reader &reader,
+ struct objfile *objfile,
const struct ecoff_debug_swap *swap,
struct ecoff_debug_info *info)
{
debug_info = info;
stabsread_new_init ();
- buildsym_new_init ();
free_header_files ();
init_header_files ();
char *fdr_end;
FDR *fdr_ptr;
- info->fdr = (FDR *) obstack_alloc (&objfile->objfile_obstack,
- (info->symbolic_header.ifdMax
- * sizeof (FDR)));
- fdr_src = info->external_fdr;
+ info->fdr = (FDR *) XOBNEWVEC (&objfile->objfile_obstack, FDR,
+ info->symbolic_header.ifdMax);
+ fdr_src = (char *) info->external_fdr;
fdr_end = (fdr_src
+ info->symbolic_header.ifdMax * swap->external_fdr_size);
fdr_ptr = info->fdr;
(*swap->swap_fdr_in) (objfile->obfd, fdr_src, fdr_ptr);
}
- parse_partial_symbols (objfile);
+ parse_partial_symbols (reader, objfile);
#if 0
/* Check to make sure file was compiled with -g. If not, warn the
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. */
/* Make sure we do not make duplicates. */
if (!p)
{
- p = ((struct mdebug_pending *)
- obstack_alloc (&mdebugread_objfile->objfile_obstack,
- sizeof (struct mdebug_pending)));
+ p = XOBNEW (&mdebugread_objfile->objfile_obstack, mdebug_pending);
p->s = sh;
p->t = t;
p->next = pending_list[f_idx];
/* Parsing Routines proper. */
+static void
+reg_value_complaint (int regnum, int num_regs, const char *sym)
+{
+ complaint (_("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 = {
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, const 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 gdbarch *gdbarch = get_objfile_arch (objfile);
const bfd_size_type external_sym_size = debug_swap->external_sym_size;
void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
- char *name;
+ const char *name;
struct symbol *s;
struct block *b;
struct mdebug_pending *pend;
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 = mdebug_register_index;
+ add_data_symbol (sh, ax, bigend, s, mdebug_register_index,
+ b, objfile, name);
else
- class = LOC_LOCAL;
-
- data: /* Common code for symbols describing data. */
- SYMBOL_DOMAIN (s) = VAR_DOMAIN;
- SYMBOL_ACLASS_INDEX (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;
- 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
keep_counting = 0;
break;
default:
- complaint (&symfile_complaints,
- _("unknown symbol type 0x%x"), sh->st);
+ complaint (_("unknown symbol type 0x%x"), sh->st);
break;
}
}
b = top_stack->cur_block;
if (sh->st == stProc)
{
- const 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
TYPE_PROTOTYPED (SYMBOL_TYPE (s)) = 1;
/* Create and enter a new lexical context. */
- b = new_block (FUNCTION_BLOCK);
+ b = new_block (FUNCTION_BLOCK, SYMBOL_LANGUAGE (s));
SYMBOL_BLOCK_VALUE (s) = b;
BLOCK_FUNCTION (b) = s;
BLOCK_START (b) = BLOCK_END (b) = sh->value;
break;
default:
- complaint (&symfile_complaints,
- _("declaration block contains "
+ complaint (_("declaration block contains "
"unhandled symbol type %d"),
tsym.st);
}
(.Fxx or .xxfake or empty) for unnamed struct/union/enums.
Alpha cc puts out an sh->iss of zero for those. */
if (sh->iss == 0 || name[0] == '.' || name[0] == '\0')
- TYPE_TAG_NAME (t) = NULL;
+ TYPE_NAME (t) = NULL;
else
- TYPE_TAG_NAME (t) = obconcat (&mdebugread_objfile->objfile_obstack,
- name, (char *) NULL);
+ TYPE_NAME (t) = obconcat (&mdebugread_objfile->objfile_obstack,
+ name, (char *) NULL);
TYPE_CODE (t) = type_code;
TYPE_LENGTH (t) = sh->value;
enum_sym = allocate_symbol (mdebugread_objfile);
SYMBOL_SET_LINKAGE_NAME
(enum_sym,
- obstack_copy0 (&mdebugread_objfile->objfile_obstack,
- f->name, strlen (f->name)));
+ (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;
}
top_stack->blocktype = stBlock;
- b = new_block (NON_FUNCTION_BLOCK);
+ b = new_block (NON_FUNCTION_BLOCK, psymtab_language);
BLOCK_START (b) = sh->value + top_stack->procadr;
BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
top_stack->cur_block = b;
top_stack->blocktype == stStaticProc))
{
/* Finished with procedure */
- const 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;
SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
SYMBOL_ACLASS_INDEX (s) = LOC_CONST;
SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->builtin_void;
- e = ((struct mdebug_extra_func_info *)
- obstack_alloc (&mdebugread_objfile->objfile_obstack,
- sizeof (struct mdebug_extra_func_info)));
- memset (e, 0, sizeof (struct mdebug_extra_func_info));
+ e = OBSTACK_ZALLOC (&mdebugread_objfile->objfile_obstack,
+ mdebug_extra_func_info);
SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
e->numargs = top_stack->numargs;
e->pdr.framereg = -1;
;
}
else
- complaint (&symfile_complaints,
- _("stEnd with storage class %d not handled"), sh->sc);
+ complaint (_("stEnd with storage class %d not handled"), sh->sc);
pop_parse_stack (); /* Restore previous lexical context. */
break;
case stConstant:
break; /* constant */
default:
- complaint (&symfile_complaints, _("unknown symbol type 0x%x"), sh->st);
+ complaint (_("unknown symbol type 0x%x"), sh->st);
break;
}
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), "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, TARGET_CHAR_BIT, "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:
static struct type *
parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
- int bigend, char *sym_name)
+ int bigend, const char *sym_name)
{
TIR t[1];
struct type *tp = 0;
else if (t->bt == btEnum)
;
else
- complaint (&symfile_complaints,
- _("can't handle TIR fBitfield for %s"),
+ complaint (_("can't handle TIR fBitfield for %s"),
sym_name);
}
else
if (rf == -1)
{
- complaint (&symfile_complaints,
- _("unable to cross ref btIndirect for %s"), sym_name);
+ complaint (_("unable to cross ref btIndirect for %s"), sym_name);
return basic_type (btInt, mdebugread_objfile);
}
xref_fh = get_rfd (fd, rf);
name. This apparently is a MIPS extension for C sets. */
t->bt == btSet)
{
- char *name;
+ const char *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, mdebugread_objfile);
+ tp = init_type (mdebugread_objfile, type_code, 0, NULL);
/* DEC c89 produces cross references to qualified aggregate types,
dereference them. */
/* Do not set the tag name if it is a compiler generated tag name
(.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
if (name[0] == '.' || name[0] == '\0')
- TYPE_TAG_NAME (tp) = NULL;
- else if (TYPE_TAG_NAME (tp) == NULL
- || strcmp (TYPE_TAG_NAME (tp), name) != 0)
- TYPE_TAG_NAME (tp)
- = obstack_copy0 (&mdebugread_objfile->objfile_obstack,
- name, strlen (name));
+ TYPE_NAME (tp) = NULL;
+ else if (TYPE_NAME (tp) == NULL
+ || strcmp (TYPE_NAME (tp), name) != 0)
+ TYPE_NAME (tp)
+ = ((const char *)
+ obstack_copy0 (&mdebugread_objfile->objfile_obstack,
+ name, strlen (name)));
}
}
FIXME: We are not doing any guessing on range types. */
if (t->bt == btRange)
{
- char *name;
+ const char *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, mdebugread_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)
- = obstack_copy0 (&mdebugread_objfile->objfile_obstack,
- name, strlen (name));
+ = ((const char *)
+ obstack_copy0 (&mdebugread_objfile->objfile_obstack,
+ name, strlen (name)));
}
}
if (t->bt == btTypedef)
{
- char *name;
+ const char *name;
/* Try to cross reference this type, it should succeed. */
ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
if (tp == (struct type *) NULL)
{
- complaint (&symfile_complaints,
- _("unable to cross ref btTypedef for %s"), sym_name);
+ complaint (_("unable to cross ref btTypedef for %s"), sym_name);
tp = basic_type (btInt, mdebugread_objfile);
}
}
/* Complain for illegal continuations due to corrupt aux entries. */
if (t->continued)
- complaint (&symfile_complaints,
- _("illegal TIR continued for %s"), sym_name);
+ complaint (_("illegal TIR continued for %s"), sym_name);
return tp;
}
static int
upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
- char *sym_name)
+ const char *sym_name)
{
int off;
struct type *t;
else due to corrupt aux entries. */
if (TYPE_CODE (indx) != TYPE_CODE_INT)
{
- complaint (&symfile_complaints,
- _("illegal array index type for %s, assuming int"),
+ complaint (_("illegal array index type for %s, assuming int"),
sym_name);
indx = objfile_type (mdebugread_objfile)->builtin_int;
}
return 0;
default:
- complaint (&symfile_complaints, _("unknown type qualifier 0x%x"), tq);
+ complaint (_("unknown type qualifier 0x%x"), tq);
return 0;
}
}
in question, or NULL to use top_stack->cur_block. */
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;
{
/* Static procedure at address pr->adr. Sigh. */
/* FIXME-32x64. assuming pr->adr fits in long. */
- complaint (&symfile_complaints,
- _("can't handle PDR for static proc at 0x%lx"),
+ complaint (_("can't handle PDR for static proc at 0x%lx"),
(unsigned long) pr->adr);
return;
}
#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
}
else
{
- complaint (&symfile_complaints, _("PDR for %s, but no symbol"), sh_name);
+ complaint (_("PDR for %s, but no symbol"), sh_name);
#if 1
return;
#else
/* Reading .o files */
if (SC_IS_UNDEF (es->asym.sc) || es->asym.sc == scNil)
{
- char *what;
+ const char *what;
switch (es->asym.st)
{
case stNil:
numbers can go back and forth, apparently we can live
with that and do not need to reorder our linetables. */
-static void parse_lines (FDR *, PDR *, struct linetable *, int,
- struct partial_symtab *, CORE_ADDR);
-
static void
parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines,
- struct partial_symtab *pst, CORE_ADDR lowest_pdr_addr)
+ CORE_ADDR textlow, CORE_ADDR lowest_pdr_addr)
{
unsigned char *base;
int j, k;
halt = base + fh->cbLine;
base += pr->cbLineOffset;
- adr = pst->textlow + pr->adr - lowest_pdr_addr;
+ adr = textlow + pr->adr - lowest_pdr_addr;
l = adr >> 2; /* in words */
for (lineno = pr->lnLow; base < halt;)
with corrupt binaries. */
if (lt->nitems >= maxlines)
{
- complaint (&symfile_complaints,
- _("guessed size of linetable for %s incorrectly"),
+ complaint (_("guessed size of linetable for %s incorrectly"),
fdr_name (fh));
break;
}
static void
function_outside_compilation_unit_complaint (const char *arg1)
{
- complaint (&symfile_complaints,
- _("function `%s' appears to be defined "
+ complaint (_("function `%s' appears to be defined "
"outside of all compilation units"),
arg1);
}
belongs to, and then records this new minimal symbol. */
static void
-record_minimal_symbol (const char *name, const CORE_ADDR address,
+record_minimal_symbol (minimal_symbol_reader &reader,
+ const char *name, const CORE_ADDR address,
enum minimal_symbol_type ms_type, int storage_class,
struct objfile *objfile)
{
section = -1;
}
- prim_record_minimal_symbol_and_info (name, address, ms_type,
- section, objfile);
+ reader.record_with_info (name, address, ms_type, section);
}
/* Master parsing procedure for first-pass reading of file symbols
into a partial_symtab. */
static void
-parse_partial_symbols (struct objfile *objfile)
+parse_partial_symbols (minimal_symbol_reader &reader,
+ struct objfile *objfile)
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
const bfd_size_type external_sym_size = debug_swap->external_sym_size;
FDR *fh;
char *ext_out;
char *ext_out_end;
- EXTR *ext_block;
EXTR *ext_in;
EXTR *ext_in_end;
SYMR sh;
struct partial_symtab *pst;
int textlow_not_set = 1;
- int past_first_source_file = 0;
/* List of current psymtab's include files. */
const char **psymtab_include_list;
/* Index within current psymtab dependency list. */
struct partial_symtab **dependency_list;
int dependencies_used, dependencies_allocated;
- struct cleanup *old_chain;
char *name;
enum language prev_language;
asection *text_sect;
&& (bfd_get_section_flags (cur_bfd, text_sect) & SEC_RELOC))
relocatable = 1;
- extern_tab = (EXTR *) obstack_alloc (&objfile->objfile_obstack,
- sizeof (EXTR) * hdr->iextMax);
+ extern_tab = XOBNEWVEC (&objfile->objfile_obstack, EXTR, hdr->iextMax);
includes_allocated = 30;
includes_used = 0;
/* 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);
- old_chain = make_cleanup (xfree, fdr_to_pst);
+ gdb::def_vector<struct pst_map> fdr_to_pst_holder (hdr->ifdMax + 1);
+ fdr_to_pst = fdr_to_pst_holder.data ();
fdr_to_pst++;
{
struct partial_symtab *pst = new_psymtab ("", objfile);
}
/* Allocate the global pending list. */
- pending_list =
- ((struct mdebug_pending **)
- obstack_alloc (&objfile->objfile_obstack,
- hdr->ifdMax * sizeof (struct mdebug_pending *)));
+ pending_list = XOBNEWVEC (&objfile->objfile_obstack, mdebug_pending *,
+ hdr->ifdMax);
memset (pending_list, 0,
hdr->ifdMax * sizeof (struct mdebug_pending *));
/* Pass 0 over external syms: swap them in. */
- ext_block = (EXTR *) xmalloc (hdr->iextMax * sizeof (EXTR));
- make_cleanup (xfree, ext_block);
+ gdb::def_vector<EXTR> ext_block (hdr->iextMax);
ext_out = (char *) debug_info->external_ext;
ext_out_end = ext_out + hdr->iextMax * external_ext_size;
- ext_in = ext_block;
+ ext_in = ext_block.data ();
for (; ext_out < ext_out_end; ext_out += external_ext_size, ext_in++)
(*swap_ext_in) (cur_bfd, ext_out, ext_in);
/* Pass 1 over external syms: Presize and partition the list. */
- ext_in = ext_block;
+ ext_in = ext_block.data ();
ext_in_end = ext_in + hdr->iextMax;
for (; ext_in < ext_in_end; ext_in++)
{
symbol table. */
/* Pass 2 over external syms: fill in external symbols. */
- ext_in = ext_block;
+ ext_in = ext_block.data ();
ext_in_end = ext_in + hdr->iextMax;
for (; ext_in < ext_in_end; ext_in++)
{
external symbols. */
if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
{
- complaint (&symfile_complaints,
- _("bad ifd for external symbol: %d (max %ld)"),
+ complaint (_("bad ifd for external symbol: %d (max %ld)"),
ext_in->ifd, hdr->ifdMax);
continue;
}
if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax)
{
- complaint (&symfile_complaints,
- _("bad iss for external symbol: %ld (max %ld)"),
+ complaint (_("bad iss for external symbol: %ld (max %ld)"),
ext_in->asym.iss, hdr->issExtMax);
continue;
}
unknown_ext_complaint (name);
}
if (!ECOFF_IN_ELF (cur_bfd))
- record_minimal_symbol (name, svalue, ms_type, ext_in->asym.sc,
+ record_minimal_symbol (reader, name, svalue, ms_type, ext_in->asym.sc,
objfile);
}
/* Determine the start address for this object file from the
file header and relocate it, except for Irix 5.2 zero fh->adr. */
if (fh->cpd)
- {
- textlow = fh->adr;
- if (relocatable || textlow != 0)
- textlow += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
- }
+ textlow = fh->adr;
else
textlow = 0;
- pst = start_psymtab_common (objfile, objfile->section_offsets,
+ pst = start_psymtab_common (objfile,
fdr_name (fh),
textlow,
- objfile->global_psymbols.next,
- objfile->static_psymbols.next);
- pst->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct symloc));
+ objfile->global_psymbols,
+ objfile->static_psymbols);
+ pst->read_symtab_private = XOBNEW (&objfile->objfile_obstack, symloc);
memset (pst->read_symtab_private, 0, sizeof (struct symloc));
save_pst = pst;
psymtab_language = prev_language;
PST_PRIVATE (pst)->pst_language = psymtab_language;
- pst->texthigh = pst->textlow;
+ pst->set_text_high (pst->raw_text_low ());
/* For stabs-in-ecoff files, the second symbol must be @stab.
This symbol is emitted by mips-tfile to signal that the
if (sh.st == stStaticProc)
{
namestring = debug_info->ss + fh->issBase + sh.iss;
- record_minimal_symbol (namestring, sh.value,
+ record_minimal_symbol (reader, namestring, sh.value,
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,
/* Kludge for Irix 5.2 zero fh->adr. */
if (!relocatable
- && (pst->textlow == 0 || procaddr < pst->textlow))
- pst->textlow = procaddr;
- if (high > pst->texthigh)
- pst->texthigh = high;
+ && (!pst->text_low_valid
+ || procaddr < pst->raw_text_low ()))
+ pst->set_text_low (procaddr);
+ if (high > pst->raw_text_high ())
+ pst->set_text_high (high);
}
}
else if (sh.st == stStatic)
case scPData:
case scXData:
namestring = debug_info->ss + fh->issBase + sh.iss;
- record_minimal_symbol (namestring, sh.value,
+ record_minimal_symbol (reader, 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;
- record_minimal_symbol (namestring, sh.value,
+ record_minimal_symbol (reader, 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);
switch (type_code)
{
- char *p;
+ const char *p;
/* Standard, external, non-debugger, symbols. */
case N_TEXT | N_EXT:
case N_NBTEXT | N_EXT:
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
goto record_it;
case N_DATA | N_EXT:
case N_NBDATA | N_EXT:
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
goto record_it;
case N_BSS:
case N_BSS | N_EXT:
case N_NBBSS | N_EXT:
case N_SETV | N_EXT: /* FIXME, is this in BSS? */
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_BSS (objfile));
goto record_it;
case N_ABS | N_EXT:
continue;
case N_DATA:
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
goto record_it;
case N_UNDF | N_EXT:
case N_SO:
{
- CORE_ADDR valu;
static int prev_so_symnum = -10;
- static int first_so_symnum;
const 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;
/* 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;
switch (p[1])
{
case 'S':
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
-
if (gdbarch_static_transform_name_p (gdbarch))
namestring = gdbarch_static_transform_name
(gdbarch, namestring);
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_STATIC,
+ SECT_OFF_DATA (objfile),
&objfile->static_psymbols,
- 0, sh.value,
+ sh.value,
psymtab_language, objfile);
continue;
case 'G':
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
/* The addresses in these entries are reported
to be wrong. See the code that reads 'G's
for symtabs. */
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_STATIC,
+ SECT_OFF_DATA (objfile),
&objfile->global_psymbols,
- 0, sh.value,
+ sh.value,
psymtab_language, objfile);
continue;
{
add_psymbol_to_list (namestring, p - namestring, 1,
STRUCT_DOMAIN, LOC_TYPEDEF,
+ -1,
&objfile->static_psymbols,
- sh.value, 0,
- psymtab_language, objfile);
+ 0, psymtab_language, objfile);
if (p[2] == 't')
{
/* Also a typedef with the same name. */
add_psymbol_to_list (namestring,
p - namestring, 1,
VAR_DOMAIN, LOC_TYPEDEF,
+ -1,
&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,
+ -1,
&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
Accept either. */
while (*p && *p != ';' && *p != ',')
{
- char *q;
+ const char *q;
/* Check for and handle cretinous dbx
symbol name continuation! */
symtabs. */
add_psymbol_to_list (p, q - p, 1,
VAR_DOMAIN, LOC_CONST,
+ -1,
&objfile->static_psymbols,
- 0, 0, psymtab_language,
+ 0, psymtab_language,
objfile);
/* Point past the name. */
p = q;
case 'c':
/* Constant, e.g. from "const" in Pascal. */
add_psymbol_to_list (namestring, p - namestring, 1,
- VAR_DOMAIN, LOC_CONST,
+ VAR_DOMAIN, LOC_CONST, -1,
&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';
function_outside_compilation_unit_complaint (name);
xfree (name);
}
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_BLOCK,
+ SECT_OFF_TEXT (objfile),
&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';
function_outside_compilation_unit_complaint (name);
xfree (name);
}
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_BLOCK,
+ SECT_OFF_TEXT (objfile),
&objfile->global_psymbols,
- 0, sh.value,
+ sh.value,
psymtab_language, objfile);
continue;
searching to the end of every string looking for
a backslash. */
- complaint (&symfile_complaints,
- _("unknown symbol descriptor `%c'"), p[1]);
+ complaint (_("unknown symbol descriptor `%c'"), p[1]);
/* Ignore it; perhaps it is an extension that we don't
know about. */
case N_ENDM:
/* Solaris 2 end of module, finish current partial
- symbol table. END_PSYMTAB will set
- pst->texthigh to the proper value, which is
- necessary if a module compiled without
+ symbol table. dbx_end_psymtab will set the
+ high text address of PST to the proper value,
+ which is necessary if a module compiled without
debugging info follows this module. */
if (pst
&& gdbarch_sofun_address_maybe_missing (gdbarch))
continue;
case N_RBRAC:
- if (sh.value > save_pst->texthigh)
- save_pst->texthigh = sh.value;
+ if (sh.value > save_pst->raw_text_high ())
+ save_pst->set_text_high (sh.value);
continue;
case N_EINCL:
case N_DSLINE:
default:
/* If we haven't found it yet, ignore it. It's
probably some new type we don't know about yet. */
- complaint (&symfile_complaints,
- _("unknown symbol type %s"),
+ complaint (_("unknown symbol type %s"),
hex_string (type_code)); /* CUR_SYMBOL_TYPE */
continue;
}
for (cur_sdx = 0; cur_sdx < fh->csym;)
{
char *name;
- enum address_class class;
+ enum address_class theclass;
CORE_ADDR minsym_value;
+ short section = -1;
(*swap_sym_in) (cur_bfd,
((char *) debug_info->external_sym
/* The value of a stEnd symbol is the displacement from the
corresponding start symbol value, do not relocate it. */
if (sh.st != stEnd)
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
+ section = SECT_OFF_TEXT (objfile);
break;
case scData:
case scSData:
case scRData:
case scPData:
case scXData:
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
+ section = SECT_OFF_DATA (objfile);
break;
case scBss:
case scSBss:
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_BSS (objfile));
+ section = SECT_OFF_BSS (objfile);
break;
}
int new_sdx;
case stStaticProc:
- prim_record_minimal_symbol_and_info (name, minsym_value,
- mst_file_text,
- SECT_OFF_TEXT (objfile),
- objfile);
+ reader.record_with_info (name, minsym_value,
+ mst_file_text,
+ SECT_OFF_TEXT (objfile));
/* FALLTHROUGH */
if (new_sdx <= cur_sdx)
{
/* This should not happen either... FIXME. */
- complaint (&symfile_complaints,
- _("bad proc end in aux found from symbol %s"),
+ complaint (_("bad proc end in aux found from symbol %s"),
name);
new_sdx = cur_sdx + 1; /* Don't skip backward. */
}
if (sh.st == stProc)
add_psymbol_to_list (name, strlen (name), 1,
VAR_DOMAIN, LOC_BLOCK,
+ section,
&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,
+ section,
&objfile->static_psymbols,
- 0, sh.value, psymtab_language, objfile);
+ sh.value, psymtab_language, objfile);
procaddr = sh.value;
/* Kludge for Irix 5.2 zero fh->adr. */
if (!relocatable
- && (pst->textlow == 0 || procaddr < pst->textlow))
- pst->textlow = procaddr;
+ && (!pst->text_low_valid
+ || procaddr < pst->raw_text_low ()))
+ pst->set_text_low (procaddr);
high = procaddr + sh.value;
- if (high > pst->texthigh)
- pst->texthigh = high;
+ if (high > pst->raw_text_high ())
+ pst->set_text_high (high);
continue;
case stStatic: /* Variable */
if (SC_IS_DATA (sh.sc))
- prim_record_minimal_symbol_and_info (name, minsym_value,
- mst_file_data,
- SECT_OFF_DATA (objfile),
- objfile);
+ reader.record_with_info (name, minsym_value,
+ mst_file_data,
+ SECT_OFF_DATA (objfile));
else
- prim_record_minimal_symbol_and_info (name, minsym_value,
- mst_file_bss,
- SECT_OFF_BSS (objfile),
- objfile);
- class = LOC_STATIC;
+ reader.record_with_info (name, minsym_value,
+ mst_file_bss,
+ SECT_OFF_BSS (objfile));
+ 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:
&& sh.index != cur_sdx + 2)
{
add_psymbol_to_list (name, strlen (name), 1,
- STRUCT_DOMAIN, LOC_TYPEDEF,
+ STRUCT_DOMAIN, LOC_TYPEDEF, -1,
&objfile->static_psymbols,
- 0, (CORE_ADDR) 0,
- psymtab_language, objfile);
+ 0, psymtab_language, objfile);
}
handle_psymbol_enumerators (objfile, fh, sh.st, sh.value);
if (new_sdx <= cur_sdx)
{
/* This happens with the Ultrix kernel. */
- complaint (&symfile_complaints,
- _("bad aux index at block symbol %s"), name);
+ complaint (_("bad aux index at block symbol %s"), name);
new_sdx = cur_sdx + 1; /* Don't skip backward. */
}
cur_sdx = new_sdx;
default:
/* Both complaints are valid: one gives symbol name,
the other the offending symbol type. */
- complaint (&symfile_complaints, _("unknown local symbol %s"),
+ complaint (_("unknown local symbol %s"),
name);
- complaint (&symfile_complaints, _("with type %d"), sh.st);
+ complaint (_("with type %d"), sh.st);
cur_sdx++;
continue;
}
/* Use this gdb symbol. */
add_psymbol_to_list (name, strlen (name), 1,
- VAR_DOMAIN, class,
+ VAR_DOMAIN, theclass, section,
&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;
+ short section;
if (ext_ptr->ifd != f_idx)
internal_error (__FILE__, __LINE__,
svalue = psh->value;
switch (psh->sc)
{
+ default:
case scText:
case scRConst:
- svalue += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
+ section = SECT_OFF_TEXT (objfile);
break;
case scData:
case scSData:
case scRData:
case scPData:
case scXData:
- svalue += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
+ section = SECT_OFF_DATA (objfile);
break;
case scBss:
case scSBss:
- svalue += ANOFFSET (objfile->section_offsets,
- SECT_OFF_BSS (objfile));
+ section = SECT_OFF_BSS (objfile);
break;
}
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);
- /* Fall through, pretend it's global. */
+ /* Pretend it's global. */
+ /* Fall through. */
case stGlobal:
/* Global common symbols are resolved by the runtime loader,
ignore them. */
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,
+ section,
&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 (objfile, 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->raw_text_high (),
+ dependency_list, dependencies_used,
+ textlow_not_set);
includes_used = 0;
dependencies_used = 0;
other cases. */
save_pst = fdr_to_pst[f_idx].pst;
if (save_pst != NULL
- && save_pst->textlow != 0
+ && save_pst->text_low_valid
&& !(objfile->flags & OBJF_REORDERED))
{
ALL_OBJFILE_PSYMTABS (objfile, pst)
{
if (save_pst != pst
- && save_pst->textlow >= pst->textlow
- && save_pst->textlow < pst->texthigh
- && save_pst->texthigh > pst->texthigh)
+ && save_pst->raw_text_low () >= pst->raw_text_low ()
+ && save_pst->raw_text_low () < pst->raw_text_high ()
+ && save_pst->raw_text_high () > pst->raw_text_high ())
{
objfile->flags |= OBJF_REORDERED;
break;
/* Skip the first file indirect entry as it is a self dependency for
source files or a reverse .h -> .c dependency for header files. */
pst->number_of_dependencies = 0;
- pst->dependencies =
- ((struct partial_symtab **)
- obstack_alloc (&objfile->objfile_obstack,
- ((fh->crfd - 1)
- * sizeof (struct partial_symtab *))));
+ pst->dependencies = XOBNEWVEC (&objfile->objfile_obstack,
+ partial_symtab *, (fh->crfd - 1));
for (s_idx = 1; s_idx < fh->crfd; s_idx++)
{
RFDT rh;
&rh);
if (rh < 0 || rh >= hdr->ifdMax)
{
- complaint (&symfile_complaints, _("bad file number %ld"), rh);
+ complaint (_("bad file number %ld"), rh);
continue;
}
&& objfile->psymtabs->n_global_syms == 0
&& objfile->psymtabs->n_static_syms == 0)
objfile->psymtabs = NULL;
- do_cleanups (old_chain);
}
/* If the current psymbol has an enumerated type, we need to add
/* Note that the value doesn't matter for enum constants
in psymtabs, just in symtabs. */
add_psymbol_to_list (name, strlen (name), 1,
- VAR_DOMAIN, LOC_CONST,
+ VAR_DOMAIN, LOC_CONST, -1,
&objfile->static_psymbols, 0,
- (CORE_ADDR) 0, psymtab_language, objfile);
+ psymtab_language, objfile);
ext_sym += external_sym_size;
}
}
/* Get the next symbol. OBJFILE is unused. */
-static char *
+static const char *
mdebug_next_symbol_text (struct objfile *objfile)
{
SYMR sh;
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;
/* Do nothing if this is a dummy psymtab. */
if (pst->n_global_syms == 0 && pst->n_static_syms == 0
- && pst->textlow == 0 && pst->texthigh == 0)
+ && !pst->text_low_valid && !pst->text_high_valid)
return;
/* Now read the symbols for this symtab. */
if (ECOFF_IS_STAB (&sh) || (name[0] == '#'))
{
int type_code = ECOFF_UNMARK_STAB (sh.index);
+ enum language language = PST_PRIVATE (pst)->pst_language;
/* We should never get non N_STAB symbols here, but they
should be harmless, so keep process_one_symbol from
&& previous_stab_code != (unsigned char) N_SO
&& *name == '\000')
{
- valu += ANOFFSET (pst->section_offsets,
+ valu += ANOFFSET (section_offsets,
SECT_OFF_TEXT (objfile));
previous_stab_code = N_SO;
- st = end_symtab (valu, objfile,
- SECT_OFF_TEXT (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, objfile);
+ section_offsets, objfile, language);
}
}
/* Similarly a hack. */
else if (name[0] == '#')
{
process_one_symbol (N_SLINE, 0, valu, name,
- pst->section_offsets, objfile);
+ section_offsets, objfile, language);
}
if (type_code == N_FUN)
{
/* Make up special symbol to contain
procedure specific info. */
- struct mdebug_extra_func_info *e =
- ((struct mdebug_extra_func_info *)
- obstack_alloc (&mdebugread_objfile->objfile_obstack,
- sizeof (struct mdebug_extra_func_info)));
+ mdebug_extra_func_info *e
+ = OBSTACK_ZALLOC (&mdebugread_objfile->objfile_obstack,
+ 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_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);
+ add_symbol_to_list (s, get_local_symbols ());
}
}
else if (sh.st == stLabel)
else
{
/* Handle encoded stab line number. */
- valu += ANOFFSET (pst->section_offsets,
+ valu += ANOFFSET (section_offsets,
SECT_OFF_TEXT (objfile));
- record_line (current_subfile, sh.index,
+ record_line (get_current_subfile (), sh.index,
gdbarch_addr_bits_remove (gdbarch, valu));
}
}
/* These are generated by gcc-2.x, do not complain. */
;
else
- complaint (&symfile_complaints,
- _("unknown stabs symbol %s"), name);
+ complaint (_("unknown stabs symbol %s"), name);
}
if (! last_symtab_ended)
{
- st = end_symtab (pst->texthigh, objfile,
- SECT_OFF_TEXT (objfile));
+ cust = end_symtab (pst->raw_text_high (), SECT_OFF_TEXT (objfile));
end_stabs ();
}
/* Fill in procedure info next. */
if (fh->cpd > 0)
{
- PDR *pr_block;
- struct cleanup *old_chain;
char *pdr_ptr;
char *pdr_end;
PDR *pdr_in;
PDR *pdr_in_end;
- pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
- old_chain = make_cleanup (xfree, pr_block);
+ gdb::def_vector<PDR> pr_block (fh->cpd);
pdr_ptr = ((char *) debug_info->external_pdr
+ fh->ipdFirst * external_pdr_size);
pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
- pdr_in = pr_block;
+ pdr_in = pr_block.data ();
for (;
pdr_ptr < pdr_end;
pdr_ptr += external_pdr_size, pdr_in++)
/* Determine lowest PDR address, the PDRs are not always
sorted. */
- if (pdr_in == pr_block)
+ if (pdr_in == pr_block.data ())
lowest_pdr_addr = pdr_in->adr;
else if (pdr_in->adr < lowest_pdr_addr)
lowest_pdr_addr = pdr_in->adr;
}
- pdr_in = pr_block;
+ pdr_in = pr_block.data ();
pdr_in_end = pdr_in + fh->cpd;
for (; pdr_in < pdr_in_end; pdr_in++)
- parse_procedure (pdr_in, st, pst);
-
- do_cleanups (old_chain);
+ parse_procedure (pdr_in, cust, pst);
}
}
else
if (fh == 0)
{
maxlines = 0;
- st = new_symtab ("unknown", 0, objfile);
+ cust = new_symtab ("unknown", 0, objfile);
}
else
{
maxlines = 2 * fh->cline;
- st = new_symtab (pst->filename, maxlines, 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);
- BLOCK_START (top_stack->cur_block) = pst->textlow;
+ 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->text_low (objfile);
BLOCK_END (top_stack->cur_block) = 0;
top_stack->blocktype = stFile;
top_stack->cur_type = 0;
c = parse_symbol (&sh,
debug_info->external_aux + fh->iauxBase,
sym_ptr, fh->fBigendian,
- pst->section_offsets, objfile);
+ section_offsets, objfile);
sym_ptr += c * external_sym_size;
}
structures, so we swap them all first. */
if (fh->cpd > 0)
{
- PDR *pr_block;
- struct cleanup *old_chain;
char *pdr_ptr;
char *pdr_end;
PDR *pdr_in;
PDR *pdr_in_end;
- pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
-
- old_chain = make_cleanup (xfree, pr_block);
+ gdb::def_vector<PDR> pr_block (fh->cpd);
pdr_ptr = ((char *) debug_info->external_pdr
+ fh->ipdFirst * external_pdr_size);
pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
- pdr_in = pr_block;
+ pdr_in = pr_block.data ();
for (;
pdr_ptr < pdr_end;
pdr_ptr += external_pdr_size, pdr_in++)
/* Determine lowest PDR address, the PDRs are not always
sorted. */
- if (pdr_in == pr_block)
+ if (pdr_in == pr_block.data ())
lowest_pdr_addr = pdr_in->adr;
else if (pdr_in->adr < lowest_pdr_addr)
lowest_pdr_addr = pdr_in->adr;
}
- parse_lines (fh, pr_block, lines, maxlines,
- pst, lowest_pdr_addr);
+ parse_lines (fh, pr_block.data (), lines, maxlines,
+ pst->text_low (objfile), lowest_pdr_addr);
if (lines->nitems < fh->cline)
lines = shrink_linetable (lines);
/* Fill in procedure info next. */
- pdr_in = pr_block;
+ pdr_in = pr_block.data ();
pdr_in_end = pdr_in + fh->cpd;
for (; pdr_in < pdr_in_end; pdr_in++)
- parse_procedure (pdr_in, 0, pst);
-
- do_cleanups (old_chain);
+ parse_procedure (pdr_in, NULL, pst);
}
}
size = lines->nitems;
if (size > 1)
--size;
- LINETABLE (st) = obstack_copy (&mdebugread_objfile->objfile_obstack,
- lines,
- (sizeof (struct linetable)
- + size * sizeof (lines->item)));
+ 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, 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:"),
- symtab_to_filename_for_display (st),
+ 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",
}
pop_parse_stack ();
- set_symtab_primary (st, 1);
-
- sort_blocks (st);
+ sort_blocks (COMPUNIT_FILETABS (cust));
}
/* Now link the psymtab and the symtab. */
- pst->symtab = st;
+ pst->compunit_symtab = cust;
mdebugread_objfile = NULL;
}
cross_ref (int fd, union aux_ext *ax, struct type **tpp,
enum type_code type_code,
/* Use to alloc new type if none is found. */
- char **pname, int bigend, char *sym_name)
+ const char **pname, int bigend, const char *sym_name)
{
RNDXR rn[1];
unsigned int rf;
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, mdebugread_objfile);
+ *tpp = init_type (mdebugread_objfile, type_code, 0, NULL);
+ TYPE_STUB (*tpp) = 1;
return result;
}
+ fh->iauxBase + sh.index)->a_ti,
&tir);
if (tir.tq0 != tqNil)
- complaint (&symfile_complaints,
- _("illegal tq0 in forward typedef for %s"), sym_name);
+ complaint (_("illegal tq0 in forward typedef for %s"), sym_name);
switch (tir.bt)
{
case btVoid:
- *tpp = init_type (type_code, 0, 0, (char *) NULL,
- mdebugread_objfile);
+ *tpp = init_type (mdebugread_objfile, type_code, 0, NULL);
*pname = "<undefined>";
break;
break;
default:
- complaint (&symfile_complaints,
- _("illegal bt %d in forward typedef for %s"), tir.bt,
+ complaint (_("illegal bt %d in forward typedef for %s"), tir.bt,
sym_name);
- *tpp = init_type (type_code, 0, 0, (char *) NULL,
- mdebugread_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, mdebugread_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, const struct block *block,
- domain_enum domain, enum address_class class)
+mylookup_symbol (const char *name, const struct block *block,
+ domain_enum domain, enum address_class theclass)
{
struct block_iterator iter;
int inc;
{
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);
}
{
/* Cast away "const", but that's ok because we're building the
symtab and blockvector here. */
- struct blockvector *bv = (struct blockvector *) BLOCKVECTOR (s);
+ 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;
}
{
/* 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 *) BLOCKVECTOR (s);
+ struct blockvector *bv = (struct blockvector *) SYMTAB_BLOCKVECTOR (s);
if (BLOCKVECTOR_NBLOCKS (bv) <= FIRST_LOCAL_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;
+ enum language lang;
+
+ add_compunit_symtab_to_objfile (cust);
+ symtab = allocate_symtab (cust, name);
- LINETABLE (s) = new_linetable (maxlines);
+ SYMTAB_LINETABLE (symtab) = new_linetable (maxlines);
+ lang = compunit_language (cust);
/* All symtabs must have at least two blocks. */
bv = new_bvect (2);
- BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = new_block (NON_FUNCTION_BLOCK);
- BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = new_block (NON_FUNCTION_BLOCK);
+ BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = new_block (NON_FUNCTION_BLOCK, lang);
+ BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = new_block (NON_FUNCTION_BLOCK, lang);
BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- BLOCKVECTOR (s) = bv;
+ COMPUNIT_BLOCKVECTOR (cust) = bv;
- s->debugformat = "ECOFF";
- return (s);
+ COMPUNIT_DEBUGFORMAT (cust) = "ECOFF";
+ return cust;
}
/* Allocate a new partial_symtab NAME. */
static struct partial_symtab *
-new_psymtab (char *name, struct objfile *objfile)
+new_psymtab (const char *name, struct objfile *objfile)
{
struct partial_symtab *psymtab;
psymtab = allocate_psymtab (name, objfile);
- psymtab->section_offsets = objfile->section_offsets;
/* Keep a backpointer to the file's symbols. */
- psymtab->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct symloc));
- memset (psymtab->read_symtab_private, 0, sizeof (struct symloc));
+ psymtab->read_symtab_private
+ = OBSTACK_ZALLOC (&objfile->objfile_obstack, symloc);
CUR_BFD (psymtab) = cur_bfd;
DEBUG_SWAP (psymtab) = debug_swap;
DEBUG_INFO (psymtab) = debug_info;
return bv;
}
-/* Allocate and zero a new block, and set its BLOCK_DICT. If function
- is non-zero, assume the block is associated to a function, and make
- sure that the symbols are stored linearly; otherwise, store them
- hashed. */
+/* Allocate and zero a new block of language LANGUAGE, and set its
+ BLOCK_DICT. If function is non-zero, assume the block is
+ associated to a function, and make sure that the symbols are stored
+ linearly; otherwise, store them hashed. */
static struct block *
-new_block (enum block_type type)
+new_block (enum block_type type, enum language language)
{
/* 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 ();
+ BLOCK_DICT (retval) = dict_create_linear_expandable (language);
else
- BLOCK_DICT (retval) = dict_create_hashed_expandable ();
+ BLOCK_DICT (retval) = dict_create_hashed_expandable (language);
return retval;
}
/* Create a new symbol with printname NAME. */
static struct symbol *
-new_symbol (char *name)
+new_symbol (const char *name)
{
struct symbol *s = allocate_symbol (mdebugread_objfile);
{
bfd *abfd = objfile->obfd;
struct ecoff_debug_info *info;
- struct cleanup *back_to;
/* FIXME: It's not clear whether we should be getting minimal symbol
information from .mdebug in an ELF file, or whether we will.
Re-initialize the minimal symbol reader in case we do. */
- init_minimal_symbol_collection ();
- back_to = make_cleanup_discard_minimal_symbols ();
+ minimal_symbol_reader reader (objfile);
- info = ((struct ecoff_debug_info *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct ecoff_debug_info)));
+ info = XOBNEW (&objfile->objfile_obstack, ecoff_debug_info);
if (!(*swap->read_debug_info) (abfd, sec, info))
error (_("Error reading ECOFF debugging information: %s"),
bfd_errmsg (bfd_get_error ()));
- mdebug_build_psymtabs (objfile, swap, info);
+ mdebug_build_psymtabs (reader, objfile, swap, info);
- install_minimal_symbols (objfile);
- do_cleanups (back_to);
+ reader.install ();
}
void
projects / thirdparty / binutils-gdb.git / blobdiff