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