1 /* Inferior process information for the remote server for GDB.
2 Copyright (C) 2002-2017 Free Software Foundation, Inc.
4 Contributed by MontaVista Software.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "gdbthread.h"
25 std::list
<process_info
*> all_processes
;
26 std::list
<thread_info
*> all_threads
;
28 struct thread_info
*current_thread
;
30 /* The current working directory used to start the inferior. */
31 static const char *current_inferior_cwd
= NULL
;
34 find_inferior (std::list
<thread_info
*> *thread_list
,
35 int (*func
) (thread_info
*, void *),
38 gdb_assert (thread_list
== &all_threads
);
40 return find_thread ([&] (thread_info
*thread
) {
41 return func (thread
, arg
);
46 find_inferior_id (std::list
<thread_info
*> *thread_list
, ptid_t id
)
48 gdb_assert (thread_list
== &all_threads
);
50 return find_thread ([&] (thread_info
*thread
) {
51 return thread
->id
== id
;
56 find_inferior_in_random (std::list
<thread_info
*> *thread_list
,
57 int (*func
) (thread_info
*, void *),
60 gdb_assert (thread_list
== &all_threads
);
62 return find_thread_in_random ([&] (thread_info
*thread
) {
63 return func (thread
, arg
);
68 for_each_inferior (std::list
<thread_info
*> *thread_list
,
69 void (*action
) (thread_info
*))
71 gdb_assert (thread_list
== &all_threads
);
73 for_each_thread ([&] (thread_info
*thread
) {
79 for_each_inferior_with_data (std::list
<thread_info
*> *thread_list
,
80 void (*action
) (thread_info
*, void *),
83 gdb_assert (thread_list
== &all_threads
);
85 for_each_thread ([&] (thread_info
*thread
) {
86 action (thread
, data
);
91 add_thread (ptid_t thread_id
, void *target_data
)
93 struct thread_info
*new_thread
= XCNEW (struct thread_info
);
95 new_thread
->id
= thread_id
;
96 new_thread
->last_resume_kind
= resume_continue
;
97 new_thread
->last_status
.kind
= TARGET_WAITKIND_IGNORE
;
99 all_threads
.push_back (new_thread
);
101 if (current_thread
== NULL
)
102 current_thread
= new_thread
;
104 new_thread
->target_data
= target_data
;
109 /* See gdbthread.h. */
112 get_first_thread (void)
114 if (!all_threads
.empty ())
115 return all_threads
.front ();
121 find_thread_ptid (ptid_t ptid
)
123 return (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
126 /* Find a thread associated with the given PROCESS, or NULL if no
127 such thread exists. */
129 static struct thread_info
*
130 find_thread_process (const struct process_info
*const process
)
132 return find_any_thread_of_pid (process
->pid
);
135 /* See gdbthread.h. */
138 find_any_thread_of_pid (int pid
)
140 return find_thread (pid
, [] (thread_info
*thread
) {
146 free_one_thread (thread_info
*thread
)
148 free_register_cache (thread_regcache_data (thread
));
153 remove_thread (struct thread_info
*thread
)
155 if (thread
->btrace
!= NULL
)
156 target_disable_btrace (thread
->btrace
);
158 discard_queued_stop_replies (ptid_of (thread
));
159 all_threads
.remove (thread
);
160 free_one_thread (thread
);
161 if (current_thread
== thread
)
162 current_thread
= NULL
;
166 thread_target_data (struct thread_info
*thread
)
168 return thread
->target_data
;
172 thread_regcache_data (struct thread_info
*thread
)
174 return thread
->regcache_data
;
178 set_thread_regcache_data (struct thread_info
*thread
, struct regcache
*data
)
180 thread
->regcache_data
= data
;
184 clear_inferiors (void)
186 for_each_inferior (&all_threads
, free_one_thread
);
187 all_threads
.clear ();
191 current_thread
= NULL
;
194 struct process_info
*
195 add_process (int pid
, int attached
)
197 process_info
*process
= new process_info (pid
, attached
);
199 all_processes
.push_back (process
);
204 /* Remove a process from the common process list and free the memory
206 The caller is responsible for freeing private data first. */
209 remove_process (struct process_info
*process
)
211 clear_symbol_cache (&process
->symbol_cache
);
212 free_all_breakpoints (process
);
213 gdb_assert (find_thread_process (process
) == NULL
);
214 all_processes
.remove (process
);
219 find_process_pid (int pid
)
221 return find_process ([&] (process_info
*process
) {
222 return process
->pid
== pid
;
226 /* Get the first process in the process list, or NULL if the list is empty. */
229 get_first_process (void)
231 if (!all_processes
.empty ())
232 return all_processes
.front ();
237 /* Return non-zero if there are any inferiors that we have created
238 (as opposed to attached-to). */
241 have_started_inferiors_p (void)
243 return find_process ([] (process_info
*process
) {
244 return !process
->attached
;
248 /* Return non-zero if there are any inferiors that we have attached to. */
251 have_attached_inferiors_p (void)
253 return find_process ([] (process_info
*process
) {
254 return process
->attached
;
258 struct process_info
*
259 get_thread_process (const struct thread_info
*thread
)
261 return find_process_pid (thread
->id
.pid ());
264 struct process_info
*
265 current_process (void)
267 gdb_assert (current_thread
!= NULL
);
268 return get_thread_process (current_thread
);
272 do_restore_current_thread_cleanup (void *arg
)
274 current_thread
= (struct thread_info
*) arg
;
278 make_cleanup_restore_current_thread (void)
280 return make_cleanup (do_restore_current_thread_cleanup
, current_thread
);
283 /* See common/common-gdbthread.h. */
286 switch_to_thread (ptid_t ptid
)
288 gdb_assert (ptid
!= minus_one_ptid
);
289 current_thread
= find_thread_ptid (ptid
);
292 /* See common/common-inferior.h. */
297 return current_inferior_cwd
;
300 /* See common/common-inferior.h. */
303 set_inferior_cwd (const char *cwd
)
305 xfree ((void *) current_inferior_cwd
);
307 current_inferior_cwd
= xstrdup (cwd
);
309 current_inferior_cwd
= NULL
;