#include "symtab.h"
#include "gdbtypes.h"
#include "breakpoint.h"
+
#include "bfd.h"
-#include "symfile.h"
-#include "objfiles.h"
-#include "buildsym.h"
-#include "complaints.h"
#include <obstack.h>
#include <string.h>
+#include <time.h> /* For time_t in libbfd.h. */
+#include <sys/types.h> /* For time_t, if not in time.h. */
#include "libbfd.h" /* FIXME secret internal data from BFD */
#include "coff/internal.h" /* Internal format of COFF symbols in BFD */
#include "libcoff.h" /* FIXME secret internal data from BFD */
+#include "symfile.h"
+#include "objfiles.h"
+#include "buildsym.h"
+#include "gdb-stabs.h"
+#include "stabsread.h"
+#include "complaints.h"
+
+struct coff_symfile_info {
+ file_ptr min_lineno_offset; /* Where in file lowest line#s are */
+ file_ptr max_lineno_offset; /* 1+last byte of line#s in file */
+
+ asection *stabsect; /* Section pointer for .stab section */
+ asection *stabstrsect; /* Section pointer for .stab section */
+ asection *stabindexsect; /* Section pointer for .stab.index section */
+ char *stabstrdata;
+};
+
/* Translate an external name string into a user-visible name. */
#define EXTERNAL_NAME(string, abfd) \
(string[0] == bfd_get_symbol_leading_char(abfd)? string+1: string)
static CORE_ADDR cur_src_start_addr;
static CORE_ADDR cur_src_end_addr;
-/* Core address of the end of the first object file. */
-static CORE_ADDR first_object_file_end;
-
/* The addresses of the symbol table stream and number of symbols
of the object file we are reading (as copied into core). */
-static FILE *nlist_stream_global;
+static GDB_FILE *nlist_stream_global;
static int nlist_nsyms_global;
/* Vector of line number information. */
static int
init_lineno PARAMS ((int, long, int));
-static char *
-getfilename PARAMS ((union internal_auxent *));
-
static char *
getsymname PARAMS ((struct internal_syment *));
static void
coff_symfile_finish PARAMS ((struct objfile *));
-static void
-record_minimal_symbol PARAMS ((char *, CORE_ADDR, enum minimal_symbol_type));
+static void record_minimal_symbol
+ PARAMS ((char *, CORE_ADDR, enum minimal_symbol_type, struct objfile *));
static void
coff_end_symtab PARAMS ((struct objfile *));
coff_lookup_type PARAMS ((int));
\f
+static void
+coff_locate_sections PARAMS ((bfd *, asection *, PTR));
+
+/* We are called once per section from coff_symfile_read. We
+ need to examine each section we are passed, check to see
+ if it is something we are interested in processing, and
+ if so, stash away some access information for the section.
+
+ FIXME: The section names should not be hardwired strings (what
+ should they be? I don't think most object file formats have enough
+ section flags to specify what kind of debug section it is
+ -kingdon). */
+
+static void
+coff_locate_sections (ignore_abfd, sectp, csip)
+ bfd *ignore_abfd;
+ asection *sectp;
+ PTR csip;
+{
+ register struct coff_symfile_info *csi;
+
+ csi = (struct coff_symfile_info *) csip;
+ if (STREQ (sectp->name, ".stab"))
+ {
+ csi->stabsect = sectp;
+ }
+ else if (STREQ (sectp->name, ".stabstr"))
+ {
+ csi->stabstrsect = sectp;
+ }
+ else if (STREQ (sectp->name, ".stab.index"))
+ {
+ csi->stabindexsect = sectp;
+ }
+}
+
/* Look up a coff type-number index. Return the address of the slot
where the type for that index is stored.
The type-number is in INDEX.
return type;
}
\f
-/* Manage the vector of line numbers. */
+/* Record a line number entry for line LINE at address PC.
+ FIXME: Use record_line instead. */
static void
coff_record_line (line, pc)
last_source_start_addr = cur_src_start_addr;
+ /* For no good reason, this file stores the number of entries in a
+ separate variable instead of in line_vector->nitems. Fix it. */
+ if (line_vector)
+ line_vector->nitems = line_vector_index;
+
/* For COFF, we only have one subfile, so we can just look at
subfiles and not worry about there being other elements in the
chain. We fill in various fields now because we didn't know them
}
\f
static void
-record_minimal_symbol (name, address, type)
+record_minimal_symbol (name, address, type, objfile)
char *name;
CORE_ADDR address;
enum minimal_symbol_type type;
+ struct objfile *objfile;
{
/* We don't want TDESC entry points in the minimal symbol table */
if (name[0] == '@') return;
- prim_record_minimal_symbol (savestring (name, strlen (name)), address, type);
+ prim_record_minimal_symbol (savestring (name, strlen (name)), address, type,
+ objfile);
}
\f
/* coff_symfile_init ()
The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
-struct coff_symfile_info {
- file_ptr min_lineno_offset; /* Where in file lowest line#s are */
- file_ptr max_lineno_offset; /* 1+last byte of line#s in file */
-};
-
static int text_bfd_scnum;
static void
asection *section;
bfd *abfd = objfile->obfd;
+ /* Allocate struct to keep track of stab reading. */
+ objfile->sym_stab_info = (PTR)
+ xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info));
+
+ memset ((PTR) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
+
/* Allocate struct to keep track of the symfile */
objfile -> sym_private = xmmalloc (objfile -> md,
sizeof (struct coff_symfile_info));
+ memset (objfile->sym_private, 0, sizeof (struct coff_symfile_info));
+
init_entry_point_info (objfile);
/* Save the section number for the text section */
- section = bfd_get_section_by_name(abfd,".text");
+ section = bfd_get_section_by_name (abfd, ".text");
if (section)
text_bfd_scnum = section->index;
else
- text_bfd_scnum = -1;
+ text_bfd_scnum = -1;
}
/* This function is called for every section; it finds the outer limits
int mainline;
{
struct coff_symfile_info *info;
+ struct dbx_symfile_info *dbxinfo;
bfd *abfd = objfile->obfd;
coff_data_type *cdata = coff_data (abfd);
char *name = bfd_get_filename (abfd);
int symtab_offset;
int stringtab_offset;
struct cleanup *back_to;
+ int stabsize, stabstrsize;
info = (struct coff_symfile_info *) objfile -> sym_private;
+ dbxinfo = (struct dbx_symfile_info *) objfile->sym_stab_info;
symfile_bfd = abfd; /* Kludge for swap routines */
/* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
- desc = fileno ((FILE *)(abfd->iostream)); /* File descriptor */
+ desc = fileno ((GDB_FILE *)(abfd->iostream)); /* File descriptor */
num_symbols = bfd_get_symcount (abfd); /* How many syms */
symtab_offset = cdata->sym_filepos; /* Symbol table file offset */
stringtab_offset = symtab_offset + /* String table file offset */
/* Read the line number table, all at once. */
info->min_lineno_offset = 0;
info->max_lineno_offset = 0;
- bfd_map_over_sections (abfd, find_linenos, (PTR)info);
+ bfd_map_over_sections (abfd, find_linenos, (PTR) info);
make_cleanup (free_linetab, 0);
val = init_lineno (desc, info->min_lineno_offset,
/* Sort symbols alphabetically within each block. */
- sort_all_symtab_syms ();
+ {
+ struct symtab *s;
+ for (s = objfile -> symtabs; s != NULL; s = s -> next)
+ {
+ sort_symtab_syms (s);
+ }
+ }
/* Install any minimal symbols that have been collected as the current
minimal symbols for this objfile. */
install_minimal_symbols (objfile);
+ bfd_map_over_sections (abfd, coff_locate_sections, (PTR) info);
+
+ if (info->stabsect)
+ {
+ /* FIXME: dubious. Why can't we use something normal like
+ bfd_get_section_contents? */
+ fseek ((GDB_FILE *) abfd->iostream, abfd->where, 0);
+
+ stabsize = bfd_section_size (abfd, info->stabsect);
+ stabstrsize = bfd_section_size (abfd, info->stabstrsect);
+
+ coffstab_build_psymtabs (objfile,
+ section_offsets,
+ mainline,
+ info->stabsect->filepos, stabsize,
+ info->stabstrsect->filepos, stabstrsize);
+ }
+
do_cleanups (back_to);
}
coff_new_init (ignore)
struct objfile *ignore;
{
- /* Nothin' to do */
}
/* Perform any local cleanups required when we are done with a particular
int nsyms;
struct objfile *objfile;
{
- FILE *stream;
+ GDB_FILE *stream;
register struct context_stack *new;
struct coff_symbol coff_symbol;
register struct coff_symbol *cs = &coff_symbol;
/* A .file is open. */
int in_source_file = 0;
- int num_object_files = 0;
int next_file_symnum = -1;
/* Name of the current file. */
coff_end_symtab (objfile);
coff_start_symtab ();
- complete_symtab ("_globals_", 0, first_object_file_end);
+ complete_symtab ("_globals_", 0, 0);
/* done with all files, everything from here on out is globals */
}
if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF)
{
/* Record all functions -- external and static -- in minsyms. */
- record_minimal_symbol (cs->c_name, cs->c_value, mst_text);
+ record_minimal_symbol (cs->c_name, cs->c_value, mst_text, objfile);
fcn_line_ptr = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr;
fcn_start_addr = cs->c_value;
* or symnum of first global after last .file.
*/
next_file_symnum = cs->c_value;
- filestring = getfilename (&main_aux);
+ if (cs->c_naux > 0)
+ filestring = coff_getfilename (&main_aux);
+ else
+ filestring = "";
+
/*
* Complete symbol table for last object file
* containing debugging information.
if (STREQ (cs->c_name, ".text")) {
/* FIXME: don't wire in ".text" as section name
or symbol name! */
- if (++num_object_files == 1) {
- /* last address of startup file */
- first_object_file_end = cs->c_value +
- main_aux.x_scn.x_scnlen;
- }
/* Check for in_source_file deals with case of
a file with debugging symbols
followed by a later file with no symbols. */
But why are absolute syms recorded as functions, anyway? */
if (cs->c_secnum <= text_bfd_scnum+1) {/* text or abs */
record_minimal_symbol (cs->c_name, cs->c_value,
- mst_text);
+ mst_text, objfile);
break;
} else {
record_minimal_symbol (cs->c_name, cs->c_value,
- mst_data);
+ mst_data, objfile);
break;
}
}
new = pop_context ();
if (depth-- != new->depth)
{
- complain (&eb_complaint, (char *)symnum);
+ complain (&eb_complaint, symnum);
break;
}
if (local_symbols && context_stack_depth > 0)
only the last component of the name. Result is in static storage and
is only good for temporary use. */
-static char *
-getfilename (aux_entry)
+char *
+coff_getfilename (aux_entry)
union internal_auxent *aux_entry;
{
static char buffer[BUFSIZ];
return type;
}
-/* Fake up support for relocating symbol addresses. FIXME. */
-
-struct section_offsets coff_symfile_faker = {0};
-
struct section_offsets *
coff_symfile_offsets (objfile, addr)
struct objfile *objfile;
CORE_ADDR addr;
{
- return &coff_symfile_faker;
+ struct section_offsets *section_offsets;
+ int i;
+
+ objfile->num_sections = SECT_OFF_MAX;
+ section_offsets = (struct section_offsets *)
+ obstack_alloc (&objfile -> psymbol_obstack,
+ sizeof (struct section_offsets)
+ + sizeof (section_offsets->offsets) * (SECT_OFF_MAX-1));
+
+ for (i = 0; i < SECT_OFF_MAX; i++)
+ ANOFFSET (section_offsets, i) = addr;
+
+ return section_offsets;
}
/* Register our ability to parse symbols for coff BFD files */
static struct sym_fns coff_sym_fns =
{
- "coff", /* sym_name: name or name prefix of BFD target type */
- 4, /* sym_namelen: number of significant sym_name chars */
+ bfd_target_coff_flavour,
coff_new_init, /* sym_new_init: init anything gbl to entire symtab */
coff_symfile_init, /* sym_init: read initial info, setup for sym_read() */
coff_symfile_read, /* sym_read: read a symbol file into symtab */
projects / deliverable / binutils-gdb.git / blobdiff