gdb/i386-darwin-nat.c - gdb

Functions defined

Macros defined

Source code

  1. /* Darwin support for GDB, the GNU debugger.
  2.    Copyright (C) 1997-2015 Free Software Foundation, Inc.

  4.    Contributed by Apple Computer, Inc.

  6.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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"

  36. #include "x86-nat.h"
  37. #include "darwin-nat.h"
  38. #include "i386-darwin-tdep.h"

  40. #ifdef BFD64
  41. #include "amd64-nat.h"
  42. #include "amd64-tdep.h"
  43. #include "amd64-darwin-tdep.h"
  44. #endif

  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);

  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;

  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.             }

  77.           /* Some kernels don't sanitize the values.  */
  78.           gp_regs.uts.ts64.__fs &= 0xffff;
  79.           gp_regs.uts.ts64.__gs &= 0xffff;

  81.           amd64_supply_native_gregset (regcache, &gp_regs.uts, -1);
  82.           fetched++;
  83.         }

  85.       if (regno == -1 || !amd64_native_gregset_supplies_p (gdbarch, regno))
  86.         {
  87.           x86_float_state_t fp_regs;
  88.           unsigned int fp_count = x86_FLOAT_STATE_COUNT;
  89.           kern_return_t ret;

  91.           ret = thread_get_state
  92.             (current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs,
  93.              &fp_count);
  94.           if (ret != KERN_SUCCESS)
  95.             {
  96.               printf_unfiltered (_("Error calling thread_get_state for "
  97.                                    "float registers for thread 0x%lx\n"),
  98.                                  (unsigned long) current_thread);
  99.               MACH_CHECK_ERROR (ret);
  100.             }
  101.           amd64_supply_fxsave (regcache, -1, &fp_regs.ufs.fs64.__fpu_fcw);
  102.           fetched++;
  103.         }
  104.     }
  105.   else
  106. #endif
  107.     {
  108.       if (regno == -1 || regno < I386_NUM_GREGS)
  109.         {
  110.           x86_thread_state32_t gp_regs;
  111.           unsigned int gp_count = x86_THREAD_STATE32_COUNT;
  112.           kern_return_t ret;
  113.           int i;

  115.           ret = thread_get_state
  116.             (current_thread, x86_THREAD_STATE32, (thread_state_t) &gp_regs,
  117.              &gp_count);
  118.           if (ret != KERN_SUCCESS)
  119.             {
  120.               printf_unfiltered (_("Error calling thread_get_state for "
  121.                                    "GP registers for thread 0x%lx\n"),
  122.                                  (unsigned long) current_thread);
  123.               MACH_CHECK_ERROR (ret);
  124.             }
  125.           for (i = 0; i < I386_NUM_GREGS; i++)
  126.             regcache_raw_supply
  127.               (regcache, i,
  128.                (char *)&gp_regs + i386_darwin_thread_state_reg_offset[i]);

  130.           fetched++;
  131.         }

  133.       if (regno == -1
  134.           || (regno >= I386_ST0_REGNUM && regno < I386_SSE_NUM_REGS))
  135.         {
  136.           x86_float_state32_t fp_regs;
  137.           unsigned int fp_count = x86_FLOAT_STATE32_COUNT;
  138.           kern_return_t ret;

  140.           ret = thread_get_state
  141.             (current_thread, x86_FLOAT_STATE32, (thread_state_t) &fp_regs,
  142.              &fp_count);
  143.           if (ret != KERN_SUCCESS)
  144.             {
  145.               printf_unfiltered (_("Error calling thread_get_state for "
  146.                                    "float registers for thread 0x%lx\n"),
  147.                                  (unsigned long) current_thread);
  148.               MACH_CHECK_ERROR (ret);
  149.             }
  150.           i387_supply_fxsave (regcache, -1, &fp_regs.__fpu_fcw);
  151.           fetched++;
  152.         }
  153.     }

  155.   if (! fetched)
  156.     {
  157.       warning (_("unknown register %d"), regno);
  158.       regcache_raw_supply (regcache, regno, NULL);
  159.     }
  160. }

  162. /* Store our register values back into the inferior.
  163.    If REGNO is -1, do this for all registers.
  164.    Otherwise, REGNO specifies which register (so we can save time).  */

  166. static void
  167. ‌i386_darwin_store_inferior_registers (struct target_ops *ops,
  168.                                       struct regcache *regcache, int regno)
  169. {
  170.   thread_t current_thread = ptid_get_tid (inferior_ptid);
  171.   struct gdbarch *gdbarch = get_regcache_arch (regcache);

  173. #ifdef BFD64
  174.   if (gdbarch_ptr_bit (gdbarch) == 64)
  175.     {
  176.       if (regno == -1 || amd64_native_gregset_supplies_p (gdbarch, regno))
  177.         {
  178.           x86_thread_state_t gp_regs;
  179.           kern_return_t ret;
  180.           unsigned int gp_count = x86_THREAD_STATE_COUNT;

  182.           ret = thread_get_state
  183.             (current_thread, x86_THREAD_STATE, (thread_state_t) &gp_regs,
  184.              &gp_count);
  185.           MACH_CHECK_ERROR (ret);
  186.           gdb_assert (gp_regs.tsh.flavor == x86_THREAD_STATE64);
  187.           gdb_assert (gp_regs.tsh.count == x86_THREAD_STATE64_COUNT);

  189.           amd64_collect_native_gregset (regcache, &gp_regs.uts, regno);

  191.           /* Some kernels don't sanitize the values.  */
  192.           gp_regs.uts.ts64.__fs &= 0xffff;
  193.           gp_regs.uts.ts64.__gs &= 0xffff;

  195.           ret = thread_set_state (current_thread, x86_THREAD_STATE,
  196.                                   (thread_state_t) &gp_regs,
  197.                                   x86_THREAD_STATE_COUNT);
  198.           MACH_CHECK_ERROR (ret);
  199.         }

  201.       if (regno == -1 || !amd64_native_gregset_supplies_p (gdbarch, regno))
  202.         {
  203.           x86_float_state_t fp_regs;
  204.           kern_return_t ret;
  205.           unsigned int fp_count = x86_FLOAT_STATE_COUNT;

  207.           ret = thread_get_state
  208.             (current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs,
  209.              &fp_count);
  210.           MACH_CHECK_ERROR (ret);
  211.           gdb_assert (fp_regs.fsh.flavor == x86_FLOAT_STATE64);
  212.           gdb_assert (fp_regs.fsh.count == x86_FLOAT_STATE64_COUNT);

  214.           amd64_collect_fxsave (regcache, regno, &fp_regs.ufs.fs64.__fpu_fcw);

  216.           ret = thread_set_state (current_thread, x86_FLOAT_STATE,
  217.                                   (thread_state_t) & fp_regs,
  218.                                   x86_FLOAT_STATE_COUNT);
  219.           MACH_CHECK_ERROR (ret);
  220.         }
  221.     }
  222.   else
  223. #endif
  224.     {
  225.       if (regno == -1 || regno < I386_NUM_GREGS)
  226.         {
  227.           x86_thread_state32_t gp_regs;
  228.           kern_return_t ret;
  229.           unsigned int gp_count = x86_THREAD_STATE32_COUNT;
  230.           int i;

  232.           ret = thread_get_state
  233.             (current_thread, x86_THREAD_STATE32, (thread_state_t) &gp_regs,
  234.              &gp_count);
  235.           MACH_CHECK_ERROR (ret);

  237.           for (i = 0; i < I386_NUM_GREGS; i++)
  238.             if (regno == -1 || regno == i)
  239.               regcache_raw_collect
  240.                 (regcache, i,
  241.                  (char *)&gp_regs + i386_darwin_thread_state_reg_offset[i]);

  243.           ret = thread_set_state (current_thread, x86_THREAD_STATE32,
  244.                                   (thread_state_t) &gp_regs,
  245.                                   x86_THREAD_STATE32_COUNT);
  246.           MACH_CHECK_ERROR (ret);
  247.         }

  249.       if (regno == -1
  250.           || (regno >= I386_ST0_REGNUM && regno < I386_SSE_NUM_REGS))
  251.         {
  252.           x86_float_state32_t fp_regs;
  253.           unsigned int fp_count = x86_FLOAT_STATE32_COUNT;
  254.           kern_return_t ret;

  256.           ret = thread_get_state
  257.             (current_thread, x86_FLOAT_STATE32, (thread_state_t) & fp_regs,
  258.              &fp_count);
  259.           MACH_CHECK_ERROR (ret);

  261.           i387_collect_fxsave (regcache, regno, &fp_regs.__fpu_fcw);

  263.           ret = thread_set_state (current_thread, x86_FLOAT_STATE32,
  264.                                   (thread_state_t) &fp_regs,
  265.                                   x86_FLOAT_STATE32_COUNT);
  266.           MACH_CHECK_ERROR (ret);
  267.         }
  268.     }
  269. }

  271. /* Support for debug registers, boosted mostly from i386-linux-nat.c.  */

  273. static void
  274. ‌i386_darwin_dr_set (int regnum, CORE_ADDR value)
  275. {
  276.   int current_pid;
  277.   thread_t current_thread;
  278.   x86_debug_state_t dr_regs;
  279.   kern_return_t ret;
  280.   unsigned int dr_count;

  282.   gdb_assert (regnum >= 0 && regnum <= DR_CONTROL);

  284.   current_thread = ptid_get_tid (inferior_ptid);

  286.   dr_regs.dsh.flavor = x86_DEBUG_STATE;
  287.   dr_regs.dsh.count = x86_DEBUG_STATE_COUNT;
  288.   dr_count = x86_DEBUG_STATE_COUNT;
  289.   ret = thread_get_state (current_thread, x86_DEBUG_STATE,
  290.                           (thread_state_t) &dr_regs, &dr_count);
  291.   MACH_CHECK_ERROR (ret);

  293.   switch (dr_regs.dsh.flavor)
  294.     {
  295.     case x86_DEBUG_STATE32:
  296.       switch (regnum)
  297.         {
  298.         case 0:
  299.           dr_regs.uds.ds32.__dr0 = value;
  300.           break;
  301.         case 1:
  302.           dr_regs.uds.ds32.__dr1 = value;
  303.           break;
  304.         case 2:
  305.           dr_regs.uds.ds32.__dr2 = value;
  306.           break;
  307.         case 3:
  308.           dr_regs.uds.ds32.__dr3 = value;
  309.           break;
  310.         case 4:
  311.           dr_regs.uds.ds32.__dr4 = value;
  312.           break;
  313.         case 5:
  314.           dr_regs.uds.ds32.__dr5 = value;
  315.           break;
  316.         case 6:
  317.           dr_regs.uds.ds32.__dr6 = value;
  318.           break;
  319.         case 7:
  320.           dr_regs.uds.ds32.__dr7 = value;
  321.           break;
  322.         }
  323.       break;
  324. #ifdef BFD64
  325.     case x86_DEBUG_STATE64:
  326.       switch (regnum)
  327.         {
  328.         case 0:
  329.           dr_regs.uds.ds64.__dr0 = value;
  330.           break;
  331.         case 1:
  332.           dr_regs.uds.ds64.__dr1 = value;
  333.           break;
  334.         case 2:
  335.           dr_regs.uds.ds64.__dr2 = value;
  336.           break;
  337.         case 3:
  338.           dr_regs.uds.ds64.__dr3 = value;
  339.           break;
  340.         case 4:
  341.           dr_regs.uds.ds64.__dr4 = value;
  342.           break;
  343.         case 5:
  344.           dr_regs.uds.ds64.__dr5 = value;
  345.           break;
  346.         case 6:
  347.           dr_regs.uds.ds64.__dr6 = value;
  348.           break;
  349.         case 7:
  350.           dr_regs.uds.ds64.__dr7 = value;
  351.           break;
  352.         }
  353.       break;
  354. #endif
  355.     }

  357.   ret = thread_set_state (current_thread, dr_regs.dsh.flavor,
  358.                           (thread_state_t) &dr_regs.uds, dr_count);

  360.   MACH_CHECK_ERROR (ret);
  361. }

  363. static CORE_ADDR
  364. ‌i386_darwin_dr_get (int regnum)
  365. {
  366.   thread_t current_thread;
  367.   x86_debug_state_t dr_regs;
  368.   kern_return_t ret;
  369.   unsigned int dr_count;

  371.   gdb_assert (regnum >= 0 && regnum <= DR_CONTROL);

  373.   current_thread = ptid_get_tid (inferior_ptid);

  375.   dr_regs.dsh.flavor = x86_DEBUG_STATE;
  376.   dr_regs.dsh.count = x86_DEBUG_STATE_COUNT;
  377.   dr_count = x86_DEBUG_STATE_COUNT;
  378.   ret = thread_get_state (current_thread, x86_DEBUG_STATE,
  379.                           (thread_state_t) &dr_regs, &dr_count);
  380.   MACH_CHECK_ERROR (ret);

  382.   switch (dr_regs.dsh.flavor)
  383.     {
  384.     case x86_DEBUG_STATE32:
  385.       switch (regnum)
  386.         {
  387.         case 0:
  388.           return dr_regs.uds.ds32.__dr0;
  389.         case 1:
  390.           return dr_regs.uds.ds32.__dr1;
  391.         case 2:
  392.           return dr_regs.uds.ds32.__dr2;
  393.         case 3:
  394.           return dr_regs.uds.ds32.__dr3;
  395.         case 4:
  396.           return dr_regs.uds.ds32.__dr4;
  397.         case 5:
  398.           return dr_regs.uds.ds32.__dr5;
  399.         case 6:
  400.           return dr_regs.uds.ds32.__dr6;
  401.         case 7:
  402.           return dr_regs.uds.ds32.__dr7;
  403.         default:
  404.           return -1;
  405.         }
  406.       break;
  407. #ifdef BFD64
  408.     case x86_DEBUG_STATE64:
  409.       switch (regnum)
  410.         {
  411.         case 0:
  412.           return dr_regs.uds.ds64.__dr0;
  413.         case 1:
  414.           return dr_regs.uds.ds64.__dr1;
  415.         case 2:
  416.           return dr_regs.uds.ds64.__dr2;
  417.         case 3:
  418.           return dr_regs.uds.ds64.__dr3;
  419.         case 4:
  420.           return dr_regs.uds.ds64.__dr4;
  421.         case 5:
  422.           return dr_regs.uds.ds64.__dr5;
  423.         case 6:
  424.           return dr_regs.uds.ds64.__dr6;
  425.         case 7:
  426.           return dr_regs.uds.ds64.__dr7;
  427.         default:
  428.           return -1;
  429.         }
  430.       break;
  431. #endif
  432.     default:
  433.       return -1;
  434.     }
  435. }

  437. static void
  438. ‌i386_darwin_dr_set_control (unsigned long control)
  439. {
  440.   i386_darwin_dr_set (DR_CONTROL, control);
  441. }

  443. static void
  444. ‌i386_darwin_dr_set_addr (int regnum, CORE_ADDR addr)
  445. {
  446.   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);

  448.   i386_darwin_dr_set (DR_FIRSTADDR + regnum, addr);
  449. }

  451. static CORE_ADDR
  452. ‌i386_darwin_dr_get_addr (int regnum)
  453. {
  454.   return i386_darwin_dr_get (regnum);
  455. }

  457. static unsigned long
  458. ‌i386_darwin_dr_get_status (void)
  459. {
  460.   return i386_darwin_dr_get (DR_STATUS);
  461. }

  463. static unsigned long
  464. ‌i386_darwin_dr_get_control (void)
  465. {
  466.   return i386_darwin_dr_get (DR_CONTROL);
  467. }

  469. void
  470. ‌darwin_check_osabi (darwin_inferior *inf, thread_t thread)
  471. {
  472.   if (gdbarch_osabi (target_gdbarch ()) == GDB_OSABI_UNKNOWN)
  473.     {
  474.       /* Attaching to a process.  Let's figure out what kind it is.  */
  475.       x86_thread_state_t gp_regs;
  476.       struct gdbarch_info info;
  477.       unsigned int gp_count = x86_THREAD_STATE_COUNT;
  478.       kern_return_t ret;

  480.       ret = thread_get_state (thread, x86_THREAD_STATE,
  481.                               (thread_state_t) &gp_regs, &gp_count);
  482.       if (ret != KERN_SUCCESS)
  483.         {
  484.           MACH_CHECK_ERROR (ret);
  485.           return;
  486.         }

  488.       gdbarch_info_init (&info);
  489.       gdbarch_info_fill (&info);
  490.       info.byte_order = gdbarch_byte_order (target_gdbarch ());
  491.       info.osabi = GDB_OSABI_DARWIN;
  492.       if (gp_regs.tsh.flavor == x86_THREAD_STATE64)
  493.         info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
  494.                                               bfd_mach_x86_64);
  495.       else
  496.         info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
  497.                                               bfd_mach_i386_i386);
  498.       gdbarch_update_p (info);
  499.     }
  500. }

  502. ‌#define X86_EFLAGS_T 0x100UL

  504. /* Returning from a signal trampoline is done by calling a
  505.    special system call (sigreturn).  This system call
  506.    restores the registers that were saved when the signal was
  507.    raised, including %eflags/%rflags.  That means that single-stepping
  508.    won't work.  Instead, we'll have to modify the signal context
  509.    that's about to be restored, and set the trace flag there.  */

  511. static int
  512. ‌i386_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
  513. {
  514.   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  515.   static const gdb_byte darwin_syscall[] = { 0xcd, 0x80 }; /* int 0x80 */
  516.   gdb_byte buf[sizeof (darwin_syscall)];

  518.   /* Check if PC is at a sigreturn system call.  */
  519.   if (target_read_memory (regs->uts.ts32.__eip, buf, sizeof (buf)) == 0
  520.       && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0
  521.       && regs->uts.ts32.__eax == 0xb8 /* SYS_sigreturn */)
  522.     {
  523.       ULONGEST uctx_addr;
  524.       ULONGEST mctx_addr;
  525.       ULONGEST flags_addr;
  526.       unsigned int eflags;

  528.       uctx_addr = read_memory_unsigned_integer
  529.                     (regs->uts.ts32.__esp + 4, 4, byte_order);
  530.       mctx_addr = read_memory_unsigned_integer
  531.                     (uctx_addr + 28, 4, byte_order);

  533.       flags_addr = mctx_addr + 12 + 9 * 4;
  534.       read_memory (flags_addr, (gdb_byte *) &eflags, 4);
  535.       eflags |= X86_EFLAGS_T;
  536.       write_memory (flags_addr, (gdb_byte *) &eflags, 4);

  538.       return 1;
  539.     }
  540.   return 0;
  541. }

  543. #ifdef BFD64
  544. static int
  545. ‌amd64_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
  546. {
  547.   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  548.   static const gdb_byte darwin_syscall[] = { 0x0f, 0x05 }; /* syscall */
  549.   gdb_byte buf[sizeof (darwin_syscall)];

  551.   /* Check if PC is at a sigreturn system call.  */
  552.   if (target_read_memory (regs->uts.ts64.__rip, buf, sizeof (buf)) == 0
  553.       && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0
  554.       && (regs->uts.ts64.__rax & 0xffffffff) == 0x20000b8 /* SYS_sigreturn */)
  555.     {
  556.       ULONGEST mctx_addr;
  557.       ULONGEST flags_addr;
  558.       unsigned int rflags;

  560.       mctx_addr = read_memory_unsigned_integer
  561.                     (regs->uts.ts64.__rdi + 48, 8, byte_order);
  562.       flags_addr = mctx_addr + 16 + 17 * 8;

  564.       /* AMD64 is little endian.  */
  565.       read_memory (flags_addr, (gdb_byte *) &rflags, 4);
  566.       rflags |= X86_EFLAGS_T;
  567.       write_memory (flags_addr, (gdb_byte *) &rflags, 4);

  569.       return 1;
  570.     }
  571.   return 0;
  572. }
  573. #endif

  575. void
  576. ‌darwin_set_sstep (thread_t thread, int enable)
  577. {
  578.   x86_thread_state_t regs;
  579.   unsigned int count = x86_THREAD_STATE_COUNT;
  580.   kern_return_t kret;

  582.   kret = thread_get_state (thread, x86_THREAD_STATE,
  583.                            (thread_state_t) &regs, &count);
  584.   if (kret != KERN_SUCCESS)
  585.     {
  586.       printf_unfiltered (_("darwin_set_sstep: error %x, thread=%x\n"),
  587.                          kret, thread);
  588.       return;
  589.     }

  591.   switch (regs.tsh.flavor)
  592.     {
  593.     case x86_THREAD_STATE32:
  594.       {
  595.         __uint32_t bit = enable ? X86_EFLAGS_T : 0;

  597.         if (enable && i386_darwin_sstep_at_sigreturn (&regs))
  598.           return;
  599.         if ((regs.uts.ts32.__eflags & X86_EFLAGS_T) == bit)
  600.           return;
  601.         regs.uts.ts32.__eflags
  602.           = (regs.uts.ts32.__eflags & ~X86_EFLAGS_T) | bit;
  603.         kret = thread_set_state (thread, x86_THREAD_STATE,
  604.                                  (thread_state_t) &regs, count);
  605.         MACH_CHECK_ERROR (kret);
  606.       }
  607.       break;
  608. #ifdef BFD64
  609.     case x86_THREAD_STATE64:
  610.       {
  611.         __uint64_t bit = enable ? X86_EFLAGS_T : 0;

  613.         if (enable && amd64_darwin_sstep_at_sigreturn (&regs))
  614.           return;
  615.         if ((regs.uts.ts64.__rflags & X86_EFLAGS_T) == bit)
  616.           return;
  617.         regs.uts.ts64.__rflags
  618.           = (regs.uts.ts64.__rflags & ~X86_EFLAGS_T) | bit;
  619.         kret = thread_set_state (thread, x86_THREAD_STATE,
  620.                                  (thread_state_t) &regs, count);
  621.         MACH_CHECK_ERROR (kret);
  622.       }
  623.       break;
  624. #endif
  625.     default:
  626.       error (_("darwin_set_sstep: unknown flavour: %d"), regs.tsh.flavor);
  627.     }
  628. }

  630. void
  631. ‌darwin_complete_target (struct target_ops *target)
  632. {
  633. #ifdef BFD64
  634.   amd64_native_gregset64_reg_offset = amd64_darwin_thread_state_reg_offset;
  635.   amd64_native_gregset64_num_regs = amd64_darwin_thread_state_num_regs;
  636.   amd64_native_gregset32_reg_offset = i386_darwin_thread_state_reg_offset;
  637.   amd64_native_gregset32_num_regs = i386_darwin_thread_state_num_regs;
  638. #endif

  640.   x86_use_watchpoints (target);

  642.   x86_dr_low.set_control = i386_darwin_dr_set_control;
  643.   x86_dr_low.set_addr = i386_darwin_dr_set_addr;
  644.   x86_dr_low.get_addr = i386_darwin_dr_get_addr;
  645.   x86_dr_low.get_status = i386_darwin_dr_get_status;
  646.   x86_dr_low.get_control = i386_darwin_dr_get_control;

  648.   /* Let's assume that the kernel is 64 bits iff the executable is.  */
  649. #ifdef __x86_64__
  650.   x86_set_debug_register_length (8);
  651. #else
  652.   x86_set_debug_register_length (4);
  653. #endif

  655.   target->to_fetch_registers = i386_darwin_fetch_inferior_registers;
  656.   target->to_store_registers = i386_darwin_store_inferior_registers;
  657. }