GDB (xrefs)

/tmp/gdb-8.1/gdb/i386-darwin-nat.c
Go to the documentation of this file.
1 /* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 1997-2018 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
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 (regcache_get_ptid (regcache));
54 int fetched = 0;
55 struct gdbarch *gdbarch = regcache->arch ();
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++)
126 regcache_raw_supply
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
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 (regcache_get_ptid (regcache));
171 struct gdbarch *gdbarch = regcache->arch ();
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)
239 regcache_raw_collect
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
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;
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
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;
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
444 i386_darwin_dr_set_addr (int regnum, CORE_ADDR addr)
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
452 i386_darwin_dr_get_addr (int regnum)
453 {
454 return i386_darwin_dr_get (regnum);
455 }
456
457 static unsigned long
458 i386_darwin_dr_get_status (void)
459 {
460 return i386_darwin_dr_get (DR_STATUS);
461 }
462
463 static unsigned long
464 i386_darwin_dr_get_control (void)
465 {
466 return i386_darwin_dr_get (DR_CONTROL);
467 }
468
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;
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);
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 }
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
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;
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
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
639
640 x86_use_watchpoints (target);
641
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;
647
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
654
655 target->to_fetch_registers = i386_darwin_fetch_inferior_registers;
656 target->to_store_registers = i386_darwin_store_inferior_registers;
657 }
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
gdbarch
Definition: gdbarch.c:127
I386_NUM_GREGS
#define I386_NUM_GREGS
Definition: i386-tdep.h:332
i386_darwin_dr_get
static CORE_ADDR i386_darwin_dr_get(int regnum)
Definition: i386-darwin-nat.c:364
darwin_complete_target
void darwin_complete_target(struct target_ops *target)
Definition: i386-darwin-nat.c:631
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
amd64-nat.h
i386_darwin_fetch_inferior_registers
static void i386_darwin_fetch_inferior_registers(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: i386-darwin-nat.c:50
amd64_collect_native_gregset
void amd64_collect_native_gregset(const struct regcache *regcache, void *gregs, int regnum)
Definition: amd64-nat.c:126
gdbarch_info_fill
void gdbarch_info_fill(struct gdbarch_info *info)
Definition: arch-utils.c:738
warning
void warning(const char *fmt,...)
Definition: errors.c:26
i387_supply_fxsave
void i387_supply_fxsave(struct regcache *regcache, int regnum, const void *fxsave)
Definition: i387-tdep.c:586
i386_darwin_dr_set_addr
static void i386_darwin_dr_set_addr(int regnum, CORE_ADDR addr)
Definition: i386-darwin-nat.c:444
I386_SSE_NUM_REGS
#define I386_SSE_NUM_REGS
Definition: i386-tdep.h:335
gdbarch_ptr_bit
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1831
amd64_native_gregset32_num_regs
int amd64_native_gregset32_num_regs
Definition: amd64-nat.c:42
regcache_get_ptid
ptid_t regcache_get_ptid(const struct regcache *regcache)
Definition: regcache.c:229
gdbarch_update_p
int gdbarch_update_p(struct gdbarch_info info)
Definition: arch-utils.c:525
amd64-darwin-tdep.h
i386_darwin_dr_get_control
static unsigned long i386_darwin_dr_get_control(void)
Definition: i386-darwin-nat.c:464
_
#define _(String)
Definition: gdb_locale.h:35
gdbarch_info::bfd_arch_info
const struct bfd_arch_info * bfd_arch_info
Definition: gdbarch.h:1629
i386_darwin_store_inferior_registers
static void i386_darwin_store_inferior_registers(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: i386-darwin-nat.c:167
x86_dr_low_type::set_control
void(* set_control)(unsigned long)
Definition: x86-dregs.h:44
defs.h
x86_dr_low
struct x86_dr_low_type x86_dr_low
Definition: x86-nat.c:37
i386_darwin_dr_set_control
static void i386_darwin_dr_set_control(unsigned long control)
Definition: i386-darwin-nat.c:438
x86_dr_low_type::get_addr
CORE_ADDR(* get_addr)(int)
Definition: x86-dregs.h:52
i386_darwin_dr_set
static void i386_darwin_dr_set(int regnum, CORE_ADDR value)
Definition: i386-darwin-nat.c:274
GDB_OSABI_UNKNOWN
Definition: defs.h:512
gdbarch_osabi
enum gdb_osabi gdbarch_osabi(struct gdbarch *gdbarch)
Definition: gdbarch.c:1527
MACH_CHECK_ERROR
#define MACH_CHECK_ERROR(ret)
Definition: darwin-nat.h:152
objfiles.h
i386_darwin_dr_get_status
static unsigned long i386_darwin_dr_get_status(void)
Definition: i386-darwin-nat.c:458
arch-utils.h
DR_FIRSTADDR
#define DR_FIRSTADDR
Definition: x86-dregs.h:69
amd64_native_gregset64_num_regs
int amd64_native_gregset64_num_regs
Definition: amd64-nat.c:46
DR_STATUS
#define DR_STATUS
Definition: x86-dregs.h:72
amd64_collect_fxsave
void amd64_collect_fxsave(const struct regcache *regcache, int regnum, void *fxsave)
Definition: amd64-tdep.c:3355
amd64_supply_native_gregset
void amd64_supply_native_gregset(struct regcache *regcache, const void *gregs, int regnum)
Definition: amd64-nat.c:95
amd64_native_gregset32_reg_offset
int * amd64_native_gregset32_reg_offset
Definition: amd64-nat.c:41
symtab.h
darwin_inferior
Definition: darwin-nat.h:105
x86_dr_low_type::set_addr
void(* set_addr)(int, CORE_ADDR)
Definition: x86-dregs.h:48
darwin_check_osabi
void darwin_check_osabi(darwin_inferior *inf, thread_t thread)
Definition: i386-darwin-nat.c:470
i387_collect_fxsave
void i387_collect_fxsave(const struct regcache *regcache, int regnum, void *fxsave)
Definition: i387-tdep.c:669
amd64_supply_fxsave
void amd64_supply_fxsave(struct regcache *regcache, int regnum, const void *fxsave)
Definition: amd64-tdep.c:3304
x86_dr_low_type::get_status
unsigned long(* get_status)(void)
Definition: x86-dregs.h:56
target_ops
Definition: target.h:412
amd64_native_gregset64_reg_offset
int * amd64_native_gregset64_reg_offset
Definition: amd64-nat.c:45
regcache.h
ptid_get_tid
long ptid_get_tid(const ptid_t &ptid)
Definition: ptid.c:63
gdbarch.h
frame.h
I386_ST0_REGNUM
Definition: i386-tdep.h:287
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
inferior.h
gdbarch_info::osabi
enum gdb_osabi osabi
Definition: gdbarch.h:1657
x86-nat.h
enable
#define enable()
Definition: ser-go32.c:239
inf
Definition: gnu-nat.c:174
amd64-tdep.h
regnum
int regnum
Definition: aarch64-tdep.c:77
printf_unfiltered
void printf_unfiltered(const char *format,...)
Definition: utils.c:2056
read_memory
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:258
GDB_OSABI_DARWIN
Definition: defs.h:527
x86_dr_low_type::get_control
unsigned long(* get_control)(void)
Definition: x86-dregs.h:60
thread_t
pthread_t thread_t
Definition: glibc_thread_db.h:242
amd64_darwin_thread_state_num_regs
const int amd64_darwin_thread_state_num_regs
Definition: amd64-darwin-tdep.c:71
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
value
Definition: value.c:169
i386_darwin_dr_get_addr
static CORE_ADDR i386_darwin_dr_get_addr(int regnum)
Definition: i386-darwin-nat.c:452
DR_CONTROL
#define DR_CONTROL
Definition: x86-dregs.h:73
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
target_ops::to_fetch_registers
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:457
darwin_set_sstep
void darwin_set_sstep(thread_t thread, int enable)
Definition: i386-darwin-nat.c:576
gdbcore.h
i386_darwin_thread_state_num_regs
const int i386_darwin_thread_state_num_regs
Definition: i386-darwin-tdep.c:62
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
gdbarch_info_init
void gdbarch_info_init(struct gdbarch_info *info)
Definition: arch-utils.c:725
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
i386-darwin-tdep.h
amd64_native_gregset_supplies_p
int amd64_native_gregset_supplies_p(struct gdbarch *gdbarch, int regnum)
Definition: amd64-nat.c:85
bit
#define bit(obj, st)
Definition: aarch64-tdep.c:63
amd64_darwin_thread_state_reg_offset
int amd64_darwin_thread_state_reg_offset[]
Definition: amd64-darwin-tdep.c:43
regcache::arch
gdbarch * arch() const
Definition: regcache.c:221
target.h
regcache_raw_supply
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1004
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
x86_set_debug_register_length
void x86_set_debug_register_length(int len)
Definition: x86-nat.c:303
regcache
Definition: regcache.h:232
i386_darwin_thread_state_reg_offset
int i386_darwin_thread_state_reg_offset[]
Definition: i386-darwin-tdep.c:42
gdbarch_info
Definition: gdbarch.h:1626
X86_EFLAGS_T
#define X86_EFLAGS_T
Definition: i386-darwin-nat.c:502
regcache_raw_collect
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
Definition: regcache.c:1085
x86_use_watchpoints
void x86_use_watchpoints(struct target_ops *t)
Definition: x86-nat.c:285
read_memory_unsigned_integer
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:326
current_thread
static windows_thread_info * current_thread
Definition: windows-nat.c:240
i386-tdep.h
write_memory
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:394
i387-tdep.h
gdbarch_info::byte_order
enum bfd_endian byte_order
Definition: gdbarch.h:1632
target_ops::to_store_registers
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:459
gdbcmd.h
error
void error(const char *fmt,...)
Definition: errors.c:38
darwin-nat.h
i386_darwin_sstep_at_sigreturn
static int i386_darwin_sstep_at_sigreturn(x86_thread_state_t *regs)
Definition: i386-darwin-nat.c:512
DR_LASTADDR
#define DR_LASTADDR
Definition: x86-dregs.h:70
symfile.h