[RFA/commit 3/3] fix internal_error during fork event handling.

[Joel Brobecker <brobecker at adacore dot com>]

When running on ia64-hpux a program that calls fork, GDB currently
reports the following internal error:

    internal-error: Can't determine the current address space of thread process 1882

Here is what happens:
  1. GDB receives a "fork" event;
  2. handle_inferior_event calls detach_breakpoints for the child process;
  3. detach_breakpoints calls ia64's gdbarch remove_breakpoint hook,
     which needs to read an entire instruction slot in order to remove
     a breakpoint instruction from memory;
  4. To read inferior memory, the ia64-hpux code needs to know where
     that memory is located relative to the bsp..bspstore area,
     and thus needs to read the value of those registers;
  5. To get the value of those registers, ia64_hpux_xfer_memory current
     uses the current regcache.

The problem is that at the time we are trying to remove the breakpoints
from the child, the child process is not part of the list of inferiors
really known to GDB (it has not been added to inferior_list), and there
is therefore no regcache for that process.  This is what triggers the
internal error.

To work around this limitation, ia64_hpux_xfer_memory has been modified
to detect the fact the current inferior is not in our inferior list,
and to go, in that case, straight to the source to fetch the registers
it needs.

gdb/ChangeLog:

        * ia64-hpux-nat.c (ia64_hpux_get_register_from_save_state_t):
        New function.
        (ia64_hpux_xfer_memory): Check if inferior_ptid is known before
        using the regache.  Use ia64_hpux_get_register_from_save_state_t
        to access the bsp and bspstore registers if not.

Same as patch #1: I feel sufficiently confident to self approve, but
comments always welcome...

Thanks,
-- 
Joel

---
 gdb/ia64-hpux-nat.c |   52 ++++++++++++++++++++++++++++++++++++++++++++++++--
 1 files changed, 49 insertions(+), 3 deletions(-)

diff --git a/gdb/ia64-hpux-nat.c b/gdb/ia64-hpux-nat.c
index 07a433e..014f571 100644
--- a/gdb/ia64-hpux-nat.c
+++ b/gdb/ia64-hpux-nat.c
@@ -485,6 +485,37 @@ ia64_hpux_xfer_memory_bs (struct target_ops *ops, const char *annex,
     return 0;
 }
 
+/* Get a register value as a unsigned value directly from the system,
+   instead of going through the regcache.
+
+   This function is meant to work when there is no regcache, or even
+   when inferior_ptid is not a thread/process known to GDB.  */
+
+static ULONGEST
+ia64_hpux_get_register_from_save_state_t (int regnum, int reg_size)
+{
+  gdb_byte *buf = alloca (reg_size);
+  int offset = u_offsets[regnum];
+  int status;
+
+  /* The register is assumed to be available for fetching.  */
+  gdb_assert (offset != -1);
+
+  status = ia64_hpux_read_register_from_save_state_t (offset, buf, reg_size);
+  if (status < 0)
+    {
+      /* This really should not happen.  If it does, emit a warning
+	 and pretend the register value is zero.  Not exactly the best
+	 error recovery mechanism, but better than nothing.  We will
+	 try to do better if we can demonstrate that this can happen
+	 under normal circumstances.  */
+      warning (_("Failed to read value of register number %d."), regnum);
+      return 0;
+    }
+
+  return extract_unsigned_integer (buf, reg_size, BFD_ENDIAN_BIG);
+}
+
 /* The "xfer_partial" target_ops routine for ia64-hpux, in the case
    where the requested object is TARGET_OBJECT_MEMORY.  */
 
@@ -504,9 +535,24 @@ ia64_hpux_xfer_memory (struct target_ops *ops, const char *annex,
        (3) The region inside the backing-store, which needs to be
            read/written specially.  */
 
-  regcache_raw_read_unsigned (get_current_regcache (), IA64_BSP_REGNUM, &bsp);
-  regcache_raw_read_unsigned (get_current_regcache (), IA64_BSPSTORE_REGNUM,
-                              &bspstore);
+  if (in_inferior_list (ptid_get_pid (inferior_ptid)))
+    {
+      struct regcache *regcache = get_current_regcache ();
+
+      regcache_raw_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp);
+      regcache_raw_read_unsigned (regcache, IA64_BSPSTORE_REGNUM, &bspstore);
+    }
+  else
+    {
+      /* This is probably a child of our inferior created by a fork.
+	 Because this process has not been added to our inferior list
+	 (we are probably in the process of handling that child
+	 process), we do not have a regcache to read the registers
+	 from.  So get those values directly from the kernel.  */
+      bsp = ia64_hpux_get_register_from_save_state_t (IA64_BSP_REGNUM, 8);
+      bspstore =
+	ia64_hpux_get_register_from_save_state_t (IA64_BSPSTORE_REGNUM, 8);
+    }
 
   /* 1. Memory region before BSPSTORE.  */
 
-- 
1.7.1