/* Symbol table definitions for GDB.
- Copyright (C) 1986-2015 Free Software Foundation, Inc.
+ Copyright (C) 1986-2017 Free Software Foundation, Inc.
This file is part of GDB.
#if !defined (SYMTAB_H)
#define SYMTAB_H 1
-#include "vec.h"
+#include <vector>
#include "gdb_vecs.h"
#include "gdbtypes.h"
+#include "common/enum-flags.h"
+#include "common/function-view.h"
+#include "completer.h"
/* Opaque declarations. */
struct ui_file;
struct language_defn;
struct probe;
struct common_block;
+struct obj_section;
+struct cmd_list_element;
/* Some of the structures in this file are space critical.
The space-critical structures are:
struct obstack *obstack;
/* This is used by languages which wish to store a demangled name.
- currently used by Ada, C++, Java, and Objective C. */
- struct mangled_lang
- {
- const char *demangled_name;
- }
- mangled_lang;
+ currently used by Ada, C++, and Objective C. */
+ const char *demangled_name;
}
language_specific;
This is used to select one of the fields from the language specific
union above. */
- ENUM_BITFIELD(language) language : 8;
+ ENUM_BITFIELD(language) language : LANGUAGE_BITS;
- /* This is only used by Ada. If set, then the 'mangled_lang' field
+ /* This is only used by Ada. If set, then the 'demangled_name' field
of language_specific is valid. Otherwise, the 'obstack' field is
valid. */
unsigned int ada_mangled : 1;
extern int demangle;
/* Macro that returns the name to be used when sorting and searching symbols.
- In C++ and Java, we search for the demangled form of a name,
+ In C++, we search for the demangled form of a name,
and so sort symbols accordingly. In Ada, however, we search by mangled
name. If there is no distinct demangled name, then SYMBOL_SEARCH_NAME
returns the same value (same pointer) as SYMBOL_LINKAGE_NAME. */
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 */
+ mst_file_bss, /* Static version of mst_bss */
+ nr_minsym_types
};
+/* The number of enum minimal_symbol_type values, with some padding for
+ reasonable growth. */
+#define MINSYM_TYPE_BITS 4
+gdb_static_assert (nr_minsym_types <= (1 << MINSYM_TYPE_BITS));
+
/* Define a simple structure used to hold some very basic information about
all defined global symbols (text, data, bss, abs, etc). The only required
information is the general_symbol_info.
struct general_symbol_info mginfo;
- /* Size of this symbol. end_psymtab in dbxread.c uses this
+ /* Size of this symbol. dbx_end_psymtab in dbxread.c uses this
information to calculate the end of the partial symtab based on the
address of the last symbol plus the size of the last symbol. */
/* Classification type for this minimal symbol. */
- ENUM_BITFIELD(minimal_symbol_type) type : 8;
+ ENUM_BITFIELD(minimal_symbol_type) type : MINSYM_TYPE_BITS;
/* Non-zero if this symbol was created by gdb.
Such symbols do not appear in the output of "info var|fun". */
/* Fortran common blocks. Their naming must be separate from VAR_DOMAIN.
They also always use LOC_COMMON_BLOCK. */
- COMMON_BLOCK_DOMAIN
+ COMMON_BLOCK_DOMAIN,
+
+ /* This must remain last. */
+ NR_DOMAINS
} domain_enum;
/* The number of bits in a symbol used to represent the domain. */
-#define SYMBOL_DOMAIN_BITS 4
+#define SYMBOL_DOMAIN_BITS 3
+gdb_static_assert (NR_DOMAINS <= (1 << SYMBOL_DOMAIN_BITS));
extern const char *domain_name (domain_enum);
not find it in the full symbol table. But a reference to an external
symbol in a local block shadowing other definition requires full symbol
without possibly having its address available for LOC_STATIC. Testcase
- is provided as `gdb.dwarf2/dw2-unresolved.exp'. */
+ is provided as `gdb.dwarf2/dw2-unresolved.exp'.
+
+ This is also used for thread local storage (TLS) variables. In this case,
+ the address of the TLS variable must be determined when the variable is
+ referenced, from the MSYMBOL_VALUE_RAW_ADDRESS, which is the offset
+ of the TLS variable in the thread local storage of the shared
+ library/object. */
LOC_UNRESOLVED,
LOC_FINAL_VALUE
};
+/* The number of bits needed for values in enum address_class, with some
+ padding for reasonable growth, and room for run-time registered address
+ classes. See symtab.c:MAX_SYMBOL_IMPLS.
+ This is a #define so that we can have a assertion elsewhere to
+ verify that we have reserved enough space for synthetic address
+ classes. */
+#define SYMBOL_ACLASS_BITS 5
+gdb_static_assert (LOC_FINAL_VALUE <= (1 << SYMBOL_ACLASS_BITS));
+
/* The methods needed to implement LOC_COMPUTED. These methods can
use the symbol's .aux_value for additional per-symbol information.
frame FRAME. If the variable has been optimized out, return
zero.
- Iff `read_needs_frame (SYMBOL)' is zero, then FRAME may be zero. */
+ Iff `read_needs_frame (SYMBOL)' is not SYMBOL_NEEDS_FRAME, then
+ FRAME may be zero. */
struct value *(*read_variable) (struct symbol * symbol,
struct frame_info * frame);
struct value *(*read_variable_at_entry) (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);
+ /* Find the "symbol_needs_kind" value for the given symbol. This
+ value determines whether reading the symbol needs memory (e.g., a
+ global variable), just registers (a thread-local), or a frame (a
+ local variable). */
+ enum symbol_needs_kind (*get_symbol_read_needs) (struct symbol * symbol);
/* Write to STREAM a natural-language description of the location of
SYMBOL, in the context of ADDR. */
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 gdbarch *gdbarch,
- struct agent_expr *ax, struct axs_value *value);
+ void (*tracepoint_var_ref) (struct symbol *symbol, struct agent_expr *ax,
+ struct axs_value *value);
/* Generate C code to compute the location of SYMBOL. The C code is
emitted to STREAM. GDBARCH is the current architecture and PC is
The generated C code must assign the location to a local
variable; this variable's name is RESULT_NAME. */
- void (*generate_c_location) (struct symbol *symbol, struct ui_file *stream,
+ void (*generate_c_location) (struct symbol *symbol, string_file &stream,
struct gdbarch *gdbarch,
unsigned char *registers_used,
CORE_ADDR pc, const char *result_name);
uninitialized in such case. */
void (*find_frame_base_location) (struct symbol *framefunc, CORE_ADDR pc,
const gdb_byte **start, size_t *length);
+
+ /* Return the frame base address. FRAME is the frame for which we want to
+ compute the base address while FRAMEFUNC is the symbol for the
+ corresponding function. Return 0 on failure (FRAMEFUNC may not hold the
+ information we need).
+
+ This method is designed to work with static links (nested functions
+ handling). Static links are function properties whose evaluation returns
+ the frame base address for the enclosing frame. However, there are
+ multiple definitions for "frame base": the content of the frame base
+ register, the CFA as defined by DWARF unwinding information, ...
+
+ So this specific method is supposed to compute the frame base address such
+ as for nested fuctions, the static link computes the same address. For
+ instance, considering DWARF debugging information, the static link is
+ computed with DW_AT_static_link and this method must be used to compute
+ the corresponding DW_AT_frame_base attribute. */
+ CORE_ADDR (*get_frame_base) (struct symbol *framefunc,
+ struct frame_info *frame);
};
/* Functions used with LOC_REGISTER and LOC_REGPARM_ADDR. */
const struct symbol_register_ops *ops_register;
};
-/* The number of bits we reserve in a symbol for the aclass index.
- This is a #define so that we can have a assertion elsewhere to
- verify that we have reserved enough space for synthetic address
- classes. */
-
-#define SYMBOL_ACLASS_BITS 6
-
/* This structure is space critical. See space comments at the top. */
struct symbol
/* An arbitrary data pointer, allowing symbol readers to record
additional information on a per-symbol basis. Note that this data
must be allocated using the same obstack as the symbol itself. */
- /* So far it is only used by LOC_COMPUTED to
- find the location information. 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
+ /* So far it is only used by:
+ LOC_COMPUTED: to find the location information
+ LOC_BLOCK (DWARF2 function): 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,
struct symbol *hash_next;
};
+/* Several lookup functions return both a symbol and the block in which the
+ symbol is found. This structure is used in these cases. */
+
+struct block_symbol
+{
+ /* The symbol that was found, or NULL if no symbol was found. */
+ struct symbol *symbol;
+
+ /* If SYMBOL is not NULL, then this is the block in which the symbol is
+ defined. */
+ const struct block *block;
+};
+
extern const struct symbol_impl *symbol_impls;
+/* For convenience. All fields are NULL. This means "there is no
+ symbol". */
+extern const struct block_symbol null_block_symbol;
+
/* Note: There is no accessor macro for symbol.owner because it is
"private". */
struct symtab
{
- /* Unordered chain of all existing symtabs of this objfile. */
+ /* Unordered chain of all filetabs in the compunit, with the exception
+ that the "main" source file is the first entry in the list. */
struct symtab *next;
extern int currently_reading_symtab;
-/* The block in which the most recently looked up symbol was found. */
-
-extern const struct block *block_found;
-
/* symtab.c lookup functions */
extern const char multiple_symbols_ask[];
C++: if IS_A_FIELD_OF_THIS is non-NULL on entry, check to see if
NAME is a field of the current implied argument `this'. If so fill in the
fields of IS_A_FIELD_OF_THIS, otherwise the fields are set to NULL.
- BLOCK_FOUND is set to the block in which NAME is found (in the case of
- a field of `this', value_of_this sets BLOCK_FOUND to the proper value).
The symbol's section is fixed up if necessary. */
-extern struct symbol *lookup_symbol_in_language (const char *,
- const struct block *,
- const domain_enum,
- enum language,
- struct field_of_this_result *);
+extern struct block_symbol
+ lookup_symbol_in_language (const char *,
+ const struct block *,
+ const domain_enum,
+ enum language,
+ struct field_of_this_result *);
/* Same as lookup_symbol_in_language, but using the current language. */
-extern struct symbol *lookup_symbol (const char *, const struct block *,
- const domain_enum,
- struct field_of_this_result *);
+extern struct block_symbol lookup_symbol (const char *,
+ const struct block *,
+ const domain_enum,
+ struct field_of_this_result *);
/* A default version of lookup_symbol_nonlocal for use by languages
that can't think of anything better to do.
This implements the C lookup rules. */
-extern struct symbol *
+extern struct block_symbol
basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
const char *,
const struct block *,
/* Lookup a symbol in the static block associated to BLOCK, if there
is one; do nothing if BLOCK is NULL or a global block.
- Upon success sets BLOCK_FOUND and fixes up the symbol's section
- if necessary. */
+ Upon success fixes up the symbol's section if necessary. */
-extern struct symbol *lookup_symbol_in_static_block (const char *name,
- const struct block *block,
- const domain_enum domain);
+extern struct block_symbol
+ lookup_symbol_in_static_block (const char *name,
+ const struct block *block,
+ const domain_enum domain);
/* Search all static file-level symbols for NAME from DOMAIN.
- Upon success sets BLOCK_FOUND and fixes up the symbol's section
- if necessary. */
+ Upon success fixes up the symbol's section if necessary. */
-extern struct symbol *lookup_static_symbol (const char *name,
- const domain_enum domain);
+extern struct block_symbol lookup_static_symbol (const char *name,
+ const domain_enum domain);
/* Lookup a symbol in all files' global blocks.
if the target requires it.
See gdbarch_iterate_over_objfiles_in_search_order.
- Upon success sets BLOCK_FOUND and fixes up the symbol's section
- if necessary. */
+ Upon success fixes up the symbol's section if necessary. */
-extern struct symbol *lookup_global_symbol (const char *name,
- const struct block *block,
- const domain_enum domain);
+extern struct block_symbol
+ lookup_global_symbol (const char *name,
+ const struct block *block,
+ const domain_enum domain);
/* Lookup a symbol in block BLOCK.
- Upon success sets BLOCK_FOUND and fixes up the symbol's section
- if necessary. */
+ Upon success fixes up the symbol's section if necessary. */
-extern struct symbol *lookup_symbol_in_block (const char *name,
- const struct block *block,
- const domain_enum domain);
+extern struct symbol *
+ lookup_symbol_in_block (const char *name,
+ const struct block *block,
+ const domain_enum domain);
/* Look up the `this' symbol for LANG in BLOCK. Return the symbol if
found, or NULL if not found. */
-extern struct symbol *lookup_language_this (const struct language_defn *lang,
- const struct block *block);
+extern struct block_symbol
+ lookup_language_this (const struct language_defn *lang,
+ const struct block *block);
/* Lookup a [struct, union, enum] by name, within a specified block. */
struct symtab_and_line
{
/* The program space of this sal. */
- struct program_space *pspace;
+ struct program_space *pspace = NULL;
- struct symtab *symtab;
- struct obj_section *section;
+ struct symtab *symtab = NULL;
+ struct symbol *symbol = NULL;
+ struct obj_section *section = NULL;
/* 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;
+ int line = 0;
- CORE_ADDR pc;
- CORE_ADDR end;
- int explicit_pc;
- int explicit_line;
+ CORE_ADDR pc = 0;
+ CORE_ADDR end = 0;
+ bool explicit_pc = false;
+ bool explicit_line = false;
/* The probe associated with this symtab_and_line. */
- struct probe *probe;
+ struct probe *probe = NULL;
/* If PROBE is not NULL, then this is the objfile in which the probe
originated. */
- struct objfile *objfile;
+ struct objfile *objfile = NULL;
};
-extern void init_sal (struct symtab_and_line *sal);
-
-struct symtabs_and_lines
-{
- struct symtab_and_line *sals;
- int nelts;
-};
\f
/* Given a pc value, return line number it is in. Second arg nonzero means
extern void resolve_sal_pc (struct symtab_and_line *);
-/* Symbol-reading stuff in symfile.c and solib.c. */
+/* solib.c */
extern void clear_solib (void);
/* Flags passed as 4th argument to print_source_lines. */
-enum print_source_lines_flags
+enum print_source_lines_flag
{
/* Do not print an error message. */
PRINT_SOURCE_LINES_NOERROR = (1 << 0),
/* Print the filename in front of the source lines. */
PRINT_SOURCE_LINES_FILENAME = (1 << 1)
};
+DEF_ENUM_FLAGS_TYPE (enum print_source_lines_flag, print_source_lines_flags);
extern void print_source_lines (struct symtab *, int, int,
- enum print_source_lines_flags);
+ print_source_lines_flags);
extern void forget_cached_source_info_for_objfile (struct objfile *);
extern void forget_cached_source_info (void);
extern void select_source_symtab (struct symtab *);
-extern VEC (char_ptr) *default_make_symbol_completion_list_break_on
- (const char *text, const char *word, const char *break_on,
+/* The reason we're calling into a completion match list collector
+ function. */
+enum class complete_symbol_mode
+ {
+ /* Completing an expression. */
+ EXPRESSION,
+
+ /* Completing a linespec. */
+ LINESPEC,
+ };
+
+extern void default_collect_symbol_completion_matches_break_on
+ (completion_tracker &tracker,
+ complete_symbol_mode mode,
+ const char *text, const char *word, const char *break_on,
enum type_code code);
-extern VEC (char_ptr) *default_make_symbol_completion_list (const char *,
- const char *,
- enum type_code);
-extern VEC (char_ptr) *make_symbol_completion_list (const char *, const char *);
-extern VEC (char_ptr) *make_symbol_completion_type (const char *, const char *,
+extern void default_collect_symbol_completion_matches
+ (completion_tracker &tracker,
+ complete_symbol_mode,
+ const char *,
+ const char *,
+ enum type_code);
+extern void collect_symbol_completion_matches (completion_tracker &tracker,
+ complete_symbol_mode,
+ const char *, const char *);
+extern void collect_symbol_completion_matches_type (completion_tracker &tracker,
+ const char *, const char *,
enum type_code);
-extern VEC (char_ptr) *make_symbol_completion_list_fn (struct cmd_list_element *,
- const char *,
- const char *);
-extern VEC (char_ptr) *make_file_symbol_completion_list (const char *,
- const char *,
- const char *);
+extern void collect_file_symbol_completion_matches (completion_tracker &tracker,
+ complete_symbol_mode,
+ const char *,
+ const char *,
+ const char *);
-extern VEC (char_ptr) *make_source_files_completion_list (const char *,
- const char *);
+extern completion_list
+ make_source_files_completion_list (const char *, const char *);
/* symtab.c */
extern void skip_prologue_sal (struct symtab_and_line *);
-/* symfile.c */
-
-extern void clear_symtab_users (int add_flags);
-
-extern enum language deduce_language_from_filename (const char *);
-
/* symtab.c */
extern CORE_ADDR skip_prologue_using_sal (struct gdbarch *gdbarch,
extern struct symbol *fixup_symbol_section (struct symbol *,
struct objfile *);
+/* If MSYMBOL is an text symbol, look for a function debug symbol with
+ the same address. Returns NULL if not found. This is necessary in
+ case a function is an alias to some other function, because debug
+ information is only emitted for the alias target function's
+ definition, not for the alias. */
+extern symbol *find_function_alias_target (bound_minimal_symbol msymbol);
+
/* Symbol searching */
/* Note: struct symbol_search, search_symbols, et.al. are declared here,
instead of making them local to symtab.c, for gdbtk's sake. */
-/* When using search_symbols, a list of the following structs is returned.
- Callers must free the search list using free_search_symbols! */
+/* When using search_symbols, a vector of the following structs is
+ returned. */
struct symbol_search
{
+ symbol_search (int block_, struct symbol *symbol_)
+ : block (block_),
+ symbol (symbol_)
+ {
+ msymbol.minsym = nullptr;
+ msymbol.objfile = nullptr;
+ }
+
+ symbol_search (int block_, struct minimal_symbol *minsym,
+ struct objfile *objfile)
+ : block (block_),
+ symbol (nullptr)
+ {
+ msymbol.minsym = minsym;
+ msymbol.objfile = objfile;
+ }
+
+ bool operator< (const symbol_search &other) const
+ {
+ return compare_search_syms (*this, other) < 0;
+ }
+
+ bool operator== (const symbol_search &other) const
+ {
+ return compare_search_syms (*this, other) == 0;
+ }
+
/* The block in which the match was found. Could be, for example,
STATIC_BLOCK or GLOBAL_BLOCK. */
int block;
which only minimal_symbols exist. */
struct bound_minimal_symbol msymbol;
- /* A link to the next match, or NULL for the end. */
- struct symbol_search *next;
+private:
+
+ static int compare_search_syms (const symbol_search &sym_a,
+ const symbol_search &sym_b);
};
-extern void search_symbols (const char *, enum search_domain, int,
- const char **, struct symbol_search **);
-extern void free_search_symbols (struct symbol_search *);
-extern struct cleanup *make_cleanup_free_search_symbols (struct symbol_search
- **);
+extern std::vector<symbol_search> search_symbols (const char *,
+ enum search_domain, int,
+ const char **);
/* The name of the ``main'' function.
FIXME: cagney/2001-03-20: Can't make main_name() const since some
/* Lookup symbol NAME from DOMAIN in MAIN_OBJFILE's global blocks.
This searches MAIN_OBJFILE as well as any associated separate debug info
objfiles of MAIN_OBJFILE.
- Upon success sets BLOCK_FOUND and fixes up the symbol's section
- if necessary. */
+ Upon success fixes up the symbol's section if necessary. */
-extern struct symbol *
+extern struct block_symbol
lookup_global_symbol_from_objfile (struct objfile *main_objfile,
const char *name,
const domain_enum domain);
int compare_filenames_for_search (const char *filename,
const char *search_name);
-int iterate_over_some_symtabs (const char *name,
- const char *real_path,
- int (*callback) (struct symtab *symtab,
- void *data),
- void *data,
- struct compunit_symtab *first,
- struct compunit_symtab *after_last);
+int compare_glob_filenames_for_search (const char *filename,
+ const char *search_name);
+
+bool iterate_over_some_symtabs (const char *name,
+ const char *real_path,
+ struct compunit_symtab *first,
+ struct compunit_symtab *after_last,
+ gdb::function_view<bool (symtab *)> callback);
void iterate_over_symtabs (const char *name,
- int (*callback) (struct symtab *symtab,
- void *data),
- void *data);
+ gdb::function_view<bool (symtab *)> callback);
-DEF_VEC_I (CORE_ADDR);
-VEC (CORE_ADDR) *find_pcs_for_symtab_line (struct symtab *symtab, int line,
- struct linetable_entry **best_entry);
+std::vector<CORE_ADDR> find_pcs_for_symtab_line
+ (struct symtab *symtab, int line, struct linetable_entry **best_entry);
-/* Callback for LA_ITERATE_OVER_SYMBOLS. The callback will be called
- once per matching symbol SYM, with DATA being the argument of the
- same name that was passed to LA_ITERATE_OVER_SYMBOLS. The callback
- should return nonzero to indicate that LA_ITERATE_OVER_SYMBOLS
- should continue iterating, or zero to indicate that the iteration
- should end. */
+/* Prototype for callbacks for LA_ITERATE_OVER_SYMBOLS. The callback
+ is called once per matching symbol SYM. The callback should return
+ true to indicate that LA_ITERATE_OVER_SYMBOLS should continue
+ iterating, or false to indicate that the iteration should end. */
-typedef int (symbol_found_callback_ftype) (struct symbol *sym, void *data);
+typedef bool (symbol_found_callback_ftype) (symbol *sym);
void iterate_over_symbols (const struct block *block, const char *name,
const domain_enum domain,
- symbol_found_callback_ftype *callback,
- void *data);
+ gdb::function_view<symbol_found_callback_ftype> callback);
+
+/* Storage type used by demangle_for_lookup. demangle_for_lookup
+ either returns a const char * pointer that points to either of the
+ fields of this type, or a pointer to the input NAME. This is done
+ this way because the underlying functions that demangle_for_lookup
+ calls either return a std::string (e.g., cp_canonicalize_string) or
+ a malloc'ed buffer (libiberty's demangled), and we want to avoid
+ unnecessary reallocation/string copying. */
+class demangle_result_storage
+{
+public:
+
+ /* Swap the std::string storage with STR, and return a pointer to
+ the beginning of the new string. */
+ const char *swap_string (std::string &str)
+ {
+ std::swap (m_string, str);
+ return m_string.c_str ();
+ }
+
+ /* Set the malloc storage to now point at PTR. Any previous malloc
+ storage is released. */
+ const char *set_malloc_ptr (char *ptr)
+ {
+ m_malloc.reset (ptr);
+ return ptr;
+ }
+
+private:
+
+ /* The storage. */
+ std::string m_string;
+ gdb::unique_xmalloc_ptr<char> m_malloc;
+};
-struct cleanup *demangle_for_lookup (const char *name, enum language lang,
- const char **result_name);
+const char *
+ demangle_for_lookup (const char *name, enum language lang,
+ demangle_result_storage &storage);
struct symbol *allocate_symbol (struct objfile *);
projects / deliverable / binutils-gdb.git / blobdiff