#include "p-lang.h"
#include "addrmap.h"
#include "cli/cli-utils.h"
+#include "cli/cli-style.h"
#include "fnmatch.h"
#include "hashtab.h"
#include "typeprint.h"
lookup_symbol_in_objfile (struct objfile *objfile, int block_index,
const char *name, const domain_enum domain);
-/* See symtab.h. */
-const struct block_symbol null_block_symbol = { NULL, NULL };
-
/* Program space key for finding name and language of "main". */
static const struct program_space_data *main_progspace_key;
return SYMTAB_LANGUAGE (symtab);
}
+/* 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;
+}
+
+/* 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;
+}
+
/* See whether FILENAME matches SEARCH_NAME using the rule that we
advertise to the user. (The manual's description of linespecs
describes what we advertise). Returns true if they match, false
gdb_assert (IS_ABSOLUTE_PATH (real_path.get ()));
}
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
if (iterate_over_some_symtabs (name, real_path.get (),
objfile->compunit_symtabs, NULL,
/* Same search rules as above apply here, but now we look thru the
psymtabs. */
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
if (objfile->sf
&& objfile->sf->qf->map_symtabs_matching_filename (objfile,
Choosing a much larger table size wastes memory, and saves only about
1% in symbol reading. */
- per_bfd->demangled_names_hash = htab_create_alloc
+ per_bfd->demangled_names_hash.reset (htab_create_alloc
(256, hash_demangled_name_entry, eq_demangled_name_entry,
- NULL, xcalloc, xfree);
+ NULL, xcalloc, xfree));
}
/* Try to determine the demangled name for a symbol, based on the
entry.mangled = linkage_name_copy;
slot = ((struct demangled_name_entry **)
- htab_find_slot (per_bfd->demangled_names_hash,
+ htab_find_slot (per_bfd->demangled_names_hash.get (),
&entry, INSERT));
/* If this name is not in the hash table, add it. */
/* Otherwise check that they are in corresponding objfiles. */
struct objfile *obj = NULL;
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
if (objfile->obfd == first->owner)
{
obj = objfile;
necessary because we loop based on texthigh and textlow, which do
not include the data ranges. */
msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
- if (msymbol.minsym
- && (MSYMBOL_TYPE (msymbol.minsym) == mst_data
- || MSYMBOL_TYPE (msymbol.minsym) == mst_bss
- || MSYMBOL_TYPE (msymbol.minsym) == mst_abs
- || MSYMBOL_TYPE (msymbol.minsym) == mst_file_data
- || MSYMBOL_TYPE (msymbol.minsym) == mst_file_bss))
+ if (msymbol.minsym && msymbol.minsym->data_p ())
return;
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
struct compunit_symtab *cust = NULL;
{
*bsc_ptr = NULL;
*slot_ptr = NULL;
- return (struct block_symbol) {NULL, NULL};
+ return {};
}
hash = hash_symbol_entry (objfile_context, name, domain);
name, domain_name (domain));
}
++bsc->misses;
- return (struct block_symbol) {NULL, NULL};
+ return {};
}
/* Clear out SLOT. */
const struct block *block)
{
if (lang->la_name_of_this == NULL || block == NULL)
- return (struct block_symbol) {NULL, NULL};
+ return {};
if (symbol_lookup_debug > 1)
{
if (symbol_lookup_debug > 1)
fprintf_unfiltered (gdb_stdlog, " = NULL\n");
- return (struct block_symbol) {NULL, NULL};
+ return {};
}
/* Given TYPE, a structure/union,
fprintf_unfiltered (gdb_stdlog,
"lookup_symbol_aux (...) = NULL\n");
}
- return (struct block_symbol) {NULL, NULL};
+ return {};
}
}
}
/* Check if either no block is specified or it's a global block. */
if (static_block == NULL)
- return (struct block_symbol) {NULL, NULL};
+ return {};
while (block != static_block)
{
/* We've reached the end of the function without finding a result. */
- return (struct block_symbol) {NULL, NULL};
+ return {};
}
/* See symtab.h. */
block = block_global_block (block);
/* Look through all blockvectors. */
- for (objfile *obj : all_objfiles (current_program_space))
+ for (objfile *obj : current_program_space->objfiles ())
{
- for (compunit_symtab *cust : objfile_compunits (obj))
+ for (compunit_symtab *cust : obj->compunits ())
if (block == BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust),
GLOBAL_BLOCK))
{
return result;
}
- return (struct block_symbol) {NULL, NULL};
+ return {};
}
/* Check to see if the symbol is defined in one of the OBJFILE's
name, domain_name (domain));
}
- for (compunit_symtab *cust : objfile_compunits (objfile))
+ for (compunit_symtab *cust : objfile->compunits ())
{
const struct blockvector *bv;
const struct block *block;
if (symbol_lookup_debug > 1)
fprintf_unfiltered (gdb_stdlog, " = NULL\n");
- return (struct block_symbol) {NULL, NULL};
+ return {};
}
/* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols.
Normally we only look in OBJFILE, and not any separate debug objfiles
because the outer loop will cause them to be searched too. This case is
different. Here we're called from search_symbols where it will only
- call us for the the objfile that contains a matching minsym. */
+ call us for the objfile that contains a matching minsym. */
static struct block_symbol
lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile,
return result;
}
- return (struct block_symbol) {NULL, NULL};
+ return {};
}
/* A helper function that throws an exception when a symbol was found
struct block_symbol result;
if (!objfile->sf)
- return (struct block_symbol) {NULL, NULL};
+ return {};
if (symbol_lookup_debug > 1)
{
fprintf_unfiltered (gdb_stdlog,
"lookup_symbol_via_quick_fns (...) = NULL\n");
}
- return (struct block_symbol) {NULL, NULL};
+ return {};
}
bv = COMPUNIT_BLOCKVECTOR (cust);
struct symbol *sym;
if (static_block == NULL)
- return (struct block_symbol) {NULL, NULL};
+ return {};
if (symbol_lookup_debug)
{
if (result.symbol != NULL)
{
if (SYMBOL_LOOKUP_FAILED_P (result))
- return (struct block_symbol) {NULL, NULL};
+ return {};
return result;
}
- for (objfile *objfile : all_objfiles (current_program_space))
+ 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_not_found (bsc, slot, NULL, name, domain);
- return (struct block_symbol) {NULL, NULL};
+ return {};
}
/* Private data to be used with lookup_symbol_global_iterator_cb. */
if (result.symbol != NULL)
{
if (SYMBOL_LOOKUP_FAILED_P (result))
- return (struct block_symbol) {NULL, NULL};
+ return {};
return result;
}
{
struct compunit_symtab *cust;
const struct blockvector *bv;
- struct block *block;
+ const struct block *block;
struct symbol *sym;
if (!objfile->sf)
const struct block *block;
const struct symbol *sym;
- for (compunit_symtab *cust : objfile_compunits (objfile))
+ for (compunit_symtab *cust : objfile->compunits ())
{
bv = COMPUNIT_BLOCKVECTOR (cust);
block = BLOCKVECTOR_BLOCK (bv, block_index);
of the desired name as a global, then do psymtab-to-symtab
conversion on the fly and return the found symbol. */
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
t = basic_lookup_transparent_type_1 (objfile, GLOBAL_BLOCK, name);
if (t)
return t;
}
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK, name);
if (t)
of the desired name as a file-level static, then do psymtab-to-symtab
conversion on the fly and return the found symbol. */
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
t = basic_lookup_transparent_type_1 (objfile, STATIC_BLOCK, name);
if (t)
return t;
}
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name);
if (t)
we call find_pc_sect_psymtab which has a similar restriction based
on the partial_symtab's texthigh and textlow. */
msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
- if (msymbol.minsym
- && (MSYMBOL_TYPE (msymbol.minsym) == mst_data
- || MSYMBOL_TYPE (msymbol.minsym) == mst_bss
- || MSYMBOL_TYPE (msymbol.minsym) == mst_abs
- || MSYMBOL_TYPE (msymbol.minsym) == mst_file_data
- || MSYMBOL_TYPE (msymbol.minsym) == mst_file_bss))
+ if (msymbol.minsym && msymbol.minsym->data_p ())
return NULL;
/* Search all symtabs for the one whose file contains our address, and which
It also happens for objfiles that have their functions reordered.
For these, the symtab we are looking for is not necessarily read in. */
- for (objfile *obj_file : all_objfiles (current_program_space))
+ for (objfile *obj_file : current_program_space->objfiles ())
{
- for (compunit_symtab *cust : objfile_compunits (obj_file))
+ for (compunit_symtab *cust : obj_file->compunits ())
{
- struct block *b;
+ const struct block *b;
const struct blockvector *bv;
bv = COMPUNIT_BLOCKVECTOR (cust);
/* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
- for (objfile *objf : all_objfiles (current_program_space))
+ for (objfile *objf : current_program_space->objfiles ())
{
struct compunit_symtab *result;
struct symbol *
find_symbol_at_address (CORE_ADDR address)
{
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
if (objfile->sf == NULL
|| objfile->sf->qf->find_compunit_symtab_by_address == NULL)
for (int i = GLOBAL_BLOCK; i <= STATIC_BLOCK; ++i)
{
- struct block *b = BLOCKVECTOR_BLOCK (bv, i);
+ const struct block *b = BLOCKVECTOR_BLOCK (bv, i);
struct block_iterator iter;
struct symbol *sym;
else
best = 0;
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
if (objfile->sf)
objfile->sf->qf->expand_symtabs_with_fullname
(objfile, symtab_to_fullname (sym_tab));
}
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
- for (compunit_symtab *cu : objfile_compunits (objfile))
+ for (compunit_symtab *cu : objfile->compunits ())
{
for (symtab *s : compunit_filetabs (cu))
{
data->first = 0;
wrap_here ("");
- fputs_filtered (name, gdb_stdout);
+ fputs_styled (name, file_name_style.style (), gdb_stdout);
}
/* A callback for map_partial_symbol_filenames. */
printf_filtered ("Source files for which symbols have been read in:\n\n");
data.first = 1;
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
- for (compunit_symtab *cu : objfile_compunits (objfile))
+ for (compunit_symtab *cu : objfile->compunits ())
{
for (symtab *s : compunit_filetabs (cu))
{
int nfiles, const char *files[])
{
const struct blockvector *bv;
- struct block *b;
+ const struct block *b;
int i = 0;
struct block_iterator iter;
struct symbol *sym;
if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
{
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
- for (minimal_symbol *msymbol : objfile_msymbols (objfile))
+ for (minimal_symbol *msymbol : objfile->msymbols ())
{
QUIT;
}
}
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
- for (compunit_symtab *cust : objfile_compunits (objfile))
+ for (compunit_symtab *cust : objfile->compunits ())
{
bv = COMPUNIT_BLOCKVECTOR (cust);
for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
if ((found_misc || (nfiles == 0 && kind != FUNCTIONS_DOMAIN))
&& !treg.has_value ())
{
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
- for (minimal_symbol *msymbol : objfile_msymbols (objfile))
+ for (minimal_symbol *msymbol : objfile->msymbols ())
{
QUIT;
if (filename_cmp (last, s_filename) != 0)
{
fputs_filtered ("\nFile ", gdb_stdout);
- fputs_filtered (s_filename, gdb_stdout);
+ fputs_styled (s_filename, file_name_style.style (), gdb_stdout);
fputs_filtered (":\n", gdb_stdout);
}
else
tmp = hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol),
16);
- printf_filtered ("%s %s\n",
- tmp, MSYMBOL_PRINT_NAME (msymbol.minsym));
+ 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);
}
/* This is the guts of the commands "info functions", "info types", and
if (t_regexp != NULL)
printf_filtered
(_("All %ss matching regular expression \"%s\""
- " with type matching regulation expression \"%s\":\n"),
+ " with type matching regular expression \"%s\":\n"),
classnames[kind], regexp, t_regexp);
else
printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
if (t_regexp != NULL)
printf_filtered
(_("All defined %ss"
- " with type matching regulation expression \"%s\" :\n"),
+ " with type matching regular expression \"%s\" :\n"),
classnames[kind], t_regexp);
else
printf_filtered (_("All defined %ss:\n"), classnames[kind]);
if (code == TYPE_CODE_UNDEF)
{
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
- for (minimal_symbol *msymbol : objfile_msymbols (objfile))
+ for (minimal_symbol *msymbol : objfile->msymbols ())
{
QUIT;
}
/* Add completions for all currently loaded symbol tables. */
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
- for (compunit_symtab *cust : objfile_compunits (objfile))
+ for (compunit_symtab *cust : objfile->compunits ())
add_symtab_completions (cust, tracker, mode, lookup_name,
sym_text, word, code);
}
filename_seen_cache filenames_seen;
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
- for (compunit_symtab *cu : objfile_compunits (objfile))
+ for (compunit_symtab *cu : objfile->compunits ())
{
for (symtab *s : compunit_filetabs (cu))
{
relies on the order of objfile creation -- which still isn't
guaranteed to get the correct answer, but is just probably more
accurate. */
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
if (objfile->per_bfd->name_of_main != NULL)
{