Merge GDB 7.5.1

gdb/i386-nat.c

 /* Native-dependent code for the i386.
 
    Copyright (C) 2001, 2004-2005, 2007-2012 Free Software Foundation,
    Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "i386-nat.h"
 #include "defs.h"
 #include "breakpoint.h"
 #include "command.h"
 #include "gdbcmd.h"
 #include "target.h"
 #include "gdb_assert.h"
+#include "inferior.h"
 
 /* Support for hardware watchpoints and breakpoints using the i386
    debug registers.
 
    This provides several functions for inserting and removing
    hardware-assisted breakpoints and watchpoints, testing if one or
    more of the watchpoints triggered and at what address, checking
    whether a given region can be watched, etc.
 
    The functions below implement debug registers sharing by reference
    counts, and allow to watch regions up to 16 bytes long.  */
 
 struct i386_dr_low_type i386_dr_low;
 
 
 /* Support for 8-byte wide hw watchpoints.  */
 #define TARGET_HAS_DR_LEN_8 (i386_dr_low.debug_register_length == 8)
 
-/* Debug registers' indices.  */
-#define DR_NADDR        4       /* The number of debug address registers.  */
-#define DR_STATUS       6       /* Index of debug status register (DR6).  */
-#define DR_CONTROL      7       /* Index of debug control register (DR7).  */
-
 /* DR7 Debug Control register fields.  */
 
 /* How many bits to skip in DR7 to get to R/W and LEN fields.  */
 #define DR_CONTROL_SHIFT        16
 /* How many bits in DR7 per R/W and LEN field for each watchpoint.  */
 #define DR_CONTROL_SIZE         4
 
 /* Watchpoint/breakpoint read/write fields in DR7.  */
 #define DR_RW_EXECUTE   (0x0)   /* Break on instruction execution.  */
 #define DR_RW_WRITE     (0x1)   /* Break on data writes.  */
@@ skipping 90 matching lines @@
 
 /* Mask that this I'th watchpoint has triggered.  */
 #define I386_DR_WATCH_MASK(i)   (1 << (i))
 
 /* Did the watchpoint whose address is in the I'th register break?  */
 #define I386_DR_WATCH_HIT(dr6, i) ((dr6) & (1 << (i)))
 
 /* A macro to loop over all debug registers.  */
 #define ALL_DEBUG_REGISTERS(i)  for (i = 0; i < DR_NADDR; i++)
 
-
-/* Global state needed to track h/w watchpoints.  */
-
-struct i386_debug_reg_state
-{
-  /* Mirror the inferior's DRi registers.  We keep the status and
-     control registers separated because they don't hold addresses.
-     Note that since we can change these mirrors while threads are
-     running, we never trust them to explain a cause of a trap.
-     For that, we need to peek directly in the inferior registers.  */
-  CORE_ADDR dr_mirror[DR_NADDR];
-  unsigned dr_status_mirror, dr_control_mirror;
-
-  /* Reference counts for each debug register.  */
-  int dr_ref_count[DR_NADDR];
-};
-
 /* Clear the reference counts and forget everything we knew about the
    debug registers.  */
 
 static void
 i386_init_dregs (struct i386_debug_reg_state *state)
 {
   int i;
 
   ALL_DEBUG_REGISTERS (i)
     {
       state->dr_mirror[i] = 0;
       state->dr_ref_count[i] = 0;
     }
   state->dr_control_mirror = 0;
   state->dr_status_mirror  = 0;
 }
 
-static struct i386_debug_reg_state dr_mirror;
+/* Per-inferior data key.  */
+static const struct inferior_data *i386_inferior_data;
+
+/* Per-inferior data.  */
+struct i386_inferior_data
+{
+  /* Copy of i386 hardware debug registers for performance reasons.  */
+  struct i386_debug_reg_state state;
+};
+
+/* Per-inferior hook for register_inferior_data_with_cleanup.  */
+
+static void
+i386_inferior_data_cleanup (struct inferior *inf, void *arg)
+{
+  struct i386_inferior_data *inf_data = arg;
+
+  xfree (inf_data);
+}
+
+/* Get data specific for INFERIOR_PTID LWP.  Return special data area
+   for processes being detached.  */
+
+static struct i386_inferior_data *
+i386_inferior_data_get (void)
+{
+  struct inferior *inf = current_inferior ();
+  struct i386_inferior_data *inf_data;
+
+  inf_data = inferior_data (inf, i386_inferior_data);
+  if (inf_data == NULL)
+    {
+      inf_data = xzalloc (sizeof (*inf_data));
+      set_inferior_data (current_inferior (), i386_inferior_data, inf_data);
+    }
+
+  if (inf->pid != ptid_get_pid (inferior_ptid))
+    {
+      /* INFERIOR_PTID is being detached from the inferior INF.
+         Provide local cache specific for the detached LWP.  */
+
+      static struct i386_inferior_data detached_inf_data_local;
+      static int detached_inf_pid = -1;
+
+      if (detached_inf_pid != ptid_get_pid (inferior_ptid))
+        {
+          /* Reinitialize the local cache if INFERIOR_PTID is
+             different from the LWP last detached.
+ 
+             Linux kernel before 2.6.33 commit
+             72f674d203cd230426437cdcf7dd6f681dad8b0d
+             will inherit hardware debug registers from parent
+             on fork/vfork/clone.  Newer Linux kernels create such tasks with
+             zeroed debug registers.
+
+             GDB will remove all breakpoints (and watchpoints) from the forked
+             off process.  We also need to reset the debug registers in that
+             process to be compatible with the older Linux kernels.
+
+             Copy the debug registers mirrors into the new process so that all
+             breakpoints and watchpoints can be removed together.  The debug
+             registers mirror will become zeroed in the end before detaching
+             the forked off process.  */
+
+          detached_inf_pid = ptid_get_pid (inferior_ptid);
+          detached_inf_data_local = *inf_data;
+        }
+
+      return &detached_inf_data_local;
+    }
+
+  return inf_data;
+}
+
+/* Get debug registers state for INFERIOR_PTID, see
+   i386_inferior_data_get.  */
+
+struct i386_debug_reg_state *
+i386_debug_reg_state (void)
+{
+  return &i386_inferior_data_get ()->state;
+}
 
 /* Whether or not to print the mirrored debug registers.  */
 static int maint_show_dr;
 
 /* Types of operations supported by i386_handle_nonaligned_watchpoint.  */
 typedef enum { WP_INSERT, WP_REMOVE, WP_COUNT } i386_wp_op_t;
 
 /* Internal functions.  */
 
 /* Return the value of a 4-bit field for DR7 suitable for watching a
@@ skipping 31 matching lines @@
                                               enum target_hw_bp_type type);
 
 /* Implementation.  */
 
 /* Clear the reference counts and forget everything we knew about the
    debug registers.  */
 
 void
 i386_cleanup_dregs (void)
 {
-  i386_init_dregs (&dr_mirror);
+  struct i386_debug_reg_state *state = i386_debug_reg_state ();
+
+  i386_init_dregs (state);
 }
 
 /* Print the values of the mirrored debug registers.  This is called
    when maint_show_dr is non-zero.  To set that up, type "maint
    show-debug-regs" at GDB's prompt.  */
 
 static void
 i386_show_dr (struct i386_debug_reg_state *state,
               const char *func, CORE_ADDR addr,
               int len, enum target_hw_bp_type type)
@@ skipping 243 matching lines @@
 
   return retval;
 }
 
 /* Update the inferior's debug registers with the new debug registers
    state, in NEW_STATE, and then update our local mirror to match.  */
 
 static void
 i386_update_inferior_debug_regs (struct i386_debug_reg_state *new_state)
 {
+  struct i386_debug_reg_state *state = i386_debug_reg_state ();
   int i;
 
   ALL_DEBUG_REGISTERS (i)
     {
-      if (I386_DR_VACANT (new_state, i) != I386_DR_VACANT (&dr_mirror, i))
-        {
-          if (!I386_DR_VACANT (new_state, i))
-            {
-              i386_dr_low.set_addr (i, new_state->dr_mirror[i]);
-
-              /* Only a sanity check for leftover bits (set possibly only
-                 by inferior).  */
-              if (i386_dr_low.unset_status)
-                i386_dr_low.unset_status (I386_DR_WATCH_MASK (i));
-            }
-          else
-            {
-              if (i386_dr_low.reset_addr)
-                i386_dr_low.reset_addr (i);
-            }
-        }
+      if (I386_DR_VACANT (new_state, i) != I386_DR_VACANT (state, i))
+        i386_dr_low.set_addr (i, new_state->dr_mirror[i]);
       else
-        gdb_assert (new_state->dr_mirror[i] == dr_mirror.dr_mirror[i]);
+        gdb_assert (new_state->dr_mirror[i] == state->dr_mirror[i]);
     }
 
-  if (new_state->dr_control_mirror != dr_mirror.dr_control_mirror)
+  if (new_state->dr_control_mirror != state->dr_control_mirror)
     i386_dr_low.set_control (new_state->dr_control_mirror);
 
-  dr_mirror = *new_state;
+  *state = *new_state;
 }
 
 /* Insert a watchpoint to watch a memory region which starts at
    address ADDR and whose length is LEN bytes.  Watch memory accesses
    of the type TYPE.  Return 0 on success, -1 on failure.  */
 
 static int
 i386_insert_watchpoint (CORE_ADDR addr, int len, int type,
                         struct expression *cond)
 {
+  struct i386_debug_reg_state *state = i386_debug_reg_state ();
   int retval;
   /* Work on a local copy of the debug registers, and on success,
      commit the change back to the inferior.  */
-  struct i386_debug_reg_state local_state = dr_mirror;
+  struct i386_debug_reg_state local_state = *state;
 
   if (type == hw_read)
     return 1; /* unsupported */
 
   if (((len != 1 && len !=2 && len !=4) && !(TARGET_HAS_DR_LEN_8 && len == 8))
       || addr % len != 0)
     retval = i386_handle_nonaligned_watchpoint (&local_state,
                                                 WP_INSERT, addr, len, type);
   else
     {
       unsigned len_rw = i386_length_and_rw_bits (len, type);
 
       retval = i386_insert_aligned_watchpoint (&local_state,
                                                addr, len_rw);
     }
 
   if (retval == 0)
     i386_update_inferior_debug_regs (&local_state);
 
   if (maint_show_dr)
-    i386_show_dr (&dr_mirror, "insert_watchpoint", addr, len, type);
+    i386_show_dr (state, "insert_watchpoint", addr, len, type);
 
   return retval;
 }
 
 /* Remove a watchpoint that watched the memory region which starts at
    address ADDR, whose length is LEN bytes, and for accesses of the
    type TYPE.  Return 0 on success, -1 on failure.  */
 static int
 i386_remove_watchpoint (CORE_ADDR addr, int len, int type,
                         struct expression *cond)
 {
+  struct i386_debug_reg_state *state = i386_debug_reg_state ();
   int retval;
   /* Work on a local copy of the debug registers, and on success,
      commit the change back to the inferior.  */
-  struct i386_debug_reg_state local_state = dr_mirror;
+  struct i386_debug_reg_state local_state = *state;
 
   if (((len != 1 && len !=2 && len !=4) && !(TARGET_HAS_DR_LEN_8 && len == 8))
       || addr % len != 0)
     retval = i386_handle_nonaligned_watchpoint (&local_state,
                                                 WP_REMOVE, addr, len, type);
   else
     {
       unsigned len_rw = i386_length_and_rw_bits (len, type);
 
       retval = i386_remove_aligned_watchpoint (&local_state,
                                                addr, len_rw);
     }
 
   if (retval == 0)
     i386_update_inferior_debug_regs (&local_state);
 
   if (maint_show_dr)
-    i386_show_dr (&dr_mirror, "remove_watchpoint", addr, len, type);
+    i386_show_dr (state, "remove_watchpoint", addr, len, type);
 
   return retval;
 }
 
 /* Return non-zero if we can watch a memory region that starts at
    address ADDR and whose length is LEN bytes.  */
 
 static int
 i386_region_ok_for_watchpoint (CORE_ADDR addr, int len)
 {
+  struct i386_debug_reg_state *state = i386_debug_reg_state ();
   int nregs;
 
   /* Compute how many aligned watchpoints we would need to cover this
      region.  */
-  nregs = i386_handle_nonaligned_watchpoint (&dr_mirror,
+  nregs = i386_handle_nonaligned_watchpoint (state,
                                              WP_COUNT, addr, len, hw_write);
   return nregs <= DR_NADDR ? 1 : 0;
 }
 
 /* If the inferior has some watchpoint that triggered, set the
    address associated with that watchpoint and return non-zero.
    Otherwise, return zero.  */
 
 static int
 i386_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
 {
+  struct i386_debug_reg_state *state = i386_debug_reg_state ();
   CORE_ADDR addr = 0;
   int i;
   int rc = 0;
+  /* The current thread's DR_STATUS.  We always need to read this to
+     check whether some watchpoint caused the trap.  */
   unsigned status;
-  unsigned control;
-  struct i386_debug_reg_state *state = &dr_mirror;
+  /* We need DR_CONTROL as well, but only iff DR_STATUS indicates a
+     data breakpoint trap.  Only fetch it when necessary, to avoid an
+     unnecessary extra syscall when no watchpoint triggered.  */
+  int control_p = 0;
+  unsigned control = 0;
 
-  dr_mirror.dr_status_mirror = i386_dr_low.get_status ();
-  status = dr_mirror.dr_status_mirror;
-  control = dr_mirror.dr_control_mirror;
+  /* In non-stop/async, threads can be running while we change the
+     STATE (and friends).  Say, we set a watchpoint, and let threads
+     resume.  Now, say you delete the watchpoint, or add/remove
+     watchpoints such that STATE changes while threads are running.
+     On targets that support non-stop, inserting/deleting watchpoints
+     updates the STATE only.  It does not update the real thread's
+     debug registers; that's only done prior to resume.  Instead, if
+     threads are running when the mirror changes, a temporary and
+     transparent stop on all threads is forced so they can get their
+     copy of the debug registers updated on re-resume.  Now, say,
+     a thread hit a watchpoint before having been updated with the new
+     STATE contents, and we haven't yet handled the corresponding
+     SIGTRAP.  If we trusted STATE below, we'd mistake the real
+     trapped address (from the last time we had updated debug
+     registers in the thread) with whatever was currently in STATE.
+     So to fix this, STATE always represents intention, what we _want_
+     threads to have in debug registers.  To get at the address and
+     cause of the trap, we need to read the state the thread still has
+     in its debug registers.
+
+     In sum, always get the current debug register values the current
+     thread has, instead of trusting the global mirror.  If the thread
+     was running when we last changed watchpoints, the mirror no
+     longer represents what was set in this thread's debug
+     registers.  */
+  status = i386_dr_low.get_status ();
 
   ALL_DEBUG_REGISTERS(i)
     {
-      if (I386_DR_WATCH_HIT (status, i)
-          /* This second condition makes sure DRi is set up for a data
-             watchpoint, not a hardware breakpoint.  The reason is
-             that GDB doesn't call the target_stopped_data_address
-             method except for data watchpoints.  In other words, I'm
-             being paranoiac.  */
-          && I386_DR_GET_RW_LEN (control, i) != 0
-          /* This third condition makes sure DRi is not vacant, this
-             avoids false positives in windows-nat.c.  */
-          && !I386_DR_VACANT (state, i))
+      if (!I386_DR_WATCH_HIT (status, i))
+        continue;
+
+      if (!control_p)
         {
-          addr = state->dr_mirror[i];
+          control = i386_dr_low.get_control ();
+          control_p = 1;
+        }
+
+      /* This second condition makes sure DRi is set up for a data
+         watchpoint, not a hardware breakpoint.  The reason is that
+         GDB doesn't call the target_stopped_data_address method
+         except for data watchpoints.  In other words, I'm being
+         paranoiac.  */
+      if (I386_DR_GET_RW_LEN (control, i) != 0)
+        {
+          addr = i386_dr_low.get_addr (i);
           rc = 1;
           if (maint_show_dr)
-            i386_show_dr (&dr_mirror, "watchpoint_hit", addr, -1, hw_write);
+            i386_show_dr (state, "watchpoint_hit", addr, -1, hw_write);
         }
     }
   if (maint_show_dr && addr == 0)
-    i386_show_dr (&dr_mirror, "stopped_data_addr", 0, 0, hw_write);
+    i386_show_dr (state, "stopped_data_addr", 0, 0, hw_write);
 
   if (rc)
     *addr_p = addr;
   return rc;
 }
 
 static int
 i386_stopped_by_watchpoint (void)
 {
   CORE_ADDR addr = 0;
   return i386_stopped_data_address (&current_target, &addr);
 }
 
 /* Insert a hardware-assisted breakpoint at BP_TGT->placed_address.
    Return 0 on success, EBUSY on failure.  */
 static int
 i386_insert_hw_breakpoint (struct gdbarch *gdbarch,
                            struct bp_target_info *bp_tgt)
 {
+  struct i386_debug_reg_state *state = i386_debug_reg_state ();
   unsigned len_rw = i386_length_and_rw_bits (1, hw_execute);
   CORE_ADDR addr = bp_tgt->placed_address;
   /* Work on a local copy of the debug registers, and on success,
      commit the change back to the inferior.  */
-  struct i386_debug_reg_state local_state = dr_mirror;
+  struct i386_debug_reg_state local_state = *state;
   int retval = i386_insert_aligned_watchpoint (&local_state,
                                                addr, len_rw) ? EBUSY : 0;
 
   if (retval == 0)
     i386_update_inferior_debug_regs (&local_state);
 
   if (maint_show_dr)
-    i386_show_dr (&dr_mirror, "insert_hwbp", addr, 1, hw_execute);
+    i386_show_dr (state, "insert_hwbp", addr, 1, hw_execute);
 
   return retval;
 }
 
 /* Remove a hardware-assisted breakpoint at BP_TGT->placed_address.
    Return 0 on success, -1 on failure.  */
 
 static int
 i386_remove_hw_breakpoint (struct gdbarch *gdbarch,
                            struct bp_target_info *bp_tgt)
 {
+  struct i386_debug_reg_state *state = i386_debug_reg_state ();
   unsigned len_rw = i386_length_and_rw_bits (1, hw_execute);
   CORE_ADDR addr = bp_tgt->placed_address;
   /* Work on a local copy of the debug registers, and on success,
      commit the change back to the inferior.  */
-  struct i386_debug_reg_state local_state = dr_mirror;
+  struct i386_debug_reg_state local_state = *state;
   int retval = i386_remove_aligned_watchpoint (&local_state,
                                                addr, len_rw);
 
   if (retval == 0)
     i386_update_inferior_debug_regs (&local_state);
 
   if (maint_show_dr)
-    i386_show_dr (&dr_mirror, "remove_hwbp", addr, 1, hw_execute);
+    i386_show_dr (state, "remove_hwbp", addr, 1, hw_execute);
 
   return retval;
 }
 
 /* Returns the number of hardware watchpoints of type TYPE that we can
    set.  Value is positive if we can set CNT watchpoints, zero if
    setting watchpoints of type TYPE is not supported, and negative if
    CNT is more than the maximum number of watchpoints of type TYPE
    that we can support.  TYPE is one of bp_hardware_watchpoint,
    bp_read_watchpoint, bp_write_watchpoint, or bp_hardware_breakpoint.
@@ skipping 44 matching lines @@
   t->to_have_continuable_watchpoint = 1;
 
   t->to_can_use_hw_breakpoint = i386_can_use_hw_breakpoint;
   t->to_region_ok_for_hw_watchpoint = i386_region_ok_for_watchpoint;
   t->to_stopped_by_watchpoint = i386_stopped_by_watchpoint;
   t->to_stopped_data_address = i386_stopped_data_address;
   t->to_insert_watchpoint = i386_insert_watchpoint;
   t->to_remove_watchpoint = i386_remove_watchpoint;
   t->to_insert_hw_breakpoint = i386_insert_hw_breakpoint;
   t->to_remove_hw_breakpoint = i386_remove_hw_breakpoint;
+
+  if (i386_inferior_data == NULL)
+    i386_inferior_data
+      = register_inferior_data_with_cleanup (i386_inferior_data_cleanup);
 }
 
 void
 i386_set_debug_register_length (int len)
 {
   /* This function should be called only once for each native target.  */
   gdb_assert (i386_dr_low.debug_register_length == 0);
   gdb_assert (len == 4 || len == 8);
   i386_dr_low.debug_register_length = len;
   add_show_debug_regs_command ();
 }