#include <obstack.h>
#include <sys/param.h>
+#ifndef NO_SYS_FILE
#include <sys/file.h>
+#endif
#include <sys/stat.h>
#include <ctype.h>
#include "symtab.h"
int ldsymlen;
};
-extern void qsort ();
-extern double atof ();
-
-/* Forward declarations */
-
-static void read_dbx_symtab ();
-static void init_psymbol_list ();
-extern void process_one_symbol ();
-void start_subfile ();
-int hashname ();
-static struct pending *copy_pending ();
-static struct symtab *read_ofile_symtab ();
-static void dbx_psymtab_to_symtab ();
-
/* Macro to determine which symbols to ignore when reading the first symbol
of a file. Some machines override this definition. */
#ifndef IGNORE_SYMBOL
static struct header_file_location *bincl_list, *next_bincl;
static int bincls_allocated;
+/* Local function prototypes */
+
+static void
+free_and_init_header_files PARAMS ((void));
+
+static struct pending *
+copy_pending PARAMS ((struct pending *, int, struct pending *));
+
+static struct symtab *
+read_ofile_symtab PARAMS ((struct objfile *, char *, unsigned int, int, int,
+ CORE_ADDR, int, int));
+
+static void
+dbx_psymtab_to_symtab PARAMS ((struct partial_symtab *));
+
+static void
+psymtab_to_symtab_1 PARAMS ((struct partial_symtab *, char *, int, int));
+
+static void
+read_dbx_symtab PARAMS ((CORE_ADDR, struct objfile *, char *, long, int,
+ CORE_ADDR, int));
+
+static void
+free_bincl_list PARAMS ((struct objfile *));
+
+static struct partial_symtab *
+find_corresponding_bincl_psymtab PARAMS ((char *, int));
+
+static void
+add_bincl_to_list PARAMS ((struct partial_symtab *, char *, int));
+
+static void
+init_bincl_list PARAMS ((int, struct objfile *));
+
+static void
+init_psymbol_list PARAMS ((int, struct objfile *));
+
+static char *
+dbx_next_symbol_text PARAMS ((void));
+
+static void
+fill_symbuf PARAMS ((bfd *));
+
+static void
+dbx_symfile_init PARAMS ((struct sym_fns *));
+
+static void
+dbx_new_init PARAMS ((void));
+
+static void
+dbx_symfile_read PARAMS ((struct sym_fns *, CORE_ADDR, int));
+
+static void
+record_minimal_symbol PARAMS ((char *, CORE_ADDR, int, struct objfile *));
+
+static void
+add_new_header_file PARAMS ((char *, int));
+
+static void
+add_old_header_file PARAMS ((char *, int));
+
+static void
+add_this_object_header_file PARAMS ((int));
+
/* Free up old header file tables, and allocate new ones.
We're reading a new symbol file now. */
-void
+static void
free_and_init_header_files ()
{
register int i;
this_object_header_files = (int *) xmalloc (10 * sizeof (int));
}
-/* Called at the start of each object file's symbols.
- Clear out the mapping of header file numbers to header files. */
-
-void
-new_object_header_files ()
-{
- /* Leave FILENUM of 0 free for builtin types and this file's types. */
- n_this_object_header_files = 1;
- header_file_prev_index = -1;
-}
-
/* Add header file number I for this object file
at the next successive FILENUM. */
{
n_allocated_this_object_header_files *= 2;
this_object_header_files
- = (int *) xrealloc (this_object_header_files,
+ = (int *) xrealloc ((char *) this_object_header_files,
n_allocated_this_object_header_files * sizeof (int));
}
{
n_allocated_header_files *= 2;
header_files = (struct header_file *)
- xrealloc (header_files,
- (n_allocated_header_files
- * sizeof (struct header_file)));
+ xrealloc ((char *) header_files,
+ (n_allocated_header_files * sizeof (struct header_file)));
}
/* Create an entry for this header file. */
#endif
\f
static void
-record_misc_function (name, address, type)
+record_minimal_symbol (name, address, type, objfile)
char *name;
CORE_ADDR address;
int type;
+ struct objfile *objfile;
{
- enum misc_function_type misc_type;
+ enum minimal_symbol_type ms_type;
switch (type &~ N_EXT) {
- case N_TEXT: misc_type = mf_text; break;
- case N_DATA: misc_type = mf_data; break;
- case N_BSS: misc_type = mf_bss; break;
- case N_ABS: misc_type = mf_abs; break;
+ case N_TEXT: ms_type = mst_text; break;
+ case N_DATA: ms_type = mst_data; break;
+ case N_BSS: ms_type = mst_bss; break;
+ case N_ABS: ms_type = mst_abs; break;
#ifdef N_SETV
- case N_SETV: misc_type = mf_data; break;
+ case N_SETV: ms_type = mst_data; break;
#endif
- default: misc_type = mf_unknown; break;
+ default: ms_type = mst_unknown; break;
}
- prim_record_misc_function (obsavestring (name, strlen (name)),
- address, misc_type);
+ prim_record_minimal_symbol (obsavestring (name, strlen (name), &objfile -> symbol_obstack),
+ address, ms_type);
}
\f
/* Scan and build partial symbols for a symbol file.
}
/* If we are reinitializing, or if we have never loaded syms yet, init */
- if (mainline || global_psymbols.size == 0 || static_psymbols.size == 0)
- init_psymbol_list (info->symcount);
+ if (mainline || sf->objfile->global_psymbols.size == 0 || sf->objfile->static_psymbols.size == 0)
+ init_psymbol_list (info->symcount, sf->objfile);
/* FIXME POKING INSIDE BFD DATA STRUCTURES */
symbol_size = obj_symbol_entry_size (sym_bfd);
pending_blocks = 0;
make_cleanup (really_free_pendings, 0);
- init_misc_bunches ();
- make_cleanup (discard_misc_bunches, 0);
+ init_minimal_symbol_collection ();
+ make_cleanup (discard_minimal_symbols, 0);
/* Now that the symbol table data of the executable file are all in core,
process them and define symbols accordingly. */
bfd_section_vma (sym_bfd, info->text_sect),
bfd_section_size (sym_bfd, info->text_sect));
- /* Go over the misc symbol bunches and install them in vector. */
+ /* Install any minimal symbols that have been collected as the current
+ minimal symbols for this objfile. */
- condense_misc_bunches (!mainline);
+ install_minimal_symbols (sf -> objfile);
/* Free up any memory we allocated for ourselves. */
if (!mainline) {
- free (info->stringtab); /* Stringtab is only saved for mainline */
+ (*sf->objfile->free) (info->stringtab); /* Stringtab is only saved for mainline */
}
- free (info);
- sf->sym_private = 0; /* Zap pointer to our (now gone) info struct */
+ (*sf->objfile->free) (info);
+ sf->sym_private = NULL; /* Zap pointer to our (now gone) info struct */
- if (!partial_symtab_list) {
+ if (!have_partial_symbols ()) {
wrap_here ("");
printf_filtered ("(no debugging symbols found)...");
wrap_here ("");
unsigned char size_temp[4];
/* Allocate struct to keep track of the symfile */
- sf->sym_private = xmalloc (sizeof (*info));
+ sf->sym_private = (*sf->objfile->xmalloc) (sizeof (*info));
info = (struct dbx_symfile_info *)sf->sym_private;
/* FIXME POKING INSIDE BFD DATA STRUCTURES */
if (info->stringtab_size >= 0)
{
- info->stringtab = (char *) xmalloc (info->stringtab_size);
+ /* Yes, this should be malloc, not xmalloc. We check its result. */
+ info->stringtab = (char *) (*sf->objfile->malloc) (info->stringtab_size);
/* Caller is responsible for freeing the string table. No cleanup. */
}
else
(a \ at the end of the text of a name)
call this function to get the continuation. */
-char *
+static char *
dbx_next_symbol_text ()
{
if (symbuf_idx == symbuf_end)
created by read_dbx_symtab and subsidiaries. */
static void
-init_psymbol_list (total_symbols)
+init_psymbol_list (total_symbols, objfile)
int total_symbols;
+ struct objfile *objfile;
{
/* Free any previously allocated psymbol lists. */
- if (global_psymbols.list)
- free (global_psymbols.list);
- if (static_psymbols.list)
- free (static_psymbols.list);
+ if (objfile -> global_psymbols.list)
+ (*objfile -> free) (objfile -> global_psymbols.list);
+ if (objfile -> static_psymbols.list)
+ (*objfile -> free) (objfile -> static_psymbols.list);
/* Current best guess is that there are approximately a twentieth
of the total symbols (in a debugging file) are global or static
oriented symbols */
- global_psymbols.size = total_symbols / 10;
- static_psymbols.size = total_symbols / 10;
- global_psymbols.next = global_psymbols.list = (struct partial_symbol *)
- xmalloc (global_psymbols.size * sizeof (struct partial_symbol));
- static_psymbols.next = static_psymbols.list = (struct partial_symbol *)
- xmalloc (static_psymbols.size * sizeof (struct partial_symbol));
+ objfile -> global_psymbols.size = total_symbols / 10;
+ objfile -> static_psymbols.size = total_symbols / 10;
+ objfile -> global_psymbols.next = objfile -> global_psymbols.list = (struct partial_symbol *)
+ (*objfile -> xmalloc) (objfile -> global_psymbols.size * sizeof (struct partial_symbol));
+ objfile -> static_psymbols.next = objfile -> static_psymbols.list = (struct partial_symbol *)
+ (*objfile -> xmalloc) (objfile -> static_psymbols.size * sizeof (struct partial_symbol));
}
/* Initialize the list of bincls to contain none and have some
allocated. */
static void
-init_bincl_list (number)
+init_bincl_list (number, objfile)
int number;
+ struct objfile *objfile;
{
bincls_allocated = number;
next_bincl = bincl_list = (struct header_file_location *)
- xmalloc (bincls_allocated * sizeof(struct header_file_location));
+ (*objfile -> xmalloc) (bincls_allocated * sizeof(struct header_file_location));
}
/* Add a bincl to the list. */
int offset = next_bincl - bincl_list;
bincls_allocated *= 2;
bincl_list = (struct header_file_location *)
- xrealloc ((char *)bincl_list,
+ (*pst->objfile->xrealloc) ((char *)bincl_list,
bincls_allocated * sizeof (struct header_file_location));
next_bincl = bincl_list + offset;
}
/* Free the storage allocated for the bincl list. */
static void
-free_bincl_list ()
+free_bincl_list (objfile)
+ struct objfile *objfile;
{
- free (bincl_list);
+ (*objfile -> free) (bincl_list);
bincls_allocated = 0;
}
old_chain = make_cleanup (free_objfile, objfile);
/* Init bincl list */
- init_bincl_list (20);
- make_cleanup (free_bincl_list, 0);
+ init_bincl_list (20, objfile);
+ make_cleanup (free_bincl_list, objfile);
last_source_file = 0;
rather than abort the symbol reading or flood the user with messages. */
#define SET_NAMESTRING()\
if (((unsigned)bufp->n_strx) >= stringtab_size) { \
- complain (&string_table_offset_complaint, symnum); \
+ complain (&string_table_offset_complaint, (char *) symnum); \
namestring = "foo"; \
} else \
namestring = bufp->n_strx + stringtab
dependency_list, dependencies_used);
}
- free_bincl_list ();
+ free_bincl_list (objfile);
discard_cleanups (old_chain);
}
struct partial_symbol *static_syms;
{
struct partial_symtab *result =
- (struct partial_symtab *) obstack_alloc (psymbol_obstack,
- sizeof (struct partial_symtab));
-
- result->addr = addr;
-
- result->filename =
- (char *) obstack_alloc (psymbol_obstack,
- strlen (filename) + 1);
- strcpy (result->filename, filename);
+ start_psymtab_common(objfile, addr,
+ filename, textlow, global_syms, static_syms);
- result->textlow = textlow;
- result->read_symtab_private = (char *) obstack_alloc (psymbol_obstack,
- sizeof (struct symloc));
- if (ldsymoff != -1)
- LDSYMOFF(result) = ldsymoff;
-
- result->readin = 0;
- result->symtab = 0;
+ result->read_symtab_private = (char *)
+ obstack_alloc (&objfile -> psymbol_obstack, sizeof (struct symloc));
+ LDSYMOFF(result) = ldsymoff;
result->read_symtab = dbx_psymtab_to_symtab;
- result->globals_offset = global_syms - global_psymbols.list;
- result->statics_offset = static_syms - static_psymbols.list;
-
- result->n_global_syms = 0;
- result->n_static_syms = 0;
-
- /* Chain it to the list owned by the current object file. */
- result->objfile = objfile;
- result->objfile_chain = objfile->psymtabs;
- objfile->psymtabs = result;
-
return result;
}
-static int
-compare_psymbols (s1, s2)
- register struct partial_symbol *s1, *s2;
-{
- register char
- *st1 = SYMBOL_NAME (s1),
- *st2 = SYMBOL_NAME (s2);
-
- if (st1[0] - st2[0])
- return st1[0] - st2[0];
- if (st1[1] - st2[1])
- return st1[1] - st2[1];
- return strcmp (st1 + 2, st2 + 2);
-}
-
/* Close off the current usage of a partial_symbol table entry. This
involves setting the correct number of includes (with a realloc),
setting the high text mark, setting the symbol length in the
Then the partial symtab is put on the global list.
*** List variables and peculiarities of same. ***
*/
+
void
end_psymtab (pst, include_list, num_includes, capping_symbol_offset,
capping_text, dependency_list, number_dependencies)
/* struct partial_symbol *capping_global, *capping_static;*/
{
int i;
+ struct objfile *objfile = pst -> objfile;
if (capping_symbol_offset != -1)
LDSYMLEN(pst) = capping_symbol_offset - LDSYMOFF(pst);
pst->texthigh = capping_text;
pst->n_global_syms =
- global_psymbols.next - (global_psymbols.list + pst->globals_offset);
+ objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset);
pst->n_static_syms =
- static_psymbols.next - (static_psymbols.list + pst->statics_offset);
+ objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset);
pst->number_of_dependencies = number_dependencies;
if (number_dependencies)
{
pst->dependencies = (struct partial_symtab **)
- obstack_alloc (psymbol_obstack,
+ obstack_alloc (&objfile->psymbol_obstack,
number_dependencies * sizeof (struct partial_symtab *));
memcpy (pst->dependencies, dependency_list,
number_dependencies * sizeof (struct partial_symtab *));
for (i = 0; i < num_includes; i++)
{
struct partial_symtab *subpst =
- (struct partial_symtab *)
- obstack_alloc (psymbol_obstack,
- sizeof (struct partial_symtab));
-
- subpst->filename =
- (char *) obstack_alloc (psymbol_obstack,
- strlen (include_list[i]) + 1);
- strcpy (subpst->filename, include_list[i]);
-
- /* Chain it to the list that this object file owns. */
- subpst->objfile = pst->objfile;
- subpst->objfile_chain = pst->objfile->psymtabs;
- pst->objfile->psymtabs = subpst;
+ allocate_psymtab (include_list[i], objfile);
subpst->addr = pst->addr;
- subpst->read_symtab_private = (char *) obstack_alloc (psymbol_obstack,
- sizeof (struct symloc));
+ subpst->read_symtab_private =
+ (char *) obstack_alloc (&objfile->psymbol_obstack,
+ sizeof (struct symloc));
LDSYMOFF(subpst) =
LDSYMLEN(subpst) =
subpst->textlow =
/* We could save slight bits of space by only making one of these,
shared by the entire set of include files. FIXME-someday. */
subpst->dependencies = (struct partial_symtab **)
- obstack_alloc (psymbol_obstack,
+ obstack_alloc (&objfile->psymbol_obstack,
sizeof (struct partial_symtab *));
subpst->dependencies[0] = pst;
subpst->number_of_dependencies = 1;
subpst->readin = 0;
subpst->symtab = 0;
subpst->read_symtab = dbx_psymtab_to_symtab;
-
- subpst->next = partial_symtab_list;
- partial_symtab_list = subpst;
}
- /* Sort the global list; don't sort the static list */
- qsort (global_psymbols.list + pst->globals_offset, pst->n_global_syms,
- sizeof (struct partial_symbol), compare_psymbols);
+ sort_pst_symbols (pst);
/* If there is already a psymtab or symtab for a file of this name, remove it.
(If there is a symtab, more drastic things also happen.)
/* Throw away this psymtab, it's empty. We can't deallocate it, since
it is on the obstack, but we can forget to chain it on the list. */
;
- } else {
- /* Put the psymtab on the psymtab list */
- pst->next = partial_symtab_list;
- partial_symtab_list = pst;
}
}
\f
#endif
{
#ifdef BROKEN_LARGE_ALLOCA
- stringtab = (char *) xmalloc (stsize);
- make_cleanup (free, stringtab);
+ stringtab = (char *) (*pst->objfile->xmalloc) (stsize);
+ make_cleanup (pst->objfile->free, stringtab);
#else
stringtab = (char *) alloca (stsize);
#endif
/* 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 ();
+ scan_file_globals (pst->objfile);
/* Finish up the debug error message. */
if (info_verbose)
unsigned max_symnum;
register bfd *abfd;
+ current_objfile = objfile;
subfile_stack = 0;
stringtab_global = stringtab;
}
}
- return end_symtab (text_offset + text_size, 0, 0, objfile);
-}
-\f
-int
-hashname (name)
- char *name;
-{
- register char *p = name;
- register int total = p[0];
- register int c;
-
- c = p[1];
- total += c << 2;
- if (c)
- {
- c = p[2];
- total += c << 4;
- if (c)
- total += p[3] << 6;
- }
-
- /* Ensure result is positive. */
- if (total < 0) total += (1000 << 6);
- return total % HASHSIZE;
+ current_objfile = NULL;
+ return (end_symtab (text_offset + text_size, 0, 0, objfile));
}
\f
/* This handles a single symbol from the symbol-file, building symbols
if (!colon_pos++
|| (*colon_pos != 'f' && *colon_pos != 'F'))
{
- define_symbol (valu, name, desc, type);
+ define_symbol (valu, name, desc, type, our_objfile);
break;
}
new = pop_context ();
/* Make a block for the local symbols within. */
finish_block (new->name, &local_symbols, new->old_blocks,
- new->start_addr, valu);
+ new->start_addr, valu, our_objfile);
}
/* Stack must be empty now. */
if (context_stack_depth != 0)
- complain (&lbrac_unmatched_complaint, symnum);
+ complain (&lbrac_unmatched_complaint, (char *) symnum);
new = push_context (0, valu);
- new->name = define_symbol (valu, name, desc, type);
+ new->name = define_symbol (valu, name, desc, type, our_objfile);
break;
case N_CATCH:
/* Record the address at which this catch takes place. */
- define_symbol (valu+offset, name, desc, type);
+ define_symbol (valu+offset, name, desc, type, our_objfile);
break;
case N_LBRAC:
new = pop_context();
if (desc != new->depth)
- complain (&lbrac_mismatch_complaint, symnum);
+ complain (&lbrac_mismatch_complaint, (char *) symnum);
/* Some compilers put the variable decls inside of an
LBRAC/RBRAC block. This macro should be nonzero if this
}
/* Make a block for the local symbols within. */
finish_block (0, &local_symbols, new->old_blocks,
- new->start_addr, valu);
+ new->start_addr, valu, our_objfile);
}
else
{
&& current_subfile->name[strlen(current_subfile->name)-1] == '/')
{
current_subfile->dirname = current_subfile->name;
- current_subfile->name = obsavestring (name, strlen (name));
+ current_subfile->name =
+ obsavestring (name, strlen (name),
+ &our_objfile -> symbol_obstack);
break;
}
- (void)end_symtab (valu, 0, 0);
+ (void) end_symtab (valu, 0, 0, our_objfile);
}
start_symtab (name, NULL, valu);
break;
{
int i;
struct symbol *sym =
- (struct symbol *) xmalloc (sizeof (struct symbol));
+ (struct symbol *) (*our_objfile -> xmalloc) (sizeof (struct symbol));
bzero (sym, sizeof *sym);
SYMBOL_NAME (sym) = savestring (name, strlen (name));
SYMBOL_CLASS (sym) = LOC_BLOCK;
case N_PSYM: /* Parameter variable */
case N_LENG: /* Length of preceding symbol type */
if (name)
- define_symbol (valu, name, desc, type);
+ define_symbol (valu, name, desc, type, our_objfile);
break;
/* The following symbol types we don't know how to process. Handle
case N_NBLCS:
complain (&unknown_symtype_complaint, local_hex_string(type));
if (name)
- define_symbol (valu, name, desc, type);
+ define_symbol (valu, name, desc, type, our_objfile);
}
previous_stab_code = type;
block for later fixup. */
static struct pending *
copy_pending (beg, begi, end)
- struct pending *beg, *end;
+ struct pending *beg;
int begi;
+ struct pending *end;
{
struct pending *new = 0;
struct pending *next;
projects / deliverable / binutils-gdb.git / blobdiff