X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Flinespec.c;h=00f59f9c286686e244d041b003568ab819409df2;hb=e04caa70901ed44eb9537ccdbd286fe9b0a46ce2;hp=9c92444e16bf82da18ad82a0503a69791decdf9b;hpb=3553eadc8cb5f087ea0fb72ebdd1c52264304e0b;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/linespec.c b/gdb/linespec.c index 9c92444e16..00f59f9c28 100644 --- a/gdb/linespec.c +++ b/gdb/linespec.c @@ -81,9 +81,6 @@ enum class linespec_complete_what typedef std::unique_ptr> symtab_vector_up; -typedef struct symbol *symbolp; -DEF_VEC_P (symbolp); - /* An address entry is used to ensure that any given location is only added to the result a single time. It holds an address and the program space from which the address came. */ @@ -94,10 +91,6 @@ struct address_entry CORE_ADDR addr; }; -typedef struct bound_minimal_symbol bound_minimal_symbol_d; - -DEF_VEC_O (bound_minimal_symbol_d); - /* A linespec. Elements of this structure are filled in by a parser (either parse_linespec or some other function). The structure is then converted into SALs by convert_linespec_to_sals. */ @@ -115,16 +108,16 @@ struct linespec /* A list of matching function symbols and minimal symbols. Both lists may be NULL (or empty) if no matching symbols were found. */ - std::vector *function_symbols; - VEC (bound_minimal_symbol_d) *minimal_symbols; + std::vector *function_symbols; + std::vector *minimal_symbols; /* A structure of matching label symbols and the corresponding function symbol in which the label was found. Both may be NULL or both must be non-NULL. */ struct { - std::vector *label_symbols; - std::vector *function_symbols; + std::vector *label_symbols; + std::vector *function_symbols; } labels; }; typedef struct linespec *linespec_p; @@ -201,26 +194,41 @@ struct collect_info /* The result being accumulated. */ struct { - std::vector *symbols; - VEC (bound_minimal_symbol_d) *minimal_symbols; + std::vector *symbols; + std::vector *minimal_symbols; } result; /* Possibly add a symbol to the results. */ - bool add_symbol (symbol *sym); + virtual bool add_symbol (block_symbol *bsym); }; bool -collect_info::add_symbol (symbol *sym) +collect_info::add_symbol (block_symbol *bsym) { /* In list mode, add all matching symbols, regardless of class. This allows the user to type "list a_global_variable". */ - if (SYMBOL_CLASS (sym) == LOC_BLOCK || this->state->list_mode) - this->result.symbols->push_back (sym); + if (SYMBOL_CLASS (bsym->symbol) == LOC_BLOCK || this->state->list_mode) + this->result.symbols->push_back (*bsym); /* Continue iterating. */ return true; } +/* Custom collect_info for symbol_searcher. */ + +struct symbol_searcher_collect_info + : collect_info +{ + bool add_symbol (block_symbol *bsym) override + { + /* Add everything. */ + this->result.symbols->push_back (*bsym); + + /* Continue iterating. */ + return true; + } +}; + /* Token types */ enum ls_token_type @@ -352,17 +360,17 @@ static std::vector decode_objc (struct linespec_state *self, static symtab_vector_up symtabs_from_filename (const char *, struct program_space *pspace); -static std::vector *find_label_symbols - (struct linespec_state *self, std::vector *function_symbols, - std::vector *label_funcs_ret, const char *name, +static std::vector *find_label_symbols + (struct linespec_state *self, std::vector *function_symbols, + std::vector *label_funcs_ret, const char *name, bool completion_mode = false); static void find_linespec_symbols (struct linespec_state *self, std::vector *file_symtabs, const char *name, symbol_name_match_type name_match_type, - std::vector *symbols, - VEC (bound_minimal_symbol_d) **minsyms); + std::vector *symbols, + std::vector *minsyms); static struct line_offset linespec_parse_variable (struct linespec_state *self, @@ -400,11 +408,10 @@ static void minsym_found (struct linespec_state *self, struct objfile *objfile, struct minimal_symbol *msymbol, std::vector *result); -static int compare_symbols (const void *a, const void *b); -static bool std_compare_symbols (const struct symbol *a, - const struct symbol *b); +static bool compare_symbols (const block_symbol &a, const block_symbol &b); -static int compare_msymbols (const void *a, const void *b); +static bool compare_msymbols (const bound_minimal_symbol &a, + const bound_minimal_symbol &b); /* Permitted quote characters for the parser. This is different from the completer's quote characters to allow backward compatibility with the @@ -786,16 +793,16 @@ linespec_lexer_lex_string (linespec_parser *parser) == language_cplus) && (PARSER_STREAM (parser) - start) >= CP_OPERATOR_LEN) { - const char *p = PARSER_STREAM (parser); + const char *op = PARSER_STREAM (parser); - while (p > start && isspace (p[-1])) - p--; - if (p - start >= CP_OPERATOR_LEN) + while (op > start && isspace (op[-1])) + op--; + if (op - start >= CP_OPERATOR_LEN) { - p -= CP_OPERATOR_LEN; - if (strncmp (p, CP_OPERATOR_STR, CP_OPERATOR_LEN) == 0 - && (p == start - || !(isalnum (p[-1]) || p[-1] == '_'))) + op -= CP_OPERATOR_LEN; + if (strncmp (op, CP_OPERATOR_STR, CP_OPERATOR_LEN) == 0 + && (op == start + || !(isalnum (op[-1]) || op[-1] == '_'))) { /* This is an operator name. Keep going. */ ++(PARSER_STREAM (parser)); @@ -806,15 +813,15 @@ linespec_lexer_lex_string (linespec_parser *parser) } } - const char *p = find_parameter_list_end (PARSER_STREAM (parser)); - PARSER_STREAM (parser) = p; + const char *end = find_parameter_list_end (PARSER_STREAM (parser)); + PARSER_STREAM (parser) = end; /* Don't loop around to the normal \0 case above because we don't want to misinterpret a potential keyword at the end of the token when the string isn't "()<>"-balanced. This handles "b function(thread" in completion mode. */ - if (*p == '\0') + if (*end == '\0') { LS_TOKEN_STOKEN (token).ptr = start; LS_TOKEN_STOKEN (token).length @@ -832,9 +839,9 @@ linespec_lexer_lex_string (linespec_parser *parser) == language_cplus) && (PARSER_STREAM (parser) - start) > CP_OPERATOR_LEN) { - const char *p = strstr (start, CP_OPERATOR_STR); + const char *op = strstr (start, CP_OPERATOR_STR); - if (p != NULL && is_operator_name (p)) + if (op != NULL && is_operator_name (op)) { /* This is an operator name. Keep going. */ ++(PARSER_STREAM (parser)); @@ -1158,12 +1165,12 @@ iterate_over_all_matching_symtabs { block = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab), i); state->language->la_iterate_over_symbols - (block, lookup_name, name_domain, [&] (symbol *sym) + (block, lookup_name, name_domain, [&] (block_symbol *bsym) { /* Restrict calls to CALLBACK to symbols representing inline symbols only. */ - if (SYMBOL_INLINED (sym)) - return callback (sym); + if (SYMBOL_INLINED (bsym->symbol)) + return callback (bsym); return true; }); } @@ -1768,9 +1775,9 @@ linespec_parse_basic (linespec_parser *parser) { gdb::unique_xmalloc_ptr name; linespec_token token; - std::vector symbols; - std::vector *labels; - VEC (bound_minimal_symbol_d) *minimal_symbols; + std::vector symbols; + std::vector *labels; + std::vector minimal_symbols; /* Get the next token. */ token = linespec_lexer_lex_one (parser); @@ -1873,11 +1880,13 @@ linespec_parse_basic (linespec_parser *parser) PARSER_EXPLICIT (parser)->func_name_match_type, &symbols, &minimal_symbols); - if (!symbols.empty () || minimal_symbols != NULL) + if (!symbols.empty () || !minimal_symbols.empty ()) { PARSER_RESULT (parser)->function_symbols - = new std::vector (std::move (symbols)); - PARSER_RESULT (parser)->minimal_symbols = minimal_symbols; + = new std::vector (std::move (symbols)); + PARSER_RESULT (parser)->minimal_symbols + = new std::vector + (std::move (minimal_symbols)); PARSER_EXPLICIT (parser)->function_name = name.release (); } else @@ -1890,7 +1899,7 @@ linespec_parse_basic (linespec_parser *parser) { PARSER_RESULT (parser)->labels.label_symbols = labels; PARSER_RESULT (parser)->labels.function_symbols - = new std::vector (std::move (symbols)); + = new std::vector (std::move (symbols)); PARSER_EXPLICIT (parser)->label_name = name.release (); } else if (token.type == LSTOKEN_STRING @@ -1996,7 +2005,7 @@ linespec_parse_basic (linespec_parser *parser) { PARSER_RESULT (parser)->labels.label_symbols = labels; PARSER_RESULT (parser)->labels.function_symbols - = new std::vector (std::move (symbols)); + = new std::vector (std::move (symbols)); PARSER_EXPLICIT (parser)->label_name = name.release (); } else @@ -2066,8 +2075,9 @@ canonicalize_linespec (struct linespec_state *state, const linespec_p ls) /* No function was specified, so add the symbol name. */ gdb_assert (!ls->labels.function_symbols->empty () && (ls->labels.function_symbols->size () == 1)); - struct symbol *s = ls->labels.function_symbols->front (); - explicit_loc->function_name = xstrdup (SYMBOL_NATURAL_NAME (s)); + block_symbol s = ls->labels.function_symbols->front (); + explicit_loc->function_name + = xstrdup (SYMBOL_NATURAL_NAME (s.symbol)); } } @@ -2243,15 +2253,17 @@ convert_linespec_to_sals (struct linespec_state *state, linespec_p ls) if (ls->labels.label_symbols != NULL) { /* We have just a bunch of functions/methods or labels. */ + struct symtab_and_line sal; + for (const auto &sym : *ls->labels.label_symbols) { - struct symtab_and_line sal; - struct program_space *pspace = SYMTAB_PSPACE (symbol_symtab (sym)); + struct program_space *pspace + = SYMTAB_PSPACE (symbol_symtab (sym.symbol)); - if (symbol_to_sal (&sal, state->funfirstline, sym) + if (symbol_to_sal (&sal, state->funfirstline, sym.symbol) && maybe_add_address (state->addr_set, pspace, sal.pc)) add_sal_to_sals (state, &sals, &sal, - SYMBOL_NATURAL_NAME (sym), 0); + SYMBOL_NATURAL_NAME (sym.symbol), 0); } } else if (ls->function_symbols != NULL || ls->minimal_symbols != NULL) @@ -2263,11 +2275,12 @@ convert_linespec_to_sals (struct linespec_state *state, linespec_p ls) to each other. */ std::sort (ls->function_symbols->begin (), ls->function_symbols->end (), - std_compare_symbols); + compare_symbols); for (const auto &sym : *ls->function_symbols) { - program_space *pspace = SYMTAB_PSPACE (symbol_symtab (sym)); + program_space *pspace + = SYMTAB_PSPACE (symbol_symtab (sym.symbol)); set_current_program_space (pspace); /* Don't skip to the first line of the function if we @@ -2278,25 +2291,21 @@ convert_linespec_to_sals (struct linespec_state *state, linespec_p ls) if (state->funfirstline && ls->minimal_symbols != NULL - && SYMBOL_CLASS (sym) == LOC_BLOCK) + && SYMBOL_CLASS (sym.symbol) == LOC_BLOCK) { const CORE_ADDR addr - = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)); + = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym.symbol)); - bound_minimal_symbol_d *elem; - for (int m = 0; - VEC_iterate (bound_minimal_symbol_d, ls->minimal_symbols, - m, elem); - ++m) + for (const auto &elem : *ls->minimal_symbols) { - if (MSYMBOL_TYPE (elem->minsym) == mst_text_gnu_ifunc - || MSYMBOL_TYPE (elem->minsym) == mst_data_gnu_ifunc) + if (MSYMBOL_TYPE (elem.minsym) == mst_text_gnu_ifunc + || MSYMBOL_TYPE (elem.minsym) == mst_data_gnu_ifunc) { - CORE_ADDR msym_addr = BMSYMBOL_VALUE_ADDRESS (*elem); - if (MSYMBOL_TYPE (elem->minsym) == mst_data_gnu_ifunc) + CORE_ADDR msym_addr = BMSYMBOL_VALUE_ADDRESS (elem); + if (MSYMBOL_TYPE (elem.minsym) == mst_data_gnu_ifunc) { struct gdbarch *gdbarch - = get_objfile_arch (elem->objfile); + = get_objfile_arch (elem.objfile); msym_addr = (gdbarch_convert_from_func_ptr_addr (gdbarch, @@ -2316,10 +2325,10 @@ convert_linespec_to_sals (struct linespec_state *state, linespec_p ls) if (!found_ifunc) { symtab_and_line sal; - if (symbol_to_sal (&sal, state->funfirstline, sym) + if (symbol_to_sal (&sal, state->funfirstline, sym.symbol) && maybe_add_address (state->addr_set, pspace, sal.pc)) add_sal_to_sals (state, &sals, &sal, - SYMBOL_NATURAL_NAME (sym), 0); + SYMBOL_NATURAL_NAME (sym.symbol), 0); } } } @@ -2327,20 +2336,15 @@ convert_linespec_to_sals (struct linespec_state *state, linespec_p ls) if (ls->minimal_symbols != NULL) { /* Sort minimal symbols by program space, too */ - qsort (VEC_address (bound_minimal_symbol_d, ls->minimal_symbols), - VEC_length (bound_minimal_symbol_d, ls->minimal_symbols), - sizeof (bound_minimal_symbol_d), compare_msymbols); - - bound_minimal_symbol_d *elem; + std::sort (ls->minimal_symbols->begin (), + ls->minimal_symbols->end (), + compare_msymbols); - for (int i = 0; - VEC_iterate (bound_minimal_symbol_d, ls->minimal_symbols, - i, elem); - ++i) + for (const auto &elem : *ls->minimal_symbols) { - program_space *pspace = elem->objfile->pspace; + program_space *pspace = elem.objfile->pspace; set_current_program_space (pspace); - minsym_found (state, elem->objfile, elem->minsym, &sals); + minsym_found (state, elem.objfile, elem.minsym, &sals); } } } @@ -2387,9 +2391,9 @@ convert_explicit_location_to_linespec (struct linespec_state *self, const char *label_name, struct line_offset line_offset) { - std::vector symbols; - std::vector *labels; - VEC (bound_minimal_symbol_d) *minimal_symbols; + std::vector symbols; + std::vector *labels; + std::vector minimal_symbols; result->explicit_loc.func_name_match_type = fname_match_type; @@ -2420,14 +2424,15 @@ convert_explicit_location_to_linespec (struct linespec_state *self, function_name, fname_match_type, &symbols, &minimal_symbols); - if (symbols.empty () && minimal_symbols == NULL) + if (symbols.empty () && minimal_symbols.empty ()) symbol_not_found_error (function_name, result->explicit_loc.source_filename); result->explicit_loc.function_name = xstrdup (function_name); result->function_symbols - = new std::vector (std::move (symbols)); - result->minimal_symbols = minimal_symbols; + = new std::vector (std::move (symbols)); + result->minimal_symbols + = new std::vector (std::move (minimal_symbols)); } if (label_name != NULL) @@ -2442,7 +2447,7 @@ convert_explicit_location_to_linespec (struct linespec_state *self, result->explicit_loc.label_name = xstrdup (label_name); result->labels.label_symbols = labels; result->labels.function_symbols - = new std::vector (std::move (symbols)); + = new std::vector (std::move (symbols)); } if (line_offset.sign != LINE_OFFSET_UNKNOWN) @@ -2778,10 +2783,7 @@ linespec_parser_delete (void *arg) delete PARSER_RESULT (parser)->file_symtabs; delete PARSER_RESULT (parser)->function_symbols; - - if (PARSER_RESULT (parser)->minimal_symbols != NULL) - VEC_free (bound_minimal_symbol_d, PARSER_RESULT (parser)->minimal_symbols); - + delete PARSER_RESULT (parser)->minimal_symbols; delete PARSER_RESULT (parser)->labels.label_symbols; delete PARSER_RESULT (parser)->labels.function_symbols; @@ -2916,8 +2918,8 @@ complete_label (completion_tracker &tracker, linespec_parser *parser, const char *label_name) { - std::vector label_function_symbols; - std::vector *labels + std::vector label_function_symbols; + std::vector *labels = find_label_symbols (PARSER_STATE (parser), PARSER_RESULT (parser)->function_symbols, &label_function_symbols, @@ -2927,7 +2929,7 @@ complete_label (completion_tracker &tracker, { for (const auto &label : *labels) { - char *match = xstrdup (SYMBOL_SEARCH_NAME (label)); + char *match = xstrdup (SYMBOL_SEARCH_NAME (label.symbol)); tracker.add_completion (gdb::unique_xmalloc_ptr (match)); } delete labels; @@ -3040,16 +3042,17 @@ linespec_complete (completion_tracker &tracker, const char *text, const char *func_name = PARSER_EXPLICIT (&parser)->function_name; - std::vector function_symbols; - VEC (bound_minimal_symbol_d) *minimal_symbols; + std::vector function_symbols; + std::vector minimal_symbols; find_linespec_symbols (PARSER_STATE (&parser), PARSER_RESULT (&parser)->file_symtabs, func_name, match_type, &function_symbols, &minimal_symbols); PARSER_RESULT (&parser)->function_symbols - = new std::vector (std::move (function_symbols)); - PARSER_RESULT (&parser)->minimal_symbols = minimal_symbols; + = new std::vector (std::move (function_symbols)); + PARSER_RESULT (&parser)->minimal_symbols + = new std::vector (std::move (minimal_symbols)); complete_label (tracker, &parser, parser.completion_word); } @@ -3447,9 +3450,10 @@ decode_objc (struct linespec_state *self, linespec_p ls, const char *arg) info.file_symtabs = &symtabs; - std::vector symbols; + std::vector symbols; info.result.symbols = &symbols; - info.result.minimal_symbols = NULL; + std::vector minimal_symbols; + info.result.minimal_symbols = &minimal_symbols; new_argptr = find_imps (arg, &symbol_names); if (symbol_names.empty ()) @@ -3459,8 +3463,7 @@ decode_objc (struct linespec_state *self, linespec_p ls, const char *arg) FUNCTIONS_DOMAIN); std::vector values; - if (!symbols.empty () - || !VEC_empty (bound_minimal_symbol_d, info.result.minimal_symbols)) + if (!symbols.empty () || !minimal_symbols.empty ()) { char *saved_arg; @@ -3469,8 +3472,10 @@ decode_objc (struct linespec_state *self, linespec_p ls, const char *arg) saved_arg[new_argptr - arg] = '\0'; ls->explicit_loc.function_name = xstrdup (saved_arg); - ls->function_symbols = new std::vector (std::move (symbols)); - ls->minimal_symbols = info.result.minimal_symbols; + ls->function_symbols + = new std::vector (std::move (symbols)); + ls->minimal_symbols + = new std::vector (std::move (minimal_symbols)); values = convert_linespec_to_sals (self, ls); if (self->canonical) @@ -3507,7 +3512,6 @@ class decode_compound_collector { public: decode_compound_collector () - : m_symbols (NULL) { m_unique_syms = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer, NULL, @@ -3520,16 +3524,14 @@ public: htab_delete (m_unique_syms); } - /* Releases ownership of the collected symbols and returns them. */ - VEC (symbolp) *release_symbols () + /* Return all symbols collected. */ + std::vector release_symbols () { - VEC (symbolp) *res = m_symbols; - m_symbols = NULL; - return res; + return std::move (m_symbols); } /* Callable as a symbol_found_callback_ftype callback. */ - bool operator () (symbol *sym); + bool operator () (block_symbol *bsym); private: /* A hash table of all symbols we found. We use this to avoid @@ -3537,14 +3539,15 @@ private: htab_t m_unique_syms; /* The result vector. */ - VEC (symbolp) *m_symbols; + std::vector m_symbols; }; bool -decode_compound_collector::operator () (symbol *sym) +decode_compound_collector::operator () (block_symbol *bsym) { void **slot; struct type *t; + struct symbol *sym = bsym->symbol; if (SYMBOL_CLASS (sym) != LOC_TYPEDEF) return true; /* Continue iterating. */ @@ -3560,7 +3563,7 @@ decode_compound_collector::operator () (symbol *sym) if (!*slot) { *slot = sym; - VEC_safe_push (symbolp, m_symbols, sym); + m_symbols.push_back (*bsym); } return true; /* Continue iterating. */ @@ -3570,7 +3573,7 @@ decode_compound_collector::operator () (symbol *sym) /* Return any symbols corresponding to CLASS_NAME in FILE_SYMTABS. */ -static VEC (symbolp) * +static std::vector lookup_prefix_sym (struct linespec_state *state, std::vector *file_symtabs, const char *class_name) @@ -3609,20 +3612,20 @@ lookup_prefix_sym (struct linespec_state *state, symbols with the same program space end up next to each other. */ static bool -std_compare_symbols (const struct symbol *a, const struct symbol *b) +compare_symbols (const block_symbol &a, const block_symbol &b) { uintptr_t uia, uib; - uia = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (a)); - uib = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (b)); + uia = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (a.symbol)); + uib = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (b.symbol)); if (uia < uib) return true; if (uia > uib) return false; - uia = (uintptr_t) a; - uib = (uintptr_t) b; + uia = (uintptr_t) a.symbol; + uib = (uintptr_t) b.symbol; if (uia < uib) return true; @@ -3630,64 +3633,28 @@ std_compare_symbols (const struct symbol *a, const struct symbol *b) return false; } -/* A qsort comparison function for symbols. The resulting order does - not actually matter; we just need to be able to sort them so that - symbols with the same program space end up next to each other. */ - -static int -compare_symbols (const void *a, const void *b) -{ - struct symbol * const *sa = (struct symbol * const*) a; - struct symbol * const *sb = (struct symbol * const*) b; - uintptr_t uia, uib; - - uia = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (*sa)); - uib = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (*sb)); - - if (uia < uib) - return -1; - if (uia > uib) - return 1; - - uia = (uintptr_t) *sa; - uib = (uintptr_t) *sb; - - if (uia < uib) - return -1; - if (uia > uib) - return 1; - - return 0; -} - /* Like compare_symbols but for minimal symbols. */ -static int -compare_msymbols (const void *a, const void *b) +static bool +compare_msymbols (const bound_minimal_symbol &a, const bound_minimal_symbol &b) { - const struct bound_minimal_symbol *sa - = (const struct bound_minimal_symbol *) a; - const struct bound_minimal_symbol *sb - = (const struct bound_minimal_symbol *) b; uintptr_t uia, uib; - uia = (uintptr_t) sa->objfile->pspace; - uib = (uintptr_t) sa->objfile->pspace; + uia = (uintptr_t) a.objfile->pspace; + uib = (uintptr_t) a.objfile->pspace; if (uia < uib) - return -1; + return true; if (uia > uib) - return 1; + return false; - uia = (uintptr_t) sa->minsym; - uib = (uintptr_t) sb->minsym; + uia = (uintptr_t) a.minsym; + uib = (uintptr_t) b.minsym; if (uia < uib) - return -1; - if (uia > uib) - return 1; + return true; - return 0; + return false; } /* Look for all the matching instances of each symbol in NAMES. Only @@ -3735,11 +3702,10 @@ find_superclass_methods (std::vector &&superclasses, static void find_method (struct linespec_state *self, std::vector *file_symtabs, const char *class_name, const char *method_name, - VEC (symbolp) *sym_classes, std::vector *symbols, - VEC (bound_minimal_symbol_d) **minsyms) + std::vector *sym_classes, + std::vector *symbols, + std::vector *minsyms) { - struct symbol *sym; - int ix; size_t last_result_len; std::vector superclass_vec; std::vector result_names; @@ -3747,15 +3713,13 @@ find_method (struct linespec_state *self, std::vector *file_symtabs, /* Sort symbols so that symbols with the same program space are next to each other. */ - qsort (VEC_address (symbolp, sym_classes), - VEC_length (symbolp, sym_classes), - sizeof (symbolp), - compare_symbols); + std::sort (sym_classes->begin (), sym_classes->end (), + compare_symbols); info.state = self; info.file_symtabs = file_symtabs; info.result.symbols = symbols; - info.result.minimal_symbols = NULL; + info.result.minimal_symbols = minsyms; /* Iterate over all the types, looking for the names of existing methods matching METHOD_NAME. If we cannot find a direct method in a @@ -3767,10 +3731,12 @@ find_method (struct linespec_state *self, std::vector *file_symtabs, because we collect data across the program space before deciding what to do. */ last_result_len = 0; - for (ix = 0; VEC_iterate (symbolp, sym_classes, ix, sym); ++ix) + unsigned int ix = 0; + for (const auto &elt : *sym_classes) { struct type *t; struct program_space *pspace; + struct symbol *sym = elt.symbol; /* Program spaces that are executing startup should have been filtered out earlier. */ @@ -3783,10 +3749,9 @@ find_method (struct linespec_state *self, std::vector *file_symtabs, /* Handle all items from a single program space at once; and be sure not to miss the last batch. */ - if (ix == VEC_length (symbolp, sym_classes) - 1 + if (ix == sym_classes->size () - 1 || (pspace - != SYMTAB_PSPACE (symbol_symtab (VEC_index (symbolp, sym_classes, - ix + 1))))) + != SYMTAB_PSPACE (symbol_symtab (sym_classes->at (ix + 1).symbol)))) { /* If we did not find a direct implementation anywhere in this program space, consider superclasses. */ @@ -3802,15 +3767,12 @@ find_method (struct linespec_state *self, std::vector *file_symtabs, superclass_vec.clear (); last_result_len = result_names.size (); + ++ix; } } - if (!symbols->empty () - || !VEC_empty (bound_minimal_symbol_d, info.result.minimal_symbols)) - { - *minsyms = info.result.minimal_symbols; - return; - } + if (!symbols->empty () || !minsyms->empty ()) + return; /* Throw an NOT_FOUND_ERROR. This will be caught by the caller and other attempts to locate the symbol will be made. */ @@ -3929,6 +3891,36 @@ symtabs_from_filename (const char *filename, return result; } +/* See symtab.h. */ + +void +symbol_searcher::find_all_symbols (const std::string &name, + const struct language_defn *language, + enum search_domain search_domain, + std::vector *search_symtabs, + struct program_space *search_pspace) +{ + symbol_searcher_collect_info info; + struct linespec_state state; + + memset (&state, 0, sizeof (state)); + state.language = language; + info.state = &state; + + info.result.symbols = &m_symbols; + info.result.minimal_symbols = &m_minimal_symbols; + std::vector all_symtabs; + if (search_symtabs == nullptr) + { + all_symtabs.push_back (nullptr); + search_symtabs = &all_symtabs; + } + info.file_symtabs = search_symtabs; + + add_matching_symbols_to_info (name.c_str (), symbol_name_match_type::WILD, + search_domain, &info, search_pspace); +} + /* Look up a function symbol named NAME in symtabs FILE_SYMTABS. Matching debug symbols are returned in SYMBOLS. Matching minimal symbols are returned in MINSYMS. */ @@ -3937,15 +3929,15 @@ static void find_function_symbols (struct linespec_state *state, std::vector *file_symtabs, const char *name, symbol_name_match_type name_match_type, - std::vector *symbols, - VEC (bound_minimal_symbol_d) **minsyms) + std::vector *symbols, + std::vector *minsyms) { struct collect_info info; std::vector symbol_names; info.state = state; info.result.symbols = symbols; - info.result.minimal_symbols = NULL; + info.result.minimal_symbols = minsyms; info.file_symtabs = file_symtabs; /* Try NAME as an Objective-C selector. */ @@ -3956,14 +3948,6 @@ find_function_symbols (struct linespec_state *state, else add_matching_symbols_to_info (name, name_match_type, FUNCTIONS_DOMAIN, &info, state->search_pspace); - - if (VEC_empty (bound_minimal_symbol_d, info.result.minimal_symbols)) - { - VEC_free (bound_minimal_symbol_d, info.result.minimal_symbols); - *minsyms = NULL; - } - else - *minsyms = info.result.minimal_symbols; } /* Find all symbols named NAME in FILE_SYMTABS, returning debug symbols @@ -3974,8 +3958,8 @@ find_linespec_symbols (struct linespec_state *state, std::vector *file_symtabs, const char *lookup_name, symbol_name_match_type name_match_type, - std::vector *symbols, - VEC (bound_minimal_symbol_d) **minsyms) + std::vector *symbols, + std::vector *minsyms) { std::string canon = cp_canonicalize_string_no_typedefs (lookup_name); if (!canon.empty ()) @@ -3996,12 +3980,10 @@ find_linespec_symbols (struct linespec_state *state, /* If we were unable to locate a symbol of the same name, try dividing the name into class and method names and searching the class and its baseclasses. */ - if (symbols->empty () - && VEC_empty (bound_minimal_symbol_d, *minsyms)) + if (symbols->empty () && minsyms->empty ()) { std::string klass, method; const char *last, *p, *scope_op; - VEC (symbolp) *classes; /* See if we can find a scope operator and break this symbol name into namespaces${SCOPE_OPERATOR}class_name and method_name. */ @@ -4030,18 +4012,16 @@ find_linespec_symbols (struct linespec_state *state, method = last; /* Find a list of classes named KLASS. */ - classes = lookup_prefix_sym (state, file_symtabs, klass.c_str ()); - struct cleanup *old_chain - = make_cleanup (VEC_cleanup (symbolp), &classes); - - if (!VEC_empty (symbolp, classes)) + std::vector classes + = lookup_prefix_sym (state, file_symtabs, klass.c_str ()); + if (!classes.empty ()) { /* Now locate a list of suitable methods named METHOD. */ TRY { find_method (state, file_symtabs, klass.c_str (), method.c_str (), - classes, symbols, minsyms); + &classes, symbols, minsyms); } /* If successful, we're done. If NOT_FOUND_ERROR @@ -4053,8 +4033,6 @@ find_linespec_symbols (struct linespec_state *state, } END_CATCH } - - do_cleanups (old_chain); } } @@ -4069,8 +4047,8 @@ static void find_label_symbols_in_block (const struct block *block, const char *name, struct symbol *fn_sym, bool completion_mode, - std::vector *result, - std::vector *label_funcs_ret) + std::vector *result, + std::vector *label_funcs_ret) { if (completion_mode) { @@ -4087,19 +4065,20 @@ find_label_symbols_in_block (const struct block *block, SYMBOL_DOMAIN (sym), LABEL_DOMAIN) && cmp (SYMBOL_SEARCH_NAME (sym), name, name_len) == 0) { - result->push_back (sym); - label_funcs_ret->push_back (fn_sym); + result->push_back ({sym, block}); + label_funcs_ret->push_back ({fn_sym, block}); } } } else { - struct symbol *sym = lookup_symbol (name, block, LABEL_DOMAIN, 0).symbol; + struct block_symbol label_sym + = lookup_symbol (name, block, LABEL_DOMAIN, 0); - if (sym != NULL) + if (label_sym.symbol != NULL) { - result->push_back (sym); - label_funcs_ret->push_back (fn_sym); + result->push_back (label_sym); + label_funcs_ret->push_back ({fn_sym, block}); } } } @@ -4112,15 +4091,17 @@ find_label_symbols_in_block (const struct block *block, interpreted as a label name prefix. Otherwise, only labels named exactly NAME match. */ -static std::vector * + +static std::vector * find_label_symbols (struct linespec_state *self, - std::vector *function_symbols, - std::vector *label_funcs_ret, const char *name, + std::vector *function_symbols, + std::vector *label_funcs_ret, + const char *name, bool completion_mode) { const struct block *block; struct symbol *fn_sym; - std::vector result; + std::vector result; if (function_symbols == NULL) { @@ -4142,16 +4123,17 @@ find_label_symbols (struct linespec_state *self, { for (const auto &elt : *function_symbols) { - set_current_program_space (SYMTAB_PSPACE (symbol_symtab (elt))); - block = SYMBOL_BLOCK_VALUE (elt); + fn_sym = elt.symbol; + set_current_program_space (SYMTAB_PSPACE (symbol_symtab (fn_sym))); + block = SYMBOL_BLOCK_VALUE (fn_sym); - find_label_symbols_in_block (block, name, elt, completion_mode, + find_label_symbols_in_block (block, name, fn_sym, completion_mode, &result, label_funcs_ret); } } if (!result.empty ()) - return new std::vector (std::move (result)); + return new std::vector (std::move (result)); return nullptr; } @@ -4472,8 +4454,7 @@ search_minsyms_for_name (struct collect_info *info, if (classify_mtype (MSYMBOL_TYPE (item.minsym)) != classification) break; - VEC_safe_push (bound_minimal_symbol_d, - info->result.minimal_symbols, &item); + info->result.minimal_symbols->push_back (item); } } } @@ -4497,8 +4478,9 @@ add_matching_symbols_to_info (const char *name, { iterate_over_all_matching_symtabs (info->state, lookup_name, VAR_DOMAIN, search_domain, - pspace, true, [&] (symbol *sym) - { return info->add_symbol (sym); }); + pspace, true, + [&] (block_symbol *bsym) + { return info->add_symbol (bsym); }); search_minsyms_for_name (info, lookup_name, pspace, NULL); } else if (pspace == NULL || pspace == SYMTAB_PSPACE (elt)) @@ -4510,8 +4492,8 @@ add_matching_symbols_to_info (const char *name, gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup); set_current_program_space (SYMTAB_PSPACE (elt)); iterate_over_file_blocks (elt, lookup_name, VAR_DOMAIN, - [&] (symbol *sym) - { return info->add_symbol (sym); }); + [&] (block_symbol *bsym) + { return info->add_symbol (bsym); }); /* If no new symbols were found in this iteration and this symtab is in assembler, we might actually be looking for a label for