X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fsymtab.h;h=6d1b22e7e071eccaea2fbd7aa386d36e2c0d01fe;hb=e74acce48c1b4efc29fd1e9e84639b77383aa002;hp=4b112585176ee9c59aa14d13cb5ba8a40da6869b;hpb=95330ec393a01d56445e21d549769ef3e4061e78;p=binutils-gdb.git diff --git a/gdb/symtab.h b/gdb/symtab.h index 4b112585176..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 { @@ -37,32 +54,23 @@ struct general_symbol_info char *name; - /* Constant value, or address if static, or register number, - or offset in arguments, or offset in stack frame. All of - these are in host byte order (though what they point to might - be in target byte order, e.g. LOC_CONST_BYTES). - - Note that the address of a function is SYMBOL_VALUE_ADDRESS (pst) - in a partial symbol table, but BLOCK_START (SYMBOL_BLOCK_VALUE (st)) - in a symbol table. */ + /* Value of the symbol. Which member of this union to use, and what + it means, depends on what kind of symbol this is and its + SYMBOL_CLASS. See comments there for more details. All of these + are in host byte order (though what they point to might be in + target byte order, e.g. LOC_CONST_BYTES). */ union { - /* for LOC_CONST, LOC_REGISTER, LOC_ARG, LOC_REF_ARG, LOC_REGPARM, - LOC_LOCAL */ - - long value; - - /* for LOC_BLOCK */ + /* 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; - /* for LOC_CONST_BYTES */ - char *bytes; - /* for LOC_STATIC, LOC_LABEL */ - CORE_ADDR address; /* for opaque typedef struct chain */ @@ -71,58 +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; - /* start-sanitize-chill */ - /* For Chill */ - struct chill_specific - { - char *demangled_name; - } chill_specific; - /* end-sanitize-chill */ - } 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. */ @@ -134,16 +132,14 @@ extern int demangle; /* We reference it, so go ahead and declare it. */ { \ SYMBOL_CPLUS_DEMANGLED_NAME (symbol) = NULL; \ } \ - /* start-sanitize-chill */ \ else if (SYMBOL_LANGUAGE (symbol) == language_chill) \ { \ SYMBOL_CHILL_DEMANGLED_NAME (symbol) = NULL; \ } \ - /* end-sanitize-chill */ \ 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) @@ -176,7 +172,6 @@ extern int demangle; /* We reference it, so go ahead and declare it. */ SYMBOL_CPLUS_DEMANGLED_NAME (symbol) = NULL; \ } \ } \ - /* start-sanitize-chill */ \ if (demangled == NULL \ && (SYMBOL_LANGUAGE (symbol) == language_chill \ || SYMBOL_LANGUAGE (symbol) == language_auto)) \ @@ -195,7 +190,6 @@ extern int demangle; /* We reference it, so go ahead and declare it. */ SYMBOL_CHILL_DEMANGLED_NAME (symbol) = NULL; \ } \ } \ - /* end-sanitize-chill */ \ if (SYMBOL_LANGUAGE (symbol) == language_auto) \ { \ SYMBOL_LANGUAGE (symbol) = language_unknown; \ @@ -205,20 +199,6 @@ extern int demangle; /* We reference it, so go ahead and declare it. */ /* Macro that returns the demangled name for a symbol based on the language for that symbol. If no demangled name exists, returns NULL. */ -#define SYMBOL_DEMANGLED_NAME(symbol) \ - (SYMBOL_LANGUAGE (symbol) == language_cplus \ - ? SYMBOL_CPLUS_DEMANGLED_NAME (symbol) \ - : NULL) - -/* start-sanitize-chill */ - -#define SYMBOL_CHILL_DEMANGLED_NAME(symbol) \ - (symbol)->ginfo.lang_specific.lang_u.chill_specific.demangled_name - -/* Redefine SYMBOL_DEMANGLED_NAME. This is simplier than trying to - devise a macro for which part of it can be cleanly sanitized away. */ - -#undef SYMBOL_DEMANGLED_NAME #define SYMBOL_DEMANGLED_NAME(symbol) \ (SYMBOL_LANGUAGE (symbol) == language_cplus \ ? SYMBOL_CPLUS_DEMANGLED_NAME (symbol) \ @@ -226,7 +206,8 @@ extern int demangle; /* We reference it, so go ahead and declare it. */ ? SYMBOL_CHILL_DEMANGLED_NAME (symbol) \ : NULL)) -/* end-sanitize-chill */ +#define SYMBOL_CHILL_DEMANGLED_NAME(symbol) \ + (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 @@ -286,7 +267,10 @@ extern int demangle; /* We reference it, so go ahead and declare it. */ struct minimal_symbol { - /* The general symbol info required for all types of symbols. */ + /* The general symbol info required for all types of symbols. + + The SYMBOL_VALUE_ADDRESS contains the address that this symbol + corresponds to. */ struct general_symbol_info ginfo; @@ -301,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 @@ -315,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; }; @@ -404,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]; }; @@ -417,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 @@ -450,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. */ @@ -468,35 +475,41 @@ enum address_class LOC_STATIC, - /* Value is in register */ + /* Value is in register. SYMBOL_VALUE is the register number. */ LOC_REGISTER, - /* Value is at spec'd offset in arglist */ + /* It's an argument; the value is at SYMBOL_VALUE offset in arglist. */ LOC_ARG, - /* Value address is at spec'd offset in arglist. Currently this is used - for C++ references (and presumably will be used for Pascal VAR - parameters), and is only dereferenced in certain contexts. */ + /* Value address is at SYMBOL_VALUE offset in arglist. */ LOC_REF_ARG, - /* Value is in specified register. Just like LOC_REGISTER except this is - an argument. Probably the cleaner way to handle this would be to - separate address_class (which would include separate ARG and LOCAL - to deal with FRAME_ARGS_ADDRESS versus FRAME_LOCALS_ADDRESS), and - an is_argument flag. + /* Value is in register number SYMBOL_VALUE. Just like LOC_REGISTER + except this is an argument. Probably the cleaner way to handle + this would be to separate address_class (which would include + separate ARG and LOCAL to deal with FRAME_ARGS_ADDRESS versus + FRAME_LOCALS_ADDRESS), and an is_argument flag. For some symbol formats (stabs, for some compilers at least), - gdb generates a LOC_ARG and a LOC_REGISTER rather than a LOC_REGPARM. - This is because that's what the compiler does, but perhaps it would - be better if the symbol-reading code detected this (is it possible?) - and generated a LOC_REGPARM. */ + 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 currently not for all cases (e.g. it's passed on the + stack and then loaded into a register). */ LOC_REGPARM, - /* Value is at spec'd offset in stack frame */ + /* 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. It is also used for call by reference where the + address is in a register, at least by mipsread.c. */ + + LOC_REGPARM_ADDR, + + /* Value is a local variable at SYMBOL_VALUE offset in stack frame. */ LOC_LOCAL, @@ -509,8 +522,9 @@ enum address_class LOC_LABEL, - /* Value is address SYMBOL_VALUE_BLOCK of a `struct block'. Function names - have this class. */ + /* In a symbol table, value is SYMBOL_BLOCK_VALUE of a `struct block'. + In a partial symbol table, SYMBOL_VALUE_ADDRESS is the start address + of the block. Function names have this class. */ LOC_BLOCK, @@ -519,16 +533,47 @@ enum address_class LOC_CONST_BYTES, - /* Value is arg at spec'd offset in stack frame. Differs from LOC_LOCAL in - that symbol is an argument; differs from LOC_ARG in that we find it - in the frame (FRAME_LOCALS_ADDRESS), not in the arglist - (FRAME_ARGS_ADDRESS). Added for i960, which passes args in regs then - copies to frame. */ + /* Value is arg at SYMBOL_VALUE offset in stack frame. Differs from + LOC_LOCAL in that symbol is an argument; differs from LOC_ARG in + that we find it in the frame (FRAME_LOCALS_ADDRESS), not in the + arglist (FRAME_ARGS_ADDRESS). Added for i960, which passes args + in regs then copies to frame. */ 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 SYMBOL_VALUE is ignored. */ + The value is ignored. */ LOC_OPTIMIZED_OUT }; @@ -540,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 @@ -563,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 @@ -608,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, @@ -640,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]; }; @@ -671,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 @@ -681,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; @@ -713,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 { @@ -730,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; @@ -804,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; @@ -877,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. */ @@ -906,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 *)); @@ -932,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)); @@ -959,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 *, const char *, struct objfile *)); extern struct minimal_symbol * -lookup_minimal_symbol PARAMS ((const char *, struct objfile *)); +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)); @@ -986,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; }; @@ -1006,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 *)); @@ -1027,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 */ @@ -1045,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 @@ -1064,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)); @@ -1075,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)); @@ -1093,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) */