[commit/Ada/ravenscar] New name for active-thread symbol

[Joel Brobecker <brobecker at adacore dot com>]

The GNAT Ravenscar implementation has recently been enhanced to allow
programs using that runtime to run on multi-cpu systems.  One of the
changes that were made is that the name of the symbol we use to
determine which task is the currently-running task has changed.

This patch enhances the debugger to use the new name, and fallback on
the old name if not found (this is for compatibility with older versions
of the compiler/runtime).

gdb/ChangeLog:

        * ravenscar-thread.c (running_thread_name): Change value.
        (read_thread_id): Remove advance declaration.
        (get_running_thread_msymbol): New function.
        (has_ravenscar_runtime): Use get_running_thread_msymbol to
        compute msym_running_thread.
        (get_running_thread_id): Renames read_thread_id. Slight modifications
        to not take any argument anymore, using get_running_thread_msymbol
        to determine which symbol to use instead.
        (ravenscar_running_thread): Use get_running_thread_id instead of
        read_thread_id.

Tested on a leon-elf system running on qemu. Checked in.

---
 gdb/ChangeLog          |   13 +++++++++++++
 gdb/ravenscar-thread.c |   38 ++++++++++++++++++++++++++++----------
 2 files changed, 41 insertions(+), 10 deletions(-)

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index b99f302..0ec2403 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,18 @@
 2010-11-22  Joel Brobecker  <brobecker@adacore.com>
 
+	* ravenscar-thread.c (running_thread_name): Change value.
+	(read_thread_id): Remove advance declaration.
+	(get_running_thread_msymbol): New function.
+	(has_ravenscar_runtime): Use get_running_thread_msymbol to
+	compute msym_running_thread.
+	(get_running_thread_id): Renames read_thread_id. Slight modifications
+	to not take any argument anymore, using get_running_thread_msymbol
+	to determine which symbol to use instead.
+	(ravenscar_running_thread): Use get_running_thread_id instead of
+	read_thread_id.
+
+2010-11-22  Joel Brobecker  <brobecker@adacore.com>
+
 	* ravenscar-sparc-thread.c (supply_register_at_address):
 	Fix passing of buf in call to regcache_raw_supply.
 
diff --git a/gdb/ravenscar-thread.c b/gdb/ravenscar-thread.c
index 7a80dcf..8f1be9b 100644
--- a/gdb/ravenscar-thread.c
+++ b/gdb/ravenscar-thread.c
@@ -48,7 +48,7 @@ static ptid_t base_magic_null_ptid;
 /* Ptid of the inferior as seen by the process stratum.  */
 static ptid_t base_ptid;
 
-static const char running_thread_name[] = "running_thread";
+static const char running_thread_name[] = "__gnat_running_thread_table";
 
 static const char known_tasks_name[] = "system__tasking__debug__known_tasks";
 
@@ -59,8 +59,6 @@ static struct observer *update_target_observer = NULL;
 /* Architecture-specific hooks.  */
 static struct ravenscar_arch_ops* current_arch_ops;
 
-static CORE_ADDR read_thread_id (const char *symbol_name);
-
 static void ravenscar_find_new_threads (struct target_ops *ops);
 static ptid_t ravenscar_running_thread (void);
 static char *ravenscar_extra_thread_info (struct thread_info *tp);
@@ -105,6 +103,27 @@ ravenscar_update_inferior_ptid (void)
     add_thread (inferior_ptid);
 }
 
+/* The Ravenscar Runtime exports a symbol which contains the ID of
+   the thread that is currently running.  Try to locate that symbol
+   and return its associated minimal symbol.
+   Return NULL if not found.  */
+
+static struct minimal_symbol *
+get_running_thread_msymbol (void)
+{
+  struct minimal_symbol *msym;
+
+  msym = lookup_minimal_symbol (running_thread_name, NULL, NULL);
+  if (!msym)
+    /* Older versions of the GNAT runtime were using a different
+       (less ideal) name for the symbol where the active thread ID
+       is stored.  If we couldn't find the symbol using the latest
+       name, then try the old one.  */
+    msym = lookup_minimal_symbol ("running_thread", NULL, NULL);
+
+  return msym;
+}
+
 /* Return True if the Ada Ravenscar run-time can be found in the
    application.  */
 
@@ -115,8 +134,7 @@ has_ravenscar_runtime (void)
     lookup_minimal_symbol (ravenscar_runtime_initializer, NULL, NULL);
   struct minimal_symbol *msym_known_tasks =
     lookup_minimal_symbol (known_tasks_name, NULL, NULL);
-  struct minimal_symbol *msym_running_thread =
-    lookup_minimal_symbol (running_thread_name, NULL, NULL);
+  struct minimal_symbol *msym_running_thread = get_running_thread_msymbol ();
 
   return (msym_ravenscar_runtime_initializer
 	  && msym_known_tasks
@@ -132,13 +150,13 @@ ravenscar_runtime_initialized (void)
   return (!(ptid_equal (ravenscar_running_thread (), null_ptid)));
 }
 
-/* Read the thread ID whose symbol name is SYMBOL_NAME.  */
+/* Return the ID of the thread that is currently running.
+   Return 0 if the ID could not be determined.  */
 
 static CORE_ADDR
-read_thread_id (const char *symbol_name)
+get_running_thread_id (void)
 {
-  const struct minimal_symbol *object_msym =
-    lookup_minimal_symbol (symbol_name, NULL, NULL);
+  const struct minimal_symbol *object_msym = get_running_thread_msymbol ();
   int object_size;
   int buf_size;
   char *buf;
@@ -213,7 +231,7 @@ ravenscar_find_new_threads (struct target_ops *ops)
 static ptid_t
 ravenscar_running_thread (void)
 {
-  CORE_ADDR tid = read_thread_id (running_thread_name);
+  CORE_ADDR tid = get_running_thread_id ();
 
   if (tid == 0)
     return null_ptid;
-- 
1.7.1