/* Read a symbol table in ECOFF format (Third-Eye).
- Copyright (C) 1986-1987, 1989-2004, 2007-2012 Free Software
- Foundation, Inc.
+ Copyright (C) 1986-2014 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 "block.h"
#include "dictionary.h"
#include "mdebugread.h"
-#include "gdb_stat.h"
-#include "gdb_string.h"
+#include <sys/stat.h>
+#include <string.h>
#include "psympriv.h"
+#include "source.h"
#include "bfd.h"
static struct partial_symtab *new_psymtab (char *, struct objfile *);
-static void psymtab_to_symtab_1 (struct partial_symtab *, const char *);
+static void psymtab_to_symtab_1 (struct objfile *objfile,
+ struct partial_symtab *, const char *);
static void add_block (struct block *, struct symtab *);
static char *mdebug_next_symbol_text (struct objfile *);
\f
-/* Exported procedure: Builds a symtab from the PST partial one.
- Restores the environment in effect when PST was created, delegates
+/* Exported procedure: Builds a symtab from the partial symtab SELF.
+ Restores the environment in effect when SELF was created, delegates
most of the work to an ancillary procedure, and sorts
- and reorders the symtab list at the end. */
+ and reorders the symtab list at the end. SELF is not NULL. */
static void
-mdebug_psymtab_to_symtab (struct partial_symtab *pst)
+mdebug_read_symtab (struct partial_symtab *self, struct objfile *objfile)
{
- if (!pst)
- return;
-
if (info_verbose)
{
- printf_filtered (_("Reading in symbols for %s..."), pst->filename);
+ printf_filtered (_("Reading in symbols for %s..."), self->filename);
gdb_flush (gdb_stdout);
}
next_symbol_text_func = mdebug_next_symbol_text;
- psymtab_to_symtab_1 (pst, pst->filename);
+ psymtab_to_symtab_1 (objfile, self, self->filename);
/* Match with global symbols. This only needs to be done once,
after all of the symtabs and dependencies have been read in. */
- scan_file_globals (pst->objfile);
+ scan_file_globals (objfile);
if (info_verbose)
printf_filtered (_("done.\n"));
};
-/* 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;
mdebug_reg_to_regnum
};
+/* The "aclass" indices for computed symbols. */
+
+static int mdebug_register_index;
+static int mdebug_regparm_index;
+
static int
parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
struct section_offsets *section_offsets, struct objfile *objfile)
s = new_symbol (name);
SYMBOL_VALUE (s) = svalue;
if (sh->sc == scRegister)
- {
- class = LOC_REGISTER;
- SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
- }
+ class = mdebug_register_index;
else
class = LOC_LOCAL;
data: /* Common code for symbols describing data. */
SYMBOL_DOMAIN (s) = VAR_DOMAIN;
- SYMBOL_CLASS (s) = class;
+ SYMBOL_ACLASS_INDEX (s) = class;
add_symbol (s, top_stack->cur_st, b);
/* Type could be missing if file is compiled without debugging info. */
{
case scRegister:
/* Pass by value in register. */
- SYMBOL_CLASS (s) = LOC_REGISTER;
- SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
+ SYMBOL_ACLASS_INDEX (s) = mdebug_register_index;
break;
case scVar:
/* Pass by reference on stack. */
- SYMBOL_CLASS (s) = LOC_REF_ARG;
+ SYMBOL_ACLASS_INDEX (s) = LOC_REF_ARG;
break;
case scVarRegister:
/* Pass by reference in register. */
- SYMBOL_CLASS (s) = LOC_REGPARM_ADDR;
- SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
+ SYMBOL_ACLASS_INDEX (s) = mdebug_regparm_index;
break;
default:
/* Pass by value on stack. */
- SYMBOL_CLASS (s) = LOC_ARG;
+ SYMBOL_ACLASS_INDEX (s) = LOC_ARG;
break;
}
SYMBOL_VALUE (s) = svalue;
case stLabel: /* label, goes into current block. */
s = new_symbol (name);
SYMBOL_DOMAIN (s) = VAR_DOMAIN; /* So that it can be used */
- SYMBOL_CLASS (s) = LOC_LABEL; /* but not misused. */
+ SYMBOL_ACLASS_INDEX (s) = LOC_LABEL; /* but not misused. */
SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int;
add_symbol (s, top_stack->cur_st, top_stack->cur_block);
}
s = new_symbol (name);
SYMBOL_DOMAIN (s) = VAR_DOMAIN;
- SYMBOL_CLASS (s) = LOC_BLOCK;
+ SYMBOL_ACLASS_INDEX (s) = LOC_BLOCK;
/* Type of the return value. */
if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
t = objfile_type (objfile)->builtin_int;
FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss;
FIELD_BITSIZE (*f) = 0;
- enum_sym = ((struct symbol *)
- obstack_alloc (&mdebugread_objfile->objfile_obstack,
- sizeof (struct symbol)));
- memset (enum_sym, 0, sizeof (struct symbol));
+ enum_sym = allocate_symbol (mdebugread_objfile);
SYMBOL_SET_LINKAGE_NAME
- (enum_sym, obsavestring (f->name, strlen (f->name),
- &mdebugread_objfile->objfile_obstack));
- SYMBOL_CLASS (enum_sym) = LOC_CONST;
+ (enum_sym,
+ obstack_copy0 (&mdebugread_objfile->objfile_obstack,
+ f->name, strlen (f->name)));
+ SYMBOL_ACLASS_INDEX (enum_sym) = LOC_CONST;
SYMBOL_TYPE (enum_sym) = t;
SYMBOL_DOMAIN (enum_sym) = VAR_DOMAIN;
SYMBOL_VALUE (enum_sym) = tsym.value;
s = new_symbol (name);
SYMBOL_DOMAIN (s) = STRUCT_DOMAIN;
- SYMBOL_CLASS (s) = LOC_TYPEDEF;
+ SYMBOL_ACLASS_INDEX (s) = LOC_TYPEDEF;
SYMBOL_VALUE (s) = 0;
SYMBOL_TYPE (s) = t;
add_symbol (s, top_stack->cur_st, top_stack->cur_block);
/* 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_ACLASS_INDEX (s) = LOC_CONST;
SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->builtin_void;
e = ((struct mdebug_extra_func_info *)
obstack_alloc (&mdebugread_objfile->objfile_obstack,
if (nparams > 0)
{
- struct dict_iterator iter;
+ struct block_iterator iter;
TYPE_NFIELDS (ftype) = nparams;
TYPE_FIELDS (ftype) = (struct field *)
break;
s = new_symbol (name);
SYMBOL_DOMAIN (s) = VAR_DOMAIN;
- SYMBOL_CLASS (s) = LOC_TYPEDEF;
+ SYMBOL_ACLASS_INDEX (s) = LOC_TYPEDEF;
SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block;
SYMBOL_TYPE (s) = t;
add_symbol (s, top_stack->cur_st, top_stack->cur_block);
else if (TYPE_TAG_NAME (tp) == NULL
|| strcmp (TYPE_TAG_NAME (tp), name) != 0)
TYPE_TAG_NAME (tp)
- = obsavestring (name, strlen (name),
- &mdebugread_objfile->objfile_obstack);
+ = obstack_copy0 (&mdebugread_objfile->objfile_obstack,
+ name, strlen (name));
}
}
}
if (TYPE_NAME (tp) == NULL
|| strcmp (TYPE_NAME (tp), name) != 0)
- TYPE_NAME (tp) = obsavestring (name, strlen (name),
- &mdebugread_objfile->objfile_obstack);
+ TYPE_NAME (tp)
+ = obstack_copy0 (&mdebugread_objfile->objfile_obstack,
+ name, strlen (name));
}
}
if (t->bt == btTypedef)
if (processing_gcc_compilation == 0
&& found_ecoff_debugging_info == 0
&& TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID)
- SYMBOL_TYPE (s) = objfile_type (pst->objfile)->nodebug_text_symbol;
+ SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->nodebug_text_symbol;
}
/* Parse the external symbol ES. Just call parse_symbol() after
struct objfile *objfile)
{
int section;
- asection *bfd_section;
switch (storage_class)
{
case scText:
section = SECT_OFF_TEXT (objfile);
- bfd_section = bfd_get_section_by_name (cur_bfd, ".text");
break;
case scData:
section = SECT_OFF_DATA (objfile);
- bfd_section = bfd_get_section_by_name (cur_bfd, ".data");
break;
case scBss:
section = SECT_OFF_BSS (objfile);
- bfd_section = bfd_get_section_by_name (cur_bfd, ".bss");
break;
case scSData:
section = get_section_index (objfile, ".sdata");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".sdata");
break;
case scSBss:
section = get_section_index (objfile, ".sbss");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".sbss");
break;
case scRData:
section = get_section_index (objfile, ".rdata");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".rdata");
break;
case scInit:
section = get_section_index (objfile, ".init");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".init");
break;
case scXData:
section = get_section_index (objfile, ".xdata");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".xdata");
break;
case scPData:
section = get_section_index (objfile, ".pdata");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".pdata");
break;
case scFini:
section = get_section_index (objfile, ".fini");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".fini");
break;
case scRConst:
section = get_section_index (objfile, ".rconst");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".rconst");
break;
#ifdef scTlsData
case scTlsData:
section = get_section_index (objfile, ".tlsdata");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsdata");
break;
#endif
#ifdef scTlsBss
case scTlsBss:
section = get_section_index (objfile, ".tlsbss");
- bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsbss");
break;
#endif
default:
/* This kind of symbol is not associated to a section. */
section = -1;
- bfd_section = NULL;
}
prim_record_minimal_symbol_and_info (name, address, ms_type,
- section, bfd_section, objfile);
+ section, objfile);
}
/* Master parsing procedure for first-pass reading of file symbols
(struct partial_symtab **) alloca (dependencies_allocated *
sizeof (struct partial_symtab *));
- last_source_file = NULL;
+ set_last_source_file (NULL);
/*
* Big plan:
PENDING_LIST (pst) = pending_list;
/* The way to turn this into a symtab is to call... */
- pst->read_symtab = mdebug_psymtab_to_symtab;
+ pst->read_symtab = mdebug_read_symtab;
/* Set up language for the pst.
The language from the FDR is used if it is unambigious (e.g. cfront
prim_record_minimal_symbol_and_info (name, sh.value,
mst_file_text,
SECT_OFF_TEXT (objfile),
- NULL, objfile);
+ objfile);
/* FALLTHROUGH */
prim_record_minimal_symbol_and_info (name, sh.value,
mst_file_data,
SECT_OFF_DATA (objfile),
- NULL,
objfile);
else
prim_record_minimal_symbol_and_info (name, sh.value,
mst_file_bss,
SECT_OFF_BSS (objfile),
- NULL,
objfile);
class = LOC_STATIC;
break;
/* Link pst to FDR. 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,
+ fdr_to_pst[f_idx].pst = end_psymtab (objfile, save_pst,
psymtab_include_list, includes_used,
-1, save_pst->texthigh,
dependency_list, dependencies_used, textlow_not_set);
The flow of control and even the memory allocation differs. FIXME. */
static void
-psymtab_to_symtab_1 (struct partial_symtab *pst, const char *filename)
+psymtab_to_symtab_1 (struct objfile *objfile,
+ struct partial_symtab *pst, const char *filename)
{
bfd_size_type external_sym_size;
bfd_size_type external_pdr_size;
gdb_flush (gdb_stdout);
}
/* We only pass the filename for debug purposes. */
- psymtab_to_symtab_1 (pst->dependencies[i],
+ psymtab_to_symtab_1 (objfile, pst->dependencies[i],
pst->dependencies[i]->filename);
}
external_pdr_size = debug_swap->external_pdr_size;
swap_sym_in = debug_swap->swap_sym_in;
swap_pdr_in = debug_swap->swap_pdr_in;
- mdebugread_objfile = pst->objfile;
+ mdebugread_objfile = objfile;
cur_fd = FDR_IDX (pst);
fh = ((cur_fd == -1)
? (FDR *) NULL
if (processing_gcc_compilation != 0)
{
- struct gdbarch *gdbarch = get_objfile_arch (pst->objfile);
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
/* This symbol table contains stabs-in-ecoff entries. */
would otherwise be ended twice, once in
process_one_symbol, and once after this loop. */
if (type_code == N_SO
- && last_source_file
+ && get_last_source_file ()
&& previous_stab_code != (unsigned char) N_SO
&& *name == '\000')
{
valu += ANOFFSET (pst->section_offsets,
- SECT_OFF_TEXT (pst->objfile));
+ SECT_OFF_TEXT (objfile));
previous_stab_code = N_SO;
- st = end_symtab (valu, pst->objfile,
- SECT_OFF_TEXT (pst->objfile));
+ st = end_symtab (valu, objfile,
+ 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);
+ pst->section_offsets, objfile);
}
}
/* Similarly a hack. */
else if (name[0] == '#')
{
process_one_symbol (N_SLINE, 0, valu, name,
- pst->section_offsets, pst->objfile);
+ pst->section_offsets, objfile);
}
if (type_code == N_FUN)
{
memset (e, 0, sizeof (struct mdebug_extra_func_info));
SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
- SYMBOL_CLASS (s) = LOC_CONST;
- SYMBOL_TYPE (s) = objfile_type (pst->objfile)->builtin_void;
+ SYMBOL_ACLASS_INDEX (s) = LOC_CONST;
+ SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_void;
SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
e->pdr.framereg = -1;
add_symbol_to_list (s, &local_symbols);
{
/* Handle encoded stab line number. */
valu += ANOFFSET (pst->section_offsets,
- SECT_OFF_TEXT (pst->objfile));
+ SECT_OFF_TEXT (objfile));
record_line (current_subfile, sh.index,
gdbarch_addr_bits_remove (gdbarch, valu));
}
if (! last_symtab_ended)
{
- st = end_symtab (pst->texthigh, pst->objfile,
- SECT_OFF_TEXT (pst->objfile));
+ st = end_symtab (pst->texthigh, objfile,
+ SECT_OFF_TEXT (objfile));
end_stabs ();
}
if (fh == 0)
{
maxlines = 0;
- st = new_symtab ("unknown", 0, pst->objfile);
+ st = new_symtab ("unknown", 0, objfile);
}
else
{
maxlines = 2 * fh->cline;
- st = new_symtab (pst->filename, maxlines, pst->objfile);
+ st = new_symtab (pst->filename, maxlines, objfile);
/* The proper language was already determined when building
the psymtab, use it. */
c = parse_symbol (&sh,
debug_info->external_aux + fh->iauxBase,
sym_ptr, fh->fBigendian,
- pst->section_offsets, pst->objfile);
+ pst->section_offsets, objfile);
sym_ptr += c * external_sym_size;
}
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);
+ pst->section_offsets, objfile);
/* If there are undefined symbols, tell the user.
The alpha has an undefined symbol for every symbol that is
if (info_verbose && n_undef_symbols)
{
printf_filtered (_("File %s contains %d unresolved references:"),
- st->filename, n_undef_symbols);
+ symtab_to_filename_for_display (st),
+ n_undef_symbols);
printf_filtered ("\n\t%4d variables\n\t%4d "
"procedures\n\t%4d labels\n",
n_undef_vars, n_undef_procs, n_undef_labels);
}
pop_parse_stack ();
- st->primary = 1;
+ set_symtab_primary (st, 1);
sort_blocks (st);
}
mylookup_symbol (char *name, struct block *block,
domain_enum domain, enum address_class class)
{
- struct dict_iterator iter;
+ struct block_iterator iter;
int inc;
struct symbol *sym;
PENDING_LIST (psymtab) = pending_list;
/* The way to turn this into a symtab is to call... */
- psymtab->read_symtab = mdebug_psymtab_to_symtab;
+ psymtab->read_symtab = mdebug_read_symtab;
return (psymtab);
}
static struct symbol *
new_symbol (char *name)
{
- struct symbol *s = ((struct symbol *)
- obstack_alloc (&mdebugread_objfile->objfile_obstack,
- sizeof (struct symbol)));
+ struct symbol *s = allocate_symbol (mdebugread_objfile);
- memset (s, 0, sizeof (*s));
- SYMBOL_SET_LANGUAGE (s, psymtab_language);
+ SYMBOL_SET_LANGUAGE (s, psymtab_language,
+ &mdebugread_objfile->objfile_obstack);
SYMBOL_SET_NAMES (s, name, strlen (name), 1, mdebugread_objfile);
return s;
}
_initialize_mdebugread (void)
{
basic_type_data = register_objfile_data ();
+
+ mdebug_register_index
+ = register_symbol_register_impl (LOC_REGISTER, &mdebug_register_funcs);
+ mdebug_regparm_index
+ = register_symbol_register_impl (LOC_REGPARM_ADDR, &mdebug_register_funcs);
}