Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009,
- 2010 Free Software Foundation, Inc.
+ 2010, 2011 Free Software Foundation, Inc.
This file is part of GDB.
/* Block in which the most recently searched-for symbol was found.
Might be better to make this a parameter to lookup_symbol and
- value_of_this. */
+ value_of_this. */
const struct block *block_found;
got_symtab:
- /* First, search for an exact match */
+ /* First, search for an exact match. */
ALL_SYMTABS (objfile, s)
{
}
}
- /* Now, search for a matching tail (only if name doesn't have any dirs) */
+ /* Now, search for a matching tail (only if name doesn't have any dirs). */
if (lbasename (name) == name)
ALL_SYMTABS (objfile, s)
been created. So, we need to run through the symtabs again in
order to find the file.
XXX - This is a crock, and should be fixed inside of the the
- symbol parsing routines. */
+ symbol parsing routines. */
goto got_symtab;
}
\f
/* Mangle a GDB method stub type. This actually reassembles the pieces of the
full method name, which consist of the class name (from T), the unadorned
method name from METHOD_ID, and the signature for the specific overload,
- specified by SIGNATURE_ID. Note that this function is g++ specific. */
+ specified by SIGNATURE_ID. Note that this function is g++ specific. */
char *
gdb_mangle_name (struct type *type, int method_id, int signature_id)
is_full_physname_constructor = is_constructor_name (physname);
- is_constructor =
- is_full_physname_constructor || (newname && strcmp (field_name, newname) == 0);
+ is_constructor = is_full_physname_constructor
+ || (newname && strcmp (field_name, newname) == 0);
if (!is_destructor)
is_destructor = (strncmp (physname, "__dt", 4) == 0);
strcat (mangled_name, buf);
/* If the class doesn't have a name, i.e. newname NULL, then we just
mangle it using 0 for the length of the class. Thus it gets mangled
- as something starting with `::' rather than `classname::'. */
+ as something starting with `::' rather than `classname::'. */
if (newname != NULL)
strcat (mangled_name, newname);
return (mangled_name);
}
+/* Initialize the cplus_specific structure. 'cplus_specific' should
+ only be allocated for use with cplus symbols. */
+
+static void
+symbol_init_cplus_specific (struct general_symbol_info *gsymbol,
+ struct objfile *objfile)
+{
+ /* A language_specific structure should not have been previously
+ initialized. */
+ gdb_assert (gsymbol->language_specific.cplus_specific == NULL);
+ gdb_assert (objfile != NULL);
+
+ gsymbol->language_specific.cplus_specific =
+ OBSTACK_ZALLOC (&objfile->objfile_obstack, struct cplus_specific);
+}
+
+/* Set the demangled name of GSYMBOL to NAME. NAME must be already
+ correctly allocated. For C++ symbols a cplus_specific struct is
+ allocated so OBJFILE must not be NULL. If this is a non C++ symbol
+ OBJFILE can be NULL. */
+void
+symbol_set_demangled_name (struct general_symbol_info *gsymbol,
+ char *name,
+ struct objfile *objfile)
+{
+ if (gsymbol->language == language_cplus)
+ {
+ if (gsymbol->language_specific.cplus_specific == NULL)
+ symbol_init_cplus_specific (gsymbol, objfile);
+
+ gsymbol->language_specific.cplus_specific->demangled_name = name;
+ }
+ else
+ gsymbol->language_specific.mangled_lang.demangled_name = name;
+}
+
+/* Return the demangled name of GSYMBOL. */
+char *
+symbol_get_demangled_name (const struct general_symbol_info *gsymbol)
+{
+ if (gsymbol->language == language_cplus)
+ {
+ if (gsymbol->language_specific.cplus_specific != NULL)
+ return gsymbol->language_specific.cplus_specific->demangled_name;
+ else
+ return NULL;
+ }
+ else
+ return gsymbol->language_specific.mangled_lang.demangled_name;
+}
+
\f
/* Initialize the language dependent portion of a symbol
- depending upon the language for the symbol. */
+ depending upon the language for the symbol. */
void
-symbol_init_language_specific (struct general_symbol_info *gsymbol,
- enum language language)
+symbol_set_language (struct general_symbol_info *gsymbol,
+ enum language language)
{
gsymbol->language = language;
- if (gsymbol->language == language_cplus
- || gsymbol->language == language_d
+ if (gsymbol->language == language_d
|| gsymbol->language == language_java
|| gsymbol->language == language_objc
|| gsymbol->language == language_fortran)
{
- gsymbol->language_specific.cplus_specific.demangled_name = NULL;
+ symbol_set_demangled_name (gsymbol, NULL, NULL);
}
+ else if (gsymbol->language == language_cplus)
+ gsymbol->language_specific.cplus_specific = NULL;
else
{
memset (&gsymbol->language_specific, 0,
memcpy (gsymbol->name, linkage_name, len);
gsymbol->name[len] = '\0';
}
- gsymbol->language_specific.cplus_specific.demangled_name = NULL;
+ symbol_set_demangled_name (gsymbol, NULL, NULL);
return;
}
gsymbol->name = (*slot)->mangled + lookup_len - len;
if ((*slot)->demangled[0] != '\0')
- gsymbol->language_specific.cplus_specific.demangled_name
- = (*slot)->demangled;
+ symbol_set_demangled_name (gsymbol, (*slot)->demangled, objfile);
else
- gsymbol->language_specific.cplus_specific.demangled_name = NULL;
+ symbol_set_demangled_name (gsymbol, NULL, objfile);
}
/* Return the source code name of a symbol. In languages where
case language_java:
case language_objc:
case language_fortran:
- if (gsymbol->language_specific.cplus_specific.demangled_name != NULL)
- return gsymbol->language_specific.cplus_specific.demangled_name;
+ if (symbol_get_demangled_name (gsymbol) != NULL)
+ return symbol_get_demangled_name (gsymbol);
break;
case language_ada:
- if (gsymbol->language_specific.cplus_specific.demangled_name != NULL)
- return gsymbol->language_specific.cplus_specific.demangled_name;
+ if (symbol_get_demangled_name (gsymbol) != NULL)
+ return symbol_get_demangled_name (gsymbol);
else
return ada_decode_symbol (gsymbol);
break;
}
/* Return the demangled name for a symbol based on the language for
- that symbol. If no demangled name exists, return NULL. */
+ that symbol. If no demangled name exists, return NULL. */
char *
symbol_demangled_name (const struct general_symbol_info *gsymbol)
{
case language_java:
case language_objc:
case language_fortran:
- if (gsymbol->language_specific.cplus_specific.demangled_name != NULL)
- return gsymbol->language_specific.cplus_specific.demangled_name;
+ if (symbol_get_demangled_name (gsymbol) != NULL)
+ return symbol_get_demangled_name (gsymbol);
break;
case language_ada:
- if (gsymbol->language_specific.cplus_specific.demangled_name != NULL)
- return gsymbol->language_specific.cplus_specific.demangled_name;
+ if (symbol_get_demangled_name (gsymbol) != NULL)
+ return symbol_get_demangled_name (gsymbol);
else
return ada_decode_symbol (gsymbol);
break;
/* Return the search name of a symbol---generally the demangled or
linkage name of the symbol, depending on how it will be searched for.
If there is no distinct demangled name, then returns the same value
- (same pointer) as SYMBOL_LINKAGE_NAME. */
+ (same pointer) as SYMBOL_LINKAGE_NAME. */
char *
symbol_search_name (const struct general_symbol_info *gsymbol)
{
NAME is a field of the current implied argument `this'. If so set
*IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
BLOCK_FOUND is set to the block in which NAME is found (in the case of
- a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
+ a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
/* This function has a bunch of loops in it and it would seem to be
attractive to put in some QUIT's (though I'm not really sure
modified_name = name;
/* If we are using C++, D, or Java, demangle the name before doing a
- lookup, so we can always binary search. */
+ lookup, so we can always binary search. */
if (lang == language_cplus)
{
demangled_name = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
/* Search all static file-level symbols for NAME from DOMAIN. Do the symtabs
first, then check the psymtabs. If a psymtab indicates the existence of the
desired name as a file-level static, then do psymtab-to-symtab conversion on
- the fly and return the found symbol. */
+ the fly and return the found symbol. */
struct symbol *
lookup_static_symbol_aux (const char *name, const domain_enum domain)
if (language == language_cplus || language == language_fortran)
{
- sym = cp_lookup_symbol_imports (scope,
- name,
- block,
- domain,
- 1,
- 1);
+ sym = cp_lookup_symbol_imports_or_template (scope, name, block,
+ domain);
if (sym != NULL)
return sym;
}
const struct block *block;
struct symtab *s;
- ALL_PRIMARY_SYMTABS (objfile, s)
+ ALL_OBJFILES (objfile)
{
- bv = BLOCKVECTOR (s);
- block = BLOCKVECTOR_BLOCK (bv, block_index);
- sym = lookup_block_symbol (block, name, domain);
- if (sym)
- {
- block_found = block;
- return fixup_symbol_section (sym, objfile);
- }
+ if (objfile->sf)
+ objfile->sf->qf->pre_expand_symtabs_matching (objfile,
+ block_index,
+ name, domain);
+
+ ALL_OBJFILE_SYMTABS (objfile, s)
+ if (s->primary)
+ {
+ bv = BLOCKVECTOR (s);
+ block = BLOCKVECTOR_BLOCK (bv, block_index);
+ sym = lookup_block_symbol (block, name, domain);
+ if (sym)
+ {
+ block_found = block;
+ return fixup_symbol_section (sym, objfile);
+ }
+ }
}
return NULL;
{
/* This shouldn't be necessary, but as a last resort try
looking in the statics even though the psymtab claimed
- the symbol was global, or vice-versa. It's possible
+ the symbol was global, or vice-versa. It's possible
that the psymtab gets it wrong in some cases. */
/* FIXME: carlton/2002-09-30: Should we really do that?
STATIC_BLOCK : GLOBAL_BLOCK);
sym = lookup_block_symbol (block, name, domain);
if (!sym)
- error (_("Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n%s may be an inlined function, or may be a template function\n(if a template, try specifying an instantiation: %s<type>)."),
+ error (_("\
+Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
+%s may be an inlined function, or may be a template function\n\
+(if a template, try specifying an instantiation: %s<type>)."),
kind == GLOBAL_BLOCK ? "global" : "static",
name, symtab->filename, name, name);
}
/* This shouldn't be necessary, but as a last resort
* try looking in the 'other kind' even though the psymtab
- * claimed the symbol was one thing. It's possible that
+ * claimed the symbol was one thing. It's possible that
* the psymtab gets it wrong in some cases.
*/
block = BLOCKVECTOR_BLOCK (bv, other_kind);
sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
if (!sym)
- /* FIXME; error is wrong in one case */
- error (_("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
+ /* FIXME; error is wrong in one case. */
+ error (_("\
+Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
%s may be an inlined function, or may be a template function\n\
(if a template, try specifying an instantiation: %s<type>)."),
name, symtab->filename, name, name);
struct type *t;
/* Now search all the global symbols. Do the symtab's first, then
- check the psymtab's. If a psymtab indicates the existence
+ check the psymtab's. If a psymtab indicates the existence
of the desired name as a global, then do psymtab-to-symtab
conversion on the fly and return the found symbol. */
- ALL_PRIMARY_SYMTABS (objfile, s)
+ ALL_OBJFILES (objfile)
{
- bv = BLOCKVECTOR (s);
- block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
- if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
- {
- return SYMBOL_TYPE (sym);
- }
+ if (objfile->sf)
+ objfile->sf->qf->pre_expand_symtabs_matching (objfile,
+ GLOBAL_BLOCK,
+ name, STRUCT_DOMAIN);
+
+ ALL_OBJFILE_SYMTABS (objfile, s)
+ if (s->primary)
+ {
+ bv = BLOCKVECTOR (s);
+ block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
+ sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
+ if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
+ {
+ return SYMBOL_TYPE (sym);
+ }
+ }
}
ALL_OBJFILES (objfile)
/* Now search the static file-level symbols.
Not strictly correct, but more useful than an error.
Do the symtab's first, then
- check the psymtab's. If a psymtab indicates the existence
+ check the psymtab's. If a psymtab indicates the existence
of the desired name as a file-level static, then do psymtab-to-symtab
- conversion on the fly and return the found symbol.
- */
+ conversion on the fly and return the found symbol. */
- ALL_PRIMARY_SYMTABS (objfile, s)
+ ALL_OBJFILES (objfile)
{
- bv = BLOCKVECTOR (s);
- block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
- sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
- if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
+ if (objfile->sf)
+ objfile->sf->qf->pre_expand_symtabs_matching (objfile, STATIC_BLOCK,
+ name, STRUCT_DOMAIN);
+
+ ALL_OBJFILE_SYMTABS (objfile, s)
{
- return SYMBOL_TYPE (sym);
+ bv = BLOCKVECTOR (s);
+ block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
+ sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
+ if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
+ {
+ return SYMBOL_TYPE (sym);
+ }
}
}
}
-/* Find the name of the file containing main(). */
+/* Find the name of the file containing main(). */
/* FIXME: What about languages without main() or specially linked
- executables that have no main() ? */
+ executables that have no main() ? */
-char *
+const char *
find_main_filename (void)
{
struct objfile *objfile;
- char *result, *name = main_name ();
+ char *name = main_name ();
ALL_OBJFILES (objfile)
{
+ const char *result;
+
if (!objfile->sf)
continue;
result = objfile->sf->qf->find_symbol_file (objfile, name);
binary search terminates, we drop through and do a straight linear
search on the symbols. Each symbol which is marked as being a ObjC/C++
symbol (language_cplus or language_objc set) has both the encoded and
- non-encoded names tested for a match.
-*/
+ non-encoded names tested for a match. */
struct symbol *
lookup_block_symbol (const struct block *block, const char *name,
}
}
}
- return (sym_found); /* Will be NULL if not found. */
+ return (sym_found); /* Will be NULL if not found. */
}
}
/* Find the symtab associated with PC and SECTION. Look through the
- psymtabs and read in another symtab if necessary. */
+ psymtabs and read in another symtab if necessary. */
struct symtab *
find_pc_sect_symtab (CORE_ADDR pc, struct obj_section *section)
0x1000-0x4000, but for address 0x2345 we want to return symtab b.
This happens for native ecoff format, where code from included files
- gets its own symtab. The symtab for the included file should have
+ gets its own symtab. The symtab for the included file should have
been read in already via the dependency mechanism.
It might be swifter to create several symtabs with the same name
like xcoff does (I'm not sure).
and we simply return its corresponding symtab. */
/* In order to better support objfiles that contain both
stabs and coff debugging info, we continue on if a psymtab
- can't be found. */
+ can't be found. */
if ((objfile->flags & OBJF_REORDERED) && objfile->sf)
{
struct symtab *result;
break;
}
if (sym == NULL)
- continue; /* no symbol in this symtab matches section */
+ continue; /* No symbol in this symtab matches
+ section. */
}
distance = BLOCK_END (b) - BLOCK_START (b);
best_s = s;
return NULL;
}
-/* Find the symtab associated with PC. Look through the psymtabs and
- read in another symtab if necessary. Backward compatibility, no section */
+/* Find the symtab associated with PC. Look through the psymtabs and read
+ in another symtab if necessary. Backward compatibility, no section. */
struct symtab *
find_pc_symtab (CORE_ADDR pc)
/* elz: added this because this function returned the wrong
information if the pc belongs to a stub (import/export)
- to call a shlib function. This stub would be anywhere between
+ to call a shlib function. This stub would be anywhere between
two functions in the target, and the line info was erroneously
- taken to be the one of the line before the pc.
- */
+ taken to be the one of the line before the pc. */
+
/* RT: Further explanation:
* We have stubs (trampolines) inserted between procedures.
* exists in the main image.
*
* In the minimal symbol table, we have a bunch of symbols
- * sorted by start address. The stubs are marked as "trampoline",
+ * sorted by start address. The stubs are marked as "trampoline",
* the others appear as text. E.g.:
*
* Minimal symbol table for main image
*
* Assumptions being made about the minimal symbol table:
* 1. lookup_minimal_symbol_by_pc() will return a trampoline only
- * if we're really in the trampoline. If we're beyond it (say
+ * if we're really in the trampoline.s If we're beyond it (say
* we're in "foo" in the above example), it'll have a closer
* symbol (the "foo" text symbol for example) and will not
* return the trampoline.
* 2. lookup_minimal_symbol_text() will find a real text symbol
* corresponding to the trampoline, and whose address will
- * be different than the trampoline address. I put in a sanity
+ * be different than the trampoline address. I put in a sanity
* check for the address being the same, to avoid an
* infinite recursion.
*/
* In the above situation, the shared lib is not loaded yet,
* so of course we can't find the real func/line info,
* but the "break" still works, and the warning is annoying.
- * So I commented out the warning. RT */
- /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ;
+ * So I commented out the warning. RT */
+ /* warning ("In stub for %s; unable to find real function/line info",
+ SYMBOL_LINKAGE_NAME (msymbol)); */
+ ;
/* fall through */
- else if (SYMBOL_VALUE_ADDRESS (mfunsym) == SYMBOL_VALUE_ADDRESS (msymbol))
+ else if (SYMBOL_VALUE_ADDRESS (mfunsym)
+ == SYMBOL_VALUE_ADDRESS (msymbol))
/* Avoid infinite recursion */
- /* See above comment about why warning is commented out */
- /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ;
+ /* See above comment about why warning is commented out. */
+ /* warning ("In stub for %s; unable to find real function/line info",
+ SYMBOL_LINKAGE_NAME (msymbol)); */
+ ;
/* fall through */
else
return find_pc_line (SYMBOL_VALUE_ADDRESS (mfunsym), 0);
s = find_pc_sect_symtab (pc, section);
if (!s)
{
- /* if no symbol information, return previous pc */
+ /* If no symbol information, return previous pc. */
if (notcurrent)
pc++;
val.pc = pc;
}
prev = NULL;
- item = l->item; /* Get first line info */
+ item = l->item; /* Get first line info. */
/* Is this file's first line closer than the first lines of other files?
If so, record this file, and its first line, as best alternate. */
{
/* If our best fit is in a range of PC's for which no line
number info is available (line number is zero) then we didn't
- find any valid line information. */
+ find any valid line information. */
val.pc = pc;
}
else
return val;
}
-/* Backward compatibility (no section) */
+/* Backward compatibility (no section). */
struct symtab_and_line
find_pc_line (CORE_ADDR pc, int notcurrent)
while (*p == ' ' || *p == '\t')
p++;
- /* Recognize 'operator TYPENAME'. */
+ /* Recognize 'operator TYPENAME'. */
if (isalpha (*p) || *p == '_' || *p == '$')
{
case '\\': /* regexp quoting */
if (p[1] == '*')
{
- if (p[2] == '=') /* 'operator\*=' */
+ if (p[2] == '=') /* 'operator\*=' */
*end = p + 3;
else /* 'operator\*' */
*end = p + 2;
else if (p[1] == '[')
{
if (p[2] == ']')
- error (_("mismatched quoting on brackets, try 'operator\\[\\]'"));
+ error (_("mismatched quoting on brackets, "
+ "try 'operator\\[\\]'"));
else if (p[2] == '\\' && p[3] == ']')
{
*end = p + 4; /* 'operator\[\]' */
}
else
{
- /* Gratuitous qoute: skip it and move on. */
+ /* Gratuitous qoute: skip it and move on. */
p++;
continue;
}
case '|':
if (p[0] == '-' && p[1] == '>')
{
- /* Struct pointer member operator 'operator->'. */
+ /* Struct pointer member operator 'operator->'. */
if (p[2] == '*')
{
*end = p + 3; /* 'operator->*' */
return p;
case '(':
if (p[1] != ')')
- error (_("`operator ()' must be specified without whitespace in `()'"));
+ error (_("`operator ()' must be specified "
+ "without whitespace in `()'"));
*end = p + 2;
return p;
case '?':
if (p[1] != ':')
- error (_("`operator ?:' must be specified without whitespace in `?:'"));
+ error (_("`operator ?:' must be specified "
+ "without whitespace in `?:'"));
*end = p + 2;
return p;
case '[':
if (p[1] != ']')
- error (_("`operator []' must be specified without whitespace in `[]'"));
+ error (_("`operator []' must be specified "
+ "without whitespace in `[]'"));
*end = p + 2;
return p;
default:
}
printf_filtered ("\n\n");
- printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
+ printf_filtered ("Source files for which symbols "
+ "will be read in on demand:\n\n");
first = 1;
map_partial_symbol_filenames (output_partial_symbol_filename, &first);
return 0;
}
-/* Free any memory associated with a search. */
+/* Free any memory associated with a search. */
void
free_search_symbols (struct symbol_search *symbols)
{
free_search_symbols should be called when *MATCHES is no longer needed.
The results are sorted locally; each symtab's global and static blocks are
- separately alphabetized.
- */
+ separately alphabetized. */
+
void
search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[],
struct symbol_search **matches)
struct minimal_symbol *msymbol;
char *val;
int found_misc = 0;
- static enum minimal_symbol_type types[]
+ static const enum minimal_symbol_type types[]
= {mst_data, mst_text, mst_abs, mst_unknown};
- static enum minimal_symbol_type types2[]
+ static const enum minimal_symbol_type types2[]
= {mst_bss, mst_file_text, mst_abs, mst_unknown};
- static enum minimal_symbol_type types3[]
+ static const enum minimal_symbol_type types3[]
= {mst_file_data, mst_solib_trampoline, mst_abs, mst_unknown};
- static enum minimal_symbol_type types4[]
+ static const enum minimal_symbol_type types4[]
= {mst_file_bss, mst_text, mst_abs, mst_unknown};
enum minimal_symbol_type ourtype;
enum minimal_symbol_type ourtype2;
/* Make sure spacing is right for C++ operators.
This is just a courtesy to make the matching less sensitive
to how many spaces the user leaves between 'operator'
- and <TYPENAME> or <OPERATOR>. */
+ and <TYPENAME> or <OPERATOR>. */
char *opend;
char *opname = operator_chars (regexp, &opend);
if (*opname)
{
- int fix = -1; /* -1 means ok; otherwise number of spaces needed. */
+ int fix = -1; /* -1 means ok; otherwise number of
+ spaces needed. */
if (isalpha (*opname) || *opname == '_' || *opname == '$')
{
- /* There should 1 space between 'operator' and 'TYPENAME'. */
+ /* There should 1 space between 'operator' and 'TYPENAME'. */
if (opname[-1] != ' ' || opname[-2] == ' ')
fix = 1;
}
else
{
- /* There should 0 spaces between 'operator' and 'OPERATOR'. */
+ /* There should 0 spaces between 'operator' and 'OPERATOR'. */
if (opname[-1] == ' ')
fix = 0;
}
- /* If wrong number of spaces, fix it. */
+ /* If wrong number of spaces, fix it. */
if (fix >= 0)
{
char *tmp = (char *) alloca (8 + fix + strlen (opname) + 1);
/* 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. */
+ the machinery below. */
datum.nfiles = nfiles;
datum.files = files;
for the function, for variables we have to call lookup_symbol
to determine if the variable has debug info.
If the lookup fails, set found_misc so that we will rescan to print
- any matching symbols without debug info.
- */
+ any matching symbols without debug info. */
if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
{
e.g., c++ static const members.
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)
- || (kind == TYPES_DOMAIN && SYMBOL_CLASS (sym) == LOC_TYPEDEF))))
+ && TYPE_CODE (SYMBOL_TYPE (sym))
+ == TYPE_CODE_ENUM))
+ || (kind == FUNCTIONS_DOMAIN
+ && SYMBOL_CLASS (sym) == LOC_BLOCK)
+ || (kind == TYPES_DOMAIN
+ && SYMBOL_CLASS (sym) == LOC_TYPEDEF))))
{
/* match */
- psr = (struct symbol_search *) xmalloc (sizeof (struct symbol_search));
+ psr = (struct symbol_search *)
+ xmalloc (sizeof (struct symbol_search));
psr->block = i;
psr->symtab = real_symtab;
psr->symbol = sym;
if (regexp == NULL
|| re_exec (SYMBOL_NATURAL_NAME (msymbol)) != 0)
{
- /* Functions: Look up by address. */
+ /* Functions: Look up by address. */
if (kind != FUNCTIONS_DOMAIN ||
(0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol))))
{
- /* Variables/Absolutes: Look up by name */
+ /* Variables/Absolutes: Look up by name. */
if (lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
(struct block *) NULL, VAR_DOMAIN, 0)
== NULL)
{
/* match */
- psr = (struct symbol_search *) xmalloc (sizeof (struct symbol_search));
+ psr = (struct symbol_search *)
+ xmalloc (sizeof (struct symbol_search));
psr->block = i;
psr->msymbol = msymbol;
psr->symtab = NULL;
/* Helper function for symtab_symbol_info, this function uses
the data returned from search_symbols() to print information
- regarding the match to gdb_stdout.
- */
+ regarding the match to gdb_stdout. */
+
static void
print_symbol_info (domain_enum kind, struct symtab *s, struct symbol *sym,
int block, char *last)
if (kind != TYPES_DOMAIN && block == STATIC_BLOCK)
printf_filtered ("static ");
- /* Typedef that is not a C++ class */
+ /* Typedef that is not a C++ class. */
if (kind == TYPES_DOMAIN
&& SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout);
- /* variable, func, or typedef-that-is-c++-class */
+ /* variable, func, or typedef-that-is-c++-class. */
else if (kind < TYPES_DOMAIN ||
(kind == TYPES_DOMAIN &&
SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
}
/* This help function for symtab_symbol_info() prints information
- for non-debugging symbols to gdb_stdout.
- */
+ for non-debugging symbols to gdb_stdout. */
+
static void
print_msymbol_info (struct minimal_symbol *msymbol)
{
}
/* This is the guts of the commands "info functions", "info types", and
- "info variables". It calls search_symbols to find all matches and then
+ "info variables". It calls search_symbols to find all matches and then
print_[m]symbol_info to print out some useful information about the
- matches.
- */
+ matches. */
+
static void
symtab_symbol_info (char *regexp, domain_enum kind, int from_tty)
{
- static char *classnames[] = {"variable", "function", "type", "method"};
+ static const char * const classnames[] =
+ {"variable", "function", "type", "method"};
struct symbol_search *symbols;
struct symbol_search *p;
struct cleanup *old_chain;
char *last_filename = NULL;
int first = 1;
- /* must make sure that if we're interrupted, symbols gets freed */
+ /* Must make sure that if we're interrupted, symbols gets freed. */
search_symbols (regexp, kind, 0, (char **) NULL, &symbols);
old_chain = make_cleanup_free_search_symbols (symbols);
symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty);
}
-/* Breakpoint all functions matching regular expression. */
+/* Breakpoint all functions matching regular expression. */
void
rbreak_command_wrapper (char *regexp, int from_tty)
/* Test to see if the symbol specified by SYMNAME (which is already
demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
- characters. If so, add it to the current completion list. */
+ characters. If so, add it to the current completion list. */
static void
completion_list_add_name (char *symname, char *sym_text, int sym_text_len,
{
int newsize;
- /* clip symbols that cannot match */
+ /* Clip symbols that cannot match. */
if (strncmp (symname, sym_text, sym_text_len) != 0)
{
}
/* We have a match for a completion, so add SYMNAME to the current list
- of matches. Note that the name is moved to freshly malloc'd space. */
+ of matches. Note that the name is moved to freshly malloc'd space. */
{
char *new;
}
/* Break the non-quoted text based on the characters which are in
- symbols. FIXME: This should probably be language-specific. */
+ symbols. FIXME: This should probably be language-specific. */
static char *
language_search_unquoted_string (char *text, char *p)
{
if ((current_language->la_language == language_objc))
{
- if (p[-1] == ':') /* might be part of a method name */
+ if (p[-1] == ':') /* Might be part of a method name. */
continue;
else if (p[-1] == '[' && (p[-2] == '-' || p[-2] == '+'))
- p -= 2; /* beginning of a method name */
+ p -= 2; /* Beginning of a method name. */
else if (p[-1] == ' ' || p[-1] == '(' || p[-1] == ')')
- { /* might be part of a method name */
+ { /* Might be part of a method name. */
char *t = p;
/* Seeing a ' ' or a '(' is not conclusive evidence
break;
if (t[-1] == '[' && (t[-2] == '-' || t[-2] == '+'))
- p = t - 2; /* method name detected */
- /* else we leave with p unchanged */
+ p = t - 2; /* Method name detected. */
+ /* Else we leave with p unchanged. */
}
}
break;
/* Search upwards from currently selected frame (so that we can
complete on local vars). Also catch fields of types defined in
this places which match our text string. Only complete on types
- visible from current context. */
+ visible from current context. */
b = get_selected_block (0);
surrounding_static_block = block_static_block (b);
/* A callback for map_partial_symbol_filenames. */
static void
-maybe_add_partial_symtab_filename (const char *fullname, const char *filename,
+maybe_add_partial_symtab_filename (const char *filename, const char *fullname,
void *user_data)
{
struct add_partial_filename_data *data = user_data;
Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
If non-zero, func_start is where we think the prologue starts, possibly
- by previous examination of symbol table information.
- */
+ by previous examination of symbol table information. */
int
in_prologue (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR func_start)
/* If there is only one sal that covers the entire function,
then it is probably a single line function, like
- "foo(){}". */
+ "foo(){}". */
if (prologue_sal.end >= end_pc)
return 0;
corresponding line number is less the first one that we
found for the function. This is more conservative then
refine_prologue_limit which scans a large number of SALs
- looking for any in the prologue */
+ looking for any in the prologue. */
prologue_sal = sal;
}
}
if (string == 0)
error (_("Empty line specification."));
- /* We use whatever is set as the current source line. We do not try
- and get a default or it will recursively call us! */
+ /* We use whatever is set as the current source line. We do not try
+ and get a default or it will recursively call us! */
cursal = get_current_source_symtab_and_line ();
sals = decode_line_1 (&string, funfirstline,
/* Track MAIN */
static char *name_of_main;
+enum language language_of_main = language_unknown;
void
set_main_name (const char *name)
{
xfree (name_of_main);
name_of_main = NULL;
+ language_of_main = language_unknown;
}
if (name != NULL)
{
name_of_main = xstrdup (name);
+ language_of_main = language_unknown;
}
}
name. This would allow us to remove this hard-coded call to
an Ada function. It is not clear that this is a better approach
at this point, because all methods need to be written in a way
- such that false positives never be returned. For instance, it is
+ such that false positives never be returned. For instance, it is
important that a method does not return a wrong name for the main
procedure if the main procedure is actually written in a different
language. It is easy to guaranty this with Ada, since we use a
special symbol generated only when the main in Ada to find the name
- of the main procedure. It is difficult however to see how this can
+ of the main procedure. It is difficult however to see how this can
be guarantied for languages such as C, for instance. This suggests
that order of call for these methods becomes important, which means
a more complicated approach. */