GDB (xrefs)
Loading...
Searching...
No Matches
i386-darwin-nat.c
Go to the documentation of this file.
1/* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 1997-2023 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
46struct 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
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
59void
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 warning (_("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 warning (_("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 warning (_("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++)
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 warning (_("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
174void
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)
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
280static void
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
369static CORE_ADDR
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
443static void
444i386_darwin_dr_set_control (unsigned long control)
445{
447}
448
449static void
450i386_darwin_dr_set_addr (int regnum, CORE_ADDR addr)
451{
452 gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
453
455}
456
457static CORE_ADDR
462
463static unsigned long
468
469static unsigned long
474
475void
477{
479 {
480 /* Attaching to a process. Let's figure out what kind it is. */
481 x86_thread_state_t gp_regs;
482 unsigned int gp_count = x86_THREAD_STATE_COUNT;
483 kern_return_t ret;
484
485 ret = thread_get_state (thread, x86_THREAD_STATE,
486 (thread_state_t) &gp_regs, &gp_count);
487 if (ret != KERN_SUCCESS)
488 {
489 MACH_CHECK_ERROR (ret);
490 return;
491 }
492
495 info.byte_order = gdbarch_byte_order (target_gdbarch ());
496 info.osabi = GDB_OSABI_DARWIN;
497 if (gp_regs.tsh.flavor == x86_THREAD_STATE64)
498 info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
499 bfd_mach_x86_64);
500 else
501 info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
502 bfd_mach_i386_i386);
504 }
505}
506
507#define X86_EFLAGS_T 0x100UL
508
509/* Returning from a signal trampoline is done by calling a
510 special system call (sigreturn). This system call
511 restores the registers that were saved when the signal was
512 raised, including %eflags/%rflags. That means that single-stepping
513 won't work. Instead, we'll have to modify the signal context
514 that's about to be restored, and set the trace flag there. */
515
516static int
517i386_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
518{
519 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
520 static const gdb_byte darwin_syscall[] = { 0xcd, 0x80 }; /* int 0x80 */
521 gdb_byte buf[sizeof (darwin_syscall)];
522
523 /* Check if PC is at a sigreturn system call. */
524 if (target_read_memory (regs->uts.ts32.__eip, buf, sizeof (buf)) == 0
525 && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0
526 && regs->uts.ts32.__eax == 0xb8 /* SYS_sigreturn */)
527 {
528 ULONGEST uctx_addr;
529 ULONGEST mctx_addr;
530 ULONGEST flags_addr;
531 unsigned int eflags;
532
534 (regs->uts.ts32.__esp + 4, 4, byte_order);
536 (uctx_addr + 28, 4, byte_order);
537
538 flags_addr = mctx_addr + 12 + 9 * 4;
539 read_memory (flags_addr, (gdb_byte *) &eflags, 4);
540 eflags |= X86_EFLAGS_T;
541 write_memory (flags_addr, (gdb_byte *) &eflags, 4);
542
543 return 1;
544 }
545 return 0;
546}
547
548#ifdef BFD64
549static int
550amd64_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
551{
552 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
553 static const gdb_byte darwin_syscall[] = { 0x0f, 0x05 }; /* syscall */
554 gdb_byte buf[sizeof (darwin_syscall)];
555
556 /* Check if PC is at a sigreturn system call. */
557 if (target_read_memory (regs->uts.ts64.__rip, buf, sizeof (buf)) == 0
558 && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0
559 && (regs->uts.ts64.__rax & 0xffffffff) == 0x20000b8 /* SYS_sigreturn */)
560 {
561 ULONGEST mctx_addr;
562 ULONGEST flags_addr;
563 unsigned int rflags;
564
566 (regs->uts.ts64.__rdi + 48, 8, byte_order);
567 flags_addr = mctx_addr + 16 + 17 * 8;
568
569 /* AMD64 is little endian. */
570 read_memory (flags_addr, (gdb_byte *) &rflags, 4);
571 rflags |= X86_EFLAGS_T;
572 write_memory (flags_addr, (gdb_byte *) &rflags, 4);
573
574 return 1;
575 }
576 return 0;
577}
578#endif
579
580void
582{
583 x86_thread_state_t regs;
584 unsigned int count = x86_THREAD_STATE_COUNT;
585 kern_return_t kret;
586
587 kret = thread_get_state (thread, x86_THREAD_STATE,
588 (thread_state_t) &regs, &count);
589 if (kret != KERN_SUCCESS)
590 {
591 warning (_("darwin_set_sstep: error %x, thread=%x\n"),
592 kret, thread);
593 return;
594 }
595
596 switch (regs.tsh.flavor)
597 {
598 case x86_THREAD_STATE32:
599 {
600 __uint32_t bit = enable ? X86_EFLAGS_T : 0;
601
603 return;
604 if ((regs.uts.ts32.__eflags & X86_EFLAGS_T) == bit)
605 return;
606 regs.uts.ts32.__eflags
607 = (regs.uts.ts32.__eflags & ~X86_EFLAGS_T) | bit;
608 kret = thread_set_state (thread, x86_THREAD_STATE,
609 (thread_state_t) &regs, count);
610 MACH_CHECK_ERROR (kret);
611 }
612 break;
613#ifdef BFD64
614 case x86_THREAD_STATE64:
615 {
616 __uint64_t bit = enable ? X86_EFLAGS_T : 0;
617
618 if (enable && amd64_darwin_sstep_at_sigreturn (&regs))
619 return;
620 if ((regs.uts.ts64.__rflags & X86_EFLAGS_T) == bit)
621 return;
622 regs.uts.ts64.__rflags
623 = (regs.uts.ts64.__rflags & ~X86_EFLAGS_T) | bit;
624 kret = thread_set_state (thread, x86_THREAD_STATE,
625 (thread_state_t) &regs, count);
626 MACH_CHECK_ERROR (kret);
627 }
628 break;
629#endif
630 default:
631 error (_("darwin_set_sstep: unknown flavour: %d"), regs.tsh.flavor);
632 }
633}
634
636void
#define bit(obj, st)
int regnum
int amd64_darwin_thread_state_reg_offset[]
const int amd64_darwin_thread_state_num_regs
int amd64_native_gregset32_num_regs
Definition amd64-nat.c:42
void amd64_collect_native_gregset(const struct regcache *regcache, void *gregs, int regnum)
Definition amd64-nat.c:119
int * amd64_native_gregset32_reg_offset
Definition amd64-nat.c:41
int amd64_native_gregset64_num_regs
Definition amd64-nat.c:46
int * amd64_native_gregset64_reg_offset
Definition amd64-nat.c:45
void amd64_supply_native_gregset(struct regcache *regcache, const void *gregs, int regnum)
Definition amd64-nat.c:88
int amd64_native_gregset_supplies_p(struct gdbarch *gdbarch, int regnum)
Definition amd64-nat.c:78
void amd64_supply_fxsave(struct regcache *regcache, int regnum, const void *fxsave)
void amd64_collect_fxsave(const struct regcache *regcache, int regnum, void *fxsave)
int gdbarch_update_p(struct gdbarch_info info)
Definition arch-utils.c:585
void gdbarch_info_fill(struct gdbarch_info *info)
Definition arch-utils.c:780
struct gdbarch * target_gdbarch(void)
gdbarch * arch() const
Definition regcache.c:231
void raw_collect(int regnum, void *buf) const override
Definition regcache.c:1127
void raw_supply(int regnum, const void *buf) override
Definition regcache.c:1062
ptid_t ptid() const
Definition regcache.h:408
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition corefile.c:347
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition corefile.c:306
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition corefile.c:238
#define MACH_CHECK_ERROR(ret)
Definition darwin-nat.h:203
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1722
enum gdb_osabi gdbarch_osabi(struct gdbarch *gdbarch)
Definition gdbarch.c:1414
pthread_t thread_t
static CORE_ADDR i386_darwin_dr_get_addr(int regnum)
static void i386_darwin_dr_set_control(unsigned long control)
static int i386_darwin_sstep_at_sigreturn(x86_thread_state_t *regs)
#define X86_EFLAGS_T
void _initialize_i386_darwin_nat()
static CORE_ADDR i386_darwin_dr_get(int regnum)
void darwin_set_sstep(thread_t thread, int enable)
static void i386_darwin_dr_set(int regnum, CORE_ADDR value)
static struct i386_darwin_nat_target darwin_target
static void i386_darwin_dr_set_addr(int regnum, CORE_ADDR addr)
static unsigned long i386_darwin_dr_get_control(void)
static unsigned long i386_darwin_dr_get_status(void)
void darwin_check_osabi(darwin_inferior *inf, thread_t thread)
const int i386_darwin_thread_state_num_regs
int i386_darwin_thread_state_reg_offset[]
@ I386_ST0_REGNUM
Definition i386-tdep.h:297
#define I386_SSE_NUM_REGS
Definition i386-tdep.h:347
#define I386_NUM_GREGS
Definition i386-tdep.h:344
void i387_supply_fxsave(struct regcache *regcache, int regnum, const void *fxsave)
Definition i387-tdep.c:589
void i387_collect_fxsave(const struct regcache *regcache, int regnum, void *fxsave)
Definition i387-tdep.c:673
void add_inf_child_target(inf_child_target *target)
Definition inf-child.c:418
ptid_t inferior_ptid
Definition infcmd.c:74
info(Component c)
Definition gdbarch.py:41
@ GDB_OSABI_DARWIN
Definition osabi.h:43
@ GDB_OSABI_UNKNOWN
Definition osabi.h:26
int value
Definition py-param.c:79
#define enable()
Definition ser-go32.c:239
void store_registers(struct regcache *, int) override
void fetch_registers(struct regcache *, int) override
Definition gnu-nat.c:153
Definition value.h:130
void(* set_addr)(int, CORE_ADDR)
Definition x86-dregs.h:49
unsigned long(* get_control)(void)
Definition x86-dregs.h:61
unsigned long(* get_status)(void)
Definition x86-dregs.h:57
void(* set_control)(unsigned long)
Definition x86-dregs.h:45
CORE_ADDR(* get_addr)(int)
Definition x86-dregs.h:53
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1785
#define DR_STATUS
Definition x86-dregs.h:73
#define DR_FIRSTADDR
Definition x86-dregs.h:70
struct x86_dr_low_type x86_dr_low
Definition x86-nat.c:39
#define DR_LASTADDR
Definition x86-dregs.h:71
#define DR_CONTROL
Definition x86-dregs.h:74
void x86_set_debug_register_length(int len)
Definition x86-nat.c:236