This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
Re: [RFC][PATCH] Consolidate gdbserver global variables
- From: Stan Cox <scox at redhat dot com>
- To: gdb-patches at sourceware dot org
- Date: Tue, 30 Jan 2018 22:41:37 -0500
- Subject: Re: [RFC][PATCH] Consolidate gdbserver global variables
- Authentication-results: sourceware.org; auth=none
- References: <3153f899-a653-9372-72fd-25ea874f7d3c@redhat.com>
> consolidating the global variables in gdbserver into one of two
> structures: client_state and server_state. Client_state are those items
> that have, or potentially could have, per client values, whereas
> server_state are those items that have a per process value, i.e. will
> have the same value for all clients. This patch, although large,
> primarily moves global data into one of the two structures
This is the same patch but with one major difference. No use is made of
access macros; instead the actual accesses are used. For example,
instead of a macro
#define current_thread (get_client_state()->ss->current_thread_)
through which all current_thread accesses are made
instead:
client_state *cs = get_client_state();
...
cs->ss->current_thread
(Another possibility to make the patch smaller would be an additional
struct thread_info *current_thread = cs->ss->current_thread;
... )
Distribution of global variables with more than 10 accesses:
program_name 11
last_ptid 11
program_args 14
remote_debug 22
non_stop 23
general_thread 23
last_status 47
own_buf 106
current_thread 248
The patch below is present in the branch:
ssh://sourceware.org/git/archer.git::scox/gdbserver-multi-client
(it is large, sorry about that, but much of it is mechanical)
diff --git a/gdb/gdbserver/event-loop.c b/gdb/gdbserver/event-loop.c
index eec0bcf3af6..382d9b3efa7 100644
--- a/gdb/gdbserver/event-loop.c
+++ b/gdb/gdbserver/event-loop.c
@@ -385,6 +385,9 @@ delete_file_handler (gdb_fildes_t fd)
;
prev_ptr->next_file = file_ptr->next_file;
}
+
+ struct multi_client_states *client_states = get_client_states();
+ client_states->delete_client_state (fd);
free (file_ptr);
}
diff --git a/gdb/gdbserver/fork-child.c b/gdb/gdbserver/fork-child.c
index 831e7e13100..74fa5e424c7 100644
--- a/gdb/gdbserver/fork-child.c
+++ b/gdb/gdbserver/fork-child.c
@@ -44,6 +44,8 @@ restore_old_foreground_pgrp (void)
void
prefork_hook (const char *args)
{
+ client_state *cs = get_client_state();
+
if (debug_threads)
{
debug_printf ("args: %s\n", args);
@@ -57,7 +59,7 @@ prefork_hook (const char *args)
/* Clear this so the backend doesn't get confused, thinking
CONT_THREAD died, and it needs to resume all threads. */
- cont_thread = null_ptid;
+ cs->ss->cont_thread = null_ptid;
}
/* See nat/fork-inferior.h. */
@@ -97,6 +99,7 @@ void
post_fork_inferior (int pid, const char *program)
{
#ifdef SIGTTOU
+ client_state *cs = get_client_state();
signal (SIGTTOU, SIG_IGN);
signal (SIGTTIN, SIG_IGN);
terminal_fd = fileno (stderr);
@@ -106,10 +109,10 @@ post_fork_inferior (int pid, const char *program)
#endif
startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED,
- &last_status, &last_ptid);
- current_thread->last_resume_kind = resume_stop;
- current_thread->last_status = last_status;
- signal_pid = pid;
+ &cs->ss->last_status, &cs->ss->last_ptid);
+ cs->ss->current_thread->last_resume_kind = resume_stop;
+ cs->ss->current_thread->last_status = cs->ss->last_status;
+ cs->ss->signal_pid = pid;
target_post_create_inferior ();
fprintf (stderr, "Process %s created; pid = %d\n", program, pid);
fflush (stderr);
diff --git a/gdb/gdbserver/gdbthread.h b/gdb/gdbserver/gdbthread.h
index 9a8c72e780e..c5bd1175f22 100644
--- a/gdb/gdbserver/gdbthread.h
+++ b/gdb/gdbserver/gdbthread.h
@@ -73,8 +73,6 @@ struct thread_info
struct btrace_target_info *btrace;
};
-extern std::list<thread_info *> all_threads;
-
void remove_thread (struct thread_info *thread);
struct thread_info *add_thread (ptid_t ptid, void *target_data);
@@ -95,9 +93,9 @@ template <typename Func>
static thread_info *
find_thread (Func func)
{
- std::list<thread_info *>::iterator next, cur = all_threads.begin ();
+ std::list<thread_info *>::iterator next, cur =
get_client_state()->ss->all_threads.begin ();
- while (cur != all_threads.end ())
+ while (cur != get_client_state()->ss->all_threads.end ())
{
next = cur;
next++;
@@ -141,9 +139,9 @@ template <typename Func>
static void
for_each_thread (Func func)
{
- std::list<thread_info *>::iterator next, cur = all_threads.begin ();
+ std::list<thread_info *>::iterator next, cur =
get_client_state()->ss->all_threads.begin ();
- while (cur != all_threads.end ())
+ while (cur != get_client_state()->ss->all_threads.end ())
{
next = cur;
next++;
@@ -198,7 +196,7 @@ find_thread_in_random (Func func)
}
/* Get current thread ID (Linux task ID). */
-#define current_ptid (current_thread->id)
+#define current_ptid (get_client_state()->ss->current_thread->id)
/* Get the ptid of THREAD. */
diff --git a/gdb/gdbserver/hostio.c b/gdb/gdbserver/hostio.c
index d2b5a71bade..4e388a85dc8 100644
--- a/gdb/gdbserver/hostio.c
+++ b/gdb/gdbserver/hostio.c
@@ -29,8 +29,6 @@
#include <sys/stat.h>
#include "fileio.h"
-extern int remote_debug;
-
struct fd_list
{
int fd;
diff --git a/gdb/gdbserver/inferiors.c b/gdb/gdbserver/inferiors.c
index 600bf201bff..c63f2026d08 100644
--- a/gdb/gdbserver/inferiors.c
+++ b/gdb/gdbserver/inferiors.c
@@ -22,10 +22,6 @@
#include "gdbthread.h"
#include "dll.h"
-std::list<process_info *> all_processes;
-std::list<thread_info *> all_threads;
-
-struct thread_info *current_thread;
/* The current working directory used to start the inferior. */
static const char *current_inferior_cwd = NULL;
@@ -33,16 +29,17 @@ static const char *current_inferior_cwd = NULL;
struct thread_info *
add_thread (ptid_t thread_id, void *target_data)
{
+ client_state *cs = get_client_state();
struct thread_info *new_thread = XCNEW (struct thread_info);
new_thread->id = thread_id;
new_thread->last_resume_kind = resume_continue;
new_thread->last_status.kind = TARGET_WAITKIND_IGNORE;
- all_threads.push_back (new_thread);
+ cs->ss->all_threads.push_back (new_thread);
- if (current_thread == NULL)
- current_thread = new_thread;
+ if (cs->ss->current_thread == NULL)
+ cs->ss->current_thread = new_thread;
new_thread->target_data = target_data;
@@ -54,8 +51,10 @@ add_thread (ptid_t thread_id, void *target_data)
struct thread_info *
get_first_thread (void)
{
- if (!all_threads.empty ())
- return all_threads.front ();
+ client_state *cs = get_client_state();
+
+ if (!cs->ss->all_threads.empty ())
+ return cs->ss->all_threads.front ();
else
return NULL;
}
@@ -97,14 +96,16 @@ free_one_thread (thread_info *thread)
void
remove_thread (struct thread_info *thread)
{
+ client_state *cs = get_client_state();
+
if (thread->btrace != NULL)
target_disable_btrace (thread->btrace);
discard_queued_stop_replies (ptid_of (thread));
- all_threads.remove (thread);
+ cs->ss->all_threads.remove (thread);
free_one_thread (thread);
- if (current_thread == thread)
- current_thread = NULL;
+ if (cs->ss->current_thread == thread)
+ cs->ss->current_thread = NULL;
}
void *
@@ -128,20 +129,24 @@ set_thread_regcache_data (struct thread_info
*thread, struct regcache *data)
void
clear_inferiors (void)
{
+ client_state *cs = get_client_state();
+
for_each_thread (free_one_thread);
- all_threads.clear ();
+ cs->ss->all_threads.clear ();
clear_dlls ();
- current_thread = NULL;
+ cs->ss->current_thread = NULL;
}
struct process_info *
add_process (int pid, int attached)
{
+ client_state *cs = get_client_state();
+
process_info *process = new process_info (pid, attached);
- all_processes.push_back (process);
+ cs->ss->all_processes.push_back (process);
return process;
}
@@ -153,10 +158,12 @@ add_process (int pid, int attached)
void
remove_process (struct process_info *process)
{
+ client_state *cs = get_client_state();
+
clear_symbol_cache (&process->symbol_cache);
free_all_breakpoints (process);
gdb_assert (find_thread_process (process) == NULL);
- all_processes.remove (process);
+ cs->ss->all_processes.remove (process);
delete process;
}
@@ -173,8 +180,10 @@ find_process_pid (int pid)
process_info *
get_first_process (void)
{
- if (!all_processes.empty ())
- return all_processes.front ();
+ client_state *cs = get_client_state();
+
+ if (!cs->ss->all_processes.empty ())
+ return cs->ss->all_processes.front ();
else
return NULL;
}
@@ -209,20 +218,26 @@ get_thread_process (const struct thread_info *thread)
struct process_info *
current_process (void)
{
- gdb_assert (current_thread != NULL);
- return get_thread_process (current_thread);
+ client_state *cs = get_client_state();
+
+ gdb_assert (cs->ss->current_thread != NULL);
+ return get_thread_process (cs->ss->current_thread);
}
static void
do_restore_current_thread_cleanup (void *arg)
{
- current_thread = (struct thread_info *) arg;
+ client_state *cs = get_client_state();
+
+ cs->ss->current_thread = (struct thread_info *) arg;
}
struct cleanup *
make_cleanup_restore_current_thread (void)
{
- return make_cleanup (do_restore_current_thread_cleanup, current_thread);
+ client_state *cs = get_client_state();
+
+ return make_cleanup (do_restore_current_thread_cleanup,
cs->ss->current_thread);
}
/* See common/common-gdbthread.h. */
@@ -230,8 +245,10 @@ make_cleanup_restore_current_thread (void)
void
switch_to_thread (ptid_t ptid)
{
+ client_state *cs = get_client_state();
+
gdb_assert (ptid != minus_one_ptid);
- current_thread = find_thread_ptid (ptid);
+ cs->ss->current_thread = find_thread_ptid (ptid);
}
/* See common/common-inferior.h. */
diff --git a/gdb/gdbserver/inferiors.h b/gdb/gdbserver/inferiors.h
index ccd42df9da4..7f149f53a48 100644
--- a/gdb/gdbserver/inferiors.h
+++ b/gdb/gdbserver/inferiors.h
@@ -85,17 +85,15 @@ pid_of (const process_info *proc)
struct process_info *current_process (void);
struct process_info *get_thread_process (const struct thread_info *);
-extern std::list<process_info *> all_processes;
-
/* Invoke FUNC for each process. */
template <typename Func>
static void
for_each_process (Func func)
{
- std::list<process_info *>::iterator next, cur = all_processes.begin ();
+ std::list<process_info *>::iterator next, cur =
get_client_state()->ss->all_processes.begin ();
- while (cur != all_processes.end ())
+ while (cur != get_client_state()->ss->all_processes.end ())
{
next = cur;
next++;
@@ -111,9 +109,9 @@ template <typename Func>
static process_info *
find_process (Func func)
{
- std::list<process_info *>::iterator next, cur = all_processes.begin ();
+ std::list<process_info *>::iterator next, cur =
get_client_state()->ss->all_processes.begin ();
- while (cur != all_processes.end ())
+ while (cur != get_client_state()->ss->all_processes.end ())
{
next = cur;
next++;
@@ -127,8 +125,6 @@ find_process (Func func)
return NULL;
}
-extern struct thread_info *current_thread;
-
/* Return the first process in the processes list. */
struct process_info *get_first_process (void);
diff --git a/gdb/gdbserver/linux-aarch32-low.c
b/gdb/gdbserver/linux-aarch32-low.c
index 12c11a4252b..85b2d0d63b4 100644
--- a/gdb/gdbserver/linux-aarch32-low.c
+++ b/gdb/gdbserver/linux-aarch32-low.c
@@ -171,7 +171,7 @@ struct regs_info regs_info_aarch32 =
int
arm_is_thumb_mode (void)
{
- struct regcache *regcache = get_thread_regcache (current_thread, 1);
+ struct regcache *regcache = get_thread_regcache
(cs->ss->current_thread, 1);
unsigned long cpsr;
collect_register_by_name (regcache, "cpsr", &cpsr);
diff --git a/gdb/gdbserver/linux-aarch64-low.c
b/gdb/gdbserver/linux-aarch64-low.c
index eccac4da138..b382f4e97d1 100644
--- a/gdb/gdbserver/linux-aarch64-low.c
+++ b/gdb/gdbserver/linux-aarch64-low.c
@@ -67,7 +67,7 @@ struct arch_process_info
static int
is_64bit_tdesc (void)
{
- struct regcache *regcache = get_thread_regcache (current_thread, 0);
+ struct regcache *regcache = get_thread_regcache
(cs->ss->current_thread, 0);
return register_size (regcache->tdesc, 0) == 8;
}
@@ -253,7 +253,7 @@ aarch64_insert_point (enum raw_bkpt_type type,
CORE_ADDR addr,
int ret;
enum target_hw_bp_type targ_type;
struct aarch64_debug_reg_state *state
- = aarch64_get_debug_reg_state (pid_of (current_thread));
+ = aarch64_get_debug_reg_state (pid_of (cs->ss->current_thread));
if (show_debug_regs)
fprintf (stderr, "insert_point on entry (addr=0x%08lx, len=%d)\n",
@@ -302,7 +302,7 @@ aarch64_remove_point (enum raw_bkpt_type type,
CORE_ADDR addr,
int ret;
enum target_hw_bp_type targ_type;
struct aarch64_debug_reg_state *state
- = aarch64_get_debug_reg_state (pid_of (current_thread));
+ = aarch64_get_debug_reg_state (pid_of (cs->ss->current_thread));
if (show_debug_regs)
fprintf (stderr, "remove_point on entry (addr=0x%08lx, len=%d)\n",
@@ -345,7 +345,7 @@ aarch64_stopped_data_address (void)
int pid, i;
struct aarch64_debug_reg_state *state;
- pid = lwpid_of (current_thread);
+ pid = lwpid_of (cs->ss->current_thread);
/* Get the siginfo. */
if (ptrace (PTRACE_GETSIGINFO, pid, NULL, &siginfo) != 0)
@@ -357,7 +357,7 @@ aarch64_stopped_data_address (void)
return (CORE_ADDR) 0;
/* Check if the address matches any watched address. */
- state = aarch64_get_debug_reg_state (pid_of (current_thread));
+ state = aarch64_get_debug_reg_state (pid_of (cs->ss->current_thread));
for (i = aarch64_num_wp_regs - 1; i >= 0; --i)
{
const unsigned int len = aarch64_watchpoint_length
(state->dr_ctrl_wp[i]);
@@ -473,7 +473,7 @@ aarch64_arch_setup (void)
int is_elf64;
int tid;
- tid = lwpid_of (current_thread);
+ tid = lwpid_of (cs->ss->current_thread);
is_elf64 = linux_pid_exe_is_elf_64_file (tid, &machine);
@@ -482,7 +482,7 @@ aarch64_arch_setup (void)
else
current_process ()->tdesc = tdesc_arm_with_neon;
- aarch64_linux_get_debug_reg_capacity (lwpid_of (current_thread));
+ aarch64_linux_get_debug_reg_capacity (lwpid_of (cs->ss->current_thread));
}
static struct regset_info aarch64_regsets[] =
@@ -527,7 +527,7 @@ aarch64_regs_info (void)
static int
aarch64_supports_tracepoints (void)
{
- if (current_thread == NULL)
+ if (cs->ss->current_thread == NULL)
return 1;
else
{
diff --git a/gdb/gdbserver/linux-arm-low.c b/gdb/gdbserver/linux-arm-low.c
index 6c2dcead03d..2bf687b773b 100644
--- a/gdb/gdbserver/linux-arm-low.c
+++ b/gdb/gdbserver/linux-arm-low.c
@@ -528,7 +528,7 @@ arm_insert_point (enum raw_bkpt_type type, CORE_ADDR
addr,
pts[i] = p;
/* Only update the threads of the current process. */
- for_each_thread (current_thread->id.pid (), [&] (thread_info *thread)
+ for_each_thread (cs->ss->current_thread->id.pid (), [&] (thread_info
*thread)
{
update_registers_callback (thread, watch, i);
});
@@ -573,7 +573,7 @@ arm_remove_point (enum raw_bkpt_type type, CORE_ADDR
addr,
pts[i].control = arm_hwbp_control_disable (pts[i].control);
/* Only update the threads of the current process. */
- for_each_thread (current_thread->id.pid (), [&] (thread_info *thread)
+ for_each_thread (cs->ss->current_thread->id.pid (), [&] (thread_info
*thread)
{
update_registers_callback (thread, watch, i);
});
@@ -589,7 +589,7 @@ arm_remove_point (enum raw_bkpt_type type, CORE_ADDR
addr,
static int
arm_stopped_by_watchpoint (void)
{
- struct lwp_info *lwp = get_thread_lwp (current_thread);
+ struct lwp_info *lwp = get_thread_lwp (cs->ss->current_thread);
siginfo_t siginfo;
/* We must be able to set hardware watchpoints. */
@@ -598,7 +598,7 @@ arm_stopped_by_watchpoint (void)
/* Retrieve siginfo. */
errno = 0;
- ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread), 0, &siginfo);
+ ptrace (PTRACE_GETSIGINFO, lwpid_of (cs->ss->current_thread), 0,
&siginfo);
if (errno != 0)
return 0;
@@ -624,7 +624,7 @@ arm_stopped_by_watchpoint (void)
static CORE_ADDR
arm_stopped_data_address (void)
{
- struct lwp_info *lwp = get_thread_lwp (current_thread);
+ struct lwp_info *lwp = get_thread_lwp (cs->ss->current_thread);
return lwp->arch_private->stopped_data_address;
}
@@ -872,7 +872,7 @@ arm_get_hwcap (unsigned long *valp)
static const struct target_desc *
arm_read_description (void)
{
- int pid = lwpid_of (current_thread);
+ int pid = lwpid_of (cs->ss->current_thread);
unsigned long arm_hwcap = 0;
/* Query hardware watchpoint/breakpoint capabilities. */
@@ -919,7 +919,7 @@ arm_read_description (void)
static void
arm_arch_setup (void)
{
- int tid = lwpid_of (current_thread);
+ int tid = lwpid_of (cs->ss->current_thread);
int gpregs[18];
struct iovec iov;
diff --git a/gdb/gdbserver/linux-crisv32-low.c
b/gdb/gdbserver/linux-crisv32-low.c
index 6eb82175bce..415826072fc 100644
--- a/gdb/gdbserver/linux-crisv32-low.c
+++ b/gdb/gdbserver/linux-crisv32-low.c
@@ -139,7 +139,7 @@ cris_insert_point (enum raw_bkpt_type type,
CORE_ADDR addr,
unsigned long ccs;
struct regcache *regcache;
- regcache = get_thread_regcache (current_thread, 1);
+ regcache = get_thread_regcache (cs->ss->current_thread, 1);
/* Read watchpoints are set as access watchpoints, because of GDB's
inability to deal with pure read watchpoints. */
@@ -212,7 +212,7 @@ cris_remove_point (enum raw_bkpt_type type,
CORE_ADDR addr, int len,
struct regcache *regcache;
unsigned long bp_d_regs[12];
- regcache = get_thread_regcache (current_thread, 1);
+ regcache = get_thread_regcache (cs->ss->current_thread, 1);
/* Read watchpoints are set as access watchpoints, because of GDB's
inability to deal with pure read watchpoints. */
@@ -289,7 +289,7 @@ static int
cris_stopped_by_watchpoint (void)
{
unsigned long exs;
- struct regcache *regcache = get_thread_regcache (current_thread, 1);
+ struct regcache *regcache = get_thread_regcache
(cs->ss->current_thread, 1);
collect_register_by_name (regcache, "exs", &exs);
@@ -300,7 +300,7 @@ static CORE_ADDR
cris_stopped_data_address (void)
{
unsigned long eda;
- struct regcache *regcache = get_thread_regcache (current_thread, 1);
+ struct regcache *regcache = get_thread_regcache
(cs->ss->current_thread, 1);
collect_register_by_name (regcache, "eda", &eda);
diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c
index 38142bba03d..3359ce7136f 100644
--- a/gdb/gdbserver/linux-low.c
+++ b/gdb/gdbserver/linux-low.c
@@ -455,14 +455,15 @@ linux_arch_setup (void)
static void
linux_arch_setup_thread (struct thread_info *thread)
{
+ client_state *cs = get_client_state();
struct thread_info *saved_thread;
- saved_thread = current_thread;
- current_thread = thread;
+ saved_thread = cs->ss->current_thread;
+ cs->ss->current_thread = thread;
linux_arch_setup ();
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
}
/* Handle a GNU/Linux extended wait response. If we see a clone,
@@ -474,6 +475,7 @@ linux_arch_setup_thread (struct thread_info *thread)
static int
handle_extended_wait (struct lwp_info **orig_event_lwp, int wstat)
{
+ client_state *cs = get_client_state();
struct lwp_info *event_lwp = *orig_event_lwp;
int event = linux_ptrace_get_extended_event (wstat);
struct thread_info *event_thr = get_lwp_thread (event_lwp);
@@ -654,7 +656,7 @@ handle_extended_wait (struct lwp_info
**orig_event_lwp, int wstat)
new_lwp->status_pending_p = 1;
new_lwp->status_pending = status;
}
- else if (report_thread_events)
+ else if (cs->report_thread_events)
{
new_lwp->waitstatus.kind = TARGET_WAITKIND_THREAD_CREATED;
new_lwp->status_pending_p = 1;
@@ -682,7 +684,7 @@ handle_extended_wait (struct lwp_info
**orig_event_lwp, int wstat)
/* Report the event. */
return 0;
}
- else if (event == PTRACE_EVENT_EXEC && report_exec_events)
+ else if (event == PTRACE_EVENT_EXEC && cs->report_exec_events)
{
struct process_info *proc;
std::vector<int> syscalls_to_catch;
@@ -705,13 +707,13 @@ handle_extended_wait (struct lwp_info
**orig_event_lwp, int wstat)
/* Delete the execing process and all its threads. */
linux_mourn (proc);
- current_thread = NULL;
+ cs->ss->current_thread = NULL;
/* Create a new process/lwp/thread. */
proc = linux_add_process (event_pid, 0);
event_lwp = add_lwp (event_ptid);
event_thr = get_lwp_thread (event_lwp);
- gdb_assert (current_thread == event_thr);
+ gdb_assert (cs->ss->current_thread == event_thr);
linux_arch_setup_thread (event_thr);
/* Set the event status. */
@@ -748,6 +750,7 @@ handle_extended_wait (struct lwp_info
**orig_event_lwp, int wstat)
static CORE_ADDR
get_pc (struct lwp_info *lwp)
{
+ client_state *cs = get_client_state();
struct thread_info *saved_thread;
struct regcache *regcache;
CORE_ADDR pc;
@@ -755,16 +758,16 @@ get_pc (struct lwp_info *lwp)
if (the_low_target.get_pc == NULL)
return 0;
- saved_thread = current_thread;
- current_thread = get_lwp_thread (lwp);
+ saved_thread = cs->ss->current_thread;
+ cs->ss->current_thread = get_lwp_thread (lwp);
- regcache = get_thread_regcache (current_thread, 1);
+ regcache = get_thread_regcache (cs->ss->current_thread, 1);
pc = (*the_low_target.get_pc) (regcache);
if (debug_threads)
debug_printf ("pc is 0x%lx\n", (long) pc);
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
return pc;
}
@@ -774,6 +777,7 @@ get_pc (struct lwp_info *lwp)
static void
get_syscall_trapinfo (struct lwp_info *lwp, int *sysno)
{
+ client_state *cs = get_client_state();
struct thread_info *saved_thread;
struct regcache *regcache;
@@ -785,16 +789,16 @@ get_syscall_trapinfo (struct lwp_info *lwp, int
*sysno)
return;
}
- saved_thread = current_thread;
- current_thread = get_lwp_thread (lwp);
+ saved_thread = cs->ss->current_thread;
+ cs->ss->current_thread = get_lwp_thread (lwp);
- regcache = get_thread_regcache (current_thread, 1);
+ regcache = get_thread_regcache (cs->ss->current_thread, 1);
(*the_low_target.get_syscall_trapinfo) (regcache, sysno);
if (debug_threads)
debug_printf ("get_syscall_trapinfo sysno %d\n", *sysno);
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
}
static int check_stopped_by_watchpoint (struct lwp_info *child);
@@ -808,6 +812,7 @@ static int check_stopped_by_watchpoint (struct
lwp_info *child);
static int
save_stop_reason (struct lwp_info *lwp)
{
+ client_state *cs = get_client_state();
CORE_ADDR pc;
CORE_ADDR sw_breakpoint_pc;
struct thread_info *saved_thread;
@@ -822,11 +827,11 @@ save_stop_reason (struct lwp_info *lwp)
sw_breakpoint_pc = pc - the_low_target.decr_pc_after_break;
/* breakpoint_at reads from the current thread. */
- saved_thread = current_thread;
- current_thread = get_lwp_thread (lwp);
+ saved_thread = cs->ss->current_thread;
+ cs->ss->current_thread = get_lwp_thread (lwp);
#if USE_SIGTRAP_SIGINFO
- if (ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
+ if (ptrace (PTRACE_GETSIGINFO, lwpid_of (cs->ss->current_thread),
(PTRACE_TYPE_ARG3) 0, &siginfo) == 0)
{
if (siginfo.si_signo == SIGTRAP)
@@ -897,7 +902,7 @@ save_stop_reason (struct lwp_info *lwp)
if (pc != sw_breakpoint_pc)
{
struct regcache *regcache
- = get_thread_regcache (current_thread, 1);
+ = get_thread_regcache (cs->ss->current_thread, 1);
(*the_low_target.set_pc) (regcache, sw_breakpoint_pc);
}
@@ -936,7 +941,7 @@ save_stop_reason (struct lwp_info *lwp)
}
lwp->stop_pc = pc;
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
return 1;
}
@@ -997,13 +1002,14 @@ static int
linux_create_inferior (const char *program,
const std::vector<char *> &program_args)
{
+ client_state *cs = get_client_state();
struct lwp_info *new_lwp;
int pid;
ptid_t ptid;
{
maybe_disable_address_space_randomization restore_personality
- (disable_randomization);
+ (cs->disable_randomization);
std::string str_program_args = stringify_argv (program_args);
pid = fork_inferior (program,
@@ -1028,7 +1034,8 @@ linux_create_inferior (const char *program,
static void
linux_post_create_inferior (void)
{
- struct lwp_info *lwp = get_thread_lwp (current_thread);
+ client_state *cs = get_client_state();
+ struct lwp_info *lwp = get_thread_lwp (cs->ss->current_thread);
linux_arch_setup ();
@@ -1037,7 +1044,7 @@ linux_post_create_inferior (void)
struct process_info *proc = current_process ();
int options = linux_low_ptrace_options (proc->attached);
- linux_enable_event_reporting (lwpid_of (current_thread), options);
+ linux_enable_event_reporting (lwpid_of (cs->ss->current_thread),
options);
lwp->must_set_ptrace_flags = 0;
}
}
@@ -1180,6 +1187,7 @@ static void async_file_mark (void);
static int
linux_attach (unsigned long pid)
{
+ client_state *cs = get_client_state();
struct process_info *proc;
struct thread_info *initial_thread;
ptid_t ptid = ptid_build (pid, pid, 0);
@@ -1219,7 +1227,7 @@ linux_attach (unsigned long pid)
the thread group reports its initial PTRACE_ATTACH SIGSTOP. Do
that now, otherwise, if GDB is fast enough, it could read the
target description _before_ that initial stop. */
- if (non_stop)
+ if (cs->non_stop)
{
struct lwp_info *lwp;
int wstat, lwpid;
@@ -1428,6 +1436,7 @@ linux_kill (int pid)
static int
get_detach_signal (struct thread_info *thread)
{
+ client_state *cs = get_client_state();
enum gdb_signal signo = GDB_SIGNAL_0;
int status;
struct lwp_info *lp = get_thread_lwp (thread);
@@ -1468,7 +1477,7 @@ get_detach_signal (struct thread_info *thread)
signo = gdb_signal_from_host (WSTOPSIG (status));
- if (program_signals_p && !program_signals[signo])
+ if (cs->program_signals_p && !cs->program_signals[signo])
{
if (debug_threads)
debug_printf ("GPS: lwp %s had signal %s, but it is in nopass state\n",
@@ -1476,7 +1485,7 @@ get_detach_signal (struct thread_info *thread)
gdb_signal_to_string (signo));
return 0;
}
- else if (!program_signals_p
+ else if (!cs->program_signals_p
/* If we have no way to know which signals GDB does not
want to have passed to the program, assume
SIGTRAP/SIGINT, which is GDB's default. */
@@ -1709,6 +1718,7 @@ linux_thread_alive (ptid_t ptid)
static int
thread_still_has_status_pending_p (struct thread_info *thread)
{
+ client_state *cs = get_client_state();
struct lwp_info *lp = get_thread_lwp (thread);
if (!lp->status_pending_p)
@@ -1726,8 +1736,8 @@ thread_still_has_status_pending_p (struct
thread_info *thread)
pc = get_pc (lp);
- saved_thread = current_thread;
- current_thread = thread;
+ saved_thread = cs->ss->current_thread;
+ cs->ss->current_thread = thread;
if (pc != lp->stop_pc)
{
@@ -1756,7 +1766,7 @@ thread_still_has_status_pending_p (struct
thread_info *thread)
}
#endif
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
if (discard)
{
@@ -2054,10 +2064,11 @@ linux_fast_tracepoint_collecting (struct
lwp_info *lwp,
static int
maybe_move_out_of_jump_pad (struct lwp_info *lwp, int *wstat)
{
+ client_state *cs = get_client_state();
struct thread_info *saved_thread;
- saved_thread = current_thread;
- current_thread = get_lwp_thread (lwp);
+ saved_thread = cs->ss->current_thread;
+ cs->ss->current_thread = get_lwp_thread (lwp);
if ((wstat == NULL
|| (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) != SIGTRAP))
@@ -2069,7 +2080,7 @@ maybe_move_out_of_jump_pad (struct lwp_info *lwp,
int *wstat)
if (debug_threads)
debug_printf ("Checking whether LWP %ld needs to move out of the "
"jump pad.\n",
- lwpid_of (current_thread));
+ lwpid_of (cs->ss->current_thread));
fast_tpoint_collect_result r
= linux_fast_tracepoint_collecting (lwp, &status);
@@ -2097,8 +2108,8 @@ maybe_move_out_of_jump_pad (struct lwp_info *lwp,
int *wstat)
if (debug_threads)
debug_printf ("Checking whether LWP %ld needs to move out of "
"the jump pad...it does\n",
- lwpid_of (current_thread));
- current_thread = saved_thread;
+ lwpid_of (cs->ss->current_thread));
+ cs->ss->current_thread = saved_thread;
return 1;
}
@@ -2128,18 +2139,18 @@ maybe_move_out_of_jump_pad (struct lwp_info
*lwp, int *wstat)
|| WSTOPSIG (*wstat) == SIGFPE
|| WSTOPSIG (*wstat) == SIGBUS
|| WSTOPSIG (*wstat) == SIGSEGV)
- && ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
+ && ptrace (PTRACE_GETSIGINFO, lwpid_of (cs->ss->current_thread),
(PTRACE_TYPE_ARG3) 0, &info) == 0
/* Final check just to make sure we don't clobber
the siginfo of non-kernel-sent signals. */
&& (uintptr_t) info.si_addr == lwp->stop_pc)
{
info.si_addr = (void *) (uintptr_t) status.tpoint_addr;
- ptrace (PTRACE_SETSIGINFO, lwpid_of (current_thread),
+ ptrace (PTRACE_SETSIGINFO, lwpid_of (cs->ss->current_thread),
(PTRACE_TYPE_ARG3) 0, &info);
}
- regcache = get_thread_regcache (current_thread, 1);
+ regcache = get_thread_regcache (cs->ss->current_thread, 1);
(*the_low_target.set_pc) (regcache, status.tpoint_addr);
lwp->stop_pc = status.tpoint_addr;
@@ -2169,9 +2180,9 @@ maybe_move_out_of_jump_pad (struct lwp_info *lwp,
int *wstat)
if (debug_threads)
debug_printf ("Checking whether LWP %ld needs to move out of the "
"jump pad...no\n",
- lwpid_of (current_thread));
+ lwpid_of (cs->ss->current_thread));
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
return 0;
}
@@ -2298,12 +2309,14 @@ dequeue_one_deferred_signal (struct lwp_info
*lwp, int *wstat)
static int
check_stopped_by_watchpoint (struct lwp_info *child)
{
+ client_state *cs = get_client_state();
+
if (the_low_target.stopped_by_watchpoint != NULL)
{
struct thread_info *saved_thread;
- saved_thread = current_thread;
- current_thread = get_lwp_thread (child);
+ saved_thread = cs->ss->current_thread;
+ cs->ss->current_thread = get_lwp_thread (child);
if (the_low_target.stopped_by_watchpoint ())
{
@@ -2316,7 +2329,7 @@ check_stopped_by_watchpoint (struct lwp_info *child)
child->stopped_data_address = 0;
}
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
}
return child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
@@ -2327,18 +2340,19 @@ check_stopped_by_watchpoint (struct lwp_info *child)
static int
linux_low_ptrace_options (int attached)
{
+ client_state *cs = get_client_state();
int options = 0;
if (!attached)
options |= PTRACE_O_EXITKILL;
- if (report_fork_events)
+ if (cs->report_fork_events)
options |= PTRACE_O_TRACEFORK;
- if (report_vfork_events)
+ if (cs->report_vfork_events)
options |= (PTRACE_O_TRACEVFORK | PTRACE_O_TRACEVFORKDONE);
- if (report_exec_events)
+ if (cs->report_exec_events)
options |= PTRACE_O_TRACEEXEC;
options |= PTRACE_O_TRACESYSGOOD;
@@ -2353,6 +2367,7 @@ linux_low_ptrace_options (int attached)
static struct lwp_info *
linux_low_filter_event (int lwpid, int wstat)
{
+ client_state *cs = get_client_state();
struct lwp_info *child;
struct thread_info *thread;
int have_stop_pc = 0;
@@ -2388,7 +2403,7 @@ linux_low_filter_event (int lwpid, int wstat)
child_ptid = ptid_build (lwpid, lwpid, 0);
child = add_lwp (child_ptid);
child->stopped = 1;
- current_thread = child->thread;
+ cs->ss->current_thread = child->thread;
}
/* If we didn't find a process, one of two things presumably happened:
@@ -2424,7 +2439,7 @@ linux_low_filter_event (int lwpid, int wstat)
/* If there is at least one more LWP, then the exit signal was
not the end of the debugged application and should be
ignored, unless GDB wants to hear about thread exits. */
- if (report_thread_events
+ if (cs->report_thread_events
|| last_thread_of_process_p (pid_of (thread)))
{
/* Since events are serialized to GDB core, and we can't
@@ -2616,6 +2631,7 @@ static int
linux_wait_for_event_filtered (ptid_t wait_ptid, ptid_t filter_ptid,
int *wstatp, int options)
{
+ client_state *cs = get_client_state();
struct thread_info *event_thread;
struct lwp_info *event_child, *requested_child;
sigset_t block_mask, prev_mask;
@@ -2680,7 +2696,7 @@ linux_wait_for_event_filtered (ptid_t wait_ptid,
ptid_t filter_ptid,
*wstatp = event_child->status_pending;
event_child->status_pending_p = 0;
event_child->status_pending = 0;
- current_thread = event_thread;
+ cs->ss->current_thread = event_thread;
return lwpid_of (event_thread);
}
@@ -2805,7 +2821,7 @@ linux_wait_for_event_filtered (ptid_t wait_ptid,
ptid_t filter_ptid,
sigprocmask (SIG_SETMASK, &prev_mask, NULL);
- current_thread = event_thread;
+ cs->ss->current_thread = event_thread;
return lwpid_of (event_thread);
}
@@ -2829,6 +2845,7 @@ linux_wait_for_event (ptid_t ptid, int *wstatp,
int options)
static void
select_event_lwp (struct lwp_info **orig_lp)
{
+ client_state *cs = get_client_state();
int random_selector;
struct thread_info *event_thread = NULL;
@@ -2840,7 +2857,7 @@ select_event_lwp (struct lwp_info **orig_lp)
report the pending SIGTRAP, and the core, not having stepped the
thread, wouldn't understand what the trap was for, and therefore
would report it to the user as a random signal. */
- if (!non_stop)
+ if (!cs->non_stop)
{
event_thread = find_thread ([] (thread_info *thread)
{
@@ -2963,6 +2980,8 @@ static ptid_t linux_wait_1 (ptid_t ptid,
static void
linux_stabilize_threads (void)
{
+ client_state *cs = get_client_state();
+
thread_info *thread_stuck = find_thread (stuck_in_jump_pad_callback);
if (thread_stuck != NULL)
@@ -2973,7 +2992,7 @@ linux_stabilize_threads (void)
return;
}
- thread_info *saved_thread = current_thread;
+ thread_info *saved_thread = cs->ss->current_thread;
stabilizing_threads = 1;
@@ -2994,13 +3013,13 @@ linux_stabilize_threads (void)
if (ourstatus.kind == TARGET_WAITKIND_STOPPED)
{
- lwp = get_thread_lwp (current_thread);
+ lwp = get_thread_lwp (cs->ss->current_thread);
/* Lock it. */
lwp_suspended_inc (lwp);
if (ourstatus.value.sig != GDB_SIGNAL_0
- || current_thread->last_resume_kind == resume_stop)
+ || cs->ss->current_thread->last_resume_kind == resume_stop)
{
wstat = W_STOPCODE (gdb_signal_to_host (ourstatus.value.sig));
enqueue_one_deferred_signal (lwp, &wstat);
@@ -3012,7 +3031,7 @@ linux_stabilize_threads (void)
stabilizing_threads = 0;
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
if (debug_threads)
{
@@ -3048,12 +3067,13 @@ static ptid_t
filter_exit_event (struct lwp_info *event_child,
struct target_waitstatus *ourstatus)
{
+ client_state *cs = get_client_state();
struct thread_info *thread = get_lwp_thread (event_child);
ptid_t ptid = ptid_of (thread);
if (!last_thread_of_process_p (pid_of (thread)))
{
- if (report_thread_events)
+ if (cs->report_thread_events)
ourstatus->kind = TARGET_WAITKIND_THREAD_EXITED;
else
ourstatus->kind = TARGET_WAITKIND_IGNORE;
@@ -3105,6 +3125,7 @@ static ptid_t
linux_wait_1 (ptid_t ptid,
struct target_waitstatus *ourstatus, int target_options)
{
+ client_state *cs = get_client_state();
int w;
struct lwp_info *event_child;
int options;
@@ -3188,7 +3209,7 @@ linux_wait_1 (ptid_t ptid,
return null_ptid;
}
- event_child = get_thread_lwp (current_thread);
+ event_child = get_thread_lwp (cs->ss->current_thread);
/* linux_wait_for_event only returns an exit status for the last
child of a process. Report it. */
@@ -3203,7 +3224,7 @@ linux_wait_1 (ptid_t ptid,
{
debug_printf ("linux_wait_1 ret = %s, exited with "
"retcode %d\n",
- target_pid_to_str (ptid_of (current_thread)),
+ target_pid_to_str (ptid_of (cs->ss->current_thread)),
WEXITSTATUS (w));
debug_exit ();
}
@@ -3217,7 +3238,7 @@ linux_wait_1 (ptid_t ptid,
{
debug_printf ("linux_wait_1 ret = %s, terminated with "
"signal %d\n",
- target_pid_to_str (ptid_of (current_thread)),
+ target_pid_to_str (ptid_of (cs->ss->current_thread)),
WTERMSIG (w));
debug_exit ();
}
@@ -3226,7 +3247,7 @@ linux_wait_1 (ptid_t ptid,
if (ourstatus->kind == TARGET_WAITKIND_EXITED)
return filter_exit_event (event_child, ourstatus);
- return ptid_of (current_thread);
+ return ptid_of (cs->ss->current_thread);
}
/* If step-over executes a breakpoint instruction, in the case of a
@@ -3256,13 +3277,13 @@ linux_wait_1 (ptid_t ptid,
if (debug_threads)
{
debug_printf ("step-over for %s executed software breakpoint\n",
- target_pid_to_str (ptid_of (current_thread)));
+ target_pid_to_str (ptid_of (cs->ss->current_thread)));
}
if (increment_pc != 0)
{
struct regcache *regcache
- = get_thread_regcache (current_thread, 1);
+ = get_thread_regcache (cs->ss->current_thread, 1);
event_child->stop_pc += increment_pc;
(*the_low_target.set_pc) (regcache, event_child->stop_pc);
@@ -3337,17 +3358,17 @@ linux_wait_1 (ptid_t ptid,
if (debug_threads)
debug_printf ("Got signal %d for LWP %ld. Check if we need "
"to defer or adjust it.\n",
- WSTOPSIG (w), lwpid_of (current_thread));
+ WSTOPSIG (w), lwpid_of (cs->ss->current_thread));
/* Allow debugging the jump pad itself. */
- if (current_thread->last_resume_kind != resume_step
+ if (cs->ss->current_thread->last_resume_kind != resume_step
&& maybe_move_out_of_jump_pad (event_child, &w))
{
enqueue_one_deferred_signal (event_child, &w);
if (debug_threads)
debug_printf ("Signal %d for LWP %ld deferred (in jump pad)\n",
- WSTOPSIG (w), lwpid_of (current_thread));
+ WSTOPSIG (w), lwpid_of (cs->ss->current_thread));
linux_resume_one_lwp (event_child, 0, 0, NULL);
@@ -3363,7 +3384,7 @@ linux_wait_1 (ptid_t ptid,
if (debug_threads)
debug_printf ("LWP %ld was trying to move out of the jump pad (%d). "
"Check if we're already there.\n",
- lwpid_of (current_thread),
+ lwpid_of (cs->ss->current_thread),
(int) event_child->collecting_fast_tracepoint);
trace_event = 1;
@@ -3426,11 +3447,11 @@ linux_wait_1 (ptid_t ptid,
{
debug_printf ("linux_wait_1 ret = %s, stopped "
"while stabilizing threads\n",
- target_pid_to_str (ptid_of (current_thread)));
+ target_pid_to_str (ptid_of (cs->ss->current_thread)));
debug_exit ();
}
- return ptid_of (current_thread);
+ return ptid_of (cs->ss->current_thread);
}
}
}
@@ -3446,7 +3467,7 @@ linux_wait_1 (ptid_t ptid,
if (debug_threads)
{
debug_printf ("Ignored syscall for LWP %ld.\n",
- lwpid_of (current_thread));
+ lwpid_of (cs->ss->current_thread));
}
linux_resume_one_lwp (event_child, event_child->stepping,
@@ -3466,7 +3487,7 @@ linux_wait_1 (ptid_t ptid,
handler. Also never ignore signals that could be caused by a
breakpoint. */
if (WIFSTOPPED (w)
- && current_thread->last_resume_kind != resume_step
+ && cs->ss->current_thread->last_resume_kind != resume_step
&& (
#if defined (USE_THREAD_DB) && !defined (__ANDROID__)
(current_process ()->priv->thread_db != NULL
@@ -3474,18 +3495,18 @@ linux_wait_1 (ptid_t ptid,
|| WSTOPSIG (w) == __SIGRTMIN + 1))
||
#endif
- (pass_signals[gdb_signal_from_host (WSTOPSIG (w))]
+ (cs->pass_signals[gdb_signal_from_host (WSTOPSIG (w))]
&& !(WSTOPSIG (w) == SIGSTOP
- && current_thread->last_resume_kind == resume_stop)
+ && cs->ss->current_thread->last_resume_kind == resume_stop)
&& !linux_wstatus_maybe_breakpoint (w))))
{
siginfo_t info, *info_p;
if (debug_threads)
debug_printf ("Ignored signal %d for LWP %ld.\n",
- WSTOPSIG (w), lwpid_of (current_thread));
+ WSTOPSIG (w), lwpid_of (cs->ss->current_thread));
- if (ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
+ if (ptrace (PTRACE_GETSIGINFO, lwpid_of (cs->ss->current_thread),
(PTRACE_TYPE_ARG3) 0, &info) == 0)
info_p = &info;
else
@@ -3534,14 +3555,14 @@ linux_wait_1 (ptid_t ptid,
left the single-step pending -- see
complete_ongoing_step_over. */
report_to_gdb = (!maybe_internal_trap
- || (current_thread->last_resume_kind == resume_step
+ || (cs->ss->current_thread->last_resume_kind == resume_step
&& !in_step_range)
|| event_child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT
|| (!in_step_range
&& !bp_explains_trap
&& !trace_event
&& !step_over_finished
- && !(current_thread->last_resume_kind == resume_continue
+ && !(cs->ss->current_thread->last_resume_kind == resume_continue
&& event_child->stop_reason == TARGET_STOPPED_BY_SINGLE_STEP))
|| (gdb_breakpoint_here (event_child->stop_pc)
&& gdb_condition_true_at_breakpoint (event_child->stop_pc)
@@ -3577,7 +3598,7 @@ linux_wait_1 (ptid_t ptid,
if (the_low_target.set_pc != NULL)
{
struct regcache *regcache
- = get_thread_regcache (current_thread, 1);
+ = get_thread_regcache (cs->ss->current_thread, 1);
(*the_low_target.set_pc) (regcache, event_child->stop_pc);
}
@@ -3596,10 +3617,10 @@ linux_wait_1 (ptid_t ptid,
there isn't single-step breakpoint if we finished stepping
over. */
if (can_software_single_step ()
- && has_single_step_breakpoints (current_thread))
+ && has_single_step_breakpoints (cs->ss->current_thread))
{
stop_all_lwps (0, event_child);
- delete_single_step_breakpoints (current_thread);
+ delete_single_step_breakpoints (cs->ss->current_thread);
unstop_all_lwps (0, event_child);
}
}
@@ -3624,7 +3645,7 @@ linux_wait_1 (ptid_t ptid,
debug_printf ("LWP %ld: extended event with waitstatus %s\n",
lwpid_of (get_lwp_thread (event_child)), str.c_str ());
}
- if (current_thread->last_resume_kind == resume_step)
+ if (cs->ss->current_thread->last_resume_kind == resume_step)
{
if (event_child->step_range_start == event_child->step_range_end)
debug_printf ("GDB wanted to single-step, reporting event.\n");
@@ -3649,10 +3670,10 @@ linux_wait_1 (ptid_t ptid,
staled memory. */
int remove_single_step_breakpoints_p = 0;
- if (non_stop)
+ if (cs->non_stop)
{
remove_single_step_breakpoints_p
- = has_single_step_breakpoints (current_thread);
+ = has_single_step_breakpoints (cs->ss->current_thread);
}
else
{
@@ -3677,10 +3698,10 @@ linux_wait_1 (ptid_t ptid,
memory. */
stop_all_lwps (0, event_child);
- if (non_stop)
+ if (cs->non_stop)
{
- gdb_assert (has_single_step_breakpoints (current_thread));
- delete_single_step_breakpoints (current_thread);
+ gdb_assert (has_single_step_breakpoints (cs->ss->current_thread));
+ delete_single_step_breakpoints (cs->ss->current_thread);
}
else
{
@@ -3697,12 +3718,12 @@ linux_wait_1 (ptid_t ptid,
if (!stabilizing_threads)
{
/* In all-stop, stop all threads. */
- if (!non_stop)
+ if (!cs->non_stop)
stop_all_lwps (0, NULL);
if (step_over_finished)
{
- if (!non_stop)
+ if (!cs->non_stop)
{
/* If we were doing a step-over, all other threads but
the stepping one had been paused in start_step_over,
@@ -3736,7 +3757,7 @@ linux_wait_1 (ptid_t ptid,
select_event_lwp (&event_child);
/* current_thread and event_child must stay in sync. */
- current_thread = get_lwp_thread (event_child);
+ cs->ss->current_thread = get_lwp_thread (event_child);
event_child->status_pending_p = 0;
w = event_child->status_pending;
@@ -3744,7 +3765,7 @@ linux_wait_1 (ptid_t ptid,
/* Stabilize threads (move out of jump pads). */
- if (!non_stop)
+ if (!cs->non_stop)
stabilize_threads ();
}
else
@@ -3781,14 +3802,14 @@ linux_wait_1 (ptid_t ptid,
it was a software breakpoint, and the client doesn't know we can
adjust the breakpoint ourselves. */
if (event_child->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
- && !swbreak_feature)
+ && !cs->swbreak_feature)
{
int decr_pc = the_low_target.decr_pc_after_break;
if (decr_pc != 0)
{
struct regcache *regcache
- = get_thread_regcache (current_thread, 1);
+ = get_thread_regcache (cs->ss->current_thread, 1);
(*the_low_target.set_pc) (regcache, event_child->stop_pc + decr_pc);
}
}
@@ -3799,7 +3820,7 @@ linux_wait_1 (ptid_t ptid,
&ourstatus->value.syscall_number);
ourstatus->kind = event_child->syscall_state;
}
- else if (current_thread->last_resume_kind == resume_stop
+ else if (cs->ss->current_thread->last_resume_kind == resume_stop
&& WSTOPSIG (w) == SIGSTOP)
{
/* A thread that has been requested to stop by GDB with vCont;t,
@@ -3807,7 +3828,7 @@ linux_wait_1 (ptid_t ptid,
SIGSTOP is an implementation detail. */
ourstatus->value.sig = GDB_SIGNAL_0;
}
- else if (current_thread->last_resume_kind == resume_stop
+ else if (cs->ss->current_thread->last_resume_kind == resume_stop
&& WSTOPSIG (w) != SIGSTOP)
{
/* A thread that has been requested to stop by GDB with vCont;t,
@@ -3824,7 +3845,7 @@ linux_wait_1 (ptid_t ptid,
if (debug_threads)
{
debug_printf ("linux_wait_1 ret = %s, %d, %d\n",
- target_pid_to_str (ptid_of (current_thread)),
+ target_pid_to_str (ptid_of (cs->ss->current_thread)),
ourstatus->kind, ourstatus->value.sig);
debug_exit ();
}
@@ -3832,7 +3853,7 @@ linux_wait_1 (ptid_t ptid,
if (ourstatus->kind == TARGET_WAITKIND_EXITED)
return filter_exit_event (event_child, ourstatus);
- return ptid_of (current_thread);
+ return ptid_of (cs->ss->current_thread);
}
/* Get rid of any pending event in the pipe. */
@@ -4013,12 +4034,13 @@ lwp_is_marked_dead (struct lwp_info *lwp)
static void
wait_for_sigstop (void)
{
+ client_state *cs = get_client_state();
struct thread_info *saved_thread;
ptid_t saved_tid;
int wstat;
int ret;
- saved_thread = current_thread;
+ saved_thread = cs->ss->current_thread;
if (saved_thread != NULL)
saved_tid = saved_thread->id;
else
@@ -4035,7 +4057,7 @@ wait_for_sigstop (void)
gdb_assert (ret == -1);
if (saved_thread == NULL || linux_thread_alive (saved_tid))
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
else
{
if (debug_threads)
@@ -4044,7 +4066,7 @@ wait_for_sigstop (void)
/* We can't change the current inferior behind GDB's back,
otherwise, a subsequent command may apply to the wrong
process. */
- current_thread = NULL;
+ cs->ss->current_thread = NULL;
}
}
@@ -4079,6 +4101,7 @@ stuck_in_jump_pad_callback (thread_info *thread)
static void
move_out_of_jump_pad_callback (thread_info *thread)
{
+ client_state *cs = get_client_state();
struct thread_info *saved_thread;
struct lwp_info *lwp = get_thread_lwp (thread);
int *wstat;
@@ -4092,8 +4115,8 @@ move_out_of_jump_pad_callback (thread_info *thread)
gdb_assert (lwp->stopped);
/* For gdb_breakpoint_here. */
- saved_thread = current_thread;
- current_thread = thread;
+ saved_thread = cs->ss->current_thread;
+ cs->ss->current_thread = thread;
wstat = lwp->status_pending_p ? &lwp->status_pending : NULL;
@@ -4123,7 +4146,7 @@ move_out_of_jump_pad_callback (thread_info *thread)
else
lwp_suspended_inc (lwp);
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
}
static bool
@@ -4205,11 +4228,12 @@ enqueue_pending_signal (struct lwp_info *lwp,
int signal, siginfo_t *info)
static void
install_software_single_step_breakpoints (struct lwp_info *lwp)
{
+ client_state *cs = get_client_state();
struct thread_info *thread = get_lwp_thread (lwp);
struct regcache *regcache = get_thread_regcache (thread, 1);
struct cleanup *old_chain = make_cleanup_restore_current_thread ();
- current_thread = thread;
+ cs->ss->current_thread = thread;
std::vector<CORE_ADDR> next_pcs = the_low_target.get_next_pcs
(regcache);
for (CORE_ADDR pc : next_pcs)
@@ -4265,6 +4289,7 @@ static void
linux_resume_one_lwp_throw (struct lwp_info *lwp,
int step, int signal, siginfo_t *info)
{
+ client_state *cs = get_client_state();
struct thread_info *thread = get_lwp_thread (lwp);
struct thread_info *saved_thread;
int ptrace_request;
@@ -4322,8 +4347,8 @@ linux_resume_one_lwp_throw (struct lwp_info *lwp,
return;
}
- saved_thread = current_thread;
- current_thread = thread;
+ saved_thread = cs->ss->current_thread;
+ cs->ss->current_thread = thread;
/* This bit needs some thinking about. If we get a signal that
we must report while a single-step reinsert is still pending,
@@ -4399,7 +4424,7 @@ linux_resume_one_lwp_throw (struct lwp_info *lwp,
if (proc->tdesc != NULL && the_low_target.get_pc != NULL)
{
- struct regcache *regcache = get_thread_regcache (current_thread, 1);
+ struct regcache *regcache = get_thread_regcache
(cs->ss->current_thread, 1);
lwp->stop_pc = (*the_low_target.get_pc) (regcache);
@@ -4453,7 +4478,7 @@ linux_resume_one_lwp_throw (struct lwp_info *lwp,
of coercing an 8 byte integer to a 4 byte pointer. */
(PTRACE_TYPE_ARG4) (uintptr_t) signal);
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
if (errno)
perror_with_name ("resuming thread");
@@ -4655,6 +4680,7 @@ resume_status_pending_p (thread_info *thread)
static bool
need_step_over_p (thread_info *thread)
{
+ client_state *cs = get_client_state();
struct lwp_info *lwp = get_thread_lwp (thread);
struct thread_info *saved_thread;
CORE_ADDR pc;
@@ -4737,8 +4763,8 @@ need_step_over_p (thread_info *thread)
return false;
}
- saved_thread = current_thread;
- current_thread = thread;
+ saved_thread = cs->ss->current_thread;
+ cs->ss->current_thread = thread;
/* We can only step over breakpoints we know about. */
if (breakpoint_here (pc) || fast_tracepoint_jump_here (pc))
@@ -4755,7 +4781,7 @@ need_step_over_p (thread_info *thread)
" GDB breakpoint at 0x%s; skipping step over\n",
lwpid_of (thread), paddress (pc));
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
return false;
}
else
@@ -4767,13 +4793,13 @@ need_step_over_p (thread_info *thread)
/* We've found an lwp that needs stepping over --- return 1 so
that find_thread stops looking. */
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
return true;
}
}
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
if (debug_threads)
debug_printf ("Need step over [LWP %ld]? No, no breakpoint found"
@@ -4796,6 +4822,7 @@ need_step_over_p (thread_info *thread)
static int
start_step_over (struct lwp_info *lwp)
{
+ client_state *cs = get_client_state();
struct thread_info *thread = get_lwp_thread (lwp);
struct thread_info *saved_thread;
CORE_ADDR pc;
@@ -4823,8 +4850,8 @@ start_step_over (struct lwp_info *lwp)
shouldn't care about. */
pc = get_pc (lwp);
- saved_thread = current_thread;
- current_thread = thread;
+ saved_thread = cs->ss->current_thread;
+ cs->ss->current_thread = thread;
lwp->bp_reinsert = pc;
uninsert_breakpoints_at (pc);
@@ -4832,7 +4859,7 @@ start_step_over (struct lwp_info *lwp)
step = single_step (lwp);
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
linux_resume_one_lwp (lwp, step, 0, NULL);
@@ -4848,14 +4875,16 @@ start_step_over (struct lwp_info *lwp)
static int
finish_step_over (struct lwp_info *lwp)
{
+ client_state *cs = get_client_state();
+
if (lwp->bp_reinsert != 0)
{
- struct thread_info *saved_thread = current_thread;
+ struct thread_info *saved_thread = cs->ss->current_thread;
if (debug_threads)
debug_printf ("Finished step over.\n");
- current_thread = get_lwp_thread (lwp);
+ cs->ss->current_thread = get_lwp_thread (lwp);
/* Reinsert any breakpoint at LWP->BP_REINSERT. Note that there
may be no breakpoint to reinsert there by now. */
@@ -4871,12 +4900,12 @@ finish_step_over (struct lwp_info *lwp)
LWP stopped while doing that. */
if (!can_hardware_single_step ())
{
- gdb_assert (has_single_step_breakpoints (current_thread));
- delete_single_step_breakpoints (current_thread);
+ gdb_assert (has_single_step_breakpoints (cs->ss->current_thread));
+ delete_single_step_breakpoints (cs->ss->current_thread);
}
step_over_bkpt = null_ptid;
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
return 1;
}
else
@@ -5036,6 +5065,7 @@ linux_resume_one_thread (thread_info *thread, bool
leave_all_stopped)
static void
linux_resume (struct thread_resume *resume_info, size_t n)
{
+ client_state *cs = get_client_state();
struct thread_info *need_step_over = NULL;
if (debug_threads)
@@ -5056,7 +5086,7 @@ linux_resume (struct thread_resume *resume_info,
size_t n)
logic to each thread individually. We consume all pending events
before considering to start a step-over (in all-stop). */
bool any_pending = false;
- if (!non_stop)
+ if (!cs->non_stop)
any_pending = find_thread (resume_status_pending_p) != NULL;
/* If there is a thread which would otherwise be resumed, which is
@@ -5327,12 +5357,13 @@ static int
regsets_fetch_inferior_registers (struct regsets_info *regsets_info,
struct regcache *regcache)
{
+ client_state *cs = get_client_state();
struct regset_info *regset;
int saw_general_regs = 0;
int pid;
struct iovec iov;
- pid = lwpid_of (current_thread);
+ pid = lwpid_of (cs->ss->current_thread);
for (regset = regsets_info->regsets; regset->size >= 0; regset++)
{
void *buf, *data;
@@ -5405,12 +5436,13 @@ static int
regsets_store_inferior_registers (struct regsets_info *regsets_info,
struct regcache *regcache)
{
+ client_state *cs = get_client_state();
struct regset_info *regset;
int saw_general_regs = 0;
int pid;
struct iovec iov;
- pid = lwpid_of (current_thread);
+ pid = lwpid_of (cs->ss->current_thread);
for (regset = regsets_info->regsets; regset->size >= 0; regset++)
{
void *buf, *data;
@@ -5531,6 +5563,7 @@ static void
fetch_register (const struct usrregs_info *usrregs,
struct regcache *regcache, int regno)
{
+ client_state *cs = get_client_state();
CORE_ADDR regaddr;
int i, size;
char *buf;
@@ -5550,7 +5583,7 @@ fetch_register (const struct usrregs_info *usrregs,
& -sizeof (PTRACE_XFER_TYPE));
buf = (char *) alloca (size);
- pid = lwpid_of (current_thread);
+ pid = lwpid_of (cs->ss->current_thread);
for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
{
errno = 0;
@@ -5579,6 +5612,7 @@ static void
store_register (const struct usrregs_info *usrregs,
struct regcache *regcache, int regno)
{
+ client_state *cs = get_client_state();
CORE_ADDR regaddr;
int i, size;
char *buf;
@@ -5604,7 +5638,7 @@ store_register (const struct usrregs_info *usrregs,
else
collect_register (regcache, regno, buf);
- pid = lwpid_of (current_thread);
+ pid = lwpid_of (cs->ss->current_thread);
for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
{
errno = 0;
@@ -5744,7 +5778,8 @@ linux_store_registers (struct regcache *regcache,
int regno)
static int
linux_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
{
- int pid = lwpid_of (current_thread);
+ client_state *cs = get_client_state();
+ int pid = lwpid_of (cs->ss->current_thread);
PTRACE_XFER_TYPE *buffer;
CORE_ADDR addr;
int count;
@@ -5833,6 +5868,7 @@ linux_read_memory (CORE_ADDR memaddr, unsigned
char *myaddr, int len)
static int
linux_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr,
int len)
{
+ client_state *cs = get_client_state();
int i;
/* Round starting address down to longword boundary. */
CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
@@ -5844,7 +5880,7 @@ linux_write_memory (CORE_ADDR memaddr, const
unsigned char *myaddr, int len)
/* Allocate buffer of that many longwords. */
PTRACE_XFER_TYPE *buffer = XALLOCAVEC (PTRACE_XFER_TYPE, count);
- int pid = lwpid_of (current_thread);
+ int pid = lwpid_of (cs->ss->current_thread);
if (len == 0)
{
@@ -5933,9 +5969,11 @@ linux_look_up_symbols (void)
static void
linux_request_interrupt (void)
{
+ client_state *cs = get_client_state();
+
/* Send a SIGINT to the process group. This acts just like the user
typed a ^C on the controlling terminal. */
- kill (-signal_pid, SIGINT);
+ kill (-cs->ss->signal_pid, SIGINT);
}
/* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
@@ -5944,9 +5982,11 @@ linux_request_interrupt (void)
static int
linux_read_auxv (CORE_ADDR offset, unsigned char *myaddr, unsigned int
len)
{
+ client_state *cs = get_client_state();
+
char filename[PATH_MAX];
int fd, n;
- int pid = lwpid_of (current_thread);
+ int pid = lwpid_of (cs->ss->current_thread);
xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
@@ -6008,7 +6048,8 @@ linux_remove_point (enum raw_bkpt_type type,
CORE_ADDR addr,
static int
linux_stopped_by_sw_breakpoint (void)
{
- struct lwp_info *lwp = get_thread_lwp (current_thread);
+ client_state *cs = get_client_state();
+ struct lwp_info *lwp = get_thread_lwp (cs->ss->current_thread);
return (lwp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT);
}
@@ -6028,7 +6069,8 @@ linux_supports_stopped_by_sw_breakpoint (void)
static int
linux_stopped_by_hw_breakpoint (void)
{
- struct lwp_info *lwp = get_thread_lwp (current_thread);
+ client_state *cs = get_client_state();
+ struct lwp_info *lwp = get_thread_lwp (cs->ss->current_thread);
return (lwp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT);
}
@@ -6059,7 +6101,8 @@ linux_supports_software_single_step (void)
static int
linux_stopped_by_watchpoint (void)
{
- struct lwp_info *lwp = get_thread_lwp (current_thread);
+ client_state *cs = get_client_state();
+ struct lwp_info *lwp = get_thread_lwp (cs->ss->current_thread);
return lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
}
@@ -6067,7 +6110,8 @@ linux_stopped_by_watchpoint (void)
static CORE_ADDR
linux_stopped_data_address (void)
{
- struct lwp_info *lwp = get_thread_lwp (current_thread);
+ client_state *cs = get_client_state();
+ struct lwp_info *lwp = get_thread_lwp (cs->ss->current_thread);
return lwp->stopped_data_address;
}
@@ -6088,7 +6132,7 @@ static int
linux_read_offsets (CORE_ADDR *text_p, CORE_ADDR *data_p)
{
unsigned long text, text_end, data;
- int pid = lwpid_of (current_thread);
+ int pid = lwpid_of (cs->ss->current_thread);
errno = 0;
@@ -6133,6 +6177,7 @@ linux_qxfer_osdata (const char *annex,
static void
siginfo_fixup (siginfo_t *siginfo, gdb_byte *inf_siginfo, int direction)
{
+ client_state *cs = get_client_state();
int done = 0;
if (the_low_target.siginfo_fixup != NULL)
@@ -6153,14 +6198,15 @@ static int
linux_xfer_siginfo (const char *annex, unsigned char *readbuf,
unsigned const char *writebuf, CORE_ADDR offset, int len)
{
+ client_state *cs = get_client_state();
int pid;
siginfo_t siginfo;
gdb_byte inf_siginfo[sizeof (siginfo_t)];
- if (current_thread == NULL)
+ if (cs->ss->current_thread == NULL)
return -1;
- pid = lwpid_of (current_thread);
+ pid = lwpid_of (cs->ss->current_thread);
if (debug_threads)
debug_printf ("%s siginfo for lwp %d.\n",
@@ -6441,7 +6487,8 @@ linux_qxfer_spu (const char *annex, unsigned char
*readbuf,
unsigned const char *writebuf,
CORE_ADDR offset, int len)
{
- long pid = lwpid_of (current_thread);
+ client_state *cs = get_client_state();
+ long pid = lwpid_of (cs->ss->current_thread);
char buf[128];
int fd = 0;
int ret = 0;
@@ -6524,7 +6571,7 @@ static int
linux_read_loadmap (const char *annex, CORE_ADDR offset,
unsigned char *myaddr, unsigned int len)
{
- int pid = lwpid_of (current_thread);
+ int pid = lwpid_of (cs->ss->current_thread);
int addr = -1;
struct target_loadmap *data = NULL;
unsigned int actual_length, copy_length;
@@ -6631,9 +6678,11 @@ linux_unpause_all (int unfreeze)
static int
linux_prepare_to_access_memory (void)
{
+ client_state *cs = get_client_state();
+
/* Neither ptrace nor /proc/PID/mem allow accessing memory through a
running LWP. */
- if (non_stop)
+ if (cs->non_stop)
linux_pause_all (1);
return 0;
}
@@ -6641,9 +6690,11 @@ linux_prepare_to_access_memory (void)
static void
linux_done_accessing_memory (void)
{
+ client_state *cs = get_client_state();
+
/* Neither ptrace nor /proc/PID/mem allow accessing memory through a
running LWP. */
- if (non_stop)
+ if (cs->non_stop)
linux_unpause_all (1);
}
@@ -6988,6 +7039,7 @@ linux_qxfer_libraries_svr4 (const char *annex,
unsigned char *readbuf,
unsigned const char *writebuf,
CORE_ADDR offset, int len)
{
+ client_state *cs = get_client_state();
char *document;
unsigned document_len;
struct process_info_private *const priv = current_process ()->priv;
@@ -7029,7 +7081,7 @@ linux_qxfer_libraries_svr4 (const char *annex,
unsigned char *readbuf,
if (readbuf == NULL)
return -1;
- pid = lwpid_of (current_thread);
+ pid = lwpid_of (cs->ss->current_thread);
xsnprintf (filename, sizeof filename, "/proc/%d/exe", pid);
is_elf64 = elf_64_file_p (filename, &machine);
lmo = is_elf64 ? &lmo_64bit_offsets : &lmo_32bit_offsets;
@@ -7367,7 +7419,9 @@ linux_low_btrace_conf (const struct
btrace_target_info *tinfo,
ptid_t
current_lwp_ptid (void)
{
- return ptid_of (current_thread);
+ client_state *cs = get_client_state();
+
+ return ptid_of (cs->ss->current_thread);
}
/* Implementation of the target_ops method "breakpoint_kind_from_pc". */
diff --git a/gdb/gdbserver/linux-mips-low.c b/gdb/gdbserver/linux-mips-low.c
index d423633747a..9054d560157 100644
--- a/gdb/gdbserver/linux-mips-low.c
+++ b/gdb/gdbserver/linux-mips-low.c
@@ -126,7 +126,7 @@ mips_read_description (void)
{
if (have_dsp < 0)
{
- int pid = lwpid_of (current_thread);
+ int pid = lwpid_of (cs->ss->current_thread);
errno = 0;
ptrace (PTRACE_PEEKUSER, pid, DSP_CONTROL, 0);
@@ -467,7 +467,7 @@ mips_insert_point (enum raw_bkpt_type type,
CORE_ADDR addr,
enum target_hw_bp_type watch_type;
uint32_t irw;
- lwpid = lwpid_of (current_thread);
+ lwpid = lwpid_of (cs->ss->current_thread);
if (!mips_linux_read_watch_registers (lwpid,
&priv->watch_readback,
&priv->watch_readback_valid,
@@ -558,7 +558,7 @@ mips_stopped_by_watchpoint (void)
struct arch_process_info *priv = proc->priv->arch_private;
int n;
int num_valid;
- long lwpid = lwpid_of (current_thread);
+ long lwpid = lwpid_of (cs->ss->current_thread);
if (!mips_linux_read_watch_registers (lwpid,
&priv->watch_readback,
@@ -586,7 +586,7 @@ mips_stopped_data_address (void)
struct arch_process_info *priv = proc->priv->arch_private;
int n;
int num_valid;
- long lwpid = lwpid_of (current_thread);
+ long lwpid = lwpid_of (cs->ss->current_thread);
/* On MIPS we don't know the low order 3 bits of the data address.
GDB does not support remote targets that can't report the
diff --git a/gdb/gdbserver/linux-ppc-low.c b/gdb/gdbserver/linux-ppc-low.c
index 36bd373c885..35557ab582c 100644
--- a/gdb/gdbserver/linux-ppc-low.c
+++ b/gdb/gdbserver/linux-ppc-low.c
@@ -1272,7 +1272,7 @@ ppc_install_fast_tracepoint_jump_pad (CORE_ADDR
tpoint, CORE_ADDR tpaddr,
const CORE_ADDR entryaddr = *jump_entry;
int rsz, min_frame, frame_size, tp_reg;
#ifdef __powerpc64__
- struct regcache *regcache = get_thread_regcache (current_thread, 0);
+ struct regcache *regcache = get_thread_regcache
(cs->ss->current_thread, 0);
int is_64 = register_size (regcache->tdesc, 0) == 8;
int is_opd = is_64 && !is_elfv2_inferior ();
#else
@@ -3044,7 +3044,7 @@ static struct emit_ops *
ppc_emit_ops (void)
{
#ifdef __powerpc64__
- struct regcache *regcache = get_thread_regcache (current_thread, 0);
+ struct regcache *regcache = get_thread_regcache
(cs->ss->current_thread, 0);
if (register_size (regcache->tdesc, 0) == 8)
{
@@ -3062,7 +3062,7 @@ ppc_emit_ops (void)
static int
ppc_get_ipa_tdesc_idx (void)
{
- struct regcache *regcache = get_thread_regcache (current_thread, 0);
+ struct regcache *regcache = get_thread_regcache
(cs->ss->current_thread, 0);
const struct target_desc *tdesc = regcache->tdesc;
#ifdef __powerpc64__
diff --git a/gdb/gdbserver/linux-s390-low.c b/gdb/gdbserver/linux-s390-low.c
index 451f42c7c99..d5828549620 100644
--- a/gdb/gdbserver/linux-s390-low.c
+++ b/gdb/gdbserver/linux-s390-low.c
@@ -541,7 +541,7 @@ s390_arch_setup (void)
struct regset_info *regset;
/* Check whether the kernel supports extra register sets. */
- int pid = pid_of (current_thread);
+ int pid = pid_of (cs->ss->current_thread);
int have_regset_last_break
= s390_check_regset (pid, NT_S390_LAST_BREAK, 8);
int have_regset_system_call
@@ -770,7 +770,7 @@ s390_get_thread_area (int lwpid, CORE_ADDR *addrp)
{
CORE_ADDR res = ptrace (PTRACE_PEEKUSER, lwpid, (long) PT_ACR0,
(long) 0);
#ifdef __s390x__
- struct regcache *regcache = get_thread_regcache (current_thread, 0);
+ struct regcache *regcache = get_thread_regcache
(cs->ss->current_thread, 0);
if (register_size (regcache->tdesc, 0) == 4)
res &= 0xffffffffull;
@@ -1260,7 +1260,7 @@ s390_install_fast_tracepoint_jump_pad (CORE_ADDR
tpoint,
unsigned char jbuf[6] = { 0xc0, 0xf4, 0, 0, 0, 0 }; /* jg ... */
CORE_ADDR buildaddr = *jump_entry;
#ifdef __s390x__
- struct regcache *regcache = get_thread_regcache (current_thread, 0);
+ struct regcache *regcache = get_thread_regcache
(cs->ss->current_thread, 0);
int is_64 = register_size (regcache->tdesc, 0) == 8;
int is_zarch = is_64 || have_hwcap_s390_high_gprs;
int has_vx = have_hwcap_s390_vx;
@@ -1425,7 +1425,7 @@ s390_get_min_fast_tracepoint_insn_len (void)
static int
s390_get_ipa_tdesc_idx (void)
{
- struct regcache *regcache = get_thread_regcache (current_thread, 0);
+ struct regcache *regcache = get_thread_regcache
(cs->ss->current_thread, 0);
const struct target_desc *tdesc = regcache->tdesc;
#ifdef __s390x__
@@ -2798,7 +2798,7 @@ static struct emit_ops *
s390_emit_ops (void)
{
#ifdef __s390x__
- struct regcache *regcache = get_thread_regcache (current_thread, 0);
+ struct regcache *regcache = get_thread_regcache
(cs->ss->current_thread, 0);
if (register_size (regcache->tdesc, 0) == 8)
return &s390x_emit_ops;
diff --git a/gdb/gdbserver/linux-tile-low.c b/gdb/gdbserver/linux-tile-low.c
index 620f61d1707..dafbab674ef 100644
--- a/gdb/gdbserver/linux-tile-low.c
+++ b/gdb/gdbserver/linux-tile-low.c
@@ -150,7 +150,7 @@ tile_regs_info (void)
static void
tile_arch_setup (void)
{
- int pid = pid_of (current_thread);
+ int pid = pid_of (cs->ss->current_thread);
unsigned int machine;
int is_elf64 = linux_pid_exe_is_elf_64_file (pid, &machine);
diff --git a/gdb/gdbserver/linux-x86-low.c b/gdb/gdbserver/linux-x86-low.c
index 408b54f2577..2fa464e889e 100644
--- a/gdb/gdbserver/linux-x86-low.c
+++ b/gdb/gdbserver/linux-x86-low.c
@@ -181,7 +181,8 @@ static /*const*/ int i386_regmap[] =
static int
is_64bit_tdesc (void)
{
- struct regcache *regcache = get_thread_regcache (current_thread, 0);
+ client_state *cs = get_client_state();
+ struct regcache *regcache = get_thread_regcache
(cs->ss->current_thread, 0);
return register_size (regcache->tdesc, 0) == 8;
}
@@ -304,6 +305,7 @@ x86_cannot_fetch_register (int regno)
static void
x86_fill_gregset (struct regcache *regcache, void *buf)
{
+ client_state *cs = get_client_state();
int i;
#ifdef __x86_64__
@@ -316,7 +318,7 @@ x86_fill_gregset (struct regcache *regcache, void *buf)
#ifndef HAVE_STRUCT_USER_REGS_STRUCT_FS_BASE
{
unsigned long base;
- int lwpid = lwpid_of (current_thread);
+ int lwpid = lwpid_of (cs->ss->current_thread);
collect_register_by_name (regcache, "fs_base", &base);
ptrace (PTRACE_ARCH_PRCTL, lwpid, &base, ARCH_SET_FS);
@@ -344,6 +346,7 @@ x86_fill_gregset (struct regcache *regcache, void *buf)
static void
x86_store_gregset (struct regcache *regcache, const void *buf)
{
+ client_state *cs = get_client_state();
int i;
#ifdef __x86_64__
@@ -356,7 +359,7 @@ x86_store_gregset (struct regcache *regcache, const
void *buf)
#ifndef HAVE_STRUCT_USER_REGS_STRUCT_FS_BASE
{
unsigned long base;
- int lwpid = lwpid_of (current_thread);
+ int lwpid = lwpid_of (cs->ss->current_thread);
if (ptrace (PTRACE_ARCH_PRCTL, lwpid, &base, ARCH_GET_FS) == 0)
supply_register_by_name (regcache, "fs_base", &base);
@@ -679,8 +682,9 @@ static int
x86_siginfo_fixup (siginfo_t *ptrace, gdb_byte *inf, int direction)
{
#ifdef __x86_64__
+ client_state *cs = get_client_state();
unsigned int machine;
- int tid = lwpid_of (current_thread);
+ int tid = lwpid_of (cs->ss->current_thread);
int is_elf64 = linux_pid_exe_is_elf_64_file (tid, &machine);
/* Is the inferior 32-bit? If so, then fixup the siginfo object. */
@@ -735,6 +739,7 @@ int have_ptrace_getfpxregs =
static const struct target_desc *
x86_linux_read_description (void)
{
+ client_state *cs = get_client_state();
unsigned int machine;
int is_elf64;
int xcr0_features;
@@ -742,7 +747,7 @@ x86_linux_read_description (void)
static uint64_t xcr0;
struct regset_info *regset;
- tid = lwpid_of (current_thread);
+ tid = lwpid_of (cs->ss->current_thread);
is_elf64 = linux_pid_exe_is_elf_64_file (tid, &machine);
@@ -860,7 +865,8 @@ x86_linux_read_description (void)
static void
x86_linux_update_xmltarget (void)
{
- struct thread_info *saved_thread = current_thread;
+ client_state *cs = get_client_state();
+ struct thread_info *saved_thread = cs->ss->current_thread;
/* Before changing the register cache's internal layout, flush the
contents of the current valid caches back to the threads, and
@@ -868,15 +874,16 @@ x86_linux_update_xmltarget (void)
regcache_release ();
for_each_process ([] (process_info *proc) {
+ client_state *cs = get_client_state();
int pid = proc->pid;
/* Look up any thread of this process. */
- current_thread = find_any_thread_of_pid (pid);
+ cs->ss->current_thread = find_any_thread_of_pid (pid);
the_low_target.arch_setup ();
});
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
}
/* Process qSupported query, "xmlRegisters=". Update the buffer size for
@@ -2824,7 +2831,8 @@ x86_supports_hardware_single_step (void)
static int
x86_get_ipa_tdesc_idx (void)
{
- struct regcache *regcache = get_thread_regcache (current_thread, 0);
+ client_state *cs = get_client_state();
+ struct regcache *regcache = get_thread_regcache
(cs->ss->current_thread, 0);
const struct target_desc *tdesc = regcache->tdesc;
#ifdef __x86_64__
diff --git a/gdb/gdbserver/lynx-low.c b/gdb/gdbserver/lynx-low.c
index a0b98177296..4e72721498b 100644
--- a/gdb/gdbserver/lynx-low.c
+++ b/gdb/gdbserver/lynx-low.c
@@ -250,10 +250,10 @@ lynx_ptrace_fun ()
static int
lynx_create_inferior (const char *program,
- const std::vector<char *> &program_args)
+ const std::vector<char *> &cs->program_args)
{
int pid;
- std::string str_program_args = stringify_argv (program_args);
+ std::string str_program_args = stringify_argv (cs->program_args);
lynx_debug ("lynx_create_inferior ()");
@@ -350,7 +350,7 @@ lynx_resume (struct thread_resume *resume_info,
size_t n)
the moment we resume its execution for the first time. It is
fine to use the current_thread's ptid in those cases. */
if (ptid_equal (ptid, minus_one_ptid))
- ptid = ptid_of (current_thread);
+ ptid = ptid_of (cs->ss->current_thread);
regcache_invalidate_pid (ptid_get_pid (ptid));
@@ -423,7 +423,7 @@ lynx_wait_1 (ptid_t ptid, struct target_waitstatus
*status, int options)
ptid_t new_ptid;
if (ptid_equal (ptid, minus_one_ptid))
- pid = lynx_ptid_get_pid (ptid_of (current_thread));
+ pid = lynx_ptid_get_pid (ptid_of (cs->ss->current_thread));
else
pid = BUILDPID (lynx_ptid_get_pid (ptid), lynx_ptid_get_tid (ptid));
@@ -594,7 +594,7 @@ static void
lynx_fetch_registers (struct regcache *regcache, int regno)
{
struct lynx_regset_info *regset = lynx_target_regsets;
- ptid_t inferior_ptid = ptid_of (current_thread);
+ ptid_t inferior_ptid = ptid_of (cs->ss->current_thread);
lynx_debug ("lynx_fetch_registers (regno = %d)", regno);
@@ -619,7 +619,7 @@ static void
lynx_store_registers (struct regcache *regcache, int regno)
{
struct lynx_regset_info *regset = lynx_target_regsets;
- ptid_t inferior_ptid = ptid_of (current_thread);
+ ptid_t inferior_ptid = ptid_of (cs->ss->current_thread);
lynx_debug ("lynx_store_registers (regno = %d)", regno);
@@ -655,7 +655,7 @@ lynx_read_memory (CORE_ADDR memaddr, unsigned char
*myaddr, int len)
int buf;
const int xfer_size = sizeof (buf);
CORE_ADDR addr = memaddr & -(CORE_ADDR) xfer_size;
- ptid_t inferior_ptid = ptid_of (current_thread);
+ ptid_t inferior_ptid = ptid_of (cs->ss->current_thread);
while (addr < memaddr + len)
{
@@ -688,7 +688,7 @@ lynx_write_memory (CORE_ADDR memaddr, const unsigned
char *myaddr, int len)
int buf;
const int xfer_size = sizeof (buf);
CORE_ADDR addr = memaddr & -(CORE_ADDR) xfer_size;
- ptid_t inferior_ptid = ptid_of (current_thread);
+ ptid_t inferior_ptid = ptid_of (cs->ss->current_thread);
while (addr < memaddr + len)
{
diff --git a/gdb/gdbserver/mem-break.c b/gdb/gdbserver/mem-break.c
index bb385733fe4..dca4756bacd 100644
--- a/gdb/gdbserver/mem-break.c
+++ b/gdb/gdbserver/mem-break.c
@@ -1301,6 +1301,8 @@ add_breakpoint_condition (struct gdb_breakpoint
*bp, const char **condition)
static int
gdb_condition_true_at_breakpoint_z_type (char z_type, CORE_ADDR addr)
{
+ client_state *cs = get_client_state();
+
/* Fetch registers for the current inferior. */
struct gdb_breakpoint *bp = find_gdb_breakpoint (z_type, addr, -1);
ULONGEST value = 0;
@@ -1316,7 +1318,7 @@ gdb_condition_true_at_breakpoint_z_type (char
z_type, CORE_ADDR addr)
if (bp->cond_list == NULL)
return 1;
- ctx.regcache = get_thread_regcache (current_thread, 1);
+ ctx.regcache = get_thread_regcache (cs->ss->current_thread, 1);
ctx.tframe = NULL;
ctx.tpoint = NULL;
@@ -1429,6 +1431,8 @@ gdb_no_commands_at_breakpoint (CORE_ADDR where)
static int
run_breakpoint_commands_z_type (char z_type, CORE_ADDR addr)
{
+ client_state *cs = get_client_state();
+
/* Fetch registers for the current inferior. */
struct gdb_breakpoint *bp = find_gdb_breakpoint (z_type, addr, -1);
ULONGEST value = 0;
@@ -1439,7 +1443,7 @@ run_breakpoint_commands_z_type (char z_type,
CORE_ADDR addr)
if (bp == NULL)
return 1;
- ctx.regcache = get_thread_regcache (current_thread, 1);
+ ctx.regcache = get_thread_regcache (cs->ss->current_thread, 1);
ctx.tframe = NULL;
ctx.tpoint = NULL;
@@ -1479,6 +1483,7 @@ gdb_breakpoint_here (CORE_ADDR where)
void
set_single_step_breakpoint (CORE_ADDR stop_at, ptid_t ptid)
{
+ client_state *cs = get_client_state();
struct single_step_breakpoint *bp;
gdb_assert (ptid_get_pid (current_ptid) == ptid_get_pid (ptid));
@@ -1491,6 +1496,7 @@ set_single_step_breakpoint (CORE_ADDR stop_at,
ptid_t ptid)
void
delete_single_step_breakpoints (struct thread_info *thread)
{
+ client_state *cs = get_client_state();
struct process_info *proc = get_thread_process (thread);
struct breakpoint *bp, **bp_link;
@@ -1503,13 +1509,13 @@ delete_single_step_breakpoints (struct
thread_info *thread)
&& ptid_equal (((struct single_step_breakpoint *) bp)->ptid,
ptid_of (thread)))
{
- struct thread_info *saved_thread = current_thread;
+ struct thread_info *saved_thread = cs->ss->current_thread;
- current_thread = thread;
+ cs->ss->current_thread = thread;
*bp_link = bp->next;
release_breakpoint (proc, bp);
bp = *bp_link;
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
}
else
{
@@ -1591,6 +1597,7 @@ uninsert_all_breakpoints (void)
void
uninsert_single_step_breakpoints (struct thread_info *thread)
{
+ client_state *cs = get_client_state();
struct process_info *proc = get_thread_process (thread);
struct breakpoint *bp;
@@ -1606,11 +1613,11 @@ uninsert_single_step_breakpoints (struct
thread_info *thread)
reinsert breakpoint. */
if (bp->raw->refcount == 1)
{
- struct thread_info *saved_thread = current_thread;
+ struct thread_info *saved_thread = cs->ss->current_thread;
- current_thread = thread;
+ cs->ss->current_thread = thread;
uninsert_raw_breakpoint (bp->raw);
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
}
}
}
@@ -1701,6 +1708,7 @@ reinsert_all_breakpoints (void)
void
reinsert_single_step_breakpoints (struct thread_info *thread)
{
+ client_state *cs = get_client_state();
struct process_info *proc = get_thread_process (thread);
struct breakpoint *bp;
@@ -1714,11 +1722,11 @@ reinsert_single_step_breakpoints (struct
thread_info *thread)
if (bp->raw->refcount == 1)
{
- struct thread_info *saved_thread = current_thread;
+ struct thread_info *saved_thread = cs->ss->current_thread;
- current_thread = thread;
+ cs->ss->current_thread = thread;
reinsert_raw_breakpoint (bp->raw);
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
}
}
}
diff --git a/gdb/gdbserver/notif.c b/gdb/gdbserver/notif.c
index 5ff7079123f..b2ca4b50207 100644
--- a/gdb/gdbserver/notif.c
+++ b/gdb/gdbserver/notif.c
@@ -79,6 +79,7 @@ notif_write_event (struct notif_server *notif, char
*own_buf)
int
handle_notif_ack (char *own_buf, int packet_len)
{
+ client_state *cs = get_client_state();
size_t i;
struct notif_server *np;
@@ -103,7 +104,7 @@ handle_notif_ack (char *own_buf, int packet_len)
struct notif_event *head
= QUEUE_deque (notif_event_p, np->queue);
- if (remote_debug)
+ if (cs->remote_debug)
debug_printf ("%s: acking %d\n", np->ack_name,
QUEUE_length (notif_event_p, np->queue));
@@ -121,9 +122,11 @@ void
notif_event_enque (struct notif_server *notif,
struct notif_event *event)
{
+ client_state *cs = get_client_state();
+
QUEUE_enque (notif_event_p, notif->queue, event);
- if (remote_debug)
+ if (cs->remote_debug)
debug_printf ("pending events: %s %d\n", notif->notif_name,
QUEUE_length (notif_event_p, notif->queue));
diff --git a/gdb/gdbserver/nto-low.c b/gdb/gdbserver/nto-low.c
index a570ca9991c..02c5ece47d2 100644
--- a/gdb/gdbserver/nto-low.c
+++ b/gdb/gdbserver/nto-low.c
@@ -352,12 +352,12 @@ nto_read_auxv_from_initial_stack (CORE_ADDR
initial_stack,
static int
nto_create_inferior (const char *program,
- const std::vector<char *> &program_args)
+ const std::vector<char *> &cs->program_args)
{
struct inheritance inherit;
pid_t pid;
sigset_t set;
- std::string str_program_args = stringify_argv (program_args);
+ std::string str_program_args = stringify_argv (cs->program_args);
TRACE ("%s %s\n", __func__, program);
/* Clear any pending SIGUSR1's but keep the behavior the same. */
@@ -625,12 +625,12 @@ nto_fetch_registers (struct regcache *regcache,
int regno)
if (regno >= the_low_target.num_regs)
return;
- if (current_thread == NULL)
+ if (cs->ss->current_thread == NULL)
{
TRACE ("current_thread is NULL\n");
return;
}
- ptid_t ptid = ptid_of (current_thread);
+ ptid_t ptid = ptid_of (cs->ss->current_thread);
if (!nto_set_thread (ptid))
return;
@@ -671,12 +671,12 @@ nto_store_registers (struct regcache *regcache,
int regno)
TRACE ("%s (regno:%d)\n", __func__, regno);
- if (current_thread == NULL)
+ if (cs->ss->current_thread == NULL)
{
TRACE ("current_thread is NULL\n");
return;
}
- ptid_t ptid = ptid_of (current_thread);
+ ptid_t ptid = ptid_of (cs->ss->current_thread);
if (!nto_set_thread (ptid))
return;
@@ -863,9 +863,9 @@ nto_stopped_by_watchpoint (void)
int ret = 0;
TRACE ("%s\n", __func__);
- if (nto_inferior.ctl_fd != -1 && current_thread != NULL)
+ if (nto_inferior.ctl_fd != -1 && cs->ss->current_thread != NULL)
{
- ptid_t ptid = ptid_of (current_thread);
+ ptid_t ptid = ptid_of (cs->ss->current_thread);
if (nto_set_thread (ptid))
{
const int watchmask = _DEBUG_FLAG_TRACE_RD | _DEBUG_FLAG_TRACE_WR
@@ -893,9 +893,9 @@ nto_stopped_data_address (void)
CORE_ADDR ret = (CORE_ADDR)0;
TRACE ("%s\n", __func__);
- if (nto_inferior.ctl_fd != -1 && current_thread != NULL)
+ if (nto_inferior.ctl_fd != -1 && cs->ss->current_thread != NULL)
{
- ptid_t ptid = ptid_of (current_thread);
+ ptid_t ptid = ptid_of (cs->ss->current_thread);
if (nto_set_thread (ptid))
{
diff --git a/gdb/gdbserver/proc-service.c b/gdb/gdbserver/proc-service.c
index f7912b884c5..01a9371465a 100644
--- a/gdb/gdbserver/proc-service.c
+++ b/gdb/gdbserver/proc-service.c
@@ -104,6 +104,7 @@ ps_err_e
ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
{
#ifdef HAVE_REGSETS
+ client_state *cs = get_client_state();
struct lwp_info *lwp;
struct thread_info *reg_thread, *saved_thread;
struct regcache *regcache;
@@ -113,12 +114,12 @@ ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t
lwpid, prgregset_t gregset)
return PS_ERR;
reg_thread = get_lwp_thread (lwp);
- saved_thread = current_thread;
- current_thread = reg_thread;
- regcache = get_thread_regcache (current_thread, 1);
+ saved_thread = cs->ss->current_thread;
+ cs->ss->current_thread = reg_thread;
+ regcache = get_thread_regcache (cs->ss->current_thread, 1);
gregset_info ()->fill_function (regcache, gregset);
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
return PS_OK;
#else
return PS_ERR;
@@ -161,5 +162,7 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t
lwpid, const prfpregset_t *fpregs
pid_t
ps_getpid (gdb_ps_prochandle_t ph)
{
- return pid_of (current_thread);
+ client_state *cs = get_client_state();
+
+ return pid_of (cs->ss->current_thread);
}
diff --git a/gdb/gdbserver/regcache.c b/gdb/gdbserver/regcache.c
index 1bb15900dd2..0ae73fb78e8 100644
--- a/gdb/gdbserver/regcache.c
+++ b/gdb/gdbserver/regcache.c
@@ -26,6 +26,7 @@
struct regcache *
get_thread_regcache (struct thread_info *thread, int fetch)
{
+ client_state *cs = get_client_state();
struct regcache *regcache;
regcache = thread_regcache_data (thread);
@@ -49,14 +50,14 @@ get_thread_regcache (struct thread_info *thread, int
fetch)
if (fetch && regcache->registers_valid == 0)
{
- struct thread_info *saved_thread = current_thread;
+ struct thread_info *saved_thread = cs->ss->current_thread;
- current_thread = thread;
+ cs->ss->current_thread = thread;
/* Invalidate all registers, to prevent stale left-overs. */
memset (regcache->register_status, REG_UNAVAILABLE,
regcache->tdesc->reg_defs.size ());
fetch_inferior_registers (regcache, -1);
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
regcache->registers_valid = 1;
}
@@ -74,6 +75,7 @@ get_thread_regcache_for_ptid (ptid_t ptid)
void
regcache_invalidate_thread (struct thread_info *thread)
{
+ client_state *cs = get_client_state();
struct regcache *regcache;
regcache = thread_regcache_data (thread);
@@ -83,11 +85,11 @@ regcache_invalidate_thread (struct thread_info *thread)
if (regcache->registers_valid)
{
- struct thread_info *saved_thread = current_thread;
+ struct thread_info *saved_thread = cs->ss->current_thread;
- current_thread = thread;
+ cs->ss->current_thread = thread;
store_inferior_registers (regcache, -1);
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
}
regcache->registers_valid = 0;
@@ -107,8 +109,10 @@ regcache_invalidate_pid (int pid)
void
regcache_invalidate (void)
{
+ client_state *cs = get_client_state();
+
/* Only update the threads of the current process. */
- int pid = current_thread->id.pid ();
+ int pid = cs->ss->current_thread->id.pid ();
regcache_invalidate_pid (pid);
}
diff --git a/gdb/gdbserver/remote-utils.c b/gdb/gdbserver/remote-utils.c
index 3b5a459ae4c..99ba97c02ca 100644
--- a/gdb/gdbserver/remote-utils.c
+++ b/gdb/gdbserver/remote-utils.c
@@ -103,7 +103,6 @@ struct sym_cache
struct sym_cache *next;
};
-int remote_debug = 0;
struct ui_file *gdb_stdlog;
static int remote_is_stdio = 0;
@@ -115,16 +114,18 @@ static gdb_fildes_t listen_desc = INVALID_DESCRIPTOR;
extern int using_threads;
extern int debug_threads;
-/* If true, then GDB has requested noack mode. */
-int noack_mode = 0;
-/* If true, then we tell GDB to use noack mode by default. */
-int transport_is_reliable = 0;
-
#ifdef USE_WIN32API
# define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
# define write(fd, buf, len) send (fd, (char *) buf, len, 0)
#endif
+int
+get_remote_desc (void)
+{
+ return remote_desc;
+}
+
+
int
gdb_connected (void)
{
@@ -156,6 +157,7 @@ enable_async_notification (int fd)
static int
handle_accept_event (int err, gdb_client_data client_data)
{
+ client_state *cs = get_client_state();
struct sockaddr_in sockaddr;
socklen_t tmp;
@@ -167,6 +169,9 @@ handle_accept_event (int err, gdb_client_data
client_data)
if (remote_desc == -1)
perror_with_name ("Accept failed");
+ struct multi_client_states *client_states = get_client_states();
+ client_states->set_client_state (remote_desc);
+
/* Enable TCP keep alive process. */
tmp = 1;
setsockopt (remote_desc, SOL_SOCKET, SO_KEEPALIVE,
@@ -183,7 +188,7 @@ handle_accept_event (int err, gdb_client_data
client_data)
exits when the remote side dies. */
#endif
- if (run_once)
+ if (cs->run_once)
{
#ifndef USE_WIN32API
close (listen_desc); /* No longer need this */
@@ -222,6 +227,7 @@ handle_accept_event (int err, gdb_client_data
client_data)
void
remote_prepare (const char *name)
{
+ client_state *cs = get_client_state();
const char *port_str;
#ifdef USE_WIN32API
static int winsock_initialized;
@@ -238,14 +244,14 @@ remote_prepare (const char *name)
call to remote_open so start_inferior knows the connection is
via stdio. */
remote_is_stdio = 1;
- transport_is_reliable = 1;
+ cs->transport_is_reliable = 1;
return;
}
port_str = strchr (name, ':');
if (port_str == NULL)
{
- transport_is_reliable = 0;
+ cs->transport_is_reliable = 0;
return;
}
@@ -280,7 +286,7 @@ remote_prepare (const char *name)
|| listen (listen_desc, 1))
perror_with_name ("Can't bind address");
- transport_is_reliable = 1;
+ cs->transport_is_reliable = 1;
}
/* Open a connection to a remote debugger.
@@ -485,9 +491,10 @@ try_rle (char *buf, int remaining, unsigned char
*csum, char **p)
char *
write_ptid (char *buf, ptid_t ptid)
{
+ client_state *cs = get_client_state();
int pid, tid;
- if (multi_process)
+ if (cs->multi_process)
{
pid = ptid_get_pid (ptid);
if (pid < 0)
@@ -594,6 +601,7 @@ read_prim (void *buf, int count)
static int
putpkt_binary_1 (char *buf, int cnt, int is_notif)
{
+ client_state *cs = get_client_state();
int i;
unsigned char csum = 0;
char *buf2;
@@ -631,10 +639,10 @@ putpkt_binary_1 (char *buf, int cnt, int is_notif)
return -1;
}
- if (noack_mode || is_notif)
+ if (cs->noack_mode || is_notif)
{
/* Don't expect an ack then. */
- if (remote_debug)
+ if (cs->remote_debug)
{
if (is_notif)
debug_printf ("putpkt (\"%s\"); [notif]\n", buf2);
@@ -645,7 +653,7 @@ putpkt_binary_1 (char *buf, int cnt, int is_notif)
break;
}
- if (remote_debug)
+ if (cs->remote_debug)
{
debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2);
debug_flush ();
@@ -659,14 +667,14 @@ putpkt_binary_1 (char *buf, int cnt, int is_notif)
return -1;
}
- if (remote_debug)
+ if (cs->remote_debug)
{
debug_printf ("[received '%c' (0x%x)]\n", cc, cc);
debug_flush ();
}
/* Check for an input interrupt while we're here. */
- if (cc == '\003' && current_thread != NULL)
+ if (cc == '\003' && cs->ss->current_thread != NULL)
(*the_target->request_interrupt) ();
}
while (cc != '+');
@@ -838,30 +846,23 @@ initialize_async_io (void)
#endif
}
-/* Internal buffer used by readchar.
- These are global to readchar because reschedule_remote needs to be
- able to tell whether the buffer is empty. */
-
-static unsigned char readchar_buf[BUFSIZ];
-static int readchar_bufcnt = 0;
-static unsigned char *readchar_bufp;
-
/* Returns next char from remote GDB. -1 if error. */
static int
readchar (void)
{
+ client_state *cs = get_client_state();
int ch;
- if (readchar_bufcnt == 0)
+ if (cs->ss->readchar_bufcnt == 0)
{
- readchar_bufcnt = read_prim (readchar_buf, sizeof (readchar_buf));
+ cs->ss->readchar_bufcnt = read_prim (cs->ss->readchar_buf, sizeof
(cs->ss->readchar_buf));
- if (readchar_bufcnt <= 0)
+ if (cs->ss->readchar_bufcnt <= 0)
{
- if (readchar_bufcnt == 0)
+ if (cs->ss->readchar_bufcnt == 0)
{
- if (remote_debug)
+ if (cs->remote_debug)
debug_printf ("readchar: Got EOF\n");
}
else
@@ -870,11 +871,11 @@ readchar (void)
return -1;
}
- readchar_bufp = readchar_buf;
+ cs->ss->readchar_bufp = cs->ss->readchar_buf;
}
- readchar_bufcnt--;
- ch = *readchar_bufp++;
+ cs->ss->readchar_bufcnt--;
+ ch = *cs->ss->readchar_bufp++;
reschedule ();
return ch;
}
@@ -884,7 +885,9 @@ readchar (void)
static void
reset_readchar (void)
{
- readchar_bufcnt = 0;
+ client_state *cs = get_client_state();
+
+ cs->ss->readchar_bufcnt = 0;
if (readchar_callback != NOT_SCHEDULED)
{
delete_callback_event (readchar_callback);
@@ -897,12 +900,13 @@ reset_readchar (void)
static int
process_remaining (void *context)
{
+ client_state *cs = get_client_state();
int res;
/* This is a one-shot event. */
readchar_callback = NOT_SCHEDULED;
- if (readchar_bufcnt > 0)
+ if (cs->ss->readchar_bufcnt > 0)
res = handle_serial_event (0, NULL);
else
res = 0;
@@ -916,7 +920,9 @@ process_remaining (void *context)
static void
reschedule (void)
{
- if (readchar_bufcnt > 0 && readchar_callback == NOT_SCHEDULED)
+ client_state *cs = get_client_state();
+
+ if (cs->ss->readchar_bufcnt > 0 && readchar_callback == NOT_SCHEDULED)
readchar_callback = append_callback_event (process_remaining, NULL);
}
@@ -926,6 +932,7 @@ reschedule (void)
int
getpkt (char *buf)
{
+ client_state *cs = get_client_state();
char *bp;
unsigned char csum, c1, c2;
int c;
@@ -948,7 +955,7 @@ getpkt (char *buf)
if (c == '$')
break;
- if (remote_debug)
+ if (cs->remote_debug)
{
debug_printf ("[getpkt: discarding char '%c']\n", c);
debug_flush ();
@@ -977,7 +984,7 @@ getpkt (char *buf)
if (csum == (c1 << 4) + c2)
break;
- if (noack_mode)
+ if (cs->noack_mode)
{
fprintf (stderr,
"Bad checksum, sentsum=0x%x, csum=0x%x, "
@@ -993,9 +1000,9 @@ getpkt (char *buf)
return -1;
}
- if (!noack_mode)
+ if (!cs->noack_mode)
{
- if (remote_debug)
+ if (cs->remote_debug)
{
debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf);
debug_flush ();
@@ -1004,7 +1011,7 @@ getpkt (char *buf)
if (write_prim ("+", 1) != 1)
return -1;
- if (remote_debug)
+ if (cs->remote_debug)
{
debug_printf ("[sent ack]\n");
debug_flush ();
@@ -1012,7 +1019,7 @@ getpkt (char *buf)
}
else
{
- if (remote_debug)
+ if (cs->remote_debug)
{
debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf);
debug_flush ();
@@ -1028,7 +1035,7 @@ getpkt (char *buf)
check for interrupt after the vCont;c packet, the interrupt character
would stay in the buffer unattended until after the next (unrelated)
stop. */
- while (readchar_bufcnt > 0 && *readchar_bufp == '\003')
+ while (cs->ss->readchar_bufcnt > 0 && *cs->ss->readchar_bufp == '\003')
{
/* Consume the interrupt character in the buffer. */
readchar ();
@@ -1081,6 +1088,8 @@ void
prepare_resume_reply (char *buf, ptid_t ptid,
struct target_waitstatus *status)
{
+ client_state *cs = get_client_state();
+
if (debug_threads)
debug_printf ("Writing resume reply for %s:%d\n",
target_pid_to_str (ptid), status->kind);
@@ -1100,8 +1109,8 @@ prepare_resume_reply (char *buf, ptid_t ptid,
const char **regp;
struct regcache *regcache;
- if ((status->kind == TARGET_WAITKIND_FORKED && report_fork_events)
- || (status->kind == TARGET_WAITKIND_VFORKED && report_vfork_events))
+ if ((status->kind == TARGET_WAITKIND_FORKED && cs->report_fork_events)
+ || (status->kind == TARGET_WAITKIND_VFORKED &&
cs->report_vfork_events))
{
enum gdb_signal signal = GDB_SIGNAL_TRAP;
const char *event = (status->kind == TARGET_WAITKIND_FORKED
@@ -1112,13 +1121,13 @@ prepare_resume_reply (char *buf, ptid_t ptid,
buf = write_ptid (buf, status->value.related_pid);
strcat (buf, ";");
}
- else if (status->kind == TARGET_WAITKIND_VFORK_DONE &&
report_vfork_events)
+ else if (status->kind == TARGET_WAITKIND_VFORK_DONE &&
cs->report_vfork_events)
{
enum gdb_signal signal = GDB_SIGNAL_TRAP;
sprintf (buf, "T%02xvforkdone:;", signal);
}
- else if (status->kind == TARGET_WAITKIND_EXECD && report_exec_events)
+ else if (status->kind == TARGET_WAITKIND_EXECD && cs->report_exec_events)
{
enum gdb_signal signal = GDB_SIGNAL_TRAP;
const char *event = "exec";
@@ -1138,7 +1147,7 @@ prepare_resume_reply (char *buf, ptid_t ptid,
buf += strlen (buf);
}
else if (status->kind == TARGET_WAITKIND_THREAD_CREATED
- && report_thread_events)
+ && cs->report_thread_events)
{
enum gdb_signal signal = GDB_SIGNAL_TRAP;
@@ -1159,13 +1168,13 @@ prepare_resume_reply (char *buf, ptid_t ptid,
buf += strlen (buf);
- saved_thread = current_thread;
+ saved_thread = cs->ss->current_thread;
switch_to_thread (ptid);
regp = current_target_desc ()->expedite_regs;
- regcache = get_thread_regcache (current_thread, 1);
+ regcache = get_thread_regcache (cs->ss->current_thread, 1);
if (the_target->stopped_by_watchpoint != NULL
&& (*the_target->stopped_by_watchpoint) ())
@@ -1186,12 +1195,12 @@ prepare_resume_reply (char *buf, ptid_t ptid,
*buf++ = tohex ((addr >> (i - 1) * 4) & 0xf);
*buf++ = ';';
}
- else if (swbreak_feature && target_stopped_by_sw_breakpoint ())
+ else if (cs->swbreak_feature && target_stopped_by_sw_breakpoint ())
{
sprintf (buf, "swbreak:;");
buf += strlen (buf);
}
- else if (hwbreak_feature && target_stopped_by_hw_breakpoint ())
+ else if (cs->hwbreak_feature && target_stopped_by_hw_breakpoint ())
{
sprintf (buf, "hwbreak:;");
buf += strlen (buf);
@@ -1219,13 +1228,13 @@ prepare_resume_reply (char *buf, ptid_t ptid,
in GDB will claim this event belongs to inferior_ptid
if we do not specify a thread, and there's no way for
gdbserver to know what inferior_ptid is. */
- if (1 || !ptid_equal (general_thread, ptid))
+ if (1 || !ptid_equal (cs->ss->general_thread, ptid))
{
int core = -1;
/* In non-stop, don't change the general thread behind
GDB's back. */
- if (!non_stop)
- general_thread = ptid;
+ if (!cs->non_stop)
+ cs->ss->general_thread = ptid;
sprintf (buf, "thread:");
buf += strlen (buf);
buf = write_ptid (buf, ptid);
@@ -1252,18 +1261,18 @@ prepare_resume_reply (char *buf, ptid_t ptid,
dlls_changed = 0;
}
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
}
break;
case TARGET_WAITKIND_EXITED:
- if (multi_process)
+ if (cs->multi_process)
sprintf (buf, "W%x;process:%x",
status->value.integer, ptid_get_pid (ptid));
else
sprintf (buf, "W%02x", status->value.integer);
break;
case TARGET_WAITKIND_SIGNALLED:
- if (multi_process)
+ if (cs->multi_process)
sprintf (buf, "X%x;process:%x",
status->value.sig, ptid_get_pid (ptid));
else
@@ -1435,6 +1444,7 @@ clear_symbol_cache (struct sym_cache **symcache_p)
int
look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb)
{
+ client_state *cs = get_client_state();
char *p, *q;
int len;
struct sym_cache *sym;
@@ -1456,14 +1466,14 @@ look_up_one_symbol (const char *name, CORE_ADDR
*addrp, int may_ask_gdb)
return 0;
/* Send the request. */
- strcpy (own_buf, "qSymbol:");
- bin2hex ((const gdb_byte *) name, own_buf + strlen ("qSymbol:"),
+ strcpy (cs->own_buf, "qSymbol:");
+ bin2hex ((const gdb_byte *) name, cs->own_buf + strlen ("qSymbol:"),
strlen (name));
- if (putpkt (own_buf) < 0)
+ if (putpkt (cs->own_buf) < 0)
return -1;
/* FIXME: Eventually add buffer overflow checking (to getpkt?) */
- len = getpkt (own_buf);
+ len = getpkt (cs->own_buf);
if (len < 0)
return -1;
@@ -1474,45 +1484,45 @@ look_up_one_symbol (const char *name, CORE_ADDR
*addrp, int may_ask_gdb)
while it figures out the address of the symbol. */
while (1)
{
- if (own_buf[0] == 'm')
+ if (cs->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);
+ decode_m_packet (&cs->own_buf[1], &mem_addr, &mem_len);
+ mem_buffer = (unsigned char *) xmalloc (mem_len);
+ if (read_inferior_memory (mem_addr, mem_buffer, mem_len) == 0)
+ bin2hex (mem_buffer, cs->own_buf, mem_len);
else
- write_enn (own_buf);
- free (mem_buf);
- if (putpkt (own_buf) < 0)
+ write_enn (cs->own_buf);
+ free (mem_buffer);
+ if (putpkt (cs->own_buf) < 0)
return -1;
}
- else if (own_buf[0] == 'v')
+ else if (cs->own_buf[0] == 'v')
{
int new_len = -1;
- handle_v_requests (own_buf, len, &new_len);
+ handle_v_requests (cs->own_buf, len, &new_len);
if (new_len != -1)
- putpkt_binary (own_buf, new_len);
+ putpkt_binary (cs->own_buf, new_len);
else
- putpkt (own_buf);
+ putpkt (cs->own_buf);
}
else
break;
- len = getpkt (own_buf);
+ len = getpkt (cs->own_buf);
if (len < 0)
return -1;
}
- if (!startswith (own_buf, "qSymbol:"))
+ if (!startswith (cs->own_buf, "qSymbol:"))
{
- warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf);
+ warning ("Malformed response to qSymbol, ignoring: %s\n",
cs->own_buf);
return -1;
}
- p = own_buf + strlen ("qSymbol:");
+ p = cs->own_buf + strlen ("qSymbol:");
q = p;
while (*q && *q != ':')
q++;
@@ -1548,17 +1558,18 @@ look_up_one_symbol (const char *name, CORE_ADDR
*addrp, int may_ask_gdb)
int
relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc)
{
+ client_state *cs = get_client_state();
int len;
ULONGEST written = 0;
/* Send the request. */
- sprintf (own_buf, "qRelocInsn:%s;%s", paddress (oldloc),
+ sprintf (cs->own_buf, "qRelocInsn:%s;%s", paddress (oldloc),
paddress (*to));
- if (putpkt (own_buf) < 0)
+ if (putpkt (cs->own_buf) < 0)
return -1;
/* FIXME: Eventually add buffer overflow checking (to getpkt?) */
- len = getpkt (own_buf);
+ len = getpkt (cs->own_buf);
if (len < 0)
return -1;
@@ -1566,61 +1577,61 @@ relocate_instruction (CORE_ADDR *to, CORE_ADDR
oldloc)
wait for the qRelocInsn "response". That requires re-entering
the main loop. For now, this is an adequate approximation; allow
GDB to access memory. */
- while (own_buf[0] == 'm' || own_buf[0] == 'M' || own_buf[0] == 'X')
+ while (cs->own_buf[0] == 'm' || cs->own_buf[0] == 'M' ||
cs->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')
+ if (cs->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);
+ decode_m_packet (&cs->own_buf[1], &mem_addr, &mem_len);
+ mem_buffer = (unsigned char *) xmalloc (mem_len);
+ if (read_inferior_memory (mem_addr, mem_buffer, mem_len) == 0)
+ bin2hex (mem_buffer, cs->own_buf, mem_len);
else
- write_enn (own_buf);
+ write_enn (cs->own_buf);
}
- else if (own_buf[0] == 'X')
+ else if (cs->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)
- write_enn (own_buf);
+ if (decode_X_packet (&cs->own_buf[1], len - 1, &mem_addr,
+ &mem_len, &mem_buffer) < 0
+ || write_inferior_memory (mem_addr, mem_buffer, mem_len) != 0)
+ write_enn (cs->own_buf);
else
- write_ok (own_buf);
+ write_ok (cs->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)
- write_ok (own_buf);
+ decode_M_packet (&cs->own_buf[1], &mem_addr, &mem_len, &mem_buffer);
+ if (write_inferior_memory (mem_addr, mem_buffer, mem_len) == 0)
+ write_ok (cs->own_buf);
else
- write_enn (own_buf);
+ write_enn (cs->own_buf);
}
- free (mem_buf);
- if (putpkt (own_buf) < 0)
+ free (mem_buffer);
+ if (putpkt (cs->own_buf) < 0)
return -1;
- len = getpkt (own_buf);
+ len = getpkt (cs->own_buf);
if (len < 0)
return -1;
}
- if (own_buf[0] == 'E')
+ if (cs->own_buf[0] == 'E')
{
warning ("An error occurred while relocating an instruction: %s\n",
- own_buf);
+ cs->own_buf);
return -1;
}
- if (!startswith (own_buf, "qRelocInsn:"))
+ if (!startswith (cs->own_buf, "qRelocInsn:"))
{
warning ("Malformed response to qRelocInsn, ignoring: %s\n",
- own_buf);
+ cs->own_buf);
return -1;
}
- unpack_varlen_hex (own_buf + strlen ("qRelocInsn:"), &written);
+ unpack_varlen_hex (cs->own_buf + strlen ("qRelocInsn:"), &written);
*to += written;
return 0;
diff --git a/gdb/gdbserver/remote-utils.h b/gdb/gdbserver/remote-utils.h
index c64807f406e..8714791e605 100644
--- a/gdb/gdbserver/remote-utils.h
+++ b/gdb/gdbserver/remote-utils.h
@@ -19,10 +19,7 @@
#ifndef REMOTE_UTILS_H
#define REMOTE_UTILS_H
-extern int remote_debug;
-extern int noack_mode;
-extern int transport_is_reliable;
-
+int get_remote_desc (void);
int gdb_connected (void);
#define STDIO_CONNECTION_NAME "stdio"
diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c
index 9d12ce6f706..261d28a5271 100644
--- a/gdb/gdbserver/server.c
+++ b/gdb/gdbserver/server.c
@@ -66,63 +66,6 @@ static gdb_environ our_environ;
int startup_with_shell = 1;
-/* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
- `vCont'. Note the multi-process extensions made `vCont' a
- 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. */
-ptid_t cont_thread;
-
-/* The thread set with an `Hg' packet. */
-ptid_t general_thread;
-
-int server_waiting;
-
-static int extended_protocol;
-static int response_needed;
-static int exit_requested;
-
-/* --once: Exit after the first connection has closed. */
-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. */
-int disable_randomization = 1;
-
-static char *program_name = NULL;
-static std::vector<char *> program_args;
-static std::string wrapper_argv;
-
-int pass_signals[GDB_SIGNAL_LAST];
-int program_signals[GDB_SIGNAL_LAST];
-int program_signals_p;
-
-/* 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
- when no longer debugging it. */
-
-unsigned long signal_pid;
-
/* Set if you want to disable optional thread related packets support
in gdbserver, for the sake of testing GDB against stubs that don't
support them. */
@@ -131,13 +74,6 @@ int disable_packet_Tthread;
int disable_packet_qC;
int disable_packet_qfThreadInfo;
-/* Last status reported to GDB. */
-struct target_waitstatus last_status;
-ptid_t last_ptid;
-
-char *own_buf;
-static unsigned char *mem_buf;
-
/* A sub-class of 'struct notif_event' for stop, holding information
relative to a single stop reply. We keep a queue of these to
push to GDB in non-stop mode. */
@@ -159,6 +95,167 @@ static struct btrace_config current_btrace_conf;
DEFINE_QUEUE_P (notif_event_p);
+static struct multi_client_states client_states;
+
+
+void dump_client_states (void) {
+ std::map<gdb_fildes_t,client_state*>::iterator it;
+ it = client_states.cs.begin();
+ for (it = client_states.cs.begin(); it != client_states.cs.end(); it++)
+ {
+ gdb_fildes_t cfd = it->first;
+ client_state *cs = it->second;
+ printf ("%d %#lx %ld %d %d\n", cfd, (unsigned long) cs,
(long)cs->ss->signal_pid, cs->ss->last_status.kind,
cs->ss->last_status.value.sig);
+ }
+}
+
+
+multi_client_states*
+get_client_states (void)
+{
+ return &client_states;
+}
+
+
+client_state*
+get_client_state (void)
+{
+ return client_states.get_client_state();
+}
+
+
+client_state::client_state (gdb_fildes_t fd, client_state *csidx)
+{
+ client_state *cs = get_client_state();
+ file_desc = fd;
+ attached_to_client = csidx->attached_to_client;
+ catch_syscalls = csidx->catch_syscalls;
+ extended_protocol = csidx->extended_protocol;
+ response_needed = csidx->response_needed;
+ exit_requested = csidx->exit_requested;
+ run_once = csidx->run_once;
+ multi_process = csidx->multi_process;
+ report_fork_events = csidx->report_fork_events;
+ report_vfork_events = csidx->report_vfork_events;
+ report_exec_events = csidx->report_exec_events;
+ report_thread_events = csidx->report_thread_events;
+ report_no_resumed = csidx->report_no_resumed;
+ non_stop = csidx->non_stop;
+ swbreak_feature = csidx->swbreak_feature;
+ hwbreak_feature = csidx->hwbreak_feature;
+ vCont_supported = csidx->vCont_supported;
+ disable_randomization = csidx->disable_randomization;
+ program_name = csidx->program_name;
+ program_args = csidx->program_args;
+ wrapper_argv = csidx->wrapper_argv;
+ remote_debug = csidx->remote_debug;
+ noack_mode = csidx->noack_mode;
+ transport_is_reliable = csidx->transport_is_reliable;
+ ss = new (server_state);
+ ss->mem_buf = csidx->ss->mem_buf;
+ ss->readchar_bufcnt = 0;
+ packet_type = other_packet;
+ last_packet_type = other_packet;
+ notify_buffer = NULL;
+ own_buf = (char*) xmalloc (PBUFSIZ + 1);
+ ss->attach_count = 0;
+ ss->cont_thread = null_ptid;
+ ss->general_thread = null_ptid;
+ ss->signal_pid = csidx->ss->signal_pid;
+ ss->last_ptid = null_ptid;
+ ss->last_status = csidx->ss->last_status;
+ if (csidx->file_desc < 0)
+ {
+ ss->all_processes = cs->ss->all_processes;
+ ss->all_threads = cs->ss->all_threads;
+ ss->current_thread = cs->ss->current_thread;
+ }
+ else
+ ss->current_thread = NULL;
+}
+
+
+/* Add a new client state for FD or return if found */
+
+client_state *
+multi_client_states::set_client_state (gdb_fildes_t fd)
+{
+/* States:
+ * fd = -1 add initial client state
+ * fd = F add client state for fd F
+ */
+
+ client_state *csidx, *cs;
+
+ /* add/return initial client state */
+ if (fd == -1)
+ {
+ if (client_states.cs.empty())
+ {
+ client_states.cs[fd] = new (client_state);
+ client_states.cs[fd]->ss = new (server_state);
+ client_states.cs[fd]->file_desc = fd;
+ }
+ client_states.current_cs = client_states.cs[fd];
+ return client_states.cs[fd];
+ }
+
+ /* add/return client state for fd F */
+
+ std::map<gdb_fildes_t,client_state*>::iterator it;
+ it = client_states.cs.find(fd);
+ if (it != client_states.cs.end())
+ {
+ client_states.current_cs = it->second;
+ return it->second;
+ }
+ else
+ csidx = client_states.cs.rbegin()->second;
+
+ /* add client state S for fd F */
+ client_states.cs[fd] = cs = new client_state (fd, csidx);
+ cs->file_desc = fd;
+ client_states.set_current_client (cs);
+ return cs;
+}
+
+
+/* Remove the client state corresponding to fd */
+
+void
+multi_client_states::delete_client_state (gdb_fildes_t fd)
+{
+ client_state *cs, *previous_cs = NULL;
+ std::map<gdb_fildes_t,client_state*>::iterator it;
+
+ for (it = client_states.cs.begin(); it != client_states.cs.end(); ++it)
+ {
+ server_state *ss= NULL;
+
+ cs = it->second;
+
+ if (it->first == fd)
+ {
+ client_states.current_cs = previous_cs;
+ if (cs->notify_buffer)
+ xfree (cs->notify_buffer);
+ free (cs->own_buf);
+ delete (cs->ss);
+ delete (cs);
+ client_states.cs.erase (fd);
+ }
+ previous_cs = cs;
+ }
+}
+
+
+#if 0
+static int
+queue_stop_reply_callback (thread_info *thread, void *arg);
+#endif
+
+/**********************************/
+
/* Put a stop reply to the stop reply queue. */
static void
@@ -257,7 +354,9 @@ target_running (void)
const char *
get_exec_wrapper ()
{
- return !wrapper_argv.empty () ? wrapper_argv.c_str () : NULL;
+ client_state *cs = get_client_state();
+
+ return !cs->wrapper_argv.empty () ? cs->wrapper_argv.c_str () : NULL;
}
/* See common/common-inferior.h. */
@@ -265,10 +364,12 @@ get_exec_wrapper ()
char *
get_exec_file (int err)
{
- if (err && program_name == NULL)
+ client_state *cs = get_client_state();
+
+ if (err && cs->program_name == NULL)
error (_("No executable file specified."));
- return program_name;
+ return cs->program_name;
}
/* See server.h. */
@@ -282,6 +383,8 @@ get_environ ()
static int
attach_inferior (int pid)
{
+ client_state *cs = get_client_state();
+
/* myattach should return -1 if attaching is unsupported,
0 if it succeeded, and call error() otherwise. */
@@ -294,28 +397,26 @@ attach_inferior (int pid)
/* FIXME - It may be that we should get the SIGNAL_PID from the
attach function, so that it can be the main thread instead of
whichever we were told to attach to. */
- signal_pid = pid;
+ cs->ss->signal_pid = pid;
- if (!non_stop)
+ if (!cs->non_stop)
{
- last_ptid = mywait (pid_to_ptid (pid), &last_status, 0, 0);
+ cs->ss->last_ptid = mywait (pid_to_ptid (pid),
&cs->ss->last_status, 0, 0);
/* GDB knows to ignore the first SIGSTOP after attaching to a
running
process using the "attach" command, but this is different; it's
just using "target remote". Pretend it's just starting up. */
- if (last_status.kind == TARGET_WAITKIND_STOPPED
- && last_status.value.sig == GDB_SIGNAL_STOP)
- last_status.value.sig = GDB_SIGNAL_TRAP;
+ if (cs->ss->last_status.kind == TARGET_WAITKIND_STOPPED
+ && cs->ss->last_status.value.sig == GDB_SIGNAL_STOP)
+ cs->ss->last_status.value.sig = GDB_SIGNAL_TRAP;
- current_thread->last_resume_kind = resume_stop;
- current_thread->last_status = last_status;
+ cs->ss->current_thread->last_resume_kind = resume_stop;
+ cs->ss->current_thread->last_status = cs->ss->last_status;
}
return 0;
}
-extern int remote_debug;
-
/* Decode a qXfer read request. Return 0 if everything looks OK,
or -1 otherwise. */
@@ -431,6 +532,7 @@ handle_btrace_disable (struct thread_info *thread)
static int
handle_btrace_general_set (char *own_buf)
{
+ client_state *cs = get_client_state();
struct thread_info *thread;
const char *err;
char *op;
@@ -440,14 +542,14 @@ handle_btrace_general_set (char *own_buf)
op = own_buf + strlen ("Qbtrace:");
- if (ptid_equal (general_thread, null_ptid)
- || ptid_equal (general_thread, minus_one_ptid))
+ if (ptid_equal (cs->ss->general_thread, null_ptid)
+ || ptid_equal (cs->ss->general_thread, minus_one_ptid))
{
strcpy (own_buf, "E.Must select a single thread.");
return -1;
}
- thread = find_thread_ptid (general_thread);
+ thread = find_thread_ptid (cs->ss->general_thread);
if (thread == NULL)
{
strcpy (own_buf, "E.No such thread.");
@@ -478,6 +580,7 @@ handle_btrace_general_set (char *own_buf)
static int
handle_btrace_conf_general_set (char *own_buf)
{
+ client_state *cs = get_client_state();
struct thread_info *thread;
char *op;
@@ -486,14 +589,14 @@ handle_btrace_conf_general_set (char *own_buf)
op = own_buf + strlen ("Qbtrace-conf:");
- if (ptid_equal (general_thread, null_ptid)
- || ptid_equal (general_thread, minus_one_ptid))
+ if (ptid_equal (cs->ss->general_thread, null_ptid)
+ || ptid_equal (cs->ss->general_thread, minus_one_ptid))
{
strcpy (own_buf, "E.Must select a single thread.");
return -1;
}
- thread = find_thread_ptid (general_thread);
+ thread = find_thread_ptid (cs->ss->general_thread);
if (thread == NULL)
{
strcpy (own_buf, "E.No such thread.");
@@ -545,6 +648,8 @@ handle_btrace_conf_general_set (char *own_buf)
static void
handle_general_set (char *own_buf)
{
+ client_state *cs = get_client_state();
+
if (startswith (own_buf, "QPassSignals:"))
{
int numsigs = (int) GDB_SIGNAL_LAST, i;
@@ -556,7 +661,7 @@ handle_general_set (char *own_buf)
{
if (i == cursig)
{
- pass_signals[i] = 1;
+ cs->pass_signals[i] = 1;
if (*p == '\0')
/* Keep looping, to clear the remaining signals. */
cursig = -1;
@@ -564,7 +669,7 @@ handle_general_set (char *own_buf)
p = decode_address_to_semicolon (&cursig, p);
}
else
- pass_signals[i] = 0;
+ cs->pass_signals[i] = 0;
}
strcpy (own_buf, "OK");
return;
@@ -576,14 +681,14 @@ handle_general_set (char *own_buf)
const char *p = own_buf + strlen ("QProgramSignals:");
CORE_ADDR cursig;
- program_signals_p = 1;
+ cs->program_signals_p = 1;
p = decode_address_to_semicolon (&cursig, p);
for (i = 0; i < numsigs; i++)
{
if (i == cursig)
{
- program_signals[i] = 1;
+ cs->program_signals[i] = 1;
if (*p == '\0')
/* Keep looping, to clear the remaining signals. */
cursig = -1;
@@ -591,7 +696,7 @@ handle_general_set (char *own_buf)
p = decode_address_to_semicolon (&cursig, p);
}
else
- program_signals[i] = 0;
+ cs->program_signals[i] = 0;
}
strcpy (own_buf, "OK");
return;
@@ -661,7 +766,7 @@ handle_general_set (char *own_buf)
std::string final_var = hex2str (p);
std::string var_name, var_value;
- if (remote_debug)
+ if (cs->remote_debug)
{
debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p);
debug_printf (_("[Environment variable to be set: '%s']\n"),
@@ -692,7 +797,7 @@ handle_general_set (char *own_buf)
const char *p = own_buf + sizeof ("QEnvironmentUnset:") - 1;
std::string varname = hex2str (p);
- if (remote_debug)
+ if (cs->remote_debug)
{
debug_printf (_("[QEnvironmentUnset received '%s']\n"), p);
debug_printf (_("[Environment variable to be unset: '%s']\n"),
@@ -708,13 +813,13 @@ handle_general_set (char *own_buf)
if (strcmp (own_buf, "QStartNoAckMode") == 0)
{
- if (remote_debug)
+ if (cs->remote_debug)
{
debug_printf ("[noack mode enabled]\n");
debug_flush ();
}
- noack_mode = 1;
+ cs->noack_mode = 1;
write_ok (own_buf);
return;
}
@@ -747,9 +852,9 @@ handle_general_set (char *own_buf)
return;
}
- non_stop = req;
+ cs->non_stop = req;
- if (remote_debug)
+ if (cs->remote_debug)
debug_printf ("[%s mode enabled]\n", req_str);
write_ok (own_buf);
@@ -762,11 +867,11 @@ handle_general_set (char *own_buf)
ULONGEST setting;
unpack_varlen_hex (packet, &setting);
- disable_randomization = setting;
+ cs->disable_randomization = setting;
- if (remote_debug)
+ if (cs->remote_debug)
{
- debug_printf (disable_randomization
+ debug_printf (cs->disable_randomization
? "[address space randomization disabled]\n"
: "[address space randomization enabled]\n");
}
@@ -797,7 +902,7 @@ handle_general_set (char *own_buf)
/* Update the flag. */
use_agent = req;
- if (remote_debug)
+ if (cs->remote_debug)
debug_printf ("[%s agent]\n", req ? "Enable" : "Disable");
write_ok (own_buf);
return;
@@ -829,11 +934,11 @@ handle_general_set (char *own_buf)
return;
}
- report_thread_events = (req == TRIBOOL_TRUE);
+ cs->report_thread_events = (req == TRIBOOL_TRUE);
- if (remote_debug)
+ if (cs->remote_debug)
{
- const char *req_str = report_thread_events ? "enabled" : "disabled";
+ const char *req_str = cs->report_thread_events ? "enabled" : "disabled";
debug_printf ("[thread events are now %s]\n", req_str);
}
@@ -859,7 +964,7 @@ handle_general_set (char *own_buf)
return;
}
- if (remote_debug)
+ if (cs->remote_debug)
debug_printf (_("[Inferior will %s started with shell]"),
startup_with_shell ? "be" : "not be");
@@ -877,7 +982,7 @@ handle_general_set (char *own_buf)
set_inferior_cwd (path.c_str ());
- if (remote_debug)
+ if (cs->remote_debug)
debug_printf (_("[Set the inferior's current directory to %s]\n"),
path.c_str ());
}
@@ -887,7 +992,7 @@ handle_general_set (char *own_buf)
previously set cwd for the inferior. */
set_inferior_cwd (NULL);
- if (remote_debug)
+ if (cs->remote_debug)
debug_printf (_("\
[Unset the inferior's current directory; will use gdbserver's cwd]\n"));
}
@@ -1189,11 +1294,12 @@ handle_search_memory (char *own_buf, int packet_len)
static void
handle_detach (char *own_buf)
{
+ client_state *cs = get_client_state();
require_running_or_return (own_buf);
int pid;
- if (multi_process)
+ if (cs->multi_process)
{
/* skip 'D;' */
pid = strtol (&own_buf[2], NULL, 16);
@@ -1226,12 +1332,12 @@ handle_detach (char *own_buf)
events simultaneously. There's also no point either in
having the target stop all threads, when we're going to
pass signals down without informing GDB. */
- if (!non_stop)
+ if (!cs->non_stop)
{
if (debug_threads)
debug_printf ("Forcing non-stop mode\n");
- non_stop = 1;
+ cs->non_stop = 1;
start_non_stop (1);
}
@@ -1253,16 +1359,16 @@ handle_detach (char *own_buf)
discard_queued_stop_replies (pid_to_ptid (pid));
write_ok (own_buf);
- if (extended_protocol || target_running ())
+ if (cs->extended_protocol || target_running ())
{
/* 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);
+ cs->ss->last_status.kind = TARGET_WAITKIND_EXITED;
+ cs->ss->last_status.value.integer = 0;
+ cs->ss->last_ptid = pid_to_ptid (pid);
- current_thread = NULL;
+ cs->ss->current_thread = NULL;
}
else
{
@@ -1355,6 +1461,8 @@ parse_debug_format_options (const char *arg, int
is_monitor)
static void
handle_monitor_command (char *mon, char *own_buf)
{
+ client_state *cs = get_client_state();
+
if (strcmp (mon, "set debug 1") == 0)
{
debug_threads = 1;
@@ -1377,12 +1485,12 @@ handle_monitor_command (char *mon, char *own_buf)
}
else if (strcmp (mon, "set remote-debug 1") == 0)
{
- remote_debug = 1;
+ cs->remote_debug = 1;
monitor_output ("Protocol debug output enabled.\n");
}
else if (strcmp (mon, "set remote-debug 0") == 0)
{
- remote_debug = 0;
+ cs->remote_debug = 0;
monitor_output ("Protocol debug output disabled.\n");
}
else if (startswith (mon, "set debug-format "))
@@ -1401,7 +1509,7 @@ handle_monitor_command (char *mon, char *own_buf)
else if (strcmp (mon, "help") == 0)
monitor_show_help ();
else if (strcmp (mon, "exit") == 0)
- exit_requested = 1;
+ cs->exit_requested = 1;
else
{
monitor_output ("Unknown monitor command.\n\n");
@@ -1441,10 +1549,12 @@ handle_qxfer_auxv (const char *annex,
gdb_byte *readbuf, const gdb_byte *writebuf,
ULONGEST offset, LONGEST len)
{
+ client_state *cs = get_client_state();
+
if (the_target->read_auxv == NULL || writebuf != NULL)
return -2;
- if (annex[0] != '\0' || current_thread == NULL)
+ if (annex[0] != '\0' || cs->ss->current_thread == NULL)
return -1;
return (*the_target->read_auxv) (offset, readbuf, len);
@@ -1457,6 +1567,7 @@ handle_qxfer_exec_file (const char *annex,
gdb_byte *readbuf, const gdb_byte *writebuf,
ULONGEST offset, LONGEST len)
{
+ client_state *cs = get_client_state();
char *file;
ULONGEST pid;
int total_len;
@@ -1466,10 +1577,10 @@ handle_qxfer_exec_file (const char *annex,
if (annex[0] == '\0')
{
- if (current_thread == NULL)
+ if (cs->ss->current_thread == NULL)
return -1;
- pid = pid_of (current_thread);
+ pid = pid_of (cs->ss->current_thread);
}
else
{
@@ -1537,10 +1648,12 @@ handle_qxfer_libraries (const char *annex,
gdb_byte *readbuf, const gdb_byte *writebuf,
ULONGEST offset, LONGEST len)
{
+ client_state *cs = get_client_state();
+
if (writebuf != NULL)
return -2;
- if (annex[0] != '\0' || current_thread == NULL)
+ if (annex[0] != '\0' || cs->ss->current_thread == NULL)
return -1;
std::string document = "<library-list version=\"1.0\">\n";
@@ -1570,10 +1683,12 @@ handle_qxfer_libraries_svr4 (const char *annex,
gdb_byte *readbuf, const gdb_byte *writebuf,
ULONGEST offset, LONGEST len)
{
+ client_state *cs = get_client_state();
+
if (writebuf != NULL)
return -2;
- if (current_thread == NULL || the_target->qxfer_libraries_svr4 == NULL)
+ if (cs->ss->current_thread == NULL ||
the_target->qxfer_libraries_svr4 == NULL)
return -1;
return the_target->qxfer_libraries_svr4 (annex, readbuf, writebuf,
offset, len);
@@ -1599,10 +1714,12 @@ handle_qxfer_siginfo (const char *annex,
gdb_byte *readbuf, const gdb_byte *writebuf,
ULONGEST offset, LONGEST len)
{
+ client_state *cs = get_client_state();
+
if (the_target->qxfer_siginfo == NULL)
return -2;
- if (annex[0] != '\0' || current_thread == NULL)
+ if (annex[0] != '\0' || cs->ss->current_thread == NULL)
return -1;
return (*the_target->qxfer_siginfo) (annex, readbuf, writebuf,
offset, len);
@@ -1615,10 +1732,12 @@ handle_qxfer_spu (const char *annex,
gdb_byte *readbuf, const gdb_byte *writebuf,
ULONGEST offset, LONGEST len)
{
+ client_state *cs = get_client_state();
+
if (the_target->qxfer_spu == NULL)
return -2;
- if (current_thread == NULL)
+ if (cs->ss->current_thread == NULL)
return -1;
return (*the_target->qxfer_spu) (annex, readbuf, writebuf, offset, len);
@@ -1631,12 +1750,13 @@ handle_qxfer_statictrace (const char *annex,
gdb_byte *readbuf, const gdb_byte *writebuf,
ULONGEST offset, LONGEST len)
{
+ client_state *cs = get_client_state();
ULONGEST nbytes;
if (writebuf != NULL)
return -2;
- if (annex[0] != '\0' || current_thread == NULL || current_traceframe
== -1)
+ if (annex[0] != '\0' || cs->ss->current_thread == NULL ||
current_traceframe == -1)
return -1;
if (traceframe_read_sdata (current_traceframe, offset,
@@ -1804,10 +1924,12 @@ static int
handle_qxfer_fdpic (const char *annex, gdb_byte *readbuf,
const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
{
+ client_state *cs = get_client_state();
+
if (the_target->read_loadmap == NULL)
return -2;
- if (current_thread == NULL)
+ if (cs->ss->current_thread == NULL)
return -1;
return (*the_target->read_loadmap) (annex, offset, readbuf, len);
@@ -1820,6 +1942,7 @@ handle_qxfer_btrace (const char *annex,
gdb_byte *readbuf, const gdb_byte *writebuf,
ULONGEST offset, LONGEST len)
{
+ client_state *cs = get_client_state();
static struct buffer cache;
struct thread_info *thread;
enum btrace_read_type type;
@@ -1828,23 +1951,23 @@ handle_qxfer_btrace (const char *annex,
if (the_target->read_btrace == NULL || writebuf != NULL)
return -2;
- if (ptid_equal (general_thread, null_ptid)
- || ptid_equal (general_thread, minus_one_ptid))
+ if (ptid_equal (cs->ss->general_thread, null_ptid)
+ || ptid_equal (cs->ss->general_thread, minus_one_ptid))
{
- strcpy (own_buf, "E.Must select a single thread.");
+ strcpy (cs->own_buf, "E.Must select a single thread.");
return -3;
}
- thread = find_thread_ptid (general_thread);
+ thread = find_thread_ptid (cs->ss->general_thread);
if (thread == NULL)
{
- strcpy (own_buf, "E.No such thread.");
+ strcpy (cs->own_buf, "E.No such thread.");
return -3;
}
if (thread->btrace == NULL)
{
- strcpy (own_buf, "E.Btrace not enabled.");
+ strcpy (cs->own_buf, "E.Btrace not enabled.");
return -3;
}
@@ -1856,7 +1979,7 @@ handle_qxfer_btrace (const char *annex,
type = BTRACE_READ_DELTA;
else
{
- strcpy (own_buf, "E.Bad annex.");
+ strcpy (cs->own_buf, "E.Bad annex.");
return -3;
}
@@ -1867,7 +1990,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 (cs->own_buf, cache.buffer, cache.used_size);
return -3;
}
}
@@ -1892,6 +2015,7 @@ handle_qxfer_btrace_conf (const char *annex,
gdb_byte *readbuf, const gdb_byte *writebuf,
ULONGEST offset, LONGEST len)
{
+ client_state *cs = get_client_state();
static struct buffer cache;
struct thread_info *thread;
int result;
@@ -1902,23 +2026,23 @@ handle_qxfer_btrace_conf (const char *annex,
if (annex[0] != '\0')
return -1;
- if (ptid_equal (general_thread, null_ptid)
- || ptid_equal (general_thread, minus_one_ptid))
+ if (ptid_equal (cs->ss->general_thread, null_ptid)
+ || ptid_equal (cs->ss->general_thread, minus_one_ptid))
{
- strcpy (own_buf, "E.Must select a single thread.");
+ strcpy (cs->own_buf, "E.Must select a single thread.");
return -3;
}
- thread = find_thread_ptid (general_thread);
+ thread = find_thread_ptid (cs->ss->general_thread);
if (thread == NULL)
{
- strcpy (own_buf, "E.No such thread.");
+ strcpy (cs->own_buf, "E.No such thread.");
return -3;
}
if (thread->btrace == NULL)
{
- strcpy (own_buf, "E.Btrace not enabled.");
+ strcpy (cs->own_buf, "E.Btrace not enabled.");
return -3;
}
@@ -1929,7 +2053,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 (cs->own_buf, cache.buffer, cache.used_size);
return -3;
}
}
@@ -2142,6 +2266,7 @@ supported_btrace_packets (char *buf)
static void
handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
{
+ client_state *cs = get_client_state();
static std::list<thread_info *>::const_iterator thread_iter;
/* Reply the current thread id. */
@@ -2150,11 +2275,11 @@ handle_query (char *own_buf, int packet_len, int
*new_packet_len_p)
ptid_t ptid;
require_running_or_return (own_buf);
- if (general_thread != null_ptid && general_thread != minus_one_ptid)
- ptid = general_thread;
+ if (cs->ss->general_thread != null_ptid && cs->ss->general_thread
!= minus_one_ptid)
+ ptid = cs->ss->general_thread;
else
{
- thread_iter = all_threads.begin ();
+ thread_iter = cs->ss->all_threads.begin ();
ptid = (*thread_iter)->id;
}
@@ -2166,24 +2291,24 @@ 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;
+ struct thread_info *save_thread = cs->ss->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)
+ if (cs->ss->current_thread == NULL)
{
- current_thread
- = find_any_thread_of_pid (ptid_get_pid (general_thread));
+ cs->ss->current_thread
+ = find_any_thread_of_pid (ptid_get_pid (cs->ss->general_thread));
/* Just in case, if we didn't find a thread, then bail out
instead of crashing. */
- if (current_thread == NULL)
+ if (cs->ss->current_thread == NULL)
{
write_enn (own_buf);
- current_thread = save_thread;
+ cs->ss->current_thread = save_thread;
return;
}
}
@@ -2203,10 +2328,10 @@ handle_query (char *own_buf, int packet_len, int
*new_packet_len_p)
if (target_supports_tracepoints ())
tracepoint_look_up_symbols ();
- if (current_thread != NULL && the_target->look_up_symbols != NULL)
+ if (cs->ss->current_thread != NULL && the_target->look_up_symbols
!= NULL)
(*the_target->look_up_symbols) ();
- current_thread = save_thread;
+ cs->ss->current_thread = save_thread;
strcpy (own_buf, "OK");
return;
@@ -2217,7 +2342,7 @@ handle_query (char *own_buf, int packet_len, int
*new_packet_len_p)
if (strcmp ("qfThreadInfo", own_buf) == 0)
{
require_running_or_return (own_buf);
- thread_iter = all_threads.begin ();
+ thread_iter = cs->ss->all_threads.begin ();
*own_buf++ = 'm';
ptid_t ptid = (*thread_iter)->id;
@@ -2229,7 +2354,7 @@ handle_query (char *own_buf, int packet_len, int
*new_packet_len_p)
if (strcmp ("qsThreadInfo", own_buf) == 0)
{
require_running_or_return (own_buf);
- if (thread_iter != all_threads.end ())
+ if (thread_iter != cs->ss->all_threads.end ())
{
*own_buf++ = 'm';
ptid_t ptid = (*thread_iter)->id;
@@ -2296,7 +2421,7 @@ handle_query (char *own_buf, int packet_len, int
*new_packet_len_p)
/* GDB supports and wants multi-process support if
possible. */
if (target_supports_multi_process ())
- multi_process = 1;
+ cs->multi_process = 1;
}
else if (strcmp (p, "qRelocInsn+") == 0)
{
@@ -2309,42 +2434,42 @@ handle_query (char *own_buf, int packet_len, int
*new_packet_len_p)
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;
+ cs->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;
+ cs->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;
+ cs->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;
+ cs->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;
+ cs->report_exec_events = 1;
}
else if (strcmp (p, "vContSupported+") == 0)
- vCont_supported = 1;
+ cs->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;
+ cs->report_no_resumed = 1;
}
else
{
@@ -2402,7 +2527,7 @@ handle_query (char *own_buf, int packet_len, int
*new_packet_len_p)
qXfer:feature:read at all, we will never be re-queried. */
strcat (own_buf, ";qXfer:features:read+");
- if (transport_is_reliable)
+ if (cs->transport_is_reliable)
strcat (own_buf, ";QStartNoAckMode+");
if (the_target->qxfer_osdata != NULL)
@@ -2713,13 +2838,15 @@ static int
handle_pending_status (const struct thread_resume *resumption,
struct thread_info *thread)
{
+ client_state *cs = get_client_state();
+
if (thread->status_pending_p)
{
thread->status_pending_p = 0;
- last_status = thread->last_status;
- last_ptid = thread->id;
- prepare_resume_reply (own_buf, last_ptid, &last_status);
+ cs->ss->last_status = thread->last_status;
+ cs->ss->last_ptid = thread->id;
+ prepare_resume_reply (cs->own_buf, cs->ss->last_ptid,
&cs->ss->last_status);
return 1;
}
return 0;
@@ -2839,7 +2966,9 @@ err:
static void
resume (struct thread_resume *actions, size_t num_actions)
{
- if (!non_stop)
+ client_state *cs = get_client_state();
+
+ if (!cs->non_stop)
{
/* Check if among the threads that GDB wants actioned, there's
one with a pending status to report. If so, skip actually
@@ -2860,38 +2989,38 @@ resume (struct thread_resume *actions, size_t
num_actions)
(*the_target->resume) (actions, num_actions);
- if (non_stop)
- write_ok (own_buf);
+ if (cs->non_stop)
+ write_ok (cs->own_buf);
else
{
- last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
+ cs->ss->last_ptid = mywait (minus_one_ptid, &cs->ss->last_status,
0, 1);
- if (last_status.kind == TARGET_WAITKIND_NO_RESUMED
- && !report_no_resumed)
+ if (cs->ss->last_status.kind == TARGET_WAITKIND_NO_RESUMED
+ && !cs->report_no_resumed)
{
/* The client does not support this stop reply. At least
return error. */
- sprintf (own_buf, "E.No unwaited-for children left.");
+ sprintf (cs->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
- && last_status.kind != TARGET_WAITKIND_NO_RESUMED)
- current_thread->last_status = last_status;
+ if (cs->ss->last_status.kind != TARGET_WAITKIND_EXITED
+ && cs->ss->last_status.kind != TARGET_WAITKIND_SIGNALLED
+ && cs->ss->last_status.kind != TARGET_WAITKIND_NO_RESUMED)
+ cs->ss->current_thread->last_status = cs->ss->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 (cs->own_buf, cs->ss->last_ptid,
&cs->ss->last_status);
disable_async_io ();
- if (last_status.kind == TARGET_WAITKIND_EXITED
- || last_status.kind == TARGET_WAITKIND_SIGNALLED)
- target_mourn_inferior (last_ptid);
+ if (cs->ss->last_status.kind == TARGET_WAITKIND_EXITED
+ || cs->ss->last_status.kind == TARGET_WAITKIND_SIGNALLED)
+ target_mourn_inferior (cs->ss->last_ptid);
}
}
@@ -2899,6 +3028,7 @@ resume (struct thread_resume *actions, size_t
num_actions)
static int
handle_v_attach (char *own_buf)
{
+ client_state *cs = get_client_state();
int pid;
pid = strtol (own_buf + 8, NULL, 16);
@@ -2910,7 +3040,7 @@ handle_v_attach (char *own_buf)
notice on the GDB side. */
dlls_changed = 0;
- if (non_stop)
+ if (cs->non_stop)
{
/* In non-stop, we don't send a resume reply. Stop events
will follow up using the normal notification
@@ -2918,7 +3048,7 @@ handle_v_attach (char *own_buf)
write_ok (own_buf);
}
else
- prepare_resume_reply (own_buf, last_ptid, &last_status);
+ prepare_resume_reply (own_buf, cs->ss->last_ptid, &cs->ss->last_status);
return 1;
}
@@ -2933,6 +3063,7 @@ handle_v_attach (char *own_buf)
static int
handle_v_run (char *own_buf)
{
+ client_state *cs = get_client_state();
char *p, *next_p;
std::vector<char *> new_argv;
char *new_program_name = NULL;
@@ -3023,7 +3154,7 @@ handle_v_run (char *own_buf)
{
/* GDB didn't specify a program to run. Use the program from the
last run with the new argument list. */
- if (program_name == NULL)
+ if (cs->program_name == NULL)
{
write_enn (own_buf);
free_vector_argv (new_argv);
@@ -3032,25 +3163,25 @@ handle_v_run (char *own_buf)
}
else
{
- xfree (program_name);
- program_name = new_program_name;
+ xfree (cs->program_name);
+ cs->program_name = new_program_name;
}
/* Free the old argv and install the new one. */
- free_vector_argv (program_args);
- program_args = new_argv;
+ free_vector_argv (cs->program_args);
+ cs->program_args = new_argv;
- create_inferior (program_name, program_args);
+ create_inferior (cs->program_name, cs->program_args);
- if (last_status.kind == TARGET_WAITKIND_STOPPED)
+ if (cs->ss->last_status.kind == TARGET_WAITKIND_STOPPED)
{
- prepare_resume_reply (own_buf, last_ptid, &last_status);
+ prepare_resume_reply (own_buf, cs->ss->last_ptid,
&cs->ss->last_status);
/* In non-stop, sending a resume reply doesn't set the general
thread, but GDB assumes a vRun sets it (this is so GDB can
query which is the main thread of the new inferior. */
- if (non_stop)
- general_thread = last_ptid;
+ if (cs->non_stop)
+ cs->ss->general_thread = cs->ss->last_ptid;
return 1;
}
@@ -3065,18 +3196,19 @@ handle_v_run (char *own_buf)
static int
handle_v_kill (char *own_buf)
{
+ client_state *cs = get_client_state();
int pid;
char *p = &own_buf[6];
- if (multi_process)
+ if (cs->multi_process)
pid = strtol (p, NULL, 16);
else
- pid = signal_pid;
+ pid = cs->ss->signal_pid;
if (pid != 0 && kill_inferior (pid) == 0)
{
- last_status.kind = TARGET_WAITKIND_SIGNALLED;
- last_status.value.sig = GDB_SIGNAL_KILL;
- last_ptid = pid_to_ptid (pid);
- discard_queued_stop_replies (last_ptid);
+ cs->ss->last_status.kind = TARGET_WAITKIND_SIGNALLED;
+ cs->ss->last_status.value.sig = GDB_SIGNAL_KILL;
+ cs->ss->last_ptid = pid_to_ptid (pid);
+ discard_queued_stop_replies (cs->ss->last_ptid);
write_ok (own_buf);
return 1;
}
@@ -3091,6 +3223,8 @@ handle_v_kill (char *own_buf)
void
handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
{
+ client_state *cs = get_client_state();
+
if (!disable_packet_vCont)
{
if (strcmp (own_buf, "vCtrlC") == 0)
@@ -3112,7 +3246,7 @@ handle_v_requests (char *own_buf, int packet_len,
int *new_packet_len)
if (target_supports_hardware_single_step ()
|| target_supports_software_single_step ()
- || !vCont_supported)
+ || !cs->vCont_supported)
{
/* If target supports single step either by hardware or by
software, add actions s and S to the list of supported
@@ -3138,7 +3272,7 @@ handle_v_requests (char *own_buf, int packet_len,
int *new_packet_len)
if (startswith (own_buf, "vAttach;"))
{
- if ((!extended_protocol || !multi_process) && target_running ())
+ if ((!cs->extended_protocol || !cs->multi_process) &&
target_running ())
{
fprintf (stderr, "Already debugging a process\n");
write_enn (own_buf);
@@ -3150,7 +3284,7 @@ handle_v_requests (char *own_buf, int packet_len,
int *new_packet_len)
if (startswith (own_buf, "vRun;"))
{
- if ((!extended_protocol || !multi_process) && target_running ())
+ if ((!cs->extended_protocol || !cs->multi_process) &&
target_running ())
{
fprintf (stderr, "Already debugging a process\n");
write_enn (own_buf);
@@ -3187,12 +3321,13 @@ handle_v_requests (char *own_buf, int
packet_len, int *new_packet_len)
static void
myresume (char *own_buf, int step, int sig)
{
+ client_state *cs = get_client_state();
struct thread_resume resume_info[2];
int n = 0;
int valid_cont_thread;
- valid_cont_thread = (!ptid_equal (cont_thread, null_ptid)
- && !ptid_equal (cont_thread, minus_one_ptid));
+ valid_cont_thread = (!ptid_equal (cs->ss->cont_thread, null_ptid)
+ && !ptid_equal (cs->ss->cont_thread, minus_one_ptid));
if (step || sig || valid_cont_thread)
{
@@ -3241,7 +3376,7 @@ queue_stop_reply_callback (thread_info *thread)
{
if (debug_threads)
{
- std::string status_string
+ std::string status_string
= target_waitstatus_to_string (&thread->last_status);
debug_printf ("Reporting thread %s as already stopped with %s\n",
@@ -3307,6 +3442,8 @@ set_pending_status_callback (thread_info *thread)
static void
handle_status (char *own_buf)
{
+ client_state *cs = get_client_state();
+
/* GDB is connected, don't forward events to the target anymore. */
for_each_process ([] (process_info *process) {
process->gdb_detached = 0;
@@ -3316,12 +3453,12 @@ handle_status (char *own_buf)
thread. In all-stop mode, just send one for the first stopped
thread we find. */
- if (non_stop)
+ if (cs->non_stop)
{
for_each_thread (queue_stop_reply_callback);
- /* The first is sent immediatly. OK is sent if there is no
- stopped thread, which is the same handling of the vStopped
+ /* The first is sent immediately. OK is sent if there is no
+ stopped thread, which is the same handling as the vStopped
packet (by design). */
notif_write_event (¬if_stop, own_buf);
}
@@ -3343,10 +3480,10 @@ handle_status (char *own_buf)
/* Prefer the last thread that reported an event to GDB (even if
that was a GDB_SIGNAL_TRAP). */
- if (last_status.kind != TARGET_WAITKIND_IGNORE
- && last_status.kind != TARGET_WAITKIND_EXITED
- && last_status.kind != TARGET_WAITKIND_SIGNALLED)
- thread = find_thread_ptid (last_ptid);
+ if (cs->ss->last_status.kind != TARGET_WAITKIND_IGNORE
+ && cs->ss->last_status.kind != TARGET_WAITKIND_EXITED
+ && cs->ss->last_status.kind != TARGET_WAITKIND_SIGNALLED)
+ thread = find_thread_ptid (cs->ss->last_ptid);
/* If the last event thread is not found for some reason, look
for some other thread that might have an event to report. */
@@ -3371,7 +3508,7 @@ handle_status (char *own_buf)
/* GDB assumes the current thread is the thread we're
reporting the status for. */
- general_thread = thread->id;
+ cs->ss->general_thread = thread->id;
set_desired_thread ();
gdb_assert (tp->last_status.kind != TARGET_WAITKIND_IGNORE);
@@ -3558,6 +3695,12 @@ captured_main (int argc, char *argv[])
volatile int multi_mode = 0;
volatile int attach = 0;
int was_running;
+ int run_once_arg = 0;
+ int disable_randomization_arg = 1;
+
+ int remote_desc = get_remote_desc();
+ client_states.set_client_state (remote_desc);
+ client_state *cs = get_client_state();
bool selftest = false;
#if GDB_SELF_TEST
const char *selftest_filter = NULL;
@@ -3588,15 +3731,15 @@ captured_main (int argc, char *argv[])
tmp = next_arg;
while (*next_arg != NULL && strcmp (*next_arg, "--") != 0)
{
- wrapper_argv += *next_arg;
- wrapper_argv += ' ';
+ cs->wrapper_argv += *next_arg;
+ cs->wrapper_argv += ' ';
next_arg++;
}
- if (!wrapper_argv.empty ())
+ if (!cs->wrapper_argv.empty ())
{
/* Erase the last whitespace. */
- wrapper_argv.erase (wrapper_argv.end () - 1);
+ cs->wrapper_argv.erase (cs->wrapper_argv.end () - 1);
}
if (next_arg == tmp || *next_arg == NULL)
@@ -3623,7 +3766,7 @@ captured_main (int argc, char *argv[])
}
}
else if (strcmp (*next_arg, "--remote-debug") == 0)
- remote_debug = 1;
+ cs->remote_debug = 1;
else if (strcmp (*next_arg, "--disable-packet") == 0)
{
gdbserver_show_disableable (stdout);
@@ -3671,15 +3814,15 @@ captured_main (int argc, char *argv[])
break;
}
else if (strcmp (*next_arg, "--disable-randomization") == 0)
- disable_randomization = 1;
+ disable_randomization_arg = 1;
else if (strcmp (*next_arg, "--no-disable-randomization") == 0)
- disable_randomization = 0;
+ disable_randomization_arg = 0;
else if (strcmp (*next_arg, "--startup-with-shell") == 0)
startup_with_shell = true;
else if (strcmp (*next_arg, "--no-startup-with-shell") == 0)
startup_with_shell = false;
else if (strcmp (*next_arg, "--once") == 0)
- run_once = 1;
+ run_once_arg = 1;
else if (strcmp (*next_arg, "--selftest") == 0)
selftest = true;
else if (startswith (*next_arg, "--selftest="))
@@ -3699,6 +3842,9 @@ captured_main (int argc, char *argv[])
continue;
}
+ cs->run_once = run_once_arg;
+ cs->disable_randomization = disable_randomization_arg;
+
if (port == NULL)
{
port = *next_arg;
@@ -3760,8 +3906,8 @@ captured_main (int argc, char *argv[])
initialize_tracepoint ();
initialize_notif ();
- own_buf = (char *) xmalloc (PBUFSIZ + 1);
- mem_buf = (unsigned char *) xmalloc (PBUFSIZ);
+ cs->own_buf = (char *) xmalloc (PBUFSIZ + 1);
+ cs->ss->mem_buf = (unsigned char *) xmalloc (PBUFSIZ);
if (selftest)
{
@@ -3778,13 +3924,13 @@ captured_main (int argc, char *argv[])
int i, n;
n = argc - (next_arg - argv);
- program_name = xstrdup (next_arg[0]);
+ cs->program_name = xstrdup (next_arg[0]);
for (i = 1; i < n; i++)
- program_args.push_back (xstrdup (next_arg[i]));
- program_args.push_back (NULL);
+ cs->program_args.push_back (xstrdup (next_arg[i]));
+ cs->program_args.push_back (NULL);
/* Wait till we are at first instruction in program. */
- create_inferior (program_name, program_args);
+ create_inferior (cs->program_name, cs->program_args);
/* We are now (hopefully) stopped at the first instruction of
the target process. This assumes that the target process was
@@ -3799,9 +3945,9 @@ captured_main (int argc, char *argv[])
}
else
{
- last_status.kind = TARGET_WAITKIND_EXITED;
- last_status.value.integer = 0;
- last_ptid = minus_one_ptid;
+ cs->ss->last_status.kind = TARGET_WAITKIND_EXITED;
+ cs->ss->last_status.value.integer = 0;
+ cs->ss->last_ptid = minus_one_ptid;
}
make_cleanup (detach_or_kill_for_exit_cleanup, NULL);
@@ -3810,8 +3956,8 @@ captured_main (int argc, char *argv[])
shared library event" notice on gdb side. */
dlls_changed = 0;
- if (last_status.kind == TARGET_WAITKIND_EXITED
- || last_status.kind == TARGET_WAITKIND_SIGNALLED)
+ if (cs->ss->last_status.kind == TARGET_WAITKIND_EXITED
+ || cs->ss->last_status.kind == TARGET_WAITKIND_SIGNALLED)
was_running = 0;
else
was_running = 1;
@@ -3822,17 +3968,13 @@ captured_main (int argc, char *argv[])
while (1)
{
- noack_mode = 0;
- multi_process = 0;
- report_fork_events = 0;
- report_vfork_events = 0;
- report_exec_events = 0;
+ cs->noack_mode = 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;
+ cs->ss->cont_thread = null_ptid;
+ cs->swbreak_feature = 0;
+ cs->hwbreak_feature = 0;
+ cs->vCont_supported = 0;
remote_open (port);
@@ -3844,7 +3986,7 @@ captured_main (int argc, char *argv[])
/* If an exit was requested (using the "monitor exit"
command), terminate now. */
- if (exit_requested)
+ if (cs->exit_requested)
throw_quit ("Quit");
/* The only other way to get here is for getpkt to fail:
@@ -3857,7 +3999,7 @@ captured_main (int argc, char *argv[])
- Otherwise, close the connection and reopen it at the
top of the loop. */
- if (run_once || (!extended_protocol && !target_running ()))
+ if (cs->run_once || (!cs->extended_protocol && !target_running ()))
throw_quit ("Quit");
fprintf (stderr,
@@ -3883,10 +4025,10 @@ captured_main (int argc, char *argv[])
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 (!cs->non_stop)
{
if (start_non_stop (1))
- non_stop = 1;
+ cs->non_stop = 1;
/* Detaching implicitly resumes all threads;
simply disconnecting does not. */
@@ -3906,13 +4048,13 @@ captured_main (int argc, char *argv[])
fflush (stdout);
fprintf (stderr, "gdbserver: %s\n", exception.message);
- if (response_needed)
+ if (cs->response_needed)
{
- write_enn (own_buf);
- putpkt (own_buf);
+ write_enn (cs->own_buf);
+ putpkt (cs->own_buf);
}
- if (run_once)
+ if (cs->run_once)
throw_quit ("Quit");
}
END_CATCH
@@ -4004,6 +4146,7 @@ process_point_options (struct gdb_breakpoint *bp,
const char **packet)
static int
process_serial_event (void)
{
+ client_state *cs = get_client_state();
int signal;
unsigned int len;
int res;
@@ -4014,41 +4157,41 @@ process_serial_event (void)
disable_async_io ();
- response_needed = 0;
- packet_len = getpkt (own_buf);
- if (packet_len <= 0)
+ cs->response_needed = 0;
+ cs->packet_length = getpkt (cs->own_buf);
+ if (cs->packet_length <= 0)
{
remote_close ();
/* Force an event loop break. */
return -1;
}
- response_needed = 1;
+ cs->response_needed = 1;
- char ch = own_buf[0];
+ char ch = cs->own_buf[0];
switch (ch)
{
case 'q':
- handle_query (own_buf, packet_len, &new_packet_len);
+ handle_query (cs->own_buf, cs->packet_length, &new_packet_len);
break;
case 'Q':
- handle_general_set (own_buf);
+ handle_general_set (cs->own_buf);
break;
case 'D':
- handle_detach (own_buf);
+ handle_detach (cs->own_buf);
break;
case '!':
- extended_protocol = 1;
- write_ok (own_buf);
+ cs->extended_protocol = 1;
+ write_ok (cs->own_buf);
break;
case '?':
- handle_status (own_buf);
+ handle_status (cs->own_buf);
break;
case 'H':
- if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
+ if (cs->own_buf[1] == 'c' || cs->own_buf[1] == 'g' ||
cs->own_buf[1] == 's')
{
- require_running_or_break (own_buf);
+ require_running_or_break (cs->own_buf);
- ptid_t thread_id = read_ptid (&own_buf[2], NULL);
+ ptid_t thread_id = read_ptid (&cs->own_buf[2], NULL);
if (thread_id == null_ptid || thread_id == minus_one_ptid)
thread_id = null_ptid;
@@ -4059,7 +4202,7 @@ process_serial_event (void)
if (thread == NULL)
{
- write_enn (own_buf);
+ write_enn (cs->own_buf);
break;
}
@@ -4070,42 +4213,42 @@ process_serial_event (void)
/* The ptid represents a lwp/tid. */
if (find_thread_ptid (thread_id) == NULL)
{
- write_enn (own_buf);
+ write_enn (cs->own_buf);
break;
}
}
- if (own_buf[1] == 'g')
+ if (cs->own_buf[1] == 'g')
{
if (ptid_equal (thread_id, null_ptid))
{
/* GDB is telling us to choose any thread. Check if
the currently selected thread is still valid. If
it is not, select the first available. */
- thread_info *thread = find_thread_ptid (general_thread);
+ thread_info *thread = find_thread_ptid (cs->ss->general_thread);
if (thread == NULL)
thread = get_first_thread ();
thread_id = thread->id;
}
- general_thread = thread_id;
+ cs->ss->general_thread = thread_id;
set_desired_thread ();
- gdb_assert (current_thread != NULL);
+ gdb_assert (cs->ss->current_thread != NULL);
}
- else if (own_buf[1] == 'c')
- cont_thread = thread_id;
+ else if (cs->own_buf[1] == 'c')
+ cs->ss->cont_thread = thread_id;
- write_ok (own_buf);
+ write_ok (cs->own_buf);
}
else
{
/* Silently ignore it so that gdb can extend the protocol
without compatibility headaches. */
- own_buf[0] = '\0';
+ cs->own_buf[0] = '\0';
}
break;
case 'g':
- require_running_or_break (own_buf);
+ require_running_or_break (cs->own_buf);
if (current_traceframe >= 0)
{
struct regcache *regcache
@@ -4113,9 +4256,9 @@ process_serial_event (void)
if (fetch_traceframe_registers (current_traceframe,
regcache, -1) == 0)
- registers_to_string (regcache, own_buf);
+ registers_to_string (regcache, cs->own_buf);
else
- write_enn (own_buf);
+ write_enn (cs->own_buf);
free_register_cache (regcache);
}
else
@@ -4123,85 +4266,85 @@ process_serial_event (void)
struct regcache *regcache;
if (!set_desired_thread ())
- write_enn (own_buf);
+ write_enn (cs->own_buf);
else
{
- regcache = get_thread_regcache (current_thread, 1);
- registers_to_string (regcache, own_buf);
+ regcache = get_thread_regcache (cs->ss->current_thread, 1);
+ registers_to_string (regcache, cs->own_buf);
}
}
break;
case 'G':
- require_running_or_break (own_buf);
+ require_running_or_break (cs->own_buf);
if (current_traceframe >= 0)
- write_enn (own_buf);
+ write_enn (cs->own_buf);
else
{
struct regcache *regcache;
if (!set_desired_thread ())
- write_enn (own_buf);
+ write_enn (cs->own_buf);
else
{
- regcache = get_thread_regcache (current_thread, 1);
- registers_from_string (regcache, &own_buf[1]);
- write_ok (own_buf);
+ regcache = get_thread_regcache (cs->ss->current_thread, 1);
+ registers_from_string (regcache, &cs->own_buf[1]);
+ write_ok (cs->own_buf);
}
}
break;
case 'm':
- require_running_or_break (own_buf);
- decode_m_packet (&own_buf[1], &mem_addr, &len);
- res = gdb_read_memory (mem_addr, mem_buf, len);
+ require_running_or_break (cs->own_buf);
+ decode_m_packet (&cs->own_buf[1], &mem_addr, &len);
+ res = gdb_read_memory (mem_addr, cs->ss->mem_buf, len);
if (res < 0)
- write_enn (own_buf);
+ write_enn (cs->own_buf);
else
- bin2hex (mem_buf, own_buf, res);
+ bin2hex (cs->ss->mem_buf, cs->own_buf, res);
break;
case 'M':
- require_running_or_break (own_buf);
- decode_M_packet (&own_buf[1], &mem_addr, &len, &mem_buf);
- if (gdb_write_memory (mem_addr, mem_buf, len) == 0)
- write_ok (own_buf);
+ require_running_or_break (cs->own_buf);
+ decode_M_packet (&cs->own_buf[1], &mem_addr, &len, &cs->ss->mem_buf);
+ if (gdb_write_memory (mem_addr, cs->ss->mem_buf, len) == 0)
+ write_ok (cs->own_buf);
else
- write_enn (own_buf);
+ write_enn (cs->own_buf);
break;
case 'X':
- require_running_or_break (own_buf);
- if (decode_X_packet (&own_buf[1], packet_len - 1,
- &mem_addr, &len, &mem_buf) < 0
- || gdb_write_memory (mem_addr, mem_buf, len) != 0)
- write_enn (own_buf);
+ require_running_or_break (cs->own_buf);
+ if (decode_X_packet (&cs->own_buf[1], cs->packet_length - 1,
+ &mem_addr, &len, &cs->ss->mem_buf) < 0
+ || gdb_write_memory (mem_addr, cs->ss->mem_buf, len) != 0)
+ write_enn (cs->own_buf);
else
- write_ok (own_buf);
+ write_ok (cs->own_buf);
break;
case 'C':
- require_running_or_break (own_buf);
- hex2bin (own_buf + 1, &sig, 1);
+ require_running_or_break (cs->own_buf);
+ hex2bin (cs->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);
+ myresume (cs->own_buf, 0, signal);
break;
case 'S':
- require_running_or_break (own_buf);
- hex2bin (own_buf + 1, &sig, 1);
+ require_running_or_break (cs->own_buf);
+ hex2bin (cs->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);
+ myresume (cs->own_buf, 1, signal);
break;
case 'c':
- require_running_or_break (own_buf);
+ require_running_or_break (cs->own_buf);
signal = 0;
- myresume (own_buf, 0, signal);
+ myresume (cs->own_buf, 0, signal);
break;
case 's':
- require_running_or_break (own_buf);
+ require_running_or_break (cs->own_buf);
signal = 0;
- myresume (own_buf, 1, signal);
+ myresume (cs->own_buf, 1, signal);
break;
case 'Z': /* insert_ ... */
/* Fallthrough. */
@@ -4210,12 +4353,12 @@ process_serial_event (void)
char *dataptr;
ULONGEST addr;
int kind;
- char type = own_buf[1];
+ char type = cs->own_buf[1];
int res;
const int insert = ch == 'Z';
- const char *p = &own_buf[3];
+ char *p = &cs->own_buf[3];
- p = unpack_varlen_hex (p, &addr);
+ p = (char*)unpack_varlen_hex (p, &addr);
kind = strtol (p + 1, &dataptr, 16);
if (insert)
@@ -4241,16 +4384,16 @@ process_serial_event (void)
res = delete_gdb_breakpoint (type, addr, kind);
if (res == 0)
- write_ok (own_buf);
+ write_ok (cs->own_buf);
else if (res == 1)
/* Unsupported. */
- own_buf[0] = '\0';
+ cs->own_buf[0] = '\0';
else
- write_enn (own_buf);
+ write_enn (cs->own_buf);
break;
}
case 'k':
- response_needed = 0;
+ cs->response_needed = 0;
if (!target_running ())
/* The packet we received doesn't make sense - but we can't
reply to it, either. */
@@ -4262,10 +4405,10 @@ process_serial_event (void)
/* When using the extended protocol, we wait with no program
running. The traditional protocol will exit instead. */
- if (extended_protocol)
+ if (cs->extended_protocol)
{
- last_status.kind = TARGET_WAITKIND_EXITED;
- last_status.value.sig = GDB_SIGNAL_KILL;
+ cs->ss->last_status.kind = TARGET_WAITKIND_EXITED;
+ cs->ss->last_status.value.sig = GDB_SIGNAL_KILL;
return 0;
}
else
@@ -4273,27 +4416,27 @@ process_serial_event (void)
case 'T':
{
- require_running_or_break (own_buf);
+ require_running_or_break (cs->own_buf);
- ptid_t thread_id = read_ptid (&own_buf[1], NULL);
+ ptid_t thread_id = read_ptid (&cs->own_buf[1], NULL);
if (find_thread_ptid (thread_id) == NULL)
{
- write_enn (own_buf);
+ write_enn (cs->own_buf);
break;
}
if (mythread_alive (thread_id))
- write_ok (own_buf);
+ write_ok (cs->own_buf);
else
- write_enn (own_buf);
+ write_enn (cs->own_buf);
}
break;
case 'R':
- response_needed = 0;
+ cs->response_needed = 0;
/* Restarting the inferior is only supported in the extended
protocol. */
- if (extended_protocol)
+ if (cs->extended_protocol)
{
if (target_running ())
for_each_process (kill_inferior_callback);
@@ -4301,26 +4444,26 @@ process_serial_event (void)
fprintf (stderr, "GDBserver restarting\n");
/* Wait till we are at 1st instruction in prog. */
- if (program_name != NULL)
+ if (cs->program_name != NULL)
{
- create_inferior (program_name, program_args);
+ create_inferior (cs->program_name, cs->program_args);
- if (last_status.kind == TARGET_WAITKIND_STOPPED)
+ if (cs->ss->last_status.kind == TARGET_WAITKIND_STOPPED)
{
/* Stopped at the first instruction of the target
process. */
- general_thread = last_ptid;
+ cs->ss->general_thread = cs->ss->last_ptid;
}
else
{
/* Something went wrong. */
- general_thread = null_ptid;
+ cs->ss->general_thread = null_ptid;
}
}
else
{
- last_status.kind = TARGET_WAITKIND_EXITED;
- last_status.value.sig = GDB_SIGNAL_KILL;
+ cs->ss->last_status.kind = TARGET_WAITKIND_EXITED;
+ cs->ss->last_status.value.sig = GDB_SIGNAL_KILL;
}
return 0;
}
@@ -4329,30 +4472,30 @@ 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';
+ cs->own_buf[0] = '\0';
break;
}
case 'v':
/* Extended (long) request. */
- handle_v_requests (own_buf, packet_len, &new_packet_len);
+ handle_v_requests (cs->own_buf, cs->packet_length, &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';
+ cs->own_buf[0] = '\0';
break;
}
if (new_packet_len != -1)
- putpkt_binary (own_buf, new_packet_len);
+ putpkt_binary (cs->own_buf, new_packet_len);
else
- putpkt (own_buf);
+ putpkt (cs->own_buf);
- response_needed = 0;
+ cs->response_needed = 0;
- if (exit_requested)
+ if (cs->exit_requested)
return -1;
return 0;
@@ -4395,38 +4538,40 @@ push_stop_notification (ptid_t ptid, struct
target_waitstatus *status)
int
handle_target_event (int err, gdb_client_data client_data)
{
+ client_state *cs = get_client_state();
+
if (debug_threads)
debug_printf ("handling possible target event\n");
- last_ptid = mywait (minus_one_ptid, &last_status,
+ cs->ss->last_ptid = mywait (minus_one_ptid, &cs->ss->last_status,
TARGET_WNOHANG, 1);
- if (last_status.kind == TARGET_WAITKIND_NO_RESUMED)
+ if (cs->ss->last_status.kind == TARGET_WAITKIND_NO_RESUMED)
{
- if (gdb_connected () && report_no_resumed)
- push_stop_notification (null_ptid, &last_status);
+ if (gdb_connected () && cs->report_no_resumed)
+ push_stop_notification (null_ptid, &cs->ss->last_status);
}
- else if (last_status.kind != TARGET_WAITKIND_IGNORE)
+ else if (cs->ss->last_status.kind != TARGET_WAITKIND_IGNORE)
{
- int pid = ptid_get_pid (last_ptid);
+ int pid = ptid_get_pid (cs->ss->last_ptid);
struct process_info *process = find_process_pid (pid);
int forward_event = !gdb_connected () || process->gdb_detached;
- if (last_status.kind == TARGET_WAITKIND_EXITED
- || last_status.kind == TARGET_WAITKIND_SIGNALLED)
+ if (cs->ss->last_status.kind == TARGET_WAITKIND_EXITED
+ || cs->ss->last_status.kind == TARGET_WAITKIND_SIGNALLED)
{
mark_breakpoints_out (process);
- target_mourn_inferior (last_ptid);
+ target_mourn_inferior (cs->ss->last_ptid);
}
- else if (last_status.kind == TARGET_WAITKIND_THREAD_EXITED)
+ else if (cs->ss->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_thread->last_resume_kind = resume_stop;
- current_thread->last_status = last_status;
+ cs->ss->current_thread->last_resume_kind = resume_stop;
+ cs->ss->current_thread->last_status = cs->ss->last_status;
}
if (forward_event)
@@ -4437,9 +4582,9 @@ handle_target_event (int err, gdb_client_data
client_data)
exit (0);
}
- if (last_status.kind == TARGET_WAITKIND_EXITED
- || last_status.kind == TARGET_WAITKIND_SIGNALLED
- || last_status.kind == TARGET_WAITKIND_THREAD_EXITED)
+ if (cs->ss->last_status.kind == TARGET_WAITKIND_EXITED
+ || cs->ss->last_status.kind == TARGET_WAITKIND_SIGNALLED
+ || cs->ss->last_status.kind == TARGET_WAITKIND_THREAD_EXITED)
;
else
{
@@ -4451,18 +4596,18 @@ handle_target_event (int err, gdb_client_data
client_data)
if (debug_threads)
debug_printf ("GDB not connected; forwarding event %d for"
" [%s]\n",
- (int) last_status.kind,
- target_pid_to_str (last_ptid));
+ (int) cs->ss->last_status.kind,
+ target_pid_to_str (cs->ss->last_ptid));
- if (last_status.kind == TARGET_WAITKIND_STOPPED)
- signal = last_status.value.sig;
+ if (cs->ss->last_status.kind == TARGET_WAITKIND_STOPPED)
+ signal = cs->ss->last_status.value.sig;
else
signal = GDB_SIGNAL_0;
- target_continue (last_ptid, signal);
+ target_continue (cs->ss->last_ptid, signal);
}
}
else
- push_stop_notification (last_ptid, &last_status);
+ push_stop_notification (cs->ss->last_ptid, &cs->ss->last_status);
}
/* Be sure to not change the selected thread behind GDB's back.
diff --git a/gdb/gdbserver/server.h b/gdb/gdbserver/server.h
index 5970431d8ed..8e1459f74e2 100644
--- a/gdb/gdbserver/server.h
+++ b/gdb/gdbserver/server.h
@@ -60,52 +60,19 @@ int vsnprintf(char *str, size_t size, const char
*format, va_list ap);
#include "gdb_signals.h"
#include "target.h"
#include "mem-break.h"
-#include "gdbthread.h"
-#include "inferiors.h"
#include "environ.h"
+#include <list>
+#include <map>
/* Target-specific functions */
void initialize_low ();
-/* Public variables in server.c */
-
-extern ptid_t cont_thread;
-extern ptid_t general_thread;
-
-extern int server_waiting;
-extern int pass_signals[];
-extern int program_signals[];
-extern int program_signals_p;
-
extern int disable_packet_vCont;
extern int disable_packet_Tthread;
extern int disable_packet_qC;
extern int disable_packet_qfThreadInfo;
-extern char *own_buf;
-
-extern int run_once;
-extern int multi_process;
-extern int report_fork_events;
-extern int report_vfork_events;
-extern int report_exec_events;
-extern int report_thread_events;
-extern int non_stop;
-
-/* True if the "swbreak+" feature is active. In that case, GDB wants
- us to report whether a trap is explained by a software breakpoint
- and for the server to handle PC adjustment if necessary on this
- target. Only enabled if the target supports it. */
-extern int swbreak_feature;
-
-/* True if the "hwbreak+" feature is active. In that case, GDB wants
- us to report whether a trap is explained by a hardware breakpoint.
- Only enabled if the target supports it. */
-extern int hwbreak_feature;
-
-extern int disable_randomization;
-
#if USE_WIN32API
#include <winsock2.h>
typedef SOCKET gdb_fildes_t;
@@ -158,8 +125,161 @@ extern void post_fork_inferior (int pid, const
char *program);
/* Get the gdb_environ being used in the current session. */
extern gdb_environ *get_environ ();
-extern target_waitstatus last_status;
-extern ptid_t last_ptid;
-extern unsigned long signal_pid;
+// extern ptid_t cs->ss->last_ptid;
+// extern unsigned long cs->ss->signal_pid;
#endif /* SERVER_H */
+
+/* Description of the remote protocol state for the currently
+ connected target. This is per-target state, and independent of the
+ selected architecture. */
+
+struct server_state
+{
+ int attach_count;
+ /* From server.c */
+ /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
+ `vCont'. Note the multi-process extensions made `vCont' a
+ 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. */
+ ptid_t cont_thread;
+ /* The thread set with an `Hg' packet. */
+ ptid_t general_thread;
+ /* 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
+ when no longer debugging it. */
+
+ unsigned long signal_pid;
+ /* Last status reported to GDB. */
+ struct target_waitstatus last_status;
+ /* Was last status an exit status? (sticky if yes) */
+ int last_status_exited;
+ ptid_t last_ptid;
+ unsigned char *mem_buf;
+
+ /* from remote-utils.c */
+ /* Internal buffer used by readchar.
+ These are global to readchar because reschedule_remote needs to be
+ able to tell whether the buffer is empty. */
+ unsigned char readchar_buf[BUFSIZ];
+ int readchar_bufcnt;
+ unsigned char *readchar_bufp;
+ /* from inferiors.c */
+ std::list<process_info *> all_processes;
+ std::list<thread_info *> all_threads;
+
+ struct thread_info *current_thread;
+};
+
+typedef struct server_state server_state;
+
+
+enum packet_types { other_packet, vContc, vConts, vContt, vRun,
vAttach, Hg, g_or_m, vStopped };
+typedef enum packet_types packet_types;
+
+enum exit_types { no_exit, have_exit, sent_exit };
+typedef enum exit_types exit_types;
+
+
+struct client_state
+{
+ gdb_fildes_t file_desc;
+ int attached_to_client;
+ int packet_type;
+ int last_packet_type;
+ int pending;
+ int nonstop_pending;
+ int catch_syscalls;
+ ptid_t last_cont_ptid;
+ ptid_t new_general_thread;
+
+ /* From server.c */
+ int server_waiting;
+
+ int extended_protocol;
+ int response_needed;
+ int exit_requested;
+
+ /* --once: Exit after the first connection has closed. */
+ 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. */
+ int report_no_resumed;
+ int non_stop;
+ /* True if the "swbreak+" feature is active. In that case, GDB wants
+ us to report whether a trap is explained by a software breakpoint
+ and for the server to handle PC adjustment if necessary on this
+ target. Only enabled if the target supports it. */
+ int swbreak_feature;
+ /* True if the "hwbreak+" feature is active. In that case, GDB wants
+ us to report whether a trap is explained by a hardware breakpoint.
+ Only enabled if the target supports it. */
+ 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. */
+ int vCont_supported;
+
+ /* Whether we should attempt to disable the operating system's address
+ space randomization feature before starting an inferior. */
+ int disable_randomization;
+
+ char *program_name = NULL;
+ std::vector<char *> program_args;
+ std::string wrapper_argv;
+
+ int packet_length;
+
+ int pass_signals[GDB_SIGNAL_LAST];
+ int program_signals[GDB_SIGNAL_LAST];
+ int program_signals_p;
+
+ char *notify_buffer;
+ /* Renamed from own_buf to avoid macro name conflict with a common
local variable name */
+ char *own_buf;
+
+ /* from remote-utils.c */
+ int remote_debug;
+ /* If true, then GDB has requested noack mode. */
+ int noack_mode;
+ /* If true, then we tell GDB to use noack mode by default. */
+ int transport_is_reliable;
+
+ server_state *ss;
+
+ client_state () {};
+ client_state (gdb_fildes_t, client_state*);
+};
+
+typedef struct client_state client_state;
+
+
+struct multi_client_states
+{
+public:
+ std::map<gdb_fildes_t,client_state*> cs;
+ client_state *current_cs;
+
+ client_state* get_client_state (void) { return current_cs; }
+ void set_current_client (client_state* p_cs) { current_cs = p_cs; }
+
+ client_state * set_client_state (gdb_fildes_t);
+ void free_client_state (client_state *cs);
+ void delete_client_state (gdb_fildes_t fd);
+};
+
+client_state* get_client_state (void);
+struct multi_client_states * get_client_states (void);
+
+
+#include "gdbthread.h"
+#include "inferiors.h"
diff --git a/gdb/gdbserver/spu-low.c b/gdb/gdbserver/spu-low.c
index fd1f8d652c6..5d51a420586 100644
--- a/gdb/gdbserver/spu-low.c
+++ b/gdb/gdbserver/spu-low.c
@@ -280,12 +280,12 @@ spu_ptrace_fun ()
static int
spu_create_inferior (const char *program,
- const std::vector<char *> &program_args)
+ const std::vector<char *> &cs->program_args)
{
int pid;
ptid_t ptid;
struct process_info *proc;
- std::string str_program_args = stringify_argv (program_args);
+ std::string str_program_args = stringify_argv (cs->program_args);
pid = fork_inferior (program,
str_program_args.c_str (),
@@ -439,7 +439,7 @@ spu_wait (ptid_t ptid, struct target_waitstatus
*ourstatus, int options)
/* On the first wait, continue running the inferior until we are
blocked inside an spu_run system call. */
- if (!server_waiting)
+ if (!cs->server_waiting)
{
int fd;
CORE_ADDR addr;
@@ -470,7 +470,7 @@ spu_wait (ptid_t ptid, struct target_waitstatus
*ourstatus, int options)
/* After attach, we may have received a SIGSTOP. Do not return this
as signal to GDB, or else it will try to continue with SIGSTOP
... */
- if (!server_waiting)
+ if (!cs->server_waiting)
{
ourstatus->kind = TARGET_WAITKIND_STOPPED;
ourstatus->value.sig = GDB_SIGNAL_0;
diff --git a/gdb/gdbserver/target.c b/gdb/gdbserver/target.c
index 019f9748346..38ad8b3341f 100644
--- a/gdb/gdbserver/target.c
+++ b/gdb/gdbserver/target.c
@@ -26,10 +26,11 @@ struct target_ops *the_target;
int
set_desired_thread ()
{
- thread_info *found = find_thread_ptid (general_thread);
+ client_state *cs = get_client_state();
+ thread_info *found = find_thread_ptid (cs->ss->general_thread);
- current_thread = found;
- return (current_thread != NULL);
+ cs->ss->current_thread = found;
+ return (cs->ss->current_thread != NULL);
}
/* The thread that was current before prepare_to_access_memory was
@@ -42,6 +43,8 @@ static ptid_t prev_general_thread;
int
prepare_to_access_memory (void)
{
+ client_state *cs = get_client_state();
+
/* The first thread found. */
struct thread_info *first = NULL;
/* The first stopped thread found. */
@@ -51,7 +54,7 @@ prepare_to_access_memory (void)
/* Save the general thread value, since prepare_to_access_memory
could change
it. */
- prev_general_thread = general_thread;
+ prev_general_thread = cs->ss->general_thread;
if (the_target->prepare_to_access_memory != NULL)
{
@@ -97,8 +100,8 @@ prepare_to_access_memory (void)
return 1;
}
- current_thread = thread;
- general_thread = ptid_of (thread);
+ cs->ss->current_thread = thread;
+ cs->ss->general_thread = ptid_of (thread);
return 0;
}
@@ -108,12 +111,14 @@ prepare_to_access_memory (void)
void
done_accessing_memory (void)
{
+ client_state *cs = get_client_state();
+
if (the_target->done_accessing_memory != NULL)
the_target->done_accessing_memory ();
/* Restore the previous selected thread. */
- general_thread = prev_general_thread;
- switch_to_thread (general_thread);
+ cs->ss->general_thread = prev_general_thread;
+ switch_to_thread (cs->ss->general_thread);
}
int
@@ -176,10 +181,11 @@ ptid_t
mywait (ptid_t ptid, struct target_waitstatus *ourstatus, int options,
int connected_wait)
{
+ client_state *cs = get_client_state();
ptid_t ret;
if (connected_wait)
- server_waiting = 1;
+ cs->server_waiting = 1;
ret = target_wait (ptid, ourstatus, options);
@@ -206,7 +212,7 @@ mywait (ptid_t ptid, struct target_waitstatus
*ourstatus, int options,
}
if (connected_wait)
- server_waiting = 0;
+ cs->server_waiting = 0;
return ret;
}
@@ -216,8 +222,9 @@ mywait (ptid_t ptid, struct target_waitstatus
*ourstatus, int options,
void
target_stop_and_wait (ptid_t ptid)
{
+ client_state *cs = get_client_state();
struct target_waitstatus status;
- int was_non_stop = non_stop;
+ int was_non_stop = cs->non_stop;
struct thread_resume resume_info;
resume_info.thread = ptid;
@@ -225,9 +232,9 @@ target_stop_and_wait (ptid_t ptid)
resume_info.sig = GDB_SIGNAL_0;
(*the_target->resume) (&resume_info, 1);
- non_stop = 1;
+ cs->non_stop = 1;
mywait (ptid, &status, 0, 0);
- non_stop = was_non_stop;
+ cs->non_stop = was_non_stop;
}
/* See target/target.h. */
diff --git a/gdb/gdbserver/tdesc.c b/gdb/gdbserver/tdesc.c
index c39b5e7d27e..9b1c398e53a 100644
--- a/gdb/gdbserver/tdesc.c
+++ b/gdb/gdbserver/tdesc.c
@@ -60,7 +60,9 @@ copy_target_description (struct target_desc *dest,
const struct target_desc *
current_target_desc (void)
{
- if (current_thread == NULL)
+ client_state *cs = get_client_state();
+
+ if (cs->ss->current_thread == NULL)
return &default_description;
return current_process ()->tdesc;
diff --git a/gdb/gdbserver/thread-db.c b/gdb/gdbserver/thread-db.c
index 812aa0f61f1..f9f31c6878a 100644
--- a/gdb/gdbserver/thread-db.c
+++ b/gdb/gdbserver/thread-db.c
@@ -308,6 +308,7 @@ find_new_threads_callback (const td_thrhandle_t
*th_p, void *data)
static void
thread_db_find_new_threads (void)
{
+ client_state *cs = get_client_state();
td_err_e err;
ptid_t ptid = current_ptid;
struct thread_db *thread_db = current_process ()->priv->thread_db;
@@ -386,6 +387,7 @@ int
thread_db_get_tls_address (struct thread_info *thread, CORE_ADDR offset,
CORE_ADDR load_module, CORE_ADDR *address)
{
+ client_state *cs = get_client_state();
psaddr_t addr;
td_err_e err;
struct lwp_info *lwp;
@@ -412,8 +414,8 @@ thread_db_get_tls_address (struct thread_info
*thread, CORE_ADDR offset,
if (!lwp->thread_known)
return TD_NOTHR;
- saved_thread = current_thread;
- current_thread = thread;
+ saved_thread = cs->ss->current_thread;
+ cs->ss->current_thread = thread;
if (load_module != 0)
{
@@ -436,7 +438,7 @@ thread_db_get_tls_address (struct thread_info
*thread, CORE_ADDR offset,
addr = (char *) addr + offset;
}
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
if (err == TD_OK)
{
*address = (CORE_ADDR) (uintptr_t) addr;
@@ -772,9 +774,10 @@ thread_db_init (void)
static void
switch_to_process (struct process_info *proc)
{
+ client_state *cs = get_client_state();
int pid = pid_of (proc);
- current_thread = find_any_thread_of_pid (pid);
+ cs->ss->current_thread = find_any_thread_of_pid (pid);
}
/* Disconnect from libthread_db and free resources. */
@@ -782,6 +785,7 @@ switch_to_process (struct process_info *proc)
static void
disable_thread_event_reporting (struct process_info *proc)
{
+ client_state *cs = get_client_state();
struct thread_db *thread_db = proc->priv->thread_db;
if (thread_db)
{
@@ -798,7 +802,7 @@ disable_thread_event_reporting (struct process_info
*proc)
if (td_ta_clear_event_p != NULL)
{
- struct thread_info *saved_thread = current_thread;
+ struct thread_info *saved_thread = cs->ss->current_thread;
td_thr_events_t events;
switch_to_process (proc);
@@ -808,7 +812,7 @@ disable_thread_event_reporting (struct process_info
*proc)
td_event_fillset (&events);
(*td_ta_clear_event_p) (thread_db->thread_agent, &events);
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
}
}
}
@@ -893,6 +897,7 @@ thread_db_handle_monitor_command (char *mon)
void
thread_db_notice_clone (struct thread_info *parent_thr, ptid_t child_ptid)
{
+ client_state *cs = get_client_state();
process_info *parent_proc = get_thread_process (parent_thr);
struct thread_db *thread_db = parent_proc->priv->thread_db;
@@ -905,7 +910,7 @@ thread_db_notice_clone (struct thread_info
*parent_thr, ptid_t child_ptid)
the current thread. Temporarily switch to a thread we know is
stopped. */
scoped_restore restore_current_thread
- = make_scoped_restore (¤t_thread, parent_thr);
+ = make_scoped_restore (&cs->ss->current_thread, parent_thr);
if (!find_one_thread (child_ptid))
warning ("Cannot find thread after clone.\n");
diff --git a/gdb/gdbserver/tracepoint.c b/gdb/gdbserver/tracepoint.c
index 41727561925..4873ecf8b44 100644
--- a/gdb/gdbserver/tracepoint.c
+++ b/gdb/gdbserver/tracepoint.c
@@ -2343,10 +2343,11 @@ find_next_traceframe_by_tracepoint (int num, int
*tfnump)
static void
cmd_qtinit (char *packet)
{
+ client_state *cs = get_client_state();
struct trace_state_variable *tsv, *prev, *next;
/* Can't do this command without a pid attached. */
- if (current_thread == NULL)
+ if (cs->ss->current_thread == NULL)
{
write_enn (packet);
return;
@@ -3959,22 +3960,23 @@ cmd_qtstmat (char *packet)
void
gdb_agent_about_to_close (int pid)
{
+ client_state *cs = get_client_state();
char buf[IPA_CMD_BUF_SIZE];
if (!maybe_write_ipa_not_loaded (buf))
{
struct thread_info *saved_thread;
- saved_thread = current_thread;
+ saved_thread = cs->ss->current_thread;
/* Find any thread which belongs to process PID. */
- current_thread = find_any_thread_of_pid (pid);
+ cs->ss->current_thread = find_any_thread_of_pid (pid);
strcpy (buf, "close");
run_inferior_command (buf, strlen (buf) + 1);
- current_thread = saved_thread;
+ cs->ss->current_thread = saved_thread;
}
}
@@ -3984,7 +3986,9 @@ gdb_agent_about_to_close (int pid)
static void
cmd_qtminftpilen (char *packet)
{
- if (current_thread == NULL)
+ client_state *cs = get_client_state();
+
+ if (cs->ss->current_thread == NULL)
{
/* Indicate that the minimum length is currently unknown. */
strcpy (packet, "0");
@@ -6833,6 +6837,7 @@ static struct ltt_available_probe gdb_ust_probe =
static int
run_inferior_command (char *cmd, int len)
{
+ client_state *cs = get_client_state();
int err = -1;
int pid = ptid_get_pid (current_ptid);
diff --git a/gdb/gdbserver/win32-i386-low.c b/gdb/gdbserver/win32-i386-low.c
index a242f7258af..04e8b13c66f 100644
--- a/gdb/gdbserver/win32-i386-low.c
+++ b/gdb/gdbserver/win32-i386-low.c
@@ -54,7 +54,7 @@ x86_dr_low_set_addr (int regnum, CORE_ADDR addr)
gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
/* Only update the threads of this process. */
- for_each_thread (current_thread->id.pid (), update_debug_registers);
+ for_each_thread (cs->ss->current_thread->id.pid (),
update_debug_registers);
}
/* Update the inferior's DR7 debug control register from STATE. */
@@ -63,7 +63,7 @@ static void
x86_dr_low_set_control (unsigned long control)
{
/* Only update the threads of this process. */
- for_each_thread (current_thread->id.pid (), update_debug_registers);
+ for_each_thread (cs->ss->current_thread->id.pid (),
update_debug_registers);
}
/* Return the current value of a DR register of the current thread's
@@ -73,7 +73,7 @@ static DWORD64
win32_get_current_dr (int dr)
{
win32_thread_info *th
- = (win32_thread_info *) thread_target_data (current_thread);
+ = (win32_thread_info *) thread_target_data (cs->ss->current_thread);
win32_require_context (th);
diff --git a/gdb/gdbserver/win32-low.c b/gdb/gdbserver/win32-low.c
index b1d9b51e533..9ae5829d546 100644
--- a/gdb/gdbserver/win32-low.c
+++ b/gdb/gdbserver/win32-low.c
@@ -242,7 +242,7 @@ static void
child_delete_thread (DWORD pid, DWORD tid)
{
/* If the last thread is exiting, just return. */
- if (all_threads.size () == 1)
+ if (cs->ss->all_threads.size () == 1)
return;
thread_info *thread = find_thread_ptid (ptid_t (pid, tid));
@@ -622,7 +622,7 @@ Could not convert the expanded inferior cwd to
wide-char."));
process with the process list. */
static int
win32_create_inferior (const char *program,
- const std::vector<char *> &program_args)
+ const std::vector<char *> &cs->program_args)
{
#ifndef USE_WIN32API
char real_path[PATH_MAX];
@@ -634,7 +634,7 @@ win32_create_inferior (const char *program,
int argc;
PROCESS_INFORMATION pi;
DWORD err;
- std::string str_program_args = stringify_argv (program_args);
+ std::string str_program_args = stringify_argv (cs->program_args);
char *args = (char *) str_program_args.c_str ();
/* win32_wait needs to know we're not attaching. */
@@ -776,7 +776,7 @@ handle_output_debug_string (void)
if (!startswith (s, "cYg"))
{
- if (!server_waiting)
+ if (!cs->server_waiting)
{
OUTMSG2(("%s", s));
return;
@@ -1472,7 +1472,7 @@ get_child_debug_event (struct target_waitstatus
*ourstatus)
child_delete_thread (current_event.dwProcessId,
current_event.dwThreadId);
- current_thread = get_first_thread ();
+ cs->ss->current_thread = get_first_thread ();
return 1;
case CREATE_PROCESS_DEBUG_EVENT:
@@ -1570,7 +1570,7 @@ get_child_debug_event (struct target_waitstatus
*ourstatus)
}
ptid = debug_event_ptid (¤t_event);
- current_thread = find_thread_ptid (ptid);
+ cs->ss->current_thread = find_thread_ptid (ptid);
return 1;
}
@@ -1610,7 +1610,7 @@ win32_wait (ptid_t ptid, struct target_waitstatus
*ourstatus, int options)
OUTMSG2 (("Child Stopped with signal = %d \n",
ourstatus->value.sig));
- regcache = get_thread_regcache (current_thread, 1);
+ regcache = get_thread_regcache (cs->ss->current_thread, 1);
child_fetch_inferior_registers (regcache, -1);
return debug_event_ptid (¤t_event);
default:
diff --git a/gdb/gnulib/import/error.c b/gdb/gnulib/import/error.c
index b3b1286a350..1d151112ca5 100644
--- a/gdb/gnulib/import/error.c
+++ b/gdb/gnulib/import/error.c
@@ -65,7 +65,7 @@ unsigned int error_message_count;
#ifdef _LIBC
/* In the GNU C library, there is a predefined variable for this. */
-# define program_name program_invocation_name
+# define cs->program_name program_invocation_name
# include <errno.h>
# include <limits.h>
# include <libio/libioP.h>
@@ -115,7 +115,7 @@ int strerror_r ();
# endif
# endif
-#define program_name getprogname ()
+#define cs->program_name getprogname ()
# if HAVE_STRERROR_R || defined strerror_r
# define __strerror_r strerror_r
@@ -310,9 +310,9 @@ error (int status, int errnum, const char *message, ...)
else
{
#if _LIBC
- __fxprintf (NULL, "%s: ", program_name);
+ __fxprintf (NULL, "%s: ", cs->program_name);
#else
- fprintf (stderr, "%s: ", program_name);
+ fprintf (stderr, "%s: ", cs->program_name);
#endif
}
@@ -372,9 +372,9 @@ error_at_line (int status, int errnum, const char
*file_name,
else
{
#if _LIBC
- __fxprintf (NULL, "%s:", program_name);
+ __fxprintf (NULL, "%s:", cs->program_name);
#else
- fprintf (stderr, "%s:", program_name);
+ fprintf (stderr, "%s:", cs->program_name);
#endif
}
diff --git a/gdb/nat/linux-personality.h b/gdb/nat/linux-personality.h
index 229cc3ef1c9..3f2e0724c49 100644
--- a/gdb/nat/linux-personality.h
+++ b/gdb/nat/linux-personality.h
@@ -27,7 +27,7 @@ public:
/* Disable the inferior's address space randomization if
DISABLE_RANDOMIZATION is not zero and if we have
<sys/personality.h>. */
- maybe_disable_address_space_randomization (int disable_randomization);
+ maybe_disable_address_space_randomization (int p_disable_randomization);
/* On destruction, re-enable address space randomization. */
~maybe_disable_address_space_randomization ();