X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbserver%2Fserver.c;h=9c50929703525f25d06b6ab1ec3a74466ea2ac05;hb=28170b88cc8b40fdea2b065dafe6e1872a47ee4e;hp=28ea0482eaba9ba4856fcf4ed36133dc2cd5cd95;hpb=969c39fbcd6a5675c1f4b97cd23d680e4b5b6487;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c index 28ea0482ea..9c50929703 100644 --- a/gdb/gdbserver/server.c +++ b/gdb/gdbserver/server.c @@ -1,5 +1,5 @@ /* Main code for remote server for GDB. - Copyright (C) 1989-2014 Free Software Foundation, Inc. + Copyright (C) 1989-2016 Free Software Foundation, Inc. This file is part of GDB. @@ -21,11 +21,14 @@ #include "agent.h" #include "notif.h" #include "tdesc.h" +#include "rsp-low.h" +#include #include #if HAVE_SIGNAL_H #include #endif +#include "gdb_vecs.h" #include "gdb_wait.h" #include "btrace-common.h" #include "filestuff.h" @@ -38,11 +41,7 @@ requirement, so `Hc pPID.TID' is pretty much undefined. So CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for resuming all threads of the process (again, `Hc' isn't used for - multi-process), or a specific thread ptid_t. - - We also set this when handling a single-thread `vCont' resume, as - some places in the backends check it to know when (and for which - thread) single-thread scheduler-locking is in effect. */ + multi-process), or a specific thread ptid_t. */ ptid_t cont_thread; /* The thread set with an `Hg' packet. */ @@ -58,7 +57,22 @@ static int exit_requested; int run_once; int multi_process; +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; + +/* True if the "vContSupported" feature is active. In that case, GDB + wants us to report whether single step is supported in the reply to + "vCont?" packet. */ +static int vCont_supported; /* Whether we should attempt to disable the operating system's address space randomization feature before starting an inferior. */ @@ -66,19 +80,10 @@ int disable_randomization = 1; static char **program_argv, **wrapper_argv; -/* Enable miscellaneous debugging output. The name is historical - it - was originally used to debug LinuxThreads support. */ -int debug_threads; - -/* Enable debugging of h/w breakpoint/watchpoint support. */ -int debug_hw_points; - int pass_signals[GDB_SIGNAL_LAST]; int program_signals[GDB_SIGNAL_LAST]; int program_signals_p; -jmp_buf toplevel; - /* The PID of the originally created or attached inferior. Used to send signals to the process when GDB sends us an asynchronous interrupt (user hitting Control-C in the client), and to wait for the child to exit @@ -114,7 +119,7 @@ int disable_packet_qfThreadInfo; static struct target_waitstatus last_status; static ptid_t last_ptid; -static char *own_buf; +char *own_buf; static unsigned char *mem_buf; /* A sub-class of 'struct notif_event' for stop, holding information @@ -132,6 +137,10 @@ struct vstop_notif struct target_waitstatus status; }; +/* The current btrace configuration. This is gdbserver's mirror of GDB's + btrace configuration. */ +static struct btrace_config current_btrace_conf; + DEFINE_QUEUE_P (notif_event_p); /* Put a stop reply to the stop reply queue. */ @@ -139,7 +148,7 @@ DEFINE_QUEUE_P (notif_event_p); static void queue_stop_reply (ptid_t ptid, struct target_waitstatus *status) { - struct vstop_notif *new_notif = xmalloc (sizeof (*new_notif)); + struct vstop_notif *new_notif = XNEW (struct vstop_notif); new_notif->ptid = ptid; new_notif->status = *status; @@ -148,15 +157,15 @@ queue_stop_reply (ptid_t ptid, struct target_waitstatus *status) } static int -remove_all_on_match_pid (QUEUE (notif_event_p) *q, - QUEUE_ITER (notif_event_p) *iter, - struct notif_event *event, - void *data) +remove_all_on_match_ptid (QUEUE (notif_event_p) *q, + QUEUE_ITER (notif_event_p) *iter, + struct notif_event *event, + void *data) { - int *pid = data; + ptid_t filter_ptid = *(ptid_t *) data; + struct vstop_notif *vstop_event = (struct vstop_notif *) event; - if (*pid == -1 - || ptid_get_pid (((struct vstop_notif *) event)->ptid) == *pid) + if (ptid_match (vstop_event->ptid, filter_ptid)) { if (q->free_func != NULL) q->free_func (event); @@ -167,14 +176,13 @@ remove_all_on_match_pid (QUEUE (notif_event_p) *q, return 1; } -/* Get rid of the currently pending stop replies for PID. If PID is - -1, then apply to all processes. */ +/* See server.h. */ -static void -discard_queued_stop_replies (int pid) +void +discard_queued_stop_replies (ptid_t ptid) { QUEUE_iterate (notif_event_p, notif_stop.queue, - remove_all_on_match_pid, &pid); + remove_all_on_match_ptid, &ptid); } static void @@ -193,7 +201,7 @@ struct notif_server notif_stop = static int target_running (void) { - return all_threads.head != NULL; + return get_first_thread () != NULL; } static int @@ -209,7 +217,7 @@ start_inferior (char **argv) count++; for (i = 0; argv[i] != NULL; i++) count++; - new_argv = alloca (sizeof (char *) * count); + new_argv = XALLOCAVEC (char *, count); count = 0; for (i = 0; wrapper_argv[i] != NULL; i++) new_argv[count++] = wrapper_argv[i]; @@ -222,8 +230,8 @@ start_inferior (char **argv) { int i; for (i = 0; new_argv[i]; ++i) - fprintf (stderr, "new_argv[%d] = \"%s\"\n", i, new_argv[i]); - fflush (stderr); + debug_printf ("new_argv[%d] = \"%s\"\n", i, new_argv[i]); + debug_flush (); } #ifdef SIGTTOU @@ -231,10 +239,6 @@ start_inferior (char **argv) signal (SIGTTIN, SIG_DFL); #endif - /* Clear this so the backend doesn't get confused, thinking - CONT_THREAD died, and it needs to resume all threads. */ - cont_thread = null_ptid; - signal_pid = create_inferior (new_argv[0], new_argv); /* FIXME: we don't actually know at this point that the create @@ -263,22 +267,22 @@ start_inferior (char **argv) last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0); - if (last_status.kind != TARGET_WAITKIND_STOPPED) - return signal_pid; - - do + if (last_status.kind == TARGET_WAITKIND_STOPPED) { - (*the_target->resume) (&resume_info, 1); + do + { + (*the_target->resume) (&resume_info, 1); - last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0); - if (last_status.kind != TARGET_WAITKIND_STOPPED) - return signal_pid; + last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0); + if (last_status.kind != TARGET_WAITKIND_STOPPED) + break; - current_inferior->last_resume_kind = resume_stop; - current_inferior->last_status = last_status; + current_thread->last_resume_kind = resume_stop; + current_thread->last_status = last_status; + } + while (last_status.value.sig != GDB_SIGNAL_TRAP); } - while (last_status.value.sig != GDB_SIGNAL_TRAP); - + target_post_create_inferior (); return signal_pid; } @@ -286,12 +290,16 @@ start_inferior (char **argv) (assuming success). */ last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0); + target_post_create_inferior (); + if (last_status.kind != TARGET_WAITKIND_EXITED && last_status.kind != TARGET_WAITKIND_SIGNALLED) { - current_inferior->last_resume_kind = resume_stop; - current_inferior->last_status = last_status; + current_thread->last_resume_kind = resume_stop; + current_thread->last_status = last_status; } + else + mourn_inferior (find_process_pid (ptid_get_pid (last_ptid))); return signal_pid; } @@ -313,10 +321,6 @@ attach_inferior (int pid) whichever we were told to attach to. */ signal_pid = pid; - /* Clear this so the backend doesn't get confused, thinking - CONT_THREAD died, and it needs to resume all threads. */ - cont_thread = null_ptid; - if (!non_stop) { last_ptid = mywait (pid_to_ptid (pid), &last_status, 0, 0); @@ -328,8 +332,8 @@ attach_inferior (int pid) && last_status.value.sig == GDB_SIGNAL_STOP) last_status.value.sig = GDB_SIGNAL_TRAP; - current_inferior->last_resume_kind = resume_stop; - current_inferior->last_status = last_status; + current_thread->last_resume_kind = resume_stop; + current_thread->last_status = last_status; } return 0; @@ -386,7 +390,7 @@ decode_xfer (char *buf, char **object, char **rw, char **annex, char **offset) 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; @@ -395,19 +399,38 @@ write_qxfer_response (char *buf, const void *data, int len, int is_more) else buf[0] = 'l'; - return remote_escape_output (data, len, (unsigned char *) buf + 1, &out_len, - PBUFSIZ - 2) + 1; + return remote_escape_output (data, len, 1, (unsigned char *) buf + 1, + &out_len, PBUFSIZ - 2) + 1; } -/* Handle btrace enabling. */ +/* Handle btrace enabling in BTS format. */ static const char * -handle_btrace_enable (struct thread_info *thread) +handle_btrace_enable_bts (struct thread_info *thread) { if (thread->btrace != NULL) return "E.Btrace already enabled."; - thread->btrace = target_enable_btrace (thread->entry.id); + current_btrace_conf.format = BTRACE_FORMAT_BTS; + thread->btrace = target_enable_btrace (thread->entry.id, + ¤t_btrace_conf); + if (thread->btrace == NULL) + return "E.Could not enable btrace."; + + return NULL; +} + +/* Handle btrace enabling in Intel Processor Trace format. */ + +static const char * +handle_btrace_enable_pt (struct thread_info *thread) +{ + if (thread->btrace != NULL) + return "E.Btrace already enabled."; + + current_btrace_conf.format = BTRACE_FORMAT_PT; + thread->btrace = target_enable_btrace (thread->entry.id, + ¤t_btrace_conf); if (thread->btrace == NULL) return "E.Could not enable btrace."; @@ -439,17 +462,11 @@ handle_btrace_general_set (char *own_buf) const char *err; char *op; - if (strncmp ("Qbtrace:", own_buf, strlen ("Qbtrace:")) != 0) + if (!startswith (own_buf, "Qbtrace:")) return 0; op = own_buf + strlen ("Qbtrace:"); - if (!target_supports_btrace ()) - { - strcpy (own_buf, "E.Target does not support branch tracing."); - return -1; - } - if (ptid_equal (general_thread, null_ptid) || ptid_equal (general_thread, minus_one_ptid)) { @@ -467,11 +484,13 @@ handle_btrace_general_set (char *own_buf) err = NULL; if (strcmp (op, "bts") == 0) - err = handle_btrace_enable (thread); + err = handle_btrace_enable_bts (thread); + else if (strcmp (op, "pt") == 0) + err = handle_btrace_enable_pt (thread); else if (strcmp (op, "off") == 0) err = handle_btrace_disable (thread); else - err = "E.Bad Qbtrace operation. Use bts or off."; + err = "E.Bad Qbtrace operation. Use bts, pt, or off."; if (err != 0) strcpy (own_buf, err); @@ -481,12 +500,79 @@ handle_btrace_general_set (char *own_buf) return 1; } +/* Handle the "Qbtrace-conf" packet. */ + +static int +handle_btrace_conf_general_set (char *own_buf) +{ + struct thread_info *thread; + char *op; + + if (!startswith (own_buf, "Qbtrace-conf:")) + return 0; + + op = own_buf + strlen ("Qbtrace-conf:"); + + if (ptid_equal (general_thread, null_ptid) + || ptid_equal (general_thread, minus_one_ptid)) + { + strcpy (own_buf, "E.Must select a single thread."); + return -1; + } + + thread = find_thread_ptid (general_thread); + if (thread == NULL) + { + strcpy (own_buf, "E.No such thread."); + return -1; + } + + if (startswith (op, "bts:size=")) + { + unsigned long size; + char *endp = NULL; + + errno = 0; + size = strtoul (op + strlen ("bts:size="), &endp, 16); + if (endp == NULL || *endp != 0 || errno != 0 || size > UINT_MAX) + { + strcpy (own_buf, "E.Bad size value."); + return -1; + } + + current_btrace_conf.bts.size = (unsigned int) size; + } + else if (strncmp (op, "pt:size=", strlen ("pt:size=")) == 0) + { + unsigned long size; + char *endp = NULL; + + errno = 0; + size = strtoul (op + strlen ("pt:size="), &endp, 16); + if (endp == NULL || *endp != 0 || errno != 0 || size > UINT_MAX) + { + strcpy (own_buf, "E.Bad size value."); + return -1; + } + + current_btrace_conf.pt.size = (unsigned int) size; + } + else + { + strcpy (own_buf, "E.Bad Qbtrace configuration option."); + return -1; + } + + write_ok (own_buf); + return 1; +} + /* Handle all of the extended 'Q' packets. */ static void handle_general_set (char *own_buf) { - if (strncmp ("QPassSignals:", own_buf, strlen ("QPassSignals:")) == 0) + if (startswith (own_buf, "QPassSignals:")) { int numsigs = (int) GDB_SIGNAL_LAST, i; const char *p = own_buf + strlen ("QPassSignals:"); @@ -511,7 +597,7 @@ handle_general_set (char *own_buf) return; } - if (strncmp ("QProgramSignals:", own_buf, strlen ("QProgramSignals:")) == 0) + if (startswith (own_buf, "QProgramSignals:")) { int numsigs = (int) GDB_SIGNAL_LAST, i; const char *p = own_buf + strlen ("QProgramSignals:"); @@ -538,6 +624,54 @@ handle_general_set (char *own_buf) 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) @@ -551,11 +685,11 @@ handle_general_set (char *own_buf) return; } - if (strncmp (own_buf, "QNonStop:", 9) == 0) + if (startswith (own_buf, "QNonStop:")) { char *mode = own_buf + 9; int req = -1; - char *req_str; + const char *req_str; if (strcmp (mode, "0") == 0) req = 0; @@ -588,8 +722,7 @@ handle_general_set (char *own_buf) return; } - if (strncmp ("QDisableRandomization:", own_buf, - strlen ("QDisableRandomization:")) == 0) + if (startswith (own_buf, "QDisableRandomization:")) { char *packet = own_buf + strlen ("QDisableRandomization:"); ULONGEST setting; @@ -613,7 +746,7 @@ handle_general_set (char *own_buf) && handle_tracepoint_general_set (own_buf)) return; - if (strncmp ("QAgent:", own_buf, strlen ("QAgent:")) == 0) + if (startswith (own_buf, "QAgent:")) { char *mode = own_buf + strlen ("QAgent:"); int req = 0; @@ -640,6 +773,42 @@ handle_general_set (char *own_buf) if (handle_btrace_general_set (own_buf)) return; + 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; @@ -684,7 +853,7 @@ get_features_xml (const char *annex) return NULL; } -void +static void monitor_show_help (void) { monitor_output ("The following monitor commands are supported:\n"); @@ -694,6 +863,11 @@ monitor_show_help (void) monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n"); monitor_output (" set remote-debug <0|1>\n"); monitor_output (" Enable remote protocol debugging messages\n"); + monitor_output (" set debug-format option1[,option2,...]\n"); + monitor_output (" Add additional information to debugging messages\n"); + monitor_output (" Options: all, none"); + monitor_output (", timestamp"); + monitor_output ("\n"); monitor_output (" exit\n"); monitor_output (" Quit GDBserver\n"); } @@ -733,7 +907,10 @@ gdb_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) res = prepare_to_access_memory (); if (res == 0) { - res = read_inferior_memory (memaddr, myaddr, len); + if (set_desired_thread (1)) + res = read_inferior_memory (memaddr, myaddr, len); + else + res = 1; done_accessing_memory (); return res == 0 ? len : -1; @@ -757,7 +934,10 @@ gdb_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len) ret = prepare_to_access_memory (); if (ret == 0) { - ret = write_inferior_memory (memaddr, myaddr, len); + if (set_desired_thread (1)) + ret = write_inferior_memory (memaddr, myaddr, len); + else + ret = EIO; done_accessing_memory (); } return ret; @@ -797,7 +977,8 @@ handle_search_memory_1 (CORE_ADDR start_addr, CORE_ADDR search_space_len, ? 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) { @@ -865,7 +1046,7 @@ handle_search_memory (char *own_buf, int packet_len) CORE_ADDR found_addr; int cmd_name_len = sizeof ("qSearch:memory:") - 1; - pattern = malloc (packet_len); + pattern = (gdb_byte *) malloc (packet_len); if (pattern == NULL) { error ("Unable to allocate memory to perform the search"); @@ -889,7 +1070,7 @@ handle_search_memory (char *own_buf, int packet_len) if (search_space_len < search_buf_size) search_buf_size = search_space_len; - search_buf = malloc (search_buf_size); + search_buf = (gdb_byte *) malloc (search_buf_size); if (search_buf == NULL) { free (pattern); @@ -921,6 +1102,78 @@ handle_search_memory (char *own_buf, int packet_len) return; \ } +/* Parse options to --debug-format= and "monitor set debug-format". + ARG is the text after "--debug-format=" or "monitor set debug-format". + IS_MONITOR is non-zero if we're invoked via "monitor set debug-format". + This triggers calls to monitor_output. + The result is NULL if all options were parsed ok, otherwise an error + message which the caller must free. + + N.B. These commands affect all debug format settings, they are not + cumulative. If a format is not specified, it is turned off. + However, we don't go to extra trouble with things like + "monitor set debug-format all,none,timestamp". + Instead we just parse them one at a time, in order. + + The syntax for "monitor set debug" we support here is not identical + to gdb's "set debug foo on|off" because we also use this function to + parse "--debug-format=foo,bar". */ + +static char * +parse_debug_format_options (const char *arg, int is_monitor) +{ + VEC (char_ptr) *options; + int ix; + char *option; + + /* First turn all debug format options off. */ + debug_timestamp = 0; + + /* First remove leading spaces, for "monitor set debug-format". */ + while (isspace (*arg)) + ++arg; + + options = delim_string_to_char_ptr_vec (arg, ','); + + for (ix = 0; VEC_iterate (char_ptr, options, ix, option); ++ix) + { + if (strcmp (option, "all") == 0) + { + debug_timestamp = 1; + if (is_monitor) + monitor_output ("All extra debug format options enabled.\n"); + } + else if (strcmp (option, "none") == 0) + { + debug_timestamp = 0; + if (is_monitor) + monitor_output ("All extra debug format options disabled.\n"); + } + else if (strcmp (option, "timestamp") == 0) + { + debug_timestamp = 1; + if (is_monitor) + monitor_output ("Timestamps will be added to debug output.\n"); + } + else if (*option == '\0') + { + /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */ + continue; + } + else + { + char *msg = xstrprintf ("Unknown debug-format argument: \"%s\"\n", + option); + + free_char_ptr_vec (options); + return msg; + } + } + + free_char_ptr_vec (options); + return NULL; +} + /* Handle monitor commands not handled by target-specific handlers. */ static void @@ -938,12 +1191,12 @@ handle_monitor_command (char *mon, char *own_buf) } else if (strcmp (mon, "set debug-hw-points 1") == 0) { - debug_hw_points = 1; + show_debug_regs = 1; monitor_output ("H/W point debugging output enabled.\n"); } else if (strcmp (mon, "set debug-hw-points 0") == 0) { - debug_hw_points = 0; + show_debug_regs = 0; monitor_output ("H/W point debugging output disabled.\n"); } else if (strcmp (mon, "set remote-debug 1") == 0) @@ -956,6 +1209,20 @@ handle_monitor_command (char *mon, char *own_buf) remote_debug = 0; monitor_output ("Protocol debug output disabled.\n"); } + else if (startswith (mon, "set debug-format ")) + { + char *error_msg + = parse_debug_format_options (mon + sizeof ("set debug-format ") - 1, + 1); + + if (error_msg != NULL) + { + monitor_output (error_msg); + monitor_show_help (); + write_enn (own_buf); + xfree (error_msg); + } + } else if (strcmp (mon, "help") == 0) monitor_show_help (); else if (strcmp (mon, "exit") == 0) @@ -1002,12 +1269,63 @@ handle_qxfer_auxv (const char *annex, if (the_target->read_auxv == NULL || writebuf != NULL) return -2; - if (annex[0] != '\0' || !target_running ()) + if (annex[0] != '\0' || current_thread == NULL) return -1; return (*the_target->read_auxv) (offset, readbuf, len); } +/* Handle qXfer:exec-file:read. */ + +static int +handle_qxfer_exec_file (const char *const_annex, + gdb_byte *readbuf, const gdb_byte *writebuf, + ULONGEST offset, LONGEST len) +{ + char *file; + ULONGEST pid; + int total_len; + + if (the_target->pid_to_exec_file == NULL || writebuf != NULL) + return -2; + + if (const_annex[0] == '\0') + { + if (current_thread == NULL) + return -1; + + pid = pid_of (current_thread); + } + else + { + char *annex = (char *) alloca (strlen (const_annex) + 1); + + strcpy (annex, const_annex); + annex = unpack_varlen_hex (annex, &pid); + + if (annex[0] != '\0') + return -1; + } + + if (pid <= 0) + return -1; + + file = (*the_target->pid_to_exec_file) (pid); + if (file == NULL) + return -1; + + total_len = strlen (file); + + if (offset > total_len) + return -1; + + if (offset + len > total_len) + len = total_len - offset; + + memcpy (readbuf, file + offset, len); + return len; +} + /* Handle qXfer:features:read. */ static int @@ -1041,6 +1359,48 @@ handle_qxfer_features (const char *annex, return len; } +/* Worker routine for handle_qxfer_libraries. + Add to the length pointed to by ARG a conservative estimate of the + length needed to transmit the file name of INF. */ + +static void +accumulate_file_name_length (struct inferior_list_entry *inf, void *arg) +{ + struct dll_info *dll = (struct dll_info *) inf; + unsigned int *total_len = (unsigned int *) arg; + + /* Over-estimate the necessary memory. Assume that every character + in the library name must be escaped. */ + *total_len += 128 + 6 * strlen (dll->name); +} + +/* Worker routine for handle_qxfer_libraries. + Emit the XML to describe the library in INF. */ + +static void +emit_dll_description (struct inferior_list_entry *inf, void *arg) +{ + struct dll_info *dll = (struct dll_info *) inf; + char **p_ptr = (char **) arg; + char *p = *p_ptr; + char *name; + + strcpy (p, " name); + strcpy (p, name); + free (name); + p = p + strlen (p); + strcpy (p, "\">base_addr); + p = p + strlen (p); + strcpy (p, "\"/>\n"); + p = p + strlen (p); + + *p_ptr = p; +} + /* Handle qXfer:libraries:read. */ static int @@ -1050,45 +1410,25 @@ handle_qxfer_libraries (const char *annex, { unsigned int total_len; char *document, *p; - struct inferior_list_entry *dll_ptr; if (writebuf != NULL) return -2; - if (annex[0] != '\0' || !target_running ()) + if (annex[0] != '\0' || current_thread == NULL) return -1; - /* Over-estimate the necessary memory. Assume that every character - in the library name must be escaped. */ total_len = 64; - for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next) - total_len += 128 + 6 * strlen (((struct dll_info *) dll_ptr)->name); + for_each_inferior_with_data (&all_dlls, accumulate_file_name_length, + &total_len); - document = malloc (total_len); + document = (char *) malloc (total_len); if (document == NULL) return -1; - strcpy (document, "\n"); + strcpy (document, "\n"); p = document + strlen (document); - for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next) - { - struct dll_info *dll = (struct dll_info *) dll_ptr; - char *name; - - strcpy (p, " name); - strcpy (p, name); - free (name); - p = p + strlen (p); - strcpy (p, "\">base_addr); - p = p + strlen (p); - strcpy (p, "\"/>\n"); - p = p + strlen (p); - } + for_each_inferior_with_data (&all_dlls, emit_dll_description, &p); strcpy (p, "\n"); @@ -1118,7 +1458,7 @@ handle_qxfer_libraries_svr4 (const char *annex, if (writebuf != NULL) return -2; - if (!target_running () || the_target->qxfer_libraries_svr4 == NULL) + if (current_thread == NULL || the_target->qxfer_libraries_svr4 == NULL) return -1; return the_target->qxfer_libraries_svr4 (annex, readbuf, writebuf, offset, len); @@ -1147,7 +1487,7 @@ handle_qxfer_siginfo (const char *annex, if (the_target->qxfer_siginfo == NULL) return -2; - if (annex[0] != '\0' || !target_running ()) + if (annex[0] != '\0' || current_thread == NULL) return -1; return (*the_target->qxfer_siginfo) (annex, readbuf, writebuf, offset, len); @@ -1163,7 +1503,7 @@ handle_qxfer_spu (const char *annex, if (the_target->qxfer_spu == NULL) return -2; - if (!target_running ()) + if (current_thread == NULL) return -1; return (*the_target->qxfer_spu) (annex, readbuf, writebuf, offset, len); @@ -1181,7 +1521,7 @@ handle_qxfer_statictrace (const char *annex, if (writebuf != NULL) return -2; - if (annex[0] != '\0' || !target_running () || current_traceframe == -1) + if (annex[0] != '\0' || current_thread == NULL || current_traceframe == -1) return -1; if (traceframe_read_sdata (current_traceframe, offset, @@ -1190,36 +1530,45 @@ handle_qxfer_statictrace (const char *annex, return nbytes; } -/* Helper for handle_qxfer_threads. */ +/* Helper for handle_qxfer_threads_proper. + Emit the XML to describe the thread of INF. */ static void -handle_qxfer_threads_proper (struct buffer *buffer) +handle_qxfer_threads_worker (struct inferior_list_entry *inf, void *arg) { - struct inferior_list_entry *thread; + struct thread_info *thread = (struct thread_info *) inf; + struct buffer *buffer = (struct buffer *) arg; + ptid_t ptid = thread_to_gdb_id (thread); + char ptid_s[100]; + int core = target_core_of_thread (ptid); + char core_s[21]; + const char *name = target_thread_name (ptid); - buffer_grow_str (buffer, "\n"); + write_ptid (ptid_s, ptid); + + buffer_xml_printf (buffer, "next) + if (core != -1) { - ptid_t ptid = thread_to_gdb_id ((struct thread_info *)thread); - char ptid_s[100]; - int core = target_core_of_thread (ptid); - char core_s[21]; + sprintf (core_s, "%d", core); + buffer_xml_printf (buffer, " core=\"%s\"", core_s); + } - write_ptid (ptid_s, ptid); + if (name != NULL) + buffer_xml_printf (buffer, " name=\"%s\"", name); - if (core != -1) - { - sprintf (core_s, "%d", core); - buffer_xml_printf (buffer, "\n", - ptid_s, core_s); - } - else - { - buffer_xml_printf (buffer, "\n", - ptid_s); - } - } + buffer_xml_printf (buffer, "/>\n"); +} + +/* Helper for handle_qxfer_threads. */ + +static void +handle_qxfer_threads_proper (struct buffer *buffer) +{ + buffer_grow_str (buffer, "\n"); + + for_each_inferior_with_data (&all_threads, handle_qxfer_threads_worker, + buffer); buffer_grow_str0 (buffer, "\n"); } @@ -1237,7 +1586,7 @@ handle_qxfer_threads (const char *annex, if (writebuf != NULL) return -2; - if (!target_running () || annex[0] != '\0') + if (annex[0] != '\0') return -1; if (offset == 0) @@ -1333,27 +1682,99 @@ handle_qxfer_fdpic (const char *annex, gdb_byte *readbuf, if (the_target->read_loadmap == NULL) return -2; - if (!target_running ()) + if (current_thread == NULL) return -1; return (*the_target->read_loadmap) (annex, offset, readbuf, len); } -/* Handle qXfer:btrace:read. */ +/* Handle qXfer:btrace:read. */ + +static int +handle_qxfer_btrace (const char *annex, + gdb_byte *readbuf, const gdb_byte *writebuf, + ULONGEST offset, LONGEST len) +{ + static struct buffer cache; + struct thread_info *thread; + enum btrace_read_type type; + int result; + + if (the_target->read_btrace == NULL || writebuf != NULL) + return -2; + + if (ptid_equal (general_thread, null_ptid) + || ptid_equal (general_thread, minus_one_ptid)) + { + strcpy (own_buf, "E.Must select a single thread."); + return -3; + } + + thread = find_thread_ptid (general_thread); + if (thread == NULL) + { + strcpy (own_buf, "E.No such thread."); + return -3; + } + + if (thread->btrace == NULL) + { + strcpy (own_buf, "E.Btrace not enabled."); + return -3; + } + + if (strcmp (annex, "all") == 0) + type = BTRACE_READ_ALL; + else if (strcmp (annex, "new") == 0) + type = BTRACE_READ_NEW; + else if (strcmp (annex, "delta") == 0) + type = BTRACE_READ_DELTA; + else + { + strcpy (own_buf, "E.Bad annex."); + return -3; + } + + if (offset == 0) + { + buffer_free (&cache); + + result = target_read_btrace (thread->btrace, &cache, type); + if (result != 0) + { + memcpy (own_buf, cache.buffer, cache.used_size); + return -3; + } + } + else if (offset > cache.used_size) + { + buffer_free (&cache); + return -3; + } + + if (len > cache.used_size - offset) + len = cache.used_size - offset; + + memcpy (readbuf, cache.buffer + offset, len); + + return len; +} + +/* Handle qXfer:btrace-conf:read. */ static int -handle_qxfer_btrace (const char *annex, - gdb_byte *readbuf, const gdb_byte *writebuf, - ULONGEST offset, LONGEST len) +handle_qxfer_btrace_conf (const char *annex, + gdb_byte *readbuf, const gdb_byte *writebuf, + ULONGEST offset, LONGEST len) { static struct buffer cache; struct thread_info *thread; - int type, result; + int result; - if (the_target->read_btrace == NULL || writebuf != NULL) + if (the_target->read_btrace_conf == NULL || writebuf != NULL) return -2; - if (!target_running ()) + if (annex[0] != '\0') return -1; if (ptid_equal (general_thread, null_ptid) @@ -1376,23 +1797,11 @@ handle_qxfer_btrace (const char *annex, return -3; } - if (strcmp (annex, "all") == 0) - type = BTRACE_READ_ALL; - else if (strcmp (annex, "new") == 0) - type = BTRACE_READ_NEW; - else if (strcmp (annex, "delta") == 0) - type = BTRACE_READ_DELTA; - else - { - strcpy (own_buf, "E.Bad annex."); - return -3; - } - if (offset == 0) { buffer_free (&cache); - result = target_read_btrace (thread->btrace, &cache, type); + result = target_read_btrace_conf (thread->btrace, &cache); if (result != 0) { memcpy (own_buf, cache.buffer, cache.used_size); @@ -1417,6 +1826,8 @@ static const struct qxfer qxfer_packets[] = { { "auxv", handle_qxfer_auxv }, { "btrace", handle_qxfer_btrace }, + { "btrace-conf", handle_qxfer_btrace_conf }, + { "exec-file", handle_qxfer_exec_file}, { "fdpic", handle_qxfer_fdpic}, { "features", handle_qxfer_features }, { "libraries", handle_qxfer_libraries }, @@ -1438,7 +1849,7 @@ handle_qxfer (char *own_buf, int packet_len, int *new_packet_len_p) char *annex; char *offset; - if (strncmp (own_buf, "qXfer:", 6) != 0) + if (!startswith (own_buf, "qXfer:")) return 0; /* Grab the object, r/w and annex. */ @@ -1474,7 +1885,7 @@ handle_qxfer (char *own_buf, int packet_len, int *new_packet_len_p) more. */ if (len > PBUFSIZ - 2) len = PBUFSIZ - 2; - data = malloc (len + 1); + data = (unsigned char *) malloc (len + 1); if (data == NULL) { write_enn (own_buf); @@ -1508,7 +1919,7 @@ handle_qxfer (char *own_buf, int packet_len, int *new_packet_len_p) unsigned char *data; strcpy (own_buf, "E00"); - data = malloc (packet_len - (offset - own_buf)); + data = (unsigned char *) malloc (packet_len - (offset - own_buf)); if (data == NULL) { write_enn (own_buf); @@ -1548,11 +1959,6 @@ handle_qxfer (char *own_buf, int packet_len, int *new_packet_len_p) 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. @@ -1561,20 +1967,6 @@ static unsigned int crc32_table[256] = 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; @@ -1583,15 +1975,46 @@ crc32 (CORE_ADDR base, int len, unsigned int crc) 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; } +/* Add supported btrace packets to BUF. */ + +static void +supported_btrace_packets (char *buf) +{ + int btrace_supported = 0; + + if (target_supports_btrace (BTRACE_FORMAT_BTS)) + { + strcat (buf, ";Qbtrace:bts+"); + strcat (buf, ";Qbtrace-conf:bts:size+"); + + btrace_supported = 1; + } + + if (target_supports_btrace (BTRACE_FORMAT_PT)) + { + strcat (buf, ";Qbtrace:pt+"); + strcat (buf, ";Qbtrace-conf:pt:size+"); + + btrace_supported = 1; + } + + if (!btrace_supported) + return; + + strcat (buf, ";Qbtrace:off+"); + strcat (buf, ";qXfer:btrace:read+"); + strcat (buf, ";qXfer:btrace-conf:read+"); +} + /* 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; @@ -1607,7 +2030,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) gdb_id = general_thread; else { - thread_ptr = all_threads.head; + thread_ptr = get_first_inferior (&all_threads); gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr); } @@ -1619,6 +2042,28 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) 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 @@ -1634,9 +2079,11 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) if (target_supports_tracepoints ()) tracepoint_look_up_symbols (); - if (target_running () && the_target->look_up_symbols != NULL) + if (current_thread != NULL && the_target->look_up_symbols != NULL) (*the_target->look_up_symbols) (); + current_thread = save_thread; + strcpy (own_buf, "OK"); return; } @@ -1648,7 +2095,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) ptid_t gdb_id; require_running (own_buf); - thread_ptr = all_threads.head; + thread_ptr = get_first_inferior (&all_threads); *own_buf++ = 'm'; gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr); @@ -1694,15 +2141,12 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) } /* Protocol features query. */ - if (strncmp ("qSupported", own_buf, 10) == 0 + if (startswith (own_buf, "qSupported") && (own_buf[10] == ':' || own_buf[10] == '\0')) { 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 ';'. */ @@ -1710,6 +2154,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) { char **qsupported = NULL; int count = 0; + int unknown = 0; int i; /* Two passes, to avoid nested strtok calls in @@ -1719,7 +2164,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) p = strtok (NULL, ";")) { count++; - qsupported = xrealloc (qsupported, count * sizeof (char *)); + qsupported = XRESIZEVEC (char *, qsupported, count); qsupported[count - 1] = xstrdup (p); } @@ -1738,12 +2183,64 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) /* GDB supports relocate instruction requests. */ gdb_supports_qRelocInsn = 1; } + else if (strcmp (p, "swbreak+") == 0) + { + /* GDB wants us to report whether a trap is caused + by a software breakpoint and for us to handle PC + adjustment if necessary on this target. */ + if (target_supports_stopped_by_sw_breakpoint ()) + swbreak_feature = 1; + } + else if (strcmp (p, "hwbreak+") == 0) + { + /* GDB wants us to report whether a trap is caused + by a hardware breakpoint. */ + if (target_supports_stopped_by_hw_breakpoint ()) + hwbreak_feature = 1; + } + else if (strcmp (p, "fork-events+") == 0) + { + /* GDB supports and wants fork events if possible. */ + if (target_supports_fork_events ()) + report_fork_events = 1; + } + else if (strcmp (p, "vfork-events+") == 0) + { + /* GDB supports and wants vfork events if possible. */ + if (target_supports_vfork_events ()) + report_vfork_events = 1; + } + else if (strcmp (p, "exec-events+") == 0) + { + /* GDB supports and wants exec events if possible. */ + if (target_supports_exec_events ()) + report_exec_events = 1; + } + 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); } @@ -1751,6 +2248,9 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) "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+"); @@ -1788,6 +2288,15 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) if (target_supports_multi_process ()) strcat (own_buf, ";multiprocess+"); + if (target_supports_fork_events ()) + strcat (own_buf, ";fork-events+"); + + if (target_supports_vfork_events ()) + strcat (own_buf, ";vfork-events+"); + + if (target_supports_exec_events ()) + strcat (own_buf, ";exec-events+"); + if (target_supports_non_stop ()) strcat (own_buf, ";QNonStop+"); @@ -1813,26 +2322,43 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) strcat (own_buf, ";tracenz+"); } - /* Support target-side breakpoint conditions and commands. */ - strcat (own_buf, ";ConditionalBreakpoints+"); + if (target_supports_hardware_single_step () + || target_supports_software_single_step () ) + { + strcat (own_buf, ";ConditionalBreakpoints+"); + } strcat (own_buf, ";BreakpointCommands+"); if (target_supports_agent ()) strcat (own_buf, ";QAgent+"); - if (target_supports_btrace ()) - { - strcat (own_buf, ";Qbtrace:bts+"); - strcat (own_buf, ";Qbtrace:off+"); - strcat (own_buf, ";qXfer:btrace:read+"); - } + supported_btrace_packets (own_buf); + + if (target_supports_stopped_by_sw_breakpoint ()) + strcat (own_buf, ";swbreak+"); + + if (target_supports_stopped_by_hw_breakpoint ()) + strcat (own_buf, ";hwbreak+"); + + if (the_target->pid_to_exec_file != NULL) + strcat (own_buf, ";qXfer:exec-file:read+"); + + 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 (); return; } /* Thread-local storage support. */ if (the_target->get_tls_address != NULL - && strncmp ("qGetTLSAddr:", own_buf, 12) == 0) + && startswith (own_buf, "qGetTLSAddr:")) { char *p = own_buf + 12; CORE_ADDR parts[2], address = 0; @@ -1897,7 +2423,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) /* Windows OS Thread Information Block address support. */ if (the_target->get_tib_address != NULL - && strncmp ("qGetTIBAddr:", own_buf, 12) == 0) + && startswith (own_buf, "qGetTIBAddr:")) { char *annex; int n; @@ -1919,9 +2445,9 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) } /* Handle "monitor" commands. */ - if (strncmp ("qRcmd,", own_buf, 6) == 0) + if (startswith (own_buf, "qRcmd,")) { - char *mon = malloc (PBUFSIZ); + char *mon = (char *) malloc (PBUFSIZ); int len = strlen (own_buf + 6); if (mon == NULL) @@ -1930,7 +2456,8 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) return; } - if ((len % 2) != 0 || unhexify (mon, own_buf + 6, len / 2) != len / 2) + if ((len % 2) != 0 + || hex2bin (own_buf + 6, (gdb_byte *) mon, len / 2) != len / 2) { write_enn (own_buf); free (mon); @@ -1949,8 +2476,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) return; } - if (strncmp ("qSearch:memory:", own_buf, - sizeof ("qSearch:memory:") - 1) == 0) + if (startswith (own_buf, "qSearch:memory:")) { require_running (own_buf); handle_search_memory (own_buf, packet_len); @@ -1958,7 +2484,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) } if (strcmp (own_buf, "qAttached") == 0 - || strncmp (own_buf, "qAttached:", sizeof ("qAttached:") - 1) == 0) + || startswith (own_buf, "qAttached:")) { struct process_info *process; @@ -1984,7 +2510,7 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) return; } - if (strncmp ("qCRC:", own_buf, 5) == 0) + if (startswith (own_buf, "qCRC:")) { /* CRC check (compare-section). */ char *comma; @@ -2025,37 +2551,48 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) static void gdb_wants_all_threads_stopped (void); static void resume (struct thread_resume *actions, size_t n); +/* The callback that is passed to visit_actioned_threads. */ +typedef int (visit_actioned_threads_callback_ftype) + (const struct thread_resume *, struct thread_info *); + +/* Struct to pass data to visit_actioned_threads. */ + +struct visit_actioned_threads_data +{ + const struct thread_resume *actions; + size_t num_actions; + visit_actioned_threads_callback_ftype *callback; +}; + /* Call CALLBACK for any thread to which ACTIONS applies to. Returns true if CALLBACK returns true. Returns false if no matching thread - is found or CALLBACK results false. */ + is found or CALLBACK results false. + Note: This function is itself a callback for find_inferior. */ static int -visit_actioned_threads (const struct thread_resume *actions, - size_t num_actions, - int (*callback) (const struct thread_resume *, - struct thread_info *)) +visit_actioned_threads (struct inferior_list_entry *entry, void *datap) { - struct inferior_list_entry *entry; - - for (entry = all_threads.head; entry != NULL; entry = entry->next) + struct visit_actioned_threads_data *data + = (struct visit_actioned_threads_data *) datap; + const struct thread_resume *actions = data->actions; + size_t num_actions = data->num_actions; + visit_actioned_threads_callback_ftype *callback = data->callback; + size_t i; + + for (i = 0; i < num_actions; i++) { - size_t i; + const struct thread_resume *action = &actions[i]; - for (i = 0; i < num_actions; i++) + if (ptid_equal (action->thread, minus_one_ptid) + || ptid_equal (action->thread, entry->id) + || ((ptid_get_pid (action->thread) + == ptid_get_pid (entry->id)) + && ptid_get_lwp (action->thread) == -1)) { - const struct thread_resume *action = &actions[i]; - - if (ptid_equal (action->thread, minus_one_ptid) - || ptid_equal (action->thread, entry->id) - || ((ptid_get_pid (action->thread) - == ptid_get_pid (entry->id)) - && ptid_get_lwp (action->thread) == -1)) - { - struct thread_info *thread = (struct thread_info *) entry; + struct thread_info *thread = (struct thread_info *) entry; - if ((*callback) (action, thread)) - return 1; - } + if ((*callback) (action, thread)) + return 1; } } @@ -2082,7 +2619,7 @@ handle_pending_status (const struct thread_resume *resumption, } /* Parse vCont packets. */ -void +static void handle_v_cont (char *own_buf) { char *p, *q; @@ -2100,7 +2637,7 @@ handle_v_cont (char *own_buf) p = strchr (p, ';'); } - resume_info = malloc (n * sizeof (resume_info[0])); + resume_info = (struct thread_resume *) malloc (n * sizeof (resume_info[0])); if (resume_info == NULL) goto err; @@ -2130,9 +2667,9 @@ handle_v_cont (char *own_buf) 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') { @@ -2179,19 +2716,6 @@ handle_v_cont (char *own_buf) if (i < n) resume_info[i] = default_action; - /* `cont_thread' is still used in occasional places in the backend, - to implement single-thread scheduler-locking. Doesn't make sense - to set it if we see a stop request, or a wildcard action (one - with '-1' (all threads), or 'pPID.-1' (all threads of PID)). */ - if (n == 1 - && !(ptid_equal (resume_info[0].thread, minus_one_ptid) - || ptid_get_lwp (resume_info[0].thread) == -1) - && resume_info[0].kind != resume_stop) - cont_thread = resume_info[0].thread; - else - cont_thread = minus_one_ptid; - set_desired_inferior (0); - resume (resume_info, n); free (resume_info); return; @@ -2213,7 +2737,12 @@ resume (struct thread_resume *actions, size_t num_actions) one with a pending status to report. If so, skip actually resuming/stopping and report the pending event immediately. */ - if (visit_actioned_threads (actions, num_actions, handle_pending_status)) + struct visit_actioned_threads_data data; + + data.actions = actions; + data.num_actions = num_actions; + data.callback = handle_pending_status; + if (find_inferior (&all_threads, visit_actioned_threads, &data) != NULL) return; enable_async_io (); @@ -2227,9 +2756,20 @@ resume (struct thread_resume *actions, size_t num_actions) { last_ptid = mywait (minus_one_ptid, &last_status, 0, 1); + if (last_status.kind == TARGET_WAITKIND_NO_RESUMED + && !report_no_resumed) + { + /* 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; + } + if (last_status.kind != TARGET_WAITKIND_EXITED - && last_status.kind != TARGET_WAITKIND_SIGNALLED) - current_inferior->last_status = last_status; + && last_status.kind != TARGET_WAITKIND_SIGNALLED + && last_status.kind != TARGET_WAITKIND_NO_RESUMED) + current_thread->last_status = last_status; /* From the client's perspective, all-stop mode always stops all threads implicitly (and the target backend has already done @@ -2246,7 +2786,7 @@ resume (struct thread_resume *actions, size_t num_actions) } /* Attach to a new program. Return 1 if successful, 0 if failure. */ -int +static int handle_v_attach (char *own_buf) { int pid; @@ -2293,7 +2833,7 @@ handle_v_run (char *own_buf) new_argc++; } - new_argv = calloc (new_argc + 2, sizeof (char *)); + new_argv = (char **) calloc (new_argc + 2, sizeof (char *)); if (new_argv == NULL) { write_enn (own_buf); @@ -2312,8 +2852,8 @@ handle_v_run (char *own_buf) else { /* FIXME: Fail request if out of memory instead of dying. */ - new_argv[i] = xmalloc (1 + (next_p - p) / 2); - unhexify (new_argv[i], p, (next_p - p) / 2); + new_argv[i] = (char *) xmalloc (1 + (next_p - p) / 2); + hex2bin (p, (gdb_byte *) new_argv[i], (next_p - p) / 2); new_argv[i][(next_p - p) / 2] = '\0'; } @@ -2369,7 +2909,7 @@ handle_v_run (char *own_buf) } /* Kill process. Return 1 if successful, 0 if failure. */ -int +static int handle_v_kill (char *own_buf) { int pid; @@ -2383,7 +2923,7 @@ handle_v_kill (char *own_buf) last_status.kind = TARGET_WAITKIND_SIGNALLED; last_status.value.sig = GDB_SIGNAL_KILL; last_ptid = pid_to_ptid (pid); - discard_queued_stop_replies (pid); + discard_queued_stop_replies (last_ptid); write_ok (own_buf); return 1; } @@ -2400,16 +2940,34 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len) { if (!disable_packet_vCont) { - if (strncmp (own_buf, "vCont;", 6) == 0) + if (strcmp (own_buf, "vCtrlC") == 0) + { + (*the_target->request_interrupt) (); + write_ok (own_buf); + return; + } + + if (startswith (own_buf, "vCont;")) { require_running (own_buf); handle_v_cont (own_buf); return; } - if (strncmp (own_buf, "vCont?", 6) == 0) + if (startswith (own_buf, "vCont?")) { - strcpy (own_buf, "vCont;c;C;s;S;t"); + strcpy (own_buf, "vCont;c;C;t"); + + if (target_supports_hardware_single_step () || !vCont_supported) + { + /* If target supports hardware single step, add actions s + and S to the list of supported actions. On the other + hand, if GDB doesn't request the supported vCont actions + in qSupported packet, add s and S to the list too. */ + own_buf = own_buf + strlen (own_buf); + strcpy (own_buf, ";s;S"); + } + if (target_supports_range_stepping ()) { own_buf = own_buf + strlen (own_buf); @@ -2419,11 +2977,11 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len) } } - if (strncmp (own_buf, "vFile:", 6) == 0 + if (startswith (own_buf, "vFile:") && handle_vFile (own_buf, packet_len, new_packet_len)) return; - if (strncmp (own_buf, "vAttach;", 8) == 0) + if (startswith (own_buf, "vAttach;")) { if ((!extended_protocol || !multi_process) && target_running ()) { @@ -2435,7 +2993,7 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len) return; } - if (strncmp (own_buf, "vRun;", 5) == 0) + if (startswith (own_buf, "vRun;")) { if ((!extended_protocol || !multi_process) && target_running ()) { @@ -2447,7 +3005,7 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len) return; } - if (strncmp (own_buf, "vKill;", 6) == 0) + if (startswith (own_buf, "vKill;")) { if (!target_running ()) { @@ -2468,7 +3026,7 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len) return; } -/* Resume inferior and wait for another event. In non-stop mode, +/* Resume thread and wait for another event. In non-stop mode, don't really wait here, but return immediatelly to the event loop. */ static void @@ -2478,8 +3036,6 @@ myresume (char *own_buf, int step, int sig) int n = 0; int valid_cont_thread; - set_desired_inferior (0); - valid_cont_thread = (!ptid_equal (cont_thread, null_ptid) && !ptid_equal (cont_thread, minus_one_ptid)); @@ -2517,7 +3073,7 @@ queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg) manage the thread's last_status field. */ if (the_target->thread_stopped == NULL) { - struct vstop_notif *new_notif = xmalloc (sizeof (*new_notif)); + struct vstop_notif *new_notif = XNEW (struct vstop_notif); new_notif->ptid = entry->id; new_notif->status = thread->last_status; @@ -2535,10 +3091,9 @@ queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg) char *status_string = target_waitstatus_to_string (&thread->last_status); - fprintf (stderr, - "Reporting thread %s as already stopped with %s\n", - target_pid_to_str (entry->id), - status_string); + debug_printf ("Reporting thread %s as already stopped with %s\n", + target_pid_to_str (entry->id), + status_string); xfree (status_string); } @@ -2687,7 +3242,7 @@ handle_status (char *own_buf) /* If we're still out of luck, simply pick the first thread in the thread list. */ if (thread == NULL) - thread = all_threads.head; + thread = get_first_inferior (&all_threads); if (thread != NULL) { @@ -2700,7 +3255,7 @@ handle_status (char *own_buf) /* GDB assumes the current thread is the thread we're reporting the status for. */ general_thread = thread->id; - set_desired_inferior (1); + set_desired_thread (1); gdb_assert (tp->last_status.kind != TARGET_WAITKIND_IGNORE); prepare_resume_reply (own_buf, tp->entry.id, &tp->last_status); @@ -2714,7 +3269,7 @@ static void gdbserver_version (void) { printf ("GNU gdbserver %s%s\n" - "Copyright (C) 2014 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", @@ -2728,16 +3283,48 @@ gdbserver_usage (FILE *stream) "\tgdbserver [OPTIONS] --attach COMM PID\n" "\tgdbserver [OPTIONS] --multi COMM\n" "\n" - "COMM may either be a tty device (for serial debugging), or \n" - "HOST:PORT to listen for a TCP connection.\n" + "COMM may either be a tty device (for serial debugging),\n" + "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n" + "stdin/stdout of gdbserver.\n" + "PROG is the executable program. ARGS are arguments passed to inferior.\n" + "PID is the process ID to attach to, when --attach is specified.\n" "\n" - "Options:\n" - " --debug Enable general debugging output.\n" - " --remote-debug Enable remote protocol debugging output.\n" + "Operating modes:\n" + "\n" + " --attach Attach to running process PID.\n" + " --multi Start server without a specific program, and\n" + " only quit when explicitly commanded.\n" + " --once Exit after the first connection has closed.\n" + " --help Print this message and then exit.\n" " --version Display version information and exit.\n" + "\n" + "Other options:\n" + "\n" " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n" - " --once Exit after the first connection has " - "closed.\n"); + " --disable-randomization\n" + " Run PROG with address space randomization disabled.\n" + " --no-disable-randomization\n" + " Don't disable address space randomization when\n" + " starting PROG.\n" + "\n" + "Debug options:\n" + "\n" + " --debug Enable general debugging output.\n" + " --debug-format=opt1[,opt2,...]\n" + " Specify extra content in debugging output.\n" + " Options:\n" + " all\n" + " none\n" + " timestamp\n" + " --remote-debug Enable remote protocol debugging output.\n" + " --disable-packet=opt1[,opt2,...]\n" + " Disable support for RSP packets or features.\n" + " Options:\n" + " vCont, Tthread, qC, qfThreadInfo and \n" + " threads (disable all threading packets).\n" + "\n" + "For more information, consult the GDB manual (available as on-line \n" + "info or a printed manual).\n"); if (REPORT_BUGS_TO[0] && stream == stdout) fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO); } @@ -2778,10 +3365,10 @@ static void kill_inferior_callback (struct inferior_list_entry *entry) { struct process_info *process = (struct process_info *) entry; - int pid = ptid_get_pid (process->head.id); + int pid = ptid_get_pid (process->entry.id); kill_inferior (pid); - discard_queued_stop_replies (pid); + discard_queued_stop_replies (pid_to_ptid (pid)); } /* Callback for for_each_inferior to detach or kill the inferior, @@ -2793,14 +3380,14 @@ static void detach_or_kill_inferior_callback (struct inferior_list_entry *entry) { struct process_info *process = (struct process_info *) entry; - int pid = ptid_get_pid (process->head.id); + int pid = ptid_get_pid (process->entry.id); if (process->attached) detach_inferior (pid); else kill_inferior (pid); - discard_queued_stop_replies (pid); + discard_queued_stop_replies (pid_to_ptid (pid)); } /* for_each_inferior callback for detach_or_kill_for_exit to print @@ -2813,7 +3400,7 @@ print_started_pid (struct inferior_list_entry *entry) if (! process->attached) { - int pid = ptid_get_pid (process->head.id); + int pid = ptid_get_pid (process->entry.id); fprintf (stderr, " %d", pid); } } @@ -2828,7 +3415,7 @@ print_attached_pid (struct inferior_list_entry *entry) if (process->attached) { - int pid = ptid_get_pid (process->head.id); + int pid = ptid_get_pid (process->entry.id); fprintf (stderr, " %d", pid); } } @@ -2862,8 +3449,34 @@ detach_or_kill_for_exit (void) for_each_inferior (&all_processes, detach_or_kill_inferior_callback); } -int -main (int argc, char *argv[]) +/* Value that will be passed to exit(3) when gdbserver exits. */ +static int exit_code; + +/* Cleanup version of detach_or_kill_for_exit. */ + +static void +detach_or_kill_for_exit_cleanup (void *ignore) +{ + + TRY + { + detach_or_kill_for_exit (); + } + + CATCH (exception, RETURN_MASK_ALL) + { + fflush (stdout); + fprintf (stderr, "Detach or kill failed: %s\n", exception.message); + exit_code = 1; + } + END_CATCH +} + +/* Main function. This is called by the real "main" function, + wrapped in a TRY_CATCH that handles any uncaught exceptions. */ + +static void ATTRIBUTE_NORETURN +captured_main (int argc, char *argv[]) { int bad_attach; int pid; @@ -2908,6 +3521,18 @@ main (int argc, char *argv[]) } else if (strcmp (*next_arg, "--debug") == 0) debug_threads = 1; + else if (startswith (*next_arg, "--debug-format=")) + { + char *error_msg + = parse_debug_format_options ((*next_arg) + + sizeof ("--debug-format=") - 1, 0); + + if (error_msg != NULL) + { + fprintf (stderr, "%s", error_msg); + exit (1); + } + } else if (strcmp (*next_arg, "--remote-debug") == 0) remote_debug = 1; else if (strcmp (*next_arg, "--disable-packet") == 0) @@ -2915,9 +3540,7 @@ main (int argc, char *argv[]) gdbserver_show_disableable (stdout); exit (0); } - else if (strncmp (*next_arg, - "--disable-packet=", - sizeof ("--disable-packet=") - 1) == 0) + else if (startswith (*next_arg, "--disable-packet=")) { char *packets, *tok; @@ -2973,12 +3596,6 @@ main (int argc, char *argv[]) continue; } - if (setjmp (toplevel)) - { - fprintf (stderr, "Exiting\n"); - exit (1); - } - port = *next_arg; next_arg++; if (port == NULL || (!attach && !multi_mode && *next_arg == NULL)) @@ -3027,16 +3644,17 @@ main (int argc, char *argv[]) initialize_event_loop (); if (target_supports_tracepoints ()) initialize_tracepoint (); + initialize_notif (); - own_buf = xmalloc (PBUFSIZ + 1); - mem_buf = xmalloc (PBUFSIZ); + own_buf = (char *) xmalloc (PBUFSIZ + 1); + mem_buf = (unsigned char *) xmalloc (PBUFSIZ); if (pid == 0 && *next_arg != NULL) { int i, n; n = argc - (next_arg - argv); - program_argv = xmalloc (sizeof (char *) * (n + 1)); + program_argv = XNEWVEC (char *, n + 1); for (i = 0; i < n; i++) program_argv[i] = xstrdup (next_arg[i]); program_argv[i] = NULL; @@ -3061,27 +3679,13 @@ main (int argc, char *argv[]) last_status.value.integer = 0; last_ptid = minus_one_ptid; } - - initialize_notif (); + make_cleanup (detach_or_kill_for_exit_cleanup, NULL); /* Don't report shared library events on the initial connection, even if some libraries are preloaded. Avoids the "stopped by shared library event" notice on gdb side. */ dlls_changed = 0; - if (setjmp (toplevel)) - { - /* If something fails and longjmps while detaching or killing - inferiors, we'd end up here again, stuck in an infinite loop - trap. Be sure that if that happens, we exit immediately - instead. */ - if (setjmp (toplevel) == 0) - detach_or_kill_for_exit (); - else - fprintf (stderr, "Detach or kill failed. Exiting\n"); - exit (1); - } - if (last_status.kind == TARGET_WAITKIND_EXITED || last_status.kind == TARGET_WAITKIND_SIGNALLED) was_running = 0; @@ -3089,102 +3693,139 @@ main (int argc, char *argv[]) was_running = 1; if (!was_running && !multi_mode) - { - fprintf (stderr, "No program to debug. GDBserver exiting.\n"); - exit (1); - } + error ("No program to debug"); while (1) { + noack_mode = 0; multi_process = 0; + report_fork_events = 0; + report_vfork_events = 0; + report_exec_events = 0; /* Be sure we're out of tfind mode. */ current_traceframe = -1; + cont_thread = null_ptid; + swbreak_feature = 0; + hwbreak_feature = 0; + vCont_supported = 0; remote_open (port); - if (setjmp (toplevel) != 0) + TRY { - /* An error occurred. */ - if (response_needed) - { - write_enn (own_buf); - putpkt (own_buf); - } - } + /* Wait for events. This will return when all event sources + are removed from the event loop. */ + start_event_loop (); - /* Wait for events. This will return when all event sources are - removed from the event loop. */ - start_event_loop (); + /* If an exit was requested (using the "monitor exit" + command), terminate now. */ + if (exit_requested) + throw_quit ("Quit"); - /* 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. */ + /* The only other way to get here is for getpkt to fail: - if (exit_requested || run_once) - { - /* If something fails and longjmps while detaching or - killing inferiors, we'd end up here again, stuck in an - infinite loop trap. Be sure that if that happens, we - exit immediately instead. */ - if (setjmp (toplevel) == 0) - { - detach_or_kill_for_exit (); - exit (0); - } - else - { - fprintf (stderr, "Detach or kill failed. Exiting\n"); - exit (1); - } - } + - If --once was specified, we're done. - fprintf (stderr, - "Remote side has terminated connection. " - "GDBserver will reopen the connection.\n"); + - If not in extended-remote mode, and we're no longer + debugging anything, simply exit: GDB has disconnected + after processing the last process exit. - /* Get rid of any pending statuses. An eventual reconnection - (by the same GDB instance or another) will refresh all its - state from scratch. */ - discard_queued_stop_replies (-1); - for_each_inferior (&all_threads, clear_pending_status_callback); + - Otherwise, close the connection and reopen it at the + top of the loop. */ + if (run_once || (!extended_protocol && !target_running ())) + throw_quit ("Quit"); - if (tracing) - { - if (disconnected_tracing) + fprintf (stderr, + "Remote side has terminated connection. " + "GDBserver will reopen the connection.\n"); + + /* Get rid of any pending statuses. An eventual reconnection + (by the same GDB instance or another) will refresh all its + state from scratch. */ + discard_queued_stop_replies (minus_one_ptid); + for_each_inferior (&all_threads, + clear_pending_status_callback); + + if (tracing) { - /* Try to enable non-stop/async mode, so we we can both - wait for an async socket accept, and handle async - target events simultaneously. There's also no point - either in having the target always stop all threads, - when we're going to pass signals down without - informing GDB. */ - if (!non_stop) + if (disconnected_tracing) { - if (start_non_stop (1)) - non_stop = 1; - - /* Detaching implicitly resumes all threads; simply - disconnecting does not. */ + /* Try to enable non-stop/async mode, so we we can + both wait for an async socket accept, and handle + async target events simultaneously. There's also + no point either in having the target always stop + all threads, when we're going to pass signals + down without informing GDB. */ + if (!non_stop) + { + if (start_non_stop (1)) + non_stop = 1; + + /* Detaching implicitly resumes all threads; + simply disconnecting does not. */ + } + } + else + { + fprintf (stderr, + "Disconnected tracing disabled; " + "stopping trace run.\n"); + stop_tracing (); } } - else + } + CATCH (exception, RETURN_MASK_ERROR) + { + fflush (stdout); + fprintf (stderr, "gdbserver: %s\n", exception.message); + + if (response_needed) { - fprintf (stderr, - "Disconnected tracing disabled; stopping trace run.\n"); - stop_tracing (); + write_enn (own_buf); + putpkt (own_buf); } + + if (run_once) + throw_quit ("Quit"); + } + END_CATCH + } +} + +/* Main function. */ + +int +main (int argc, char *argv[]) +{ + + TRY + { + captured_main (argc, argv); + } + CATCH (exception, RETURN_MASK_ALL) + { + if (exception.reason == RETURN_ERROR) + { + fflush (stdout); + fprintf (stderr, "%s\n", exception.message); + fprintf (stderr, "Exiting\n"); + exit_code = 1; } + + exit (exit_code); } + END_CATCH + + gdb_assert_not_reached ("captured_main should never return"); } -/* Process options coming from Z packets for *point at address - POINT_ADDR. PACKET is the packet buffer. *PACKET is updated - to point to the first char after the last processed option. */ +/* Process options coming from Z packets for a breakpoint. PACKET is + the packet buffer. *PACKET is updated to point to the first char + after the last processed option. */ static void -process_point_options (CORE_ADDR point_addr, char **packet) +process_point_options (struct breakpoint *bp, char **packet) { char *dataptr = *packet; int persist; @@ -3204,25 +3845,26 @@ process_point_options (CORE_ADDR point_addr, char **packet) { /* Conditional expression. */ if (debug_threads) - fprintf (stderr, "Found breakpoint condition.\n"); - add_breakpoint_condition (point_addr, &dataptr); + debug_printf ("Found breakpoint condition.\n"); + if (!add_breakpoint_condition (bp, &dataptr)) + dataptr = strchrnul (dataptr, ';'); } - else if (strncmp (dataptr, "cmds:", strlen ("cmds:")) == 0) + else if (startswith (dataptr, "cmds:")) { dataptr += strlen ("cmds:"); if (debug_threads) - fprintf (stderr, "Found breakpoint commands %s.\n", dataptr); + debug_printf ("Found breakpoint commands %s.\n", dataptr); persist = (*dataptr == '1'); dataptr += 2; - add_breakpoint_commands (point_addr, &dataptr, persist); + if (add_breakpoint_commands (bp, &dataptr, persist)) + dataptr = strchrnul (dataptr, ';'); } else { fprintf (stderr, "Unknown token %c, ignoring.\n", *dataptr); /* Skip tokens until we find one that we recognize. */ - while (*dataptr && *dataptr != ';') - dataptr++; + dataptr = strchrnul (dataptr, ';'); } } *packet = dataptr; @@ -3247,13 +3889,6 @@ process_serial_event (void) 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; @@ -3316,7 +3951,7 @@ process_serial_event (void) if (!non_stop) { if (debug_threads) - fprintf (stderr, "Forcing non-stop mode\n"); + debug_printf ("Forcing non-stop mode\n"); non_stop = 1; start_non_stop (1); @@ -3340,17 +3975,19 @@ process_serial_event (void) write_enn (own_buf); else { - discard_queued_stop_replies (pid); + 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); - current_inferior = NULL; + current_thread = NULL; } else { @@ -3401,7 +4038,7 @@ process_serial_event (void) break; } - thread_id = ((struct inferior_list_entry *)thread)->id; + thread_id = thread->entry.id; } else { @@ -3424,11 +4061,13 @@ process_serial_event (void) (struct thread_info *) find_inferior_id (&all_threads, general_thread); if (thread == NULL) - thread_id = all_threads.head->id; + thread = get_first_thread (); + thread_id = thread->entry.id; } general_thread = thread_id; - set_desired_inferior (1); + set_desired_thread (1); + gdb_assert (current_thread != NULL); } else if (own_buf[1] == 'c') cont_thread = thread_id; @@ -3460,9 +4099,13 @@ process_serial_event (void) { struct regcache *regcache; - set_desired_inferior (1); - regcache = get_thread_regcache (current_inferior, 1); - registers_to_string (regcache, own_buf); + if (!set_desired_thread (1)) + write_enn (own_buf); + else + { + regcache = get_thread_regcache (current_thread, 1); + registers_to_string (regcache, own_buf); + } } break; case 'G': @@ -3473,10 +4116,14 @@ process_serial_event (void) { struct regcache *regcache; - set_desired_inferior (1); - regcache = get_thread_regcache (current_inferior, 1); - registers_from_string (regcache, &own_buf[1]); - write_ok (own_buf); + if (!set_desired_thread (1)) + write_enn (own_buf); + else + { + regcache = get_thread_regcache (current_thread, 1); + registers_from_string (regcache, &own_buf[1]); + write_ok (own_buf); + } } break; case 'm': @@ -3486,7 +4133,7 @@ process_serial_event (void) if (res < 0) write_enn (own_buf); else - convert_int_to_ascii (mem_buf, own_buf, res); + bin2hex (mem_buf, own_buf, res); break; case 'M': require_running (own_buf); @@ -3507,18 +4154,18 @@ process_serial_event (void) break; case 'C': require_running (own_buf); - convert_ascii_to_int (own_buf + 1, &sig, 1); - if (gdb_signal_to_host_p (sig)) - signal = gdb_signal_to_host (sig); + hex2bin (own_buf + 1, &sig, 1); + 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); break; case 'S': require_running (own_buf); - convert_ascii_to_int (own_buf + 1, &sig, 1); - if (gdb_signal_to_host_p (sig)) - signal = gdb_signal_to_host (sig); + hex2bin (own_buf + 1, &sig, 1); + 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); @@ -3539,48 +4186,35 @@ process_serial_event (void) { 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); - /* Default to unrecognized/unsupported. */ - res = 1; - switch (type) + if (insert) { - case '0': /* software-breakpoint */ - case '1': /* hardware-breakpoint */ - case '2': /* write watchpoint */ - case '3': /* read watchpoint */ - case '4': /* access watchpoint */ - require_running (own_buf); - if (insert && the_target->insert_point != NULL) + struct breakpoint *bp; + + bp = set_gdb_breakpoint (type, addr, kind, &res); + if (bp != NULL) { - /* Insert the breakpoint. If it is already inserted, nothing - will take place. */ - res = (*the_target->insert_point) (type, addr, len); - - /* GDB may have sent us a list of *point parameters to be - evaluated on the target's side. Read such list here. If we - already have a list of parameters, GDB is telling us to drop - that list and use this one instead. */ - if (!res && (type == '0' || type == '1')) - { - /* Remove previous conditions. */ - clear_gdb_breakpoint_conditions (addr); - process_point_options (addr, &dataptr); - } + res = 0; + + /* GDB may have sent us a list of *point parameters to + be evaluated on the target's side. Read such list + here. If we already have a list of parameters, GDB + is telling us to drop that list and use this one + instead. */ + clear_breakpoint_conditions_and_commands (bp); + process_point_options (bp, &dataptr); } - else if (!insert && the_target->remove_point != NULL) - res = (*the_target->remove_point) (type, addr, len); - break; - default: - break; } + else + res = delete_gdb_breakpoint (type, addr, kind); if (res == 0) write_ok (own_buf); @@ -3646,7 +4280,20 @@ process_serial_event (void) /* Wait till we are at 1st instruction in prog. */ if (program_argv != NULL) - start_inferior (program_argv); + { + start_inferior (program_argv); + if (last_status.kind == TARGET_WAITKIND_STOPPED) + { + /* Stopped at the first instruction of the target + process. */ + general_thread = last_ptid; + } + else + { + /* Something went wrong. */ + general_thread = null_ptid; + } + } else { last_status.kind = TARGET_WAITKIND_EXITED; @@ -3682,21 +4329,6 @@ process_serial_event (void) 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; @@ -3709,31 +4341,49 @@ int handle_serial_event (int err, gdb_client_data client_data) { if (debug_threads) - fprintf (stderr, "handling possible serial event\n"); + debug_printf ("handling possible serial event\n"); /* Really handle it. */ if (process_serial_event () < 0) return -1; - /* Be sure to not change the selected inferior behind GDB's back. + /* Be sure to not change the selected thread behind GDB's back. Important in the non-stop mode asynchronous protocol. */ - set_desired_inferior (1); + set_desired_thread (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 handle_target_event (int err, gdb_client_data client_data) { if (debug_threads) - fprintf (stderr, "handling possible target event\n"); + debug_printf ("handling possible target event\n"); last_ptid = mywait (minus_one_ptid, &last_status, TARGET_WNOHANG, 1); - if (last_status.kind != TARGET_WAITKIND_IGNORE) + if (last_status.kind == TARGET_WAITKIND_NO_RESUMED) + { + if (gdb_connected () && report_no_resumed) + push_stop_notification (null_ptid, &last_status); + } + else if (last_status.kind != TARGET_WAITKIND_IGNORE) { int pid = ptid_get_pid (last_ptid); struct process_info *process = find_process_pid (pid); @@ -3745,13 +4395,15 @@ handle_target_event (int err, gdb_client_data client_data) 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 "want-stopped" state to what the client wants, until it gets a new resume action. */ - current_inferior->last_resume_kind = resume_stop; - current_inferior->last_status = last_status; + current_thread->last_resume_kind = resume_stop; + current_thread->last_status = last_status; } if (forward_event) @@ -3762,7 +4414,11 @@ handle_target_event (int err, gdb_client_data client_data) 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 @@ -3770,37 +4426,27 @@ handle_target_event (int err, gdb_client_data client_data) struct thread_resume resume_info; if (debug_threads) - fprintf (stderr, - "GDB not connected; forwarding event %d for [%s]\n", - (int) last_status.kind, - target_pid_to_str (last_ptid)); + debug_printf ("GDB not connected; forwarding event %d for" + " [%s]\n", + (int) last_status.kind, + target_pid_to_str (last_ptid)); 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) - fprintf (stderr, "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 - = xmalloc (sizeof (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 inferior behind GDB's back. + /* Be sure to not change the selected thread behind GDB's back. Important in the non-stop mode asynchronous protocol. */ - set_desired_inferior (1); + set_desired_thread (1); return 0; }