Merge GDB 7.5.1

gdb/gdbserver/linux-arm-low.c

 /* GNU/Linux/ARM specific low level interface, for the remote server for GDB.
    Copyright (C) 1995-1996, 1998-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 414 matching lines @@
 /* Are two break-/watch-points equal?  */
 static int
 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint *p1,
                                const struct arm_linux_hw_breakpoint *p2)
 {
   return p1->address == p2->address && p1->control == p2->control;
 }
 
 /* Initialize the hardware breakpoint structure P for a breakpoint or
    watchpoint at ADDR to LEN.  The type of watchpoint is given in TYPE.
-   Returns -1 if TYPE is unsupported, 0 if TYPE represents a breakpoint,
-   and 1 if type represents a watchpoint.  */
+   Returns -1 if TYPE is unsupported, or -2 if the particular combination
+   of ADDR and LEN cannot be implemented.  Otherwise, returns 0 if TYPE
+   represents a breakpoint and 1 if type represents a watchpoint.  */
 static int
 arm_linux_hw_point_initialize (char type, CORE_ADDR addr, int len,
                                struct arm_linux_hw_breakpoint *p)
 {
   arm_hwbp_type hwbp_type;
   unsigned mask;
 
   /* Breakpoint/watchpoint types (GDB terminology):
      0 = memory breakpoint for instructions
      (not supported; done via memory write instead)
@@ skipping 20 matching lines @@
       return -1;
     }
 
   if (hwbp_type == arm_hwbp_break)
     {
       /* For breakpoints, the length field encodes the mode.  */
       switch (len)
         {
         case 2:  /* 16-bit Thumb mode breakpoint */
         case 3:  /* 32-bit Thumb mode breakpoint */
-          mask = 0x3 << (addr & 2);
+          mask = 0x3;
+          addr &= ~1;
           break;
         case 4:  /* 32-bit ARM mode breakpoint */
           mask = 0xf;
+          addr &= ~3;
           break;
         default:
           /* Unsupported. */
-          return -1;
+          return -2;
         }
-
-      addr &= ~3;
     }
   else
     {
       CORE_ADDR max_wp_length = arm_linux_get_hw_watchpoint_max_length ();
       CORE_ADDR aligned_addr;
 
       /* Can not set watchpoints for zero or negative lengths.  */
       if (len <= 0)
-        return -1;
+        return -2;
       /* The current ptrace interface can only handle watchpoints that are a
          power of 2.  */
       if ((len & (len - 1)) != 0)
-        return -1;
+        return -2;
 
       /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
          range covered by a watchpoint.  */
       aligned_addr = addr & ~(max_wp_length - 1);
       if (aligned_addr + max_wp_length < addr + len)
-        return -1;
+        return -2;
 
       mask = (1 << len) - 1;
     }
 
   p->address = (unsigned int) addr;
   p->control = arm_hwbp_control_initialize (mask, hwbp_type, 1);
 
   return hwbp_type != arm_hwbp_break;
 }
 
@@ skipping 36 matching lines @@
 arm_insert_point (char type, CORE_ADDR addr, int len)
 {
   struct process_info *proc = current_process ();
   struct arm_linux_hw_breakpoint p, *pts;
   int watch, i, count;
 
   watch = arm_linux_hw_point_initialize (type, addr, len, &p);
   if (watch < 0)
     {
       /* Unsupported.  */
-      return 1;
+      return watch == -1 ? 1 : -1;
     }
 
   if (watch)
     {
       count = arm_linux_get_hw_watchpoint_count ();
       pts = proc->private->arch_private->wpts;
     }
   else
     {
       count = arm_linux_get_hw_breakpoint_count ();
@@ skipping 50 matching lines @@
 
   /* No watchpoint matched.  */
   return -1;
 }
 
 /* Return whether current thread is stopped due to a watchpoint.  */
 static int
 arm_stopped_by_watchpoint (void)
 {
   struct lwp_info *lwp = get_thread_lwp (current_inferior);
-  struct siginfo siginfo;
+  siginfo_t siginfo;
 
   /* We must be able to set hardware watchpoints.  */
   if (arm_linux_get_hw_watchpoint_count () == 0)
     return 0;
 
   /* Retrieve siginfo.  */
   errno = 0;
   ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), 0, &siginfo);
   if (errno != 0)
     return 0;
@@ skipping 57 matching lines @@
   struct arch_process_info *proc_info = proc->private->arch_private;
   struct arch_lwp_info *lwp_info = lwp->arch_private;
   int i;
 
   for (i = 0; i < arm_linux_get_hw_breakpoint_count (); i++)
     if (lwp_info->bpts_changed[i])
       {
         errno = 0;
 
         if (arm_hwbp_control_is_enabled (proc_info->bpts[i].control))
-          if (ptrace (PTRACE_SETHBPREGS, pid, ((i << 1) + 1),
-              &proc_info->bpts[i].address) < 0)
+          if (ptrace (PTRACE_SETHBPREGS, pid,
+                      (PTRACE_ARG3_TYPE) ((i << 1) + 1),
+                      &proc_info->bpts[i].address) < 0)
             perror_with_name ("Unexpected error setting breakpoint address");
 
         if (arm_hwbp_control_is_initialized (proc_info->bpts[i].control))
-          if (ptrace (PTRACE_SETHBPREGS, pid, ((i << 1) + 2),
-              &proc_info->bpts[i].control) < 0)
+          if (ptrace (PTRACE_SETHBPREGS, pid,
+                      (PTRACE_ARG3_TYPE) ((i << 1) + 2),
+                      &proc_info->bpts[i].control) < 0)
             perror_with_name ("Unexpected error setting breakpoint");
 
         lwp_info->bpts_changed[i] = 0;
       }
 
   for (i = 0; i < arm_linux_get_hw_watchpoint_count (); i++)
     if (lwp_info->wpts_changed[i])
       {
         errno = 0;
 
         if (arm_hwbp_control_is_enabled (proc_info->wpts[i].control))
-          if (ptrace (PTRACE_SETHBPREGS, pid, -((i << 1) + 1),
-              &proc_info->wpts[i].address) < 0)
+          if (ptrace (PTRACE_SETHBPREGS, pid,
+                      (PTRACE_ARG3_TYPE) -((i << 1) + 1),
+                      &proc_info->wpts[i].address) < 0)
             perror_with_name ("Unexpected error setting watchpoint address");
 
         if (arm_hwbp_control_is_initialized (proc_info->wpts[i].control))
-          if (ptrace (PTRACE_SETHBPREGS, pid, -((i << 1) + 2),
-              &proc_info->wpts[i].control) < 0)
+          if (ptrace (PTRACE_SETHBPREGS, pid,
+                      (PTRACE_ARG3_TYPE) -((i << 1) + 2),
+                      &proc_info->wpts[i].control) < 0)
             perror_with_name ("Unexpected error setting watchpoint");
 
         lwp_info->wpts_changed[i] = 0;
       }
 }
 
 
 static int
 arm_get_hwcap (unsigned long *valp)
 {
@@ skipping 80 matching lines @@
   { PTRACE_GETVFPREGS, PTRACE_SETVFPREGS, 0, 32 * 8 + 4,
     EXTENDED_REGS,
     arm_fill_vfpregset, arm_store_vfpregset },
   { 0, 0, 0, -1, -1, NULL, NULL }
 };
 
 struct linux_target_ops the_low_target = {
   arm_arch_setup,
   arm_num_regs,
   arm_regmap,
+  NULL,
   arm_cannot_fetch_register,
   arm_cannot_store_register,
+  NULL, /* fetch_register */
   arm_get_pc,
   arm_set_pc,
 
   /* Define an ARM-mode breakpoint; we only set breakpoints in the C
      library, which is most likely to be ARM.  If the kernel supports
      clone events, we will never insert a breakpoint, so even a Thumb
      C library will work; so will mixing EABI/non-EABI gdbserver and
      application.  */
 #ifndef __ARM_EABI__
   (const unsigned char *) &arm_breakpoint,
 #else
   (const unsigned char *) &arm_eabi_breakpoint,
 #endif
   arm_breakpoint_len,
   arm_reinsert_addr,
   0,
   arm_breakpoint_at,
   arm_insert_point,
   arm_remove_point,
   arm_stopped_by_watchpoint,
   arm_stopped_data_address,
   NULL, /* collect_ptrace_register */
   NULL, /* supply_ptrace_register */
   NULL, /* siginfo_fixup */
   arm_new_process,
   arm_new_thread,
   arm_prepare_to_resume,
 };