X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fsymtab.c;h=567195304f40f9c40471ed09c35054814bad52af;hb=b4987c956dfa44ca9fd8552f63e15f5fa094b2a4;hp=aecee8f383a67ae70a722a51833f9718853d5adb;hpb=b5ec771e60c1a0863e51eb491c85c674097e9e13;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/symtab.c b/gdb/symtab.c index aecee8f383..567195304f 100644 --- a/gdb/symtab.c +++ b/gdb/symtab.c @@ -1,6 +1,6 @@ /* Symbol table lookup for the GNU debugger, GDB. - Copyright (C) 1986-2017 Free Software Foundation, Inc. + Copyright (C) 1986-2018 Free Software Foundation, Inc. This file is part of GDB. @@ -66,6 +66,7 @@ #include "filename-seen-cache.h" #include "arch-utils.h" #include +#include "common/pathstuff.h" /* Forward declarations for local functions. */ @@ -75,6 +76,7 @@ static int find_line_common (struct linetable *, int, int *, int); static struct block_symbol lookup_symbol_aux (const char *name, + symbol_name_match_type match_type, const struct block *block, const domain_enum domain, enum language language, @@ -82,6 +84,7 @@ static struct block_symbol static struct block_symbol lookup_local_symbol (const char *name, + symbol_name_match_type match_type, const struct block *block, const domain_enum domain, enum language language); @@ -729,7 +732,6 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol, { char *demangled = NULL; int i; - int recognized; if (gsymbol->language == language_unknown) gsymbol->language = language_auto; @@ -954,8 +956,7 @@ symbol_matches_search_name (const struct general_symbol_info *gsymbol, const lookup_name_info &name) { symbol_name_matcher_ftype *name_match - = language_get_symbol_name_matcher (language_def (gsymbol->language), - name); + = get_symbol_name_matcher (language_def (gsymbol->language), name); return name_match (symbol_search_name (gsymbol), name, NULL); } @@ -1766,8 +1767,26 @@ demangle_for_lookup_info::demangle_for_lookup_info { demangle_result_storage storage; - m_demangled_name = demangle_for_lookup (lookup_name.name ().c_str (), - lang, storage); + if (lookup_name.ignore_parameters () && lang == language_cplus) + { + gdb::unique_xmalloc_ptr without_params + = cp_remove_params_if_any (lookup_name.name ().c_str (), + lookup_name.completion_mode ()); + + if (without_params != NULL) + { + if (lookup_name.match_type () != symbol_name_match_type::SEARCH_NAME) + m_demangled_name = demangle_for_lookup (without_params.get (), + lang, storage); + return; + } + } + + if (lookup_name.match_type () == symbol_name_match_type::SEARCH_NAME) + m_demangled_name = lookup_name.name (); + else + m_demangled_name = demangle_for_lookup (lookup_name.name ().c_str (), + lang, storage); } /* See symtab.h. */ @@ -1863,7 +1882,9 @@ lookup_symbol_in_language (const char *name, const struct block *block, demangle_result_storage storage; const char *modified_name = demangle_for_lookup (name, lang, storage); - return lookup_symbol_aux (modified_name, block, domain, lang, + return lookup_symbol_aux (modified_name, + symbol_name_match_type::FULL, + block, domain, lang, is_a_field_of_this); } @@ -1881,6 +1902,16 @@ lookup_symbol (const char *name, const struct block *block, /* See symtab.h. */ +struct block_symbol +lookup_symbol_search_name (const char *search_name, const struct block *block, + domain_enum domain) +{ + return lookup_symbol_aux (search_name, symbol_name_match_type::SEARCH_NAME, + block, domain, language_asm, NULL); +} + +/* See symtab.h. */ + struct block_symbol lookup_language_this (const struct language_defn *lang, const struct block *block) @@ -1902,7 +1933,9 @@ lookup_language_this (const struct language_defn *lang, { struct symbol *sym; - sym = block_lookup_symbol (block, lang->la_name_of_this, VAR_DOMAIN); + sym = block_lookup_symbol (block, lang->la_name_of_this, + symbol_name_match_type::SEARCH_NAME, + VAR_DOMAIN); if (sym != NULL) { if (symbol_lookup_debug > 1) @@ -1973,7 +2006,8 @@ check_field (struct type *type, const char *name, (e.g., demangled name) of the symbol that we're looking for. */ static struct block_symbol -lookup_symbol_aux (const char *name, const struct block *block, +lookup_symbol_aux (const char *name, symbol_name_match_type match_type, + const struct block *block, const domain_enum domain, enum language language, struct field_of_this_result *is_a_field_of_this) { @@ -2002,7 +2036,7 @@ lookup_symbol_aux (const char *name, const struct block *block, /* Search specified block and its superiors. Don't search STATIC_BLOCK or GLOBAL_BLOCK. */ - result = lookup_local_symbol (name, block, domain, language); + result = lookup_local_symbol (name, match_type, block, domain, language); if (result.symbol != NULL) { if (symbol_lookup_debug) @@ -2084,7 +2118,9 @@ lookup_symbol_aux (const char *name, const struct block *block, Don't search STATIC_BLOCK or GLOBAL_BLOCK. */ static struct block_symbol -lookup_local_symbol (const char *name, const struct block *block, +lookup_local_symbol (const char *name, + symbol_name_match_type match_type, + const struct block *block, const domain_enum domain, enum language language) { @@ -2099,7 +2135,7 @@ lookup_local_symbol (const char *name, const struct block *block, while (block != static_block) { - sym = lookup_symbol_in_block (name, block, domain); + sym = lookup_symbol_in_block (name, match_type, block, domain); if (sym != NULL) return (struct block_symbol) {sym, block}; @@ -2152,7 +2188,8 @@ lookup_objfile_from_block (const struct block *block) /* See symtab.h. */ struct symbol * -lookup_symbol_in_block (const char *name, const struct block *block, +lookup_symbol_in_block (const char *name, symbol_name_match_type match_type, + const struct block *block, const domain_enum domain) { struct symbol *sym; @@ -2168,7 +2205,7 @@ lookup_symbol_in_block (const char *name, const struct block *block, domain_name (domain)); } - sym = block_lookup_symbol (block, name, domain); + sym = block_lookup_symbol (block, name, match_type, domain); if (sym) { if (symbol_lookup_debug > 1) @@ -2357,7 +2394,8 @@ lookup_symbol_via_quick_fns (struct objfile *objfile, int block_index, bv = COMPUNIT_BLOCKVECTOR (cust); block = BLOCKVECTOR_BLOCK (bv, block_index); - result.symbol = block_lookup_symbol (block, name, domain); + result.symbol = block_lookup_symbol (block, name, + symbol_name_match_type::FULL, domain); if (result.symbol == NULL) error_in_psymtab_expansion (block_index, name, cust); @@ -2470,7 +2508,9 @@ lookup_symbol_in_static_block (const char *name, domain_name (domain)); } - sym = lookup_symbol_in_block (name, static_block, domain); + sym = lookup_symbol_in_block (name, + symbol_name_match_type::FULL, + static_block, domain); if (symbol_lookup_debug) { fprintf_unfiltered (gdb_stdlog, @@ -2950,6 +2990,45 @@ find_pc_compunit_symtab (CORE_ADDR pc) { 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; +} + /* Find the source file and line number for a given PC value and SECTION. @@ -3874,14 +3953,14 @@ skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr) 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; @@ -4230,7 +4309,6 @@ search_symbols (const char *regexp, enum search_domain kind, and or . */ const char *opend; const char *opname = operator_chars (regexp, &opend); - int errcode; if (*opname) { @@ -4619,58 +4697,19 @@ rbreak_command (const char *regexp, int from_tty) } -/* Evaluate if NAME matches SYM_TEXT and SYM_TEXT_LEN. - - Either sym_text[sym_text_len] != '(' and then we search for any - symbol starting with SYM_TEXT text. - - Otherwise sym_text[sym_text_len] == '(' and then we require symbol name to - be terminated at that point. Partial symbol tables do not have parameters - information. */ +/* Evaluate if SYMNAME matches LOOKUP_NAME. */ static int -compare_symbol_name (const char *name, - language symbol_language, +compare_symbol_name (const char *symbol_name, language symbol_language, const lookup_name_info &lookup_name, - const char *sym_text, int sym_text_len, completion_match_result &match_res) { - const language_defn *lang; - - /* If we're completing for an expression and the symbol doesn't have - an explicit language set, fallback to the current language. Ada - minimal symbols won't have their language set to Ada, for - example, and if we compared using the default/C-like matcher, - then when completing e.g., symbols in a package named "pck", we'd - match internal Ada symbols like "pckS", which are invalid in an - Ada expression, unless you wrap them in '<' '>' to request a - verbatim match. */ - if (symbol_language == language_auto - && lookup_name.match_type () == symbol_name_match_type::EXPRESSION) - lang = current_language; - else - lang = language_def (symbol_language); + const language_defn *lang = language_def (symbol_language); symbol_name_matcher_ftype *name_match - = language_get_symbol_name_matcher (lang, lookup_name); - - /* Clip symbols that cannot match. */ - if (!name_match (name, lookup_name, &match_res.match)) - return 0; - - if (sym_text[sym_text_len] == '(') - { - /* User searches for `name(someth...'. Require NAME to be terminated. - Normally psymtabs and gdbindex have no parameter types so '\0' will be - present but accept even parameters presence. In this case this - function is in fact strcmp_iw but whitespace skipping is not supported - for tab completion. */ + = get_symbol_name_matcher (lang, lookup_name); - if (name[sym_text_len] != '\0' && name[sym_text_len] != '(') - return 0; - } - - return 1; + return name_match (symbol_name, lookup_name, &match_res); } /* See symtab.h. */ @@ -4680,17 +4719,13 @@ completion_list_add_name (completion_tracker &tracker, 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 = tracker.reset_completion_match_result (); /* Clip symbols that cannot match. */ - if (!compare_symbol_name (symname, symbol_language, - lookup_name, - sym_text, sym_text_len, - match_res)) + if (!compare_symbol_name (symname, symbol_language, lookup_name, match_res)) return; /* Refresh SYMNAME from the match string. It's potentially @@ -4703,31 +4738,17 @@ completion_list_add_name (completion_tracker &tracker, 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 completion (newobj); - - tracker.add_completion (std::move (completion)); + gdb::unique_xmalloc_ptr 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, text, word); } } @@ -4737,12 +4758,11 @@ static void 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. */ @@ -4751,12 +4771,11 @@ static void 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); } @@ -4767,7 +4786,6 @@ static void 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; @@ -4782,12 +4800,12 @@ completion_list_objc_symbol (completion_tracker &tracker, 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) { @@ -4809,12 +4827,10 @@ completion_list_objc_symbol (completion_tracker &tracker, 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) @@ -4826,8 +4842,7 @@ completion_list_objc_symbol (completion_tracker &tracker, *tmp2 = '\0'; completion_list_add_name (tracker, language_objc, tmp, - lookup_name, - sym_text, sym_text_len, text, word); + lookup_name, text, word); } } @@ -4881,7 +4896,6 @@ static void 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) @@ -4895,8 +4909,39 @@ completion_list_add_fields (completion_tracker &tracker, 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; } } @@ -4905,8 +4950,8 @@ completion_list_add_fields (completion_tracker &tracker, 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) { @@ -4924,12 +4969,14 @@ add_symtab_completions (struct compunit_symtab *cust, 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); } } @@ -4955,8 +5002,6 @@ default_collect_symbol_completion_matches_break_on 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) @@ -5012,25 +5057,7 @@ default_collect_symbol_completion_matches_break_on } } - sym_text_len = strlen (sym_text); - - /* Prepare SYM_TEXT_LEN for compare_symbol_name. */ - - if (current_language->la_language == language_cplus - || current_language->la_language == language_fortran) - { - /* These languages may have parameters entered by user but they are never - present in the partial symbol tables. */ - - const char *cs = (const char *) memchr (sym_text, '(', sym_text_len); - - if (cs) - sym_text_len = cs - sym_text; - } - gdb_assert (sym_text[sym_text_len] == '\0' || sym_text[sym_text_len] == '('); - - 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 @@ -5043,20 +5070,21 @@ default_collect_symbol_completion_matches_break_on { 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. */ @@ -5066,9 +5094,8 @@ default_collect_symbol_completion_matches_break_on [&] (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); @@ -5090,17 +5117,14 @@ default_collect_symbol_completion_matches_break_on 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 @@ -5118,12 +5142,12 @@ default_collect_symbol_completion_matches_break_on 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 @@ -5131,7 +5155,7 @@ default_collect_symbol_completion_matches_break_on if (current_language->la_macro_expansion == macro_expansion_c && code == TYPE_CODE_UNDEF) { - struct macro_scope *scope; + gdb::unique_xmalloc_ptr scope; /* This adds a macro's name to the current completion list. */ auto add_macro_name = [&] (const char *macro_name, @@ -5139,12 +5163,8 @@ default_collect_symbol_completion_matches_break_on 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 @@ -5156,11 +5176,8 @@ default_collect_symbol_completion_matches_break_on completion time. */ scope = default_macro_scope (); if (scope) - { - macro_for_each_in_scope (scope->file, scope->line, - add_macro_name); - xfree (scope); - } + macro_for_each_in_scope (scope->file, scope->line, + add_macro_name); /* User-defined macros are always visible. */ macro_for_each (macro_user_macros, add_macro_name); @@ -5226,8 +5243,6 @@ collect_file_symbol_completion_matches (completion_tracker &tracker, { /* 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. */ @@ -5275,19 +5290,15 @@ collect_file_symbol_completion_matches (completion_tracker &tracker, } } - 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; }); } @@ -5300,30 +5311,7 @@ static void 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 @@ -5783,7 +5771,7 @@ allocate_template_symbol (struct objfile *objfile) 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; }