From 318bf84ffe5bc5472cefe0c1a838f132f9ac4ff9 Mon Sep 17 00:00:00 2001 From: Fred Fish Date: Sun, 15 Mar 1992 01:09:14 +0000 Subject: Globs of changes. See the ChangeLog for details. Most related to using the new mmalloc package. --- gdb/symfile.h | 317 ++++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 252 insertions(+), 65 deletions(-) (limited to 'gdb/symfile.h') diff --git a/gdb/symfile.h b/gdb/symfile.h index 67226b9..c0fdf4f 100644 --- a/gdb/symfile.h +++ b/gdb/symfile.h @@ -1,5 +1,5 @@ /* Definitions for reading symbol files into GDB. - Copyright (C) 1990, 1991 Free Software Foundation, Inc. + Copyright (C) 1990, 1991, 1992 Free Software Foundation, Inc. This file is part of GDB. @@ -17,52 +17,133 @@ 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; +}; + +/* 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. */ -/* Structure for keeping track of object files. +struct objfile +{ - One of these is allocated for each object file we access, e.g. the - exec_file, symbol_file, and any shared library object files. */ + /* 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 { - /* All struct objfile's are chained together by their next pointers. */ struct objfile *next; - /* Each objfile points to a chain of struct symtabs derived from this - object file. They are chained by their objfile_chain pointers, and - each one points back to this struct objfile. */ + /* 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; - /* Ditto for psymtabs. */ + /* 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; - /* The object file's name. Malloc'd; free it if you free this struct. */ - char *name; + /* 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. */ + + void *md; + }; +/* 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 */ + /* Structure to keep track of symbol reading functions for various object file types. */ struct sym_fns { - /* sym_name - is the name, or name prefix, of the BFD "target type" that this + /* 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; - /* sym_namelen - counts how many bytes of sym_name should be checked against the + /* 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 @@ -70,19 +151,18 @@ struct sym_fns { int sym_namelen; - /* sym_new_init - initializes anything that is global to the entire + /* 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) (); + void (*sym_new_init) PARAMS ((void)); /* sym_init (sf) 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) (); + void (*sym_init) PARAMS ((struct sym_fns *)); /* sym_read (sf, addr, mainline) reads a symbol file into a psymtab (or possibly a symtab). @@ -93,86 +173,133 @@ struct sym_fns { symbol file (e.g. shared library or dynamically loaded file) is being read. */ - void (*sym_read) (); + void (*sym_read) PARAMS ((struct sym_fns *, CORE_ADDR, int)); - /* sym_bfd - is the accessor for the symbol file being read. */ + /* is the accessor for the symbol file being read. */ - bfd *sym_bfd; + bfd *sym_bfd; - /* sym_private - is where information can be shared among sym_init and sym_read. + /* is where information can be shared among sym_init and sym_read. It is typically a pointer to malloc'd memory. */ char *sym_private; /* Should be void * */ - /* next - finds the next struct sym_fns. They are allocated and initialized + /* is the "struct objfile" for the object file being read. */ + + struct objfile *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; - /* objfile - is the "struct objfile" for the object file being read. */ - struct objfile *objfile; }; -extern void extend_psymbol_list(); +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)\ +#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)); \ + extend_psymbol_list (&(LIST),objfile); \ psym = (LIST).next++; \ \ - SYMBOL_NAME (psym) = (char *) obstack_alloc (psymbol_obstack, \ + SYMBOL_NAME (psym) = (char *) obstack_alloc (&objfile->psymbol_obstack, \ (NAMELENGTH) + 1); \ - strncpy (SYMBOL_NAME (psym), (NAME), (NAMELENGTH)); \ + 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 struct symtab *allocate_symtab (); -extern struct objfile *allocate_objfile (); -extern void free_objfile (); -extern int free_named_symtabs (); -extern void fill_in_vptr_fieldno (); -extern void add_symtab_fns (); -extern void syms_from_objfile (); +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 *, char *, int)); + +extern void +free_objfile PARAMS ((struct objfile *)); + +extern void +free_all_objfiles PARAMS ((void)); + +extern int +free_named_symtabs PARAMS ((char *)); -/* Functions for dealing with the misc "function" vector, really a misc - address<->symbol mapping vector for things we don't have debug symbols - for. */ +extern void +fill_in_vptr_fieldno PARAMS ((struct type *)); -extern void init_misc_bunches (); -extern void prim_record_misc_function (); -extern void discard_misc_bunches (); -extern void condense_misc_bunches (); +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 (); -extern void sort_symtab_syms (); -extern void sort_all_symtab_syms (); -extern void sort_block_syms (); +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 (); +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 (); +extern char * +obconcat PARAMS ((struct obstack *obstackp, const char *, const char *, + const char *)); /* Variables */ @@ -183,18 +310,20 @@ extern struct objfile *symfile_objfile; /* Where execution starts in symfile */ -CORE_ADDR entry_point; +extern CORE_ADDR entry_point; /* Root of object file struct chain. */ -struct objfile *object_files; +extern struct objfile *object_files; -/* Vectors of all partial symbols read in from file. */ +/* Traverse all object files. ALL_OBJFILES_SAFE works even if you delete + the objfile during the traversal. */ -extern struct psymbol_allocation_list { - struct partial_symbol *list, *next; - int size; -} global_psymbols, static_psymbols; +#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. @@ -214,7 +343,65 @@ struct complaint { extern struct complaint complaint_root[1]; +/* Externally visible variables defined in symfile.c */ + +/* 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; + /* Functions that handle complaints. (in symfile.c) */ -void complain(); -void clear_complaints(); +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) */ -- cgit v1.1