Merge GDB 7.5.1

gdb/arm-linux-nat.c

 /* GNU/Linux on ARM native support.
    Copyright (C) 1999-2002, 2004-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.
 
@@ skipping 59 matching lines @@
 static int arm_linux_vfp_register_count;
 
 extern int arm_apcs_32;
 
 /* On GNU/Linux, threads are implemented as pseudo-processes, in which
    case we may be tracing more than one process at a time.  In that
    case, inferior_ptid will contain the main process ID and the
    individual thread (process) ID.  get_thread_id () is used to get
    the thread id if it's available, and the process id otherwise.  */
 
-int
+static int
 get_thread_id (ptid_t ptid)
 {
   int tid = TIDGET (ptid);
   if (0 == tid)
     tid = PIDGET (ptid);
   return tid;
 }
 
 #define GET_THREAD_ID(PTID)     get_thread_id (PTID)
 
@@ skipping 798 matching lines @@
 arm_linux_hw_breakpoint_initialize (struct gdbarch *gdbarch,
                                     struct bp_target_info *bp_tgt,
                                     struct arm_linux_hw_breakpoint *p)
 {
   unsigned mask;
   CORE_ADDR address = bp_tgt->placed_address;
 
   /* We have to create a mask for the control register which says which bits
      of the word pointed to by address to break on.  */
   if (arm_pc_is_thumb (gdbarch, address))
-    mask = 0x3 << (address & 2);
+    {
+      mask = 0x3;
+      address &= ~1;
+    }
   else
-    mask = 0xf;
+    {
+      mask = 0xf;
+      address &= ~3;
+    }
 
-  p->address = (unsigned int) (address & ~3);
+  p->address = (unsigned int) address;
   p->control = arm_hwbp_control_initialize (mask, arm_hwbp_break, 1);
 }
 
 /* Get the ARM hardware breakpoint type from the RW value we're given when
    asked to set a watchpoint.  */
 static arm_hwbp_type 
 arm_linux_get_hwbp_type (int rw)
 {
   if (rw == hw_read)
     return arm_hwbp_load;
@@ skipping 216 matching lines @@
   ALL_LWPS (lp)
     arm_linux_remove_hw_breakpoint1 (&p, TIDGET (lp->ptid), 1);
 
   return 0;
 }
 
 /* What was the data address the target was stopped on accessing.  */
 static int
 arm_linux_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
 {
-  struct siginfo *siginfo_p = linux_nat_get_siginfo (inferior_ptid);
-  int slot = siginfo_p->si_errno;
+  siginfo_t siginfo;
+  int slot;
+
+  if (!linux_nat_get_siginfo (inferior_ptid, &siginfo))
+    return 0;
 
   /* This must be a hardware breakpoint.  */
-  if (siginfo_p->si_signo != SIGTRAP
-      || (siginfo_p->si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */)
+  if (siginfo.si_signo != SIGTRAP
+      || (siginfo.si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */)
     return 0;
 
   /* We must be able to set hardware watchpoints.  */
   if (arm_linux_get_hw_watchpoint_count () == 0)
     return 0;
 
+  slot = siginfo.si_errno;
+
   /* If we are in a positive slot then we're looking at a breakpoint and not
      a watchpoint.  */
   if (slot >= 0)
     return 0;
 
-  *addr_p = (CORE_ADDR) (uintptr_t) siginfo_p->si_addr;
+  *addr_p = (CORE_ADDR) (uintptr_t) siginfo.si_addr;
   return 1;
 }
 
 /* Has the target been stopped by hitting a watchpoint?  */
 static int
 arm_linux_stopped_by_watchpoint (void)
 {
   CORE_ADDR addr;
   return arm_linux_stopped_data_address (&current_target, &addr);
 }
 
 static int
 arm_linux_watchpoint_addr_within_range (struct target_ops *target,
                                         CORE_ADDR addr,
                                         CORE_ADDR start, int length)
 {
   return start <= addr && start + length - 1 >= addr;
 }
 
 /* Handle thread creation.  We need to copy the breakpoints and watchpoints
    in the parent thread to the child thread.  */
 static void
-arm_linux_new_thread (ptid_t ptid)
+arm_linux_new_thread (struct lwp_info *lp)
 {
-  int tid = TIDGET (ptid);
+  int tid = TIDGET (lp->ptid);
   const struct arm_linux_hwbp_cap *info = arm_linux_get_hwbp_cap ();
 
   if (info != NULL)
     {
       int i;
       struct arm_linux_thread_points *p;
       struct arm_linux_hw_breakpoint *bpts;
 
       if (VEC_empty (arm_linux_thread_points_p, arm_threads))
         return;
@@ skipping 72 matching lines @@
 
   t->to_read_description = arm_linux_read_description;
 
   /* Register the target.  */
   linux_nat_add_target (t);
 
   /* Handle thread creation and exit */
   observer_attach_thread_exit (arm_linux_thread_exit);
   linux_nat_set_new_thread (t, arm_linux_new_thread);
 }