X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fsymtab.h;h=6d1b22e7e071eccaea2fbd7aa386d36e2c0d01fe;hb=e74acce48c1b4efc29fd1e9e84639b77383aa002;hp=f04407d8d9e3ae723276a2a5e522b17e210c36cf;hpb=5afa2040f45d3772e759c2e148ad8bf33115c80a;p=binutils-gdb.git diff --git a/gdb/symtab.h b/gdb/symtab.h index f04407d8d9e..6d1b22e7e07 100644 --- a/gdb/symtab.h +++ b/gdb/symtab.h @@ -1,5 +1,5 @@ /* Symbol table definitions for GDB. - Copyright (C) 1986, 1989, 1991, 1992 Free Software Foundation, Inc. + Copyright 1986, 1989, 1991, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc. This file is part of GDB. @@ -15,7 +15,7 @@ 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. */ +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #if !defined (SYMTAB_H) #define SYMTAB_H 1 @@ -25,9 +25,26 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "obstack.h" #define obstack_chunk_alloc xmalloc #define obstack_chunk_free free +#include "bcache.h" + +/* Don't do this; it means that if some .o's are compiled with GNU C + and some are not (easy to do accidentally the way we configure + things; also it is a pain to have to "make clean" every time you + want to switch compilers), then GDB dies a horrible death. */ +/* GNU C supports enums that are bitfields. Some compilers don't. */ +#if 0 && defined(__GNUC__) && !defined(BYTE_BITFIELD) +#define BYTE_BITFIELD :8; +#else +#define BYTE_BITFIELD /*nothing*/ +#endif /* Define a structure for the information that is common to all symbol types, - including minimal symbols, partial symbols, and full symbols. */ + including minimal symbols, partial symbols, and full symbols. In a + multilanguage environment, some language specific information may need to + be recorded along with each symbol. + + These fields are ordered to encourage good packing, since we frequently + have tens or hundreds of thousands of these. */ struct general_symbol_info { @@ -45,7 +62,10 @@ struct general_symbol_info union { - long value; + /* The fact that this is a long not a LONGEST mainly limits the + range of a LOC_CONST. Since LOC_CONST_BYTES exists, I'm not + sure that is a big deal. */ + long ivalue; struct block *block; @@ -59,56 +79,48 @@ struct general_symbol_info } value; - /* In a multilanguage environment, some language specific information may - need to be recorded along with each symbol. */ + /* Since one and only one language can apply, wrap the language specific + information inside a union. */ - struct language_dependent_info + union { + struct cplus_specific /* For C++ */ + { + char *demangled_name; + } cplus_specific; + struct chill_specific /* For Chill */ + { + char *demangled_name; + } chill_specific; + } language_specific; - /* Record the language that this information applies to. */ - - enum language language; - - /* Since one and only one language can apply, wrap the information inside - a union. */ + /* Record the source code language that applies to this symbol. + This is used to select one of the fields from the language specific + union above. */ - union lang_specific - { - /* For C++ */ - struct cplus_specific - { - char *demangled_name; - } cplus_specific; - /* For Chill */ - struct chill_specific - { - char *demangled_name; - } chill_specific; - } lang_u; - } lang_specific; + enum language language BYTE_BITFIELD; /* Which section is this symbol in? This is an index into section_offsets for this objfile. Negative means that the symbol - does not get relocated relative to a section. */ - /* Disclaimer: currently this is just used for xcoff, so don't expect - all symbol-reading code to set it correctly. */ - int section; + does not get relocated relative to a section. + Disclaimer: currently this is just used for xcoff, so don't + expect all symbol-reading code to set it correctly (the ELF code + also tries to set it correctly). */ + + short section; }; #define SYMBOL_NAME(symbol) (symbol)->ginfo.name -#define SYMBOL_VALUE(symbol) (symbol)->ginfo.value.value +#define SYMBOL_VALUE(symbol) (symbol)->ginfo.value.ivalue #define SYMBOL_VALUE_ADDRESS(symbol) (symbol)->ginfo.value.address #define SYMBOL_VALUE_BYTES(symbol) (symbol)->ginfo.value.bytes #define SYMBOL_BLOCK_VALUE(symbol) (symbol)->ginfo.value.block #define SYMBOL_VALUE_CHAIN(symbol) (symbol)->ginfo.value.chain -#define SYMBOL_LANGUAGE(symbol) (symbol)->ginfo.lang_specific.language +#define SYMBOL_LANGUAGE(symbol) (symbol)->ginfo.language #define SYMBOL_SECTION(symbol) (symbol)->ginfo.section #define SYMBOL_CPLUS_DEMANGLED_NAME(symbol) \ - (symbol)->ginfo.lang_specific.lang_u.cplus_specific.demangled_name - - -extern int demangle; /* We reference it, so go ahead and declare it. */ + (symbol)->ginfo.language_specific.cplus_specific.demangled_name /* Macro that initializes the language dependent portion of a symbol depending upon the language for the symbol. */ @@ -126,8 +138,8 @@ extern int demangle; /* We reference it, so go ahead and declare it. */ } \ else \ { \ - memset (&(symbol)->ginfo.lang_specific.lang_u, 0, \ - sizeof ((symbol)->ginfo.lang_specific.lang_u)); \ + memset (&(symbol)->ginfo.language_specific, 0, \ + sizeof ((symbol)->ginfo.language_specific)); \ } \ } while (0) @@ -195,7 +207,7 @@ extern int demangle; /* We reference it, so go ahead and declare it. */ : NULL)) #define SYMBOL_CHILL_DEMANGLED_NAME(symbol) \ - (symbol)->ginfo.lang_specific.lang_u.chill_specific.demangled_name + (symbol)->ginfo.language_specific.chill_specific.demangled_name /* Macro that returns the "natural source name" of a symbol. In C++ this is the "demangled" form of the name if demangle is on and the "mangled" form @@ -273,6 +285,11 @@ struct minimal_symbol char *info; +#ifdef SOFUN_ADDRESS_MAYBE_MISSING + /* Which source file is this symbol in? Only relevant for mst_file_*. */ + char *filename; +#endif + /* Classification types for this symbol. These should be taken as "advisory only", since if gdb can't easily figure out a classification it simply selects mst_unknown. It may also have to guess when it can't figure out @@ -287,8 +304,22 @@ struct minimal_symbol mst_text, /* Generally executable instructions */ mst_data, /* Generally initialized data */ mst_bss, /* Generally uninitialized data */ - mst_abs /* Generally absolute (nonrelocatable) */ - } type; + mst_abs, /* Generally absolute (nonrelocatable) */ + /* GDB uses mst_solib_trampoline for the start address of a shared + library trampoline entry. Breakpoints for shared library functions + are put there if the shared library is not yet loaded. + After the shared library is loaded, lookup_minimal_symbol will + prefer the minimal symbol from the shared library (usually + a mst_text symbol) over the mst_solib_trampoline symbol, and the + breakpoints will be moved to their true address in the shared + library via breakpoint_re_set. */ + mst_solib_trampoline, /* Shared library trampoline code */ + /* For the mst_file* types, the names are only guaranteed to be unique + within a given .o file. */ + mst_file_text, /* Static version of mst_text */ + mst_file_data, /* Static version of mst_data */ + mst_file_bss /* Static version of mst_bss */ + } type BYTE_BITFIELD; }; @@ -376,7 +407,8 @@ struct block int nsyms; - /* The symbols. */ + /* The symbols. If some of them are arguments, then they must be + in the order in which we would like to print them. */ struct symbol *sym[1]; }; @@ -389,17 +421,20 @@ struct block #define BLOCK_SUPERBLOCK(bl) (bl)->superblock #define BLOCK_GCC_COMPILED(bl) (bl)->gcc_compile_flag -/* Nonzero if symbols of block BL should be sorted alphabetically. */ +/* Nonzero if symbols of block BL should be sorted alphabetically. + Don't sort a block which corresponds to a function. If we did the + sorting would have to preserve the order of the symbols for the + arguments. */ -#define BLOCK_SHOULD_SORT(bl) ((bl)->nsyms >= 40) +#define BLOCK_SHOULD_SORT(bl) ((bl)->nsyms >= 40 && BLOCK_FUNCTION (bl) == NULL) /* Represent one symbol name; a variable, constant, function or typedef. */ /* Different name spaces for symbols. Looking up a symbol specifies a namespace and ignores symbol definitions in other name spaces. */ - -enum namespace + +typedef enum { /* UNDEF_NAMESPACE is used when a namespace has not been discovered or none of the following apply. This usually indicates an error either @@ -422,7 +457,7 @@ enum namespace currently it is not used and labels are not recorded at all. */ LABEL_NAMESPACE -}; +} namespace_enum; /* An address-class says where to find the value of a symbol. */ @@ -461,15 +496,16 @@ enum address_class For some symbol formats (stabs, for some compilers at least), the compiler generates two symbols, an argument and a register. In some cases we combine them to a single LOC_REGPARM in symbol - reading, but I'm not sure whether we do for all cases (I'm thinking - of when it's passed on the stack and then loaded into a register). */ + reading, but currently not for all cases (e.g. it's passed on the + stack and then loaded into a register). */ LOC_REGPARM, /* Value is in specified register. Just like LOC_REGPARM except the register holds the address of the argument instead of the argument itself. This is currently used for the passing of structs and unions - on sparc and hppa. */ + on sparc and hppa. It is also used for call by reference where the + address is in a register, at least by mipsread.c. */ LOC_REGPARM_ADDR, @@ -505,6 +541,37 @@ enum address_class LOC_LOCAL_ARG, + /* Value is at SYMBOL_VALUE offset from the current value of + register number SYMBOL_BASEREG. This exists mainly for the same + things that LOC_LOCAL and LOC_ARG do; but we need to do this + instead because on 88k DWARF gives us the offset from the + frame/stack pointer, rather than the offset from the "canonical + frame address" used by COFF, stabs, etc., and we don't know how + to convert between these until we start examining prologues. + + Note that LOC_BASEREG is much less general than a DWARF expression. + We don't need the generality (at least not yet), and storing a general + DWARF expression would presumably take up more space than the existing + scheme. */ + + LOC_BASEREG, + + /* Same as LOC_BASEREG but it is an argument. */ + + LOC_BASEREG_ARG, + + /* Value is at fixed address, but the address of the variable has + to be determined from the minimal symbol table whenever the + variable is referenced. + This happens if debugging information for a global symbol is + emitted and the corresponding minimal symbol is defined + in another object file or runtime common storage. + The linker might even remove the minimal symbol if the global + symbol is never referenced, in which case the symbol remains + unresolved. */ + + LOC_UNRESOLVED, + /* The variable does not actually exist in the program. The value is ignored. */ @@ -518,17 +585,17 @@ struct symbol struct general_symbol_info ginfo; - /* Name space code. */ + /* Data type of value */ - enum namespace namespace; + struct type *type; - /* Address class */ + /* Name space code. */ - enum address_class class; + namespace_enum namespace BYTE_BITFIELD; - /* Data type of value */ + /* Address class */ - struct type *type; + enum address_class aclass BYTE_BITFIELD; /* Line number of definition. FIXME: Should we really make the assumption that nobody will try to debug files longer than 64K lines? What about @@ -541,34 +608,17 @@ struct symbol union { - /* for OP_BASEREG in DWARF location specs */ - struct - { - short regno_valid; /* 0 == regno invalid; !0 == regno valid */ - short regno; /* base register number {0, 1, 2, ...} */ - } basereg; + /* Used by LOC_BASEREG and LOC_BASEREG_ARG. */ + short basereg; } aux_value; - }; #define SYMBOL_NAMESPACE(symbol) (symbol)->namespace -#define SYMBOL_CLASS(symbol) (symbol)->class +#define SYMBOL_CLASS(symbol) (symbol)->aclass #define SYMBOL_TYPE(symbol) (symbol)->type #define SYMBOL_LINE(symbol) (symbol)->line -#define SYMBOL_BASEREG(symbol) (symbol)->aux_value.basereg.regno - -/* This currently fails because some symbols are not being initialized - to zero on allocation, and no code is currently setting this value. - Basereg handling will probably change significantly in the next release. - FIXME -fnf */ - -#if 0 -#define SYMBOL_BASEREG_VALID(symbol) (symbol)->aux_value.basereg.regno_valid -#else -#define SYMBOL_BASEREG_VALID(symbol) 0 -#endif - +#define SYMBOL_BASEREG(symbol) (symbol)->aux_value.basereg /* A partial_symbol records the name, namespace, and address class of symbols whose types we have not parsed yet. For functions, it also @@ -586,16 +636,16 @@ struct partial_symbol /* Name space code. */ - enum namespace namespace; + namespace_enum namespace BYTE_BITFIELD; /* Address class (for info_symbols) */ - enum address_class class; + enum address_class aclass BYTE_BITFIELD; }; #define PSYMBOL_NAMESPACE(psymbol) (psymbol)->namespace -#define PSYMBOL_CLASS(psymbol) (psymbol)->class +#define PSYMBOL_CLASS(psymbol) (psymbol)->aclass /* Source-file information. This describes the relation between source files, @@ -618,9 +668,27 @@ struct linetable_entry CORE_ADDR pc; }; +/* The order of entries in the linetable is significant. They should + be sorted by increasing values of the pc field. If there is more than + one entry for a given pc, then I'm not sure what should happen (and + I not sure whether we currently handle it the best way). + + Example: a C for statement generally looks like this + + 10 0x100 - for the init/test part of a for stmt. + 20 0x200 + 30 0x300 + 10 0x400 - for the increment part of a for stmt. + + */ + struct linetable { int nitems; + + /* Actually NITEMS elements. If you don't like this use of the + `struct hack', you can shove it up your ANSI (seriously, if the + committee tells us how to do it, we can probably go along). */ struct linetable_entry item[1]; }; @@ -649,7 +717,14 @@ struct section_offsets #define ANOFFSET(secoff, whichone) (secoff->offsets[whichone]) -/* Each source file is represented by a struct symtab. +/* The maximum possible size of a section_offsets table. */ + +#define SIZEOF_SECTION_OFFSETS \ + (sizeof (struct section_offsets) \ + + sizeof (((struct section_offsets *) 0)->offsets) * (SECT_OFF_MAX-1)) + + +/* Each source file or header is represented by a struct symtab. These objects are chained through the `next' field. */ struct symtab @@ -659,17 +734,19 @@ struct symtab struct symtab *next; - /* List of all symbol scope blocks for this symtab. */ + /* List of all symbol scope blocks for this symtab. May be shared + between different symtabs (and normally is for all the symtabs + in a given compilation unit). */ struct blockvector *blockvector; /* Table mapping core addresses to line numbers for this file. - Can be NULL if none. */ + Can be NULL if none. Never shared between different symtabs. */ struct linetable *linetable; /* Section in objfile->section_offsets for the blockvector and - the linetable. */ + the linetable. Probably always SECT_OFF_TEXT. */ int block_line_section; @@ -691,7 +768,8 @@ struct symtab free_contents => do a tree walk and free each object. free_nothing => do nothing; some other symtab will free the data this one uses. - free_linetable => free just the linetable. */ + free_linetable => free just the linetable. FIXME: Is this redundant + with the primary field? */ enum free_code { @@ -708,7 +786,9 @@ struct symtab int nlines; - /* Array mapping line number to character position. */ + /* line_charpos[N] is the position of the (N-1)th line of the + source file. "position" means something we can lseek() to; it + is not guaranteed to be useful any other way. */ int *line_charpos; @@ -782,7 +862,11 @@ struct partial_symtab /* Array of pointers to all of the partial_symtab's which this one depends on. Since this array can only be set to previous or the current (?) psymtab, this dependency tree is guaranteed not - to have any loops. */ + to have any loops. "depends on" means that symbols must be read + for the dependencies before being read for this psymtab; this is + for type references in stabs, where if foo.c includes foo.h, declarations + in foo.h may use type numbers defined in foo.c. For other debugging + formats there may be no need to use dependencies. */ struct partial_symtab **dependencies; @@ -855,19 +939,24 @@ struct partial_symtab Note that this macro is g++ specific (FIXME). */ #define OPNAME_PREFIX_P(NAME) \ - ((NAME)[0] == 'o' && (NAME)[1] == 'p' && (NAME)[2] == CPLUS_MARKER) + ((NAME)[0] == 'o' && (NAME)[1] == 'p' && is_cplus_marker ((NAME)[2])) /* Macro that yields non-zero value iff NAME is the prefix for C++ vtbl - names. Note that this macro is g++ specific (FIXME). */ + names. Note that this macro is g++ specific (FIXME). + '_vt$' is the old cfront-style vtables; '_VT$' is the new + style, using thunks (where '$' is really CPLUS_MARKER). */ #define VTBL_PREFIX_P(NAME) \ - ((NAME)[3] == CPLUS_MARKER && !strncmp ((NAME), "_vt", 3)) + ((NAME)[0] == '_' \ + && (((NAME)[1] == 'V' && (NAME)[2] == 'T') \ + || ((NAME)[1] == 'v' && (NAME)[2] == 't')) \ + && is_cplus_marker ((NAME)[3])) /* Macro that yields non-zero value iff NAME is the prefix for C++ destructor names. Note that this macro is g++ specific (FIXME). */ #define DESTRUCTOR_PREFIX_P(NAME) \ - ((NAME)[0] == '_' && (NAME)[1] == CPLUS_MARKER && (NAME)[2] == '_') + ((NAME)[0] == '_' && is_cplus_marker ((NAME)[1]) && (NAME)[2] == '_') /* External variables and functions for the objects described above. */ @@ -884,16 +973,24 @@ extern int current_source_line; extern struct objfile *current_objfile; +/* True if we are nested inside psymtab_to_symtab. */ + +extern int currently_reading_symtab; + +/* From utils.c. */ +extern int demangle; +extern int asm_demangle; + extern struct symtab * lookup_symtab PARAMS ((char *)); extern struct symbol * lookup_symbol PARAMS ((const char *, const struct block *, - const enum namespace, int *, struct symtab **)); + const namespace_enum, int *, struct symtab **)); extern struct symbol * lookup_block_symbol PARAMS ((const struct block *, const char *, - const enum namespace)); + const namespace_enum)); extern struct type * lookup_struct PARAMS ((char *, struct block *)); @@ -910,8 +1007,8 @@ block_function PARAMS ((struct block *)); extern struct symbol * find_pc_function PARAMS ((CORE_ADDR)); -extern int -find_pc_partial_function PARAMS ((CORE_ADDR, char **, CORE_ADDR *)); +extern int find_pc_partial_function + PARAMS ((CORE_ADDR, char **, CORE_ADDR *, CORE_ADDR *)); extern void clear_pc_function_cache PARAMS ((void)); @@ -937,24 +1034,55 @@ contained_in PARAMS ((struct block *, struct block *)); extern void reread_symbols PARAMS ((void)); +/* Macro for name of symbol to indicate a file compiled with gcc. */ +#ifndef GCC_COMPILED_FLAG_SYMBOL +#define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled." +#endif + +/* Macro for name of symbol to indicate a file compiled with gcc2. */ +#ifndef GCC2_COMPILED_FLAG_SYMBOL +#define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled." +#endif + /* Functions for dealing with the minimal symbol table, really a misc address<->symbol mapping for things we don't have debug symbols for. */ -extern void -prim_record_minimal_symbol PARAMS ((const char *, CORE_ADDR, - enum minimal_symbol_type)); +extern void prim_record_minimal_symbol PARAMS ((const char *, CORE_ADDR, + enum minimal_symbol_type, + struct objfile *)); -extern void -prim_record_minimal_symbol_and_info PARAMS ((const char *, CORE_ADDR, - enum minimal_symbol_type, - char *info, int section)); +extern struct minimal_symbol *prim_record_minimal_symbol_and_info + PARAMS ((const char *, CORE_ADDR, + enum minimal_symbol_type, + char *info, int section, + struct objfile *)); + +#ifdef SOFUN_ADDRESS_MAYBE_MISSING +extern CORE_ADDR find_stab_function_addr PARAMS ((char *, + struct partial_symtab *, + struct objfile *)); +#endif extern struct minimal_symbol * -lookup_minimal_symbol PARAMS ((const char *, struct objfile *)); +lookup_minimal_symbol PARAMS ((const char *, const char *, struct objfile *)); + +extern struct minimal_symbol * +lookup_minimal_symbol_text PARAMS ((const char *, const char *, struct objfile *)); + +struct minimal_symbol * +lookup_minimal_symbol_solib_trampoline PARAMS ((const char *, + const char *, + struct objfile *)); extern struct minimal_symbol * lookup_minimal_symbol_by_pc PARAMS ((CORE_ADDR)); +extern struct minimal_symbol * +lookup_solib_trampoline_symbol_by_pc PARAMS ((CORE_ADDR)); + +extern CORE_ADDR +find_solib_trampoline_target PARAMS ((CORE_ADDR)); + extern void init_minimal_symbol_collection PARAMS ((void)); @@ -964,10 +1092,19 @@ discard_minimal_symbols PARAMS ((int)); extern void install_minimal_symbols PARAMS ((struct objfile *)); +/* Sort all the minimal symbols in OBJFILE. */ + +extern void msymbols_sort PARAMS ((struct objfile *objfile)); + struct symtab_and_line { struct symtab *symtab; + + /* Line number. Line numbers start at 1 and proceed through symtab->nlines. + 0 is never a valid line number; it is used to indicate that line number + information is not available. */ int line; + CORE_ADDR pc; CORE_ADDR end; }; @@ -984,13 +1121,21 @@ struct symtabs_and_lines extern struct symtab_and_line find_pc_line PARAMS ((CORE_ADDR, int)); +/* Given an address, return the nearest symbol at or below it in memory. + Optionally return the symtab it's from through 2nd arg, and the + address in inferior memory of the symbol through 3rd arg. */ + +extern struct symbol * +find_addr_symbol PARAMS ((CORE_ADDR, struct symtab **, CORE_ADDR *)); + /* Given a symtab and line number, return the pc there. */ extern CORE_ADDR find_line_pc PARAMS ((struct symtab *, int)); extern int -find_line_pc_range PARAMS ((struct symtab *, int, CORE_ADDR *, CORE_ADDR *)); +find_line_pc_range PARAMS ((struct symtab_and_line, + CORE_ADDR *, CORE_ADDR *)); extern void resolve_sal_pc PARAMS ((struct symtab_and_line *)); @@ -1005,7 +1150,7 @@ extern struct symtabs_and_lines decode_line_spec_1 PARAMS ((char *, int)); extern struct symtabs_and_lines -decode_line_1 PARAMS ((char **, int, struct symtab *, int)); +decode_line_1 PARAMS ((char **, int, struct symtab *, int, char ***)); /* Symmisc.c */ @@ -1023,6 +1168,9 @@ maintenance_print_msymbols PARAMS ((char *, int)); void maintenance_print_objfiles PARAMS ((char *, int)); +void +maintenance_check_symtabs PARAMS ((char *, int)); + #endif extern void @@ -1042,7 +1190,7 @@ symbol_file_add PARAMS ((char *, int, CORE_ADDR, int, int, int)); /* source.c */ extern int -identify_source_line PARAMS ((struct symtab *, int, int)); +identify_source_line PARAMS ((struct symtab *, int, int, CORE_ADDR)); extern void print_source_lines PARAMS ((struct symtab *, int, int, int)); @@ -1053,14 +1201,10 @@ forget_cached_source_info PARAMS ((void)); extern void select_source_symtab PARAMS ((struct symtab *)); -extern char ** -make_symbol_completion_list PARAMS ((char *)); +extern char **make_symbol_completion_list PARAMS ((char *, char *)); /* symtab.c */ -extern void -clear_symtab_users_once PARAMS ((void)); - extern struct partial_symtab * find_main_psymtab PARAMS ((void)); @@ -1071,7 +1215,15 @@ blockvector_for_pc PARAMS ((CORE_ADDR, int *)); /* symfile.c */ +extern void +clear_symtab_users PARAMS ((void)); + extern enum language deduce_language_from_filename PARAMS ((char *)); +/* symtab.c */ + +extern int +in_prologue PARAMS ((CORE_ADDR pc, CORE_ADDR func_start)); + #endif /* !defined(SYMTAB_H) */