/* Main code for remote server for GDB.
- Copyright (C) 1989-2015 Free Software Foundation, Inc.
+ Copyright (C) 1989-2016 Free Software Foundation, Inc.
This file is part of GDB.
int server_waiting;
-int extended_protocol;
+static int extended_protocol;
static int response_needed;
static int exit_requested;
int report_fork_events;
int report_vfork_events;
int report_exec_events;
+int report_thread_events;
+
+/* Whether to report TARGET_WAITKING_NO_RESUMED events. */
+static int report_no_resumed;
+
int non_stop;
int swbreak_feature;
int hwbreak_feature;
}
while (last_status.value.sig != GDB_SIGNAL_TRAP);
}
- target_arch_setup ();
+ target_post_create_inferior ();
return signal_pid;
}
(assuming success). */
last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
- target_arch_setup ();
+ target_post_create_inferior ();
if (last_status.kind != TARGET_WAITKIND_EXITED
&& last_status.kind != TARGET_WAITKIND_SIGNALLED)
to as much of DATA/LEN as we could fit. IS_MORE controls
the first character of the response. */
static int
-write_qxfer_response (char *buf, const void *data, int len, int is_more)
+write_qxfer_response (char *buf, const gdb_byte *data, int len, int is_more)
{
int out_len;
return NULL;
}
-/* Handle btrace enabling in Intel(R) Processor Trace format. */
+/* Handle btrace enabling in Intel Processor Trace format. */
static const char *
handle_btrace_enable_pt (struct thread_info *thread)
return;
}
+ if (startswith (own_buf, "QCatchSyscalls:"))
+ {
+ const char *p = own_buf + sizeof ("QCatchSyscalls:") - 1;
+ int enabled = -1;
+ CORE_ADDR sysno;
+ struct process_info *process;
+
+ if (!target_running () || !target_supports_catch_syscall ())
+ {
+ write_enn (own_buf);
+ return;
+ }
+
+ if (strcmp (p, "0") == 0)
+ enabled = 0;
+ else if (p[0] == '1' && (p[1] == ';' || p[1] == '\0'))
+ enabled = 1;
+ else
+ {
+ fprintf (stderr, "Unknown catch-syscalls mode requested: %s\n",
+ own_buf);
+ write_enn (own_buf);
+ return;
+ }
+
+ process = current_process ();
+ VEC_truncate (int, process->syscalls_to_catch, 0);
+
+ if (enabled)
+ {
+ p += 1;
+ if (*p == ';')
+ {
+ p += 1;
+ while (*p != '\0')
+ {
+ p = decode_address_to_semicolon (&sysno, p);
+ VEC_safe_push (int, process->syscalls_to_catch, (int) sysno);
+ }
+ }
+ else
+ VEC_safe_push (int, process->syscalls_to_catch, ANY_SYSCALL);
+ }
+
+ write_ok (own_buf);
+ return;
+ }
+
if (strcmp (own_buf, "QStartNoAckMode") == 0)
{
if (remote_debug)
if (handle_btrace_conf_general_set (own_buf))
return;
+ if (startswith (own_buf, "QThreadEvents:"))
+ {
+ char *mode = own_buf + strlen ("QThreadEvents:");
+ enum tribool req = TRIBOOL_UNKNOWN;
+
+ if (strcmp (mode, "0") == 0)
+ req = TRIBOOL_FALSE;
+ else if (strcmp (mode, "1") == 0)
+ req = TRIBOOL_TRUE;
+ else
+ {
+ char *mode_copy = xstrdup (mode);
+
+ /* We don't know what this mode is, so complain to GDB. */
+ sprintf (own_buf, "E.Unknown thread-events mode requested: %s\n",
+ mode_copy);
+ xfree (mode_copy);
+ return;
+ }
+
+ report_thread_events = (req == TRIBOOL_TRUE);
+
+ if (remote_debug)
+ {
+ const char *req_str = report_thread_events ? "enabled" : "disabled";
+
+ fprintf (stderr, "[thread events are now %s]\n", req_str);
+ }
+
+ write_ok (own_buf);
+ return;
+ }
+
/* Otherwise we didn't know what packet it was. Say we didn't
understand it. */
own_buf[0] = 0;
return NULL;
}
-void
+static void
monitor_show_help (void)
{
monitor_output ("The following monitor commands are supported:\n");
? search_space_len
: search_buf_size);
- found_ptr = memmem (search_buf, nr_search_bytes, pattern, pattern_len);
+ found_ptr = (gdb_byte *) memmem (search_buf, nr_search_bytes, pattern,
+ pattern_len);
if (found_ptr != NULL)
{
char ptid_s[100];
int core = target_core_of_thread (ptid);
char core_s[21];
+ const char *name = target_thread_name (ptid);
write_ptid (ptid_s, ptid);
+ buffer_xml_printf (buffer, "<thread id=\"%s\"", ptid_s);
+
if (core != -1)
{
sprintf (core_s, "%d", core);
- buffer_xml_printf (buffer, "<thread id=\"%s\" core=\"%s\"/>\n",
- ptid_s, core_s);
- }
- else
- {
- buffer_xml_printf (buffer, "<thread id=\"%s\"/>\n",
- ptid_s);
+ buffer_xml_printf (buffer, " core=\"%s\"", core_s);
}
+
+ if (name != NULL)
+ buffer_xml_printf (buffer, " name=\"%s\"", name);
+
+ buffer_xml_printf (buffer, "/>\n");
}
/* Helper for handle_qxfer_threads. */
{
static struct buffer cache;
struct thread_info *thread;
- int type, result;
+ enum btrace_read_type type;
+ int result;
if (the_target->read_btrace == NULL || writebuf != NULL)
return -2;
return 0;
}
-/* Table used by the crc32 function to calcuate the checksum. */
-
-static unsigned int crc32_table[256] =
-{0, 0};
-
/* Compute 32 bit CRC from inferior memory.
On success, return 32 bit CRC.
static unsigned long long
crc32 (CORE_ADDR base, int len, unsigned int crc)
{
- if (!crc32_table[1])
- {
- /* Initialize the CRC table and the decoding table. */
- int i, j;
- unsigned int c;
-
- for (i = 0; i < 256; i++)
- {
- for (c = i << 24, j = 8; j > 0; --j)
- c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
- crc32_table[i] = c;
- }
- }
-
while (len--)
{
unsigned char byte = 0;
if (read_inferior_memory (base, &byte, 1) != 0)
return (unsigned long long) -1;
- crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ byte) & 255];
+ crc = xcrc32 (&byte, 1, crc);
base++;
}
return (unsigned long long) crc;
/* Handle all of the extended 'q' packets. */
-void
+static void
handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
{
static struct inferior_list_entry *thread_ptr;
if (strcmp ("qSymbol::", own_buf) == 0)
{
+ struct thread_info *save_thread = current_thread;
+
+ /* For qSymbol, GDB only changes the current thread if the
+ previous current thread was of a different process. So if
+ the previous thread is gone, we need to pick another one of
+ the same process. This can happen e.g., if we followed an
+ exec in a non-leader thread. */
+ if (current_thread == NULL)
+ {
+ current_thread
+ = find_any_thread_of_pid (ptid_get_pid (general_thread));
+
+ /* Just in case, if we didn't find a thread, then bail out
+ instead of crashing. */
+ if (current_thread == NULL)
+ {
+ write_enn (own_buf);
+ current_thread = save_thread;
+ return;
+ }
+ }
+
/* GDB is suggesting new symbols have been loaded. This may
mean a new shared library has been detected as loaded, so
take the opportunity to check if breakpoints we think are
if (current_thread != NULL && the_target->look_up_symbols != NULL)
(*the_target->look_up_symbols) ();
+ current_thread = save_thread;
+
strcpy (own_buf, "OK");
return;
}
char *p = &own_buf[10];
int gdb_supports_qRelocInsn = 0;
- /* Start processing qSupported packet. */
- target_process_qsupported (NULL);
-
/* Process each feature being provided by GDB. The first
feature will follow a ':', and latter features will follow
';'. */
{
char **qsupported = NULL;
int count = 0;
+ int unknown = 0;
int i;
/* Two passes, to avoid nested strtok calls in
}
else if (strcmp (p, "vContSupported+") == 0)
vCont_supported = 1;
+ else if (strcmp (p, "QThreadEvents+") == 0)
+ ;
+ else if (strcmp (p, "no-resumed+") == 0)
+ {
+ /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
+ events. */
+ report_no_resumed = 1;
+ }
else
- target_process_qsupported (p);
-
- free (p);
+ {
+ /* Move the unknown features all together. */
+ qsupported[i] = NULL;
+ qsupported[unknown] = p;
+ unknown++;
+ }
}
+ /* Give the target backend a chance to process the unknown
+ features. */
+ target_process_qsupported (qsupported, unknown);
+
+ for (i = 0; i < count; i++)
+ free (qsupported[i]);
free (qsupported);
}
"PacketSize=%x;QPassSignals+;QProgramSignals+",
PBUFSIZ - 1);
+ if (target_supports_catch_syscall ())
+ strcat (own_buf, ";QCatchSyscalls+");
+
if (the_target->qxfer_libraries_svr4 != NULL)
strcat (own_buf, ";qXfer:libraries-svr4:read+"
";augmented-libraries-svr4-read+");
strcat (own_buf, ";tracenz+");
}
- if (target_supports_hardware_single_step ())
+ if (target_supports_hardware_single_step ()
+ || target_supports_software_single_step () )
{
- /* Support target-side breakpoint conditions and commands.
- GDBserver needs to step over the breakpoint if the condition
- is false. GDBserver software single step is too simple, so
- disable conditional breakpoints if the target doesn't have
- hardware single step. */
strcat (own_buf, ";ConditionalBreakpoints+");
}
strcat (own_buf, ";BreakpointCommands+");
strcat (own_buf, ";vContSupported+");
+ strcat (own_buf, ";QThreadEvents+");
+
+ strcat (own_buf, ";no-resumed+");
+
/* Reinitialize components as needed for the new connection. */
hostio_handle_new_gdb_connection ();
target_handle_new_gdb_connection ();
}
/* Parse vCont packets. */
-void
+static void
handle_v_cont (char *own_buf)
{
char *p, *q;
goto err;
p = q;
- if (!gdb_signal_to_host_p (sig))
+ if (!gdb_signal_to_host_p ((enum gdb_signal) sig))
goto err;
- resume_info[i].sig = gdb_signal_to_host (sig);
+ resume_info[i].sig = gdb_signal_to_host ((enum gdb_signal) sig);
}
else if (p[0] == 'r')
{
{
last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
- if (last_status.kind == TARGET_WAITKIND_NO_RESUMED)
+ if (last_status.kind == TARGET_WAITKIND_NO_RESUMED
+ && !report_no_resumed)
{
- /* No proper RSP support for this yet. At least return
- error. */
+ /* The client does not support this stop reply. At least
+ return error. */
sprintf (own_buf, "E.No unwaited-for children left.");
disable_async_io ();
return;
}
/* Attach to a new program. Return 1 if successful, 0 if failure. */
-int
+static int
handle_v_attach (char *own_buf)
{
int pid;
}
/* Kill process. Return 1 if successful, 0 if failure. */
-int
+static int
handle_v_kill (char *own_buf)
{
int pid;
}
/* Handle all of the extended 'v' packets. */
-void
+static void
handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
{
if (!disable_packet_vCont)
{
+ if (strcmp (own_buf, "vCtrlC") == 0)
+ {
+ (*the_target->request_interrupt) ();
+ write_ok (own_buf);
+ return;
+ }
+
if (startswith (own_buf, "vCont;"))
{
require_running (own_buf);
gdbserver_version (void)
{
printf ("GNU gdbserver %s%s\n"
- "Copyright (C) 2015 Free Software Foundation, Inc.\n"
+ "Copyright (C) 2016 Free Software Foundation, Inc.\n"
"gdbserver is free software, covered by the "
"GNU General Public License.\n"
"This gdbserver was configured as \"%s\"\n",
start_event_loop ();
/* If an exit was requested (using the "monitor exit"
- command), terminate now. The only other way to get
- here is for getpkt to fail; close the connection
- and reopen it at the top of the loop. */
+ command), terminate now. */
+ if (exit_requested)
+ throw_quit ("Quit");
+
+ /* The only other way to get here is for getpkt to fail:
+
+ - If --once was specified, we're done.
+
+ - If not in extended-remote mode, and we're no longer
+ debugging anything, simply exit: GDB has disconnected
+ after processing the last process exit.
- if (exit_requested || run_once)
+ - Otherwise, close the connection and reopen it at the
+ top of the loop. */
+ if (run_once || (!extended_protocol && !target_running ()))
throw_quit ("Quit");
fprintf (stderr,
int packet_len;
int new_packet_len = -1;
- /* Used to decide when gdbserver should exit in
- multi-mode/remote. */
- static int have_ran = 0;
-
- if (!have_ran)
- have_ran = target_running ();
-
disable_async_io ();
response_needed = 0;
discard_queued_stop_replies (pid_to_ptid (pid));
write_ok (own_buf);
- if (extended_protocol)
+ if (extended_protocol || target_running ())
{
- /* Treat this like a normal program exit. */
+ /* There is still at least one inferior remaining or
+ we are in extended mode, so don't terminate gdbserver,
+ and instead treat this like a normal program exit. */
last_status.kind = TARGET_WAITKIND_EXITED;
last_status.value.integer = 0;
last_ptid = pid_to_ptid (pid);
case 'C':
require_running (own_buf);
hex2bin (own_buf + 1, &sig, 1);
- if (gdb_signal_to_host_p (sig))
- signal = gdb_signal_to_host (sig);
+ if (gdb_signal_to_host_p ((enum gdb_signal) sig))
+ signal = gdb_signal_to_host ((enum gdb_signal) sig);
else
signal = 0;
myresume (own_buf, 0, signal);
case 'S':
require_running (own_buf);
hex2bin (own_buf + 1, &sig, 1);
- if (gdb_signal_to_host_p (sig))
- signal = gdb_signal_to_host (sig);
+ if (gdb_signal_to_host_p ((enum gdb_signal) sig))
+ signal = gdb_signal_to_host ((enum gdb_signal) sig);
else
signal = 0;
myresume (own_buf, 1, signal);
{
char *dataptr;
ULONGEST addr;
- int len;
+ int kind;
char type = own_buf[1];
int res;
const int insert = ch == 'Z';
char *p = &own_buf[3];
p = unpack_varlen_hex (p, &addr);
- len = strtol (p + 1, &dataptr, 16);
+ kind = strtol (p + 1, &dataptr, 16);
if (insert)
{
struct breakpoint *bp;
- bp = set_gdb_breakpoint (type, addr, len, &res);
+ bp = set_gdb_breakpoint (type, addr, kind, &res);
if (bp != NULL)
{
res = 0;
}
}
else
- res = delete_gdb_breakpoint (type, addr, len);
+ res = delete_gdb_breakpoint (type, addr, kind);
if (res == 0)
write_ok (own_buf);
response_needed = 0;
- if (!extended_protocol && have_ran && !target_running ())
- {
- /* In non-stop, defer exiting until GDB had a chance to query
- the whole vStopped list (until it gets an OK). */
- if (QUEUE_is_empty (notif_event_p, notif_stop.queue))
- {
- /* Be transparent when GDB is connected through stdio -- no
- need to spam GDB's console. */
- if (!remote_connection_is_stdio ())
- fprintf (stderr, "GDBserver exiting\n");
- remote_close ();
- exit (0);
- }
- }
-
if (exit_requested)
return -1;
return 0;
}
+/* Push a stop notification on the notification queue. */
+
+static void
+push_stop_notification (ptid_t ptid, struct target_waitstatus *status)
+{
+ struct vstop_notif *vstop_notif = XNEW (struct vstop_notif);
+
+ vstop_notif->status = *status;
+ vstop_notif->ptid = ptid;
+ /* Push Stop notification. */
+ notif_push (¬if_stop, (struct notif_event *) vstop_notif);
+}
+
/* Event-loop callback for target events. */
int
if (last_status.kind == TARGET_WAITKIND_NO_RESUMED)
{
- /* No RSP support for this yet. */
+ if (gdb_connected () && report_no_resumed)
+ push_stop_notification (null_ptid, &last_status);
}
else if (last_status.kind != TARGET_WAITKIND_IGNORE)
{
mark_breakpoints_out (process);
mourn_inferior (process);
}
+ else if (last_status.kind == TARGET_WAITKIND_THREAD_EXITED)
+ ;
else
{
/* We're reporting this thread as stopped. Update its
exit (0);
}
- if (last_status.kind == TARGET_WAITKIND_STOPPED)
+ if (last_status.kind == TARGET_WAITKIND_EXITED
+ || last_status.kind == TARGET_WAITKIND_SIGNALLED
+ || last_status.kind == TARGET_WAITKIND_THREAD_EXITED)
+ ;
+ else
{
/* A thread stopped with a signal, but gdb isn't
connected to handle it. Pass it down to the
resume_info.thread = last_ptid;
resume_info.kind = resume_continue;
- resume_info.sig = gdb_signal_to_host (last_status.value.sig);
+ if (last_status.kind == TARGET_WAITKIND_STOPPED)
+ resume_info.sig = gdb_signal_to_host (last_status.value.sig);
+ else
+ resume_info.sig = 0;
(*the_target->resume) (&resume_info, 1);
}
- else if (debug_threads)
- debug_printf ("GDB not connected; ignoring event %d for [%s]\n",
- (int) last_status.kind,
- target_pid_to_str (last_ptid));
}
else
- {
- struct vstop_notif *vstop_notif = XNEW (struct vstop_notif);
-
- vstop_notif->status = last_status;
- vstop_notif->ptid = last_ptid;
- /* Push Stop notification. */
- notif_push (¬if_stop,
- (struct notif_event *) vstop_notif);
- }
+ push_stop_notification (last_ptid, &last_status);
}
/* Be sure to not change the selected thread behind GDB's back.
projects / deliverable / binutils-gdb.git / blobdiff