6c5b2ebeac
This replaces "struct symtabs_and_lines" with std::vector<symtab_and_line> in most cases. This removes a number of cleanups. In some cases, the sals objects do not own the sals they point at. Instead they point at some sal that lives on the stack. Typically something like this: struct symtab_and_line sal; struct symtabs_and_lines sals; // fill in sal sals.nelts = 1; sals.sals = &sal; // use sals Instead of switching those cases to std::vector too, such usages are replaced by gdb::array_view<symtab_and_line> instead. This avoids introducing heap allocations. gdb/ChangeLog: 2017-09-04 Pedro Alves <palves@redhat.com> * ax-gdb.c (agent_command_1): Use range-for. * break-catch-throw.c (re_set_exception_catchpoint): Update. * breakpoint.c: Include "common/array-view.h". (init_breakpoint_sal, create_breakpoint_sal): Change sals parameter from struct symtabs_and_lines to array_view<symtab_and_line>. Adjust. Use range-for. Update. (breakpoint_sals_to_pc): Change sals parameter from struct symtabs_and_lines to std::vector reference. (check_fast_tracepoint_sals): Change sals parameter from struct symtabs_and_lines to std::array_view. Use range-for. (decode_static_tracepoint_spec): Return a std::vector instead of symtabs_and_lines. Update. (create_breakpoint): Update. (break_range_command, until_break_command, clear_command): Update. (base_breakpoint_decode_location, bkpt_decode_location) (bkpt_probe_create_sals_from_location) (bkpt_probe_decode_location, tracepoint_decode_location) (tracepoint_probe_decode_location) (strace_marker_create_sals_from_location): Return a std::vector instead of symtabs_and_lines. (strace_marker_create_breakpoints_sal): Update. (strace_marker_decode_location): Return a std::vector instead of symtabs_and_lines. Update. (update_breakpoint_locations): Change struct symtabs_and_lines parameters to gdb::array_view. Adjust. (location_to_sals): Return a std::vector instead of symtabs_and_lines. Update. (breakpoint_re_set_default): Use std::vector instead of struct symtabs_and_lines. (decode_location_default): Return a std::vector instead of symtabs_and_lines. Update. * breakpoint.h: Include "common/array-view.h". (struct breakpoint_ops) <decode_location>: Now returns a std::vector instead of returning a symtabs_and_lines via output parameter. (update_breakpoint_locations): Change sals parameters to use gdb::array_view. * cli/cli-cmds.c (edit_command, list_command): Update to use std::vector and gdb::array_view. (ambiguous_line_spec): Adjust to use gdb::array_view and range-for. (compare_symtabs): Rename to ... (cmp_symtabs): ... this. Change parameters to symtab_and_line const reference and adjust. (filter_sals): Rewrite using std::vector and standard algorithms. * elfread.c (elf_gnu_ifunc_resolver_return_stop): Simplify. (jump_command): Update to use std::vector. * linespec.c (struct linespec_state) <canonical_names>: Update comment. (add_sal_to_sals_basic): Delete. (add_sal_to_sals, filter_results, convert_results_to_lsals) (decode_line_2, create_sals_line_offset) (convert_address_location_to_sals, convert_linespec_to_sals) (convert_explicit_location_to_sals, parse_linespec) (event_location_to_sals, decode_line_full, decode_line_1) (decode_line_with_current_source) (decode_line_with_last_displayed, decode_objc) (decode_digits_list_mode, decode_digits_ordinary, minsym_found) (linespec_result::~linespec_result): Adjust to use std::vector instead of symtabs_and_lines. * linespec.h (linespec_sals::sals): Now a std::vector. (struct linespec_result): Use std::vector, bool, and in-class initialization. (decode_line_1, decode_line_with_current_source) (decode_line_with_last_displayed): Return std::vector. * macrocmd.c (info_macros_command): Use std::vector. * mi/mi-main.c (mi_cmd_trace_find): Use std::vector. * probe.c (parse_probes_in_pspace, parse_probes): Adjust to use std::vector. * probe.h (parse_probes): Return a std::vector. * python/python.c (gdbpy_decode_line): Use std::vector and gdb::array_view. * source.c (select_source_symtab, line_info): Use std::vector. * stack.c (func_command): Use std::vector. * symtab.h (struct symtabs_and_lines): Delete. * tracepoint.c (tfind_line_command, scope_info): Use std::vector.
208 lines
7.4 KiB
C++
208 lines
7.4 KiB
C++
/* Header for GDB line completion.
|
|
Copyright (C) 2000-2017 Free Software Foundation, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#if !defined (LINESPEC_H)
|
|
#define LINESPEC_H 1
|
|
|
|
struct symtab;
|
|
|
|
#include "location.h"
|
|
#include "vec.h"
|
|
|
|
/* Flags to pass to decode_line_1 and decode_line_full. */
|
|
|
|
enum decode_line_flags
|
|
{
|
|
/* Set this flag if you want the resulting SALs to describe the
|
|
first line of indicated functions. */
|
|
DECODE_LINE_FUNFIRSTLINE = 1,
|
|
|
|
/* Set this flag if you want "list mode". In this mode, a
|
|
FILE:LINE linespec will always return a result, and such
|
|
linespecs will not be expanded to all matches. */
|
|
DECODE_LINE_LIST_MODE = 2
|
|
};
|
|
|
|
/* decode_line_full returns a vector of these. */
|
|
|
|
struct linespec_sals
|
|
{
|
|
/* This is the location corresponding to the sals contained in this
|
|
object. It can be passed as the FILTER argument to future calls
|
|
to decode_line_full. This is freed by the linespec_result
|
|
destructor. */
|
|
char *canonical;
|
|
|
|
/* Sals. */
|
|
std::vector<symtab_and_line> sals;
|
|
};
|
|
|
|
/* An instance of this may be filled in by decode_line_1. The caller
|
|
must make copies of any data that it needs to keep. */
|
|
|
|
struct linespec_result
|
|
{
|
|
linespec_result () = default;
|
|
~linespec_result ();
|
|
|
|
linespec_result (const linespec_result &) = delete;
|
|
linespec_result &operator= (const linespec_result &) = delete;
|
|
|
|
/* If true, the linespec should be displayed to the user. This
|
|
is used by "unusual" linespecs where the ordinary `info break'
|
|
display mechanism would do the wrong thing. */
|
|
bool special_display = false;
|
|
|
|
/* If true, the linespec result should be considered to be a
|
|
"pre-expanded" multi-location linespec. A pre-expanded linespec
|
|
holds all matching locations in a single linespec_sals
|
|
object. */
|
|
bool pre_expanded = false;
|
|
|
|
/* If PRE_EXPANDED is non-zero, this is set to the location entered
|
|
by the user. */
|
|
event_location_up location;
|
|
|
|
/* The sals. The vector will be freed by the destructor. */
|
|
std::vector<linespec_sals> lsals;
|
|
};
|
|
|
|
/* Decode a linespec using the provided default symtab and line. */
|
|
|
|
extern std::vector<symtab_and_line>
|
|
decode_line_1 (const struct event_location *location, int flags,
|
|
struct program_space *search_pspace,
|
|
struct symtab *default_symtab, int default_line);
|
|
|
|
/* Parse LOCATION and return results. This is the "full"
|
|
interface to this module, which handles multiple results
|
|
properly.
|
|
|
|
For FLAGS, see decode_line_flags. DECODE_LINE_LIST_MODE is not
|
|
valid for this function.
|
|
|
|
If SEARCH_PSPACE is not NULL, symbol search is restricted to just
|
|
that program space.
|
|
|
|
DEFAULT_SYMTAB and DEFAULT_LINE describe the default location.
|
|
DEFAULT_SYMTAB can be NULL, in which case the current symtab and
|
|
line are used.
|
|
|
|
CANONICAL is where the results are stored. It must not be NULL.
|
|
|
|
SELECT_MODE must be one of the multiple_symbols_* constants, or
|
|
NULL. It determines how multiple results will be handled. If
|
|
NULL, the appropriate CLI value will be used.
|
|
|
|
FILTER can either be NULL or a string holding a canonical name.
|
|
This is only valid when SELECT_MODE is multiple_symbols_all.
|
|
|
|
Multiple results are handled differently depending on the
|
|
arguments:
|
|
|
|
. With multiple_symbols_cancel, an exception is thrown.
|
|
|
|
. With multiple_symbols_ask, a menu is presented to the user. The
|
|
user may select none, in which case an exception is thrown; or all,
|
|
which is handled like multiple_symbols_all, below. Otherwise,
|
|
CANONICAL->SALS will have one entry for each name the user chose.
|
|
|
|
. With multiple_symbols_all, CANONICAL->SALS will have a single
|
|
entry describing all the matching locations. If FILTER is
|
|
non-NULL, then only locations whose canonical name is equal (in the
|
|
strcmp sense) to FILTER will be returned; all others will be
|
|
filtered out. */
|
|
|
|
extern void decode_line_full (const struct event_location *location, int flags,
|
|
struct program_space *search_pspace,
|
|
struct symtab *default_symtab, int default_line,
|
|
struct linespec_result *canonical,
|
|
const char *select_mode,
|
|
const char *filter);
|
|
|
|
/* Given a string, return the line specified by it, using the current
|
|
source symtab and line as defaults.
|
|
This is for commands like "list" and "breakpoint". */
|
|
|
|
extern std::vector<symtab_and_line> decode_line_with_current_source (char *, int);
|
|
|
|
/* Given a string, return the line specified by it, using the last displayed
|
|
codepoint's values as defaults, or nothing if they aren't valid. */
|
|
|
|
extern std::vector<symtab_and_line> decode_line_with_last_displayed (char *, int);
|
|
|
|
/* Does P represent one of the keywords? If so, return
|
|
the keyword. If not, return NULL. */
|
|
|
|
extern const char *linespec_lexer_lex_keyword (const char *p);
|
|
|
|
/* Parse a line offset from STRING. */
|
|
|
|
extern struct line_offset linespec_parse_line_offset (const char *string);
|
|
|
|
/* Return the quote characters permitted by the linespec parser. */
|
|
|
|
extern const char *get_gdb_linespec_parser_quote_characters (void);
|
|
|
|
/* Does STRING represent an Ada operator? If so, return the length
|
|
of the decoded operator name. If not, return 0. */
|
|
|
|
extern int is_ada_operator (const char *string);
|
|
|
|
/* Find an instance of the character C in the string S that is outside
|
|
of all parenthesis pairs, single-quoted strings, and double-quoted
|
|
strings. Also, ignore the char within a template name, like a ','
|
|
within foo<int, int>. */
|
|
|
|
extern const char *find_toplevel_char (const char *s, char c);
|
|
|
|
/* Find the end of the (first) linespec pointed to by *STRINGP.
|
|
STRINGP will be advanced to this point. */
|
|
|
|
extern void linespec_lex_to_end (char **stringp);
|
|
|
|
extern const char * const linespec_keywords[];
|
|
|
|
/* Complete a linespec. */
|
|
|
|
extern void linespec_complete (completion_tracker &tracker,
|
|
const char *text);
|
|
|
|
/* Complete a function symbol, in linespec mode. If SOURCE_FILENAME
|
|
is non-NULL, limits completion to the list of functions defined in
|
|
source files that match SOURCE_FILENAME. */
|
|
|
|
extern void linespec_complete_function (completion_tracker &tracker,
|
|
const char *function,
|
|
const char *source_filename);
|
|
|
|
/* Complete a label symbol, in linespec mode. Only labels of
|
|
functions named FUNCTION_NAME are considered. If SOURCE_FILENAME
|
|
is non-NULL, limits completion to labels of functions defined in
|
|
source files that match SOURCE_FILENAME. */
|
|
|
|
extern void linespec_complete_label (completion_tracker &tracker,
|
|
const struct language_defn *language,
|
|
const char *source_filename,
|
|
const char *function_name,
|
|
const char *label_name);
|
|
|
|
/* Evaluate the expression pointed to by EXP_PTR into a CORE_ADDR,
|
|
advancing EXP_PTR past any parsed text. */
|
|
|
|
extern CORE_ADDR linespec_expression_to_pc (const char **exp_ptr);
|
|
#endif /* defined (LINESPEC_H) */
|