X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fsymtab.c;h=8f3aa60018022e7be98d9a5062b7bf97e6dd6653;hb=663a1470e1a7af58a3d0691f480bc5621bd0c54f;hp=1e1b5def91bbb25364cb58ab358d2357ef4f02d6;hpb=5f9a71c3d74f62fb4e6a3fe0007044f429638a60;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 1e1b5def91..60bc585fcc 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -1,14 +1,14 @@
/* Symbol table lookup for the GNU debugger, GDB.
- Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
- 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
- Free Software Foundation, Inc.
+ 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, 2011 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
@@ -17,9 +17,7 @@
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see . */
#include "defs.h"
#include "symtab.h"
@@ -41,11 +39,16 @@
#include "source.h"
#include "filenames.h" /* for FILENAME_CMP */
#include "objc-lang.h"
+#include "d-lang.h"
+#include "ada-lang.h"
+#include "p-lang.h"
+#include "addrmap.h"
#include "hashtab.h"
#include "gdb_obstack.h"
#include "block.h"
+#include "dictionary.h"
#include
#include
@@ -53,6 +56,14 @@
#include "gdb_stat.h"
#include
#include "cp-abi.h"
+#include "cp-support.h"
+#include "observer.h"
+#include "gdb_assert.h"
+#include "solist.h"
+#include "macrotab.h"
+#include "macroscope.h"
+
+#include "psymtab.h"
/* Prototypes for local functions */
@@ -68,7 +79,7 @@ static void variables_info (char *, int);
static void sources_info (char *, int);
-static void output_source_filename (char *, int *);
+static void output_source_filename (const char *, int *);
static int find_line_common (struct linetable *, int, int *);
@@ -76,57 +87,28 @@ static int find_line_common (struct linetable *, int, int *);
char *operator_chars (char *p, char **end);
-static struct partial_symbol *lookup_partial_symbol (struct partial_symtab *,
- const char *,
- const char *, int,
- domain_enum);
-
static struct symbol *lookup_symbol_aux (const char *name,
- const char *linkage_name,
const struct block *block,
const domain_enum domain,
- int *is_a_field_of_this,
- struct symtab **symtab);
+ enum language language,
+ int *is_a_field_of_this);
static
struct symbol *lookup_symbol_aux_local (const char *name,
- const char *linkage_name,
const struct block *block,
const domain_enum domain,
- struct symtab **symtab);
+ enum language language);
static
struct symbol *lookup_symbol_aux_symtabs (int block_index,
const char *name,
- const char *linkage_name,
- const domain_enum domain,
- struct symtab **symtab);
-
-static
-struct symbol *lookup_symbol_aux_psymtabs (int block_index,
- const char *name,
- const char *linkage_name,
- const domain_enum domain,
- struct symtab **symtab);
+ const domain_enum domain);
-#if 0
static
-struct symbol *lookup_symbol_aux_minsyms (const char *name,
- const char *linkage_name,
- const domain_enum domain,
- int *is_a_field_of_this,
- struct symtab **symtab);
-#endif
-
-static struct symbol *find_active_alias (struct symbol *sym, CORE_ADDR addr);
-
-/* This flag is used in hppa-tdep.c, and set in hp-symtab-read.c */
-/* Signals the presence of objects compiled by HP compilers */
-int hp_som_som_object_present = 0;
-
-static void fixup_section (struct general_symbol_info *, struct objfile *);
-
-static int file_matches (char *, char **, int);
+struct symbol *lookup_symbol_aux_quick (struct objfile *objfile,
+ int block_index,
+ const char *name,
+ const domain_enum domain);
static void print_symbol_info (domain_enum,
struct symtab *, struct symbol *, int, char *);
@@ -135,18 +117,37 @@ static void print_msymbol_info (struct minimal_symbol *);
static void symtab_symbol_info (char *, domain_enum, int);
-static void overload_list_add_symbol (struct symbol *sym, char *oload_name);
-
void _initialize_symtab (void);
/* */
-/* The single non-language-specific builtin type */
-struct type *builtin_type_error;
+/* Allow the user to configure the debugger behavior with respect
+ to multiple-choice menus when more than one symbol matches during
+ a symbol lookup. */
+
+const char multiple_symbols_ask[] = "ask";
+const char multiple_symbols_all[] = "all";
+const char multiple_symbols_cancel[] = "cancel";
+static const char *multiple_symbols_modes[] =
+{
+ multiple_symbols_ask,
+ multiple_symbols_all,
+ multiple_symbols_cancel,
+ NULL
+};
+static const char *multiple_symbols_mode = multiple_symbols_all;
+
+/* Read-only accessor to AUTO_SELECT_MODE. */
+
+const char *
+multiple_symbols_select_mode (void)
+{
+ return multiple_symbols_mode;
+}
/* 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. */
+ Might be better to make this a parameter to lookup_symbol and
+ value_of_this. */
const struct block *block_found;
@@ -157,9 +158,9 @@ const struct block *block_found;
struct symtab *
lookup_symtab (const char *name)
{
- register struct symtab *s;
- register struct partial_symtab *ps;
- register struct objfile *objfile;
+ int found;
+ struct symtab *s = NULL;
+ struct objfile *objfile;
char *real_path = NULL;
char *full_path = NULL;
@@ -175,7 +176,7 @@ lookup_symtab (const char *name)
got_symtab:
- /* First, search for an exact match */
+ /* First, search for an exact match. */
ALL_SYMTABS (objfile, s)
{
@@ -183,31 +184,38 @@ got_symtab:
{
return s;
}
-
+
/* If the user gave us an absolute path, try to find the file in
this symtab and use its absolute path. */
-
+
if (full_path != NULL)
{
- const char *fp = symtab_to_filename (s);
- if (FILENAME_CMP (full_path, fp) == 0)
- {
- return s;
- }
+ const char *fp = symtab_to_fullname (s);
+
+ if (fp != NULL && FILENAME_CMP (full_path, fp) == 0)
+ {
+ return s;
+ }
}
if (real_path != NULL)
{
- char *rp = gdb_realpath (symtab_to_filename (s));
- make_cleanup (xfree, rp);
- if (FILENAME_CMP (real_path, rp) == 0)
- {
- return s;
- }
+ char *fullname = symtab_to_fullname (s);
+
+ if (fullname != NULL)
+ {
+ char *rp = gdb_realpath (fullname);
+
+ make_cleanup (xfree, rp);
+ if (FILENAME_CMP (real_path, rp) == 0)
+ {
+ return 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)
@@ -219,18 +227,22 @@ got_symtab:
/* Same search rules as above apply here, but now we look thru the
psymtabs. */
- ps = lookup_partial_symtab (name);
- if (!ps)
- return (NULL);
-
- if (ps->readin)
- error ("Internal: readin %s pst for `%s' found when no symtab found.",
- ps->filename, name);
-
- s = PSYMTAB_TO_SYMTAB (ps);
+ found = 0;
+ ALL_OBJFILES (objfile)
+ {
+ if (objfile->sf
+ && objfile->sf->qf->lookup_symtab (objfile, name, full_path, real_path,
+ &s))
+ {
+ found = 1;
+ break;
+ }
+ }
- if (s)
+ if (s != NULL)
return s;
+ if (!found)
+ return NULL;
/* At this point, we have located the psymtab for this file, but
the conversion to a symtab has failed. This usually happens
@@ -239,85 +251,14 @@ got_symtab:
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;
}
-
-/* Lookup the partial symbol table of a source file named NAME.
- *If* there is no '/' in the name, a match after a '/'
- in the psymtab filename will also work. */
-
-struct partial_symtab *
-lookup_partial_symtab (const char *name)
-{
- register struct partial_symtab *pst;
- register struct objfile *objfile;
- char *full_path = NULL;
- char *real_path = NULL;
-
- /* Here we are interested in canonicalizing an absolute path, not
- absolutizing a relative path. */
- if (IS_ABSOLUTE_PATH (name))
- {
- full_path = xfullpath (name);
- make_cleanup (xfree, full_path);
- real_path = gdb_realpath (name);
- make_cleanup (xfree, real_path);
- }
-
- ALL_PSYMTABS (objfile, pst)
- {
- if (FILENAME_CMP (name, pst->filename) == 0)
- {
- return (pst);
- }
-
- /* If the user gave us an absolute path, try to find the file in
- this symtab and use its absolute path. */
- if (full_path != NULL)
- {
- if (pst->fullname == NULL)
- source_full_path_of (pst->filename, &pst->fullname);
- if (pst->fullname != NULL
- && FILENAME_CMP (full_path, pst->fullname) == 0)
- {
- return pst;
- }
- }
-
- if (real_path != NULL)
- {
- char *rp = NULL;
- if (pst->fullname == NULL)
- source_full_path_of (pst->filename, &pst->fullname);
- if (pst->fullname != NULL)
- {
- rp = gdb_realpath (pst->fullname);
- make_cleanup (xfree, rp);
- }
- if (rp != NULL && FILENAME_CMP (real_path, rp) == 0)
- {
- return pst;
- }
- }
- }
-
- /* Now, search for a matching tail (only if name doesn't have any dirs) */
-
- if (lbasename (name) == name)
- ALL_PSYMTABS (objfile, pst)
- {
- if (FILENAME_CMP (lbasename (pst->filename), name) == 0)
- return (pst);
- }
-
- return (NULL);
-}
/* 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)
@@ -350,8 +291,8 @@ 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 && STREQ (field_name, newname));
+ is_constructor = is_full_physname_constructor
+ || (newname && strcmp (field_name, newname) == 0);
if (!is_destructor)
is_destructor = (strncmp (physname, "__dt", 4) == 0);
@@ -382,17 +323,16 @@ gdb_mangle_name (struct type *type, int method_id, int signature_id)
mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
+ strlen (buf) + len + strlen (physname) + 1);
- {
- mangled_name = (char *) xmalloc (mangled_name_len);
- if (is_constructor)
- mangled_name[0] = '\0';
- else
- strcpy (mangled_name, field_name);
- }
+ mangled_name = (char *) xmalloc (mangled_name_len);
+ if (is_constructor)
+ mangled_name[0] = '\0';
+ else
+ strcpy (mangled_name, field_name);
+
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);
@@ -400,20 +340,74 @@ gdb_mangle_name (struct type *type, int method_id, int signature_id)
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;
+}
+
/* 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
+ if (gsymbol->language == language_d
|| gsymbol->language == language_java
- || gsymbol->language == language_objc)
+ || 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,
@@ -423,6 +417,32 @@ symbol_init_language_specific (struct general_symbol_info *gsymbol,
/* Functions to initialize a symbol's mangled name. */
+/* Objects of this type are stored in the demangled name hash table. */
+struct demangled_name_entry
+{
+ char *mangled;
+ char demangled[1];
+};
+
+/* Hash function for the demangled name hash. */
+static hashval_t
+hash_demangled_name_entry (const void *data)
+{
+ const struct demangled_name_entry *e = data;
+
+ return htab_hash_string (e->mangled);
+}
+
+/* Equality function for the demangled name hash. */
+static int
+eq_demangled_name_entry (const void *a, const void *b)
+{
+ const struct demangled_name_entry *da = a;
+ const struct demangled_name_entry *db = b;
+
+ return strcmp (da->mangled, db->mangled) == 0;
+}
+
/* Create the hash table used for demangled names. Each hash entry is
a pair of strings; one for the mangled name and one for the demangled
name. The entry is hashed via just the mangled name. */
@@ -431,13 +451,13 @@ static void
create_demangled_names_hash (struct objfile *objfile)
{
/* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
- The hash table code will round this up to the next prime number.
+ The hash table code will round this up to the next prime number.
Choosing a much larger table size wastes memory, and saves only about
1% in symbol reading. */
- objfile->demangled_names_hash = htab_create_alloc_ex
- (256, htab_hash_string, (int (*) (const void *, const void *)) streq,
- NULL, objfile->md, xmcalloc, xmfree);
+ objfile->demangled_names_hash = htab_create_alloc
+ (256, hash_demangled_name_entry, eq_demangled_name_entry,
+ NULL, xcalloc, xfree);
}
/* Try to determine the demangled name for a symbol, based on the
@@ -470,7 +490,7 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol,
|| gsymbol->language == language_auto)
{
demangled =
- cplus_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
+ cplus_demangle (mangled, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE);
if (demangled != NULL)
{
gsymbol->language = language_cplus;
@@ -488,14 +508,34 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol,
return demangled;
}
}
+ if (gsymbol->language == language_d
+ || gsymbol->language == language_auto)
+ {
+ demangled = d_demangle(mangled, 0);
+ if (demangled != NULL)
+ {
+ gsymbol->language = language_d;
+ return demangled;
+ }
+ }
+ /* We could support `gsymbol->language == language_fortran' here to provide
+ module namespaces also for inferiors with only minimal symbol table (ELF
+ symbols). Just the mangling standard is not standardized across compilers
+ and there is no DW_AT_producer available for inferiors with only the ELF
+ symbols to check the mangling kind. */
return NULL;
}
/* Set both the mangled and demangled (if any) names for GSYMBOL based
- on LINKAGE_NAME and LEN. The hash table corresponding to OBJFILE
- is used, and the memory comes from that objfile's symbol_obstack.
- LINKAGE_NAME is copied, so the pointer can be discarded after
- calling this function. */
+ on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
+ objfile's obstack; but if COPY_NAME is 0 and if NAME is
+ NUL-terminated, then this function assumes that NAME is already
+ correctly saved (either permanently or with a lifetime tied to the
+ objfile), and it will not be copied.
+
+ The hash table corresponding to OBJFILE is used, and the memory
+ comes from that objfile's objfile_obstack. LINKAGE_NAME is copied,
+ so the pointer can be discarded after calling this function. */
/* We have to be careful when dealing with Java names: when we run
into a Java minimal symbol, we don't know it's a Java symbol, so it
@@ -518,9 +558,10 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol,
void
symbol_set_names (struct general_symbol_info *gsymbol,
- const char *linkage_name, int len, struct objfile *objfile)
+ const char *linkage_name, int len, int copy_name,
+ struct objfile *objfile)
{
- char **slot;
+ struct demangled_name_entry **slot;
/* A 0-terminated copy of the linkage name. */
const char *linkage_name_copy;
/* A copy of the linkage name that might have a special Java prefix
@@ -528,6 +569,30 @@ symbol_set_names (struct general_symbol_info *gsymbol,
const char *lookup_name;
/* The length of lookup_name. */
int lookup_len;
+ struct demangled_name_entry entry;
+
+ if (gsymbol->language == language_ada)
+ {
+ /* In Ada, we do the symbol lookups using the mangled name, so
+ we can save some space by not storing the demangled name.
+
+ As a side note, we have also observed some overlap between
+ the C++ mangling and Ada mangling, similarly to what has
+ been observed with Java. Because we don't store the demangled
+ name with the symbol, we don't need to use the same trick
+ as Java. */
+ if (!copy_name)
+ gsymbol->name = (char *) linkage_name;
+ else
+ {
+ gsymbol->name = obstack_alloc (&objfile->objfile_obstack, len + 1);
+ memcpy (gsymbol->name, linkage_name, len);
+ gsymbol->name[len] = '\0';
+ }
+ symbol_set_demangled_name (gsymbol, NULL, NULL);
+
+ return;
+ }
if (objfile->demangled_names_hash == NULL)
create_demangled_names_hash (objfile);
@@ -538,8 +603,8 @@ symbol_set_names (struct general_symbol_info *gsymbol,
if (gsymbol->language == language_java)
{
char *alloc_name;
- lookup_len = len + JAVA_PREFIX_LEN;
+ lookup_len = len + JAVA_PREFIX_LEN;
alloc_name = alloca (lookup_len + 1);
memcpy (alloc_name, JAVA_PREFIX, JAVA_PREFIX_LEN);
memcpy (alloc_name + JAVA_PREFIX_LEN, linkage_name, len);
@@ -551,8 +616,8 @@ symbol_set_names (struct general_symbol_info *gsymbol,
else if (linkage_name[len] != '\0')
{
char *alloc_name;
- lookup_len = len;
+ lookup_len = len;
alloc_name = alloca (lookup_len + 1);
memcpy (alloc_name, linkage_name, len);
alloc_name[lookup_len] = '\0';
@@ -567,8 +632,10 @@ symbol_set_names (struct general_symbol_info *gsymbol,
linkage_name_copy = linkage_name;
}
- slot = (char **) htab_find_slot (objfile->demangled_names_hash,
- lookup_name, INSERT);
+ entry.mangled = (char *) lookup_name;
+ slot = ((struct demangled_name_entry **)
+ htab_find_slot (objfile->demangled_names_hash,
+ &entry, INSERT));
/* If this name is not in the hash table, add it. */
if (*slot == NULL)
@@ -577,61 +644,50 @@ symbol_set_names (struct general_symbol_info *gsymbol,
linkage_name_copy);
int demangled_len = demangled_name ? strlen (demangled_name) : 0;
- /* If there is a demangled name, place it right after the mangled name.
- Otherwise, just place a second zero byte after the end of the mangled
- name. */
- *slot = obstack_alloc (&objfile->symbol_obstack,
- lookup_len + demangled_len + 2);
- memcpy (*slot, lookup_name, lookup_len + 1);
- if (demangled_name != NULL)
+ /* Suppose we have demangled_name==NULL, copy_name==0, and
+ lookup_name==linkage_name. In this case, we already have the
+ mangled name saved, and we don't have a demangled name. So,
+ you might think we could save a little space by not recording
+ this in the hash table at all.
+
+ It turns out that it is actually important to still save such
+ an entry in the hash table, because storing this name gives
+ us better bcache hit rates for partial symbols. */
+ if (!copy_name && lookup_name == linkage_name)
{
- memcpy (*slot + lookup_len + 1, demangled_name, demangled_len + 1);
- xfree (demangled_name);
+ *slot = obstack_alloc (&objfile->objfile_obstack,
+ offsetof (struct demangled_name_entry,
+ demangled)
+ + demangled_len + 1);
+ (*slot)->mangled = (char *) lookup_name;
}
else
- (*slot)[lookup_len + 1] = '\0';
- }
-
- gsymbol->name = *slot + lookup_len - len;
- if ((*slot)[lookup_len + 1] != '\0')
- gsymbol->language_specific.cplus_specific.demangled_name
- = &(*slot)[lookup_len + 1];
- else
- gsymbol->language_specific.cplus_specific.demangled_name = NULL;
-}
-
-/* Initialize the demangled name of GSYMBOL if possible. Any required space
- to store the name is obtained from the specified obstack. The function
- symbol_set_names, above, should be used instead where possible for more
- efficient memory usage. */
-
-void
-symbol_init_demangled_name (struct general_symbol_info *gsymbol,
- struct obstack *obstack)
-{
- char *mangled = gsymbol->name;
- char *demangled = NULL;
+ {
+ /* If we must copy the mangled name, put it directly after
+ the demangled name so we can have a single
+ allocation. */
+ *slot = obstack_alloc (&objfile->objfile_obstack,
+ offsetof (struct demangled_name_entry,
+ demangled)
+ + lookup_len + demangled_len + 2);
+ (*slot)->mangled = &((*slot)->demangled[demangled_len + 1]);
+ strcpy ((*slot)->mangled, lookup_name);
+ }
- demangled = symbol_find_demangled_name (gsymbol, mangled);
- if (gsymbol->language == language_cplus
- || gsymbol->language == language_java
- || gsymbol->language == language_objc)
- {
- if (demangled)
+ if (demangled_name != NULL)
{
- gsymbol->language_specific.cplus_specific.demangled_name
- = obsavestring (demangled, strlen (demangled), obstack);
- xfree (demangled);
+ strcpy ((*slot)->demangled, demangled_name);
+ xfree (demangled_name);
}
else
- gsymbol->language_specific.cplus_specific.demangled_name = NULL;
+ (*slot)->demangled[0] = '\0';
}
+
+ gsymbol->name = (*slot)->mangled + lookup_len - len;
+ if ((*slot)->demangled[0] != '\0')
+ symbol_set_demangled_name (gsymbol, (*slot)->demangled, objfile);
else
- {
- /* Unknown language; just clean up quietly. */
- if (demangled)
- xfree (demangled);
- }
+ symbol_set_demangled_name (gsymbol, NULL, objfile);
}
/* Return the source code name of a symbol. In languages where
@@ -640,247 +696,306 @@ symbol_init_demangled_name (struct general_symbol_info *gsymbol,
char *
symbol_natural_name (const struct general_symbol_info *gsymbol)
{
- if ((gsymbol->language == language_cplus
- || gsymbol->language == language_java
- || gsymbol->language == language_objc)
- && (gsymbol->language_specific.cplus_specific.demangled_name != NULL))
- {
- return gsymbol->language_specific.cplus_specific.demangled_name;
- }
- else
+ switch (gsymbol->language)
{
- return gsymbol->name;
+ case language_cplus:
+ case language_d:
+ case language_java:
+ case language_objc:
+ case language_fortran:
+ if (symbol_get_demangled_name (gsymbol) != NULL)
+ return symbol_get_demangled_name (gsymbol);
+ break;
+ case language_ada:
+ if (symbol_get_demangled_name (gsymbol) != NULL)
+ return symbol_get_demangled_name (gsymbol);
+ else
+ return ada_decode_symbol (gsymbol);
+ break;
+ default:
+ break;
}
+ return gsymbol->name;
}
/* 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 (struct general_symbol_info *gsymbol)
+symbol_demangled_name (const struct general_symbol_info *gsymbol)
{
- if (gsymbol->language == language_cplus
- || gsymbol->language == language_java
- || gsymbol->language == language_objc)
- return gsymbol->language_specific.cplus_specific.demangled_name;
+ switch (gsymbol->language)
+ {
+ case language_cplus:
+ case language_d:
+ case language_java:
+ case language_objc:
+ case language_fortran:
+ if (symbol_get_demangled_name (gsymbol) != NULL)
+ return symbol_get_demangled_name (gsymbol);
+ break;
+ case language_ada:
+ if (symbol_get_demangled_name (gsymbol) != NULL)
+ return symbol_get_demangled_name (gsymbol);
+ else
+ return ada_decode_symbol (gsymbol);
+ break;
+ default:
+ break;
+ }
+ return NULL;
+}
- else
- return NULL;
+/* 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. */
+char *
+symbol_search_name (const struct general_symbol_info *gsymbol)
+{
+ if (gsymbol->language == language_ada)
+ return gsymbol->name;
+ else
+ return symbol_natural_name (gsymbol);
}
/* Initialize the structure fields to zero values. */
void
init_sal (struct symtab_and_line *sal)
{
+ sal->pspace = NULL;
sal->symtab = 0;
sal->section = 0;
sal->line = 0;
sal->pc = 0;
sal->end = 0;
+ sal->explicit_pc = 0;
+ sal->explicit_line = 0;
}
+/* Return 1 if the two sections are the same, or if they could
+ plausibly be copies of each other, one in an original object
+ file and another in a separated debug file. */
-/* Find which partial symtab on contains PC and SECTION. Return 0 if none. */
-
-struct partial_symtab *
-find_pc_sect_psymtab (CORE_ADDR pc, asection *section)
+int
+matching_obj_sections (struct obj_section *obj_first,
+ struct obj_section *obj_second)
{
- register struct partial_symtab *pst;
- register struct objfile *objfile;
- struct minimal_symbol *msymbol;
-
- /* If we know that this is not a text address, return failure. This is
- 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
- && (msymbol->type == mst_data
- || msymbol->type == mst_bss
- || msymbol->type == mst_abs
- || msymbol->type == mst_file_data
- || msymbol->type == mst_file_bss))
- return NULL;
+ asection *first = obj_first? obj_first->the_bfd_section : NULL;
+ asection *second = obj_second? obj_second->the_bfd_section : NULL;
+ struct objfile *obj;
- ALL_PSYMTABS (objfile, pst)
- {
- if (pc >= pst->textlow && pc < pst->texthigh)
- {
- struct partial_symtab *tpst;
+ /* If they're the same section, then they match. */
+ if (first == second)
+ return 1;
- /* An objfile that has its functions reordered might have
- many partial symbol tables containing the PC, but
- we want the partial symbol table that contains the
- function containing the PC. */
- if (!(objfile->flags & OBJF_REORDERED) &&
- section == 0) /* can't validate section this way */
- return (pst);
+ /* If either is NULL, give up. */
+ if (first == NULL || second == NULL)
+ return 0;
- if (msymbol == NULL)
- return (pst);
+ /* This doesn't apply to absolute symbols. */
+ if (first->owner == NULL || second->owner == NULL)
+ return 0;
- for (tpst = pst; tpst != NULL; tpst = tpst->next)
- {
- if (pc >= tpst->textlow && pc < tpst->texthigh)
- {
- struct partial_symbol *p;
+ /* If they're in the same object file, they must be different sections. */
+ if (first->owner == second->owner)
+ return 0;
- p = find_pc_sect_psymbol (tpst, pc, section);
- if (p != NULL
- && SYMBOL_VALUE_ADDRESS (p)
- == SYMBOL_VALUE_ADDRESS (msymbol))
- return (tpst);
- }
- }
- return (pst);
- }
- }
- return (NULL);
-}
+ /* Check whether the two sections are potentially corresponding. They must
+ have the same size, address, and name. We can't compare section indexes,
+ which would be more reliable, because some sections may have been
+ stripped. */
+ if (bfd_get_section_size (first) != bfd_get_section_size (second))
+ return 0;
-/* Find which partial symtab contains PC. Return 0 if none.
- Backward compatibility, no section */
+ /* In-memory addresses may start at a different offset, relativize them. */
+ if (bfd_get_section_vma (first->owner, first)
+ - bfd_get_start_address (first->owner)
+ != bfd_get_section_vma (second->owner, second)
+ - bfd_get_start_address (second->owner))
+ return 0;
-struct partial_symtab *
-find_pc_psymtab (CORE_ADDR pc)
-{
- return find_pc_sect_psymtab (pc, find_pc_mapped_section (pc));
-}
+ if (bfd_get_section_name (first->owner, first) == NULL
+ || bfd_get_section_name (second->owner, second) == NULL
+ || strcmp (bfd_get_section_name (first->owner, first),
+ bfd_get_section_name (second->owner, second)) != 0)
+ return 0;
-/* Find which partial symbol within a psymtab matches PC and SECTION.
- Return 0 if none. Check all psymtabs if PSYMTAB is 0. */
+ /* Otherwise check that they are in corresponding objfiles. */
-struct partial_symbol *
-find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc,
- asection *section)
-{
- struct partial_symbol *best = NULL, *p, **pp;
- CORE_ADDR best_pc;
+ ALL_OBJFILES (obj)
+ if (obj->obfd == first->owner)
+ break;
+ gdb_assert (obj != NULL);
- if (!psymtab)
- psymtab = find_pc_sect_psymtab (pc, section);
- if (!psymtab)
- return 0;
+ if (obj->separate_debug_objfile != NULL
+ && obj->separate_debug_objfile->obfd == second->owner)
+ return 1;
+ if (obj->separate_debug_objfile_backlink != NULL
+ && obj->separate_debug_objfile_backlink->obfd == second->owner)
+ return 1;
- /* Cope with programs that start at address 0 */
- best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;
+ return 0;
+}
- /* 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 (pp = psymtab->objfile->global_psymbols.list + psymtab->globals_offset;
- (pp - (psymtab->objfile->global_psymbols.list + psymtab->globals_offset)
- < psymtab->n_global_syms);
- pp++)
- {
- p = *pp;
- if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
- && SYMBOL_CLASS (p) == LOC_BLOCK
- && pc >= SYMBOL_VALUE_ADDRESS (p)
- && (SYMBOL_VALUE_ADDRESS (p) > best_pc
- || (psymtab->textlow == 0
- && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
- {
- if (section) /* match on a specific section */
- {
- fixup_psymbol_section (p, psymtab->objfile);
- if (SYMBOL_BFD_SECTION (p) != section)
- continue;
- }
- best_pc = SYMBOL_VALUE_ADDRESS (p);
- best = p;
- }
- }
+struct symtab *
+find_pc_sect_symtab_via_partial (CORE_ADDR pc, struct obj_section *section)
+{
+ struct objfile *objfile;
+ struct minimal_symbol *msymbol;
- for (pp = psymtab->objfile->static_psymbols.list + psymtab->statics_offset;
- (pp - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset)
- < psymtab->n_static_syms);
- pp++)
- {
- p = *pp;
- if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
- && SYMBOL_CLASS (p) == LOC_BLOCK
- && pc >= SYMBOL_VALUE_ADDRESS (p)
- && (SYMBOL_VALUE_ADDRESS (p) > best_pc
- || (psymtab->textlow == 0
- && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
- {
- if (section) /* match on a specific section */
- {
- fixup_psymbol_section (p, psymtab->objfile);
- if (SYMBOL_BFD_SECTION (p) != section)
- continue;
- }
- best_pc = SYMBOL_VALUE_ADDRESS (p);
- best = p;
- }
- }
+ /* If we know that this is not a text address, return failure. This is
+ 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
+ && (MSYMBOL_TYPE (msymbol) == mst_data
+ || MSYMBOL_TYPE (msymbol) == mst_bss
+ || MSYMBOL_TYPE (msymbol) == mst_abs
+ || MSYMBOL_TYPE (msymbol) == mst_file_data
+ || MSYMBOL_TYPE (msymbol) == mst_file_bss))
+ return NULL;
- return best;
-}
+ ALL_OBJFILES (objfile)
+ {
+ struct symtab *result = NULL;
-/* Find which partial symbol within a psymtab matches PC. Return 0 if none.
- Check all psymtabs if PSYMTAB is 0. Backwards compatibility, no section. */
+ if (objfile->sf)
+ result = objfile->sf->qf->find_pc_sect_symtab (objfile, msymbol,
+ pc, section, 0);
+ if (result)
+ return result;
+ }
-struct partial_symbol *
-find_pc_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc)
-{
- return find_pc_sect_psymbol (psymtab, pc, find_pc_mapped_section (pc));
+ return NULL;
}
/* Debug symbols usually don't have section information. We need to dig that
out of the minimal symbols and stash that in the debug symbol. */
-static void
-fixup_section (struct general_symbol_info *ginfo, struct objfile *objfile)
+void
+fixup_section (struct general_symbol_info *ginfo,
+ CORE_ADDR addr, struct objfile *objfile)
{
struct minimal_symbol *msym;
- msym = lookup_minimal_symbol (ginfo->name, NULL, objfile);
+ /* First, check whether a minimal symbol with the same name exists
+ and points to the same address. The address check is required
+ e.g. on PowerPC64, where the minimal symbol for a function will
+ point to the function descriptor, while the debug symbol will
+ point to the actual function code. */
+ msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->name, objfile);
if (msym)
{
- ginfo->bfd_section = SYMBOL_BFD_SECTION (msym);
+ ginfo->obj_section = SYMBOL_OBJ_SECTION (msym);
ginfo->section = SYMBOL_SECTION (msym);
}
+ else
+ {
+ /* Static, function-local variables do appear in the linker
+ (minimal) symbols, but are frequently given names that won't
+ be found via lookup_minimal_symbol(). E.g., it has been
+ observed in frv-uclinux (ELF) executables that a static,
+ function-local variable named "foo" might appear in the
+ linker symbols as "foo.6" or "foo.3". Thus, there is no
+ point in attempting to extend the lookup-by-name mechanism to
+ handle this case due to the fact that there can be multiple
+ names.
+
+ So, instead, search the section table when lookup by name has
+ failed. The ``addr'' and ``endaddr'' fields may have already
+ been relocated. If so, the relocation offset (i.e. the
+ ANOFFSET value) needs to be subtracted from these values when
+ performing the comparison. We unconditionally subtract it,
+ because, when no relocation has been performed, the ANOFFSET
+ value will simply be zero.
+
+ The address of the symbol whose section we're fixing up HAS
+ NOT BEEN adjusted (relocated) yet. It can't have been since
+ the section isn't yet known and knowing the section is
+ necessary in order to add the correct relocation value. In
+ other words, we wouldn't even be in this function (attempting
+ to compute the section) if it were already known.
+
+ Note that it is possible to search the minimal symbols
+ (subtracting the relocation value if necessary) to find the
+ matching minimal symbol, but this is overkill and much less
+ efficient. It is not necessary to find the matching minimal
+ symbol, only its section.
+
+ Note that this technique (of doing a section table search)
+ can fail when unrelocated section addresses overlap. For
+ this reason, we still attempt a lookup by name prior to doing
+ a search of the section table. */
+
+ struct obj_section *s;
+
+ ALL_OBJFILE_OSECTIONS (objfile, s)
+ {
+ int idx = s->the_bfd_section->index;
+ CORE_ADDR offset = ANOFFSET (objfile->section_offsets, idx);
+
+ if (obj_section_addr (s) - offset <= addr
+ && addr < obj_section_endaddr (s) - offset)
+ {
+ ginfo->obj_section = s;
+ ginfo->section = idx;
+ return;
+ }
+ }
+ }
}
struct symbol *
fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
{
+ CORE_ADDR addr;
+
if (!sym)
return NULL;
- if (SYMBOL_BFD_SECTION (sym))
+ if (SYMBOL_OBJ_SECTION (sym))
return sym;
- fixup_section (&sym->ginfo, objfile);
+ /* 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));
- return sym;
-}
+ if (objfile == NULL)
+ objfile = SYMBOL_SYMTAB (sym)->objfile;
-struct partial_symbol *
-fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
-{
- if (!psym)
- return NULL;
+ /* We should have an objfile by now. */
+ gdb_assert (objfile);
- if (SYMBOL_BFD_SECTION (psym))
- return psym;
+ switch (SYMBOL_CLASS (sym))
+ {
+ case LOC_STATIC:
+ case LOC_LABEL:
+ addr = SYMBOL_VALUE_ADDRESS (sym);
+ break;
+ case LOC_BLOCK:
+ addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
+ break;
+
+ default:
+ /* Nothing else will be listed in the minsyms -- no use looking
+ it up. */
+ return sym;
+ }
- fixup_section (&psym->ginfo, objfile);
+ fixup_section (&sym->ginfo, addr, objfile);
- return psym;
+ return sym;
}
/* Find the definition for a specified symbol name NAME
in domain DOMAIN, visible from lexical block BLOCK.
Returns the struct symbol pointer, or zero if no symbol is found.
- If SYMTAB is non-NULL, store the symbol table in which the
- symbol was found there, or NULL if not found.
C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
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.
+ *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
@@ -893,28 +1008,56 @@ fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
code). */
struct symbol *
-lookup_symbol (const char *name, const struct block *block,
- const domain_enum domain, int *is_a_field_of_this,
- struct symtab **symtab)
+lookup_symbol_in_language (const char *name, const struct block *block,
+ const domain_enum domain, enum language lang,
+ int *is_a_field_of_this)
{
char *demangled_name = NULL;
const char *modified_name = NULL;
- const char *mangled_name = NULL;
- int needtofreename = 0;
struct symbol *returnval;
+ struct cleanup *cleanup = make_cleanup (null_cleanup, 0);
modified_name = name;
- /* If we are using C++ language, demangle the name before doing a lookup, so
- we can always binary search. */
- if (current_language->la_language == language_cplus)
+ /* If we are using C++, D, or Java, demangle the name before doing a
+ lookup, so we can always binary search. */
+ if (lang == language_cplus)
{
demangled_name = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
if (demangled_name)
{
- mangled_name = name;
modified_name = demangled_name;
- needtofreename = 1;
+ make_cleanup (xfree, demangled_name);
+ }
+ else
+ {
+ /* If we were given a non-mangled name, canonicalize it
+ according to the language (so far only for C++). */
+ demangled_name = cp_canonicalize_string (name);
+ if (demangled_name)
+ {
+ modified_name = demangled_name;
+ make_cleanup (xfree, demangled_name);
+ }
+ }
+ }
+ else if (lang == language_java)
+ {
+ demangled_name = cplus_demangle (name,
+ DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA);
+ if (demangled_name)
+ {
+ modified_name = demangled_name;
+ make_cleanup (xfree, demangled_name);
+ }
+ }
+ else if (lang == language_d)
+ {
+ demangled_name = d_demangle (name, 0);
+ if (demangled_name)
+ {
+ modified_name = demangled_name;
+ make_cleanup (xfree, demangled_name);
}
}
@@ -931,79 +1074,131 @@ lookup_symbol (const char *name, const struct block *block,
modified_name = copy;
}
- returnval = lookup_symbol_aux (modified_name, mangled_name, block,
- domain, is_a_field_of_this, symtab);
- if (needtofreename)
- xfree (demangled_name);
+ returnval = lookup_symbol_aux (modified_name, block, domain, lang,
+ is_a_field_of_this);
+ do_cleanups (cleanup);
+
+ return returnval;
+}
+
+/* Behave like lookup_symbol_in_language, but performed with the
+ current language. */
- return returnval;
+struct symbol *
+lookup_symbol (const char *name, const struct block *block,
+ domain_enum domain, int *is_a_field_of_this)
+{
+ return lookup_symbol_in_language (name, block, domain,
+ current_language->la_language,
+ is_a_field_of_this);
}
-/* Behave like lookup_symbol_aux except that NAME is the natural name
+/* Behave like lookup_symbol except that NAME is the natural name
of the symbol that we're looking for and, if LINKAGE_NAME is
non-NULL, ensure that the symbol's linkage name matches as
well. */
static struct symbol *
-lookup_symbol_aux (const char *name, const char *linkage_name,
- const struct block *block, const domain_enum domain,
- int *is_a_field_of_this, struct symtab **symtab)
+lookup_symbol_aux (const char *name, const struct block *block,
+ const domain_enum domain, enum language language,
+ int *is_a_field_of_this)
{
struct symbol *sym;
+ const struct language_defn *langdef;
+
+ /* Make sure we do something sensible with is_a_field_of_this, since
+ the callers that set this parameter to some non-null value will
+ certainly use it later and expect it to be either 0 or 1.
+ If we don't set it, the contents of is_a_field_of_this are
+ undefined. */
+ if (is_a_field_of_this != NULL)
+ *is_a_field_of_this = 0;
/* Search specified block and its superiors. Don't search
STATIC_BLOCK or GLOBAL_BLOCK. */
- sym = lookup_symbol_aux_local (name, linkage_name, block, domain,
- symtab);
+ sym = lookup_symbol_aux_local (name, block, domain, language);
if (sym != NULL)
return sym;
- /* If requested to do so by the caller and if appropriate for the
- current language, check to see if NAME is a field of `this'. */
+ /* If requested to do so by the caller and if appropriate for LANGUAGE,
+ check to see if NAME is a field of `this'. */
- if (current_language->la_value_of_this != NULL
- && is_a_field_of_this != NULL)
- {
- struct value *v = current_language->la_value_of_this (0);
+ langdef = language_def (language);
- *is_a_field_of_this = 0;
- if (v && check_field (v, name))
+ if (langdef->la_name_of_this != NULL && is_a_field_of_this != NULL
+ && block != NULL)
+ {
+ struct symbol *sym = NULL;
+ const struct block *function_block = block;
+
+ /* 'this' is only defined in the function's block, so find the
+ enclosing function block. */
+ for (; function_block && !BLOCK_FUNCTION (function_block);
+ function_block = BLOCK_SUPERBLOCK (function_block));
+
+ if (function_block && !dict_empty (BLOCK_DICT (function_block)))
+ sym = lookup_block_symbol (function_block, langdef->la_name_of_this,
+ VAR_DOMAIN);
+ if (sym)
{
- *is_a_field_of_this = 1;
- if (symtab != NULL)
- *symtab = NULL;
- return NULL;
+ struct type *t = sym->type;
+
+ /* I'm not really sure that type of this can ever
+ be typedefed; just be safe. */
+ CHECK_TYPEDEF (t);
+ if (TYPE_CODE (t) == TYPE_CODE_PTR
+ || TYPE_CODE (t) == TYPE_CODE_REF)
+ t = TYPE_TARGET_TYPE (t);
+
+ if (TYPE_CODE (t) != TYPE_CODE_STRUCT
+ && TYPE_CODE (t) != TYPE_CODE_UNION)
+ error (_("Internal error: `%s' is not an aggregate"),
+ langdef->la_name_of_this);
+
+ if (check_field (t, name))
+ {
+ *is_a_field_of_this = 1;
+ return NULL;
+ }
}
}
- /* Now do whatever is appropriate for the current language to look
+ /* Now do whatever is appropriate for LANGUAGE to look
up static and global variables. */
- sym = current_language->la_lookup_symbol_nonlocal (name, linkage_name,
- block, domain,
- symtab);
+ sym = langdef->la_lookup_symbol_nonlocal (name, block, domain);
if (sym != NULL)
return sym;
/* Now search all static file-level symbols. Not strictly correct,
- but more useful than an error. 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. */
+ but more useful than an error. */
- sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, linkage_name,
- domain, symtab);
- if (sym != NULL)
- return sym;
-
- sym = lookup_symbol_aux_psymtabs (STATIC_BLOCK, name, linkage_name,
- domain, symtab);
+ return lookup_static_symbol_aux (name, domain);
+}
+
+/* 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. */
+
+struct symbol *
+lookup_static_symbol_aux (const char *name, const domain_enum domain)
+{
+ struct objfile *objfile;
+ struct symbol *sym;
+
+ sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, domain);
if (sym != NULL)
return sym;
- if (symtab != NULL)
- *symtab = NULL;
+ ALL_OBJFILES (objfile)
+ {
+ sym = lookup_symbol_aux_quick (objfile, STATIC_BLOCK, name, domain);
+ if (sym != NULL)
+ return sym;
+ }
+
return NULL;
}
@@ -1011,14 +1206,14 @@ lookup_symbol_aux (const char *name, const char *linkage_name,
Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
static struct symbol *
-lookup_symbol_aux_local (const char *name, const char *linkage_name,
- const struct block *block,
- const domain_enum domain,
- struct symtab **symtab)
+lookup_symbol_aux_local (const char *name, const struct block *block,
+ const domain_enum domain,
+ enum language language)
{
struct symbol *sym;
const struct block *static_block = block_static_block (block);
-
+ const char *scope = block_scope (block);
+
/* Check if either no block is specified or it's a global block. */
if (static_block == NULL)
@@ -1026,278 +1221,199 @@ lookup_symbol_aux_local (const char *name, const char *linkage_name,
while (block != static_block)
{
- sym = lookup_symbol_aux_block (name, linkage_name, block, domain,
- symtab);
+ sym = lookup_symbol_aux_block (name, block, domain);
if (sym != NULL)
return sym;
+
+ if (language == language_cplus || language == language_fortran)
+ {
+ sym = cp_lookup_symbol_imports_or_template (scope, name, block,
+ domain);
+ if (sym != NULL)
+ return sym;
+ }
+
+ if (BLOCK_FUNCTION (block) != NULL && block_inlined_p (block))
+ break;
block = BLOCK_SUPERBLOCK (block);
}
- /* We've reached the static block without finding a result. */
+ /* We've reached the edge of the function without finding a result. */
+
+ return NULL;
+}
+
+/* Look up OBJFILE to BLOCK. */
+
+struct objfile *
+lookup_objfile_from_block (const struct block *block)
+{
+ struct objfile *obj;
+ struct symtab *s;
+
+ if (block == NULL)
+ return NULL;
+
+ block = block_global_block (block);
+ /* Go through SYMTABS. */
+ ALL_SYMTABS (obj, s)
+ if (block == BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK))
+ {
+ if (obj->separate_debug_objfile_backlink)
+ obj = obj->separate_debug_objfile_backlink;
+
+ return obj;
+ }
return NULL;
}
-/* Look up a symbol in a block; if found, locate its symtab, fixup the
- symbol, and set block_found appropriately. */
+/* Look up a symbol in a block; if found, fixup the symbol, and set
+ block_found appropriately. */
struct symbol *
-lookup_symbol_aux_block (const char *name, const char *linkage_name,
- const struct block *block,
- const domain_enum domain,
- struct symtab **symtab)
+lookup_symbol_aux_block (const char *name, const struct block *block,
+ const domain_enum domain)
{
struct symbol *sym;
- struct objfile *objfile = NULL;
- struct blockvector *bv;
- struct block *b;
- struct symtab *s = NULL;
- sym = lookup_block_symbol (block, name, linkage_name, domain);
+ sym = lookup_block_symbol (block, name, domain);
if (sym)
{
block_found = block;
- if (symtab != NULL)
- {
- /* Search the list of symtabs for one which contains the
- address of the start of this block. */
- ALL_SYMTABS (objfile, s)
- {
- bv = BLOCKVECTOR (s);
- b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- if (BLOCK_START (b) <= BLOCK_START (block)
- && BLOCK_END (b) > BLOCK_START (block))
- goto found;
- }
- found:
- *symtab = s;
- }
-
- return fixup_symbol_section (sym, objfile);
+ return fixup_symbol_section (sym, NULL);
}
return NULL;
}
-/* Check to see if the symbol is defined in one of the symtabs.
- BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
- depending on whether or not we want to search global symbols or
- static symbols. */
+/* Check all global symbols in OBJFILE in symtabs and
+ psymtabs. */
-static struct symbol *
-lookup_symbol_aux_symtabs (int block_index,
- const char *name, const char *linkage_name,
- const domain_enum domain,
- struct symtab **symtab)
+struct symbol *
+lookup_global_symbol_from_objfile (const struct objfile *main_objfile,
+ const char *name,
+ const domain_enum domain)
{
+ const struct objfile *objfile;
struct symbol *sym;
- struct objfile *objfile;
struct blockvector *bv;
const struct block *block;
struct symtab *s;
- ALL_SYMTABS (objfile, s)
- {
- bv = BLOCKVECTOR (s);
- block = BLOCKVECTOR_BLOCK (bv, block_index);
- sym = lookup_block_symbol (block, name, linkage_name, domain);
- if (sym)
- {
- block_found = block;
- if (symtab != NULL)
- *symtab = s;
- return fixup_symbol_section (sym, objfile);
- }
- }
+ for (objfile = main_objfile;
+ objfile;
+ objfile = objfile_separate_debug_iterate (main_objfile, objfile))
+ {
+ /* Go through symtabs. */
+ ALL_OBJFILE_SYMTABS (objfile, s)
+ {
+ bv = BLOCKVECTOR (s);
+ block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
+ sym = lookup_block_symbol (block, name, domain);
+ if (sym)
+ {
+ block_found = block;
+ return fixup_symbol_section (sym, (struct objfile *)objfile);
+ }
+ }
+
+ sym = lookup_symbol_aux_quick ((struct objfile *) objfile, GLOBAL_BLOCK,
+ name, domain);
+ if (sym)
+ return sym;
+ }
return NULL;
}
-/* Check to see if the symbol is defined in one of the partial
- symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or
- STATIC_BLOCK, depending on whether or not we want to search global
- symbols or static symbols. */
+/* Check to see if the symbol is defined in one of the symtabs.
+ BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
+ depending on whether or not we want to search global symbols or
+ static symbols. */
static struct symbol *
-lookup_symbol_aux_psymtabs (int block_index, const char *name,
- const char *linkage_name,
- const domain_enum domain,
- struct symtab **symtab)
+lookup_symbol_aux_symtabs (int block_index, const char *name,
+ const domain_enum domain)
{
struct symbol *sym;
struct objfile *objfile;
struct blockvector *bv;
const struct block *block;
- struct partial_symtab *ps;
struct symtab *s;
- const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
- ALL_PSYMTABS (objfile, ps)
+ ALL_OBJFILES (objfile)
{
- if (!ps->readin
- && lookup_partial_symbol (ps, name, linkage_name,
- psymtab_index, domain))
- {
- s = PSYMTAB_TO_SYMTAB (ps);
- bv = BLOCKVECTOR (s);
- block = BLOCKVECTOR_BLOCK (bv, block_index);
- sym = lookup_block_symbol (block, name, linkage_name, domain);
- if (!sym)
- {
- /* 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
- that the psymtab gets it wrong in some cases. */
-
- /* FIXME: carlton/2002-09-30: Should we really do that?
- If that happens, isn't it likely to be a GDB error, in
- which case we should fix the GDB error rather than
- silently dealing with it here? So I'd vote for
- removing the check for the symbol in the other
- block. */
- block = BLOCKVECTOR_BLOCK (bv,
- block_index == GLOBAL_BLOCK ?
- STATIC_BLOCK : GLOBAL_BLOCK);
- sym = lookup_block_symbol (block, name, linkage_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).",
- block_index == GLOBAL_BLOCK ? "global" : "static",
- name, ps->filename, name, name);
- }
- if (symtab != NULL)
- *symtab = s;
- 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;
}
-#if 0
-/* Check for the possibility of the symbol being a function or a
- mangled variable that is stored in one of the minimal symbol
- tables. Eventually, all global symbols might be resolved in this
- way. */
-
-/* NOTE: carlton/2002-12-05: At one point, this function was part of
- lookup_symbol_aux, and what are now 'return' statements within
- lookup_symbol_aux_minsyms returned from lookup_symbol_aux, even if
- sym was NULL. As far as I can tell, this was basically accidental;
- it didn't happen every time that msymbol was non-NULL, but only if
- some additional conditions held as well, and it caused problems
- with HP-generated symbol tables. */
-
-/* NOTE: carlton/2003-05-14: This function was once used as part of
- lookup_symbol. It is currently unnecessary for correctness
- reasons, however, and using it doesn't seem to be any faster than
- using lookup_symbol_aux_psymtabs, so I'm commenting it out. */
+/* A helper function for lookup_symbol_aux that interfaces with the
+ "quick" symbol table functions. */
static struct symbol *
-lookup_symbol_aux_minsyms (const char *name,
- const char *linkage_name,
- const domain_enum domain,
- int *is_a_field_of_this,
- struct symtab **symtab)
+lookup_symbol_aux_quick (struct objfile *objfile, int kind,
+ const char *name, const domain_enum domain)
{
- struct symbol *sym;
+ struct symtab *symtab;
struct blockvector *bv;
const struct block *block;
- struct minimal_symbol *msymbol;
- struct symtab *s;
-
- if (domain == VAR_DOMAIN)
- {
- msymbol = lookup_minimal_symbol (name, NULL, NULL);
+ struct symbol *sym;
- if (msymbol != NULL)
- {
- /* OK, we found a minimal symbol in spite of not finding any
- symbol. There are various possible explanations for
- this. One possibility is the symbol exists in code not
- compiled -g. Another possibility is that the 'psymtab'
- isn't doing its job. A third possibility, related to #2,
- is that we were confused by name-mangling. For instance,
- maybe the psymtab isn't doing its job because it only
- know about demangled names, but we were given a mangled
- name... */
-
- /* We first use the address in the msymbol to try to locate
- the appropriate symtab. Note that find_pc_sect_symtab()
- has a side-effect of doing psymtab-to-symtab expansion,
- for the found symtab. */
- s = find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol),
- SYMBOL_BFD_SECTION (msymbol));
- if (s != NULL)
- {
- /* This is a function which has a symtab for its address. */
- bv = BLOCKVECTOR (s);
- block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
-
- /* This call used to pass `DEPRECATED_SYMBOL_NAME (msymbol)' as the
- `name' argument to lookup_block_symbol. But the name
- of a minimal symbol is always mangled, so that seems
- to be clearly the wrong thing to pass as the
- unmangled name. */
- sym =
- lookup_block_symbol (block, name, linkage_name, domain);
- /* We kept static functions in minimal symbol table as well as
- in static scope. We want to find them in the symbol table. */
- if (!sym)
- {
- block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
- sym = lookup_block_symbol (block, name,
- linkage_name, domain);
- }
+ if (!objfile->sf)
+ return NULL;
+ symtab = objfile->sf->qf->lookup_symbol (objfile, kind, name, domain);
+ if (!symtab)
+ return NULL;
- /* NOTE: carlton/2002-12-04: The following comment was
- taken from a time when two versions of this function
- were part of the body of lookup_symbol_aux: this
- comment was taken from the version of the function
- that was #ifdef HPUXHPPA, and the comment was right
- before the 'return NULL' part of lookup_symbol_aux.
- (Hence the "Fall through and return 0" comment.)
- Elena did some digging into the situation for
- Fortran, and she reports:
-
- "I asked around (thanks to Jeff Knaggs), and I think
- the story for Fortran goes like this:
-
- "Apparently, in older Fortrans, '_' was not part of
- the user namespace. g77 attached a final '_' to
- procedure names as the exported symbols for linkage
- (foo_) , but the symbols went in the debug info just
- like 'foo'. The rationale behind this is not
- completely clear, and maybe it was done to other
- symbols as well, not just procedures." */
-
- /* If we get here with sym == 0, the symbol was
- found in the minimal symbol table
- but not in the symtab.
- Fall through and return 0 to use the msymbol
- definition of "foo_".
- (Note that outer code generally follows up a call
- to this routine with a call to lookup_minimal_symbol(),
- so a 0 return means we'll just flow into that other routine).
-
- This happens for Fortran "foo_" symbols,
- which are "foo" in the symtab.
-
- This can also happen if "asm" is used to make a
- regular symbol but not a debugging symbol, e.g.
- asm(".globl _main");
- asm("_main:");
- */
-
- if (symtab != NULL && sym != NULL)
- *symtab = s;
- return fixup_symbol_section (sym, s->objfile);
- }
- }
+ bv = BLOCKVECTOR (symtab);
+ block = BLOCKVECTOR_BLOCK (bv, kind);
+ sym = lookup_block_symbol (block, name, domain);
+ if (!sym)
+ {
+ /* 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
+ that the psymtab gets it wrong in some cases. */
+
+ /* FIXME: carlton/2002-09-30: Should we really do that?
+ If that happens, isn't it likely to be a GDB error, in
+ which case we should fix the GDB error rather than
+ silently dealing with it here? So I'd vote for
+ removing the check for the symbol in the other
+ block. */
+ block = BLOCKVECTOR_BLOCK (bv,
+ kind == GLOBAL_BLOCK ?
+ 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)."),
+ kind == GLOBAL_BLOCK ? "global" : "static",
+ name, symtab->filename, name, name);
}
-
- return NULL;
+ return fixup_symbol_section (sym, objfile);
}
-#endif /* 0 */
/* A default version of lookup_symbol_nonlocal for use by languages
that can't think of anything better to do. This implements the C
@@ -1305,10 +1421,8 @@ lookup_symbol_aux_minsyms (const char *name,
struct symbol *
basic_lookup_symbol_nonlocal (const char *name,
- const char *linkage_name,
const struct block *block,
- const domain_enum domain,
- struct symtab **symtab)
+ const domain_enum domain)
{
struct symbol *sym;
@@ -1340,11 +1454,11 @@ basic_lookup_symbol_nonlocal (const char *name,
than that one, so I don't think we should worry about that for
now. */
- sym = lookup_symbol_static (name, linkage_name, block, domain, symtab);
+ sym = lookup_symbol_static (name, block, domain);
if (sym != NULL)
return sym;
- return lookup_symbol_global (name, linkage_name, domain, symtab);
+ return lookup_symbol_global (name, block, domain);
}
/* Lookup a symbol in the static block associated to BLOCK, if there
@@ -1352,16 +1466,13 @@ basic_lookup_symbol_nonlocal (const char *name,
struct symbol *
lookup_symbol_static (const char *name,
- const char *linkage_name,
const struct block *block,
- const domain_enum domain,
- struct symtab **symtab)
+ const domain_enum domain)
{
const struct block *static_block = block_static_block (block);
if (static_block != NULL)
- return lookup_symbol_aux_block (name, linkage_name, static_block,
- domain, symtab);
+ return lookup_symbol_aux_block (name, static_block, domain);
else
return NULL;
}
@@ -1371,244 +1482,213 @@ lookup_symbol_static (const char *name,
struct symbol *
lookup_symbol_global (const char *name,
- const char *linkage_name,
- const domain_enum domain,
- struct symtab **symtab)
+ const struct block *block,
+ const domain_enum domain)
{
- struct symbol *sym;
+ struct symbol *sym = NULL;
+ struct objfile *objfile = NULL;
- sym = lookup_symbol_aux_symtabs (GLOBAL_BLOCK, name, linkage_name,
- domain, symtab);
+ /* Call library-specific lookup procedure. */
+ objfile = lookup_objfile_from_block (block);
+ if (objfile != NULL)
+ sym = solib_global_lookup (objfile, name, domain);
if (sym != NULL)
return sym;
- return lookup_symbol_aux_psymtabs (GLOBAL_BLOCK, name, linkage_name,
- domain, symtab);
-}
+ sym = lookup_symbol_aux_symtabs (GLOBAL_BLOCK, name, domain);
+ if (sym != NULL)
+ return sym;
+
+ ALL_OBJFILES (objfile)
+ {
+ sym = lookup_symbol_aux_quick (objfile, GLOBAL_BLOCK, name, domain);
+ if (sym)
+ return sym;
+ }
-/* Look, in partial_symtab PST, for symbol whose natural name is NAME.
- If LINKAGE_NAME is non-NULL, check in addition that the symbol's
- linkage name matches it. Check the global symbols if GLOBAL, the
- static symbols if not */
+ return NULL;
+}
-static struct partial_symbol *
-lookup_partial_symbol (struct partial_symtab *pst, const char *name,
- const char *linkage_name, int global,
+int
+symbol_matches_domain (enum language symbol_language,
+ domain_enum symbol_domain,
domain_enum domain)
{
- struct partial_symbol *temp;
- struct partial_symbol **start, **psym;
- struct partial_symbol **top, **real_top, **bottom, **center;
- int length = (global ? pst->n_global_syms : pst->n_static_syms);
- int do_linear_search = 1;
-
- if (length == 0)
+ /* For C++ "struct foo { ... }" also defines a typedef for "foo".
+ A Java class declaration also defines a typedef for the class.
+ Similarly, any Ada type declaration implicitly defines a typedef. */
+ if (symbol_language == language_cplus
+ || symbol_language == language_d
+ || symbol_language == language_java
+ || symbol_language == language_ada)
{
- return (NULL);
+ if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
+ && symbol_domain == STRUCT_DOMAIN)
+ return 1;
}
- start = (global ?
- pst->objfile->global_psymbols.list + pst->globals_offset :
- pst->objfile->static_psymbols.list + pst->statics_offset);
-
- if (global) /* This means we can use a binary search. */
- {
- do_linear_search = 0;
-
- /* Binary search. This search is guaranteed to end with center
- pointing at the earliest partial symbol whose name might be
- correct. At that point *all* partial symbols with an
- appropriate name will be checked against the correct
- domain. */
-
- bottom = start;
- top = start + length - 1;
- real_top = top;
- while (top > bottom)
- {
- center = bottom + (top - bottom) / 2;
- if (!(center < top))
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
- if (!do_linear_search
- && (SYMBOL_LANGUAGE (*center) == language_java))
- {
- do_linear_search = 1;
- }
- if (strcmp_iw_ordered (SYMBOL_NATURAL_NAME (*center), name) >= 0)
- {
- top = center;
- }
- else
- {
- bottom = center + 1;
- }
- }
- if (!(top == bottom))
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ /* For all other languages, strict match is required. */
+ return (symbol_domain == domain);
+}
- while (top <= real_top
- && (linkage_name != NULL
- ? strcmp (SYMBOL_LINKAGE_NAME (*top), linkage_name) == 0
- : SYMBOL_MATCHES_NATURAL_NAME (*top,name)))
- {
- if (SYMBOL_DOMAIN (*top) == domain)
- {
- return (*top);
- }
- top++;
- }
- }
+/* Look up a type named NAME in the struct_domain. The type returned
+ must not be opaque -- i.e., must have at least one field
+ defined. */
- /* Can't use a binary search or else we found during the binary search that
- we should also do a linear search. */
+struct type *
+lookup_transparent_type (const char *name)
+{
+ return current_language->la_lookup_transparent_type (name);
+}
- if (do_linear_search)
- {
- for (psym = start; psym < start + length; psym++)
- {
- if (domain == SYMBOL_DOMAIN (*psym))
- {
- if (linkage_name != NULL
- ? strcmp (SYMBOL_LINKAGE_NAME (*psym), linkage_name) == 0
- : SYMBOL_MATCHES_NATURAL_NAME (*psym, name))
- {
- return (*psym);
- }
- }
- }
- }
+/* A helper for basic_lookup_transparent_type that interfaces with the
+ "quick" symbol table functions. */
- return (NULL);
-}
+static struct type *
+basic_lookup_transparent_type_quick (struct objfile *objfile, int kind,
+ const char *name)
+{
+ struct symtab *symtab;
+ struct blockvector *bv;
+ struct block *block;
+ struct symbol *sym;
-/* Look up a type named NAME in the struct_domain. The type returned
- must not be opaque -- i.e., must have at least one field defined
+ if (!objfile->sf)
+ return NULL;
+ symtab = objfile->sf->qf->lookup_symbol (objfile, kind, name, STRUCT_DOMAIN);
+ if (!symtab)
+ return NULL;
+
+ bv = BLOCKVECTOR (symtab);
+ block = BLOCKVECTOR_BLOCK (bv, kind);
+ sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
+ if (!sym)
+ {
+ int other_kind = kind == GLOBAL_BLOCK ? STATIC_BLOCK : GLOBAL_BLOCK;
+
+ /* 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
+ * 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\
+%s may be an inlined function, or may be a template function\n\
+(if a template, try specifying an instantiation: %s)."),
+ name, symtab->filename, name, name);
+ }
+ if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
+ return SYMBOL_TYPE (sym);
- This code was modelled on lookup_symbol -- the parts not relevant to looking
- up types were just left out. In particular it's assumed here that types
- are available in struct_domain and only at file-static or global blocks. */
+ return NULL;
+}
+/* The standard implementation of lookup_transparent_type. This code
+ was modeled on lookup_symbol -- the parts not relevant to looking
+ up types were just left out. In particular it's assumed here that
+ types are available in struct_domain and only at file-static or
+ global blocks. */
struct type *
-lookup_transparent_type (const char *name)
+basic_lookup_transparent_type (const char *name)
{
- register struct symbol *sym;
- register struct symtab *s = NULL;
- register struct partial_symtab *ps;
+ struct symbol *sym;
+ struct symtab *s = NULL;
struct blockvector *bv;
- register struct objfile *objfile;
- register struct block *block;
+ struct objfile *objfile;
+ struct block *block;
+ 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_SYMTABS (objfile, s)
+ ALL_OBJFILES (objfile)
{
- bv = BLOCKVECTOR (s);
- block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- sym = lookup_block_symbol (block, name, NULL, 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_PSYMTABS (objfile, ps)
+ ALL_OBJFILES (objfile)
{
- if (!ps->readin && lookup_partial_symbol (ps, name, NULL,
- 1, STRUCT_DOMAIN))
- {
- s = PSYMTAB_TO_SYMTAB (ps);
- bv = BLOCKVECTOR (s);
- block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
- if (!sym)
- {
- /* This shouldn't be necessary, but as a last resort
- * try looking in the statics even though the psymtab
- * claimed the symbol was global. It's possible that
- * the psymtab gets it wrong in some cases.
- */
- block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
- sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
- if (!sym)
- 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).",
- name, ps->filename, name, name);
- }
- if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
- return SYMBOL_TYPE (sym);
- }
+ 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.
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_SYMTABS (objfile, s)
+ ALL_OBJFILES (objfile)
{
- bv = BLOCKVECTOR (s);
- block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
- sym = lookup_block_symbol (block, name, NULL, 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, STATIC_BLOCK,
+ name, STRUCT_DOMAIN);
- ALL_PSYMTABS (objfile, ps)
- {
- if (!ps->readin && lookup_partial_symbol (ps, name, NULL, 0, STRUCT_DOMAIN))
+ ALL_OBJFILE_SYMTABS (objfile, s)
{
- s = PSYMTAB_TO_SYMTAB (ps);
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
- sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
- if (!sym)
+ sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
+ if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
{
- /* This shouldn't be necessary, but as a last resort
- * try looking in the globals even though the psymtab
- * claimed the symbol was static. It's possible that
- * the psymtab gets it wrong in some cases.
- */
- block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
- if (!sym)
- error ("Internal: static 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).",
- name, ps->filename, name, name);
+ return SYMBOL_TYPE (sym);
}
- if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
- return SYMBOL_TYPE (sym);
}
}
+
+ ALL_OBJFILES (objfile)
+ {
+ t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name);
+ if (t)
+ return t;
+ }
+
return (struct type *) 0;
}
-/* Find the psymtab 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() ? */
-struct partial_symtab *
-find_main_psymtab (void)
+const char *
+find_main_filename (void)
{
- register struct partial_symtab *pst;
- register struct objfile *objfile;
+ struct objfile *objfile;
+ char *name = main_name ();
- ALL_PSYMTABS (objfile, pst)
+ ALL_OBJFILES (objfile)
{
- if (lookup_partial_symbol (pst, main_name (), NULL, 1, VAR_DOMAIN))
- {
- return (pst);
- }
+ const char *result;
+
+ if (!objfile->sf)
+ continue;
+ result = objfile->sf->qf->find_symbol_file (objfile, name);
+ if (result)
+ return result;
}
return (NULL);
}
@@ -1621,228 +1701,73 @@ find_main_psymtab (void)
a match we'll never find, since it will go pretty quick. Once the
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.
-
- If LINKAGE_NAME is non-NULL, verify that any symbol we find has this
- particular mangled name.
-*/
+ symbol (language_cplus or language_objc set) has both the encoded and
+ non-encoded names tested for a match. */
struct symbol *
-lookup_block_symbol (register const struct block *block, const char *name,
- const char *linkage_name,
+lookup_block_symbol (const struct block *block, const char *name,
const domain_enum domain)
{
- register int bot, top, inc;
- register struct symbol *sym;
- register struct symbol *sym_found = NULL;
- register int do_linear_search = 1;
+ struct dict_iterator iter;
+ struct symbol *sym;
- if (BLOCK_HASHTABLE (block))
+ if (!BLOCK_FUNCTION (block))
{
- unsigned int hash_index;
- hash_index = msymbol_hash_iw (name);
- hash_index = hash_index % BLOCK_BUCKETS (block);
- for (sym = BLOCK_BUCKET (block, hash_index); sym; sym = sym->hash_next)
+ for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter);
+ sym != NULL;
+ sym = dict_iter_name_next (name, &iter))
{
- if (SYMBOL_DOMAIN (sym) == domain
- && (linkage_name
- ? strcmp (DEPRECATED_SYMBOL_NAME (sym), linkage_name) == 0
- : SYMBOL_MATCHES_NATURAL_NAME (sym, name)))
+ if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
+ SYMBOL_DOMAIN (sym), domain))
return sym;
}
return NULL;
- }
-
- /* If the blocks's symbols were sorted, start with a binary search. */
-
- if (BLOCK_SHOULD_SORT (block))
- {
- /* Reset the linear search flag so if the binary search fails, we
- won't do the linear search once unless we find some reason to
- do so */
-
- do_linear_search = 0;
- top = BLOCK_NSYMS (block);
- bot = 0;
-
- /* Advance BOT to not far before the first symbol whose name is NAME. */
-
- while (1)
- {
- inc = (top - bot + 1);
- /* No need to keep binary searching for the last few bits worth. */
- if (inc < 4)
- {
- break;
- }
- inc = (inc >> 1) + bot;
- sym = BLOCK_SYM (block, inc);
- if (!do_linear_search && (SYMBOL_LANGUAGE (sym) == language_java))
- {
- do_linear_search = 1;
- }
- if (SYMBOL_NATURAL_NAME (sym)[0] < name[0])
- {
- bot = inc;
- }
- else if (SYMBOL_NATURAL_NAME (sym)[0] > name[0])
- {
- top = inc;
- }
- else if (strcmp (SYMBOL_NATURAL_NAME (sym), name) < 0)
- {
- bot = inc;
- }
- else
- {
- top = inc;
- }
- }
-
- /* Now scan forward until we run out of symbols, find one whose
- name is greater than NAME, or find one we want. If there is
- more than one symbol with the right name and domain, we
- return the first one; I believe it is now impossible for us
- to encounter two symbols with the same name and domain
- here, because blocks containing argument symbols are no
- longer sorted. The exception is for C++, where multiple functions
- (cloned constructors / destructors, in particular) can have
- the same demangled name. So if we have a particular
- mangled name to match, try to do so. */
-
- top = BLOCK_NSYMS (block);
- while (bot < top)
- {
- sym = BLOCK_SYM (block, bot);
- if (SYMBOL_DOMAIN (sym) == domain
- && (linkage_name
- ? strcmp (DEPRECATED_SYMBOL_NAME (sym), linkage_name) == 0
- : SYMBOL_MATCHES_NATURAL_NAME (sym, name)))
- {
- return sym;
- }
- if (SYMBOL_PRINT_NAME (sym)[0] > name[0])
- {
- break;
- }
- bot++;
- }
- }
-
- /* Here if block isn't sorted, or we fail to find a match during the
- binary search above. If during the binary search above, we find a
- symbol which is a Java symbol, then we have re-enabled the linear
- search flag which was reset when starting the binary search.
-
- This loop is equivalent to the loop above, but hacked greatly for speed.
-
- Note that parameter symbols do not always show up last in the
- list; this loop makes sure to take anything else other than
- parameter symbols first; it only uses parameter symbols as a
- last resort. Note that this only takes up extra computation
- time on a match. */
-
- if (do_linear_search)
- {
- top = BLOCK_NSYMS (block);
- bot = 0;
- while (bot < top)
- {
- sym = BLOCK_SYM (block, bot);
- if (SYMBOL_DOMAIN (sym) == domain
- && (linkage_name
- ? strcmp (DEPRECATED_SYMBOL_NAME (sym), linkage_name) == 0
- : SYMBOL_MATCHES_NATURAL_NAME (sym, name)))
- {
- /* If SYM has aliases, then use any alias that is active
- at the current PC. If no alias is active at the current
- PC, then use the main symbol.
-
- ?!? Is checking the current pc correct? Is this routine
- ever called to look up a symbol from another context?
-
- FIXME: No, it's not correct. If someone sets a
- conditional breakpoint at an address, then the
- breakpoint's `struct expression' should refer to the
- `struct symbol' appropriate for the breakpoint's
- address, which may not be the PC.
-
- Even if it were never called from another context,
- it's totally bizarre for lookup_symbol's behavior to
- depend on the value of the inferior's current PC. We
- should pass in the appropriate PC as well as the
- block. The interface to lookup_symbol should change
- to require the caller to provide a PC. */
-
- if (SYMBOL_ALIASES (sym))
- sym = find_active_alias (sym, read_pc ());
-
- sym_found = sym;
- if (SYMBOL_CLASS (sym) != LOC_ARG &&
- SYMBOL_CLASS (sym) != LOC_LOCAL_ARG &&
- SYMBOL_CLASS (sym) != LOC_REF_ARG &&
- SYMBOL_CLASS (sym) != LOC_REGPARM &&
- SYMBOL_CLASS (sym) != LOC_REGPARM_ADDR &&
- SYMBOL_CLASS (sym) != LOC_BASEREG_ARG &&
- SYMBOL_CLASS (sym) != LOC_COMPUTED_ARG)
- {
- break;
- }
- }
- bot++;
- }
- }
- return (sym_found); /* Will be NULL if not found. */
-}
-
-/* Given a main symbol SYM and ADDR, search through the alias
- list to determine if an alias is active at ADDR and return
- the active alias.
-
- If no alias is active, then return SYM. */
-
-static struct symbol *
-find_active_alias (struct symbol *sym, CORE_ADDR addr)
-{
- struct range_list *r;
- struct alias_list *aliases;
+ }
+ else
+ {
+ /* Note that parameter symbols do not always show up last in the
+ list; this loop makes sure to take anything else other than
+ parameter symbols first; it only uses parameter symbols as a
+ last resort. Note that this only takes up extra computation
+ time on a match. */
- /* If we have aliases, check them first. */
- aliases = SYMBOL_ALIASES (sym);
+ struct symbol *sym_found = NULL;
- while (aliases)
- {
- if (!SYMBOL_RANGES (aliases->sym))
- return aliases->sym;
- for (r = SYMBOL_RANGES (aliases->sym); r; r = r->next)
+ for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter);
+ sym != NULL;
+ sym = dict_iter_name_next (name, &iter))
{
- if (r->start <= addr && r->end > addr)
- return aliases->sym;
+ if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
+ SYMBOL_DOMAIN (sym), domain))
+ {
+ sym_found = sym;
+ if (!SYMBOL_IS_ARGUMENT (sym))
+ {
+ break;
+ }
+ }
}
- aliases = aliases->next;
+ return (sym_found); /* Will be NULL if not found. */
}
-
- /* Nothing found, return the main symbol. */
- return sym;
}
-
/* 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, asection *section)
+find_pc_sect_symtab (CORE_ADDR pc, struct obj_section *section)
{
- register struct block *b;
+ struct block *b;
struct blockvector *bv;
- register struct symtab *s = NULL;
- register struct symtab *best_s = NULL;
- register struct partial_symtab *ps;
- register struct objfile *objfile;
+ struct symtab *s = NULL;
+ struct symtab *best_s = NULL;
+ struct objfile *objfile;
+ struct program_space *pspace;
CORE_ADDR distance = 0;
struct minimal_symbol *msymbol;
+ pspace = current_program_space;
+
/* If we know that this is not a text address, return failure. This is
necessary because we loop based on the block's high and low code
addresses, which do not include the data ranges, and because
@@ -1850,11 +1775,11 @@ find_pc_sect_symtab (CORE_ADDR pc, asection *section)
on the partial_symtab's texthigh and textlow. */
msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
if (msymbol
- && (msymbol->type == mst_data
- || msymbol->type == mst_bss
- || msymbol->type == mst_abs
- || msymbol->type == mst_file_data
- || msymbol->type == mst_file_bss))
+ && (MSYMBOL_TYPE (msymbol) == mst_data
+ || MSYMBOL_TYPE (msymbol) == mst_bss
+ || MSYMBOL_TYPE (msymbol) == mst_abs
+ || MSYMBOL_TYPE (msymbol) == mst_file_data
+ || MSYMBOL_TYPE (msymbol) == mst_file_bss))
return NULL;
/* Search all symtabs for the one whose file contains our address, and which
@@ -1864,7 +1789,7 @@ find_pc_sect_symtab (CORE_ADDR pc, asection *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).
@@ -1872,7 +1797,7 @@ find_pc_sect_symtab (CORE_ADDR pc, asection *section)
It also happens for objfiles that have their functions reordered.
For these, the symtab we are looking for is not necessarily read in. */
- ALL_SYMTABS (objfile, s)
+ ALL_PRIMARY_SYMTABS (objfile, s)
{
bv = BLOCKVECTOR (s);
b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
@@ -1887,26 +1812,33 @@ find_pc_sect_symtab (CORE_ADDR pc, asection *section)
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. */
- if ((objfile->flags & OBJF_REORDERED) && objfile->psymtabs)
+ can't be found. */
+ if ((objfile->flags & OBJF_REORDERED) && objfile->sf)
{
- ps = find_pc_sect_psymtab (pc, section);
- if (ps)
- return PSYMTAB_TO_SYMTAB (ps);
+ struct symtab *result;
+
+ result
+ = objfile->sf->qf->find_pc_sect_symtab (objfile,
+ msymbol,
+ pc, section,
+ 0);
+ if (result)
+ return result;
}
if (section != 0)
{
- int i;
+ struct dict_iterator iter;
struct symbol *sym = NULL;
- ALL_BLOCK_SYMBOLS (b, i, sym)
+ ALL_BLOCK_SYMBOLS (b, iter, sym)
{
fixup_symbol_section (sym, objfile);
- if (section == SYMBOL_BFD_SECTION (sym))
+ if (matching_obj_sections (SYMBOL_OBJ_SECTION (sym), section))
break;
}
- if ((i >= BLOCK_BUCKETS (b)) && (sym == NULL))
- continue; /* no symbol in this symtab matches section */
+ if (sym == NULL)
+ continue; /* No symbol in this symtab matches
+ section. */
}
distance = BLOCK_END (b) - BLOCK_START (b);
best_s = s;
@@ -1916,24 +1848,25 @@ find_pc_sect_symtab (CORE_ADDR pc, asection *section)
if (best_s != NULL)
return (best_s);
- s = NULL;
- ps = find_pc_sect_psymtab (pc, section);
- if (ps)
- {
- if (ps->readin)
- /* Might want to error() here (in case symtab is corrupt and
- will cause a core dump), but maybe we can successfully
- continue, so let's not. */
- warning ("\
-(Internal error: pc 0x%s in read in psymtab, but not in symtab.)\n",
- paddr_nz (pc));
- s = PSYMTAB_TO_SYMTAB (ps);
- }
- return (s);
+ ALL_OBJFILES (objfile)
+ {
+ struct symtab *result;
+
+ if (!objfile->sf)
+ continue;
+ result = objfile->sf->qf->find_pc_sect_symtab (objfile,
+ msymbol,
+ pc, section,
+ 1);
+ if (result)
+ return result;
+ }
+
+ 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)
@@ -1960,17 +1893,18 @@ find_pc_symtab (CORE_ADDR pc)
/* If it's worth the effort, we could be using a binary search. */
struct symtab_and_line
-find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent)
+find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
{
struct symtab *s;
- register struct linetable *l;
- register int len;
- register int i;
- register struct linetable_entry *item;
+ struct linetable *l;
+ int len;
+ int i;
+ struct linetable_entry *item;
struct symtab_and_line val;
struct blockvector *bv;
struct minimal_symbol *msymbol;
struct minimal_symbol *mfunsym;
+ struct objfile *objfile;
/* Info on best line seen so far, and where it starts, and its file. */
@@ -1998,6 +1932,8 @@ find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent)
init_sal (&val); /* initialize to zeroes */
+ val.pspace = current_program_space;
+
/* It's tempting to assume that, if we can't find debugging info for
any function enclosing PC, that we shouldn't search for line
number info, either. However, GAS can emit line number info for
@@ -2010,10 +1946,10 @@ find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent)
/* 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
- two functions in the target, and the line info was erroneously
- taken to be the one of the line before the pc.
- */
+ 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. */
+
/* RT: Further explanation:
* We have stubs (trampolines) inserted between procedures.
@@ -2022,10 +1958,10 @@ find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent)
* 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
+ * Minimal symbol table for main image
* main: code for main (text symbol)
* shr1: stub (trampoline symbol)
* foo: code for foo (text symbol)
@@ -2042,13 +1978,13 @@ find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent)
*
* 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
- * we're in "foo" in the above example), it'll have a closer
+ * 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.
*/
@@ -2056,33 +1992,39 @@ find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent)
if (msymbol != NULL)
if (MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
{
- mfunsym = lookup_minimal_symbol_text (DEPRECATED_SYMBOL_NAME (msymbol), NULL, NULL);
+ mfunsym = lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol),
+ NULL);
if (mfunsym == NULL)
/* I eliminated this warning since it is coming out
* in the following situation:
* gdb shmain // test program with shared libraries
* (gdb) break shr1 // function in shared lib
* Warning: In stub for ...
- * In the above situation, the shared lib is not loaded yet,
+ * 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", DEPRECATED_SYMBOL_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 (mfunsym) == SYMBOL_VALUE (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", DEPRECATED_SYMBOL_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 (mfunsym), 0);
+ 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;
@@ -2090,13 +2032,17 @@ find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent)
}
bv = BLOCKVECTOR (s);
+ objfile = s->objfile;
/* 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 (; s && BLOCKVECTOR (s) == bv; s = s->next)
+ ALL_OBJFILE_SYMTABS (objfile, s)
{
+ if (BLOCKVECTOR (s) != bv)
+ continue;
+
/* Find the best line in this symtab. */
l = LINETABLE (s);
if (!l)
@@ -2112,7 +2058,7 @@ find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent)
}
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. */
@@ -2162,29 +2108,17 @@ find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent)
if (!best_symtab)
{
- if (!alt_symtab)
- { /* If we didn't find any line # info, just
- return zeros. */
- val.pc = pc;
- }
- else
- {
- val.symtab = alt_symtab;
- val.line = alt->line - 1;
-
- /* Don't return line 0, that means that we didn't find the line. */
- if (val.line == 0)
- ++val.line;
-
- val.pc = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
- val.end = alt->pc;
- }
+ /* If we didn't find any line number info, just return zeros.
+ We used to return alt->line - 1 here, but that could be
+ anywhere; if we don't have line number info for this PC,
+ don't make some up. */
+ val.pc = pc;
}
else if (best->line == 0)
{
/* 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
@@ -2203,12 +2137,12 @@ find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent)
return val;
}
-/* Backward compatibility (no section) */
+/* Backward compatibility (no section). */
struct symtab_and_line
find_pc_line (CORE_ADDR pc, int notcurrent)
{
- asection *section;
+ struct obj_section *section;
section = find_pc_overlay (pc);
if (pc_in_unmapped_range (pc, section))
@@ -2227,9 +2161,10 @@ find_pc_line (CORE_ADDR pc, int notcurrent)
If not found, return NULL. */
struct symtab *
-find_line_symtab (struct symtab *symtab, int line, int *index, int *exact_match)
+find_line_symtab (struct symtab *symtab, int line,
+ int *index, int *exact_match)
{
- int exact;
+ int exact = 0; /* Initialized here to avoid a compiler warning. */
/* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
so far seen. */
@@ -2264,13 +2199,27 @@ find_line_symtab (struct symtab *symtab, int line, int *index, int *exact_match)
else
best = 0;
+ ALL_OBJFILES (objfile)
+ {
+ if (objfile->sf)
+ objfile->sf->qf->expand_symtabs_with_filename (objfile,
+ symtab->filename);
+ }
+
+ /* Get symbol full file name if possible. */
+ symtab_to_fullname (symtab);
+
ALL_SYMTABS (objfile, s)
{
struct linetable *l;
int ind;
- if (!STREQ (symtab->filename, s->filename))
+ if (FILENAME_CMP (symtab->filename, s->filename) != 0)
continue;
+ if (symtab->fullname != NULL
+ && symtab_to_fullname (s) != NULL
+ && FILENAME_CMP (symtab->fullname, s->fullname) != 0)
+ continue;
l = LINETABLE (s);
ind = find_line_common (l, line, &exact);
if (ind >= 0)
@@ -2375,11 +2324,11 @@ find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr,
Set *EXACT_MATCH nonzero if the value returned is an exact match. */
static int
-find_line_common (register struct linetable *l, register int lineno,
+find_line_common (struct linetable *l, int lineno,
int *exact_match)
{
- register int i;
- register int len;
+ int i;
+ int len;
/* BEST is the smallest linenumber > LINENO so far seen,
or 0 if none has been seen so far.
@@ -2388,6 +2337,8 @@ find_line_common (register struct linetable *l, register int lineno,
int best_index = -1;
int best = 0;
+ *exact_match = 0;
+
if (lineno <= 0)
return -1;
if (l == 0)
@@ -2396,7 +2347,7 @@ find_line_common (register struct linetable *l, register int lineno,
len = l->nitems;
for (i = 0; i < len; i++)
{
- register struct linetable_entry *item = &(l->item[i]);
+ struct linetable_entry *item = &(l->item[i]);
if (item->line == lineno)
{
@@ -2413,8 +2364,6 @@ find_line_common (register struct linetable *l, register int lineno,
}
/* If we got here, we didn't get an exact match. */
-
- *exact_match = 0;
return best_index;
}
@@ -2422,12 +2371,52 @@ int
find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
{
struct symtab_and_line sal;
+
sal = find_pc_line (pc, 0);
*startptr = sal.pc;
*endptr = sal.end;
return sal.symtab != 0;
}
+/* Given a function start address FUNC_ADDR and SYMTAB, find the first
+ address for that function that has an entry in SYMTAB's line info
+ table. If such an entry cannot be found, return FUNC_ADDR
+ unaltered. */
+CORE_ADDR
+skip_prologue_using_lineinfo (CORE_ADDR func_addr, struct symtab *symtab)
+{
+ CORE_ADDR func_start, func_end;
+ struct linetable *l;
+ int i;
+
+ /* Give up if this symbol has no lineinfo table. */
+ l = LINETABLE (symtab);
+ if (l == NULL)
+ return func_addr;
+
+ /* Get the range for the function's PC values, or give up if we
+ cannot, for some reason. */
+ if (!find_pc_partial_function (func_addr, NULL, &func_start, &func_end))
+ return func_addr;
+
+ /* Linetable entries are ordered by PC values, see the commentary in
+ symtab.h where `struct linetable' is defined. Thus, the first
+ entry whose PC is in the range [FUNC_START..FUNC_END[ is the
+ address we are looking for. */
+ for (i = 0; i < l->nitems; i++)
+ {
+ struct linetable_entry *item = &(l->item[i]);
+
+ /* Don't use line numbers of zero, they mark special entries in
+ the table. See the commentary on symtab.h before the
+ definition of struct linetable. */
+ if (item->line > 0 && func_start <= item->pc && item->pc < func_end)
+ return item->pc;
+ }
+
+ return func_addr;
+}
+
/* Given a function symbol SYM, find the symtab and line for the start
of the function.
If the argument FUNFIRSTLINE is nonzero, we want the first line
@@ -2436,47 +2425,176 @@ find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
struct symtab_and_line
find_function_start_sal (struct symbol *sym, int funfirstline)
{
- CORE_ADDR pc;
struct symtab_and_line sal;
- pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
fixup_symbol_section (sym, NULL);
+ sal = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
+ SYMBOL_OBJ_SECTION (sym), 0);
+
+ /* We always should have a line for the function start address.
+ If we don't, something is odd. Create a plain SAL refering
+ just the PC and hope that skip_prologue_sal (if requested)
+ can find a line number for after the prologue. */
+ if (sal.pc < BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))
+ {
+ init_sal (&sal);
+ sal.pspace = current_program_space;
+ sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
+ sal.section = SYMBOL_OBJ_SECTION (sym);
+ }
+
if (funfirstline)
- { /* skip "first line" of function (which is actually its prologue) */
- asection *section = SYMBOL_BFD_SECTION (sym);
- /* If function is in an unmapped overlay, use its unmapped LMA
- address, so that SKIP_PROLOGUE has something unique to work on */
- if (section_is_overlay (section) &&
- !section_is_mapped (section))
- pc = overlay_unmapped_address (pc, section);
-
- pc += FUNCTION_START_OFFSET;
- pc = SKIP_PROLOGUE (pc);
-
- /* For overlays, map pc back into its mapped VMA range */
- pc = overlay_mapped_address (pc, section);
+ skip_prologue_sal (&sal);
+
+ return sal;
+}
+
+/* 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, at most the SAL's PC
+ is updated. If SAL is already past the prologue, then do nothing. */
+void
+skip_prologue_sal (struct symtab_and_line *sal)
+{
+ struct symbol *sym;
+ struct symtab_and_line start_sal;
+ struct cleanup *old_chain;
+ CORE_ADDR pc;
+ struct obj_section *section;
+ const char *name;
+ struct objfile *objfile;
+ struct gdbarch *gdbarch;
+ struct block *b, *function_block;
+
+ /* Do not change the SAL is PC was specified explicitly. */
+ if (sal->explicit_pc)
+ return;
+
+ old_chain = save_current_space_and_thread ();
+ switch_to_program_space_and_thread (sal->pspace);
+
+ sym = find_pc_sect_function (sal->pc, sal->section);
+ if (sym != NULL)
+ {
+ fixup_symbol_section (sym, NULL);
+
+ pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
+ section = SYMBOL_OBJ_SECTION (sym);
+ name = SYMBOL_LINKAGE_NAME (sym);
+ objfile = SYMBOL_SYMTAB (sym)->objfile;
}
- sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0);
+ else
+ {
+ struct minimal_symbol *msymbol
+ = lookup_minimal_symbol_by_pc_section (sal->pc, sal->section);
-#ifdef PROLOGUE_FIRSTLINE_OVERLAP
- /* Convex: no need to suppress code on first line, if any */
- sal.pc = pc;
-#else
- /* Check if SKIP_PROLOGUE left us in mid-line, and the next
+ if (msymbol == NULL)
+ {
+ do_cleanups (old_chain);
+ return;
+ }
+
+ pc = SYMBOL_VALUE_ADDRESS (msymbol);
+ section = SYMBOL_OBJ_SECTION (msymbol);
+ name = SYMBOL_LINKAGE_NAME (msymbol);
+ objfile = msymbol_objfile (msymbol);
+ }
+
+ gdbarch = get_objfile_arch (objfile);
+
+ /* 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))
+ pc = overlay_unmapped_address (pc, section);
+
+ /* Skip "first line" of function (which is actually its prologue). */
+ pc += gdbarch_deprecated_function_start_offset (gdbarch);
+ pc = gdbarch_skip_prologue (gdbarch, pc);
+
+ /* For overlays, map pc back into its mapped VMA range. */
+ pc = overlay_mapped_address (pc, section);
+
+ /* Calculate line number. */
+ start_sal = find_pc_sect_line (pc, section, 0);
+
+ /* Check if gdbarch_skip_prologue left us in mid-line, and the next
line is still part of the same function. */
- if (sal.pc != pc
- && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= sal.end
- && sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
+ if (start_sal.pc != pc
+ && (sym? (BLOCK_START (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)
+ == lookup_minimal_symbol_by_pc_section (pc, section))))
{
/* First pc of next line */
- pc = sal.end;
+ pc = start_sal.end;
/* Recalculate the line number (might not be N+1). */
- sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0);
+ start_sal = find_pc_sect_line (pc, section, 0);
}
- sal.pc = pc;
-#endif
- return sal;
+ /* On targets with executable formats that don't have a concept of
+ constructors (ELF with .init has, PE doesn't), gcc emits a call
+ to `__main' in `main' between the prologue and before user
+ code. */
+ if (gdbarch_skip_main_prologue_p (gdbarch)
+ && name && strcmp (name, "main") == 0)
+ {
+ pc = gdbarch_skip_main_prologue (gdbarch, pc);
+ /* Recalculate the line number (might not be N+1). */
+ start_sal = find_pc_sect_line (pc, section, 0);
+ }
+
+ /* If we still don't have a valid source line, try to find the first
+ PC in the lineinfo table that belongs to the same function. This
+ happens with COFF debug info, which does not seem to have an
+ entry in lineinfo table for the code after the prologue which has
+ no direct relation to source. For example, this was found to be
+ the case with the DJGPP target using "gcc -gcoff" when the
+ compiler inserted code after the prologue to make sure the stack
+ is aligned. */
+ if (sym && start_sal.symtab == NULL)
+ {
+ pc = skip_prologue_using_lineinfo (pc, SYMBOL_SYMTAB (sym));
+ /* Recalculate the line number. */
+ start_sal = find_pc_sect_line (pc, section, 0);
+ }
+
+ do_cleanups (old_chain);
+
+ /* If we're already past the prologue, leave SAL unchanged. Otherwise
+ forward SAL to the end of the prologue. */
+ if (sal->pc >= pc)
+ return;
+
+ sal->pc = pc;
+ sal->section = section;
+
+ /* Unless the explicit_line flag was set, update the SAL line
+ and symtab to correspond to the modified PC location. */
+ if (sal->explicit_line)
+ return;
+
+ sal->symtab = start_sal.symtab;
+ sal->line = start_sal.line;
+ sal->end = start_sal.end;
+
+ /* Check if we are now inside an inlined function. If we can,
+ use the call site of the function instead. */
+ b = block_for_pc_sect (sal->pc, sal->section);
+ function_block = NULL;
+ while (b != NULL)
+ {
+ if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
+ function_block = b;
+ else if (BLOCK_FUNCTION (b) != NULL)
+ break;
+ b = BLOCK_SUPERBLOCK (b);
+ }
+ if (function_block != NULL
+ && SYMBOL_LINE (BLOCK_FUNCTION (function_block)) != 0)
+ {
+ sal->line = SYMBOL_LINE (BLOCK_FUNCTION (function_block));
+ sal->symtab = SYMBOL_SYMTAB (BLOCK_FUNCTION (function_block));
+ }
}
/* If P is of the form "operator[ \t]+..." where `...' is
@@ -2500,11 +2618,12 @@ operator_chars (char *p, char **end)
while (*p == ' ' || *p == '\t')
p++;
- /* Recognize 'operator TYPENAME'. */
+ /* Recognize 'operator TYPENAME'. */
if (isalpha (*p) || *p == '_' || *p == '$')
{
- register char *q = p + 1;
+ char *q = p + 1;
+
while (isalnum (*q) || *q == '_' || *q == '$')
q++;
*end = q;
@@ -2517,7 +2636,7 @@ operator_chars (char *p, char **end)
case '\\': /* regexp quoting */
if (p[1] == '*')
{
- if (p[2] == '=') /* 'operator\*=' */
+ if (p[2] == '=') /* 'operator\*=' */
*end = p + 3;
else /* 'operator\*' */
*end = p + 2;
@@ -2526,18 +2645,19 @@ operator_chars (char *p, char **end)
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\[\]' */
return p;
}
else
- error ("nothing is allowed between '[' and ']'");
+ error (_("nothing is allowed between '[' and ']'"));
}
- else
+ else
{
- /* Gratuitous qoute: skip it and move on. */
+ /* Gratuitous qoute: skip it and move on. */
p++;
continue;
}
@@ -2561,7 +2681,7 @@ operator_chars (char *p, char **end)
case '|':
if (p[0] == '-' && p[1] == '>')
{
- /* Struct pointer member operator 'operator->'. */
+ /* Struct pointer member operator 'operator->'. */
if (p[2] == '*')
{
*end = p + 3; /* 'operator->*' */
@@ -2589,21 +2709,24 @@ operator_chars (char *p, char **end)
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:
- error ("`operator %s' not supported", p);
+ error (_("`operator %s' not supported"), p);
break;
}
@@ -2660,7 +2783,7 @@ filename_seen (const char *file, int add, int *first)
NAME is the name to print and *FIRST is nonzero if this is the first
name printed. Set *FIRST to zero. */
static void
-output_source_filename (char *name, int *first)
+output_source_filename (const char *name, int *first)
{
/* Since a single source file can result in several partial symbol
tables, we need to avoid printing it more than once. Note: if
@@ -2691,17 +2814,24 @@ output_source_filename (char *name, int *first)
fputs_filtered (name, gdb_stdout);
}
+/* A callback for map_partial_symbol_filenames. */
+static void
+output_partial_symbol_filename (const char *fullname, const char *filename,
+ void *data)
+{
+ output_source_filename (fullname ? fullname : filename, data);
+}
+
static void
sources_info (char *ignore, int from_tty)
{
- register struct symtab *s;
- register struct partial_symtab *ps;
- register struct objfile *objfile;
+ struct symtab *s;
+ struct objfile *objfile;
int first;
if (!have_full_symbols () && !have_partial_symbols ())
{
- error ("No symbol table is loaded. Use the \"file\" command.");
+ error (_("No symbol table is loaded. Use the \"file\" command."));
}
printf_filtered ("Source files for which symbols have been read in:\n\n");
@@ -2709,25 +2839,22 @@ sources_info (char *ignore, int from_tty)
first = 1;
ALL_SYMTABS (objfile, s)
{
- output_source_filename (s->filename, &first);
+ const char *fullname = symtab_to_fullname (s);
+
+ output_source_filename (fullname ? fullname : s->filename, &first);
}
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;
- ALL_PSYMTABS (objfile, ps)
- {
- if (!ps->readin)
- {
- output_source_filename (ps->filename, &first);
- }
- }
+ map_partial_symbol_filenames (output_partial_symbol_filename, &first);
printf_filtered ("\n");
}
static int
-file_matches (char *file, char *files[], int nfiles)
+file_matches (const char *file, char *files[], int nfiles)
{
int i;
@@ -2744,7 +2871,7 @@ file_matches (char *file, char *files[], int nfiles)
return 0;
}
-/* Free any memory associated with a search. */
+/* Free any memory associated with a search. */
void
free_search_symbols (struct symbol_search *symbols)
{
@@ -2817,50 +2944,69 @@ sort_search_symbols (struct symbol_search *prevtail, int nfound)
return symp;
}
+/* An object of this type is passed as the user_data to the
+ expand_symtabs_matching method. */
+struct search_symbols_data
+{
+ int nfiles;
+ char **files;
+ char *regexp;
+};
+
+/* A callback for expand_symtabs_matching. */
+static int
+search_symbols_file_matches (const char *filename, void *user_data)
+{
+ struct search_symbols_data *data = user_data;
+
+ return file_matches (filename, data->files, data->nfiles);
+}
+
+/* A callback for expand_symtabs_matching. */
+static int
+search_symbols_name_matches (const char *symname, void *user_data)
+{
+ struct search_symbols_data *data = user_data;
+
+ return data->regexp == NULL || re_exec (symname);
+}
+
/* Search the symbol table for matches to the regular expression REGEXP,
returning the results in *MATCHES.
Only symbols of KIND are searched:
FUNCTIONS_DOMAIN - search all functions
TYPES_DOMAIN - search all type names
- METHODS_DOMAIN - search all methods NOT IMPLEMENTED
VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
and constants (enums)
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)
{
- register struct symtab *s;
- register struct partial_symtab *ps;
- register struct blockvector *bv;
- struct blockvector *prev_bv = 0;
- register struct block *b;
- register int i = 0;
- register int j;
- register struct symbol *sym;
- struct partial_symbol **psym;
+ struct symtab *s;
+ struct blockvector *bv;
+ struct block *b;
+ int i = 0;
+ struct dict_iterator iter;
+ struct symbol *sym;
struct objfile *objfile;
struct minimal_symbol *msymbol;
char *val;
int found_misc = 0;
- static enum minimal_symbol_type types[]
- =
- {mst_data, mst_text, mst_abs, mst_unknown};
- static enum minimal_symbol_type types2[]
- =
- {mst_bss, mst_file_text, mst_abs, mst_unknown};
- static enum minimal_symbol_type types3[]
- =
- {mst_file_data, mst_solib_trampoline, mst_abs, mst_unknown};
- static enum minimal_symbol_type types4[]
- =
- {mst_file_bss, mst_text, mst_abs, mst_unknown};
+ static const enum minimal_symbol_type types[]
+ = {mst_data, mst_text, mst_abs, mst_unknown};
+ static const enum minimal_symbol_type types2[]
+ = {mst_bss, mst_file_text, mst_abs, mst_unknown};
+ static const enum minimal_symbol_type types3[]
+ = {mst_file_data, mst_solib_trampoline, mst_abs, mst_unknown};
+ 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;
enum minimal_symbol_type ourtype3;
@@ -2869,9 +3015,10 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[],
struct symbol_search *psr;
struct symbol_search *tail;
struct cleanup *old_chain = NULL;
+ struct search_symbols_data datum;
if (kind < VARIABLES_DOMAIN)
- error ("must search on specific domain");
+ error (_("must search on specific domain"));
ourtype = types[(int) (kind - VARIABLES_DOMAIN)];
ourtype2 = types2[(int) (kind - VARIABLES_DOMAIN)];
@@ -2886,90 +3033,56 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[],
/* 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 or . */
+ and or . */
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);
+
sprintf (tmp, "operator%.*s%s", fix, " ", opname);
regexp = tmp;
}
}
if (0 != (val = re_comp (regexp)))
- error ("Invalid regexp (%s): %s", val, regexp);
+ error (_("Invalid regexp (%s): %s"), val, 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. */
+ the machinery below. */
- ALL_PSYMTABS (objfile, ps)
+ datum.nfiles = nfiles;
+ datum.files = files;
+ datum.regexp = regexp;
+ ALL_OBJFILES (objfile)
{
- struct partial_symbol **bound, **gbound, **sbound;
- int keep_going = 1;
-
- if (ps->readin)
- continue;
-
- gbound = objfile->global_psymbols.list + ps->globals_offset + ps->n_global_syms;
- sbound = objfile->static_psymbols.list + ps->statics_offset + ps->n_static_syms;
- bound = gbound;
-
- /* Go through all of the symbols stored in a partial
- symtab in one loop. */
- psym = objfile->global_psymbols.list + ps->globals_offset;
- while (keep_going)
- {
- if (psym >= bound)
- {
- if (bound == gbound && ps->n_static_syms != 0)
- {
- psym = objfile->static_psymbols.list + ps->statics_offset;
- bound = sbound;
- }
- else
- keep_going = 0;
- continue;
- }
- else
- {
- QUIT;
-
- /* If it would match (logic taken from loop below)
- load the file and go on to the next one */
- if (file_matches (ps->filename, files, nfiles)
- && ((regexp == NULL
- || re_exec (SYMBOL_NATURAL_NAME (*psym)) != 0)
- && ((kind == VARIABLES_DOMAIN && SYMBOL_CLASS (*psym) != LOC_TYPEDEF
- && SYMBOL_CLASS (*psym) != LOC_BLOCK)
- || (kind == FUNCTIONS_DOMAIN && SYMBOL_CLASS (*psym) == LOC_BLOCK)
- || (kind == TYPES_DOMAIN && SYMBOL_CLASS (*psym) == LOC_TYPEDEF)
- || (kind == METHODS_DOMAIN && SYMBOL_CLASS (*psym) == LOC_BLOCK))))
- {
- PSYMTAB_TO_SYMTAB (ps);
- keep_going = 0;
- }
- }
- psym++;
- }
+ if (objfile->sf)
+ objfile->sf->qf->expand_symtabs_matching (objfile,
+ search_symbols_file_matches,
+ search_symbols_name_matches,
+ kind,
+ &datum);
}
/* Here, we search through the minimal symbol tables for functions
@@ -2982,13 +3095,14 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *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))
{
ALL_MSYMBOLS (objfile, msymbol)
{
+ QUIT;
+
if (MSYMBOL_TYPE (msymbol) == ourtype ||
MSYMBOL_TYPE (msymbol) == ourtype2 ||
MSYMBOL_TYPE (msymbol) == ourtype3 ||
@@ -3006,10 +3120,10 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[],
symbol associated to a given minimal symbol (if
any). */
if (kind == FUNCTIONS_DOMAIN
- || lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol),
+ || lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
(struct block *) NULL,
- VAR_DOMAIN,
- 0, (struct symtab **) NULL) == NULL)
+ VAR_DOMAIN, 0)
+ == NULL)
found_misc = 1;
}
}
@@ -3017,37 +3131,44 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[],
}
}
- ALL_SYMTABS (objfile, s)
+ ALL_PRIMARY_SYMTABS (objfile, s)
{
bv = BLOCKVECTOR (s);
- /* Often many files share a blockvector.
- Scan each blockvector only once so that
- we don't get every symbol many times.
- It happens that the first symtab in the list
- for any given blockvector is the main file. */
- if (bv != prev_bv)
for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
{
struct symbol_search *prevtail = tail;
int nfound = 0;
+
b = BLOCKVECTOR_BLOCK (bv, i);
- ALL_BLOCK_SYMBOLS (b, j, sym)
+ ALL_BLOCK_SYMBOLS (b, iter, sym)
{
+ struct symtab *real_symtab = SYMBOL_SYMTAB (sym);
+
QUIT;
- if (file_matches (s->filename, files, nfiles)
+
+ if (file_matches (real_symtab->filename, files, nfiles)
&& ((regexp == NULL
|| re_exec (SYMBOL_NATURAL_NAME (sym)) != 0)
- && ((kind == VARIABLES_DOMAIN && SYMBOL_CLASS (sym) != LOC_TYPEDEF
+ && ((kind == VARIABLES_DOMAIN
+ && SYMBOL_CLASS (sym) != LOC_TYPEDEF
+ && SYMBOL_CLASS (sym) != LOC_UNRESOLVED
&& SYMBOL_CLASS (sym) != LOC_BLOCK
- && SYMBOL_CLASS (sym) != LOC_CONST)
- || (kind == FUNCTIONS_DOMAIN && SYMBOL_CLASS (sym) == LOC_BLOCK)
- || (kind == TYPES_DOMAIN && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
- || (kind == METHODS_DOMAIN && SYMBOL_CLASS (sym) == 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
+ && 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 = s;
+ psr->symtab = real_symtab;
psr->symbol = sym;
psr->msymbol = NULL;
psr->next = NULL;
@@ -3075,7 +3196,6 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[],
tail = sort_search_symbols (prevtail, nfound);
}
}
- prev_bv = bv;
}
/* If there are no eyes, avoid all contact. I mean, if there are
@@ -3085,6 +3205,8 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[],
{
ALL_MSYMBOLS (objfile, msymbol)
{
+ QUIT;
+
if (MSYMBOL_TYPE (msymbol) == ourtype ||
MSYMBOL_TYPE (msymbol) == ourtype2 ||
MSYMBOL_TYPE (msymbol) == ourtype3 ||
@@ -3093,17 +3215,18 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[],
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 */
- if (lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol),
- (struct block *) NULL, VAR_DOMAIN,
- 0, (struct symtab **) NULL) == NULL)
+ /* 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;
@@ -3131,8 +3254,8 @@ search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[],
/* 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)
@@ -3147,11 +3270,11 @@ print_symbol_info (domain_enum kind, struct symtab *s, struct symbol *sym,
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))
@@ -3166,42 +3289,42 @@ print_symbol_info (domain_enum kind, struct symtab *s, struct symbol *sym,
}
/* 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)
{
+ struct gdbarch *gdbarch = get_objfile_arch (msymbol_objfile (msymbol));
char *tmp;
- if (TARGET_ADDR_BIT <= 32)
- tmp = local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol)
- & (CORE_ADDR) 0xffffffff,
- "08l");
+ if (gdbarch_addr_bit (gdbarch) <= 32)
+ tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol)
+ & (CORE_ADDR) 0xffffffff,
+ 8);
else
- tmp = local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol),
- "016l");
+ tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol),
+ 16);
printf_filtered ("%s %s\n",
tmp, SYMBOL_PRINT_NAME (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);
@@ -3256,7 +3379,7 @@ types_info (char *regexp, int from_tty)
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)
@@ -3264,26 +3387,68 @@ rbreak_command_wrapper (char *regexp, int from_tty)
rbreak_command (regexp, from_tty);
}
+/* A cleanup function that calls end_rbreak_breakpoints. */
+
+static void
+do_end_rbreak_breakpoints (void *ignore)
+{
+ end_rbreak_breakpoints ();
+}
+
static void
rbreak_command (char *regexp, int from_tty)
{
struct symbol_search *ss;
struct symbol_search *p;
struct cleanup *old_chain;
+ char *string = NULL;
+ int len = 0;
+ char **files = NULL, *file_name;
+ int nfiles = 0;
+
+ if (regexp)
+ {
+ char *colon = strchr (regexp, ':');
- search_symbols (regexp, FUNCTIONS_DOMAIN, 0, (char **) NULL, &ss);
+ if (colon && *(colon + 1) != ':')
+ {
+ int colon_index;
+
+ colon_index = colon - regexp;
+ file_name = alloca (colon_index + 1);
+ memcpy (file_name, regexp, colon_index);
+ file_name[colon_index--] = 0;
+ while (isspace (file_name[colon_index]))
+ file_name[colon_index--] = 0;
+ files = &file_name;
+ nfiles = 1;
+ regexp = colon + 1;
+ while (isspace (*regexp)) regexp++;
+ }
+ }
+
+ search_symbols (regexp, FUNCTIONS_DOMAIN, nfiles, files, &ss);
old_chain = make_cleanup_free_search_symbols (ss);
+ make_cleanup (free_current_contents, &string);
+ start_rbreak_breakpoints ();
+ make_cleanup (do_end_rbreak_breakpoints, NULL);
for (p = ss; p != NULL; p = p->next)
{
if (p->msymbol == NULL)
{
- char *string = (char *) alloca (strlen (p->symtab->filename)
- + strlen (DEPRECATED_SYMBOL_NAME (p->symbol))
- + 4);
+ int newlen = (strlen (p->symtab->filename)
+ + strlen (SYMBOL_LINKAGE_NAME (p->symbol))
+ + 4);
+
+ if (newlen > len)
+ {
+ string = xrealloc (string, newlen);
+ len = newlen;
+ }
strcpy (string, p->symtab->filename);
strcat (string, ":'");
- strcat (string, DEPRECATED_SYMBOL_NAME (p->symbol));
+ strcat (string, SYMBOL_LINKAGE_NAME (p->symbol));
strcat (string, "'");
break_command (string, from_tty);
print_symbol_info (FUNCTIONS_DOMAIN,
@@ -3294,7 +3459,18 @@ rbreak_command (char *regexp, int from_tty)
}
else
{
- break_command (DEPRECATED_SYMBOL_NAME (p->msymbol), from_tty);
+ int newlen = (strlen (SYMBOL_LINKAGE_NAME (p->msymbol)) + 3);
+
+ if (newlen > len)
+ {
+ string = xrealloc (string, newlen);
+ len = newlen;
+ }
+ strcpy (string, "'");
+ strcat (string, SYMBOL_LINKAGE_NAME (p->msymbol));
+ strcat (string, "'");
+
+ break_command (string, from_tty);
printf_filtered (" %s;\n",
SYMBOL_PRINT_NAME (p->msymbol));
}
@@ -3311,30 +3487,20 @@ static int return_val_index;
static char **return_val;
#define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
- do { \
- if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
- /* Put only the mangled name on the list. */ \
- /* Advantage: "b foo" completes to "b foo(int, int)" */ \
- /* Disadvantage: "b foo__i" doesn't complete. */ \
- completion_list_add_name \
- (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
- else \
completion_list_add_name \
- (DEPRECATED_SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \
- } while (0)
+ (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
/* 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,
char *text, char *word)
{
int newsize;
- int i;
- /* clip symbols that cannot match */
+ /* Clip symbols that cannot match. */
if (strncmp (symname, sym_text, sym_text_len) != 0)
{
@@ -3342,10 +3508,11 @@ completion_list_add_name (char *symname, char *sym_text, int sym_text_len,
}
/* 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;
+
if (word == sym_text)
{
new = xmalloc (strlen (symname) + 5);
@@ -3385,10 +3552,10 @@ completion_list_objc_symbol (struct minimal_symbol *msymbol, char *sym_text,
{
static char *tmp = NULL;
static unsigned int tmplen = 0;
-
+
char *method, *category, *selector;
char *tmp2 = NULL;
-
+
method = SYMBOL_NATURAL_NAME (msymbol);
/* Is it a method? */
@@ -3398,7 +3565,7 @@ completion_list_objc_symbol (struct minimal_symbol *msymbol, char *sym_text,
if (sym_text[0] == '[')
/* Complete on shortened method method. */
completion_list_add_name (method + 1, sym_text, sym_text_len, text, word);
-
+
while ((strlen (method) + 1) >= tmplen)
{
if (tmplen == 0)
@@ -3410,9 +3577,9 @@ completion_list_objc_symbol (struct minimal_symbol *msymbol, char *sym_text,
selector = strchr (method, ' ');
if (selector != NULL)
selector++;
-
+
category = strchr (method, '(');
-
+
if ((category != NULL) && (selector != NULL))
{
memcpy (tmp, method, (category - method));
@@ -3422,7 +3589,7 @@ completion_list_objc_symbol (struct minimal_symbol *msymbol, char *sym_text,
if (sym_text[0] == '[')
completion_list_add_name (tmp + 1, sym_text, sym_text_len, text, word);
}
-
+
if (selector != NULL)
{
/* Complete on selector only. */
@@ -3430,13 +3597,13 @@ completion_list_objc_symbol (struct minimal_symbol *msymbol, char *sym_text,
tmp2 = strchr (tmp, ']');
if (tmp2 != NULL)
*tmp2 = '\0';
-
+
completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
}
}
/* 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)
@@ -3449,12 +3616,12 @@ 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
@@ -3471,8 +3638,8 @@ language_search_unquoted_string (char *text, char *p)
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;
@@ -3481,32 +3648,81 @@ language_search_unquoted_string (char *text, char *p)
return p;
}
+static void
+completion_list_add_fields (struct symbol *sym, char *sym_text,
+ int sym_text_len, char *text, char *word)
+{
+ if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+ {
+ struct type *t = SYMBOL_TYPE (sym);
+ enum type_code c = TYPE_CODE (t);
+ int j;
+
+ if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
+ for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
+ if (TYPE_FIELD_NAME (t, j))
+ completion_list_add_name (TYPE_FIELD_NAME (t, j),
+ sym_text, sym_text_len, text, word);
+ }
+}
+
+/* Type of the user_data argument passed to add_macro_name or
+ add_partial_symbol_name. The contents are simply whatever is
+ needed by completion_list_add_name. */
+struct add_name_data
+{
+ char *sym_text;
+ int sym_text_len;
+ char *text;
+ char *word;
+};
+
+/* A callback used with macro_for_each and macro_for_each_in_scope.
+ This adds a macro's name to the current completion list. */
+static void
+add_macro_name (const char *name, const struct macro_definition *ignore,
+ void *user_data)
+{
+ struct add_name_data *datum = (struct add_name_data *) user_data;
-/* Return a NULL terminated array of all symbols (regardless of class)
- which begin by matching TEXT. If the answer is no symbols, then
- the return value is an array which contains only a NULL pointer.
+ completion_list_add_name ((char *) name,
+ datum->sym_text, datum->sym_text_len,
+ datum->text, datum->word);
+}
+
+/* A callback for map_partial_symbol_names. */
+static void
+add_partial_symbol_name (const char *name, void *user_data)
+{
+ struct add_name_data *datum = (struct add_name_data *) user_data;
- Problem: All of the symbols have to be copied because readline frees them.
- I'm not going to worry about this; hopefully there won't be that many. */
+ completion_list_add_name ((char *) name,
+ datum->sym_text, datum->sym_text_len,
+ datum->text, datum->word);
+}
char **
-make_symbol_completion_list (char *text, char *word)
+default_make_symbol_completion_list_break_on (char *text, char *word,
+ const char *break_on)
{
- register struct symbol *sym;
- register struct symtab *s;
- register struct partial_symtab *ps;
- register struct minimal_symbol *msymbol;
- register struct objfile *objfile;
- register struct block *b, *surrounding_static_block = 0;
- register int i, j;
- struct partial_symbol **psym;
+ /* Problem: All of the symbols have to be copied because readline
+ frees them. I'm not going to worry about this; hopefully there
+ won't be that many. */
+
+ struct symbol *sym;
+ struct symtab *s;
+ struct minimal_symbol *msymbol;
+ struct objfile *objfile;
+ struct block *b;
+ const struct block *surrounding_static_block, *surrounding_global_block;
+ struct dict_iterator iter;
/* The symbol we are completing on. Points in same buffer as text. */
char *sym_text;
/* Length of sym_text. */
int sym_text_len;
+ struct add_name_data datum;
- /* Now look for the symbol we are supposed to complete on.
- FIXME: This should be language-specific. */
+ /* Now look for the symbol we are supposed to complete on. */
{
char *p;
char quote_found;
@@ -3549,7 +3765,8 @@ make_symbol_completion_list (char *text, char *word)
which are in symbols. */
while (p > text)
{
- if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
+ if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0'
+ || p[-1] == ':' || strchr (break_on, p[-1]) != NULL)
--p;
else
break;
@@ -3565,35 +3782,14 @@ make_symbol_completion_list (char *text, char *word)
return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
return_val[0] = NULL;
+ datum.sym_text = sym_text;
+ datum.sym_text_len = sym_text_len;
+ datum.text = text;
+ datum.word = word;
+
/* Look through the partial symtabs for all symbols which begin
by matching SYM_TEXT. Add each one that you find to the list. */
-
- ALL_PSYMTABS (objfile, ps)
- {
- /* If the psymtab's been read in we'll get it when we search
- through the blockvector. */
- if (ps->readin)
- continue;
-
- for (psym = objfile->global_psymbols.list + ps->globals_offset;
- psym < (objfile->global_psymbols.list + ps->globals_offset
- + ps->n_global_syms);
- psym++)
- {
- /* If interrupted, then quit. */
- QUIT;
- COMPLETION_LIST_ADD_SYMBOL (*psym, sym_text, sym_text_len, text, word);
- }
-
- for (psym = objfile->static_psymbols.list + ps->statics_offset;
- psym < (objfile->static_psymbols.list + ps->statics_offset
- + ps->n_static_syms);
- psym++)
- {
- QUIT;
- COMPLETION_LIST_ADD_SYMBOL (*psym, sym_text, sym_text_len, text, word);
- }
- }
+ map_partial_symbol_names (add_partial_symbol_name, &datum);
/* At this point scan through the misc symbol vectors and add each
symbol you find to the list. Eventually we want to ignore
@@ -3604,86 +3800,134 @@ make_symbol_completion_list (char *text, char *word)
{
QUIT;
COMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text, word);
-
+
completion_list_objc_symbol (msymbol, sym_text, sym_text_len, text, word);
}
/* Search upwards from currently selected frame (so that we can
- complete on local vars. */
+ 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. */
+
+ b = get_selected_block (0);
+ surrounding_static_block = block_static_block (b);
+ surrounding_global_block = block_global_block (b);
+ if (surrounding_static_block != NULL)
+ while (b != surrounding_static_block)
+ {
+ QUIT;
- for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
- {
- if (!BLOCK_SUPERBLOCK (b))
- {
- surrounding_static_block = b; /* For elmin of dups */
- }
+ ALL_BLOCK_SYMBOLS (b, iter, sym)
+ {
+ COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text,
+ word);
+ completion_list_add_fields (sym, sym_text, sym_text_len, text,
+ word);
+ }
- /* Also catch fields of types defined in this places which match our
- text string. Only complete on types visible from current context. */
+ /* 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))
+ break;
+ b = BLOCK_SUPERBLOCK (b);
+ }
- ALL_BLOCK_SYMBOLS (b, i, sym)
- {
- QUIT;
- COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
- if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
- {
- struct type *t = SYMBOL_TYPE (sym);
- enum type_code c = TYPE_CODE (t);
+ /* Add fields from the file's types; symbols will be added below. */
- if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
- {
- for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
- {
- if (TYPE_FIELD_NAME (t, j))
- {
- completion_list_add_name (TYPE_FIELD_NAME (t, j),
- sym_text, sym_text_len, text, word);
- }
- }
- }
- }
- }
- }
+ if (surrounding_static_block != NULL)
+ ALL_BLOCK_SYMBOLS (surrounding_static_block, iter, sym)
+ completion_list_add_fields (sym, sym_text, sym_text_len, text, word);
+
+ if (surrounding_global_block != NULL)
+ ALL_BLOCK_SYMBOLS (surrounding_global_block, iter, sym)
+ completion_list_add_fields (sym, sym_text, sym_text_len, text, word);
/* Go through the symtabs and check the externs and statics for
symbols which match. */
- ALL_SYMTABS (objfile, s)
+ ALL_PRIMARY_SYMTABS (objfile, s)
{
QUIT;
b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
- ALL_BLOCK_SYMBOLS (b, i, sym)
+ ALL_BLOCK_SYMBOLS (b, iter, sym)
{
COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
}
}
- ALL_SYMTABS (objfile, s)
+ ALL_PRIMARY_SYMTABS (objfile, s)
{
QUIT;
b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
- /* Don't do this block twice. */
- if (b == surrounding_static_block)
- continue;
- ALL_BLOCK_SYMBOLS (b, i, sym)
+ ALL_BLOCK_SYMBOLS (b, iter, sym)
{
COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
}
}
+ if (current_language->la_macro_expansion == macro_expansion_c)
+ {
+ struct macro_scope *scope;
+
+ /* Add any macros visible in the default scope. Note that this
+ may yield the occasional wrong result, because an expression
+ might be evaluated in a scope other than the default. For
+ example, if the user types "break file:line if ", the
+ resulting expression will be evaluated at "file:line" -- but
+ at there does not seem to be a way to detect this at
+ completion time. */
+ scope = default_macro_scope ();
+ if (scope)
+ {
+ macro_for_each_in_scope (scope->file, scope->line,
+ add_macro_name, &datum);
+ xfree (scope);
+ }
+
+ /* User-defined macros are always visible. */
+ macro_for_each (macro_user_macros, add_macro_name, &datum);
+ }
+
return (return_val);
}
+char **
+default_make_symbol_completion_list (char *text, char *word)
+{
+ return default_make_symbol_completion_list_break_on (text, word, "");
+}
+
+/* Return a NULL terminated array of all symbols (regardless of class)
+ which begin by matching TEXT. If the answer is no symbols, then
+ the return value is an array which contains only a NULL pointer. */
+
+char **
+make_symbol_completion_list (char *text, char *word)
+{
+ return current_language->la_make_symbol_completion_list (text, word);
+}
+
+/* Like make_symbol_completion_list, but suitable for use as a
+ completion function. */
+
+char **
+make_symbol_completion_list_fn (struct cmd_list_element *ignore,
+ char *text, char *word)
+{
+ return make_symbol_completion_list (text, word);
+}
+
/* Like make_symbol_completion_list, but returns a list of symbols
defined in a source file FILE. */
char **
make_file_symbol_completion_list (char *text, char *word, char *srcfile)
{
- register struct symbol *sym;
- register struct symtab *s;
- register struct block *b;
- register int i;
+ struct symbol *sym;
+ struct symtab *s;
+ struct block *b;
+ struct dict_iterator iter;
/* The symbol we are completing on. Points in same buffer as text. */
char *sym_text;
/* Length of sym_text. */
@@ -3762,13 +4006,13 @@ make_file_symbol_completion_list (char *text, char *word, char *srcfile)
symbols which match. */
b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
- ALL_BLOCK_SYMBOLS (b, i, sym)
+ ALL_BLOCK_SYMBOLS (b, iter, sym)
{
COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
}
b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
- ALL_BLOCK_SYMBOLS (b, i, sym)
+ ALL_BLOCK_SYMBOLS (b, iter, sym)
{
COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
}
@@ -3835,6 +4079,58 @@ not_interesting_fname (const char *fname)
return 0;
}
+/* An object of this type is passed as the user_data argument to
+ map_partial_symbol_filenames. */
+struct add_partial_filename_data
+{
+ int *first;
+ char *text;
+ char *word;
+ int text_len;
+ char ***list;
+ int *list_used;
+ int *list_alloced;
+};
+
+/* A callback for map_partial_symbol_filenames. */
+static void
+maybe_add_partial_symtab_filename (const char *filename, const char *fullname,
+ void *user_data)
+{
+ struct add_partial_filename_data *data = user_data;
+
+ if (not_interesting_fname (filename))
+ return;
+ if (!filename_seen (filename, 1, data->first)
+#if HAVE_DOS_BASED_FILE_SYSTEM
+ && strncasecmp (filename, data->text, data->text_len) == 0
+#else
+ && strncmp (filename, data->text, data->text_len) == 0
+#endif
+ )
+ {
+ /* This file matches for a completion; add it to the
+ current list of matches. */
+ add_filename_to_list (filename, data->text, data->word,
+ data->list, data->list_used, data->list_alloced);
+ }
+ else
+ {
+ const char *base_name = lbasename (filename);
+
+ if (base_name != filename
+ && !filename_seen (base_name, 1, data->first)
+#if HAVE_DOS_BASED_FILE_SYSTEM
+ && strncasecmp (base_name, data->text, data->text_len) == 0
+#else
+ && strncmp (base_name, data->text, data->text_len) == 0
+#endif
+ )
+ add_filename_to_list (base_name, data->text, data->word,
+ data->list, data->list_used, data->list_alloced);
+ }
+}
+
/* Return a NULL terminated array of all source files whose names
begin with matching TEXT. The file names are looked up in the
symbol tables of this program. If the answer is no matchess, then
@@ -3843,15 +4139,15 @@ not_interesting_fname (const char *fname)
char **
make_source_files_completion_list (char *text, char *word)
{
- register struct symtab *s;
- register struct partial_symtab *ps;
- register struct objfile *objfile;
+ struct symtab *s;
+ struct objfile *objfile;
int first = 1;
int list_alloced = 1;
int list_used = 0;
size_t text_len = strlen (text);
char **list = (char **) xmalloc (list_alloced * sizeof (char *));
const char *base_name;
+ struct add_partial_filename_data datum;
list[0] = NULL;
@@ -3895,42 +4191,14 @@ make_source_files_completion_list (char *text, char *word)
}
}
- ALL_PSYMTABS (objfile, ps)
- {
- if (not_interesting_fname (ps->filename))
- continue;
- if (!ps->readin)
- {
- if (!filename_seen (ps->filename, 1, &first)
-#if HAVE_DOS_BASED_FILE_SYSTEM
- && strncasecmp (ps->filename, text, text_len) == 0
-#else
- && strncmp (ps->filename, text, text_len) == 0
-#endif
- )
- {
- /* This file matches for a completion; add it to the
- current list of matches. */
- add_filename_to_list (ps->filename, text, word,
- &list, &list_used, &list_alloced);
-
- }
- else
- {
- base_name = lbasename (ps->filename);
- if (base_name != ps->filename
- && !filename_seen (base_name, 1, &first)
-#if HAVE_DOS_BASED_FILE_SYSTEM
- && strncasecmp (base_name, text, text_len) == 0
-#else
- && strncmp (base_name, text, text_len) == 0
-#endif
- )
- add_filename_to_list (base_name, text, word,
- &list, &list_used, &list_alloced);
- }
- }
- }
+ datum.first = &first;
+ datum.text = text;
+ datum.word = word;
+ datum.text_len = text_len;
+ datum.list = &list;
+ datum.list_used = &list_used;
+ datum.list_alloced = &list_alloced;
+ map_partial_symbol_filenames (maybe_add_partial_symtab_filename, &datum);
return list;
}
@@ -3940,11 +4208,10 @@ make_source_files_completion_list (char *text, char *word)
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 (CORE_ADDR pc, CORE_ADDR func_start)
+in_prologue (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR func_start)
{
struct symtab_and_line sal;
CORE_ADDR func_addr, func_end;
@@ -3958,7 +4225,7 @@ in_prologue (CORE_ADDR pc, CORE_ADDR func_start)
- The minimal symbols and partial symbols, which can usually tell
us the starting and ending addresses of a function.
- If we know the function's start address, we can call the
- architecture-defined SKIP_PROLOGUE function to analyze the
+ architecture-defined gdbarch_skip_prologue function to analyze the
instruction stream and guess where the prologue ends.
- Our `func_start' argument; if non-zero, this is the caller's
best guess as to the function's entry point. At the time of
@@ -3976,7 +4243,7 @@ in_prologue (CORE_ADDR pc, CORE_ADDR func_start)
if (! func_start)
return 1; /* We *might* be in a prologue. */
- prologue_end = SKIP_PROLOGUE (func_start);
+ prologue_end = gdbarch_skip_prologue (gdbarch, func_start);
return func_start <= pc && pc < prologue_end;
}
@@ -4000,7 +4267,7 @@ in_prologue (CORE_ADDR pc, CORE_ADDR func_start)
/* We don't have any good line number info, so use the minsym
information, together with the architecture-specific prologue
scanning code. */
- CORE_ADDR prologue_end = SKIP_PROLOGUE (func_addr);
+ CORE_ADDR prologue_end = gdbarch_skip_prologue (gdbarch, func_addr);
return func_addr <= pc && pc < prologue_end;
}
@@ -4009,274 +4276,463 @@ in_prologue (CORE_ADDR pc, CORE_ADDR func_start)
return func_addr <= pc && pc < sal.end;
}
+/* Given PC at the function's start address, attempt to find the
+ prologue end using SAL information. Return zero if the skip fails.
-/* Begin overload resolution functions */
+ A non-optimized prologue traditionally has one SAL for the function
+ and a second for the function body. A single line function has
+ them both pointing at the same line.
-static char *
-remove_params (const char *demangled_name)
-{
- const char *argp;
- char *new_name;
- int depth;
+ An optimized prologue is similar but the prologue may contain
+ instructions (SALs) from the instruction body. Need to skip those
+ while not getting into the function body.
- if (demangled_name == NULL)
- return NULL;
+ The functions end point and an increasing SAL line are used as
+ indicators of the prologue's endpoint.
- /* First find the end of the arg list. */
- argp = strrchr (demangled_name, ')');
- if (argp == NULL)
- return NULL;
+ This code is based on the function refine_prologue_limit (versions
+ found in both ia64 and ppc). */
- /* Back up to the beginning. */
- depth = 1;
+CORE_ADDR
+skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr)
+{
+ struct symtab_and_line prologue_sal;
+ CORE_ADDR start_pc;
+ CORE_ADDR end_pc;
+ struct block *bl;
+
+ /* Get an initial range for the function. */
+ find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc);
+ start_pc += gdbarch_deprecated_function_start_offset (gdbarch);
- while (argp-- > demangled_name)
+ prologue_sal = find_pc_line (start_pc, 0);
+ if (prologue_sal.line != 0)
{
- if (*argp == ')')
- depth ++;
- else if (*argp == '(')
+ /* For langauges other than assembly, treat two consecutive line
+ entries at the same address as a zero-instruction prologue.
+ 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)
+ {
+ struct linetable *linetable = LINETABLE (prologue_sal.symtab);
+ int idx = 0;
+
+ /* Skip any earlier lines, and any end-of-sequence marker
+ from a previous function. */
+ while (linetable->item[idx].pc != prologue_sal.pc
+ || linetable->item[idx].line == 0)
+ idx++;
+
+ if (idx+1 < linetable->nitems
+ && linetable->item[idx+1].line != 0
+ && linetable->item[idx+1].pc == start_pc)
+ return start_pc;
+ }
+
+ /* If there is only one sal that covers the entire function,
+ then it is probably a single line function, like
+ "foo(){}". */
+ if (prologue_sal.end >= end_pc)
+ return 0;
+
+ while (prologue_sal.end < end_pc)
{
- depth --;
+ struct symtab_and_line sal;
+
+ sal = find_pc_line (prologue_sal.end, 0);
+ if (sal.line == 0)
+ break;
+ /* Assume that a consecutive SAL for the same (or larger)
+ line mark the prologue -> body transition. */
+ if (sal.line >= prologue_sal.line)
+ break;
- if (depth == 0)
+ /* The line number is smaller. Check that it's from the
+ same function, not something inlined. If it's inlined,
+ then there is no point comparing the line numbers. */
+ bl = block_for_pc (prologue_sal.end);
+ while (bl)
+ {
+ if (block_inlined_p (bl))
+ break;
+ if (BLOCK_FUNCTION (bl))
+ {
+ bl = NULL;
+ break;
+ }
+ bl = BLOCK_SUPERBLOCK (bl);
+ }
+ if (bl != NULL)
break;
+
+ /* The case in which compiler's optimizer/scheduler has
+ moved instructions into the prologue. We look ahead in
+ the function looking for address ranges whose
+ 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. */
+ prologue_sal = sal;
}
}
- if (depth != 0)
- internal_error (__FILE__, __LINE__,
- "bad demangled name %s\n", demangled_name);
- while (argp[-1] == ' ' && argp > demangled_name)
- argp --;
-
- new_name = xmalloc (argp - demangled_name + 1);
- memcpy (new_name, demangled_name, argp - demangled_name);
- new_name[argp - demangled_name] = '\0';
- return new_name;
+
+ if (prologue_sal.end < end_pc)
+ /* Return the end of this line, or zero if we could not find a
+ line. */
+ return prologue_sal.end;
+ else
+ /* Don't return END_PC, which is past the end of the function. */
+ return prologue_sal.pc;
}
+
+struct symtabs_and_lines
+decode_line_spec (char *string, int funfirstline)
+{
+ struct symtabs_and_lines sals;
+ struct symtab_and_line cursal;
-/* Helper routine for make_symbol_completion_list. */
+ if (string == 0)
+ error (_("Empty line specification."));
-static int sym_return_val_size;
-static int sym_return_val_index;
-static struct symbol **sym_return_val;
+ /* 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 ();
-/* 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. */
+ sals = decode_line_1 (&string, funfirstline,
+ cursal.symtab, cursal.line,
+ (char ***) NULL, NULL);
-static void
-overload_list_add_symbol (struct symbol *sym, char *oload_name)
-{
- int newsize;
- int i;
- char *sym_name;
+ if (*string)
+ error (_("Junk at end of line specification: %s"), string);
+ return sals;
+}
- /* If there is no type information, we can't do anything, so skip */
- if (SYMBOL_TYPE (sym) == NULL)
- return;
+/* Track MAIN */
+static char *name_of_main;
+enum language language_of_main = language_unknown;
- /* skip any symbols that we've already considered. */
- for (i = 0; i < sym_return_val_index; ++i)
- if (!strcmp (DEPRECATED_SYMBOL_NAME (sym), DEPRECATED_SYMBOL_NAME (sym_return_val[i])))
- return;
+void
+set_main_name (const char *name)
+{
+ if (name_of_main != NULL)
+ {
+ 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;
+ }
+}
- /* Get the demangled name without parameters */
- sym_name = remove_params (SYMBOL_DEMANGLED_NAME (sym));
- if (!sym_name)
- return;
+/* Deduce the name of the main procedure, and set NAME_OF_MAIN
+ accordingly. */
- /* skip symbols that cannot match */
- if (strcmp (sym_name, oload_name) != 0)
+static void
+find_main_name (void)
+{
+ const char *new_main_name;
+
+ /* Try to see if the main procedure is in Ada. */
+ /* FIXME: brobecker/2005-03-07: Another way of doing this would
+ be to add a new method in the language vector, and call this
+ method for each language until one of them returns a non-empty
+ 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
+ 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
+ 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. */
+ new_main_name = ada_main_name ();
+ if (new_main_name != NULL)
{
- xfree (sym_name);
+ set_main_name (new_main_name);
return;
}
- xfree (sym_name);
-
- /* We have a match for an overload instance, so add SYM to the current list
- * of overload instances */
- if (sym_return_val_index + 3 > sym_return_val_size)
+ new_main_name = pascal_main_name ();
+ if (new_main_name != NULL)
{
- newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
- sym_return_val = (struct symbol **) xrealloc ((char *) sym_return_val, newsize);
+ set_main_name (new_main_name);
+ return;
}
- sym_return_val[sym_return_val_index++] = sym;
- sym_return_val[sym_return_val_index] = NULL;
+
+ /* The languages above didn't identify the name of the main procedure.
+ Fallback to "main". */
+ set_main_name ("main");
}
-/* Return a null-terminated list of pointers to function symbols that
- * match name of the supplied symbol FSYM.
- * This is used in finding all overloaded instances of a function name.
- * This has been modified from make_symbol_completion_list. */
+char *
+main_name (void)
+{
+ if (name_of_main == NULL)
+ find_main_name ();
+
+ return name_of_main;
+}
+/* Handle ``executable_changed'' events for the symtab module. */
-struct symbol **
-make_symbol_overload_list (struct symbol *fsym)
+static void
+symtab_observer_executable_changed (void)
{
- register struct symbol *sym;
- register struct symtab *s;
- register struct partial_symtab *ps;
- register struct objfile *objfile;
- register struct block *b, *surrounding_static_block = 0;
- register int i;
- /* The name we are completing on. */
- char *oload_name = NULL;
- /* Length of name. */
- int oload_name_len = 0;
-
- /* Look for the symbol we are supposed to complete on. */
-
- oload_name = remove_params (SYMBOL_DEMANGLED_NAME (fsym));
- if (!oload_name)
- {
- sym_return_val_size = 1;
- sym_return_val = (struct symbol **) xmalloc (2 * sizeof (struct symbol *));
- sym_return_val[0] = fsym;
- sym_return_val[1] = NULL;
+ /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
+ set_main_name (NULL);
+}
- return sym_return_val;
- }
- oload_name_len = strlen (oload_name);
+/* Helper to expand_line_sal below. Appends new sal to SAL,
+ initializing it from SYMTAB, LINENO and PC. */
+static void
+append_expanded_sal (struct symtabs_and_lines *sal,
+ struct program_space *pspace,
+ struct symtab *symtab,
+ int lineno, CORE_ADDR pc)
+{
+ sal->sals = xrealloc (sal->sals,
+ sizeof (sal->sals[0])
+ * (sal->nelts + 1));
+ init_sal (sal->sals + sal->nelts);
+ sal->sals[sal->nelts].pspace = pspace;
+ sal->sals[sal->nelts].symtab = symtab;
+ sal->sals[sal->nelts].section = NULL;
+ sal->sals[sal->nelts].end = 0;
+ sal->sals[sal->nelts].line = lineno;
+ sal->sals[sal->nelts].pc = pc;
+ ++sal->nelts;
+}
- sym_return_val_size = 100;
- sym_return_val_index = 0;
- sym_return_val = (struct symbol **) xmalloc ((sym_return_val_size + 1) * sizeof (struct symbol *));
- sym_return_val[0] = NULL;
+/* Helper to expand_line_sal below. Search in the symtabs for any
+ linetable entry that exactly matches FULLNAME and LINENO and append
+ them to RET. If FULLNAME is NULL or if a symtab has no full name,
+ use FILENAME and LINENO instead. If there is at least one match,
+ return 1; otherwise, return 0, and return the best choice in BEST_ITEM
+ and BEST_SYMTAB. */
+
+static int
+append_exact_match_to_sals (char *filename, char *fullname, int lineno,
+ struct symtabs_and_lines *ret,
+ struct linetable_entry **best_item,
+ struct symtab **best_symtab)
+{
+ struct program_space *pspace;
+ struct objfile *objfile;
+ struct symtab *symtab;
+ int exact = 0;
+ int j;
+ *best_item = 0;
+ *best_symtab = 0;
+
+ ALL_PSPACES (pspace)
+ ALL_PSPACE_SYMTABS (pspace, objfile, symtab)
+ {
+ if (FILENAME_CMP (filename, symtab->filename) == 0)
+ {
+ struct linetable *l;
+ int len;
+
+ if (fullname != NULL
+ && symtab_to_fullname (symtab) != NULL
+ && FILENAME_CMP (fullname, symtab->fullname) != 0)
+ continue;
+ l = LINETABLE (symtab);
+ if (!l)
+ continue;
+ len = l->nitems;
- /* Read in all partial symtabs containing a partial symbol named
- OLOAD_NAME. */
+ for (j = 0; j < len; j++)
+ {
+ struct linetable_entry *item = &(l->item[j]);
- ALL_PSYMTABS (objfile, ps)
- {
- struct partial_symbol **psym;
+ if (item->line == lineno)
+ {
+ exact = 1;
+ append_expanded_sal (ret, objfile->pspace,
+ symtab, lineno, item->pc);
+ }
+ else if (!exact && item->line > lineno
+ && (*best_item == NULL
+ || item->line < (*best_item)->line))
+ {
+ *best_item = item;
+ *best_symtab = symtab;
+ }
+ }
+ }
+ }
+ return exact;
+}
- /* If the psymtab's been read in we'll get it when we search
- through the blockvector. */
- if (ps->readin)
- continue;
+/* Compute a set of all sals in all program spaces that correspond to
+ same file and line as SAL and return those. If there are several
+ sals that belong to the same block, only one sal for the block is
+ included in results. */
- if ((lookup_partial_symbol (ps, oload_name, NULL, 1, VAR_DOMAIN)
- != NULL)
- || (lookup_partial_symbol (ps, oload_name, NULL, 0, VAR_DOMAIN)
- != NULL))
- PSYMTAB_TO_SYMTAB (ps);
- }
+struct symtabs_and_lines
+expand_line_sal (struct symtab_and_line sal)
+{
+ struct symtabs_and_lines ret;
+ int i, j;
+ struct objfile *objfile;
+ int lineno;
+ int deleted = 0;
+ struct block **blocks = NULL;
+ int *filter;
+ struct cleanup *old_chain;
- /* Search upwards from currently selected frame (so that we can
- complete on local vars. */
+ ret.nelts = 0;
+ ret.sals = NULL;
- for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
+ /* Only expand sals that represent file.c:line. */
+ if (sal.symtab == NULL || sal.line == 0 || sal.pc != 0)
{
- if (!BLOCK_SUPERBLOCK (b))
+ ret.sals = xmalloc (sizeof (struct symtab_and_line));
+ ret.sals[0] = sal;
+ ret.nelts = 1;
+ return ret;
+ }
+ else
+ {
+ struct program_space *pspace;
+ struct linetable_entry *best_item = 0;
+ struct symtab *best_symtab = 0;
+ int exact = 0;
+ char *match_filename;
+
+ lineno = sal.line;
+ match_filename = sal.symtab->filename;
+
+ /* We need to find all symtabs for a file which name
+ is described by sal. We cannot just directly
+ iterate over symtabs, since a symtab might not be
+ yet created. We also cannot iterate over psymtabs,
+ calling PSYMTAB_TO_SYMTAB and working on that symtab,
+ since PSYMTAB_TO_SYMTAB will return NULL for psymtab
+ corresponding to an included file. Therefore, we do
+ first pass over psymtabs, reading in those with
+ the right name. Then, we iterate over symtabs, knowing
+ that all symtabs we're interested in are loaded. */
+
+ old_chain = save_current_program_space ();
+ ALL_PSPACES (pspace)
+ {
+ set_current_program_space (pspace);
+ ALL_PSPACE_OBJFILES (pspace, objfile)
{
- surrounding_static_block = b; /* For elimination of dups */
+ if (objfile->sf)
+ objfile->sf->qf->expand_symtabs_with_filename (objfile,
+ sal.symtab->filename);
}
+ }
+ do_cleanups (old_chain);
+
+ /* Now search the symtab for exact matches and append them. If
+ none is found, append the best_item and all its exact
+ matches. */
+ symtab_to_fullname (sal.symtab);
+ exact = append_exact_match_to_sals (sal.symtab->filename,
+ sal.symtab->fullname, lineno,
+ &ret, &best_item, &best_symtab);
+ if (!exact && best_item)
+ append_exact_match_to_sals (best_symtab->filename,
+ best_symtab->fullname, best_item->line,
+ &ret, &best_item, &best_symtab);
+ }
- /* Also catch fields of types defined in this places which match our
- text string. Only complete on types visible from current context. */
+ /* For optimized code, compiler can scatter one source line accross
+ disjoint ranges of PC values, even when no duplicate functions
+ or inline functions are involved. For example, 'for (;;)' inside
+ non-template non-inline non-ctor-or-dtor function can result
+ in two PC ranges. In this case, we don't want to set breakpoint
+ on first PC of each range. To filter such cases, we use containing
+ blocks -- for each PC found above we see if there are other PCs
+ that are in the same block. If yes, the other PCs are filtered out. */
+
+ old_chain = save_current_program_space ();
+ filter = alloca (ret.nelts * sizeof (int));
+ blocks = alloca (ret.nelts * sizeof (struct block *));
+ for (i = 0; i < ret.nelts; ++i)
+ {
+ set_current_program_space (ret.sals[i].pspace);
+
+ filter[i] = 1;
+ blocks[i] = block_for_pc_sect (ret.sals[i].pc, ret.sals[i].section);
- ALL_BLOCK_SYMBOLS (b, i, sym)
- {
- overload_list_add_symbol (sym, oload_name);
- }
}
+ do_cleanups (old_chain);
- /* Go through the symtabs and check the externs and statics for
- symbols which match. */
+ for (i = 0; i < ret.nelts; ++i)
+ if (blocks[i] != NULL)
+ for (j = i+1; j < ret.nelts; ++j)
+ if (blocks[j] == blocks[i])
+ {
+ filter[j] = 0;
+ ++deleted;
+ break;
+ }
- ALL_SYMTABS (objfile, s)
{
- QUIT;
- b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
- ALL_BLOCK_SYMBOLS (b, i, sym)
- {
- overload_list_add_symbol (sym, oload_name);
- }
- }
+ struct symtab_and_line *final =
+ xmalloc (sizeof (struct symtab_and_line) * (ret.nelts-deleted));
- ALL_SYMTABS (objfile, s)
- {
- QUIT;
- b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
- /* Don't do this block twice. */
- if (b == surrounding_static_block)
- continue;
- ALL_BLOCK_SYMBOLS (b, i, sym)
- {
- overload_list_add_symbol (sym, oload_name);
- }
- }
+ for (i = 0, j = 0; i < ret.nelts; ++i)
+ if (filter[i])
+ final[j++] = ret.sals[i];
- xfree (oload_name);
+ ret.nelts -= deleted;
+ xfree (ret.sals);
+ ret.sals = final;
+ }
- return (sym_return_val);
+ return ret;
}
-/* End of overload resolution functions */
-
-struct symtabs_and_lines
-decode_line_spec (char *string, int funfirstline)
-{
- struct symtabs_and_lines sals;
- struct symtab_and_line cursal;
-
- 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! */
- cursal = get_current_source_symtab_and_line ();
-
- sals = decode_line_1 (&string, funfirstline,
- cursal.symtab, cursal.line,
- (char ***) NULL);
+/* Return 1 if the supplied producer string matches the ARM RealView
+ compiler (armcc). */
- if (*string)
- error ("Junk at end of line specification: %s", string);
- return sals;
-}
+int
+producer_is_realview (const char *producer)
+{
+ static const char *const arm_idents[] = {
+ "ARM C Compiler, ADS",
+ "Thumb C Compiler, ADS",
+ "ARM C++ Compiler, ADS",
+ "Thumb C++ Compiler, ADS",
+ "ARM/Thumb C/C++ Compiler, RVCT",
+ "ARM C/C++ Compiler, RVCT"
+ };
+ int i;
-/* Track MAIN */
-static char *name_of_main;
+ if (producer == NULL)
+ return 0;
-void
-set_main_name (const char *name)
-{
- if (name_of_main != NULL)
- {
- xfree (name_of_main);
- name_of_main = NULL;
- }
- if (name != NULL)
- {
- name_of_main = xstrdup (name);
- }
-}
+ for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
+ if (strncmp (producer, arm_idents[i], strlen (arm_idents[i])) == 0)
+ return 1;
-char *
-main_name (void)
-{
- if (name_of_main != NULL)
- return name_of_main;
- else
- return "main";
+ return 0;
}
-
void
_initialize_symtab (void)
{
- add_info ("variables", variables_info,
- "All global and static variable names, or those matching REGEXP.");
+ add_info ("variables", variables_info, _("\
+All global and static variable names, or those matching REGEXP."));
if (dbx_commands)
- add_com ("whereis", class_info, variables_info,
- "All global and static variable names, or those matching REGEXP.");
+ add_com ("whereis", class_info, variables_info, _("\
+All global and static variable names, or those matching REGEXP."));
add_info ("functions", functions_info,
- "All function names, or those matching REGEXP.");
+ _("All function names, or those matching REGEXP."));
-
/* FIXME: This command has at least the following problems:
1. It prints builtin types (in a very strange and confusing fashion).
2. It doesn't print right, e.g. with
@@ -4286,22 +4742,30 @@ _initialize_symtab (void)
I also think "ptype" or "whatis" is more likely to be useful (but if
there is much disagreement "info types" can be fixed). */
add_info ("types", types_info,
- "All type names, or those matching REGEXP.");
+ _("All type names, or those matching REGEXP."));
add_info ("sources", sources_info,
- "Source files in the program.");
+ _("Source files in the program."));
add_com ("rbreak", class_breakpoint, rbreak_command,
- "Set a breakpoint for all functions matching REGEXP.");
+ _("Set a breakpoint for all functions matching REGEXP."));
if (xdb_commands)
{
- add_com ("lf", class_info, sources_info, "Source files in the program");
- add_com ("lg", class_info, variables_info,
- "All global and static variable names, or those matching REGEXP.");
+ add_com ("lf", class_info, sources_info,
+ _("Source files in the program"));
+ add_com ("lg", class_info, variables_info, _("\
+All global and static variable names, or those matching REGEXP."));
}
- /* Initialize the one built-in type that isn't language dependent... */
- builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0,
- "", (struct objfile *) NULL);
+ add_setshow_enum_cmd ("multiple-symbols", no_class,
+ multiple_symbols_modes, &multiple_symbols_mode,
+ _("\
+Set the debugger behavior when more than one symbol are possible matches\n\
+in an expression."), _("\
+Show how the debugger handles ambiguities in expressions."), _("\
+Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
+ NULL, NULL, &setlist, &showlist);
+
+ observer_attach_executable_changed (symtab_observer_executable_changed);
}