Toolchain/binutils-gdb
1
0
Fork 0
forked from Imagelibrary/binutils-gdb
Code Pull Requests Activity

event_location -> location_spec

Browse Source 
Currently, GDB internally uses the term "location" for both the
location specification the user input (linespec, explicit location, or
an address location), and for actual resolved locations, like the
breakpoint locations, or the result of decoding a location spec to
SaLs.  This is expecially confusing in the breakpoints module, as
struct breakpoint has these two fields:

  breakpoint::location;
  breakpoint::loc;

"location" is the location spec, and "loc" is the resolved locations.

And then, we have a method called "locations()", which returns the
resolved locations as range...

The location spec type is presently called event_location:

  /* Location we used to set the breakpoint.  */
  event_location_up location;

and it is described like this:

  /* The base class for all an event locations used to set a stop event
     in the inferior.  */

  struct event_location
  {

and even that is incorrect...  Location specs are used for finding
actual locations in the program in scenarios that have nothing to do
with stop events.  E.g., "list" works with location specs.

To clean all this confusion up, this patch renames "event_location" to
"location_spec" throughout, and then all the variables that hold a
location spec, they are renamed to include "spec" in their name, like
e.g., "location" -> "locspec".  Similarly, functions that work with
location specs, and currently have just "location" in their name are
renamed to include "spec" in their name too.

Change-Id: I5814124798aa2b2003e79496e78f95c74e5eddca
This commit is contained in:
Pedro Alves
2022-05-23 20:15:18 +01:00
parent 14e283ff4e
commit 264f98902f
21 changed files with 604 additions and 590 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
gdb/ada-lang.c
View File

@@ -12144,7 +12144,7 @@ struct ada_catchpoint : public code_breakpoint
enable_state = enabled ? bp_enabled : bp_disabled;
disposition = tempflag ? disp_del : disp_donttouch;
location = string_to_event_location (&addr_string_,
locspec = string_to_location_spec (&addr_string_,
language_def (language_ada));
language = language_ada;
}

6
gdb/ax-gdb.c
View File

@@ -2526,9 +2526,9 @@ maint_agent_command_1 (const char *exp, int eval)
{
struct linespec_result canonical;
event_location_up location
= new_linespec_location (&exp, symbol_name_match_type::WILD);
decode_line_full (location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
location_spec_up locspec
= new_linespec_location_spec (&exp, symbol_name_match_type::WILD);
decode_line_full (locspec.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
NULL, 0, &canonical,
NULL, NULL);
exp = skip_spaces (exp);

10
gdb/break-catch-throw.c
View File

@@ -215,9 +215,9 @@ exception_catchpoint::re_set ()
/* We first try to use the probe interface. */
try
{
event_location_up location
= new_probe_location (exception_functions[kind].probe);
sals = parse_probes (location.get (), filter_pspace, NULL);
location_spec_up locspec
= new_probe_location_spec (exception_functions[kind].probe);
sals = parse_probes (locspec.get (), filter_pspace, NULL);
}
catch (const gdb_exception_error &e)
{
@@ -230,8 +230,8 @@ exception_catchpoint::re_set ()
initialize_explicit_location (&explicit_loc);
explicit_loc.function_name
= ASTRDUP (exception_functions[kind].function);
event_location_up location = new_explicit_location (&explicit_loc);
sals = this->decode_location (location.get (), filter_pspace);
location_spec_up locspec = new_explicit_location_spec (&explicit_loc);
sals = this->decode_location_spec (locspec.get (), filter_pspace);
}
catch (const gdb_exception_error &ex)
{

328
gdb/breakpoint.c
View File

@@ -90,8 +90,8 @@ static void map_breakpoint_numbers (const char *,
static void breakpoint_re_set_default (code_breakpoint *);
static void
create_sals_from_location_default (struct event_location *location,
struct linespec_result *canonical);
create_sals_from_location_spec_default (location_spec *locspec,
linespec_result *canonical);
static void create_breakpoints_sal (struct gdbarch *,
struct linespec_result *,
@@ -102,8 +102,8 @@ static void create_breakpoints_sal (struct gdbarch *,
int,
int, int, int, unsigned);
static std::vector<symtab_and_line> decode_location_default
(struct breakpoint *b, struct event_location *location,
static std::vector<symtab_and_line> decode_location_spec_default
(struct breakpoint *b, struct location_spec *locspec,
struct program_space *search_pspace);
static int can_use_hardware_watchpoint
@@ -159,9 +159,9 @@ static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp,
static void decref_bp_location (struct bp_location **loc);
static std::vector<symtab_and_line> bkpt_probe_decode_location
static std::vector<symtab_and_line> bkpt_probe_decode_location_spec
(struct breakpoint *b,
struct event_location *location,
location_spec *locspec,
struct program_space *search_pspace);
static bool bl_address_is_meaningful (bp_location *loc);
@@ -218,30 +218,30 @@ static bool is_masked_watchpoint (const struct breakpoint *b);
static int strace_marker_p (struct breakpoint *b);
static void bkpt_probe_create_sals_from_location
(struct event_location *location,
static void bkpt_probe_create_sals_from_location_spec
(location_spec *locspec,
struct linespec_result *canonical);
static void tracepoint_probe_create_sals_from_location
(struct event_location *location,
static void tracepoint_probe_create_sals_from_location_spec
(location_spec *locspec,
struct linespec_result *canonical);
const struct breakpoint_ops code_breakpoint_ops =
{
create_sals_from_location_default,
create_sals_from_location_spec_default,
create_breakpoints_sal,
};
/* Breakpoints set on probes. */
static const struct breakpoint_ops bkpt_probe_breakpoint_ops =
{
bkpt_probe_create_sals_from_location,
bkpt_probe_create_sals_from_location_spec,
create_breakpoints_sal,
};
/* Tracepoints set on probes. */
static const struct breakpoint_ops tracepoint_probe_breakpoint_ops =
{
tracepoint_probe_create_sals_from_location,
tracepoint_probe_create_sals_from_location_spec,
create_breakpoints_sal,
};
@@ -351,8 +351,8 @@ struct ranged_breakpoint : public ordinary_breakpoint
explicit ranged_breakpoint (struct gdbarch *gdbarch,
const symtab_and_line &sal_start,
int length,
event_location_up start_location,
event_location_up end_location)
location_spec_up start_locspec,
location_spec_up end_locspec)
: ordinary_breakpoint (gdbarch, bp_hardware_breakpoint)
{
bp_location *bl = add_location (sal_start);
@@ -360,8 +360,8 @@ struct ranged_breakpoint : public ordinary_breakpoint
disposition = disp_donttouch;
location = std::move (start_location);
location_range_end = std::move (end_location);
locspec = std::move (start_locspec);
locspec_range_end = std::move (end_locspec);
}
int breakpoint_hit (const struct bp_location *bl,
@@ -381,8 +381,8 @@ struct static_marker_tracepoint : public tracepoint
{
using tracepoint::tracepoint;
std::vector<symtab_and_line> decode_location
(struct event_location *location,
std::vector<symtab_and_line> decode_location_spec
(struct location_spec *locspec,
struct program_space *search_pspace) override;
};
@@ -3390,7 +3390,7 @@ create_overlay_event_breakpoint (void)
bp_overlay_event);
initialize_explicit_location (&explicit_loc);
explicit_loc.function_name = ASTRDUP (func_name);
b->location = new_explicit_location (&explicit_loc);
b->locspec = new_explicit_location_spec (&explicit_loc);
if (overlay_debugging == ovly_auto)
{
@@ -3447,7 +3447,7 @@ create_longjmp_master_breakpoint_probe (objfile *objfile)
b = create_internal_breakpoint (gdbarch,
p->get_relocated_address (objfile),
bp_longjmp_master);
b->location = new_probe_location ("-probe-stap libc:longjmp");
b->locspec = new_probe_location_spec ("-probe-stap libc:longjmp");
b->enable_state = bp_disabled;
}
@@ -3497,7 +3497,7 @@ create_longjmp_master_breakpoint_names (objfile *objfile)
b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master);
initialize_explicit_location (&explicit_loc);
explicit_loc.function_name = ASTRDUP (func_name);
b->location = new_explicit_location (&explicit_loc);
b->locspec = new_explicit_location_spec (&explicit_loc);
b->enable_state = bp_disabled;
installed_bp++;
}
@@ -3580,7 +3580,7 @@ create_std_terminate_master_breakpoint (void)
bp_std_terminate_master);
initialize_explicit_location (&explicit_loc);
explicit_loc.function_name = ASTRDUP (func_name);
b->location = new_explicit_location (&explicit_loc);
b->locspec = new_explicit_location_spec (&explicit_loc);
b->enable_state = bp_disabled;
}
}
@@ -3630,7 +3630,7 @@ create_exception_master_breakpoint_probe (objfile *objfile)
b = create_internal_breakpoint (gdbarch,
p->get_relocated_address (objfile),
bp_exception_master);
b->location = new_probe_location ("-probe-stap libgcc:unwind");
b->locspec = new_probe_location_spec ("-probe-stap libgcc:unwind");
b->enable_state = bp_disabled;
}
@@ -3677,7 +3677,7 @@ create_exception_master_breakpoint_hook (objfile *objfile)
b = create_internal_breakpoint (gdbarch, addr, bp_exception_master);
initialize_explicit_location (&explicit_loc);
explicit_loc.function_name = ASTRDUP (func_name);
b->location = new_explicit_location (&explicit_loc);
b->locspec = new_explicit_location_spec (&explicit_loc);
b->enable_state = bp_disabled;
return true;
@@ -3709,9 +3709,10 @@ create_exception_master_breakpoint (void)
/* Does B have a location spec? */
static int
breakpoint_event_location_empty_p (const struct breakpoint *b)
breakpoint_location_spec_empty_p (const struct breakpoint *b)
{
return b->location != NULL && event_location_empty_p (b->location.get ());
return (b->locspec != nullptr
&& location_spec_empty_p (b->locspec.get ()));
}
void
@@ -3825,7 +3826,7 @@ update_breakpoints_after_exec (void)
/* Without a symbolic address, we have little hope of the
pre-exec() address meaning the same thing in the post-exec()
a.out. */
if (breakpoint_event_location_empty_p (b))
if (breakpoint_location_spec_empty_p (b))
{
delete_breakpoint (b);
continue;
@@ -6019,7 +6020,8 @@ print_breakpoint_location (const breakpoint *b,
set_current_program_space (loc->pspace);
if (b->display_canonical)
uiout->field_string ("what", event_location_to_string (b->location.get ()));
uiout->field_string ("what",
location_spec_to_string (b->locspec.get ()));
else if (loc && loc->symtab)
{
const struct symbol *sym = loc->symbol;
@@ -6054,7 +6056,7 @@ print_breakpoint_location (const breakpoint *b,
else
{
uiout->field_string ("pending",
event_location_to_string (b->location.get ()));
location_spec_to_string (b->locspec.get ()));
/* If extra_string is available, it could be holding a condition
or dprintf arguments. In either case, make sure it is printed,
too, but only for non-MI streams. */
@@ -6514,10 +6516,12 @@ print_one_breakpoint_location (struct breakpoint *b,
uiout->field_string ("original-location", w->exp_string.get ());
}
else if (b->location != NULL
&& event_location_to_string (b->location.get ()) != NULL)
uiout->field_string ("original-location",
event_location_to_string (b->location.get ()));
else if (b->locspec != nullptr)
{
const char *str = location_spec_to_string (b->locspec.get ());
if (str != nullptr)
uiout->field_string ("original-location", str);
}
}
return result;
@@ -7534,8 +7538,8 @@ create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
b = create_internal_breakpoint (gdbarch, address, bp_thread_event);
b->enable_state = bp_enabled;
/* location has to be used or breakpoint_re_set will delete me. */
b->location = new_address_location (b->loc->address, NULL, 0);
/* locspec has to be used or breakpoint_re_set will delete me. */
b->locspec = new_address_location_spec (b->loc->address, NULL, 0);
update_global_location_list_nothrow (UGLL_MAY_INSERT);
@@ -8243,7 +8247,7 @@ update_dprintf_commands (const char *args, int from_tty,
code_breakpoint::code_breakpoint (struct gdbarch *gdbarch_,
enum bptype type_,
gdb::array_view<const symtab_and_line> sals,
event_location_up &&location_,
location_spec_up &&locspec_,
gdb::unique_xmalloc_ptr<char> filter_,
gdb::unique_xmalloc_ptr<char> cond_string_,
gdb::unique_xmalloc_ptr<char> extra_string_,
@@ -8291,7 +8295,7 @@ code_breakpoint::code_breakpoint (struct gdbarch *gdbarch_,
{
/* We already know the marker exists, otherwise, we wouldn't
see a sal for it. */
const char *p = &event_location_to_string (location_.get ())[3];
const char *p = &location_spec_to_string (locspec_.get ())[3];
const char *endp;
p = skip_spaces (p);
@@ -8360,17 +8364,17 @@ code_breakpoint::code_breakpoint (struct gdbarch *gdbarch_,
}
display_canonical = display_canonical_;
if (location_ != nullptr)
location = std::move (location_);
if (locspec_ != nullptr)
locspec = std::move (locspec_);
else
location = new_address_location (this->loc->address, NULL, 0);
locspec = new_address_location_spec (this->loc->address, NULL, 0);
filter = std::move (filter_);
}
static void
create_breakpoint_sal (struct gdbarch *gdbarch,
gdb::array_view<const symtab_and_line> sals,
event_location_up &&location,
location_spec_up &&locspec,
gdb::unique_xmalloc_ptr<char> filter,
gdb::unique_xmalloc_ptr<char> cond_string,
gdb::unique_xmalloc_ptr<char> extra_string,
@@ -8384,7 +8388,7 @@ create_breakpoint_sal (struct gdbarch *gdbarch,
= new_breakpoint_from_type (gdbarch,
type,
sals,
std::move (location),
std::move (locspec),
std::move (filter),
std::move (cond_string),
std::move (extra_string),
@@ -8429,14 +8433,14 @@ create_breakpoints_sal (struct gdbarch *gdbarch,
{
/* Note that 'location' can be NULL in the case of a plain
'break', without arguments. */
event_location_up location
= (canonical->location != NULL
? copy_event_location (canonical->location.get ()) : NULL);
location_spec_up locspec
= (canonical->locspec != NULL
? copy_location_spec (canonical->locspec.get ()) : NULL);
gdb::unique_xmalloc_ptr<char> filter_string
(lsal.canonical != NULL ? xstrdup (lsal.canonical) : NULL);
create_breakpoint_sal (gdbarch, lsal.sals,
std::move (location),
std::move (locspec),
std::move (filter_string),
std::move (cond_string),
std::move (extra_string),
@@ -8447,23 +8451,23 @@ create_breakpoints_sal (struct gdbarch *gdbarch,
}
}
/* Parse LOCATION which is assumed to be a SAL specification possibly
/* Parse LOCSPEC which is assumed to be a SAL specification possibly
followed by conditionals. On return, SALS contains an array of SAL
addresses found. LOCATION points to the end of the SAL (for
linespec locations).
addresses found. LOCSPEC points to the end of the SAL (for
linespec locspecs).
The array and the line spec strings are allocated on the heap, it is
the caller's responsibility to free them. */
static void
parse_breakpoint_sals (struct event_location *location,
parse_breakpoint_sals (location_spec *locspec,
struct linespec_result *canonical)
{
struct symtab_and_line cursal;
if (event_location_type (location) == LINESPEC_LOCATION)
if (location_spec_type (locspec) == LINESPEC_LOCATION_SPEC)
{
const char *spec = get_linespec_location (location)->spec_string;
const char *spec = get_linespec_location (locspec)->spec_string;
if (spec == NULL)
{
@@ -8513,15 +8517,15 @@ parse_breakpoint_sals (struct event_location *location,
{
const char *spec = NULL;
if (event_location_type (location) == LINESPEC_LOCATION)
spec = get_linespec_location (location)->spec_string;
if (location_spec_type (locspec) == LINESPEC_LOCATION_SPEC)
spec = get_linespec_location (locspec)->spec_string;
if (!cursal.symtab
|| (spec != NULL
&& strchr ("+-", spec[0]) != NULL
&& spec[1] != '['))
{
decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
decode_line_full (locspec, DECODE_LINE_FUNFIRSTLINE, NULL,
get_last_displayed_symtab (),
get_last_displayed_line (),
canonical, NULL, NULL);
@@ -8529,7 +8533,7 @@ parse_breakpoint_sals (struct event_location *location,
}
}
decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
decode_line_full (locspec, DECODE_LINE_FUNFIRSTLINE, NULL,
cursal.symtab, cursal.line, canonical, NULL, NULL);
}
@@ -8749,19 +8753,19 @@ decode_static_tracepoint_spec (const char **arg_p)
according to IS_TRACEPOINT. */
static const struct breakpoint_ops *
breakpoint_ops_for_event_location_type (enum event_location_type location_type,
breakpoint_ops_for_location_spec_type (enum location_spec_type locspec_type,
bool is_tracepoint)
{
if (is_tracepoint)
{
if (location_type == PROBE_LOCATION)
if (locspec_type == PROBE_LOCATION_SPEC)
return &tracepoint_probe_breakpoint_ops;
else
return &code_breakpoint_ops;
}
else
{
if (location_type == PROBE_LOCATION)
if (locspec_type == PROBE_LOCATION_SPEC)
return &bkpt_probe_breakpoint_ops;
else
return &code_breakpoint_ops;
@@ -8771,12 +8775,12 @@ breakpoint_ops_for_event_location_type (enum event_location_type location_type,
/* See breakpoint.h. */
const struct breakpoint_ops *
breakpoint_ops_for_event_location (const struct event_location *location,
breakpoint_ops_for_location_spec (const location_spec *locspec,
bool is_tracepoint)
{
if (location != nullptr)
return breakpoint_ops_for_event_location_type
(event_location_type (location), is_tracepoint);
if (locspec != nullptr)
return (breakpoint_ops_for_location_spec_type
(location_spec_type (locspec), is_tracepoint));
return &code_breakpoint_ops;
}
@@ -8784,7 +8788,7 @@ breakpoint_ops_for_event_location (const struct event_location *location,
int
create_breakpoint (struct gdbarch *gdbarch,
struct event_location *location,
location_spec *locspec,
const char *cond_string,
int thread, const char *extra_string,
bool force_condition, int parse_extra,
@@ -8808,7 +8812,7 @@ create_breakpoint (struct gdbarch *gdbarch,
try
{
ops->create_sals_from_location (location, &canonical);
ops->create_sals_from_location_spec (locspec, &canonical);
}
catch (const gdb_exception_error &e)
{
@@ -8932,7 +8936,7 @@ create_breakpoint (struct gdbarch *gdbarch,
{
std::unique_ptr <breakpoint> b = new_breakpoint_from_type (gdbarch,
type_wanted);
b->location = copy_event_location (location);
b->locspec = copy_location_spec (locspec);
if (parse_extra)
b->cond_string = NULL;
@@ -8987,12 +8991,13 @@ break_command_1 (const char *arg, int flag, int from_tty)
? bp_hardware_breakpoint
: bp_breakpoint);
event_location_up location = string_to_event_location (&arg, current_language);
const struct breakpoint_ops *ops = breakpoint_ops_for_event_location
(location.get (), false /* is_tracepoint */);
location_spec_up locspec = string_to_location_spec (&arg, current_language);
const struct breakpoint_ops *ops
= breakpoint_ops_for_location_spec (locspec.get (),
false /* is_tracepoint */);
create_breakpoint (get_current_arch (),
location.get (),
locspec.get (),
NULL, 0, arg, false, 1 /* parse arg */,
tempflag, type_wanted,
0 /* Ignore count */,
@@ -9091,7 +9096,7 @@ thbreak_command (const char *arg, int from_tty)
static void
dprintf_command (const char *arg, int from_tty)
{
event_location_up location = string_to_event_location (&arg, current_language);
location_spec_up locspec = string_to_location_spec (&arg, current_language);
/* If non-NULL, ARG should have been advanced past the location;
the next character must be ','. */
@@ -9107,7 +9112,7 @@ dprintf_command (const char *arg, int from_tty)
}
create_breakpoint (get_current_arch (),
location.get (),
locspec.get (),
NULL, 0, arg, false, 1 /* parse arg */,
0, bp_dprintf,
0 /* Ignore count */,
@@ -9251,8 +9256,8 @@ void
ranged_breakpoint::print_recreate (struct ui_file *fp) const
{
gdb_printf (fp, "break-range %s, %s",
event_location_to_string (location.get ()),
event_location_to_string (location_range_end.get ()));
location_spec_to_string (locspec.get ()),
location_spec_to_string (locspec_range_end.get ()));
print_recreate_thread (fp);
}
@@ -9312,9 +9317,9 @@ break_range_command (const char *arg, int from_tty)
error(_("No address range specified."));
arg_start = arg;
event_location_up start_location = string_to_event_location (&arg,
current_language);
parse_breakpoint_sals (start_location.get (), &canonical_start);
location_spec_up start_locspec
= string_to_location_spec (&arg, current_language);
parse_breakpoint_sals (start_locspec.get (), &canonical_start);
if (arg[0] != ',')
error (_("Too few arguments."));
@@ -9333,18 +9338,19 @@ break_range_command (const char *arg, int from_tty)
arg++; /* Skip the comma. */
arg = skip_spaces (arg);
/* Parse the end location. */
/* Parse the end location specification. */
arg_start = arg;
/* We call decode_line_full directly here instead of using
parse_breakpoint_sals because we need to specify the start location's
symtab and line as the default symtab and line for the end of the
range. This makes it possible to have ranges like "foo.c:27, +14",
where +14 means 14 lines from the start location. */
event_location_up end_location = string_to_event_location (&arg,
current_language);
decode_line_full (end_location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
parse_breakpoint_sals because we need to specify the start
location spec's symtab and line as the default symtab and line
for the end of the range. This makes it possible to have ranges
like "foo.c:27, +14", where +14 means 14 lines from the start
location spec. */
location_spec_up end_locspec
= string_to_location_spec (&arg, current_language);
decode_line_full (end_locspec.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
sal_start.symtab, sal_start.line,
&canonical_end, NULL, NULL);
@@ -9380,8 +9386,8 @@ break_range_command (const char *arg, int from_tty)
std::unique_ptr<breakpoint> br
(new ranged_breakpoint (get_current_arch (),
sal_start, length,
std::move (start_location),
std::move (end_location)));
std::move (start_locspec),
std::move (end_locspec)));
install_breakpoint (false, std::move (br), true);
}
@@ -10447,14 +10453,14 @@ until_break_command (const char *arg, int from_tty, int anywhere)
/* Set a breakpoint where the user wants it and at return from
this function. */
event_location_up location = string_to_event_location (&arg, current_language);
location_spec_up locspec = string_to_location_spec (&arg, current_language);
std::vector<symtab_and_line> sals
= (last_displayed_sal_is_valid ()
? decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
? decode_line_1 (locspec.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
get_last_displayed_symtab (),
get_last_displayed_line ())
: decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
: decode_line_1 (locspec.get (), DECODE_LINE_FUNFIRSTLINE,
NULL, NULL, 0));
if (sals.empty ())
@@ -11360,18 +11366,18 @@ say_where (const breakpoint *b)
if (b->extra_string == NULL)
{
gdb_printf (_(" (%s) pending."),
event_location_to_string (b->location.get ()));
location_spec_to_string (b->locspec.get ()));
}
else if (b->type == bp_dprintf)
{
gdb_printf (_(" (%s,%s) pending."),
event_location_to_string (b->location.get ()),
location_spec_to_string (b->locspec.get ()),
b->extra_string.get ());
}
else
{
gdb_printf (_(" (%s %s) pending."),
event_location_to_string (b->location.get ()),
location_spec_to_string (b->locspec.get ()),
b->extra_string.get ());
}
}
@@ -11400,7 +11406,7 @@ say_where (const breakpoint *b)
different file name, and this at least reflects the
real situation somewhat. */
gdb_printf (": %s.",
event_location_to_string (b->location.get ()));
location_spec_to_string (b->locspec.get ()));
}
if (b->loc->next)
@@ -11477,8 +11483,8 @@ breakpoint::print_recreate (struct ui_file *fp) const
}
std::vector<symtab_and_line>
breakpoint::decode_location (struct event_location *location,
struct program_space *search_pspace)
breakpoint::decode_location_spec (location_spec *locspec,
program_space *search_pspace)
{
internal_error_pure_virtual_called ();
}
@@ -11489,7 +11495,7 @@ void
code_breakpoint::re_set ()
{
/* FIXME: is this still reachable? */
if (breakpoint_event_location_empty_p (this))
if (breakpoint_location_spec_empty_p (this))
{
/* Anything without a location can't be re-set. */
delete_breakpoint (this);
@@ -11665,7 +11671,7 @@ ordinary_breakpoint::print_recreate (struct ui_file *fp) const
internal_error (__FILE__, __LINE__,
_("unhandled breakpoint type %d"), (int) type);
gdb_printf (fp, " %s", event_location_to_string (location.get ()));
gdb_printf (fp, " %s", location_spec_to_string (locspec.get ()));
/* Print out extra_string if this breakpoint is pending. It might
contain, for example, conditions that were set by the user. */
@@ -11676,13 +11682,13 @@ ordinary_breakpoint::print_recreate (struct ui_file *fp) const
}
std::vector<symtab_and_line>
code_breakpoint::decode_location (struct event_location *location,
struct program_space *search_pspace)
code_breakpoint::decode_location_spec (location_spec *locspec,
program_space *search_pspace)
{
if (event_location_type (location) == PROBE_LOCATION)
return bkpt_probe_decode_location (this, location, search_pspace);
if (location_spec_type (locspec) == PROBE_LOCATION_SPEC)
return bkpt_probe_decode_location_spec (this, locspec, search_pspace);
return decode_location_default (this, location, search_pspace);
return decode_location_spec_default (this, locspec, search_pspace);
}
/* Virtual table for internal breakpoints. */
@@ -11821,24 +11827,25 @@ longjmp_breakpoint::~longjmp_breakpoint ()
}
static void
bkpt_probe_create_sals_from_location (struct event_location *location,
bkpt_probe_create_sals_from_location_spec (location_spec *locspec,
struct linespec_result *canonical)
{
struct linespec_sals lsal;
lsal.sals = parse_probes (location, NULL, canonical);
lsal.sals = parse_probes (locspec, NULL, canonical);
lsal.canonical
= xstrdup (event_location_to_string (canonical->location.get ()));
= xstrdup (location_spec_to_string (canonical->locspec.get ()));
canonical->lsals.push_back (std::move (lsal));
}
static std::vector<symtab_and_line>
bkpt_probe_decode_location (struct breakpoint *b,
struct event_location *location,
struct program_space *search_pspace)
bkpt_probe_decode_location_spec (struct breakpoint *b,
location_spec *locspec,
program_space *search_pspace)
{
std::vector<symtab_and_line> sals = parse_probes (location, search_pspace, NULL);
std::vector<symtab_and_line> sals
= parse_probes (locspec, search_pspace, NULL);
if (sals.empty ())
error (_("probe not found"));
return sals;
@@ -11911,7 +11918,7 @@ tracepoint::print_recreate (struct ui_file *fp) const
internal_error (__FILE__, __LINE__,
_("unhandled tracepoint type %d"), (int) type);
gdb_printf (fp, " %s", event_location_to_string (location.get ()));
gdb_printf (fp, " %s", location_spec_to_string (locspec.get ()));
print_recreate_thread (fp);
if (pass_count)
@@ -11921,12 +11928,12 @@ tracepoint::print_recreate (struct ui_file *fp) const
/* Virtual table for tracepoints on static probes. */
static void
tracepoint_probe_create_sals_from_location
(struct event_location *location,
tracepoint_probe_create_sals_from_location_spec
(location_spec *locspec,
struct linespec_result *canonical)
{
/* We use the same method for breakpoint on probes. */
bkpt_probe_create_sals_from_location (location, canonical);
bkpt_probe_create_sals_from_location_spec (locspec, canonical);
}
void
@@ -11957,7 +11964,7 @@ void
dprintf_breakpoint::print_recreate (struct ui_file *fp) const
{
gdb_printf (fp, "dprintf %s,%s",
event_location_to_string (location.get ()),
location_spec_to_string (locspec.get ()),
extra_string.get ());
print_recreate_thread (fp);
}
@@ -11992,22 +11999,22 @@ dprintf_breakpoint::after_condition_true (struct bpstat *bs)
markers (`-m'). */
static void
strace_marker_create_sals_from_location (struct event_location *location,
strace_marker_create_sals_from_location_spec (location_spec *locspec,
struct linespec_result *canonical)
{
struct linespec_sals lsal;
const char *arg_start, *arg;
arg = arg_start = get_linespec_location (location)->spec_string;
arg = arg_start = get_linespec_location (locspec)->spec_string;
lsal.sals = decode_static_tracepoint_spec (&arg);
std::string str (arg_start, arg - arg_start);
const char *ptr = str.c_str ();
canonical->location
= new_linespec_location (&ptr, symbol_name_match_type::FULL);
canonical->locspec
= new_linespec_location_spec (&ptr, symbol_name_match_type::FULL);
lsal.canonical
= xstrdup (event_location_to_string (canonical->location.get ()));
= xstrdup (location_spec_to_string (canonical->locspec.get ()));
canonical->lsals.push_back (std::move (lsal));
}
@@ -12034,14 +12041,14 @@ strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
for (size_t i = 0; i < lsal.sals.size (); i++)
{
event_location_up location
= copy_event_location (canonical->location.get ());
location_spec_up locspec
= copy_location_spec (canonical->locspec.get ());
std::unique_ptr<tracepoint> tp
(new tracepoint (gdbarch,
type_wanted,
lsal.sals[i],
std::move (location),
std::move (locspec),
NULL,
std::move (cond_string),
std::move (extra_string),
@@ -12063,10 +12070,10 @@ strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
}
std::vector<symtab_and_line>
static_marker_tracepoint::decode_location (struct event_location *location,
struct program_space *search_pspace)
static_marker_tracepoint::decode_location_spec (location_spec *locspec,
program_space *search_pspace)
{
const char *s = get_linespec_location (location)->spec_string;
const char *s = get_linespec_location (locspec)->spec_string;
std::vector<symtab_and_line> sals = decode_static_tracepoint_spec (&s);
if (sals.size () > static_trace_marker_id_idx)
@@ -12082,7 +12089,7 @@ static_marker_tracepoint::decode_location (struct event_location *location,
/* Static tracepoints with marker (`-m'). */
static struct breakpoint_ops strace_marker_breakpoint_ops =
{
strace_marker_create_sals_from_location,
strace_marker_create_sals_from_location_spec,
strace_marker_create_breakpoints_sal,
};
@@ -12411,13 +12418,13 @@ update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
b->loc->line_number = sal2.line;
b->loc->symtab = sym != NULL ? sal2.symtab : NULL;
b->location.reset (NULL);
b->locspec.reset (nullptr);
initialize_explicit_location (&explicit_loc);
explicit_loc.source_filename
= ASTRDUP (symtab_to_filename_for_display (sal2.symtab));
explicit_loc.line_offset.offset = b->loc->line_number;
explicit_loc.line_offset.sign = LINE_OFFSET_NONE;
b->location = new_explicit_location (&explicit_loc);
b->locspec = new_explicit_location_spec (&explicit_loc);
/* Might be nice to check if function changed, and warn if
so. */
@@ -12620,11 +12627,11 @@ update_breakpoint_locations (code_breakpoint *b,
gdb::observers::breakpoint_modified.notify (b);
}
/* Find the SaL locations corresponding to the given LOCATION.
/* Find the SaL locations corresponding to the given LOCSPEC.
On return, FOUND will be 1 if any SaL was found, zero otherwise. */
static std::vector<symtab_and_line>
location_to_sals (struct breakpoint *b, struct event_location *location,
location_spec_to_sals (struct breakpoint *b, location_spec *locspec,
struct program_space *search_pspace, int *found)
{
struct gdb_exception exception;
@@ -12633,7 +12640,7 @@ location_to_sals (struct breakpoint *b, struct event_location *location,
try
{
sals = b->decode_location (location, search_pspace);
sals = b->decode_location_spec (locspec, search_pspace);
}
catch (gdb_exception_error &e)
{
@@ -12715,15 +12722,15 @@ breakpoint_re_set_default (code_breakpoint *b)
std::vector<symtab_and_line> expanded, expanded_end;
int found;
std::vector<symtab_and_line> sals = location_to_sals (b, b->location.get (),
filter_pspace, &found);
std::vector<symtab_and_line> sals
= location_spec_to_sals (b, b->locspec.get (), filter_pspace, &found);
if (found)
expanded = std::move (sals);
if (b->location_range_end != NULL)
if (b->locspec_range_end != nullptr)
{
std::vector<symtab_and_line> sals_end
= location_to_sals (b, b->location_range_end.get (),
= location_spec_to_sals (b, b->locspec_range_end.get (),
filter_pspace, &found);
if (found)
expanded_end = std::move (sals_end);
@@ -12736,23 +12743,23 @@ breakpoint_re_set_default (code_breakpoint *b)
calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
static void
create_sals_from_location_default (struct event_location *location,
create_sals_from_location_spec_default (location_spec *locspec,
struct linespec_result *canonical)
{
parse_breakpoint_sals (location, canonical);
parse_breakpoint_sals (locspec, canonical);
}
/* Decode the line represented by S by calling decode_line_full. This is the
default function for the `decode_location' method of breakpoint_ops. */
static std::vector<symtab_and_line>
decode_location_default (struct breakpoint *b,
struct event_location *location,
struct program_space *search_pspace)
decode_location_spec_default (struct breakpoint *b,
location_spec *locspec,
program_space *search_pspace)
{
struct linespec_result canonical;
decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, search_pspace,
decode_line_full (locspec, DECODE_LINE_FUNFIRSTLINE, search_pspace,
NULL, 0, &canonical, multiple_symbols_all,
b->filter.get ());
@@ -13510,13 +13517,13 @@ set_tracepoint_count (int num)
static void
trace_command (const char *arg, int from_tty)
{
event_location_up location = string_to_event_location (&arg,
location_spec_up locspec = string_to_location_spec (&arg,
current_language);
const struct breakpoint_ops *ops = breakpoint_ops_for_event_location
(location.get (), true /* is_tracepoint */);
const struct breakpoint_ops *ops = breakpoint_ops_for_location_spec
(locspec.get (), true /* is_tracepoint */);
create_breakpoint (get_current_arch (),
location.get (),
locspec.get (),
NULL, 0, arg, false, 1 /* parse arg */,
0 /* tempflag */,
bp_tracepoint /* type_wanted */,
@@ -13531,10 +13538,10 @@ trace_command (const char *arg, int from_tty)
static void
ftrace_command (const char *arg, int from_tty)
{
event_location_up location = string_to_event_location (&arg,
location_spec_up locspec = string_to_location_spec (&arg,
current_language);
create_breakpoint (get_current_arch (),
location.get (),
locspec.get (),
NULL, 0, arg, false, 1 /* parse arg */,
0 /* tempflag */,
bp_fast_tracepoint /* type_wanted */,
@@ -13552,7 +13559,7 @@ static void
strace_command (const char *arg, int from_tty)
{
const struct breakpoint_ops *ops;
event_location_up location;
location_spec_up locspec;
enum bptype type;
/* Decide if we are dealing with a static tracepoint marker (`-m'),
@@ -13560,18 +13567,19 @@ strace_command (const char *arg, int from_tty)
if (arg && startswith (arg, "-m") && isspace (arg[2]))
{
ops = &strace_marker_breakpoint_ops;
location = new_linespec_location (&arg, symbol_name_match_type::FULL);
locspec = new_linespec_location_spec (&arg,
symbol_name_match_type::FULL);
type = bp_static_marker_tracepoint;
}
else
{
ops = &code_breakpoint_ops;
location = string_to_event_location (&arg, current_language);
locspec = string_to_location_spec (&arg, current_language);
type = bp_static_tracepoint;
}
create_breakpoint (get_current_arch (),
location.get (),
locspec.get (),
NULL, 0, arg, false, 1 /* parse arg */,
0 /* tempflag */,
type /* type_wanted */,
@@ -13637,10 +13645,10 @@ create_tracepoint_from_upload (struct uploaded_tp *utp)
"has no source form, ignoring it"),
utp->number);
event_location_up location = string_to_event_location (&addr_str,
location_spec_up locspec = string_to_location_spec (&addr_str,
current_language);
if (!create_breakpoint (get_current_arch (),
location.get (),
locspec.get (),
utp->cond_string.get (), -1, addr_str,
false /* force_condition */,
0 /* parse cond/thread */,
@@ -14054,7 +14062,7 @@ save_tracepoints_command (const char *args, int from_tty)
/* This help string is used to consolidate all the help string for specifying
locations used by several commands. */
#define LOCATION_HELP_STRING \
#define LOCATION_SPEC_HELP_STRING \
"Linespecs are colon-separated lists of location parameters, such as\n\
source filename, function name, label name, and line number.\n\
Example: To specify the start of a label named \"the_top\" in the\n\
@@ -14101,7 +14109,7 @@ CONDITION is a boolean expression.\n\
\n\
With the \"-force-condition\" flag, the condition is defined even when\n\
it is invalid for all current locations.\n\
\n" LOCATION_HELP_STRING "\n\n\
\n" LOCATION_SPEC_HELP_STRING "\n\n\
Multiple breakpoints at one place are permitted, and useful if their\n\
conditions are different.\n\
\n\
@@ -14370,7 +14378,7 @@ Argument may be a linespec, explicit, or address location as described below.\n\
\n\
With no argument, clears all breakpoints in the line that the selected frame\n\
is executing in.\n"
"\n" LOCATION_HELP_STRING "\n\n\
"\n" LOCATION_SPEC_HELP_STRING "\n\n\
See also the \"delete\" command which clears breakpoints by number."));
add_com_alias ("cl", clear_cmd, class_breakpoint, 1);
@@ -14531,7 +14539,7 @@ tracing library. You can inspect it when analyzing the trace buffer,\n\
by printing the $_sdata variable like any other convenience variable.\n\
\n\
CONDITION is a boolean expression.\n\
\n" LOCATION_HELP_STRING "\n\n\
\n" LOCATION_SPEC_HELP_STRING "\n\n\
Multiple tracepoints at one place are permitted, and useful if their\n\
conditions are different.\n\
\n\
@@ -14688,7 +14696,7 @@ range (including START-LOCATION and END-LOCATION)."));
Set a dynamic printf at specified location.\n\
dprintf location,format string,arg1,arg2,...\n\
location may be a linespec, explicit, or address location.\n"
"\n" LOCATION_HELP_STRING));
"\n" LOCATION_SPEC_HELP_STRING));
set_cmd_completer (c, location_completer);
add_setshow_enum_cmd ("dprintf-style", class_support,

60
gdb/breakpoint.h
View File

@@ -502,7 +502,7 @@ public:
struct symtab *symtab = NULL;
/* The symbol found by the location parser, if any. This may be used to
ascertain when an event location was set at a different location than
ascertain when a location spec was set at a different location than
the one originally selected by parsing, e.g., inlined symbols. */
const struct symbol *symbol = NULL;
@@ -562,13 +562,14 @@ enum print_stop_action
struct breakpoint_ops
{
/* Create SALs from location, storing the result in linespec_result.
/* Create SALs from location spec, storing the result in
linespec_result.
For an explanation about the arguments, see the function
`create_sals_from_location_default'.
`create_sals_from_location_spec_default'.
This function is called inside `create_breakpoint'. */
void (*create_sals_from_location) (struct event_location *location,
void (*create_sals_from_location_spec) (location_spec *locspec,
struct linespec_result *canonical);
/* This method will be responsible for creating a breakpoint given its SALs.
@@ -709,14 +710,14 @@ struct breakpoint
/* Print to FP the CLI command that recreates this breakpoint. */
virtual void print_recreate (struct ui_file *fp) const;
/* Given the location (second parameter), this method decodes it and
returns the SAL locations related to it. For ordinary
/* Given the location spec (second parameter), this method decodes
it and returns the SAL locations related to it. For ordinary
breakpoints, it calls `decode_line_full'. If SEARCH_PSPACE is
not NULL, symbol search is restricted to just that program space.
This function is called inside `location_to_sals'. */
virtual std::vector<symtab_and_line> decode_location
(struct event_location *location,
This function is called inside `location_spec_to_sals'. */
virtual std::vector<symtab_and_line> decode_location_spec
(location_spec *locspec,
struct program_space *search_pspace);
/* Return true if this breakpoint explains a signal. See
@@ -774,16 +775,16 @@ struct breakpoint
non-thread-specific ordinary breakpoints this is NULL. */
program_space *pspace = NULL;
/* Location we used to set the breakpoint. */
event_location_up location;
/* The location specification we used to set the breakpoint. */
location_spec_up locspec;
/* The filter that should be passed to decode_line_full when
re-setting this breakpoint. This may be NULL. */
gdb::unique_xmalloc_ptr<char> filter;
/* For a ranged breakpoint, the location we used to find the end of
the range. */
event_location_up location_range_end;
/* For a ranged breakpoint, the location specification we used to
find the end of the range. */
location_spec_up locspec_range_end;
/* Architecture we used to set the breakpoint. */
struct gdbarch *gdbarch;
@@ -859,7 +860,7 @@ struct code_breakpoint : public breakpoint
location" from the address in the SAL. */
code_breakpoint (struct gdbarch *gdbarch, bptype type,
gdb::array_view<const symtab_and_line> sals,
event_location_up &&location,
location_spec_up &&locspec,
gdb::unique_xmalloc_ptr<char> filter,
gdb::unique_xmalloc_ptr<char> cond_string,
gdb::unique_xmalloc_ptr<char> extra_string,
@@ -882,8 +883,8 @@ struct code_breakpoint : public breakpoint
const address_space *aspace,
CORE_ADDR bp_addr,
const target_waitstatus &ws) override;
std::vector<symtab_and_line> decode_location
(struct event_location *location,
std::vector<symtab_and_line> decode_location_spec
(struct location_spec *locspec,
struct program_space *search_pspace) override;
};
@@ -1460,13 +1461,14 @@ extern void
extern void install_breakpoint (int internal, std::unique_ptr<breakpoint> &&b,
int update_gll);
/* Returns the breakpoint ops appropriate for use with with LOCATION and
according to IS_TRACEPOINT. Use this to ensure, for example, that you pass
the correct ops to create_breakpoint for probe locations. If LOCATION is
NULL, returns code_breakpoint_ops. */
/* Returns the breakpoint ops appropriate for use with with LOCSPEC
and according to IS_TRACEPOINT. Use this to ensure, for example,
that you pass the correct ops to create_breakpoint for probe
location specs. If LOCSPEC is NULL, returns
code_breakpoint_ops. */
extern const struct breakpoint_ops *breakpoint_ops_for_event_location
(const struct event_location *location, bool is_tracepoint);
extern const struct breakpoint_ops *breakpoint_ops_for_location_spec
(const location_spec *locspec, bool is_tracepoint);
/* Flags that can be passed down to create_breakpoint, etc., to affect
breakpoint creation in several ways. */
@@ -1478,15 +1480,15 @@ enum breakpoint_create_flags
CREATE_BREAKPOINT_FLAGS_INSERTED = 1 << 0
};
/* Set a breakpoint. This function is shared between CLI and MI functions
for setting a breakpoint at LOCATION.
/* Set a breakpoint. This function is shared between CLI and MI
functions for setting a breakpoint at LOCSPEC.
This function has two major modes of operations, selected by the
PARSE_EXTRA parameter.
If PARSE_EXTRA is zero, LOCATION is just the breakpoint's location,
with condition, thread, and extra string specified by the COND_STRING,
THREAD, and EXTRA_STRING parameters.
If PARSE_EXTRA is zero, LOCSPEC is just the breakpoint's location
spec, with condition, thread, and extra string specified by the
COND_STRING, THREAD, and EXTRA_STRING parameters.
If PARSE_EXTRA is non-zero, this function will attempt to extract
the condition, thread, and extra string from EXTRA_STRING, ignoring
@@ -1503,7 +1505,7 @@ enum breakpoint_create_flags
Returns true if any breakpoint was created; false otherwise. */
extern int create_breakpoint (struct gdbarch *gdbarch,
struct event_location *location,
struct location_spec *locspec,
const char *cond_string, int thread,
const char *extra_string,
bool force_condition,

28
gdb/cli/cli-cmds.c
View File

@@ -970,13 +970,13 @@ edit_command (const char *arg, int from_tty)
/* Now should only be one argument -- decode it in SAL. */
arg1 = arg;
event_location_up location = string_to_event_location (&arg1,
location_spec_up locspec = string_to_location_spec (&arg1,
current_language);
if (*arg1)
error (_("Junk at end of line specification."));
std::vector<symtab_and_line> sals = decode_line_1 (location.get (),
std::vector<symtab_and_line> sals = decode_line_1 (locspec.get (),
DECODE_LINE_LIST_MODE,
NULL, NULL, 0);
@@ -1241,18 +1241,18 @@ list_command (const char *arg, int from_tty)
dummy_beg = 1;
else
{
event_location_up location = string_to_event_location (&arg1,
current_language);
location_spec_up locspec
= string_to_location_spec (&arg1, current_language);
/* We know that the ARG string is not empty, yet the attempt to parse
a location from the string consumed no characters. This most
likely means that the first thing in ARG looks like a location
condition, and so the string_to_event_location call stopped
parsing. */
/* We know that the ARG string is not empty, yet the attempt to
parse a location spec from the string consumed no characters.
This most likely means that the first thing in ARG looks like
a location spec condition, and so the string_to_location_spec
call stopped parsing. */
if (arg1 == arg)
error (_("Junk at end of line specification."));
sals = decode_line_1 (location.get (), DECODE_LINE_LIST_MODE,
sals = decode_line_1 (locspec.get (), DECODE_LINE_LIST_MODE,
NULL, NULL, 0);
filter_sals (sals);
if (sals.empty ())
@@ -1297,17 +1297,17 @@ list_command (const char *arg, int from_tty)
know it was ambiguous. */
const char *end_arg = arg1;
event_location_up location
= string_to_event_location (&arg1, current_language);
location_spec_up locspec
= string_to_location_spec (&arg1, current_language);
if (*arg1)
error (_("Junk at end of line specification."));
std::vector<symtab_and_line> sals_end
= (dummy_beg
? decode_line_1 (location.get (), DECODE_LINE_LIST_MODE,
? decode_line_1 (locspec.get (), DECODE_LINE_LIST_MODE,
NULL, NULL, 0)
: decode_line_1 (location.get (), DECODE_LINE_LIST_MODE,
: decode_line_1 (locspec.get (), DECODE_LINE_LIST_MODE,
NULL, sal.symtab, sal.line));
filter_sals (sals_end);

24
gdb/completer.c
View File

@@ -707,13 +707,13 @@ string_or_empty (const char *string)
static void
collect_explicit_location_matches (completion_tracker &tracker,
struct event_location *location,
location_spec *locspec,
enum explicit_location_match_type what,
const char *word,
const struct language_defn *language)
{
const struct explicit_location *explicit_loc
= get_explicit_location (location);
= get_explicit_location (locspec);
/* True if the option expects an argument. */
bool needs_arg = true;
@@ -846,15 +846,15 @@ skip_keyword (completion_tracker &tracker,
return -1;
}
/* A completer function for explicit locations. This function
/* A completer function for explicit location specs. This function
completes both options ("-source", "-line", etc) and values. If
completing a quoted string, then QUOTED_ARG_START and
QUOTED_ARG_END point to the quote characters. LANGUAGE is the
current language. */
static void
complete_explicit_location (completion_tracker &tracker,
struct event_location *location,
complete_explicit_location_spec (completion_tracker &tracker,
location_spec *locspec,
const char *text,
const language_defn *language,
const char *quoted_arg_start,
@@ -916,7 +916,7 @@ complete_explicit_location (completion_tracker &tracker,
}
/* Now gather matches */
collect_explicit_location_matches (tracker, location, what, text,
collect_explicit_location_matches (tracker, locspec, what, text,
language);
}
}
@@ -943,8 +943,8 @@ location_completer (struct cmd_list_element *ignore,
const char *copy = text;
explicit_completion_info completion_info;
event_location_up location
= string_to_explicit_location (&copy, current_language,
location_spec_up locspec
= string_to_explicit_location_spec (&copy, current_language,
&completion_info);
if (completion_info.quoted_arg_start != NULL
&& completion_info.quoted_arg_end == NULL)
@@ -954,7 +954,7 @@ location_completer (struct cmd_list_element *ignore,
tracker.advance_custom_word_point_by (1);
}
if (completion_info.saw_explicit_location_option)
if (completion_info.saw_explicit_location_spec_option)
{
if (*copy != '\0')
{
@@ -987,7 +987,7 @@ location_completer (struct cmd_list_element *ignore,
- text);
text = completion_info.last_option;
complete_explicit_location (tracker, location.get (), text,
complete_explicit_location_spec (tracker, locspec.get (), text,
current_language,
completion_info.quoted_arg_start,
completion_info.quoted_arg_end);
@@ -995,7 +995,7 @@ location_completer (struct cmd_list_element *ignore,
}
}
/* This is an address or linespec location. */
else if (location != NULL)
else if (locspec != nullptr)
{
/* Handle non-explicit location options. */
@@ -1008,7 +1008,7 @@ location_completer (struct cmd_list_element *ignore,
text = copy;
symbol_name_match_type match_type
= get_explicit_location (location.get ())->func_name_match_type;
= get_explicit_location (locspec.get ())->func_name_match_type;
complete_address_and_linespec_locations (tracker, text, match_type);
}
}

4
gdb/elfread.c
View File

@@ -1026,8 +1026,8 @@ elf_gnu_ifunc_resolver_return_stop (code_breakpoint *b)
resolved_pc = gdbarch_addr_bits_remove (gdbarch, resolved_pc);
gdb_assert (current_program_space == b->pspace || b->pspace == NULL);
elf_gnu_ifunc_record_cache (event_location_to_string (b->location.get ()),
resolved_pc);
const char *locspec_str = location_spec_to_string (b->locspec.get ());
elf_gnu_ifunc_record_cache (locspec_str, resolved_pc);
b->type = bp_breakpoint;
update_breakpoint_locations (b, current_program_space,

18
gdb/guile/scm-breakpoint.c
View File

@@ -187,9 +187,9 @@ bpscm_print_breakpoint_smob (SCM self, SCM port, scm_print_state *pstate)
gdbscm_printf (port, " hit:%d", b->hit_count);
gdbscm_printf (port, " ignore:%d", b->ignore_count);
if (b->location != nullptr)
if (b->locspec != nullptr)
{
const char *str = event_location_to_string (b->location.get ());
const char *str = location_spec_to_string (b->locspec.get ());
if (str != nullptr)
gdbscm_printf (port, " @%s", str);
}
@@ -448,8 +448,8 @@ gdbscm_register_breakpoint_x (SCM self)
pending_breakpoint_scm = self;
location = bp_smob->spec.location;
copy = skip_spaces (location);
event_location_up eloc
= string_to_event_location_basic (&copy,
location_spec_up locspec
= string_to_location_spec_basic (&copy,
current_language,
symbol_name_match_type::WILD);
@@ -463,9 +463,9 @@ gdbscm_register_breakpoint_x (SCM self)
case bp_breakpoint:
{
const breakpoint_ops *ops =
breakpoint_ops_for_event_location (eloc.get (), false);
breakpoint_ops_for_location_spec (locspec.get (), false);
create_breakpoint (get_current_arch (),
eloc.get (), NULL, -1, NULL, false,
locspec.get (), NULL, -1, NULL, false,
0,
temporary, bp_breakpoint,
0,
@@ -855,13 +855,13 @@ gdbscm_breakpoint_location (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
const char *str;
if (bp_smob->bp->type != bp_breakpoint)
return SCM_BOOL_F;
str = event_location_to_string (bp_smob->bp->location.get ());
if (! str)
const char *str
= location_spec_to_string (bp_smob->bp->locspec.get ());
if (str == nullptr)
str = "";
return gdbscm_scm_from_c_string (str);

66
gdb/linespec.c
View File

@@ -1990,7 +1990,7 @@ linespec_parse_basic (linespec_parser *parser)
static void
canonicalize_linespec (struct linespec_state *state, const linespec *ls)
{
struct event_location *canon;
location_spec *canon;
struct explicit_location *explicit_loc;
/* If canonicalization was not requested, no need to do anything. */
@@ -1998,9 +1998,9 @@ canonicalize_linespec (struct linespec_state *state, const linespec *ls)
return;
/* Save everything as an explicit location. */
state->canonical->location
= new_explicit_location (&ls->explicit_loc);
canon = state->canonical->location.get ();
state->canonical->locspec
= new_explicit_location_spec (&ls->explicit_loc);
canon = state->canonical->locspec.get ();
explicit_loc = get_explicit_location (canon);
if (explicit_loc->label_name != NULL)
@@ -2019,7 +2019,7 @@ canonicalize_linespec (struct linespec_state *state, const linespec *ls)
/* If this location originally came from a linespec, save a string
representation of it for display and saving to file. */
if (state->is_linespec)
set_event_location_string (canon,
set_location_spec_string (canon,
explicit_location_to_linespec (explicit_loc));
}
@@ -3061,22 +3061,22 @@ linespec_complete (completion_tracker &tracker, const char *text,
}
/* A helper function for decode_line_full and decode_line_1 to
turn LOCATION into std::vector<symtab_and_line>. */
turn LOCSPEC into std::vector<symtab_and_line>. */
static std::vector<symtab_and_line>
event_location_to_sals (linespec_parser *parser,
const struct event_location *location)
location_spec_to_sals (linespec_parser *parser,
const location_spec *locspec)
{
std::vector<symtab_and_line> result;
switch (event_location_type (location))
switch (location_spec_type (locspec))
{
case LINESPEC_LOCATION:
case LINESPEC_LOCATION_SPEC:
{
PARSER_STATE (parser)->is_linespec = 1;
try
{
const linespec_location *ls = get_linespec_location (location);
const linespec_location *ls = get_linespec_location (locspec);
result = parse_linespec (parser,
ls->spec_string, ls->match_type);
}
@@ -3087,17 +3087,17 @@ event_location_to_sals (linespec_parser *parser,
}
break;
case ADDRESS_LOCATION:
case ADDRESS_LOCATION_SPEC:
{
const char *addr_string = get_address_string_location (location);
CORE_ADDR addr = get_address_location (location);
const char *addr_string = get_address_string_location (locspec);
CORE_ADDR addr = get_address_location (locspec);
if (addr_string != NULL)
{
addr = linespec_expression_to_pc (&addr_string);
if (PARSER_STATE (parser)->canonical != NULL)
PARSER_STATE (parser)->canonical->location
= copy_event_location (location);
PARSER_STATE (parser)->canonical->locspec
= copy_location_spec (locspec);
}
result = convert_address_location_to_sals (PARSER_STATE (parser),
@@ -3105,24 +3105,24 @@ event_location_to_sals (linespec_parser *parser,
}
break;
case EXPLICIT_LOCATION:
case EXPLICIT_LOCATION_SPEC:
{
const struct explicit_location *explicit_loc;
explicit_loc = get_explicit_location_const (location);
explicit_loc = get_explicit_location_const (locspec);
result = convert_explicit_location_to_sals (PARSER_STATE (parser),
PARSER_RESULT (parser),
explicit_loc);
}
break;
case PROBE_LOCATION:
case PROBE_LOCATION_SPEC:
/* Probes are handled by their own decoders. */
gdb_assert_not_reached ("attempt to decode probe location");
break;
default:
gdb_assert_not_reached ("unhandled event location type");
gdb_assert_not_reached ("unhandled location spec type");
}
return result;
@@ -3131,7 +3131,7 @@ event_location_to_sals (linespec_parser *parser,
/* See linespec.h. */
void
decode_line_full (struct event_location *location, int flags,
decode_line_full (struct location_spec *locspec, int flags,
struct program_space *search_pspace,
struct symtab *default_symtab,
int default_line, struct linespec_result *canonical,
@@ -3156,13 +3156,13 @@ decode_line_full (struct event_location *location, int flags,
scoped_restore_current_program_space restore_pspace;
std::vector<symtab_and_line> result = event_location_to_sals (&parser,
location);
std::vector<symtab_and_line> result = location_spec_to_sals (&parser,
locspec);
state = PARSER_STATE (&parser);
if (result.size () == 0)
throw_error (NOT_SUPPORTED_ERROR, _("Location %s not available"),
event_location_to_string (location));
location_spec_to_string (locspec));
gdb_assert (result.size () == 1 || canonical->pre_expanded);
canonical->pre_expanded = 1;
@@ -3200,7 +3200,7 @@ decode_line_full (struct event_location *location, int flags,
/* See linespec.h. */
std::vector<symtab_and_line>
decode_line_1 (const struct event_location *location, int flags,
decode_line_1 (const location_spec *locspec, int flags,
struct program_space *search_pspace,
struct symtab *default_symtab,
int default_line)
@@ -3211,7 +3211,7 @@ decode_line_1 (const struct event_location *location, int flags,
scoped_restore_current_program_space restore_pspace;
return event_location_to_sals (&parser, location);
return location_spec_to_sals (&parser, locspec);
}
/* See linespec.h. */
@@ -3226,10 +3226,10 @@ decode_line_with_current_source (const char *string, int flags)
and get a default source symtab+line or it will recursively call us! */
symtab_and_line cursal = get_current_source_symtab_and_line ();
event_location_up location = string_to_event_location (&string,
location_spec_up locspec = string_to_location_spec (&string,
current_language);
std::vector<symtab_and_line> sals
= decode_line_1 (location.get (), flags, NULL, cursal.symtab, cursal.line);
= decode_line_1 (locspec.get (), flags, NULL, cursal.symtab, cursal.line);
if (*string)
error (_("Junk at end of line specification: %s"), string);
@@ -3245,14 +3245,14 @@ decode_line_with_last_displayed (const char *string, int flags)
if (string == 0)
error (_("Empty line specification."));
event_location_up location = string_to_event_location (&string,
location_spec_up locspec = string_to_location_spec (&string,
current_language);
std::vector<symtab_and_line> sals
= (last_displayed_sal_is_valid ()
? decode_line_1 (location.get (), flags, NULL,
? decode_line_1 (locspec.get (), flags, NULL,
get_last_displayed_symtab (),
get_last_displayed_line ())
: decode_line_1 (location.get (), flags, NULL, NULL, 0));
: decode_line_1 (locspec.get (), flags, NULL, NULL, 0));
if (*string)
error (_("Junk at end of line specification: %s"), string);
@@ -3364,8 +3364,8 @@ decode_objc (struct linespec_state *self, linespec *ls, const char *arg)
else
str = saved_arg;
self->canonical->location
= new_linespec_location (&str, symbol_name_match_type::FULL);
self->canonical->locspec
= new_linespec_location_spec (&str, symbol_name_match_type::FULL);
}
}

12
gdb/linespec.h
View File

@@ -70,9 +70,9 @@ struct linespec_result
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;
/* If PRE_EXPANDED is true, this is set to the location spec
entered by the user. */
location_spec_up locspec;
/* The sals. The vector will be freed by the destructor. */
std::vector<linespec_sals> lsals;
@@ -81,11 +81,11 @@ struct linespec_result
/* 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,
decode_line_1 (const location_spec *locspec, int flags,
struct program_space *search_pspace,
struct symtab *default_symtab, int default_line);
/* Parse LOCATION and return results. This is the "full"
/* Parse LOCSPEC and return results. This is the "full"
interface to this module, which handles multiple results
properly.
@@ -124,7 +124,7 @@ extern std::vector<symtab_and_line>
strcmp sense) to FILTER will be returned; all others will be
filtered out. */
extern void decode_line_full (struct event_location *location, int flags,
extern void decode_line_full (struct location_spec *locspec, int flags,
struct program_space *search_pspace,
struct symtab *default_symtab, int default_line,
struct linespec_result *canonical,

291
gdb/location.c
View File

@@ -1,4 +1,4 @@
/* Data structures and API for event locations in GDB.
/* Data structures and API for location specs in GDB.
Copyright (C) 2013-2022 Free Software Foundation, Inc.
This file is part of GDB.
@@ -32,17 +32,17 @@
static std::string explicit_location_to_string
(const struct explicit_location *explicit_loc);
/* The base class for all an event locations used to set a stop event
in the inferior. */
/* The base class for all location specs used to match actual
locations in the inferior. */
struct event_location
struct location_spec
{
virtual ~event_location () = default;
virtual ~location_spec () = default;
/* Clone this object. */
virtual event_location_up clone () const = 0;
virtual location_spec_up clone () const = 0;
/* Return true if this location is empty, false otherwise. */
/* Return true if this location spec is empty, false otherwise. */
virtual bool empty_p () const = 0;
/* Return a string representation of this location. */
@@ -55,29 +55,29 @@ struct event_location
return as_string.c_str ();
}
DISABLE_COPY_AND_ASSIGN (event_location);
DISABLE_COPY_AND_ASSIGN (location_spec);
/* The type of this breakpoint specification. */
enum event_location_type type;
/* The type of this location specification. */
enum location_spec_type type;
/* Cached string representation of this location. This is used,
e.g., to save stop event locations to file. */
/* Cached string representation of this location spec. This is
used, e.g., to save location specs to file. */
mutable std::string as_string;
protected:
explicit event_location (enum event_location_type t)
explicit location_spec (enum location_spec_type t)
: type (t)
{
}
event_location (enum event_location_type t, std::string &&str)
location_spec (enum location_spec_type t, std::string &&str)
: type (t),
as_string (std::move (str))
{
}
explicit event_location (const event_location *to_clone)
explicit location_spec (const location_spec *to_clone)
: type (to_clone->type),
as_string (to_clone->as_string)
{
@@ -89,16 +89,16 @@ protected:
};
/* A probe. */
struct event_location_probe : public event_location
struct probe_location_spec : public location_spec
{
explicit event_location_probe (std::string &&probe)
: event_location (PROBE_LOCATION, std::move (probe))
explicit probe_location_spec (std::string &&probe)
: location_spec (PROBE_LOCATION_SPEC, std::move (probe))
{
}
event_location_up clone () const override
location_spec_up clone () const override
{
return event_location_up (new event_location_probe (this));
return location_spec_up (new probe_location_spec (this));
}
bool empty_p () const override
@@ -108,8 +108,8 @@ struct event_location_probe : public event_location
protected:
explicit event_location_probe (const event_location_probe *to_clone)
: event_location (to_clone)
explicit probe_location_spec (const probe_location_spec *to_clone)
: location_spec (to_clone)
{
}
@@ -120,11 +120,11 @@ protected:
};
/* A "normal" linespec. */
struct event_location_linespec : public event_location
struct linespec_location_spec : public location_spec
{
event_location_linespec (const char **linespec,
linespec_location_spec (const char **linespec,
symbol_name_match_type match_type)
: event_location (LINESPEC_LOCATION)
: location_spec (LINESPEC_LOCATION_SPEC)
{
linespec_location.match_type = match_type;
if (*linespec != NULL)
@@ -144,14 +144,14 @@ struct event_location_linespec : public event_location
}
}
~event_location_linespec ()
~linespec_location_spec ()
{
xfree (linespec_location.spec_string);
}
event_location_up clone () const override
location_spec_up clone () const override
{
return event_location_up (new event_location_linespec (this));
return location_spec_up (new linespec_location_spec (this));
}
bool empty_p () const override
@@ -163,8 +163,8 @@ struct event_location_linespec : public event_location
protected:
explicit event_location_linespec (const event_location_linespec *to_clone)
: event_location (to_clone),
explicit linespec_location_spec (const linespec_location_spec *to_clone)
: location_spec (to_clone),
linespec_location (to_clone->linespec_location)
{
if (linespec_location.spec_string != nullptr)
@@ -186,20 +186,20 @@ protected:
};
/* An address in the inferior. */
struct event_location_address : public event_location
struct address_location_spec : public location_spec
{
event_location_address (CORE_ADDR addr, const char *addr_string,
address_location_spec (CORE_ADDR addr, const char *addr_string,
int addr_string_len)
: event_location (ADDRESS_LOCATION),
: location_spec (ADDRESS_LOCATION_SPEC),
address (addr)
{
if (addr_string != nullptr)
as_string = std::string (addr_string, addr_string_len);
}
event_location_up clone () const override
location_spec_up clone () const override
{
return event_location_up (new event_location_address (this));
return location_spec_up (new address_location_spec (this));
}
bool empty_p () const override
@@ -211,8 +211,8 @@ struct event_location_address : public event_location
protected:
event_location_address (const event_location_address *to_clone)
: event_location (to_clone),
address_location_spec (const address_location_spec *to_clone)
: location_spec (to_clone),
address (to_clone->address)
{
}
@@ -224,25 +224,25 @@ protected:
}
};
/* An explicit location. */
struct event_location_explicit : public event_location
/* An explicit location spec. */
struct explicit_location_spec : public location_spec
{
explicit event_location_explicit (const struct explicit_location *loc)
: event_location (EXPLICIT_LOCATION)
explicit explicit_location_spec (const struct explicit_location *loc)
: location_spec (EXPLICIT_LOCATION_SPEC)
{
copy_loc (loc);
}
~event_location_explicit ()
~explicit_location_spec ()
{
xfree (explicit_loc.source_filename);
xfree (explicit_loc.function_name);
xfree (explicit_loc.label_name);
}
event_location_up clone () const override
location_spec_up clone () const override
{
return event_location_up (new event_location_explicit (this));
return location_spec_up (new explicit_location_spec (this));
}
bool empty_p () const override
@@ -257,8 +257,8 @@ struct event_location_explicit : public event_location
protected:
explicit event_location_explicit (const event_location_explicit *to_clone)
: event_location (to_clone)
explicit explicit_location_spec (const explicit_location_spec *to_clone)
: location_spec (to_clone)
{
copy_loc (&to_clone->explicit_loc);
}
@@ -289,10 +289,10 @@ private:
/* See description in location.h. */
enum event_location_type
event_location_type (const struct event_location *location)
enum location_spec_type
location_spec_type (const location_spec *locspec)
{
return location->type;
return locspec->type;
}
/* See description in location.h. */
@@ -307,99 +307,99 @@ initialize_explicit_location (struct explicit_location *explicit_loc)
/* See description in location.h. */
event_location_up
new_linespec_location (const char **linespec,
location_spec_up
new_linespec_location_spec (const char **linespec,
symbol_name_match_type match_type)
{
return event_location_up (new event_location_linespec (linespec,
return location_spec_up (new linespec_location_spec (linespec,
match_type));
}
/* See description in location.h. */
const linespec_location *
get_linespec_location (const struct event_location *location)
get_linespec_location (const location_spec *locspec)
{
gdb_assert (location->type == LINESPEC_LOCATION);
return &((event_location_linespec *) location)->linespec_location;
gdb_assert (locspec->type == LINESPEC_LOCATION_SPEC);
return &((linespec_location_spec *) locspec)->linespec_location;
}
/* See description in location.h. */
event_location_up
new_address_location (CORE_ADDR addr, const char *addr_string,
location_spec_up
new_address_location_spec (CORE_ADDR addr, const char *addr_string,
int addr_string_len)
{
return event_location_up (new event_location_address (addr, addr_string,
return location_spec_up (new address_location_spec (addr, addr_string,
addr_string_len));
}
/* See description in location.h. */
CORE_ADDR
get_address_location (const struct event_location *location)
get_address_location (const location_spec *locspec)
{
gdb_assert (location->type == ADDRESS_LOCATION);
return ((event_location_address *) location)->address;
gdb_assert (locspec->type == ADDRESS_LOCATION_SPEC);
return ((address_location_spec *) locspec)->address;
}
/* See description in location.h. */
const char *
get_address_string_location (const struct event_location *location)
get_address_string_location (const location_spec *locspec)
{
gdb_assert (location->type == ADDRESS_LOCATION);
return location->to_string ();
gdb_assert (locspec->type == ADDRESS_LOCATION_SPEC);
return locspec->to_string ();
}
/* See description in location.h. */
event_location_up
new_probe_location (std::string &&probe)
location_spec_up
new_probe_location_spec (std::string &&probe)
{
return event_location_up (new event_location_probe (std::move (probe)));
return location_spec_up (new probe_location_spec (std::move (probe)));
}
/* See description in location.h. */
const char *
get_probe_location (const struct event_location *location)
get_probe_location_spec_string (const location_spec *locspec)
{
gdb_assert (location->type == PROBE_LOCATION);
return location->to_string ();
gdb_assert (locspec->type == PROBE_LOCATION_SPEC);
return locspec->to_string ();
}
/* See description in location.h. */
event_location_up
new_explicit_location (const struct explicit_location *explicit_loc)
location_spec_up
new_explicit_location_spec (const explicit_location *explicit_loc)
{
return event_location_up (new event_location_explicit (explicit_loc));
return location_spec_up (new explicit_location_spec (explicit_loc));
}
/* See description in location.h. */
struct explicit_location *
get_explicit_location (struct event_location *location)
get_explicit_location (location_spec *locspec)
{
gdb_assert (location->type == EXPLICIT_LOCATION);
return &((event_location_explicit *) location)->explicit_loc;
gdb_assert (locspec->type == EXPLICIT_LOCATION_SPEC);
return &((explicit_location_spec *) locspec)->explicit_loc;
}
/* See description in location.h. */
const struct explicit_location *
get_explicit_location_const (const struct event_location *location)
get_explicit_location_const (const location_spec *locspec)
{
gdb_assert (location->type == EXPLICIT_LOCATION);
return &((event_location_explicit *) location)->explicit_loc;
gdb_assert (locspec->type == EXPLICIT_LOCATION_SPEC);
return &((explicit_location_spec *) locspec)->explicit_loc;
}
/* This convenience function returns a malloc'd string which
represents the location in EXPLICIT_LOC.
/* Return a string representation of the explicit location spec in
EXPLICIT_LOCSPEC.
AS_LINESPEC is true if this string should be a linespec.
Otherwise it will be output in explicit form. */
AS_LINESPEC is true if this string should be a linespec. Otherwise
it will be output in explicit form. */
static std::string
explicit_to_string_internal (bool as_linespec,
@@ -473,24 +473,24 @@ explicit_location_to_linespec (const struct explicit_location *explicit_loc)
/* See description in location.h. */
event_location_up
copy_event_location (const struct event_location *src)
location_spec_up
copy_location_spec (const location_spec *src)
{
return src->clone ();
}
void
event_location_deleter::operator() (event_location *location) const
location_spec_deleter::operator() (location_spec *locspec) const
{
delete location;
delete locspec;
}
/* See description in location.h. */
const char *
event_location_to_string (struct event_location *location)
location_spec_to_string (struct location_spec *locspec)
{
return location->to_string ();
return locspec->to_string ();
}
/* Find an instance of the quote character C in the string S that is
@@ -523,12 +523,12 @@ find_end_quote (const char *s, char end_quote_char)
return 0;
}
/* A lexer for explicit locations. This function will advance INP
past any strings that it lexes. Returns a malloc'd copy of the
/* A lexer for explicit location specs. This function will advance
INP past any strings that it lexes. Returns a malloc'd copy of the
lexed string or NULL if no lexing was done. */
static gdb::unique_xmalloc_ptr<char>
explicit_location_lex_one (const char **inp,
explicit_location_spec_lex_one (const char **inp,
const struct language_defn *language,
explicit_completion_info *completion_info)
{
@@ -630,7 +630,7 @@ is_cp_operator (const char *start, const char *comma)
}
/* When scanning the input string looking for the next explicit
location option/delimiter, we jump to the next option by looking
location spec option/delimiter, we jump to the next option by looking
for ",", and "-". Such a character can also appear in C++ symbols
like "operator," and "operator-". So when we find such a
character, we call this function to check if we found such a
@@ -673,13 +673,14 @@ first_of (const char *first, const char *new_tok)
return first;
}
/* A lexer for functions in explicit locations. This function will
/* A lexer for functions in explicit location specs. This function will
advance INP past a function until the next option, or until end of
string. Returns a malloc'd copy of the lexed string or NULL if no
lexing was done. */
static gdb::unique_xmalloc_ptr<char>
explicit_location_lex_one_function (const char **inp,
explicit_location_spec_lex_one_function
(const char **inp,
const struct language_defn *language,
explicit_completion_info *completion_info)
{
@@ -771,8 +772,8 @@ explicit_location_lex_one_function (const char **inp,
/* See description in location.h. */
event_location_up
string_to_explicit_location (const char **argp,
location_spec_up
string_to_explicit_location_spec (const char **argp,
const struct language_defn *language,
explicit_completion_info *completion_info)
{
@@ -786,8 +787,8 @@ string_to_explicit_location (const char **argp,
|| ((*argp)[0] == '-' && (*argp)[1] == 'p'))
return NULL;
std::unique_ptr<event_location_explicit> location
(new event_location_explicit ((const explicit_location *) nullptr));
std::unique_ptr<explicit_location_spec> locspec
(new explicit_location_spec ((const explicit_location *) nullptr));
/* Process option/argument pairs. dprintf_command
requires that processing stop on ','. */
@@ -817,7 +818,7 @@ string_to_explicit_location (const char **argp,
/* Get the option string. */
gdb::unique_xmalloc_ptr<char> opt
= explicit_location_lex_one (argp, language, NULL);
= explicit_location_spec_lex_one (argp, language, NULL);
/* Use the length of the option to allow abbreviations. */
len = strlen (opt.get ());
@@ -845,7 +846,7 @@ string_to_explicit_location (const char **argp,
/* We do this here because the set of options that take
arguments matches the set of explicit location
options. */
completion_info->saw_explicit_location_option = true;
completion_info->saw_explicit_location_spec_option = true;
}
oarg = std::move (arg);
have_oarg = oarg != NULL;
@@ -854,36 +855,37 @@ string_to_explicit_location (const char **argp,
if (strncmp (opt.get (), "-source", len) == 0)
{
set_oarg (explicit_location_lex_one (argp, language,
set_oarg (explicit_location_spec_lex_one (argp, language,
completion_info));
location->explicit_loc.source_filename = oarg.release ();
locspec->explicit_loc.source_filename = oarg.release ();
}
else if (strncmp (opt.get (), "-function", len) == 0)
{
set_oarg (explicit_location_lex_one_function (argp, language,
set_oarg (explicit_location_spec_lex_one_function (argp, language,
completion_info));
location->explicit_loc.function_name = oarg.release ();
locspec->explicit_loc.function_name = oarg.release ();
}
else if (strncmp (opt.get (), "-qualified", len) == 0)
{
location->explicit_loc.func_name_match_type
locspec->explicit_loc.func_name_match_type
= symbol_name_match_type::FULL;
}
else if (strncmp (opt.get (), "-line", len) == 0)
{
set_oarg (explicit_location_lex_one (argp, language, NULL));
set_oarg (explicit_location_spec_lex_one (argp, language, NULL));
*argp = skip_spaces (*argp);
if (have_oarg)
{
location->explicit_loc.line_offset
locspec->explicit_loc.line_offset
= linespec_parse_line_offset (oarg.get ());
continue;
}
}
else if (strncmp (opt.get (), "-label", len) == 0)
{
set_oarg (explicit_location_lex_one (argp, language, completion_info));
location->explicit_loc.label_name = oarg.release ();
set_oarg (explicit_location_spec_lex_one (argp, language,
completion_info));
locspec->explicit_loc.label_name = oarg.release ();
}
/* Only emit an "invalid argument" error for options
that look like option strings. */
@@ -913,39 +915,39 @@ string_to_explicit_location (const char **argp,
/* One special error check: If a source filename was given
without offset, function, or label, issue an error. */
if (location->explicit_loc.source_filename != NULL
&& location->explicit_loc.function_name == NULL
&& location->explicit_loc.label_name == NULL
&& (location->explicit_loc.line_offset.sign == LINE_OFFSET_UNKNOWN)
if (locspec->explicit_loc.source_filename != NULL
&& locspec->explicit_loc.function_name == NULL
&& locspec->explicit_loc.label_name == NULL
&& (locspec->explicit_loc.line_offset.sign == LINE_OFFSET_UNKNOWN)
&& completion_info == NULL)
{
error (_("Source filename requires function, label, or "
"line offset."));
}
return event_location_up (location.release ());
return location_spec_up (locspec.release ());
}
/* See description in location.h. */
event_location_up
string_to_event_location_basic (const char **stringp,
location_spec_up
string_to_location_spec_basic (const char **stringp,
const struct language_defn *language,
symbol_name_match_type match_type)
{
event_location_up location;
location_spec_up locspec;
const char *cs;
/* Try the input as a probe spec. */
cs = *stringp;
if (cs != NULL && probe_linespec_to_static_ops (&cs) != NULL)
{
location = new_probe_location (*stringp);
locspec = new_probe_location_spec (*stringp);
*stringp += strlen (*stringp);
}
else
{
/* Try an address location. */
/* Try an address location spec. */
if (*stringp != NULL && **stringp == '*')
{
const char *arg, *orig;
@@ -953,69 +955,72 @@ string_to_event_location_basic (const char **stringp,
orig = arg = *stringp;
addr = linespec_expression_to_pc (&arg);
location = new_address_location (addr, orig, arg - orig);
locspec = new_address_location_spec (addr, orig, arg - orig);
*stringp += arg - orig;
}
else
{
/* Everything else is a linespec. */
location = new_linespec_location (stringp, match_type);
locspec = new_linespec_location_spec (stringp, match_type);
}
}
return location;
return locspec;
}
/* See description in location.h. */
event_location_up
string_to_event_location (const char **stringp,
location_spec_up
string_to_location_spec (const char **stringp,
const struct language_defn *language,
symbol_name_match_type match_type)
{
const char *arg, *orig;
/* Try an explicit location. */
/* Try an explicit location spec. */
orig = arg = *stringp;
event_location_up location = string_to_explicit_location (&arg, language, NULL);
if (location != NULL)
location_spec_up locspec
= string_to_explicit_location_spec (&arg, language, NULL);
if (locspec != nullptr)
{
/* It was a valid explicit location. Advance STRINGP to
the end of input. */
*stringp += arg - orig;
/* If the user really specified a location, then we're done. */
if (!event_location_empty_p (location.get ()))
return location;
/* If the user really specified a location spec, then we're
done. */
if (!location_spec_empty_p (locspec.get ()))
return locspec;
/* Otherwise, the user _only_ specified optional flags like
"-qualified", otherwise string_to_explicit_location would
have thrown an error. Save the flags for "basic" linespec
parsing below and discard the explicit location. */
event_location_explicit *xloc
= dynamic_cast<event_location_explicit *> (location.get ());
"-qualified", otherwise string_to_explicit_location_spec
would have thrown an error. Save the flags for "basic"
linespec parsing below and discard the explicit location
spec. */
explicit_location_spec *xloc
= dynamic_cast<explicit_location_spec *> (locspec.get ());
gdb_assert (xloc != nullptr);
match_type = xloc->explicit_loc.func_name_match_type;
}
/* Everything else is a "basic" linespec, address, or probe
location. */
return string_to_event_location_basic (stringp, language, match_type);
/* Everything else is a "basic" linespec, address, or probe location
spec. */
return string_to_location_spec_basic (stringp, language, match_type);
}
/* See description in location.h. */
int
event_location_empty_p (const struct event_location *location)
location_spec_empty_p (const location_spec *locspec)
{
return location->empty_p ();
return locspec->empty_p ();
}
/* See description in location.h. */
void
set_event_location_string (struct event_location *location,
set_location_spec_string (struct location_spec *locspec,
std::string &&string)
{
location->as_string = std::move (string);
locspec->as_string = std::move (string);
}

169
gdb/location.h
View File

@@ -1,4 +1,4 @@
/* Data structures and API for event locations in GDB.
/* Data structures and API for location specs in GDB.
Copyright (C) 2013-2022 Free Software Foundation, Inc.
This file is part of GDB.
@@ -22,7 +22,7 @@
#include "symtab.h"
struct language_defn;
struct event_location;
struct location_spec;
/* An enumeration of possible signs for a line offset. */
@@ -50,22 +50,21 @@ struct line_offset
enum offset_relative_sign sign;
};
/* An enumeration of the various ways to specify a stop event
location (used with create_breakpoint). */
/* An enumeration of the various ways to specify a location spec. */
enum event_location_type
enum location_spec_type
{
/* A traditional linespec. */
LINESPEC_LOCATION,
LINESPEC_LOCATION_SPEC,
/* An address in the inferior. */
ADDRESS_LOCATION,
/* An address location spec. */
ADDRESS_LOCATION_SPEC,
/* An explicit location. */
EXPLICIT_LOCATION,
/* An explicit location spec. */
EXPLICIT_LOCATION_SPEC,
/* A probe location. */
PROBE_LOCATION
/* A probe location spec. */
PROBE_LOCATION_SPEC
};
/* A traditional linespec. */
@@ -79,7 +78,7 @@ struct linespec_location
char *spec_string;
};
/* An explicit location. This structure is used to bypass the
/* An explicit location spec. This structure is used to bypass the
parsing done on linespecs. It still has the same requirements
as linespecs, though. For example, source_filename requires
at least one other field. */
@@ -104,136 +103,137 @@ struct explicit_location
struct line_offset line_offset;
};
/* Return the type of the given event location. */
/* Return the type of the given location spec. */
extern enum event_location_type
event_location_type (const struct event_location *);
extern enum location_spec_type
location_spec_type (const location_spec *);
/* Return a linespec string representation of the given explicit
location. The location must already be canonicalized/valid. */
location spec. The location spec must already be
canonicalized/valid. */
extern std::string
explicit_location_to_linespec (const struct explicit_location *explicit_loc);
extern std::string explicit_location_to_linespec
(const explicit_location *explicit_locspec);
/* Return a string representation of the LOCATION.
/* Return a string representation of LOCSPEC.
This function may return NULL for unspecified linespecs,
e.g, LINESPEC_LOCATION and spec_string is NULL.
e.g, LINESPEC_LOCATION_SPEC and spec_string is NULL.
The result is cached in LOCATION. */
The result is cached in LOCSPEC. */
extern const char *
event_location_to_string (struct event_location *location);
location_spec_to_string (location_spec *locspec);
/* A deleter for a struct event_location. */
/* A deleter for a struct location_spec. */
struct event_location_deleter
struct location_spec_deleter
{
void operator() (event_location *location) const;
void operator() (location_spec *locspec) const;
};
/* A unique pointer for event_location. */
typedef std::unique_ptr<event_location, event_location_deleter>
event_location_up;
/* A unique pointer for location_spec. */
typedef std::unique_ptr<location_spec, location_spec_deleter>
location_spec_up;
/* Create a new linespec location. */
/* Create a new linespec location spec. */
extern event_location_up new_linespec_location
extern location_spec_up new_linespec_location_spec
(const char **linespec, symbol_name_match_type match_type);
/* Return the linespec location of the given event_location (which
must be of type LINESPEC_LOCATION). */
/* Return the linespec location spec of the given location_spec (which
must be of type LINESPEC_LOCATION_SPEC). */
extern const linespec_location *
get_linespec_location (const struct event_location *location);
get_linespec_location (const location_spec *locspec);
/* Create a new address location.
ADDR is the address corresponding to this event_location.
/* Create a new address location spec.
ADDR is the address corresponding to this location_spec.
ADDR_STRING, a string of ADDR_STRING_LEN characters, is
the expression that was parsed to determine the address ADDR. */
extern event_location_up new_address_location (CORE_ADDR addr,
extern location_spec_up new_address_location_spec (CORE_ADDR addr,
const char *addr_string,
int addr_string_len);
/* Return the address location (a CORE_ADDR) of the given event_location
(which must be of type ADDRESS_LOCATION). */
/* Return the address (a CORE_ADDR) of the given location_spec, which
must be of type ADDRESS_LOCATION_SPEC. */
extern CORE_ADDR
get_address_location (const struct event_location *location);
get_address_location (const location_spec *locspec);
/* Return the expression (a string) that was used to compute the address
of the given event_location (which must be of type ADDRESS_LOCATION). */
/* Return the expression (a string) that was used to compute the
address of the given location_spec, which must be of type
ADDRESS_LOCATION_SPEC. */
extern const char *
get_address_string_location (const struct event_location *location);
get_address_string_location (const location_spec *locspec);
/* Create a new probe location. */
extern event_location_up new_probe_location (std::string &&probe);
extern location_spec_up new_probe_location_spec (std::string &&probe);
/* Return the probe location (a string) of the given event_location
(which must be of type PROBE_LOCATION). */
/* Return the probe location spec string of the given location_spec,
which must be of type PROBE_LOCATION_SPEC. */
extern const char *
get_probe_location (const struct event_location *location);
get_probe_location_spec_string (const location_spec *locspec);
/* Initialize the given explicit location. */
extern void
initialize_explicit_location (struct explicit_location *explicit_loc);
initialize_explicit_location (explicit_location *locspec);
/* Create a new explicit location. If not NULL, EXPLICIT is checked for
validity. If invalid, an exception is thrown. */
extern event_location_up
new_explicit_location (const struct explicit_location *explicit_loc);
extern location_spec_up
new_explicit_location_spec (const explicit_location *locspec);
/* Return the explicit location of the given event_location
(which must be of type EXPLICIT_LOCATION). */
/* Return the explicit location spec of the given location_spec, which
must be of type EXPLICIT_LOCATION. */
extern struct explicit_location *
get_explicit_location (struct event_location *location);
get_explicit_location (location_spec *locspec);
/* A const version of the above. */
extern const struct explicit_location *
get_explicit_location_const (const struct event_location *location);
extern const explicit_location *
get_explicit_location_const (const location_spec *locspec);
/* Return a copy of the given SRC location. */
/* Return a copy of the given SRC location spec. */
extern event_location_up
copy_event_location (const struct event_location *src);
extern location_spec_up copy_location_spec (const location_spec *src);
/* Attempt to convert the input string in *ARGP into an event_location.
/* Attempt to convert the input string in *ARGP into a location_spec.
ARGP is advanced past any processed input. Always returns a non-nullptr
event_location unique pointer object.
location_spec unique pointer object.
This function may call error() if *ARGP looks like properly formed, but
invalid, input, e.g., if it is called with missing argument parameters
or invalid options.
This function is intended to be used by CLI commands and will parse
explicit locations in a CLI-centric way. Other interfaces should use
string_to_event_location_basic if they want to maintain support for
legacy specifications of probe, address, and linespec locations.
explicit location specs in a CLI-centric way. Other interfaces should use
string_to_location_spec_basic if they want to maintain support for
legacy specifications of probe, address, and linespec location specs.
MATCH_TYPE should be either WILD or FULL. If -q/--qualified is specified
in the input string, it will take precedence over this parameter. */
extern event_location_up string_to_event_location
extern location_spec_up string_to_location_spec
(const char **argp, const struct language_defn *language,
symbol_name_match_type match_type = symbol_name_match_type::WILD);
/* Like string_to_event_location, but does not attempt to parse
explicit locations. MATCH_TYPE indicates how function names should
be matched. */
/* Like string_to_location_spec, but does not attempt to parse
explicit location specs. MATCH_TYPE indicates how function names
should be matched. */
extern event_location_up
string_to_event_location_basic (const char **argp,
extern location_spec_up
string_to_location_spec_basic (const char **argp,
const struct language_defn *language,
symbol_name_match_type match_type);
/* Structure filled in by string_to_explicit_location to aid the
/* Structure filled in by string_to_explicit_location_spec to aid the
completer. */
struct explicit_completion_info
{
@@ -249,35 +249,34 @@ struct explicit_completion_info
const char *quoted_arg_start = NULL;
const char *quoted_arg_end = NULL;
/* True if we saw an explicit location option, as opposed to only
flags that affect both explicit locations and linespecs, like
"-qualified". */
bool saw_explicit_location_option = false;
/* True if we saw an explicit location spec option, as opposed to
only flags that affect both explicit location specs and
linespecs, like "-qualified". */
bool saw_explicit_location_spec_option = false;
};
/* Attempt to convert the input string in *ARGP into an explicit location.
ARGP is advanced past any processed input. Returns an event_location
(malloc'd) if an explicit location was successfully found in *ARGP,
NULL otherwise.
/* Attempt to convert the input string in *ARGP into an explicit
location spec. ARGP is advanced past any processed input. Returns
a location_spec (malloc'd) if an explicit location spec was
successfully found in *ARGP, NULL otherwise.
If COMPLETION_INFO is NULL, this function may call error() if *ARGP
looks like improperly formed input, e.g., if it is called with
missing argument parameters or invalid options. If COMPLETION_INFO
is not NULL, this function will not throw any exceptions. */
extern event_location_up
string_to_explicit_location (const char **argp,
extern location_spec_up
string_to_explicit_location_spec (const char **argp,
const struct language_defn *language,
explicit_completion_info *completion_info);
/* A convenience function for testing for unset locations. */
/* A convenience function for testing for unset location specs. */
extern int event_location_empty_p (const struct event_location *location);
extern int location_spec_empty_p (const location_spec *locspec);
/* Set the location's string representation. */
/* Set the location specs's string representation. */
extern void
set_event_location_string (struct event_location *location,
extern void set_location_spec_string (struct location_spec *locspec,
std::string &&string);
#endif /* LOCATION_H */

10
gdb/mi/mi-cmd-break.c
View File

@@ -179,7 +179,7 @@ mi_cmd_break_insert_1 (int dprintf, const char *command, char **argv, int argc)
int tracepoint = 0;
symbol_name_match_type match_type = symbol_name_match_type::WILD;
enum bptype type_wanted;
event_location_up location;
location_spec_up locspec;
const struct breakpoint_ops *ops;
int is_explicit = 0;
struct explicit_location explicit_loc;
@@ -322,7 +322,7 @@ mi_cmd_break_insert_1 (int dprintf, const char *command, char **argv, int argc)
A simulator or an emulator could conceivably implement fast
regular non-jump based tracepoints. */
type_wanted = hardware ? bp_fast_tracepoint : bp_tracepoint;
ops = breakpoint_ops_for_event_location (nullptr, true);
ops = breakpoint_ops_for_location_spec (nullptr, true);
}
else if (dprintf)
{
@@ -348,17 +348,17 @@ mi_cmd_break_insert_1 (int dprintf, const char *command, char **argv, int argc)
explicit_loc.func_name_match_type = match_type;
location = new_explicit_location (&explicit_loc);
locspec = new_explicit_location_spec (&explicit_loc);
}
else
{
location = string_to_event_location_basic (&address, current_language,
locspec = string_to_location_spec_basic (&address, current_language,
match_type);
if (*address)
error (_("Garbage '%s' at end of location"), address);
}
create_breakpoint (get_current_arch (), location.get (), condition, thread,
create_breakpoint (get_current_arch (), locspec.get (), condition, thread,
extra_string.c_str (),
force_condition,
0 /* condition and thread are valid. */,

8
gdb/probe.c
View File

@@ -114,7 +114,7 @@ parse_probes_in_pspace (const static_probe_ops *spops,
/* See definition in probe.h. */
std::vector<symtab_and_line>
parse_probes (const struct event_location *location,
parse_probes (const location_spec *locspec,
struct program_space *search_pspace,
struct linespec_result *canonical)
{
@@ -122,8 +122,8 @@ parse_probes (const struct event_location *location,
char *objfile_namestr = NULL, *provider = NULL, *name, *p;
const char *arg_start, *cs;
gdb_assert (event_location_type (location) == PROBE_LOCATION);
arg_start = get_probe_location (location);
gdb_assert (location_spec_type (locspec) == PROBE_LOCATION_SPEC);
arg_start = get_probe_location_spec_string (locspec);
cs = arg_start;
const static_probe_ops *spops = probe_linespec_to_static_ops (&cs);
@@ -204,7 +204,7 @@ parse_probes (const struct event_location *location,
std::string canon (arg_start, arg_end - arg_start);
canonical->special_display = 1;
canonical->pre_expanded = 1;
canonical->location = new_probe_location (std::move (canon));
canonical->locspec = new_probe_location_spec (std::move (canon));
}
return result;

4
gdb/probe.h
View File

@@ -22,7 +22,7 @@
#include "symtab.h"
struct event_location;
struct location_spec;
struct linespec_result;
/* Structure useful for passing the header names in the method
@@ -263,7 +263,7 @@ struct bound_probe
throws an error. */
extern std::vector<symtab_and_line> parse_probes
(const struct event_location *loc,
(const location_spec *locspec,
struct program_space *pspace,
struct linespec_result *canon);

16
gdb/python/py-breakpoint.c
View File

@@ -412,8 +412,8 @@ bppy_get_location (PyObject *self, void *closure)
&& obj->bp->type != bp_hardware_breakpoint)
Py_RETURN_NONE;
const char *str = event_location_to_string (obj->bp->location.get ());
if (! str)
const char *str = location_spec_to_string (obj->bp->locspec.get ());
if (str == nullptr)
str = "";
return host_string_to_python_string (str).release ();
}
@@ -821,7 +821,7 @@ bppy_init (PyObject *self, PyObject *args, PyObject *kwargs)
case bp_breakpoint:
case bp_hardware_breakpoint:
{
event_location_up location;
location_spec_up locspec;
symbol_name_match_type func_name_match_type
= (qualified != NULL && PyObject_IsTrue (qualified)
? symbol_name_match_type::FULL
@@ -833,7 +833,7 @@ bppy_init (PyObject *self, PyObject *args, PyObject *kwargs)
copy_holder (xstrdup (skip_spaces (spec)));
const char *copy = copy_holder.get ();
location = string_to_event_location (&copy,
locspec = string_to_location_spec (&copy,
current_language,
func_name_match_type);
}
@@ -852,14 +852,14 @@ bppy_init (PyObject *self, PyObject *args, PyObject *kwargs)
explicit_loc.func_name_match_type = func_name_match_type;
location = new_explicit_location (&explicit_loc);
locspec = new_explicit_location_spec (&explicit_loc);
}
const struct breakpoint_ops *ops =
breakpoint_ops_for_event_location (location.get (), false);
const struct breakpoint_ops *ops
= breakpoint_ops_for_location_spec (locspec.get (), false);
create_breakpoint (gdbpy_enter::get_gdbarch (),
location.get (), NULL, -1, NULL, false,
locspec.get (), NULL, -1, NULL, false,
0,
temporary_bp, type,
0,

6
gdb/python/py-finishbreakpoint.c
View File

@@ -296,10 +296,10 @@ bpfinishpy_init (PyObject *self, PyObject *args, PyObject *kwargs)
try
{
/* Set a breakpoint on the return address. */
event_location_up location
= new_address_location (get_frame_pc (prev_frame), NULL, 0);
location_spec_up locspec
= new_address_location_spec (get_frame_pc (prev_frame), NULL, 0);
create_breakpoint (gdbpy_enter::get_gdbarch (),
location.get (), NULL, thread, NULL, false,
locspec.get (), NULL, thread, NULL, false,
0,
1 /*temp_flag*/,
bp_breakpoint,

8
gdb/python/python.c
View File

@@ -868,7 +868,7 @@ gdbpy_decode_line (PyObject *self, PyObject *args)
const char *arg = NULL;
gdbpy_ref<> result;
gdbpy_ref<> unparsed;
event_location_up location;
location_spec_up locspec;
if (! PyArg_ParseTuple (args, "|s", &arg))
return NULL;
@@ -883,7 +883,7 @@ gdbpy_decode_line (PyObject *self, PyObject *args)
}
if (arg != NULL)
location = string_to_event_location_basic (&arg, current_language,
locspec = string_to_location_spec_basic (&arg, current_language,
symbol_name_match_type::WILD);
std::vector<symtab_and_line> decoded_sals;
@@ -891,9 +891,9 @@ gdbpy_decode_line (PyObject *self, PyObject *args)
gdb::array_view<symtab_and_line> sals;
try
{
if (location != NULL)
if (locspec != NULL)
{
decoded_sals = decode_line_1 (location.get (), 0, NULL, NULL, 0);
decoded_sals = decode_line_1 (locspec.get (), 0, NULL, NULL, 0);
sals = decoded_sals;
}
else

6
gdb/remote.c
View File

@@ -13368,15 +13368,15 @@ remote_target::download_tracepoint (struct bp_location *loc)
if (packet_support (PACKET_TracepointSource) == PACKET_ENABLE)
{
if (b->location != NULL)
if (b->locspec != nullptr)
{
ret = snprintf (buf.data (), buf.size (), "QTDPsrc:");
if (ret < 0 || ret >= buf.size ())
error ("%s", err_msg);
encode_source_string (b->number, loc->address, "at",
event_location_to_string (b->location.get ()),
const char *str = location_spec_to_string (b->locspec.get ());
encode_source_string (b->number, loc->address, "at", str,
buf.data () + strlen (buf.data ()),
buf.size () - strlen (buf.data ()));
putpkt (buf.data ());

4
gdb/tracepoint.c
View File

@@ -2477,10 +2477,10 @@ info_scope_command (const char *args_in, int from_tty)
error (_("requires an argument (function, "
"line or *addr) to define a scope"));
event_location_up location = string_to_event_location (&args,
location_spec_up locspec = string_to_location_spec (&args,
current_language);
std::vector<symtab_and_line> sals
= decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
= decode_line_1 (locspec.get (), DECODE_LINE_FUNFIRSTLINE,
NULL, NULL, 0);
if (sals.empty ())
{