OpenE2K/binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
939a343342
binutils-gdb/gdb/symfile.h
Fred Fish 80d68b1d49 * coffread.c, mipsread.c, xcoffread.c, coffread.c, dbxread.c, 
elfread.c (coff_symfile_finish):  Add function, prototype, and
	add to the xxxx_sym_fns struct for each file type.  Also reformat
	the xxxx_sym_fns vector to a standard format and add comments.
	* coffread.c, mipsread.c, xcoffread.c, coffread.c, dbxread.c,
	elfread.c (xxx_symfile_new_init, xxx_symfile_init, xxx_symfile_read):
	Pass pointer to struct objfile rather than pointer to sym_fns.
	Change references inside each function accordingly.  Allocate any
	symbol file specific info in the per-objfile memory region.
	* dbxread.c (free_and_init_header_files):  Break function into
	free_header_files(), called from dbx_symfile_finish(), and
	init_header_files(), called from dbx_new_init().
	* dbxread.c (dbx_new_init):  Move deallocation things to new
	dbx_symfile_finish function.
	* elfread.c (elf_new_init):  Call buildsym_new_init().
	* objfiles.c (free_objfile): Call the appropriate symfile_finish()
	routine for the objfile before deallocating other stuff.
	* sparc-tdep.c (get_longjmp_target):  Cast target_read_memory arg.
	* symfile.h:  Move struct sym_fns to before struct objfile def.
	Add sym_finish function pointer and change prototypes of other
	function pointers to reflect passing struct objfile pointer rather
	than struct sym_fns pointer.
	* symfile.c:  Remove now obsolete symtab_fns pointer.
	* symfile.c (symfile_init):  Renamed to find_sym_fns, and now only
	locates the correct sym_fns struct for the given objfile.
	* symfile.c (syms_from_objfile, symbol_file_add):  Restructured
	for better support of mapped symbol tables.
	* symfile.c (symbol_file_command):  Remove obsolete code using
	symfile_fns.
	* symfile.h:  Remove duplicate declarations for symfile_objfile,
	entry_point, and object_files.
	* target.c (target_info):  Compare symfile_objfile to NULL.
	* xcoffread.c (aixcoff_new_init):  Move deallocation stuff to
	aixcoff_symfile_finish().
1992-03-19 21:57:15 +00:00

397 lines
13 KiB
C
Raw Blame History

/* Definitions for reading symbol files into GDB.
Copyright (C) 1990, 1991, 1992 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#if !defined (SYMFILE_H)
#define SYMFILE_H
/* This file requires that you first include "bfd.h". */
struct psymbol_allocation_list {
struct partial_symbol *list;
struct partial_symbol *next;
int size;
};
/* Structure to keep track of symbol reading functions for various
object file types. */
struct sym_fns {
/* is the name, or name prefix, of the BFD "target type" that this
set of functions handles. E.g. "a.out" or "sunOs" or "coff" or "elf". */
char *sym_name;
/* counts how many bytes of sym_name should be checked against the
BFD target type of the file being read. If an exact match is
desired, specify the number of characters in sym_name plus 1 for the
NUL. If a prefix match is desired, specify the number of characters in
sym_name. */
int sym_namelen;
/* Initializes anything that is global to the entire symbol table. It is
called during symbol_file_add, when we begin debugging an entirely new
program. */
void (*sym_new_init) PARAMS ((struct objfile *));
/* Reads any initial information from a symbol file, and initializes the
struct sym_fns SF in preparation for sym_read(). It is called every
time we read a symbol file for any reason. */
void (*sym_init) PARAMS ((struct objfile *));
/* sym_read (objfile, addr, mainline)
Reads a symbol file into a psymtab (or possibly a symtab).
OBJFILE is the objfile struct for the file we are reading. ADDR
is the offset between the file's specified start address and
its true address in memory. MAINLINE is 1 if this is the
main symbol table being read, and 0 if a secondary
symbol file (e.g. shared library or dynamically loaded file)
is being read. */
void (*sym_read) PARAMS ((struct objfile *, CORE_ADDR, int));
/* Called when we are finished with an objfile. Should do all cleanup
that is specific to the object file format for the particular objfile. */
void (*sym_finish) PARAMS ((struct objfile *));
/* Finds the next struct sym_fns. They are allocated and initialized
in whatever module implements the functions pointed to; an
initializer calls add_symtab_fns to add them to the global chain. */
struct sym_fns *next;
};
/* Master structure for keeping track of each input file from which
gdb reads symbols. One of these is allocated for each such file we
access, e.g. the exec_file, symbol_file, and any shared library object
files. */
struct objfile
{
/* All struct objfile's are chained together by their next pointers.
The global variable "object_files" points to the first link in this
chain. */
struct objfile *next;
/* The object file's name. Malloc'd; free it if you free this struct. */
char *name;
/* Some flag bits for this objfile. */
unsigned short flags;
/* Each objfile points to a linked list of symtabs derived from this file,
one symtab structure for each compilation unit (source file). Each link
in the symtab list contains a backpointer to this objfile. */
struct symtab *symtabs;
/* Each objfile points to a linked list of partial symtabs derived from
this file, one partial symtab structure for each compilation unit
(source file). */
struct partial_symtab *psymtabs;
/* List of freed partial symtabs, available for re-use */
struct partial_symtab *free_psymtabs;
/* The object file's BFD. Can be null, in which case bfd_open (name) and
put the result here. */
bfd *obfd;
/* The modification timestamp of the object file, as of the last time
we read its symbols. */
long mtime;
/* Obstacks to hold objects that should be freed when we load a new symbol
table from this object file. */
struct obstack psymbol_obstack; /* Partial symbols */
struct obstack symbol_obstack; /* Full symbols */
struct obstack type_obstack; /* Types */
/* Vectors of all partial symbols read in from file. The actual data
is stored in the psymbol_obstack. */
struct psymbol_allocation_list global_psymbols;
struct psymbol_allocation_list static_psymbols;
/* Each file contains a pointer to an array of minimal symbols for all
global symbols that are defined within the file. The array is terminated
by a "null symbol", one that has a NULL pointer for the name and a zero
value for the address. This makes it easy to walk through the array
when passed a pointer to somewhere in the middle of it. There is also
a count of the number of symbols, which does include the terminating
null symbol. The array itself, as well as all the data that it points
to, should be allocated on the symbol_obstack for this file. */
struct minimal_symbol *msymbols;
int minimal_symbol_count;
/* For object file formats which don't specify fundamental types, gdb
can create such types. For now, it maintains a vector of pointers
to these internally created fundamental types on a per objfile basis,
however it really should ultimately keep them on a per-compilation-unit
basis, to account for linkage-units that consist of a number of
compilation units that may have different fundamental types, such as
linking C modules with ADA modules, or linking C modules that are
compiled with 32-bit ints with C modules that are compiled with 64-bit
ints (not inherently evil with a smarter linker). */
struct type **fundamental_types;
/* The mmalloc() malloc-descriptor for this objfile if we are using
the memory mapped malloc() package to manage storage for this objfile's
data. NULL if we are not. */
PTR md;
/* Structure which keeps track of functions that manipulate objfile's
of the same type as this objfile. I.E. the function to read partial
symbols for example. Note that this structure is in statically
allocated memory, and is shared by all objfiles that use the
object module reader of this type. */
struct sym_fns *sf;
/* Hook for information which is shared by sym_init and sym_read for
this objfile. It is typically a pointer to malloc'd memory. */
PTR sym_private;
};
/* Defines for the objfile flag word. */
/* Gdb can arrange to allocate storage for all objects related to a
particular objfile in a designated section of it's address space,
managed at a low level by mmap() and using a special version of
malloc that handles malloc/free/realloc on top of the mmap() interface.
This allows the "internal gdb state" for a particular objfile to be
dumped to a gdb state file and subsequently reloaded at a later time. */
#define OBJF_MAPPED (1 << 0) /* Objfile data is mmap'd */
extern void
extend_psymbol_list PARAMS ((struct psymbol_allocation_list *,
struct objfile *));
/* Add any kind of symbol to a psymbol_allocation_list. */
#define ADD_PSYMBOL_VT_TO_LIST(NAME,NAMELENGTH,NAMESPACE,CLASS,LIST,VALUE,VT) \
do { \
register struct partial_symbol *psym; \
if ((LIST).next >= (LIST).list + (LIST).size) \
extend_psymbol_list (&(LIST),objfile); \
psym = (LIST).next++; \
\
SYMBOL_NAME (psym) = (char *) obstack_alloc (&objfile->psymbol_obstack, \
(NAMELENGTH) + 1); \
memcpy (SYMBOL_NAME (psym), (NAME), (NAMELENGTH)); \
SYMBOL_NAME (psym)[(NAMELENGTH)] = '\0'; \
SYMBOL_NAMESPACE (psym) = (NAMESPACE); \
SYMBOL_CLASS (psym) = (CLASS); \
VT (psym) = (VALUE); \
} while (0);
#ifdef DEBUG
/* Since one arg is a struct, we have to pass in a ptr and deref it (sigh) */
#define ADD_PSYMBOL_TO_LIST(name, namelength, namespace, class, list, value) \
add_psymbol_to_list (name, namelength, namespace, class, &list, value)
#define ADD_PSYMBOL_ADDR_TO_LIST(name, namelength, namespace, class, list, value) \
add_psymbol_addr_to_list (name, namelength, namespace, class, &list, value)
#else /* !DEBUG */
/* Add a symbol with an integer value to a psymtab. */
#define ADD_PSYMBOL_TO_LIST(name, namelength, namespace, class, list, value) \
ADD_PSYMBOL_VT_TO_LIST (name, namelength, namespace, class, list, value, SYMBOL_VALUE)
/* Add a symbol with a CORE_ADDR value to a psymtab. */
#define ADD_PSYMBOL_ADDR_TO_LIST(name, namelength, namespace, class, list, value)\
ADD_PSYMBOL_VT_TO_LIST (name, namelength, namespace, class, list, value, SYMBOL_VALUE_ADDRESS)
#endif /* DEBUG */
/* Functions */
extern void
sort_pst_symbols PARAMS ((struct partial_symtab *));
extern struct symtab *
allocate_symtab PARAMS ((char *, struct objfile *));
extern struct objfile *
allocate_objfile PARAMS ((bfd *, int));
extern void
free_objfile PARAMS ((struct objfile *));
extern void
free_all_objfiles PARAMS ((void));
extern int
free_named_symtabs PARAMS ((char *));
extern void
fill_in_vptr_fieldno PARAMS ((struct type *));
extern void
add_symtab_fns PARAMS ((struct sym_fns *));
extern void
syms_from_objfile PARAMS ((struct objfile *, CORE_ADDR, int, int));
extern struct partial_symtab *
start_psymtab_common PARAMS ((struct objfile *, CORE_ADDR, char *, CORE_ADDR,
struct partial_symbol *,
struct partial_symbol *));
/* Sorting your symbols for fast lookup or alphabetical printing. */
extern void
sort_block_syms PARAMS ((struct block *));
extern void
sort_symtab_syms PARAMS ((struct symtab *));
extern void
sort_all_symtab_syms PARAMS ((void));
/* Make a copy of the string at PTR with SIZE characters in the symbol obstack
(and add a null character at the end in the copy).
Returns the address of the copy. */
extern char *
obsavestring PARAMS ((char *, int, struct obstack *));
/* Concatenate strings S1, S2 and S3; return the new string.
Space is found in the symbol_obstack. */
extern char *
obconcat PARAMS ((struct obstack *obstackp, const char *, const char *,
const char *));
/* Variables */
/* The object file that the main symbol table was loaded from (e.g. the
argument to the "symbol-file" or "file" command). */
extern struct objfile *symfile_objfile;
/* Where execution starts in symfile */
extern CORE_ADDR entry_point;
/* Root of object file struct chain. */
extern struct objfile *object_files;
/* Traverse all object files. ALL_OBJFILES_SAFE works even if you delete
the objfile during the traversal. */
#define ALL_OBJFILES(obj) \
for (obj = object_files; 0 != obj; obj = obj->next)
#define ALL_OBJFILES_SAFE(obj,nxt) \
for (obj = object_files; obj? (nxt=obj->next, 1): 0; obj = nxt)
/* Support for complaining about things in the symbol file that aren't
catastrophic.
Each such thing gets a counter. The first time we have the problem,
during a symbol read, we report it. At the end of symbol reading,
if verbose, we report how many of each problem we had. */
struct complaint {
char *message;
unsigned counter;
struct complaint *next;
};
/* Root of the chain of complaints that have at some point been issued.
This is used to reset the counters, and/or report the total counts. */
extern struct complaint complaint_root[1];
/* Functions that handle complaints. (in symfile.c) */
extern void
complain PARAMS ((struct complaint *, char *));
extern void
clear_complaints PARAMS ((int sym_reading, int noisy));
/* From symfile.c */
extern struct partial_symtab *
allocate_psymtab PARAMS ((char *, struct objfile *));
/* From minsyms.c */
extern PTR
iterate_over_msymbols PARAMS ((PTR (*func) (struct objfile *,
struct minimal_symbol *,
PTR arg1, PTR arg2, PTR arg3),
PTR arg1, PTR arg2, PTR arg3));
/* From objfiles.c */
extern PTR
iterate_over_objfiles PARAMS ((PTR (*func) (struct objfile *,
PTR arg1, PTR arg2, PTR arg3),
PTR arg1, PTR arg2, PTR arg3));
extern PTR
iterate_over_symtabs PARAMS ((PTR (*func) (struct objfile *, struct symtab *,
PTR arg1, PTR arg2, PTR arg3),
PTR arg1, PTR arg2, PTR arg3));
extern PTR
iterate_over_psymtabs PARAMS ((PTR (*func) (struct objfile *,
struct partial_symtab *,
PTR arg1, PTR arg2, PTR arg3),
PTR arg1, PTR arg2, PTR arg3));
/* From dwarfread.c */
extern void
dwarf_build_psymtabs PARAMS ((int, char *, CORE_ADDR, int, unsigned int,
unsigned int, unsigned int, unsigned int,
struct objfile *));
#endif /* !defined(SYMFILE_H) */
Reference in New Issue View Git Blame Copy Permalink