/* Symbol table definitions for GDB.
- Copyright (C) 1986-2018 Free Software Foundation, Inc.
+ Copyright (C) 1986-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include <array>
#include <vector>
#include <string>
-#include "gdb_vecs.h"
+#include "gdbsupport/gdb_vecs.h"
#include "gdbtypes.h"
-#include "common/enum-flags.h"
-#include "common/function-view.h"
-#include "common/gdb_optional.h"
+#include "gdb_obstack.h"
+#include "gdb_regex.h"
+#include "gdbsupport/enum-flags.h"
+#include "gdbsupport/function-view.h"
+#include "gdbsupport/gdb_optional.h"
+#include "gdbsupport/gdb_string_view.h"
+#include "gdbsupport/next-iterator.h"
#include "completer.h"
/* Opaque declarations. */
extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
-/* Note that all the following SYMBOL_* macros are used with the
- SYMBOL argument being either a partial symbol or
- a full symbol. Both types have a ginfo field. In particular
- the SYMBOL_SET_LANGUAGE, SYMBOL_DEMANGLED_NAME, etc.
- macros cannot be entirely substituted by
- functions, unless the callers are changed to pass in the ginfo
- field only, instead of the SYMBOL parameter. */
-
-#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_VALUE_COMMON_BLOCK(symbol) (symbol)->ginfo.value.common_block
-#define SYMBOL_BLOCK_VALUE(symbol) (symbol)->ginfo.value.block
-#define SYMBOL_VALUE_CHAIN(symbol) (symbol)->ginfo.value.chain
-#define SYMBOL_LANGUAGE(symbol) (symbol)->ginfo.language
-#define SYMBOL_SECTION(symbol) (symbol)->ginfo.section
+/* Return the address of SYM. The MAYBE_COPIED flag must be set on
+ SYM. If SYM appears in the main program's minimal symbols, then
+ that minsym's address is returned; otherwise, SYM's address is
+ returned. This should generally only be used via the
+ SYMBOL_VALUE_ADDRESS macro. */
+
+extern CORE_ADDR get_symbol_address (const struct symbol *sym);
+
+/* Note that these macros only work with symbol, not partial_symbol. */
+
+#define SYMBOL_VALUE(symbol) (symbol)->value.ivalue
+#define SYMBOL_VALUE_ADDRESS(symbol) \
+ (((symbol)->maybe_copied) ? get_symbol_address (symbol) \
+ : ((symbol)->value.address))
+#define SET_SYMBOL_VALUE_ADDRESS(symbol, new_value) \
+ ((symbol)->value.address = (new_value))
+#define SYMBOL_VALUE_BYTES(symbol) (symbol)->value.bytes
+#define SYMBOL_VALUE_COMMON_BLOCK(symbol) (symbol)->value.common_block
+#define SYMBOL_BLOCK_VALUE(symbol) (symbol)->value.block
+#define SYMBOL_VALUE_CHAIN(symbol) (symbol)->value.chain
+#define SYMBOL_LANGUAGE(symbol) (symbol)->language
+#define SYMBOL_SECTION(symbol) (symbol)->section
#define SYMBOL_OBJ_SECTION(objfile, symbol) \
- (((symbol)->ginfo.section >= 0) \
- ? (&(((objfile)->sections)[(symbol)->ginfo.section])) \
+ (((symbol)->section >= 0) \
+ ? (&(((objfile)->sections)[(symbol)->section])) \
: NULL)
/* Initializes the language dependent portion of a symbol
depending upon the language for the symbol. */
#define SYMBOL_SET_LANGUAGE(symbol,language,obstack) \
- (symbol_set_language (&(symbol)->ginfo, (language), (obstack)))
+ (symbol_set_language ((symbol), (language), (obstack)))
extern void symbol_set_language (struct general_symbol_info *symbol,
enum language language,
struct obstack *obstack);
be terminated and either already on the objfile's obstack or
permanently allocated. */
#define SYMBOL_SET_LINKAGE_NAME(symbol,linkage_name) \
- (symbol)->ginfo.name = (linkage_name)
+ (symbol)->name = (linkage_name)
/* Set the linkage and natural names of a symbol, by demangling
- the linkage name. */
-#define SYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile) \
- symbol_set_names (&(symbol)->ginfo, linkage_name, len, copy_name, objfile)
+ the linkage name. If linkage_name may not be nullterminated,
+ copy_name must be set to true. */
+#define SYMBOL_SET_NAMES(symbol,linkage_name,copy_name,objfile) \
+ symbol_set_names ((symbol), linkage_name, copy_name, \
+ (objfile)->per_bfd)
extern void symbol_set_names (struct general_symbol_info *symbol,
- const char *linkage_name, int len, int copy_name,
- struct objfile *objfile);
+ gdb::string_view linkage_name, bool copy_name,
+ struct objfile_per_bfd_storage *per_bfd);
/* 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
demangled name. */
#define SYMBOL_NATURAL_NAME(symbol) \
- (symbol_natural_name (&(symbol)->ginfo))
+ (symbol_natural_name ((symbol)))
extern const char *symbol_natural_name
(const struct general_symbol_info *symbol);
manipulation by the linker, this is the mangled name; otherwise,
it's the same as SYMBOL_NATURAL_NAME. */
-#define SYMBOL_LINKAGE_NAME(symbol) (symbol)->ginfo.name
+#define SYMBOL_LINKAGE_NAME(symbol) (symbol)->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))
+ (symbol_demangled_name ((symbol)))
extern const char *symbol_demangled_name
(const struct general_symbol_info *symbol);
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.
- N.B. symbol may be anything with a ginfo member,
+ N.B. symbol may be anything inheriting from general_symbol_info,
e.g., struct symbol or struct minimal_symbol. */
#define SYMBOL_PRINT_NAME(symbol) \
(demangle ? SYMBOL_NATURAL_NAME (symbol) : SYMBOL_LINKAGE_NAME (symbol))
-extern int demangle;
+extern bool demangle;
/* Macro that returns the name to be used when sorting and searching symbols.
In C++, we search for the demangled form of a name,
name. If there is no distinct demangled name, then SYMBOL_SEARCH_NAME
returns the same value (same pointer) as SYMBOL_LINKAGE_NAME. */
#define SYMBOL_SEARCH_NAME(symbol) \
- (symbol_search_name (&(symbol)->ginfo))
+ (symbol_search_name (symbol))
extern const char *symbol_search_name (const struct general_symbol_info *ginfo);
/* Return true if NAME matches the "search" name of SYMBOL, according
to the symbol's language. */
#define SYMBOL_MATCHES_SEARCH_NAME(symbol, name) \
- symbol_matches_search_name (&(symbol)->ginfo, (name))
+ symbol_matches_search_name ((symbol), (name))
/* Helper for SYMBOL_MATCHES_SEARCH_NAME that works with both symbols
and psymbols. */
between names and addresses, and vice versa. They are also sometimes
used to figure out what full symbol table entries need to be read in. */
-struct minimal_symbol
+struct minimal_symbol : public general_symbol_info
{
-
- /* 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 mginfo;
-
/* 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. */
the object file format may not carry that piece of information. */
unsigned int has_size : 1;
+ /* For data symbols only, if this is set, then the symbol might be
+ subject to copy relocation. In this case, a minimal symbol
+ matching the symbol's linkage name is first looked for in the
+ main objfile. If found, then that address is used; otherwise the
+ address in this symbol is used. */
+
+ unsigned maybe_copied : 1;
+
/* Minimal symbols with the same hash key are kept on a linked
list. This is the link. */
the `next' pointer for the demangled hash table. */
struct minimal_symbol *demangled_hash_next;
+
+ /* True if this symbol is of some data type. */
+
+ bool data_p () const;
+
+ /* True if MSYMBOL is of some text type. */
+
+ bool text_p () const;
};
+/* Return the address of MINSYM, which comes from OBJF. The
+ MAYBE_COPIED flag must be set on MINSYM. If MINSYM appears in the
+ main program's minimal symbols, then that minsym's address is
+ returned; otherwise, MINSYM's address is returned. This should
+ generally only be used via the MSYMBOL_VALUE_ADDRESS macro. */
+
+extern CORE_ADDR get_msymbol_address (struct objfile *objf,
+ const struct minimal_symbol *minsym);
+
#define MSYMBOL_TARGET_FLAG_1(msymbol) (msymbol)->target_flag_1
#define MSYMBOL_TARGET_FLAG_2(msymbol) (msymbol)->target_flag_2
#define MSYMBOL_SIZE(msymbol) ((msymbol)->size + 0)
#define MSYMBOL_HAS_SIZE(msymbol) ((msymbol)->has_size + 0)
#define MSYMBOL_TYPE(msymbol) (msymbol)->type
-#define MSYMBOL_VALUE(symbol) (symbol)->mginfo.value.ivalue
+#define MSYMBOL_VALUE(symbol) (symbol)->value.ivalue
/* The unrelocated address of the minimal symbol. */
-#define MSYMBOL_VALUE_RAW_ADDRESS(symbol) ((symbol)->mginfo.value.address + 0)
+#define MSYMBOL_VALUE_RAW_ADDRESS(symbol) ((symbol)->value.address + 0)
/* The relocated address of the minimal symbol, using the section
offsets from OBJFILE. */
#define MSYMBOL_VALUE_ADDRESS(objfile, symbol) \
- ((symbol)->mginfo.value.address \
- + ANOFFSET ((objfile)->section_offsets, ((symbol)->mginfo.section)))
+ (((symbol)->maybe_copied) ? get_msymbol_address (objfile, symbol) \
+ : ((symbol)->value.address \
+ + ANOFFSET ((objfile)->section_offsets, ((symbol)->section))))
/* For a bound minsym, we can easily compute the address directly. */
#define BMSYMBOL_VALUE_ADDRESS(symbol) \
MSYMBOL_VALUE_ADDRESS ((symbol).objfile, (symbol).minsym)
#define SET_MSYMBOL_VALUE_ADDRESS(symbol, new_value) \
- ((symbol)->mginfo.value.address = (new_value))
-#define MSYMBOL_VALUE_BYTES(symbol) (symbol)->mginfo.value.bytes
-#define MSYMBOL_BLOCK_VALUE(symbol) (symbol)->mginfo.value.block
-#define MSYMBOL_VALUE_CHAIN(symbol) (symbol)->mginfo.value.chain
-#define MSYMBOL_LANGUAGE(symbol) (symbol)->mginfo.language
-#define MSYMBOL_SECTION(symbol) (symbol)->mginfo.section
+ ((symbol)->value.address = (new_value))
+#define MSYMBOL_VALUE_BYTES(symbol) (symbol)->value.bytes
+#define MSYMBOL_BLOCK_VALUE(symbol) (symbol)->value.block
+#define MSYMBOL_VALUE_CHAIN(symbol) (symbol)->value.chain
+#define MSYMBOL_LANGUAGE(symbol) (symbol)->language
+#define MSYMBOL_SECTION(symbol) (symbol)->section
#define MSYMBOL_OBJ_SECTION(objfile, symbol) \
- (((symbol)->mginfo.section >= 0) \
- ? (&(((objfile)->sections)[(symbol)->mginfo.section])) \
+ (((symbol)->section >= 0) \
+ ? (&(((objfile)->sections)[(symbol)->section])) \
: NULL)
#define MSYMBOL_NATURAL_NAME(symbol) \
- (symbol_natural_name (&(symbol)->mginfo))
-#define MSYMBOL_LINKAGE_NAME(symbol) (symbol)->mginfo.name
+ (symbol_natural_name (symbol))
+#define MSYMBOL_LINKAGE_NAME(symbol) (symbol)->name
#define MSYMBOL_PRINT_NAME(symbol) \
(demangle ? MSYMBOL_NATURAL_NAME (symbol) : MSYMBOL_LINKAGE_NAME (symbol))
#define MSYMBOL_DEMANGLED_NAME(symbol) \
- (symbol_demangled_name (&(symbol)->mginfo))
-#define MSYMBOL_SET_LANGUAGE(symbol,language,obstack) \
- (symbol_set_language (&(symbol)->mginfo, (language), (obstack)))
+ (symbol_demangled_name (symbol))
#define MSYMBOL_SEARCH_NAME(symbol) \
- (symbol_search_name (&(symbol)->mginfo))
-#define MSYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile) \
- symbol_set_names (&(symbol)->mginfo, linkage_name, len, copy_name, objfile)
+ (symbol_search_name (symbol))
#include "minsyms.h"
/* All defined types */
TYPES_DOMAIN = 2,
+ /* All modules. */
+ MODULES_DOMAIN = 3,
+
/* Any type. */
- ALL_DOMAIN = 3
+ ALL_DOMAIN = 4
};
extern const char *search_domain_name (enum search_domain);
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, string_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);
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
+ as for nested functions, 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. */
/* This structure is space critical. See space comments at the top. */
-struct symbol
+struct symbol : public general_symbol_info, public allocate_on_obstack
{
-
- /* The general symbol info required for all types of symbols. */
-
- struct general_symbol_info ginfo;
+ symbol ()
+ /* Class-initialization of bitfields is only allowed in C++20. */
+ : domain (UNDEF_DOMAIN),
+ aclass_index (0),
+ is_objfile_owned (0),
+ is_argument (0),
+ is_inlined (0),
+ maybe_copied (0),
+ subclass (SYMBOL_NONE)
+ {
+ /* We can't use an initializer list for members of a base class, and
+ general_symbol_info needs to stay a POD type. */
+ name = nullptr;
+ value.ivalue = 0;
+ language_specific.obstack = nullptr;
+ language = language_unknown;
+ ada_mangled = 0;
+ section = 0;
+ }
/* Data type of value */
- struct type *type;
+ struct type *type = nullptr;
/* The owner of this symbol.
Which one to use is defined by symbol.is_objfile_owned. */
/* The symbol table containing this symbol. This is the file associated
with LINE. It can be NULL during symbols read-in but it is never NULL
during normal operation. */
- struct symtab *symtab;
+ struct symtab *symtab = nullptr;
/* For types defined by the architecture. */
struct gdbarch *arch;
unsigned int aclass_index : SYMBOL_ACLASS_BITS;
/* If non-zero then symbol is objfile-owned, use owner.symtab.
- Otherwise symbol is arch-owned, use owner.arch. */
+ Otherwise symbol is arch-owned, use owner.arch. */
unsigned int is_objfile_owned : 1;
/* Whether this is an inlined function (class LOC_BLOCK only). */
unsigned is_inlined : 1;
+ /* For LOC_STATIC only, if this is set, then the symbol might be
+ subject to copy relocation. In this case, a minimal symbol
+ matching the symbol's linkage name is first looked for in the
+ main objfile. If found, then that address is used; otherwise the
+ address in this symbol is used. */
+
+ unsigned maybe_copied : 1;
+
/* The concrete type of this symbol. */
ENUM_BITFIELD (symbol_subclass_kind) subclass : 2;
to debug files longer than 64K lines? What about machine
generated programs? */
- unsigned short line;
+ unsigned short line = 0;
/* An arbitrary data pointer, allowing symbol readers to record
additional information on a per-symbol basis. Note that this data
to add a magic symbol to the block containing this information,
or to have a generic debug info annotation slot for symbols. */
- void *aux_value;
+ void *aux_value = nullptr;
- struct symbol *hash_next;
+ struct symbol *hash_next = nullptr;
};
/* Several lookup functions return both a symbol and the block in which the
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 template_symbol : public symbol
{
/* The number of template arguments. */
- int n_template_arguments;
+ int n_template_arguments = 0;
/* The template arguments. This is an array with
N_TEMPLATE_ARGUMENTS elements. */
- struct symbol **template_arguments;
+ struct symbol **template_arguments = nullptr;
};
/* A symbol that represents a Rust virtual table object. */
{
/* The concrete type for which this vtable was created; that is, in
"impl Trait for Type", this is "Type". */
- struct type *concrete_type;
+ struct type *concrete_type = nullptr;
};
\f
const char *filename;
- /* Total number of lines found in source file. */
-
- int nlines;
-
- /* 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;
-
/* Language of this source file. */
enum language language;
#define SYMTAB_DIRNAME(symtab) \
COMPUNIT_DIRNAME (SYMTAB_COMPUNIT (symtab))
-typedef struct symtab *symtab_ptr;
-DEF_VEC_P (symtab_ptr);
-
/* Compunit symtabs contain the actual "symbol table", aka blockvector, as well
as the list of all source files (what gdb has historically associated with
the term "symtab").
#define COMPUNIT_CALL_SITE_HTAB(cust) ((cust)->call_site_htab)
#define COMPUNIT_MACRO_TABLE(cust) ((cust)->macro_table)
-/* Iterate over all file tables (struct symtab) within a compunit. */
+/* A range adapter to allowing iterating over all the file tables
+ within a compunit. */
-#define ALL_COMPUNIT_FILETABS(cu, s) \
- for ((s) = (cu) -> filetabs; (s) != NULL; (s) = (s) -> next)
+struct compunit_filetabs : public next_adapter<struct symtab>
+{
+ compunit_filetabs (struct compunit_symtab *cu)
+ : next_adapter<struct symtab> (cu->filetabs)
+ {
+ }
+};
/* Return the primary symtab of CUST. */
extern enum language compunit_language (const struct compunit_symtab *cust);
-typedef struct compunit_symtab *compunit_symtab_ptr;
-DEF_VEC_P (compunit_symtab_ptr);
-
\f
/* The virtual function table is now an array of structures which have the
const char *multiple_symbols_select_mode (void);
-int symbol_matches_domain (enum language symbol_language,
- domain_enum symbol_domain,
- domain_enum domain);
+bool symbol_matches_domain (enum language symbol_language,
+ domain_enum symbol_domain,
+ domain_enum domain);
/* lookup a symbol table by source file name. */
/* from blockframe.c: */
-/* lookup the function symbol corresponding to the address. */
+/* lookup the function symbol corresponding to the address. The
+ return value will not be an inlined function; the containing
+ function will be returned instead. */
extern struct symbol *find_pc_function (CORE_ADDR);
-/* lookup the function corresponding to the address and section. */
+/* lookup the function corresponding to the address and section. The
+ return value will not be an inlined function; the containing
+ function will be returned instead. */
extern struct symbol *find_pc_sect_function (CORE_ADDR, struct obj_section *);
+/* lookup the function symbol corresponding to the address and
+ section. The return value will be the closest enclosing function,
+ which might be an inline function. */
+
+extern struct symbol *find_pc_sect_containing_function
+ (CORE_ADDR pc, struct obj_section *section);
+
/* Find the symbol at the given address. Returns NULL if no symbol
found. Only exact matches for ADDRESS are considered. */
extern struct symbol *find_symbol_at_address (CORE_ADDR);
-/* lookup function from address, return name, start addr and end addr. */
-
-extern int find_pc_partial_function (CORE_ADDR, const char **, CORE_ADDR *,
- CORE_ADDR *);
+/* Finds the "function" (text symbol) that is smaller than PC but
+ greatest of all of the potential text symbols in SECTION. Sets
+ *NAME and/or *ADDRESS conditionally if that pointer is non-null.
+ If ENDADDR is non-null, then set *ENDADDR to be the end of the
+ function (exclusive). If the optional parameter BLOCK is non-null,
+ then set *BLOCK to the address of the block corresponding to the
+ function symbol, if such a symbol could be found during the lookup;
+ nullptr is used as a return value for *BLOCK if no block is found.
+ This function either succeeds or fails (not halfway succeeds). If
+ it succeeds, it sets *NAME, *ADDRESS, and *ENDADDR to real
+ information and returns true. If it fails, it sets *NAME, *ADDRESS
+ and *ENDADDR to zero and returns false.
+
+ If the function in question occupies non-contiguous ranges,
+ *ADDRESS and *ENDADDR are (subject to the conditions noted above) set
+ to the start and end of the range in which PC is found. Thus
+ *ADDRESS <= PC < *ENDADDR with no intervening gaps (in which ranges
+ from other functions might be found).
+
+ This property allows find_pc_partial_function to be used (as it had
+ been prior to the introduction of non-contiguous range support) by
+ various tdep files for finding a start address and limit address
+ for prologue analysis. This still isn't ideal, however, because we
+ probably shouldn't be doing prologue analysis (in which
+ instructions are scanned to determine frame size and stack layout)
+ for any range that doesn't contain the entry pc. Moreover, a good
+ argument can be made that prologue analysis ought to be performed
+ starting from the entry pc even when PC is within some other range.
+ This might suggest that *ADDRESS and *ENDADDR ought to be set to the
+ limits of the entry pc range, but that will cause the
+ *ADDRESS <= PC < *ENDADDR condition to be violated; many of the
+ callers of find_pc_partial_function expect this condition to hold.
+
+ Callers which require the start and/or end addresses for the range
+ containing the entry pc should instead call
+ find_function_entry_range_from_pc. */
+
+extern bool find_pc_partial_function (CORE_ADDR pc, const char **name,
+ CORE_ADDR *address, CORE_ADDR *endaddr,
+ const struct block **block = nullptr);
+
+/* Like find_pc_partial_function, above, but *ADDRESS and *ENDADDR are
+ set to start and end addresses of the range containing the entry pc.
+
+ Note that it is not necessarily the case that (for non-NULL ADDRESS
+ and ENDADDR arguments) the *ADDRESS <= PC < *ENDADDR condition will
+ hold.
+
+ See comment for find_pc_partial_function, above, for further
+ explanation. */
+
+extern bool find_function_entry_range_from_pc (CORE_ADDR pc,
+ const char **name,
+ CORE_ADDR *address,
+ CORE_ADDR *endaddr);
/* Return the type of a function with its first instruction exactly at
the PC address. Return NULL otherwise. */
extern struct compunit_symtab *
find_pc_sect_compunit_symtab (CORE_ADDR, struct obj_section *);
-extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
+extern bool find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
extern void reread_symbols (void);
#define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
#endif
-extern int in_gnu_ifunc_stub (CORE_ADDR pc);
+extern bool in_gnu_ifunc_stub (CORE_ADDR pc);
/* Functions for resolving STT_GNU_IFUNC symbols which are implemented only
for ELF symbol files. */
CORE_ADDR (*gnu_ifunc_resolve_addr) (struct gdbarch *gdbarch, CORE_ADDR pc);
/* See elf_gnu_ifunc_resolve_name for its real implementation. */
- int (*gnu_ifunc_resolve_name) (const char *function_name,
+ bool (*gnu_ifunc_resolve_name) (const char *function_name,
CORE_ADDR *function_address_p);
/* See elf_gnu_ifunc_resolver_stop for its real implementation. */
/* Given a symtab and line number, return the pc there. */
-extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
+extern bool find_line_pc (struct symtab *, int, CORE_ADDR *);
-extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
- CORE_ADDR *);
+extern bool find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
+ CORE_ADDR *);
extern void resolve_sal_pc (struct symtab_and_line *);
extern void clear_solib (void);
-/* source.c */
-
-extern int identify_source_line (struct symtab *, int, int, CORE_ADDR);
-
-/* Flags passed as 4th argument to print_source_lines. */
-
-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,
- 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 *);
-
/* The reason we're calling into a completion match list collector
function. */
enum class complete_symbol_mode
/* symtab.c */
-int matching_obj_sections (struct obj_section *, struct obj_section *);
+bool matching_obj_sections (struct obj_section *, struct obj_section *);
-extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *);
+extern struct symtab *find_line_symtab (struct symtab *, int, int *, bool *);
/* Given a function symbol SYM, find the symtab and line for the start
of the function. If FUNFIRSTLINE is true, we want the first line
};
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
- of the calling code currently assumes that the string isn't
- const. */
-extern /*const */ char *main_name (void);
+ enum search_domain,
+ const char *,
+ int,
+ const char **,
+ bool);
+
+/* When searching for Fortran symbols within modules (functions/variables)
+ we return a vector of this type. The first item in the pair is the
+ module symbol, and the second item is the symbol for the function or
+ variable we found. */
+typedef std::pair<symbol_search, symbol_search> module_symbol_search;
+
+/* Searches the symbols to find function and variables symbols (depending
+ on KIND) within Fortran modules. The MODULE_REGEXP matches against the
+ name of the module, REGEXP matches against the name of the symbol within
+ the module, and TYPE_REGEXP matches against the type of the symbol
+ within the module. */
+extern std::vector<module_symbol_search> search_module_symbols
+ (const char *module_regexp, const char *regexp,
+ const char *type_regexp, search_domain kind);
+
+extern bool treg_matches_sym_type_name (const compiled_regex &treg,
+ const struct symbol *sym);
+
+/* The name of the ``main'' function. */
+extern const char *main_name ();
extern enum language main_language (void);
-/* Lookup symbol NAME from DOMAIN in MAIN_OBJFILE's global blocks.
+/* Lookup symbol NAME from DOMAIN in MAIN_OBJFILE's global or static blocks,
+ as specified by BLOCK_INDEX.
This searches MAIN_OBJFILE as well as any associated separate debug info
objfiles of MAIN_OBJFILE.
+ BLOCK_INDEX can be GLOBAL_BLOCK or STATIC_BLOCK.
Upon success fixes up the symbol's section if necessary. */
extern struct block_symbol
lookup_global_symbol_from_objfile (struct objfile *main_objfile,
+ enum block_enum block_index,
const char *name,
const domain_enum domain);
/* Return 1 if the supplied producer string matches the ARM RealView
compiler (armcc). */
-int producer_is_realview (const char *producer);
+bool producer_is_realview (const char *producer);
void fixup_section (struct general_symbol_info *ginfo,
CORE_ADDR addr, struct objfile *objfile);
extern unsigned int symbol_lookup_debug;
-extern int basenames_may_differ;
+extern bool basenames_may_differ;
-int compare_filenames_for_search (const char *filename,
- const char *search_name);
+bool compare_filenames_for_search (const char *filename,
+ const char *search_name);
-int compare_glob_filenames_for_search (const char *filename,
- const char *search_name);
+bool compare_glob_filenames_for_search (const char *filename,
+ const char *search_name);
bool iterate_over_some_symtabs (const char *name,
const char *real_path,
true to indicate that LA_ITERATE_OVER_SYMBOLS should continue
iterating, or false to indicate that the iteration should end. */
-typedef bool (symbol_found_callback_ftype) (symbol *sym);
+typedef bool (symbol_found_callback_ftype) (struct block_symbol *bsym);
+
+/* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
+
+ For each symbol that matches, CALLBACK is called. The symbol is
+ passed to the callback.
-void iterate_over_symbols (const struct block *block,
+ If CALLBACK returns false, the iteration ends and this function
+ returns false. Otherwise, the search continues, and the function
+ eventually returns true. */
+
+bool iterate_over_symbols (const struct block *block,
const lookup_name_info &name,
const domain_enum domain,
gdb::function_view<symbol_found_callback_ftype> callback);
+/* Like iterate_over_symbols, but if all calls to CALLBACK return
+ true, then calls CALLBACK one additional time with a block_symbol
+ that has a valid block but a NULL symbol. */
+
+bool iterate_over_symbols_terminated
+ (const struct block *block,
+ const lookup_name_info &name,
+ const domain_enum domain,
+ 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
const lookup_name_info &lookup_name,
const char *text, const char *word);
+/* A simple symbol searching class. */
+
+class symbol_searcher
+{
+public:
+ /* Returns the symbols found for the search. */
+ const std::vector<block_symbol> &
+ matching_symbols () const
+ {
+ return m_symbols;
+ }
+
+ /* Returns the minimal symbols found for the search. */
+ const std::vector<bound_minimal_symbol> &
+ matching_msymbols () const
+ {
+ return m_minimal_symbols;
+ }
+
+ /* Search for all symbols named NAME in LANGUAGE with DOMAIN, restricting
+ search to FILE_SYMTABS and SEARCH_PSPACE, both of which may be NULL
+ to search all symtabs and program spaces. */
+ void find_all_symbols (const std::string &name,
+ const struct language_defn *language,
+ enum search_domain search_domain,
+ std::vector<symtab *> *search_symtabs,
+ struct program_space *search_pspace);
+
+ /* Reset this object to perform another search. */
+ void reset ()
+ {
+ m_symbols.clear ();
+ m_minimal_symbols.clear ();
+ }
+
+private:
+ /* Matching debug symbols. */
+ std::vector<block_symbol> m_symbols;
+
+ /* Matching non-debug symbols. */
+ std::vector<bound_minimal_symbol> m_minimal_symbols;
+};
+
#endif /* !defined(SYMTAB_H) */
projects / binutils-gdb.git / blobdiff