KEYWORD,
};
-typedef struct symbol *symbolp;
-DEF_VEC_P (symbolp);
+/* Typedef for unique_ptrs of vectors of symtabs. */
+
+typedef std::unique_ptr<std::vector<symtab *>> symtab_vector_up;
/* 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
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. */
be NULL. If explicit.SOURCE_FILENAME is NULL (no user-specified
filename), FILE_SYMTABS should contain one single NULL member. This
will cause the code to use the default symtab. */
- VEC (symtab_ptr) *file_symtabs;
+ std::vector<symtab *> *file_symtabs;
/* A list of matching function symbols and minimal symbols. Both lists
- may be NULL if no matching symbols were found. */
- VEC (symbolp) *function_symbols;
- VEC (bound_minimal_symbol_d) *minimal_symbols;
+ may be NULL (or empty) if no matching symbols were found. */
+ std::vector<block_symbol> *function_symbols;
+ std::vector<bound_minimal_symbol> *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
{
- VEC (symbolp) *label_symbols;
- VEC (symbolp) *function_symbols;
+ std::vector<block_symbol> *label_symbols;
+ std::vector<block_symbol> *function_symbols;
} labels;
};
typedef struct linespec *linespec_p;
struct linespec_state *state;
/* A list of symtabs to which to restrict matches. */
- VEC (symtab_ptr) *file_symtabs;
+ std::vector<symtab *> *file_symtabs;
/* The result being accumulated. */
struct
{
- VEC (symbolp) *symbols;
- VEC (bound_minimal_symbol_d) *minimal_symbols;
+ std::vector<block_symbol> *symbols;
+ std::vector<bound_minimal_symbol> *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)
- VEC_safe_push (symbolp, this->result.symbols, 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
linespec_p ls,
const char *arg);
-static VEC (symtab_ptr) *symtabs_from_filename (const char *,
- struct program_space *pspace);
+static symtab_vector_up symtabs_from_filename
+ (const char *, struct program_space *pspace);
-static VEC (symbolp) *find_label_symbols (struct linespec_state *self,
- VEC (symbolp) *function_symbols,
- VEC (symbolp) **label_funcs_ret,
- const char *name,
- bool completion_mode = false);
+static std::vector<block_symbol> *find_label_symbols
+ (struct linespec_state *self, std::vector<block_symbol> *function_symbols,
+ std::vector<block_symbol> *label_funcs_ret, const char *name,
+ bool completion_mode = false);
static void find_linespec_symbols (struct linespec_state *self,
- VEC (symtab_ptr) *file_symtabs,
+ std::vector<symtab *> *file_symtabs,
const char *name,
symbol_name_match_type name_match_type,
- VEC (symbolp) **symbols,
- VEC (bound_minimal_symbol_d) **minsyms);
+ std::vector<block_symbol> *symbols,
+ std::vector<bound_minimal_symbol> *minsyms);
static struct line_offset
linespec_parse_variable (struct linespec_state *self,
(struct collect_info *info, struct program_space *pspace,
const std::vector<const char *> &names, enum search_domain search_domain);
-static VEC (symtab_ptr) *
+static symtab_vector_up
collect_symtabs_from_filename (const char *file,
struct program_space *pspace);
struct minimal_symbol *msymbol,
std::vector<symtab_and_line> *result);
-static int compare_symbols (const void *a, const void *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
{
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;
});
}
{
prompt = "> ";
}
- args = command_line_input (prompt, 0, "overload-choice");
+ args = command_line_input (prompt, "overload-choice");
if (args == 0 || *args == 0)
error_no_arg (_("one or more choice numbers"));
{
gdb::unique_xmalloc_ptr<char> name;
linespec_token token;
- VEC (symbolp) *symbols, *labels;
- VEC (bound_minimal_symbol_d) *minimal_symbols;
+ std::vector<block_symbol> symbols;
+ std::vector<block_symbol> *labels;
+ std::vector<bound_minimal_symbol> minimal_symbols;
/* Get the next token. */
token = linespec_lexer_lex_one (parser);
PARSER_EXPLICIT (parser)->func_name_match_type,
&symbols, &minimal_symbols);
- if (symbols != NULL || minimal_symbols != NULL)
+ if (!symbols.empty () || !minimal_symbols.empty ())
{
- PARSER_RESULT (parser)->function_symbols = symbols;
- PARSER_RESULT (parser)->minimal_symbols = minimal_symbols;
+ PARSER_RESULT (parser)->function_symbols
+ = new std::vector<block_symbol> (std::move (symbols));
+ PARSER_RESULT (parser)->minimal_symbols
+ = new std::vector<bound_minimal_symbol>
+ (std::move (minimal_symbols));
PARSER_EXPLICIT (parser)->function_name = name.release ();
- symbols = NULL;
}
else
{
if (labels != NULL)
{
PARSER_RESULT (parser)->labels.label_symbols = labels;
- PARSER_RESULT (parser)->labels.function_symbols = symbols;
+ PARSER_RESULT (parser)->labels.function_symbols
+ = new std::vector<block_symbol> (std::move (symbols));
PARSER_EXPLICIT (parser)->label_name = name.release ();
- symbols = NULL;
}
else if (token.type == LSTOKEN_STRING
&& *LS_TOKEN_STOKEN (token).ptr == '$')
if (labels != NULL)
{
PARSER_RESULT (parser)->labels.label_symbols = labels;
- PARSER_RESULT (parser)->labels.function_symbols = symbols;
+ PARSER_RESULT (parser)->labels.function_symbols
+ = new std::vector<block_symbol> (std::move (symbols));
PARSER_EXPLICIT (parser)->label_name = name.release ();
- symbols = NULL;
}
else
{
if (explicit_loc->function_name == NULL)
{
- struct symbol *s;
-
/* No function was specified, so add the symbol name. */
- gdb_assert (ls->labels.function_symbols != NULL
- && (VEC_length (symbolp, ls->labels.function_symbols)
- == 1));
- s = VEC_index (symbolp, ls->labels.function_symbols, 0);
- explicit_loc->function_name = xstrdup (SYMBOL_NATURAL_NAME (s));
+ gdb_assert (!ls->labels.function_symbols->empty ()
+ && (ls->labels.function_symbols->size () == 1));
+ block_symbol s = ls->labels.function_symbols->front ();
+ explicit_loc->function_name
+ = xstrdup (SYMBOL_NATURAL_NAME (s.symbol));
}
}
set_default_source_symtab_and_line uses
select_source_symtab that calls us with such an argument. */
- if (VEC_length (symtab_ptr, ls->file_symtabs) == 1
- && VEC_index (symtab_ptr, ls->file_symtabs, 0) == NULL)
+ if (ls->file_symtabs->size () == 1
+ && ls->file_symtabs->front () == nullptr)
{
const char *fullname;
set_default_source_symtab_and_line ();
initialize_defaults (&self->default_symtab, &self->default_line);
fullname = symtab_to_fullname (self->default_symtab);
- VEC_pop (symtab_ptr, ls->file_symtabs);
- VEC_free (symtab_ptr, ls->file_symtabs);
- ls->file_symtabs = collect_symtabs_from_filename (fullname,
- self->search_pspace);
+ symtab_vector_up r =
+ collect_symtabs_from_filename (fullname, self->search_pspace);
+ ls->file_symtabs = r.release ();
use_default = 1;
}
if (ls->labels.label_symbols != NULL)
{
/* We have just a bunch of functions/methods or labels. */
- int i;
struct symtab_and_line sal;
- struct symbol *sym;
- for (i = 0; VEC_iterate (symbolp, ls->labels.label_symbols, i, sym); ++i)
+ for (const auto &sym : *ls->labels.label_symbols)
{
- 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)
{
/* Sort symbols so that symbols with the same program space are next
to each other. */
- qsort (VEC_address (symbolp, ls->function_symbols),
- VEC_length (symbolp, ls->function_symbols),
- sizeof (symbolp), compare_symbols);
+ std::sort (ls->function_symbols->begin (),
+ ls->function_symbols->end (),
+ compare_symbols);
- struct symbol *sym;
- for (int i = 0; VEC_iterate (symbolp, ls->function_symbols, i, sym); ++i)
+ 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
if (state->funfirstline
&& ls->minimal_symbols != NULL
- && SYMBOL_CLASS (sym) == LOC_BLOCK)
+ && SYMBOL_CLASS (sym.symbol) == LOC_BLOCK)
{
const CORE_ADDR addr
- = BLOCK_START (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,
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);
}
}
}
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);
}
}
}
const char *label_name,
struct line_offset line_offset)
{
- VEC (symbolp) *symbols, *labels;
- VEC (bound_minimal_symbol_d) *minimal_symbols;
+ std::vector<block_symbol> symbols;
+ std::vector<block_symbol> *labels;
+ std::vector<bound_minimal_symbol> minimal_symbols;
result->explicit_loc.func_name_match_type = fname_match_type;
TRY
{
result->file_symtabs
- = symtabs_from_filename (source_filename, self->search_pspace);
+ = symtabs_from_filename (source_filename,
+ self->search_pspace).release ();
}
CATCH (except, RETURN_MASK_ERROR)
{
else
{
/* A NULL entry means to use the default symtab. */
- VEC_safe_push (symtab_ptr, result->file_symtabs, NULL);
+ result->file_symtabs->push_back (nullptr);
}
if (function_name != NULL)
function_name, fname_match_type,
&symbols, &minimal_symbols);
- if (symbols == NULL && 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 = symbols;
- result->minimal_symbols = minimal_symbols;
+ result->function_symbols
+ = new std::vector<block_symbol> (std::move (symbols));
+ result->minimal_symbols
+ = new std::vector<bound_minimal_symbol> (std::move (minimal_symbols));
}
if (label_name != NULL)
{
- symbols = NULL;
labels = find_label_symbols (self, result->function_symbols,
&symbols, label_name);
result->explicit_loc.label_name = xstrdup (label_name);
result->labels.label_symbols = labels;
- result->labels.function_symbols = symbols;
+ result->labels.function_symbols
+ = new std::vector<block_symbol> (std::move (symbols));
}
if (line_offset.sign != LINE_OFFSET_UNKNOWN)
{
/* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
if (parser->completion_tracker == NULL)
- VEC_safe_push (symtab_ptr, PARSER_RESULT (parser)->file_symtabs, NULL);
+ PARSER_RESULT (parser)->file_symtabs->push_back (nullptr);
/* User specified a convenience variable or history value. */
gdb::unique_xmalloc_ptr<char> var = copy_token_string (token);
/* Check if the input is a filename. */
TRY
{
- PARSER_RESULT (parser)->file_symtabs
+ symtab_vector_up r
= symtabs_from_filename (user_filename.get (),
PARSER_STATE (parser)->search_pspace);
+ PARSER_RESULT (parser)->file_symtabs = r.release ();
}
CATCH (ex, RETURN_MASK_ERROR)
{
else
{
/* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
- VEC_safe_push (symtab_ptr, PARSER_RESULT (parser)->file_symtabs, NULL);
+ PARSER_RESULT (parser)->file_symtabs->push_back (nullptr);
}
}
/* If the next token is not EOI, KEYWORD, or COMMA, issue an error. */
else
{
/* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
- VEC_safe_push (symtab_ptr, PARSER_RESULT (parser)->file_symtabs, NULL);
+ PARSER_RESULT (parser)->file_symtabs->push_back (nullptr);
}
/* Parse the rest of the linespec. */
memset (parser, 0, sizeof (linespec_parser));
parser->lexer.current.type = LSTOKEN_CONSUMED;
memset (PARSER_RESULT (parser), 0, sizeof (struct linespec));
+ PARSER_RESULT (parser)->file_symtabs = new std::vector<symtab *> ();
PARSER_EXPLICIT (parser)->func_name_match_type
= symbol_name_match_type::WILD;
PARSER_EXPLICIT (parser)->line_offset.sign = LINE_OFFSET_UNKNOWN;
xfree (PARSER_EXPLICIT (parser)->label_name);
xfree (PARSER_EXPLICIT (parser)->function_name);
- if (PARSER_RESULT (parser)->file_symtabs != NULL)
- VEC_free (symtab_ptr, PARSER_RESULT (parser)->file_symtabs);
-
- if (PARSER_RESULT (parser)->function_symbols != NULL)
- VEC_free (symbolp, PARSER_RESULT (parser)->function_symbols);
-
- if (PARSER_RESULT (parser)->minimal_symbols != NULL)
- VEC_free (bound_minimal_symbol_d, PARSER_RESULT (parser)->minimal_symbols);
-
- if (PARSER_RESULT (parser)->labels.label_symbols != NULL)
- VEC_free (symbolp, PARSER_RESULT (parser)->labels.label_symbols);
-
- if (PARSER_RESULT (parser)->labels.function_symbols != NULL)
- VEC_free (symbolp, PARSER_RESULT (parser)->labels.function_symbols);
+ delete PARSER_RESULT (parser)->file_symtabs;
+ delete PARSER_RESULT (parser)->function_symbols;
+ delete PARSER_RESULT (parser)->minimal_symbols;
+ delete PARSER_RESULT (parser)->labels.label_symbols;
+ delete PARSER_RESULT (parser)->labels.function_symbols;
linespec_state_destructor (PARSER_STATE (parser));
}
new "quote" char. */
if (tracker.quote_char ())
{
- char quote_char_str[2] = { tracker.quote_char () };
+ char quote_char_str[2] = { (char) tracker.quote_char () };
fn = reconcat (fn, fn, quote_char_str, (char *) NULL);
tracker.set_quote_char (':');
linespec_parser *parser,
const char *label_name)
{
- VEC (symbolp) *label_function_symbols = NULL;
- VEC (symbolp) *labels
+ std::vector<block_symbol> label_function_symbols;
+ std::vector<block_symbol> *labels
= find_label_symbols (PARSER_STATE (parser),
PARSER_RESULT (parser)->function_symbols,
&label_function_symbols,
label_name, true);
- symbol *label;
- for (int ix = 0;
- VEC_iterate (symbolp, labels, ix, label); ++ix)
+ if (labels != nullptr)
{
- char *match = xstrdup (SYMBOL_SEARCH_NAME (label));
- tracker.add_completion (gdb::unique_xmalloc_ptr<char> (match));
+ for (const auto &label : *labels)
+ {
+ char *match = xstrdup (SYMBOL_SEARCH_NAME (label.symbol));
+ tracker.add_completion (gdb::unique_xmalloc_ptr<char> (match));
+ }
+ delete labels;
}
- VEC_free (symbolp, labels);
}
/* See linespec.h. */
const char *func_name = PARSER_EXPLICIT (&parser)->function_name;
- VEC (symbolp) *function_symbols;
- VEC (bound_minimal_symbol_d) *minimal_symbols;
+ std::vector<block_symbol> function_symbols;
+ std::vector<bound_minimal_symbol> 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 = function_symbols;
- PARSER_RESULT (&parser)->minimal_symbols = minimal_symbols;
+ PARSER_RESULT (&parser)->function_symbols
+ = new std::vector<block_symbol> (std::move (function_symbols));
+ PARSER_RESULT (&parser)->minimal_symbols
+ = new std::vector<bound_minimal_symbol> (std::move (minimal_symbols));
complete_label (tracker, &parser, parser.completion_word);
}
const char *new_argptr;
info.state = self;
- info.file_symtabs = NULL;
- VEC_safe_push (symtab_ptr, info.file_symtabs, NULL);
- struct cleanup *cleanup = make_cleanup (VEC_cleanup (symtab_ptr),
- &info.file_symtabs);
- info.result.symbols = NULL;
- info.result.minimal_symbols = NULL;
+ std::vector<symtab *> symtabs;
+ symtabs.push_back (nullptr);
+
+ info.file_symtabs = &symtabs;
+
+ std::vector<block_symbol> symbols;
+ info.result.symbols = &symbols;
+ std::vector<bound_minimal_symbol> minimal_symbols;
+ info.result.minimal_symbols = &minimal_symbols;
new_argptr = find_imps (arg, &symbol_names);
if (symbol_names.empty ())
- {
- do_cleanups (cleanup);
- return {};
- }
+ return {};
add_all_symbol_names_from_pspace (&info, NULL, symbol_names,
FUNCTIONS_DOMAIN);
std::vector<symtab_and_line> values;
- if (!VEC_empty (symbolp, info.result.symbols)
- || !VEC_empty (bound_minimal_symbol_d, info.result.minimal_symbols))
+ if (!symbols.empty () || !minimal_symbols.empty ())
{
char *saved_arg;
saved_arg[new_argptr - arg] = '\0';
ls->explicit_loc.function_name = xstrdup (saved_arg);
- ls->function_symbols = info.result.symbols;
- ls->minimal_symbols = info.result.minimal_symbols;
+ ls->function_symbols
+ = new std::vector<block_symbol> (std::move (symbols));
+ ls->minimal_symbols
+ = new std::vector<bound_minimal_symbol> (std::move (minimal_symbols));
values = convert_linespec_to_sals (self, ls);
if (self->canonical)
}
}
- do_cleanups (cleanup);
-
return values;
}
{
public:
decode_compound_collector ()
- : m_symbols (NULL)
{
m_unique_syms = htab_create_alloc (1, htab_hash_pointer,
htab_eq_pointer, NULL,
htab_delete (m_unique_syms);
}
- /* Releases ownership of the collected symbols and returns them. */
- VEC (symbolp) *release_symbols ()
+ /* Return all symbols collected. */
+ std::vector<block_symbol> 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
htab_t m_unique_syms;
/* The result vector. */
- VEC (symbolp) *m_symbols;
+ std::vector<block_symbol> 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. */
if (!*slot)
{
*slot = sym;
- VEC_safe_push (symbolp, m_symbols, sym);
+ m_symbols.push_back (*bsym);
}
return true; /* Continue iterating. */
/* Return any symbols corresponding to CLASS_NAME in FILE_SYMTABS. */
-static VEC (symbolp) *
-lookup_prefix_sym (struct linespec_state *state, VEC (symtab_ptr) *file_symtabs,
+static std::vector<block_symbol>
+lookup_prefix_sym (struct linespec_state *state,
+ std::vector<symtab *> *file_symtabs,
const char *class_name)
{
- int ix;
- struct symtab *elt;
decode_compound_collector collector;
lookup_name_info lookup_name (class_name, symbol_name_match_type::FULL);
- for (ix = 0; VEC_iterate (symtab_ptr, file_symtabs, ix, elt); ++ix)
+ for (const auto &elt : *file_symtabs)
{
- if (elt == NULL)
+ if (elt == nullptr)
{
iterate_over_all_matching_symtabs (state, lookup_name,
STRUCT_DOMAIN, ALL_DOMAIN,
return collector.release_symbols ();
}
-/* A qsort comparison function for symbols. The resulting order does
+/* A std::sort 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)
+static bool
+compare_symbols (const block_symbol &a, const block_symbol &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));
+ uia = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (a.symbol));
+ uib = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (b.symbol));
if (uia < uib)
- return -1;
+ return true;
if (uia > uib)
- return 1;
+ return false;
- uia = (uintptr_t) *sa;
- uib = (uintptr_t) *sb;
+ uia = (uintptr_t) a.symbol;
+ uib = (uintptr_t) b.symbol;
if (uia < uib)
- return -1;
- if (uia > uib)
- return 1;
+ return true;
- return 0;
+ return false;
}
/* 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
in SYMBOLS (for debug symbols) and MINSYMS (for minimal symbols). */
static void
-find_method (struct linespec_state *self, VEC (symtab_ptr) *file_symtabs,
+find_method (struct linespec_state *self, std::vector<symtab *> *file_symtabs,
const char *class_name, const char *method_name,
- VEC (symbolp) *sym_classes, VEC (symbolp) **symbols,
- VEC (bound_minimal_symbol_d) **minsyms)
+ std::vector<block_symbol> *sym_classes,
+ std::vector<block_symbol> *symbols,
+ std::vector<bound_minimal_symbol> *minsyms)
{
- struct symbol *sym;
- int ix;
size_t last_result_len;
std::vector<struct type *> superclass_vec;
std::vector<const char *> result_names;
/* 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 = NULL;
- info.result.minimal_symbols = NULL;
+ info.result.symbols = symbols;
+ 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
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. */
/* 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. */
superclass_vec.clear ();
last_result_len = result_names.size ();
+ ++ix;
}
}
- if (!VEC_empty (symbolp, info.result.symbols)
- || !VEC_empty (bound_minimal_symbol_d, info.result.minimal_symbols))
- {
- *symbols = info.result.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. */
{
public:
symtab_collector ()
+ : m_symtabs (new std::vector<symtab *> ())
{
- m_symtabs = NULL;
m_symtab_table = htab_create (1, htab_hash_pointer, htab_eq_pointer,
NULL);
}
bool operator () (symtab *sym);
/* Releases ownership of the collected symtabs and returns them. */
- VEC (symtab_ptr) *release_symtabs ()
+ symtab_vector_up release_symtabs ()
{
- VEC (symtab_ptr) *res = m_symtabs;
- m_symtabs = NULL;
- return res;
+ return std::move (m_symtabs);
}
private:
/* The result vector of symtabs. */
- VEC (symtab_ptr) *m_symtabs;
+ symtab_vector_up m_symtabs;
/* This is used to ensure the symtabs are unique. */
htab_t m_symtab_table;
if (!*slot)
{
*slot = symtab;
- VEC_safe_push (symtab_ptr, m_symtabs, symtab);
+ m_symtabs->push_back (symtab);
}
return false;
} // namespace
-/* Given a file name, return a VEC of all matching symtabs. If
+/* Given a file name, return a list of all matching symtabs. If
SEARCH_PSPACE is not NULL, the search is restricted to just that
program space. */
-static VEC (symtab_ptr) *
+static symtab_vector_up
collect_symtabs_from_filename (const char *file,
struct program_space *search_pspace)
{
/* Return all the symtabs associated to the FILENAME. If SEARCH_PSPACE is
not NULL, the search is restricted to just that program space. */
-static VEC (symtab_ptr) *
+static symtab_vector_up
symtabs_from_filename (const char *filename,
struct program_space *search_pspace)
{
- VEC (symtab_ptr) *result;
-
- result = collect_symtabs_from_filename (filename, search_pspace);
+ symtab_vector_up result
+ = collect_symtabs_from_filename (filename, search_pspace);
- if (VEC_empty (symtab_ptr, result))
+ if (result->empty ())
{
if (!have_full_symbols () && !have_partial_symbols ())
throw_error (NOT_FOUND_ERROR,
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<symtab *> *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<symtab *> 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. */
static void
find_function_symbols (struct linespec_state *state,
- VEC (symtab_ptr) *file_symtabs, const char *name,
+ std::vector<symtab *> *file_symtabs, const char *name,
symbol_name_match_type name_match_type,
- VEC (symbolp) **symbols,
- VEC (bound_minimal_symbol_d) **minsyms)
+ std::vector<block_symbol> *symbols,
+ std::vector<bound_minimal_symbol> *minsyms)
{
struct collect_info info;
std::vector<const char *> symbol_names;
info.state = state;
- info.result.symbols = NULL;
- info.result.minimal_symbols = NULL;
+ info.result.symbols = symbols;
+ info.result.minimal_symbols = minsyms;
info.file_symtabs = file_symtabs;
/* Try NAME as an Objective-C selector. */
else
add_matching_symbols_to_info (name, name_match_type, FUNCTIONS_DOMAIN,
&info, state->search_pspace);
-
- if (VEC_empty (symbolp, info.result.symbols))
- {
- VEC_free (symbolp, info.result.symbols);
- *symbols = NULL;
- }
- else
- *symbols = info.result.symbols;
-
- 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
static void
find_linespec_symbols (struct linespec_state *state,
- VEC (symtab_ptr) *file_symtabs,
+ std::vector<symtab *> *file_symtabs,
const char *lookup_name,
symbol_name_match_type name_match_type,
- VEC (symbolp) **symbols,
- VEC (bound_minimal_symbol_d) **minsyms)
+ std::vector <block_symbol> *symbols,
+ std::vector<bound_minimal_symbol> *minsyms)
{
std::string canon = cp_canonicalize_string_no_typedefs (lookup_name);
if (!canon.empty ())
2) break class::method where method is in class (and not a baseclass) */
find_function_symbols (state, file_symtabs, lookup_name,
- name_match_type,
- symbols, minsyms);
+ name_match_type, symbols, minsyms);
/* 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 (VEC_empty (symbolp, *symbols)
- && 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. */
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<block_symbol> 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
}
END_CATCH
}
-
- do_cleanups (old_chain);
}
}
find_label_symbols_in_block (const struct block *block,
const char *name, struct symbol *fn_sym,
bool completion_mode,
- VEC (symbolp) **result,
- VEC (symbolp) **label_funcs_ret)
+ std::vector<block_symbol> *result,
+ std::vector<block_symbol> *label_funcs_ret)
{
if (completion_mode)
{
SYMBOL_DOMAIN (sym), LABEL_DOMAIN)
&& cmp (SYMBOL_SEARCH_NAME (sym), name, name_len) == 0)
{
- VEC_safe_push (symbolp, *result, sym);
- VEC_safe_push (symbolp, *label_funcs_ret, 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)
{
- VEC_safe_push (symbolp, *result, sym);
- VEC_safe_push (symbolp, *label_funcs_ret, fn_sym);
+ result->push_back (label_sym);
+ label_funcs_ret->push_back ({fn_sym, block});
}
}
}
-/* Return all labels that match name NAME in FUNCTION_SYMBOLS. Return
- the actual function symbol in which the label was found in
+/* Return all labels that match name NAME in FUNCTION_SYMBOLS or NULL
+ if no matches were found.
+
+ Return the actual function symbol in which the label was found in
LABEL_FUNC_RET. If COMPLETION_MODE is true, then NAME is
interpreted as a label name prefix. Otherwise, only labels named
exactly NAME match. */
-static VEC (symbolp) *
+
+static std::vector<block_symbol> *
find_label_symbols (struct linespec_state *self,
- VEC (symbolp) *function_symbols,
- VEC (symbolp) **label_funcs_ret, const char *name,
+ std::vector<block_symbol> *function_symbols,
+ std::vector<block_symbol> *label_funcs_ret,
+ const char *name,
bool completion_mode)
{
- int ix;
const struct block *block;
struct symbol *fn_sym;
- VEC (symbolp) *result = NULL;
+ std::vector<block_symbol> result;
if (function_symbols == NULL)
{
}
else
{
- for (ix = 0;
- VEC_iterate (symbolp, function_symbols, ix, fn_sym); ++ix)
+ for (const auto &elt : *function_symbols)
{
+ fn_sym = elt.symbol;
set_current_program_space (SYMTAB_PSPACE (symbol_symtab (fn_sym)));
block = SYMBOL_BLOCK_VALUE (fn_sym);
}
}
- return result;
+ if (!result.empty ())
+ return new std::vector<block_symbol> (std::move (result));
+ return nullptr;
}
\f
linespec_p ls,
struct symtab_and_line val)
{
- int ix;
- struct symtab *elt;
-
gdb_assert (self->list_mode);
std::vector<symtab_and_line> values;
- for (ix = 0; VEC_iterate (symtab_ptr, ls->file_symtabs, ix, elt);
- ++ix)
+ for (const auto &elt : *ls->file_symtabs)
{
/* The logic above should ensure this. */
gdb_assert (elt != NULL);
int line,
struct linetable_entry **best_entry)
{
- int ix;
- struct symtab *elt;
-
std::vector<symtab_and_line> sals;
- for (ix = 0; VEC_iterate (symtab_ptr, ls->file_symtabs, ix, elt); ++ix)
+ for (const auto &elt : *ls->file_symtabs)
{
std::vector<CORE_ADDR> pcs;
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);
}
}
}
struct collect_info *info,
struct program_space *pspace)
{
- int ix;
- struct symtab *elt;
-
lookup_name_info lookup_name (name, name_match_type);
- for (ix = 0; VEC_iterate (symtab_ptr, info->file_symtabs, ix, elt); ++ix)
+ for (const auto &elt : *info->file_symtabs)
{
- if (elt == NULL)
+ if (elt == nullptr)
{
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))
{
- int prev_len = VEC_length (symbolp, info->result.symbols);
+ int prev_len = info->result.symbols->size ();
/* Program spaces that are executing startup should have
been filtered out earlier. */
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
which we don't have debug info. Check for a minimal symbol in
this case. */
- if (prev_len == VEC_length (symbolp, info->result.symbols)
+ if (prev_len == info->result.symbols->size ()
&& elt->language == language_asm)
search_minsyms_for_name (info, lookup_name, pspace, elt);
}
projects / deliverable / binutils-gdb.git / blobdiff