* linux-nat.c (linux_nat_thread_address_space): New.

	(linux_nat_add_target): Install it.
	* progspace.c (address_space_num): New.
	* progspace.h (address_space_num): Declare.
	* target.c (target_thread_address_space): Really query the target.
	* target.h (struct target_ops) <to_thread_address_space>: New
	field.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 0c83a78bac319bd0e52081f83ddb7cb39f1a8758..42d230d0becd8973173fc60477f4af315ef8d53f 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,13 @@
+2009-10-20  Pedro Alves  <pedro@codesourcery.com>
+
+       * linux-nat.c (linux_nat_thread_address_space): New.
+       (linux_nat_add_target): Install it.
+       * progspace.c (address_space_num): New.
+       * progspace.h (address_space_num): Declare.
+       * target.c (target_thread_address_space): Really query the target.
+       * target.h (struct target_ops) <to_thread_address_space>: New
+       field.
+
 2009-10-19  Joel Brobecker  <brobecker@adacore.com>
 
        * amd64fbsd-nat.c (amd64fbsd_supply_pcb): Add comment.

diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index 724cdee5032416333b79f73a6c5362aaa9595a5c..c0c024073142a84a8f92127b22c856d8177f85f5 100644 (file)
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -5311,6 +5311,39 @@ linux_nat_close (int quitting)
     linux_ops->to_close (quitting);
 }
 
+/* When requests are passed down from the linux-nat layer to the
+   single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
+   used.  The address space pointer is stored in the inferior object,
+   but the common code that is passed such ptid can't tell whether
+   lwpid is a "main" process id or not (it assumes so).  We reverse
+   look up the "main" process id from the lwp here.  */
+
+struct address_space *
+linux_nat_thread_address_space (struct target_ops *t, ptid_t ptid)
+{
+  struct lwp_info *lwp;
+  struct inferior *inf;
+  int pid;
+
+  pid = GET_LWP (ptid);
+  if (GET_LWP (ptid) == 0)
+    {
+      /* An (lwpid,0,0) ptid.  Look up the lwp object to get at the
+        tgid.  */
+      lwp = find_lwp_pid (ptid);
+      pid = GET_PID (lwp->ptid);
+    }
+  else
+    {
+      /* A (pid,lwpid,0) ptid.  */
+      pid = GET_PID (ptid);
+    }
+
+  inf = find_inferior_pid (pid);
+  gdb_assert (inf != NULL);
+  return inf->aspace;
+}
+
 void
 linux_nat_add_target (struct target_ops *t)
 {
@@ -5333,6 +5366,7 @@ linux_nat_add_target (struct target_ops *t)
   t->to_thread_alive = linux_nat_thread_alive;
   t->to_pid_to_str = linux_nat_pid_to_str;
   t->to_has_thread_control = tc_schedlock;
+  t->to_thread_address_space = linux_nat_thread_address_space;
 
   t->to_can_async_p = linux_nat_can_async_p;
   t->to_is_async_p = linux_nat_is_async_p;

diff --git a/gdb/progspace.c b/gdb/progspace.c
index 1a465ce42cc6bd41200be1ef870d1839ab9b63f5..926c4ead38eff0ed0cd4414e5607ce12d7d80cb1 100644 (file)
--- a/gdb/progspace.c
+++ b/gdb/progspace.c
@@ -89,6 +89,12 @@ free_address_space (struct address_space *aspace)
   xfree (aspace);
 }
 
+int
+address_space_num (struct address_space *aspace)
+{
+  return aspace->num;
+}
+
 /* Start counting over from scratch.  */
 
 static void

diff --git a/gdb/progspace.h b/gdb/progspace.h
index 2a0d1d294c5d8947eb37b4a213486564677299be..0cf1382b77a33d8869d9b0127397205694a3c0e3 100644 (file)
--- a/gdb/progspace.h
+++ b/gdb/progspace.h
@@ -254,6 +254,9 @@ extern struct address_space *new_address_space (void);
    share an address space.  */
 extern struct address_space *maybe_new_address_space (void);
 
+/* Returns the integer address space id of ASPACE.  */
+extern int address_space_num (struct address_space *aspace);
+
 /* Update all program spaces matching to address spaces.  The user may
    have created several program spaces, and loaded executables into
    them before connecting to the target interface that will create the

diff --git a/gdb/target.c b/gdb/target.c
index ac1010b2d0f7ec245c274aaae02753cf4c41e4a3..2f5f55681a465ed0a6f6192f0d41bc4d0a8d55ae 100644 (file)
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -2555,10 +2555,25 @@ target_get_osdata (const char *type)
 struct address_space *
 target_thread_address_space (ptid_t ptid)
 {
+  struct address_space *aspace;
   struct inferior *inf;
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    {
+      if (t->to_thread_address_space != NULL)
+       {
+         aspace = t->to_thread_address_space (t, ptid);
+         gdb_assert (aspace);
 
-  /* For now, assume frame chains and inferiors only see one address
-     space.  */
+         if (targetdebug)
+           fprintf_unfiltered (gdb_stdlog,
+                               "target_thread_address_space (%s) = %d\n",
+                               target_pid_to_str (ptid),
+                               address_space_num (aspace));
+         return aspace;
+       }
+    }
 
   /* Fall-back to the "main" address space of the inferior.  */
   inf = find_inferior_pid (ptid_get_pid (ptid));

diff --git a/gdb/target.h b/gdb/target.h
index 3d5a348580288fe05fabdd5fa6a07cea7b79da54..e4421e90e308dc53eda58bfde351da70ce5c3e90 100644 (file)
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -585,6 +585,13 @@ struct target_ops
        The default implementation always returns target_gdbarch.  */
     struct gdbarch *(*to_thread_architecture) (struct target_ops *, ptid_t);
 
+    /* Determine current address space of thread PTID.
+
+       The default implementation always returns the inferior's
+       address space.  */
+    struct address_space *(*to_thread_address_space) (struct target_ops *,
+                                                     ptid_t);
+
     int to_magic;
     /* Need sub-structure for target machine related rather than comm related?
      */