make calls to help_list use enumerator
[external/binutils.git] / gdb / ravenscar-thread.c
1 /* Ada Ravenscar thread support.
2
3    Copyright (C) 2004-2014 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
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.
11
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.
16
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/>.  */
19
20 #include "defs.h"
21 #include "gdbcore.h"
22 #include "gdbthread.h"
23 #include "ada-lang.h"
24 #include "target.h"
25 #include "inferior.h"
26 #include "command.h"
27 #include "ravenscar-thread.h"
28 #include "observer.h"
29 #include <string.h>
30 #include "gdbcmd.h"
31 #include "top.h"
32 #include "regcache.h"
33 #include "objfiles.h"
34
35 /* If non-null, ravenscar task support is enabled.  */
36 static int ravenscar_task_support = 1;
37
38 /* This module's target-specific operations.  */
39 static struct target_ops ravenscar_ops;
40
41 /* Some base target uses a special value for the null PID (exempli gratia
42    remote).  */
43 static ptid_t base_magic_null_ptid;
44
45 /* Ptid of the inferior as seen by the process stratum.  */
46 static ptid_t base_ptid;
47
48 static const char running_thread_name[] = "__gnat_running_thread_table";
49
50 static const char known_tasks_name[] = "system__tasking__debug__known_tasks";
51 static const char first_task_name[] = "system__tasking__debug__first_task";
52
53 static const char ravenscar_runtime_initializer[] =
54   "system__bb__threads__initialize";
55
56 static void ravenscar_find_new_threads (struct target_ops *ops);
57 static ptid_t ravenscar_running_thread (void);
58 static char *ravenscar_extra_thread_info (struct target_ops *self,
59                                           struct thread_info *tp);
60 static int ravenscar_thread_alive (struct target_ops *ops, ptid_t ptid);
61 static void ravenscar_fetch_registers (struct target_ops *ops,
62                                        struct regcache *regcache, int regnum);
63 static void ravenscar_store_registers (struct target_ops *ops,
64                                        struct regcache *regcache, int regnum);
65 static void ravenscar_prepare_to_store (struct target_ops *self,
66                                         struct regcache *regcache);
67 static void ravenscar_resume (struct target_ops *ops, ptid_t ptid, int step,
68                               enum gdb_signal siggnal);
69 static void ravenscar_mourn_inferior (struct target_ops *ops);
70 static void ravenscar_update_inferior_ptid (void);
71 static int has_ravenscar_runtime (void);
72 static int ravenscar_runtime_initialized (void);
73 static void ravenscar_inferior_created (struct target_ops *target,
74                                         int from_tty);
75
76 /* Fetch the ravenscar running thread from target memory and
77    update inferior_ptid accordingly.  */
78
79 static void
80 ravenscar_update_inferior_ptid (void)
81 {
82   base_ptid = inferior_ptid;
83
84   /* If the runtime has not been initialized yet, the inferior_ptid is
85      the only ptid that there is.  */
86   if (!ravenscar_runtime_initialized ())
87     return;
88
89   /* Make sure we set base_ptid before calling ravenscar_running_thread
90      as the latter relies on it.  */
91   inferior_ptid = ravenscar_running_thread ();
92   gdb_assert (!ptid_equal (inferior_ptid, null_ptid));
93
94   /* The running thread may not have been added to
95      system.tasking.debug's list yet; so ravenscar_find_new_threads
96      may not always add it to the thread list.  Add it here.  */
97   if (!find_thread_ptid (inferior_ptid))
98     add_thread (inferior_ptid);
99 }
100
101 /* The Ravenscar Runtime exports a symbol which contains the ID of
102    the thread that is currently running.  Try to locate that symbol
103    and return its associated minimal symbol.
104    Return NULL if not found.  */
105
106 static struct bound_minimal_symbol
107 get_running_thread_msymbol (void)
108 {
109   struct bound_minimal_symbol msym;
110
111   msym = lookup_minimal_symbol (running_thread_name, NULL, NULL);
112   if (!msym.minsym)
113     /* Older versions of the GNAT runtime were using a different
114        (less ideal) name for the symbol where the active thread ID
115        is stored.  If we couldn't find the symbol using the latest
116        name, then try the old one.  */
117     msym = lookup_minimal_symbol ("running_thread", NULL, NULL);
118
119   return msym;
120 }
121
122 /* Return True if the Ada Ravenscar run-time can be found in the
123    application.  */
124
125 static int
126 has_ravenscar_runtime (void)
127 {
128   struct bound_minimal_symbol msym_ravenscar_runtime_initializer =
129     lookup_minimal_symbol (ravenscar_runtime_initializer, NULL, NULL);
130   struct bound_minimal_symbol msym_known_tasks =
131     lookup_minimal_symbol (known_tasks_name, NULL, NULL);
132   struct bound_minimal_symbol msym_first_task =
133     lookup_minimal_symbol (first_task_name, NULL, NULL);
134   struct bound_minimal_symbol msym_running_thread
135     = get_running_thread_msymbol ();
136
137   return (msym_ravenscar_runtime_initializer.minsym
138           && (msym_known_tasks.minsym || msym_first_task.minsym)
139           && msym_running_thread.minsym);
140 }
141
142 /* Return True if the Ada Ravenscar run-time can be found in the
143    application, and if it has been initialized on target.  */
144
145 static int
146 ravenscar_runtime_initialized (void)
147 {
148   return (!(ptid_equal (ravenscar_running_thread (), null_ptid)));
149 }
150
151 /* Return the ID of the thread that is currently running.
152    Return 0 if the ID could not be determined.  */
153
154 static CORE_ADDR
155 get_running_thread_id (void)
156 {
157   struct bound_minimal_symbol object_msym = get_running_thread_msymbol ();
158   int object_size;
159   int buf_size;
160   gdb_byte *buf;
161   CORE_ADDR object_addr;
162   struct type *builtin_type_void_data_ptr =
163     builtin_type (target_gdbarch ())->builtin_data_ptr;
164
165   if (!object_msym.minsym)
166     return 0;
167
168   object_addr = BMSYMBOL_VALUE_ADDRESS (object_msym);
169   object_size = TYPE_LENGTH (builtin_type_void_data_ptr);
170   buf_size = object_size;
171   buf = alloca (buf_size);
172   read_memory (object_addr, buf, buf_size);
173   return extract_typed_address (buf, builtin_type_void_data_ptr);
174 }
175
176 static void
177 ravenscar_resume (struct target_ops *ops, ptid_t ptid, int step,
178                   enum gdb_signal siggnal)
179 {
180   struct target_ops *beneath = find_target_beneath (ops);
181
182   inferior_ptid = base_ptid;
183   beneath->to_resume (beneath, base_ptid, step, siggnal);
184 }
185
186 static ptid_t
187 ravenscar_wait (struct target_ops *ops, ptid_t ptid,
188                 struct target_waitstatus *status,
189                 int options)
190 {
191   struct target_ops *beneath = find_target_beneath (ops);
192
193   inferior_ptid = base_ptid;
194   beneath->to_wait (beneath, base_ptid, status, 0);
195   /* Find any new threads that might have been created, and update
196      inferior_ptid to the active thread.
197
198      Only do it if the program is still alive, though.  Otherwise,
199      this causes problems when debugging through the remote protocol,
200      because we might try switching threads (and thus sending packets)
201      after the remote has disconnected.  */
202   if (status->kind != TARGET_WAITKIND_EXITED
203       && status->kind != TARGET_WAITKIND_SIGNALLED)
204     {
205       ravenscar_find_new_threads (ops);
206       ravenscar_update_inferior_ptid ();
207     }
208   return inferior_ptid;
209 }
210
211 /* Add the thread associated to the given TASK to the thread list
212    (if the thread has already been added, this is a no-op).  */
213
214 static void
215 ravenscar_add_thread (struct ada_task_info *task)
216 {
217   if (find_thread_ptid (task->ptid) == NULL)
218     add_thread (task->ptid);
219 }
220
221 static void
222 ravenscar_find_new_threads (struct target_ops *ops)
223 {
224   ada_build_task_list ();
225
226   /* Do not clear the thread list before adding the Ada task, to keep
227      the thread that the process stratum has included into it
228      (base_ptid) and the running thread, that may not have been included
229      to system.tasking.debug's list yet.  */
230
231   iterate_over_live_ada_tasks (ravenscar_add_thread);
232 }
233
234 static ptid_t
235 ravenscar_running_thread (void)
236 {
237   CORE_ADDR tid = get_running_thread_id ();
238
239   if (tid == 0)
240     return null_ptid;
241   else
242     return ptid_build (ptid_get_pid (base_ptid), 0, tid);
243 }
244
245 static char *
246 ravenscar_extra_thread_info (struct target_ops *self, struct thread_info *tp)
247 {
248   return "Ravenscar task";
249 }
250
251 static int
252 ravenscar_thread_alive (struct target_ops *ops, ptid_t ptid)
253 {
254   /* Ravenscar tasks are non-terminating.  */
255   return 1;
256 }
257
258 static char *
259 ravenscar_pid_to_str (struct target_ops *ops, ptid_t ptid)
260 {
261   static char buf[30];
262
263   snprintf (buf, sizeof (buf), "Thread %#x", (int) ptid_get_tid (ptid));
264   return buf;
265 }
266
267 static void
268 ravenscar_fetch_registers (struct target_ops *ops,
269                            struct regcache *regcache, int regnum)
270 {
271   struct target_ops *beneath = find_target_beneath (ops);
272
273   if (!ravenscar_runtime_initialized ()
274       || ptid_equal (inferior_ptid, base_magic_null_ptid)
275       || ptid_equal (inferior_ptid, ravenscar_running_thread ()))
276     beneath->to_fetch_registers (beneath, regcache, regnum);
277   else
278     {
279       struct gdbarch *gdbarch = get_regcache_arch (regcache);
280       struct ravenscar_arch_ops *arch_ops
281         = gdbarch_ravenscar_ops (gdbarch);
282
283       arch_ops->to_fetch_registers (regcache, regnum);
284     }
285 }
286
287 static void
288 ravenscar_store_registers (struct target_ops *ops,
289                            struct regcache *regcache, int regnum)
290 {
291   struct target_ops *beneath = find_target_beneath (ops);
292
293   if (!ravenscar_runtime_initialized ()
294       || ptid_equal (inferior_ptid, base_magic_null_ptid)
295       || ptid_equal (inferior_ptid, ravenscar_running_thread ()))
296     beneath->to_store_registers (beneath, regcache, regnum);
297   else
298     {
299       struct gdbarch *gdbarch = get_regcache_arch (regcache);
300       struct ravenscar_arch_ops *arch_ops
301         = gdbarch_ravenscar_ops (gdbarch);
302
303       arch_ops->to_store_registers (regcache, regnum);
304     }
305 }
306
307 static void
308 ravenscar_prepare_to_store (struct target_ops *self,
309                             struct regcache *regcache)
310 {
311   struct target_ops *beneath = find_target_beneath (&ravenscar_ops);
312
313   if (!ravenscar_runtime_initialized ()
314       || ptid_equal (inferior_ptid, base_magic_null_ptid)
315       || ptid_equal (inferior_ptid, ravenscar_running_thread ()))
316     beneath->to_prepare_to_store (beneath, regcache);
317   else
318     {
319       struct gdbarch *gdbarch = get_regcache_arch (regcache);
320       struct ravenscar_arch_ops *arch_ops
321         = gdbarch_ravenscar_ops (gdbarch);
322
323       arch_ops->to_prepare_to_store (regcache);
324     }
325 }
326
327 static void
328 ravenscar_mourn_inferior (struct target_ops *ops)
329 {
330   struct target_ops *beneath = find_target_beneath (&ravenscar_ops);
331
332   base_ptid = null_ptid;
333   beneath->to_mourn_inferior (beneath);
334   unpush_target (&ravenscar_ops);
335 }
336
337 /* Observer on inferior_created: push ravenscar thread stratum if needed.  */
338
339 static void
340 ravenscar_inferior_created (struct target_ops *target, int from_tty)
341 {
342   struct ravenscar_arch_ops *ops;
343
344   if (!ravenscar_task_support
345       || gdbarch_ravenscar_ops (current_inferior ()->gdbarch) == NULL
346       || !has_ravenscar_runtime ())
347     return;
348
349   base_magic_null_ptid = inferior_ptid;
350   ravenscar_update_inferior_ptid ();
351   push_target (&ravenscar_ops);
352 }
353
354 static ptid_t
355 ravenscar_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
356 {
357   return ptid_build (ptid_get_pid (base_ptid), 0, thread);
358 }
359
360 static void
361 init_ravenscar_thread_ops (void)
362 {
363   ravenscar_ops.to_shortname = "ravenscar";
364   ravenscar_ops.to_longname = "Ravenscar tasks.";
365   ravenscar_ops.to_doc = "Ravenscar tasks support.";
366   ravenscar_ops.to_resume = ravenscar_resume;
367   ravenscar_ops.to_wait = ravenscar_wait;
368   ravenscar_ops.to_fetch_registers = ravenscar_fetch_registers;
369   ravenscar_ops.to_store_registers = ravenscar_store_registers;
370   ravenscar_ops.to_prepare_to_store = ravenscar_prepare_to_store;
371   ravenscar_ops.to_thread_alive = ravenscar_thread_alive;
372   ravenscar_ops.to_find_new_threads = ravenscar_find_new_threads;
373   ravenscar_ops.to_pid_to_str = ravenscar_pid_to_str;
374   ravenscar_ops.to_extra_thread_info = ravenscar_extra_thread_info;
375   ravenscar_ops.to_get_ada_task_ptid = ravenscar_get_ada_task_ptid;
376   ravenscar_ops.to_mourn_inferior = ravenscar_mourn_inferior;
377   ravenscar_ops.to_has_all_memory = default_child_has_all_memory;
378   ravenscar_ops.to_has_memory = default_child_has_memory;
379   ravenscar_ops.to_has_stack = default_child_has_stack;
380   ravenscar_ops.to_has_registers = default_child_has_registers;
381   ravenscar_ops.to_has_execution = default_child_has_execution;
382   ravenscar_ops.to_stratum = thread_stratum;
383   ravenscar_ops.to_magic = OPS_MAGIC;
384 }
385
386 /* Command-list for the "set/show ravenscar" prefix command.  */
387 static struct cmd_list_element *set_ravenscar_list;
388 static struct cmd_list_element *show_ravenscar_list;
389
390 /* Implement the "set ravenscar" prefix command.  */
391
392 static void
393 set_ravenscar_command (char *arg, int from_tty)
394 {
395   printf_unfiltered (_(\
396 "\"set ravenscar\" must be followed by the name of a setting.\n"));
397   help_list (set_ravenscar_list, "set ravenscar ", all_commands, gdb_stdout);
398 }
399
400 /* Implement the "show ravenscar" prefix command.  */
401
402 static void
403 show_ravenscar_command (char *args, int from_tty)
404 {
405   cmd_show_list (show_ravenscar_list, from_tty, "");
406 }
407
408 /* Implement the "show ravenscar task-switching" command.  */
409
410 static void
411 show_ravenscar_task_switching_command (struct ui_file *file, int from_tty,
412                                        struct cmd_list_element *c,
413                                        const char *value)
414 {
415   if (ravenscar_task_support)
416     fprintf_filtered (file, _("\
417 Support for Ravenscar task/thread switching is enabled\n"));
418   else
419     fprintf_filtered (file, _("\
420 Support for Ravenscar task/thread switching is disabled\n"));
421 }
422
423 /* Provide a prototype to silence -Wmissing-prototypes.  */
424 extern void _initialize_ravenscar (void);
425
426 /* Module startup initialization function, automagically called by
427    init.c.  */
428
429 void
430 _initialize_ravenscar (void)
431 {
432   init_ravenscar_thread_ops ();
433   base_ptid = null_ptid;
434
435   /* Notice when the inferior is created in order to push the
436      ravenscar ops if needed.  */
437   observer_attach_inferior_created (ravenscar_inferior_created);
438
439   complete_target_initialization (&ravenscar_ops);
440
441   add_prefix_cmd ("ravenscar", no_class, set_ravenscar_command,
442                   _("Prefix command for changing Ravenscar-specific settings"),
443                   &set_ravenscar_list, "set ravenscar ", 0, &setlist);
444
445   add_prefix_cmd ("ravenscar", no_class, show_ravenscar_command,
446                   _("Prefix command for showing Ravenscar-specific settings"),
447                   &show_ravenscar_list, "show ravenscar ", 0, &showlist);
448
449   add_setshow_boolean_cmd ("task-switching", class_obscure,
450                            &ravenscar_task_support, _("\
451 Enable or disable support for GNAT Ravenscar tasks"), _("\
452 Show whether support for GNAT Ravenscar tasks is enabled"),
453                            _("\
454 Enable or disable support for task/thread switching with the GNAT\n\
455 Ravenscar run-time library for bareboard configuration."),
456                            NULL, show_ravenscar_task_switching_command,
457                            &set_ravenscar_list, &show_ravenscar_list);
458 }