/* Symbol table lookup for the GNU debugger, GDB.
- Copyright (C) 1986-2021 Free Software Foundation, Inc.
+ Copyright (C) 1986-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include "symfile.h"
#include "objfiles.h"
#include "gdbcmd.h"
-#include "gdb_regex.h"
+#include "gdbsupport/gdb_regex.h"
#include "expression.h"
#include "language.h"
#include "demangle.h"
#include "hashtab.h"
#include "typeprint.h"
-#include "gdb_obstack.h"
+#include "gdbsupport/gdb_obstack.h"
#include "block.h"
#include "dictionary.h"
/* Program space key for finding name and language of "main". */
-static const program_space_key<main_info> main_progspace_key;
+static const registry<program_space>::key<main_info> main_progspace_key;
/* The default symbol cache size.
There is no extra cpu cost for large N (except when flushing the cache,
/* Program space key for finding its symbol cache. */
-static const program_space_key<symbol_cache> symbol_cache_key;
+static const registry<program_space>::key<symbol_cache> symbol_cache_key;
/* When non-zero, print debugging messages related to symtab creation. */
unsigned int symtab_create_debug = 0;
};
static const char *multiple_symbols_mode = multiple_symbols_all;
+/* When TRUE, ignore the prologue-end flag in linetable_entry when searching
+ for the SAL past a function prologue. */
+static bool ignore_prologue_end_flag = false;
+
/* Read-only accessor to AUTO_SELECT_MODE. */
const char *
/* See symtab.h. */
+call_site *
+compunit_symtab::find_call_site (CORE_ADDR pc) const
+{
+ if (m_call_site_htab == nullptr)
+ return nullptr;
+
+ CORE_ADDR delta
+ = this->objfile ()->section_offsets[this->block_line_section ()];
+ CORE_ADDR unrelocated_pc = pc - delta;
+
+ struct call_site call_site_local (unrelocated_pc, nullptr, nullptr);
+ void **slot
+ = htab_find_slot (m_call_site_htab, &call_site_local, NO_INSERT);
+ if (slot == nullptr)
+ return nullptr;
+
+ return (call_site *) *slot;
+}
+
+/* See symtab.h. */
+
+void
+compunit_symtab::set_call_site_htab (htab_t call_site_htab)
+{
+ gdb_assert (m_call_site_htab == nullptr);
+ m_call_site_htab = call_site_htab;
+}
+
+/* See symtab.h. */
+
+void
+compunit_symtab::set_primary_filetab (symtab *primary_filetab)
+{
+ symtab *prev_filetab = nullptr;
+
+ /* Move PRIMARY_FILETAB to the head of the filetab list. */
+ for (symtab *filetab : this->filetabs ())
+ {
+ if (filetab == primary_filetab)
+ {
+ if (prev_filetab != nullptr)
+ {
+ prev_filetab->next = primary_filetab->next;
+ primary_filetab->next = m_filetabs;
+ m_filetabs = primary_filetab;
+ }
+
+ break;
+ }
+
+ prev_filetab = filetab;
+ }
+
+ gdb_assert (primary_filetab == m_filetabs);
+}
+
+/* See symtab.h. */
+
struct symtab *
-compunit_primary_filetab (const struct compunit_symtab *cust)
+compunit_symtab::primary_filetab () const
{
- gdb_assert (COMPUNIT_FILETABS (cust) != NULL);
+ gdb_assert (m_filetabs != nullptr);
/* The primary file symtab is the first one in the list. */
- return COMPUNIT_FILETABS (cust);
+ return m_filetabs;
}
/* See symtab.h. */
enum language
-compunit_language (const struct compunit_symtab *cust)
+compunit_symtab::language () const
{
- struct symtab *symtab = compunit_primary_filetab (cust);
+ struct symtab *symtab = primary_filetab ();
-/* The language of the compunit symtab is the language of its primary
- source file. */
- return SYMTAB_LANGUAGE (symtab);
+ /* The language of the compunit symtab is the language of its
+ primary source file. */
+ return symtab->language ();
+}
+
+/* The relocated address of the minimal symbol, using the section
+ offsets from OBJFILE. */
+
+CORE_ADDR
+minimal_symbol::value_address (objfile *objfile) const
+{
+ if (this->maybe_copied)
+ return get_msymbol_address (objfile, this);
+ else
+ return (this->value_raw_address ()
+ + objfile->section_offsets[this->section_index ()]);
}
/* See symtab.h. */
bool
minimal_symbol::data_p () const
{
- return type == mst_data
- || type == mst_bss
- || type == mst_abs
- || type == mst_file_data
- || type == mst_file_bss;
+ return m_type == mst_data
+ || m_type == mst_bss
+ || m_type == mst_abs
+ || m_type == mst_file_data
+ || m_type == mst_file_bss;
}
/* See symtab.h. */
bool
minimal_symbol::text_p () const
{
- return type == mst_text
- || type == mst_text_gnu_ifunc
- || type == mst_data_gnu_ifunc
- || type == mst_slot_got_plt
- || type == mst_solib_trampoline
- || type == mst_file_text;
+ return m_type == mst_text
+ || m_type == mst_text_gnu_ifunc
+ || m_type == mst_data_gnu_ifunc
+ || m_type == mst_slot_got_plt
+ || m_type == mst_solib_trampoline
+ || m_type == mst_file_text;
}
/* See whether FILENAME matches SEARCH_NAME using the rule that we
for (cust = first; cust != NULL && cust != after_last; cust = cust->next)
{
- for (symtab *s : compunit_filetabs (cust))
+ for (symtab *s : cust->filetabs ())
{
if (compare_filenames_for_search (s->filename, name))
{
/* See symtab.h */
-char *
+gdb::unique_xmalloc_ptr<char>
symbol_find_demangled_name (struct general_symbol_info *gsymbol,
const char *mangled)
{
- char *demangled = NULL;
+ gdb::unique_xmalloc_ptr<char> demangled;
int i;
if (gsymbol->language () == language_unknown)
linkage_name_copy = linkage_name;
if (demangled_name.get () == nullptr)
- demangled_name.reset
- (symbol_find_demangled_name (this, linkage_name_copy.data ()));
+ demangled_name
+ = symbol_find_demangled_name (this, linkage_name_copy.data ());
/* Suppose we have demangled_name==NULL, copy_name==0, and
linkage_name_copy==linkage_name. In this case, we already have the
else
{
slot_name = slot->value.found.symbol->search_name ();
- slot_domain = SYMBOL_DOMAIN (slot->value.found.symbol);
+ slot_domain = slot->value.found.symbol->domain ();
}
/* NULL names match. */
struct symbol *sym = slot->value.found.symbol;
lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
- if (!SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
+ if (!symbol_matches_search_name (sym, lookup_name))
return 0;
if (!symbol_matches_domain (sym->language (), slot_domain, domain))
if (eq_symbol_entry (slot, objfile_context, name, domain))
{
- if (symbol_lookup_debug)
- fprintf_unfiltered (gdb_stdlog,
- "%s block symbol cache hit%s for %s, %s\n",
- block == GLOBAL_BLOCK ? "Global" : "Static",
- slot->state == SYMBOL_SLOT_NOT_FOUND
- ? " (not found)" : "",
- name, domain_name (domain));
+ symbol_lookup_debug_printf ("%s block symbol cache hit%s for %s, %s",
+ block == GLOBAL_BLOCK ? "Global" : "Static",
+ slot->state == SYMBOL_SLOT_NOT_FOUND
+ ? " (not found)" : "", name,
+ domain_name (domain));
++bsc->hits;
if (slot->state == SYMBOL_SLOT_NOT_FOUND)
return SYMBOL_LOOKUP_FAILED;
/* Symbol is not present in the cache. */
- if (symbol_lookup_debug)
- {
- fprintf_unfiltered (gdb_stdlog,
- "%s block symbol cache miss for %s, %s\n",
- block == GLOBAL_BLOCK ? "Global" : "Static",
- name, domain_name (domain));
- }
+ symbol_lookup_debug_printf ("%s block symbol cache miss for %s, %s",
+ block == GLOBAL_BLOCK ? "Global" : "Static",
+ name, domain_name (domain));
++bsc->misses;
return {};
}
if (cache->global_symbols == NULL)
{
- printf_filtered (" <disabled>\n");
+ gdb_printf (" <disabled>\n");
return;
}
unsigned int i;
if (pass == 0)
- printf_filtered ("Global symbols:\n");
+ gdb_printf ("Global symbols:\n");
else
- printf_filtered ("Static symbols:\n");
+ gdb_printf ("Static symbols:\n");
for (i = 0; i < bsc->size; ++i)
{
case SYMBOL_SLOT_UNUSED:
break;
case SYMBOL_SLOT_NOT_FOUND:
- printf_filtered (" [%4u] = %s, %s %s (not found)\n", i,
- host_address_to_string (slot->objfile_context),
- slot->value.not_found.name,
- domain_name (slot->value.not_found.domain));
+ gdb_printf (" [%4u] = %s, %s %s (not found)\n", i,
+ host_address_to_string (slot->objfile_context),
+ slot->value.not_found.name,
+ domain_name (slot->value.not_found.domain));
break;
case SYMBOL_SLOT_FOUND:
{
struct symbol *found = slot->value.found.symbol;
const struct objfile *context = slot->objfile_context;
- printf_filtered (" [%4u] = %s, %s %s\n", i,
- host_address_to_string (context),
- found->print_name (),
- domain_name (SYMBOL_DOMAIN (found)));
+ gdb_printf (" [%4u] = %s, %s %s\n", i,
+ host_address_to_string (context),
+ found->print_name (),
+ domain_name (found->domain ()));
break;
}
}
{
struct symbol_cache *cache;
- printf_filtered (_("Symbol cache for pspace %d\n%s:\n"),
- pspace->num,
- pspace->symfile_object_file != NULL
- ? objfile_name (pspace->symfile_object_file)
- : "(no object file)");
+ gdb_printf (_("Symbol cache for pspace %d\n%s:\n"),
+ pspace->num,
+ pspace->symfile_object_file != NULL
+ ? objfile_name (pspace->symfile_object_file)
+ : "(no object file)");
/* If the cache hasn't been created yet, avoid creating one. */
cache = symbol_cache_key.get (pspace);
if (cache == NULL)
- printf_filtered (" <empty>\n");
+ gdb_printf (" <empty>\n");
else
symbol_cache_dump (cache);
}
if (cache->global_symbols == NULL)
{
- printf_filtered (" <disabled>\n");
+ gdb_printf (" <disabled>\n");
return;
}
QUIT;
if (pass == 0)
- printf_filtered ("Global block cache stats:\n");
+ gdb_printf ("Global block cache stats:\n");
else
- printf_filtered ("Static block cache stats:\n");
+ gdb_printf ("Static block cache stats:\n");
- printf_filtered (" size: %u\n", bsc->size);
- printf_filtered (" hits: %u\n", bsc->hits);
- printf_filtered (" misses: %u\n", bsc->misses);
- printf_filtered (" collisions: %u\n", bsc->collisions);
+ gdb_printf (" size: %u\n", bsc->size);
+ gdb_printf (" hits: %u\n", bsc->hits);
+ gdb_printf (" misses: %u\n", bsc->misses);
+ gdb_printf (" collisions: %u\n", bsc->collisions);
}
}
{
struct symbol_cache *cache;
- printf_filtered (_("Symbol cache statistics for pspace %d\n%s:\n"),
- pspace->num,
- pspace->symfile_object_file != NULL
- ? objfile_name (pspace->symfile_object_file)
- : "(no object file)");
+ gdb_printf (_("Symbol cache statistics for pspace %d\n%s:\n"),
+ pspace->num,
+ pspace->symfile_object_file != NULL
+ ? objfile_name (pspace->symfile_object_file)
+ : "(no object file)");
/* If the cache hasn't been created yet, avoid creating one. */
cache = symbol_cache_key.get (pspace);
if (cache == NULL)
- printf_filtered (" empty, no stats available\n");
+ gdb_printf (" empty, no stats available\n");
else
symbol_cache_stats (cache);
}
if (!sym)
return NULL;
- if (!SYMBOL_OBJFILE_OWNED (sym))
+ if (!sym->is_objfile_owned ())
return sym;
/* We either have an OBJFILE, or we can get at it from the sym's
symtab. Anything else is a bug. */
- gdb_assert (objfile || symbol_symtab (sym));
+ gdb_assert (objfile || sym->symtab ());
if (objfile == NULL)
- objfile = symbol_objfile (sym);
+ objfile = sym->objfile ();
if (sym->obj_section (objfile) != nullptr)
return sym;
/* We should have an objfile by now. */
gdb_assert (objfile);
- switch (SYMBOL_CLASS (sym))
+ switch (sym->aclass ())
{
case LOC_STATIC:
case LOC_LABEL:
- addr = SYMBOL_VALUE_ADDRESS (sym);
+ addr = sym->value_address ();
break;
case LOC_BLOCK:
- addr = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym));
+ addr = sym->value_block ()->entry_pc ();
break;
default:
lookup, so we can always binary search. */
if (lang == language_cplus)
{
- char *demangled_name = gdb_demangle (name, DMGL_ANSI | DMGL_PARAMS);
+ gdb::unique_xmalloc_ptr<char> demangled_name
+ = gdb_demangle (name, DMGL_ANSI | DMGL_PARAMS);
if (demangled_name != NULL)
- return storage.set_malloc_ptr (demangled_name);
+ return storage.set_malloc_ptr (std::move (demangled_name));
/* If we were given a non-mangled name, canonicalize it
according to the language (so far only for C++). */
}
else if (lang == language_d)
{
- char *demangled_name = d_demangle (name, 0);
+ gdb::unique_xmalloc_ptr<char> demangled_name = d_demangle (name, 0);
if (demangled_name != NULL)
- return storage.set_malloc_ptr (demangled_name);
+ return storage.set_malloc_ptr (std::move (demangled_name));
}
else if (lang == language_go)
{
- char *demangled_name
+ gdb::unique_xmalloc_ptr<char> demangled_name
= language_def (language_go)->demangle_symbol (name, 0);
if (demangled_name != NULL)
- return storage.set_malloc_ptr (demangled_name);
+ return storage.set_malloc_ptr (std::move (demangled_name));
}
return name;
const domain_enum domain, enum language lang,
struct field_of_this_result *is_a_field_of_this)
{
+ SYMBOL_LOOKUP_SCOPED_DEBUG_ENTER_EXIT;
+
demangle_result_storage storage;
const char *modified_name = demangle_for_lookup (name, lang, storage);
if (lang->name_of_this () == NULL || block == NULL)
return {};
- if (symbol_lookup_debug > 1)
- {
- struct objfile *objfile = block_objfile (block);
-
- fprintf_unfiltered (gdb_stdlog,
- "lookup_language_this (%s, %s (objfile %s))",
- lang->name (), host_address_to_string (block),
- objfile_debug_name (objfile));
- }
+ symbol_lookup_debug_printf_v ("lookup_language_this (%s, %s (objfile %s))",
+ lang->name (), host_address_to_string (block),
+ objfile_debug_name (block_objfile (block)));
while (block)
{
VAR_DOMAIN);
if (sym != NULL)
{
- if (symbol_lookup_debug > 1)
- {
- fprintf_unfiltered (gdb_stdlog, " = %s (%s, block %s)\n",
- sym->print_name (),
- host_address_to_string (sym),
- host_address_to_string (block));
- }
+ symbol_lookup_debug_printf_v
+ ("lookup_language_this (...) = %s (%s, block %s)",
+ sym->print_name (), host_address_to_string (sym),
+ host_address_to_string (block));
return (struct block_symbol) {sym, block};
}
- if (BLOCK_FUNCTION (block))
+ if (block->function ())
break;
- block = BLOCK_SUPERBLOCK (block);
+ block = block->superblock ();
}
- if (symbol_lookup_debug > 1)
- fprintf_unfiltered (gdb_stdlog, " = NULL\n");
+ symbol_lookup_debug_printf_v ("lookup_language_this (...) = NULL");
return {};
}
for (i = type->num_fields () - 1; i >= TYPE_N_BASECLASSES (type); i--)
{
- const char *t_field_name = TYPE_FIELD_NAME (type, i);
+ const char *t_field_name = type->field (i).name ();
if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
{
const domain_enum domain, enum language language,
struct field_of_this_result *is_a_field_of_this)
{
+ SYMBOL_LOOKUP_SCOPED_DEBUG_ENTER_EXIT;
+
struct block_symbol result;
const struct language_defn *langdef;
struct objfile *objfile = (block == nullptr
? nullptr : block_objfile (block));
- fprintf_unfiltered (gdb_stdlog,
- "lookup_symbol_aux (%s, %s (objfile %s), %s, %s)\n",
- name, host_address_to_string (block),
- objfile != NULL
- ? objfile_debug_name (objfile) : "NULL",
- domain_name (domain), language_str (language));
+ symbol_lookup_debug_printf
+ ("demangled symbol name = \"%s\", block @ %s (objfile %s)",
+ name, host_address_to_string (block),
+ objfile != NULL ? objfile_debug_name (objfile) : "NULL");
+ symbol_lookup_debug_printf
+ ("domain name = \"%s\", language = \"%s\")",
+ domain_name (domain), language_str (language));
}
/* Make sure we do something sensible with is_a_field_of_this, since
result = lookup_local_symbol (name, match_type, block, domain, language);
if (result.symbol != NULL)
{
- if (symbol_lookup_debug)
- {
- fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
- host_address_to_string (result.symbol));
- }
+ symbol_lookup_debug_printf
+ ("found symbol @ %s (using lookup_local_symbol)",
+ host_address_to_string (result.symbol));
return result;
}
if (result.symbol)
{
- struct type *t = result.symbol->type;
+ struct type *t = result.symbol->type ();
/* I'm not really sure that type of this can ever
be typedefed; just be safe. */
t = check_typedef (t);
- if (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
- t = TYPE_TARGET_TYPE (t);
+ if (t->is_pointer_or_reference ())
+ t = t->target_type ();
if (t->code () != TYPE_CODE_STRUCT
&& t->code () != TYPE_CODE_UNION)
if (check_field (t, name, is_a_field_of_this))
{
- if (symbol_lookup_debug)
- {
- fprintf_unfiltered (gdb_stdlog,
- "lookup_symbol_aux (...) = NULL\n");
- }
+ symbol_lookup_debug_printf ("no symbol found");
return {};
}
}
result = langdef->lookup_symbol_nonlocal (name, block, domain);
if (result.symbol != NULL)
{
- if (symbol_lookup_debug)
- {
- fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
- host_address_to_string (result.symbol));
- }
+ symbol_lookup_debug_printf
+ ("found symbol @ %s (using language lookup_symbol_nonlocal)",
+ host_address_to_string (result.symbol));
return result;
}
but more useful than an error. */
result = lookup_static_symbol (name, domain);
- if (symbol_lookup_debug)
- {
- fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
- result.symbol != NULL
- ? host_address_to_string (result.symbol)
- : "NULL");
- }
+ symbol_lookup_debug_printf
+ ("found symbol @ %s (using lookup_static_symbol)",
+ result.symbol != NULL ? host_address_to_string (result.symbol) : "NULL");
return result;
}
return blocksym;
}
- if (BLOCK_FUNCTION (block) != NULL && block_inlined_p (block))
+ if (block->function () != NULL && block_inlined_p (block))
break;
- block = BLOCK_SUPERBLOCK (block);
+ block = block->superblock ();
}
/* We've reached the end of the function without finding a result. */
{
struct symbol *sym;
- if (symbol_lookup_debug > 1)
+ if (symbol_lookup_debug)
{
- struct objfile *objfile = (block == nullptr
- ? nullptr : block_objfile (block));
+ struct objfile *objfile
+ = block == nullptr ? nullptr : block_objfile (block);
- fprintf_unfiltered (gdb_stdlog,
- "lookup_symbol_in_block (%s, %s (objfile %s), %s)",
- name, host_address_to_string (block),
- objfile_debug_name (objfile),
- domain_name (domain));
+ symbol_lookup_debug_printf_v
+ ("lookup_symbol_in_block (%s, %s (objfile %s), %s)",
+ name, host_address_to_string (block),
+ objfile != nullptr ? objfile_debug_name (objfile) : "NULL",
+ domain_name (domain));
}
sym = block_lookup_symbol (block, name, match_type, domain);
if (sym)
{
- if (symbol_lookup_debug > 1)
- {
- fprintf_unfiltered (gdb_stdlog, " = %s\n",
- host_address_to_string (sym));
- }
+ symbol_lookup_debug_printf_v ("lookup_symbol_in_block (...) = %s",
+ host_address_to_string (sym));
return fixup_symbol_section (sym, NULL);
}
- if (symbol_lookup_debug > 1)
- fprintf_unfiltered (gdb_stdlog, " = NULL\n");
+ symbol_lookup_debug_printf_v ("lookup_symbol_in_block (...) = NULL");
return NULL;
}
{
gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
- if (symbol_lookup_debug > 1)
- {
- fprintf_unfiltered (gdb_stdlog,
- "lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)",
- objfile_debug_name (objfile),
- block_index == GLOBAL_BLOCK
- ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
- name, domain_name (domain));
- }
+ symbol_lookup_debug_printf_v
+ ("lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)",
+ objfile_debug_name (objfile),
+ block_index == GLOBAL_BLOCK ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
+ name, domain_name (domain));
struct block_symbol other;
other.symbol = NULL;
const struct block *block;
struct block_symbol result;
- bv = COMPUNIT_BLOCKVECTOR (cust);
- block = BLOCKVECTOR_BLOCK (bv, block_index);
+ bv = cust->blockvector ();
+ block = bv->block (block_index);
result.symbol = block_lookup_symbol_primary (block, name, domain);
result.block = block;
if (result.symbol == NULL)
break;
}
if (symbol_matches_domain (result.symbol->language (),
- SYMBOL_DOMAIN (result.symbol), domain))
+ result.symbol->domain (), domain))
{
struct symbol *better
= better_symbol (other.symbol, result.symbol, domain);
if (other.symbol != NULL)
{
- if (symbol_lookup_debug > 1)
- {
- fprintf_unfiltered (gdb_stdlog, " = %s (block %s)\n",
- host_address_to_string (other.symbol),
- host_address_to_string (other.block));
- }
+ symbol_lookup_debug_printf_v
+ ("lookup_symbol_in_objfile_symtabs (...) = %s (block %s)",
+ host_address_to_string (other.symbol),
+ host_address_to_string (other.block));
other.symbol = fixup_symbol_section (other.symbol, objfile);
return other;
}
- if (symbol_lookup_debug > 1)
- fprintf_unfiltered (gdb_stdlog, " = NULL\n");
+ symbol_lookup_debug_printf_v
+ ("lookup_symbol_in_objfile_symtabs (...) = NULL");
return {};
}
(if a template, try specifying an instantiation: %s<type>)."),
block_index == GLOBAL_BLOCK ? "global" : "static",
name,
- symtab_to_filename_for_display (compunit_primary_filetab (cust)),
+ symtab_to_filename_for_display (cust->primary_filetab ()),
name, name);
}
const struct block *block;
struct block_symbol result;
- if (symbol_lookup_debug > 1)
- {
- fprintf_unfiltered (gdb_stdlog,
- "lookup_symbol_via_quick_fns (%s, %s, %s, %s)\n",
- objfile_debug_name (objfile),
- block_index == GLOBAL_BLOCK
- ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
- name, domain_name (domain));
- }
+ symbol_lookup_debug_printf_v
+ ("lookup_symbol_via_quick_fns (%s, %s, %s, %s)",
+ objfile_debug_name (objfile),
+ block_index == GLOBAL_BLOCK ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
+ name, domain_name (domain));
cust = objfile->lookup_symbol (block_index, name, domain);
if (cust == NULL)
{
- if (symbol_lookup_debug > 1)
- {
- fprintf_unfiltered (gdb_stdlog,
- "lookup_symbol_via_quick_fns (...) = NULL\n");
- }
+ symbol_lookup_debug_printf_v
+ ("lookup_symbol_via_quick_fns (...) = NULL");
return {};
}
- bv = COMPUNIT_BLOCKVECTOR (cust);
- block = BLOCKVECTOR_BLOCK (bv, block_index);
+ bv = cust->blockvector ();
+ block = bv->block (block_index);
result.symbol = block_lookup_symbol (block, name,
symbol_name_match_type::FULL, domain);
if (result.symbol == NULL)
error_in_psymtab_expansion (block_index, name, cust);
- if (symbol_lookup_debug > 1)
- {
- fprintf_unfiltered (gdb_stdlog,
- "lookup_symbol_via_quick_fns (...) = %s (block %s)\n",
- host_address_to_string (result.symbol),
- host_address_to_string (block));
- }
+ symbol_lookup_debug_printf_v
+ ("lookup_symbol_via_quick_fns (...) = %s (block %s)",
+ host_address_to_string (result.symbol),
+ host_address_to_string (block));
result.symbol = fixup_symbol_section (result.symbol, objfile);
result.block = block;
struct objfile *objfile = (block == nullptr
? nullptr : block_objfile (block));
- fprintf_unfiltered (gdb_stdlog,
- "lookup_symbol_in_static_block (%s, %s (objfile %s),"
- " %s)\n",
- name,
- host_address_to_string (block),
- objfile_debug_name (objfile),
- domain_name (domain));
+ symbol_lookup_debug_printf
+ ("lookup_symbol_in_static_block (%s, %s (objfile %s), %s)",
+ name, host_address_to_string (block),
+ objfile != nullptr ? objfile_debug_name (objfile) : "NULL",
+ domain_name (domain));
}
sym = lookup_symbol_in_block (name,
symbol_name_match_type::FULL,
static_block, domain);
- if (symbol_lookup_debug)
- {
- fprintf_unfiltered (gdb_stdlog,
- "lookup_symbol_in_static_block (...) = %s\n",
- sym != NULL ? host_address_to_string (sym) : "NULL");
- }
+ symbol_lookup_debug_printf ("lookup_symbol_in_static_block (...) = %s",
+ sym != NULL
+ ? host_address_to_string (sym) : "NULL");
return (struct block_symbol) {sym, static_block};
}
gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
- if (symbol_lookup_debug)
- {
- fprintf_unfiltered (gdb_stdlog,
- "lookup_symbol_in_objfile (%s, %s, %s, %s)\n",
- objfile_debug_name (objfile),
- block_index == GLOBAL_BLOCK
- ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
- name, domain_name (domain));
- }
+ symbol_lookup_debug_printf ("lookup_symbol_in_objfile (%s, %s, %s, %s)",
+ objfile_debug_name (objfile),
+ block_index == GLOBAL_BLOCK
+ ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
+ name, domain_name (domain));
result = lookup_symbol_in_objfile_symtabs (objfile, block_index,
name, domain);
if (result.symbol != NULL)
{
- if (symbol_lookup_debug)
- {
- fprintf_unfiltered (gdb_stdlog,
- "lookup_symbol_in_objfile (...) = %s"
- " (in symtabs)\n",
- host_address_to_string (result.symbol));
- }
+ symbol_lookup_debug_printf
+ ("lookup_symbol_in_objfile (...) = %s (in symtabs)",
+ host_address_to_string (result.symbol));
return result;
}
result = lookup_symbol_via_quick_fns (objfile, block_index,
name, domain);
- if (symbol_lookup_debug)
- {
- fprintf_unfiltered (gdb_stdlog,
- "lookup_symbol_in_objfile (...) = %s%s\n",
- result.symbol != NULL
- ? host_address_to_string (result.symbol)
- : "NULL",
- result.symbol != NULL ? " (via quick fns)" : "");
- }
+ symbol_lookup_debug_printf ("lookup_symbol_in_objfile (...) = %s%s",
+ result.symbol != NULL
+ ? host_address_to_string (result.symbol)
+ : "NULL",
+ result.symbol != NULL ? " (via quick fns)"
+ : "");
return result;
}
-/* Find the language for partial symbol with NAME. */
-
-static enum language
-find_quick_global_symbol_language (const char *name, const domain_enum domain)
-{
- for (objfile *objfile : current_program_space->objfiles ())
- {
- bool symbol_found_p;
- enum language lang
- = objfile->lookup_global_symbol_language (name, domain, &symbol_found_p);
- if (symbol_found_p)
- return lang;
- }
-
- return language_unknown;
-}
-
-/* Private data to be used with lookup_symbol_global_iterator_cb. */
-
-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 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_or_static_iterator_cb (struct objfile *objfile,
- void *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, data->block_index,
- data->name, data->domain);
-
- /* If we found a match, tell the iterator to stop. Otherwise,
- keep going. */
- return (data->result.symbol != NULL);
-}
-
/* 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 symbol_cache *cache = get_symbol_cache (current_program_space);
struct block_symbol result;
- struct global_or_static_sym_lookup_data lookup_data;
struct block_symbol_cache *bsc;
struct symbol_cache_slot *slot;
/* 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 ? objfile->arch () : target_gdbarch (),
- lookup_symbol_global_or_static_iterator_cb, &lookup_data, objfile);
- result = lookup_data.result;
- }
+ gdbarch_iterate_over_objfiles_in_search_order
+ (objfile != NULL ? objfile->arch () : target_gdbarch (),
+ [&result, block_index, name, domain] (struct objfile *objfile_iter)
+ {
+ result = lookup_symbol_in_objfile (objfile_iter, block_index,
+ name, domain);
+ return result.symbol != nullptr;
+ },
+ objfile);
if (result.symbol != NULL)
symbol_cache_mark_found (bsc, slot, objfile, result.symbol, result.block);
if (cust == NULL)
return NULL;
- bv = COMPUNIT_BLOCKVECTOR (cust);
- block = BLOCKVECTOR_BLOCK (bv, block_index);
+ bv = cust->blockvector ();
+ block = bv->block (block_index);
sym = block_find_symbol (block, name, STRUCT_DOMAIN,
block_find_non_opaque_type, NULL);
if (sym == NULL)
error_in_psymtab_expansion (block_index, name, cust);
- gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
- return SYMBOL_TYPE (sym);
+ gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
+ return sym->type ();
}
/* Subroutine of basic_lookup_transparent_type to simplify it.
for (compunit_symtab *cust : objfile->compunits ())
{
- bv = COMPUNIT_BLOCKVECTOR (cust);
- block = BLOCKVECTOR_BLOCK (bv, block_index);
+ bv = cust->blockvector ();
+ block = bv->block (block_index);
sym = block_find_symbol (block, name, STRUCT_DOMAIN,
block_find_non_opaque_type, NULL);
if (sym != NULL)
{
- gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
- return SYMBOL_TYPE (sym);
+ gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
+ return sym->type ();
}
}
ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym)
{
- if (symbol_matches_domain (sym->language (), SYMBOL_DOMAIN (sym), domain))
+ if (symbol_matches_domain (sym->language (), sym->domain (), domain))
{
struct block_symbol block_sym = {sym, block};
{
for (compunit_symtab *cust : obj_file->compunits ())
{
- const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (cust);
- const struct block *global_block
- = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- CORE_ADDR start = BLOCK_START (global_block);
- CORE_ADDR end = BLOCK_END (global_block);
+ const struct blockvector *bv = cust->blockvector ();
+ const struct block *global_block = bv->global_block ();
+ CORE_ADDR start = global_block->start ();
+ CORE_ADDR end = global_block->end ();
bool in_range_p = start <= pc && pc < end;
if (!in_range_p)
continue;
- if (BLOCKVECTOR_MAP (bv))
+ if (bv->map () != nullptr)
{
- if (addrmap_find (BLOCKVECTOR_MAP (bv), pc) == nullptr)
+ if (bv->map ()->find (pc) == nullptr)
continue;
return cust;
b_index <= STATIC_BLOCK && sym == NULL;
++b_index)
{
- const struct block *b = BLOCKVECTOR_BLOCK (bv, b_index);
+ const struct block *b = bv->block (b_index);
ALL_BLOCK_SYMBOLS (b, iter, sym)
{
fixup_symbol_section (sym, obj_file);
ADDR. */
auto search_symtab = [] (compunit_symtab *symtab, CORE_ADDR addr) -> symbol *
{
- const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (symtab);
+ const struct blockvector *bv = symtab->blockvector ();
for (int i = GLOBAL_BLOCK; i <= STATIC_BLOCK; ++i)
{
- const struct block *b = BLOCKVECTOR_BLOCK (bv, i);
+ const struct block *b = bv->block (i);
struct block_iterator iter;
struct symbol *sym;
ALL_BLOCK_SYMBOLS (b, iter, sym)
{
- if (SYMBOL_CLASS (sym) == LOC_STATIC
- && SYMBOL_VALUE_ADDRESS (sym) == addr)
+ if (sym->aclass () == LOC_STATIC
+ && sym->value_address () == addr)
return sym;
}
}
*/
msymbol = lookup_minimal_symbol_by_pc (pc);
if (msymbol.minsym != NULL)
- if (MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline)
+ if (msymbol.minsym->type () == mst_solib_trampoline)
{
struct bound_minimal_symbol mfunsym
= lookup_minimal_symbol_text (msymbol.minsym->linkage_name (),
msymbol->linkage_name ()); */
;
/* fall through */
- else if (BMSYMBOL_VALUE_ADDRESS (mfunsym)
- == BMSYMBOL_VALUE_ADDRESS (msymbol))
+ else if (mfunsym.value_address ()
+ == msymbol.value_address ())
/* Avoid infinite recursion */
/* See above comment about why warning is commented out. */
/* warning ("In stub for %s; unable to find real function/line info",
/* Detect an obvious case of infinite recursion. If this
should occur, we'd like to know about it, so error out,
fatally. */
- if (BMSYMBOL_VALUE_ADDRESS (mfunsym) == pc)
- internal_error (__FILE__, __LINE__,
- _("Infinite recursion detected in find_pc_sect_line;"
+ if (mfunsym.value_address () == pc)
+ internal_error (_("Infinite recursion detected in find_pc_sect_line;"
"please file a bug report"));
- return find_pc_line (BMSYMBOL_VALUE_ADDRESS (mfunsym), 0);
+ return find_pc_line (mfunsym.value_address (), 0);
}
}
return val;
}
- bv = COMPUNIT_BLOCKVECTOR (cust);
+ bv = cust->blockvector ();
/* Look at all the symtabs that share this blockvector.
They all have the same apriori range, that we found was right;
but they have different line tables. */
- for (symtab *iter_s : compunit_filetabs (cust))
+ for (symtab *iter_s : cust->filetabs ())
{
/* Find the best line in this symtab. */
- l = SYMTAB_LINETABLE (iter_s);
+ l = iter_s->linetable ();
if (!l)
continue;
len = l->nitems;
else if (alt)
val.end = alt->pc;
else
- val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
+ val.end = bv->global_block ()->end ();
}
val.section = section;
return val;
struct symtab *best_symtab;
/* First try looking it up in the given symtab. */
- best_linetable = SYMTAB_LINETABLE (sym_tab);
+ best_linetable = sym_tab->linetable ();
best_symtab = sym_tab;
best_index = find_line_common (best_linetable, line, &exact, 0);
if (best_index < 0 || !exact)
{
for (compunit_symtab *cu : objfile->compunits ())
{
- for (symtab *s : compunit_filetabs (cu))
+ for (symtab *s : cu->filetabs ())
{
struct linetable *l;
int ind;
if (FILENAME_CMP (symtab_to_fullname (sym_tab),
symtab_to_fullname (s)) != 0)
continue;
- l = SYMTAB_LINETABLE (s);
+ l = s->linetable ();
ind = find_line_common (l, line, &exact, 0);
if (ind >= 0)
{
int was_exact;
int idx;
- idx = find_line_common (SYMTAB_LINETABLE (symtab), line, &was_exact,
+ idx = find_line_common (symtab->linetable (), line, &was_exact,
start);
if (idx < 0)
break;
if (!was_exact)
{
- struct linetable_entry *item = &SYMTAB_LINETABLE (symtab)->item[idx];
+ struct linetable_entry *item = &symtab->linetable ()->item[idx];
if (*best_item == NULL
|| (item->line < (*best_item)->line && item->is_stmt))
break;
}
- result.push_back (SYMTAB_LINETABLE (symtab)->item[idx].pc);
+ result.push_back (symtab->linetable ()->item[idx].pc);
start = idx + 1;
}
symtab = find_line_symtab (symtab, line, &ind, NULL);
if (symtab != NULL)
{
- l = SYMTAB_LINETABLE (symtab);
+ l = symtab->linetable ();
*pc = l->item[ind].pc;
return true;
}
symtab_and_line sal = find_pc_sect_line (func_addr, section, 0);
if (funfirstline && sal.symtab != NULL
- && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal.symtab))
- || SYMTAB_LANGUAGE (sal.symtab) == language_asm))
+ && (sal.symtab->compunit ()->locations_valid ()
+ || sal.symtab->language () == language_asm))
{
- struct gdbarch *gdbarch = SYMTAB_OBJFILE (sal.symtab)->arch ();
+ struct gdbarch *gdbarch = sal.symtab->compunit ()->objfile ()->arch ();
sal.pc = func_addr;
if (gdbarch_skip_entrypoint_p (gdbarch))
{
fixup_symbol_section (sym, NULL);
symtab_and_line sal
- = find_function_start_sal_1 (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)),
- sym->obj_section (symbol_objfile (sym)),
+ = find_function_start_sal_1 (sym->value_block ()->entry_pc (),
+ sym->obj_section (sym->objfile ()),
funfirstline);
sal.symbol = sym;
return sal;
int i;
/* Give up if this symbol has no lineinfo table. */
- l = SYMTAB_LINETABLE (symtab);
+ l = symtab->linetable ();
if (l == NULL)
return func_addr;
return func_addr;
}
+/* Try to locate the address where a breakpoint should be placed past the
+ prologue of function starting at FUNC_ADDR using the line table.
+
+ Return the address associated with the first entry in the line-table for
+ the function starting at FUNC_ADDR which has prologue_end set to true if
+ such entry exist, otherwise return an empty optional. */
+
+static gdb::optional<CORE_ADDR>
+skip_prologue_using_linetable (CORE_ADDR func_addr)
+{
+ CORE_ADDR start_pc, end_pc;
+
+ if (!find_pc_partial_function (func_addr, nullptr, &start_pc, &end_pc))
+ return {};
+
+ const struct symtab_and_line prologue_sal = find_pc_line (start_pc, 0);
+ if (prologue_sal.symtab != nullptr
+ && prologue_sal.symtab->language () != language_asm)
+ {
+ struct linetable *linetable = prologue_sal.symtab->linetable ();
+
+ auto it = std::lower_bound
+ (linetable->item, linetable->item + linetable->nitems, start_pc,
+ [] (const linetable_entry <e, CORE_ADDR pc) -> bool
+ {
+ return lte.pc < pc;
+ });
+
+ for (;
+ it < linetable->item + linetable->nitems && it->pc <= end_pc;
+ it++)
+ if (it->prologue_end)
+ return {it->pc};
+ }
+
+ return {};
+}
+
/* Adjust SAL to the first instruction past the function prologue.
If the PC was explicitly specified, the SAL is not changed.
If the line number was explicitly specified then the SAL can still be
is likely to be the wrong choice. */
if (sal->symtab != nullptr
&& sal->explicit_line
- && SYMTAB_LANGUAGE (sal->symtab) == language_asm)
+ && sal->symtab->language () == language_asm)
return;
scoped_restore_current_pspace_and_thread restore_pspace_thread;
{
fixup_symbol_section (sym, NULL);
- objfile = symbol_objfile (sym);
- pc = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym));
+ objfile = sym->objfile ();
+ pc = sym->value_block ()->entry_pc ();
section = sym->obj_section (objfile);
name = sym->linkage_name ();
}
return;
objfile = msymbol.objfile;
- pc = BMSYMBOL_VALUE_ADDRESS (msymbol);
+ pc = msymbol.value_address ();
section = msymbol.minsym->obj_section (objfile);
name = msymbol.minsym->linkage_name ();
}
have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
have to be set by the caller so we use SYM instead. */
if (sym != NULL
- && COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (symbol_symtab (sym))))
+ && sym->symtab ()->compunit ()->locations_valid ())
force_skip = 0;
saved_pc = pc;
{
pc = saved_pc;
+ /* Check if the compiler explicitly indicated where a breakpoint should
+ be placed to skip the prologue. */
+ if (!ignore_prologue_end_flag && skip)
+ {
+ gdb::optional<CORE_ADDR> linetable_pc
+ = skip_prologue_using_linetable (pc);
+ if (linetable_pc)
+ {
+ pc = *linetable_pc;
+ start_sal = find_pc_sect_line (pc, section, 0);
+ force_skip = 1;
+ continue;
+ }
+ }
+
/* If the function is in an unmapped overlay, use its unmapped LMA address,
so that gdbarch_skip_prologue has something unique to work on. */
if (section_is_overlay (section) && !section_is_mapped (section))
/* Check if gdbarch_skip_prologue left us in mid-line, and the next
line is still part of the same function. */
if (skip && start_sal.pc != pc
- && (sym ? (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)) <= start_sal.end
- && start_sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
+ && (sym ? (sym->value_block ()->entry_pc () <= start_sal.end
+ && start_sal.end < sym->value_block()->end ())
: (lookup_minimal_symbol_by_pc_section (start_sal.end, section).minsym
== lookup_minimal_symbol_by_pc_section (pc, section).minsym)))
{
is aligned. */
if (!force_skip && sym && start_sal.symtab == NULL)
{
- pc = skip_prologue_using_lineinfo (pc, symbol_symtab (sym));
+ pc = skip_prologue_using_lineinfo (pc, sym->symtab ());
/* Recalculate the line number. */
start_sal = find_pc_sect_line (pc, section, 0);
}
function_block = NULL;
while (b != NULL)
{
- if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
+ if (b->function () != NULL && block_inlined_p (b))
function_block = b;
- else if (BLOCK_FUNCTION (b) != NULL)
+ else if (b->function () != NULL)
break;
- b = BLOCK_SUPERBLOCK (b);
+ b = b->superblock ();
}
if (function_block != NULL
- && SYMBOL_LINE (BLOCK_FUNCTION (function_block)) != 0)
+ && function_block->function ()->line () != 0)
{
- sal->line = SYMBOL_LINE (BLOCK_FUNCTION (function_block));
- sal->symtab = symbol_symtab (BLOCK_FUNCTION (function_block));
+ sal->line = function_block->function ()->line ();
+ sal->symtab = function_block->function ()->symtab ();
}
}
The GNU assembler emits separate line notes for each instruction
in a multi-instruction macro, but compilers generally will not
do this. */
- if (prologue_sal.symtab->language != language_asm)
+ if (prologue_sal.symtab->language () != language_asm)
{
- struct linetable *linetable = SYMTAB_LINETABLE (prologue_sal.symtab);
+ struct linetable *linetable = prologue_sal.symtab->linetable ();
int idx = 0;
/* Skip any earlier lines, and any end-of-sequence marker
{
if (block_inlined_p (bl))
break;
- if (BLOCK_FUNCTION (bl))
+ if (bl->function ())
{
bl = NULL;
break;
}
- bl = BLOCK_SUPERBLOCK (bl);
+ bl = bl->superblock ();
}
if (bl != NULL)
break;
symbol *sym = find_pc_function (func_addr);
if (sym != NULL
- && SYMBOL_CLASS (sym) == LOC_BLOCK
- && BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)) == func_addr)
+ && sym->aclass () == LOC_BLOCK
+ && sym->value_block ()->entry_pc () == func_addr)
return sym;
return NULL;
case match_on::FULLNAME:
to_match = fullname;
break;
+ default:
+ gdb_assert_not_reached ("bad m_match_type");
}
if (m_c_regexp->exec (to_match, 0, NULL, 0) != 0)
m_uiout->text (", ");
m_first = false;
- wrap_here ("");
+ m_uiout->wrap_hint (0);
if (m_uiout->is_mi_like_p ())
{
m_uiout->field_string ("file", disp_name, file_name_style.style ());
if (group_by_objfile)
{
output_tuple.emplace (uiout, nullptr);
- uiout->field_string ("filename", objfile_name (objfile));
+ uiout->field_string ("filename", objfile_name (objfile),
+ file_name_style.style ());
uiout->text (":\n");
bool debug_fully_readin = !objfile->has_unexpanded_symtabs ();
if (uiout->is_mi_like_p ())
for (compunit_symtab *cu : objfile->compunits ())
{
- for (symtab *s : compunit_filetabs (cu))
+ for (symtab *s : cu->filetabs ())
{
const char *file = symtab_to_filename_for_display (s);
const char *fullname = symtab_to_fullname (s);
{
int c;
- c = FILENAME_CMP (symbol_symtab (sym_a.symbol)->filename,
- symbol_symtab (sym_b.symbol)->filename);
+ c = FILENAME_CMP (sym_a.symbol->symtab ()->filename,
+ sym_b.symbol->symtab ()->filename);
if (c != 0)
return c;
struct type *sym_type;
std::string printed_sym_type_name;
- if (symbol_lookup_debug > 1)
- {
- fprintf_unfiltered (gdb_stdlog,
- "treg_matches_sym_type_name\n sym %s\n",
- sym->natural_name ());
- }
+ symbol_lookup_debug_printf_v ("treg_matches_sym_type_name, sym %s",
+ sym->natural_name ());
- sym_type = SYMBOL_TYPE (sym);
+ sym_type = sym->type ();
if (sym_type == NULL)
return false;
printed_sym_type_name = type_to_string (sym_type);
}
-
- if (symbol_lookup_debug > 1)
- {
- fprintf_unfiltered (gdb_stdlog,
- " sym_type_name %s\n",
- printed_sym_type_name.c_str ());
- }
-
+ symbol_lookup_debug_printf_v ("sym_type_name %s",
+ printed_sym_type_name.c_str ());
if (printed_sym_type_name.empty ())
return false;
global_symbol_searcher::is_suitable_msymbol
(const enum search_domain kind, const minimal_symbol *msymbol)
{
- switch (MSYMBOL_TYPE (msymbol))
+ switch (msymbol->type ())
{
case mst_data:
case mst_bss:
enum search_domain kind = m_kind;
bool found_msymbol = false;
+ auto do_file_match = [&] (const char *filename, bool basenames)
+ {
+ return file_matches (filename, filenames, basenames);
+ };
+ gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher = nullptr;
+ if (!filenames.empty ())
+ file_matcher = do_file_match;
+
objfile->expand_symtabs_matching
- ([&] (const char *filename, bool basenames)
- {
- return file_matches (filename, filenames, basenames);
- },
+ (file_matcher,
&lookup_name_info::match_any (),
[&] (const char *symname)
{
the symbols tables are expanded. */
if (kind == FUNCTIONS_DOMAIN
? (find_pc_compunit_symtab
- (MSYMBOL_VALUE_ADDRESS (objfile, msymbol))
- == NULL)
+ (msymbol->value_address (objfile)) == NULL)
: (lookup_symbol_in_objfile_from_linkage_name
(objfile, msymbol->linkage_name (),
VAR_DOMAIN)
/* Add matching symbols (if not already present). */
for (compunit_symtab *cust : objfile->compunits ())
{
- const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (cust);
+ const struct blockvector *bv = cust->blockvector ();
for (block_enum block : { GLOBAL_BLOCK, STATIC_BLOCK })
{
struct block_iterator iter;
struct symbol *sym;
- const struct block *b = BLOCKVECTOR_BLOCK (bv, block);
+ const struct block *b = bv->block (block);
ALL_BLOCK_SYMBOLS (b, iter, sym)
{
- struct symtab *real_symtab = symbol_symtab (sym);
+ struct symtab *real_symtab = sym->symtab ();
QUIT;
|| preg->exec (sym->natural_name (), 0,
NULL, 0) == 0)
&& ((kind == VARIABLES_DOMAIN
- && SYMBOL_CLASS (sym) != LOC_TYPEDEF
- && SYMBOL_CLASS (sym) != LOC_UNRESOLVED
- && SYMBOL_CLASS (sym) != LOC_BLOCK
+ && sym->aclass () != LOC_TYPEDEF
+ && sym->aclass () != LOC_UNRESOLVED
+ && sym->aclass () != LOC_BLOCK
/* LOC_CONST can be used for more than
just enums, e.g., c++ static const
members. We only want to skip enums
here. */
- && !(SYMBOL_CLASS (sym) == LOC_CONST
- && (SYMBOL_TYPE (sym)->code ()
+ && !(sym->aclass () == LOC_CONST
+ && (sym->type ()->code ()
== TYPE_CODE_ENUM))
&& (!treg.has_value ()
|| treg_matches_sym_type_name (*treg, sym)))
|| (kind == FUNCTIONS_DOMAIN
- && SYMBOL_CLASS (sym) == LOC_BLOCK
+ && sym->aclass () == LOC_BLOCK
&& (!treg.has_value ()
|| treg_matches_sym_type_name (*treg,
sym)))
|| (kind == TYPES_DOMAIN
- && SYMBOL_CLASS (sym) == LOC_TYPEDEF
- && SYMBOL_DOMAIN (sym) != MODULE_DOMAIN)
+ && sym->aclass () == LOC_TYPEDEF
+ && sym->domain () != MODULE_DOMAIN)
|| (kind == MODULES_DOMAIN
- && SYMBOL_DOMAIN (sym) == MODULE_DOMAIN
- && SYMBOL_LINE (sym) != 0))))
+ && sym->domain () == MODULE_DOMAIN
+ && sym->line () != 0))))
{
if (result_set->size () < m_max_search_results)
{
symbol might be found via find_pc_symtab. */
if (kind != FUNCTIONS_DOMAIN
|| (find_pc_compunit_symtab
- (MSYMBOL_VALUE_ADDRESS (objfile, msymbol))
- == NULL))
+ (msymbol->value_address (objfile)) == NULL))
{
if (lookup_symbol_in_objfile_from_linkage_name
(objfile, msymbol->linkage_name (),
if (m_symbol_name_regexp != NULL)
{
const char *symbol_name_regexp = m_symbol_name_regexp;
+ std::string symbol_name_regexp_holder;
/* Make sure spacing is right for C++ operators.
This is just a courtesy to make the matching less sensitive
/* If wrong number of spaces, fix it. */
if (fix >= 0)
{
- char *tmp = (char *) alloca (8 + fix + strlen (opname) + 1);
-
- sprintf (tmp, "operator%.*s%s", fix, " ", opname);
- symbol_name_regexp = tmp;
+ symbol_name_regexp_holder
+ = string_printf ("operator%.*s%s", fix, " ", opname);
+ symbol_name_regexp = symbol_name_regexp_holder.c_str ();
}
}
/* Typedef that is not a C++ class. */
if (kind == TYPES_DOMAIN
- && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
+ && sym->domain () != STRUCT_DOMAIN)
{
string_file tmp_stream;
For the struct printing case below, things are worse, we force
printing of the ";" in this function, which is going to be wrong
for languages that don't require a ";" between statements. */
- if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_TYPEDEF)
- typedef_print (SYMBOL_TYPE (sym), sym, &tmp_stream);
+ if (sym->type ()->code () == TYPE_CODE_TYPEDEF)
+ typedef_print (sym->type (), sym, &tmp_stream);
else
- type_print (SYMBOL_TYPE (sym), "", &tmp_stream, -1);
+ type_print (sym->type (), "", &tmp_stream, -1);
str += tmp_stream.string ();
}
/* variable, func, or typedef-that-is-c++-class. */
else if (kind < TYPES_DOMAIN
|| (kind == TYPES_DOMAIN
- && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
+ && sym->domain () == STRUCT_DOMAIN))
{
string_file tmp_stream;
- type_print (SYMBOL_TYPE (sym),
- (SYMBOL_CLASS (sym) == LOC_TYPEDEF
+ type_print (sym->type (),
+ (sym->aclass () == LOC_TYPEDEF
? "" : sym->print_name ()),
&tmp_stream, 0);
int block, const char *last)
{
scoped_switch_to_sym_language_if_auto l (sym);
- struct symtab *s = symbol_symtab (sym);
+ struct symtab *s = sym->symtab ();
if (last != NULL)
{
if (filename_cmp (last, s_filename) != 0)
{
- printf_filtered (_("\nFile %ps:\n"),
- styled_string (file_name_style.style (),
- s_filename));
+ gdb_printf (_("\nFile %ps:\n"),
+ styled_string (file_name_style.style (),
+ s_filename));
}
- if (SYMBOL_LINE (sym) != 0)
- printf_filtered ("%d:\t", SYMBOL_LINE (sym));
+ if (sym->line () != 0)
+ gdb_printf ("%d:\t", sym->line ());
else
- puts_filtered ("\t");
+ gdb_puts ("\t");
}
std::string str = symbol_to_info_string (sym, block, kind);
- printf_filtered ("%s\n", str.c_str ());
+ gdb_printf ("%s\n", str.c_str ());
}
/* This help function for symtab_symbol_info() prints information
char *tmp;
if (gdbarch_addr_bit (gdbarch) <= 32)
- tmp = hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol)
+ tmp = hex_string_custom (msymbol.value_address ()
& (CORE_ADDR) 0xffffffff,
8);
else
- tmp = hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol),
+ tmp = hex_string_custom (msymbol.value_address (),
16);
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.minsym->print_name ()));
+ gdb_printf (_("%ps %ps\n"),
+ styled_string (address_style.style (), tmp),
+ styled_string (sym_style, msymbol.minsym->print_name ()));
}
/* This is the guts of the commands "info functions", "info types", and
if (regexp != NULL)
{
if (t_regexp != NULL)
- printf_filtered
+ gdb_printf
(_("All %ss matching regular expression \"%s\""
" with type matching regular expression \"%s\":\n"),
classnames[kind], regexp, t_regexp);
else
- printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
- classnames[kind], regexp);
+ gdb_printf (_("All %ss matching regular expression \"%s\":\n"),
+ classnames[kind], regexp);
}
else
{
if (t_regexp != NULL)
- printf_filtered
+ gdb_printf
(_("All defined %ss"
" with type matching regular expression \"%s\" :\n"),
classnames[kind], t_regexp);
else
- printf_filtered (_("All defined %ss:\n"), classnames[kind]);
+ gdb_printf (_("All defined %ss:\n"), classnames[kind]);
}
}
if (first)
{
if (!quiet)
- printf_filtered (_("\nNon-debugging symbols:\n"));
+ gdb_printf (_("\nNon-debugging symbols:\n"));
first = 0;
}
print_msymbol_info (p.msymbol);
p.block,
last_filename);
last_filename
- = symtab_to_filename_for_display (symbol_symtab (p.symbol));
+ = symtab_to_filename_for_display (p.symbol->symtab ());
}
}
}
{
bool quiet = false;
bool exclude_minsyms = false;
- char *type_regexp = nullptr;
-
- ~info_vars_funcs_options ()
- {
- xfree (type_regexp);
- }
+ std::string type_regexp;
};
/* The options used by the 'info variables' and 'info functions'
gdb::option::string_option_def<info_vars_funcs_options> {
"t",
- [] (info_vars_funcs_options *opt) { return &opt->type_regexp;
- },
+ [] (info_vars_funcs_options *opt) { return &opt->type_regexp; },
nullptr, /* show_cmd_cb */
nullptr /* set_doc */
}
if (args != nullptr && *args == '\0')
args = nullptr;
- symtab_symbol_info (opts.quiet, opts.exclude_minsyms, args, VARIABLES_DOMAIN,
- opts.type_regexp, from_tty);
+ symtab_symbol_info
+ (opts.quiet, opts.exclude_minsyms, args, VARIABLES_DOMAIN,
+ opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
+ from_tty);
}
/* Implement the 'info functions' command. */
if (args != nullptr && *args == '\0')
args = nullptr;
- symtab_symbol_info (opts.quiet, opts.exclude_minsyms, args,
- FUNCTIONS_DOMAIN, opts.type_regexp, from_tty);
+ symtab_symbol_info
+ (opts.quiet, opts.exclude_minsyms, args, FUNCTIONS_DOMAIN,
+ opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
+ from_tty);
}
/* Holds the -q option for the 'info types' command. */
{
if (p.msymbol.minsym == NULL)
{
- struct symtab *symtab = symbol_symtab (p.symbol);
+ struct symtab *symtab = p.symbol->symtab ();
const char *fullname = symtab_to_fullname (symtab);
string = string_printf ("%s:'%s'", fullname,
p.msymbol.minsym->linkage_name ());
break_command (&string[0], from_tty);
- printf_filtered ("<function, no debug info> %s;\n",
- p.msymbol.minsym->print_name ());
+ gdb_printf ("<function, no debug info> %s;\n",
+ p.msymbol.minsym->print_name ());
}
}
}
the msymbol name and removes the msymbol name from the completion
tracker. */
if (sym->language () == language_cplus
- && SYMBOL_DOMAIN (sym) == VAR_DOMAIN
- && SYMBOL_CLASS (sym) == LOC_BLOCK)
+ && sym->domain () == VAR_DOMAIN
+ && sym->aclass () == LOC_BLOCK)
{
/* The call to canonicalize returns the empty string if the input
string is already in canonical form, thanks to this we don't
const lookup_name_info &lookup_name,
const char *text, const char *word)
{
- if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+ if (sym->aclass () == LOC_TYPEDEF)
{
- struct type *t = SYMBOL_TYPE (sym);
+ struct type *t = sym->type ();
enum type_code c = t->code ();
int j;
if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
for (j = TYPE_N_BASECLASSES (t); j < t->num_fields (); j++)
- if (TYPE_FIELD_NAME (t, j))
+ if (t->field (j).name ())
completion_list_add_name (tracker, sym->language (),
- TYPE_FIELD_NAME (t, j),
+ t->field (j).name (),
lookup_name, text, word);
}
}
bool
symbol_is_function_or_method (symbol *sym)
{
- switch (SYMBOL_TYPE (sym)->code ())
+ switch (sym->type ()->code ())
{
case TYPE_CODE_FUNC:
case TYPE_CODE_METHOD:
bool
symbol_is_function_or_method (minimal_symbol *msymbol)
{
- switch (MSYMBOL_TYPE (msymbol))
+ switch (msymbol->type ())
{
case mst_text:
case mst_text_gnu_ifunc:
bound_minimal_symbol
find_gnu_ifunc (const symbol *sym)
{
- if (SYMBOL_CLASS (sym) != LOC_BLOCK)
+ if (sym->aclass () != LOC_BLOCK)
return {};
lookup_name_info lookup_name (sym->search_name (),
symbol_name_match_type::SEARCH_NAME);
- struct objfile *objfile = symbol_objfile (sym);
+ struct objfile *objfile = sym->objfile ();
- CORE_ADDR address = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym));
+ CORE_ADDR address = sym->value_block ()->entry_pc ();
minimal_symbol *ifunc = NULL;
iterate_over_minimal_symbols (objfile, lookup_name,
[&] (minimal_symbol *minsym)
{
- if (MSYMBOL_TYPE (minsym) == mst_text_gnu_ifunc
- || MSYMBOL_TYPE (minsym) == mst_data_gnu_ifunc)
+ if (minsym->type () == mst_text_gnu_ifunc
+ || minsym->type () == mst_data_gnu_ifunc)
{
- CORE_ADDR msym_addr = MSYMBOL_VALUE_ADDRESS (objfile, minsym);
- if (MSYMBOL_TYPE (minsym) == mst_data_gnu_ifunc)
+ CORE_ADDR msym_addr = minsym->value_address (objfile);
+ if (minsym->type () == mst_data_gnu_ifunc)
{
struct gdbarch *gdbarch = objfile->arch ();
msym_addr = gdbarch_convert_from_func_ptr_addr
enum type_code code)
{
struct symbol *sym;
- const struct block *b;
struct block_iterator iter;
int i;
for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
{
QUIT;
- b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), i);
+
+ const struct block *b = cust->blockvector ()->block (i);
ALL_BLOCK_SYMBOLS (b, iter, sym)
{
if (completion_skip_symbol (mode, sym))
continue;
if (code == TYPE_CODE_UNDEF
- || (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
- && SYMBOL_TYPE (sym)->code () == code))
+ || (sym->domain () == STRUCT_DOMAIN
+ && sym->type ()->code () == code))
completion_list_add_symbol (tracker, sym,
lookup_name,
text, word);
completion_list_add_fields (tracker, sym, lookup_name,
sym_text, word);
}
- else if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
- && SYMBOL_TYPE (sym)->code () == code)
+ else if (sym->domain () == STRUCT_DOMAIN
+ && sym->type ()->code () == code)
completion_list_add_symbol (tracker, sym, lookup_name,
sym_text, word);
}
/* Stop when we encounter an enclosing function. Do not stop for
non-inlined functions - the locals of the enclosing function
are in scope for a nested function. */
- if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
+ if (b->function () != NULL && block_inlined_p (b))
break;
- b = BLOCK_SUPERBLOCK (b);
+ b = b->superblock ();
}
/* Add fields from the file's types; symbols will be added below. */
for symbols which match. */
iterate_over_symtabs (srcfile, [&] (symtab *s)
{
- add_symtab_completions (SYMTAB_COMPUNIT (s),
+ add_symtab_completions (s->compunit (),
tracker, mode, lookup_name,
sym_text, word, TYPE_CODE_UNDEF);
return false;
{
for (compunit_symtab *cu : objfile->compunits ())
{
- for (symtab *s : compunit_filetabs (cu))
+ for (symtab *s : cu->filetabs ())
{
if (not_interesting_fname (s->filename))
continue;
Fallback to "main". */
/* Try to find language for main in psymtabs. */
- enum language lang
- = find_quick_global_symbol_language ("main", VAR_DOMAIN);
- if (lang != language_unknown)
- {
- set_main_name ("main", lang);
- return;
- }
+ bool symbol_found_p = false;
+ gdbarch_iterate_over_objfiles_in_search_order
+ (target_gdbarch (),
+ [&symbol_found_p] (objfile *obj)
+ {
+ language lang
+ = obj->lookup_global_symbol_language ("main", VAR_DOMAIN,
+ &symbol_found_p);
+ if (symbol_found_p)
+ {
+ set_main_name ("main", lang);
+ return 1;
+ }
+
+ return 0;
+ }, nullptr);
+
+ if (symbol_found_p)
+ return;
set_main_name ("main", language_unknown);
}
"ARM/Thumb C/C++ Compiler, RVCT",
"ARM C/C++ Compiler, RVCT"
};
- int i;
if (producer == NULL)
return false;
- for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
- if (startswith (producer, arm_idents[i]))
+ for (const char *ident : arm_idents)
+ if (startswith (producer, ident))
return true;
return false;
/* The globally visible pointer. This is separate from 'symbol_impl'
so that it can be const. */
-const struct symbol_impl *symbol_impls = &symbol_impl[0];
+gdb::array_view<const struct symbol_impl> symbol_impls (symbol_impl);
/* Make sure we saved enough room in struct symbol. */
/* See symtab.h. */
struct objfile *
-symbol_objfile (const struct symbol *symbol)
+symbol::objfile () const
{
- gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
- return SYMTAB_OBJFILE (symbol->owner.symtab);
+ gdb_assert (is_objfile_owned ());
+ return owner.symtab->compunit ()->objfile ();
}
/* See symtab.h. */
struct gdbarch *
-symbol_arch (const struct symbol *symbol)
+symbol::arch () const
{
- if (!SYMBOL_OBJFILE_OWNED (symbol))
- return symbol->owner.arch;
- return SYMTAB_OBJFILE (symbol->owner.symtab)->arch ();
+ if (!is_objfile_owned ())
+ return owner.arch;
+ return owner.symtab->compunit ()->objfile ()->arch ();
}
/* See symtab.h. */
struct symtab *
-symbol_symtab (const struct symbol *symbol)
+symbol::symtab () const
{
- gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
- return symbol->owner.symtab;
+ gdb_assert (is_objfile_owned ());
+ return owner.symtab;
}
/* See symtab.h. */
void
-symbol_set_symtab (struct symbol *symbol, struct symtab *symtab)
+symbol::set_symtab (struct symtab *symtab)
{
- gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
- symbol->owner.symtab = symtab;
+ gdb_assert (is_objfile_owned ());
+ owner.symtab = symtab;
}
/* See symtab.h. */
get_symbol_address (const struct symbol *sym)
{
gdb_assert (sym->maybe_copied);
- gdb_assert (SYMBOL_CLASS (sym) == LOC_STATIC);
+ gdb_assert (sym->aclass () == LOC_STATIC);
const char *linkage_name = sym->linkage_name ();
bound_minimal_symbol minsym
= lookup_minimal_symbol_linkage (linkage_name, objfile);
if (minsym.minsym != nullptr)
- return BMSYMBOL_VALUE_ADDRESS (minsym);
+ return minsym.value_address ();
}
- return sym->value.address;
+ return sym->m_value.address;
}
/* See symtab.h. */
bound_minimal_symbol found
= lookup_minimal_symbol_linkage (linkage_name, objfile);
if (found.minsym != nullptr)
- return BMSYMBOL_VALUE_ADDRESS (found);
+ return found.value_address ();
}
}
- return (minsym->value.address
+ return (minsym->m_value.address
+ objf->section_offsets[minsym->section_index ()]);
}
if (type_regexp == nullptr)
{
if (regexp == nullptr)
- printf_filtered ((kind == VARIABLES_DOMAIN
- ? _("All variables in all modules:")
- : _("All functions in all modules:")));
+ gdb_printf ((kind == VARIABLES_DOMAIN
+ ? _("All variables in all modules:")
+ : _("All functions in all modules:")));
else
- printf_filtered
+ gdb_printf
((kind == VARIABLES_DOMAIN
? _("All variables matching regular expression"
" \"%s\" in all modules:")
else
{
if (regexp == nullptr)
- printf_filtered
+ gdb_printf
((kind == VARIABLES_DOMAIN
? _("All variables with type matching regular "
"expression \"%s\" in all modules:")
"expression \"%s\" in all modules:")),
type_regexp);
else
- printf_filtered
+ gdb_printf
((kind == VARIABLES_DOMAIN
? _("All variables matching regular expression "
"\"%s\",\n\twith type matching regular "
if (type_regexp == nullptr)
{
if (regexp == nullptr)
- printf_filtered
+ gdb_printf
((kind == VARIABLES_DOMAIN
? _("All variables in all modules matching regular "
"expression \"%s\":")
"expression \"%s\":")),
module_regexp);
else
- printf_filtered
+ gdb_printf
((kind == VARIABLES_DOMAIN
? _("All variables matching regular expression "
"\"%s\",\n\tin all modules matching regular "
else
{
if (regexp == nullptr)
- printf_filtered
+ gdb_printf
((kind == VARIABLES_DOMAIN
? _("All variables with type matching regular "
"expression \"%s\"\n\tin all modules matching "
"regular expression \"%s\":")),
type_regexp, module_regexp);
else
- printf_filtered
+ gdb_printf
((kind == VARIABLES_DOMAIN
? _("All variables matching regular expression "
"\"%s\",\n\twith type matching regular expression "
regexp, type_regexp, module_regexp);
}
}
- printf_filtered ("\n");
+ gdb_printf ("\n");
}
/* Find all symbols of type KIND matching the given regular expressions
if (last_module_symbol != p.symbol)
{
- printf_filtered ("\n");
- printf_filtered (_("Module \"%s\":\n"), p.symbol->print_name ());
+ gdb_printf ("\n");
+ gdb_printf (_("Module \"%s\":\n"), p.symbol->print_name ());
last_module_symbol = p.symbol;
last_filename = "";
}
print_symbol_info (FUNCTIONS_DOMAIN, q.symbol, q.block,
last_filename);
last_filename
- = symtab_to_filename_for_display (symbol_symtab (q.symbol));
+ = symtab_to_filename_for_display (q.symbol->symtab ());
}
}
struct info_modules_var_func_options
{
bool quiet = false;
- char *type_regexp = nullptr;
- char *module_regexp = nullptr;
-
- ~info_modules_var_func_options ()
- {
- xfree (type_regexp);
- xfree (module_regexp);
- }
+ std::string type_regexp;
+ std::string module_regexp;
};
/* The options used by 'info module variables' and 'info module functions'
if (args != nullptr && *args == '\0')
args = nullptr;
- info_module_subcommand (opts.quiet, opts.module_regexp, args,
- opts.type_regexp, FUNCTIONS_DOMAIN);
+ info_module_subcommand
+ (opts.quiet,
+ opts.module_regexp.empty () ? nullptr : opts.module_regexp.c_str (), args,
+ opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
+ FUNCTIONS_DOMAIN);
}
/* Implements the 'info module variables' command. */
if (args != nullptr && *args == '\0')
args = nullptr;
- info_module_subcommand (opts.quiet, opts.module_regexp, args,
- opts.type_regexp, VARIABLES_DOMAIN);
+ info_module_subcommand
+ (opts.quiet,
+ opts.module_regexp.empty () ? nullptr : opts.module_regexp.c_str (), args,
+ opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
+ VARIABLES_DOMAIN);
}
/* Command completer for 'info module ...' sub-commands. */
_("global and static variables"),
true));
set_cmd_completer_handle_brkchars (c, info_vars_funcs_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] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\
-Prints the global and static variables.\n"),
- _("global and static variables"),
- true));
- set_cmd_completer_handle_brkchars (c, info_vars_funcs_command_completer);
- }
c = add_info ("functions", info_functions_command,
info_print_args_help (_("\
&maintenance_set_cmdlist,
&maintenance_show_cmdlist);
+ add_setshow_boolean_cmd ("ignore-prologue-end-flag", no_class,
+ &ignore_prologue_end_flag,
+ _("Set if the PROLOGUE-END flag is ignored."),
+ _("Show if the PROLOGUE-END flag is ignored."),
+ _("\
+The PROLOGUE-END flag from the line-table entries is used to place \
+breakpoints past the prologue of functions. Disabeling its use use forces \
+the use of prologue scanners."),
+ nullptr, nullptr,
+ &maintenance_set_cmdlist,
+ &maintenance_show_cmdlist);
+
+
add_cmd ("symbol-cache", class_maintenance, maintenance_print_symbol_cache,
_("Dump the symbol cache for each program space."),
&maintenanceprintlist);
projects / binutils-gdb.git / blobdiff