GDB (xrefs)
/tmp/gdb-7.10/gdb/i386-darwin-nat.c
Go to the documentation of this file.
1 /* Darwin support for GDB, the GNU debugger.
2  Copyright (C) 1997-2015 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 /* 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
51  struct regcache *regcache, int regno)
52 {
54  int fetched = 0;
55  struct gdbarch *gdbarch = get_regcache_arch (regcache);
56 
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;
65 
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  }
76 
77  /* Some kernels don't sanitize the values. */
78  gp_regs.uts.ts64.__fs &= 0xffff;
79  gp_regs.uts.ts64.__gs &= 0xffff;
80 
81  amd64_supply_native_gregset (regcache, &gp_regs.uts, -1);
82  fetched++;
83  }
84 
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;
90 
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;
114 
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++)
127  (regcache, i,
128  (char *)&gp_regs + i386_darwin_thread_state_reg_offset[i]);
129 
130  fetched++;
131  }
132 
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;
139 
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  }
154 
155  if (! fetched)
156  {
157  warning (_("unknown register %d"), regno);
158  regcache_raw_supply (regcache, regno, NULL);
159  }
160 }
161 
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). */
165 
166 static void
168  struct regcache *regcache, int regno)
169 {
171  struct gdbarch *gdbarch = get_regcache_arch (regcache);
172 
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;
181 
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);
188 
189  amd64_collect_native_gregset (regcache, &gp_regs.uts, regno);
190 
191  /* Some kernels don't sanitize the values. */
192  gp_regs.uts.ts64.__fs &= 0xffff;
193  gp_regs.uts.ts64.__gs &= 0xffff;
194 
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  }
200 
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;
206 
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);
213 
214  amd64_collect_fxsave (regcache, regno, &fp_regs.ufs.fs64.__fpu_fcw);
215 
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;
231 
232  ret = thread_get_state
233  (current_thread, x86_THREAD_STATE32, (thread_state_t) &gp_regs,
234  &gp_count);
235  MACH_CHECK_ERROR (ret);
236 
237  for (i = 0; i < I386_NUM_GREGS; i++)
238  if (regno == -1 || regno == i)
240  (regcache, i,
241  (char *)&gp_regs + i386_darwin_thread_state_reg_offset[i]);
242 
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  }
248 
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;
255 
256  ret = thread_get_state
257  (current_thread, x86_FLOAT_STATE32, (thread_state_t) & fp_regs,
258  &fp_count);
259  MACH_CHECK_ERROR (ret);
260 
261  i387_collect_fxsave (regcache, regno, &fp_regs.__fpu_fcw);
262 
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 }
270 
271 /* Support for debug registers, boosted mostly from i386-linux-nat.c. */
272 
273 static void
275 {
276  int current_pid;
278  x86_debug_state_t dr_regs;
279  kern_return_t ret;
280  unsigned int dr_count;
281 
282  gdb_assert (regnum >= 0 && regnum <= DR_CONTROL);
283 
284  current_thread = ptid_get_tid (inferior_ptid);
285 
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);
292 
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  }
356 
357  ret = thread_set_state (current_thread, dr_regs.dsh.flavor,
358  (thread_state_t) &dr_regs.uds, dr_count);
359 
360  MACH_CHECK_ERROR (ret);
361 }
362 
363 static CORE_ADDR
365 {
367  x86_debug_state_t dr_regs;
368  kern_return_t ret;
369  unsigned int dr_count;
370 
371  gdb_assert (regnum >= 0 && regnum <= DR_CONTROL);
372 
373  current_thread = ptid_get_tid (inferior_ptid);
374 
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);
381 
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 }
436 
437 static void
438 i386_darwin_dr_set_control (unsigned long control)
439 {
440  i386_darwin_dr_set (DR_CONTROL, control);
441 }
442 
443 static void
445 {
446  gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
447 
448  i386_darwin_dr_set (DR_FIRSTADDR + regnum, addr);
449 }
450 
451 static CORE_ADDR
453 {
454  return i386_darwin_dr_get (regnum);
455 }
456 
457 static unsigned long
459 {
460  return i386_darwin_dr_get (DR_STATUS);
461 }
462 
463 static unsigned long
465 {
467 }
468 
469 void
471 {
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;
479 
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  }
487 
488  gdbarch_info_init (&info);
489  gdbarch_info_fill (&info);
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 }
501 
502 #define X86_EFLAGS_T 0x100UL
503 
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. */
510 
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)];
517 
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;
527 
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);
532 
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);
537 
538  return 1;
539  }
540  return 0;
541 }
542 
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)];
550 
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;
559 
560  mctx_addr = read_memory_unsigned_integer
561  (regs->uts.ts64.__rdi + 48, 8, byte_order);
562  flags_addr = mctx_addr + 16 + 17 * 8;
563 
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);
568 
569  return 1;
570  }
571  return 0;
572 }
573 #endif
574 
575 void
577 {
578  x86_thread_state_t regs;
579  unsigned int count = x86_THREAD_STATE_COUNT;
580  kern_return_t kret;
581 
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  }
590 
591  switch (regs.tsh.flavor)
592  {
593  case x86_THREAD_STATE32:
594  {
595  __uint32_t bit = enable ? X86_EFLAGS_T : 0;
596 
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;
612 
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 }
629 
630 void
632 {
633 #ifdef BFD64
638 #endif
639 
640  x86_use_watchpoints (target);
641 
647 
648  /* Let's assume that the kernel is 64 bits iff the executable is. */
649 #ifdef __x86_64__
651 #else
653 #endif
654 
657 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
#define I386_NUM_GREGS
Definition: i386-tdep.h:320
static CORE_ADDR i386_darwin_dr_get(int regnum)
void darwin_complete_target(struct target_ops *target)
bfd_vma CORE_ADDR
Definition: common-types.h:41
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
static void i386_darwin_fetch_inferior_registers(struct target_ops *ops, struct regcache *regcache, int regno)
void amd64_collect_native_gregset(const struct regcache *regcache, void *gregs, int regnum)
Definition: amd64-nat.c:119
void gdbarch_info_fill(struct gdbarch_info *info)
Definition: arch-utils.c:721
void warning(const char *fmt,...)
Definition: errors.c:26
void i387_supply_fxsave(struct regcache *regcache, int regnum, const void *fxsave)
Definition: i387-tdep.c:595
static void i386_darwin_dr_set_addr(int regnum, CORE_ADDR addr)
#define I386_SSE_NUM_REGS
Definition: i386-tdep.h:323
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1690
int amd64_native_gregset32_num_regs
Definition: amd64-nat.c:42
int gdbarch_update_p(struct gdbarch_info info)
Definition: arch-utils.c:508
static unsigned long i386_darwin_dr_get_control(void)
#define _(String)
Definition: gdb_locale.h:40
const struct bfd_arch_info * bfd_arch_info
Definition: gdbarch.h:1549
static void i386_darwin_store_inferior_registers(struct target_ops *ops, struct regcache *regcache, int regno)
void(* set_control)(unsigned long)
Definition: x86-dregs.h:44
struct x86_dr_low_type x86_dr_low
Definition: x86-nat.c:37
static void i386_darwin_dr_set_control(unsigned long control)
CORE_ADDR(* get_addr)(int)
Definition: x86-dregs.h:52
static void i386_darwin_dr_set(int regnum, CORE_ADDR value)
enum gdb_osabi gdbarch_osabi(struct gdbarch *gdbarch)
Definition: gdbarch.c:1438
#define MACH_CHECK_ERROR(ret)
Definition: darwin-nat.h:143
static unsigned long i386_darwin_dr_get_status(void)
#define DR_FIRSTADDR
Definition: x86-dregs.h:69
int amd64_native_gregset64_num_regs
Definition: amd64-nat.c:46
#define DR_STATUS
Definition: x86-dregs.h:72
void amd64_collect_fxsave(const struct regcache *regcache, int regnum, void *fxsave)
Definition: amd64-tdep.c:3224
void amd64_supply_native_gregset(struct regcache *regcache, const void *gregs, int regnum)
Definition: amd64-nat.c:88
int * amd64_native_gregset32_reg_offset
Definition: amd64-nat.c:41
void(* set_addr)(int, CORE_ADDR)
Definition: x86-dregs.h:48
void darwin_check_osabi(darwin_inferior *inf, thread_t thread)
void i387_collect_fxsave(const struct regcache *regcache, int regnum, void *fxsave)
Definition: i387-tdep.c:678
void amd64_supply_fxsave(struct regcache *regcache, int regnum, const void *fxsave)
Definition: amd64-tdep.c:3173
unsigned long(* get_status)(void)
Definition: x86-dregs.h:56
int * amd64_native_gregset64_reg_offset
Definition: amd64-nat.c:45
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
enum gdb_osabi osabi
Definition: gdbarch.h:1563
#define enable()
Definition: ser-go32.c:239
Definition: gnu-nat.c:163
#define gdb_assert(expr)
Definition: gdb_assert.h:33
int regnum
Definition: aarch64-tdep.c:69
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:244
unsigned long(* get_control)(void)
Definition: x86-dregs.h:60
pthread_t thread_t
const int amd64_darwin_thread_state_num_regs
Definition: value.c:172
static CORE_ADDR i386_darwin_dr_get_addr(int regnum)
#define DR_CONTROL
Definition: x86-dregs.h:73
bfd_byte gdb_byte
Definition: common-types.h:38
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:472
long ptid_get_tid(ptid_t ptid)
Definition: ptid.c:68
void darwin_set_sstep(thread_t thread, int enable)
const int i386_darwin_thread_state_num_regs
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
void gdbarch_info_init(struct gdbarch_info *info)
Definition: arch-utils.c:708
ptid_t inferior_ptid
Definition: infcmd.c:124
int amd64_native_gregset_supplies_p(struct gdbarch *gdbarch, int regnum)
Definition: amd64-nat.c:78
#define bit(obj, st)
int amd64_darwin_thread_state_reg_offset[]
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1041
unsigned long long ULONGEST
Definition: common-types.h:53
void x86_set_debug_register_length(int len)
Definition: x86-nat.c:307
int i386_darwin_thread_state_reg_offset[]
#define X86_EFLAGS_T
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
Definition: regcache.c:1071
void x86_use_watchpoints(struct target_ops *t)
Definition: x86-nat.c:289
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:321
static windows_thread_info * current_thread
Definition: windows-nat.c:201
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:389
enum bfd_endian byte_order
Definition: gdbarch.h:1552
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:474
void error(const char *fmt,...)
Definition: errors.c:38
static int i386_darwin_sstep_at_sigreturn(x86_thread_state_t *regs)
#define DR_LASTADDR
Definition: x86-dregs.h:70