/* 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
- 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 "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"
-#include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
+#include "coff/ecoff.h" /* COFF-like aspects of ecoff files. */
#include "libaout.h" /* Private BFD a.out information. */
#include "aout/aout64.h"
-#include "aout/stab_gnu.h" /* STABS information */
+#include "aout/stab_gnu.h" /* STABS information. */
#include "expression.h"
-extern void _initialize_mdebugread (void);
-
-/* Provide a way to test if we have both ECOFF and ELF symbol tables.
+/* 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
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
#define SC_IS_SBSS(sc) ((sc) == scSBss)
#define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
\f
-/* Various complaints about symbol reading that don't abort the process */
+/* Various complaints about symbol reading that don't abort the process. */
static void
index_complaint (const char *arg1)
{
static void
bad_tag_guess_complaint (const char *arg1)
{
- complaint (&symfile_complaints, _("guessed tag type of %s incorrectly"), arg1);
+ complaint (&symfile_complaints,
+ _("guessed tag type of %s incorrectly"), arg1);
}
static void
complaint (&symfile_complaints, _("unexpected type code for %s"), arg1);
}
-/* Macros and extra defs */
+/* Macros and extra defs. */
-/* Puns: hard to find whether -g was used and how */
+/* Puns: hard to find whether -g was used and how. */
#define MIN_GLEVEL GLEVEL_0
#define compare_glevel(a,b) \
(((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
\f
-/* Things that really are local to this module */
+/* Things that really are local to this module. */
-/* Remember what we deduced to be the source language of this psymtab. */
+/* Remember what we deduced to be the source language of this psymtab. */
static enum language psymtab_language = language_unknown;
static struct ecoff_debug_info *debug_info;
-/* Pointer to current file decriptor record, and its index */
+/* Pointer to current file decriptor record, and its index. */
static FDR *cur_fdr;
static int cur_fd;
-/* Index of current symbol */
+/* Index of current symbol. */
static int cur_sdx;
/* Note how much "debuggable" this image is. We would like
- to see at least one FDR with full symbols */
+ to see at least one FDR with full symbols. */
static int max_gdbinfo;
static int max_glevel;
-/* When examining .o files, report on undefined symbols */
+/* When examining .o files, report on undefined symbols. */
static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs;
static char stabs_symbol[] = STABS_SYMBOL;
-/* Types corresponding to mdebug format bt* basic types. */
-
-static struct type *mdebug_type_void;
-static struct type *mdebug_type_char;
-static struct type *mdebug_type_short;
-static struct type *mdebug_type_int_32;
-#define mdebug_type_int mdebug_type_int_32
-static struct type *mdebug_type_int_64;
-static struct type *mdebug_type_long_32;
-static struct type *mdebug_type_long_64;
-static struct type *mdebug_type_long_long_64;
-static struct type *mdebug_type_unsigned_char;
-static struct type *mdebug_type_unsigned_short;
-static struct type *mdebug_type_unsigned_int_32;
-static struct type *mdebug_type_unsigned_int_64;
-static struct type *mdebug_type_unsigned_long_32;
-static struct type *mdebug_type_unsigned_long_64;
-static struct type *mdebug_type_unsigned_long_long_64;
-static struct type *mdebug_type_adr_32;
-static struct type *mdebug_type_adr_64;
-static struct type *mdebug_type_float;
-static struct type *mdebug_type_double;
-static struct type *mdebug_type_complex;
-static struct type *mdebug_type_double_complex;
-static struct type *mdebug_type_fixed_dec;
-static struct type *mdebug_type_float_dec;
-static struct type *mdebug_type_string;
-
/* Nonzero if we have seen ecoff debugging info for a file. */
static int found_ecoff_debugging_info;
-/* Forward declarations */
+/* 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 (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 *, struct block *, domain_enum,
- enum address_class);
+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 partial_symtab *, char *);
+static void psymtab_to_symtab_1 (struct objfile *objfile,
+ struct partial_symtab *, const char *);
static void add_block (struct block *, struct symtab *);
-static void add_symbol (struct symbol *, struct block *);
+static void add_symbol (struct symbol *, struct symtab *, struct block *);
static int add_line (struct linetable *, int, CORE_ADDR, int);
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 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);
+ after all of the symtabs and dependencies have been read in. */
+ scan_file_globals (objfile);
if (info_verbose)
printf_filtered (_("done.\n"));
}
\f
-/* File-level interface functions */
+/* File-level interface functions. */
-/* Find a file descriptor given its index RF relative to a file CF */
+/* Find a file descriptor given its index RF relative to a file CF. */
static FDR *
get_rfd (int cf, int rf)
fdrs = debug_info->fdr;
f = fdrs + cf;
- /* Object files do not have the RFD table, all refs are absolute */
+ /* Object files do not have the RFD table, all refs are absolute. */
if (f->rfdBase == 0)
return fdrs + rf;
(*debug_swap->swap_rfd_in) (cur_bfd,
return fdrs + rfd;
}
-/* Return a safer print NAME for a file descriptor */
+/* 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)
{
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;
(*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
if (compare_glevel (max_glevel, GLEVEL_2) < 0)
{
if (max_gdbinfo == 0)
- printf_unfiltered (_("\n%s not compiled with -g, debugging support is limited.\n"),
+ printf_unfiltered (_("\n%s not compiled with -g, "
+ "debugging support is limited.\n"),
objfile->name);
- printf_unfiltered (_("You should compile with -g2 or -g3 for best debugging support.\n"));
+ printf_unfiltered (_("You should compile with -g2 or "
+ "-g3 for best debugging support.\n"));
gdb_flush (gdb_stdout);
}
#endif
\f
/* Local utilities */
-/* Map of FDR indexes to partial symtabs */
+/* Map of FDR indexes to partial symtabs. */
struct pst_map
{
/* Utility stack, used to nest procedures and blocks properly.
It is a doubly linked list, to avoid too many alloc/free.
Since we might need it quite a few times it is NOT deallocated
- after use. */
+ after use. */
static struct parse_stack
{
struct parse_stack *next, *prev;
- struct symtab *cur_st; /* Current symtab. */
- struct block *cur_block; /* Block in it. */
+ struct symtab *cur_st; /* Current symtab. */
+ struct block *cur_block; /* Block in it. */
/* What are we parsing. stFile, or stBlock are for files and
blocks. stProc or stStaticProc means we have seen the start of a
int blocktype;
- struct type *cur_type; /* Type we parse fields for. */
- int cur_field; /* Field number in cur_type. */
- CORE_ADDR procadr; /* Start addres of this procedure */
- int numargs; /* Its argument count */
+ struct type *cur_type; /* Type we parse fields for. */
+ int cur_field; /* Field number in cur_type. */
+ CORE_ADDR procadr; /* Start addres of this procedure. */
+ int numargs; /* Its argument count. */
}
*top_stack; /* Top stack ptr */
-/* Enter a new lexical context */
+/* Enter a new lexical context. */
static void
push_parse_stack (void)
{
- struct parse_stack *new;
+ struct parse_stack *newobj;
- /* Reuse frames if possible */
+ /* 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));
- /* Initialize new frame with previous content */
+ 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 */
+/* Exit a lexical context. */
static void
pop_parse_stack (void)
/* Cross-references might be to things we haven't looked at
yet, e.g. type references. To avoid too many type
duplications we keep a quick fixup table, an array
- of lists of references indexed by file descriptor */
+ of lists of references indexed by file descriptor. */
struct mdebug_pending
{
};
-/* 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;
-/* Check whether we already saw symbol SH in file FH */
+/* Check whether we already saw symbol SH in file FH. */
static struct mdebug_pending *
is_pending_symbol (FDR *fh, char *sh)
int f_idx = fh - debug_info->fdr;
struct mdebug_pending *p;
- /* Linear search is ok, list is typically no more than 10 deep */
+ /* Linear search is ok, list is typically no more than 10 deep. */
for (p = pending_list[f_idx]; p; p = p->next)
if (p->s == sh)
break;
return p;
}
-/* Add a new symbol SH of type T */
+/* Add a new symbol SH of type T. */
static void
add_pending (FDR *fh, char *sh, struct type *t)
int f_idx = fh - debug_info->fdr;
struct mdebug_pending *p = is_pending_symbol (fh, sh);
- /* Make sure we do not make duplicates */
+ /* Make sure we do not make duplicates. */
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;
}
\f
-/* Parsing Routines proper. */
+/* 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.
+/* 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
AX is the base pointer of aux symbols for this file (fh->iauxBase).
aux symbols are big-endian or little-endian. Return count of
SYMR's handled (normally one). */
+static int
+mdebug_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
+{
+ 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, 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;
case stNil:
break;
- case stGlobal: /* external symbol, goes into global block */
- class = LOC_STATIC;
- b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
+ case stGlobal: /* External symbol, goes into global block. */
+ 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;
+ case stStatic: /* Static data, goes into current block. */
b = top_stack->cur_block;
s = new_symbol (name);
if (SC_IS_COMMON (sh->sc))
/* It is a FORTRAN common block. At least for SGI Fortran the
address is not in the symbol; we need to fix it later in
scan_file_globals. */
- int bucket = hashname (DEPRECATED_SYMBOL_NAME (s));
+ int bucket = hashname (SYMBOL_LINKAGE_NAME (s));
SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];
global_sym_chain[bucket] = s;
}
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 */
- if (sh->sc == scRegister)
- {
- class = LOC_REGISTER;
- svalue = gdbarch_ecoff_reg_to_regnum (current_gdbarch, svalue);
- }
- else
- class = LOC_LOCAL;
+ case stLocal: /* Local variable, goes into current block. */
b = top_stack->cur_block;
s = new_symbol (name);
SYMBOL_VALUE (s) = svalue;
-
- data: /* Common code for symbols describing data */
- SYMBOL_DOMAIN (s) = VAR_DOMAIN;
- SYMBOL_CLASS (s) = class;
- add_symbol (s, 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) = builtin_type (current_gdbarch)->nodebug_data_symbol;
+ if (sh->sc == scRegister)
+ 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 block */
+ case stParam: /* Arg to procedure, goes into current
+ block. */
max_gdbinfo++;
found_ecoff_debugging_info = 1;
top_stack->numargs++;
/* Special GNU C++ name. */
if (is_cplus_marker (name[0]) && name[1] == 't' && name[2] == 0)
- name = "this"; /* FIXME, not alloc'd in obstack */
+ name = "this"; /* FIXME, not alloc'd in obstack. */
s = new_symbol (name);
SYMBOL_DOMAIN (s) = VAR_DOMAIN;
+ SYMBOL_IS_ARGUMENT (s) = 1;
switch (sh->sc)
{
case scRegister:
/* Pass by value in register. */
- SYMBOL_CLASS (s) = LOC_REGPARM;
- svalue = gdbarch_ecoff_reg_to_regnum (current_gdbarch, svalue);
+ 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;
- svalue = gdbarch_ecoff_reg_to_regnum (current_gdbarch, svalue);
+ 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;
SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
- add_symbol (s, top_stack->cur_block);
+ add_symbol (s, top_stack->cur_st, top_stack->cur_block);
break;
- case stLabel: /* label, goes into current block */
+ 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_DOMAIN (s) = VAR_DOMAIN; /* So that it can be used */
+ SYMBOL_ACLASS_INDEX (s) = LOC_LABEL; /* but not misused. */
SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
- SYMBOL_TYPE (s) = mdebug_type_int;
- add_symbol (s, top_stack->cur_block);
+ SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int;
+ add_symbol (s, top_stack->cur_st, top_stack->cur_block);
break;
- case stProc: /* Procedure, usually goes into global block */
- case stStaticProc: /* Static procedure, goes into current block */
+ case stProc: /* Procedure, usually goes into global block. */
+ case stStaticProc: /* Static procedure, goes into current block. */
/* For stProc symbol records, we need to check the storage class
as well, as only (stProc, scText) entries represent "real"
procedures - See the Compaq document titled "Object File /
}
s = new_symbol (name);
SYMBOL_DOMAIN (s) = VAR_DOMAIN;
- SYMBOL_CLASS (s) = LOC_BLOCK;
- /* Type of the return value */
+ SYMBOL_ACLASS_INDEX (s) = LOC_BLOCK;
+ /* Type of the return value. */
if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
- t = mdebug_type_int;
+ t = objfile_type (objfile)->builtin_int;
else
{
t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name);
printf("howdy\n")" would fail with the error message
"program has no memory available". To avoid this, we
patch up the type and make it void*
- instead. (davidm@azstarnet.com)
- */
+ instead. (davidm@azstarnet.com). */
t = make_pointer_type (t, NULL);
}
}
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
global). */
else if (sh->value == top_stack->procadr)
b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
}
- add_symbol (s, b);
+ add_symbol (s, top_stack->cur_st, b);
- /* Make a type for the procedure itself */
+ /* Make a type for the procedure itself. */
SYMBOL_TYPE (s) = lookup_function_type (t);
/* All functions in C++ have prototypes. For C we don't have enough
information in the debug info. */
if (SYMBOL_LANGUAGE (s) == language_cplus)
- TYPE_FLAGS (SYMBOL_TYPE (s)) |= TYPE_FLAG_PROTOTYPED;
+ TYPE_PROTOTYPED (SYMBOL_TYPE (s)) = 1;
- /* Create and enter a new lexical context */
- b = new_block (FUNCTION_BLOCK);
+ /* Create and enter a new lexical context. */
+ 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;
BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
add_block (b, top_stack->cur_st);
- /* Not if we only have partial info */
+ /* Not if we only have partial info. */
if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
break;
long max_value;
struct field *f;
- case stStruct: /* Start a block defining a struct type */
+ case stStruct: /* Start a block defining a struct type. */
type_code = TYPE_CODE_STRUCT;
goto structured_common;
- case stUnion: /* Start a block defining a union type */
+ case stUnion: /* Start a block defining a union type. */
type_code = TYPE_CODE_UNION;
goto structured_common;
- case stEnum: /* Start a block defining an enum type */
+ case stEnum: /* Start a block defining an enum type. */
type_code = TYPE_CODE_ENUM;
goto structured_common;
- case stBlock: /* Either a lexical block, or some type */
+ case stBlock: /* Either a lexical block, or some type. */
if (sh->sc != scInfo && !SC_IS_COMMON (sh->sc))
goto case_stBlock_code; /* Lexical block */
push_parse_stack ();
top_stack->blocktype = stBlock;
- /* First count the number of fields and the highest value. */
+ /* First count the number of fields and the highest value. */
nfields = 0;
max_value = 0;
for (ext_tsym = ext_sh + external_sym_size;
{
case stEnd:
/* C++ encodes class types as structures where there the
- methods are encoded as stProc. The scope of stProc
+ methods are encoded as stProc. The scope of stProc
symbols also ends with stEnd, thus creating a risk of
taking the wrong stEnd symbol record as the end of
the current struct, which would cause GDB to undercount
/* mips cc puts out a typedef for struct x if it is not yet
defined when it encounters
struct y { struct x *xp; };
- Just ignore it. */
+ Just ignore it. */
break;
case stIndirect:
/* Irix5 cc puts out a stIndirect for struct x if it is not
yet defined when it encounters
struct y { struct x *xp; };
- Just ignore it. */
+ Just ignore it. */
break;
default:
complaint (&symfile_complaints,
- _("declaration block contains unhandled symbol type %d"),
+ _("declaration block contains "
+ "unhandled symbol type %d"),
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
differently from struct/union fields, and that is harder to
patch up, but luckily we shouldn't need to. (If there are
any enumeration members, we can tell for sure it's an enum
- here.) */
+ here.) */
if (type_code == TYPE_CODE_UNDEF)
{
if (sh->iss == 0 || name[0] == '.' || name[0] == '\0')
TYPE_TAG_NAME (t) = NULL;
else
- TYPE_TAG_NAME (t) = obconcat (¤t_objfile->objfile_obstack,
- "", "", name);
+ TYPE_TAG_NAME (t) = obconcat (&mdebugread_objfile->objfile_obstack,
+ name, (char *) NULL);
TYPE_CODE (t) = type_code;
TYPE_LENGTH (t) = sh->value;
{
int unsigned_enum = 1;
- /* This is a non-empty enum. */
+ /* This is a non-empty enum. */
/* DEC c89 has the number of enumerators in the sh.value field,
not the type length, so we have to compensate for that
that too. */
if (TYPE_LENGTH (t) == TYPE_NFIELDS (t)
|| TYPE_LENGTH (t) == 0)
- TYPE_LENGTH (t) =
- gdbarch_int_bit (current_gdbarch) / HOST_CHAR_BIT;
+ TYPE_LENGTH (t) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
for (ext_tsym = ext_sh + external_sym_size;
;
ext_tsym += external_sym_size)
if (tsym.st != stMember)
break;
- 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;
- FIELD_STATIC_KIND (*f) = 0;
-
- enum_sym = ((struct symbol *)
- obstack_alloc (¤t_objfile->objfile_obstack,
- sizeof (struct symbol)));
- memset (enum_sym, 0, sizeof (struct symbol));
- DEPRECATED_SYMBOL_NAME (enum_sym) =
- obsavestring (f->name, strlen (f->name),
- ¤t_objfile->objfile_obstack);
- SYMBOL_CLASS (enum_sym) = LOC_CONST;
+
+ enum_sym = allocate_symbol (mdebugread_objfile);
+ SYMBOL_SET_LINKAGE_NAME
+ (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;
if (SYMBOL_VALUE (enum_sym) < 0)
unsigned_enum = 0;
- add_symbol (enum_sym, top_stack->cur_block);
+ add_symbol (enum_sym, top_stack->cur_st, top_stack->cur_block);
- /* Skip the stMembers that we've handled. */
+ /* Skip the stMembers that we've handled. */
count++;
f++;
}
if (unsigned_enum)
- TYPE_FLAGS (t) |= TYPE_FLAG_UNSIGNED;
+ TYPE_UNSIGNED (t) = 1;
}
- /* make this the current type */
+ /* Make this the current type. */
top_stack->cur_type = t;
top_stack->cur_field = 0;
do not create a symbol for it either. */
if (TYPE_NFIELDS (t) == 0)
{
- TYPE_FLAGS (t) |= TYPE_FLAG_STUB;
+ TYPE_STUB (t) = 1;
break;
}
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_block);
+ add_symbol (s, top_stack->cur_st, top_stack->cur_block);
break;
/* End of local variables shared by struct, union, enum, and
case_stBlock_code:
found_ecoff_debugging_info = 1;
- /* beginnning of (code) block. Value of symbol
- is the displacement from procedure start */
+ /* Beginnning of (code) block. Value of symbol
+ is the displacement from procedure start. */
push_parse_stack ();
/* Do not start a new block if this is the outermost block of a
}
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 */
- 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;
BLOCK_END (top_stack->cur_block) += sh->value; /* size */
- /* Make up special symbol to contain procedure specific info */
+ /* 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) = mdebug_type_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 (s) = (long) e;
+ SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
e->numargs = top_stack->numargs;
e->pdr.framereg = -1;
- add_symbol (s, top_stack->cur_block);
+ add_symbol (s, top_stack->cur_st, top_stack->cur_block);
/* f77 emits proc-level with address bounds==[0,0],
So look for such child blocks, and patch them. */
for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
{
struct block *b_bad = BLOCKVECTOR_BLOCK (bv, i);
+
if (BLOCK_SUPERBLOCK (b_bad) == b
&& BLOCK_START (b_bad) == top_stack->procadr
&& BLOCK_END (b_bad) == top_stack->procadr)
if (TYPE_NFIELDS (ftype) <= 0)
{
/* No parameter type information is recorded with the function's
- type. Set that from the type of the parameter symbols. */
+ type. Set that from the type of the parameter symbols. */
int nparams = top_stack->numargs;
int iparams;
struct symbol *sym;
if (nparams > 0)
{
- struct dict_iterator iter;
+ struct block_iterator iter;
+
TYPE_NFIELDS (ftype) = nparams;
TYPE_FIELDS (ftype) = (struct field *)
TYPE_ALLOC (ftype, nparams * sizeof (struct field));
if (iparams == nparams)
break;
- switch (SYMBOL_CLASS (sym))
+ if (SYMBOL_IS_ARGUMENT (sym))
{
- case LOC_ARG:
- case LOC_REF_ARG:
- case LOC_REGPARM:
- case LOC_REGPARM_ADDR:
TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
iparams++;
- break;
- default:
- break;
}
}
}
}
else if (sh->sc == scText && top_stack->blocktype == stBlock)
{
- /* End of (code) block. The value of the symbol is the
+ /* End of (code) block. The value of the symbol is the
displacement from the procedure`s start address of the
- end of this block. */
+ end of this block. */
BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr;
}
else if (sh->sc == scText && top_stack->blocktype == stNil)
complaint (&symfile_complaints,
_("stEnd with storage class %d not handled"), sh->sc);
- pop_parse_stack (); /* restore previous lexical context */
+ pop_parse_stack (); /* Restore previous lexical context. */
break;
case stMember: /* member of struct or union */
f = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++];
FIELD_NAME (*f) = name;
- FIELD_BITPOS (*f) = sh->value;
+ SET_FIELD_BITPOS (*f, sh->value);
bitsize = 0;
- FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index, &bitsize, bigend, name);
+ FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index,
+ &bitsize, bigend, name);
FIELD_BITSIZE (*f) = bitsize;
- FIELD_STATIC_KIND (*f) = 0;
break;
case stIndirect: /* forward declaration on Irix5 */
else
t = pend->t;
- /* mips cc puts out a typedef with the name of the struct for forward
- declarations. These should not go into the symbol table and
+ /* Mips cc puts out a typedef with the name of the struct for forward
+ declarations. These should not go into the symbol table and
TYPE_NAME should not be set for them.
They can't be distinguished from an intentional typedef to
the same name however:
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_block);
+ add_symbol (s, top_stack->cur_st, top_stack->cur_block);
/* Incomplete definitions of structs should not get a name. */
if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL
for anything except pointers or functions. */
}
else
- TYPE_NAME (SYMBOL_TYPE (s)) = DEPRECATED_SYMBOL_NAME (s);
+ TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_LINKAGE_NAME (s);
}
break;
return count;
}
+/* Basic types. */
+
+static const struct objfile_data *basic_type_data;
+
+static struct type *
+basic_type (int bt, struct objfile *objfile)
+{
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct type **map_bt
+ = (struct type **) objfile_data (objfile, basic_type_data);
+ struct type *tp;
+
+ if (bt >= btMax)
+ return NULL;
+
+ if (!map_bt)
+ {
+ map_bt = OBSTACK_CALLOC (&objfile->objfile_obstack,
+ btMax, struct type *);
+ set_objfile_data (objfile, basic_type_data, map_bt);
+ }
+
+ if (map_bt[bt])
+ return map_bt[bt];
+
+ switch (bt)
+ {
+ case btNil:
+ tp = objfile_type (objfile)->builtin_void;
+ break;
+
+ case btAdr:
+ tp = init_pointer_type (objfile, 32, "adr_32",
+ objfile_type (objfile)->builtin_void);
+ break;
+
+ case btChar:
+ tp = init_integer_type (objfile, 8, 0, "char");
+ TYPE_NOSIGN (tp) = 1;
+ break;
+
+ case btUChar:
+ tp = init_integer_type (objfile, 8, 1, "unsigned char");
+ break;
+
+ case btShort:
+ tp = init_integer_type (objfile, 16, 0, "short");
+ break;
+
+ case btUShort:
+ tp = init_integer_type (objfile, 16, 1, "unsigned short");
+ break;
+
+ case btInt:
+ tp = init_integer_type (objfile, 32, 0, "int");
+ break;
+
+ case btUInt:
+ tp = init_integer_type (objfile, 32, 1, "unsigned int");
+ break;
+
+ case btLong:
+ tp = init_integer_type (objfile, 32, 0, "long");
+ break;
+
+ case btULong:
+ tp = init_integer_type (objfile, 32, 1, "unsigned long");
+ break;
+
+ case btFloat:
+ tp = init_float_type (objfile, gdbarch_float_bit (gdbarch),
+ "float", gdbarch_float_format (gdbarch));
+ break;
+
+ case btDouble:
+ tp = init_float_type (objfile, gdbarch_double_bit (gdbarch),
+ "double", gdbarch_double_format (gdbarch));
+ break;
+
+ case btComplex:
+ tp = init_complex_type (objfile, "complex",
+ basic_type (btFloat, objfile));
+ break;
+
+ case btDComplex:
+ 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_integer_type (objfile, gdbarch_int_bit (gdbarch), 0,
+ "fixed decimal");
+ break;
+
+ case btFloatDec:
+ 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 (objfile, TYPE_CODE_STRING, TARGET_CHAR_BIT, "string");
+ break;
+
+ case btVoid:
+ tp = objfile_type (objfile)->builtin_void;
+ break;
+
+ case btLong64:
+ tp = init_integer_type (objfile, 64, 0, "long");
+ break;
+
+ case btULong64:
+ tp = init_integer_type (objfile, 64, 1, "unsigned long");
+ break;
+
+ case btLongLong64:
+ tp = init_integer_type (objfile, 64, 0, "long long");
+ break;
+
+ case btULongLong64:
+ tp = init_integer_type (objfile, 64, 1, "unsigned long long");
+ break;
+
+ case btAdr64:
+ tp = init_pointer_type (objfile, 64, "adr_64",
+ objfile_type (objfile)->builtin_void);
+ break;
+
+ case btInt64:
+ tp = init_integer_type (objfile, 64, 0, "int");
+ break;
+
+ case btUInt64:
+ tp = init_integer_type (objfile, 64, 1, "unsigned int");
+ break;
+
+ default:
+ tp = NULL;
+ break;
+ }
+
+ map_bt[bt] = tp;
+ return tp;
+}
+
/* Parse the type information provided in the raw AX entries for
- the symbol SH. Return the bitfield size in BS, in case.
+ the symbol SH. Return the bitfield size in BS, in case.
We must byte-swap the AX entries before we use them; BIGEND says whether
they are big-endian or little-endian (from fh->fBigendian). */
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)
{
- /* Null entries in this map are treated specially */
- static struct type **map_bt[] =
- {
- &mdebug_type_void, /* btNil */
- &mdebug_type_adr_32, /* btAdr */
- &mdebug_type_char, /* btChar */
- &mdebug_type_unsigned_char, /* btUChar */
- &mdebug_type_short, /* btShort */
- &mdebug_type_unsigned_short, /* btUShort */
- &mdebug_type_int_32, /* btInt */
- &mdebug_type_unsigned_int_32, /* btUInt */
- &mdebug_type_long_32, /* btLong */
- &mdebug_type_unsigned_long_32, /* btULong */
- &mdebug_type_float, /* btFloat */
- &mdebug_type_double, /* btDouble */
- 0, /* btStruct */
- 0, /* btUnion */
- 0, /* btEnum */
- 0, /* btTypedef */
- 0, /* btRange */
- 0, /* btSet */
- &mdebug_type_complex, /* btComplex */
- &mdebug_type_double_complex, /* btDComplex */
- 0, /* btIndirect */
- &mdebug_type_fixed_dec, /* btFixedDec */
- &mdebug_type_float_dec, /* btFloatDec */
- &mdebug_type_string, /* btString */
- 0, /* btBit */
- 0, /* btPicture */
- &mdebug_type_void, /* btVoid */
- 0, /* DEC C++: Pointer to member */
- 0, /* DEC C++: Virtual function table */
- 0, /* DEC C++: Class (Record) */
- &mdebug_type_long_64, /* btLong64 */
- &mdebug_type_unsigned_long_64, /* btULong64 */
- &mdebug_type_long_long_64, /* btLongLong64 */
- &mdebug_type_unsigned_long_long_64, /* btULongLong64 */
- &mdebug_type_adr_64, /* btAdr64 */
- &mdebug_type_int_64, /* btInt64 */
- &mdebug_type_unsigned_int_64, /* btUInt64 */
- };
-
TIR t[1];
struct type *tp = 0;
enum type_code type_code = TYPE_CODE_UNDEF;
- /* Handle undefined types, they have indexNil. */
+ /* Handle undefined types, they have indexNil. */
if (aux_index == indexNil)
- return mdebug_type_int;
+ return basic_type (btInt, mdebugread_objfile);
/* Handle corrupt aux indices. */
if (aux_index >= (debug_info->fdr + fd)->caux)
{
index_complaint (sym_name);
- return mdebug_type_int;
+ 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);
- if (t->bt >= (sizeof (map_bt) / sizeof (*map_bt)))
+ tp = basic_type (t->bt, mdebugread_objfile);
+ if (tp == NULL)
{
- basic_type_complaint (t->bt, sym_name);
- return mdebug_type_int;
- }
- if (map_bt[t->bt])
- {
- tp = *map_bt[t->bt];
- }
- else
- {
- tp = NULL;
- /* Cannot use builtin types -- build our own */
+ /* Cannot use builtin types -- build our own. */
switch (t->bt)
{
case btStruct:
type_code = TYPE_CODE_SET;
break;
case btIndirect:
- /* alpha cc -migrate uses this for typedefs. The true type will
+ /* alpha cc -migrate uses this for typedefs. The true type will
be obtained by crossreferencing below. */
type_code = TYPE_CODE_ERROR;
break;
case btTypedef:
- /* alpha cc uses this for typedefs. The true type will be
+ /* alpha cc uses this for typedefs. The true type will be
obtained by crossreferencing below. */
type_code = TYPE_CODE_ERROR;
break;
default:
basic_type_complaint (t->bt, sym_name);
- return mdebug_type_int;
+ return basic_type (btInt, mdebugread_objfile);
}
}
- /* Move on to next aux */
+ /* Move on to next aux. */
ax++;
if (t->fBitfield)
{
int width = AUX_GET_WIDTH (bigend, ax);
+
/* Inhibit core dumps if TIR is corrupted. */
if (bs == (int *) NULL)
{
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 = mdebug_type_char;
+ tp = basic_type (btChar, mdebugread_objfile);
else if (t->bt == btUShort && width == 8)
- tp = mdebug_type_unsigned_char;
+ tp = basic_type (btUChar, mdebugread_objfile);
else if (t->bt == btEnum)
;
else
- complaint (&symfile_complaints, _("can't handle TIR fBitfield for %s"),
+ complaint (&symfile_complaints,
+ _("can't handle TIR fBitfield for %s"),
sym_name);
}
else
{
complaint (&symfile_complaints,
_("unable to cross ref btIndirect for %s"), sym_name);
- return mdebug_type_int;
+ return basic_type (btInt, mdebugread_objfile);
}
xref_fh = get_rfd (fd, rf);
xref_fd = xref_fh - debug_info->fdr;
/* All these types really point to some (common) MIPS type
definition, and only the type-qualifiers fully identify
- them. We'll make the same effort at sharing. */
+ them. We'll make the same effort at sharing. */
if (t->bt == btStruct ||
t->bt == btUnion ||
t->bt == btEnum ||
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, current_objfile);
+ tp = init_type (mdebugread_objfile, type_code, 0, NULL);
/* DEC c89 produces cross references to qualified aggregate types,
dereference them. */
}
else
{
-
/* Usually, TYPE_CODE(tp) is already type_code. The main
exception is if we guessed wrong re struct/union/enum.
But for struct vs. union a wrong guess is harmless, so
TYPE_TAG_NAME (tp) = NULL;
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);
+ TYPE_TAG_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, 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
else
{
/* Usually, TYPE_CODE(tp) is already type_code. The main
- exception is if we guessed wrong re struct/union/enum. */
+ exception is if we guessed wrong re struct/union/enum. */
if (TYPE_CODE (tp) != type_code)
{
bad_tag_guess_complaint (sym_name);
}
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)
{
- 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);
{
complaint (&symfile_complaints,
_("unable to cross ref btTypedef for %s"), sym_name);
- tp = mdebug_type_int;
+ tp = basic_type (btInt, mdebugread_objfile);
}
}
- /* Deal with range types */
+ /* Deal with range types. */
if (t->bt == btRange)
{
- TYPE_NFIELDS (tp) = 2;
- TYPE_FIELDS (tp) = ((struct field *)
- TYPE_ALLOC (tp, 2 * sizeof (struct field)));
- TYPE_FIELD_NAME (tp, 0) = obsavestring ("Low", strlen ("Low"),
- ¤t_objfile->objfile_obstack);
- TYPE_FIELD_BITPOS (tp, 0) = AUX_GET_DNLOW (bigend, ax);
+ TYPE_NFIELDS (tp) = 0;
+ TYPE_RANGE_DATA (tp) = ((struct range_bounds *)
+ TYPE_ZALLOC (tp, sizeof (struct range_bounds)));
+ TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax);
ax++;
- TYPE_FIELD_NAME (tp, 1) = obsavestring ("High", strlen ("High"),
- ¤t_objfile->objfile_obstack);
- TYPE_FIELD_BITPOS (tp, 1) = AUX_GET_DNHIGH (bigend, ax);
+ TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax);
ax++;
}
- /* Parse all the type qualifiers now. If there are more
- than 6 the game will continue in the next aux */
+ /* Parse all the type qualifiers now. If there are more
+ than 6 the game will continue in the next aux. */
while (1)
{
/* Complain for illegal continuations due to corrupt aux entries. */
if (t->continued)
- complaint (&symfile_complaints, _("illegal TIR continued for %s"), sym_name);
+ complaint (&symfile_complaints,
+ _("illegal TIR continued for %s"), sym_name);
return tp;
}
/* Make up a complex type from a basic one. Type is passed by
- reference in TPP and side-effected as necessary. The type
+ reference in TPP and side-effected as necessary. The type
qualifier TQ says how to handle the aux symbols at AX for
the symbol SX we are currently analyzing. BIGEND says whether
aux symbols are big-endian or little-endian.
- Returns the number of aux symbols we parsed. */
+ Returns the number of aux symbols we parsed. */
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;
- /* Used in array processing */
+ /* Used in array processing. */
int rf, id;
FDR *fh;
struct type *range;
case tqArray:
off = 0;
- /* Determine and record the domain type (type of index) */
+ /* Determine and record the domain type (type of index). */
(*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, &rndx);
id = rndx.index;
rf = rndx.rfd;
if (TYPE_CODE (indx) != TYPE_CODE_INT)
{
complaint (&symfile_complaints,
- _("illegal array index type for %s, assuming int"), sym_name);
- indx = mdebug_type_int;
+ _("illegal array index type for %s, assuming int"),
+ sym_name);
+ 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);
ignore the erroneous bitsize from the auxiliary entry safely.
dbx seems to ignore it too. */
- /* TYPE_FLAG_TARGET_STUB now takes care of the zero TYPE_LENGTH
- problem. */
+ /* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem. */
if (TYPE_LENGTH (*tpp) == 0)
- {
- TYPE_FLAGS (t) |= TYPE_FLAG_TARGET_STUB;
- }
+ TYPE_TARGET_STUB (t) = 1;
*tpp = t;
return 4 + off;
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;
- struct mdebug_extra_func_info *e;
+ const struct block *b;
char *sh_name;
- /* Simple rule to find files linked "-x" */
+ /* Simple rule to find files linked "-x". */
if (cur_fdr->rss == -1)
{
if (pr->isym == -1)
{
- /* Static procedure at address pr->adr. Sigh. */
+ /* 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"),
the same name exists, lookup_symbol will eventually read in the symtab
for the global function and clobber cur_fdr. */
FDR *save_cur_fdr = cur_fdr;
- s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0, NULL);
+
+ s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0);
cur_fdr = save_cur_fdr;
#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
s = new_symbol (sh_name);
SYMBOL_DOMAIN (s) = VAR_DOMAIN;
SYMBOL_CLASS (s) = LOC_BLOCK;
- /* Donno its type, hope int is ok */
- SYMBOL_TYPE (s) = lookup_function_type (mdebug_type_int);
- add_symbol (s, top_stack->cur_block);
- /* Wont have symbols for this one */
+ /* Donno its type, hope int is ok. */
+ SYMBOL_TYPE (s)
+ = lookup_function_type (objfile_type (pst->objfile)->builtin_int);
+ add_symbol (s, top_stack->cur_st, top_stack->cur_block);
+ /* Won't have symbols for this one. */
b = new_block (2);
SYMBOL_BLOCK_VALUE (s) = b;
BLOCK_FUNCTION (b) = s;
if (i)
{
- e = (struct mdebug_extra_func_info *) SYMBOL_VALUE (i);
+ struct mdebug_extra_func_info *e;
+
+ e = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (i);
e->pdr = *pr;
- e->pdr.isym = (long) s;
/* GDB expects the absolute function start address for the
procedure descriptor in e->pdr.adr.
if (processing_gcc_compilation == 0
&& found_ecoff_debugging_info == 0
&& TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID)
- SYMBOL_TYPE (s) = builtin_type (current_gdbarch)->nodebug_text_symbol;
+ SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->nodebug_text_symbol;
}
-/* Parse the external symbol ES. Just call parse_symbol() after
+/* Parse the external symbol ES. Just call parse_symbol() after
making sure we know where the aux are for it.
BIGEND says whether aux entries are big-endian or little-endian.
- This routine clobbers top_stack->cur_block and ->cur_st. */
+ This routine clobbers top_stack->cur_block and ->cur_st. */
static void parse_external (EXTR *, int, struct section_offsets *,
struct objfile *);
/* 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:
break;
}
n_undef_symbols++;
- /* FIXME: Turn this into a complaint? */
+ /* FIXME: Turn this into a complaint? */
if (info_verbose)
printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"),
what, debug_info->ssext + es->asym.iss,
/* Note that the case of a symbol with indexNil must be handled
anyways by parse_symbol(). */
- parse_symbol (&es->asym, ax, (char *) NULL, bigend, section_offsets, objfile);
+ parse_symbol (&es->asym, ax, (char *) NULL,
+ bigend, section_offsets, objfile);
break;
default:
break;
GDB's linetable LT. MIPS' encoding requires a little bit
of magic to get things out. Note also that MIPS' line
numbers can go back and forth, apparently we can live
- with that and do not need to reorder our linetables */
+ with that and do not need to reorder our linetables. */
static void parse_lines (FDR *, PDR *, struct linetable *, int,
struct partial_symtab *, CORE_ADDR);
if (fh->cbLine == 0)
return;
- /* Scan by procedure descriptors */
+ /* Scan by procedure descriptors. */
k = 0;
for (j = 0; j < fh->cpd; j++, pr++)
{
CORE_ADDR adr;
unsigned char *halt;
- /* No code for this one */
+ /* No code for this one. */
if (pr->iline == ilineNil ||
pr->lnLow == -1 || pr->lnHigh == -1)
continue;
}
lineno += delta; /* first delta is 0 */
- /* Complain if the line table overflows. Could happen
+ /* Complain if the line table overflows. Could happen
with corrupt binaries. */
if (lt->nitems >= maxlines)
{
function_outside_compilation_unit_complaint (const char *arg1)
{
complaint (&symfile_complaints,
- _("function `%s' appears to be defined outside of all compilation units"),
+ _("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)
{
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, NULL,
- section, bfd_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;
const bfd_size_type external_rfd_size = debug_swap->external_rfd_size;
const bfd_size_type external_ext_size = debug_swap->external_ext_size;
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;
+ /* List of current psymtab's include files. */
+ const char **psymtab_include_list;
int includes_allocated;
int includes_used;
EXTR *extern_tab;
struct pst_map *fdr_to_pst;
- /* Index within current psymtab dependency list */
+ /* Index within current psymtab dependency list. */
struct partial_symtab **dependency_list;
int dependencies_used, dependencies_allocated;
struct cleanup *old_chain;
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:
* Only parse the Local and External symbols, and the Relative FDR.
* Fixup enough of the loader symtab to be able to use it.
* Allocate space only for the file's portions we need to
- * look at. (XXX)
+ * look at. (XXX)
*/
max_gdbinfo = 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);
+ to FDR -1. We`ll go along with that. */
+ fdr_to_pst = XCNEWVEC (struct pst_map, hdr->ifdMax + 1);
old_chain = make_cleanup (xfree, fdr_to_pst);
fdr_to_pst++;
{
struct partial_symtab *pst = new_psymtab ("", objfile);
+
fdr_to_pst[-1].pst = pst;
FDR_IDX (pst) = -1;
}
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;
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 */
+ /* Pass 1 over external syms: Presize and partition the list. */
ext_in = ext_block;
ext_in_end = ext_in + hdr->iextMax;
for (; ext_in < ext_in_end; ext_in++)
fdr_to_pst[ext_in->ifd].n_globals++;
}
- /* Pass 1.5 over files: partition out global symbol space */
+ /* Pass 1.5 over files: partition out global symbol space. */
s_idx = 0;
for (f_idx = -1; f_idx < hdr->ifdMax; f_idx++)
{
Since absolute sections don't get relocated, we
end up calculating an address different from that of
the symbol's minimal symbol (created earlier from the
- Elf symtab).
+ Elf symtab).
To fix this, either :
1) don't create the duplicate symbol
I've implemented #1 here...
Skip the creation of the minimal symbols based on the ECOFF
- symbol table. */
+ symbol table. */
- /* Pass 2 over external syms: fill in external symbols */
+ /* Pass 2 over external syms: fill in external symbols. */
ext_in = ext_block;
ext_in_end = ext_in + hdr->iextMax;
for (; ext_in < ext_in_end; ext_in++)
if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
{
complaint (&symfile_complaints,
- _("bad ifd for external symbol: %d (max %ld)"), ext_in->ifd,
- hdr->ifdMax);
+ _("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)
continue;
- /* Pass 3 over files, over local syms: fill in static symbols */
+ /* Pass 3 over files, over local syms: fill in static symbols. */
name = debug_info->ssext + ext_in->asym.iss;
- /* Process ECOFF Symbol Types and Storage Classes */
+ /* Process ECOFF Symbol Types and Storage Classes. */
switch (ext_in->asym.st)
{
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;
/* Label */
/* On certain platforms, some extra label symbols can be
- generated by the linker. One possible usage for this kind
+ generated by the linker. One possible usage for this kind
of symbols is to represent the address of the begining of a
- given section. For instance, on Tru64 5.1, the address of
+ given section. For instance, on Tru64 5.1, the address of
the _ftext label is the start address of the .text section.
The storage class of these symbols is usually directly
- related to the section to which the symbol refers. For
+ related to the section to which the symbol refers. For
instance, on Tru64 5.1, the storage class for the _fdata
label is scData, refering to the .data section.
It is actually possible that the section associated to the
- storage class of the label does not exist. On True64 5.1
+ storage class of the label does not exist. On True64 5.1
for instance, the libm.so shared library does not contain
any .data section, although it contains a _fpdata label
- which storage class is scData... Since these symbols are
+ which storage class is scData... Since these symbols are
usually useless for the debugger user anyway, we just
- discard these symbols.
- */
+ discard these symbols. */
if (SC_IS_TEXT (ext_in->asym.sc))
{
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;
case stLocal:
case stNil:
/* The alpha has the section start addresses in stLocal symbols
- whose name starts with a `.'. Skip those but complain for all
+ whose name starts with a `.'. Skip those but complain for all
other stLocal symbols.
Irix6 puts the section start addresses in stNil symbols, skip
- those too. */
+ those too. */
if (name[0] == '.')
continue;
/* Fall through. */
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);
}
- /* Pass 3 over files, over local syms: fill in static symbols */
+ /* Pass 3 over files, over local syms: fill in static symbols. */
for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
{
struct partial_symtab *save_pst;
{
textlow = fh->adr;
if (relocatable || textlow != 0)
- textlow += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
+ textlow += ANOFFSET (objfile->section_offsets,
+ SECT_OFF_TEXT (objfile));
}
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 = ((char *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct symloc)));
+ objfile->global_psymbols,
+ objfile->static_psymbols);
+ pst->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
+ sizeof (struct symloc));
memset (pst->read_symtab_private, 0, sizeof (struct symloc));
save_pst = pst;
DEBUG_INFO (pst) = debug_info;
PENDING_LIST (pst) = pending_list;
- /* The way to turn this into a symtab is to call... */
- pst->read_symtab = mdebug_psymtab_to_symtab;
+ /* The way to turn this into a symtab is to call... */
+ 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
a header file, which is not what we want.
But the FDRs for the header files are after the FDR for the source
file, so we can assign the language of the source file to the
- following header files. Then we save the language in the private
+ following header files. Then we save the language in the private
pst data so that we can reuse it when building symtabs. */
prev_language = psymtab_language;
current object file uses encapsulated stabs instead of mips
ecoff for local symbols. (It is the second symbol because
the first symbol is the stFile used to signal the start of a
- file). */
+ file). */
processing_gcc_compilation = 0;
if (fh->csym >= 2)
{
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;
- 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,
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,
+ 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? */
+ 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,
+ record_minimal_symbol (reader, namestring, sh.value,
mst_file_bss, sh.sc,
objfile);
+ sh.value += ANOFFSET (objfile->section_offsets,
+ SECT_OFF_BSS (objfile));
break;
}
}
continue;
}
- /* Handle stabs continuation */
+ /* Handle stabs continuation. */
{
char *stabstring = debug_info->ss + fh->issBase + sh.iss;
int len = strlen (stabstring);
+
while (stabstring[len - 1] == '\\')
{
SYMR sh2;
char *stabstring2;
int len2;
- /* Ignore continuation char from 1st string */
+ /* Ignore continuation char from 1st string. */
len--;
- /* Read next stabstring */
+ /* Read next stabstring. */
cur_sdx++;
(*swap_sym_in) (cur_bfd,
(((char *) debug_info->external_sym)
stabstring2 = debug_info->ss + fh->issBase + sh2.iss;
len2 = strlen (stabstring2);
- /* Concatinate stabstring2 with stabstring1 */
+ /* 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;
- /*
- * Standard, external, non-debugger, symbols
- */
+ 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));
+ 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));
+ 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));
+ 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:
record_it:
- continue;
+ continue;
- /* Standard, local, non-debugger, symbols */
+ /* Standard, local, non-debugger, symbols. */
case N_NBTEXT:
- /* We need to be able to deal with both N_FN or N_TEXT,
- because we have no way of knowing whether the sys-supplied ld
- or GNU ld was used to make the executable. Sequents throw
- in another wrinkle -- they renumbered N_FN. */
+ /* We need to be able to deal with both N_FN or
+ N_TEXT, because we have no way of knowing
+ whether the sys-supplied ld or GNU ld was used
+ to make the executable. Sequents throw in
+ another wrinkle -- they renumbered N_FN. */
case N_FN:
case N_FN_SEQ:
continue;
case N_DATA:
- sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
+ sh.value += ANOFFSET (objfile->section_offsets,
+ SECT_OFF_DATA (objfile));
goto record_it;
case N_UNDF | N_EXT:
- continue; /* Just undefined, not COMMON */
+ continue; /* Just undefined, not COMMON. */
case N_UNDF:
continue;
case N_NBBSS:
continue;
- /* Keep going . . . */
+ /* Keep going . . . */
/*
* Special symbol types for GNU
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));
+ const char *p;
- prev_textlow_not_set = textlow_not_set;
-
- /* A zero value is probably an indication for the SunPRO 3.0
- compiler. end_psymtab explicitly tests for zero, so
- don't relocate it. */
+ /* A zero value is probably an indication for the
+ 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
- (current_gdbarch))
- {
- textlow_not_set = 1;
- valu = 0;
- }
+ && gdbarch_sofun_address_maybe_missing (gdbarch))
+ 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;
-
+ { /* Here if prev stab wasn't N_SO. */
if (pst)
{
pst = (struct partial_symtab *) 0;
prev_so_symnum = symnum;
- /* End the current partial symtab and start a new one */
+ /* End the current partial symtab and start a
+ new one. */
/* SET_NAMESTRING ();*/
namestring = stabstring;
- /* Null name means end of .o file. Don't start a new one. */
+ /* Null name means end of .o file. Don't start a new
+ one. */
if (*namestring == '\000')
continue;
- /* Some compilers (including gcc) emit a pair of initial N_SOs.
- The first one is a directory name; 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')
- continue; /* Simply ignore directory name SOs */
-
- /* Some other compilers (C++ ones in particular) emit useless
- SOs for non-existant .c files. We ignore all subsequent SOs that
- immediately follow the first. */
+ /* Some compilers (including gcc) emit a pair of
+ initial N_SOs. The first one is a directory name;
+ 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 = lbasename (namestring);
+ if (p != namestring && *p == '\000')
+ continue; /* Simply ignore directory
+ name SOs. */
+
+ /* Some other compilers (C++ ones in particular) emit
+ useless SOs for non-existant .c files. We ignore
+ all subsequent SOs that immediately follow the
+ first. */
if (!pst)
pst = save_pst;
case N_SOL:
{
enum language tmp_language;
- /* Mark down an include file in the current psymtab */
- /* SET_NAMESTRING ();*/
+ /* Mark down an include file in the current psymtab. */
+
+ /* SET_NAMESTRING (); */
namestring = stabstring;
- tmp_language = deduce_language_from_filename (namestring);
+ tmp_language
+ = deduce_language_from_filename (namestring);
- /* Only change the psymtab's language if we've learned
- something useful (eg. tmp_language is not language_unknown).
- In addition, to match what start_subfile does, never change
- from C++ to C. */
+ /* Only change the psymtab's language if we've
+ learned something useful (eg. tmp_language is not
+ language_unknown). In addition, to match what
+ start_subfile does, never change from C++ to
+ C. */
if (tmp_language != language_unknown
&& (tmp_language != language_c
|| psymtab_language != language_cplus))
psymtab_language = tmp_language;
- /* In C++, one may expect the same filename to come round many
- times, when code is coming alternately from the main file
- and from inline functions in other files. So I check to see
- if this is a file we've seen before -- either the main
- source file, or a previously included file.
-
- This seems to be a lot of time to be spending on N_SOL, but
- things like "break c-exp.y:435" need to 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)
+ /* In C++, one may expect the same filename to come
+ round many times, when code is coming alternately
+ from the main file and from inline functions in
+ other files. So I check to see if this is a file
+ we've seen before -- either the main source file,
+ or a previously included file.
+
+ This seems to be a lot of time to be spending on
+ N_SOL, but things like "break c-exp.y:435" need to
+ 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 && 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;
}
- case N_LSYM: /* Typedef or automatic variable. */
- case N_STSYM: /* Data seg var -- static */
- case N_LCSYM: /* BSS " */
- case N_ROSYM: /* Read-only data seg var -- static. */
- case N_NBSTS: /* Gould nobase. */
- case N_NBLCS: /* symbols. */
+ case N_LSYM: /* Typedef or automatic variable. */
+ case N_STSYM: /* Data seg var -- static */
+ case N_LCSYM: /* BSS " */
+ case N_ROSYM: /* Read-only data seg var -- static. */
+ case N_NBSTS: /* Gould nobase. */
+ case N_NBLCS: /* symbols. */
case N_FUN:
- case N_GSYM: /* Global (extern) variable; can be
- data or bss (sigh FIXME). */
+ case N_GSYM: /* Global (extern) variable; can be
+ data or bss (sigh FIXME). */
/* Following may probably be ignored; I'll leave them here
for now (until I do Pascal and Modula 2 extensions). */
- case N_PC: /* I may or may not need this; I
- suspect not. */
- case N_M2C: /* I suspect that I can ignore this here. */
- case N_SCOPE: /* Same. */
+ case N_PC: /* I may or may not need this; I
+ suspect not. */
+ case N_M2C: /* I suspect that I can ignore this
+ here. */
+ case N_SCOPE: /* Same. */
- /* SET_NAMESTRING ();*/
+ /* SET_NAMESTRING (); */
namestring = stabstring;
p = (char *) strchr (namestring, ':');
if (!p)
- continue; /* Not a debugging symbol. */
+ continue; /* Not a debugging symbol. */
/* Main processing section for debugging symbols which
- the initial read through the symbol tables needs to worry
- about. If we reach this point, the symbol which we are
- considering is definitely one we are interested in.
- p must also contain the (valid) index into the namestring
- which indicates the debugging type symbol. */
+ the initial read through the symbol tables needs to
+ worry about. If we reach this point, the symbol
+ which we are considering is definitely one we are
+ interested in. p must also contain the (valid)
+ index into the namestring which indicates the
+ debugging type symbol. */
switch (p[1])
{
case 'S':
- sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
+ sh.value += ANOFFSET (objfile->section_offsets,
+ SECT_OFF_DATA (objfile));
- if (gdbarch_static_transform_name_p (current_gdbarch))
+ if (gdbarch_static_transform_name_p (gdbarch))
namestring = gdbarch_static_transform_name
- (current_gdbarch, namestring);
+ (gdbarch, namestring);
- add_psymbol_to_list (namestring, p - namestring,
+ 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':
- 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,
+ 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,
&objfile->global_psymbols,
- 0, sh.value,
+ sh.value,
psymtab_language, objfile);
continue;
|| (p == namestring + 1
&& namestring[0] != ' '))
{
- add_psymbol_to_list (namestring, p - namestring,
+ 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. */
- add_psymbol_to_list (namestring, p - namestring,
+ 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);
p += 1;
}
}
goto check_enum;
case 't':
- if (p != namestring) /* a name is there, not just :T... */
+ if (p != namestring) /* a name is there, not
+ just :T... */
{
- add_psymbol_to_list (namestring, p - namestring,
+ 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 all the enum constants to the partial symbol
- table. This does not cover enums without names, e.g.
- "enum {a, b} c;" in C, but fortunately those are
- rare. There is no way for GDB to find those from the
- enum type without spending too much time on it. Thus
- to solve this problem, the compiler needs to put out the
- enum in a nameless type. GCC2 does this. */
+ /* If this is an enumerated type, we need to add
+ all the enum constants to the partial symbol
+ table. This does not cover enums without names,
+ e.g. "enum {a, b} c;" in C, but fortunately
+ those are rare. There is no way for GDB to find
+ those from the enum type without spending too
+ much time on it. Thus to solve this problem,
+ the compiler needs to put out the enum in a
+ nameless type. GCC2 does this. */
/* We are looking for something of the form
<name> ":" ("t" | "T") [<number> "="] "e"
/* Skip over the colon and the 't' or 'T'. */
p += 2;
- /* This type may be given a number. Also, numbers can come
- in pairs like (0,26). Skip over it. */
+ /* This type may be given a number. Also, numbers
+ can come in pairs like (0,26). Skip over it. */
while ((*p >= '0' && *p <= '9')
|| *p == '(' || *p == ',' || *p == ')'
|| *p == '=')
if (*p++ == 'e')
{
- /* The aix4 compiler emits extra crud before the members. */
+ /* The aix4 compiler emits extra crud before
+ the members. */
if (*p == '-')
{
/* Skip over the type (?). */
Accept either. */
while (*p && *p != ';' && *p != ',')
{
- char *q;
+ const char *q;
- /* Check for and handle cretinous dbx symbol name
- continuation! */
+ /* Check for and handle cretinous dbx
+ symbol name continuation! */
if (*p == '\\' || (*p == '?' && p[1] == '\0'))
p = next_symbol_text (objfile);
for (q = p; *q && *q != ':'; q++)
;
/* Note that the value doesn't matter for
- enum constants in psymtabs, just in symtabs. */
- add_psymbol_to_list (p, q - p,
+ enum constants in psymtabs, just in
+ symtabs. */
+ add_psymbol_to_list (p, q - p, 1,
VAR_DOMAIN, LOC_CONST,
- &objfile->static_psymbols, 0,
- 0, psymtab_language, objfile);
+ &objfile->static_psymbols,
+ 0, psymtab_language,
+ objfile);
/* Point past the name. */
p = q;
/* Skip over the value. */
continue;
case 'c':
/* Constant, e.g. from "const" in Pascal. */
- add_psymbol_to_list (namestring, p - namestring,
+ add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_CONST,
- &objfile->static_psymbols, sh.value,
+ &objfile->static_psymbols,
0, 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,
+ sh.value += ANOFFSET (objfile->section_offsets,
+ SECT_OFF_TEXT (objfile));
+ add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->static_psymbols,
- 0, sh.value,
+ sh.value,
psymtab_language, objfile);
continue;
/* Global functions were ignored here, but now they
- are put into the global psymtab like one would expect.
- They're also in the minimal symbol table. */
+ are put into the global psymtab like one would
+ expect. They're also in the minimal symbol
+ table. */
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,
+ sh.value += ANOFFSET (objfile->section_offsets,
+ SECT_OFF_TEXT (objfile));
+ add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->global_psymbols,
- 0, sh.value,
+ sh.value,
psymtab_language, objfile);
continue;
- /* Two things show up here (hopefully); static symbols of
- local scope (static used inside braces) or extensions
- of structure symbols. We can ignore both. */
+ /* Two things show up here (hopefully); static
+ symbols of local scope (static used inside
+ braces) or extensions of structure symbols. We
+ can ignore both. */
case 'V':
case '(':
case '0':
case '8':
case '9':
case '-':
- case '#': /* for symbol identification (used in live ranges) */
+ case '#': /* For symbol identification (used
+ in live ranges). */
continue;
case ':':
- /* It is a C++ nested symbol. We don't need to record it
- (I don't think); if we try to look up foo::bar::baz,
- then symbols for the symtab containing foo should get
- read in, I think. */
+ /* It is a C++ nested symbol. We don't need to
+ record it (I don't think); if we try to look up
+ foo::bar::baz, then symbols for the symtab
+ containing foo should get read in, I think. */
/* Someone says sun cc puts out symbols like
/foo/baz/maclib::/usr/local/bin/maclib,
which would get here with a symbol type of ':'. */
continue;
default:
- /* Unexpected symbol descriptor. The second and subsequent stabs
- of a continued stab can show up here. The question is
- whether they ever can mimic a normal stab--it would be
- nice if not, since we certainly don't want to spend the
- time searching to the end of every string looking for
+ /* Unexpected symbol descriptor. The second and
+ subsequent stabs of a continued stab can show up
+ here. The question is whether they ever can
+ mimic a normal stab--it would be nice if not,
+ since we certainly don't want to spend the time
+ searching to the end of every string looking for
a backslash. */
complaint (&symfile_complaints,
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. */
if (pst
- && gdbarch_sofun_address_maybe_missing
- (current_gdbarch))
+ && gdbarch_sofun_address_maybe_missing (gdbarch))
{
pst = (struct partial_symtab *) 0;
includes_used = 0;
case N_EINCL:
case N_DSLINE:
case N_BSLINE:
- case N_SSYM: /* Claim: Structure or union element.
- Hopefully, I can ignore this. */
- case N_ENTRY: /* Alternate entry point; can ignore. */
- case N_MAIN: /* Can definitely ignore this. */
- case N_CATCH: /* These are GNU C++ extensions */
- case N_EHDECL: /* that can safely be ignored here. */
+ case N_SSYM: /* Claim: Structure or union
+ element. Hopefully, I can
+ ignore this. */
+ case N_ENTRY: /* Alternate entry point; can
+ ignore. */
+ case N_MAIN: /* Can definitely ignore this. */
+ case N_CATCH: /* These are GNU C++ extensions. */
+ case N_EHDECL: /* that can safely be ignored here. */
case N_LENG:
case N_BCOMM:
case N_ECOMM:
case N_LBRAC:
case N_NSYMS: /* Ultrix 4.0: symbol count */
case N_DEFD: /* GNU Modula-2 */
- case N_ALIAS: /* SunPro F77: alias name, ignore for now. */
+ case N_ALIAS: /* SunPro F77: alias name, ignore
+ for now. */
- case N_OBJ: /* useless types from Solaris */
+ case N_OBJ: /* Useless types from Solaris. */
case N_OPT:
- /* These symbols aren't interesting; don't worry about them */
+ /* These symbols aren't interesting; don't worry about
+ them. */
continue;
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"),
- hex_string (type_code)); /*CUR_SYMBOL_TYPE*/
+ /* 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"),
+ hex_string (type_code)); /* CUR_SYMBOL_TYPE */
continue;
}
if (stabstring
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
|| (sh.index == indexNil
&& (sh.st != stStatic || sh.sc == scAbs)))
{
- /* FIXME, premature? */
+ /* FIXME, premature? */
cur_sdx++;
continue;
}
name = debug_info->ss + fh->issBase + sh.iss;
+ minsym_value = sh.value;
+
switch (sh.sc)
{
case scText:
/* 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));
+ sh.value += ANOFFSET (objfile->section_offsets,
+ 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));
+ sh.value += ANOFFSET (objfile->section_offsets,
+ SECT_OFF_DATA (objfile));
break;
case scBss:
case scSBss:
- sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
+ sh.value += ANOFFSET (objfile->section_offsets,
+ SECT_OFF_BSS (objfile));
break;
}
int new_sdx;
case stStaticProc:
- prim_record_minimal_symbol_and_info (name, sh.value,
- mst_file_text, NULL,
- SECT_OFF_TEXT (objfile), NULL,
- objfile);
+ reader.record_with_info (name, minsym_value,
+ mst_file_text,
+ SECT_OFF_TEXT (objfile));
/* FALLTHROUGH */
/* Should not happen, but does when cross-compiling
with the MIPS compiler. FIXME -- pull later. */
index_complaint (name);
- new_sdx = cur_sdx + 1; /* Don't skip at all */
+ new_sdx = cur_sdx + 1; /* Don't skip at all. */
}
else
new_sdx = AUX_GET_ISYM (fh->fBigendian,
complaint (&symfile_complaints,
_("bad proc end in aux found from symbol %s"),
name);
- new_sdx = cur_sdx + 1; /* Don't skip backward */
+ new_sdx = cur_sdx + 1; /* Don't skip backward. */
}
/* For stProc symbol records, we need to check the
goto skip;
/* Usually there is a local and a global stProc symbol
- for a function. This means that the function name
+ for a function. This means that the function name
has already been entered into the mimimal symbol table
while processing the global symbols in pass 2 above.
One notable exception is the PROGRAM name from
symbol table, and the MAIN__ symbol via the minimal
symbol table. */
if (sh.st == stProc)
- add_psymbol_to_list (name, strlen (name),
+ 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),
+ 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,
- mst_file_data, NULL,
- SECT_OFF_DATA (objfile),
- NULL,
- objfile);
+ reader.record_with_info (name, minsym_value,
+ mst_file_data,
+ SECT_OFF_DATA (objfile));
else
- prim_record_minimal_symbol_and_info (name, sh.value,
- mst_file_bss, NULL,
- SECT_OFF_BSS (objfile),
- NULL,
- 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 */
- /* Skip forward declarations from Irix5 cc */
+ /* Skip forward declarations from Irix5 cc. */
goto skip;
case stTypedef: /* Typedef */
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:
case stEnum:
case stBlock: /* { }, str, un, enum */
/* Do not create a partial symbol for cc unnamed aggregates
- and gcc empty aggregates. */
+ and gcc empty aggregates. */
if ((sh.sc == scInfo
|| SC_IS_COMMON (sh.sc))
&& sh.iss != 0
&& sh.index != cur_sdx + 2)
{
- add_psymbol_to_list (name, strlen (name),
+ 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);
- /* Skip over the block */
+ /* Skip over the block. */
new_sdx = sh.index;
if (new_sdx <= cur_sdx)
{
- /* This happens with the Ultrix kernel. */
+ /* This happens with the Ultrix kernel. */
complaint (&symfile_complaints,
_("bad aux index at block symbol %s"), name);
- new_sdx = cur_sdx + 1; /* Don't skip backward */
+ new_sdx = cur_sdx + 1; /* Don't skip backward. */
}
cur_sdx = new_sdx;
continue;
case stLocal: /* Local variables */
/* Normally these are skipped because we skip over
all blocks we see. However, these can occur
- as visible symbols in a .h file that contains code. */
+ as visible symbols in a .h file that contains code. */
goto skip;
default:
cur_sdx++;
continue;
}
- /* Use this gdb symbol */
- add_psymbol_to_list (name, strlen (name),
- VAR_DOMAIN, class,
+ /* Use this gdb symbol. */
+ add_psymbol_to_list (name, strlen (name), 1,
+ 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 */
+ cur_sdx++; /* Go to next file symbol. */
}
- /* Now do enter the external symbols. */
+ /* Now do enter the external symbols. */
ext_ptr = &extern_tab[fdr_to_pst[f_idx].globals_offset];
cur_sdx = fdr_to_pst[f_idx].n_globals;
PST_PRIVATE (save_pst)->extern_count = cur_sdx;
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;
if (ext_ptr->ifd != f_idx)
- internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
+ internal_error (__FILE__, __LINE__,
+ _("failed internal consistency check"));
psh = &ext_ptr->asym;
/* Do not add undefined symbols to the partial symbol table. */
{
case scText:
case scRConst:
- svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
+ svalue += ANOFFSET (objfile->section_offsets,
+ SECT_OFF_TEXT (objfile));
break;
case scData:
case scSData:
case scRData:
case scPData:
case scXData:
- svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
+ svalue += ANOFFSET (objfile->section_offsets,
+ SECT_OFF_DATA (objfile));
break;
case scBss:
case scSBss:
- svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
+ svalue += ANOFFSET (objfile->section_offsets,
+ 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);
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),
- VAR_DOMAIN, class,
+ add_psymbol_to_list (name, strlen (name), 1,
+ 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;
}
}
- /* Now scan the FDRs for dependencies */
+ /* Now scan the FDRs for dependencies. */
for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
{
fh = f_idx + debug_info->fdr;
if (pst == (struct partial_symtab *) NULL)
continue;
- /* This should catch stabs-in-ecoff. */
+ /* This should catch stabs-in-ecoff. */
if (fh->crfd <= 1)
continue;
- /* Skip the first file indirect entry as it is a self dependency
- for source files or a reverse .h -> .c dependency for header files. */
+ /* 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 **)
/* Do not add to dependeny list if psymtab was empty. */
if (fdr_to_pst[rh].pst == (struct partial_symtab *) NULL)
continue;
- pst->dependencies[pst->number_of_dependencies++] = fdr_to_pst[rh].pst;
+ pst->dependencies[pst->number_of_dependencies++]
+ = fdr_to_pst[rh].pst;
}
}
}
/* If the current psymbol has an enumerated type, we need to add
- all the the enum constants to the partial symbol table. */
+ all the enum constants to the partial symbol table. */
static void
handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype,
/* Note that the value doesn't matter for enum constants
in psymtabs, just in symtabs. */
- add_psymbol_to_list (name, strlen (name),
+ 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;
}
}
-/* Get the next symbol. OBJFILE is unused. */
+/* Get the next symbol. OBJFILE is unused. */
-static char *
+static const char *
mdebug_next_symbol_text (struct objfile *objfile)
{
SYMR sh;
The flow of control and even the memory allocation differs. FIXME. */
static void
-psymtab_to_symtab_1 (struct partial_symtab *pst, 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;
wrap_here (""); /* Flush output */
gdb_flush (gdb_stdout);
}
- /* We only pass the filename for debug purposes */
- psymtab_to_symtab_1 (pst->dependencies[i],
+ /* We only pass the filename for debug purposes. */
+ psymtab_to_symtab_1 (objfile, pst->dependencies[i],
pst->dependencies[i]->filename);
}
&& pst->textlow == 0 && pst->texthigh == 0)
return;
- /* Now read the symbols for this symtab */
+ /* Now read the symbols for this symtab. */
cur_bfd = CUR_BFD (pst);
debug_swap = DEBUG_SWAP (pst);
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
: debug_info->fdr + cur_fd);
cur_fdr = fh;
- /* See comment in parse_partial_symbols about the @stabs sentinel. */
+ /* See comment in parse_partial_symbols about the @stabs sentinel. */
processing_gcc_compilation = 0;
if (fh != (FDR *) NULL && fh->csym >= 2)
{
if (processing_gcc_compilation != 0)
{
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
/* This symbol table contains stabs-in-ecoff entries. */
- /* Parse local symbols first */
+ /* Parse local symbols first. */
- if (fh->csym <= 2) /* FIXME, this blows psymtab->symtab ptr */
+ 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++)
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
it here instead of in process_one_symbol, so we
can keep a handle to its symtab. The symtab
would otherwise be ended twice, once in
- process_one_symbol, and once after this loop. */
+ 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, language);
}
}
/* Similarly a hack. */
else if (name[0] == '#')
{
process_one_symbol (N_SLINE, 0, valu, name,
- pst->section_offsets, pst->objfile);
+ section_offsets, objfile, language);
}
if (type_code == N_FUN)
{
/* Make up special symbol to contain
- procedure specific info */
+ procedure specific info. */
struct mdebug_extra_func_info *e =
- ((struct mdebug_extra_func_info *)
- obstack_alloc (¤t_objfile->objfile_obstack,
- sizeof (struct mdebug_extra_func_info)));
+ ((struct mdebug_extra_func_info *)
+ 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) = mdebug_type_void;
- SYMBOL_VALUE (s) = (long) e;
+ 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));
- record_line (current_subfile, sh.index, valu);
+ /* Handle encoded stab line number. */
+ valu += ANOFFSET (section_offsets,
+ SECT_OFF_TEXT (objfile));
+ record_line (current_subfile, sh.index,
+ gdbarch_addr_bits_remove (gdbarch, valu));
}
}
else if (sh.st == stProc || sh.st == stStaticProc
|| sh.st == stStatic || sh.st == stEnd)
- /* These are generated by gcc-2.x, do not complain */
+ /* These are generated by gcc-2.x, do not complain. */
;
else
- complaint (&symfile_complaints, _("unknown stabs symbol %s"), name);
+ complaint (&symfile_complaints,
+ _("unknown stabs symbol %s"), name);
}
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 f_max;
- 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 */
+ /* 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;
char *sym_ptr;
char *sym_end;
- /* Parse local symbols first */
+ /* Parse local symbols first. */
sym_ptr = ((char *) debug_info->external_sym
+ fh->isymBase * external_sym_size);
sym_end = sym_ptr + fh->csym * external_sym_size;
(*swap_sym_in) (cur_bfd, sym_ptr, &sh);
c = parse_symbol (&sh,
debug_info->external_aux + fh->iauxBase,
- sym_ptr, fh->fBigendian, pst->section_offsets, pst->objfile);
+ sym_ptr, fh->fBigendian,
+ 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);
lowest_pdr_addr = pdr_in->adr;
}
- parse_lines (fh, pr_block, lines, maxlines, pst, lowest_pdr_addr);
+ parse_lines (fh, pr_block, lines, maxlines,
+ pst, lowest_pdr_addr);
if (lines->nitems < fh->cline)
lines = shrink_linetable (lines);
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_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
- GLOBAL_BLOCK);
+ 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 = COMPUNIT_FILETABS (cust);
+ top_stack->cur_block
+ = 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);
+ parse_external (ext_ptr, fh->fBigendian,
+ 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);
- printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
+ 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);
n_undef_symbols = n_undef_labels = n_undef_vars = n_undef_procs = 0;
}
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. */
+/* Ancillary parsing procedures. */
/* Return 1 if the symbol pointed to by SH has a cross reference
to an opaque aggregate type, else 0. */
/* Lookup the type at relative index RN. Return it in TPP
if found and in any event come up with its name PNAME.
BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
- Return value says how many aux symbols we ate. */
+ Return value says how many aux symbols we ate. */
static int
-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)
+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. */
+ 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);
- /* Escape index means 'the next one' */
+ /* Escape index means 'the next one'. */
if (rn->rfd == 0xfff)
{
result++;
}
/* 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;
}
/* mips cc uses an escaped rn->index of 0 for struct return types
- of procedures that were compiled without -g. These will always remain
+ of procedures that were compiled without -g. These will always remain
undefined. */
if (rn->rfd == 0xfff && rn->index == 0)
{
two cases:
a) forward declarations of structs/unions/enums which are not
defined in this compilation unit.
- For these the type will be void. This is a bad design decision
+ For these the type will be void. This is a bad design decision
as cross referencing across compilation units is impossible
due to the missing name.
b) forward declarations of structs/unions/enums/typedefs which
are defined later in this file or in another file in the same
- compilation unit. Irix5 cc uses a stIndirect symbol for this.
+ compilation unit. Irix5 cc uses a stIndirect symbol for this.
Simply cross reference those again to get the true type.
The forward references are not entered in the pending list and
in the symbol table. */
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;
break;
case btTypedef:
- /* Follow a forward typedef. This might recursively
+ /* Follow a forward typedef. This might recursively
call cross_ref till we get a non typedef'ed type.
FIXME: This is not correct behaviour, but gdb currently
- cannot handle typedefs without type copying. Type
+ cannot handle typedefs without type copying. Type
copying is impossible as we might have mutual forward
references between two files and the copied type would not
get filled in when we later parse its definition. */
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;
}
else if (sh.st == stTypedef)
{
- /* Parse the type for a normal typedef. This might recursively call
+ /* Parse the type for a normal typedef. This might recursively call
cross_ref till we get a non typedef'ed type.
FIXME: This is not correct behaviour, but gdb currently
- cannot handle typedefs without type copying. But type copying is
+ cannot handle typedefs without type copying. But type copying is
impossible as we might have mutual forward references between
two files and the copied type would not get filled in when
we later parse its definition. */
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);
}
- /* We used one auxent normally, two if we got a "next one" rf. */
+ /* We used one auxent normally, two if we got a "next one" rf. */
return result;
}
/* Quick&dirty lookup procedure, to avoid the MI ones that require
- keeping the symtab sorted */
+ keeping the symtab sorted. */
static struct symbol *
-mylookup_symbol (char *name, 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 dict_iterator iter;
+ struct block_iterator iter;
int inc;
struct symbol *sym;
inc = name[0];
ALL_BLOCK_SYMBOLS (block, iter, sym)
{
- if (DEPRECATED_SYMBOL_NAME (sym)[0] == inc
+ if (SYMBOL_LINKAGE_NAME (sym)[0] == inc
&& SYMBOL_DOMAIN (sym) == domain
- && SYMBOL_CLASS (sym) == class
- && strcmp (DEPRECATED_SYMBOL_NAME (sym), name) == 0)
+ && 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;
}
/* Add a new symbol S to a block B. */
static void
-add_symbol (struct symbol *s, struct block *b)
+add_symbol (struct symbol *s, struct symtab *symtab, struct block *b)
{
+ symbol_set_symtab (s, symtab);
dict_add_symbol (BLOCK_DICT (b), s);
}
-/* Add a new block B to a symtab S */
+/* Add a new block B to a symtab 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;
}
a prologue than mips_skip_prologue).
But due to the compressed line table format there are line number entries
for the same line which are needed to bridge the gap to the next
- line number entry. These entries have a bogus address info with them
+ line number entry. These entries have a bogus address info with them
and we are unable to tell them from intended duplicate line number
entries.
This is another reason why -ggdb debugging format is preferable. */
add_line (struct linetable *lt, int lineno, CORE_ADDR adr, int last)
{
/* DEC c89 sometimes produces zero linenos which confuse gdb.
- Change them to something sensible. */
+ Change them to something sensible. */
if (lineno == 0)
lineno = 1;
if (last == 0)
- last = -2; /* make sure we record first line */
+ last = -2; /* Make sure we record first line. */
- if (last == lineno) /* skip continuation lines */
+ if (last == lineno) /* Skip continuation lines. */
return lineno;
lt->item[lt->nitems].line = lineno;
return lineno;
}
\f
-/* Sorting and reordering procedures */
+/* Sorting and reordering procedures. */
-/* Blocks with a smaller low bound should come first */
+/* Blocks with a smaller low bound should come first. */
static int
compare_blocks (const void *arg1, const void *arg2)
/* Sort the blocks of a symtab S.
Reorder the blocks in the blockvector by code-address,
- as required by some MI search routines */
+ as required by some MI search routines. */
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 *),
}
\f
-/* Constructor/restructor/destructor procedures */
+/* Constructor/restructor/destructor procedures. */
/* Allocate a new symtab for NAME. Needs an estimate of how many
- linenumbers MAXLINES we'll put in it */
+ linenumbers MAXLINES we'll put in it. */
-static struct symtab *
-new_symtab (char *name, int maxlines, struct objfile *objfile)
+static struct compunit_symtab *
+new_symtab (const char *name, int maxlines, struct objfile *objfile)
{
- struct symtab *s = allocate_symtab (name, objfile);
-
- LINETABLE (s) = 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 = obsavestring ("ECOFF", 5,
- &objfile->objfile_obstack);
- return (s);
+ 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);
+
+ 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, lang);
+ BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = new_block (NON_FUNCTION_BLOCK, lang);
+ 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 */
+/* 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 */
+ /* Keep a backpointer to the file's symbols. */
- psymtab->read_symtab_private = ((char *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct symloc)));
+ psymtab->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
+ sizeof (struct symloc));
memset (psymtab->read_symtab_private, 0, sizeof (struct symloc));
CUR_BFD (psymtab) = cur_bfd;
DEBUG_SWAP (psymtab) = debug_swap;
DEBUG_INFO (psymtab) = debug_info;
PENDING_LIST (psymtab) = pending_list;
- /* The way to turn this into a symtab is to call... */
- psymtab->read_symtab = mdebug_psymtab_to_symtab;
+ /* The way to turn this into a symtab is to call... */
+ 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;
}
-/* Oops, too big. Shrink it. This was important with the 2.4 linetables,
+/* Oops, too big. Shrink it. This was important with the 2.4 linetables,
I am not so sure about the 3.4 ones.
Since the struct linetable already includes one item, we subtract one when
static struct linetable *
shrink_linetable (struct linetable *lt)
{
-
return (struct linetable *) xrealloc ((void *) lt,
(sizeof (struct linetable)
+ ((lt->nitems - 1)
* sizeof (lt->item))));
}
-/* Allocate and zero a new blockvector of NBLOCKS blocks. */
+/* Allocate and zero a new blockvector of NBLOCKS blocks. */
static struct blockvector *
new_bvect (int nblocks)
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 */
+/* Create a new symbol with printname NAME. */
static struct symbol *
-new_symbol (char *name)
+new_symbol (const 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_LANGUAGE (s) = psymtab_language;
- SYMBOL_SET_NAMES (s, name, strlen (name), current_objfile);
+ SYMBOL_SET_LANGUAGE (s, psymtab_language,
+ &mdebugread_objfile->objfile_obstack);
+ SYMBOL_SET_NAMES (s, name, strlen (name), 1, mdebugread_objfile);
return s;
}
-/* Create a new type with printname NAME */
+/* Create a new type with printname NAME. */
static struct type *
new_type (char *name)
{
struct type *t;
- t = alloc_type (current_objfile);
+ t = alloc_type (mdebugread_objfile);
TYPE_NAME (t) = name;
- TYPE_CPLUS_SPECIFIC (t) = (struct cplus_struct_type *) &cplus_struct_default;
+ INIT_CPLUS_SPECIFIC (t);
return t;
}
\f
{
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,
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
_initialize_mdebugread (void)
{
- mdebug_type_void =
- init_type (TYPE_CODE_VOID, 1,
- 0,
- "void", (struct objfile *) NULL);
- mdebug_type_char =
- init_type (TYPE_CODE_INT, 1,
- 0,
- "char", (struct objfile *) NULL);
- mdebug_type_unsigned_char =
- init_type (TYPE_CODE_INT, 1,
- TYPE_FLAG_UNSIGNED,
- "unsigned char", (struct objfile *) NULL);
- mdebug_type_short =
- init_type (TYPE_CODE_INT, 2,
- 0,
- "short", (struct objfile *) NULL);
- mdebug_type_unsigned_short =
- init_type (TYPE_CODE_INT, 2,
- TYPE_FLAG_UNSIGNED,
- "unsigned short", (struct objfile *) NULL);
- mdebug_type_int_32 =
- init_type (TYPE_CODE_INT, 4,
- 0,
- "int", (struct objfile *) NULL);
- mdebug_type_unsigned_int_32 =
- init_type (TYPE_CODE_INT, 4,
- TYPE_FLAG_UNSIGNED,
- "unsigned int", (struct objfile *) NULL);
- mdebug_type_int_64 =
- init_type (TYPE_CODE_INT, 8,
- 0,
- "int", (struct objfile *) NULL);
- mdebug_type_unsigned_int_64 =
- init_type (TYPE_CODE_INT, 8,
- TYPE_FLAG_UNSIGNED,
- "unsigned int", (struct objfile *) NULL);
- mdebug_type_long_32 =
- init_type (TYPE_CODE_INT, 4,
- 0,
- "long", (struct objfile *) NULL);
- mdebug_type_unsigned_long_32 =
- init_type (TYPE_CODE_INT, 4,
- TYPE_FLAG_UNSIGNED,
- "unsigned long", (struct objfile *) NULL);
- mdebug_type_long_64 =
- init_type (TYPE_CODE_INT, 8,
- 0,
- "long", (struct objfile *) NULL);
- mdebug_type_unsigned_long_64 =
- init_type (TYPE_CODE_INT, 8,
- TYPE_FLAG_UNSIGNED,
- "unsigned long", (struct objfile *) NULL);
- mdebug_type_long_long_64 =
- init_type (TYPE_CODE_INT, 8,
- 0,
- "long long", (struct objfile *) NULL);
- mdebug_type_unsigned_long_long_64 =
- init_type (TYPE_CODE_INT, 8,
- TYPE_FLAG_UNSIGNED,
- "unsigned long long", (struct objfile *) NULL);
- mdebug_type_adr_32 =
- init_type (TYPE_CODE_PTR, 4,
- TYPE_FLAG_UNSIGNED,
- "adr_32", (struct objfile *) NULL);
- TYPE_TARGET_TYPE (mdebug_type_adr_32) = mdebug_type_void;
- mdebug_type_adr_64 =
- init_type (TYPE_CODE_PTR, 8,
- TYPE_FLAG_UNSIGNED,
- "adr_64", (struct objfile *) NULL);
- TYPE_TARGET_TYPE (mdebug_type_adr_64) = mdebug_type_void;
- mdebug_type_float =
- init_type (TYPE_CODE_FLT,
- gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT,
- 0, "float", (struct objfile *) NULL);
- mdebug_type_double =
- init_type (TYPE_CODE_FLT,
- gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT,
- 0, "double", (struct objfile *) NULL);
- mdebug_type_complex =
- init_type (TYPE_CODE_COMPLEX,
- 2 * gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT,
- 0, "complex", (struct objfile *) NULL);
- TYPE_TARGET_TYPE (mdebug_type_complex) = mdebug_type_float;
- mdebug_type_double_complex =
- init_type (TYPE_CODE_COMPLEX,
- 2 * gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT,
- 0, "double complex", (struct objfile *) NULL);
- TYPE_TARGET_TYPE (mdebug_type_double_complex) = mdebug_type_double;
-
- /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
- FIXME. */
- mdebug_type_string =
- init_type (TYPE_CODE_STRING,
- TARGET_CHAR_BIT / TARGET_CHAR_BIT,
- 0, "string",
- (struct objfile *) NULL);
-
- /* 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? */
- mdebug_type_fixed_dec =
- init_type (TYPE_CODE_INT,
- gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
- 0, "fixed decimal",
- (struct objfile *) NULL);
-
- mdebug_type_float_dec =
- init_type (TYPE_CODE_ERROR,
- gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT,
- 0, "floating decimal",
- (struct objfile *) NULL);
+ 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);
}