{
char *demangled = NULL;
int i;
- int recognized;
if (gsymbol->language == language_unknown)
gsymbol->language = language_auto;
{
return find_pc_sect_compunit_symtab (pc, find_pc_mapped_section (pc));
}
+
+/* See symtab.h. */
+
+struct symbol *
+find_symbol_at_address (CORE_ADDR address)
+{
+ struct objfile *objfile;
+
+ ALL_OBJFILES (objfile)
+ {
+ if (objfile->sf == NULL
+ || objfile->sf->qf->find_compunit_symtab_by_address == NULL)
+ continue;
+
+ struct compunit_symtab *symtab
+ = objfile->sf->qf->find_compunit_symtab_by_address (objfile, address);
+ if (symtab != NULL)
+ {
+ const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (symtab);
+
+ for (int i = GLOBAL_BLOCK; i <= STATIC_BLOCK; ++i)
+ {
+ struct block *b = BLOCKVECTOR_BLOCK (bv, i);
+ struct block_iterator iter;
+ struct symbol *sym;
+
+ ALL_BLOCK_SYMBOLS (b, iter, sym)
+ {
+ if (SYMBOL_CLASS (sym) == LOC_STATIC
+ && SYMBOL_VALUE_ADDRESS (sym) == address)
+ return sym;
+ }
+ }
+ }
+ }
+
+ return NULL;
+}
+
\f
/* Find the source file and line number for a given PC value and SECTION.
symbol *
find_function_alias_target (bound_minimal_symbol msymbol)
{
- if (!msymbol_is_text (msymbol.minsym))
+ CORE_ADDR func_addr;
+ if (!msymbol_is_function (msymbol.objfile, msymbol.minsym, &func_addr))
return NULL;
- CORE_ADDR addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
- symbol *sym = find_pc_function (addr);
+ symbol *sym = find_pc_function (func_addr);
if (sym != NULL
&& SYMBOL_CLASS (sym) == LOC_BLOCK
- && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == addr)
+ && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == func_addr)
return sym;
return NULL;
and <TYPENAME> or <OPERATOR>. */
const char *opend;
const char *opname = operator_chars (regexp, &opend);
- int errcode;
if (*opname)
{
symbol_name_matcher_ftype *name_match
= language_get_symbol_name_matcher (lang, lookup_name);
- return name_match (symbol_name, lookup_name, &match_res.match);
+ return name_match (symbol_name, lookup_name, &match_res);
}
/* See symtab.h. */
language symbol_language,
const char *symname,
const lookup_name_info &lookup_name,
- const char *sym_text, int sym_text_len,
const char *text, const char *word)
{
completion_match_result &match_res
of matches. Note that the name is moved to freshly malloc'd space. */
{
- char *newobj;
-
- if (word == sym_text)
- {
- newobj = (char *) xmalloc (strlen (symname) + 5);
- strcpy (newobj, symname);
- }
- else if (word > sym_text)
- {
- /* Return some portion of symname. */
- newobj = (char *) xmalloc (strlen (symname) + 5);
- strcpy (newobj, symname + (word - sym_text));
- }
- else
- {
- /* Return some of SYM_TEXT plus symname. */
- newobj = (char *) xmalloc (strlen (symname) + (sym_text - word) + 5);
- strncpy (newobj, word, sym_text - word);
- newobj[sym_text - word] = '\0';
- strcat (newobj, symname);
- }
-
- gdb::unique_xmalloc_ptr<char> completion (newobj);
-
- tracker.add_completion (std::move (completion));
+ gdb::unique_xmalloc_ptr<char> completion
+ = make_completion_match_str (symname, text, word);
+
+ /* Here we pass the match-for-lcd object to add_completion. Some
+ languages match the user text against substrings of symbol
+ names in some cases. E.g., in C++, "b push_ba" completes to
+ "std::vector::push_back", "std::string::push_back", etc., and
+ in this case we want the completion lowest common denominator
+ to be "push_back" instead of "std::". */
+ tracker.add_completion (std::move (completion),
+ &match_res.match_for_lcd);
}
}
completion_list_add_symbol (completion_tracker &tracker,
symbol *sym,
const lookup_name_info &lookup_name,
- const char *sym_text, int sym_text_len,
const char *text, const char *word)
{
completion_list_add_name (tracker, SYMBOL_LANGUAGE (sym),
SYMBOL_NATURAL_NAME (sym),
- lookup_name, sym_text, sym_text_len, text, word);
+ lookup_name, text, word);
}
/* completion_list_add_name wrapper for struct minimal_symbol. */
completion_list_add_msymbol (completion_tracker &tracker,
minimal_symbol *sym,
const lookup_name_info &lookup_name,
- const char *sym_text, int sym_text_len,
const char *text, const char *word)
{
completion_list_add_name (tracker, MSYMBOL_LANGUAGE (sym),
MSYMBOL_NATURAL_NAME (sym),
- lookup_name, sym_text, sym_text_len, text, word);
+ lookup_name, text, word);
}
completion_list_objc_symbol (completion_tracker &tracker,
struct minimal_symbol *msymbol,
const lookup_name_info &lookup_name,
- const char *sym_text, int sym_text_len,
const char *text, const char *word)
{
static char *tmp = NULL;
if ((method[0] != '-') && (method[0] != '+'))
return;
- if (sym_text[0] == '[')
+ if (text[0] == '[')
/* Complete on shortened method method. */
completion_list_add_name (tracker, language_objc,
method + 1,
lookup_name,
- sym_text, sym_text_len, text, word);
+ text, word);
while ((strlen (method) + 1) >= tmplen)
{
tmp[category - method] = ' ';
memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1);
completion_list_add_name (tracker, language_objc, tmp,
- lookup_name,
- sym_text, sym_text_len, text, word);
- if (sym_text[0] == '[')
+ lookup_name, text, word);
+ if (text[0] == '[')
completion_list_add_name (tracker, language_objc, tmp + 1,
- lookup_name,
- sym_text, sym_text_len, text, word);
+ lookup_name, text, word);
}
if (selector != NULL)
*tmp2 = '\0';
completion_list_add_name (tracker, language_objc, tmp,
- lookup_name,
- sym_text, sym_text_len, text, word);
+ lookup_name, text, word);
}
}
completion_list_add_fields (completion_tracker &tracker,
struct symbol *sym,
const lookup_name_info &lookup_name,
- const char *sym_text, int sym_text_len,
const char *text, const char *word)
{
if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
if (TYPE_FIELD_NAME (t, j))
completion_list_add_name (tracker, SYMBOL_LANGUAGE (sym),
TYPE_FIELD_NAME (t, j),
- lookup_name,
- sym_text, sym_text_len, text, word);
+ lookup_name, text, word);
+ }
+}
+
+/* See symtab.h. */
+
+bool
+symbol_is_function_or_method (symbol *sym)
+{
+ switch (TYPE_CODE (SYMBOL_TYPE (sym)))
+ {
+ case TYPE_CODE_FUNC:
+ case TYPE_CODE_METHOD:
+ return true;
+ default:
+ return false;
+ }
+}
+
+/* See symtab.h. */
+
+bool
+symbol_is_function_or_method (minimal_symbol *msymbol)
+{
+ switch (MSYMBOL_TYPE (msymbol))
+ {
+ case mst_text:
+ case mst_text_gnu_ifunc:
+ case mst_solib_trampoline:
+ case mst_file_text:
+ return true;
+ default:
+ return false;
}
}
static void
add_symtab_completions (struct compunit_symtab *cust,
completion_tracker &tracker,
+ complete_symbol_mode mode,
const lookup_name_info &lookup_name,
- const char *sym_text, int sym_text_len,
const char *text, const char *word,
enum type_code code)
{
b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), i);
ALL_BLOCK_SYMBOLS (b, iter, sym)
{
+ if (completion_skip_symbol (mode, sym))
+ continue;
+
if (code == TYPE_CODE_UNDEF
|| (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
&& TYPE_CODE (SYMBOL_TYPE (sym)) == code))
completion_list_add_symbol (tracker, sym,
lookup_name,
- sym_text, sym_text_len,
text, word);
}
}
struct block_iterator iter;
/* The symbol we are completing on. Points in same buffer as text. */
const char *sym_text;
- /* Length of sym_text. */
- int sym_text_len;
/* Now look for the symbol we are supposed to complete on. */
if (mode == complete_symbol_mode::LINESPEC)
}
}
- sym_text_len = strlen (sym_text);
-
- lookup_name_info lookup_name (std::string (sym_text, sym_text_len),
- name_match_type, true);
+ lookup_name_info lookup_name (sym_text, name_match_type, true);
/* At this point scan through the misc symbol vectors and add each
symbol you find to the list. Eventually we want to ignore
{
QUIT;
+ if (completion_skip_symbol (mode, msymbol))
+ continue;
+
completion_list_add_msymbol (tracker, msymbol, lookup_name,
- sym_text, sym_text_len,
- text, word);
+ sym_text, word);
completion_list_objc_symbol (tracker, msymbol, lookup_name,
- sym_text, sym_text_len, text,
- word);
+ sym_text, word);
}
}
/* Add completions for all currently loaded symbol tables. */
ALL_COMPUNITS (objfile, cust)
- add_symtab_completions (cust, tracker, lookup_name,
- sym_text, sym_text_len, text, word, code);
+ add_symtab_completions (cust, tracker, mode, lookup_name,
+ sym_text, word, code);
/* Look through the partial symtabs for all symbols which begin by
matching SYM_TEXT. Expand all CUs that you find to the list. */
[&] (compunit_symtab *symtab) /* expansion notify */
{
add_symtab_completions (symtab,
- tracker, lookup_name,
- sym_text, sym_text_len,
- text, word, code);
+ tracker, mode, lookup_name,
+ sym_text, word, code);
},
ALL_DOMAIN);
if (code == TYPE_CODE_UNDEF)
{
completion_list_add_symbol (tracker, sym, lookup_name,
- sym_text, sym_text_len, text,
- word);
+ sym_text, word);
completion_list_add_fields (tracker, sym, lookup_name,
- sym_text, sym_text_len, text,
- word);
+ sym_text, word);
}
else if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
&& TYPE_CODE (SYMBOL_TYPE (sym)) == code)
completion_list_add_symbol (tracker, sym, lookup_name,
- sym_text, sym_text_len, text,
- word);
+ sym_text, word);
}
/* Stop when we encounter an enclosing function. Do not stop for
if (surrounding_static_block != NULL)
ALL_BLOCK_SYMBOLS (surrounding_static_block, iter, sym)
completion_list_add_fields (tracker, sym, lookup_name,
- sym_text, sym_text_len, text, word);
+ sym_text, word);
if (surrounding_global_block != NULL)
ALL_BLOCK_SYMBOLS (surrounding_global_block, iter, sym)
completion_list_add_fields (tracker, sym, lookup_name,
- sym_text, sym_text_len, text, word);
+ sym_text, word);
}
/* Skip macros if we are completing a struct tag -- arguable but
macro_source_file *,
int)
{
- completion_list_add_name (tracker,
- language_c,
- macro_name,
- lookup_name,
- sym_text, sym_text_len,
- text, word);
+ completion_list_add_name (tracker, language_c, macro_name,
+ lookup_name, sym_text, word);
};
/* Add any macros visible in the default scope. Note that this
{
/* The symbol we are completing on. Points in same buffer as text. */
const char *sym_text;
- /* Length of sym_text. */
- int sym_text_len;
/* Now look for the symbol we are supposed to complete on.
FIXME: This should be language-specific. */
}
}
- sym_text_len = strlen (sym_text);
-
- lookup_name_info lookup_name (std::string (sym_text, sym_text_len),
- name_match_type, true);
+ lookup_name_info lookup_name (sym_text, name_match_type, true);
/* Go through symtabs for SRCFILE and check the externs and statics
for symbols which match. */
iterate_over_symtabs (srcfile, [&] (symtab *s)
{
add_symtab_completions (SYMTAB_COMPUNIT (s),
- tracker, lookup_name,
- sym_text, sym_text_len,
- text, word, TYPE_CODE_UNDEF);
+ tracker, mode, lookup_name,
+ sym_text, word, TYPE_CODE_UNDEF);
return false;
});
}
add_filename_to_list (const char *fname, const char *text, const char *word,
completion_list *list)
{
- char *newobj;
- size_t fnlen = strlen (fname);
-
- if (word == text)
- {
- /* Return exactly fname. */
- newobj = (char *) xmalloc (fnlen + 5);
- strcpy (newobj, fname);
- }
- else if (word > text)
- {
- /* Return some portion of fname. */
- newobj = (char *) xmalloc (fnlen + 5);
- strcpy (newobj, fname + (word - text));
- }
- else
- {
- /* Return some of TEXT plus fname. */
- newobj = (char *) xmalloc (fnlen + (text - word) + 5);
- strncpy (newobj, word, text - word);
- newobj[text - word] = '\0';
- strcat (newobj, fname);
- }
- list->emplace_back (newobj);
+ list->emplace_back (make_completion_match_str (fname, text, word));
}
static int
struct template_symbol *result;
result = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct template_symbol);
- initialize_objfile_symbol_1 (&result->base);
+ initialize_objfile_symbol_1 (result);
return result;
}
projects / deliverable / binutils-gdb.git / blobdiff