1 /* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 2008-2017 Free Software Foundation, Inc.
4 Contributed by AdaCore.
6 This file is part of GDB.
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.
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.
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/>. */
31 #include "gdbthread.h"
33 #include "event-top.h"
36 #include "inf-child.h"
38 #include "arch-utils.h"
40 #include "bfd/mach-o.h"
42 #include <sys/ptrace.h>
43 #include <sys/signal.h>
45 #include <sys/types.h>
49 #include <sys/sysctl.h>
52 #include <sys/syscall.h>
55 #include <mach/mach_error.h>
56 #include <mach/mach_vm.h>
57 #include <mach/mach_init.h>
58 #include <mach/vm_map.h>
59 #include <mach/task.h>
60 #include <mach/mach_port.h>
61 #include <mach/thread_act.h>
62 #include <mach/port.h>
64 #include "darwin-nat.h"
65 #include "common/filestuff.h"
68 Darwin kernel is Mach + BSD derived kernel. Note that they share the
69 same memory space and are linked together (ie there is no micro-kernel).
71 Although ptrace(2) is available on Darwin, it is not complete. We have
72 to use Mach calls to read and write memory and to modify registers. We
73 also use Mach to get inferior faults. As we cannot use select(2) or
74 signals with Mach port (the Mach communication channel), signals are
75 reported to gdb as an exception. Furthermore we detect death of the
76 inferior through a Mach notification message. This way we only wait
79 Some Mach documentation is available for Apple xnu source package or
83 #define PTRACE(CMD, PID, ADDR, SIG) \
84 darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
86 static void darwin_interrupt (struct target_ops
*self
, ptid_t
);
88 static void darwin_resume_to (struct target_ops
*ops
, ptid_t ptid
, int step
,
89 enum gdb_signal signal
);
90 static void darwin_resume (ptid_t ptid
, int step
,
91 enum gdb_signal signal
);
93 static ptid_t
darwin_wait_to (struct target_ops
*ops
, ptid_t ptid
,
94 struct target_waitstatus
*status
, int options
);
95 static ptid_t
darwin_wait (ptid_t ptid
, struct target_waitstatus
*status
);
97 static void darwin_mourn_inferior (struct target_ops
*ops
);
99 static void darwin_kill_inferior (struct target_ops
*ops
);
101 static void darwin_ptrace_me (void);
103 static void darwin_ptrace_him (int pid
);
105 static void darwin_create_inferior (struct target_ops
*ops
,
106 const char *exec_file
,
107 const std::string
&allargs
,
108 char **env
, int from_tty
);
110 static void darwin_files_info (struct target_ops
*ops
);
112 static const char *darwin_pid_to_str (struct target_ops
*ops
, ptid_t tpid
);
114 static int darwin_thread_alive (struct target_ops
*ops
, ptid_t tpid
);
116 static void darwin_encode_reply (mig_reply_error_t
*reply
,
117 mach_msg_header_t
*hdr
, integer_t code
);
119 static void darwin_setup_request_notification (struct inferior
*inf
);
120 static void darwin_deallocate_exception_ports (darwin_inferior
*inf
);
121 static void darwin_setup_exceptions (struct inferior
*inf
);
122 static void darwin_deallocate_threads (struct inferior
*inf
);
124 /* Target operations for Darwin. */
125 static struct target_ops
*darwin_ops
;
127 /* Task identifier of gdb. */
128 static task_t gdb_task
;
130 /* A copy of mach_host_self (). */
131 mach_port_t darwin_host_self
;
133 /* Exception port. */
134 mach_port_t darwin_ex_port
;
136 /* Port set, to wait for answer on all ports. */
137 mach_port_t darwin_port_set
;
140 static vm_size_t mach_page_size
;
142 /* If Set, catch all mach exceptions (before they are converted to signals
144 static int enable_mach_exceptions
;
146 /* Inferior that should report a fake stop event. */
147 static struct inferior
*darwin_inf_fake_stop
;
149 #define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
150 #define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
152 /* This controls output of inferior debugging. */
153 static unsigned int darwin_debug_flag
= 0;
155 /* Create a __TEXT __info_plist section in the executable so that gdb could
156 be signed. This is required to get an authorization for task_for_pid.
158 Once gdb is built, you must codesign it with any system-trusted signing
159 authority. See taskgated(8) for details. */
160 static const unsigned char info_plist
[]
161 __attribute__ ((section ("__TEXT,__info_plist"),used
)) =
162 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
163 "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
164 " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
165 "<plist version=\"1.0\">\n"
167 " <key>CFBundleIdentifier</key>\n"
168 " <string>org.gnu.gdb</string>\n"
169 " <key>CFBundleName</key>\n"
170 " <string>gdb</string>\n"
171 " <key>CFBundleVersion</key>\n"
172 " <string>1.0</string>\n"
173 " <key>SecTaskAccess</key>\n"
175 " <string>allowed</string>\n"
176 " <string>debug</string>\n"
181 static void inferior_debug (int level
, const char *fmt
, ...)
182 ATTRIBUTE_PRINTF (2, 3);
185 inferior_debug (int level
, const char *fmt
, ...)
189 if (darwin_debug_flag
< level
)
193 printf_unfiltered (_("[%d inferior]: "), getpid ());
194 vprintf_unfiltered (fmt
, ap
);
199 mach_check_error (kern_return_t ret
, const char *file
,
200 unsigned int line
, const char *func
)
202 if (ret
== KERN_SUCCESS
)
205 func
= _("[UNKNOWN]");
207 warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
208 file
, line
, func
, mach_error_string (ret
), (unsigned long) ret
);
212 unparse_exception_type (unsigned int i
)
214 static char unknown_exception_buf
[32];
219 return "EXC_BAD_ACCESS";
220 case EXC_BAD_INSTRUCTION
:
221 return "EXC_BAD_INSTRUCTION";
223 return "EXC_ARITHMETIC";
225 return "EXC_EMULATION";
227 return "EXC_SOFTWARE";
229 return "EXC_BREAKPOINT";
231 return "EXC_SYSCALL";
232 case EXC_MACH_SYSCALL
:
233 return "EXC_MACH_SYSCALL";
235 return "EXC_RPC_ALERT";
239 snprintf (unknown_exception_buf
, 32, _("unknown (%d)"), i
);
240 return unknown_exception_buf
;
244 /* Set errno to zero, and then call ptrace with the given arguments.
245 If inferior debugging traces are on, then also print a debug
248 The returned value is the same as the value returned by ptrace,
249 except in the case where that value is -1 but errno is zero.
250 This case is documented to be a non-error situation, so we
251 return zero in that case. */
254 darwin_ptrace (const char *name
,
255 int request
, int pid
, caddr_t arg3
, int arg4
)
260 ret
= ptrace (request
, pid
, arg3
, arg4
);
261 if (ret
== -1 && errno
== 0)
264 inferior_debug (4, _("ptrace (%s, %d, 0x%lx, %d): %d (%s)\n"),
265 name
, pid
, (unsigned long) arg3
, arg4
, ret
,
266 (ret
!= 0) ? safe_strerror (errno
) : _("no error"));
271 cmp_thread_t (const void *l
, const void *r
)
273 thread_t tl
= *(const thread_t
*)l
;
274 thread_t tr
= *(const thread_t
*)r
;
275 return (int)(tl
- tr
);
279 darwin_check_new_threads (struct inferior
*inf
)
283 thread_array_t thread_list
;
284 unsigned int new_nbr
;
285 unsigned int old_nbr
;
286 unsigned int new_ix
, old_ix
;
287 darwin_inferior
*darwin_inf
= inf
->priv
;
288 VEC (darwin_thread_t
) *thread_vec
;
290 /* Get list of threads. */
291 kret
= task_threads (darwin_inf
->task
, &thread_list
, &new_nbr
);
292 MACH_CHECK_ERROR (kret
);
293 if (kret
!= KERN_SUCCESS
)
298 qsort (thread_list
, new_nbr
, sizeof (thread_t
), cmp_thread_t
);
300 if (darwin_inf
->threads
)
301 old_nbr
= VEC_length (darwin_thread_t
, darwin_inf
->threads
);
305 /* Quick check for no changes. */
306 if (old_nbr
== new_nbr
)
308 for (i
= 0; i
< new_nbr
; i
++)
310 != VEC_index (darwin_thread_t
, darwin_inf
->threads
, i
)->gdb_port
)
314 /* Deallocate ports. */
315 for (i
= 0; i
< new_nbr
; i
++)
317 kret
= mach_port_deallocate (mach_task_self (), thread_list
[i
]);
318 MACH_CHECK_ERROR (kret
);
321 /* Deallocate the buffer. */
322 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
323 new_nbr
* sizeof (int));
324 MACH_CHECK_ERROR (kret
);
330 /* Full handling: detect new threads, remove dead threads. */
331 thread_vec
= VEC_alloc (darwin_thread_t
, new_nbr
);
333 for (new_ix
= 0, old_ix
= 0; new_ix
< new_nbr
|| old_ix
< old_nbr
;)
335 thread_t new_id
= (new_ix
< new_nbr
) ?
336 thread_list
[new_ix
] : THREAD_NULL
;
337 darwin_thread_t
*old
= (old_ix
< old_nbr
) ?
338 VEC_index (darwin_thread_t
, darwin_inf
->threads
, old_ix
) : NULL
;
339 thread_t old_id
= old
? old
->gdb_port
: THREAD_NULL
;
342 (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
343 new_ix
, new_nbr
, old_ix
, old_nbr
, new_id
, old_id
);
345 if (old_id
== new_id
)
347 /* Thread still exist. */
348 VEC_safe_push (darwin_thread_t
, thread_vec
, old
);
352 /* Deallocate the port. */
353 kret
= mach_port_deallocate (gdb_task
, new_id
);
354 MACH_CHECK_ERROR (kret
);
358 if (new_ix
< new_nbr
&& new_id
== MACH_PORT_DEAD
)
360 /* Ignore dead ports.
361 In some weird cases, we might get dead ports. They should
362 correspond to dead thread so they could safely be ignored. */
366 if (new_ix
< new_nbr
&& (old_ix
== old_nbr
|| new_id
< old_id
))
368 /* A thread was created. */
369 struct thread_info
*tp
;
370 struct private_thread_info
*pti
;
372 pti
= XCNEW (struct private_thread_info
);
373 pti
->gdb_port
= new_id
;
374 pti
->msg_state
= DARWIN_RUNNING
;
376 if (old_nbr
== 0 && new_ix
== 0)
378 /* A ptid is create when the inferior is started (see
379 fork-child.c) with lwp=tid=0. This ptid will be renamed
380 later by darwin_init_thread_list (). */
381 tp
= find_thread_ptid (ptid_build (inf
->pid
, 0, 0));
383 gdb_assert (tp
->priv
== NULL
);
388 /* Add the new thread. */
389 tp
= add_thread_with_info
390 (ptid_build (inf
->pid
, 0, new_id
), pti
);
392 VEC_safe_push (darwin_thread_t
, thread_vec
, pti
);
396 if (old_ix
< old_nbr
&& (new_ix
== new_nbr
|| new_id
> old_id
))
398 /* A thread was removed. */
399 delete_thread (ptid_build (inf
->pid
, 0, old_id
));
400 kret
= mach_port_deallocate (gdb_task
, old_id
);
401 MACH_CHECK_ERROR (kret
);
405 gdb_assert_not_reached ("unexpected thread case");
408 if (darwin_inf
->threads
)
409 VEC_free (darwin_thread_t
, darwin_inf
->threads
);
410 darwin_inf
->threads
= thread_vec
;
412 /* Deallocate the buffer. */
413 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
414 new_nbr
* sizeof (int));
415 MACH_CHECK_ERROR (kret
);
419 find_inferior_task_it (struct inferior
*inf
, void *port_ptr
)
421 return inf
->priv
->task
== *(task_t
*)port_ptr
;
425 find_inferior_pid_it (struct inferior
*inf
, void *pid_ptr
)
427 return inf
->pid
== *(int *)pid_ptr
;
430 /* Return an inferior by task port. */
431 static struct inferior
*
432 darwin_find_inferior_by_task (task_t port
)
434 return iterate_over_inferiors (&find_inferior_task_it
, &port
);
437 /* Return an inferior by pid port. */
438 static struct inferior
*
439 darwin_find_inferior_by_pid (int pid
)
441 return iterate_over_inferiors (&find_inferior_pid_it
, &pid
);
444 /* Return a thread by port. */
445 static darwin_thread_t
*
446 darwin_find_thread (struct inferior
*inf
, thread_t thread
)
452 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, t
);
454 if (t
->gdb_port
== thread
)
459 /* Suspend (ie stop) an inferior at Mach level. */
462 darwin_suspend_inferior (struct inferior
*inf
)
464 if (!inf
->priv
->suspended
)
468 kret
= task_suspend (inf
->priv
->task
);
469 MACH_CHECK_ERROR (kret
);
471 inf
->priv
->suspended
= 1;
475 /* Resume an inferior at Mach level. */
478 darwin_resume_inferior (struct inferior
*inf
)
480 if (inf
->priv
->suspended
)
484 kret
= task_resume (inf
->priv
->task
);
485 MACH_CHECK_ERROR (kret
);
487 inf
->priv
->suspended
= 0;
491 /* Iterator functions. */
494 darwin_suspend_inferior_it (struct inferior
*inf
, void *arg
)
496 darwin_suspend_inferior (inf
);
497 darwin_check_new_threads (inf
);
502 darwin_resume_inferior_it (struct inferior
*inf
, void *arg
)
504 darwin_resume_inferior (inf
);
509 darwin_dump_message (mach_msg_header_t
*hdr
, int disp_body
)
511 printf_unfiltered (_("message header:\n"));
512 printf_unfiltered (_(" bits: 0x%x\n"), hdr
->msgh_bits
);
513 printf_unfiltered (_(" size: 0x%x\n"), hdr
->msgh_size
);
514 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr
->msgh_remote_port
);
515 printf_unfiltered (_(" local-port: 0x%x\n"), hdr
->msgh_local_port
);
516 printf_unfiltered (_(" reserved: 0x%x\n"), hdr
->msgh_reserved
);
517 printf_unfiltered (_(" id: 0x%x\n"), hdr
->msgh_id
);
521 const unsigned char *data
;
522 const unsigned int *ldata
;
526 data
= (unsigned char *)(hdr
+ 1);
527 size
= hdr
->msgh_size
- sizeof (mach_msg_header_t
);
529 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
531 mach_msg_body_t
*bod
= (mach_msg_body_t
*)data
;
532 mach_msg_port_descriptor_t
*desc
=
533 (mach_msg_port_descriptor_t
*)(bod
+ 1);
536 printf_unfiltered (_("body: descriptor_count=%u\n"),
537 bod
->msgh_descriptor_count
);
538 data
+= sizeof (mach_msg_body_t
);
539 size
-= sizeof (mach_msg_body_t
);
540 for (k
= 0; k
< bod
->msgh_descriptor_count
; k
++)
541 switch (desc
[k
].type
)
543 case MACH_MSG_PORT_DESCRIPTOR
:
545 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
546 k
, desc
[k
].type
, desc
[k
].name
, desc
[k
].disposition
);
549 printf_unfiltered (_(" descr %d: type=%u\n"),
553 data
+= bod
->msgh_descriptor_count
554 * sizeof (mach_msg_port_descriptor_t
);
555 size
-= bod
->msgh_descriptor_count
556 * sizeof (mach_msg_port_descriptor_t
);
557 ndr
= (NDR_record_t
*)(desc
+ bod
->msgh_descriptor_count
);
559 (_("NDR: mig=%02x if=%02x encod=%02x "
560 "int=%02x char=%02x float=%02x\n"),
561 ndr
->mig_vers
, ndr
->if_vers
, ndr
->mig_encoding
,
562 ndr
->int_rep
, ndr
->char_rep
, ndr
->float_rep
);
563 data
+= sizeof (NDR_record_t
);
564 size
-= sizeof (NDR_record_t
);
567 printf_unfiltered (_(" data:"));
568 ldata
= (const unsigned int *)data
;
569 for (i
= 0; i
< size
/ sizeof (unsigned int); i
++)
570 printf_unfiltered (" %08x", ldata
[i
]);
571 printf_unfiltered (_("\n"));
575 /* Adjust inferior data when a new task was created. */
577 static struct inferior
*
578 darwin_find_new_inferior (task_t task_port
, thread_t thread_port
)
581 struct inferior
*inf
;
585 /* Find the corresponding pid. */
586 kret
= pid_for_task (task_port
, &task_pid
);
587 if (kret
!= KERN_SUCCESS
)
589 MACH_CHECK_ERROR (kret
);
593 /* Find the inferior for this pid. */
594 inf
= darwin_find_inferior_by_pid (task_pid
);
598 /* Deallocate saved exception ports. */
599 darwin_deallocate_exception_ports (inf
->priv
);
601 /* No need to remove dead_name notification, but still... */
602 kret
= mach_port_request_notification (gdb_task
, inf
->priv
->task
,
603 MACH_NOTIFY_DEAD_NAME
, 0,
605 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
607 if (kret
!= KERN_INVALID_ARGUMENT
)
608 MACH_CHECK_ERROR (kret
);
610 /* Replace old task port. */
611 kret
= mach_port_deallocate (gdb_task
, inf
->priv
->task
);
612 MACH_CHECK_ERROR (kret
);
613 inf
->priv
->task
= task_port
;
615 darwin_setup_request_notification (inf
);
616 darwin_setup_exceptions (inf
);
621 /* Check data representation. */
624 darwin_check_message_ndr (NDR_record_t
*ndr
)
626 if (ndr
->mig_vers
!= NDR_PROTOCOL_2_0
627 || ndr
->if_vers
!= NDR_PROTOCOL_2_0
628 || ndr
->mig_encoding
!= NDR_record
.mig_encoding
629 || ndr
->int_rep
!= NDR_record
.int_rep
630 || ndr
->char_rep
!= NDR_record
.char_rep
631 || ndr
->float_rep
!= NDR_record
.float_rep
)
636 /* Decode an exception message. */
639 darwin_decode_exception_message (mach_msg_header_t
*hdr
,
640 struct inferior
**pinf
,
641 darwin_thread_t
**pthread
)
643 mach_msg_body_t
*bod
= (mach_msg_body_t
*)(hdr
+ 1);
644 mach_msg_port_descriptor_t
*desc
= (mach_msg_port_descriptor_t
*)(bod
+ 1);
647 struct inferior
*inf
;
648 darwin_thread_t
*thread
;
650 thread_t thread_port
;
654 /* Check message destination. */
655 if (hdr
->msgh_local_port
!= darwin_ex_port
)
658 /* Check message header. */
659 if (!(hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
))
662 /* Check descriptors. */
663 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
664 + sizeof (*ndr
) + 2 * sizeof (integer_t
))
665 || bod
->msgh_descriptor_count
!= 2
666 || desc
[0].type
!= MACH_MSG_PORT_DESCRIPTOR
667 || desc
[0].disposition
!= MACH_MSG_TYPE_MOVE_SEND
668 || desc
[1].type
!= MACH_MSG_PORT_DESCRIPTOR
669 || desc
[1].disposition
!= MACH_MSG_TYPE_MOVE_SEND
)
672 /* Check data representation. */
673 ndr
= (NDR_record_t
*)(desc
+ 2);
674 if (darwin_check_message_ndr (ndr
) != 0)
677 /* Ok, the hard work. */
678 data
= (integer_t
*)(ndr
+ 1);
680 task_port
= desc
[1].name
;
681 thread_port
= desc
[0].name
;
683 /* Find process by port. */
684 inf
= darwin_find_inferior_by_task (task_port
);
687 if (inf
== NULL
&& data
[0] == EXC_SOFTWARE
&& data
[1] == 2
688 && data
[2] == EXC_SOFT_SIGNAL
&& data
[3] == SIGTRAP
)
690 /* Not a known inferior, but a sigtrap. This happens on darwin 16.1.0,
691 as a new Mach task is created when a process exec. */
692 inf
= darwin_find_new_inferior (task_port
, thread_port
);
697 /* Deallocate task_port, unless it was saved. */
698 kret
= mach_port_deallocate (mach_task_self (), task_port
);
699 MACH_CHECK_ERROR (kret
);
704 /* We got new rights to the task, get rid of it. Do not get rid of
705 thread right, as we will need it to find the thread. */
706 kret
= mach_port_deallocate (mach_task_self (), task_port
);
707 MACH_CHECK_ERROR (kret
);
712 /* Not a known inferior. This could happen if the child fork, as
713 the created process will inherit its exception port.
714 FIXME: should the exception port be restored ? */
716 mig_reply_error_t reply
;
719 (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
722 /* Free thread port (we don't know it). */
723 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
724 MACH_CHECK_ERROR (kret
);
726 darwin_encode_reply (&reply
, hdr
, KERN_SUCCESS
);
728 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
729 reply
.Head
.msgh_size
, 0,
730 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
732 MACH_CHECK_ERROR (kret
);
737 /* Find thread by port. */
738 /* Check for new threads. Do it early so that the port in the exception
739 message can be deallocated. */
740 darwin_check_new_threads (inf
);
742 /* Free the thread port (as gdb knows the thread, it has already has a right
743 for it, so this just decrement a reference counter). */
744 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
745 MACH_CHECK_ERROR (kret
);
747 thread
= darwin_find_thread (inf
, thread_port
);
752 /* The thread should be running. However we have observed cases where a
753 thread got a SIGTTIN message after being stopped. */
754 gdb_assert (thread
->msg_state
!= DARWIN_MESSAGE
);
756 /* Finish decoding. */
757 thread
->event
.header
= *hdr
;
758 thread
->event
.thread_port
= thread_port
;
759 thread
->event
.task_port
= task_port
;
760 thread
->event
.ex_type
= data
[0];
761 thread
->event
.data_count
= data
[1];
763 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
764 + sizeof (*ndr
) + 2 * sizeof (integer_t
)
765 + data
[1] * sizeof (integer_t
)))
767 for (i
= 0; i
< data
[1]; i
++)
768 thread
->event
.ex_data
[i
] = data
[2 + i
];
770 thread
->msg_state
= DARWIN_MESSAGE
;
775 /* Decode dead_name notify message. */
778 darwin_decode_notify_message (mach_msg_header_t
*hdr
, struct inferior
**pinf
)
780 NDR_record_t
*ndr
= (NDR_record_t
*)(hdr
+ 1);
781 integer_t
*data
= (integer_t
*)(ndr
+ 1);
782 struct inferior
*inf
;
783 darwin_thread_t
*thread
;
785 thread_t thread_port
;
789 /* Check message header. */
790 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
793 /* Check descriptors. */
794 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*ndr
) + sizeof (integer_t
)))
797 /* Check data representation. */
798 if (darwin_check_message_ndr (ndr
) != 0)
803 /* Find process by port. */
804 inf
= darwin_find_inferior_by_task (task_port
);
807 /* Check message destination. */
808 if (inf
!= NULL
&& hdr
->msgh_local_port
!= inf
->priv
->notify_port
)
815 darwin_encode_reply (mig_reply_error_t
*reply
, mach_msg_header_t
*hdr
,
818 mach_msg_header_t
*rh
= &reply
->Head
;
820 rh
->msgh_bits
= MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr
->msgh_bits
), 0);
821 rh
->msgh_remote_port
= hdr
->msgh_remote_port
;
822 rh
->msgh_size
= (mach_msg_size_t
) sizeof (mig_reply_error_t
);
823 rh
->msgh_local_port
= MACH_PORT_NULL
;
824 rh
->msgh_id
= hdr
->msgh_id
+ 100;
826 reply
->NDR
= NDR_record
;
827 reply
->RetCode
= code
;
831 darwin_send_reply (struct inferior
*inf
, darwin_thread_t
*thread
)
834 mig_reply_error_t reply
;
836 darwin_encode_reply (&reply
, &thread
->event
.header
, KERN_SUCCESS
);
838 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
839 reply
.Head
.msgh_size
, 0,
840 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
842 MACH_CHECK_ERROR (kret
);
844 inf
->priv
->pending_messages
--;
848 darwin_resume_thread (struct inferior
*inf
, darwin_thread_t
*thread
,
849 int step
, int nsignal
)
855 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
856 thread
->msg_state
, thread
->gdb_port
, step
, nsignal
);
858 switch (thread
->msg_state
)
861 if (thread
->event
.ex_type
== EXC_SOFTWARE
862 && thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
864 /* Either deliver a new signal or cancel the signal received. */
865 res
= PTRACE (PT_THUPDATE
, inf
->pid
,
866 (caddr_t
) (uintptr_t) thread
->gdb_port
, nsignal
);
868 inferior_debug (1, _("ptrace THUP: res=%d\n"), res
);
872 /* Note: ptrace is allowed only if the process is stopped.
873 Directly send the signal to the thread. */
874 res
= syscall (SYS___pthread_kill
, thread
->gdb_port
, nsignal
);
875 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
876 thread
->gdb_port
, nsignal
, res
);
877 thread
->signaled
= 1;
880 /* Set or reset single step. */
881 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
882 thread
->gdb_port
, step
);
883 darwin_set_sstep (thread
->gdb_port
, step
);
884 thread
->single_step
= step
;
886 darwin_send_reply (inf
, thread
);
887 thread
->msg_state
= DARWIN_RUNNING
;
894 kret
= thread_resume (thread
->gdb_port
);
895 MACH_CHECK_ERROR (kret
);
897 thread
->msg_state
= DARWIN_RUNNING
;
902 /* Resume all threads of the inferior. */
905 darwin_resume_inferior_threads (struct inferior
*inf
, int step
, int nsignal
)
907 darwin_thread_t
*thread
;
911 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, thread
);
913 darwin_resume_thread (inf
, thread
, step
, nsignal
);
916 struct resume_inferior_threads_param
923 darwin_resume_inferior_threads_it (struct inferior
*inf
, void *param
)
925 int step
= ((struct resume_inferior_threads_param
*)param
)->step
;
926 int nsignal
= ((struct resume_inferior_threads_param
*)param
)->nsignal
;
928 darwin_resume_inferior_threads (inf
, step
, nsignal
);
933 /* Suspend all threads of INF. */
936 darwin_suspend_inferior_threads (struct inferior
*inf
)
938 darwin_thread_t
*thread
;
943 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, thread
);
945 switch (thread
->msg_state
)
951 kret
= thread_suspend (thread
->gdb_port
);
952 MACH_CHECK_ERROR (kret
);
953 thread
->msg_state
= DARWIN_STOPPED
;
959 darwin_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
961 struct target_waitstatus status
;
967 struct inferior
*inf
;
970 (2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
971 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, signal
);
973 if (signal
== GDB_SIGNAL_0
)
976 nsignal
= gdb_signal_to_host (signal
);
978 /* Don't try to single step all threads. */
980 ptid
= inferior_ptid
;
982 /* minus_one_ptid is RESUME_ALL. */
983 if (ptid_equal (ptid
, minus_one_ptid
))
985 struct resume_inferior_threads_param param
;
987 param
.nsignal
= nsignal
;
990 /* Resume threads. */
991 iterate_over_inferiors (darwin_resume_inferior_threads_it
, ¶m
);
993 iterate_over_inferiors (darwin_resume_inferior_it
, NULL
);
997 struct inferior
*inf
= find_inferior_ptid (ptid
);
998 long tid
= ptid_get_tid (ptid
);
1000 /* Stop the inferior (should be useless). */
1001 darwin_suspend_inferior (inf
);
1004 darwin_resume_inferior_threads (inf
, step
, nsignal
);
1007 darwin_thread_t
*thread
;
1009 /* Suspend threads of the task. */
1010 darwin_suspend_inferior_threads (inf
);
1012 /* Resume the selected thread. */
1013 thread
= darwin_find_thread (inf
, tid
);
1014 gdb_assert (thread
);
1015 darwin_resume_thread (inf
, thread
, step
, nsignal
);
1018 /* Resume the task. */
1019 darwin_resume_inferior (inf
);
1024 darwin_resume_to (struct target_ops
*ops
, ptid_t ptid
, int step
,
1025 enum gdb_signal signal
)
1027 return darwin_resume (ptid
, step
, signal
);
1031 darwin_decode_message (mach_msg_header_t
*hdr
,
1032 darwin_thread_t
**pthread
,
1033 struct inferior
**pinf
,
1034 struct target_waitstatus
*status
)
1036 darwin_thread_t
*thread
;
1037 struct inferior
*inf
;
1039 /* Exception message. 2401 == 0x961 is exc. */
1040 if (hdr
->msgh_id
== 2401)
1044 /* Decode message. */
1045 res
= darwin_decode_exception_message (hdr
, &inf
, &thread
);
1049 /* Should not happen... */
1051 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr
->msgh_id
);
1052 /* FIXME: send a failure reply? */
1053 status
->kind
= TARGET_WAITKIND_IGNORE
;
1054 return minus_one_ptid
;
1058 status
->kind
= TARGET_WAITKIND_IGNORE
;
1059 return minus_one_ptid
;
1063 inf
->priv
->pending_messages
++;
1065 status
->kind
= TARGET_WAITKIND_STOPPED
;
1066 thread
->msg_state
= DARWIN_MESSAGE
;
1068 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1070 unparse_exception_type (thread
->event
.ex_type
));
1072 switch (thread
->event
.ex_type
)
1074 case EXC_BAD_ACCESS
:
1075 status
->value
.sig
= GDB_EXC_BAD_ACCESS
;
1077 case EXC_BAD_INSTRUCTION
:
1078 status
->value
.sig
= GDB_EXC_BAD_INSTRUCTION
;
1080 case EXC_ARITHMETIC
:
1081 status
->value
.sig
= GDB_EXC_ARITHMETIC
;
1084 status
->value
.sig
= GDB_EXC_EMULATION
;
1087 if (thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
1090 gdb_signal_from_host (thread
->event
.ex_data
[1]);
1091 inferior_debug (5, _(" (signal %d: %s)\n"),
1092 thread
->event
.ex_data
[1],
1093 gdb_signal_to_name (status
->value
.sig
));
1095 /* If the thread is stopped because it has received a signal
1096 that gdb has just sent, continue. */
1097 if (thread
->signaled
)
1099 thread
->signaled
= 0;
1100 darwin_send_reply (inf
, thread
);
1101 thread
->msg_state
= DARWIN_RUNNING
;
1102 status
->kind
= TARGET_WAITKIND_IGNORE
;
1106 status
->value
.sig
= GDB_EXC_SOFTWARE
;
1108 case EXC_BREAKPOINT
:
1109 /* Many internal GDB routines expect breakpoints to be reported
1110 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1111 as a spurious signal. */
1112 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1115 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1119 return ptid_build (inf
->pid
, 0, thread
->gdb_port
);
1121 else if (hdr
->msgh_id
== 0x48)
1123 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
1126 res
= darwin_decode_notify_message (hdr
, &inf
);
1130 /* Should not happen... */
1132 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1139 if (res
< 0 || inf
== NULL
)
1141 status
->kind
= TARGET_WAITKIND_IGNORE
;
1142 return minus_one_ptid
;
1147 if (!inf
->priv
->no_ptrace
)
1152 res
= wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1153 if (res
< 0 || res
!= inf
->pid
)
1155 printf_unfiltered (_("wait4: res=%d: %s\n"),
1156 res
, safe_strerror (errno
));
1157 status
->kind
= TARGET_WAITKIND_IGNORE
;
1158 return minus_one_ptid
;
1160 if (WIFEXITED (wstatus
))
1162 status
->kind
= TARGET_WAITKIND_EXITED
;
1163 status
->value
.integer
= WEXITSTATUS (wstatus
);
1167 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
1168 status
->value
.sig
= gdb_signal_from_host (WTERMSIG (wstatus
));
1171 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1174 /* Looks necessary on Leopard and harmless... */
1175 wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1177 inferior_ptid
= ptid_build (inf
->pid
, 0, 0);
1178 return inferior_ptid
;
1182 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf
->pid
);
1183 status
->kind
= TARGET_WAITKIND_EXITED
;
1184 status
->value
.integer
= 0; /* Don't know. */
1185 return ptid_build (inf
->pid
, 0, 0);
1190 /* Unknown message. */
1191 warning (_("darwin: got unknown message, id: 0x%x"), hdr
->msgh_id
);
1192 status
->kind
= TARGET_WAITKIND_IGNORE
;
1193 return minus_one_ptid
;
1197 cancel_breakpoint (ptid_t ptid
)
1199 /* Arrange for a breakpoint to be hit again later. We will handle
1200 the current event, eventually we will resume this thread, and this
1201 breakpoint will trap again.
1203 If we do not do this, then we run the risk that the user will
1204 delete or disable the breakpoint, but the thread will have already
1207 struct regcache
*regcache
= get_thread_regcache (ptid
);
1208 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1211 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
1212 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache
), pc
))
1214 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1215 (unsigned long) ptid_get_tid (ptid
));
1217 /* Back up the PC if necessary. */
1218 if (gdbarch_decr_pc_after_break (gdbarch
))
1219 regcache_write_pc (regcache
, pc
);
1227 darwin_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1232 mach_msg_header_t hdr
;
1235 mach_msg_header_t
*hdr
= &msgin
.hdr
;
1237 darwin_thread_t
*thread
;
1238 struct inferior
*inf
;
1241 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1242 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
1244 /* Handle fake stop events at first. */
1245 if (darwin_inf_fake_stop
!= NULL
)
1247 inf
= darwin_inf_fake_stop
;
1248 darwin_inf_fake_stop
= NULL
;
1250 status
->kind
= TARGET_WAITKIND_STOPPED
;
1251 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1252 thread
= VEC_index (darwin_thread_t
, inf
->priv
->threads
, 0);
1253 thread
->msg_state
= DARWIN_STOPPED
;
1254 return ptid_build (inf
->pid
, 0, thread
->gdb_port
);
1259 /* set_sigint_trap (); */
1261 /* Wait for a message. */
1262 kret
= mach_msg (&msgin
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
, 0,
1263 sizeof (msgin
.data
), darwin_port_set
, 0, MACH_PORT_NULL
);
1265 /* clear_sigint_trap (); */
1267 if (kret
== MACH_RCV_INTERRUPTED
)
1269 status
->kind
= TARGET_WAITKIND_IGNORE
;
1270 return minus_one_ptid
;
1273 if (kret
!= MACH_MSG_SUCCESS
)
1275 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret
);
1276 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
1277 return minus_one_ptid
;
1280 /* Debug: display message. */
1281 if (darwin_debug_flag
> 10)
1282 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1284 res
= darwin_decode_message (hdr
, &thread
, &inf
, status
);
1285 if (ptid_equal (res
, minus_one_ptid
))
1288 /* Early return in case an inferior has exited. */
1292 while (status
->kind
== TARGET_WAITKIND_IGNORE
);
1294 /* Stop all tasks. */
1295 iterate_over_inferiors (darwin_suspend_inferior_it
, NULL
);
1297 /* Read pending messages. */
1300 struct target_waitstatus status2
;
1303 kret
= mach_msg (&msgin
.hdr
,
1304 MACH_RCV_MSG
| MACH_RCV_TIMEOUT
, 0,
1305 sizeof (msgin
.data
), darwin_port_set
, 1, MACH_PORT_NULL
);
1307 if (kret
== MACH_RCV_TIMED_OUT
)
1309 if (kret
!= MACH_MSG_SUCCESS
)
1312 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret
);
1316 /* Debug: display message. */
1317 if (darwin_debug_flag
> 10)
1318 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1320 ptid2
= darwin_decode_message (hdr
, &thread
, &inf
, &status2
);
1322 if (inf
!= NULL
&& thread
!= NULL
1323 && thread
->event
.ex_type
== EXC_BREAKPOINT
)
1325 if (thread
->single_step
1326 || cancel_breakpoint (ptid_build (inf
->pid
, 0, thread
->gdb_port
)))
1328 gdb_assert (thread
->msg_state
== DARWIN_MESSAGE
);
1329 darwin_send_reply (inf
, thread
);
1330 thread
->msg_state
= DARWIN_RUNNING
;
1334 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1338 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1344 darwin_wait_to (struct target_ops
*ops
,
1345 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
1347 return darwin_wait (ptid
, status
);
1351 darwin_interrupt (struct target_ops
*self
, ptid_t t
)
1353 struct inferior
*inf
= current_inferior ();
1355 /* FIXME: handle in no_ptrace mode. */
1356 gdb_assert (!inf
->priv
->no_ptrace
);
1357 kill (inf
->pid
, SIGINT
);
1360 /* Deallocate threads port and vector. */
1363 darwin_deallocate_threads (struct inferior
*inf
)
1365 if (inf
->priv
->threads
)
1371 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, t
);
1374 kret
= mach_port_deallocate (gdb_task
, t
->gdb_port
);
1375 MACH_CHECK_ERROR (kret
);
1377 VEC_free (darwin_thread_t
, inf
->priv
->threads
);
1378 inf
->priv
->threads
= NULL
;
1383 darwin_mourn_inferior (struct target_ops
*ops
)
1385 struct inferior
*inf
= current_inferior ();
1390 /* Deallocate threads. */
1391 darwin_deallocate_threads (inf
);
1393 /* Remove notify_port from darwin_port_set. */
1394 kret
= mach_port_move_member (gdb_task
,
1395 inf
->priv
->notify_port
, MACH_PORT_NULL
);
1396 MACH_CHECK_ERROR (kret
);
1398 /* Remove task port dead_name notification. */
1399 kret
= mach_port_request_notification (gdb_task
, inf
->priv
->task
,
1400 MACH_NOTIFY_DEAD_NAME
, 0,
1402 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1404 /* This can fail if the task is dead. */
1405 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1406 inf
->priv
->task
, prev
, inf
->priv
->notify_port
);
1408 if (kret
== KERN_SUCCESS
)
1410 kret
= mach_port_deallocate (gdb_task
, prev
);
1411 MACH_CHECK_ERROR (kret
);
1414 /* Destroy notify_port. */
1415 kret
= mach_port_destroy (gdb_task
, inf
->priv
->notify_port
);
1416 MACH_CHECK_ERROR (kret
);
1418 /* Deallocate saved exception ports. */
1419 darwin_deallocate_exception_ports (inf
->priv
);
1421 /* Deallocate task port. */
1422 kret
= mach_port_deallocate (gdb_task
, inf
->priv
->task
);
1423 MACH_CHECK_ERROR (kret
);
1428 inf_child_mourn_inferior (ops
);
1432 darwin_reply_to_all_pending_messages (struct inferior
*inf
)
1438 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, t
);
1441 if (t
->msg_state
== DARWIN_MESSAGE
)
1442 darwin_resume_thread (inf
, t
, 0, 0);
1447 darwin_stop_inferior (struct inferior
*inf
)
1449 struct target_waitstatus wstatus
;
1455 gdb_assert (inf
!= NULL
);
1457 darwin_suspend_inferior (inf
);
1459 darwin_reply_to_all_pending_messages (inf
);
1461 if (inf
->priv
->no_ptrace
)
1464 res
= kill (inf
->pid
, SIGSTOP
);
1466 warning (_("cannot kill: %s"), safe_strerror (errno
));
1468 /* Wait until the process is really stopped. */
1471 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1472 if (wstatus
.kind
== TARGET_WAITKIND_STOPPED
1473 && wstatus
.value
.sig
== GDB_SIGNAL_STOP
)
1478 static kern_return_t
1479 darwin_save_exception_ports (darwin_inferior
*inf
)
1483 inf
->exception_info
.count
=
1484 sizeof (inf
->exception_info
.ports
) / sizeof (inf
->exception_info
.ports
[0]);
1486 kret
= task_get_exception_ports
1487 (inf
->task
, EXC_MASK_ALL
, inf
->exception_info
.masks
,
1488 &inf
->exception_info
.count
, inf
->exception_info
.ports
,
1489 inf
->exception_info
.behaviors
, inf
->exception_info
.flavors
);
1493 static kern_return_t
1494 darwin_restore_exception_ports (darwin_inferior
*inf
)
1499 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1501 kret
= task_set_exception_ports
1502 (inf
->task
, inf
->exception_info
.masks
[i
], inf
->exception_info
.ports
[i
],
1503 inf
->exception_info
.behaviors
[i
], inf
->exception_info
.flavors
[i
]);
1504 if (kret
!= KERN_SUCCESS
)
1508 return KERN_SUCCESS
;
1511 /* Deallocate saved exception ports. */
1514 darwin_deallocate_exception_ports (darwin_inferior
*inf
)
1519 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1521 kret
= mach_port_deallocate (gdb_task
, inf
->exception_info
.ports
[i
]);
1522 MACH_CHECK_ERROR (kret
);
1524 inf
->exception_info
.count
= 0;
1528 darwin_setup_exceptions (struct inferior
*inf
)
1532 exception_mask_t mask
;
1534 kret
= darwin_save_exception_ports (inf
->priv
);
1535 if (kret
!= KERN_SUCCESS
)
1536 error (_("Unable to save exception ports, task_get_exception_ports"
1540 /* Set exception port. */
1541 if (enable_mach_exceptions
)
1542 mask
= EXC_MASK_ALL
;
1544 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1545 kret
= task_set_exception_ports (inf
->priv
->task
, mask
, darwin_ex_port
,
1546 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1547 if (kret
!= KERN_SUCCESS
)
1548 error (_("Unable to set exception ports, task_set_exception_ports"
1554 darwin_kill_inferior (struct target_ops
*ops
)
1556 struct inferior
*inf
= current_inferior ();
1557 struct target_waitstatus wstatus
;
1563 if (ptid_equal (inferior_ptid
, null_ptid
))
1566 gdb_assert (inf
!= NULL
);
1568 kret
= darwin_restore_exception_ports (inf
->priv
);
1569 MACH_CHECK_ERROR (kret
);
1571 darwin_reply_to_all_pending_messages (inf
);
1573 res
= kill (inf
->pid
, 9);
1577 darwin_resume_inferior (inf
);
1579 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1581 else if (errno
!= ESRCH
)
1582 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1583 inf
->pid
, safe_strerror (errno
));
1585 target_mourn_inferior (inferior_ptid
);
1589 darwin_setup_request_notification (struct inferior
*inf
)
1592 mach_port_t prev_not
;
1594 kret
= mach_port_request_notification (gdb_task
, inf
->priv
->task
,
1595 MACH_NOTIFY_DEAD_NAME
, 0,
1596 inf
->priv
->notify_port
,
1597 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1599 if (kret
!= KERN_SUCCESS
)
1600 error (_("Termination notification request failed, "
1601 "mach_port_request_notification\n"
1604 if (prev_not
!= MACH_PORT_NULL
)
1606 /* This is unexpected, as there should not be any previously
1607 registered notification request. But this is not a fatal
1608 issue, so just emit a warning. */
1610 A task termination request was registered before the debugger registered\n\
1611 its own. This is unexpected, but should otherwise not have any actual\n\
1612 impact on the debugging session."));
1617 darwin_attach_pid (struct inferior
*inf
)
1620 mach_port_t prev_port
;
1622 mach_port_t prev_not
;
1623 exception_mask_t mask
;
1625 inf
->priv
= XCNEW (darwin_inferior
);
1627 kret
= task_for_pid (gdb_task
, inf
->pid
, &inf
->priv
->task
);
1628 if (kret
!= KERN_SUCCESS
)
1632 if (!inf
->attach_flag
)
1635 waitpid (inf
->pid
, &status
, 0);
1638 error (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1639 " (please check gdb is codesigned - see taskgated(8))"),
1640 inf
->pid
, mach_error_string (kret
), (unsigned long) kret
);
1643 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1644 inf
->priv
->task
, inf
->pid
);
1646 if (darwin_ex_port
== MACH_PORT_NULL
)
1648 /* Create a port to get exceptions. */
1649 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1651 if (kret
!= KERN_SUCCESS
)
1652 error (_("Unable to create exception port, mach_port_allocate "
1656 kret
= mach_port_insert_right (gdb_task
, darwin_ex_port
, darwin_ex_port
,
1657 MACH_MSG_TYPE_MAKE_SEND
);
1658 if (kret
!= KERN_SUCCESS
)
1659 error (_("Unable to create exception port, mach_port_insert_right "
1663 /* Create a port set and put ex_port in it. */
1664 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_PORT_SET
,
1666 if (kret
!= KERN_SUCCESS
)
1667 error (_("Unable to create port set, mach_port_allocate "
1671 kret
= mach_port_move_member (gdb_task
, darwin_ex_port
, darwin_port_set
);
1672 if (kret
!= KERN_SUCCESS
)
1673 error (_("Unable to move exception port into new port set, "
1674 "mach_port_move_member\n"
1679 /* Create a port to be notified when the child task terminates. */
1680 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1681 &inf
->priv
->notify_port
);
1682 if (kret
!= KERN_SUCCESS
)
1683 error (_("Unable to create notification port, mach_port_allocate "
1687 kret
= mach_port_move_member (gdb_task
,
1688 inf
->priv
->notify_port
, darwin_port_set
);
1689 if (kret
!= KERN_SUCCESS
)
1690 error (_("Unable to move notification port into new port set, "
1691 "mach_port_move_member\n"
1695 darwin_setup_request_notification (inf
);
1697 darwin_setup_exceptions (inf
);
1699 if (!target_is_pushed (darwin_ops
))
1700 push_target (darwin_ops
);
1704 darwin_init_thread_list (struct inferior
*inf
)
1706 darwin_thread_t
*thread
;
1709 darwin_check_new_threads (inf
);
1711 gdb_assert (inf
->priv
->threads
1712 && VEC_length (darwin_thread_t
, inf
->priv
->threads
) > 0);
1713 thread
= VEC_index (darwin_thread_t
, inf
->priv
->threads
, 0);
1715 /* Note: fork_inferior automatically add a thead but it uses a wrong ptid.
1717 new_ptid
= ptid_build (inf
->pid
, 0, thread
->gdb_port
);
1718 thread_change_ptid (inferior_ptid
, new_ptid
);
1719 inferior_ptid
= new_ptid
;
1722 /* The child must synchronize with gdb: gdb must set the exception port
1723 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1724 FIXME: is there a lighter way ? */
1725 static int ptrace_fds
[2];
1728 darwin_ptrace_me (void)
1733 /* Close write end point. */
1734 if (close (ptrace_fds
[1]) < 0)
1735 trace_start_error_with_name ("close");
1737 /* Wait until gdb is ready. */
1738 res
= read (ptrace_fds
[0], &c
, 1);
1740 trace_start_error (_("unable to read from pipe, read returned: %d"), res
);
1742 if (close (ptrace_fds
[0]) < 0)
1743 trace_start_error_with_name ("close");
1745 /* Get rid of privileges. */
1746 if (setegid (getgid ()) < 0)
1747 trace_start_error_with_name ("setegid");
1750 if (PTRACE (PT_TRACE_ME
, 0, 0, 0) < 0)
1751 trace_start_error_with_name ("PTRACE");
1753 /* Redirect signals to exception port. */
1754 if (PTRACE (PT_SIGEXC
, 0, 0, 0) < 0)
1755 trace_start_error_with_name ("PTRACE");
1758 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1760 darwin_pre_ptrace (void)
1762 if (pipe (ptrace_fds
) != 0)
1766 error (_("unable to create a pipe: %s"), safe_strerror (errno
));
1769 mark_fd_no_cloexec (ptrace_fds
[0]);
1770 mark_fd_no_cloexec (ptrace_fds
[1]);
1774 darwin_ptrace_him (int pid
)
1778 mach_port_t prev_port
;
1780 struct inferior
*inf
= current_inferior ();
1782 darwin_attach_pid (inf
);
1784 /* Let's the child run. */
1785 close (ptrace_fds
[0]);
1786 close (ptrace_fds
[1]);
1788 unmark_fd_no_cloexec (ptrace_fds
[0]);
1789 unmark_fd_no_cloexec (ptrace_fds
[1]);
1791 darwin_init_thread_list (inf
);
1793 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
1797 darwin_execvp (const char *file
, char * const argv
[], char * const env
[])
1799 posix_spawnattr_t attr
;
1803 res
= posix_spawnattr_init (&attr
);
1807 (gdb_stderr
, "Cannot initialize attribute for posix_spawn\n");
1811 /* Do like execve: replace the image. */
1812 ps_flags
= POSIX_SPAWN_SETEXEC
;
1814 /* Disable ASLR. The constant doesn't look to be available outside the
1815 kernel include files. */
1816 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1817 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1819 ps_flags
|= _POSIX_SPAWN_DISABLE_ASLR
;
1820 res
= posix_spawnattr_setflags (&attr
, ps_flags
);
1823 fprintf_unfiltered (gdb_stderr
, "Cannot set posix_spawn flags\n");
1827 posix_spawnp (NULL
, argv
[0], NULL
, &attr
, argv
, env
);
1831 darwin_create_inferior (struct target_ops
*ops
,
1832 const char *exec_file
,
1833 const std::string
&allargs
,
1834 char **env
, int from_tty
)
1836 /* Do the hard work. */
1837 fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
, darwin_ptrace_him
,
1838 darwin_pre_ptrace
, NULL
, darwin_execvp
);
1840 /* Return now in case of error. */
1841 if (ptid_equal (inferior_ptid
, null_ptid
))
1846 /* Set things up such that the next call to darwin_wait will immediately
1847 return a fake stop event for inferior INF.
1849 This assumes that the inferior's thread list has been initialized,
1850 as it will suspend the inferior's first thread. */
1853 darwin_setup_fake_stop_event (struct inferior
*inf
)
1855 darwin_thread_t
*thread
;
1858 gdb_assert (darwin_inf_fake_stop
== NULL
);
1859 darwin_inf_fake_stop
= inf
;
1861 /* When detecting a fake pending stop event, darwin_wait returns
1862 an event saying that the first thread is in a DARWIN_STOPPED
1863 state. To make that accurate, we need to suspend that thread
1864 as well. Otherwise, we'll try resuming it when resuming the
1865 inferior, and get a warning because the thread's suspend count
1866 is already zero, making the resume request useless. */
1867 thread
= VEC_index (darwin_thread_t
, inf
->priv
->threads
, 0);
1868 kret
= thread_suspend (thread
->gdb_port
);
1869 MACH_CHECK_ERROR (kret
);
1872 /* Attach to process PID, then initialize for debugging it
1873 and wait for the trace-trap that results from attaching. */
1875 darwin_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
1881 struct inferior
*inf
;
1884 pid
= parse_pid_to_attach (args
);
1886 if (pid
== getpid ()) /* Trying to masturbate? */
1887 error (_("I refuse to debug myself!"));
1891 char *exec_file
= get_exec_file (0);
1894 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
1895 target_pid_to_str (pid_to_ptid (pid
)));
1897 printf_unfiltered (_("Attaching to %s\n"),
1898 target_pid_to_str (pid_to_ptid (pid
)));
1900 gdb_flush (gdb_stdout
);
1903 if (pid
== 0 || kill (pid
, 0) < 0)
1904 error (_("Can't attach to process %d: %s (%d)"),
1905 pid
, safe_strerror (errno
), errno
);
1907 inferior_ptid
= pid_to_ptid (pid
);
1908 inf
= current_inferior ();
1909 inferior_appeared (inf
, pid
);
1910 inf
->attach_flag
= 1;
1912 /* Always add a main thread. */
1913 add_thread_silent (inferior_ptid
);
1915 darwin_attach_pid (inf
);
1917 darwin_suspend_inferior (inf
);
1919 darwin_init_thread_list (inf
);
1921 darwin_check_osabi (inf
->priv
, ptid_get_tid (inferior_ptid
));
1923 darwin_setup_fake_stop_event (inf
);
1925 inf
->priv
->no_ptrace
= 1;
1928 /* Take a program previously attached to and detaches it.
1929 The program resumes execution and will no longer stop
1930 on signals, etc. We'd better not have left any breakpoints
1931 in the program or it'll die when it hits one. For this
1932 to work, it may be necessary for the process to have been
1933 previously attached. It *might* work if the program was
1934 started via fork. */
1936 darwin_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
1938 pid_t pid
= ptid_get_pid (inferior_ptid
);
1939 struct inferior
*inf
= current_inferior ();
1943 /* Display message. */
1944 target_announce_detach (from_tty
);
1946 /* If ptrace() is in use, stop the process. */
1947 if (!inf
->priv
->no_ptrace
)
1948 darwin_stop_inferior (inf
);
1950 kret
= darwin_restore_exception_ports (inf
->priv
);
1951 MACH_CHECK_ERROR (kret
);
1953 if (!inf
->priv
->no_ptrace
)
1955 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
1957 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1958 inf
->pid
, safe_strerror (errno
), errno
);
1961 darwin_reply_to_all_pending_messages (inf
);
1963 /* When using ptrace, we have just performed a PT_DETACH, which
1964 resumes the inferior. On the other hand, when we are not using
1965 ptrace, we need to resume its execution ourselves. */
1966 if (inf
->priv
->no_ptrace
)
1967 darwin_resume_inferior (inf
);
1969 darwin_mourn_inferior (ops
);
1973 darwin_files_info (struct target_ops
*ops
)
1978 darwin_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1980 static char buf
[80];
1981 long tid
= ptid_get_tid (ptid
);
1985 snprintf (buf
, sizeof (buf
), _("Thread 0x%lx of process %u"),
1986 tid
, ptid_get_pid (ptid
));
1990 return normal_pid_to_str (ptid
);
1994 darwin_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1999 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2000 copy it to RDADDR in gdb's address space.
2001 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2002 to ADDR in inferior task's address space.
2003 Return 0 on failure; number of bytes read / writen otherwise. */
2006 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
2007 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
2011 mach_vm_size_t res_length
= 0;
2013 mach_msg_type_number_t copy_count
;
2014 mach_vm_size_t remaining_length
;
2015 mach_vm_address_t region_address
;
2016 mach_vm_size_t region_length
;
2018 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2019 task
, core_addr_to_string (addr
), pulongest (length
));
2024 mach_vm_size_t count
;
2026 /* According to target.h(to_xfer_partial), one and only one may be
2028 gdb_assert (wraddr
== NULL
);
2030 kret
= mach_vm_read_overwrite (task
, addr
, length
,
2031 (mach_vm_address_t
) rdaddr
, &count
);
2032 if (kret
!= KERN_SUCCESS
)
2035 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2036 core_addr_to_string (addr
), mach_error_string (kret
));
2043 gdb_assert (wraddr
!= NULL
);
2047 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
2048 mach_vm_address_t region_address
= (mach_vm_address_t
) (addr
- offset
);
2049 mach_vm_size_t aligned_length
=
2050 (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
2051 vm_region_submap_short_info_data_64_t info
;
2052 mach_msg_type_number_t count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
2053 natural_t region_depth
= 1000;
2054 mach_vm_address_t region_start
= region_address
;
2055 mach_vm_size_t region_length
;
2056 mach_vm_size_t write_length
;
2058 /* Read page protection. */
2059 kret
= mach_vm_region_recurse
2060 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
2061 (vm_region_recurse_info_t
) &info
, &count
);
2063 if (kret
!= KERN_SUCCESS
)
2065 inferior_debug (1, _("darwin_read_write_inferior: "
2066 "mach_vm_region_recurse failed at %s: %s\n"),
2067 core_addr_to_string (region_address
),
2068 mach_error_string (kret
));
2073 (9, _("darwin_read_write_inferior: "
2074 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2075 core_addr_to_string (region_address
),
2076 core_addr_to_string (region_start
),
2077 core_addr_to_string (region_length
));
2079 /* Check for holes in memory. */
2080 if (region_start
> region_address
)
2082 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
2083 core_addr_to_string (region_address
),
2084 core_addr_to_string (region_start
),
2085 (unsigned)region_length
);
2089 /* Adjust the length. */
2090 region_length
-= (region_address
- region_start
);
2091 if (region_length
> aligned_length
)
2092 region_length
= aligned_length
;
2094 /* Make the pages RW. */
2095 if (!(info
.protection
& VM_PROT_WRITE
))
2097 vm_prot_t prot
= VM_PROT_READ
| VM_PROT_WRITE
;
2099 kret
= mach_vm_protect (task
, region_address
, region_length
,
2101 if (kret
!= KERN_SUCCESS
)
2103 prot
|= VM_PROT_COPY
;
2104 kret
= mach_vm_protect (task
, region_address
, region_length
,
2107 if (kret
!= KERN_SUCCESS
)
2109 warning (_("darwin_read_write_inferior: "
2110 "mach_vm_protect failed at %s "
2111 "(len=0x%lx, prot=0x%x): %s"),
2112 core_addr_to_string (region_address
),
2113 (unsigned long) region_length
, (unsigned) prot
,
2114 mach_error_string (kret
));
2119 if (offset
+ length
> region_length
)
2120 write_length
= region_length
- offset
;
2122 write_length
= length
;
2125 kret
= mach_vm_write (task
, addr
, (vm_offset_t
) wraddr
, write_length
);
2126 if (kret
!= KERN_SUCCESS
)
2128 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2129 mach_error_string (kret
));
2133 /* Restore page rights. */
2134 if (!(info
.protection
& VM_PROT_WRITE
))
2136 kret
= mach_vm_protect (task
, region_address
, region_length
,
2137 FALSE
, info
.protection
);
2138 if (kret
!= KERN_SUCCESS
)
2140 warning (_("darwin_read_write_inferior: "
2141 "mach_vm_protect restore failed at %s "
2143 core_addr_to_string (region_address
),
2144 (unsigned long) region_length
,
2145 mach_error_string (kret
));
2149 addr
+= write_length
;
2150 wraddr
+= write_length
;
2151 res_length
+= write_length
;
2152 length
-= write_length
;
2158 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2159 to RDADDR (in big endian).
2160 Return 0 on failure; number of bytes read / written otherwise. */
2162 #ifdef TASK_DYLD_INFO_COUNT
2163 /* This is not available in Darwin 9. */
2164 static enum target_xfer_status
2165 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
2166 ULONGEST length
, ULONGEST
*xfered_len
)
2168 struct task_dyld_info task_dyld_info
;
2169 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
2170 int sz
= TASK_DYLD_INFO_COUNT
* sizeof (natural_t
);
2173 if (addr
!= 0 || length
> sizeof (mach_vm_address_t
))
2174 return TARGET_XFER_EOF
;
2176 kret
= task_info (task
, TASK_DYLD_INFO
,
2177 (task_info_t
) &task_dyld_info
, &count
);
2178 MACH_CHECK_ERROR (kret
);
2179 if (kret
!= KERN_SUCCESS
)
2180 return TARGET_XFER_E_IO
;
2182 store_unsigned_integer (rdaddr
, length
, BFD_ENDIAN_BIG
,
2183 task_dyld_info
.all_image_info_addr
);
2184 *xfered_len
= (ULONGEST
) length
;
2185 return TARGET_XFER_OK
;
2191 static enum target_xfer_status
2192 darwin_xfer_partial (struct target_ops
*ops
,
2193 enum target_object object
, const char *annex
,
2194 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2195 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
2197 struct inferior
*inf
= current_inferior ();
2200 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2201 core_addr_to_string (offset
), pulongest (len
),
2202 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
2207 case TARGET_OBJECT_MEMORY
:
2209 int l
= darwin_read_write_inferior (inf
->priv
->task
, offset
,
2210 readbuf
, writebuf
, len
);
2213 return TARGET_XFER_EOF
;
2217 *xfered_len
= (ULONGEST
) l
;
2218 return TARGET_XFER_OK
;
2221 #ifdef TASK_DYLD_INFO_COUNT
2222 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
2223 if (writebuf
!= NULL
|| readbuf
== NULL
)
2225 /* Support only read. */
2226 return TARGET_XFER_E_IO
;
2228 return darwin_read_dyld_info (inf
->priv
->task
, offset
, readbuf
, len
,
2232 return TARGET_XFER_E_IO
;
2238 set_enable_mach_exceptions (char *args
, int from_tty
,
2239 struct cmd_list_element
*c
)
2241 if (!ptid_equal (inferior_ptid
, null_ptid
))
2243 struct inferior
*inf
= current_inferior ();
2244 exception_mask_t mask
;
2247 if (enable_mach_exceptions
)
2248 mask
= EXC_MASK_ALL
;
2251 darwin_restore_exception_ports (inf
->priv
);
2252 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
2254 kret
= task_set_exception_ports (inf
->priv
->task
, mask
, darwin_ex_port
,
2255 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
2256 MACH_CHECK_ERROR (kret
);
2261 darwin_pid_to_exec_file (struct target_ops
*self
, int pid
)
2263 static char path
[PATH_MAX
];
2266 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, PATH_MAX
);
2274 darwin_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
2279 struct inferior
*inf
= current_inferior ();
2281 mach_port_name_array_t names
;
2282 mach_msg_type_number_t names_count
;
2283 mach_port_type_array_t types
;
2284 mach_msg_type_number_t types_count
;
2287 /* First linear search. */
2289 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, t
);
2291 if (t
->inf_port
== lwp
)
2292 return ptid_build (ptid_get_pid (inferior_ptid
), 0, t
->gdb_port
);
2294 /* Maybe the port was never extract. Do it now. */
2296 /* First get inferior port names. */
2297 kret
= mach_port_names (inf
->priv
->task
, &names
, &names_count
, &types
,
2299 MACH_CHECK_ERROR (kret
);
2300 if (kret
!= KERN_SUCCESS
)
2303 /* For each name, copy the right in the gdb space and then compare with
2304 our view of the inferior threads. We don't forget to deallocate the
2306 for (i
= 0; i
< names_count
; i
++)
2308 mach_port_t local_name
;
2309 mach_msg_type_name_t local_type
;
2311 /* We just need to know the corresponding name in gdb name space.
2312 So extract and deallocate the right. */
2313 kret
= mach_port_extract_right (inf
->priv
->task
, names
[i
],
2314 MACH_MSG_TYPE_COPY_SEND
,
2315 &local_name
, &local_type
);
2316 if (kret
!= KERN_SUCCESS
)
2318 mach_port_deallocate (gdb_task
, local_name
);
2321 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, t
);
2323 if (t
->gdb_port
== local_name
)
2325 t
->inf_port
= names
[i
];
2326 if (names
[i
] == lwp
)
2331 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2332 names_count
* sizeof (mach_port_t
));
2335 return ptid_build (ptid_get_pid (inferior_ptid
), 0, res
);
2341 darwin_supports_multi_process (struct target_ops
*self
)
2346 /* -Wmissing-prototypes */
2347 extern initialize_file_ftype _initialize_darwin_inferior
;
2350 _initialize_darwin_inferior (void)
2354 gdb_task
= mach_task_self ();
2355 darwin_host_self
= mach_host_self ();
2357 /* Read page size. */
2358 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2359 if (kret
!= KERN_SUCCESS
)
2361 mach_page_size
= 0x1000;
2362 MACH_CHECK_ERROR (kret
);
2365 darwin_ops
= inf_child_target ();
2367 darwin_ops
->to_create_inferior
= darwin_create_inferior
;
2368 darwin_ops
->to_attach
= darwin_attach
;
2369 darwin_ops
->to_attach_no_wait
= 0;
2370 darwin_ops
->to_detach
= darwin_detach
;
2371 darwin_ops
->to_files_info
= darwin_files_info
;
2372 darwin_ops
->to_wait
= darwin_wait_to
;
2373 darwin_ops
->to_mourn_inferior
= darwin_mourn_inferior
;
2374 darwin_ops
->to_kill
= darwin_kill_inferior
;
2375 darwin_ops
->to_interrupt
= darwin_interrupt
;
2376 darwin_ops
->to_resume
= darwin_resume_to
;
2377 darwin_ops
->to_thread_alive
= darwin_thread_alive
;
2378 darwin_ops
->to_pid_to_str
= darwin_pid_to_str
;
2379 darwin_ops
->to_pid_to_exec_file
= darwin_pid_to_exec_file
;
2380 darwin_ops
->to_load
= NULL
;
2381 darwin_ops
->to_xfer_partial
= darwin_xfer_partial
;
2382 darwin_ops
->to_supports_multi_process
= darwin_supports_multi_process
;
2383 darwin_ops
->to_get_ada_task_ptid
= darwin_get_ada_task_ptid
;
2385 darwin_complete_target (darwin_ops
);
2387 add_target (darwin_ops
);
2389 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2390 (unsigned long) mach_task_self (), getpid ());
2392 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2393 &darwin_debug_flag
, _("\
2394 Set if printing inferior communication debugging statements."), _("\
2395 Show if printing inferior communication debugging statements."), NULL
,
2397 &setdebuglist
, &showdebuglist
);
2399 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2400 &enable_mach_exceptions
, _("\
2401 Set if mach exceptions are caught."), _("\
2402 Show if mach exceptions are caught."), _("\
2403 When this mode is on, all low level exceptions are reported before being\n\
2404 reported by the kernel."),
2405 &set_enable_mach_exceptions
, NULL
,
2406 &setlist
, &showlist
);