Merge GDB 7.5.1

gdb/i386-darwin-nat.c

 /* Darwin support for GDB, the GNU debugger.
    Copyright 1997-2002, 2008-2012 Free Software Foundation, Inc.
 
    Contributed by Apple Computer, 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
@@ skipping 16 matching lines @@
 #include "objfiles.h"
 #include "gdbcmd.h"
 #include "regcache.h"
 #include "gdb_assert.h"
 #include "i386-tdep.h"
 #include "i387-tdep.h"
 #include "gdbarch.h"
 #include "arch-utils.h"
 #include "gdbcore.h"
 
+#include "i386-nat.h"
 #include "darwin-nat.h"
 #include "i386-darwin-tdep.h"
 
 #ifdef BFD64
 #include "amd64-nat.h"
 #include "amd64-tdep.h"
 #include "amd64-darwin-tdep.h"
 #endif
 
 /* Read register values from the inferior process.
@@ skipping 15 matching lines @@
           x86_thread_state_t gp_regs;
           unsigned int gp_count = x86_THREAD_STATE_COUNT;
           kern_return_t ret;
 
           ret = thread_get_state
             (current_thread, x86_THREAD_STATE, (thread_state_t) & gp_regs,
              &gp_count);
           if (ret != KERN_SUCCESS)
             {
               printf_unfiltered (_("Error calling thread_get_state for "
-                                   "GP registers for thread 0x%ulx"),
-                                 current_thread);
+                                   "GP registers for thread 0x%lx\n"),
+                                 (unsigned long) current_thread);
               MACH_CHECK_ERROR (ret);
             }
           amd64_supply_native_gregset (regcache, &gp_regs.uts, -1);
           fetched++;
         }
 
       if (regno == -1 || !amd64_native_gregset_supplies_p (gdbarch, regno))
         {
           x86_float_state_t fp_regs;
           unsigned int fp_count = x86_FLOAT_STATE_COUNT;
           kern_return_t ret;
 
           ret = thread_get_state
             (current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs,
              &fp_count);
           if (ret != KERN_SUCCESS)
             {
               printf_unfiltered (_("Error calling thread_get_state for "
-                                   "float registers for thread 0x%ulx"),
-                                 current_thread);
+                                   "float registers for thread 0x%lx\n"),
+                                 (unsigned long) current_thread);
               MACH_CHECK_ERROR (ret);
             }
           amd64_supply_fxsave (regcache, -1, &fp_regs.ufs.fs64.__fpu_fcw);
           fetched++;
         }
     }
   else
 #endif
     {
       if (regno == -1 || regno < I386_NUM_GREGS)
         {
-          i386_thread_state_t gp_regs;
-          unsigned int gp_count = i386_THREAD_STATE_COUNT;
+          x86_thread_state32_t gp_regs;
+          unsigned int gp_count = x86_THREAD_STATE32_COUNT;
           kern_return_t ret;
           int i;
 
           ret = thread_get_state
-            (current_thread, i386_THREAD_STATE, (thread_state_t) & gp_regs,
+            (current_thread, x86_THREAD_STATE32, (thread_state_t) &gp_regs,
              &gp_count);
           if (ret != KERN_SUCCESS)
             {
               printf_unfiltered (_("Error calling thread_get_state for "
-                                   "GP registers for thread 0x%ulx"),
-                                 current_thread);
+                                   "GP registers for thread 0x%lx\n"),
+                                 (unsigned long) current_thread);
               MACH_CHECK_ERROR (ret);
             }
           for (i = 0; i < I386_NUM_GREGS; i++)
             regcache_raw_supply
               (regcache, i,
                (char *)&gp_regs + i386_darwin_thread_state_reg_offset[i]);
 
           fetched++;
         }
 
       if (regno == -1
           || (regno >= I386_ST0_REGNUM && regno < I386_SSE_NUM_REGS))
         {
-          i386_float_state_t fp_regs;
-          unsigned int fp_count = i386_FLOAT_STATE_COUNT;
+          x86_float_state32_t fp_regs;
+          unsigned int fp_count = x86_FLOAT_STATE32_COUNT;
           kern_return_t ret;
 
           ret = thread_get_state
-            (current_thread, i386_FLOAT_STATE, (thread_state_t) & fp_regs,
+            (current_thread, x86_FLOAT_STATE32, (thread_state_t) &fp_regs,
              &fp_count);
           if (ret != KERN_SUCCESS)
             {
               printf_unfiltered (_("Error calling thread_get_state for "
-                                   "float registers for thread 0x%ulx"),
-                                 current_thread);
+                                   "float registers for thread 0x%lx\n"),
+                                 (unsigned long) current_thread);
               MACH_CHECK_ERROR (ret);
             }
           i387_supply_fxsave (regcache, -1, &fp_regs.__fpu_fcw);
           fetched++;
         }
     }
 
   if (! fetched)
     {
       warning (_("unknown register %d"), regno);
@@ skipping 55 matching lines @@
                                   (thread_state_t) & fp_regs,
                                   x86_FLOAT_STATE_COUNT);
           MACH_CHECK_ERROR (ret);
         }
     }
   else
 #endif
     {
       if (regno == -1 || regno < I386_NUM_GREGS)
         {
-          i386_thread_state_t gp_regs;
+          x86_thread_state32_t gp_regs;
           kern_return_t ret;
-          unsigned int gp_count = i386_THREAD_STATE_COUNT;
+          unsigned int gp_count = x86_THREAD_STATE32_COUNT;
           int i;
 
           ret = thread_get_state
-            (current_thread, i386_THREAD_STATE, (thread_state_t) & gp_regs,
+            (current_thread, x86_THREAD_STATE32, (thread_state_t) &gp_regs,
              &gp_count);
           MACH_CHECK_ERROR (ret);
 
           for (i = 0; i < I386_NUM_GREGS; i++)
             if (regno == -1 || regno == i)
               regcache_raw_collect
                 (regcache, i,
                  (char *)&gp_regs + i386_darwin_thread_state_reg_offset[i]);
 
-          ret = thread_set_state (current_thread, i386_THREAD_STATE,
-                                  (thread_state_t) & gp_regs,
-                                  i386_THREAD_STATE_COUNT);
+          ret = thread_set_state (current_thread, x86_THREAD_STATE32,
+                                  (thread_state_t) &gp_regs,
+                                  x86_THREAD_STATE32_COUNT);
           MACH_CHECK_ERROR (ret);
         }
 
       if (regno == -1
           || (regno >= I386_ST0_REGNUM && regno < I386_SSE_NUM_REGS))
         {
-          i386_float_state_t fp_regs;
-          unsigned int fp_count = i386_FLOAT_STATE_COUNT;
+          x86_float_state32_t fp_regs;
+          unsigned int fp_count = x86_FLOAT_STATE32_COUNT;
           kern_return_t ret;
 
           ret = thread_get_state
-            (current_thread, i386_FLOAT_STATE, (thread_state_t) & fp_regs,
+            (current_thread, x86_FLOAT_STATE32, (thread_state_t) & fp_regs,
              &fp_count);
           MACH_CHECK_ERROR (ret);
 
           i387_collect_fxsave (regcache, regno, &fp_regs.__fpu_fcw);
 
-          ret = thread_set_state (current_thread, i386_FLOAT_STATE,
-                                  (thread_state_t) & fp_regs,
-                                  i386_FLOAT_STATE_COUNT);
+          ret = thread_set_state (current_thread, x86_FLOAT_STATE32,
+                                  (thread_state_t) &fp_regs,
+                                  x86_FLOAT_STATE32_COUNT);
           MACH_CHECK_ERROR (ret);
         }
     }
 }
 
-
+#ifdef HW_WATCHPOINT_NOT_YET_ENABLED
 /* Support for debug registers, boosted mostly from i386-linux-nat.c.  */
 
-#ifndef DR_FIRSTADDR
-#define DR_FIRSTADDR 0
-#endif
-
-#ifndef DR_LASTADDR
-#define DR_LASTADDR 3
-#endif
-
-#ifndef DR_STATUS
-#define DR_STATUS 6
-#endif
-
-#ifndef DR_CONTROL
-#define DR_CONTROL 7
-#endif
-
-
 static void
 i386_darwin_dr_set (int regnum, uint32_t value)
 {
   int current_pid;
   thread_t current_thread;
   x86_debug_state_t dr_regs;
   kern_return_t ret;
   unsigned int dr_count = x86_DEBUG_STATE_COUNT;
 
   gdb_assert (regnum >= 0 && regnum <= DR_CONTROL);
@@ skipping 110 matching lines @@
 }
 
 void
 i386_darwin_dr_set_addr (int regnum, CORE_ADDR addr)
 {
   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 
   i386_darwin_dr_set (DR_FIRSTADDR + regnum, addr);
 }
 
-void
-i386_darwin_dr_reset_addr (int regnum)
+CORE_ADDR
+i386_darwin_dr_get_addr (int regnum)
 {
-  gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
-
-  i386_darwin_dr_set (DR_FIRSTADDR + regnum, 0L);
+  return i386_darwin_dr_get (regnum);
 }
 
 unsigned long
 i386_darwin_dr_get_status (void)
 {
   return i386_darwin_dr_get (DR_STATUS);
 }
 
+unsigned long
+i386_darwin_dr_get_control (void)
+{
+  return i386_darwin_dr_get (DR_CONTROL);
+}
+#endif
+
 void
 darwin_check_osabi (darwin_inferior *inf, thread_t thread)
 {
   if (gdbarch_osabi (target_gdbarch) == GDB_OSABI_UNKNOWN)
     {
       /* Attaching to a process.  Let's figure out what kind it is.  */
       x86_thread_state_t gp_regs;
       struct gdbarch_info info;
       unsigned int gp_count = x86_THREAD_STATE_COUNT;
       kern_return_t ret;
@@ skipping 154 matching lines @@
 #ifdef BFD64
   amd64_native_gregset64_reg_offset = amd64_darwin_thread_state_reg_offset;
   amd64_native_gregset64_num_regs = amd64_darwin_thread_state_num_regs;
   amd64_native_gregset32_reg_offset = i386_darwin_thread_state_reg_offset;
   amd64_native_gregset32_num_regs = i386_darwin_thread_state_num_regs;
 #endif
 
   target->to_fetch_registers = i386_darwin_fetch_inferior_registers;
   target->to_store_registers = i386_darwin_store_inferior_registers;
 }