/* Read coff symbol tables and convert to internal format, for GDB.
- Copyright 1987, 88, 89, 90, 91, 92, 93, 94, 96, 97, 1998
+ Copyright 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
+ 1997, 1998, 1999, 2000, 2001
Free Software Foundation, Inc.
Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
#include "stabsread.h"
#include "complaints.h"
#include "target.h"
+#include "gdb_assert.h"
extern void _initialize_coffread (void);
#define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))
-/* Convert from an sdb register number to an internal gdb register number.
- This should be defined in tm.h, if REGISTER_NAMES is not set up
- to map one to one onto the sdb register numbers. */
-
-#ifndef SDB_REG_TO_REGNUM
-#define SDB_REG_TO_REGNUM(value) (value)
-#endif
-
/* Core address of start and end of text of current source file.
This comes from a ".text" symbol where x_nlinno > 0. */
-kingdon). */
static void
-coff_locate_sections (abfd, sectp, csip)
- bfd *abfd;
- asection *sectp;
- PTR csip;
+coff_locate_sections (bfd *abfd, asection *sectp, PTR csip)
{
register struct coff_symfile_info *csi;
const char *name;
/* This will be run after coffstab_build_psymtabs is called
in coff_symfile_read, at which point we no longer need
the information. */
- make_cleanup (free, n);
+ make_cleanup (xfree, n);
}
}
}
asection **resultp;
};
-static void find_targ_sec (bfd *, asection *, void *);
+static void find_targ_sec (bfd *, asection *, PTR);
static void
-find_targ_sec (abfd, sect, obj)
- bfd *abfd;
- asection *sect;
- PTR obj;
+find_targ_sec (bfd *abfd, asection *sect, PTR obj)
{
struct find_targ_sec_arg *args = (struct find_targ_sec_arg *) obj;
if (sect->target_index == args->targ_index)
/* Return the section number (SECT_OFF_*) that CS points to. */
static int
-cs_to_section (cs, objfile)
- struct coff_symbol *cs;
- struct objfile *objfile;
+cs_to_section (struct coff_symbol *cs, struct objfile *objfile)
{
asection *sect = NULL;
struct find_targ_sec_arg args;
else if (bfd_get_section_flags (abfd, sect) & SEC_LOAD)
off = SECT_OFF_DATA (objfile);
else
- off = SECT_OFF_BSS (objfile);
+ /* Just return the bfd section index. */
+ off = sect->index;
}
return off;
}
static CORE_ADDR cs_section_address (struct coff_symbol *, bfd *);
static CORE_ADDR
-cs_section_address (cs, abfd)
- struct coff_symbol *cs;
- bfd *abfd;
+cs_section_address (struct coff_symbol *cs, bfd *abfd)
{
asection *sect = NULL;
struct find_targ_sec_arg args;
or for associating a new type with the index. */
static struct type **
-coff_lookup_type (index)
- register int index;
+coff_lookup_type (register int index)
{
if (index >= type_vector_length)
{
This can create an empty (zeroed) type object. */
static struct type *
-coff_alloc_type (index)
- int index;
+coff_alloc_type (int index)
{
register struct type **type_addr = coff_lookup_type (index);
register struct type *type = *type_addr;
it indicates the start of data for one original source file. */
static void
-coff_start_symtab (name)
- char *name;
+coff_start_symtab (char *name)
{
start_symtab (
/* We fill in the filename later. start_symtab puts
text address for the file, and SIZE is the number of bytes of text. */
static void
-complete_symtab (name, start_addr, size)
- char *name;
- CORE_ADDR start_addr;
- unsigned int size;
+complete_symtab (char *name, CORE_ADDR start_addr, unsigned int size)
{
if (last_source_file != NULL)
- free (last_source_file);
+ xfree (last_source_file);
last_source_file = savestring (name, strlen (name));
current_source_start_addr = start_addr;
current_source_end_addr = start_addr + size;
struct symtab for that file and put it in the list of all such. */
static void
-coff_end_symtab (objfile)
- struct objfile *objfile;
+coff_end_symtab (struct objfile *objfile)
{
struct symtab *symtab;
last_source_start_addr = current_source_start_addr;
- symtab = end_symtab (current_source_end_addr, objfile, 0);
+ symtab = end_symtab (current_source_end_addr, objfile, SECT_OFF_TEXT (objfile));
if (symtab != NULL)
free_named_symtabs (symtab->filename);
}
\f
static void
-record_minimal_symbol (name, address, type, objfile)
- char *name;
- CORE_ADDR address;
- enum minimal_symbol_type type;
- struct objfile *objfile;
+record_minimal_symbol (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] == '@')
The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */
static void
-coff_symfile_init (objfile)
- struct objfile *objfile;
+coff_symfile_init (struct objfile *objfile)
{
/* Allocate struct to keep track of stab reading. */
objfile->sym_stab_info = (struct dbx_symfile_info *)
/* ARGSUSED */
static void
-find_linenos (abfd, asect, vpinfo)
- bfd *abfd;
- sec_ptr asect;
- PTR vpinfo;
+find_linenos (bfd *abfd, sec_ptr asect, PTR vpinfo)
{
struct coff_symfile_info *info;
int size, count;
/* ARGSUSED */
static void
-coff_symfile_read (objfile, mainline)
- struct objfile *objfile;
- int mainline;
+coff_symfile_read (struct objfile *objfile, int mainline)
{
struct coff_symfile_info *info;
struct dbx_symfile_info *dbxinfo;
info->stabsects,
info->stabstrsect->filepos, stabstrsize);
}
+ if (dwarf2_has_info (abfd))
+ {
+ /* DWARF2 sections. */
+ dwarf2_build_psymtabs (objfile, mainline);
+ }
do_cleanups (back_to);
}
static void
-coff_new_init (ignore)
- struct objfile *ignore;
+coff_new_init (struct objfile *ignore)
{
}
objfile struct from the global list of known objfiles. */
static void
-coff_symfile_finish (objfile)
- struct objfile *objfile;
+coff_symfile_finish (struct objfile *objfile)
{
if (objfile->sym_private != NULL)
{
- mfree (objfile->md, objfile->sym_private);
+ xmfree (objfile->md, objfile->sym_private);
}
/* Let stabs reader clean up */
We read them one at a time using read_one_sym (). */
static void
-coff_symtab_read (symtab_offset, nsyms, objfile)
- long symtab_offset;
- unsigned int nsyms;
- struct objfile *objfile;
+coff_symtab_read (long symtab_offset, unsigned int nsyms,
+ struct objfile *objfile)
{
register struct context_stack *new;
struct coff_symbol coff_symbol;
char *filestring = "";
int depth = 0;
int fcn_first_line = 0;
- CORE_ADDR fcn_first_line_addr;
+ CORE_ADDR fcn_first_line_addr = 0;
int fcn_last_line = 0;
int fcn_start_addr = 0;
long fcn_line_ptr = 0;
memset (opaque_type_chain, 0, sizeof opaque_type_chain);
if (type_vector) /* Get rid of previous one */
- free ((PTR) type_vector);
+ xfree (type_vector);
type_vector_length = 160;
type_vector = (struct type **)
xmalloc (type_vector_length * sizeof (struct type *));
SMASH_TEXT_ADDRESS (tmpaddr);
#endif
}
- else
- if (sec == SECT_OFF_DATA (objfile))
- {
+ else if (sec == SECT_OFF_DATA (objfile))
+ {
ms_type =
cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
mst_data : mst_file_data;
- }
- else
- if (sec == SECT_OFF_BSS (objfile))
- {
+ }
+ else if (sec == SECT_OFF_BSS (objfile))
+ {
ms_type =
cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
mst_data : mst_file_data;
- }
- else
- ms_type = mst_unknown;
+ }
+ else
+ ms_type = mst_unknown;
}
if (cs->c_name[0] != '@' /* Skip tdesc symbols */ )
{
struct minimal_symbol *msym;
+ /* FIXME: cagney/2001-02-01: The nasty (int) -> (long)
+ -> (void*) cast is to ensure that that the value of
+ cs->c_sclass can be correctly stored in a void
+ pointer in MSYMBOL_INFO. Better solutions
+ welcome. */
+ gdb_assert (sizeof (void *) >= sizeof (cs->c_sclass));
msym = prim_record_minimal_symbol_and_info
- (cs->c_name, tmpaddr, ms_type, (char *) cs->c_sclass, sec,
- NULL, objfile);
+ (cs->c_name, tmpaddr, ms_type, (void *) (long) cs->c_sclass,
+ sec, NULL, objfile);
#ifdef COFF_MAKE_MSYMBOL_SPECIAL
if (msym)
COFF_MAKE_MSYMBOL_SPECIAL (cs->c_sclass, msym);
}
else if (STREQ (cs->c_name, ".ef"))
{
+ if (!within_function)
+ error ("Bad coff function information\n");
/* the value of .ef is the address of epilogue code;
not useful for gdb. */
/* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
in internal_auxent form, and skip any other auxents. */
static void
-read_one_sym (cs, sym, aux)
- register struct coff_symbol *cs;
- register struct internal_syment *sym;
- register union internal_auxent *aux;
+read_one_sym (register struct coff_symbol *cs,
+ register struct internal_syment *sym,
+ register union internal_auxent *aux)
{
int i;
cs->c_symnum = symnum;
- bfd_read (temp_sym, local_symesz, 1, nlist_bfd_global);
+ bfd_bread (temp_sym, local_symesz, nlist_bfd_global);
bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *) sym);
cs->c_naux = sym->n_numaux & 0xff;
if (cs->c_naux >= 1)
{
- bfd_read (temp_aux, local_auxesz, 1, nlist_bfd_global);
+ bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
bfd_coff_swap_aux_in (symfile_bfd, temp_aux, sym->n_type, sym->n_sclass,
0, cs->c_naux, (char *) aux);
/* If more than one aux entry, read past it (only the first aux
is important). */
for (i = 1; i < cs->c_naux; i++)
- bfd_read (temp_aux, local_auxesz, 1, nlist_bfd_global);
+ bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
}
cs->c_name = getsymname (sym);
cs->c_value = sym->n_value;
static char *stringtab = NULL;
static int
-init_stringtab (abfd, offset)
- bfd *abfd;
- long offset;
+init_stringtab (bfd *abfd, long offset)
{
long length;
int val;
if (bfd_seek (abfd, offset, 0) < 0)
return -1;
- val = bfd_read ((char *) lengthbuf, sizeof lengthbuf, 1, abfd);
+ val = bfd_bread ((char *) lengthbuf, sizeof lengthbuf, abfd);
length = bfd_h_get_32 (symfile_bfd, lengthbuf);
/* If no string table is needed, then the file may end immediately
if (length == sizeof length) /* Empty table -- just the count */
return 0;
- val = bfd_read (stringtab + sizeof lengthbuf, length - sizeof lengthbuf, 1, abfd);
+ val = bfd_bread (stringtab + sizeof lengthbuf, length - sizeof lengthbuf,
+ abfd);
if (val != length - sizeof lengthbuf || stringtab[length - 1] != '\0')
return -1;
}
static void
-free_stringtab ()
+free_stringtab (void)
{
if (stringtab)
- free (stringtab);
+ xfree (stringtab);
stringtab = NULL;
}
}
static char *
-getsymname (symbol_entry)
- struct internal_syment *symbol_entry;
+getsymname (struct internal_syment *symbol_entry)
{
static char buffer[SYMNMLEN + 1];
char *result;
is only good for temporary use. */
static char *
-coff_getfilename (aux_entry)
- union internal_auxent *aux_entry;
+coff_getfilename (union internal_auxent *aux_entry)
{
static char buffer[BUFSIZ];
register char *temp;
them into GDB's data structures. */
static int
-init_lineno (abfd, offset, size)
- bfd *abfd;
- long offset;
- int size;
+init_lineno (bfd *abfd, long offset, int size)
{
int val;
/* Allocate the desired table, plus a sentinel */
linetab = (char *) xmalloc (size + local_linesz);
- val = bfd_read (linetab, size, 1, abfd);
+ val = bfd_bread (linetab, size, abfd);
if (val != size)
return -1;
}
static void
-free_linetab ()
+free_linetab (void)
{
if (linetab)
- free (linetab);
+ xfree (linetab);
linetab = NULL;
}
#endif
static void
-enter_linenos (file_offset, first_line, last_line, objfile)
- long file_offset;
- register int first_line;
- register int last_line;
- struct objfile *objfile;
+enter_linenos (long file_offset, register int first_line,
+ register int last_line, struct objfile *objfile)
{
register char *rawptr;
struct internal_lineno lptr;
}
\f
static void
-patch_type (type, real_type)
- struct type *type;
- struct type *real_type;
+patch_type (struct type *type, struct type *real_type)
{
register struct type *target = TYPE_TARGET_TYPE (type);
register struct type *real_target = TYPE_TARGET_TYPE (real_type);
if (TYPE_NAME (real_target))
{
if (TYPE_NAME (target))
- free (TYPE_NAME (target));
+ xfree (TYPE_NAME (target));
TYPE_NAME (target) = concat (TYPE_NAME (real_target), NULL);
}
}
so that they can be used to print out opaque data structures properly. */
static void
-patch_opaque_types (s)
- struct symtab *s;
+patch_opaque_types (struct symtab *s)
{
register struct block *b;
register int i;
}
\f
static struct symbol *
-process_coff_symbol (cs, aux, objfile)
- register struct coff_symbol *cs;
- register union internal_auxent *aux;
- struct objfile *objfile;
+process_coff_symbol (register struct coff_symbol *cs,
+ register union internal_auxent *aux,
+ struct objfile *objfile)
{
register struct symbol *sym
= (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
/* Decode a coff type specifier; return the type that is meant. */
static struct type *
-decode_type (cs, c_type, aux)
- register struct coff_symbol *cs;
- unsigned int c_type;
- register union internal_auxent *aux;
+decode_type (register struct coff_symbol *cs, unsigned int c_type,
+ register union internal_auxent *aux)
{
register struct type *type = 0;
unsigned int new_c_type;
return the type that the function returns. */
static struct type *
-decode_function_type (cs, c_type, aux)
- register struct coff_symbol *cs;
- unsigned int c_type;
- register union internal_auxent *aux;
+decode_function_type (register struct coff_symbol *cs, unsigned int c_type,
+ register union internal_auxent *aux)
{
if (aux->x_sym.x_tagndx.l == 0)
cs->c_naux = 0; /* auxent refers to function, not base type */
/* basic C types */
static struct type *
-decode_base_type (cs, c_type, aux)
- register struct coff_symbol *cs;
- unsigned int c_type;
- register union internal_auxent *aux;
+decode_base_type (register struct coff_symbol *cs, unsigned int c_type,
+ register union internal_auxent *aux)
{
struct type *type;
object describing the type. */
static struct type *
-coff_read_struct_type (index, length, lastsym)
- int index;
- int length;
- int lastsym;
+coff_read_struct_type (int index, int length, int lastsym)
{
struct nextfield
{
/* ARGSUSED */
static struct type *
-coff_read_enum_type (index, length, lastsym)
- int index;
- int length;
- int lastsym;
+coff_read_enum_type (int index, int length, int lastsym)
{
register struct symbol *sym;
register struct type *type;
};
void
-_initialize_coffread ()
+_initialize_coffread (void)
{
add_symtab_fns (&coff_sym_fns);
}
projects / deliverable / binutils-gdb.git / blobdiff