#include "filename-seen-cache.h"
#include "arch-utils.h"
#include <algorithm>
+#include "gdbsupport/gdb_string_view.h"
#include "gdbsupport/pathstuff.h"
+#include "gdbsupport/common-utils.h"
/* Forward declarations for local functions. */
the original value from here. */
static unsigned int symbol_cache_size = DEFAULT_SYMBOL_CACHE_SIZE;
-/* Non-zero if a file may be known by two different basenames.
+/* True if a file may be known by two different basenames.
This is the uncommon case, and significantly slows down gdb.
Default set to "off" to not slow down the common case. */
-int basenames_may_differ = 0;
+bool basenames_may_differ = false;
/* Allow the user to configure the debugger behavior with respect
to multiple-choice menus when more than one symbol matches during
describes what we advertise). Returns true if they match, false
otherwise. */
-int
+bool
compare_filenames_for_search (const char *filename, const char *search_name)
{
int len = strlen (filename);
size_t search_len = strlen (search_name);
if (len < search_len)
- return 0;
+ return false;
/* The tail of FILENAME must match. */
if (FILENAME_CMP (filename + len - search_len, search_name) != 0)
- return 0;
+ return false;
/* Either the names must completely match, or the character
preceding the trailing SEARCH_NAME segment of FILENAME must be a
compare_filenames_for_search, but it's the opposite of the order of
arguments to gdb_filename_fnmatch. */
-int
+bool
compare_glob_filenames_for_search (const char *filename,
const char *search_name)
{
int search_path_elements = count_path_elements (search_name);
if (search_path_elements > file_path_elements)
- return 0;
+ return false;
if (IS_ABSOLUTE_PATH (search_name))
{
gdb_assert (IS_ABSOLUTE_PATH (real_path));
gdb_assert (IS_ABSOLUTE_PATH (name));
+ gdb::unique_xmalloc_ptr<char> fullname_real_path
+ = gdb_realpath (fullname);
+ fullname = fullname_real_path.get ();
if (FILENAME_CMP (real_path, fullname) == 0)
{
if (callback (s))
/* Objects of this type are stored in the demangled name hash table. */
struct demangled_name_entry
{
- const char *mangled;
- ENUM_BITFIELD(language) language : LANGUAGE_BITS;
- char demangled[1];
+ demangled_name_entry (gdb::string_view mangled_name)
+ : mangled (mangled_name) {}
+
+ gdb::string_view mangled;
+ enum language language;
+ gdb::unique_xmalloc_ptr<char> demangled;
};
/* Hash function for the demangled name hash. */
const struct demangled_name_entry *e
= (const struct demangled_name_entry *) data;
- return htab_hash_string (e->mangled);
+ return fast_hash (e->mangled.data (), e->mangled.length ());
}
/* Equality function for the demangled name hash. */
const struct demangled_name_entry *db
= (const struct demangled_name_entry *) b;
- return strcmp (da->mangled, db->mangled) == 0;
+ return da->mangled == db->mangled;
+}
+
+static void
+free_demangled_name_entry (void *data)
+{
+ struct demangled_name_entry *e
+ = (struct demangled_name_entry *) data;
+
+ e->~demangled_name_entry();
}
/* Create the hash table used for demangled names. Each hash entry is
per_bfd->demangled_names_hash.reset (htab_create_alloc
(256, hash_demangled_name_entry, eq_demangled_name_entry,
- NULL, xcalloc, xfree));
+ free_demangled_name_entry, xcalloc, xfree));
}
/* Try to determine the demangled name for a symbol, based on the
void
symbol_set_names (struct general_symbol_info *gsymbol,
- const char *linkage_name, int len, int copy_name,
+ const char *linkage_name, int len, bool copy_name,
struct objfile_per_bfd_storage *per_bfd)
{
struct demangled_name_entry **slot;
- /* A 0-terminated copy of the linkage name. */
- const char *linkage_name_copy;
- struct demangled_name_entry entry;
if (gsymbol->language == language_ada)
{
if (per_bfd->demangled_names_hash == NULL)
create_demangled_names_hash (per_bfd);
- if (linkage_name[len] != '\0')
- {
- char *alloc_name;
-
- alloc_name = (char *) alloca (len + 1);
- memcpy (alloc_name, linkage_name, len);
- alloc_name[len] = '\0';
-
- linkage_name_copy = alloc_name;
- }
- else
- linkage_name_copy = linkage_name;
-
- entry.mangled = linkage_name_copy;
+ struct demangled_name_entry entry (gdb::string_view (linkage_name, len));
slot = ((struct demangled_name_entry **)
htab_find_slot (per_bfd->demangled_names_hash.get (),
&entry, INSERT));
if (*slot == NULL
/* A C version of the symbol may have already snuck into the table.
This happens to, e.g., main.init (__go_init_main). Cope. */
- || (gsymbol->language == language_go
- && (*slot)->demangled[0] == '\0'))
+ || (gsymbol->language == language_go && (*slot)->demangled == nullptr))
{
- char *demangled_name_ptr
- = symbol_find_demangled_name (gsymbol, linkage_name_copy);
- gdb::unique_xmalloc_ptr<char> demangled_name (demangled_name_ptr);
- int demangled_len = demangled_name ? strlen (demangled_name.get ()) : 0;
+ /* A 0-terminated copy of the linkage name. Callers must set COPY_NAME
+ to true if the string might not be nullterminated. We have to make
+ this copy because demangling needs a nullterminated string. */
+ const char *linkage_name_copy;
+ if (copy_name)
+ {
+ char *alloc_name = (char *) alloca (len + 1);
+ memcpy (alloc_name, linkage_name, len);
+ alloc_name[len] = '\0';
+
+ linkage_name_copy = alloc_name;
+ }
+ else
+ linkage_name_copy = linkage_name;
+
+ gdb::unique_xmalloc_ptr<char> demangled_name_ptr
+ (symbol_find_demangled_name (gsymbol, linkage_name_copy));
/* Suppose we have demangled_name==NULL, copy_name==0, and
linkage_name_copy==linkage_name. In this case, we already have the
mangled name saved, and we don't have a demangled name. So,
you might think we could save a little space by not recording
this in the hash table at all.
-
+
It turns out that it is actually important to still save such
an entry in the hash table, because storing this name gives
us better bcache hit rates for partial symbols. */
- if (!copy_name && linkage_name_copy == linkage_name)
+ if (!copy_name)
{
*slot
= ((struct demangled_name_entry *)
obstack_alloc (&per_bfd->storage_obstack,
- offsetof (struct demangled_name_entry, demangled)
- + demangled_len + 1));
- (*slot)->mangled = linkage_name;
+ sizeof (demangled_name_entry)));
+ new (*slot) demangled_name_entry
+ (gdb::string_view (linkage_name, len));
}
else
{
- char *mangled_ptr;
-
/* If we must copy the mangled name, put it directly after
- the demangled name so we can have a single
- allocation. */
+ the struct so we can have a single allocation. */
*slot
= ((struct demangled_name_entry *)
obstack_alloc (&per_bfd->storage_obstack,
- offsetof (struct demangled_name_entry, demangled)
- + len + demangled_len + 2));
- mangled_ptr = &((*slot)->demangled[demangled_len + 1]);
- strcpy (mangled_ptr, linkage_name_copy);
- (*slot)->mangled = mangled_ptr;
+ sizeof (demangled_name_entry) + len + 1));
+ char *mangled_ptr = reinterpret_cast<char *> (*slot + 1);
+ memcpy (mangled_ptr, linkage_name, len);
+ mangled_ptr [len] = '\0';
+ new (*slot) demangled_name_entry
+ (gdb::string_view (mangled_ptr, len));
}
+ (*slot)->demangled = std::move (demangled_name_ptr);
(*slot)->language = gsymbol->language;
-
- if (demangled_name != NULL)
- strcpy ((*slot)->demangled, demangled_name.get ());
- else
- (*slot)->demangled[0] = '\0';
}
else if (gsymbol->language == language_unknown
|| gsymbol->language == language_auto)
gsymbol->language = (*slot)->language;
- gsymbol->name = (*slot)->mangled;
- if ((*slot)->demangled[0] != '\0')
- symbol_set_demangled_name (gsymbol, (*slot)->demangled,
+ gsymbol->name = (*slot)->mangled.data ();
+ if ((*slot)->demangled != nullptr)
+ symbol_set_demangled_name (gsymbol, (*slot)->demangled.get (),
&per_bfd->storage_obstack);
else
symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack);
\f
-/* Return 1 if the two sections are the same, or if they could
+/* Return true if the two sections are the same, or if they could
plausibly be copies of each other, one in an original object
file and another in a separated debug file. */
-int
+bool
matching_obj_sections (struct obj_section *obj_first,
struct obj_section *obj_second)
{
/* If they're the same section, then they match. */
if (first == second)
- return 1;
+ return true;
/* If either is NULL, give up. */
if (first == NULL || second == NULL)
- return 0;
+ return false;
/* This doesn't apply to absolute symbols. */
if (first->owner == NULL || second->owner == NULL)
- return 0;
+ return false;
/* If they're in the same object file, they must be different sections. */
if (first->owner == second->owner)
- return 0;
+ return false;
/* Check whether the two sections are potentially corresponding. They must
have the same size, address, and name. We can't compare section indexes,
which would be more reliable, because some sections may have been
stripped. */
- if (bfd_get_section_size (first) != bfd_get_section_size (second))
- return 0;
+ if (bfd_section_size (first) != bfd_section_size (second))
+ return false;
/* In-memory addresses may start at a different offset, relativize them. */
- if (bfd_get_section_vma (first->owner, first)
- - bfd_get_start_address (first->owner)
- != bfd_get_section_vma (second->owner, second)
- - bfd_get_start_address (second->owner))
- return 0;
+ if (bfd_section_vma (first) - bfd_get_start_address (first->owner)
+ != bfd_section_vma (second) - bfd_get_start_address (second->owner))
+ return false;
- if (bfd_get_section_name (first->owner, first) == NULL
- || bfd_get_section_name (second->owner, second) == NULL
- || strcmp (bfd_get_section_name (first->owner, first),
- bfd_get_section_name (second->owner, second)) != 0)
- return 0;
+ if (bfd_section_name (first) == NULL
+ || bfd_section_name (second) == NULL
+ || strcmp (bfd_section_name (first), bfd_section_name (second)) != 0)
+ return false;
/* Otherwise check that they are in corresponding objfiles. */
if (obj->separate_debug_objfile != NULL
&& obj->separate_debug_objfile->obfd == second->owner)
- return 1;
+ return true;
if (obj->separate_debug_objfile_backlink != NULL
&& obj->separate_debug_objfile_backlink->obfd == second->owner)
- return 1;
+ return true;
- return 0;
+ return false;
}
/* See symtab.h. */
The result is the symbol if found, SYMBOL_LOOKUP_FAILED if a previous lookup
failed (and thus this one will too), or NULL if the symbol is not present
in the cache.
- If the symbol is not present in the cache, then *BSC_PTR and *SLOT_PTR are
- set to the cache and slot of the symbol to save the result of a full lookup
- attempt. */
+ *BSC_PTR and *SLOT_PTR are set to the cache and slot of the symbol, which
+ can be used to save the result of a full lookup attempt. */
static struct block_symbol
symbol_cache_lookup (struct symbol_cache *cache,
hash = hash_symbol_entry (objfile_context, name, domain);
slot = bsc->symbols + hash % bsc->size;
+ *bsc_ptr = bsc;
+ *slot_ptr = slot;
+
if (eq_symbol_entry (slot, objfile_context, name, domain))
{
if (symbol_lookup_debug)
/* Symbol is not present in the cache. */
- *bsc_ptr = bsc;
- *slot_ptr = slot;
-
if (symbol_lookup_debug)
{
fprintf_unfiltered (gdb_stdlog,
{
struct block_symbol result;
- /* NOTE: carlton/2003-05-19: The comments below were written when
- this (or what turned into this) was part of lookup_symbol_aux;
- I'm much less worried about these questions now, since these
- decisions have turned out well, but I leave these comments here
- for posterity. */
-
- /* NOTE: carlton/2002-12-05: There is a question as to whether or
- not it would be appropriate to search the current global block
- here as well. (That's what this code used to do before the
- is_a_field_of_this check was moved up.) On the one hand, it's
- redundant with the lookup in all objfiles search that happens
- next. On the other hand, if decode_line_1 is passed an argument
- like filename:var, then the user presumably wants 'var' to be
- searched for in filename. On the third hand, there shouldn't be
- multiple global variables all of which are named 'var', and it's
- not like decode_line_1 has ever restricted its search to only
- global variables in a single filename. All in all, only
- searching the static block here seems best: it's correct and it's
- cleanest. */
-
- /* NOTE: carlton/2002-12-05: There's also a possible performance
- issue here: if you usually search for global symbols in the
- current file, then it would be slightly better to search the
- current global block before searching all the symtabs. But there
- are other factors that have a much greater effect on performance
- than that one, so I don't think we should worry about that for
- now. */
-
/* NOTE: dje/2014-10-26: The lookup in all objfiles search could skip
the current objfile. Searching the current objfile first is useful
for both matching user expectations as well as performance. */
return result;
}
-/* See symtab.h. */
-
-struct block_symbol
-lookup_static_symbol (const char *name, const domain_enum domain)
-{
- struct symbol_cache *cache = get_symbol_cache (current_program_space);
- struct block_symbol result;
- struct block_symbol_cache *bsc;
- struct symbol_cache_slot *slot;
-
- /* Lookup in STATIC_BLOCK is not current-objfile-dependent, so just pass
- NULL for OBJFILE_CONTEXT. */
- result = symbol_cache_lookup (cache, NULL, STATIC_BLOCK, name, domain,
- &bsc, &slot);
- if (result.symbol != NULL)
- {
- if (SYMBOL_LOOKUP_FAILED_P (result))
- return {};
- return result;
- }
-
- for (objfile *objfile : current_program_space->objfiles ())
- {
- result = lookup_symbol_in_objfile (objfile, STATIC_BLOCK, name, domain);
- if (result.symbol != NULL)
- {
- /* Still pass NULL for OBJFILE_CONTEXT here. */
- symbol_cache_mark_found (bsc, slot, NULL, result.symbol,
- result.block);
- return result;
- }
- }
-
- /* Still pass NULL for OBJFILE_CONTEXT here. */
- symbol_cache_mark_not_found (bsc, slot, NULL, name, domain);
- return {};
-}
-
/* Private data to be used with lookup_symbol_global_iterator_cb. */
-struct global_sym_lookup_data
+struct global_or_static_sym_lookup_data
{
/* The name of the symbol we are searching for. */
const char *name;
/* The domain to use for our search. */
domain_enum domain;
+ /* The block index in which to search. */
+ enum block_enum block_index;
+
/* The field where the callback should store the symbol if found.
It should be initialized to {NULL, NULL} before the search is started. */
struct block_symbol result;
};
/* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
- It searches by name for a symbol in the GLOBAL_BLOCK of the given
- OBJFILE. The arguments for the search are passed via CB_DATA,
- which in reality is a pointer to struct global_sym_lookup_data. */
+ It searches by name for a symbol in the block given by BLOCK_INDEX of the
+ given OBJFILE. The arguments for the search are passed via CB_DATA, which
+ in reality is a pointer to struct global_or_static_sym_lookup_data. */
static int
-lookup_symbol_global_iterator_cb (struct objfile *objfile,
- void *cb_data)
+lookup_symbol_global_or_static_iterator_cb (struct objfile *objfile,
+ void *cb_data)
{
- struct global_sym_lookup_data *data =
- (struct global_sym_lookup_data *) cb_data;
+ struct global_or_static_sym_lookup_data *data =
+ (struct global_or_static_sym_lookup_data *) cb_data;
gdb_assert (data->result.symbol == NULL
&& data->result.block == NULL);
- data->result = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK,
+ data->result = lookup_symbol_in_objfile (objfile, data->block_index,
data->name, data->domain);
/* If we found a match, tell the iterator to stop. Otherwise,
return (data->result.symbol != NULL);
}
-/* See symtab.h. */
+/* This function contains the common code of lookup_{global,static}_symbol.
+ OBJFILE is only used if BLOCK_INDEX is GLOBAL_SCOPE, in which case it is
+ the objfile to start the lookup in. */
-struct block_symbol
-lookup_global_symbol (const char *name,
- const struct block *block,
- const domain_enum domain)
+static struct block_symbol
+lookup_global_or_static_symbol (const char *name,
+ enum block_enum block_index,
+ struct objfile *objfile,
+ const domain_enum domain)
{
struct symbol_cache *cache = get_symbol_cache (current_program_space);
struct block_symbol result;
- struct objfile *objfile;
- struct global_sym_lookup_data lookup_data;
+ struct global_or_static_sym_lookup_data lookup_data;
struct block_symbol_cache *bsc;
struct symbol_cache_slot *slot;
- objfile = lookup_objfile_from_block (block);
+ gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
+ gdb_assert (objfile == nullptr || block_index == GLOBAL_BLOCK);
/* First see if we can find the symbol in the cache.
This works because we use the current objfile to qualify the lookup. */
- result = symbol_cache_lookup (cache, objfile, GLOBAL_BLOCK, name, domain,
+ result = symbol_cache_lookup (cache, objfile, block_index, name, domain,
&bsc, &slot);
if (result.symbol != NULL)
{
return result;
}
- /* Call library-specific lookup procedure. */
- if (objfile != NULL)
- result = solib_global_lookup (objfile, name, domain);
-
- /* If that didn't work go a global search (of global blocks, heh). */
+ /* Do a global search (of global blocks, heh). */
if (result.symbol == NULL)
{
memset (&lookup_data, 0, sizeof (lookup_data));
lookup_data.name = name;
+ lookup_data.block_index = block_index;
lookup_data.domain = domain;
gdbarch_iterate_over_objfiles_in_search_order
(objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (),
- lookup_symbol_global_iterator_cb, &lookup_data, objfile);
+ lookup_symbol_global_or_static_iterator_cb, &lookup_data, objfile);
result = lookup_data.result;
}
return result;
}
-int
+/* See symtab.h. */
+
+struct block_symbol
+lookup_static_symbol (const char *name, const domain_enum domain)
+{
+ return lookup_global_or_static_symbol (name, STATIC_BLOCK, nullptr, domain);
+}
+
+/* See symtab.h. */
+
+struct block_symbol
+lookup_global_symbol (const char *name,
+ const struct block *block,
+ const domain_enum domain)
+{
+ /* If a block was passed in, we want to search the corresponding
+ global block first. This yields "more expected" behavior, and is
+ needed to support 'FILENAME'::VARIABLE lookups. */
+ const struct block *global_block = block_global_block (block);
+ if (global_block != nullptr)
+ {
+ symbol *sym = lookup_symbol_in_block (name,
+ symbol_name_match_type::FULL,
+ global_block, domain);
+ if (sym != nullptr)
+ return { sym, global_block };
+ }
+
+ struct objfile *objfile = lookup_objfile_from_block (block);
+ return lookup_global_or_static_symbol (name, GLOBAL_BLOCK, objfile, domain);
+}
+
+bool
symbol_matches_domain (enum language symbol_language,
domain_enum symbol_domain,
domain_enum domain)
{
if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
&& symbol_domain == STRUCT_DOMAIN)
- return 1;
+ return true;
}
/* For all other languages, strict match is required. */
return (symbol_domain == domain);
return (struct type *) 0;
}
-/* 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.
-
- If CALLBACK returns false, the iteration ends. Otherwise, the
- search continues. */
+/* See symtab.h. */
-void
+bool
iterate_over_symbols (const struct block *block,
const lookup_name_info &name,
const domain_enum domain,
struct block_symbol block_sym = {sym, block};
if (!callback (&block_sym))
- return;
+ return false;
}
}
+ return true;
+}
+
+/* See symtab.h. */
+
+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)
+{
+ if (!iterate_over_symbols (block, name, domain, callback))
+ return false;
+ struct block_symbol block_sym = {nullptr, block};
+ return callback (&block_sym);
}
/* Find the compunit symtab associated with PC and SECTION.
If found, return the symtab that contains the linetable in which it was
found, set *INDEX to the index in the linetable of the best entry
- found, and set *EXACT_MATCH nonzero if the value returned is an
+ found, and set *EXACT_MATCH to true if the value returned is an
exact match.
If not found, return NULL. */
struct symtab *
find_line_symtab (struct symtab *sym_tab, int line,
- int *index, int *exact_match)
+ int *index, bool *exact_match)
{
int exact = 0; /* Initialized here to avoid a compiler warning. */
if (index)
*index = best_index;
if (exact_match)
- *exact_match = exact;
+ *exact_match = (exact != 0);
return best_symtab;
}
\f
/* Set the PC value for a given source file and line number and return true.
- Returns zero for invalid line number (and sets the PC to 0).
+ Returns false for invalid line number (and sets the PC to 0).
The source file is specified with a struct symtab. */
-int
+bool
find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
{
struct linetable *l;
*pc = 0;
if (symtab == 0)
- return 0;
+ return false;
symtab = find_line_symtab (symtab, line, &ind, NULL);
if (symtab != NULL)
{
l = SYMTAB_LINETABLE (symtab);
*pc = l->item[ind].pc;
- return 1;
+ return true;
}
else
- return 0;
+ return false;
}
/* Find the range of pc values in a line.
Store the starting pc of the line into *STARTPTR
and the ending pc (start of next line) into *ENDPTR.
- Returns 1 to indicate success.
- Returns 0 if could not find the specified line. */
+ Returns true to indicate success.
+ Returns false if could not find the specified line. */
-int
+bool
find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr,
CORE_ADDR *endptr)
{
startaddr = sal.pc;
if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
- return 0;
+ return false;
/* This whole function is based on address. For example, if line 10 has
two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
*startptr = found_sal.pc;
*endptr = found_sal.end;
}
- return 1;
+ return true;
}
/* Given a line table and a line number, return the index into the line
return best_index;
}
-int
+bool
find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
{
struct symtab_and_line sal;
}
else
{
- /* Gratuitous qoute: skip it and move on. */
+ /* Gratuitous quote: skip it and move on. */
p++;
continue;
}
struct filename_partial_match_opts
{
/* Only match the directory name part. */
- int dirname = false;
+ bool dirname = false;
/* Only match the basename part. */
- int basename = false;
+ bool basename = false;
};
/* Data structure to maintain printing state for output_source_filename. */
Within each file the results are sorted locally; each symtab's global and
static blocks are separately alphabetized.
- Duplicate entries are removed. */
+ Duplicate entries are removed.
+
+ When EXCLUDE_MINSYMS is false then matching minsyms are also returned,
+ otherwise they are excluded. */
std::vector<symbol_search>
search_symbols (const char *regexp, enum search_domain kind,
const char *t_regexp,
- int nfiles, const char *files[])
+ int nfiles, const char *files[],
+ bool exclude_minsyms)
{
const struct blockvector *bv;
const struct block *b;
|| treg_matches_sym_type_name (*treg,
sym)))
|| (kind == TYPES_DOMAIN
- && SYMBOL_CLASS (sym) == LOC_TYPEDEF))))
+ && SYMBOL_CLASS (sym) == LOC_TYPEDEF
+ && SYMBOL_DOMAIN (sym) != MODULE_DOMAIN))))
{
/* match */
result.emplace_back (i, sym);
as we assume that a minimal symbol does not have a type. */
if ((found_misc || (nfiles == 0 && kind != FUNCTIONS_DOMAIN))
+ && !exclude_minsyms
&& !treg.has_value ())
{
for (objfile *objfile : current_program_space->objfiles ())
if (filename_cmp (last, s_filename) != 0)
{
- fputs_filtered ("\nFile ", gdb_stdout);
- fputs_styled (s_filename, file_name_style.style (), gdb_stdout);
- fputs_filtered (":\n", gdb_stdout);
+ printf_filtered (_("\nFile %ps:\n"),
+ styled_string (file_name_style.style (),
+ s_filename));
}
if (SYMBOL_LINE (sym) != 0)
else
tmp = hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol),
16);
- fputs_styled (tmp, address_style.style (), gdb_stdout);
- fputs_filtered (" ", gdb_stdout);
- if (msymbol.minsym->text_p ())
- fputs_styled (MSYMBOL_PRINT_NAME (msymbol.minsym),
- function_name_style.style (),
- gdb_stdout);
- else
- fputs_filtered (MSYMBOL_PRINT_NAME (msymbol.minsym), gdb_stdout);
- fputs_filtered ("\n", gdb_stdout);
+
+ ui_file_style sym_style = (msymbol.minsym->text_p ()
+ ? function_name_style.style ()
+ : ui_file_style ());
+
+ printf_filtered (_("%ps %ps\n"),
+ styled_string (address_style.style (), tmp),
+ styled_string (sym_style,
+ MSYMBOL_PRINT_NAME (msymbol.minsym)));
}
/* This is the guts of the commands "info functions", "info types", and
matches. */
static void
-symtab_symbol_info (bool quiet,
+symtab_symbol_info (bool quiet, bool exclude_minsyms,
const char *regexp, enum search_domain kind,
const char *t_regexp, int from_tty)
{
/* Must make sure that if we're interrupted, symbols gets freed. */
std::vector<symbol_search> symbols = search_symbols (regexp, kind,
- t_regexp, 0, NULL);
+ t_regexp, 0, NULL,
+ exclude_minsyms);
if (!quiet)
{
}
}
+/* Structure to hold the values of the options used by the 'info variables'
+ and 'info functions' commands. These correspond to the -q, -t, and -n
+ options. */
+
+struct info_print_options
+{
+ bool quiet = false;
+ bool exclude_minsyms = false;
+ char *type_regexp = nullptr;
+
+ ~info_print_options ()
+ {
+ xfree (type_regexp);
+ }
+};
+
+/* The options used by the 'info variables' and 'info functions'
+ commands. */
+
+static const gdb::option::option_def info_print_options_defs[] = {
+ gdb::option::boolean_option_def<info_print_options> {
+ "q",
+ [] (info_print_options *opt) { return &opt->quiet; },
+ nullptr, /* show_cmd_cb */
+ nullptr /* set_doc */
+ },
+
+ gdb::option::boolean_option_def<info_print_options> {
+ "n",
+ [] (info_print_options *opt) { return &opt->exclude_minsyms; },
+ nullptr, /* show_cmd_cb */
+ nullptr /* set_doc */
+ },
+
+ gdb::option::string_option_def<info_print_options> {
+ "t",
+ [] (info_print_options *opt) { return &opt->type_regexp; },
+ nullptr, /* show_cmd_cb */
+ nullptr /* set_doc */
+ }
+};
+
+/* Returns the option group used by 'info variables' and 'info
+ functions'. */
+
+static gdb::option::option_def_group
+make_info_print_options_def_group (info_print_options *opts)
+{
+ return {{info_print_options_defs}, opts};
+}
+
+/* Command completer for 'info variables' and 'info functions'. */
+
+static void
+info_print_command_completer (struct cmd_list_element *ignore,
+ completion_tracker &tracker,
+ const char *text, const char * /* word */)
+{
+ const auto group
+ = make_info_print_options_def_group (nullptr);
+ if (gdb::option::complete_options
+ (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
+ return;
+
+ const char *word = advance_to_expression_complete_word_point (tracker, text);
+ symbol_completer (ignore, tracker, text, word);
+}
+
/* Implement the 'info variables' command. */
static void
info_variables_command (const char *args, int from_tty)
{
info_print_options opts;
- extract_info_print_options (&opts, &args);
+ auto grp = make_info_print_options_def_group (&opts);
+ gdb::option::process_options
+ (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
+ if (args != nullptr && *args == '\0')
+ args = nullptr;
- symtab_symbol_info (opts.quiet, args, VARIABLES_DOMAIN,
+ symtab_symbol_info (opts.quiet, opts.exclude_minsyms, args, VARIABLES_DOMAIN,
opts.type_regexp, from_tty);
}
info_functions_command (const char *args, int from_tty)
{
info_print_options opts;
- extract_info_print_options (&opts, &args);
+ auto grp = make_info_print_options_def_group (&opts);
+ gdb::option::process_options
+ (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
+ if (args != nullptr && *args == '\0')
+ args = nullptr;
- symtab_symbol_info (opts.quiet, args, FUNCTIONS_DOMAIN,
- opts.type_regexp, from_tty);
+ symtab_symbol_info (opts.quiet, opts.exclude_minsyms, args,
+ FUNCTIONS_DOMAIN, opts.type_regexp, from_tty);
}
/* Holds the -q option for the 'info types' command. */
struct info_types_options
{
- int quiet = false;
+ bool quiet = false;
};
/* The options used by the 'info types' command. */
(&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
if (args != nullptr && *args == '\0')
args = nullptr;
- symtab_symbol_info (opts.quiet, args, TYPES_DOMAIN, NULL, from_tty);
+ symtab_symbol_info (opts.quiet, false, args, TYPES_DOMAIN, NULL, from_tty);
}
/* Command completer for 'info types' command. */
std::vector<symbol_search> symbols = search_symbols (regexp,
FUNCTIONS_DOMAIN,
NULL,
- nfiles, files);
+ nfiles, files,
+ false);
scoped_rbreak_breakpoints finalize;
for (const symbol_search &p : symbols)
/* Return 1 if the supplied producer string matches the ARM RealView
compiler (armcc). */
-int
+bool
producer_is_realview (const char *producer)
{
static const char *const arm_idents[] = {
int i;
if (producer == NULL)
- return 0;
+ return false;
for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
if (startswith (producer, arm_idents[i]))
- return 1;
+ return true;
- return 0;
+ return false;
}
\f
symbol->owner.symtab = symtab;
}
+/* See symtab.h. */
+
+CORE_ADDR
+get_symbol_address (const struct symbol *sym)
+{
+ gdb_assert (sym->maybe_copied);
+ gdb_assert (SYMBOL_CLASS (sym) == LOC_STATIC);
+
+ const char *linkage_name = SYMBOL_LINKAGE_NAME (sym);
+
+ for (objfile *objfile : current_program_space->objfiles ())
+ {
+ bound_minimal_symbol minsym
+ = lookup_minimal_symbol_linkage (linkage_name, objfile);
+ if (minsym.minsym != nullptr)
+ return BMSYMBOL_VALUE_ADDRESS (minsym);
+ }
+ return sym->ginfo.value.address;
+}
+
+/* See symtab.h. */
+
+CORE_ADDR
+get_msymbol_address (struct objfile *objf, const struct minimal_symbol *minsym)
+{
+ gdb_assert (minsym->maybe_copied);
+ gdb_assert ((objf->flags & OBJF_MAINLINE) == 0);
+
+ const char *linkage_name = MSYMBOL_LINKAGE_NAME (minsym);
+
+ for (objfile *objfile : current_program_space->objfiles ())
+ {
+ if ((objfile->flags & OBJF_MAINLINE) != 0)
+ {
+ bound_minimal_symbol found
+ = lookup_minimal_symbol_linkage (linkage_name, objfile);
+ if (found.minsym != nullptr)
+ return BMSYMBOL_VALUE_ADDRESS (found);
+ }
+ }
+ return (minsym->value.address
+ + ANOFFSET (objf->section_offsets, minsym->section));
+}
+
\f
void
c = add_info ("variables", info_variables_command,
info_print_args_help (_("\
All global and static variable names or those matching REGEXPs.\n\
-Usage: info variables [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
+Usage: info variables [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\
Prints the global and static variables.\n"),
- _("global and static variables")));
+ _("global and static variables"),
+ true));
set_cmd_completer_handle_brkchars (c, info_print_command_completer);
if (dbx_commands)
{
c = add_com ("whereis", class_info, info_variables_command,
info_print_args_help (_("\
All global and static variable names, or those matching REGEXPs.\n\
-Usage: whereis [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
+Usage: whereis [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\
Prints the global and static variables.\n"),
- _("global and static variables")));
+ _("global and static variables"),
+ true));
set_cmd_completer_handle_brkchars (c, info_print_command_completer);
}
c = add_info ("functions", info_functions_command,
info_print_args_help (_("\
All function names or those matching REGEXPs.\n\
-Usage: info functions [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
+Usage: info functions [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\
Prints the functions.\n"),
- _("functions")));
+ _("functions"),
+ true));
set_cmd_completer_handle_brkchars (c, info_print_command_completer);
c = add_info ("types", info_types_command, _("\
projects / deliverable / binutils-gdb.git / blobdiff