/* Symbol table lookup for the GNU debugger, GDB.
- Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994
+ Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995
Free Software Foundation, Inc.
This file is part of GDB.
#include "objfiles.h"
#include "gdbcmd.h"
#include "call-cmds.h"
-#include "regex.h"
+#include "gnu-regex.h"
#include "expression.h"
#include "language.h"
#include "demangle.h"
-#include <obstack.h>
+#include "obstack.h"
#include <sys/types.h>
#include <fcntl.h>
static struct partial_symbol *
lookup_partial_symbol PARAMS ((struct partial_symtab *, const char *,
- int, enum namespace));
+ int, namespace_enum));
static struct symtab *
lookup_symtab_1 PARAMS ((char *));
+static void
+cplusplus_hint PARAMS ((char *));
+
/* */
/* The single non-language-specific builtin type */
using the new command completion feature on single quoted demangled C++
symbols. Remove when loose ends are cleaned up. FIXME -fnf */
-void
+static void
cplusplus_hint (name)
char *name;
{
+ while (*name == '\'')
+ name++;
printf_filtered ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name, name);
printf_filtered ("(Note leading single quote.)\n");
}
work with the normal mechanisms. */
if (OPNAME_PREFIX_P (field_name))
{
- char *opname = cplus_mangle_opname (field_name + 3, 0);
+ const char *opname = cplus_mangle_opname (field_name + 3, 0);
if (opname == NULL)
error ("No mangling for \"%s\"", field_name);
mangled_name_len += strlen (opname);
struct partial_symtab *psymtab;
CORE_ADDR pc;
{
- struct partial_symbol *best = NULL, *p;
+ struct partial_symbol *best = NULL, *p, **pp;
CORE_ADDR best_pc;
if (!psymtab)
/* Search the global symbols as well as the static symbols, so that
find_pc_partial_function doesn't use a minimal symbol and thus
cache a bad endaddr. */
- for (p = psymtab->objfile->global_psymbols.list + psymtab->globals_offset;
- (p - (psymtab->objfile->global_psymbols.list + psymtab->globals_offset)
+ for (pp = psymtab->objfile->global_psymbols.list + psymtab->globals_offset;
+ (pp - (psymtab->objfile->global_psymbols.list + psymtab->globals_offset)
< psymtab->n_global_syms);
- p++)
- if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE
- && SYMBOL_CLASS (p) == LOC_BLOCK
- && pc >= SYMBOL_VALUE_ADDRESS (p)
- && SYMBOL_VALUE_ADDRESS (p) > best_pc)
- {
- best_pc = SYMBOL_VALUE_ADDRESS (p);
- best = p;
- }
- for (p = psymtab->objfile->static_psymbols.list + psymtab->statics_offset;
- (p - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset)
+ pp++)
+ {
+ p = *pp;
+ if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE
+ && SYMBOL_CLASS (p) == LOC_BLOCK
+ && pc >= SYMBOL_VALUE_ADDRESS (p)
+ && SYMBOL_VALUE_ADDRESS (p) > best_pc)
+ {
+ best_pc = SYMBOL_VALUE_ADDRESS (p);
+ best = p;
+ }
+ }
+ for (pp = psymtab->objfile->static_psymbols.list + psymtab->statics_offset;
+ (pp - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset)
< psymtab->n_static_syms);
- p++)
- if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE
- && SYMBOL_CLASS (p) == LOC_BLOCK
- && pc >= SYMBOL_VALUE_ADDRESS (p)
- && SYMBOL_VALUE_ADDRESS (p) > best_pc)
- {
- best_pc = SYMBOL_VALUE_ADDRESS (p);
- best = p;
- }
+ pp++)
+ {
+ p = *pp;
+ if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE
+ && SYMBOL_CLASS (p) == LOC_BLOCK
+ && pc >= SYMBOL_VALUE_ADDRESS (p)
+ && SYMBOL_VALUE_ADDRESS (p) > best_pc)
+ {
+ best_pc = SYMBOL_VALUE_ADDRESS (p);
+ best = p;
+ }
+ }
if (best_pc == psymtab->textlow - 1)
return 0;
return best;
lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
const char *name;
register const struct block *block;
- const enum namespace namespace;
+ const namespace_enum namespace;
int *is_a_field_of_this;
struct symtab **symtab;
{
struct partial_symtab *pst;
const char *name;
int global;
- enum namespace namespace;
+ namespace_enum namespace;
{
- struct partial_symbol *start, *psym;
- struct partial_symbol *top, *bottom, *center;
+ struct partial_symbol **start, **psym;
+ struct partial_symbol **top, **bottom, **center;
int length = (global ? pst->n_global_syms : pst->n_static_syms);
int do_linear_search = 1;
center = bottom + (top - bottom) / 2;
if (!(center < top))
abort ();
- if (!do_linear_search && SYMBOL_LANGUAGE (center) == language_cplus)
+ if (!do_linear_search && SYMBOL_LANGUAGE (*center) == language_cplus)
{
do_linear_search = 1;
}
- if (STRCMP (SYMBOL_NAME (center), name) >= 0)
+ if (STRCMP (SYMBOL_NAME (*center), name) >= 0)
{
top = center;
}
}
if (!(top == bottom))
abort ();
- while (STREQ (SYMBOL_NAME (top), name))
+ while (STREQ (SYMBOL_NAME (*top), name))
{
- if (SYMBOL_NAMESPACE (top) == namespace)
+ if (SYMBOL_NAMESPACE (*top) == namespace)
{
- return top;
+ return (*top);
}
top ++;
}
{
for (psym = start; psym < start + length; psym++)
{
- if (namespace == SYMBOL_NAMESPACE (psym))
+ if (namespace == SYMBOL_NAMESPACE (*psym))
{
- if (SYMBOL_MATCHES_NAME (psym, name))
+ if (SYMBOL_MATCHES_NAME (*psym, name))
{
- return (psym);
+ return (*psym);
}
}
}
lookup_block_symbol (block, name, namespace)
register const struct block *block;
const char *name;
- const enum namespace namespace;
+ const namespace_enum namespace;
{
register int bot, top, inc;
register struct symbol *sym;
/* For an objfile that has its functions reordered,
find_pc_psymtab will find the proper partial symbol table
and we simply return its corresponding symtab. */
- if (objfile->flags & OBJF_REORDERED)
+ if ((objfile->flags & OBJF_REORDERED) && objfile->psymtabs)
{
ps = find_pc_psymtab (pc);
if (ps)
for (i = 0; i < len; i++, item++)
{
- /* Return the last line that did not start after PC. */
+ /* Leave prev pointing to the linetable entry for the last line
+ that started at or before PC. */
if (item->pc > pc)
break;
int n;
int count;
- check_stub_type (type);
+ CHECK_TYPEDEF (type);
count = TYPE_NFN_FIELDS_TOTAL (type);
for (n = 0; n < TYPE_N_BASECLASSES (type); n++)
(struct symtab **)NULL)))
{
int method_counter;
- /* FIXME: Shouldn't this just be check_stub_type (t)? */
+ /* FIXME: Shouldn't this just be CHECK_TYPEDEF (t)? */
t = SYMBOL_TYPE (sym_class);
for (method_counter = TYPE_NFN_FIELDS (t) - 1;
method_counter >= 0;
/* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
s = NULL;
- is_quoted = (strchr(gdb_completer_quote_characters, **argptr) != NULL);
- has_parens = (( pp = strchr(*argptr, '(')) != NULL &&
- (pp = strchr(pp, ')')) != NULL);
+ is_quoted = (**argptr
+ && strchr (gdb_completer_quote_characters, **argptr) != NULL);
+ has_parens = ((pp = strchr (*argptr, '(')) != NULL
+ && (pp = strchr (pp, ')')) != NULL);
for (p = *argptr; *p; p++)
{
(struct symtab **)NULL);
if (sym_class &&
- ( TYPE_CODE (SYMBOL_TYPE (sym_class)) == TYPE_CODE_STRUCT
- || TYPE_CODE (SYMBOL_TYPE (sym_class)) == TYPE_CODE_UNION))
+ (t = check_typedef (SYMBOL_TYPE (sym_class)),
+ (TYPE_CODE (t) == TYPE_CODE_STRUCT
+ || TYPE_CODE (t) == TYPE_CODE_UNION)))
{
/* Arg token is not digits => try it as a function name
Find the next token(everything up to end or next blank). */
- if (strchr(gdb_completer_quote_characters, **argptr) != NULL)
+ if (**argptr
+ && strchr (gdb_completer_quote_characters, **argptr) != NULL)
{
p = skip_quoted(*argptr);
*argptr = *argptr + 1;
copy = (char *) alloca (p - *argptr + 1 );
memcpy (copy, *argptr, p - *argptr);
copy[p - *argptr] = '\0';
- if (strchr(gdb_completer_quote_characters, copy[p-*argptr-1]) != NULL)
- copy[p - *argptr -1] = '\0';
+ if (p != *argptr
+ && copy[p - *argptr - 1]
+ && strchr (gdb_completer_quote_characters,
+ copy[p - *argptr - 1]) != NULL)
+ copy[p - *argptr - 1] = '\0';
}
/* no line number may be specified */
sym = 0;
i1 = 0; /* counter for the symbol array */
- t = SYMBOL_TYPE (sym_class);
sym_arr = (struct symbol **) alloca(total_number_of_methods (t)
* sizeof(struct symbol *));
memcpy (copy, *argptr, p - *argptr);
copy[p - *argptr] = '\0';
if (p != *argptr
- && (copy[0] == copy [p - *argptr - 1])
+ && copy[0]
+ && copy[0] == copy [p - *argptr - 1]
&& strchr (gdb_completer_quote_characters, copy[0]) != NULL)
{
copy [p - *argptr - 1] = '\0';
register struct block *b;
register int i, j;
register struct symbol *sym;
- struct partial_symbol *psym;
+ struct partial_symbol **psym;
struct objfile *objfile;
struct minimal_symbol *msymbol;
char *val;
ALL_PSYMTABS (objfile, ps)
{
- struct partial_symbol *bound, *gbound, *sbound;
+ struct partial_symbol **bound, **gbound, **sbound;
int keep_going = 1;
if (ps->readin) continue;
/* If it would match (logic taken from loop below)
load the file and go on to the next one */
- if ((regexp == NULL || SYMBOL_MATCHES_REGEXP (psym))
- && ((class == 0 && SYMBOL_CLASS (psym) != LOC_TYPEDEF
- && SYMBOL_CLASS (psym) != LOC_BLOCK)
- || (class == 1 && SYMBOL_CLASS (psym) == LOC_BLOCK)
- || (class == 2 && SYMBOL_CLASS (psym) == LOC_TYPEDEF)
- || (class == 3 && SYMBOL_CLASS (psym) == LOC_BLOCK)))
+ if ((regexp == NULL || SYMBOL_MATCHES_REGEXP (*psym))
+ && ((class == 0 && SYMBOL_CLASS (*psym) != LOC_TYPEDEF
+ && SYMBOL_CLASS (*psym) != LOC_BLOCK)
+ || (class == 1 && SYMBOL_CLASS (*psym) == LOC_BLOCK)
+ || (class == 2 && SYMBOL_CLASS (*psym) == LOC_TYPEDEF)
+ || (class == 3 && SYMBOL_CLASS (*psym) == LOC_BLOCK)))
{
PSYMTAB_TO_SYMTAB(ps);
keep_going = 0;
register struct objfile *objfile;
register struct block *b, *surrounding_static_block = 0;
register int i, j;
- struct partial_symbol *psym;
+ struct partial_symbol **psym;
/* The symbol we are completing on. Points in same buffer as text. */
char *sym_text;
/* Length of sym_text. */
{
/* If interrupted, then quit. */
QUIT;
- COMPLETION_LIST_ADD_SYMBOL (psym, sym_text, sym_text_len, text, word);
+ COMPLETION_LIST_ADD_SYMBOL (*psym, sym_text, sym_text_len, text, word);
}
for (psym = objfile->static_psymbols.list + ps->statics_offset;
psym++)
{
QUIT;
- COMPLETION_LIST_ADD_SYMBOL (psym, sym_text, sym_text_len, text, word);
+ COMPLETION_LIST_ADD_SYMBOL (*psym, sym_text, sym_text_len, text, word);
}
}
/* Determine if PC is in the prologue of a function. The prologue is the area
between the first instruction of a function, and the first executable line.
Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
+
+ If non-zero, func_start is where we thing the prologue starts, possibly
+ by previous examination of symbol table information.
*/
int
nosyms:
+/* If func_start is zero (meaning unknown) then we don't know whether pc is
+ in the prologue or not. I.E. it might be. */
+
+ if (!func_start) return 1;
+
/* We need to call the target-specific prologue skipping functions with the
function's start address because PC may be pointing at an instruction that
could be mistakenly considered part of the prologue. */
projects / binutils.git / blobdiff