gdb/i386-darwin-nat.c

   1 /* Darwin support for GDB, the GNU debugger.
   2    Copyright (C) 1997-2014 Free Software Foundation, Inc.
   3
   4    Contributed by Apple Computer, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "frame.h"
  23 #include "inferior.h"
  24 #include "target.h"
  25 #include "symfile.h"
  26 #include "symtab.h"
  27 #include "objfiles.h"
  28 #include "gdbcmd.h"
  29 #include "regcache.h"
  30 #include "i386-tdep.h"
  31 #include "i387-tdep.h"
  32 #include "gdbarch.h"
  33 #include "arch-utils.h"
  34 #include "gdbcore.h"
  35
  36 #include "x86-nat.h"
  37 #include "darwin-nat.h"
  38 #include "i386-darwin-tdep.h"
  39
  40 #ifdef BFD64
  41 #include "amd64-nat.h"
  42 #include "amd64-tdep.h"
  43 #include "amd64-darwin-tdep.h"
  44 #endif
  45
  46 /* Read register values from the inferior process.
  47    If REGNO is -1, do this for all registers.
  48    Otherwise, REGNO specifies which register (so we can save time).  */
  49 static void
  50 i386_darwin_fetch_inferior_registers (struct target_ops *ops,
  51                                       struct regcache *regcache, int regno)
  52 {
  53   thread_t current_thread = ptid_get_tid (inferior_ptid);
  54   int fetched = 0;
  55   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  56
  57 #ifdef BFD64
  58   if (gdbarch_ptr_bit (gdbarch) == 64)
  59     {
  60       if (regno == -1 || amd64_native_gregset_supplies_p (gdbarch, regno))
  61         {
  62           x86_thread_state_t gp_regs;
  63           unsigned int gp_count = x86_THREAD_STATE_COUNT;
  64           kern_return_t ret;
  65
  66           ret = thread_get_state
  67             (current_thread, x86_THREAD_STATE, (thread_state_t) & gp_regs,
  68              &gp_count);
  69           if (ret != KERN_SUCCESS)
  70             {
  71               printf_unfiltered (_("Error calling thread_get_state for "
  72                                    "GP registers for thread 0x%lx\n"),
  73                                  (unsigned long) current_thread);
  74               MACH_CHECK_ERROR (ret);
  75             }
  76           amd64_supply_native_gregset (regcache, &gp_regs.uts, -1);
  77           fetched++;
  78         }
  79
  80       if (regno == -1 || !amd64_native_gregset_supplies_p (gdbarch, regno))
  81         {
  82           x86_float_state_t fp_regs;
  83           unsigned int fp_count = x86_FLOAT_STATE_COUNT;
  84           kern_return_t ret;
  85
  86           ret = thread_get_state
  87             (current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs,
  88              &fp_count);
  89           if (ret != KERN_SUCCESS)
  90             {
  91               printf_unfiltered (_("Error calling thread_get_state for "
  92                                    "float registers for thread 0x%lx\n"),
  93                                  (unsigned long) current_thread);
  94               MACH_CHECK_ERROR (ret);
  95             }
  96           amd64_supply_fxsave (regcache, -1, &fp_regs.ufs.fs64.__fpu_fcw);
  97           fetched++;
  98         }
  99     }
 100   else
 101 #endif
 102     {
 103       if (regno == -1 || regno < I386_NUM_GREGS)
 104         {
 105           x86_thread_state32_t gp_regs;
 106           unsigned int gp_count = x86_THREAD_STATE32_COUNT;
 107           kern_return_t ret;
 108           int i;
 109
 110           ret = thread_get_state
 111             (current_thread, x86_THREAD_STATE32, (thread_state_t) &gp_regs,
 112              &gp_count);
 113           if (ret != KERN_SUCCESS)
 114             {
 115               printf_unfiltered (_("Error calling thread_get_state for "
 116                                    "GP registers for thread 0x%lx\n"),
 117                                  (unsigned long) current_thread);
 118               MACH_CHECK_ERROR (ret);
 119             }
 120           for (i = 0; i < I386_NUM_GREGS; i++)
 121             regcache_raw_supply
 122               (regcache, i,
 123                (char *)&gp_regs + i386_darwin_thread_state_reg_offset[i]);
 124
 125           fetched++;
 126         }
 127
 128       if (regno == -1
 129           || (regno >= I386_ST0_REGNUM && regno < I386_SSE_NUM_REGS))
 130         {
 131           x86_float_state32_t fp_regs;
 132           unsigned int fp_count = x86_FLOAT_STATE32_COUNT;
 133           kern_return_t ret;
 134
 135           ret = thread_get_state
 136             (current_thread, x86_FLOAT_STATE32, (thread_state_t) &fp_regs,
 137              &fp_count);
 138           if (ret != KERN_SUCCESS)
 139             {
 140               printf_unfiltered (_("Error calling thread_get_state for "
 141                                    "float registers for thread 0x%lx\n"),
 142                                  (unsigned long) current_thread);
 143               MACH_CHECK_ERROR (ret);
 144             }
 145           i387_supply_fxsave (regcache, -1, &fp_regs.__fpu_fcw);
 146           fetched++;
 147         }
 148     }
 149
 150   if (! fetched)
 151     {
 152       warning (_("unknown register %d"), regno);
 153       regcache_raw_supply (regcache, regno, NULL);
 154     }
 155 }
 156
 157 /* Store our register values back into the inferior.
 158    If REGNO is -1, do this for all registers.
 159    Otherwise, REGNO specifies which register (so we can save time).  */
 160
 161 static void
 162 i386_darwin_store_inferior_registers (struct target_ops *ops,
 163                                       struct regcache *regcache, int regno)
 164 {
 165   thread_t current_thread = ptid_get_tid (inferior_ptid);
 166   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 167
 168 #ifdef BFD64
 169   if (gdbarch_ptr_bit (gdbarch) == 64)
 170     {
 171       if (regno == -1 || amd64_native_gregset_supplies_p (gdbarch, regno))
 172         {
 173           x86_thread_state_t gp_regs;
 174           kern_return_t ret;
 175           unsigned int gp_count = x86_THREAD_STATE_COUNT;
 176
 177           ret = thread_get_state
 178             (current_thread, x86_THREAD_STATE, (thread_state_t) &gp_regs,
 179              &gp_count);
 180           MACH_CHECK_ERROR (ret);
 181           gdb_assert (gp_regs.tsh.flavor == x86_THREAD_STATE64);
 182           gdb_assert (gp_regs.tsh.count == x86_THREAD_STATE64_COUNT);
 183
 184           amd64_collect_native_gregset (regcache, &gp_regs.uts, regno);
 185
 186           ret = thread_set_state (current_thread, x86_THREAD_STATE,
 187                                   (thread_state_t) &gp_regs,
 188                                   x86_THREAD_STATE_COUNT);
 189           MACH_CHECK_ERROR (ret);
 190         }
 191
 192       if (regno == -1 || !amd64_native_gregset_supplies_p (gdbarch, regno))
 193         {
 194           x86_float_state_t fp_regs;
 195           kern_return_t ret;
 196           unsigned int fp_count = x86_FLOAT_STATE_COUNT;
 197
 198           ret = thread_get_state
 199             (current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs,
 200              &fp_count);
 201           MACH_CHECK_ERROR (ret);
 202           gdb_assert (fp_regs.fsh.flavor == x86_FLOAT_STATE64);
 203           gdb_assert (fp_regs.fsh.count == x86_FLOAT_STATE64_COUNT);
 204
 205           amd64_collect_fxsave (regcache, regno, &fp_regs.ufs.fs64.__fpu_fcw);
 206
 207           ret = thread_set_state (current_thread, x86_FLOAT_STATE,
 208                                   (thread_state_t) & fp_regs,
 209                                   x86_FLOAT_STATE_COUNT);
 210           MACH_CHECK_ERROR (ret);
 211         }
 212     }
 213   else
 214 #endif
 215     {
 216       if (regno == -1 || regno < I386_NUM_GREGS)
 217         {
 218           x86_thread_state32_t gp_regs;
 219           kern_return_t ret;
 220           unsigned int gp_count = x86_THREAD_STATE32_COUNT;
 221           int i;
 222
 223           ret = thread_get_state
 224             (current_thread, x86_THREAD_STATE32, (thread_state_t) &gp_regs,
 225              &gp_count);
 226           MACH_CHECK_ERROR (ret);
 227
 228           for (i = 0; i < I386_NUM_GREGS; i++)
 229             if (regno == -1 || regno == i)
 230               regcache_raw_collect
 231                 (regcache, i,
 232                  (char *)&gp_regs + i386_darwin_thread_state_reg_offset[i]);
 233
 234           ret = thread_set_state (current_thread, x86_THREAD_STATE32,
 235                                   (thread_state_t) &gp_regs,
 236                                   x86_THREAD_STATE32_COUNT);
 237           MACH_CHECK_ERROR (ret);
 238         }
 239
 240       if (regno == -1
 241           || (regno >= I386_ST0_REGNUM && regno < I386_SSE_NUM_REGS))
 242         {
 243           x86_float_state32_t fp_regs;
 244           unsigned int fp_count = x86_FLOAT_STATE32_COUNT;
 245           kern_return_t ret;
 246
 247           ret = thread_get_state
 248             (current_thread, x86_FLOAT_STATE32, (thread_state_t) & fp_regs,
 249              &fp_count);
 250           MACH_CHECK_ERROR (ret);
 251
 252           i387_collect_fxsave (regcache, regno, &fp_regs.__fpu_fcw);
 253
 254           ret = thread_set_state (current_thread, x86_FLOAT_STATE32,
 255                                   (thread_state_t) &fp_regs,
 256                                   x86_FLOAT_STATE32_COUNT);
 257           MACH_CHECK_ERROR (ret);
 258         }
 259     }
 260 }
 261
 262 /* Support for debug registers, boosted mostly from i386-linux-nat.c.  */
 263
 264 static void
 265 i386_darwin_dr_set (int regnum, CORE_ADDR value)
 266 {
 267   int current_pid;
 268   thread_t current_thread;
 269   x86_debug_state_t dr_regs;
 270   kern_return_t ret;
 271   unsigned int dr_count;
 272
 273   gdb_assert (regnum >= 0 && regnum <= DR_CONTROL);
 274
 275   current_thread = ptid_get_tid (inferior_ptid);
 276
 277   dr_regs.dsh.flavor = x86_DEBUG_STATE;
 278   dr_regs.dsh.count = x86_DEBUG_STATE_COUNT;
 279   dr_count = x86_DEBUG_STATE_COUNT;
 280   ret = thread_get_state (current_thread, x86_DEBUG_STATE,
 281                           (thread_state_t) &dr_regs, &dr_count);
 282   MACH_CHECK_ERROR (ret);
 283
 284   switch (dr_regs.dsh.flavor)
 285     {
 286     case x86_DEBUG_STATE32:
 287       switch (regnum)
 288         {
 289         case 0:
 290           dr_regs.uds.ds32.__dr0 = value;
 291           break;
 292         case 1:
 293           dr_regs.uds.ds32.__dr1 = value;
 294           break;
 295         case 2:
 296           dr_regs.uds.ds32.__dr2 = value;
 297           break;
 298         case 3:
 299           dr_regs.uds.ds32.__dr3 = value;
 300           break;
 301         case 4:
 302           dr_regs.uds.ds32.__dr4 = value;
 303           break;
 304         case 5:
 305           dr_regs.uds.ds32.__dr5 = value;
 306           break;
 307         case 6:
 308           dr_regs.uds.ds32.__dr6 = value;
 309           break;
 310         case 7:
 311           dr_regs.uds.ds32.__dr7 = value;
 312           break;
 313         }
 314       break;
 315 #ifdef BFD64
 316     case x86_DEBUG_STATE64:
 317       switch (regnum)
 318         {
 319         case 0:
 320           dr_regs.uds.ds64.__dr0 = value;
 321           break;
 322         case 1:
 323           dr_regs.uds.ds64.__dr1 = value;
 324           break;
 325         case 2:
 326           dr_regs.uds.ds64.__dr2 = value;
 327           break;
 328         case 3:
 329           dr_regs.uds.ds64.__dr3 = value;
 330           break;
 331         case 4:
 332           dr_regs.uds.ds64.__dr4 = value;
 333           break;
 334         case 5:
 335           dr_regs.uds.ds64.__dr5 = value;
 336           break;
 337         case 6:
 338           dr_regs.uds.ds64.__dr6 = value;
 339           break;
 340         case 7:
 341           dr_regs.uds.ds64.__dr7 = value;
 342           break;
 343         }
 344       break;
 345 #endif
 346     }
 347
 348   ret = thread_set_state (current_thread, dr_regs.dsh.flavor,
 349                           (thread_state_t) &dr_regs.uds, dr_count);
 350
 351   MACH_CHECK_ERROR (ret);
 352 }
 353
 354 static CORE_ADDR
 355 i386_darwin_dr_get (int regnum)
 356 {
 357   thread_t current_thread;
 358   x86_debug_state_t dr_regs;
 359   kern_return_t ret;
 360   unsigned int dr_count;
 361
 362   gdb_assert (regnum >= 0 && regnum <= DR_CONTROL);
 363
 364   current_thread = ptid_get_tid (inferior_ptid);
 365
 366   dr_regs.dsh.flavor = x86_DEBUG_STATE;
 367   dr_regs.dsh.count = x86_DEBUG_STATE_COUNT;
 368   dr_count = x86_DEBUG_STATE_COUNT;
 369   ret = thread_get_state (current_thread, x86_DEBUG_STATE,
 370                           (thread_state_t) &dr_regs, &dr_count);
 371   MACH_CHECK_ERROR (ret);
 372
 373   switch (dr_regs.dsh.flavor)
 374     {
 375     case x86_DEBUG_STATE32:
 376       switch (regnum)
 377         {
 378         case 0:
 379           return dr_regs.uds.ds32.__dr0;
 380         case 1:
 381           return dr_regs.uds.ds32.__dr1;
 382         case 2:
 383           return dr_regs.uds.ds32.__dr2;
 384         case 3:
 385           return dr_regs.uds.ds32.__dr3;
 386         case 4:
 387           return dr_regs.uds.ds32.__dr4;
 388         case 5:
 389           return dr_regs.uds.ds32.__dr5;
 390         case 6:
 391           return dr_regs.uds.ds32.__dr6;
 392         case 7:
 393           return dr_regs.uds.ds32.__dr7;
 394         default:
 395           return -1;
 396         }
 397       break;
 398 #ifdef BFD64
 399     case x86_DEBUG_STATE64:
 400       switch (regnum)
 401         {
 402         case 0:
 403           return dr_regs.uds.ds64.__dr0;
 404         case 1:
 405           return dr_regs.uds.ds64.__dr1;
 406         case 2:
 407           return dr_regs.uds.ds64.__dr2;
 408         case 3:
 409           return dr_regs.uds.ds64.__dr3;
 410         case 4:
 411           return dr_regs.uds.ds64.__dr4;
 412         case 5:
 413           return dr_regs.uds.ds64.__dr5;
 414         case 6:
 415           return dr_regs.uds.ds64.__dr6;
 416         case 7:
 417           return dr_regs.uds.ds64.__dr7;
 418         default:
 419           return -1;
 420         }
 421       break;
 422 #endif
 423     default:
 424       return -1;
 425     }
 426 }
 427
 428 static void
 429 i386_darwin_dr_set_control (unsigned long control)
 430 {
 431   i386_darwin_dr_set (DR_CONTROL, control);
 432 }
 433
 434 static void
 435 i386_darwin_dr_set_addr (int regnum, CORE_ADDR addr)
 436 {
 437   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 438
 439   i386_darwin_dr_set (DR_FIRSTADDR + regnum, addr);
 440 }
 441
 442 static CORE_ADDR
 443 i386_darwin_dr_get_addr (int regnum)
 444 {
 445   return i386_darwin_dr_get (regnum);
 446 }
 447
 448 static unsigned long
 449 i386_darwin_dr_get_status (void)
 450 {
 451   return i386_darwin_dr_get (DR_STATUS);
 452 }
 453
 454 static unsigned long
 455 i386_darwin_dr_get_control (void)
 456 {
 457   return i386_darwin_dr_get (DR_CONTROL);
 458 }
 459
 460 void
 461 darwin_check_osabi (darwin_inferior *inf, thread_t thread)
 462 {
 463   if (gdbarch_osabi (target_gdbarch ()) == GDB_OSABI_UNKNOWN)
 464     {
 465       /* Attaching to a process.  Let's figure out what kind it is.  */
 466       x86_thread_state_t gp_regs;
 467       struct gdbarch_info info;
 468       unsigned int gp_count = x86_THREAD_STATE_COUNT;
 469       kern_return_t ret;
 470
 471       ret = thread_get_state (thread, x86_THREAD_STATE,
 472                               (thread_state_t) &gp_regs, &gp_count);
 473       if (ret != KERN_SUCCESS)
 474         {
 475           MACH_CHECK_ERROR (ret);
 476           return;
 477         }
 478
 479       gdbarch_info_init (&info);
 480       gdbarch_info_fill (&info);
 481       info.byte_order = gdbarch_byte_order (target_gdbarch ());
 482       info.osabi = GDB_OSABI_DARWIN;
 483       if (gp_regs.tsh.flavor == x86_THREAD_STATE64)
 484         info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
 485                                               bfd_mach_x86_64);
 486       else
 487         info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
 488                                               bfd_mach_i386_i386);
 489       gdbarch_update_p (info);
 490     }
 491 }
 492
 493 #define X86_EFLAGS_T 0x100UL
 494
 495 /* Returning from a signal trampoline is done by calling a
 496    special system call (sigreturn).  This system call
 497    restores the registers that were saved when the signal was
 498    raised, including %eflags/%rflags.  That means that single-stepping
 499    won't work.  Instead, we'll have to modify the signal context
 500    that's about to be restored, and set the trace flag there.  */
 501
 502 static int
 503 i386_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
 504 {
 505   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 506   static const gdb_byte darwin_syscall[] = { 0xcd, 0x80 }; /* int 0x80 */
 507   gdb_byte buf[sizeof (darwin_syscall)];
 508
 509   /* Check if PC is at a sigreturn system call.  */
 510   if (target_read_memory (regs->uts.ts32.__eip, buf, sizeof (buf)) == 0
 511       && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0
 512       && regs->uts.ts32.__eax == 0xb8 /* SYS_sigreturn */)
 513     {
 514       ULONGEST uctx_addr;
 515       ULONGEST mctx_addr;
 516       ULONGEST flags_addr;
 517       unsigned int eflags;
 518
 519       uctx_addr = read_memory_unsigned_integer
 520                     (regs->uts.ts32.__esp + 4, 4, byte_order);
 521       mctx_addr = read_memory_unsigned_integer
 522                     (uctx_addr + 28, 4, byte_order);
 523
 524       flags_addr = mctx_addr + 12 + 9 * 4;
 525       read_memory (flags_addr, (gdb_byte *) &eflags, 4);
 526       eflags |= X86_EFLAGS_T;
 527       write_memory (flags_addr, (gdb_byte *) &eflags, 4);
 528
 529       return 1;
 530     }
 531   return 0;
 532 }
 533
 534 #ifdef BFD64
 535 static int
 536 amd64_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
 537 {
 538   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 539   static const gdb_byte darwin_syscall[] = { 0x0f, 0x05 }; /* syscall */
 540   gdb_byte buf[sizeof (darwin_syscall)];
 541
 542   /* Check if PC is at a sigreturn system call.  */
 543   if (target_read_memory (regs->uts.ts64.__rip, buf, sizeof (buf)) == 0
 544       && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0
 545       && (regs->uts.ts64.__rax & 0xffffffff) == 0x20000b8 /* SYS_sigreturn */)
 546     {
 547       ULONGEST mctx_addr;
 548       ULONGEST flags_addr;
 549       unsigned int rflags;
 550
 551       mctx_addr = read_memory_unsigned_integer
 552                     (regs->uts.ts64.__rdi + 48, 8, byte_order);
 553       flags_addr = mctx_addr + 16 + 17 * 8;
 554
 555       /* AMD64 is little endian.  */
 556       read_memory (flags_addr, (gdb_byte *) &rflags, 4);
 557       rflags |= X86_EFLAGS_T;
 558       write_memory (flags_addr, (gdb_byte *) &rflags, 4);
 559
 560       return 1;
 561     }
 562   return 0;
 563 }
 564 #endif
 565
 566 void
 567 darwin_set_sstep (thread_t thread, int enable)
 568 {
 569   x86_thread_state_t regs;
 570   unsigned int count = x86_THREAD_STATE_COUNT;
 571   kern_return_t kret;
 572
 573   kret = thread_get_state (thread, x86_THREAD_STATE,
 574                            (thread_state_t) &regs, &count);
 575   if (kret != KERN_SUCCESS)
 576     {
 577       printf_unfiltered (_("darwin_set_sstep: error %x, thread=%x\n"),
 578                          kret, thread);
 579       return;
 580     }
 581
 582   switch (regs.tsh.flavor)
 583     {
 584     case x86_THREAD_STATE32:
 585       {
 586         __uint32_t bit = enable ? X86_EFLAGS_T : 0;
 587
 588         if (enable && i386_darwin_sstep_at_sigreturn (&regs))
 589           return;
 590         if ((regs.uts.ts32.__eflags & X86_EFLAGS_T) == bit)
 591           return;
 592         regs.uts.ts32.__eflags
 593           = (regs.uts.ts32.__eflags & ~X86_EFLAGS_T) | bit;
 594         kret = thread_set_state (thread, x86_THREAD_STATE,
 595                                  (thread_state_t) &regs, count);
 596         MACH_CHECK_ERROR (kret);
 597       }
 598       break;
 599 #ifdef BFD64
 600     case x86_THREAD_STATE64:
 601       {
 602         __uint64_t bit = enable ? X86_EFLAGS_T : 0;
 603
 604         if (enable && amd64_darwin_sstep_at_sigreturn (&regs))
 605           return;
 606         if ((regs.uts.ts64.__rflags & X86_EFLAGS_T) == bit)
 607           return;
 608         regs.uts.ts64.__rflags
 609           = (regs.uts.ts64.__rflags & ~X86_EFLAGS_T) | bit;
 610         kret = thread_set_state (thread, x86_THREAD_STATE,
 611                                  (thread_state_t) &regs, count);
 612         MACH_CHECK_ERROR (kret);
 613       }
 614       break;
 615 #endif
 616     default:
 617       error (_("darwin_set_sstep: unknown flavour: %d"), regs.tsh.flavor);
 618     }
 619 }
 620
 621 void
 622 darwin_complete_target (struct target_ops *target)
 623 {
 624 #ifdef BFD64
 625   amd64_native_gregset64_reg_offset = amd64_darwin_thread_state_reg_offset;
 626   amd64_native_gregset64_num_regs = amd64_darwin_thread_state_num_regs;
 627   amd64_native_gregset32_reg_offset = i386_darwin_thread_state_reg_offset;
 628   amd64_native_gregset32_num_regs = i386_darwin_thread_state_num_regs;
 629 #endif
 630
 631   x86_use_watchpoints (target);
 632
 633   x86_dr_low.set_control = i386_darwin_dr_set_control;
 634   x86_dr_low.set_addr = i386_darwin_dr_set_addr;
 635   x86_dr_low.get_addr = i386_darwin_dr_get_addr;
 636   x86_dr_low.get_status = i386_darwin_dr_get_status;
 637   x86_dr_low.get_control = i386_darwin_dr_get_control;
 638
 639   /* Let's assume that the kernel is 64 bits iff the executable is.  */
 640 #ifdef __x86_64__
 641   x86_set_debug_register_length (8);
 642 #else
 643   x86_set_debug_register_length (4);
 644 #endif
 645
 646   target->to_fetch_registers = i386_darwin_fetch_inferior_registers;
 647   target->to_store_registers = i386_darwin_store_inferior_registers;
 648 }