gdb/i386-darwin-nat.c

   1 /* Darwin support for GDB, the GNU debugger.
   2    Copyright (C) 1997-2020 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               printf_unfiltered (_("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               printf_unfiltered (_("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               printf_unfiltered (_("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               printf_unfiltered (_("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       struct gdbarch_info info;
 483       unsigned int gp_count = x86_THREAD_STATE_COUNT;
 484       kern_return_t ret;
 485
 486       ret = thread_get_state (thread, x86_THREAD_STATE,
 487                               (thread_state_t) &gp_regs, &gp_count);
 488       if (ret != KERN_SUCCESS)
 489         {
 490           MACH_CHECK_ERROR (ret);
 491           return;
 492         }
 493
 494       gdbarch_info_init (&info);
 495       gdbarch_info_fill (&info);
 496       info.byte_order = gdbarch_byte_order (target_gdbarch ());
 497       info.osabi = GDB_OSABI_DARWIN;
 498       if (gp_regs.tsh.flavor == x86_THREAD_STATE64)
 499         info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
 500                                               bfd_mach_x86_64);
 501       else
 502         info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
 503                                               bfd_mach_i386_i386);
 504       gdbarch_update_p (info);
 505     }
 506 }
 507
 508 #define X86_EFLAGS_T 0x100UL
 509
 510 /* Returning from a signal trampoline is done by calling a
 511    special system call (sigreturn).  This system call
 512    restores the registers that were saved when the signal was
 513    raised, including %eflags/%rflags.  That means that single-stepping
 514    won't work.  Instead, we'll have to modify the signal context
 515    that's about to be restored, and set the trace flag there.  */
 516
 517 static int
 518 i386_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
 519 {
 520   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 521   static const gdb_byte darwin_syscall[] = { 0xcd, 0x80 }; /* int 0x80 */
 522   gdb_byte buf[sizeof (darwin_syscall)];
 523
 524   /* Check if PC is at a sigreturn system call.  */
 525   if (target_read_memory (regs->uts.ts32.__eip, buf, sizeof (buf)) == 0
 526       && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0
 527       && regs->uts.ts32.__eax == 0xb8 /* SYS_sigreturn */)
 528     {
 529       ULONGEST uctx_addr;
 530       ULONGEST mctx_addr;
 531       ULONGEST flags_addr;
 532       unsigned int eflags;
 533
 534       uctx_addr = read_memory_unsigned_integer
 535                     (regs->uts.ts32.__esp + 4, 4, byte_order);
 536       mctx_addr = read_memory_unsigned_integer
 537                     (uctx_addr + 28, 4, byte_order);
 538
 539       flags_addr = mctx_addr + 12 + 9 * 4;
 540       read_memory (flags_addr, (gdb_byte *) &eflags, 4);
 541       eflags |= X86_EFLAGS_T;
 542       write_memory (flags_addr, (gdb_byte *) &eflags, 4);
 543
 544       return 1;
 545     }
 546   return 0;
 547 }
 548
 549 #ifdef BFD64
 550 static int
 551 amd64_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
 552 {
 553   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 554   static const gdb_byte darwin_syscall[] = { 0x0f, 0x05 }; /* syscall */
 555   gdb_byte buf[sizeof (darwin_syscall)];
 556
 557   /* Check if PC is at a sigreturn system call.  */
 558   if (target_read_memory (regs->uts.ts64.__rip, buf, sizeof (buf)) == 0
 559       && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0
 560       && (regs->uts.ts64.__rax & 0xffffffff) == 0x20000b8 /* SYS_sigreturn */)
 561     {
 562       ULONGEST mctx_addr;
 563       ULONGEST flags_addr;
 564       unsigned int rflags;
 565
 566       mctx_addr = read_memory_unsigned_integer
 567                     (regs->uts.ts64.__rdi + 48, 8, byte_order);
 568       flags_addr = mctx_addr + 16 + 17 * 8;
 569
 570       /* AMD64 is little endian.  */
 571       read_memory (flags_addr, (gdb_byte *) &rflags, 4);
 572       rflags |= X86_EFLAGS_T;
 573       write_memory (flags_addr, (gdb_byte *) &rflags, 4);
 574
 575       return 1;
 576     }
 577   return 0;
 578 }
 579 #endif
 580
 581 void
 582 darwin_set_sstep (thread_t thread, int enable)
 583 {
 584   x86_thread_state_t regs;
 585   unsigned int count = x86_THREAD_STATE_COUNT;
 586   kern_return_t kret;
 587
 588   kret = thread_get_state (thread, x86_THREAD_STATE,
 589                            (thread_state_t) &regs, &count);
 590   if (kret != KERN_SUCCESS)
 591     {
 592       printf_unfiltered (_("darwin_set_sstep: error %x, thread=%x\n"),
 593                          kret, thread);
 594       return;
 595     }
 596
 597   switch (regs.tsh.flavor)
 598     {
 599     case x86_THREAD_STATE32:
 600       {
 601         __uint32_t bit = enable ? X86_EFLAGS_T : 0;
 602
 603         if (enable && i386_darwin_sstep_at_sigreturn (&regs))
 604           return;
 605         if ((regs.uts.ts32.__eflags & X86_EFLAGS_T) == bit)
 606           return;
 607         regs.uts.ts32.__eflags
 608           = (regs.uts.ts32.__eflags & ~X86_EFLAGS_T) | bit;
 609         kret = thread_set_state (thread, x86_THREAD_STATE,
 610                                  (thread_state_t) &regs, count);
 611         MACH_CHECK_ERROR (kret);
 612       }
 613       break;
 614 #ifdef BFD64
 615     case x86_THREAD_STATE64:
 616       {
 617         __uint64_t bit = enable ? X86_EFLAGS_T : 0;
 618
 619         if (enable && amd64_darwin_sstep_at_sigreturn (&regs))
 620           return;
 621         if ((regs.uts.ts64.__rflags & X86_EFLAGS_T) == bit)
 622           return;
 623         regs.uts.ts64.__rflags
 624           = (regs.uts.ts64.__rflags & ~X86_EFLAGS_T) | bit;
 625         kret = thread_set_state (thread, x86_THREAD_STATE,
 626                                  (thread_state_t) &regs, count);
 627         MACH_CHECK_ERROR (kret);
 628       }
 629       break;
 630 #endif
 631     default:
 632       error (_("darwin_set_sstep: unknown flavour: %d"), regs.tsh.flavor);
 633     }
 634 }
 635
 636 void _initialize_i386_darwin_nat ();
 637 void
 638 _initialize_i386_darwin_nat ()
 639 {
 640 #ifdef BFD64
 641   amd64_native_gregset64_reg_offset = amd64_darwin_thread_state_reg_offset;
 642   amd64_native_gregset64_num_regs = amd64_darwin_thread_state_num_regs;
 643   amd64_native_gregset32_reg_offset = i386_darwin_thread_state_reg_offset;
 644   amd64_native_gregset32_num_regs = i386_darwin_thread_state_num_regs;
 645 #endif
 646
 647   x86_dr_low.set_control = i386_darwin_dr_set_control;
 648   x86_dr_low.set_addr = i386_darwin_dr_set_addr;
 649   x86_dr_low.get_addr = i386_darwin_dr_get_addr;
 650   x86_dr_low.get_status = i386_darwin_dr_get_status;
 651   x86_dr_low.get_control = i386_darwin_dr_get_control;
 652
 653   /* Let's assume that the kernel is 64 bits iff the executable is.  */
 654 #ifdef __x86_64__
 655   x86_set_debug_register_length (8);
 656 #else
 657   x86_set_debug_register_length (4);
 658 #endif
 659
 660   add_inf_child_target (&darwin_target);
 661 }