Explicit locations: use new location API

This patch converts the code base to use the new struct event_location
API being introduced. This patch preserves the current functionality and
adds no new features.

The "big picture" API usage introduced by this patch may be illustrated
with a simple exmaple. Where previously developers would write:

void
my_command (char *arg, int from_tty)
{
   create_breakpoint (..., arg, ...);
   ...
}

one now uses:

void
my_command (char *arg, int from_tty)
{
   struct event_locaiton *location;
   struct cleanup *back_to;

   location = string_to_event_locaiton (&arg, ...);
   back_to = make_cleanup_delete_event_location (location);
   create_breakpoint (..., location, ...);
   do_cleanups (back_to);
}

Linespec-decoding functions (now called location-decoding) such as
decode_line_full no longer skip argument pointers over processed input.
That functionality has been moved into string_to_event_location as
demonstrated above.

gdb/ChangeLog

	* ax-gdb.c: Include location.h.
	(agent_command_1) Use linespec location instead of address
	string.
	* break-catch-throw.c: Include location.h.
	(re_set_exception_catchpoint): Use linespec locations instead
	of address strings.
	* breakpoint.c: Include location.h.
	(create_overlay_event_breakpoint, create_longjmp_master_breakpoint)
	(create_std_terminate_master_breakpoint)
	(create_exception_master_breakpoint, update_breakpoints_after_exec):
	Use linespec location instead of address string.
	(print_breakpoint_location):  Use locations and
	event_location_to_string.
	Print extra_string for pending locations for non-MI streams.
	(print_one_breakpoint_location): Use locations and
	event_location_to_string.
	(init_raw_breakpoint_without_location): Initialize b->location.
	(create_thread_event_breakpoint): Use linespec location instead of
	address string.
	(init_breakpoint_sal): Likewise.
	Only save extra_string if it is non-NULL and not the empty string.
	Use event_location_to_string instead of `addr_string'.
	Constify `p' and `endp'.
	Use skip_spaces_const/skip_space_const instead of non-const versions.
	Copy the location into the breakpoint.
	If LOCATION is NULL, save the breakpoint address as a linespec location
	instead of an address string.
	(create_breakpoint_sal): Change `addr_string' parameter to a struct
	event_location. All uses updated.
	(create_breakpoints_sal): Likewise for local variable `addr_string'.
	(parse_breakpoint_sals): Use locations instead of address strings.
	Remove check for empty linespec with conditional.
	Refactor.
	(decode_static_tracepoint_spec): Make argument const and update
	function.
	(create_breakpoint): Change `arg' to a struct event_location and
	rename.
	Remove `copy_arg' and `addr_start'.
	If EXTRA_STRING is empty, set it to NULL.
	Don't populate `canonical' for pending breakpoints.
	Pass `extra_string' to find_condition_and_thread.
	Clear `extra_string' if `rest' was NULL.
	Do not error with "garbage after location" if setting a dprintf
	breakpoint.
	Copy the location into the breakpoint instead of an address string.
	(break_command_1): Use string_to_event_location and pass this to
	create_breakpoint instead of an address string.
	Check against `arg_cp' for a probe linespec.
	(dprintf_command): Use string_to_event_location and pass this to
	create_breakpoint instead of an address string.
	Throw an exception if no format string was specified.
	(print_recreate_ranged_breakpoint): Use event_location_to_string
	instead of address strings.
	(break_range_command, until_break_command)
	(init_ada_exception_breakpoint): Use locations instead
	of address strings.
	(say_where): Print out extra_string for pending locations.
	(base_breakpoint_dtor): Delete `location' and `location_range_end' of
	the breakpoint.
	(base_breakpoint_create_sals_from_location): Use struct event_location
	instead of address string.
	Remove `addr_start' and `copy_arg' parameters.
	(base_breakpoint_decode_location): Use struct event_location instead of
	address string.
	(bkpt_re_set): Use locations instead of address strings.
	Use event_location_empty_p to check for unset location.
	(bkpt_print_recreate): Use event_location_to_string instead of
	an address string.
	Print out extra_string for pending locations.
	(bkpt_create_sals_from_location, bkpt_decode_location)
 	(bkpt_probe_create_sals_from_location): Use struct event_location
	instead of address string.
	(bkpt_probe_decode_location): Use struct event_location instead of
	address string.
	(tracepoint_print_recreate): Use event_location_to_string to
	recreate the tracepoint.
	(tracepoint_create_sals_from_location, tracepoint_decode_location)
	(tracepoint_probe_create_sals_from_location)
	(tracepoint_probe_decode_location): Use struct event_location
	instead of address string.
	(dprintf_print_recreate): Use event_location_to_string to recreate
	the dprintf.
	(dprintf_re_set): Remove check for valid/missing format string.
	(strace_marker_create_sals_from_location)
	(strace_marker_create_breakpoints_sal, strace_marker_decode_location)
	(update_static_tracepoint): Use struct event_location instead of
	address string.
	(location_to_sals): Likewise.
	Pass `extra_string' to find_condition_and_thread.
	For newly resolved pending breakpoint locations, clear the location's
	string representation.
	Assert that the breakpoint's condition string is NULL when
	condition_not_parsed.
	(breakpoint_re_set_default, create_sals_from_location_default)
	(decode_location_default, trace_command, ftrace_command)
	(strace_command, create_tracepoint_from_upload): Use locations
	instead of address strings.
	* breakpoint.h (struct breakpoint_ops) <create_sals_from_location>:
	Use struct event_location instead of address string.
	Update all uses.
	<decode_location>: Likewise.
	(struct breakpoint) <addr_string>: Change to struct event_location
	and rename `location'.
	<addr_string_range_end>: Change to struct event_location and rename
	`location_range_end'.
	(create_breakpoint): Use struct event_location instead of address
	string.
	* cli/cli-cmds.c: Include location.h.
	(edit_command, list_command): Use locations instead of address strings.
	* elfread.c: Include location.h.
	(elf_gnu_ifunc_resolver_return_stop): Use event_location_to_string.
	* guile/scm-breakpoint.c: Include location.h.
	(bpscm_print_breakpoint_smob): Use event_location_to_string.
	(gdbscm_register_breakpoint): Use locations instead of address
	strings.
	* linespec.c: Include location.h.
	(struct ls_parser) <stream>: Change to const char *.
	(PARSER_STREAM): Update.
	(lionespec_lexer_lex_keyword): According to find_condition_and_thread,
	keywords must be followed by whitespace.
	(canonicalize_linespec): Save a linespec location into `canonical'.
	Save a canonical linespec into `canonical'.
	(parse_linespec): Change `argptr' to const char * and rename `arg'.
	All uses updated.
	Update function description.
	(linespec_parser_new): Initialize `parser'.
	Update initialization of  parsing stream.
	(event_location_to_sals): New function.
	(decode_line_full): Change `argptr' to a struct event_location and
	rename it `location'.
	Use locations instead of address strings.
	Call event_location_to_sals instead of parse_linespec.
	(decode_line_1): Likewise.
	(decode_line_with_current_source, decode_line_with_last_displayed)
	Use locations instead of address strings.
	(decode_objc): Likewise.
	Change `argptr' to const char * and rename `arg'.
	(destroy_linespec_result): Delete the linespec result's location
	instead of freeing the address string.
	* linespec.h (struct linespec_result) <addr_string>: Change to
	struct event_location and rename to ...
	<location>: ... this.
	(decode_line_1, decode_line_full): Change `argptr' to struct
	event_location.  All callers updated.
	* mi/mi-cmd-break.c: Include language.h, location.h, and linespec.h.
	(mi_cmd_break_insert_1): Use locations instead of address strings.
	Throw an error if there was "garbage" at the end of the specified
	linespec.
	* probe.c: Include location.h.
	(parse_probes): Change `argptr' to struct event_location.
	Use event locations instead of address strings.
	* probe.h (parse_probes): Change `argptr' to struct event_location.
	* python/py-breakpoint.c: Include location.h.
	(bppy_get_location): Constify local variable `str'.
	Use event_location_to_string.
	(bppy_init): Use locations instead of address strings.
	* python/py-finishbreakpoint.c: Include location.h.
	(bpfinishpy_init): Remove local variable `addr_str'.
	Use locations instead of address strings.
	* python/python.c: Include location.h.
	(gdbpy_decode_line): Use locations instead of address strings.
	* remote.c: Include location.h.
	(remote_download_tracepoint): Use locations instead of address
	strings.
	* spu-tdep.c: Include location.h.
	(spu_catch_start): Remove local variable `buf'.
	Use locations instead of address strings.
	* tracepoint.c: Include location.h.
	(scope_info): Use locations instead of address strings.
	(encode_source_string): Constify parameter `src'.
	* tracepoint.h (encode_source_string): Likewise.

gdb/testsuite/ChangeLog

	* gdb.base/dprintf-pending.exp: Update dprintf "without format"
	test.
	Add tests for missing ",FMT" and ",".

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 7b6be92c779bb432a56dcf3c98fae3aa3ff7c808..f6dc1b6f3711187dde63847129b0ef3791a1aa81 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,177 @@
+2015-08-11  Keith Seitz  <keiths@redhat.com>
+
+       * ax-gdb.c: Include location.h.
+       (agent_command_1) Use linespec location instead of address
+       string.
+       * break-catch-throw.c: Include location.h.
+       (re_set_exception_catchpoint): Use linespec locations instead
+       of address strings.
+       * breakpoint.c: Include location.h.
+       (create_overlay_event_breakpoint, create_longjmp_master_breakpoint)
+       (create_std_terminate_master_breakpoint)
+       (create_exception_master_breakpoint, update_breakpoints_after_exec):
+       Use linespec location instead of address string.
+       (print_breakpoint_location):  Use locations and
+       event_location_to_string.
+       Print extra_string for pending locations for non-MI streams.
+       (print_one_breakpoint_location): Use locations and
+       event_location_to_string.
+       (init_raw_breakpoint_without_location): Initialize b->location.
+       (create_thread_event_breakpoint): Use linespec location instead of
+       address string.
+       (init_breakpoint_sal): Likewise.
+       Only save extra_string if it is non-NULL and not the empty string.
+       Use event_location_to_string instead of `addr_string'.
+       Constify `p' and `endp'.
+       Use skip_spaces_const/skip_space_const instead of non-const versions.
+       Copy the location into the breakpoint.
+       If LOCATION is NULL, save the breakpoint address as a linespec location
+       instead of an address string.
+       (create_breakpoint_sal): Change `addr_string' parameter to a struct
+       event_location. All uses updated.
+       (create_breakpoints_sal): Likewise for local variable `addr_string'.
+       (parse_breakpoint_sals): Use locations instead of address strings.
+       Remove check for empty linespec with conditional.
+       Refactor.
+       (decode_static_tracepoint_spec): Make argument const and update
+       function.
+       (create_breakpoint): Change `arg' to a struct event_location and
+       rename.
+       Remove `copy_arg' and `addr_start'.
+       If EXTRA_STRING is empty, set it to NULL.
+       Don't populate `canonical' for pending breakpoints.
+       Pass `extra_string' to find_condition_and_thread.
+       Clear `extra_string' if `rest' was NULL.
+       Do not error with "garbage after location" if setting a dprintf
+       breakpoint.
+       Copy the location into the breakpoint instead of an address string.
+       (break_command_1): Use string_to_event_location and pass this to
+       create_breakpoint instead of an address string.
+       Check against `arg_cp' for a probe linespec.
+       (dprintf_command): Use string_to_event_location and pass this to
+       create_breakpoint instead of an address string.
+       Throw an exception if no format string was specified.
+       (print_recreate_ranged_breakpoint): Use event_location_to_string
+       instead of address strings.
+       (break_range_command, until_break_command)
+       (init_ada_exception_breakpoint): Use locations instead
+       of address strings.
+       (say_where): Print out extra_string for pending locations.
+       (base_breakpoint_dtor): Delete `location' and `location_range_end' of
+       the breakpoint.
+       (base_breakpoint_create_sals_from_location): Use struct event_location
+       instead of address string.
+       Remove `addr_start' and `copy_arg' parameters.
+       (base_breakpoint_decode_location): Use struct event_location instead of
+       address string.
+       (bkpt_re_set): Use locations instead of address strings.
+       Use event_location_empty_p to check for unset location.
+       (bkpt_print_recreate): Use event_location_to_string instead of
+       an address string.
+       Print out extra_string for pending locations.
+       (bkpt_create_sals_from_location, bkpt_decode_location)
+       (bkpt_probe_create_sals_from_location): Use struct event_location
+       instead of address string.
+       (bkpt_probe_decode_location): Use struct event_location instead of
+       address string.
+       (tracepoint_print_recreate): Use event_location_to_string to
+       recreate the tracepoint.
+       (tracepoint_create_sals_from_location, tracepoint_decode_location)
+       (tracepoint_probe_create_sals_from_location)
+       (tracepoint_probe_decode_location): Use struct event_location
+       instead of address string.
+       (dprintf_print_recreate): Use event_location_to_string to recreate
+       the dprintf.
+       (dprintf_re_set): Remove check for valid/missing format string.
+       (strace_marker_create_sals_from_location)
+       (strace_marker_create_breakpoints_sal, strace_marker_decode_location)
+       (update_static_tracepoint): Use struct event_location instead of
+       address string.
+       (location_to_sals): Likewise.
+       Pass `extra_string' to find_condition_and_thread.
+       For newly resolved pending breakpoint locations, clear the location's
+       string representation.
+       Assert that the breakpoint's condition string is NULL when
+       condition_not_parsed.
+       (breakpoint_re_set_default, create_sals_from_location_default)
+       (decode_location_default, trace_command, ftrace_command)
+       (strace_command, create_tracepoint_from_upload): Use locations
+       instead of address strings.
+       * breakpoint.h (struct breakpoint_ops) <create_sals_from_location>:
+       Use struct event_location instead of address string.
+       Update all uses.
+       <decode_location>: Likewise.
+       (struct breakpoint) <addr_string>: Change to struct event_location
+       and rename `location'.
+       <addr_string_range_end>: Change to struct event_location and rename
+       `location_range_end'.
+       (create_breakpoint): Use struct event_location instead of address
+       string.
+       * cli/cli-cmds.c: Include location.h.
+       (edit_command, list_command): Use locations instead of address strings.
+       * elfread.c: Include location.h.
+       (elf_gnu_ifunc_resolver_return_stop): Use event_location_to_string.
+       * guile/scm-breakpoint.c: Include location.h.
+       (bpscm_print_breakpoint_smob): Use event_location_to_string.
+       (gdbscm_register_breakpoint): Use locations instead of address
+       strings.
+       * linespec.c: Include location.h.
+       (struct ls_parser) <stream>: Change to const char *.
+       (PARSER_STREAM): Update.
+       (lionespec_lexer_lex_keyword): According to find_condition_and_thread,
+       keywords must be followed by whitespace.
+       (canonicalize_linespec): Save a linespec location into `canonical'.
+       Save a canonical linespec into `canonical'.
+       (parse_linespec): Change `argptr' to const char * and rename `arg'.
+       All uses updated.
+       Update function description.
+       (linespec_parser_new): Initialize `parser'.
+       Update initialization of  parsing stream.
+       (event_location_to_sals): New function.
+       (decode_line_full): Change `argptr' to a struct event_location and
+       rename it `location'.
+       Use locations instead of address strings.
+       Call event_location_to_sals instead of parse_linespec.
+       (decode_line_1): Likewise.
+       (decode_line_with_current_source, decode_line_with_last_displayed)
+       Use locations instead of address strings.
+       (decode_objc): Likewise.
+       Change `argptr' to const char * and rename `arg'.
+       (destroy_linespec_result): Delete the linespec result's location
+       instead of freeing the address string.
+       * linespec.h (struct linespec_result) <addr_string>: Change to
+       struct event_location and rename to ...
+       <location>: ... this.
+       (decode_line_1, decode_line_full): Change `argptr' to struct
+       event_location.  All callers updated.
+       * mi/mi-cmd-break.c: Include language.h, location.h, and linespec.h.
+       (mi_cmd_break_insert_1): Use locations instead of address strings.
+       Throw an error if there was "garbage" at the end of the specified
+       linespec.
+       * probe.c: Include location.h.
+       (parse_probes): Change `argptr' to struct event_location.
+       Use event locations instead of address strings.
+       * probe.h (parse_probes): Change `argptr' to struct event_location.
+       * python/py-breakpoint.c: Include location.h.
+       (bppy_get_location): Constify local variable `str'.
+       Use event_location_to_string.
+       (bppy_init): Use locations instead of address strings.
+       * python/py-finishbreakpoint.c: Include location.h.
+       (bpfinishpy_init): Remove local variable `addr_str'.
+       Use locations instead of address strings.
+       * python/python.c: Include location.h.
+       (gdbpy_decode_line): Use locations instead of address strings.
+       * remote.c: Include location.h.
+       (remote_download_tracepoint): Use locations instead of address
+       strings.
+       * spu-tdep.c: Include location.h.
+       (spu_catch_start): Remove local variable `buf'.
+       Use locations instead of address strings.
+       * tracepoint.c: Include location.h.
+       (scope_info): Use locations instead of address strings.
+       (encode_source_string): Constify parameter `src'.
+       * tracepoint.h (encode_source_string): Likewise.
+
 2015-08-11  Keith Seitz  <keiths@redhat.com>
 
        * Makefile.in (SFILES): Add location.c.

diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index 38f2c55f7194205fb3df583a3f5651c7c242f105..817fa53ed90b2f33f6c54ab79bde707df3976c9f 100644 (file)
--- a/gdb/ax-gdb.c
+++ b/gdb/ax-gdb.c
@@ -40,6 +40,7 @@
 #include "arch-utils.h"
 #include "cli/cli-utils.h"
 #include "linespec.h"
+#include "location.h"
 #include "objfiles.h"
 
 #include "valprint.h"
@@ -2642,13 +2643,16 @@ agent_command_1 (char *exp, int eval)
       int ix;
       struct linespec_sals *iter;
       struct cleanup *old_chain;
+      struct event_location *location;
 
       exp = skip_spaces (exp);
       init_linespec_result (&canonical);
-      decode_line_full (&exp, DECODE_LINE_FUNFIRSTLINE,
+      location = new_linespec_location (&exp);
+      old_chain = make_cleanup_delete_event_location (location);
+      decode_line_full (location, DECODE_LINE_FUNFIRSTLINE,
                        (struct symtab *) NULL, 0, &canonical,
                        NULL, NULL);
-      old_chain = make_cleanup_destroy_linespec_result (&canonical);
+      make_cleanup_destroy_linespec_result (&canonical);
       exp = skip_spaces (exp);
       if (exp[0] == ',')
         {

diff --git a/gdb/break-catch-throw.c b/gdb/break-catch-throw.c
index 927176f9613944ffa8255bc66ead3adf386f06e3..9449aa5f38131e50b99f3586aee10317dd2174d6 100644 (file)
--- a/gdb/break-catch-throw.c
+++ b/gdb/break-catch-throw.c
@@ -35,6 +35,7 @@
 #include "cp-abi.h"
 #include "gdb_regex.h"
 #include "cp-support.h"
+#include "location.h"
 
 /* Enums for exception-handling support.  */
 enum exception_event_kind
@@ -210,25 +211,31 @@ re_set_exception_catchpoint (struct breakpoint *self)
   struct symtabs_and_lines sals_end = {0};
   struct cleanup *cleanup;
   enum exception_event_kind kind = classify_exception_breakpoint (self);
+  struct event_location *location;
 
   /* We first try to use the probe interface.  */
   TRY
     {
       char *spec = ASTRDUP (exception_functions[kind].probe);
 
-      sals = parse_probes (&spec, NULL);
+      location = new_linespec_location (&spec);
+      cleanup = make_cleanup_delete_event_location (location);
+      sals = parse_probes (location, NULL);
+      do_cleanups (cleanup);
     }
 
   CATCH (e, RETURN_MASK_ERROR)
     {
-
       /* Using the probe interface failed.  Let's fallback to the normal
         catchpoint mode.  */
       TRY
        {
          char *spec = ASTRDUP (exception_functions[kind].function);
 
-         self->ops->decode_location (self, &spec, &sals);
+         location = new_linespec_location (&spec);
+         cleanup = make_cleanup_delete_event_location (location);
+         self->ops->decode_location (self, location, &sals);
+         do_cleanups (cleanup);
        }
       CATCH (ex, RETURN_MASK_ERROR)
        {

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 1d1cb03a023949ab682dfcb3340197033803fa03..395da1f4d36f95e8588e261cecc9648be6b6539c 100644 (file)
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -67,6 +67,7 @@
 #include "dummy-frame.h"
 #include "interps.h"
 #include "format.h"
+#include "location.h"
 
 /* readline include files */
 #include "readline/readline.h"
@@ -108,10 +109,10 @@ static int breakpoint_re_set_one (void *);
 
 static void breakpoint_re_set_default (struct breakpoint *);
 
-static void create_sals_from_location_default (char **,
-                                              struct linespec_result *,
-                                              enum bptype, char *,
-                                              char **);
+static void
+  create_sals_from_location_default (const struct event_location *location,
+                                    struct linespec_result *canonical,
+                                    enum bptype type_wanted);
 
 static void create_breakpoints_sal_default (struct gdbarch *,
                                            struct linespec_result *,
@@ -121,8 +122,9 @@ static void create_breakpoints_sal_default (struct gdbarch *,
                                            const struct breakpoint_ops *,
                                            int, int, int, unsigned);
 
-static void decode_location_default (struct breakpoint *, char **,
-                                    struct symtabs_and_lines *);
+static void decode_location_default (struct breakpoint *b,
+                                    const struct event_location *location,
+                                    struct symtabs_and_lines *sals);
 
 static void clear_command (char *, int);
 
@@ -3422,6 +3424,7 @@ create_overlay_event_breakpoint (void)
       struct breakpoint *b;
       struct breakpoint_objfile_data *bp_objfile_data;
       CORE_ADDR addr;
+      char *p;
 
       bp_objfile_data = get_breakpoint_objfile_data (objfile);
 
@@ -3446,7 +3449,8 @@ create_overlay_event_breakpoint (void)
       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
                                       bp_overlay_event,
                                      &internal_breakpoint_ops);
-      b->addr_string = xstrdup (func_name);
+      p = ASTRDUP (func_name);
+      b->location = new_linespec_location (&p);
 
       if (overlay_debugging == ovly_auto)
         {
@@ -3513,6 +3517,7 @@ create_longjmp_master_breakpoint (void)
          int i;
          struct probe *probe;
          struct gdbarch *gdbarch = get_objfile_arch (objfile);
+         char *p;
 
          for (i = 0;
               VEC_iterate (probe_p,
@@ -3527,7 +3532,8 @@ create_longjmp_master_breakpoint (void)
                                                                 objfile),
                                              bp_longjmp_master,
                                              &internal_breakpoint_ops);
-             b->addr_string = xstrdup ("-probe-stap libc:longjmp");
+             p = ASTRDUP ("-probe-stap libc:longjmp");
+             b->location = new_linespec_location (&p);
              b->enable_state = bp_disabled;
            }
 
@@ -3542,6 +3548,7 @@ create_longjmp_master_breakpoint (void)
          struct breakpoint *b;
          const char *func_name;
          CORE_ADDR addr;
+         char *p;
 
          if (msym_not_found_p (bp_objfile_data->longjmp_msym[i].minsym))
            continue;
@@ -3564,7 +3571,8 @@ create_longjmp_master_breakpoint (void)
          addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
          b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master,
                                          &internal_breakpoint_ops);
-         b->addr_string = xstrdup (func_name);
+         p = ASTRDUP (func_name);
+         b->location = new_linespec_location (&p);
          b->enable_state = bp_disabled;
        }
     }
@@ -3595,6 +3603,7 @@ create_std_terminate_master_breakpoint (void)
     {
       struct breakpoint *b;
       struct breakpoint_objfile_data *bp_objfile_data;
+      char *p;
 
       bp_objfile_data = get_breakpoint_objfile_data (objfile);
 
@@ -3620,7 +3629,8 @@ create_std_terminate_master_breakpoint (void)
       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
                                       bp_std_terminate_master,
                                      &internal_breakpoint_ops);
-      b->addr_string = xstrdup (func_name);
+      p = ASTRDUP (func_name);
+      b->location = new_linespec_location (&p);
       b->enable_state = bp_disabled;
     }
   }
@@ -3644,6 +3654,7 @@ create_exception_master_breakpoint (void)
       struct gdbarch *gdbarch;
       struct breakpoint_objfile_data *bp_objfile_data;
       CORE_ADDR addr;
+      char *p;
 
       bp_objfile_data = get_breakpoint_objfile_data (objfile);
 
@@ -3684,13 +3695,15 @@ create_exception_master_breakpoint (void)
               ++i)
            {
              struct breakpoint *b;
+             char *p;
 
              b = create_internal_breakpoint (gdbarch,
                                              get_probe_address (probe,
                                                                 objfile),
                                              bp_exception_master,
                                              &internal_breakpoint_ops);
-             b->addr_string = xstrdup ("-probe-stap libgcc:unwind");
+             p = ASTRDUP ("-probe-stap libgcc:unwind");
+             b->location = new_linespec_location (&p);
              b->enable_state = bp_disabled;
            }
 
@@ -3723,7 +3736,8 @@ create_exception_master_breakpoint (void)
                                                 &current_target);
       b = create_internal_breakpoint (gdbarch, addr, bp_exception_master,
                                      &internal_breakpoint_ops);
-      b->addr_string = xstrdup (func_name);
+      p = ASTRDUP (func_name);
+      b->location = new_linespec_location (&p);
       b->enable_state = bp_disabled;
     }
 
@@ -3844,7 +3858,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 (b->addr_string == NULL)
+    if (event_location_empty_p (b->location))
       {
        delete_breakpoint (b);
        continue;
@@ -6032,7 +6046,8 @@ print_breakpoint_location (struct breakpoint *b,
     set_current_program_space (loc->pspace);
 
   if (b->display_canonical)
-    ui_out_field_string (uiout, "what", b->addr_string);
+    ui_out_field_string (uiout, "what",
+                        event_location_to_string (b->location));
   else if (loc && loc->symtab)
     {
       struct symbol *sym 
@@ -6068,7 +6083,21 @@ print_breakpoint_location (struct breakpoint *b,
       do_cleanups (stb_chain);
     }
   else
-    ui_out_field_string (uiout, "pending", b->addr_string);
+    {
+      ui_out_field_string (uiout, "pending",
+                          event_location_to_string (b->location));
+      /* 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.  */
+      if (!ui_out_is_mi_like_p (uiout) && b->extra_string != NULL)
+       {
+         if (b->type == bp_dprintf)
+           ui_out_text (uiout, ",");
+         else
+           ui_out_text (uiout, " ");
+         ui_out_text (uiout, b->extra_string);
+       }
+    }
 
   if (loc && is_breakpoint (b)
       && breakpoint_condition_evaluation_mode () == condition_evaluation_target
@@ -6537,8 +6566,10 @@ print_one_breakpoint_location (struct breakpoint *b,
 
          ui_out_field_string (uiout, "original-location", w->exp_string);
        }
-      else if (b->addr_string)
-       ui_out_field_string (uiout, "original-location", b->addr_string);
+      else if (b->location != NULL
+              && event_location_to_string (b->location) != NULL)
+       ui_out_field_string (uiout, "original-location",
+                            event_location_to_string (b->location));
     }
 }
 
@@ -7308,6 +7339,7 @@ init_raw_breakpoint_without_location (struct breakpoint *b,
   b->condition_not_parsed = 0;
   b->py_bp_object = NULL;
   b->related_breakpoint = b;
+  b->location = NULL;
 }
 
 /* Helper to set_raw_breakpoint below.  Creates a breakpoint
@@ -7628,15 +7660,19 @@ delete_std_terminate_breakpoint (void)
 struct breakpoint *
 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
 {
+  char *tmp;
   struct breakpoint *b;
+  struct cleanup *cleanup;
 
   b = create_internal_breakpoint (gdbarch, address, bp_thread_event,
                                  &internal_breakpoint_ops);
 
   b->enable_state = bp_enabled;
-  /* addr_string has to be used or breakpoint_re_set will delete me.  */
-  b->addr_string
-    = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
+  /* location has to be used or breakpoint_re_set will delete me.  */
+  tmp = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
+  cleanup = make_cleanup (xfree, tmp);
+  b->location = new_linespec_location (&tmp);
+  do_cleanups (cleanup);
 
   update_global_location_list_nothrow (UGLL_MAY_INSERT);
 
@@ -9070,13 +9106,14 @@ update_dprintf_commands (char *args, int from_tty,
     }
 }
 
-/* Create a breakpoint with SAL as location.  Use ADDR_STRING
-   as textual description of the location, and COND_STRING
+/* Create a breakpoint with SAL as location.  Use LOCATION
+   as a description of the location, and COND_STRING
    as condition expression.  */
 
 static void
 init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
-                    struct symtabs_and_lines sals, char *addr_string,
+                    struct symtabs_and_lines sals,
+                    struct event_location *location,
                     char *filter, char *cond_string,
                     char *extra_string,
                     enum bptype type, enum bpdisp disposition,
@@ -9142,13 +9179,13 @@ init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
                {
                  /* We already know the marker exists, otherwise, we
                     wouldn't see a sal for it.  */
-                 char *p = &addr_string[3];
-                 char *endp;
+                 const char *p = &event_location_to_string (b->location)[3];
+                 const char *endp;
                  char *marker_str;
 
-                 p = skip_spaces (p);
+                 p = skip_spaces_const (p);
 
-                 endp = skip_to_space (p);
+                 endp = skip_to_space_const (p);
 
                  marker_str = savestring (p, endp - p);
                  t->static_trace_marker_id = marker_str;
@@ -9204,19 +9241,26 @@ init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
     }
 
   b->display_canonical = display_canonical;
-  if (addr_string)
-    b->addr_string = addr_string;
+  if (location != NULL)
+    b->location = location;
   else
-    /* addr_string has to be used or breakpoint_re_set will delete
-       me.  */
-    b->addr_string
-      = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
+    {
+      char *tmp;
+      struct cleanup *cleanup;
+
+      tmp = xstrprintf ("*%s",
+                           paddress (b->loc->gdbarch, b->loc->address));
+      cleanup = make_cleanup (xfree, tmp);
+      b->location = new_linespec_location (&tmp);
+      do_cleanups (cleanup);
+   }
   b->filter = filter;
 }
 
 static void
 create_breakpoint_sal (struct gdbarch *gdbarch,
-                      struct symtabs_and_lines sals, char *addr_string,
+                      struct symtabs_and_lines sals,
+                      struct event_location *location,
                       char *filter, char *cond_string,
                       char *extra_string,
                       enum bptype type, enum bpdisp disposition,
@@ -9241,7 +9285,7 @@ create_breakpoint_sal (struct gdbarch *gdbarch,
   old_chain = make_cleanup (xfree, b);
 
   init_breakpoint_sal (b, gdbarch,
-                      sals, addr_string,
+                      sals, location,
                       filter, cond_string, extra_string,
                       type, disposition,
                       thread, task, ignore_count,
@@ -9285,17 +9329,17 @@ create_breakpoints_sal (struct gdbarch *gdbarch,
 
   for (i = 0; VEC_iterate (linespec_sals, canonical->sals, i, lsal); ++i)
     {
-      /* Note that 'addr_string' can be NULL in the case of a plain
+      /* Note that 'location' can be NULL in the case of a plain
         'break', without arguments.  */
-      char *addr_string = (canonical->addr_string
-                          ? xstrdup (canonical->addr_string)
-                          : NULL);
+      struct event_location *location
+       = (canonical->location != NULL
+          ? copy_event_location (canonical->location) : NULL);
       char *filter_string = lsal->canonical ? xstrdup (lsal->canonical) : NULL;
-      struct cleanup *inner = make_cleanup (xfree, addr_string);
+      struct cleanup *inner = make_cleanup_delete_event_location (location);
 
       make_cleanup (xfree, filter_string);
       create_breakpoint_sal (gdbarch, lsal->sals,
-                            addr_string,
+                            location,
                             filter_string,
                             cond_string, extra_string,
                             type, disposition,
@@ -9306,83 +9350,97 @@ create_breakpoints_sal (struct gdbarch *gdbarch,
     }
 }
 
-/* Parse ADDRESS which is assumed to be a SAL specification possibly
+/* Parse LOCATION which is assumed to be a SAL specification possibly
    followed by conditionals.  On return, SALS contains an array of SAL
-   addresses found.  ADDR_STRING contains a vector of (canonical)
-   address strings.  ADDRESS points to the end of the SAL.
+   addresses found.  LOCATION points to the end of the SAL (for
+   linespec locations).
 
    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 (char **address,
+parse_breakpoint_sals (const struct event_location *location,
                       struct linespec_result *canonical)
 {
-  /* If no arg given, or if first arg is 'if ', use the default
-     breakpoint.  */
-  if ((*address) == NULL || linespec_lexer_lex_keyword (*address))
-    {
-      /* The last displayed codepoint, if it's valid, is our default breakpoint
-         address.  */
-      if (last_displayed_sal_is_valid ())
-       {
-         struct linespec_sals lsal;
-         struct symtab_and_line sal;
-         CORE_ADDR pc;
-
-         init_sal (&sal);              /* Initialize to zeroes.  */
-         lsal.sals.sals = (struct symtab_and_line *)
-           xmalloc (sizeof (struct symtab_and_line));
-
-         /* Set sal's pspace, pc, symtab, and line to the values
-            corresponding to the last call to print_frame_info.
-            Be sure to reinitialize LINE with NOTCURRENT == 0
-            as the breakpoint line number is inappropriate otherwise.
-            find_pc_line would adjust PC, re-set it back.  */
-         get_last_displayed_sal (&sal);
-         pc = sal.pc;
-         sal = find_pc_line (pc, 0);
-
-         /* "break" without arguments is equivalent to "break *PC"
-            where PC is the last displayed codepoint's address.  So
-            make sure to set sal.explicit_pc to prevent GDB from
-            trying to expand the list of sals to include all other
-            instances with the same symtab and line.  */
-         sal.pc = pc;
-         sal.explicit_pc = 1;
-
-         lsal.sals.sals[0] = sal;
-         lsal.sals.nelts = 1;
-         lsal.canonical = NULL;
-
-         VEC_safe_push (linespec_sals, canonical->sals, &lsal);
+  struct symtab_and_line cursal;
+
+  if (event_location_type (location) == LINESPEC_LOCATION)
+    {
+      const char *address = get_linespec_location (location);
+
+      if (address == NULL)
+       {
+         /* The last displayed codepoint, if it's valid, is our default
+            breakpoint address.  */
+         if (last_displayed_sal_is_valid ())
+           {
+             struct linespec_sals lsal;
+             struct symtab_and_line sal;
+             CORE_ADDR pc;
+
+             init_sal (&sal);          /* Initialize to zeroes.  */
+             lsal.sals.sals = (struct symtab_and_line *)
+               xmalloc (sizeof (struct symtab_and_line));
+
+             /* Set sal's pspace, pc, symtab, and line to the values
+                corresponding to the last call to print_frame_info.
+                Be sure to reinitialize LINE with NOTCURRENT == 0
+                as the breakpoint line number is inappropriate otherwise.
+                find_pc_line would adjust PC, re-set it back.  */
+             get_last_displayed_sal (&sal);
+             pc = sal.pc;
+             sal = find_pc_line (pc, 0);
+
+             /* "break" without arguments is equivalent to "break *PC"
+                where PC is the last displayed codepoint's address.  So
+                make sure to set sal.explicit_pc to prevent GDB from
+                trying to expand the list of sals to include all other
+                instances with the same symtab and line.  */
+             sal.pc = pc;
+             sal.explicit_pc = 1;
+
+             lsal.sals.sals[0] = sal;
+             lsal.sals.nelts = 1;
+             lsal.canonical = NULL;
+
+             VEC_safe_push (linespec_sals, canonical->sals, &lsal);
+             return;
+           }
+         else
+           error (_("No default breakpoint address now."));
        }
-      else
-       error (_("No default breakpoint address now."));
     }
-  else
+
+  /* Force almost all breakpoints to be in terms of the
+     current_source_symtab (which is decode_line_1's default).
+     This should produce the results we want almost all of the
+     time while leaving default_breakpoint_* alone.
+
+     ObjC: However, don't match an Objective-C method name which
+     may have a '+' or '-' succeeded by a '['.  */
+  cursal = get_current_source_symtab_and_line ();
+  if (last_displayed_sal_is_valid ())
     {
-      struct symtab_and_line cursal = get_current_source_symtab_and_line ();
+      const char *address = NULL;
 
-      /* Force almost all breakpoints to be in terms of the
-         current_source_symtab (which is decode_line_1's default).
-         This should produce the results we want almost all of the
-         time while leaving default_breakpoint_* alone.
+      if (event_location_type (location) == LINESPEC_LOCATION)
+       address = get_linespec_location (location);
 
-        ObjC: However, don't match an Objective-C method name which
-        may have a '+' or '-' succeeded by a '['.  */
-      if (last_displayed_sal_is_valid ()
-         && (!cursal.symtab
-             || ((strchr ("+-", (*address)[0]) != NULL)
-                 && ((*address)[1] != '['))))
-       decode_line_full (address, DECODE_LINE_FUNFIRSTLINE,
-                         get_last_displayed_symtab (),
-                         get_last_displayed_line (),
-                         canonical, NULL, NULL);
-      else
-       decode_line_full (address, DECODE_LINE_FUNFIRSTLINE,
-                         cursal.symtab, cursal.line, canonical, NULL, NULL);
+      if (!cursal.symtab
+         || (address != NULL
+             && strchr ("+-", address[0]) != NULL
+             && address[1] != '['))
+       {
+         decode_line_full (location, DECODE_LINE_FUNFIRSTLINE,
+                           get_last_displayed_symtab (),
+                           get_last_displayed_line (),
+                           canonical, NULL, NULL);
+         return;
+       }
     }
+
+  decode_line_full (location, DECODE_LINE_FUNFIRSTLINE,
+                   cursal.symtab, cursal.line, canonical, NULL, NULL);
 }
 
 
@@ -9527,19 +9585,19 @@ find_condition_and_thread (const char *tok, CORE_ADDR pc,
 /* Decode a static tracepoint marker spec.  */
 
 static struct symtabs_and_lines
-decode_static_tracepoint_spec (char **arg_p)
+decode_static_tracepoint_spec (const char **arg_p)
 {
   VEC(static_tracepoint_marker_p) *markers = NULL;
   struct symtabs_and_lines sals;
   struct cleanup *old_chain;
-  char *p = &(*arg_p)[3];
-  char *endp;
+  const char *p = &(*arg_p)[3];
+  const char *endp;
   char *marker_str;
   int i;
 
-  p = skip_spaces (p);
+  p = skip_spaces_const (p);
 
-  endp = skip_to_space (p);
+  endp = skip_to_space_const (p);
 
   marker_str = savestring (p, endp - p);
   old_chain = make_cleanup (xfree, marker_str);
@@ -9571,22 +9629,13 @@ decode_static_tracepoint_spec (char **arg_p)
   return sals;
 }
 
-/* Set a breakpoint.  This function is shared between CLI and MI
-   functions for setting a breakpoint.  This function has two major
-   modes of operations, selected by the PARSE_ARG parameter.  If
-   non-zero, the function will parse ARG, extracting location,
-   condition, thread and extra string.  Otherwise, ARG is just the
-   breakpoint's location, with condition, thread, and extra string
-   specified by the COND_STRING, THREAD and EXTRA_STRING parameters.
-   If INTERNAL is non-zero, the breakpoint number will be allocated
-   from the internal breakpoint count.  Returns true if any breakpoint
-   was created; false otherwise.  */
+/* See breakpoint.h.  */
 
 int
 create_breakpoint (struct gdbarch *gdbarch,
-                  char *arg, char *cond_string,
+                  const struct event_location *location, char *cond_string,
                   int thread, char *extra_string,
-                  int parse_arg,
+                  int parse_extra,
                   int tempflag, enum bptype type_wanted,
                   int ignore_count,
                   enum auto_boolean pending_break_support,
@@ -9594,8 +9643,6 @@ create_breakpoint (struct gdbarch *gdbarch,
                   int from_tty, int enabled, int internal,
                   unsigned flags)
 {
-  char *copy_arg = NULL;
-  char *addr_start = arg;
   struct linespec_result canonical;
   struct cleanup *old_chain;
   struct cleanup *bkpt_chain = NULL;
@@ -9605,12 +9652,15 @@ create_breakpoint (struct gdbarch *gdbarch,
 
   gdb_assert (ops != NULL);
 
+  /* If extra_string isn't useful, set it to NULL.  */
+  if (extra_string != NULL && *extra_string == '\0')
+    extra_string = NULL;
+
   init_linespec_result (&canonical);
 
   TRY
     {
-      ops->create_sals_from_location (&arg, &canonical, type_wanted,
-                                     addr_start, &copy_arg);
+      ops->create_sals_from_location (location, &canonical, type_wanted);
     }
   CATCH (e, RETURN_MASK_ERROR)
     {
@@ -9637,24 +9687,14 @@ create_breakpoint (struct gdbarch *gdbarch,
             a pending breakpoint and selected yes, or pending
             breakpoint behavior is on and thus a pending breakpoint
             is defaulted on behalf of the user.  */
-         {
-           struct linespec_sals lsal;
-
-           copy_arg = xstrdup (addr_start);
-           lsal.canonical = xstrdup (copy_arg);
-           lsal.sals.nelts = 1;
-           lsal.sals.sals = XNEW (struct symtab_and_line);
-           init_sal (&lsal.sals.sals[0]);
-           pending = 1;
-           VEC_safe_push (linespec_sals, canonical.sals, &lsal);
-         }
+         pending = 1;
        }
       else
        throw_exception (e);
     }
   END_CATCH
 
-  if (VEC_empty (linespec_sals, canonical.sals))
+  if (!pending && VEC_empty (linespec_sals, canonical.sals))
     return 0;
 
   /* Create a chain of things that always need to be cleaned up.  */
@@ -9692,7 +9732,7 @@ create_breakpoint (struct gdbarch *gdbarch,
      breakpoint.  */
   if (!pending)
     {
-      if (parse_arg)
+      if (parse_extra)
         {
          char *rest;
          struct linespec_sals *lsal;
@@ -9704,19 +9744,22 @@ create_breakpoint (struct gdbarch *gdbarch,
             sal is OK.  When setting the breakpoint we'll
             re-parse it in context of each sal.  */
 
-         find_condition_and_thread (arg, lsal->sals.sals[0].pc, &cond_string,
-                                    &thread, &task, &rest);
+         find_condition_and_thread (extra_string, lsal->sals.sals[0].pc,
+                                    &cond_string, &thread, &task, &rest);
          if (cond_string)
            make_cleanup (xfree, cond_string);
          if (rest)
            make_cleanup (xfree, rest);
          if (rest)
            extra_string = rest;
+         else
+           extra_string = NULL;
         }
       else
         {
-         if (*arg != '\0')
-           error (_("Garbage '%s' at end of location"), arg);
+         if (type_wanted != bp_dprintf
+             && extra_string != NULL && *extra_string != '\0')
+               error (_("Garbage '%s' at end of location"), extra_string);
 
          /* Create a private copy of condition string.  */
          if (cond_string)
@@ -9742,8 +9785,6 @@ create_breakpoint (struct gdbarch *gdbarch,
     {
       struct breakpoint *b;
 
-      make_cleanup (xfree, copy_arg);
-
       if (is_tracepoint_type (type_wanted))
        {
          struct tracepoint *t;
@@ -9755,13 +9796,10 @@ create_breakpoint (struct gdbarch *gdbarch,
        b = XNEW (struct breakpoint);
 
       init_raw_breakpoint_without_location (b, gdbarch, type_wanted, ops);
+      b->location = copy_event_location (location);
 
-      b->addr_string = copy_arg;
-      if (parse_arg)
-       {
-         b->cond_string = NULL;
-         b->extra_string = NULL;
-       }
+      if (parse_extra)
+       b->cond_string = NULL;
       else
        {
          /* Create a private copy of condition string.  */
@@ -9770,16 +9808,17 @@ create_breakpoint (struct gdbarch *gdbarch,
              cond_string = xstrdup (cond_string);
              make_cleanup (xfree, cond_string);
            }
-         /* Create a private copy of any extra string.  */
-         if (extra_string != NULL)
-           {
-             extra_string = xstrdup (extra_string);
-             make_cleanup (xfree, extra_string);
-           }
          b->cond_string = cond_string;
-         b->extra_string = extra_string;
          b->thread = thread;
        }
+
+      /* Create a private copy of any extra string.  */
+      if (extra_string != NULL)
+       {
+         extra_string = xstrdup (extra_string);
+         make_cleanup (xfree, extra_string);
+       }
+      b->extra_string = extra_string;
       b->ignore_count = ignore_count;
       b->disposition = tempflag ? disp_del : disp_donttouch;
       b->condition_not_parsed = 1;
@@ -9826,16 +9865,21 @@ break_command_1 (char *arg, int flag, int from_tty)
                             : bp_breakpoint);
   struct breakpoint_ops *ops;
   const char *arg_cp = arg;
+  struct event_location *location;
+  struct cleanup *cleanup;
+
+  location = string_to_event_location (&arg, current_language);
+  cleanup = make_cleanup_delete_event_location (location);
 
   /* Matching breakpoints on probes.  */
-  if (arg && probe_linespec_to_ops (&arg_cp) != NULL)
+  if (arg_cp != NULL && probe_linespec_to_ops (&arg_cp) != NULL)
     ops = &bkpt_probe_breakpoint_ops;
   else
     ops = &bkpt_breakpoint_ops;
 
   create_breakpoint (get_current_arch (),
-                    arg,
-                    NULL, 0, NULL, 1 /* parse arg */,
+                    location,
+                    NULL, 0, arg, 1 /* parse arg */,
                     tempflag, type_wanted,
                     0 /* Ignore count */,
                     pending_break_support,
@@ -9844,6 +9888,7 @@ break_command_1 (char *arg, int flag, int from_tty)
                     1 /* enabled */,
                     0 /* internal */,
                     0);
+  do_cleanups (cleanup);
 }
 
 /* Helper function for break_command_1 and disassemble_command.  */
@@ -10010,9 +10055,28 @@ stopat_command (char *arg, int from_tty)
 static void
 dprintf_command (char *arg, int from_tty)
 {
+  struct event_location *location;
+  struct cleanup *cleanup;
+
+  location = string_to_event_location (&arg, current_language);
+  cleanup = make_cleanup_delete_event_location (location);
+
+  /* If non-NULL, ARG should have been advanced past the location;
+     the next character must be ','.  */
+  if (arg != NULL)
+    {
+      if (arg[0] != ',' || arg[1] == '\0')
+       error (_("Format string required"));
+      else
+       {
+         /* Skip the comma.  */
+         ++arg;
+       }
+    }
+
   create_breakpoint (get_current_arch (),
-                    arg,
-                    NULL, 0, NULL, 1 /* parse arg */,
+                    location,
+                    NULL, 0, arg, 1 /* parse arg */,
                     0, bp_dprintf,
                     0 /* Ignore count */,
                     pending_break_support,
@@ -10021,6 +10085,7 @@ dprintf_command (char *arg, int from_tty)
                     1 /* enabled */,
                     0 /* internal */,
                     0);
+  do_cleanups (cleanup);
 }
 
 static void
@@ -10165,8 +10230,9 @@ print_mention_ranged_breakpoint (struct breakpoint *b)
 static void
 print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
 {
-  fprintf_unfiltered (fp, "break-range %s, %s", b->addr_string,
-                     b->addr_string_range_end);
+  fprintf_unfiltered (fp, "break-range %s, %s",
+                     event_location_to_string (b->location),
+                     event_location_to_string (b->location_range_end));
   print_recreate_thread (b, fp);
 }
 
@@ -10217,6 +10283,7 @@ break_range_command (char *arg, int from_tty)
   struct symtab_and_line sal_start, sal_end;
   struct cleanup *cleanup_bkpt;
   struct linespec_sals *lsal_start, *lsal_end;
+  struct event_location *start_location, *end_location;
 
   /* We don't support software ranged breakpoints.  */
   if (target_ranged_break_num_registers () < 0)
@@ -10236,9 +10303,10 @@ break_range_command (char *arg, int from_tty)
   init_linespec_result (&canonical_start);
 
   arg_start = arg;
-  parse_breakpoint_sals (&arg, &canonical_start);
-
-  cleanup_bkpt = make_cleanup_destroy_linespec_result (&canonical_start);
+  start_location = string_to_event_location (&arg, current_language);
+  cleanup_bkpt = make_cleanup_delete_event_location (start_location);
+  parse_breakpoint_sals (start_location, &canonical_start);
+  make_cleanup_destroy_linespec_result (&canonical_start);
 
   if (arg[0] != ',')
     error (_("Too few arguments."));
@@ -10268,7 +10336,9 @@ break_range_command (char *arg, int from_tty)
      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.  */
-  decode_line_full (&arg, DECODE_LINE_FUNFIRSTLINE,
+  end_location = string_to_event_location (&arg, current_language);
+  make_cleanup_delete_event_location (end_location);
+  decode_line_full (end_location, DECODE_LINE_FUNFIRSTLINE,
                    sal_start.symtab, sal_start.line,
                    &canonical_end, NULL, NULL);
 
@@ -10283,8 +10353,6 @@ break_range_command (char *arg, int from_tty)
     error (_("Cannot create a ranged breakpoint with multiple locations."));
 
   sal_end = lsal_end->sals.sals[0];
-  addr_string_end = savestring (arg_start, arg - arg_start);
-  make_cleanup (xfree, addr_string_end);
 
   end = find_breakpoint_range_end (sal_end);
   if (sal_start.pc > end)
@@ -10311,8 +10379,8 @@ break_range_command (char *arg, int from_tty)
   set_breakpoint_count (breakpoint_count + 1);
   b->number = breakpoint_count;
   b->disposition = disp_donttouch;
-  b->addr_string = xstrdup (addr_string_start);
-  b->addr_string_range_end = xstrdup (addr_string_end);
+  b->location = copy_event_location (start_location);
+  b->location_range_end = copy_event_location (end_location);
   b->loc->length = length;
 
   do_cleanups (cleanup_bkpt);
@@ -11439,21 +11507,25 @@ until_break_command (char *arg, int from_tty, int anywhere)
   struct frame_id caller_frame_id;
   struct breakpoint *breakpoint;
   struct breakpoint *breakpoint2 = NULL;
-  struct cleanup *old_chain;
+  struct cleanup *old_chain, *cleanup;
   int thread;
   struct thread_info *tp;
+  struct event_location *location;
 
   clear_proceed_status (0);
 
   /* Set a breakpoint where the user wants it and at return from
      this function.  */
 
+  location = string_to_event_location (&arg, current_language);
+  cleanup = make_cleanup_delete_event_location (location);
+
   if (last_displayed_sal_is_valid ())
-    sals = decode_line_1 (&arg, DECODE_LINE_FUNFIRSTLINE,
+    sals = decode_line_1 (location, DECODE_LINE_FUNFIRSTLINE,
                          get_last_displayed_symtab (),
                          get_last_displayed_line ());
   else
-    sals = decode_line_1 (&arg, DECODE_LINE_FUNFIRSTLINE,
+    sals = decode_line_1 (location, DECODE_LINE_FUNFIRSTLINE,
                          (struct symtab *) NULL, 0);
 
   if (sals.nelts != 1)
@@ -11539,6 +11611,8 @@ until_break_command (char *arg, int from_tty, int anywhere)
     }
   else
     do_cleanups (old_chain);
+
+  do_cleanups (cleanup);
 }
 
 /* This function attempts to parse an optional "if <cond>" clause
@@ -11694,7 +11768,8 @@ init_ada_exception_breakpoint (struct breakpoint *b,
 
   b->enable_state = enabled ? bp_enabled : bp_disabled;
   b->disposition = tempflag ? disp_del : disp_donttouch;
-  b->addr_string = addr_string;
+  b->location = string_to_event_location (&addr_string,
+                                         language_def (language_ada));
   b->language = language_ada;
 }
 
@@ -12552,7 +12627,26 @@ say_where (struct breakpoint *b)
      single string.  */
   if (b->loc == NULL)
     {
-      printf_filtered (_(" (%s) pending."), b->addr_string);
+      /* For pending locations, the output differs slightly based
+        on b->extra_string.  If this is non-NULL, it contains either
+        a condition or dprintf arguments.  */
+      if (b->extra_string == NULL)
+       {
+         printf_filtered (_(" (%s) pending."),
+                          event_location_to_string (b->location));
+       }
+      else if (b->type == bp_dprintf)
+       {
+         printf_filtered (_(" (%s,%s) pending."),
+                          event_location_to_string (b->location),
+                          b->extra_string);
+       }
+      else
+       {
+         printf_filtered (_(" (%s %s) pending."),
+                          event_location_to_string (b->location),
+                          b->extra_string);
+       }
     }
   else
     {
@@ -12574,7 +12668,8 @@ say_where (struct breakpoint *b)
            /* This is not ideal, but each location may have a
               different file name, and this at least reflects the
               real situation somewhat.  */
-           printf_filtered (": %s.", b->addr_string);
+           printf_filtered (": %s.",
+                            event_location_to_string (b->location));
        }
 
       if (b->loc->next)
@@ -12616,9 +12711,9 @@ base_breakpoint_dtor (struct breakpoint *self)
   decref_counted_command_line (&self->commands);
   xfree (self->cond_string);
   xfree (self->extra_string);
-  xfree (self->addr_string);
   xfree (self->filter);
-  xfree (self->addr_string_range_end);
+  delete_event_location (self->location);
+  delete_event_location (self->location_range_end);
 }
 
 static struct bp_location *
@@ -12711,11 +12806,10 @@ base_breakpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
 }
 
 static void
-base_breakpoint_create_sals_from_location (char **arg,
-                                          struct linespec_result *canonical,
-                                          enum bptype type_wanted,
-                                          char *addr_start,
-                                          char **copy_arg)
+base_breakpoint_create_sals_from_location
+  (const struct event_location *location,
+   struct linespec_result *canonical,
+   enum bptype type_wanted)
 {
   internal_error_pure_virtual_called ();
 }
@@ -12737,7 +12831,8 @@ base_breakpoint_create_breakpoints_sal (struct gdbarch *gdbarch,
 }
 
 static void
-base_breakpoint_decode_location (struct breakpoint *b, char **s,
+base_breakpoint_decode_location (struct breakpoint *b,
+                                const struct event_location *location,
                                 struct symtabs_and_lines *sals)
 {
   internal_error_pure_virtual_called ();
@@ -12788,9 +12883,9 @@ static void
 bkpt_re_set (struct breakpoint *b)
 {
   /* FIXME: is this still reachable?  */
-  if (b->addr_string == NULL)
+  if (event_location_empty_p (b->location))
     {
-      /* Anything without a string can't be re-set.  */
+      /* Anything without a location can't be re-set.  */
       delete_breakpoint (b);
       return;
     }
@@ -12942,18 +13037,23 @@ bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
     internal_error (__FILE__, __LINE__,
                    _("unhandled breakpoint type %d"), (int) tp->type);
 
-  fprintf_unfiltered (fp, " %s", tp->addr_string);
+  fprintf_unfiltered (fp, " %s",
+                     event_location_to_string (tp->location));
+
+  /* Print out extra_string if this breakpoint is pending.  It might
+     contain, for example, conditions that were set by the user.  */
+  if (tp->loc == NULL && tp->extra_string != NULL)
+    fprintf_unfiltered (fp, " %s", tp->extra_string);
+
   print_recreate_thread (tp, fp);
 }
 
 static void
-bkpt_create_sals_from_location (char **arg,
-                              struct linespec_result *canonical,
-                              enum bptype type_wanted,
-                              char *addr_start, char **copy_arg)
+bkpt_create_sals_from_location (const struct event_location *location,
+                               struct linespec_result *canonical,
+                               enum bptype type_wanted)
 {
-  create_sals_from_location_default (arg, canonical, type_wanted,
-                                   addr_start, copy_arg);
+  create_sals_from_location_default (location, canonical, type_wanted);
 }
 
 static void
@@ -12978,10 +13078,11 @@ bkpt_create_breakpoints_sal (struct gdbarch *gdbarch,
 }
 
 static void
-bkpt_decode_location (struct breakpoint *b, char **s,
+bkpt_decode_location (struct breakpoint *b,
+                     const struct event_location *location,
                      struct symtabs_and_lines *sals)
 {
-  decode_location_default (b, s, sals);
+  decode_location_default (b, location, sals);
 }
 
 /* Virtual table for internal breakpoints.  */
@@ -13181,26 +13282,23 @@ bkpt_probe_remove_location (struct bp_location *bl)
 }
 
 static void
-bkpt_probe_create_sals_from_location (char **arg,
+bkpt_probe_create_sals_from_location (const struct event_location *location,
                                      struct linespec_result *canonical,
-                                     enum bptype type_wanted,
-                                     char *addr_start, char **copy_arg)
+                                     enum bptype type_wanted)
 {
   struct linespec_sals lsal;
 
-  lsal.sals = parse_probes (arg, canonical);
-
-  *copy_arg = xstrdup (canonical->addr_string);
-  lsal.canonical = xstrdup (*copy_arg);
-
+  lsal.sals = parse_probes (location, canonical);
+  lsal.canonical = xstrdup (event_location_to_string (canonical->location));
   VEC_safe_push (linespec_sals, canonical->sals, &lsal);
 }
 
 static void
-bkpt_probe_decode_location (struct breakpoint *b, char **s,
+bkpt_probe_decode_location (struct breakpoint *b,
+                           const struct event_location *location,
                            struct symtabs_and_lines *sals)
 {
-  *sals = parse_probes (s, NULL);
+  *sals = parse_probes (location, NULL);
   if (!sals->sals)
     error (_("probe not found"));
 }
@@ -13282,7 +13380,8 @@ tracepoint_print_recreate (struct breakpoint *self, struct ui_file *fp)
     internal_error (__FILE__, __LINE__,
                    _("unhandled tracepoint type %d"), (int) self->type);
 
-  fprintf_unfiltered (fp, " %s", self->addr_string);
+  fprintf_unfiltered (fp, " %s",
+                     event_location_to_string (self->location));
   print_recreate_thread (self, fp);
 
   if (tp->pass_count)
@@ -13290,13 +13389,11 @@ tracepoint_print_recreate (struct breakpoint *self, struct ui_file *fp)
 }
 
 static void
-tracepoint_create_sals_from_location (char **arg,
-                                    struct linespec_result *canonical,
-                                    enum bptype type_wanted,
-                                    char *addr_start, char **copy_arg)
+tracepoint_create_sals_from_location (const struct event_location *location,
+                                     struct linespec_result *canonical,
+                                     enum bptype type_wanted)
 {
-  create_sals_from_location_default (arg, canonical, type_wanted,
-                                   addr_start, copy_arg);
+  create_sals_from_location_default (location, canonical, type_wanted);
 }
 
 static void
@@ -13321,10 +13418,11 @@ tracepoint_create_breakpoints_sal (struct gdbarch *gdbarch,
 }
 
 static void
-tracepoint_decode_location (struct breakpoint *b, char **s,
+tracepoint_decode_location (struct breakpoint *b,
+                           const struct event_location *location,
                            struct symtabs_and_lines *sals)
 {
-  decode_location_default (b, s, sals);
+  decode_location_default (b, location, sals);
 }
 
 struct breakpoint_ops tracepoint_breakpoint_ops;
@@ -13333,22 +13431,22 @@ struct breakpoint_ops tracepoint_breakpoint_ops;
    static probe.  */
 
 static void
-tracepoint_probe_create_sals_from_location (char **arg,
-                                           struct linespec_result *canonical,
-                                           enum bptype type_wanted,
-                                           char *addr_start, char **copy_arg)
+tracepoint_probe_create_sals_from_location
+  (const struct event_location *location,
+   struct linespec_result *canonical,
+   enum bptype type_wanted)
 {
   /* We use the same method for breakpoint on probes.  */
-  bkpt_probe_create_sals_from_location (arg, canonical, type_wanted,
-                                       addr_start, copy_arg);
+  bkpt_probe_create_sals_from_location (location, canonical, type_wanted);
 }
 
 static void
-tracepoint_probe_decode_location (struct breakpoint *b, char **s,
+tracepoint_probe_decode_location (struct breakpoint *b,
+                                 const struct event_location *location,
                                  struct symtabs_and_lines *sals)
 {
   /* We use the same method for breakpoint on probes.  */
-  bkpt_probe_decode_location (b, s, sals);
+  bkpt_probe_decode_location (b, location, sals);
 }
 
 static struct breakpoint_ops tracepoint_probe_breakpoint_ops;
@@ -13360,13 +13458,8 @@ dprintf_re_set (struct breakpoint *b)
 {
   breakpoint_re_set_default (b);
 
-  /* This breakpoint could have been pending, and be resolved now, and
-     if so, we should now have the extra string.  If we don't, the
-     dprintf was malformed when created, but we couldn't tell because
-     we can't extract the extra string until the location is
-     resolved.  */
-  if (b->loc != NULL && b->extra_string == NULL)
-    error (_("Format string required"));
+  /* extra_string should never be non-NULL for dprintf.  */
+  gdb_assert (b->extra_string != NULL);
 
   /* 1 - connect to target 1, that can run breakpoint commands.
      2 - create a dprintf, which resolves fine.
@@ -13387,7 +13480,8 @@ dprintf_re_set (struct breakpoint *b)
 static void
 dprintf_print_recreate (struct breakpoint *tp, struct ui_file *fp)
 {
-  fprintf_unfiltered (fp, "dprintf %s%s", tp->addr_string,
+  fprintf_unfiltered (fp, "dprintf %s,%s",
+                     event_location_to_string (tp->location),
                      tp->extra_string);
   print_recreate_thread (tp, fp);
 }
@@ -13434,19 +13528,24 @@ dprintf_after_condition_true (struct bpstats *bs)
    markers (`-m').  */
 
 static void
-strace_marker_create_sals_from_location (char **arg,
+strace_marker_create_sals_from_location (const struct event_location *location,
                                         struct linespec_result *canonical,
-                                        enum bptype type_wanted,
-                                        char *addr_start, char **copy_arg)
+                                        enum bptype type_wanted)
 {
   struct linespec_sals lsal;
+  const char *arg_start, *arg;
+  char *str;
+  struct cleanup *cleanup;
 
-  lsal.sals = decode_static_tracepoint_spec (arg);
+  arg = arg_start = get_linespec_location (location);
+  lsal.sals = decode_static_tracepoint_spec (&arg);
 
-  *copy_arg = savestring (addr_start, *arg - addr_start);
+  str = savestring (arg_start, arg - arg_start);
+  cleanup = make_cleanup (xfree, str);
+  canonical->location = new_linespec_location (&str);
+  do_cleanups (cleanup);
 
-  canonical->addr_string = xstrdup (*copy_arg);
-  lsal.canonical = xstrdup (*copy_arg);
+  lsal.canonical = xstrdup (event_location_to_string (canonical->location));
   VEC_safe_push (linespec_sals, canonical->sals, &lsal);
 }
 
@@ -13479,17 +13578,17 @@ strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
       struct symtabs_and_lines expanded;
       struct tracepoint *tp;
       struct cleanup *old_chain;
-      char *addr_string;
+      struct event_location *location;
 
       expanded.nelts = 1;
       expanded.sals = &lsal->sals.sals[i];
 
-      addr_string = xstrdup (canonical->addr_string);
-      old_chain = make_cleanup (xfree, addr_string);
+      location = copy_event_location (canonical->location);
+      old_chain = make_cleanup_delete_event_location (location);
 
       tp = XCNEW (struct tracepoint);
       init_breakpoint_sal (&tp->base, gdbarch, expanded,
-                          addr_string, NULL,
+                          location, NULL,
                           cond_string, extra_string,
                           type_wanted, disposition,
                           thread, task, ignore_count, ops,
@@ -13510,12 +13609,14 @@ strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
 }
 
 static void
-strace_marker_decode_location (struct breakpoint *b, char **s,
+strace_marker_decode_location (struct breakpoint *b,
+                              const struct event_location *location,
                               struct symtabs_and_lines *sals)
 {
   struct tracepoint *tp = (struct tracepoint *) b;
+  const char *s = get_linespec_location (location);
 
-  *sals = decode_static_tracepoint_spec (s);
+  *sals = decode_static_tracepoint_spec (&s);
   if (sals->nelts > tp->static_trace_marker_id_idx)
     {
       sals->sals[0] = sals->sals[tp->static_trace_marker_id_idx];
@@ -13847,10 +13948,12 @@ update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
 
       if (!VEC_empty(static_tracepoint_marker_p, markers))
        {
+         char *p, *tmp;
          struct symtab_and_line sal2;
          struct symbol *sym;
          struct static_tracepoint_marker *tpmarker;
          struct ui_out *uiout = current_uiout;
+         struct cleanup *cleanup;
 
          tpmarker = VEC_index (static_tracepoint_marker_p, markers, 0);
 
@@ -13891,10 +13994,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;
 
-         xfree (b->addr_string);
-         b->addr_string = xstrprintf ("%s:%d",
-                                  symtab_to_filename_for_display (sal2.symtab),
-                                      b->loc->line_number);
+         delete_event_location (b->location);
+         p = tmp = xstrprintf ("%s:%d",
+                               symtab_to_filename_for_display (sal2.symtab),
+                               b->loc->line_number);
+         cleanup = make_cleanup (xfree, tmp);
+         b->location = new_linespec_location (&tmp);
+         do_cleanups (cleanup);
 
          /* Might be nice to check if function changed, and warn if
             so.  */
@@ -14051,22 +14157,21 @@ update_breakpoint_locations (struct breakpoint *b,
   update_global_location_list (UGLL_MAY_INSERT);
 }
 
-/* Find the SaL locations corresponding to the given ADDR_STRING.
+/* Find the SaL locations corresponding to the given LOCATION.
    On return, FOUND will be 1 if any SaL was found, zero otherwise.  */
 
 static struct symtabs_and_lines
-location_to_sals (struct breakpoint *b, char *addr_string, int *found)
+location_to_sals (struct breakpoint *b, struct event_location *location,
+                 int *found)
 {
-  char *s;
   struct symtabs_and_lines sals = {0};
   struct gdb_exception exception = exception_none;
 
   gdb_assert (b->ops != NULL);
-  s = addr_string;
 
   TRY
     {
-      b->ops->decode_location (b, &s, &sals);
+      b->ops->decode_location (b, location, &sals);
     }
   CATCH (e, RETURN_MASK_ERROR)
     {
@@ -14108,20 +14213,24 @@ location_to_sals (struct breakpoint *b, char *addr_string, int *found)
 
       for (i = 0; i < sals.nelts; ++i)
        resolve_sal_pc (&sals.sals[i]);
-      if (b->condition_not_parsed && s && s[0])
+      if (b->condition_not_parsed && b->extra_string != NULL)
        {
          char *cond_string, *extra_string;
          int thread, task;
 
-         find_condition_and_thread (s, sals.sals[0].pc,
+         find_condition_and_thread (b->extra_string, sals.sals[0].pc,
                                     &cond_string, &thread, &task,
                                     &extra_string);
+         gdb_assert (b->cond_string == NULL);
          if (cond_string)
            b->cond_string = cond_string;
          b->thread = thread;
          b->task = task;
          if (extra_string)
-           b->extra_string = extra_string;
+           {
+             xfree (b->extra_string);
+             b->extra_string = extra_string;
+           }
          b->condition_not_parsed = 0;
        }
 
@@ -14148,16 +14257,16 @@ breakpoint_re_set_default (struct breakpoint *b)
   struct symtabs_and_lines expanded = {0};
   struct symtabs_and_lines expanded_end = {0};
 
-  sals = location_to_sals (b, b->addr_string, &found);
+  sals = location_to_sals (b, b->location, &found);
   if (found)
     {
       make_cleanup (xfree, sals.sals);
       expanded = sals;
     }
 
-  if (b->addr_string_range_end)
+  if (b->location_range_end != NULL)
     {
-      sals_end = location_to_sals (b, b->addr_string_range_end, &found);
+      sals_end = location_to_sals (b, b->location_range_end, &found);
       if (found)
        {
          make_cleanup (xfree, sals_end.sals);
@@ -14172,12 +14281,11 @@ breakpoint_re_set_default (struct breakpoint *b)
    calls parse_breakpoint_sals.  Return 1 for success, zero for failure.  */
 
 static void
-create_sals_from_location_default (char **arg,
-                                 struct linespec_result *canonical,
-                                 enum bptype type_wanted,
-                                 char *addr_start, char **copy_arg)
+create_sals_from_location_default (const struct event_location *location,
+                                  struct linespec_result *canonical,
+                                  enum bptype type_wanted)
 {
-  parse_breakpoint_sals (arg, canonical);
+  parse_breakpoint_sals (location, canonical);
 }
 
 /* Call create_breakpoints_sal for the given arguments.  This is the default
@@ -14208,13 +14316,14 @@ create_breakpoints_sal_default (struct gdbarch *gdbarch,
    default function for the `decode_location' method of breakpoint_ops.  */
 
 static void
-decode_location_default (struct breakpoint *b, char **s,
+decode_location_default (struct breakpoint *b,
+                        const struct event_location *location,
                         struct symtabs_and_lines *sals)
 {
   struct linespec_result canonical;
 
   init_linespec_result (&canonical);
-  decode_line_full (s, DECODE_LINE_FUNFIRSTLINE,
+  decode_line_full (location, DECODE_LINE_FUNFIRSTLINE,
                    (struct symtab *) NULL, 0,
                    &canonical, multiple_symbols_all,
                    b->filter);
@@ -14886,16 +14995,20 @@ static void
 trace_command (char *arg, int from_tty)
 {
   struct breakpoint_ops *ops;
+  struct event_location *location;
+  struct cleanup *back_to;
   const char *arg_cp = arg;
 
-  if (arg && probe_linespec_to_ops (&arg_cp))
+  location = string_to_event_location (&arg, current_language);
+  back_to = make_cleanup_delete_event_location (location);
+  if (arg_cp != NULL && probe_linespec_to_ops (&arg_cp) != NULL)
     ops = &tracepoint_probe_breakpoint_ops;
   else
     ops = &tracepoint_breakpoint_ops;
 
   create_breakpoint (get_current_arch (),
-                    arg,
-                    NULL, 0, NULL, 1 /* parse arg */,
+                    location,
+                    NULL, 0, arg, 1 /* parse arg */,
                     0 /* tempflag */,
                     bp_tracepoint /* type_wanted */,
                     0 /* Ignore count */,
@@ -14904,14 +15017,20 @@ trace_command (char *arg, int from_tty)
                     from_tty,
                     1 /* enabled */,
                     0 /* internal */, 0);
+  do_cleanups (back_to);
 }
 
 static void
 ftrace_command (char *arg, int from_tty)
 {
+  struct event_location *location;
+  struct cleanup *back_to;
+
+  location = string_to_event_location (&arg, current_language);
+  back_to = make_cleanup_delete_event_location (location);
   create_breakpoint (get_current_arch (),
-                    arg,
-                    NULL, 0, NULL, 1 /* parse arg */,
+                    location,
+                    NULL, 0, arg, 1 /* parse arg */,
                     0 /* tempflag */,
                     bp_fast_tracepoint /* type_wanted */,
                     0 /* Ignore count */,
@@ -14920,6 +15039,7 @@ ftrace_command (char *arg, int from_tty)
                     from_tty,
                     1 /* enabled */,
                     0 /* internal */, 0);
+  do_cleanups (back_to);
 }
 
 /* strace command implementation.  Creates a static tracepoint.  */
@@ -14928,17 +15048,26 @@ static void
 strace_command (char *arg, int from_tty)
 {
   struct breakpoint_ops *ops;
+  struct event_location *location;
+  struct cleanup *back_to;
 
   /* Decide if we are dealing with a static tracepoint marker (`-m'),
      or with a normal static tracepoint.  */
   if (arg && startswith (arg, "-m") && isspace (arg[2]))
-    ops = &strace_marker_breakpoint_ops;
+    {
+      ops = &strace_marker_breakpoint_ops;
+      location = new_linespec_location (&arg);
+    }
   else
-    ops = &tracepoint_breakpoint_ops;
+    {
+      ops = &tracepoint_breakpoint_ops;
+      location = string_to_event_location (&arg, current_language);
+    }
 
+  back_to = make_cleanup_delete_event_location (location);
   create_breakpoint (get_current_arch (),
-                    arg,
-                    NULL, 0, NULL, 1 /* parse arg */,
+                    location,
+                    NULL, 0, arg, 1 /* parse arg */,
                     0 /* tempflag */,
                     bp_static_tracepoint /* type_wanted */,
                     0 /* Ignore count */,
@@ -14947,6 +15076,7 @@ strace_command (char *arg, int from_tty)
                     from_tty,
                     1 /* enabled */,
                     0 /* internal */, 0);
+  do_cleanups (back_to);
 }
 
 /* Set up a fake reader function that gets command lines from a linked
@@ -14978,6 +15108,8 @@ create_tracepoint_from_upload (struct uploaded_tp *utp)
 {
   char *addr_str, small_buf[100];
   struct tracepoint *tp;
+  struct event_location *location;
+  struct cleanup *cleanup;
 
   if (utp->at_string)
     addr_str = utp->at_string;
@@ -15000,9 +15132,11 @@ create_tracepoint_from_upload (struct uploaded_tp *utp)
               "has no source form, ignoring it"),
             utp->number);
 
+  location = string_to_event_location (&addr_str, current_language);
+  cleanup = make_cleanup_delete_event_location (location);
   if (!create_breakpoint (get_current_arch (),
-                         addr_str,
-                         utp->cond_string, -1, NULL,
+                         location,
+                         utp->cond_string, -1, addr_str,
                          0 /* parse cond/thread */,
                          0 /* tempflag */,
                          utp->type /* type_wanted */,
@@ -15013,7 +15147,12 @@ create_tracepoint_from_upload (struct uploaded_tp *utp)
                          utp->enabled /* enabled */,
                          0 /* internal */,
                          CREATE_BREAKPOINT_FLAGS_INSERTED))
-    return NULL;
+    {
+      do_cleanups (cleanup);
+      return NULL;
+    }
+
+  do_cleanups (cleanup);
 
   /* Get the tracepoint we just created.  */
   tp = get_tracepoint (tracepoint_count);

diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h
index 44062606668f73c05732186be450164b0e5d2b21..877766a1de7702a7c037c2fbebdddc18289efdef 100644 (file)
--- a/gdb/breakpoint.h
+++ b/gdb/breakpoint.h
@@ -37,6 +37,7 @@ struct bpstats;
 struct bp_location;
 struct linespec_result;
 struct linespec_sals;
+struct event_location;
 
 /* This is the maximum number of bytes a breakpoint instruction can
    take.  Feel free to increase it.  It's just used in a few places to
@@ -580,8 +581,9 @@ struct breakpoint_ops
      `create_sals_from_location_default'.
 
      This function is called inside `create_breakpoint'.  */
-  void (*create_sals_from_location) (char **, struct linespec_result *,
-                                    enum bptype, char *, char **);
+  void (*create_sals_from_location) (const struct event_location *location,
+                                    struct linespec_result *canonical,
+                                    enum bptype type_wanted);
 
   /* This method will be responsible for creating a breakpoint given its SALs.
      Usually, it just calls `create_breakpoints_sal' (for ordinary
@@ -602,8 +604,9 @@ struct breakpoint_ops
      it calls `decode_line_full'.
 
      This function is called inside `location_to_sals'.  */
-  void (*decode_location) (struct breakpoint *, char **,
-                          struct symtabs_and_lines *);
+  void (*decode_location) (struct breakpoint *b,
+                          const struct event_location *location,
+                          struct symtabs_and_lines *sals);
 
   /* Return true if this breakpoint explains a signal.  See
      bpstat_explains_signal.  */
@@ -702,17 +705,17 @@ struct breakpoint
        non-thread-specific ordinary breakpoints this is NULL.  */
     struct program_space *pspace;
 
-    /* String we used to set the breakpoint (malloc'd).  */
-    char *addr_string;
+    /* Location we used to set the breakpoint (malloc'd).  */
+    struct event_location *location;
 
     /* The filter that should be passed to decode_line_full when
        re-setting this breakpoint.  This may be NULL, but otherwise is
        allocated with xmalloc.  */
     char *filter;
 
-    /* For a ranged breakpoint, the string we used to find
+    /* For a ranged breakpoint, the location we used to find
        the end of the range (malloc'd).  */
-    char *addr_string_range_end;
+    struct event_location *location_range_end;
 
     /* Architecture we used to set the breakpoint.  */
     struct gdbarch *gdbarch;
@@ -1293,10 +1296,30 @@ enum breakpoint_create_flags
     CREATE_BREAKPOINT_FLAGS_INSERTED = 1 << 0
   };
 
-extern int create_breakpoint (struct gdbarch *gdbarch, char *arg,
+/* Set a breakpoint.  This function is shared between CLI and MI functions
+   for setting a breakpoint at LOCATION.
+
+   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 non-zero, this function will attempt to extract
+   the condition, thread, and extra string from EXTRA_STRING, ignoring
+   the similarly named parameters.
+
+   If INTERNAL is non-zero, the breakpoint number will be allocated
+   from the internal breakpoint count.
+
+   Returns true if any breakpoint was created; false otherwise.  */
+
+extern int create_breakpoint (struct gdbarch *gdbarch,
+                             const struct event_location *location,
                              char *cond_string, int thread,
                              char *extra_string,
-                             int parse_arg,
+                             int parse_extra,
                              int tempflag, enum bptype wanted_type,
                              int ignore_count,
                              enum auto_boolean pending_break_support,

diff --git a/gdb/cli/cli-cmds.c b/gdb/cli/cli-cmds.c
index 2ec2dd35d33a943ebfbd5b0a43bf58f0b25dd20b..e9664c974fab258529b9af5bf6ed7ddf2b6be7a0 100644 (file)
--- a/gdb/cli/cli-cmds.c
+++ b/gdb/cli/cli-cmds.c
@@ -38,6 +38,7 @@
 #include "disasm.h"
 #include "tracepoint.h"
 #include "filestuff.h"
+#include "location.h"
 
 #include "ui-out.h"
 
@@ -782,7 +783,6 @@ edit_command (char *arg, int from_tty)
   struct symtabs_and_lines sals;
   struct symtab_and_line sal;
   struct symbol *sym;
-  char *arg1;
   char *editor;
   char *p;
   const char *fn;
@@ -804,21 +804,28 @@ edit_command (char *arg, int from_tty)
     }
   else
     {
-      /* Now should only be one argument -- decode it in SAL.  */
+      struct cleanup *cleanup;
+      struct event_location *location;
+      char *arg1;
 
+      /* Now should only be one argument -- decode it in SAL.  */
       arg1 = arg;
-      sals = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE, 0, 0);
+      location = string_to_event_location (&arg1, current_language);
+      cleanup = make_cleanup_delete_event_location (location);
+      sals = decode_line_1 (location, DECODE_LINE_LIST_MODE, 0, 0);
 
       filter_sals (&sals);
       if (! sals.nelts)
        {
          /*  C++  */
+         do_cleanups (cleanup);
          return;
        }
       if (sals.nelts > 1)
        {
          ambiguous_line_spec (&sals);
          xfree (sals.sals);
+         do_cleanups (cleanup);
          return;
        }
 
@@ -860,6 +867,7 @@ edit_command (char *arg, int from_tty)
 
       if (sal.symtab == 0)
         error (_("No line number known for %s."), arg);
+      do_cleanups (cleanup);
     }
 
   if ((editor = (char *) getenv ("EDITOR")) == NULL)
@@ -888,6 +896,9 @@ list_command (char *arg, int from_tty)
   int dummy_beg = 0;
   int linenum_beg = 0;
   char *p;
+  struct cleanup *cleanup;
+
+  cleanup = make_cleanup (null_cleanup, NULL);
 
   /* Pull in the current default source line if necessary.  */
   if (arg == 0 || arg[0] == '+' || arg[0] == '-')
@@ -951,15 +962,24 @@ list_command (char *arg, int from_tty)
     dummy_beg = 1;
   else
     {
-      sals = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE, 0, 0);
+      struct event_location *location;
+
+      location = string_to_event_location (&arg1, current_language);
+      make_cleanup_delete_event_location (location);
+      sals = decode_line_1 (location, DECODE_LINE_LIST_MODE, 0, 0);
 
       filter_sals (&sals);
       if (!sals.nelts)
-       return;                 /*  C++  */
+       {
+         /*  C++  */
+         do_cleanups (cleanup);
+         return;
+       }
       if (sals.nelts > 1)
        {
          ambiguous_line_spec (&sals);
          xfree (sals.sals);
+         do_cleanups (cleanup);
          return;
        }
 
@@ -984,18 +1004,28 @@ list_command (char *arg, int from_tty)
        dummy_end = 1;
       else
        {
+         struct event_location *location;
+
+         location = string_to_event_location (&arg1, current_language);
+         make_cleanup_delete_event_location (location);
          if (dummy_beg)
-           sals_end = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE, 0, 0);
+           sals_end = decode_line_1 (location,
+                                     DECODE_LINE_LIST_MODE, 0, 0);
          else
-           sals_end = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE,
+           sals_end = decode_line_1 (location, DECODE_LINE_LIST_MODE,
                                      sal.symtab, sal.line);
+
          filter_sals (&sals_end);
          if (sals_end.nelts == 0)
-           return;
+           {
+             do_cleanups (cleanup);
+             return;
+           }
          if (sals_end.nelts > 1)
            {
              ambiguous_line_spec (&sals_end);
              xfree (sals_end.sals);
+             do_cleanups (cleanup);
              return;
            }
          sal_end = sals_end.sals[0];
@@ -1076,6 +1106,7 @@ list_command (char *arg, int from_tty)
                         ? sal.line + get_lines_to_list ()
                         : sal_end.line + 1),
                        0);
+  do_cleanups (cleanup);
 }
 
 /* Subroutine of disassemble_command to simplify it.

diff --git a/gdb/elfread.c b/gdb/elfread.c
index 0e169c7c8ca89098f376c805646ecc3e5ebdb034..1e5251550294d4fad1ad4dab02b59a80081f2edd 100644 (file)
--- a/gdb/elfread.c
+++ b/gdb/elfread.c
@@ -45,6 +45,7 @@
 #include "bcache.h"
 #include "gdb_bfd.h"
 #include "build-id.h"
+#include "location.h"
 
 extern void _initialize_elfread (void);
 
@@ -989,7 +990,8 @@ elf_gnu_ifunc_resolver_return_stop (struct 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 (b->addr_string, resolved_pc);
+  elf_gnu_ifunc_record_cache (event_location_to_string (b->location),
+                             resolved_pc);
 
   sal = find_pc_line (resolved_pc, 0);
   sals.nelts = 1;

diff --git a/gdb/guile/scm-breakpoint.c b/gdb/guile/scm-breakpoint.c
index eef8a4b0ca5781bac1eabddf5714846a6dddb1e8..a7e0fe00927c1bb49d37c66a7cc935089461dbd2 100644 (file)
--- a/gdb/guile/scm-breakpoint.c
+++ b/gdb/guile/scm-breakpoint.c
@@ -31,6 +31,7 @@
 #include "arch-utils.h"
 #include "language.h"
 #include "guile-internal.h"
+#include "location.h"
 
 /* The <gdb:breakpoint> smob.
    N.B.: The name of this struct is known to breakpoint.h.
@@ -173,6 +174,8 @@ bpscm_print_breakpoint_smob (SCM self, SCM port, scm_print_state *pstate)
   /* Careful, the breakpoint may be invalid.  */
   if (b != NULL)
     {
+      const char *str;
+
       gdbscm_printf (port, " %s %s %s",
                     bpscm_type_to_string (b->type),
                     bpscm_enable_state_to_string (b->enable_state),
@@ -181,8 +184,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->addr_string != NULL)
-       gdbscm_printf (port, " @%s", b->addr_string);
+      str = event_location_to_string (b->location);
+      if (str != NULL)
+       gdbscm_printf (port, " @%s", str);
     }
 
   scm_puts (">", port);
@@ -408,6 +412,9 @@ gdbscm_register_breakpoint_x (SCM self)
   breakpoint_smob *bp_smob
     = bpscm_get_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
   struct gdb_exception except = exception_none;
+  char *location, *copy;
+  struct event_location *eloc;
+  struct cleanup *cleanup;
 
   /* We only support registering breakpoints created with make-breakpoint.  */
   if (!bp_smob->is_scheme_bkpt)
@@ -417,10 +424,13 @@ gdbscm_register_breakpoint_x (SCM self)
     scm_misc_error (FUNC_NAME, _("breakpoint is already registered"), SCM_EOL);
 
   pending_breakpoint_scm = self;
+  location = bp_smob->spec.location;
+  copy = location;
+  eloc = new_linespec_location (&copy);
+  cleanup = make_cleanup_delete_event_location (eloc);
 
   TRY
     {
-      char *location = bp_smob->spec.location;
       int internal = bp_smob->spec.is_internal;
 
       switch (bp_smob->spec.type)
@@ -428,7 +438,7 @@ gdbscm_register_breakpoint_x (SCM self)
        case bp_breakpoint:
          {
            create_breakpoint (get_current_arch (),
-                              location, NULL, -1, NULL,
+                              eloc, NULL, -1, NULL,
                               0,
                               0, bp_breakpoint,
                               0,
@@ -464,6 +474,7 @@ gdbscm_register_breakpoint_x (SCM self)
   /* Ensure this gets reset, even if there's an error.  */
   pending_breakpoint_scm = SCM_BOOL_F;
   GDBSCM_HANDLE_GDB_EXCEPTION (except);
+  do_cleanups (cleanup);
 
   return SCM_UNSPECIFIED;
 }
@@ -819,12 +830,12 @@ gdbscm_breakpoint_location (SCM self)
 {
   breakpoint_smob *bp_smob
     = bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
-  char *str;
+  const char *str;
 
   if (bp_smob->bp->type != bp_breakpoint)
     return SCM_BOOL_F;
 
-  str = bp_smob->bp->addr_string;
+  str = event_location_to_string (bp_smob->bp->location);
   if (! str)
     str = "";
 

diff --git a/gdb/linespec.c b/gdb/linespec.c
index 5c4ed3f3ea9d04189299e3aae54541339692d0b0..7cebe39fb15730fb3108018a85536e63864e304a 100644 (file)
--- a/gdb/linespec.c
+++ b/gdb/linespec.c
@@ -43,6 +43,7 @@
 #include "filenames.h"
 #include "ada-lang.h"
 #include "stack.h"
+#include "location.h"
 
 typedef struct symbol *symbolp;
 DEF_VEC_P (symbolp);
@@ -281,8 +282,8 @@ struct ls_parser
     const char *saved_arg;
 
     /* Head of the input stream.  */
-    const char **stream;
-#define PARSER_STREAM(P) (*(P)->lexer.stream)
+    const char *stream;
+#define PARSER_STREAM(P) ((P)->lexer.stream)
 
     /* The current token.  */
     linespec_token current;
@@ -315,7 +316,7 @@ static CORE_ADDR linespec_expression_to_pc (const char **exp_ptr);
 
 static struct symtabs_and_lines decode_objc (struct linespec_state *self,
                                             linespec_p ls,
-                                            const char **argptr);
+                                            const char *arg);
 
 static VEC (symtab_ptr) *symtabs_from_filename (const char *);
 
@@ -1785,21 +1786,29 @@ linespec_parse_basic (linespec_parser *parser)
    STATE->canonical.  */
 
 static void
-canonicalize_linespec (struct linespec_state *state, linespec_p ls)
+canonicalize_linespec (struct linespec_state *state, const linespec_p ls)
 {
+  char *tmp;
+
   /* If canonicalization was not requested, no need to do anything.  */
   if (!state->canonical)
     return;
 
   /* Shortcut expressions, which can only appear by themselves.  */
   if (ls->expression != NULL)
-    state->canonical->addr_string = xstrdup (ls->expression);
+    {
+      tmp = ASTRDUP (ls->expression);
+      state->canonical->location = new_linespec_location (&tmp);
+    }
   else
     {
       struct ui_file *buf;
       int need_colon = 0;
+      struct cleanup *cleanup;
 
       buf = mem_fileopen ();
+      cleanup = make_cleanup_ui_file_delete (buf);
+
       if (ls->source_filename)
        {
          fputs_unfiltered (ls->source_filename, buf);
@@ -1848,8 +1857,10 @@ canonicalize_linespec (struct linespec_state *state, linespec_p ls)
                            ls->line_offset.offset);
        }
 
-      state->canonical->addr_string = ui_file_xstrdup (buf, NULL);
-      ui_file_delete (buf);
+      tmp = ui_file_xstrdup (buf, NULL);
+      make_cleanup (xfree, tmp);
+      state->canonical->location = new_linespec_location (&tmp);
+      do_cleanups (cleanup);
     }
 }
 
@@ -2117,8 +2128,6 @@ convert_linespec_to_sals (struct linespec_state *state, linespec_p ls)
 }
 
 /* Parse a string that specifies a linespec.
-   Pass the address of a char * variable; that variable will be
-   advanced over the characters actually parsed.
 
    The basic grammar of linespecs:
 
@@ -2167,10 +2176,10 @@ convert_linespec_to_sals (struct linespec_state *state, linespec_p ls)
    if no file is validly specified.  Callers must check that.
    Also, the line number returned may be invalid.  */
 
-/* Parse the linespec in ARGPTR.  */
+/* Parse the linespec in ARG.  */
 
 static struct symtabs_and_lines
-parse_linespec (linespec_parser *parser, const char **argptr)
+parse_linespec (linespec_parser *parser, const char *arg)
 {
   linespec_token token;
   struct symtabs_and_lines values;
@@ -2181,30 +2190,30 @@ parse_linespec (linespec_parser *parser, const char **argptr)
      IDEs to work around bugs in the previous parser by quoting
      the entire linespec, so we attempt to deal with this nicely.  */
   parser->is_quote_enclosed = 0;
-  if (!is_ada_operator (*argptr)
-      && strchr (linespec_quote_characters, **argptr) != NULL)
+  if (!is_ada_operator (arg)
+      && strchr (linespec_quote_characters, *arg) != NULL)
     {
       const char *end;
 
-      end = skip_quote_char (*argptr + 1, **argptr);
+      end = skip_quote_char (arg + 1, *arg);
       if (end != NULL && is_closing_quote_enclosed (end))
        {
-         /* Here's the special case.  Skip ARGPTR past the initial
+         /* Here's the special case.  Skip ARG past the initial
             quote.  */
-         ++(*argptr);
+         ++arg;
          parser->is_quote_enclosed = 1;
        }
     }
 
-  parser->lexer.saved_arg = *argptr;
-  parser->lexer.stream = argptr;
+  parser->lexer.saved_arg = arg;
+  parser->lexer.stream = arg;
 
   /* Initialize the default symtab and line offset.  */
   initialize_defaults (&PARSER_STATE (parser)->default_symtab,
                       &PARSER_STATE (parser)->default_line);
 
   /* Objective-C shortcut.  */
-  values = decode_objc (PARSER_STATE (parser), PARSER_RESULT (parser), argptr);
+  values = decode_objc (PARSER_STATE (parser), PARSER_RESULT (parser), arg);
   if (values.sals != NULL)
     return values;
 
@@ -2390,6 +2399,7 @@ linespec_parser_new (linespec_parser *parser,
                     int default_line,
                     struct linespec_result *canonical)
 {
+  memset (parser, 0, sizeof (linespec_parser));
   parser->lexer.current.type = LSTOKEN_CONSUMED;
   memset (PARSER_RESULT (parser), 0, sizeof (struct linespec));
   PARSER_RESULT (parser)->line_offset.sign = LINE_OFFSET_UNKNOWN;
@@ -2443,7 +2453,6 @@ linespec_lex_to_end (char **stringp)
   linespec_parser parser;
   struct cleanup *cleanup;
   linespec_token token;
-  volatile struct gdb_exception e;
   const char *orig;
 
   if (stringp == NULL || *stringp == NULL)
@@ -2483,10 +2492,42 @@ linespec_lex_to_end (char **stringp)
   do_cleanups (cleanup);
 }
 
+/* A helper function for decode_line_full and decode_line_1 to
+   turn LOCATION into symtabs_and_lines.  */
+
+static struct symtabs_and_lines
+event_location_to_sals (linespec_parser *parser,
+                       const struct event_location *location)
+{
+  struct symtabs_and_lines result = {NULL, 0};
+
+  switch (event_location_type (location))
+    {
+    case LINESPEC_LOCATION:
+      {
+       TRY
+         {
+           result = parse_linespec (parser, get_linespec_location (location));
+         }
+       CATCH (except, RETURN_MASK_ERROR)
+         {
+           throw_exception (except);
+         }
+       END_CATCH
+      }
+      break;
+
+    default:
+      gdb_assert_not_reached ("unhandled event location type");
+    }
+
+  return result;
+}
+
 /* See linespec.h.  */
 
 void
-decode_line_full (char **argptr, int flags,
+decode_line_full (const struct event_location *location, int flags,
                  struct symtab *default_symtab,
                  int default_line, struct linespec_result *canonical,
                  const char *select_mode,
@@ -2497,7 +2538,6 @@ decode_line_full (char **argptr, int flags,
   VEC (const_char_ptr) *filters = NULL;
   linespec_parser parser;
   struct linespec_state *state;
-  const char *copy, *orig;
 
   gdb_assert (canonical != NULL);
   /* The filter only makes sense for 'all'.  */
@@ -2513,13 +2553,10 @@ decode_line_full (char **argptr, int flags,
   cleanups = make_cleanup (linespec_parser_delete, &parser);
   save_current_program_space ();
 
-  orig = copy = *argptr;
-  result = parse_linespec (&parser, &copy);
-  *argptr += copy - orig;
+  result = event_location_to_sals (&parser, location);
   state = PARSER_STATE (&parser);
 
   gdb_assert (result.nelts == 1 || canonical->pre_expanded);
-  gdb_assert (canonical->addr_string != NULL);
   canonical->pre_expanded = 1;
 
   /* Arrange for allocated canonical names to be freed.  */
@@ -2563,23 +2600,20 @@ decode_line_full (char **argptr, int flags,
 /* See linespec.h.  */
 
 struct symtabs_and_lines
-decode_line_1 (char **argptr, int flags,
+decode_line_1 (const struct event_location *location, int flags,
               struct symtab *default_symtab,
               int default_line)
 {
   struct symtabs_and_lines result;
   linespec_parser parser;
   struct cleanup *cleanups;
-  const char *copy, *orig;
 
   linespec_parser_new (&parser, flags, current_language, default_symtab,
                       default_line, NULL);
   cleanups = make_cleanup (linespec_parser_delete, &parser);
   save_current_program_space ();
 
-  orig = copy = *argptr;
-  result = parse_linespec (&parser, &copy);
-  *argptr += copy - orig;
+  result = event_location_to_sals (&parser, location);
 
   do_cleanups (cleanups);
   return result;
@@ -2592,6 +2626,8 @@ decode_line_with_current_source (char *string, int flags)
 {
   struct symtabs_and_lines sals;
   struct symtab_and_line cursal;
+  struct event_location *location;
+  struct cleanup *cleanup;
 
   if (string == 0)
     error (_("Empty line specification."));
@@ -2600,11 +2636,15 @@ decode_line_with_current_source (char *string, int flags)
      and get a default source symtab+line or it will recursively call us!  */
   cursal = get_current_source_symtab_and_line ();
 
-  sals = decode_line_1 (&string, flags,
+  location = string_to_event_location (&string, current_language);
+  cleanup = make_cleanup_delete_event_location (location);
+  sals = decode_line_1 (location, flags,
                        cursal.symtab, cursal.line);
 
   if (*string)
     error (_("Junk at end of line specification: %s"), string);
+
+  do_cleanups (cleanup);
   return sals;
 }
 
@@ -2614,19 +2654,25 @@ struct symtabs_and_lines
 decode_line_with_last_displayed (char *string, int flags)
 {
   struct symtabs_and_lines sals;
+  struct event_location *location;
+  struct cleanup *cleanup;
 
   if (string == 0)
     error (_("Empty line specification."));
 
+  location = string_to_event_location (&string, current_language);
+  cleanup = make_cleanup_delete_event_location (location);
   if (last_displayed_sal_is_valid ())
-    sals = decode_line_1 (&string, flags,
+    sals = decode_line_1 (location, flags,
                          get_last_displayed_symtab (),
                          get_last_displayed_line ());
   else
-    sals = decode_line_1 (&string, flags, (struct symtab *) NULL, 0);
+    sals = decode_line_1 (location, flags, (struct symtab *) NULL, 0);
 
   if (*string)
     error (_("Junk at end of line specification: %s"), string);
+
+  do_cleanups (cleanup);
   return sals;
 }
 
@@ -2679,7 +2725,7 @@ linespec_expression_to_pc (const char **exp_ptr)
    the existing C++ code to let the user choose one.  */
 
 static struct symtabs_and_lines
-decode_objc (struct linespec_state *self, linespec_p ls, const char **argptr)
+decode_objc (struct linespec_state *self, linespec_p ls, const char *arg)
 {
   struct collect_info info;
   VEC (const_char_ptr) *symbol_names = NULL;
@@ -2697,7 +2743,7 @@ decode_objc (struct linespec_state *self, linespec_p ls, const char **argptr)
   values.nelts = 0;
   values.sals = NULL;
 
-  new_argptr = find_imps (*argptr, &symbol_names); 
+  new_argptr = find_imps (arg, &symbol_names);
   if (VEC_empty (const_char_ptr, symbol_names))
     {
       do_cleanups (cleanup);
@@ -2711,9 +2757,9 @@ decode_objc (struct linespec_state *self, linespec_p ls, const char **argptr)
     {
       char *saved_arg;
 
-      saved_arg = alloca (new_argptr - *argptr + 1);
-      memcpy (saved_arg, *argptr, new_argptr - *argptr);
-      saved_arg[new_argptr - *argptr] = '\0';
+      saved_arg = alloca (new_argptr - arg + 1);
+      memcpy (saved_arg, arg, new_argptr - arg);
+      saved_arg[new_argptr - arg] = '\0';
 
       ls->function_name = xstrdup (saved_arg);
       ls->function_symbols = info.result.symbols;
@@ -2722,17 +2768,23 @@ decode_objc (struct linespec_state *self, linespec_p ls, const char **argptr)
 
       if (self->canonical)
        {
+         char *str;
+
          self->canonical->pre_expanded = 1;
+
          if (ls->source_filename)
-           self->canonical->addr_string
-             = xstrprintf ("%s:%s", ls->source_filename, saved_arg);
+           {
+             str = xstrprintf ("%s:%s",
+                               ls->source_filename, saved_arg);
+           }
          else
-           self->canonical->addr_string = xstrdup (saved_arg);
+           str = xstrdup (saved_arg);
+
+         make_cleanup (xfree, str);
+         self->canonical->location = new_linespec_location (&str);
        }
     }
 
-  *argptr = new_argptr;
-
   do_cleanups (cleanup);
 
   return values;
@@ -3830,7 +3882,7 @@ destroy_linespec_result (struct linespec_result *ls)
   int i;
   struct linespec_sals *lsal;
 
-  xfree (ls->addr_string);
+  delete_event_location (ls->location);
   for (i = 0; VEC_iterate (linespec_sals, ls->sals, i, lsal); ++i)
     {
       xfree (lsal->canonical);

diff --git a/gdb/linespec.h b/gdb/linespec.h
index 77ec46d327b0ccd58aacd375a7abc3b5302c6ea4..840bae5e4957e3c739118311d18d65e74bc9c9c7 100644 (file)
--- a/gdb/linespec.h
+++ b/gdb/linespec.h
@@ -39,7 +39,7 @@ enum decode_line_flags
 
 struct linespec_sals
 {
-  /* This is the linespec corresponding to the sals contained in this
+  /* This is the location corresponding to the sals contained in this
      object.  It can be passed as the FILTER argument to future calls
      to decode_line_full.  This is freed by
      destroy_linespec_result.  */
@@ -71,9 +71,9 @@ struct linespec_result
      object.  */
   int pre_expanded;
 
-  /* If PRE_EXPANDED is non-zero, this is set to the linespec entered
+  /* If PRE_EXPANDED is non-zero, this is set to the location entered
      by the user.  This will be freed by destroy_linespec_result.  */
-  char *addr_string;
+  struct event_location *location;
 
   /* The sals.  The vector will be freed by
      destroy_linespec_result.  */
@@ -96,10 +96,10 @@ extern struct cleanup *
 /* Decode a linespec using the provided default symtab and line.  */
 
 extern struct symtabs_and_lines
-       decode_line_1 (char **argptr, int flags,
+       decode_line_1 (const struct event_location *location, int flags,
                       struct symtab *default_symtab, int default_line);
 
-/* Parse *ARGPTR as a linespec and return results.  This is the "full"
+/* Parse LOCATION and return results.  This is the "full"
    interface to this module, which handles multiple results
    properly.
 
@@ -135,7 +135,7 @@ extern struct symtabs_and_lines
    strcmp sense) to FILTER will be returned; all others will be
    filtered out.  */
 
-extern void decode_line_full (char **argptr, int flags,
+extern void decode_line_full (const struct event_location *location, int flags,
                              struct symtab *default_symtab, int default_line,
                              struct linespec_result *canonical,
                              const char *select_mode,

diff --git a/gdb/mi/mi-cmd-break.c b/gdb/mi/mi-cmd-break.c
index 186f8076dc9a732e694687cae05a9a22b4d7f4eb..c8c988dd7642fe775af8fb8a67bff431ae6d3982 100644 (file)
--- a/gdb/mi/mi-cmd-break.c
+++ b/gdb/mi/mi-cmd-break.c
@@ -28,6 +28,9 @@
 #include "observer.h"
 #include "mi-main.h"
 #include "mi-cmd-break.h"
+#include "language.h"
+#include "location.h"
+#include "linespec.h"
 #include "gdb_obstack.h"
 #include <ctype.h>
 
@@ -177,6 +180,7 @@ mi_cmd_break_insert_1 (int dprintf, char *command, char **argv, int argc)
   int tracepoint = 0;
   struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
   enum bptype type_wanted;
+  struct event_location *location;
   struct breakpoint_ops *ops;
   char *extra_string = NULL;
 
@@ -287,7 +291,13 @@ mi_cmd_break_insert_1 (int dprintf, char *command, char **argv, int argc)
       ops = &bkpt_breakpoint_ops;
     }
 
-  create_breakpoint (get_current_arch (), address, condition, thread,
+  location = string_to_event_location (&address, current_language);
+  make_cleanup_delete_event_location (location);
+
+  if (*address)
+    error (_("Garbage '%s' at end of location"), address);
+
+  create_breakpoint (get_current_arch (), location, condition, thread,
                     extra_string,
                     0 /* condition and thread are valid.  */,
                     temp_p, type_wanted,

diff --git a/gdb/probe.c b/gdb/probe.c
index dce2b25967de09b3b74127ae41ef003356db1b32..836622081bf7172349b5e9721f5a565619b6c464 100644 (file)
--- a/gdb/probe.c
+++ b/gdb/probe.c
@@ -33,6 +33,7 @@
 #include "value.h"
 #include "ax.h"
 #include "ax-gdb.h"
+#include "location.h"
 #include <ctype.h>
 
 typedef struct bound_probe bound_probe_s;
@@ -43,23 +44,24 @@ DEF_VEC_O (bound_probe_s);
 /* See definition in probe.h.  */
 
 struct symtabs_and_lines
-parse_probes (char **argptr, struct linespec_result *canonical)
+parse_probes (const struct event_location *location,
+             struct linespec_result *canonical)
 {
-  char *arg_start, *arg_end, *arg;
+  char *arg_end, *arg;
   char *objfile_namestr = NULL, *provider = NULL, *name, *p;
   struct cleanup *cleanup;
   struct symtabs_and_lines result;
   struct objfile *objfile;
   struct program_space *pspace;
   const struct probe_ops *probe_ops;
-  const char *cs;
+  const char *arg_start, *cs;
 
   result.sals = NULL;
   result.nelts = 0;
 
-  arg_start = *argptr;
+  arg_start = get_linespec_location (location);
 
-  cs = *argptr;
+  cs = arg_start;
   probe_ops = probe_linespec_to_ops (&cs);
   if (probe_ops == NULL)
     error (_("'%s' is not a probe linespec"), arg_start);
@@ -170,12 +172,15 @@ parse_probes (char **argptr, struct linespec_result *canonical)
 
   if (canonical)
     {
+      char *canon;
+
+      canon = savestring (arg_start, arg_end - arg_start);
+      make_cleanup (xfree, canon);
       canonical->special_display = 1;
       canonical->pre_expanded = 1;
-      canonical->addr_string = savestring (*argptr, arg_end - *argptr);
+      canonical->location = new_linespec_location (&canon);
     }
 
-  *argptr = arg_end;
   do_cleanups (cleanup);
 
   return result;

diff --git a/gdb/probe.h b/gdb/probe.h
index e8d5dfe0ba351eea630bcba8901fb0771f6fecf4..c058a38943823e610f83af1b0525ef340bc143bf 100644 (file)
--- a/gdb/probe.h
+++ b/gdb/probe.h
@@ -20,6 +20,8 @@
 #if !defined (PROBE_H)
 #define PROBE_H 1
 
+struct event_location;
+
 #include "gdb_vecs.h"
 
 /* Definition of a vector of probes.  */
@@ -219,9 +221,9 @@ struct bound_probe
   };
 
 /* A helper for linespec that decodes a probe specification.  It returns a
-   symtabs_and_lines object and updates *ARGPTR or throws an error.  */
+   symtabs_and_lines object and updates LOC or throws an error.  */
 
-extern struct symtabs_and_lines parse_probes (char **argptr,
+extern struct symtabs_and_lines parse_probes (const struct event_location *loc,
                                              struct linespec_result *canon);
 
 /* Helper function to register the proper probe_ops to a newly created probe.

diff --git a/gdb/python/py-breakpoint.c b/gdb/python/py-breakpoint.c
index 42a85962f6edfceb4182fd62de73cd5ffb3f8fe2..30619dc1962e89a43002f2116a1d70ac8d4d2886 100644 (file)
--- a/gdb/python/py-breakpoint.c
+++ b/gdb/python/py-breakpoint.c
@@ -30,6 +30,7 @@
 #include "ada-lang.h"
 #include "arch-utils.h"
 #include "language.h"
+#include "location.h"
 
 /* Number of live breakpoints.  */
 static int bppy_live;
@@ -380,7 +381,7 @@ bppy_set_hit_count (PyObject *self, PyObject *newvalue, void *closure)
 static PyObject *
 bppy_get_location (PyObject *self, void *closure)
 {
-  char *str;
+  const char *str;
   gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
 
   BPPY_REQUIRE_VALID (obj);
@@ -388,8 +389,7 @@ bppy_get_location (PyObject *self, void *closure)
   if (obj->bp->type != bp_breakpoint)
     Py_RETURN_NONE;
 
-  str = obj->bp->addr_string;
-
+  str = event_location_to_string (obj->bp->location);
   if (! str)
     str = "";
   return PyString_Decode (str, strlen (str), host_charset (), NULL);
@@ -670,8 +670,12 @@ bppy_init (PyObject *self, PyObject *args, PyObject *kwargs)
        {
        case bp_breakpoint:
          {
+           struct event_location *location;
+
+           location = new_linespec_location (&copy);
+           make_cleanup_delete_event_location (location);
            create_breakpoint (python_gdbarch,
-                              copy, NULL, -1, NULL,
+                              location, NULL, -1, NULL,
                               0,
                               temporary_bp, bp_breakpoint,
                               0,

diff --git a/gdb/python/py-finishbreakpoint.c b/gdb/python/py-finishbreakpoint.c
index e3d48671a43114ab29eae444050bc8ec8e84d51c..671fd234c38d9ff39d618c34116827f19acdd73d 100644 (file)
--- a/gdb/python/py-finishbreakpoint.c
+++ b/gdb/python/py-finishbreakpoint.c
@@ -29,6 +29,7 @@
 #include "observer.h"
 #include "inferior.h"
 #include "block.h"
+#include "location.h"
 
 /* Function that is called when a Python finish bp is found out of scope.  */
 static char * const outofscope_func = "out_of_scope";
@@ -169,7 +170,7 @@ bpfinishpy_init (PyObject *self, PyObject *args, PyObject *kwargs)
   PyObject *internal = NULL;
   int internal_bp = 0;
   CORE_ADDR finish_pc, pc;
-  char *addr_str, small_buf[100];
+  char small_buf[100], *p;
   struct symbol *function;
 
   if (!PyArg_ParseTupleAndKeywords (args, kwargs, "|OO", keywords,
@@ -296,13 +297,17 @@ bpfinishpy_init (PyObject *self, PyObject *args, PyObject *kwargs)
 
   TRY
     {
+      struct event_location *location;
+      struct cleanup *back_to;
+
       /* Set a breakpoint on the return address.  */
       finish_pc = get_frame_pc (prev_frame);
       xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (finish_pc));
-      addr_str = small_buf;
-
+      p = small_buf;
+      location = new_linespec_location (&p);
+      back_to = make_cleanup_delete_event_location (location);
       create_breakpoint (python_gdbarch,
-                         addr_str, NULL, thread, NULL,
+                         location, NULL, thread, NULL,
                          0,
                          1 /*temp_flag*/,
                          bp_breakpoint,
@@ -310,6 +315,7 @@ bpfinishpy_init (PyObject *self, PyObject *args, PyObject *kwargs)
                          AUTO_BOOLEAN_TRUE,
                          &bkpt_breakpoint_ops,
                          0, 1, internal_bp, 0);
+      do_cleanups (back_to);
     }
   CATCH (except, RETURN_MASK_ALL)
     {

diff --git a/gdb/python/python.c b/gdb/python/python.c
index 4f88b0e26b5d4b0531271810d6d497be4258a2f5..c28f98be83db9b498e8cee964453e6b255f9661c 100644 (file)
--- a/gdb/python/python.c
+++ b/gdb/python/python.c
@@ -34,6 +34,7 @@
 #include "extension-priv.h"
 #include "cli/cli-utils.h"
 #include <ctype.h>
+#include "location.h"
 
 /* Declared constants and enum for python stack printing.  */
 static const char python_excp_none[] = "none";
@@ -724,12 +725,12 @@ gdbpy_decode_line (PyObject *self, PyObject *args)
   struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to
                                                  appease gcc.  */
   struct symtab_and_line sal;
-  const char *arg = NULL;
-  char *copy_to_free = NULL, *copy = NULL;
+  char *arg = NULL;
   struct cleanup *cleanups;
   PyObject *result = NULL;
   PyObject *return_result = NULL;
   PyObject *unparsed = NULL;
+  struct event_location *location;
 
   if (! PyArg_ParseTuple (args, "|s", &arg))
     return NULL;
@@ -738,14 +739,16 @@ gdbpy_decode_line (PyObject *self, PyObject *args)
 
   sals.sals = NULL;
 
+  if (arg != NULL)
+    {
+      location = new_linespec_location (&arg);
+      make_cleanup_delete_event_location (location);
+    }
+
   TRY
     {
       if (arg)
-       {
-         copy = xstrdup (arg);
-         copy_to_free = copy;
-         sals = decode_line_1 (&copy, 0, 0, 0);
-       }
+       sals = decode_line_1 (location, 0, 0, 0);
       else
        {
          set_default_source_symtab_and_line ();
@@ -761,10 +764,7 @@ gdbpy_decode_line (PyObject *self, PyObject *args)
   END_CATCH
 
   if (sals.sals != NULL && sals.sals != &sal)
-    {
-      make_cleanup (xfree, copy_to_free);
-      make_cleanup (xfree, sals.sals);
-    }
+    make_cleanup (xfree, sals.sals);
 
   if (except.reason < 0)
     {
@@ -808,9 +808,9 @@ gdbpy_decode_line (PyObject *self, PyObject *args)
       goto error;
     }
 
-  if (copy && strlen (copy) > 0)
+  if (arg != NULL && strlen (arg) > 0)
     {
-      unparsed = PyString_FromString (copy);
+      unparsed = PyString_FromString (arg);
       if (unparsed == NULL)
        {
          Py_DECREF (result);

diff --git a/gdb/remote.c b/gdb/remote.c
index 6d577d815c5e5bafe8fa55ee6c86f476acca8a3d..ca1f0df6e210cc934a7c6a43b1d161525d1b88d8 100644 (file)
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -45,6 +45,7 @@
 #include "filestuff.h"
 #include "rsp-low.h"
 #include "disasm.h"
+#include "location.h"
 
 #include <sys/time.h>
 
@@ -11242,13 +11243,12 @@ remote_download_tracepoint (struct target_ops *self, struct bp_location *loc)
 
   if (packet_support (PACKET_TracepointSource) == PACKET_ENABLE)
     {
-      if (b->addr_string)
+      if (b->location != NULL)
        {
          strcpy (buf, "QTDPsrc:");
-         encode_source_string (b->number, loc->address,
-                               "at", b->addr_string, buf + strlen (buf),
-                               2048 - strlen (buf));
-
+         encode_source_string (b->number, loc->address, "at",
+                               event_location_to_string (b->location),
+                               buf + strlen (buf), 2048 - strlen (buf));
          putpkt (buf);
          remote_get_noisy_reply (&target_buf, &target_buf_size);
          if (strcmp (target_buf, "OK"))

diff --git a/gdb/spu-tdep.c b/gdb/spu-tdep.c
index e2cd91f7722144b709d2eef5c8740a097ddcbbd4..58d66710c40c23c2aa5ed2d491bb2524fd91a7da 100644 (file)
--- a/gdb/spu-tdep.c
+++ b/gdb/spu-tdep.c
@@ -45,7 +45,7 @@
 #include "dwarf2-frame.h"
 #include "ax.h"
 #include "spu-tdep.h"
-
+#include "location.h"
 
 /* The list of available "set spu " and "show spu " commands.  */
 static struct cmd_list_element *setspucmdlist = NULL;
@@ -1953,8 +1953,10 @@ spu_catch_start (struct objfile *objfile)
 {
   struct bound_minimal_symbol minsym;
   struct compunit_symtab *cust;
+  char buf[32], *p;
   CORE_ADDR pc;
-  char buf[32];
+  struct event_location *location;
+  struct cleanup *back_to;
 
   /* Do this only if requested by "set spu stop-on-load on".  */
   if (!spu_stop_on_load_p)
@@ -1999,7 +2001,10 @@ spu_catch_start (struct objfile *objfile)
   /* Use a numerical address for the set_breakpoint command to avoid having
      the breakpoint re-set incorrectly.  */
   xsnprintf (buf, sizeof buf, "*%s", core_addr_to_string (pc));
-  create_breakpoint (get_objfile_arch (objfile), buf /* arg */,
+  p = buf;
+  location = new_linespec_location (&p);
+  back_to = make_cleanup_delete_event_location (location);
+  create_breakpoint (get_objfile_arch (objfile), location,
                     NULL /* cond_string */, -1 /* thread */,
                     NULL /* extra_string */,
                     0 /* parse_condition_and_thread */, 1 /* tempflag */,
@@ -2008,6 +2013,7 @@ spu_catch_start (struct objfile *objfile)
                     AUTO_BOOLEAN_FALSE /* pending_break_support */,
                     &bkpt_breakpoint_ops /* ops */, 0 /* from_tty */,
                     1 /* enabled */, 0 /* internal  */, 0);
+  do_cleanups (back_to);
 }
 
 

diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 294fbce75cc7c4b96b80fa2f90b08e2566ea25e2..5fa6cdd01b514806fb6dc1c3fd2419391d1b4265 100644 (file)
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,9 @@
+2015-08-11  Keith Seitz  <keiths@redhat.com>
+
+       * gdb.base/dprintf-pending.exp: Update dprintf "without format"
+       test.
+       Add tests for missing ",FMT" and ",".
+
 2015-08-10  Doug Evans  <dje@google.com>
            Keith Seitz  <keiths@redhat.com>
 

diff --git a/gdb/testsuite/gdb.base/dprintf-pending.exp b/gdb/testsuite/gdb.base/dprintf-pending.exp
index ad0aa539bf9b9e535225fb026a85731afb736431..953998f021e7fd2d709d64ae0a78009d890cf810 100644 (file)
--- a/gdb/testsuite/gdb.base/dprintf-pending.exp
+++ b/gdb/testsuite/gdb.base/dprintf-pending.exp
@@ -41,14 +41,8 @@ with_test_prefix "without format" {
     gdb_start
     gdb_reinitialize_dir $srcdir/$subdir
 
-    gdb_test \
-       "dprintf pendfunc" \
-       "Dprintf.*pendfunc.*pending." \
-       "set pending dprintf" \
-       ".*Make dprintf pending.*y or \\\[n\\\]. $" \
-       "y"
-
-    gdb_test "file ${binfile}" ".*Error in re-setting breakpoint.*" "resolved dprintf fails to be re-set"
+    gdb_test "dprintf pendfunc" "Format string required" "missing ,FMT"
+    gdb_test "dprintf pendfunc," "Format string required" "missing FMT"
 }
 
 with_test_prefix "without symbols" {

diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
index 7c04ecbcd76741ae049514fa30d6604e43c8af16..af553a325ca61eb82f3aa36f2c20724900ba5701 100644 (file)
--- a/gdb/tracepoint.c
+++ b/gdb/tracepoint.c
@@ -55,6 +55,7 @@
 #include "filestuff.h"
 #include "rsp-low.h"
 #include "tracefile.h"
+#include "location.h"
 
 /* readline include files */
 #include "readline/readline.h"
@@ -2712,14 +2713,22 @@ scope_info (char *args, int from_tty)
   int j, count = 0;
   struct gdbarch *gdbarch;
   int regno;
+  struct event_location *location;
+  struct cleanup *back_to;
 
   if (args == 0 || *args == 0)
     error (_("requires an argument (function, "
             "line or *addr) to define a scope"));
 
-  sals = decode_line_1 (&args, DECODE_LINE_FUNFIRSTLINE, NULL, 0);
+  location = string_to_event_location (&args, current_language);
+  back_to = make_cleanup_delete_event_location (location);
+  sals = decode_line_1 (location, DECODE_LINE_FUNFIRSTLINE, NULL, 0);
   if (sals.nelts == 0)
-    return;            /* Presumably decode_line_1 has already warned.  */
+    {
+      /* Presumably decode_line_1 has already warned.  */
+      do_cleanups (back_to);
+      return;
+    }
 
   /* Resolve line numbers to PC.  */
   resolve_sal_pc (&sals.sals[0]);
@@ -2856,6 +2865,7 @@ scope_info (char *args, int from_tty)
   if (count <= 0)
     printf_filtered ("Scope for %s contains no locals or arguments.\n",
                     save_args);
+  do_cleanups (back_to);
 }
 
 /* Helper for trace_dump_command.  Dump the action list starting at
@@ -3078,7 +3088,7 @@ trace_dump_command (char *args, int from_tty)
 
 extern int
 encode_source_string (int tpnum, ULONGEST addr,
-                     char *srctype, char *src, char *buf, int buf_size)
+                     char *srctype, const char *src, char *buf, int buf_size)
 {
   if (80 + strlen (srctype) > buf_size)
     error (_("Buffer too small for source encoding"));

diff --git a/gdb/tracepoint.h b/gdb/tracepoint.h
index f34be15787ddea709433f94e2d7dcc8cbded8bce..549cf61f19ba0521bf51264fbb7bc16de34ffde8 100644 (file)
--- a/gdb/tracepoint.h
+++ b/gdb/tracepoint.h
@@ -298,7 +298,7 @@ extern struct trace_state_variable *
 extern struct trace_state_variable *create_trace_state_variable (const char *name);
 
 extern int encode_source_string (int num, ULONGEST addr,
-                                char *srctype, char *src,
+                                char *srctype, const char *src,
                                 char *buf, int buf_size);
 
 extern void parse_trace_status (char *line, struct trace_status *ts);