gdb/fortran: Remove some dead code from the parser
[external/binutils.git] / gdb / i386-darwin-nat.c
1 /* Darwin support for GDB, the GNU debugger.
2    Copyright (C) 1997-2019 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
637 _initialize_i386_darwin_nat (void)
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 }