From patchwork Thu Dec 17 21:05:58 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stan Cox X-Patchwork-Id: 10057 Received: (qmail 29972 invoked by alias); 17 Dec 2015 21:06:27 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 29835 invoked by uid 89); 17 Dec 2015 21:06:24 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.3 required=5.0 tests=AWL, BAYES_40, RCVD_IN_DNSWL_LOW, SPF_HELO_PASS, SPF_PASS, T_RP_MATCHES_RCVD autolearn=ham version=3.3.2 spammy=peek, reenable, UD:No, *except X-HELO: plane.gmane.org Received: from plane.gmane.org (HELO plane.gmane.org) (80.91.229.3) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-SHA encrypted) ESMTPS; Thu, 17 Dec 2015 21:06:19 +0000 Received: from list by plane.gmane.org with local (Exim 4.69) (envelope-from ) id 1a9fkd-0007zD-FA for gdb-patches@sourceware.org; Thu, 17 Dec 2015 22:06:15 +0100 Received: from nat-pool-rdu-t.redhat.com ([66.187.233.202]) by main.gmane.org with esmtp (Gmexim 0.1 (Debian)) id 1AlnuQ-0007hv-00 for ; Thu, 17 Dec 2015 22:06:15 +0100 Received: from scox by nat-pool-rdu-t.redhat.com with local (Gmexim 0.1 (Debian)) id 1AlnuQ-0007hv-00 for ; Thu, 17 Dec 2015 22:06:15 +0100 To: gdb-patches@sourceware.org From: Stan Cox Subject: Re: [PATCH v2 1/2] consolidate gdbserver global data Date: Thu, 17 Dec 2015 16:05:58 -0500 Lines: 965 Message-ID: References: <5648B89D.3050305@redhat.com> Mime-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:38.0) Gecko/20100101 Thunderbird/38.3.0 In-Reply-To: X-IsSubscribed: yes The previous patch was split into two parts to hopefully make it a bit easier to digest. This first patch simply changes a few variable names that conflict with the names of gdbserver external data variables. Those conflicts are: - struct thread_info member last_status renamed to last_waitstatus - various local variables mem_buf renamed to mem_buffer - a parameter in nat/linux-personality.h disable_randomization renamed to disable_randomization - the external data variable own_buf renamed to own_buffer to avoid conflicts with a frequently used local variable own_buf The next patch consolidates global data into structures. To maintain source compatibility, macros are defined such that, e.g. out_buf will logically expand to client_state->out_buf. The above name changes will avoid name conflicts. gdb/gdbserver/Changelog * server.c (handle_qxfer_btrace, resume): Global own_buf now own_buffer thread_info last_status now last_waitstatus. (Change all references) * remote-utils.c Local mem_buf name mem_buffer. (Change all) * linux-low.c: Global last_status now last_waitstatus. (Change all) * gdbthread.h (last_status): Now known as last_waitstatus. diff --git a/gdb/gdbserver/gdbthread.h b/gdb/gdbserver/gdbthread.h index 0510419..7bada2f 100644 --- a/gdb/gdbserver/gdbthread.h +++ b/gdb/gdbserver/gdbthread.h @@ -37,7 +37,7 @@ struct thread_info enum resume_kind last_resume_kind; /* The last wait status reported for this thread. */ - struct target_waitstatus last_status; + struct target_waitstatus last_waitstatus; /* True if LAST_STATUS hasn't been reported to GDB yet. */ int status_pending_p; diff --git a/gdb/gdbserver/inferiors.c b/gdb/gdbserver/inferiors.c index 95f3ad0..4d64250 100644 --- a/gdb/gdbserver/inferiors.c +++ b/gdb/gdbserver/inferiors.c @@ -109,7 +109,7 @@ add_thread (ptid_t thread_id, void *target_data) new_thread->entry.id = thread_id; new_thread->last_resume_kind = resume_continue; - new_thread->last_status.kind = TARGET_WAITKIND_IGNORE; + new_thread->last_waitstatus.kind = TARGET_WAITKIND_IGNORE; add_inferior_to_list (&all_threads, &new_thread->entry); diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c index 5e2dc58..1f0a977 100644 --- a/gdb/gdbserver/linux-low.c +++ b/gdb/gdbserver/linux-low.c @@ -520,7 +520,7 @@ handle_extended_wait (struct lwp_info **orig_event_lwp, int wstat) child_lwp->status_pending_p = 0; child_thr = get_lwp_thread (child_lwp); child_thr->last_resume_kind = resume_stop; - child_thr->last_status.kind = TARGET_WAITKIND_STOPPED; + child_thr->last_waitstatus.kind = TARGET_WAITKIND_STOPPED; /* If we're suspending all threads, leave this one suspended too. */ @@ -646,7 +646,7 @@ handle_extended_wait (struct lwp_info **orig_event_lwp, int wstat) event_lwp->status_pending_p = 1; event_lwp->status_pending = wstat; event_thr->last_resume_kind = resume_continue; - event_thr->last_status.kind = TARGET_WAITKIND_IGNORE; + event_thr->last_waitstatus.kind = TARGET_WAITKIND_IGNORE; /* Report the event. */ *orig_event_lwp = event_lwp; @@ -1342,13 +1342,13 @@ get_detach_signal (struct thread_info *thread) /* If the thread had been suspended by gdbserver, and it stopped cleanly, then it'll have stopped with SIGSTOP. But we don't want to deliver that SIGSTOP. */ - if (thread->last_status.kind != TARGET_WAITKIND_STOPPED - || thread->last_status.value.sig == GDB_SIGNAL_0) + if (thread->last_waitstatus.kind != TARGET_WAITKIND_STOPPED + || thread->last_waitstatus.value.sig == GDB_SIGNAL_0) return 0; /* Otherwise, we may need to deliver the signal we intercepted. */ - status = lp->last_status; + status = lp->last_waitstatus; } if (!WIFSTOPPED (status)) @@ -1564,7 +1564,7 @@ thread_still_has_status_pending_p (struct thread_info *thread) CORE_ADDR pc; int discard = 0; - gdb_assert (lp->last_status != 0); + gdb_assert (lp->last_waitstatus != 0); pc = get_pc (lp); @@ -1626,7 +1626,7 @@ lwp_resumed (struct lwp_info *lwp) corresponding stop to gdb yet? If so, the thread is still resumed/running from gdb's perspective. */ if (thread->last_resume_kind == resume_stop - && thread->last_status.kind == TARGET_WAITKIND_IGNORE) + && thread->last_waitstatus.kind == TARGET_WAITKIND_IGNORE) return 1; return 0; @@ -2305,7 +2305,7 @@ linux_low_filter_event (int lwpid, int wstat) child->stopped = 1; - child->last_status = wstat; + child->last_waitstatus = wstat; /* Check if the thread has exited. */ if ((WIFEXITED (wstat) || WIFSIGNALED (wstat))) @@ -2462,7 +2462,7 @@ resume_stopped_resumed_lwps (struct inferior_list_entry *entry) if (lp->stopped && !lp->suspended && !lp->status_pending_p - && thread->last_status.kind == TARGET_WAITKIND_IGNORE) + && thread->last_waitstatus.kind == TARGET_WAITKIND_IGNORE) { int step = thread->last_resume_kind == resume_step; @@ -2699,7 +2699,7 @@ count_events_callback (struct inferior_list_entry *entry, void *data) gdb_assert (count != NULL); /* Count only resumed LWPs that have an event pending. */ - if (thread->last_status.kind == TARGET_WAITKIND_IGNORE + if (thread->last_waitstatus.kind == TARGET_WAITKIND_IGNORE && lp->status_pending_p) (*count)++; @@ -2714,7 +2714,7 @@ select_singlestep_lwp_callback (struct inferior_list_entry *entry, void *data) struct thread_info *thread = (struct thread_info *) entry; struct lwp_info *lp = get_thread_lwp (thread); - if (thread->last_status.kind == TARGET_WAITKIND_IGNORE + if (thread->last_waitstatus.kind == TARGET_WAITKIND_IGNORE && thread->last_resume_kind == resume_step && lp->status_pending_p) return 1; @@ -2734,7 +2734,7 @@ select_event_lwp_callback (struct inferior_list_entry *entry, void *data) gdb_assert (selector != NULL); /* Select only resumed LWPs that have an event pending. */ - if (thread->last_status.kind == TARGET_WAITKIND_IGNORE + if (thread->last_waitstatus.kind == TARGET_WAITKIND_IGNORE && lp->status_pending_p) if ((*selector)-- == 0) return 1; @@ -4287,7 +4287,7 @@ linux_set_resume_request (struct inferior_list_entry *entry, void *arg) { if (debug_threads) debug_printf ("already %s LWP %ld at GDB's request\n", - (thread->last_status.kind + (thread->last_waitstatus.kind == TARGET_WAITKIND_STOPPED) ? "stopped" : "stopping", @@ -4697,7 +4697,7 @@ linux_resume_one_thread (struct inferior_list_entry *entry, void *arg) /* For stop requests, we're done. */ lwp->resume = NULL; - thread->last_status.kind = TARGET_WAITKIND_IGNORE; + thread->last_waitstatus.kind = TARGET_WAITKIND_IGNORE; return 0; } @@ -4738,8 +4738,8 @@ linux_resume_one_thread (struct inferior_list_entry *entry, void *arg) make sure to queue its siginfo. We can ignore the return value of ptrace; if it fails, we'll skip PTRACE_SETSIGINFO. */ - if (WIFSTOPPED (lwp->last_status) - && WSTOPSIG (lwp->last_status) == lwp->resume->sig) + if (WIFSTOPPED (lwp->last_waitstatus) + && WSTOPSIG (lwp->last_waitstatus) == lwp->resume->sig) ptrace (PTRACE_GETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0, &p_sig->info); @@ -4747,7 +4747,7 @@ linux_resume_one_thread (struct inferior_list_entry *entry, void *arg) } } - thread->last_status.kind = TARGET_WAITKIND_IGNORE; + thread->last_waitstatus.kind = TARGET_WAITKIND_IGNORE; lwp->resume = NULL; return 0; } @@ -4851,7 +4851,7 @@ proceed_one_lwp (struct inferior_list_entry *entry, void *except) } if (thread->last_resume_kind == resume_stop - && thread->last_status.kind != TARGET_WAITKIND_IGNORE) + && thread->last_waitstatus.kind != TARGET_WAITKIND_IGNORE) { if (debug_threads) debug_printf (" client wants LWP to remain %ld stopped\n", diff --git a/gdb/gdbserver/linux-low.h b/gdb/gdbserver/linux-low.h index c211a37..dbfb7f2 100644 --- a/gdb/gdbserver/linux-low.h +++ b/gdb/gdbserver/linux-low.h @@ -278,7 +278,7 @@ struct lwp_info int stopped; /* When stopped is set, the last wait status recorded for this lwp. */ - int last_status; + int last_waitstatus; /* If WAITSTATUS->KIND != TARGET_WAITKIND_IGNORE, the waitstatus for this LWP's last event, to pass to GDB without any further diff --git a/gdb/gdbserver/remote-utils.c b/gdb/gdbserver/remote-utils.c index 05e3d63..a00a9f5 100644 --- a/gdb/gdbserver/remote-utils.c +++ b/gdb/gdbserver/remote-utils.c @@ -1493,16 +1493,16 @@ look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb) while (own_buf[0] == 'm') { CORE_ADDR mem_addr; - unsigned char *mem_buf; + unsigned char *mem_buffer; unsigned int mem_len; decode_m_packet (&own_buf[1], &mem_addr, &mem_len); - mem_buf = (unsigned char *) xmalloc (mem_len); - if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0) - bin2hex (mem_buf, own_buf, mem_len); + mem_buffer = (unsigned char *) xmalloc (mem_len); + if (read_inferior_memory (mem_addr, mem_buffer, mem_len) == 0) + bin2hex (mem_buffer, own_buf, mem_len); else write_enn (own_buf); - free (mem_buf); + free (mem_buffer); if (putpkt (own_buf) < 0) return -1; len = getpkt (own_buf); @@ -1575,36 +1575,36 @@ relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc) while (own_buf[0] == 'm' || own_buf[0] == 'M' || own_buf[0] == 'X') { CORE_ADDR mem_addr; - unsigned char *mem_buf = NULL; + unsigned char *mem_buffer = NULL; unsigned int mem_len; if (own_buf[0] == 'm') { decode_m_packet (&own_buf[1], &mem_addr, &mem_len); - mem_buf = (unsigned char *) xmalloc (mem_len); - if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0) - bin2hex (mem_buf, own_buf, mem_len); + mem_buffer = (unsigned char *) xmalloc (mem_len); + if (read_inferior_memory (mem_addr, mem_buffer, mem_len) == 0) + bin2hex (mem_buffer, own_buf, mem_len); else write_enn (own_buf); } else if (own_buf[0] == 'X') { if (decode_X_packet (&own_buf[1], len - 1, &mem_addr, - &mem_len, &mem_buf) < 0 - || write_inferior_memory (mem_addr, mem_buf, mem_len) != 0) + &mem_len, &mem_buffer) < 0 + || write_inferior_memory (mem_addr, mem_buffer, mem_len) != 0) write_enn (own_buf); else write_ok (own_buf); } else { - decode_M_packet (&own_buf[1], &mem_addr, &mem_len, &mem_buf); - if (write_inferior_memory (mem_addr, mem_buf, mem_len) == 0) + decode_M_packet (&own_buf[1], &mem_addr, &mem_len, &mem_buffer); + if (write_inferior_memory (mem_addr, mem_buffer, mem_len) == 0) write_ok (own_buf); else write_enn (own_buf); } - free (mem_buf); + free (mem_buffer); if (putpkt (own_buf) < 0) return -1; len = getpkt (own_buf); diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c index 8f097e5..ec408d3 100644 --- a/gdb/gdbserver/server.c +++ b/gdb/gdbserver/server.c @@ -119,7 +119,7 @@ int disable_packet_qfThreadInfo; static struct target_waitstatus last_status; static ptid_t last_ptid; -static char *own_buf; +static char *own_buffer; static unsigned char *mem_buf; /* A sub-class of 'struct notif_event' for stop, holding information @@ -278,7 +278,7 @@ start_inferior (char **argv) break; current_thread->last_resume_kind = resume_stop; - current_thread->last_status = last_status; + current_thread->last_waitstatus = last_status; } while (last_status.value.sig != GDB_SIGNAL_TRAP); } @@ -296,7 +296,7 @@ start_inferior (char **argv) && last_status.kind != TARGET_WAITKIND_SIGNALLED) { current_thread->last_resume_kind = resume_stop; - current_thread->last_status = last_status; + current_thread->last_waitstatus = last_status; } else mourn_inferior (find_process_pid (ptid_get_pid (last_ptid))); @@ -333,7 +333,7 @@ attach_inferior (int pid) last_status.value.sig = GDB_SIGNAL_TRAP; current_thread->last_resume_kind = resume_stop; - current_thread->last_status = last_status; + current_thread->last_waitstatus = last_status; } return 0; @@ -1658,20 +1658,20 @@ handle_qxfer_btrace (const char *annex, if (ptid_equal (general_thread, null_ptid) || ptid_equal (general_thread, minus_one_ptid)) { - strcpy (own_buf, "E.Must select a single thread."); + strcpy (own_buffer, "E.Must select a single thread."); return -3; } thread = find_thread_ptid (general_thread); if (thread == NULL) { - strcpy (own_buf, "E.No such thread."); + strcpy (own_buffer, "E.No such thread."); return -3; } if (thread->btrace == NULL) { - strcpy (own_buf, "E.Btrace not enabled."); + strcpy (own_buffer, "E.Btrace not enabled."); return -3; } @@ -1683,7 +1683,7 @@ handle_qxfer_btrace (const char *annex, type = BTRACE_READ_DELTA; else { - strcpy (own_buf, "E.Bad annex."); + strcpy (own_buffer, "E.Bad annex."); return -3; } @@ -1694,7 +1694,7 @@ handle_qxfer_btrace (const char *annex, result = target_read_btrace (thread->btrace, &cache, type); if (result != 0) { - memcpy (own_buf, cache.buffer, cache.used_size); + memcpy (own_buffer, cache.buffer, cache.used_size); return -3; } } @@ -1732,20 +1732,20 @@ handle_qxfer_btrace_conf (const char *annex, if (ptid_equal (general_thread, null_ptid) || ptid_equal (general_thread, minus_one_ptid)) { - strcpy (own_buf, "E.Must select a single thread."); + strcpy (own_buffer, "E.Must select a single thread."); return -3; } thread = find_thread_ptid (general_thread); if (thread == NULL) { - strcpy (own_buf, "E.No such thread."); + strcpy (own_buffer, "E.No such thread."); return -3; } if (thread->btrace == NULL) { - strcpy (own_buf, "E.Btrace not enabled."); + strcpy (own_buffer, "E.Btrace not enabled."); return -3; } @@ -1756,7 +1756,7 @@ handle_qxfer_btrace_conf (const char *annex, result = target_read_btrace_conf (thread->btrace, &cache); if (result != 0) { - memcpy (own_buf, cache.buffer, cache.used_size); + memcpy (own_buffer, cache.buffer, cache.used_size); return -3; } } @@ -2582,9 +2582,9 @@ handle_pending_status (const struct thread_resume *resumption, { thread->status_pending_p = 0; - last_status = thread->last_status; + last_status = thread->last_waitstatus; last_ptid = thread->entry.id; - prepare_resume_reply (own_buf, last_ptid, &last_status); + prepare_resume_reply (own_buffer, last_ptid, &last_status); return 1; } return 0; @@ -2723,7 +2723,7 @@ resume (struct thread_resume *actions, size_t num_actions) (*the_target->resume) (actions, num_actions); if (non_stop) - write_ok (own_buf); + write_ok (own_buffer); else { last_ptid = mywait (minus_one_ptid, &last_status, 0, 1); @@ -2733,7 +2733,7 @@ resume (struct thread_resume *actions, size_t num_actions) { /* The client does not support this stop reply. At least return error. */ - sprintf (own_buf, "E.No unwaited-for children left."); + sprintf (own_buffer, "E.No unwaited-for children left."); disable_async_io (); return; } @@ -2741,14 +2741,14 @@ resume (struct thread_resume *actions, size_t num_actions) if (last_status.kind != TARGET_WAITKIND_EXITED && last_status.kind != TARGET_WAITKIND_SIGNALLED && last_status.kind != TARGET_WAITKIND_NO_RESUMED) - current_thread->last_status = last_status; + current_thread->last_waitstatus = last_status; /* From the client's perspective, all-stop mode always stops all threads implicitly (and the target backend has already done so by now). Tag all threads as "want-stopped", so we don't resume them implicitly without the client telling us to. */ gdb_wants_all_threads_stopped (); - prepare_resume_reply (own_buf, last_ptid, &last_status); + prepare_resume_reply (own_buffer, last_ptid, &last_status); disable_async_io (); if (last_status.kind == TARGET_WAITKIND_EXITED @@ -3048,7 +3048,7 @@ queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg) struct vstop_notif *new_notif = XNEW (struct vstop_notif); new_notif->ptid = entry->id; - new_notif->status = thread->last_status; + new_notif->status = thread->last_waitstatus; /* Pass the last stop reply back to GDB, but don't notify yet. */ notif_event_enque (¬if_stop, @@ -3061,7 +3061,7 @@ queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg) if (debug_threads) { char *status_string - = target_waitstatus_to_string (&thread->last_status); + = target_waitstatus_to_string (&thread->last_waitstatus); debug_printf ("Reporting thread %s as already stopped with %s\n", target_pid_to_str (entry->id), @@ -3070,11 +3070,11 @@ queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg) xfree (status_string); } - gdb_assert (thread->last_status.kind != TARGET_WAITKIND_IGNORE); + gdb_assert (thread->last_waitstatus.kind != TARGET_WAITKIND_IGNORE); /* Pass the last stop reply back to GDB, but don't notify yet. */ - queue_stop_reply (entry->id, &thread->last_status); + queue_stop_reply (entry->id, &thread->last_waitstatus); } } @@ -3092,12 +3092,12 @@ gdb_wants_thread_stopped (struct inferior_list_entry *entry) thread->last_resume_kind = resume_stop; - if (thread->last_status.kind == TARGET_WAITKIND_IGNORE) + if (thread->last_waitstatus.kind == TARGET_WAITKIND_IGNORE) { /* Most threads are stopped implicitly (all-stop); tag that with signal 0. */ - thread->last_status.kind = TARGET_WAITKIND_STOPPED; - thread->last_status.value.sig = GDB_SIGNAL_0; + thread->last_waitstatus.kind = TARGET_WAITKIND_STOPPED; + thread->last_waitstatus.value.sig = GDB_SIGNAL_0; } } @@ -3138,15 +3138,15 @@ set_pending_status_callback (struct inferior_list_entry *entry) { struct thread_info *thread = (struct thread_info *) entry; - if (thread->last_status.kind != TARGET_WAITKIND_STOPPED - || (thread->last_status.value.sig != GDB_SIGNAL_0 + if (thread->last_waitstatus.kind != TARGET_WAITKIND_STOPPED + || (thread->last_waitstatus.value.sig != GDB_SIGNAL_0 /* A breakpoint, watchpoint or finished step from a previous GDB run isn't considered interesting for a new GDB run. If we left those pending, the new GDB could consider them random SIGTRAPs. This leaves out real async traps. We'd have to peek into the (target-specific) siginfo to distinguish those. */ - && thread->last_status.value.sig != GDB_SIGNAL_TRAP)) + && thread->last_waitstatus.value.sig != GDB_SIGNAL_TRAP)) thread->status_pending_p = 1; } @@ -3229,8 +3229,8 @@ handle_status (char *own_buf) general_thread = thread->id; set_desired_thread (1); - gdb_assert (tp->last_status.kind != TARGET_WAITKIND_IGNORE); - prepare_resume_reply (own_buf, tp->entry.id, &tp->last_status); + gdb_assert (tp->last_waitstatus.kind != TARGET_WAITKIND_IGNORE); + prepare_resume_reply (own_buf, tp->entry.id, &tp->last_waitstatus); } else strcpy (own_buf, "W00"); @@ -3618,7 +3618,7 @@ captured_main (int argc, char *argv[]) initialize_tracepoint (); initialize_notif (); - own_buf = (char *) xmalloc (PBUFSIZ + 1); + own_buffer = (char *) xmalloc (PBUFSIZ + 1); mem_buf = (unsigned char *) xmalloc (PBUFSIZ); if (pid == 0 && *next_arg != NULL) @@ -3754,8 +3754,8 @@ captured_main (int argc, char *argv[]) if (response_needed) { - write_enn (own_buf); - putpkt (own_buf); + write_enn (own_buffer); + putpkt (own_buffer); } if (run_once) @@ -3873,7 +3873,7 @@ process_serial_event (void) disable_async_io (); response_needed = 0; - packet_len = getpkt (own_buf); + packet_len = getpkt (own_buffer); if (packet_len <= 0) { remote_close (); @@ -3883,22 +3883,22 @@ process_serial_event (void) response_needed = 1; i = 0; - ch = own_buf[i++]; + ch = own_buffer[i++]; switch (ch) { case 'q': - handle_query (own_buf, packet_len, &new_packet_len); + handle_query (own_buffer, packet_len, &new_packet_len); break; case 'Q': - handle_general_set (own_buf); + handle_general_set (own_buffer); break; case 'D': - require_running (own_buf); + require_running (own_buffer); if (multi_process) { i++; /* skip ';' */ - pid = strtol (&own_buf[i], NULL, 16); + pid = strtol (&own_buffer[i], NULL, 16); } else pid = ptid_get_pid (current_ptid); @@ -3910,7 +3910,7 @@ process_serial_event (void) if (process == NULL) { - write_enn (own_buf); + write_enn (own_buffer); break; } @@ -3946,18 +3946,18 @@ process_serial_event (void) resume_info.sig = 0; (*the_target->resume) (&resume_info, 1); - write_ok (own_buf); + write_ok (own_buffer); break; /* from switch/case */ } fprintf (stderr, "Detaching from process %d\n", pid); stop_tracing (); if (detach_inferior (pid) != 0) - write_enn (own_buf); + write_enn (own_buffer); else { discard_queued_stop_replies (pid_to_ptid (pid)); - write_ok (own_buf); + write_ok (own_buffer); if (extended_protocol || target_running ()) { @@ -3972,7 +3972,7 @@ process_serial_event (void) } else { - putpkt (own_buf); + putpkt (own_buffer); remote_close (); /* If we are attached, then we can exit. Otherwise, we @@ -3985,20 +3985,20 @@ process_serial_event (void) break; case '!': extended_protocol = 1; - write_ok (own_buf); + write_ok (own_buffer); break; case '?': - handle_status (own_buf); + handle_status (own_buffer); break; case 'H': - if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's') + if (own_buffer[1] == 'c' || own_buffer[1] == 'g' || own_buffer[1] == 's') { ptid_t gdb_id, thread_id; int pid; - require_running (own_buf); + require_running (own_buffer); - gdb_id = read_ptid (&own_buf[2], NULL); + gdb_id = read_ptid (&own_buffer[2], NULL); pid = ptid_get_pid (gdb_id); @@ -4015,7 +4015,7 @@ process_serial_event (void) &pid); if (!thread) { - write_enn (own_buf); + write_enn (own_buffer); break; } @@ -4026,12 +4026,12 @@ process_serial_event (void) thread_id = gdb_id_to_thread_id (gdb_id); if (ptid_equal (thread_id, null_ptid)) { - write_enn (own_buf); + write_enn (own_buffer); break; } } - if (own_buf[1] == 'g') + if (own_buffer[1] == 'g') { if (ptid_equal (thread_id, null_ptid)) { @@ -4050,20 +4050,20 @@ process_serial_event (void) set_desired_thread (1); gdb_assert (current_thread != NULL); } - else if (own_buf[1] == 'c') + else if (own_buffer[1] == 'c') cont_thread = thread_id; - write_ok (own_buf); + write_ok (own_buffer); } else { /* Silently ignore it so that gdb can extend the protocol without compatibility headaches. */ - own_buf[0] = '\0'; + own_buffer[0] = '\0'; } break; case 'g': - require_running (own_buf); + require_running (own_buffer); if (current_traceframe >= 0) { struct regcache *regcache @@ -4071,9 +4071,9 @@ process_serial_event (void) if (fetch_traceframe_registers (current_traceframe, regcache, -1) == 0) - registers_to_string (regcache, own_buf); + registers_to_string (regcache, own_buffer); else - write_enn (own_buf); + write_enn (own_buffer); free_register_cache (regcache); } else @@ -4081,85 +4081,85 @@ process_serial_event (void) struct regcache *regcache; if (!set_desired_thread (1)) - write_enn (own_buf); + write_enn (own_buffer); else { regcache = get_thread_regcache (current_thread, 1); - registers_to_string (regcache, own_buf); + registers_to_string (regcache, own_buffer); } } break; case 'G': - require_running (own_buf); + require_running (own_buffer); if (current_traceframe >= 0) - write_enn (own_buf); + write_enn (own_buffer); else { struct regcache *regcache; if (!set_desired_thread (1)) - write_enn (own_buf); + write_enn (own_buffer); else { regcache = get_thread_regcache (current_thread, 1); - registers_from_string (regcache, &own_buf[1]); - write_ok (own_buf); + registers_from_string (regcache, &own_buffer[1]); + write_ok (own_buffer); } } break; case 'm': - require_running (own_buf); - decode_m_packet (&own_buf[1], &mem_addr, &len); + require_running (own_buffer); + decode_m_packet (&own_buffer[1], &mem_addr, &len); res = gdb_read_memory (mem_addr, mem_buf, len); if (res < 0) - write_enn (own_buf); + write_enn (own_buffer); else - bin2hex (mem_buf, own_buf, res); + bin2hex (mem_buf, own_buffer, res); break; case 'M': - require_running (own_buf); - decode_M_packet (&own_buf[1], &mem_addr, &len, &mem_buf); + require_running (own_buffer); + decode_M_packet (&own_buffer[1], &mem_addr, &len, &mem_buf); if (gdb_write_memory (mem_addr, mem_buf, len) == 0) - write_ok (own_buf); + write_ok (own_buffer); else - write_enn (own_buf); + write_enn (own_buffer); break; case 'X': - require_running (own_buf); - if (decode_X_packet (&own_buf[1], packet_len - 1, + require_running (own_buffer); + if (decode_X_packet (&own_buffer[1], packet_len - 1, &mem_addr, &len, &mem_buf) < 0 || gdb_write_memory (mem_addr, mem_buf, len) != 0) - write_enn (own_buf); + write_enn (own_buffer); else - write_ok (own_buf); + write_ok (own_buffer); break; case 'C': - require_running (own_buf); - hex2bin (own_buf + 1, &sig, 1); + require_running (own_buffer); + hex2bin (own_buffer + 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); + myresume (own_buffer, 0, signal); break; case 'S': - require_running (own_buf); - hex2bin (own_buf + 1, &sig, 1); + require_running (own_buffer); + hex2bin (own_buffer + 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); + myresume (own_buffer, 1, signal); break; case 'c': - require_running (own_buf); + require_running (own_buffer); signal = 0; - myresume (own_buf, 0, signal); + myresume (own_buffer, 0, signal); break; case 's': - require_running (own_buf); + require_running (own_buffer); signal = 0; - myresume (own_buf, 1, signal); + myresume (own_buffer, 1, signal); break; case 'Z': /* insert_ ... */ /* Fallthrough. */ @@ -4168,10 +4168,10 @@ process_serial_event (void) char *dataptr; ULONGEST addr; int kind; - char type = own_buf[1]; + char type = own_buffer[1]; int res; const int insert = ch == 'Z'; - char *p = &own_buf[3]; + char *p = &own_buffer[3]; p = unpack_varlen_hex (p, &addr); kind = strtol (p + 1, &dataptr, 16); @@ -4198,12 +4198,12 @@ process_serial_event (void) res = delete_gdb_breakpoint (type, addr, kind); if (res == 0) - write_ok (own_buf); + write_ok (own_buffer); else if (res == 1) /* Unsupported. */ - own_buf[0] = '\0'; + own_buffer[0] = '\0'; else - write_enn (own_buf); + write_enn (own_buffer); break; } case 'k': @@ -4231,20 +4231,20 @@ process_serial_event (void) { ptid_t gdb_id, thread_id; - require_running (own_buf); + require_running (own_buffer); - gdb_id = read_ptid (&own_buf[1], NULL); + gdb_id = read_ptid (&own_buffer[1], NULL); thread_id = gdb_id_to_thread_id (gdb_id); if (ptid_equal (thread_id, null_ptid)) { - write_enn (own_buf); + write_enn (own_buffer); break; } if (mythread_alive (thread_id)) - write_ok (own_buf); + write_ok (own_buffer); else - write_enn (own_buf); + write_enn (own_buffer); } break; case 'R': @@ -4287,26 +4287,26 @@ process_serial_event (void) /* It is a request we don't understand. Respond with an empty packet so that gdb knows that we don't support this request. */ - own_buf[0] = '\0'; + own_buffer[0] = '\0'; break; } case 'v': /* Extended (long) request. */ - handle_v_requests (own_buf, packet_len, &new_packet_len); + handle_v_requests (own_buffer, packet_len, &new_packet_len); break; default: /* It is a request we don't understand. Respond with an empty packet so that gdb knows that we don't support this request. */ - own_buf[0] = '\0'; + own_buffer[0] = '\0'; break; } if (new_packet_len != -1) - putpkt_binary (own_buf, new_packet_len); + putpkt_binary (own_buffer, new_packet_len); else - putpkt (own_buf); + putpkt (own_buffer); response_needed = 0; @@ -4384,7 +4384,7 @@ handle_target_event (int err, gdb_client_data client_data) "want-stopped" state to what the client wants, until it gets a new resume action. */ current_thread->last_resume_kind = resume_stop; - current_thread->last_status = last_status; + current_thread->last_waitstatus = last_status; } if (forward_event) diff --git a/gdb/nat/linux-personality.h b/gdb/nat/linux-personality.h index 009e614..5f7fa8b 100644 --- a/gdb/nat/linux-personality.h +++ b/gdb/nat/linux-personality.h @@ -26,6 +26,6 @@ re-enable the inferior's address space randomization. */ extern struct cleanup *maybe_disable_address_space_randomization - (int disable_randomization); + (int disable_randomization_p); #endif /* ! NAT_LINUX_PERSONALITY_H */