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 gdb_startup_inferior (pid
, 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
)
1839 /* Do the hard work. */
1840 pid
= fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
,
1841 darwin_ptrace_him
, darwin_pre_ptrace
, NULL
,
1844 ptid
= pid_to_ptid (pid
);
1845 /* Return now in case of error. */
1846 if (ptid_equal (inferior_ptid
, null_ptid
))
1849 /* We have something that executes now. We'll be running through
1850 the shell at this point (if startup-with-shell is true), but the
1851 pid shouldn't change. */
1852 add_thread_silent (ptid
);
1856 /* Set things up such that the next call to darwin_wait will immediately
1857 return a fake stop event for inferior INF.
1859 This assumes that the inferior's thread list has been initialized,
1860 as it will suspend the inferior's first thread. */
1863 darwin_setup_fake_stop_event (struct inferior
*inf
)
1865 darwin_thread_t
*thread
;
1868 gdb_assert (darwin_inf_fake_stop
== NULL
);
1869 darwin_inf_fake_stop
= inf
;
1871 /* When detecting a fake pending stop event, darwin_wait returns
1872 an event saying that the first thread is in a DARWIN_STOPPED
1873 state. To make that accurate, we need to suspend that thread
1874 as well. Otherwise, we'll try resuming it when resuming the
1875 inferior, and get a warning because the thread's suspend count
1876 is already zero, making the resume request useless. */
1877 thread
= VEC_index (darwin_thread_t
, inf
->priv
->threads
, 0);
1878 kret
= thread_suspend (thread
->gdb_port
);
1879 MACH_CHECK_ERROR (kret
);
1882 /* Attach to process PID, then initialize for debugging it
1883 and wait for the trace-trap that results from attaching. */
1885 darwin_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
1891 struct inferior
*inf
;
1894 pid
= parse_pid_to_attach (args
);
1896 if (pid
== getpid ()) /* Trying to masturbate? */
1897 error (_("I refuse to debug myself!"));
1901 char *exec_file
= get_exec_file (0);
1904 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
1905 target_pid_to_str (pid_to_ptid (pid
)));
1907 printf_unfiltered (_("Attaching to %s\n"),
1908 target_pid_to_str (pid_to_ptid (pid
)));
1910 gdb_flush (gdb_stdout
);
1913 if (pid
== 0 || kill (pid
, 0) < 0)
1914 error (_("Can't attach to process %d: %s (%d)"),
1915 pid
, safe_strerror (errno
), errno
);
1917 inferior_ptid
= pid_to_ptid (pid
);
1918 inf
= current_inferior ();
1919 inferior_appeared (inf
, pid
);
1920 inf
->attach_flag
= 1;
1922 /* Always add a main thread. */
1923 add_thread_silent (inferior_ptid
);
1925 darwin_attach_pid (inf
);
1927 darwin_suspend_inferior (inf
);
1929 darwin_init_thread_list (inf
);
1931 darwin_check_osabi (inf
->priv
, ptid_get_tid (inferior_ptid
));
1933 darwin_setup_fake_stop_event (inf
);
1935 inf
->priv
->no_ptrace
= 1;
1938 /* Take a program previously attached to and detaches it.
1939 The program resumes execution and will no longer stop
1940 on signals, etc. We'd better not have left any breakpoints
1941 in the program or it'll die when it hits one. For this
1942 to work, it may be necessary for the process to have been
1943 previously attached. It *might* work if the program was
1944 started via fork. */
1946 darwin_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
1948 pid_t pid
= ptid_get_pid (inferior_ptid
);
1949 struct inferior
*inf
= current_inferior ();
1953 /* Display message. */
1954 target_announce_detach (from_tty
);
1956 /* If ptrace() is in use, stop the process. */
1957 if (!inf
->priv
->no_ptrace
)
1958 darwin_stop_inferior (inf
);
1960 kret
= darwin_restore_exception_ports (inf
->priv
);
1961 MACH_CHECK_ERROR (kret
);
1963 if (!inf
->priv
->no_ptrace
)
1965 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
1967 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1968 inf
->pid
, safe_strerror (errno
), errno
);
1971 darwin_reply_to_all_pending_messages (inf
);
1973 /* When using ptrace, we have just performed a PT_DETACH, which
1974 resumes the inferior. On the other hand, when we are not using
1975 ptrace, we need to resume its execution ourselves. */
1976 if (inf
->priv
->no_ptrace
)
1977 darwin_resume_inferior (inf
);
1979 darwin_mourn_inferior (ops
);
1983 darwin_files_info (struct target_ops
*ops
)
1988 darwin_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1990 static char buf
[80];
1991 long tid
= ptid_get_tid (ptid
);
1995 snprintf (buf
, sizeof (buf
), _("Thread 0x%lx of process %u"),
1996 tid
, ptid_get_pid (ptid
));
2000 return normal_pid_to_str (ptid
);
2004 darwin_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2009 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2010 copy it to RDADDR in gdb's address space.
2011 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2012 to ADDR in inferior task's address space.
2013 Return 0 on failure; number of bytes read / writen otherwise. */
2016 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
2017 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
2021 mach_vm_size_t res_length
= 0;
2023 mach_msg_type_number_t copy_count
;
2024 mach_vm_size_t remaining_length
;
2025 mach_vm_address_t region_address
;
2026 mach_vm_size_t region_length
;
2028 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2029 task
, core_addr_to_string (addr
), pulongest (length
));
2034 mach_vm_size_t count
;
2036 /* According to target.h(to_xfer_partial), one and only one may be
2038 gdb_assert (wraddr
== NULL
);
2040 kret
= mach_vm_read_overwrite (task
, addr
, length
,
2041 (mach_vm_address_t
) rdaddr
, &count
);
2042 if (kret
!= KERN_SUCCESS
)
2045 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2046 core_addr_to_string (addr
), mach_error_string (kret
));
2053 gdb_assert (wraddr
!= NULL
);
2057 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
2058 mach_vm_address_t region_address
= (mach_vm_address_t
) (addr
- offset
);
2059 mach_vm_size_t aligned_length
=
2060 (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
2061 vm_region_submap_short_info_data_64_t info
;
2062 mach_msg_type_number_t count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
2063 natural_t region_depth
= 1000;
2064 mach_vm_address_t region_start
= region_address
;
2065 mach_vm_size_t region_length
;
2066 mach_vm_size_t write_length
;
2068 /* Read page protection. */
2069 kret
= mach_vm_region_recurse
2070 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
2071 (vm_region_recurse_info_t
) &info
, &count
);
2073 if (kret
!= KERN_SUCCESS
)
2075 inferior_debug (1, _("darwin_read_write_inferior: "
2076 "mach_vm_region_recurse failed at %s: %s\n"),
2077 core_addr_to_string (region_address
),
2078 mach_error_string (kret
));
2083 (9, _("darwin_read_write_inferior: "
2084 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2085 core_addr_to_string (region_address
),
2086 core_addr_to_string (region_start
),
2087 core_addr_to_string (region_length
));
2089 /* Check for holes in memory. */
2090 if (region_start
> region_address
)
2092 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
2093 core_addr_to_string (region_address
),
2094 core_addr_to_string (region_start
),
2095 (unsigned)region_length
);
2099 /* Adjust the length. */
2100 region_length
-= (region_address
- region_start
);
2101 if (region_length
> aligned_length
)
2102 region_length
= aligned_length
;
2104 /* Make the pages RW. */
2105 if (!(info
.protection
& VM_PROT_WRITE
))
2107 vm_prot_t prot
= VM_PROT_READ
| VM_PROT_WRITE
;
2109 kret
= mach_vm_protect (task
, region_address
, region_length
,
2111 if (kret
!= KERN_SUCCESS
)
2113 prot
|= VM_PROT_COPY
;
2114 kret
= mach_vm_protect (task
, region_address
, region_length
,
2117 if (kret
!= KERN_SUCCESS
)
2119 warning (_("darwin_read_write_inferior: "
2120 "mach_vm_protect failed at %s "
2121 "(len=0x%lx, prot=0x%x): %s"),
2122 core_addr_to_string (region_address
),
2123 (unsigned long) region_length
, (unsigned) prot
,
2124 mach_error_string (kret
));
2129 if (offset
+ length
> region_length
)
2130 write_length
= region_length
- offset
;
2132 write_length
= length
;
2135 kret
= mach_vm_write (task
, addr
, (vm_offset_t
) wraddr
, write_length
);
2136 if (kret
!= KERN_SUCCESS
)
2138 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2139 mach_error_string (kret
));
2143 /* Restore page rights. */
2144 if (!(info
.protection
& VM_PROT_WRITE
))
2146 kret
= mach_vm_protect (task
, region_address
, region_length
,
2147 FALSE
, info
.protection
);
2148 if (kret
!= KERN_SUCCESS
)
2150 warning (_("darwin_read_write_inferior: "
2151 "mach_vm_protect restore failed at %s "
2153 core_addr_to_string (region_address
),
2154 (unsigned long) region_length
,
2155 mach_error_string (kret
));
2159 addr
+= write_length
;
2160 wraddr
+= write_length
;
2161 res_length
+= write_length
;
2162 length
-= write_length
;
2168 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2169 to RDADDR (in big endian).
2170 Return 0 on failure; number of bytes read / written otherwise. */
2172 #ifdef TASK_DYLD_INFO_COUNT
2173 /* This is not available in Darwin 9. */
2174 static enum target_xfer_status
2175 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
2176 ULONGEST length
, ULONGEST
*xfered_len
)
2178 struct task_dyld_info task_dyld_info
;
2179 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
2180 int sz
= TASK_DYLD_INFO_COUNT
* sizeof (natural_t
);
2183 if (addr
!= 0 || length
> sizeof (mach_vm_address_t
))
2184 return TARGET_XFER_EOF
;
2186 kret
= task_info (task
, TASK_DYLD_INFO
,
2187 (task_info_t
) &task_dyld_info
, &count
);
2188 MACH_CHECK_ERROR (kret
);
2189 if (kret
!= KERN_SUCCESS
)
2190 return TARGET_XFER_E_IO
;
2192 store_unsigned_integer (rdaddr
, length
, BFD_ENDIAN_BIG
,
2193 task_dyld_info
.all_image_info_addr
);
2194 *xfered_len
= (ULONGEST
) length
;
2195 return TARGET_XFER_OK
;
2201 static enum target_xfer_status
2202 darwin_xfer_partial (struct target_ops
*ops
,
2203 enum target_object object
, const char *annex
,
2204 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2205 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
2207 struct inferior
*inf
= current_inferior ();
2210 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2211 core_addr_to_string (offset
), pulongest (len
),
2212 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
2217 case TARGET_OBJECT_MEMORY
:
2219 int l
= darwin_read_write_inferior (inf
->priv
->task
, offset
,
2220 readbuf
, writebuf
, len
);
2223 return TARGET_XFER_EOF
;
2227 *xfered_len
= (ULONGEST
) l
;
2228 return TARGET_XFER_OK
;
2231 #ifdef TASK_DYLD_INFO_COUNT
2232 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
2233 if (writebuf
!= NULL
|| readbuf
== NULL
)
2235 /* Support only read. */
2236 return TARGET_XFER_E_IO
;
2238 return darwin_read_dyld_info (inf
->priv
->task
, offset
, readbuf
, len
,
2242 return TARGET_XFER_E_IO
;
2248 set_enable_mach_exceptions (char *args
, int from_tty
,
2249 struct cmd_list_element
*c
)
2251 if (!ptid_equal (inferior_ptid
, null_ptid
))
2253 struct inferior
*inf
= current_inferior ();
2254 exception_mask_t mask
;
2257 if (enable_mach_exceptions
)
2258 mask
= EXC_MASK_ALL
;
2261 darwin_restore_exception_ports (inf
->priv
);
2262 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
2264 kret
= task_set_exception_ports (inf
->priv
->task
, mask
, darwin_ex_port
,
2265 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
2266 MACH_CHECK_ERROR (kret
);
2271 darwin_pid_to_exec_file (struct target_ops
*self
, int pid
)
2273 static char path
[PATH_MAX
];
2276 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, PATH_MAX
);
2284 darwin_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
2289 struct inferior
*inf
= current_inferior ();
2291 mach_port_name_array_t names
;
2292 mach_msg_type_number_t names_count
;
2293 mach_port_type_array_t types
;
2294 mach_msg_type_number_t types_count
;
2297 /* First linear search. */
2299 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, t
);
2301 if (t
->inf_port
== lwp
)
2302 return ptid_build (ptid_get_pid (inferior_ptid
), 0, t
->gdb_port
);
2304 /* Maybe the port was never extract. Do it now. */
2306 /* First get inferior port names. */
2307 kret
= mach_port_names (inf
->priv
->task
, &names
, &names_count
, &types
,
2309 MACH_CHECK_ERROR (kret
);
2310 if (kret
!= KERN_SUCCESS
)
2313 /* For each name, copy the right in the gdb space and then compare with
2314 our view of the inferior threads. We don't forget to deallocate the
2316 for (i
= 0; i
< names_count
; i
++)
2318 mach_port_t local_name
;
2319 mach_msg_type_name_t local_type
;
2321 /* We just need to know the corresponding name in gdb name space.
2322 So extract and deallocate the right. */
2323 kret
= mach_port_extract_right (inf
->priv
->task
, names
[i
],
2324 MACH_MSG_TYPE_COPY_SEND
,
2325 &local_name
, &local_type
);
2326 if (kret
!= KERN_SUCCESS
)
2328 mach_port_deallocate (gdb_task
, local_name
);
2331 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, t
);
2333 if (t
->gdb_port
== local_name
)
2335 t
->inf_port
= names
[i
];
2336 if (names
[i
] == lwp
)
2341 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2342 names_count
* sizeof (mach_port_t
));
2345 return ptid_build (ptid_get_pid (inferior_ptid
), 0, res
);
2351 darwin_supports_multi_process (struct target_ops
*self
)
2356 /* -Wmissing-prototypes */
2357 extern initialize_file_ftype _initialize_darwin_inferior
;
2360 _initialize_darwin_inferior (void)
2364 gdb_task
= mach_task_self ();
2365 darwin_host_self
= mach_host_self ();
2367 /* Read page size. */
2368 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2369 if (kret
!= KERN_SUCCESS
)
2371 mach_page_size
= 0x1000;
2372 MACH_CHECK_ERROR (kret
);
2375 darwin_ops
= inf_child_target ();
2377 darwin_ops
->to_create_inferior
= darwin_create_inferior
;
2378 darwin_ops
->to_attach
= darwin_attach
;
2379 darwin_ops
->to_attach_no_wait
= 0;
2380 darwin_ops
->to_detach
= darwin_detach
;
2381 darwin_ops
->to_files_info
= darwin_files_info
;
2382 darwin_ops
->to_wait
= darwin_wait_to
;
2383 darwin_ops
->to_mourn_inferior
= darwin_mourn_inferior
;
2384 darwin_ops
->to_kill
= darwin_kill_inferior
;
2385 darwin_ops
->to_interrupt
= darwin_interrupt
;
2386 darwin_ops
->to_resume
= darwin_resume_to
;
2387 darwin_ops
->to_thread_alive
= darwin_thread_alive
;
2388 darwin_ops
->to_pid_to_str
= darwin_pid_to_str
;
2389 darwin_ops
->to_pid_to_exec_file
= darwin_pid_to_exec_file
;
2390 darwin_ops
->to_load
= NULL
;
2391 darwin_ops
->to_xfer_partial
= darwin_xfer_partial
;
2392 darwin_ops
->to_supports_multi_process
= darwin_supports_multi_process
;
2393 darwin_ops
->to_get_ada_task_ptid
= darwin_get_ada_task_ptid
;
2395 darwin_complete_target (darwin_ops
);
2397 add_target (darwin_ops
);
2399 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2400 (unsigned long) mach_task_self (), getpid ());
2402 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2403 &darwin_debug_flag
, _("\
2404 Set if printing inferior communication debugging statements."), _("\
2405 Show if printing inferior communication debugging statements."), NULL
,
2407 &setdebuglist
, &showdebuglist
);
2409 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2410 &enable_mach_exceptions
, _("\
2411 Set if mach exceptions are caught."), _("\
2412 Show if mach exceptions are caught."), _("\
2413 When this mode is on, all low level exceptions are reported before being\n\
2414 reported by the kernel."),
2415 &set_enable_mach_exceptions
, NULL
,
2416 &setlist
, &showlist
);