1 /* Ada Ravenscar thread support.
3 Copyright 2004, 2009, 2010, 2011 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "gdbthread.h"
27 #include "ravenscar-thread.h"
29 #include "gdb_string.h"
34 /* If non-null, ravenscar task support is enabled. */
35 static int ravenscar_task_support
= 1;
37 /* Non-null if the ravenscar thread layer has been pushed on the target
39 static int ravenscar_is_open
= 0;
41 /* This module's target-specific operations. */
42 static struct target_ops ravenscar_ops
;
44 /* Some base target uses a special value for the null PID (exempli gratia
46 static ptid_t base_magic_null_ptid
;
48 /* Ptid of the inferior as seen by the process stratum. */
49 static ptid_t base_ptid
;
51 static const char running_thread_name
[] = "__gnat_running_thread_table";
53 static const char known_tasks_name
[] = "system__tasking__debug__known_tasks";
55 static const char ravenscar_runtime_initializer
[] =
56 "system__bb__threads__initialize";
58 static struct observer
*update_target_observer
= NULL
;
60 /* Architecture-specific hooks. */
61 static struct ravenscar_arch_ops
* current_arch_ops
;
63 static void ravenscar_find_new_threads (struct target_ops
*ops
);
64 static ptid_t
ravenscar_running_thread (void);
65 static char *ravenscar_extra_thread_info (struct thread_info
*tp
);
66 static int ravenscar_thread_alive (struct target_ops
*ops
, ptid_t ptid
);
67 static void ravenscar_fetch_registers (struct target_ops
*ops
,
68 struct regcache
*regcache
, int regnum
);
69 static void ravenscar_store_registers (struct target_ops
*ops
,
70 struct regcache
*regcache
, int regnum
);
71 static void ravenscar_prepare_to_store (struct regcache
*regcache
);
72 static void ravenscar_initialize (char *name
, int from_tty
);
73 static void ravenscar_resume (struct target_ops
*ops
, ptid_t ptid
, int step
,
74 enum target_signal siggnal
);
75 static void ravenscar_mourn_inferior (struct target_ops
*ops
);
76 static void ravenscar_update_inferior_ptid (void);
77 static int has_ravenscar_runtime (void);
78 static int ravenscar_runtime_initialized (void);
79 static void ravenscar_inferior_created (struct target_ops
*target
,
82 /* Fetch the ravenscar running thread from target memory and
83 update inferior_ptid accordingly. */
86 ravenscar_update_inferior_ptid (void)
88 base_ptid
= inferior_ptid
;
90 /* If the runtime has not been initialized yet, the inferior_ptid is
91 the only ptid that there is. */
92 if (!ravenscar_runtime_initialized ())
95 /* Make sure we set base_ptid before calling ravenscar_running_thread
96 as the latter relies on it. */
97 inferior_ptid
= ravenscar_running_thread ();
98 gdb_assert (!ptid_equal (inferior_ptid
, null_ptid
));
100 /* The running thread may not have been added to
101 system.tasking.debug's list yet; so ravenscar_find_new_threads
102 may not always add it to the thread list. Add it here. */
103 if (!find_thread_ptid (inferior_ptid
))
104 add_thread (inferior_ptid
);
107 /* The Ravenscar Runtime exports a symbol which contains the ID of
108 the thread that is currently running. Try to locate that symbol
109 and return its associated minimal symbol.
110 Return NULL if not found. */
112 static struct minimal_symbol
*
113 get_running_thread_msymbol (void)
115 struct minimal_symbol
*msym
;
117 msym
= lookup_minimal_symbol (running_thread_name
, NULL
, NULL
);
119 /* Older versions of the GNAT runtime were using a different
120 (less ideal) name for the symbol where the active thread ID
121 is stored. If we couldn't find the symbol using the latest
122 name, then try the old one. */
123 msym
= lookup_minimal_symbol ("running_thread", NULL
, NULL
);
128 /* Return True if the Ada Ravenscar run-time can be found in the
132 has_ravenscar_runtime (void)
134 struct minimal_symbol
*msym_ravenscar_runtime_initializer
=
135 lookup_minimal_symbol (ravenscar_runtime_initializer
, NULL
, NULL
);
136 struct minimal_symbol
*msym_known_tasks
=
137 lookup_minimal_symbol (known_tasks_name
, NULL
, NULL
);
138 struct minimal_symbol
*msym_running_thread
= get_running_thread_msymbol ();
140 return (msym_ravenscar_runtime_initializer
142 && msym_running_thread
);
145 /* Return True if the Ada Ravenscar run-time can be found in the
146 application, and if it has been initialized on target. */
149 ravenscar_runtime_initialized (void)
151 return (!(ptid_equal (ravenscar_running_thread (), null_ptid
)));
154 /* Return the ID of the thread that is currently running.
155 Return 0 if the ID could not be determined. */
158 get_running_thread_id (void)
160 const struct minimal_symbol
*object_msym
= get_running_thread_msymbol ();
164 CORE_ADDR object_addr
;
165 struct type
*builtin_type_void_data_ptr
=
166 builtin_type (target_gdbarch
)->builtin_data_ptr
;
171 object_addr
= SYMBOL_VALUE_ADDRESS (object_msym
);
172 object_size
= TYPE_LENGTH (builtin_type_void_data_ptr
);
173 buf_size
= object_size
;
174 buf
= alloca (buf_size
);
175 read_memory (object_addr
, buf
, buf_size
);
176 return extract_typed_address (buf
, builtin_type_void_data_ptr
);
180 ravenscar_close (int quitting
)
182 ravenscar_is_open
= 0;
186 ravenscar_resume (struct target_ops
*ops
, ptid_t ptid
, int step
,
187 enum target_signal siggnal
)
189 struct target_ops
*beneath
= find_target_beneath (ops
);
191 inferior_ptid
= base_ptid
;
192 beneath
->to_resume (beneath
, base_ptid
, step
, siggnal
);
196 ravenscar_wait (struct target_ops
*ops
, ptid_t ptid
,
197 struct target_waitstatus
*status
,
200 struct target_ops
*beneath
= find_target_beneath (ops
);
202 inferior_ptid
= base_ptid
;
203 beneath
->to_wait (beneath
, base_ptid
, status
, 0);
204 ravenscar_find_new_threads (ops
);
205 ravenscar_update_inferior_ptid ();
206 return inferior_ptid
;
209 /* Add the thread associated to the given TASK to the thread list
210 (if the thread has already been added, this is a no-op). */
213 ravenscar_add_thread (struct ada_task_info
*task
)
215 if (find_thread_ptid (task
->ptid
) == NULL
)
216 add_thread (task
->ptid
);
220 ravenscar_find_new_threads (struct target_ops
*ops
)
222 ada_build_task_list (0);
224 /* Do not clear the thread list before adding the Ada task, to keep
225 the thread that the process stratum has included into it
226 (base_ptid) and the running thread, that may not have been included
227 to system.tasking.debug's list yet. */
229 iterate_over_live_ada_tasks (ravenscar_add_thread
);
233 ravenscar_running_thread (void)
235 CORE_ADDR tid
= get_running_thread_id ();
240 return ptid_build (ptid_get_pid (base_ptid
), 0, tid
);
244 ravenscar_extra_thread_info (struct thread_info
*tp
)
246 return "Ravenscar task";
250 ravenscar_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
252 /* Ravenscar tasks are non-terminating. */
257 ravenscar_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
261 snprintf (buf
, sizeof (buf
), "Thread %#x", (int) ptid_get_tid (ptid
));
266 ravenscar_fetch_registers (struct target_ops
*ops
,
267 struct regcache
*regcache
, int regnum
)
269 struct target_ops
*beneath
= find_target_beneath (ops
);
271 if (!ravenscar_runtime_initialized ()
272 || ptid_equal (inferior_ptid
, base_magic_null_ptid
)
273 || ptid_equal (inferior_ptid
, ravenscar_running_thread ()))
274 beneath
->to_fetch_registers (beneath
, regcache
, regnum
);
276 current_arch_ops
->to_fetch_registers (regcache
, regnum
);
280 ravenscar_store_registers (struct target_ops
*ops
,
281 struct regcache
*regcache
, int regnum
)
283 struct target_ops
*beneath
= find_target_beneath (ops
);
285 if (!ravenscar_runtime_initialized ()
286 || ptid_equal (inferior_ptid
, base_magic_null_ptid
)
287 || ptid_equal (inferior_ptid
, ravenscar_running_thread ()))
288 beneath
->to_store_registers (beneath
, regcache
, regnum
);
290 current_arch_ops
->to_store_registers (regcache
, regnum
);
294 ravenscar_prepare_to_store (struct regcache
*regcache
)
296 struct target_ops
*beneath
= find_target_beneath (&ravenscar_ops
);
298 if (!ravenscar_runtime_initialized ()
299 || ptid_equal (inferior_ptid
, base_magic_null_ptid
)
300 || ptid_equal (inferior_ptid
, ravenscar_running_thread ()))
301 beneath
->to_prepare_to_store (regcache
);
303 current_arch_ops
->to_prepare_to_store (regcache
);
307 ravenscar_mourn_inferior (struct target_ops
*ops
)
309 struct target_ops
*beneath
= find_target_beneath (&ravenscar_ops
);
311 base_ptid
= null_ptid
;
312 beneath
->to_mourn_inferior (beneath
);
313 unpush_target (&ravenscar_ops
);
316 /* Observer on inferior_created: push ravenscar thread stratum if needed. */
319 ravenscar_inferior_created (struct target_ops
*target
, int from_tty
)
321 if (ravenscar_task_support
322 && has_ravenscar_runtime ())
323 ravenscar_initialize (NULL
, 0);
327 ravenscar_register_arch_ops (struct ravenscar_arch_ops
*ops
)
329 /* FIXME: To be clean, we would need to handle a list of
330 architectures, just like in remote-wtx-hw.c. However, for now the
331 only Ravenscar run-time for bare board that is implemented in
332 GNAT is for only one architecture: erc32-elf. So no need to care about
334 current_arch_ops
= ops
;
337 /* Initialize Ravenscar support. */
340 ravenscar_initialize (char *name
, int from_tty
)
342 if (ravenscar_is_open
)
345 base_magic_null_ptid
= inferior_ptid
;
346 ravenscar_update_inferior_ptid ();
347 push_target (&ravenscar_ops
);
348 ravenscar_is_open
= 1;
352 ravenscar_get_ada_task_ptid (long lwp
, long thread
)
354 return ptid_build (ptid_get_pid (base_ptid
), 0, thread
);
358 init_ravenscar_thread_ops (void)
360 ravenscar_ops
.to_shortname
= "ravenscar";
361 ravenscar_ops
.to_longname
= "Ravenscar tasks.";
362 ravenscar_ops
.to_doc
= "Ravenscar tasks support.";
363 ravenscar_ops
.to_close
= ravenscar_close
;
364 ravenscar_ops
.to_resume
= ravenscar_resume
;
365 ravenscar_ops
.to_wait
= ravenscar_wait
;
366 ravenscar_ops
.to_fetch_registers
= ravenscar_fetch_registers
;
367 ravenscar_ops
.to_store_registers
= ravenscar_store_registers
;
368 ravenscar_ops
.to_prepare_to_store
= ravenscar_prepare_to_store
;
369 ravenscar_ops
.to_thread_alive
= ravenscar_thread_alive
;
370 ravenscar_ops
.to_find_new_threads
= ravenscar_find_new_threads
;
371 ravenscar_ops
.to_pid_to_str
= ravenscar_pid_to_str
;
372 ravenscar_ops
.to_extra_thread_info
= ravenscar_extra_thread_info
;
373 ravenscar_ops
.to_get_ada_task_ptid
= ravenscar_get_ada_task_ptid
;
374 ravenscar_ops
.to_mourn_inferior
= ravenscar_mourn_inferior
;
375 ravenscar_ops
.to_has_all_memory
= default_child_has_all_memory
;
376 ravenscar_ops
.to_has_memory
= default_child_has_memory
;
377 ravenscar_ops
.to_has_stack
= default_child_has_stack
;
378 ravenscar_ops
.to_has_registers
= default_child_has_registers
;
379 ravenscar_ops
.to_has_execution
= default_child_has_execution
;
380 ravenscar_ops
.to_stratum
= thread_stratum
;
381 ravenscar_ops
.to_magic
= OPS_MAGIC
;
384 /* Command-list for the "set/show ravenscar" prefix command. */
385 static struct cmd_list_element
*set_ravenscar_list
;
386 static struct cmd_list_element
*show_ravenscar_list
;
388 /* Implement the "set ravenscar" prefix command. */
391 set_ravenscar_command (char *arg
, int from_tty
)
393 printf_unfiltered (_(\
394 "\"set ravenscar\" must be followed by the name of a setting.\n"));
395 help_list (set_ravenscar_list
, "set ravenscar ", -1, gdb_stdout
);
398 /* Implement the "show ravenscar" prefix command. */
401 show_ravenscar_command (char *args
, int from_tty
)
403 cmd_show_list (show_ravenscar_list
, from_tty
, "");
406 /* Implement the "show ravenscar task-switching" command. */
409 show_ravenscar_task_switching_command (struct ui_file
*file
, int from_tty
,
410 struct cmd_list_element
*c
,
413 if (ravenscar_task_support
)
414 fprintf_filtered (file
, _("\
415 Support for Ravenscar task/thread switching is enabled\n"));
417 fprintf_filtered (file
, _("\
418 Support for Ravenscar task/thread switching is disabled\n"));
421 /* Module startup initialization function, automagically called by
425 _initialize_ravenscar (void)
427 init_ravenscar_thread_ops ();
428 base_ptid
= null_ptid
;
430 /* Notice when the inferior is created in order to push the
431 ravenscar ops if needed. */
432 observer_attach_inferior_created (ravenscar_inferior_created
);
434 add_target (&ravenscar_ops
);
436 add_prefix_cmd ("ravenscar", no_class
, set_ravenscar_command
,
437 _("Prefix command for changing Ravenscar-specific settings"),
438 &set_ravenscar_list
, "set ravenscar ", 0, &setlist
);
440 add_prefix_cmd ("ravenscar", no_class
, show_ravenscar_command
,
441 _("Prefix command for showing Ravenscar-specific settings"),
442 &show_ravenscar_list
, "show ravenscar ", 0, &showlist
);
444 add_setshow_boolean_cmd ("task-switching", class_obscure
,
445 &ravenscar_task_support
, _("\
446 Enable or disable support for GNAT Ravenscar tasks"), _("\
447 Show whether support for GNAT Ravenscar tasks is enabled"),
449 Enable or disable support for task/thread switching with the GNAT\n\
450 Ravenscar run-time library for bareboard configuration."),
451 NULL
, show_ravenscar_task_switching_command
,
452 &set_ravenscar_list
, &show_ravenscar_list
);