[PATCH] Autoload-breakpoints without report-async

Hui Zhu
2012-05-03T16:37:36Z

[-- Attachment #1: Type: text/plain, Size: 2472 bytes --]

Hi guys,

According to the mail form Yao. I thought make the autoload-breakpoints and report-async function together make it too hard to review. So I move the function that depend on the report-async to be a series of separate patches after report-async.
Then the other patches of autoload-breakpoints can be reveiw separate from report-async.

Thanks,
Hui

2012-05-04 Hui Zhu <hui_zhu@mentor.com>

* breakpoint.c (hex2bin, unpack_varlen_hex): New extern.
(autoload_breakpoints_query, autoload_breakpoints_merge,
autoload_breakpoints_gdb, autoload_breakpoints_stub,
autoload_breakpoints_enums, this_ubpcmd): New variable.
(breakpoint_get_commands): New function.
(print_one_breakpoint): Add out for b->autoload_id.
(init_raw_breakpoint_without_location): Add init for autoload_id
and autoload_inserted.
(autoload_breakpoints_get_id, uploaded_bp_commands_clean,
uploaded_bp_commands_add, handle_autoload_breakpoint_cmd,
parse_autoload_breakpoint_definition,
handle_autoload_breakpoint_cmd_to_breakpoints,
parse_autoload_breakpoint_definition_to_breakpoints,
clean_upload_autoload_breakpoints,
show_upload_autoload_breakpoints,
read_autoload_breakpoints_action,
merge_uploaded_autoload_breakpoints, autoload_breakpoints_reset,
autoload_breakpoints_clean,
autoload_breakpoints_number): New function.
(initialize_breakpoint_ops): add command "autoload".
* breakpoint.h (breakpoint): Add autoload_id and autoload_inserted.
(uploaded_bpcmd, uploaded_bp): New struct.
(autoload_breakpoints_query, autoload_breakpoints_merge,
autoload_breakpoints_gdb, autoload_breakpoints_stub,
autoload_breakpoints_mode, breakpoint_get_commands,
autoload_breakpoints_reset, autoload_breakpoints_clean,
autoload_breakpoints_number, parse_autoload_breakpoint_definition,
parse_autoload_breakpoint_definition_to_breakpoints,
clean_upload_autoload_breakpoints, show_upload_autoload_breakpoints,
merge_uploaded_autoload_breakpoints): New extern.
* remote.c (PACKET_AutoloadBreakpoints): New enum.
(remote_start_remote): Check PACKET_AutoloadBreakpoints,
if need call autoload-breakpoints functions.
(remote_pr): Add PACKET_AutoloadBreakpoints.
(remote_reportasync_handler): Add handle for "QBDP".
(remote_upload_autoload_breakpoints,
remote_download_autoload_breakpoints): New functions.

2012-05-04 Hui Zhu <hui_zhu@mentor.com>

* gdb.texinfo (Setting Breakpoints): Add set breakpoint autoload.
(Remote Serial Protocol): Add Autoload-breakpoints Format.

[-- Attachment #2: autoload-breakpoints.txt --]
[-- Type: text/plain, Size: 19116 bytes --]

---
breakpoint.c | 454 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
breakpoint.h | 49 ++++++
remote.c | 133 +++++++++++++++++
3 files changed, 635 insertions(+), 1 deletion(-)

--- a/breakpoint.c
+++ b/breakpoint.c
@@ -79,6 +79,9 @@
#include "mi/mi-common.h"
#include "python/python.h"

+extern int hex2bin (const char *hex, gdb_byte *bin, int count);
+extern char *unpack_varlen_hex (char *buff, ULONGEST *result);
+
/* Prototypes for local functions. */

static void enable_delete_command (char *, int);
@@ -470,6 +473,19 @@ gdb_evaluates_breakpoint_condition_p (vo
return (mode == condition_evaluation_host);
}

+const char autoload_breakpoints_query[] = "query";
+const char autoload_breakpoints_merge[] = "merge";
+const char autoload_breakpoints_gdb[] = "gdb";
+const char autoload_breakpoints_stub[] = "stub";
+const char *const autoload_breakpoints_enums[] = {
+ autoload_breakpoints_query,
+ autoload_breakpoints_merge,
+ autoload_breakpoints_gdb,
+ autoload_breakpoints_stub,
+ NULL
+};
+const char *autoload_breakpoints_mode = autoload_breakpoints_query;
+
void _initialize_breakpoint (void);

/* Are we executing breakpoint commands? */
@@ -1120,6 +1136,15 @@ breakpoint_set_commands (struct breakpoi
observer_notify_breakpoint_modified (b);
}

+struct command_line *
+breakpoint_get_commands (struct breakpoint *b)
+{
+ if (b->commands && b->commands->commands)
+ return b->commands->commands;
+
+ return NULL;
+}
+
/* Set the internal `silent' flag on the breakpoint. Note that this
is not the same as the "silent" that may appear in the breakpoint's
commands. */
@@ -5837,6 +5862,14 @@ print_one_breakpoint (struct breakpoint
}
}
}
+
+ if (b->autoload_id)
+ {
+ annotate_field (7);
+ ui_out_text (uiout, "\tautoload-breakpoint ");
+ ui_out_field_int (uiout, "id", b->autoload_id);
+ ui_out_text (uiout, "\n");
+ }
}

static int
@@ -6554,6 +6587,8 @@ init_raw_breakpoint_without_location (st
b->condition_not_parsed = 0;
b->py_bp_object = NULL;
b->related_breakpoint = b;
+ b->autoload_id = 0;
+ b->autoload_inserted = 0;
}

/* Helper to set_raw_breakpoint below. Creates a breakpoint
@@ -15074,6 +15109,407 @@ pc_at_non_inline_function (struct addres
return 0;
}

+static int
+autoload_breakpoints_get_id (void)
+{
+ struct breakpoint *b;
+ int id = 1;
+
+ while (1)
+ {
+ ALL_BREAKPOINTS (b)
+ {
+ if (b->autoload_id == id)
+ break;
+ }
+ if (b)
+ id ++;
+ else
+ break;
+ }
+
+ return id;
+}
+
+static void
+uploaded_bp_commands_clean (struct uploaded_bp *ubp)
+{
+ struct uploaded_bpcmd *cmd, *cmd_tmp;
+
+ for (cmd = ubp->commands; cmd ? (cmd_tmp = cmd->next, 1): 0; cmd = cmd_tmp)
+ xfree (cmd);
+ ubp->commands = NULL;
+}
+
+static void
+uploaded_bp_commands_add (struct uploaded_bp *ubp, char *buf)
+{
+ struct uploaded_bpcmd *new_cmd, *cmd;
+
+ new_cmd = xzalloc (sizeof (struct uploaded_bpcmd));
+ new_cmd->str = xstrdup (buf);
+
+ for (cmd = ubp->commands; cmd && cmd->next; cmd = cmd->next)
+ ;
+ if (cmd)
+ cmd->next = new_cmd;
+ else
+ ubp->commands = new_cmd;
+}
+
+static void
+handle_autoload_breakpoint_cmd (char cmd, struct uploaded_bp *ubp)
+{
+ switch (cmd)
+ {
+ case 'E':
+ ubp->enable = 1;
+ break;
+ case 'D':
+ ubp->enable = 0;
+ break;
+ case 'R':
+ ubp->removed = 1;
+ break;
+ }
+}
+
+int
+parse_autoload_breakpoint_definition (char *line, struct uploaded_bp **ubpp)
+{
+ ULONGEST id;
+ char cmd;
+ struct uploaded_bp *ubp, *ubp_tmp;
+
+ /* Get id. */
+ line = unpack_varlen_hex (line, &id);
+ if (line[0] != ':')
+ return -1;
+ if (strlen (line) < 2)
+ return -1;
+ line += 1;
+
+ cmd = line[0];
+ if (line[1] == ':')
+ line += 2;
+ else
+ line += 1;
+
+ if ((cmd == 'C' || cmd == 'O') && id == 0)
+ return -1;
+
+ for (ubp = *ubpp; ubp ? (ubp_tmp = ubp->next, 1): 0; ubp = ubp_tmp)
+ {
+ int loop_stop = 0;
+
+ if (ubp->removed)
+ continue;
+
+ switch (cmd)
+ {
+ case 'E':
+ case 'D':
+ case 'R':
+ if (id == 0)
+ handle_autoload_breakpoint_cmd (cmd, ubp);
+ else if (ubp->id == (int)id)
+ {
+ if (line[0] != '\0' && cmd != 'R')
+ {
+ /* Get the ubp that same with the id,
+ change it to new value. */
+ loop_stop = 1;
+ }
+ else
+ {
+ handle_autoload_breakpoint_cmd (cmd, ubp);
+ return 0;
+ }
+ }
+ break;
+ case 'C':
+ case 'O':
+ if (ubp->id == (int)id)
+ loop_stop = 1;
+ break;
+ default:
+ return -1;
+ break;
+ }
+
+ if (loop_stop)
+ break;
+ }
+
+ if (id == 0)
+ return 0;
+
+ switch (cmd)
+ {
+ case 'E':
+ case 'D':
+ {
+ char *b_addr_hex;
+ char *b_addr;
+ enum bptype b_type;
+ ULONGEST ignore_num;
+ int end;
+
+ b_addr_hex = line;
+ line = strchr (line, ':');
+ if (!line)
+ return -1;
+ line[0] = '\0';
+ line += 1;
+ b_addr = alloca (strlen (b_addr_hex) / 2);
+ end = hex2bin (b_addr_hex, (gdb_byte *) b_addr,
+ strlen (b_addr_hex) / 2);
+ b_addr[end] = '\0';
+
+ if (line[0] == 'S')
+ b_type = bp_breakpoint;
+ else if (line[0] == 'H')
+ b_type = bp_hardware_breakpoint;
+ else
+ return -1;
+ if (line[1] != ':' || line[2] == '\0')
+ return -1;
+ line += 2;
+
+ unpack_varlen_hex (line, &ignore_num);
+
+ if (ubp)
+ ubp->removed = 1;
+ ubp = xzalloc (sizeof (struct uploaded_bp));
+
+ ubp->id = (int) id;
+ ubp->enable = (cmd == 'E') ? 1 : 0;
+ ubp->addr_string = xstrdup (b_addr);
+ ubp->type = b_type;
+ ubp->ignore_count = (int) ignore_num;
+
+ for (ubp_tmp = *ubpp; ubp_tmp && ubp_tmp->next;
+ ubp_tmp = ubp_tmp->next)
+ ;
+ if (ubp_tmp)
+ ubp_tmp->next = ubp;
+ else
+ *ubpp = ubp;
+ }
+ break;
+ case 'R':
+ return -1;
+ break;
+ case 'C':
+ case 'O':
+ if (!ubp)
+ return -1;
+ {
+ char buf[strlen(line)/2 + 1];
+ int end;
+
+ end = hex2bin (line, (gdb_byte *) buf, strlen (line) / 2);
+ buf[end] = '\0';
+ if (cmd == 'O')
+ {
+ if (ubp->condition)
+ {
+ xfree (ubp->condition);
+ ubp->condition = NULL;
+ }
+ if (end)
+ ubp->condition = xstrdup (buf);
+ }
+ else
+ {
+ if (end == 0)
+ uploaded_bp_commands_clean (ubp);
+ else
+ uploaded_bp_commands_add (ubp, buf);
+ }
+ }
+ break;
+ }
+
+ return 0;
+}
+
+void
+clean_upload_autoload_breakpoints (void *p)
+{
+ struct uploaded_bp **ubpp = p;
+ struct uploaded_bp *ubp, *ubp_tmp;
+
+ for (ubp = *ubpp; ubp ? (ubp_tmp = ubp->next, 1): 0; ubp = ubp_tmp)
+ {
+ uploaded_bp_commands_clean (ubp);
+ xfree (ubp);
+ }
+ *ubpp = NULL;
+}
+
+void
+show_upload_autoload_breakpoints (struct uploaded_bp *ubp)
+{
+ struct uploaded_bp *tmp;
+ int number = 0;
+
+ for (tmp = ubp; tmp; tmp = tmp->next)
+ {
+ if (!tmp->removed)
+ number ++;
+ }
+ if (number)
+ printf_filtered (_("Got %d autoload-breakpoints from target\n"), number);
+ else
+ return;
+
+ for (tmp = ubp; tmp; tmp = tmp->next)
+ {
+ if (tmp->removed)
+ continue;
+ printf_filtered (_("Id %d in %s"), tmp->id, tmp->addr_string);
+ if (tmp->condition)
+ printf_filtered (_(" stop only if %s"), tmp->condition);
+ if (tmp->ignore_count)
+ printf_filtered (_(" ignore next %d hits"), tmp->ignore_count);
+ printf_filtered (_("\n"));
+ if (tmp->commands)
+ {
+ struct uploaded_bpcmd *cmd;
+
+ for (cmd = ubp->commands; cmd; cmd = cmd->next)
+ printf_filtered (_(" %s\n"), cmd->str);
+ }
+ }
+}
+
+struct uploaded_bpcmd *this_ubpcmd = NULL;
+
+static char *
+read_autoload_breakpoints_action (void)
+{
+ char *ret = NULL;
+
+ if (this_ubpcmd)
+ {
+ ret = this_ubpcmd->str;
+ this_ubpcmd = this_ubpcmd->next;
+ }
+
+ return ret;
+}
+
+void
+merge_uploaded_autoload_breakpoints (struct uploaded_bp *ubp)
+{
+ for (; ubp; ubp = ubp->next)
+ {
+ struct breakpoint *b;
+
+ if (ubp->removed)
+ continue;
+
+ ALL_BREAKPOINTS(b)
+ {
+ if (b->autoload_inserted)
+ continue;
+
+ if (b->autoload_id == ubp->id)
+ {
+ if (strcmp (b->addr_string, ubp->addr_string) == 0)
+ {
+ printf_filtered (_("\
+Assuming autoload-breakpoints %d in GDB is same as target's\n\
+autoload-breakpoints %d at %s.\n"),
+ b->number, ubp->id, ubp->addr_string);
+ b->autoload_inserted = 1;
+ break;
+ }
+ else
+ {
+ b->autoload_id = autoload_breakpoints_get_id ();
+ printf_filtered (_("\
+Change breakpoint %d's autoload-breakpoints id to %d.\n"),
+ b->number, b->autoload_id);
+ }
+ }
+ }
+
+ if (!b)
+ {
+ /* Create new breakpoint. */
+ if (!create_breakpoint (get_current_arch (),
+ ubp->addr_string,
+ ubp->condition, -1, 0,
+ 0, ubp->type,
+ ubp->ignore_count,
+ AUTO_BOOLEAN_TRUE,
+ &bkpt_breakpoint_ops,
+ 0,
+ ubp->enable,
+ 0, CREATE_BREAKPOINT_FLAGS_INSERTED))
+ {
+ printf_filtered (_("\
+Create breakpoint for autoload-breakpoint %d got error.\n"),
+ ubp->id);
+ continue;
+ }
+ b = get_breakpoint (breakpoint_count);
+ b->autoload_id = ubp->id;
+ b->autoload_inserted = 1;
+ if (ubp->commands)
+ {
+ struct command_line *cmd_list;
+
+ this_ubpcmd = ubp->commands;
+ cmd_list = read_command_lines_1 (read_autoload_breakpoints_action,
+ 1, NULL, NULL);
+ breakpoint_set_commands (b, cmd_list);
+ }
+ printf_filtered (_("\
+Create breakpoint %d for autoload-breakpoint %d.\n"),
+ b->number, b->autoload_id);
+ }
+ }
+}
+
+void
+autoload_breakpoints_reset (void)
+{
+ struct breakpoint *b;
+
+ ALL_BREAKPOINTS(b)
+ b->autoload_inserted = 0;
+}
+
+void
+autoload_breakpoints_clean (void)
+{
+ struct breakpoint *b, *btmp;
+
+ ALL_BREAKPOINTS_SAFE (b, btmp)
+ {
+ if (b->autoload_id)
+ delete_breakpoint (b);
+ }
+}
+
+int
+autoload_breakpoints_number (void)
+{
+ int ret = 0;
+ struct breakpoint *b;
+
+ ALL_BREAKPOINTS(b)
+ {
+ if (b->autoload_id)
+ ret ++;
+ }
+
+ return ret;
+}
+
void
initialize_breakpoint_ops (void)
{
@@ -15805,6 +16241,24 @@ In this case, if gdb is controlling the
behaves as if always-inserted mode is on; if gdb is controlling the\n\
inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
NULL,
+ NULL,
+ &breakpoint_set_cmdlist,
+ &breakpoint_show_cmdlist);
+
+ add_setshow_enum_cmd ("autoload", class_support,
+ autoload_breakpoints_enums, &autoload_breakpoints_mode,
+ _("\
+Set mode for autoload-breakpoints."), _("\
+Show mode for autoload-breakpoints."), _("\
+When this mode is \"query\" (the default mode), will query when got the\n\
+autoload-breakpoints.\n\
+When this mode is \"merge\", the autoload-breakpoints\n\
+of GDB and stub will merge together when GDB connect to stub.\n\
+When this mode is \"gdb\", the autoload-breakpoints of stub will be removed\n\
+when GDB connect to stub.\n\
+When this mode is \"stub\", the autoload-breakpoints of GDB will be removed\n\
+when GDB connect to stub."),
+ NULL,
&show_always_inserted_mode,
&breakpoint_set_cmdlist,
&breakpoint_show_cmdlist);
--- a/breakpoint.h
+++ b/breakpoint.h
@@ -709,6 +709,9 @@ struct breakpoint
can sometimes be NULL for enabled GDBs as not all breakpoint
types are tracked by the Python scripting API. */
struct breakpoint_object *py_bp_object;
+
+ int autoload_id;
+ int autoload_inserted;
};

/* An instance of this type is used to represent a watchpoint. It
@@ -1059,6 +1062,25 @@ struct bpstats
enum bp_print_how print_it;
};

+struct uploaded_bpcmd
+ {
+ struct uploaded_bpcmd *next;
+ char *str;
+ };
+
+struct uploaded_bp
+ {
+ int removed;
+ struct uploaded_bp *next;
+ int id;
+ int enable;
+ char *addr_string;
+ enum bptype type;
+ int ignore_count;
+ char *condition;
+ struct uploaded_bpcmd *commands;
+ };
+
enum inf_context
{
inf_starting,
@@ -1075,8 +1097,14 @@ enum breakpoint_here
ordinary_breakpoint_here,
permanent_breakpoint_here
};
-\f

+extern const char autoload_breakpoints_query[];
+extern const char autoload_breakpoints_merge[];
+extern const char autoload_breakpoints_gdb[];
+extern const char autoload_breakpoints_stub[];
+extern const char *autoload_breakpoints_mode;
+
+\f
/* Prototypes for breakpoint-related functions. */

extern enum breakpoint_here breakpoint_here_p (struct address_space *,
@@ -1344,6 +1372,8 @@ extern void enable_breakpoint (struct br
extern void breakpoint_set_commands (struct breakpoint *b,
struct command_line *commands);

+extern struct command_line * breakpoint_get_commands (struct breakpoint *b);
+
extern void breakpoint_set_silent (struct breakpoint *b, int silent);

extern void breakpoint_set_thread (struct breakpoint *b, int thread);
@@ -1488,4 +1518,21 @@ extern struct gdbarch *get_sal_arch (str

extern void handle_solib_event (void);

+extern void autoload_breakpoints_reset (void);
+
+extern void autoload_breakpoints_clean (void);
+
+extern int autoload_breakpoints_number (void);
+
+extern int parse_autoload_breakpoint_definition (char *line,
+ struct uploaded_bp **ubpp);
+
+extern int parse_autoload_breakpoint_definition_to_breakpoints (char *line);
+
+extern void clean_upload_autoload_breakpoints (void *p);
+
+extern void show_upload_autoload_breakpoints (struct uploaded_bp *ubp);
+
+extern void merge_uploaded_autoload_breakpoints (struct uploaded_bp *ubp);
+
#endif /* !defined (BREAKPOINT_H) */
--- a/remote.c
+++ b/remote.c
@@ -214,6 +214,10 @@ static int remote_get_trace_status (stru
static int remote_upload_tracepoints (struct uploaded_tp **utpp);

static int remote_upload_trace_state_variables (struct uploaded_tsv **utsvp);
+
+static int remote_upload_autoload_breakpoints (struct uploaded_bp **ubpp);
+
+static void remote_download_autoload_breakpoints (void);

static void remote_query_supported (void);

@@ -1284,6 +1288,7 @@ enum {
PACKET_qXfer_fdpic,
PACKET_QDisableRandomization,
PACKET_QAgent,
+ PACKET_AutoloadBreakpoints,
PACKET_MAX
};

@@ -3529,6 +3534,52 @@ remote_start_remote (int from_tty, struc
up. */
rs->starting_up = 0;

+ /* Get autoload-breakpoints from stub. */
+ if (remote_protocol_packets[PACKET_AutoloadBreakpoints].support
+ != PACKET_DISABLE)
+ {
+ static struct uploaded_bp *uploaded_bps = NULL;
+ struct cleanup *old_chain = make_cleanup
+ (clean_upload_autoload_breakpoints,
+ &uploaded_bps);
+ int num;
+
+ if ((autoload_breakpoints_mode == autoload_breakpoints_stub)
+ || (autoload_breakpoints_mode == autoload_breakpoints_query
+ && (num = autoload_breakpoints_number ())
+ && query (_("Remove %d autoload-breakpoints in GDB?"), num)))
+ autoload_breakpoints_clean ();
+ else
+ autoload_breakpoints_reset ();
+
+ if (autoload_breakpoints_mode != autoload_breakpoints_gdb)
+ {
+ remote_upload_autoload_breakpoints (&uploaded_bps);
+ show_upload_autoload_breakpoints (uploaded_bps);
+ }
+ else
+ {
+ /* Remove all the autoload-breakpoints in stub part. */
+ snprintf (rs->buf, rs->buf_size, "QBDP0:R");
+ remote_send (&rs->buf, &rs->buf_size);
+ }
+
+ if (autoload_breakpoints_mode == autoload_breakpoints_query)
+ {
+ if (uploaded_bps)
+ {
+ if (!query (_("Add to GDB?")))
+ clean_upload_autoload_breakpoints (&uploaded_bps);
+ }
+ }
+
+ merge_uploaded_autoload_breakpoints (uploaded_bps);
+
+ do_cleanups (old_chain);
+
+ remote_download_autoload_breakpoints ();
+ }
+
/* If breakpoints are global, insert them now. */
if (gdbarch_has_global_breakpoints (target_gdbarch)
&& breakpoints_always_inserted_mode ())
@@ -3925,6 +3976,8 @@ static struct protocol_feature remote_pr
{ "QAgent", PACKET_DISABLE, remote_supported_packet, PACKET_QAgent},
{ "tracenz", PACKET_DISABLE,
remote_string_tracing_feature, -1 },
+ { "AutoloadBreakpoints", PACKET_DISABLE, remote_supported_packet,
+ PACKET_AutoloadBreakpoints },
};

static char *remote_support_xml;
@@ -11204,6 +11257,83 @@ remote_upload_trace_state_variables (str
return 0;
}

+static int
+remote_upload_autoload_breakpoints (struct uploaded_bp **ubpp)
+{
+ struct remote_state *rs = get_remote_state ();
+ char *p;
+
+ /* Ask for a first packet of autoload-breakpoints definition. */
+ putpkt ("qBfP");
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ p = rs->buf;
+ while (*p && *p != 'l')
+ {
+ parse_autoload_breakpoint_definition (p, ubpp);
+ /* Ask for another packet of autoload-breakpoints definition. */
+ putpkt ("qBsP");
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ p = rs->buf;
+ }
+ return 0;
+}
+
+static void
+remote_download_autoload_breakpoints (void)
+{
+ struct remote_state *rs = get_remote_state ();
+ struct breakpoint *b;
+ extern struct breakpoint *breakpoint_chain;
+
+ for (b = breakpoint_chain; b; b = b->next)
+ {
+ if (b->autoload_id && !b->autoload_inserted)
+ {
+ struct command_line *cmd;
+ char *hex = alloca (strlen (b->addr_string) * 2);
+ int end = bin2hex (b->addr_string, hex, 0);
+
+ hex[end * 2] = '\0';
+ snprintf (rs->buf, rs->buf_size, "QBDP%x:%c:%s:%c:%x",
+ b->autoload_id, (b->enable_state == bp_enabled) ? 'E' : 'D',
+ hex,
+ (b->type == bp_hardware_breakpoint) ? 'H' : 'S',
+ b->ignore_count);
+ remote_send (&rs->buf, &rs->buf_size);
+
+ if (b->cond_string)
+ {
+ char *p = rs->buf;
+ int end;
+
+ snprintf (rs->buf, rs->buf_size, "QBDP%x:O:", b->autoload_id);
+ p += strlen (p);
+ end = bin2hex (b->cond_string, p, strlen (b->cond_string));
+ p[end] = '\0';
+ remote_send (&rs->buf, &rs->buf_size);
+ }
+
+ for (cmd = breakpoint_get_commands (b); cmd; cmd = cmd->next)
+ {
+ char *p = rs->buf;
+ int end;
+
+ snprintf (rs->buf, rs->buf_size, "QBDP%x:C:", b->autoload_id);
+ p += strlen (p);
+ end = bin2hex (cmd->line, p, strlen (cmd->line));
+ p[end] = '\0';
+ remote_send (&rs->buf, &rs->buf_size);
+ }
+
+ b->autoload_inserted = 1;
+
+ printf_filtered (_("\
+Download breakpoint %d to target as autoload-breakpoint %d.\n"),
+ b->number, b->autoload_id);
+ }
+ }
+}
+
void
_initialize_remote (void)
{
@@ -11537,6 +11667,9 @@ Show the maximum size of the address (in
add_packet_config_cmd (&remote_protocol_packets[PACKET_QAgent],
"QAgent", "agent", 0);

+ add_packet_config_cmd (&remote_protocol_packets[PACKET_AutoloadBreakpoints],
+ "AutoloadBreakpoints", "autoload-breakpoints", 0);
+
/* Keep the old ``set remote Z-packet ...'' working. Each individual
Z sub-packet has its own set and show commands, but users may
have sets to this variable in their .gdbinit files (or in their

[-- Attachment #3: autoload-breakpoints-doc.txt --]
[-- Type: text/plain, Size: 4910 bytes --]

---
doc/gdb.texinfo | 103 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 103 insertions(+)

--- a/doc/gdb.texinfo
+++ b/doc/gdb.texinfo
@@ -3773,6 +3773,34 @@ not support breakpoint condition evaluat
to evaluating all these conditions on the host's side.
@end table

+Prior to @value{GDBN} connects to remote stub, some breakpoints might
+have been already set in target, either by a prior @value{GDBN} session or
+by the program itself through some special system API. When @value{GDBN}
+connects to target, it should handle these existing breakpoints from
+remote stub. We call these breakpoints @dfn{auotload-breakpoints}.
+
+This feature can be controlled via the following commands:
+
+@kindex set breakpoint autoload
+@kindex show breakpoint autoload
+@table @code
+@item set breakpoint autoload query
+If this option is @samp{query} (the default), @value{GDBN} will query to user
+how to handle the autoload-breakpoints when @value{GDBN} connect to the stub.
+
+@item set breakpoint autoload merge
+If this option is @samp{merge}, the autoload-breakpoints of both @value{GDBN}
+and of the stub will be kept.
+
+@item set breakpoint autoload gdb
+If this option is @samp{gdb}, the autoload-breakpoints of stub will be removed
+when @value{GDBN} connects to stub.
+
+@item set breakpoint autoload stub
+If this option is @samp{stub}, the autoload-breakpoints of GDB will be removed
+when @value{GDBN} connects to stub.
+@end table
+

@cindex negative breakpoint numbers
@cindex internal @value{GDBN} breakpoints
@@ -34333,6 +34361,7 @@ Show the current setting of the target w
* Memory Map Format::
* Thread List Format::
* Traceframe Info Format::
+* Autoload-breakpoints Format::
@end menu

@node Overview
@@ -38936,6 +38965,80 @@ The formal DTD for the traceframe info f
length CDATA #REQUIRED>
@end smallexample

+@node Autoload-breakpoints Format
+@section Autoload-breakpoints Format
+@cindex autoload-breakpoints format
+
+@table @samp
+@item qBfP
+@itemx qBsP
+These packets request data in autoload-breakpoints base format
+about autoload-breakpoints from the stub.
+@value{GDBN} sends @code{qBfP} to get the first piece
+of data, and multiple @code{qTsP} to get additional pieces.
+
+@item @samp{QBDP}@var{autoload-breakpoints base format}
+@value{GDBN} and the stub use this packet to control
+the autoload-breakpoints in the remote. The stub will translate
+this packet through ReportAsync Packets.
+@end table
+
+Autoload-breakpoints base format describes the operation of
+the autoload-breakpoints in @value{GDBN} and the stub.
+
+@table @samp
+
+@item @var{id}@samp{:}@var{command}@samp{:}@var{addr_string}@samp{:}@var{type}@samp{:}@var{ignore_num}
+@table @samp
+@item @var{id}
+This is the id in hex string format of this command want to control.
+this command wants to control.
+0 means all autoload-breakpoints.
+@item @var{command}
+This is the command character, either @samp{E} (for ``enable'') or
+@samp{D} (for ``disable'').
+If the autoload-breakpoint @var{id} does not exist, create one and
+enable or disable it. @value{GDBN} will create this breakpoint as
+it have been created in the target. So when the target creates the
+breakpoint, it needs to insert this breakpoint by itself.
+If the autoload-breakpoint @var{id} does exist, the following items
+will be ignored, and the autoload-breakpoint will be enabled or
+disabled as specified by @var{command}.
+@item @var{addr_string}
+This is the address of an autoload-breakpoint to create, encoded
+as a hex string.
+@item @var{type}
+This is the type of the autoload-breakpoint to create, either
+@samp{H} (for ``hardware'') or @samp{S} (for ``software'').
+@item @var{ignore_num}
+This is the ignore count of the autoload-breakpoint to create,
+encoded as a hex string.
+@end table
+
+@item @var{id}@samp{:}@samp{R}
+This is the remove packet.
+@var{id} is the number of the autoload-breakpoint that this command
+wants to remove, encoded as a hex string.
+0 means all autoload-breakpoints.
+When @value{GDBN} get this packet, it will delete this breakpoint
+as it have been removed in the target. So when the target send
+this packet, it needs to remove these breakpoints in local part by itself.
+
+@item @var{id}@samp{:}@samp{C}@samp{:}@var{cmd_str}
+This packet adds commands in @var{cmd_list} to the command list
+of the autoload-breakpoint whose number is @var{id}.
+If @var{cmd_str} is empty, the command list will be emptied.
+@var{cmd_str} is encoded as hex string.
+
+@item @var{id}@samp{:}@samp{O}@samp{:}@var{condition_str}
+This packet sets the condition of the autoload-breakpoint @var{id} to
+be as specified by @var{condition_str}.
+If @var{condition_str} is empty, the autoload-breakpoint becomes
+unconditional.
+@var{condition_str} is encoded as hex string.
+
+@end table
+
@include agentexpr.texi

@node Target Descriptions