gdb/i386-darwin-nat.c

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