this can go away. */
static int wait_forever_enabled_p = 1;
+/* Allow the user to specify what sequence to send to the remote
+ when he requests a program interruption: Although ^C is usually
+ what remote systems expect (this is the default, here), it is
+ sometimes preferable to send a break. On other systems such
+ as the Linux kernel, a break followed by g, which is Magic SysRq g
+ is required in order to interrupt the execution. */
+const char interrupt_sequence_control_c[] = "Ctrl-C";
+const char interrupt_sequence_break[] = "BREAK";
+const char interrupt_sequence_break_g[] = "BREAK-g";
+static const char *interrupt_sequence_modes[] =
+ {
+ interrupt_sequence_control_c,
+ interrupt_sequence_break,
+ interrupt_sequence_break_g,
+ NULL
+ };
+static const char *interrupt_sequence_mode = interrupt_sequence_control_c;
-/* This variable chooses whether to send a ^C or a break when the user
- requests program interruption. Although ^C is usually what remote
- systems expect, and that is the default here, sometimes a break is
- preferable instead. */
+static void
+show_interrupt_sequence (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
+{
+ if (interrupt_sequence_mode == interrupt_sequence_control_c)
+ fprintf_filtered (file,
+ _("Send the ASCII ETX character (Ctrl-c) "
+ "to the remote target to interrupt the "
+ "execution of the program.\n"));
+ else if (interrupt_sequence_mode == interrupt_sequence_break)
+ fprintf_filtered (file,
+ _("send a break signal to the remote target "
+ "to interrupt the execution of the program.\n"));
+ else if (interrupt_sequence_mode == interrupt_sequence_break_g)
+ fprintf_filtered (file,
+ _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
+ "the remote target to interrupt the execution "
+ "of Linux kernel.\n"));
+ else
+ internal_error (__FILE__, __LINE__,
+ _("Invalid value for interrupt_sequence_mode: %s."),
+ interrupt_sequence_mode);
+}
+
+/* This boolean variable specifies whether interrupt_sequence is sent
+ to the remote target when gdb connects to it.
+ This is mostly needed when you debug the Linux kernel: The Linux kernel
+ expects BREAK g which is Magic SysRq g for connecting gdb. */
+static int interrupt_on_connect = 0;
+/* This variable is used to implement the "set/show remotebreak" commands.
+ Since these commands are now deprecated in favor of "set/show remote
+ interrupt-sequence", it no longer has any effect on the code. */
static int remote_break;
+static void
+set_remotebreak (char *args, int from_tty, struct cmd_list_element *c)
+{
+ if (remote_break)
+ interrupt_sequence_mode = interrupt_sequence_break;
+ else
+ interrupt_sequence_mode = interrupt_sequence_control_c;
+}
+
+static void
+show_remotebreak (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
+{
+}
+
/* Descriptor for I/O to remote machine. Initialize it to NULL so that
remote_open knows that we don't have a file open when the program
starts. */
set_remote_protocol_packet_cmd,
show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist);
+ /* The command code copies the documentation strings. */
+ xfree (set_doc);
+ xfree (show_doc);
/* set/show remote NAME-packet {auto,on,off} -- legacy. */
if (legacy)
{
PACKET_qXfer_siginfo_write,
PACKET_qAttached,
PACKET_ConditionalTracepoints,
+ PACKET_bc,
+ PACKET_bs,
PACKET_MAX
};
if (attached == -1)
attached = remote_query_attached (pid);
- inf = add_inferior (pid);
+ if (gdbarch_has_global_solist (target_gdbarch))
+ {
+ /* If the target shares code across all inferiors, then every
+ attach adds a new inferior. */
+ inf = add_inferior (pid);
+
+ /* ... and every inferior is bound to the same program space.
+ However, each inferior may still have its own address
+ space. */
+ inf->aspace = maybe_new_address_space ();
+ inf->pspace = current_program_space;
+ }
+ else
+ {
+ /* In the traditional debugging scenario, there's a 1-1 match
+ between program/address spaces. We simply bind the inferior
+ to the program space's address space. */
+ inf = current_inferior ();
+ inferior_appeared (inf, pid);
+ }
inf->attach_flag = attached;
int extended_p;
};
+/* Send interrupt_sequence to remote target. */
+static void
+send_interrupt_sequence ()
+{
+ if (interrupt_sequence_mode == interrupt_sequence_control_c)
+ serial_write (remote_desc, "\x03", 1);
+ else if (interrupt_sequence_mode == interrupt_sequence_break)
+ serial_send_break (remote_desc);
+ else if (interrupt_sequence_mode == interrupt_sequence_break_g)
+ {
+ serial_send_break (remote_desc);
+ serial_write (remote_desc, "g", 1);
+ }
+ else
+ internal_error (__FILE__, __LINE__,
+ _("Invalid value for interrupt_sequence_mode: %s."),
+ interrupt_sequence_mode);
+}
+
static void
remote_start_remote (struct ui_out *uiout, void *opaque)
{
/* Ack any packet which the remote side has already sent. */
serial_write (remote_desc, "+", 1);
+ if (interrupt_on_connect)
+ send_interrupt_sequence ();
+
/* The first packet we send to the target is the optional "supported
packets" request. If the target can answer this, it will tell us
which later probes to skip. */
this before anything involving memory or registers. */
target_find_description ();
+ /* Next, now that we know something about the target, update the
+ address spaces in the program spaces. */
+ update_address_spaces ();
+
/* On OSs where the list of libraries is global to all
processes, we fetch them early. */
if (gdbarch_has_global_solist (target_gdbarch))
PACKET_qXfer_siginfo_write },
{ "ConditionalTracepoints", PACKET_DISABLE, remote_cond_tracepoint_feature,
PACKET_ConditionalTracepoints },
+ { "ReverseContinue", PACKET_DISABLE, remote_supported_packet,
+ PACKET_bc },
+ { "ReverseStep", PACKET_DISABLE, remote_supported_packet,
+ PACKET_bs },
};
static void
error (_("Attaching to %s failed"),
target_pid_to_str (pid_to_ptid (pid)));
- remote_add_inferior (pid, 1);
+ set_current_inferior (remote_add_inferior (pid, 1));
inferior_ptid = pid_to_ptid (pid);
remote_pass_signals ();
/* The vCont packet doesn't need to specify threads via Hc. */
- if (remote_vcont_resume (ptid, step, siggnal))
- goto done;
+ /* No reverse support (yet) for vCont. */
+ if (execution_direction != EXEC_REVERSE)
+ if (remote_vcont_resume (ptid, step, siggnal))
+ goto done;
/* All other supported resume packets do use Hc, so set the continue
thread. */
if (info_verbose && siggnal != TARGET_SIGNAL_0)
warning (" - Can't pass signal %d to target in reverse: ignored.\n",
siggnal);
+
+ if (step
+ && remote_protocol_packets[PACKET_bs].support == PACKET_DISABLE)
+ error (_("Remote reverse-step not supported."));
+ if (!step
+ && remote_protocol_packets[PACKET_bc].support == PACKET_DISABLE)
+ error (_("Remote reverse-continue not supported."));
+
strcpy (buf, step ? "bs" : "bc");
}
else if (siggnal != TARGET_SIGNAL_0)
if (rs->cached_wait_status)
return;
- /* Send a break or a ^C, depending on user preference. */
-
- if (remote_break)
- serial_send_break (remote_desc);
- else
- serial_write (remote_desc, "\003", 1);
+ /* Send interrupt_sequence to remote target. */
+ send_interrupt_sequence ();
}
/* This is the generic stop called via the target vector. When a target
struct cleanup *old_chain;
struct ui_file *stb;
char *str;
- long length;
stb = mem_fileopen ();
old_chain = make_cleanup_ui_file_delete (stb);
fputstrn_unfiltered (buf, n, 0, stb);
- str = ui_file_xstrdup (stb, &length);
+ str = ui_file_xstrdup (stb, NULL);
do_cleanups (old_chain);
return str;
}
extended_remote_restart ();
}
- /* Clean up from the last time we ran, before we mark the target
- running again. This will mark breakpoints uninserted, and
- get_offsets may insert breakpoints. */
- init_thread_list ();
- init_wait_for_inferior ();
+ if (!have_inferiors ())
+ {
+ /* Clean up from the last time we ran, before we mark the target
+ running again. This will mark breakpoints uninserted, and
+ get_offsets may insert breakpoints. */
+ init_thread_list ();
+ init_wait_for_inferior ();
+ }
/* Now mark the inferior as running before we do anything else. */
inferior_ptid = magic_null_ptid;
static char buf[64];
struct remote_state *rs = get_remote_state ();
- if (ptid_equal (magic_null_ptid, ptid))
- {
- xsnprintf (buf, sizeof buf, "Thread <main>");
- return buf;
- }
- else if (remote_multi_process_p (rs)
- && ptid_get_tid (ptid) != 0 && ptid_get_pid (ptid) != 0)
+ if (ptid_is_pid (ptid))
{
- xsnprintf (buf, sizeof buf, "Thread %d.%ld",
- ptid_get_pid (ptid), ptid_get_tid (ptid));
- return buf;
+ /* Printing an inferior target id. */
+
+ /* When multi-process extensions are off, there's no way in the
+ remote protocol to know the remote process id, if there's any
+ at all. There's one exception --- when we're connected with
+ target extended-remote, and we manually attached to a process
+ with "attach PID". We don't record anywhere a flag that
+ allows us to distinguish that case from the case of
+ connecting with extended-remote and the stub already being
+ attached to a process, and reporting yes to qAttached, hence
+ no smart special casing here. */
+ if (!remote_multi_process_p (rs))
+ {
+ xsnprintf (buf, sizeof buf, "Remote target");
+ return buf;
+ }
+
+ return normal_pid_to_str (ptid);
}
- else if (ptid_get_tid (ptid) != 0)
+ else
{
- xsnprintf (buf, sizeof buf, "Thread %ld",
- ptid_get_tid (ptid));
+ if (ptid_equal (magic_null_ptid, ptid))
+ xsnprintf (buf, sizeof buf, "Thread <main>");
+ else if (remote_multi_process_p (rs))
+ xsnprintf (buf, sizeof buf, "Thread %d.%ld",
+ ptid_get_pid (ptid), ptid_get_tid (ptid));
+ else
+ xsnprintf (buf, sizeof buf, "Thread %ld",
+ ptid_get_tid (ptid));
return buf;
}
-
- return normal_pid_to_str (ptid);
}
/* Get the address of the thread local variable in OBJFILE which is
help_list (remote_cmdlist, "remote ", -1, gdb_stdout);
}
-static int remote_target_can_reverse = 1;
-
static int
remote_can_execute_reverse (void)
{
- return remote_target_can_reverse;
+ if (remote_protocol_packets[PACKET_bs].support == PACKET_ENABLE
+ || remote_protocol_packets[PACKET_bc].support == PACKET_ENABLE)
+ return 1;
+ else
+ return 0;
}
static int
_initialize_remote (void)
{
struct remote_state *rs;
+ struct cmd_list_element *cmd;
+ char *cmd_name;
/* architecture specific data */
remote_gdbarch_data_handle =
Set whether to send break if interrupted."), _("\
Show whether to send break if interrupted."), _("\
If set, a break, instead of a cntrl-c, is sent to the remote target."),
- NULL, NULL, /* FIXME: i18n: Whether to send break if interrupted is %s. */
+ set_remotebreak, show_remotebreak,
&setlist, &showlist);
+ cmd_name = "remotebreak";
+ cmd = lookup_cmd (&cmd_name, setlist, "", -1, 1);
+ deprecate_cmd (cmd, "set remote interrupt-sequence");
+ cmd_name = "remotebreak"; /* needed because lookup_cmd updates the pointer */
+ cmd = lookup_cmd (&cmd_name, showlist, "", -1, 1);
+ deprecate_cmd (cmd, "show remote interrupt-sequence");
+
+ add_setshow_enum_cmd ("interrupt-sequence", class_support,
+ interrupt_sequence_modes, &interrupt_sequence_mode, _("\
+Set interrupt sequence to remote target."), _("\
+Show interrupt sequence to remote target."), _("\
+Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
+ NULL, show_interrupt_sequence,
+ &remote_set_cmdlist,
+ &remote_show_cmdlist);
+
+ add_setshow_boolean_cmd ("interrupt-on-connect", class_support,
+ &interrupt_on_connect, _("\
+Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
+Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
+If set, interrupt sequence is sent to remote target."),
+ NULL, NULL,
+ &remote_set_cmdlist, &remote_show_cmdlist);
/* Install commands for configuring memory read/write packets. */
"qGetTLSAddr", "get-thread-local-storage-address",
0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_bc],
+ "bc", "reverse-continue", 0);
+
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_bs],
+ "bs", "reverse-step", 0);
+
add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported],
"qSupported", "supported-packets", 0);
projects / deliverable / binutils-gdb.git / blobdiff