gdb/ravenscar-thread.c

   1 /* Ada Ravenscar thread support.
   2
   3    Copyright 2004, 2009, 2010, 2011 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 "gdb_string.h"
  30 #include "gdbcmd.h"
  31 #include "top.h"
  32 #include "regcache.h"
  33
  34 /* If non-null, ravenscar task support is enabled.  */
  35 static int ravenscar_task_support = 1;
  36
  37 /* Non-null if the ravenscar thread layer has been pushed on the target
  38    stack.  */
  39 static int ravenscar_is_open = 0;
  40
  41 /* This module's target-specific operations.  */
  42 static struct target_ops ravenscar_ops;
  43
  44 /* Some base target uses a special value for the null PID (exempli gratia
  45    remote).  */
  46 static ptid_t base_magic_null_ptid;
  47
  48 /* Ptid of the inferior as seen by the process stratum.  */
  49 static ptid_t base_ptid;
  50
  51 static const char running_thread_name[] = "__gnat_running_thread_table";
  52
  53 static const char known_tasks_name[] = "system__tasking__debug__known_tasks";
  54
  55 static const char ravenscar_runtime_initializer[] =
  56   "system__bb__threads__initialize";
  57
  58 static struct observer *update_target_observer = NULL;
  59
  60 /* Architecture-specific hooks.  */
  61 static struct ravenscar_arch_ops* current_arch_ops;
  62
  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,
  80                                         int from_tty);
  81
  82 /* Fetch the ravenscar running thread from target memory and
  83    update inferior_ptid accordingly.  */
  84
  85 static void
  86 ravenscar_update_inferior_ptid (void)
  87 {
  88   base_ptid = inferior_ptid;
  89
  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 ())
  93     return;
  94
  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));
  99
 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);
 105 }
 106
 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.  */
 111
 112 static struct minimal_symbol *
 113 get_running_thread_msymbol (void)
 114 {
 115   struct minimal_symbol *msym;
 116
 117   msym = lookup_minimal_symbol (running_thread_name, NULL, NULL);
 118   if (!msym)
 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);
 124
 125   return msym;
 126 }
 127
 128 /* Return True if the Ada Ravenscar run-time can be found in the
 129    application.  */
 130
 131 static int
 132 has_ravenscar_runtime (void)
 133 {
 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 ();
 139
 140   return (msym_ravenscar_runtime_initializer
 141           && msym_known_tasks
 142           && msym_running_thread);
 143 }
 144
 145 /* Return True if the Ada Ravenscar run-time can be found in the
 146    application, and if it has been initialized on target.  */
 147
 148 static int
 149 ravenscar_runtime_initialized (void)
 150 {
 151   return (!(ptid_equal (ravenscar_running_thread (), null_ptid)));
 152 }
 153
 154 /* Return the ID of the thread that is currently running.
 155    Return 0 if the ID could not be determined.  */
 156
 157 static CORE_ADDR
 158 get_running_thread_id (void)
 159 {
 160   const struct minimal_symbol *object_msym = get_running_thread_msymbol ();
 161   int object_size;
 162   int buf_size;
 163   char *buf;
 164   CORE_ADDR object_addr;
 165   struct type *builtin_type_void_data_ptr =
 166     builtin_type (target_gdbarch)->builtin_data_ptr;
 167
 168   if (!object_msym)
 169     return 0;
 170
 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);
 177 }
 178
 179 static void
 180 ravenscar_close (int quitting)
 181 {
 182   ravenscar_is_open = 0;
 183 }
 184
 185 static void
 186 ravenscar_resume (struct target_ops *ops, ptid_t ptid, int step,
 187                   enum target_signal siggnal)
 188 {
 189   struct target_ops *beneath = find_target_beneath (ops);
 190
 191   inferior_ptid = base_ptid;
 192   beneath->to_resume (beneath, base_ptid, step, siggnal);
 193 }
 194
 195 static ptid_t
 196 ravenscar_wait (struct target_ops *ops, ptid_t ptid,
 197                 struct target_waitstatus *status,
 198                 int options)
 199 {
 200   struct target_ops *beneath = find_target_beneath (ops);
 201
 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;
 207 }
 208
 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).  */
 211
 212 static void
 213 ravenscar_add_thread (struct ada_task_info *task)
 214 {
 215   if (find_thread_ptid (task->ptid) == NULL)
 216     add_thread (task->ptid);
 217 }
 218
 219 static void
 220 ravenscar_find_new_threads (struct target_ops *ops)
 221 {
 222   ada_build_task_list (0);
 223
 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.  */
 228
 229   iterate_over_live_ada_tasks (ravenscar_add_thread);
 230 }
 231
 232 static ptid_t
 233 ravenscar_running_thread (void)
 234 {
 235   CORE_ADDR tid = get_running_thread_id ();
 236
 237   if (tid == 0)
 238     return null_ptid;
 239   else
 240     return ptid_build (ptid_get_pid (base_ptid), 0, tid);
 241 }
 242
 243 static char *
 244 ravenscar_extra_thread_info (struct thread_info *tp)
 245 {
 246   return "Ravenscar task";
 247 }
 248
 249 static int
 250 ravenscar_thread_alive (struct target_ops *ops, ptid_t ptid)
 251 {
 252   /* Ravenscar tasks are non-terminating.  */
 253   return 1;
 254 }
 255
 256 static char *
 257 ravenscar_pid_to_str (struct target_ops *ops, ptid_t ptid)
 258 {
 259   static char buf[30];
 260
 261   snprintf (buf, sizeof (buf), "Thread %#x", (int) ptid_get_tid (ptid));
 262   return buf;
 263 }
 264
 265 static void
 266 ravenscar_fetch_registers (struct target_ops *ops,
 267                            struct regcache *regcache, int regnum)
 268 {
 269   struct target_ops *beneath = find_target_beneath (ops);
 270
 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);
 275   else
 276     current_arch_ops->to_fetch_registers (regcache, regnum);
 277 }
 278
 279 static void
 280 ravenscar_store_registers (struct target_ops *ops,
 281                            struct regcache *regcache, int regnum)
 282 {
 283   struct target_ops *beneath = find_target_beneath (ops);
 284
 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);
 289   else
 290     current_arch_ops->to_store_registers (regcache, regnum);
 291 }
 292
 293 static void
 294 ravenscar_prepare_to_store (struct regcache *regcache)
 295 {
 296   struct target_ops *beneath = find_target_beneath (&ravenscar_ops);
 297
 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);
 302   else
 303     current_arch_ops->to_prepare_to_store (regcache);
 304 }
 305
 306 static void
 307 ravenscar_mourn_inferior (struct target_ops *ops)
 308 {
 309   struct target_ops *beneath = find_target_beneath (&ravenscar_ops);
 310
 311   base_ptid = null_ptid;
 312   beneath->to_mourn_inferior (beneath);
 313   unpush_target (&ravenscar_ops);
 314 }
 315
 316 /* Observer on inferior_created: push ravenscar thread stratum if needed.  */
 317
 318 static void
 319 ravenscar_inferior_created (struct target_ops *target, int from_tty)
 320 {
 321   if (ravenscar_task_support
 322       && has_ravenscar_runtime ())
 323     ravenscar_initialize (NULL, 0);
 324 }
 325
 326 void
 327 ravenscar_register_arch_ops (struct ravenscar_arch_ops *ops)
 328 {
 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
 333      that for now...  */
 334   current_arch_ops = ops;
 335 }
 336
 337 /* Initialize Ravenscar support.  */
 338
 339 static void
 340 ravenscar_initialize (char *name, int from_tty)
 341 {
 342   if (ravenscar_is_open)
 343     return;
 344
 345   base_magic_null_ptid = inferior_ptid;
 346   ravenscar_update_inferior_ptid ();
 347   push_target (&ravenscar_ops);
 348   ravenscar_is_open = 1;
 349 }
 350
 351 static ptid_t
 352 ravenscar_get_ada_task_ptid (long lwp, long thread)
 353 {
 354   return ptid_build (ptid_get_pid (base_ptid), 0, thread);
 355 }
 356
 357 static void
 358 init_ravenscar_thread_ops (void)
 359 {
 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;
 382 }
 383
 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;
 387
 388 /* Implement the "set ravenscar" prefix command.  */
 389
 390 static void
 391 set_ravenscar_command (char *arg, int from_tty)
 392 {
 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);
 396 }
 397
 398 /* Implement the "show ravenscar" prefix command.  */
 399
 400 static void
 401 show_ravenscar_command (char *args, int from_tty)
 402 {
 403   cmd_show_list (show_ravenscar_list, from_tty, "");
 404 }
 405
 406 /* Implement the "show ravenscar task-switching" command.  */
 407
 408 static void
 409 show_ravenscar_task_switching_command (struct ui_file *file, int from_tty,
 410                                        struct cmd_list_element *c,
 411                                        const char *value)
 412 {
 413   if (ravenscar_task_support)
 414     fprintf_filtered (file, _("\
 415 Support for Ravenscar task/thread switching is enabled\n"));
 416   else
 417     fprintf_filtered (file, _("\
 418 Support for Ravenscar task/thread switching is disabled\n"));
 419 }
 420
 421 /* Module startup initialization function, automagically called by
 422    init.c.  */
 423
 424 void
 425 _initialize_ravenscar (void)
 426 {
 427   init_ravenscar_thread_ops ();
 428   base_ptid = null_ptid;
 429
 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);
 433
 434   add_target (&ravenscar_ops);
 435
 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);
 439
 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);
 443
 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"),
 448                            _("\
 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);
 453 }