/* Symbol table definitions for GDB.
- Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
- 1997, 1998, 1999, 2000, 2001, 2002
- Free Software Foundation, Inc.
+
+ Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+ 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
+ Foundation, Inc.
This file is part of GDB.
#define SYMTAB_H 1
/* Opaque declarations. */
+
struct obstack;
+struct objfile;
+struct block;
+struct blockvector;
+struct axs_value;
+struct agent_expr;
/* 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
struct general_symbol_info
{
- /* Name of the symbol. This is a required field. Storage for the name is
- allocated on the psymbol_obstack or symbol_obstack for the associated
- objfile. */
+ /* Name of the symbol. This is a required field. Storage for the
+ name is allocated on the psymbol_obstack or symbol_obstack for
+ the associated objfile. For languages like C++ that make a
+ distinction between the mangled name and demangled name, this is
+ the mangled name. */
char *name;
union
{
- struct cplus_specific /* For C++ */
- /* and Java */
+ struct cplus_specific
{
+ /* This is in fact used for C++, Java, and Objective C. */
char *demangled_name;
}
cplus_specific;
- struct objc_specific
- {
- char *demangled_name;
- }
- objc_specific;
}
language_specific;
functions, unless the callers are changed to pass in the ginfo
field only, instead of the SYMBOL parameter. */
-#define SYMBOL_NAME(symbol) (symbol)->ginfo.name
+#define DEPRECATED_SYMBOL_NAME(symbol) (symbol)->ginfo.name
#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
enum language language);
#define SYMBOL_INIT_DEMANGLED_NAME(symbol,obstack) \
- (symbol_init_demangled_name (&symbol->ginfo, (obstack)))
+ (symbol_init_demangled_name (&(symbol)->ginfo, (obstack)))
extern void symbol_init_demangled_name (struct general_symbol_info *symbol,
struct obstack *obstack);
+#define SYMBOL_SET_NAMES(symbol,name,len,objfile) \
+ symbol_set_names (&(symbol)->ginfo, name, len, objfile)
+extern void symbol_set_names (struct general_symbol_info *symbol,
+ const char *name, int len,
+ struct objfile *objfile);
+
+/* Now come lots of name accessor macros. Short version as to when to
+ use which: Use SYMBOL_NATURAL_NAME to refer to the name of the
+ symbol in the original source code. Use SYMBOL_LINKAGE_NAME if you
+ want to know what the linker thinks the symbol's name is. Use
+ SYMBOL_PRINT_NAME for output. Use SYMBOL_DEMANGLED_NAME if you
+ specifically need to know whether SYMBOL_NATURAL_NAME and
+ SYMBOL_LINKAGE_NAME are different. Don't use
+ DEPRECATED_SYMBOL_NAME at all: instances of that macro should be
+ replaced by SYMBOL_NATURAL_NAME, SYMBOL_LINKAGE_NAME, or perhaps
+ SYMBOL_PRINT_NAME. */
+
+/* Return SYMBOL's "natural" name, i.e. the name that it was called in
+ the original source code. In languages like C++ where symbols may
+ be mangled for ease of manipulation by the linker, this is the
+ demangled name. */
+
+#define SYMBOL_NATURAL_NAME(symbol) \
+ (symbol_natural_name (&(symbol)->ginfo))
+extern char *symbol_natural_name (const struct general_symbol_info *symbol);
+
+/* Return SYMBOL's name from the point of view of the linker. In
+ languages like C++ where symbols may be mangled for ease of
+ manipulation by the linker, this is the mangled name; otherwise,
+ it's the same as SYMBOL_NATURAL_NAME. This is currently identical
+ to DEPRECATED_SYMBOL_NAME, but please use SYMBOL_LINKAGE_NAME when
+ appropriate: it conveys the additional semantic information that
+ you really have thought about the issue and decided that you mean
+ SYMBOL_LINKAGE_NAME instead of SYMBOL_NATURAL_NAME. */
+
+#define SYMBOL_LINKAGE_NAME(symbol) (symbol)->ginfo.name
+
/* Return the demangled name for a symbol based on the language for
that symbol. If no demangled name exists, return NULL. */
#define SYMBOL_DEMANGLED_NAME(symbol) \
(symbol_demangled_name (&(symbol)->ginfo))
extern char *symbol_demangled_name (struct general_symbol_info *symbol);
-#define SYMBOL_OBJC_DEMANGLED_NAME(symbol) \
- (symbol)->ginfo.language_specific.objc_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
- of the name if demangle is off. In other languages this is just the
- symbol name. The result should never be NULL. */
-
-#define SYMBOL_SOURCE_NAME(symbol) \
- (demangle && SYMBOL_DEMANGLED_NAME (symbol) != NULL \
- ? SYMBOL_DEMANGLED_NAME (symbol) \
- : SYMBOL_NAME (symbol))
+/* Macro that returns a version of the name of a symbol that is
+ suitable for output. In C++ this is the "demangled" form of the
+ name if demangle is on and the "mangled" form of the name if
+ demangle is off. In other languages this is just the symbol name.
+ The result should never be NULL. Don't use this for internal
+ purposes (e.g. storing in a hashtable): it's only suitable for
+ output. */
-/* Macro that returns the "natural assembly name" of a symbol. In C++ this is
- the "mangled" form of the name if demangle is off, or if demangle is on and
- asm_demangle is off. Otherwise if asm_demangle is on it is the "demangled"
- form. In other languages this is just the symbol name. The result should
- never be NULL. */
-
-#define SYMBOL_LINKAGE_NAME(symbol) \
- (demangle && asm_demangle && SYMBOL_DEMANGLED_NAME (symbol) != NULL \
- ? SYMBOL_DEMANGLED_NAME (symbol) \
- : SYMBOL_NAME (symbol))
+#define SYMBOL_PRINT_NAME(symbol) \
+ (demangle ? SYMBOL_NATURAL_NAME (symbol) : SYMBOL_LINKAGE_NAME (symbol))
/* Macro that tests a symbol for a match against a specified name string.
First test the unencoded name, then looks for and test a C++ encoded
"foo :: bar (int, long)".
Evaluates to zero if the match fails, or nonzero if it succeeds. */
-#define SYMBOL_MATCHES_NAME(symbol, name) \
- (STREQ (SYMBOL_NAME (symbol), (name)) \
+/* FIXME: carlton/2003-02-27: This is an unholy mixture of linkage
+ names and natural names. If you want to test the linkage names
+ with strcmp, do that. If you want to test the natural names with
+ strcmp_iw, use SYMBOL_MATCHES_NATURAL_NAME. */
+
+#define DEPRECATED_SYMBOL_MATCHES_NAME(symbol, name) \
+ (STREQ (DEPRECATED_SYMBOL_NAME (symbol), (name)) \
|| (SYMBOL_DEMANGLED_NAME (symbol) != NULL \
&& strcmp_iw (SYMBOL_DEMANGLED_NAME (symbol), (name)) == 0))
-/* Macro that tests a symbol for an re-match against the last compiled regular
- expression. First test the unencoded name, then look for and test a C++
- encoded name if it exists.
- Evaluates to zero if the match fails, or nonzero if it succeeds. */
+/* Macro that tests a symbol for a match against a specified name
+ string. It tests against SYMBOL_NATURAL_NAME, and it ignores
+ whitespace and trailing parentheses. (See strcmp_iw for details
+ about its behavior.) */
-#define SYMBOL_MATCHES_REGEXP(symbol) \
- (re_exec (SYMBOL_NAME (symbol)) != 0 \
- || (SYMBOL_DEMANGLED_NAME (symbol) != NULL \
- && re_exec (SYMBOL_DEMANGLED_NAME (symbol)) != 0))
+#define SYMBOL_MATCHES_NATURAL_NAME(symbol, name) \
+ (strcmp_iw (SYMBOL_NATURAL_NAME (symbol), (name)) == 0)
/* Define a simple structure used to hold some very basic information about
all defined global symbols (text, data, bss, abs, etc). The only required
#define MSYMBOL_INFO(msymbol) (msymbol)->info
#define MSYMBOL_TYPE(msymbol) (msymbol)->type
-\f
-
-
-/* All of the name-scope contours of the program
- are represented by `struct block' objects.
- All of these objects are pointed to by the blockvector.
-
- Each block represents one name scope.
- Each lexical context has its own block.
-
- The blockvector begins with some special blocks.
- The GLOBAL_BLOCK contains all the symbols defined in this compilation
- whose scope is the entire program linked together.
- The STATIC_BLOCK contains all the symbols whose scope is the
- entire compilation excluding other separate compilations.
- Blocks starting with the FIRST_LOCAL_BLOCK are not special.
-
- Each block records a range of core addresses for the code that
- is in the scope of the block. The STATIC_BLOCK and GLOBAL_BLOCK
- give, for the range of code, the entire range of code produced
- by the compilation that the symbol segment belongs to.
-
- The blocks appear in the blockvector
- in order of increasing starting-address,
- and, within that, in order of decreasing ending-address.
-
- This implies that within the body of one function
- the blocks appear in the order of a depth-first tree walk. */
-
-struct blockvector
-{
- /* Number of blocks in the list. */
- int nblocks;
- /* The blocks themselves. */
- struct block *block[1];
-};
-
-#define BLOCKVECTOR_NBLOCKS(blocklist) (blocklist)->nblocks
-#define BLOCKVECTOR_BLOCK(blocklist,n) (blocklist)->block[n]
-
-/* Special block numbers */
-
-#define GLOBAL_BLOCK 0
-#define STATIC_BLOCK 1
-#define FIRST_LOCAL_BLOCK 2
-
-struct block
-{
-
- /* Addresses in the executable code that are in this block. */
-
- CORE_ADDR startaddr;
- CORE_ADDR endaddr;
-
- /* The symbol that names this block, if the block is the body of a
- function; otherwise, zero. */
-
- struct symbol *function;
-
- /* The `struct block' for the containing block, or 0 if none.
-
- The superblock of a top-level local block (i.e. a function in the
- case of C) is the STATIC_BLOCK. The superblock of the
- STATIC_BLOCK is the GLOBAL_BLOCK. */
-
- struct block *superblock;
-
- /* Version of GCC used to compile the function corresponding
- to this block, or 0 if not compiled with GCC. When possible,
- GCC should be compatible with the native compiler, or if that
- is not feasible, the differences should be fixed during symbol
- reading. As of 16 Apr 93, this flag is never used to distinguish
- between gcc2 and the native compiler.
-
- If there is no function corresponding to this block, this meaning
- of this flag is undefined. */
-
- unsigned char gcc_compile_flag;
- /* The symbols for this block are either in a simple linear list or
- in a simple hashtable. Blocks which correspond to a function
- (which have a list of symbols corresponding to arguments) use
- a linear list, as do some older symbol readers (currently only
- mdebugread and dstread). Other blocks are hashed.
-
- The hashtable uses the same hash function as the minsym hashtables,
- found in minsyms.c:minsym_hash_iw. Symbols are hashed based on
- their demangled name if appropriate, and on their name otherwise.
- The hash function ignores space, and stops at the beginning of the
- argument list if any.
-
- The table is laid out in NSYMS/5 buckets and symbols are chained via
- their hash_next field. */
-
- /* If this is really a hashtable of the symbols, this flag is 1. */
-
- unsigned char hashtable;
-
- /* Number of local symbols. */
-
- int nsyms;
-
- /* 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];
-};
-
-#define BLOCK_START(bl) (bl)->startaddr
-#define BLOCK_END(bl) (bl)->endaddr
-#define BLOCK_FUNCTION(bl) (bl)->function
-#define BLOCK_SUPERBLOCK(bl) (bl)->superblock
-#define BLOCK_GCC_COMPILED(bl) (bl)->gcc_compile_flag
-#define BLOCK_HASHTABLE(bl) (bl)->hashtable
-
-/* For blocks without a hashtable (BLOCK_HASHTABLE (bl) == 0) only. */
-#define BLOCK_NSYMS(bl) (bl)->nsyms
-#define BLOCK_SYM(bl, n) (bl)->sym[n]
-
-/* For blocks with a hashtable, but these are valid for non-hashed blocks as
- well - each symbol will appear to be one bucket by itself. */
-#define BLOCK_BUCKETS(bl) (bl)->nsyms
-#define BLOCK_BUCKET(bl, n) (bl)->sym[n]
-
-/* Macro used to set the size of a hashtable for N symbols. */
-#define BLOCK_HASHTABLE_SIZE(n) ((n)/5 + 1)
-
-/* Macro to loop through all symbols in a block BL, in no particular order.
- i counts which bucket we are in, and sym points to the current symbol. */
-
-#define ALL_BLOCK_SYMBOLS(bl, i, sym) \
- for ((i) = 0; (i) < BLOCK_BUCKETS ((bl)); (i)++) \
- for ((sym) = BLOCK_BUCKET ((bl), (i)); (sym); \
- (sym) = (sym)->hash_next)
-
-/* 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. Also don't sort any block that we chose to hash. */
-
-#define BLOCK_SHOULD_SORT(bl) (! BLOCK_HASHTABLE (bl) \
- && BLOCK_FUNCTION (bl) == NULL)
\f
/* Represent one symbol name; a variable, constant, function or typedef. */
* with a level of indirection.
*/
- LOC_INDIRECT
+ LOC_INDIRECT,
+
+ /* The variable's address is computed by a set of location
+ functions (see "struct location_funcs" below). */
+ LOC_COMPUTED,
+
+ /* Same as LOC_COMPUTED, but for function arguments. */
+ LOC_COMPUTED_ARG
+};
+
+/* A structure of function pointers describing the location of a
+ variable, structure member, or structure base class.
+
+ These functions' BATON arguments are generic data pointers, holding
+ whatever data the functions need --- the code which provides this
+ structure also provides the actual contents of the baton, and
+ decides its form. However, there may be other rules about where
+ the baton data must be allocated; whoever is pointing to this
+ `struct location_funcs' object will know the rules. For example,
+ when a symbol S's location is LOC_COMPUTED, then
+ SYMBOL_LOCATION_FUNCS(S) is pointing to a location_funcs structure,
+ and SYMBOL_LOCATION_BATON(S) is the baton, which must be allocated
+ on the same obstack as the symbol itself. */
+
+struct location_funcs
+{
+
+ /* Return the value of the variable SYMBOL, relative to the stack
+ frame FRAME. If the variable has been optimized out, return
+ zero.
+
+ Iff `read_needs_frame (SYMBOL)' is zero, then FRAME may be zero. */
+
+ struct value *(*read_variable) (struct symbol * symbol,
+ struct frame_info * frame);
+
+ /* Return non-zero if we need a frame to find the value of the SYMBOL. */
+ int (*read_needs_frame) (struct symbol * symbol);
+
+ /* Write to STREAM a natural-language description of the location of
+ SYMBOL. */
+ int (*describe_location) (struct symbol * symbol, struct ui_file * stream);
+
+ /* Tracepoint support. Append bytecodes to the tracepoint agent
+ expression AX that push the address of the object SYMBOL. Set
+ VALUE appropriately. Note --- for objects in registers, this
+ needn't emit any code; as long as it sets VALUE properly, then
+ the caller will generate the right code in the process of
+ treating this as an lvalue or rvalue. */
+
+ void (*tracepoint_var_ref) (struct symbol * symbol, struct agent_expr * ax,
+ struct axs_value * value);
};
/* Linked list of symbol's live ranges. */
variable declared with the `__thread' storage class), we may
need to know which object file it's in. */
struct objfile *objfile;
+
+ /* For a LOC_COMPUTED or LOC_COMPUTED_ARG symbol, this is the
+ baton and location_funcs structure to find its location. For a
+ LOC_BLOCK symbol for a function in a compilation unit compiled
+ with DWARF 2 information, this is information used internally
+ by the DWARF 2 code --- specifically, the location expression
+ for the frame base for this function. */
+ /* FIXME drow/2003-02-21: For the LOC_BLOCK case, it might be better
+ to add a magic symbol to the block containing this information,
+ or to have a generic debug info annotation slot for symbols. */
+ struct
+ {
+ void *baton;
+ struct location_funcs *funcs;
+ } loc;
}
aux_value;
#define SYMBOL_OBJFILE(symbol) (symbol)->aux_value.objfile
#define SYMBOL_ALIASES(symbol) (symbol)->aliases
#define SYMBOL_RANGES(symbol) (symbol)->ranges
+#define SYMBOL_LOCATION_BATON(symbol) (symbol)->aux_value.loc.baton
+#define SYMBOL_LOCATION_FUNCS(symbol) (symbol)->aux_value.loc.funcs
\f
/* A partial_symbol records the name, namespace, and address class of
symbols whose types we have not parsed yet. For functions, it also
extern struct type *lookup_enum (char *, struct block *);
-/* lookup the function corresponding to the block */
-
-extern struct symbol *block_function (struct block *);
-
/* from blockframe.c: */
/* lookup the function symbol corresponding to the address */
/* lookup function from address, return name, start addr and end addr */
-extern int
-find_pc_partial_function (CORE_ADDR, char **, CORE_ADDR *, CORE_ADDR *);
+extern int find_pc_partial_function (CORE_ADDR, char **, CORE_ADDR *,
+ CORE_ADDR *);
extern void clear_pc_function_cache (void);
extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
-extern int contained_in (struct block *, struct block *);
-
extern void reread_symbols (void);
extern struct type *lookup_transparent_type (const char *);
extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
-extern int
-find_line_pc_range (struct symtab_and_line, CORE_ADDR *, CORE_ADDR *);
+extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
+ CORE_ADDR *);
extern void resolve_sal_pc (struct symtab_and_line *);
extern struct symtab_and_line find_function_start_sal (struct symbol *sym,
int);
-/* blockframe.c */
-
-extern struct blockvector *blockvector_for_pc (CORE_ADDR, int *);
-
-extern struct blockvector *blockvector_for_pc_sect (CORE_ADDR, asection *,
- int *, struct symtab *);
-
/* symfile.c */
extern void clear_symtab_users (void);