#include "language.h"
#include "demangle.h"
#include "inferior.h"
-#include "linespec.h"
#include "source.h"
#include "filenames.h" /* for FILENAME_CMP */
#include "objc-lang.h"
#include "d-lang.h"
#include "ada-lang.h"
+#include "go-lang.h"
#include "p-lang.h"
#include "addrmap.h"
/* */
+/* When non-zero, print debugging messages related to symtab creation. */
+int symtab_create_debug = 0;
+
/* Non-zero if a file may be known by two different basenames.
This is the uncommon case, and significantly slows down gdb.
Default set to "off" to not slow down the common case. */
int search_len)
{
int len = strlen (filename);
- int offset;
if (len < search_len)
return 0;
struct symtab *after_last)
{
struct symtab *s = NULL;
- struct cleanup *cleanup;
const char* base_name = lbasename (name);
int name_len = strlen (name);
int is_abs = IS_ABSOLUTE_PATH (name);
{
gsymbol->language = language;
if (gsymbol->language == language_d
+ || gsymbol->language == language_go
|| gsymbol->language == language_java
|| gsymbol->language == language_objc
|| gsymbol->language == language_fortran)
return demangled;
}
}
+ /* FIXME(dje): Continually adding languages here is clumsy.
+ Better to just call la_demangle if !auto, and if auto then call
+ a utility routine that tries successive languages in turn and reports
+ which one it finds. I realize the la_demangle options may be different
+ for different languages but there's already a FIXME for that. */
+ if (gsymbol->language == language_go
+ || gsymbol->language == language_auto)
+ {
+ demangled = go_demangle (mangled, 0);
+ if (demangled != NULL)
+ {
+ gsymbol->language = language_go;
+ 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
&entry, INSERT));
/* If this name is not in the hash table, add it. */
- if (*slot == NULL)
+ if (*slot == NULL
+ /* A C version of the symbol may have already snuck into the table.
+ This happens to, e.g., main.init (__go_init_main). Cope. */
+ || (gsymbol->language == language_go
+ && (*slot)->demangled[0] == '\0'))
{
char *demangled_name = symbol_find_demangled_name (gsymbol,
linkage_name_copy);
{
case language_cplus:
case language_d:
+ case language_go:
case language_java:
case language_objc:
case language_fortran:
const char *
symbol_demangled_name (const struct general_symbol_info *gsymbol)
{
+ const char *dem_name = NULL;
+
switch (gsymbol->language)
{
case language_cplus:
case language_d:
+ case language_go:
case language_java:
case language_objc:
case language_fortran:
- if (symbol_get_demangled_name (gsymbol) != NULL)
- return symbol_get_demangled_name (gsymbol);
+ dem_name = 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);
+ dem_name = symbol_get_demangled_name (gsymbol);
+ if (dem_name == NULL)
+ dem_name = ada_decode_symbol (gsymbol);
break;
default:
break;
}
- return NULL;
+ return dem_name;
}
/* Return the search name of a symbol---generally the demangled or
sal->end = 0;
sal->explicit_pc = 0;
sal->explicit_line = 0;
+ sal->probe = NULL;
}
\f
modified_name = name;
- /* If we are using C++, D, or Java, demangle the name before doing a
+ /* If we are using C++, D, Go, or Java, demangle the name before doing a
lookup, so we can always binary search. */
if (lang == language_cplus)
{
make_cleanup (xfree, demangled_name);
}
}
+ else if (lang == language_go)
+ {
+ demangled_name = go_demangle (name, 0);
+ if (demangled_name)
+ {
+ modified_name = demangled_name;
+ make_cleanup (xfree, demangled_name);
+ }
+ }
*result_name = modified_name;
return cleanup;
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);
- }
- }
+ ALL_OBJFILE_PRIMARY_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);
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,
+/* Check to see if the symbol is defined in one of the OBJFILE's
+ 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_objfile (struct objfile *objfile, int block_index,
+ const char *name, const domain_enum domain)
+{
+ struct symbol *sym = NULL;
+ struct blockvector *bv;
+ const struct block *block;
+ struct symtab *s;
+
+ if (objfile->sf)
+ objfile->sf->qf->pre_expand_symtabs_matching (objfile, block_index,
+ name, domain);
+
+ ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
+ {
+ 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;
+}
+
+/* Same as lookup_symbol_aux_objfile, except that it searches all
+ objfiles. Return the first match found. */
+
static struct symbol *
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 symtab *s;
ALL_OBJFILES (objfile)
{
- if (objfile->sf)
- objfile->sf->qf->pre_expand_symtabs_matching (objfile,
- block_index,
- name, domain);
+ sym = lookup_symbol_aux_objfile (objfile, block_index, name, domain);
+ if (sym)
+ return sym;
+ }
- ALL_OBJFILE_SYMTABS (objfile, s)
- if (s->primary)
+ return NULL;
+}
+
+/* Wrapper around lookup_symbol_aux_objfile for search_symbols.
+ Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
+ and all related objfiles. */
+
+static struct symbol *
+lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile,
+ const char *linkage_name,
+ domain_enum domain)
+{
+ enum language lang = current_language->la_language;
+ const char *modified_name;
+ struct cleanup *cleanup = demangle_for_lookup (linkage_name, lang,
+ &modified_name);
+ struct objfile *main_objfile, *cur_objfile;
+
+ if (objfile->separate_debug_objfile_backlink)
+ main_objfile = objfile->separate_debug_objfile_backlink;
+ else
+ main_objfile = objfile;
+
+ for (cur_objfile = main_objfile;
+ cur_objfile;
+ cur_objfile = objfile_separate_debug_iterate (main_objfile, cur_objfile))
+ {
+ struct symbol *sym;
+
+ sym = lookup_symbol_aux_objfile (cur_objfile, GLOBAL_BLOCK,
+ modified_name, domain);
+ if (sym == NULL)
+ sym = lookup_symbol_aux_objfile (cur_objfile, STATIC_BLOCK,
+ modified_name, domain);
+ if (sym != NULL)
{
- 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);
- }
+ do_cleanups (cleanup);
+ return sym;
}
- }
+ }
+ do_cleanups (cleanup);
return NULL;
}
return NULL;
}
+/* Private data to be used with lookup_symbol_global_iterator_cb. */
+
+struct global_sym_lookup_data
+{
+ /* The name of the symbol we are searching for. */
+ const char *name;
+
+ /* The domain to use for our search. */
+ domain_enum domain;
+
+ /* The field where the callback should store the symbol if found.
+ It should be initialized to NULL before the search is started. */
+ struct symbol *result;
+};
+
+/* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
+ It searches by name for a symbol in the GLOBAL_BLOCK of the given
+ OBJFILE. The arguments for the search are passed via CB_DATA,
+ which in reality is a pointer to struct global_sym_lookup_data. */
+
+static int
+lookup_symbol_global_iterator_cb (struct objfile *objfile,
+ void *cb_data)
+{
+ struct global_sym_lookup_data *data =
+ (struct global_sym_lookup_data *) cb_data;
+
+ gdb_assert (data->result == NULL);
+
+ data->result = lookup_symbol_aux_objfile (objfile, GLOBAL_BLOCK,
+ data->name, data->domain);
+ if (data->result == NULL)
+ data->result = lookup_symbol_aux_quick (objfile, GLOBAL_BLOCK,
+ data->name, data->domain);
+
+ /* If we found a match, tell the iterator to stop. Otherwise,
+ keep going. */
+ return (data->result != NULL);
+}
+
/* Lookup a symbol in all files' global blocks (searching psymtabs if
necessary). */
{
struct symbol *sym = NULL;
struct objfile *objfile = NULL;
+ struct global_sym_lookup_data lookup_data;
/* Call library-specific lookup procedure. */
objfile = lookup_objfile_from_block (block);
if (sym != NULL)
return sym;
- sym = lookup_symbol_aux_symtabs (GLOBAL_BLOCK, name, domain);
- if (sym != NULL)
- return sym;
+ memset (&lookup_data, 0, sizeof (lookup_data));
+ lookup_data.name = name;
+ lookup_data.domain = domain;
+ gdbarch_iterate_over_objfiles_in_search_order
+ (objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch,
+ lookup_symbol_global_iterator_cb, &lookup_data, objfile);
- ALL_OBJFILES (objfile)
- {
- sym = lookup_symbol_aux_quick (objfile, GLOBAL_BLOCK, name, domain);
- if (sym)
- return sym;
- }
-
- return NULL;
+ return lookup_data.result;
}
int
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_OBJFILE_PRIMARY_SYMTABS (objfile, s)
+ {
+ bv = BLOCKVECTOR (s);
+ block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
+ sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
+ if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
+ {
+ return SYMBOL_TYPE (sym);
+ }
+ }
}
ALL_OBJFILES (objfile)
objfile->sf->qf->pre_expand_symtabs_matching (objfile, STATIC_BLOCK,
name, STRUCT_DOMAIN);
- ALL_OBJFILE_SYMTABS (objfile, s)
+ ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
{
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
lookup_block_symbol (const struct block *block, const char *name,
const domain_enum domain)
{
- struct dict_iterator iter;
+ struct block_iterator iter;
struct symbol *sym;
if (!BLOCK_FUNCTION (block))
{
- for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter);
+ for (sym = block_iter_name_first (block, name, &iter);
sym != NULL;
- sym = dict_iter_name_next (name, &iter))
+ sym = block_iter_name_next (name, &iter))
{
if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
SYMBOL_DOMAIN (sym), domain))
struct symbol *sym_found = NULL;
- for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter);
+ for (sym = block_iter_name_first (block, name, &iter);
sym != NULL;
- sym = dict_iter_name_next (name, &iter))
+ sym = block_iter_name_next (name, &iter))
{
if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
SYMBOL_DOMAIN (sym), domain))
{
while (block)
{
- struct dict_iterator iter;
+ struct block_iterator iter;
struct symbol *sym;
- for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter);
+ for (sym = block_iter_name_first (block, name, &iter);
sym != NULL;
- sym = dict_iter_name_next (name, &iter))
+ sym = block_iter_name_next (name, &iter))
{
if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
SYMBOL_DOMAIN (sym), domain))
}
if (section != 0)
{
- struct dict_iterator iter;
+ struct block_iterator iter;
struct symbol *sym = NULL;
ALL_BLOCK_SYMBOLS (b, iter, sym)
table. If such an entry cannot be found, return FUNC_ADDR
unaltered. */
-CORE_ADDR
+static CORE_ADDR
skip_prologue_using_lineinfo (CORE_ADDR func_addr, struct symtab *symtab)
{
CORE_ADDR func_start, func_end;
to `__main' in `main' between the prologue and before user
code. */
if (gdbarch_skip_main_prologue_p (gdbarch)
- && name && strcmp (name, "main") == 0)
+ && name && strcmp_iw (name, "main") == 0)
{
pc = gdbarch_skip_main_prologue (gdbarch, pc);
/* Recalculate the line number (might not be N+1). */
struct blockvector *bv;
struct block *b;
int i = 0;
- struct dict_iterator iter;
+ struct block_iterator iter;
struct symbol *sym;
struct objfile *objfile;
struct minimal_symbol *msymbol;
- char *val;
int found_misc = 0;
static const enum minimal_symbol_type types[]
= {mst_data, mst_text, mst_abs};
{
if (objfile->sf)
objfile->sf->qf->expand_symtabs_matching (objfile,
- search_symbols_file_matches,
+ (nfiles == 0
+ ? NULL
+ : search_symbols_file_matches),
search_symbols_name_matches,
kind,
&datum);
The symbol will then be found during the scan of symtabs below.
For functions, find_pc_symtab should succeed if we have debug info
- for the function, for variables we have to call lookup_symbol
- to determine if the variable has debug info.
+ for the function, for variables we have to call
+ lookup_symbol_in_objfile_from_linkage_name 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.
+ We only search the objfile the msymbol came from, we no longer search
+ all objfiles. In large programs (1000s of shared libs) searching all
+ objfiles is not worth the pain. */
if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
{
{
QUIT;
- if (MSYMBOL_TYPE (msymbol) == ourtype ||
- MSYMBOL_TYPE (msymbol) == ourtype2 ||
- MSYMBOL_TYPE (msymbol) == ourtype3 ||
- MSYMBOL_TYPE (msymbol) == ourtype4)
+ if (msymbol->created_by_gdb)
+ continue;
+
+ if (MSYMBOL_TYPE (msymbol) == ourtype
+ || MSYMBOL_TYPE (msymbol) == ourtype2
+ || MSYMBOL_TYPE (msymbol) == ourtype3
+ || MSYMBOL_TYPE (msymbol) == ourtype4)
{
if (!datum.preg_p
|| regexec (&datum.preg, SYMBOL_NATURAL_NAME (msymbol), 0,
NULL, 0) == 0)
{
- if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)))
- {
- /* FIXME: carlton/2003-02-04: Given that the
- semantics of lookup_symbol keeps on changing
- slightly, it would be a nice idea if we had a
- function lookup_symbol_minsym that found the
- symbol associated to a given minimal symbol (if
- any). */
- if (kind == FUNCTIONS_DOMAIN
- || lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
- (struct block *) NULL,
- VAR_DOMAIN, 0)
- == NULL)
- found_misc = 1;
- }
+ /* Note: An important side-effect of these lookup functions
+ is to expand the symbol table if msymbol is found, for the
+ benefit of the next loop on ALL_PRIMARY_SYMTABS. */
+ if (kind == FUNCTIONS_DOMAIN
+ ? find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)) == NULL
+ : (lookup_symbol_in_objfile_from_linkage_name
+ (objfile, SYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
+ == NULL))
+ found_misc = 1;
}
}
}
ALL_PRIMARY_SYMTABS (objfile, s)
{
bv = BLOCKVECTOR (s);
- for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
- {
- struct symbol_search *prevtail = tail;
- int nfound = 0;
+ 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, iter, sym)
- {
- struct symtab *real_symtab = SYMBOL_SYMTAB (sym);
-
- QUIT;
-
- if (file_matches (real_symtab->filename, files, nfiles)
- && ((!datum.preg_p
- || regexec (&datum.preg, SYMBOL_NATURAL_NAME (sym), 0,
- NULL, 0) == 0)
- && ((kind == VARIABLES_DOMAIN
- && SYMBOL_CLASS (sym) != LOC_TYPEDEF
- && SYMBOL_CLASS (sym) != LOC_UNRESOLVED
- && 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->block = i;
- psr->symtab = real_symtab;
- psr->symbol = sym;
- psr->msymbol = NULL;
- psr->next = NULL;
- if (tail == NULL)
- sr = psr;
- else
- tail->next = psr;
- tail = psr;
- nfound ++;
- }
- }
- if (nfound > 0)
- {
- if (prevtail == NULL)
- {
- struct symbol_search dummy;
+ b = BLOCKVECTOR_BLOCK (bv, i);
+ ALL_BLOCK_SYMBOLS (b, iter, sym)
+ {
+ struct symtab *real_symtab = SYMBOL_SYMTAB (sym);
+
+ QUIT;
+
+ if (file_matches (real_symtab->filename, files, nfiles)
+ && ((!datum.preg_p
+ || regexec (&datum.preg, SYMBOL_NATURAL_NAME (sym), 0,
+ NULL, 0) == 0)
+ && ((kind == VARIABLES_DOMAIN
+ && SYMBOL_CLASS (sym) != LOC_TYPEDEF
+ && SYMBOL_CLASS (sym) != LOC_UNRESOLVED
+ && 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->block = i;
+ psr->symtab = real_symtab;
+ psr->symbol = sym;
+ psr->msymbol = NULL;
+ psr->next = NULL;
+ if (tail == NULL)
+ sr = psr;
+ else
+ tail->next = psr;
+ tail = psr;
+ nfound ++;
+ }
+ }
+ if (nfound > 0)
+ {
+ if (prevtail == NULL)
+ {
+ struct symbol_search dummy;
- dummy.next = sr;
- tail = sort_search_symbols (&dummy, nfound);
- sr = dummy.next;
+ dummy.next = sr;
+ tail = sort_search_symbols (&dummy, nfound);
+ sr = dummy.next;
- make_cleanup_free_search_symbols (sr);
- }
- else
- tail = sort_search_symbols (prevtail, nfound);
- }
- }
+ make_cleanup_free_search_symbols (sr);
+ }
+ else
+ tail = sort_search_symbols (prevtail, nfound);
+ }
+ }
}
/* If there are no eyes, avoid all contact. I mean, if there are
no debug symbols, then print directly from the msymbol_vector. */
- if (found_misc || kind != FUNCTIONS_DOMAIN)
+ if (found_misc || (nfiles == 0 && kind != FUNCTIONS_DOMAIN))
{
ALL_MSYMBOLS (objfile, msymbol)
{
QUIT;
- if (MSYMBOL_TYPE (msymbol) == ourtype ||
- MSYMBOL_TYPE (msymbol) == ourtype2 ||
- MSYMBOL_TYPE (msymbol) == ourtype3 ||
- MSYMBOL_TYPE (msymbol) == ourtype4)
+ if (msymbol->created_by_gdb)
+ continue;
+
+ if (MSYMBOL_TYPE (msymbol) == ourtype
+ || MSYMBOL_TYPE (msymbol) == ourtype2
+ || MSYMBOL_TYPE (msymbol) == ourtype3
+ || MSYMBOL_TYPE (msymbol) == ourtype4)
{
if (!datum.preg_p
|| regexec (&datum.preg, SYMBOL_NATURAL_NAME (msymbol), 0,
NULL, 0) == 0)
{
- /* Functions: Look up by address. */
- if (kind != FUNCTIONS_DOMAIN ||
- (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol))))
+ /* For functions we can do a quick check of whether the
+ symbol might be found via find_pc_symtab. */
+ if (kind != FUNCTIONS_DOMAIN
+ || find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)) == NULL)
{
- /* Variables/Absolutes: Look up by name. */
- if (lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
- (struct block *) NULL, VAR_DOMAIN, 0)
- == NULL)
+ if (lookup_symbol_in_objfile_from_linkage_name
+ (objfile, SYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
+ == NULL)
{
/* match */
psr = (struct symbol_search *)
&& SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout);
/* variable, func, or typedef-that-is-c++-class. */
- else if (kind < TYPES_DOMAIN ||
- (kind == TYPES_DOMAIN &&
- SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
+ else if (kind < TYPES_DOMAIN
+ || (kind == TYPES_DOMAIN
+ && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
{
type_print (SYMBOL_TYPE (sym),
(SYMBOL_CLASS (sym) == LOC_TYPEDEF
/* Free any memory associated with a completion list. */
static void
-free_completion_list (char ***list_ptr)
+free_completion_list (VEC (char_ptr) **list_ptr)
{
- int i = 0;
- char **list = *list_ptr;
+ int i;
+ char *p;
- while (list[i] != NULL)
- {
- xfree (list[i]);
- i++;
- }
- xfree (list);
+ for (i = 0; VEC_iterate (char_ptr, *list_ptr, i, p); ++i)
+ xfree (p);
+ VEC_free (char_ptr, *list_ptr);
}
/* Callback for make_cleanup. */
/* Helper routine for make_symbol_completion_list. */
-static int return_val_size;
-static int return_val_index;
-static char **return_val;
+static VEC (char_ptr) *return_val;
#define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
completion_list_add_name \
strcat (new, symname);
}
- if (return_val_index + 3 > return_val_size)
- {
- newsize = (return_val_size *= 2) * sizeof (char *);
- return_val = (char **) xrealloc ((char *) return_val, newsize);
- }
- return_val[return_val_index++] = new;
- return_val[return_val_index] = NULL;
+ VEC_safe_push (char_ptr, return_val, new);
}
}
return compare_symbol_name (name, datum->sym_text, datum->sym_text_len);
}
-char **
+VEC (char_ptr) *
default_make_symbol_completion_list_break_on (char *text, char *word,
const char *break_on)
{
struct objfile *objfile;
struct block *b;
const struct block *surrounding_static_block, *surrounding_global_block;
- struct dict_iterator iter;
+ struct block_iterator iter;
/* The symbol we are completing on. Points in same buffer as text. */
char *sym_text;
/* Length of sym_text. */
/* A double-quoted string is never a symbol, nor does it make sense
to complete it any other way. */
{
- return_val = (char **) xmalloc (sizeof (char *));
- return_val[0] = NULL;
- return return_val;
+ return NULL;
}
else
{
}
gdb_assert (sym_text[sym_text_len] == '\0' || sym_text[sym_text_len] == '(');
- return_val_size = 100;
- return_val_index = 0;
- return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
- return_val[0] = NULL;
+ return_val = NULL;
back_to = make_cleanup (do_free_completion_list, &return_val);
datum.sym_text = sym_text;
return (return_val);
}
-char **
+VEC (char_ptr) *
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. */
+/* Return a vector of all symbols (regardless of class) which begin by
+ matching TEXT. If the answer is no symbols, then the return value
+ is NULL. */
-char **
+VEC (char_ptr) *
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 **
+VEC (char_ptr) *
make_symbol_completion_list_fn (struct cmd_list_element *ignore,
char *text, char *word)
{
/* Like make_symbol_completion_list, but returns a list of symbols
defined in a source file FILE. */
-char **
+VEC (char_ptr) *
make_file_symbol_completion_list (char *text, char *word, char *srcfile)
{
struct symbol *sym;
struct symtab *s;
struct block *b;
- struct dict_iterator iter;
+ struct block_iterator iter;
/* The symbol we are completing on. Points in same buffer as text. */
char *sym_text;
/* Length of sym_text. */
/* A double-quoted string is never a symbol, nor does it make sense
to complete it any other way. */
{
- return_val = (char **) xmalloc (sizeof (char *));
- return_val[0] = NULL;
- return return_val;
+ return NULL;
}
else
{
sym_text_len = strlen (sym_text);
- return_val_size = 10;
- return_val_index = 0;
- return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
- return_val[0] = NULL;
+ return_val = NULL;
/* Find the symtab for SRCFILE (this loads it if it was not yet read
in). */
static void
add_filename_to_list (const char *fname, char *text, char *word,
- char ***list, int *list_used, int *list_alloced)
+ VEC (char_ptr) **list)
{
char *new;
size_t fnlen = strlen (fname);
- if (*list_used + 1 >= *list_alloced)
- {
- *list_alloced *= 2;
- *list = (char **) xrealloc ((char *) *list,
- *list_alloced * sizeof (char *));
- }
-
if (word == text)
{
/* Return exactly fname. */
new[text - word] = '\0';
strcat (new, fname);
}
- (*list)[*list_used] = new;
- (*list)[++*list_used] = NULL;
+ VEC_safe_push (char_ptr, *list, new);
}
static int
char *text;
char *word;
int text_len;
- char ***list;
- int *list_used;
- int *list_alloced;
+ VEC (char_ptr) **list;
};
/* A callback for map_partial_symbol_filenames. */
{
/* 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);
+ add_filename_to_list (filename, data->text, data->word, data->list);
}
else
{
if (base_name != filename
&& !filename_seen (base_name, 1, data->first)
&& filename_ncmp (base_name, data->text, data->text_len) == 0)
- add_filename_to_list (base_name, data->text, data->word,
- data->list, data->list_used, data->list_alloced);
+ add_filename_to_list (base_name, data->text, data->word, data->list);
}
}
-/* 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
- the return value is an array which contains only a NULL pointer. */
+/* Return a vector 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 the return value is
+ NULL. */
-char **
+VEC (char_ptr) *
make_source_files_completion_list (char *text, char *word)
{
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 *));
+ VEC (char_ptr) *list = NULL;
const char *base_name;
struct add_partial_filename_data datum;
struct cleanup *back_to;
- list[0] = NULL;
-
if (!have_full_symbols () && !have_partial_symbols ())
return list;
{
/* This file matches for a completion; add it to the current
list of matches. */
- add_filename_to_list (s->filename, text, word,
- &list, &list_used, &list_alloced);
+ add_filename_to_list (s->filename, text, word, &list);
}
else
{
if (base_name != s->filename
&& !filename_seen (base_name, 1, &first)
&& filename_ncmp (base_name, text, text_len) == 0)
- add_filename_to_list (base_name, text, word,
- &list, &list_used, &list_alloced);
+ add_filename_to_list (base_name, text, word, &list);
}
}
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,
0 /*need_fullname*/);
discard_cleanups (back_to);
return prologue_sal.pc;
}
\f
-struct symtabs_and_lines
-decode_line_spec (char *string, int flags)
-{
- 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, flags,
- cursal.symtab, cursal.line);
-
- if (*string)
- error (_("Junk at end of line specification: %s"), string);
- return sals;
-}
-
/* Track MAIN */
static char *name_of_main;
enum language language_of_main = language_unknown;
return;
}
+ new_main_name = go_main_name ();
+ if (new_main_name != NULL)
+ {
+ set_main_name (new_main_name);
+ return;
+ }
+
new_main_name = pascal_main_name ();
if (new_main_name != NULL)
{
NULL, NULL,
&setlist, &showlist);
+ add_setshow_boolean_cmd ("symtab-create", no_class, &symtab_create_debug,
+ _("Set debugging of symbol table creation."),
+ _("Show debugging of symbol table creation."), _("\
+When enabled, debugging messages are printed when building symbol tables."),
+ NULL,
+ NULL,
+ &setdebuglist, &showdebuglist);
+
observer_attach_executable_changed (symtab_observer_executable_changed);
}