/* Symbol table lookup for the GNU debugger, GDB.
- Copyright (C) 1986-2018 Free Software Foundation, Inc.
+ Copyright (C) 1986-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "cli/cli-utils.h"
#include "fnmatch.h"
#include "hashtab.h"
+#include "typeprint.h"
#include "gdb_obstack.h"
#include "block.h"
iterate_over_symtabs (const char *name,
gdb::function_view<bool (symtab *)> callback)
{
- struct objfile *objfile;
gdb::unique_xmalloc_ptr<char> real_path;
/* Here we are interested in canonicalizing an absolute path, not
gdb_assert (IS_ABSOLUTE_PATH (real_path.get ()));
}
- ALL_OBJFILES (objfile)
+ for (objfile *objfile : all_objfiles (current_program_space))
{
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. */
- ALL_OBJFILES (objfile)
+ for (objfile *objfile : all_objfiles (current_program_space))
{
if (objfile->sf
&& objfile->sf->qf->map_symtabs_matching_filename (objfile,
else
linkage_name_copy = linkage_name;
+ /* Set the symbol language. */
+ char *demangled_name_ptr
+ = symbol_find_demangled_name (gsymbol, linkage_name_copy);
+ gdb::unique_xmalloc_ptr<char> demangled_name (demangled_name_ptr);
+
entry.mangled = linkage_name_copy;
slot = ((struct demangled_name_entry **)
htab_find_slot (per_bfd->demangled_names_hash,
|| (gsymbol->language == language_go
&& (*slot)->demangled[0] == '\0'))
{
- char *demangled_name = symbol_find_demangled_name (gsymbol,
- linkage_name_copy);
- int demangled_len = demangled_name ? strlen (demangled_name) : 0;
+ int demangled_len = demangled_name ? strlen (demangled_name.get ()) : 0;
/* Suppose we have demangled_name==NULL, copy_name==0, and
linkage_name_copy==linkage_name. In this case, we already have the
}
if (demangled_name != NULL)
- {
- strcpy ((*slot)->demangled, demangled_name);
- xfree (demangled_name);
- }
+ strcpy ((*slot)->demangled, demangled_name.get());
else
(*slot)->demangled[0] = '\0';
}
/* Otherwise check that they are in corresponding objfiles. */
- ALL_OBJFILES (obj)
- if (obj->obfd == first->owner)
- break;
+ for (objfile *objfile : all_objfiles (current_program_space))
+ if (objfile->obfd == first->owner)
+ {
+ obj = objfile;
+ break;
+ }
gdb_assert (obj != NULL);
if (obj->separate_debug_objfile != NULL
void
expand_symtab_containing_pc (CORE_ADDR pc, struct obj_section *section)
{
- struct objfile *objfile;
struct bound_minimal_symbol msymbol;
/* If we know that this is not a text address, return failure. This is
|| MSYMBOL_TYPE (msymbol.minsym) == mst_file_bss))
return;
- ALL_OBJFILES (objfile)
- {
- struct compunit_symtab *cust = NULL;
+ for (objfile *objfile : all_objfiles (current_program_space))
+ {
+ struct compunit_symtab *cust = NULL;
- if (objfile->sf)
- cust = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol,
- pc, section, 0);
- if (cust)
- return;
- }
+ if (objfile->sf)
+ cust = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol,
+ pc, section, 0);
+ if (cust)
+ return;
+ }
}
\f
/* Hash function for the symbol cache. */
addr = SYMBOL_VALUE_ADDRESS (sym);
break;
case LOC_BLOCK:
- addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
+ addr = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym));
break;
default:
if (language == language_cplus || language == language_fortran)
{
- struct block_symbol sym
+ struct block_symbol blocksym
= cp_lookup_symbol_imports_or_template (scope, name, block,
domain);
- if (sym.symbol != NULL)
- return sym;
+ if (blocksym.symbol != NULL)
+ return blocksym;
}
if (BLOCK_FUNCTION (block) != NULL && block_inlined_p (block))
lookup_static_symbol (const char *name, const domain_enum domain)
{
struct symbol_cache *cache = get_symbol_cache (current_program_space);
- struct objfile *objfile;
struct block_symbol result;
struct block_symbol_cache *bsc;
struct symbol_cache_slot *slot;
return result;
}
- ALL_OBJFILES (objfile)
+ for (objfile *objfile : all_objfiles (current_program_space))
{
result = lookup_symbol_in_objfile (objfile, STATIC_BLOCK, name, domain);
if (result.symbol != NULL)
struct type *
basic_lookup_transparent_type (const char *name)
{
- struct objfile *objfile;
struct type *t;
/* Now search all the global symbols. Do the symtab's first, then
of the desired name as a global, then do psymtab-to-symtab
conversion on the fly and return the found symbol. */
- ALL_OBJFILES (objfile)
- {
- t = basic_lookup_transparent_type_1 (objfile, GLOBAL_BLOCK, name);
- if (t)
- return t;
- }
+ for (objfile *objfile : all_objfiles (current_program_space))
+ {
+ t = basic_lookup_transparent_type_1 (objfile, GLOBAL_BLOCK, name);
+ if (t)
+ return t;
+ }
- ALL_OBJFILES (objfile)
- {
- t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK, name);
- if (t)
- return t;
- }
+ for (objfile *objfile : all_objfiles (current_program_space))
+ {
+ t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK, name);
+ if (t)
+ return t;
+ }
/* Now search the static file-level symbols.
Not strictly correct, but more useful than an error.
of the desired name as a file-level static, then do psymtab-to-symtab
conversion on the fly and return the found symbol. */
- ALL_OBJFILES (objfile)
- {
- t = basic_lookup_transparent_type_1 (objfile, STATIC_BLOCK, name);
- if (t)
- return t;
- }
+ for (objfile *objfile : all_objfiles (current_program_space))
+ {
+ t = basic_lookup_transparent_type_1 (objfile, STATIC_BLOCK, name);
+ if (t)
+ return t;
+ }
- ALL_OBJFILES (objfile)
- {
- t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name);
- if (t)
- return t;
- }
+ for (objfile *objfile : all_objfiles (current_program_space))
+ {
+ t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name);
+ if (t)
+ return t;
+ }
return (struct type *) 0;
}
if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
SYMBOL_DOMAIN (sym), domain))
{
- if (!callback (sym))
+ struct block_symbol block_sym = {sym, block};
+
+ if (!callback (&block_sym))
return;
}
}
{
struct compunit_symtab *cust;
struct compunit_symtab *best_cust = NULL;
- struct objfile *objfile;
+ struct objfile *obj_file;
CORE_ADDR distance = 0;
struct bound_minimal_symbol msymbol;
It also happens for objfiles that have their functions reordered.
For these, the symtab we are looking for is not necessarily read in. */
- ALL_COMPUNITS (objfile, cust)
+ ALL_COMPUNITS (obj_file, cust)
{
struct block *b;
const struct blockvector *bv;
/* In order to better support objfiles that contain both
stabs and coff debugging info, we continue on if a psymtab
can't be found. */
- if ((objfile->flags & OBJF_REORDERED) && objfile->sf)
+ if ((obj_file->flags & OBJF_REORDERED) && obj_file->sf)
{
struct compunit_symtab *result;
result
- = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile,
- msymbol,
- pc, section,
- 0);
+ = obj_file->sf->qf->find_pc_sect_compunit_symtab (obj_file,
+ msymbol,
+ pc, section,
+ 0);
if (result != NULL)
return result;
}
ALL_BLOCK_SYMBOLS (b, iter, sym)
{
- fixup_symbol_section (sym, objfile);
- if (matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, sym),
+ fixup_symbol_section (sym, obj_file);
+ if (matching_obj_sections (SYMBOL_OBJ_SECTION (obj_file, sym),
section))
break;
}
/* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
- ALL_OBJFILES (objfile)
- {
- struct compunit_symtab *result;
-
- if (!objfile->sf)
- continue;
- result = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile,
- msymbol,
- pc, section,
- 1);
- if (result != NULL)
- return result;
- }
+ for (objfile *objf : all_objfiles (current_program_space))
+ {
+ struct compunit_symtab *result;
+
+ if (!objf->sf)
+ continue;
+ result = objf->sf->qf->find_pc_sect_compunit_symtab (objf,
+ msymbol,
+ pc, section,
+ 1);
+ if (result != NULL)
+ return result;
+ }
return NULL;
}
struct symbol *
find_symbol_at_address (CORE_ADDR address)
{
- struct objfile *objfile;
-
- ALL_OBJFILES (objfile)
- {
- if (objfile->sf == NULL
- || objfile->sf->qf->find_compunit_symtab_by_address == NULL)
- continue;
-
- struct compunit_symtab *symtab
- = objfile->sf->qf->find_compunit_symtab_by_address (objfile, address);
- if (symtab != NULL)
- {
- const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (symtab);
+ for (objfile *objfile : all_objfiles (current_program_space))
+ {
+ if (objfile->sf == NULL
+ || objfile->sf->qf->find_compunit_symtab_by_address == NULL)
+ continue;
- for (int i = GLOBAL_BLOCK; i <= STATIC_BLOCK; ++i)
- {
- struct block *b = BLOCKVECTOR_BLOCK (bv, i);
- struct block_iterator iter;
- struct symbol *sym;
+ struct compunit_symtab *symtab
+ = objfile->sf->qf->find_compunit_symtab_by_address (objfile, address);
+ if (symtab != NULL)
+ {
+ const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (symtab);
- ALL_BLOCK_SYMBOLS (b, iter, sym)
+ for (int i = GLOBAL_BLOCK; i <= STATIC_BLOCK; ++i)
{
- if (SYMBOL_CLASS (sym) == LOC_STATIC
- && SYMBOL_VALUE_ADDRESS (sym) == address)
- return sym;
+ struct block *b = BLOCKVECTOR_BLOCK (bv, i);
+ struct block_iterator iter;
+ struct symbol *sym;
+
+ ALL_BLOCK_SYMBOLS (b, iter, sym)
+ {
+ if (SYMBOL_CLASS (sym) == LOC_STATIC
+ && SYMBOL_VALUE_ADDRESS (sym) == address)
+ return sym;
+ }
}
- }
- }
- }
+ }
+ }
return NULL;
}
struct symtab *iter_s;
struct linetable *l;
int len;
- int i;
struct linetable_entry *item;
const struct blockvector *bv;
struct bound_minimal_symbol msymbol;
if (item->pc > pc && (!alt || item->pc < alt->pc))
alt = item;
- auto pc_compare = [](const CORE_ADDR & pc,
+ auto pc_compare = [](const CORE_ADDR & comp_pc,
const struct linetable_entry & lhs)->bool
{
- return pc < lhs.pc;
+ return comp_pc < lhs.pc;
};
struct linetable_entry *first = item;
BEST_INDEX and BEST_LINETABLE identify the item for it. */
int best;
- struct objfile *objfile;
struct compunit_symtab *cu;
struct symtab *s;
else
best = 0;
- ALL_OBJFILES (objfile)
- {
- if (objfile->sf)
- objfile->sf->qf->expand_symtabs_with_fullname (objfile,
- symtab_to_fullname (symtab));
- }
+ for (objfile *objfile : all_objfiles (current_program_space))
+ {
+ if (objfile->sf)
+ objfile->sf->qf->expand_symtabs_with_fullname
+ (objfile, symtab_to_fullname (symtab));
+ }
+ struct objfile *objfile;
ALL_FILETABS (objfile, cu, s)
{
struct linetable *l;
{
fixup_symbol_section (sym, NULL);
symtab_and_line sal
- = find_function_start_sal_1 (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
+ = find_function_start_sal_1 (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)),
SYMBOL_OBJ_SECTION (symbol_objfile (sym), sym),
funfirstline);
sal.symbol = sym;
fixup_symbol_section (sym, NULL);
objfile = symbol_objfile (sym);
- pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
+ pc = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym));
section = SYMBOL_OBJ_SECTION (objfile, sym);
name = SYMBOL_LINKAGE_NAME (sym);
}
/* 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_START (SYMBOL_BLOCK_VALUE (sym)) <= start_sal.end
+ && (sym ? (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)) <= start_sal.end
&& start_sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
: (lookup_minimal_symbol_by_pc_section (start_sal.end, section).minsym
== lookup_minimal_symbol_by_pc_section (pc, section).minsym)))
symbol *sym = find_pc_function (func_addr);
if (sym != NULL
&& SYMBOL_CLASS (sym) == LOC_BLOCK
- && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == func_addr)
+ && BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)) == func_addr)
return sym;
return NULL;
SYMBOL_PRINT_NAME (sym_b.symbol));
}
+/* Returns true if the type_name of symbol_type of SYM matches TREG.
+ If SYM has no symbol_type or symbol_name, returns false. */
+
+bool
+treg_matches_sym_type_name (const compiled_regex &treg,
+ const struct symbol *sym)
+{
+ 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",
+ SYMBOL_NATURAL_NAME (sym));
+ }
+
+ sym_type = SYMBOL_TYPE (sym);
+ if (sym_type == NULL)
+ return false;
+
+ {
+ scoped_switch_to_sym_language_if_auto l (sym);
+
+ 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 ());
+ }
+
+
+ if (printed_sym_type_name.empty ())
+ return false;
+
+ return treg.exec (printed_sym_type_name.c_str (), 0, NULL, 0) == 0;
+}
+
+
/* Sort the symbols in RESULT and remove duplicates. */
static void
Only symbols of KIND are searched:
VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
- and constants (enums)
+ and constants (enums).
+ if T_REGEXP is not NULL, only returns var that have
+ a type matching regular expression T_REGEXP.
FUNCTIONS_DOMAIN - search all functions
TYPES_DOMAIN - search all type names
ALL_DOMAIN - an internal error for this function
std::vector<symbol_search>
search_symbols (const char *regexp, enum search_domain kind,
+ const char *t_regexp,
int nfiles, const char *files[])
{
struct compunit_symtab *cust;
enum minimal_symbol_type ourtype4;
std::vector<symbol_search> result;
gdb::optional<compiled_regex> preg;
+ gdb::optional<compiled_regex> treg;
gdb_assert (kind <= TYPES_DOMAIN);
preg.emplace (regexp, cflags, _("Invalid regexp"));
}
+ if (t_regexp != NULL)
+ {
+ int cflags = REG_NOSUB | (case_sensitivity == case_sensitive_off
+ ? REG_ICASE : 0);
+ treg.emplace (t_regexp, cflags, _("Invalid regexp"));
+ }
+
/* Search through the partial symtabs *first* for all symbols
matching the regexp. That way we don't have to reproduce all of
the machinery below. */
lookup_name_info::match_any (),
[&] (const char *symname)
{
- return (!preg || preg->exec (symname,
- 0, NULL, 0) == 0);
+ return (!preg.has_value ()
+ || preg->exec (symname,
+ 0, NULL, 0) == 0);
},
NULL,
kind);
|| MSYMBOL_TYPE (msymbol) == ourtype3
|| MSYMBOL_TYPE (msymbol) == ourtype4)
{
- if (!preg
+ if (!preg.has_value ()
|| preg->exec (MSYMBOL_NATURAL_NAME (msymbol), 0,
NULL, 0) == 0)
{
files, nfiles, 1))
&& file_matches (symtab_to_fullname (real_symtab),
files, nfiles, 0)))
- && ((!preg
+ && ((!preg.has_value ()
|| preg->exec (SYMBOL_NATURAL_NAME (sym), 0,
NULL, 0) == 0)
&& ((kind == VARIABLES_DOMAIN
We only want to skip enums here. */
&& !(SYMBOL_CLASS (sym) == LOC_CONST
&& (TYPE_CODE (SYMBOL_TYPE (sym))
- == TYPE_CODE_ENUM)))
- || (kind == FUNCTIONS_DOMAIN
- && SYMBOL_CLASS (sym) == LOC_BLOCK)
+ == TYPE_CODE_ENUM))
+ && (!treg.has_value ()
+ || treg_matches_sym_type_name (*treg, sym)))
+ || (kind == FUNCTIONS_DOMAIN
+ && SYMBOL_CLASS (sym) == LOC_BLOCK
+ && (!treg.has_value ()
+ || treg_matches_sym_type_name (*treg, sym)))
|| (kind == TYPES_DOMAIN
&& SYMBOL_CLASS (sym) == LOC_TYPEDEF))))
{
sort_search_symbols_remove_dups (&result);
/* If there are no eyes, avoid all contact. I mean, if there are
- no debug symbols, then add matching minsyms. */
+ no debug symbols, then add matching minsyms. But if the user wants
+ to see symbols matching a type regexp, then never give a minimal symbol,
+ as we assume that a minimal symbol does not have a type. */
- if (found_misc || (nfiles == 0 && kind != FUNCTIONS_DOMAIN))
+ if ((found_misc || (nfiles == 0 && kind != FUNCTIONS_DOMAIN))
+ && !treg.has_value ())
{
ALL_MSYMBOLS (objfile, msymbol)
{
|| MSYMBOL_TYPE (msymbol) == ourtype3
|| MSYMBOL_TYPE (msymbol) == ourtype4)
{
- if (!preg || preg->exec (MSYMBOL_NATURAL_NAME (msymbol), 0,
- NULL, 0) == 0)
+ if (!preg.has_value ()
+ || preg->exec (MSYMBOL_NATURAL_NAME (msymbol), 0,
+ NULL, 0) == 0)
{
/* For functions we can do a quick check of whether the
symbol might be found via find_pc_symtab. */
struct symbol *sym,
int block, const char *last)
{
+ scoped_switch_to_sym_language_if_auto l (sym);
struct symtab *s = symbol_symtab (sym);
if (last != NULL)
matches. */
static void
-symtab_symbol_info (const char *regexp, enum search_domain kind, int from_tty)
+symtab_symbol_info (bool quiet,
+ const char *regexp, enum search_domain kind,
+ const char *t_regexp, int from_tty)
{
static const char * const classnames[] =
{"variable", "function", "type"};
gdb_assert (kind <= TYPES_DOMAIN);
/* Must make sure that if we're interrupted, symbols gets freed. */
- std::vector<symbol_search> symbols = search_symbols (regexp, kind, 0, NULL);
+ std::vector<symbol_search> symbols = search_symbols (regexp, kind,
+ t_regexp, 0, NULL);
- if (regexp != NULL)
- printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
- classnames[kind], regexp);
- else
- printf_filtered (_("All defined %ss:\n"), classnames[kind]);
+ if (!quiet)
+ {
+ if (regexp != NULL)
+ {
+ if (t_regexp != NULL)
+ printf_filtered
+ (_("All %ss matching regular expression \"%s\""
+ " with type matching regulation expression \"%s\":\n"),
+ classnames[kind], regexp, t_regexp);
+ else
+ printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
+ classnames[kind], regexp);
+ }
+ else
+ {
+ if (t_regexp != NULL)
+ printf_filtered
+ (_("All defined %ss"
+ " with type matching regulation expression \"%s\" :\n"),
+ classnames[kind], t_regexp);
+ else
+ printf_filtered (_("All defined %ss:\n"), classnames[kind]);
+ }
+ }
for (const symbol_search &p : symbols)
{
{
if (first)
{
- printf_filtered (_("\nNon-debugging symbols:\n"));
+ if (!quiet)
+ printf_filtered (_("\nNon-debugging symbols:\n"));
first = 0;
}
print_msymbol_info (p.msymbol);
}
static void
-info_variables_command (const char *regexp, int from_tty)
+info_variables_command (const char *args, int from_tty)
{
- symtab_symbol_info (regexp, VARIABLES_DOMAIN, from_tty);
+ std::string regexp;
+ std::string t_regexp;
+ bool quiet = false;
+
+ while (args != NULL
+ && extract_info_print_args (&args, &quiet, ®exp, &t_regexp))
+ ;
+
+ if (args != NULL)
+ report_unrecognized_option_error ("info variables", args);
+
+ symtab_symbol_info (quiet,
+ regexp.empty () ? NULL : regexp.c_str (),
+ VARIABLES_DOMAIN,
+ t_regexp.empty () ? NULL : t_regexp.c_str (),
+ from_tty);
}
+
static void
-info_functions_command (const char *regexp, int from_tty)
+info_functions_command (const char *args, int from_tty)
{
- symtab_symbol_info (regexp, FUNCTIONS_DOMAIN, from_tty);
+ std::string regexp;
+ std::string t_regexp;
+ bool quiet = false;
+
+ while (args != NULL
+ && extract_info_print_args (&args, &quiet, ®exp, &t_regexp))
+ ;
+
+ if (args != NULL)
+ report_unrecognized_option_error ("info functions", args);
+
+ symtab_symbol_info (quiet,
+ regexp.empty () ? NULL : regexp.c_str (),
+ FUNCTIONS_DOMAIN,
+ t_regexp.empty () ? NULL : t_regexp.c_str (),
+ from_tty);
}
static void
info_types_command (const char *regexp, int from_tty)
{
- symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty);
+ symtab_symbol_info (false, regexp, TYPES_DOMAIN, NULL, from_tty);
}
/* Breakpoint all functions matching regular expression. */
std::vector<symbol_search> symbols = search_symbols (regexp,
FUNCTIONS_DOMAIN,
+ NULL,
nfiles, files);
scoped_rbreak_breakpoints finalize;
symbol_name_match_type::SEARCH_NAME);
struct objfile *objfile = symbol_objfile (sym);
- CORE_ADDR address = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
+ CORE_ADDR address = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym));
minimal_symbol *ifunc = NULL;
iterate_over_minimal_symbols (objfile, lookup_name,
find_main_name (void)
{
const char *new_main_name;
- struct objfile *objfile;
/* First check the objfiles to see whether a debuginfo reader has
picked up the appropriate main name. Historically the main name
relies on the order of objfile creation -- which still isn't
guaranteed to get the correct answer, but is just probably more
accurate. */
- ALL_OBJFILES (objfile)
- {
- if (objfile->per_bfd->name_of_main != NULL)
- {
- set_main_name (objfile->per_bfd->name_of_main,
- objfile->per_bfd->language_of_main);
- return;
- }
- }
+ for (objfile *objfile : all_objfiles (current_program_space))
+ {
+ if (objfile->per_bfd->name_of_main != NULL)
+ {
+ set_main_name (objfile->per_bfd->name_of_main,
+ objfile->per_bfd->language_of_main);
+ return;
+ }
+ }
/* Try to see if the main procedure is in Ada. */
/* FIXME: brobecker/2005-03-07: Another way of doing this would
symbol_cache_key
= register_program_space_data_with_cleanup (NULL, symbol_cache_cleanup);
- add_info ("variables", info_variables_command, _("\
-All global and static variable names, or those matching REGEXP."));
+ 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\
+Prints the global and static variables.\n"),
+ _("global and static variables")));
if (dbx_commands)
- add_com ("whereis", class_info, info_variables_command, _("\
-All global and static variable names, or those matching REGEXP."));
+ 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\
+Prints the global and static variables.\n"),
+ _("global and static variables")));
add_info ("functions", info_functions_command,
- _("All function names, or those matching REGEXP."));
+ info_print_args_help (_("\
+All function names or those matching REGEXPs.\n\
+Usage: info functions [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
+Prints the functions.\n"),
+ _("functions")));
/* FIXME: This command has at least the following problems:
1. It prints builtin types (in a very strange and confusing fashion).
projects / deliverable / binutils-gdb.git / blobdiff