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/>. */
30 #include "gdbthread.h"
32 #include "event-top.h"
35 #include "inf-child.h"
37 #include "arch-utils.h"
39 #include "bfd/mach-o.h"
41 #include <sys/ptrace.h>
42 #include <sys/signal.h>
44 #include <sys/types.h>
48 #include <sys/sysctl.h>
51 #include <sys/syscall.h>
54 #include <mach/mach_error.h>
55 #include <mach/mach_vm.h>
56 #include <mach/mach_init.h>
57 #include <mach/vm_map.h>
58 #include <mach/task.h>
59 #include <mach/mach_port.h>
60 #include <mach/thread_act.h>
61 #include <mach/port.h>
63 #include "darwin-nat.h"
64 #include "common/filestuff.h"
65 #include "nat/fork-inferior.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
)
282 thread_array_t thread_list
;
283 unsigned int new_nbr
;
284 unsigned int old_nbr
;
285 unsigned int new_ix
, old_ix
;
286 darwin_inferior
*darwin_inf
= get_darwin_inferior (inf
);
287 std::vector
<darwin_thread_t
*> new_thread_vec
;
289 /* Get list of threads. */
290 kret
= task_threads (darwin_inf
->task
, &thread_list
, &new_nbr
);
291 MACH_CHECK_ERROR (kret
);
292 if (kret
!= KERN_SUCCESS
)
297 qsort (thread_list
, new_nbr
, sizeof (thread_t
), cmp_thread_t
);
299 old_nbr
= darwin_inf
->threads
.size ();
301 /* Quick check for no changes. */
302 if (old_nbr
== new_nbr
)
306 for (i
= 0; i
< new_nbr
; i
++)
307 if (thread_list
[i
] != darwin_inf
->threads
[i
]->gdb_port
)
311 /* Deallocate ports. */
312 for (i
= 0; i
< new_nbr
; i
++)
314 kret
= mach_port_deallocate (mach_task_self (), thread_list
[i
]);
315 MACH_CHECK_ERROR (kret
);
318 /* Deallocate the buffer. */
319 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
320 new_nbr
* sizeof (int));
321 MACH_CHECK_ERROR (kret
);
327 /* Full handling: detect new threads, remove dead threads. */
329 new_thread_vec
.reserve (new_nbr
);
331 for (new_ix
= 0, old_ix
= 0; new_ix
< new_nbr
|| old_ix
< old_nbr
;)
333 thread_t new_id
= (new_ix
< new_nbr
) ? thread_list
[new_ix
] : THREAD_NULL
;
335 = (old_ix
< old_nbr
) ? darwin_inf
->threads
[old_ix
] : NULL
;
336 thread_t old_id
= old
!= NULL
? old
->gdb_port
: THREAD_NULL
;
339 (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
340 new_ix
, new_nbr
, old_ix
, old_nbr
, new_id
, old_id
);
342 if (old_id
== new_id
)
344 /* Thread still exist. */
345 new_thread_vec
.push_back (old
);
349 /* Deallocate the port. */
350 kret
= mach_port_deallocate (gdb_task
, new_id
);
351 MACH_CHECK_ERROR (kret
);
355 if (new_ix
< new_nbr
&& new_id
== MACH_PORT_DEAD
)
357 /* Ignore dead ports.
358 In some weird cases, we might get dead ports. They should
359 correspond to dead thread so they could safely be ignored. */
363 if (new_ix
< new_nbr
&& (old_ix
== old_nbr
|| new_id
< old_id
))
365 /* A thread was created. */
366 struct private_thread_info
*pti
;
368 pti
= XCNEW (darwin_thread_t
);
369 pti
->gdb_port
= new_id
;
370 pti
->msg_state
= DARWIN_RUNNING
;
372 /* Add the new thread. */
373 add_thread_with_info (ptid_build (inf
->pid
, 0, new_id
), pti
);
374 new_thread_vec
.push_back (pti
);
378 if (old_ix
< old_nbr
&& (new_ix
== new_nbr
|| new_id
> old_id
))
380 /* A thread was removed. */
381 delete_thread (ptid_build (inf
->pid
, 0, old_id
));
382 kret
= mach_port_deallocate (gdb_task
, old_id
);
383 MACH_CHECK_ERROR (kret
);
387 gdb_assert_not_reached ("unexpected thread case");
390 darwin_inf
->threads
= std::move (new_thread_vec
);
392 /* Deallocate the buffer. */
393 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
394 new_nbr
* sizeof (int));
395 MACH_CHECK_ERROR (kret
);
399 find_inferior_task_it (struct inferior
*inf
, void *port_ptr
)
401 darwin_inferior
*priv
= get_darwin_inferior (inf
);
403 return priv
->task
== *(task_t
*)port_ptr
;
407 find_inferior_pid_it (struct inferior
*inf
, void *pid_ptr
)
409 return inf
->pid
== *(int *)pid_ptr
;
412 /* Return an inferior by task port. */
413 static struct inferior
*
414 darwin_find_inferior_by_task (task_t port
)
416 return iterate_over_inferiors (&find_inferior_task_it
, &port
);
419 /* Return an inferior by pid port. */
420 static struct inferior
*
421 darwin_find_inferior_by_pid (int pid
)
423 return iterate_over_inferiors (&find_inferior_pid_it
, &pid
);
426 /* Return a thread by port. */
427 static darwin_thread_t
*
428 darwin_find_thread (struct inferior
*inf
, thread_t thread
)
430 darwin_inferior
*priv
= get_darwin_inferior (inf
);
432 for (darwin_thread_t
*t
: priv
->threads
)
434 if (t
->gdb_port
== thread
)
441 /* Suspend (ie stop) an inferior at Mach level. */
444 darwin_suspend_inferior (struct inferior
*inf
)
446 darwin_inferior
*priv
= get_darwin_inferior (inf
);
448 if (!priv
->suspended
)
452 kret
= task_suspend (priv
->task
);
453 MACH_CHECK_ERROR (kret
);
459 /* Resume an inferior at Mach level. */
462 darwin_resume_inferior (struct inferior
*inf
)
464 darwin_inferior
*priv
= get_darwin_inferior (inf
);
470 kret
= task_resume (priv
->task
);
471 MACH_CHECK_ERROR (kret
);
477 /* Iterator functions. */
480 darwin_suspend_inferior_it (struct inferior
*inf
, void *arg
)
482 darwin_suspend_inferior (inf
);
483 darwin_check_new_threads (inf
);
488 darwin_resume_inferior_it (struct inferior
*inf
, void *arg
)
490 darwin_resume_inferior (inf
);
495 darwin_dump_message (mach_msg_header_t
*hdr
, int disp_body
)
497 printf_unfiltered (_("message header:\n"));
498 printf_unfiltered (_(" bits: 0x%x\n"), hdr
->msgh_bits
);
499 printf_unfiltered (_(" size: 0x%x\n"), hdr
->msgh_size
);
500 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr
->msgh_remote_port
);
501 printf_unfiltered (_(" local-port: 0x%x\n"), hdr
->msgh_local_port
);
502 printf_unfiltered (_(" reserved: 0x%x\n"), hdr
->msgh_reserved
);
503 printf_unfiltered (_(" id: 0x%x\n"), hdr
->msgh_id
);
507 const unsigned char *data
;
508 const unsigned int *ldata
;
512 data
= (unsigned char *)(hdr
+ 1);
513 size
= hdr
->msgh_size
- sizeof (mach_msg_header_t
);
515 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
517 mach_msg_body_t
*bod
= (mach_msg_body_t
*)data
;
518 mach_msg_port_descriptor_t
*desc
=
519 (mach_msg_port_descriptor_t
*)(bod
+ 1);
522 printf_unfiltered (_("body: descriptor_count=%u\n"),
523 bod
->msgh_descriptor_count
);
524 data
+= sizeof (mach_msg_body_t
);
525 size
-= sizeof (mach_msg_body_t
);
526 for (k
= 0; k
< bod
->msgh_descriptor_count
; k
++)
527 switch (desc
[k
].type
)
529 case MACH_MSG_PORT_DESCRIPTOR
:
531 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
532 k
, desc
[k
].type
, desc
[k
].name
, desc
[k
].disposition
);
535 printf_unfiltered (_(" descr %d: type=%u\n"),
539 data
+= bod
->msgh_descriptor_count
540 * sizeof (mach_msg_port_descriptor_t
);
541 size
-= bod
->msgh_descriptor_count
542 * sizeof (mach_msg_port_descriptor_t
);
543 ndr
= (NDR_record_t
*)(desc
+ bod
->msgh_descriptor_count
);
545 (_("NDR: mig=%02x if=%02x encod=%02x "
546 "int=%02x char=%02x float=%02x\n"),
547 ndr
->mig_vers
, ndr
->if_vers
, ndr
->mig_encoding
,
548 ndr
->int_rep
, ndr
->char_rep
, ndr
->float_rep
);
549 data
+= sizeof (NDR_record_t
);
550 size
-= sizeof (NDR_record_t
);
553 printf_unfiltered (_(" data:"));
554 ldata
= (const unsigned int *)data
;
555 for (i
= 0; i
< size
/ sizeof (unsigned int); i
++)
556 printf_unfiltered (" %08x", ldata
[i
]);
557 printf_unfiltered (_("\n"));
561 /* Adjust inferior data when a new task was created. */
563 static struct inferior
*
564 darwin_find_new_inferior (task_t task_port
, thread_t thread_port
)
567 struct inferior
*inf
;
571 /* Find the corresponding pid. */
572 kret
= pid_for_task (task_port
, &task_pid
);
573 if (kret
!= KERN_SUCCESS
)
575 MACH_CHECK_ERROR (kret
);
579 /* Find the inferior for this pid. */
580 inf
= darwin_find_inferior_by_pid (task_pid
);
584 darwin_inferior
*priv
= get_darwin_inferior (inf
);
586 /* Deallocate saved exception ports. */
587 darwin_deallocate_exception_ports (priv
);
589 /* No need to remove dead_name notification, but still... */
590 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
591 MACH_NOTIFY_DEAD_NAME
, 0,
593 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
595 if (kret
!= KERN_INVALID_ARGUMENT
)
596 MACH_CHECK_ERROR (kret
);
598 /* Replace old task port. */
599 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
600 MACH_CHECK_ERROR (kret
);
601 priv
->task
= task_port
;
603 darwin_setup_request_notification (inf
);
604 darwin_setup_exceptions (inf
);
609 /* Check data representation. */
612 darwin_check_message_ndr (NDR_record_t
*ndr
)
614 if (ndr
->mig_vers
!= NDR_PROTOCOL_2_0
615 || ndr
->if_vers
!= NDR_PROTOCOL_2_0
616 || ndr
->mig_encoding
!= NDR_record
.mig_encoding
617 || ndr
->int_rep
!= NDR_record
.int_rep
618 || ndr
->char_rep
!= NDR_record
.char_rep
619 || ndr
->float_rep
!= NDR_record
.float_rep
)
624 /* Decode an exception message. */
627 darwin_decode_exception_message (mach_msg_header_t
*hdr
,
628 struct inferior
**pinf
,
629 darwin_thread_t
**pthread
)
631 mach_msg_body_t
*bod
= (mach_msg_body_t
*)(hdr
+ 1);
632 mach_msg_port_descriptor_t
*desc
= (mach_msg_port_descriptor_t
*)(bod
+ 1);
635 struct inferior
*inf
;
636 darwin_thread_t
*thread
;
638 thread_t thread_port
;
642 /* Check message destination. */
643 if (hdr
->msgh_local_port
!= darwin_ex_port
)
646 /* Check message header. */
647 if (!(hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
))
650 /* Check descriptors. */
651 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
652 + sizeof (*ndr
) + 2 * sizeof (integer_t
))
653 || bod
->msgh_descriptor_count
!= 2
654 || desc
[0].type
!= MACH_MSG_PORT_DESCRIPTOR
655 || desc
[0].disposition
!= MACH_MSG_TYPE_MOVE_SEND
656 || desc
[1].type
!= MACH_MSG_PORT_DESCRIPTOR
657 || desc
[1].disposition
!= MACH_MSG_TYPE_MOVE_SEND
)
660 /* Check data representation. */
661 ndr
= (NDR_record_t
*)(desc
+ 2);
662 if (darwin_check_message_ndr (ndr
) != 0)
665 /* Ok, the hard work. */
666 data
= (integer_t
*)(ndr
+ 1);
668 task_port
= desc
[1].name
;
669 thread_port
= desc
[0].name
;
671 /* Find process by port. */
672 inf
= darwin_find_inferior_by_task (task_port
);
675 if (inf
== NULL
&& data
[0] == EXC_SOFTWARE
&& data
[1] == 2
676 && data
[2] == EXC_SOFT_SIGNAL
&& data
[3] == SIGTRAP
)
678 /* Not a known inferior, but a sigtrap. This happens on darwin 16.1.0,
679 as a new Mach task is created when a process exec. */
680 inf
= darwin_find_new_inferior (task_port
, thread_port
);
685 /* Deallocate task_port, unless it was saved. */
686 kret
= mach_port_deallocate (mach_task_self (), task_port
);
687 MACH_CHECK_ERROR (kret
);
692 /* We got new rights to the task, get rid of it. Do not get rid of
693 thread right, as we will need it to find the thread. */
694 kret
= mach_port_deallocate (mach_task_self (), task_port
);
695 MACH_CHECK_ERROR (kret
);
700 /* Not a known inferior. This could happen if the child fork, as
701 the created process will inherit its exception port.
702 FIXME: should the exception port be restored ? */
704 mig_reply_error_t reply
;
707 (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
710 /* Free thread port (we don't know it). */
711 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
712 MACH_CHECK_ERROR (kret
);
714 darwin_encode_reply (&reply
, hdr
, KERN_SUCCESS
);
716 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
717 reply
.Head
.msgh_size
, 0,
718 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
720 MACH_CHECK_ERROR (kret
);
725 /* Find thread by port. */
726 /* Check for new threads. Do it early so that the port in the exception
727 message can be deallocated. */
728 darwin_check_new_threads (inf
);
730 /* Free the thread port (as gdb knows the thread, it has already has a right
731 for it, so this just decrement a reference counter). */
732 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
733 MACH_CHECK_ERROR (kret
);
735 thread
= darwin_find_thread (inf
, thread_port
);
740 /* The thread should be running. However we have observed cases where a
741 thread got a SIGTTIN message after being stopped. */
742 gdb_assert (thread
->msg_state
!= DARWIN_MESSAGE
);
744 /* Finish decoding. */
745 thread
->event
.header
= *hdr
;
746 thread
->event
.thread_port
= thread_port
;
747 thread
->event
.task_port
= task_port
;
748 thread
->event
.ex_type
= data
[0];
749 thread
->event
.data_count
= data
[1];
751 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
752 + sizeof (*ndr
) + 2 * sizeof (integer_t
)
753 + data
[1] * sizeof (integer_t
)))
755 for (i
= 0; i
< data
[1]; i
++)
756 thread
->event
.ex_data
[i
] = data
[2 + i
];
758 thread
->msg_state
= DARWIN_MESSAGE
;
763 /* Decode dead_name notify message. */
766 darwin_decode_notify_message (mach_msg_header_t
*hdr
, struct inferior
**pinf
)
768 NDR_record_t
*ndr
= (NDR_record_t
*)(hdr
+ 1);
769 integer_t
*data
= (integer_t
*)(ndr
+ 1);
770 struct inferior
*inf
;
771 darwin_thread_t
*thread
;
773 thread_t thread_port
;
777 /* Check message header. */
778 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
781 /* Check descriptors. */
782 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*ndr
) + sizeof (integer_t
)))
785 /* Check data representation. */
786 if (darwin_check_message_ndr (ndr
) != 0)
791 /* Find process by port. */
792 inf
= darwin_find_inferior_by_task (task_port
);
795 darwin_inferior
*priv
= get_darwin_inferior (inf
);
797 /* Check message destination. */
798 if (inf
!= NULL
&& hdr
->msgh_local_port
!= priv
->notify_port
)
805 darwin_encode_reply (mig_reply_error_t
*reply
, mach_msg_header_t
*hdr
,
808 mach_msg_header_t
*rh
= &reply
->Head
;
810 rh
->msgh_bits
= MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr
->msgh_bits
), 0);
811 rh
->msgh_remote_port
= hdr
->msgh_remote_port
;
812 rh
->msgh_size
= (mach_msg_size_t
) sizeof (mig_reply_error_t
);
813 rh
->msgh_local_port
= MACH_PORT_NULL
;
814 rh
->msgh_id
= hdr
->msgh_id
+ 100;
816 reply
->NDR
= NDR_record
;
817 reply
->RetCode
= code
;
821 darwin_send_reply (struct inferior
*inf
, darwin_thread_t
*thread
)
824 mig_reply_error_t reply
;
825 darwin_inferior
*priv
= get_darwin_inferior (inf
);
827 darwin_encode_reply (&reply
, &thread
->event
.header
, KERN_SUCCESS
);
829 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
830 reply
.Head
.msgh_size
, 0,
831 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
833 MACH_CHECK_ERROR (kret
);
835 priv
->pending_messages
--;
839 darwin_resume_thread (struct inferior
*inf
, darwin_thread_t
*thread
,
840 int step
, int nsignal
)
846 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
847 thread
->msg_state
, thread
->gdb_port
, step
, nsignal
);
849 switch (thread
->msg_state
)
852 if (thread
->event
.ex_type
== EXC_SOFTWARE
853 && thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
855 /* Either deliver a new signal or cancel the signal received. */
856 res
= PTRACE (PT_THUPDATE
, inf
->pid
,
857 (caddr_t
) (uintptr_t) thread
->gdb_port
, nsignal
);
859 inferior_debug (1, _("ptrace THUP: res=%d\n"), res
);
863 /* Note: ptrace is allowed only if the process is stopped.
864 Directly send the signal to the thread. */
865 res
= syscall (SYS___pthread_kill
, thread
->gdb_port
, nsignal
);
866 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
867 thread
->gdb_port
, nsignal
, res
);
868 thread
->signaled
= 1;
871 /* Set or reset single step. */
872 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
873 thread
->gdb_port
, step
);
874 darwin_set_sstep (thread
->gdb_port
, step
);
875 thread
->single_step
= step
;
877 darwin_send_reply (inf
, thread
);
878 thread
->msg_state
= DARWIN_RUNNING
;
885 kret
= thread_resume (thread
->gdb_port
);
886 MACH_CHECK_ERROR (kret
);
888 thread
->msg_state
= DARWIN_RUNNING
;
893 /* Resume all threads of the inferior. */
896 darwin_resume_inferior_threads (struct inferior
*inf
, int step
, int nsignal
)
898 darwin_inferior
*priv
= get_darwin_inferior (inf
);
900 for (darwin_thread_t
*thread
: priv
->threads
)
901 darwin_resume_thread (inf
, thread
, step
, nsignal
);
904 struct resume_inferior_threads_param
911 darwin_resume_inferior_threads_it (struct inferior
*inf
, void *param
)
913 int step
= ((struct resume_inferior_threads_param
*)param
)->step
;
914 int nsignal
= ((struct resume_inferior_threads_param
*)param
)->nsignal
;
916 darwin_resume_inferior_threads (inf
, step
, nsignal
);
921 /* Suspend all threads of INF. */
924 darwin_suspend_inferior_threads (struct inferior
*inf
)
926 darwin_inferior
*priv
= get_darwin_inferior (inf
);
928 for (darwin_thread_t
*thread
: priv
->threads
)
930 switch (thread
->msg_state
)
937 kern_return_t kret
= thread_suspend (thread
->gdb_port
);
938 MACH_CHECK_ERROR (kret
);
939 thread
->msg_state
= DARWIN_STOPPED
;
947 darwin_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
949 struct target_waitstatus status
;
955 struct inferior
*inf
;
958 (2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
959 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, signal
);
961 if (signal
== GDB_SIGNAL_0
)
964 nsignal
= gdb_signal_to_host (signal
);
966 /* Don't try to single step all threads. */
968 ptid
= inferior_ptid
;
970 /* minus_one_ptid is RESUME_ALL. */
971 if (ptid_equal (ptid
, minus_one_ptid
))
973 struct resume_inferior_threads_param param
;
975 param
.nsignal
= nsignal
;
978 /* Resume threads. */
979 iterate_over_inferiors (darwin_resume_inferior_threads_it
, ¶m
);
981 iterate_over_inferiors (darwin_resume_inferior_it
, NULL
);
985 struct inferior
*inf
= find_inferior_ptid (ptid
);
986 long tid
= ptid_get_tid (ptid
);
988 /* Stop the inferior (should be useless). */
989 darwin_suspend_inferior (inf
);
992 darwin_resume_inferior_threads (inf
, step
, nsignal
);
995 darwin_thread_t
*thread
;
997 /* Suspend threads of the task. */
998 darwin_suspend_inferior_threads (inf
);
1000 /* Resume the selected thread. */
1001 thread
= darwin_find_thread (inf
, tid
);
1002 gdb_assert (thread
);
1003 darwin_resume_thread (inf
, thread
, step
, nsignal
);
1006 /* Resume the task. */
1007 darwin_resume_inferior (inf
);
1012 darwin_resume_to (struct target_ops
*ops
, ptid_t ptid
, int step
,
1013 enum gdb_signal signal
)
1015 return darwin_resume (ptid
, step
, signal
);
1019 darwin_decode_message (mach_msg_header_t
*hdr
,
1020 darwin_thread_t
**pthread
,
1021 struct inferior
**pinf
,
1022 struct target_waitstatus
*status
)
1024 darwin_thread_t
*thread
;
1025 struct inferior
*inf
;
1027 /* Exception message. 2401 == 0x961 is exc. */
1028 if (hdr
->msgh_id
== 2401)
1032 /* Decode message. */
1033 res
= darwin_decode_exception_message (hdr
, &inf
, &thread
);
1037 /* Should not happen... */
1039 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr
->msgh_id
);
1040 /* FIXME: send a failure reply? */
1041 status
->kind
= TARGET_WAITKIND_IGNORE
;
1042 return minus_one_ptid
;
1046 status
->kind
= TARGET_WAITKIND_IGNORE
;
1047 return minus_one_ptid
;
1052 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1054 priv
->pending_messages
++;
1056 status
->kind
= TARGET_WAITKIND_STOPPED
;
1057 thread
->msg_state
= DARWIN_MESSAGE
;
1059 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1061 unparse_exception_type (thread
->event
.ex_type
));
1063 switch (thread
->event
.ex_type
)
1065 case EXC_BAD_ACCESS
:
1066 status
->value
.sig
= GDB_EXC_BAD_ACCESS
;
1068 case EXC_BAD_INSTRUCTION
:
1069 status
->value
.sig
= GDB_EXC_BAD_INSTRUCTION
;
1071 case EXC_ARITHMETIC
:
1072 status
->value
.sig
= GDB_EXC_ARITHMETIC
;
1075 status
->value
.sig
= GDB_EXC_EMULATION
;
1078 if (thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
1081 gdb_signal_from_host (thread
->event
.ex_data
[1]);
1082 inferior_debug (5, _(" (signal %d: %s)\n"),
1083 thread
->event
.ex_data
[1],
1084 gdb_signal_to_name (status
->value
.sig
));
1086 /* If the thread is stopped because it has received a signal
1087 that gdb has just sent, continue. */
1088 if (thread
->signaled
)
1090 thread
->signaled
= 0;
1091 darwin_send_reply (inf
, thread
);
1092 thread
->msg_state
= DARWIN_RUNNING
;
1093 status
->kind
= TARGET_WAITKIND_IGNORE
;
1097 status
->value
.sig
= GDB_EXC_SOFTWARE
;
1099 case EXC_BREAKPOINT
:
1100 /* Many internal GDB routines expect breakpoints to be reported
1101 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1102 as a spurious signal. */
1103 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1106 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1110 return ptid_build (inf
->pid
, 0, thread
->gdb_port
);
1112 else if (hdr
->msgh_id
== 0x48)
1114 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
1117 res
= darwin_decode_notify_message (hdr
, &inf
);
1121 /* Should not happen... */
1123 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1130 if (res
< 0 || inf
== NULL
)
1132 status
->kind
= TARGET_WAITKIND_IGNORE
;
1133 return minus_one_ptid
;
1138 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1140 if (!priv
->no_ptrace
)
1145 res
= wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1146 if (res
< 0 || res
!= inf
->pid
)
1148 printf_unfiltered (_("wait4: res=%d: %s\n"),
1149 res
, safe_strerror (errno
));
1150 status
->kind
= TARGET_WAITKIND_IGNORE
;
1151 return minus_one_ptid
;
1153 if (WIFEXITED (wstatus
))
1155 status
->kind
= TARGET_WAITKIND_EXITED
;
1156 status
->value
.integer
= WEXITSTATUS (wstatus
);
1160 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
1161 status
->value
.sig
= gdb_signal_from_host (WTERMSIG (wstatus
));
1164 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1167 /* Looks necessary on Leopard and harmless... */
1168 wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1170 inferior_ptid
= ptid_build (inf
->pid
, 0, 0);
1171 return inferior_ptid
;
1175 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf
->pid
);
1176 status
->kind
= TARGET_WAITKIND_EXITED
;
1177 status
->value
.integer
= 0; /* Don't know. */
1178 return ptid_build (inf
->pid
, 0, 0);
1183 /* Unknown message. */
1184 warning (_("darwin: got unknown message, id: 0x%x"), hdr
->msgh_id
);
1185 status
->kind
= TARGET_WAITKIND_IGNORE
;
1186 return minus_one_ptid
;
1190 cancel_breakpoint (ptid_t ptid
)
1192 /* Arrange for a breakpoint to be hit again later. We will handle
1193 the current event, eventually we will resume this thread, and this
1194 breakpoint will trap again.
1196 If we do not do this, then we run the risk that the user will
1197 delete or disable the breakpoint, but the thread will have already
1200 struct regcache
*regcache
= get_thread_regcache (ptid
);
1201 struct gdbarch
*gdbarch
= regcache
->arch ();
1204 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
1205 if (breakpoint_inserted_here_p (regcache
->aspace (), pc
))
1207 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1208 (unsigned long) ptid_get_tid (ptid
));
1210 /* Back up the PC if necessary. */
1211 if (gdbarch_decr_pc_after_break (gdbarch
))
1212 regcache_write_pc (regcache
, pc
);
1220 darwin_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1225 mach_msg_header_t hdr
;
1228 mach_msg_header_t
*hdr
= &msgin
.hdr
;
1230 darwin_thread_t
*thread
;
1231 struct inferior
*inf
;
1234 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1235 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
1237 /* Handle fake stop events at first. */
1238 if (darwin_inf_fake_stop
!= NULL
)
1240 inf
= darwin_inf_fake_stop
;
1241 darwin_inf_fake_stop
= NULL
;
1243 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1245 status
->kind
= TARGET_WAITKIND_STOPPED
;
1246 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1247 thread
= priv
->threads
[0];
1248 thread
->msg_state
= DARWIN_STOPPED
;
1249 return ptid_build (inf
->pid
, 0, thread
->gdb_port
);
1254 /* set_sigint_trap (); */
1256 /* Wait for a message. */
1257 kret
= mach_msg (&msgin
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
, 0,
1258 sizeof (msgin
.data
), darwin_port_set
, 0, MACH_PORT_NULL
);
1260 /* clear_sigint_trap (); */
1262 if (kret
== MACH_RCV_INTERRUPTED
)
1264 status
->kind
= TARGET_WAITKIND_IGNORE
;
1265 return minus_one_ptid
;
1268 if (kret
!= MACH_MSG_SUCCESS
)
1270 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret
);
1271 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
1272 return minus_one_ptid
;
1275 /* Debug: display message. */
1276 if (darwin_debug_flag
> 10)
1277 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1279 res
= darwin_decode_message (hdr
, &thread
, &inf
, status
);
1280 if (ptid_equal (res
, minus_one_ptid
))
1283 /* Early return in case an inferior has exited. */
1287 while (status
->kind
== TARGET_WAITKIND_IGNORE
);
1289 /* Stop all tasks. */
1290 iterate_over_inferiors (darwin_suspend_inferior_it
, NULL
);
1292 /* Read pending messages. */
1295 struct target_waitstatus status2
;
1298 kret
= mach_msg (&msgin
.hdr
,
1299 MACH_RCV_MSG
| MACH_RCV_TIMEOUT
, 0,
1300 sizeof (msgin
.data
), darwin_port_set
, 1, MACH_PORT_NULL
);
1302 if (kret
== MACH_RCV_TIMED_OUT
)
1304 if (kret
!= MACH_MSG_SUCCESS
)
1307 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret
);
1311 /* Debug: display message. */
1312 if (darwin_debug_flag
> 10)
1313 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1315 ptid2
= darwin_decode_message (hdr
, &thread
, &inf
, &status2
);
1317 if (inf
!= NULL
&& thread
!= NULL
1318 && thread
->event
.ex_type
== EXC_BREAKPOINT
)
1320 if (thread
->single_step
1321 || cancel_breakpoint (ptid_build (inf
->pid
, 0, thread
->gdb_port
)))
1323 gdb_assert (thread
->msg_state
== DARWIN_MESSAGE
);
1324 darwin_send_reply (inf
, thread
);
1325 thread
->msg_state
= DARWIN_RUNNING
;
1329 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1333 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1339 darwin_wait_to (struct target_ops
*ops
,
1340 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
1342 return darwin_wait (ptid
, status
);
1346 darwin_interrupt (struct target_ops
*self
, ptid_t t
)
1348 struct inferior
*inf
= current_inferior ();
1349 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1351 /* FIXME: handle in no_ptrace mode. */
1352 gdb_assert (!priv
->no_ptrace
);
1353 kill (inf
->pid
, SIGINT
);
1356 /* Deallocate threads port and vector. */
1359 darwin_deallocate_threads (struct inferior
*inf
)
1361 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1363 for (darwin_thread_t
*t
: priv
->threads
)
1365 kern_return_t kret
= mach_port_deallocate (gdb_task
, t
->gdb_port
);
1366 MACH_CHECK_ERROR (kret
);
1369 priv
->threads
.clear ();
1373 darwin_mourn_inferior (struct target_ops
*ops
)
1375 struct inferior
*inf
= current_inferior ();
1376 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1381 /* Deallocate threads. */
1382 darwin_deallocate_threads (inf
);
1384 /* Remove notify_port from darwin_port_set. */
1385 kret
= mach_port_move_member (gdb_task
,
1386 priv
->notify_port
, MACH_PORT_NULL
);
1387 MACH_CHECK_ERROR (kret
);
1389 /* Remove task port dead_name notification. */
1390 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1391 MACH_NOTIFY_DEAD_NAME
, 0,
1393 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1395 /* This can fail if the task is dead. */
1396 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1397 priv
->task
, prev
, priv
->notify_port
);
1399 if (kret
== KERN_SUCCESS
)
1401 kret
= mach_port_deallocate (gdb_task
, prev
);
1402 MACH_CHECK_ERROR (kret
);
1405 /* Destroy notify_port. */
1406 kret
= mach_port_destroy (gdb_task
, priv
->notify_port
);
1407 MACH_CHECK_ERROR (kret
);
1409 /* Deallocate saved exception ports. */
1410 darwin_deallocate_exception_ports (priv
);
1412 /* Deallocate task port. */
1413 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
1414 MACH_CHECK_ERROR (kret
);
1418 inf_child_mourn_inferior (ops
);
1422 darwin_reply_to_all_pending_messages (struct inferior
*inf
)
1424 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1426 for (darwin_thread_t
*t
: priv
->threads
)
1428 if (t
->msg_state
== DARWIN_MESSAGE
)
1429 darwin_resume_thread (inf
, t
, 0, 0);
1434 darwin_stop_inferior (struct inferior
*inf
)
1436 struct target_waitstatus wstatus
;
1441 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1443 gdb_assert (inf
!= NULL
);
1445 darwin_suspend_inferior (inf
);
1447 darwin_reply_to_all_pending_messages (inf
);
1449 if (priv
->no_ptrace
)
1452 res
= kill (inf
->pid
, SIGSTOP
);
1454 warning (_("cannot kill: %s"), safe_strerror (errno
));
1456 /* Wait until the process is really stopped. */
1459 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1460 if (wstatus
.kind
== TARGET_WAITKIND_STOPPED
1461 && wstatus
.value
.sig
== GDB_SIGNAL_STOP
)
1466 static kern_return_t
1467 darwin_save_exception_ports (darwin_inferior
*inf
)
1471 inf
->exception_info
.count
=
1472 sizeof (inf
->exception_info
.ports
) / sizeof (inf
->exception_info
.ports
[0]);
1474 kret
= task_get_exception_ports
1475 (inf
->task
, EXC_MASK_ALL
, inf
->exception_info
.masks
,
1476 &inf
->exception_info
.count
, inf
->exception_info
.ports
,
1477 inf
->exception_info
.behaviors
, inf
->exception_info
.flavors
);
1481 static kern_return_t
1482 darwin_restore_exception_ports (darwin_inferior
*inf
)
1487 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1489 kret
= task_set_exception_ports
1490 (inf
->task
, inf
->exception_info
.masks
[i
], inf
->exception_info
.ports
[i
],
1491 inf
->exception_info
.behaviors
[i
], inf
->exception_info
.flavors
[i
]);
1492 if (kret
!= KERN_SUCCESS
)
1496 return KERN_SUCCESS
;
1499 /* Deallocate saved exception ports. */
1502 darwin_deallocate_exception_ports (darwin_inferior
*inf
)
1507 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1509 kret
= mach_port_deallocate (gdb_task
, inf
->exception_info
.ports
[i
]);
1510 MACH_CHECK_ERROR (kret
);
1512 inf
->exception_info
.count
= 0;
1516 darwin_setup_exceptions (struct inferior
*inf
)
1518 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1521 exception_mask_t mask
;
1523 kret
= darwin_save_exception_ports (priv
);
1524 if (kret
!= KERN_SUCCESS
)
1525 error (_("Unable to save exception ports, task_get_exception_ports"
1529 /* Set exception port. */
1530 if (enable_mach_exceptions
)
1531 mask
= EXC_MASK_ALL
;
1533 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1534 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
1535 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1536 if (kret
!= KERN_SUCCESS
)
1537 error (_("Unable to set exception ports, task_set_exception_ports"
1543 darwin_kill_inferior (struct target_ops
*ops
)
1545 struct inferior
*inf
= current_inferior ();
1546 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1547 struct target_waitstatus wstatus
;
1553 if (ptid_equal (inferior_ptid
, null_ptid
))
1556 gdb_assert (inf
!= NULL
);
1558 kret
= darwin_restore_exception_ports (priv
);
1559 MACH_CHECK_ERROR (kret
);
1561 darwin_reply_to_all_pending_messages (inf
);
1563 res
= kill (inf
->pid
, 9);
1567 darwin_resume_inferior (inf
);
1569 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1571 else if (errno
!= ESRCH
)
1572 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1573 inf
->pid
, safe_strerror (errno
));
1575 target_mourn_inferior (inferior_ptid
);
1579 darwin_setup_request_notification (struct inferior
*inf
)
1581 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1583 mach_port_t prev_not
;
1585 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1586 MACH_NOTIFY_DEAD_NAME
, 0,
1588 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1590 if (kret
!= KERN_SUCCESS
)
1591 error (_("Termination notification request failed, "
1592 "mach_port_request_notification\n"
1595 if (prev_not
!= MACH_PORT_NULL
)
1597 /* This is unexpected, as there should not be any previously
1598 registered notification request. But this is not a fatal
1599 issue, so just emit a warning. */
1601 A task termination request was registered before the debugger registered\n\
1602 its own. This is unexpected, but should otherwise not have any actual\n\
1603 impact on the debugging session."));
1608 darwin_attach_pid (struct inferior
*inf
)
1611 mach_port_t prev_port
;
1613 mach_port_t prev_not
;
1614 exception_mask_t mask
;
1616 darwin_inferior
*priv
= new darwin_inferior
;
1617 inf
->priv
.reset (priv
);
1619 kret
= task_for_pid (gdb_task
, inf
->pid
, &priv
->task
);
1620 if (kret
!= KERN_SUCCESS
)
1624 if (!inf
->attach_flag
)
1627 waitpid (inf
->pid
, &status
, 0);
1630 error (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1631 " (please check gdb is codesigned - see taskgated(8))"),
1632 inf
->pid
, mach_error_string (kret
), (unsigned long) kret
);
1635 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1636 priv
->task
, inf
->pid
);
1638 if (darwin_ex_port
== MACH_PORT_NULL
)
1640 /* Create a port to get exceptions. */
1641 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1643 if (kret
!= KERN_SUCCESS
)
1644 error (_("Unable to create exception port, mach_port_allocate "
1648 kret
= mach_port_insert_right (gdb_task
, darwin_ex_port
, darwin_ex_port
,
1649 MACH_MSG_TYPE_MAKE_SEND
);
1650 if (kret
!= KERN_SUCCESS
)
1651 error (_("Unable to create exception port, mach_port_insert_right "
1655 /* Create a port set and put ex_port in it. */
1656 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_PORT_SET
,
1658 if (kret
!= KERN_SUCCESS
)
1659 error (_("Unable to create port set, mach_port_allocate "
1663 kret
= mach_port_move_member (gdb_task
, darwin_ex_port
, darwin_port_set
);
1664 if (kret
!= KERN_SUCCESS
)
1665 error (_("Unable to move exception port into new port set, "
1666 "mach_port_move_member\n"
1671 /* Create a port to be notified when the child task terminates. */
1672 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1673 &priv
->notify_port
);
1674 if (kret
!= KERN_SUCCESS
)
1675 error (_("Unable to create notification port, mach_port_allocate "
1679 kret
= mach_port_move_member (gdb_task
,
1680 priv
->notify_port
, darwin_port_set
);
1681 if (kret
!= KERN_SUCCESS
)
1682 error (_("Unable to move notification port into new port set, "
1683 "mach_port_move_member\n"
1687 darwin_setup_request_notification (inf
);
1689 darwin_setup_exceptions (inf
);
1691 if (!target_is_pushed (darwin_ops
))
1692 push_target (darwin_ops
);
1695 /* Get the thread_info object corresponding to this private_thread_info. */
1697 static struct thread_info
*
1698 thread_info_from_private_thread_info (private_thread_info
*pti
)
1700 struct thread_info
*it
;
1704 if (it
->priv
->gdb_port
== pti
->gdb_port
)
1708 gdb_assert (it
!= NULL
);
1714 darwin_init_thread_list (struct inferior
*inf
)
1716 darwin_check_new_threads (inf
);
1718 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1720 gdb_assert (!priv
->threads
.empty ());
1722 private_thread_info
*first_pti
= priv
->threads
.front ();
1723 struct thread_info
*first_thread
1724 = thread_info_from_private_thread_info (first_pti
);
1726 inferior_ptid
= first_thread
->ptid
;
1729 /* The child must synchronize with gdb: gdb must set the exception port
1730 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1731 FIXME: is there a lighter way ? */
1732 static int ptrace_fds
[2];
1735 darwin_ptrace_me (void)
1740 /* Close write end point. */
1741 if (close (ptrace_fds
[1]) < 0)
1742 trace_start_error_with_name ("close");
1744 /* Wait until gdb is ready. */
1745 res
= read (ptrace_fds
[0], &c
, 1);
1747 trace_start_error (_("unable to read from pipe, read returned: %d"), res
);
1749 if (close (ptrace_fds
[0]) < 0)
1750 trace_start_error_with_name ("close");
1752 /* Get rid of privileges. */
1753 if (setegid (getgid ()) < 0)
1754 trace_start_error_with_name ("setegid");
1757 if (PTRACE (PT_TRACE_ME
, 0, 0, 0) < 0)
1758 trace_start_error_with_name ("PTRACE");
1760 /* Redirect signals to exception port. */
1761 if (PTRACE (PT_SIGEXC
, 0, 0, 0) < 0)
1762 trace_start_error_with_name ("PTRACE");
1765 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1767 darwin_pre_ptrace (void)
1769 if (pipe (ptrace_fds
) != 0)
1773 error (_("unable to create a pipe: %s"), safe_strerror (errno
));
1776 mark_fd_no_cloexec (ptrace_fds
[0]);
1777 mark_fd_no_cloexec (ptrace_fds
[1]);
1781 darwin_ptrace_him (int pid
)
1785 mach_port_t prev_port
;
1787 struct inferior
*inf
= current_inferior ();
1789 darwin_attach_pid (inf
);
1791 /* Let's the child run. */
1792 close (ptrace_fds
[0]);
1793 close (ptrace_fds
[1]);
1795 unmark_fd_no_cloexec (ptrace_fds
[0]);
1796 unmark_fd_no_cloexec (ptrace_fds
[1]);
1798 darwin_init_thread_list (inf
);
1800 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
1804 darwin_execvp (const char *file
, char * const argv
[], char * const env
[])
1806 posix_spawnattr_t attr
;
1810 res
= posix_spawnattr_init (&attr
);
1814 (gdb_stderr
, "Cannot initialize attribute for posix_spawn\n");
1818 /* Do like execve: replace the image. */
1819 ps_flags
= POSIX_SPAWN_SETEXEC
;
1821 /* Disable ASLR. The constant doesn't look to be available outside the
1822 kernel include files. */
1823 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1824 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1826 ps_flags
|= _POSIX_SPAWN_DISABLE_ASLR
;
1827 res
= posix_spawnattr_setflags (&attr
, ps_flags
);
1830 fprintf_unfiltered (gdb_stderr
, "Cannot set posix_spawn flags\n");
1834 posix_spawnp (NULL
, argv
[0], NULL
, &attr
, argv
, env
);
1838 darwin_create_inferior (struct target_ops
*ops
,
1839 const char *exec_file
,
1840 const std::string
&allargs
,
1841 char **env
, int from_tty
)
1843 /* Do the hard work. */
1844 fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
,
1845 darwin_ptrace_him
, darwin_pre_ptrace
, NULL
,
1850 /* Set things up such that the next call to darwin_wait will immediately
1851 return a fake stop event for inferior INF.
1853 This assumes that the inferior's thread list has been initialized,
1854 as it will suspend the inferior's first thread. */
1857 darwin_setup_fake_stop_event (struct inferior
*inf
)
1859 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1860 darwin_thread_t
*thread
;
1863 gdb_assert (darwin_inf_fake_stop
== NULL
);
1864 darwin_inf_fake_stop
= inf
;
1866 /* When detecting a fake pending stop event, darwin_wait returns
1867 an event saying that the first thread is in a DARWIN_STOPPED
1868 state. To make that accurate, we need to suspend that thread
1869 as well. Otherwise, we'll try resuming it when resuming the
1870 inferior, and get a warning because the thread's suspend count
1871 is already zero, making the resume request useless. */
1872 thread
= priv
->threads
[0];
1873 kret
= thread_suspend (thread
->gdb_port
);
1874 MACH_CHECK_ERROR (kret
);
1877 /* Attach to process PID, then initialize for debugging it
1878 and wait for the trace-trap that results from attaching. */
1880 darwin_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
1886 struct inferior
*inf
;
1889 pid
= parse_pid_to_attach (args
);
1891 if (pid
== getpid ()) /* Trying to masturbate? */
1892 error (_("I refuse to debug myself!"));
1896 char *exec_file
= get_exec_file (0);
1899 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
1900 target_pid_to_str (pid_to_ptid (pid
)));
1902 printf_unfiltered (_("Attaching to %s\n"),
1903 target_pid_to_str (pid_to_ptid (pid
)));
1905 gdb_flush (gdb_stdout
);
1908 if (pid
== 0 || kill (pid
, 0) < 0)
1909 error (_("Can't attach to process %d: %s (%d)"),
1910 pid
, safe_strerror (errno
), errno
);
1912 inferior_ptid
= pid_to_ptid (pid
);
1913 inf
= current_inferior ();
1914 inferior_appeared (inf
, pid
);
1915 inf
->attach_flag
= 1;
1917 darwin_attach_pid (inf
);
1919 darwin_suspend_inferior (inf
);
1921 darwin_init_thread_list (inf
);
1923 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1925 darwin_check_osabi (priv
, ptid_get_tid (inferior_ptid
));
1927 darwin_setup_fake_stop_event (inf
);
1929 priv
->no_ptrace
= 1;
1932 /* Take a program previously attached to and detaches it.
1933 The program resumes execution and will no longer stop
1934 on signals, etc. We'd better not have left any breakpoints
1935 in the program or it'll die when it hits one. For this
1936 to work, it may be necessary for the process to have been
1937 previously attached. It *might* work if the program was
1938 started via fork. */
1940 darwin_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
1942 pid_t pid
= ptid_get_pid (inferior_ptid
);
1943 struct inferior
*inf
= current_inferior ();
1944 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1948 /* Display message. */
1949 target_announce_detach (from_tty
);
1951 /* If ptrace() is in use, stop the process. */
1952 if (!priv
->no_ptrace
)
1953 darwin_stop_inferior (inf
);
1955 kret
= darwin_restore_exception_ports (priv
);
1956 MACH_CHECK_ERROR (kret
);
1958 if (!priv
->no_ptrace
)
1960 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
1962 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1963 inf
->pid
, safe_strerror (errno
), errno
);
1966 darwin_reply_to_all_pending_messages (inf
);
1968 /* When using ptrace, we have just performed a PT_DETACH, which
1969 resumes the inferior. On the other hand, when we are not using
1970 ptrace, we need to resume its execution ourselves. */
1971 if (priv
->no_ptrace
)
1972 darwin_resume_inferior (inf
);
1974 darwin_mourn_inferior (ops
);
1978 darwin_files_info (struct target_ops
*ops
)
1983 darwin_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1985 static char buf
[80];
1986 long tid
= ptid_get_tid (ptid
);
1990 snprintf (buf
, sizeof (buf
), _("Thread 0x%lx of process %u"),
1991 tid
, ptid_get_pid (ptid
));
1995 return normal_pid_to_str (ptid
);
1999 darwin_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2004 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2005 copy it to RDADDR in gdb's address space.
2006 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2007 to ADDR in inferior task's address space.
2008 Return 0 on failure; number of bytes read / writen otherwise. */
2011 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
2012 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
2016 mach_vm_size_t res_length
= 0;
2018 mach_msg_type_number_t copy_count
;
2019 mach_vm_size_t remaining_length
;
2020 mach_vm_address_t region_address
;
2021 mach_vm_size_t region_length
;
2023 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2024 task
, core_addr_to_string (addr
), pulongest (length
));
2029 mach_vm_size_t count
;
2031 /* According to target.h(to_xfer_partial), one and only one may be
2033 gdb_assert (wraddr
== NULL
);
2035 kret
= mach_vm_read_overwrite (task
, addr
, length
,
2036 (mach_vm_address_t
) rdaddr
, &count
);
2037 if (kret
!= KERN_SUCCESS
)
2040 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2041 core_addr_to_string (addr
), mach_error_string (kret
));
2048 gdb_assert (wraddr
!= NULL
);
2052 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
2053 mach_vm_address_t region_address
= (mach_vm_address_t
) (addr
- offset
);
2054 mach_vm_size_t aligned_length
=
2055 (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
2056 vm_region_submap_short_info_data_64_t info
;
2057 mach_msg_type_number_t count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
2058 natural_t region_depth
= 1000;
2059 mach_vm_address_t region_start
= region_address
;
2060 mach_vm_size_t region_length
;
2061 mach_vm_size_t write_length
;
2063 /* Read page protection. */
2064 kret
= mach_vm_region_recurse
2065 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
2066 (vm_region_recurse_info_t
) &info
, &count
);
2068 if (kret
!= KERN_SUCCESS
)
2070 inferior_debug (1, _("darwin_read_write_inferior: "
2071 "mach_vm_region_recurse failed at %s: %s\n"),
2072 core_addr_to_string (region_address
),
2073 mach_error_string (kret
));
2078 (9, _("darwin_read_write_inferior: "
2079 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2080 core_addr_to_string (region_address
),
2081 core_addr_to_string (region_start
),
2082 core_addr_to_string (region_length
));
2084 /* Check for holes in memory. */
2085 if (region_start
> region_address
)
2087 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
2088 core_addr_to_string (region_address
),
2089 core_addr_to_string (region_start
),
2090 (unsigned)region_length
);
2094 /* Adjust the length. */
2095 region_length
-= (region_address
- region_start
);
2096 if (region_length
> aligned_length
)
2097 region_length
= aligned_length
;
2099 /* Make the pages RW. */
2100 if (!(info
.protection
& VM_PROT_WRITE
))
2102 vm_prot_t prot
= VM_PROT_READ
| VM_PROT_WRITE
;
2104 kret
= mach_vm_protect (task
, region_address
, region_length
,
2106 if (kret
!= KERN_SUCCESS
)
2108 prot
|= VM_PROT_COPY
;
2109 kret
= mach_vm_protect (task
, region_address
, region_length
,
2112 if (kret
!= KERN_SUCCESS
)
2114 warning (_("darwin_read_write_inferior: "
2115 "mach_vm_protect failed at %s "
2116 "(len=0x%lx, prot=0x%x): %s"),
2117 core_addr_to_string (region_address
),
2118 (unsigned long) region_length
, (unsigned) prot
,
2119 mach_error_string (kret
));
2124 if (offset
+ length
> region_length
)
2125 write_length
= region_length
- offset
;
2127 write_length
= length
;
2130 kret
= mach_vm_write (task
, addr
, (vm_offset_t
) wraddr
, write_length
);
2131 if (kret
!= KERN_SUCCESS
)
2133 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2134 mach_error_string (kret
));
2138 /* Restore page rights. */
2139 if (!(info
.protection
& VM_PROT_WRITE
))
2141 kret
= mach_vm_protect (task
, region_address
, region_length
,
2142 FALSE
, info
.protection
);
2143 if (kret
!= KERN_SUCCESS
)
2145 warning (_("darwin_read_write_inferior: "
2146 "mach_vm_protect restore failed at %s "
2148 core_addr_to_string (region_address
),
2149 (unsigned long) region_length
,
2150 mach_error_string (kret
));
2154 addr
+= write_length
;
2155 wraddr
+= write_length
;
2156 res_length
+= write_length
;
2157 length
-= write_length
;
2163 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2164 to RDADDR (in big endian).
2165 Return 0 on failure; number of bytes read / written otherwise. */
2167 #ifdef TASK_DYLD_INFO_COUNT
2168 /* This is not available in Darwin 9. */
2169 static enum target_xfer_status
2170 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
2171 ULONGEST length
, ULONGEST
*xfered_len
)
2173 struct task_dyld_info task_dyld_info
;
2174 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
2175 int sz
= TASK_DYLD_INFO_COUNT
* sizeof (natural_t
);
2178 if (addr
!= 0 || length
> sizeof (mach_vm_address_t
))
2179 return TARGET_XFER_EOF
;
2181 kret
= task_info (task
, TASK_DYLD_INFO
,
2182 (task_info_t
) &task_dyld_info
, &count
);
2183 MACH_CHECK_ERROR (kret
);
2184 if (kret
!= KERN_SUCCESS
)
2185 return TARGET_XFER_E_IO
;
2187 store_unsigned_integer (rdaddr
, length
, BFD_ENDIAN_BIG
,
2188 task_dyld_info
.all_image_info_addr
);
2189 *xfered_len
= (ULONGEST
) length
;
2190 return TARGET_XFER_OK
;
2196 static enum target_xfer_status
2197 darwin_xfer_partial (struct target_ops
*ops
,
2198 enum target_object object
, const char *annex
,
2199 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2200 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
2202 struct inferior
*inf
= current_inferior ();
2203 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2206 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2207 core_addr_to_string (offset
), pulongest (len
),
2208 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
2213 case TARGET_OBJECT_MEMORY
:
2215 int l
= darwin_read_write_inferior (priv
->task
, offset
,
2216 readbuf
, writebuf
, len
);
2219 return TARGET_XFER_EOF
;
2223 *xfered_len
= (ULONGEST
) l
;
2224 return TARGET_XFER_OK
;
2227 #ifdef TASK_DYLD_INFO_COUNT
2228 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
2229 if (writebuf
!= NULL
|| readbuf
== NULL
)
2231 /* Support only read. */
2232 return TARGET_XFER_E_IO
;
2234 return darwin_read_dyld_info (priv
->task
, offset
, readbuf
, len
,
2238 return TARGET_XFER_E_IO
;
2244 set_enable_mach_exceptions (const char *args
, int from_tty
,
2245 struct cmd_list_element
*c
)
2247 if (!ptid_equal (inferior_ptid
, null_ptid
))
2249 struct inferior
*inf
= current_inferior ();
2250 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2251 exception_mask_t mask
;
2254 if (enable_mach_exceptions
)
2255 mask
= EXC_MASK_ALL
;
2258 darwin_restore_exception_ports (priv
);
2259 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
2261 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
2262 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
2263 MACH_CHECK_ERROR (kret
);
2268 darwin_pid_to_exec_file (struct target_ops
*self
, int pid
)
2270 static char path
[PATH_MAX
];
2273 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, PATH_MAX
);
2281 darwin_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
2283 struct inferior
*inf
= current_inferior ();
2284 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2286 mach_port_name_array_t names
;
2287 mach_msg_type_number_t names_count
;
2288 mach_port_type_array_t types
;
2289 mach_msg_type_number_t types_count
;
2292 /* First linear search. */
2293 for (darwin_thread_t
*t
: priv
->threads
)
2295 if (t
->inf_port
== lwp
)
2296 return ptid_build (ptid_get_pid (inferior_ptid
), 0, t
->gdb_port
);
2299 /* Maybe the port was never extract. Do it now. */
2301 /* First get inferior port names. */
2302 kret
= mach_port_names (priv
->task
, &names
, &names_count
, &types
,
2304 MACH_CHECK_ERROR (kret
);
2305 if (kret
!= KERN_SUCCESS
)
2308 /* For each name, copy the right in the gdb space and then compare with
2309 our view of the inferior threads. We don't forget to deallocate the
2311 for (int i
= 0; i
< names_count
; i
++)
2313 mach_port_t local_name
;
2314 mach_msg_type_name_t local_type
;
2316 /* We just need to know the corresponding name in gdb name space.
2317 So extract and deallocate the right. */
2318 kret
= mach_port_extract_right (priv
->task
, names
[i
],
2319 MACH_MSG_TYPE_COPY_SEND
,
2320 &local_name
, &local_type
);
2321 if (kret
!= KERN_SUCCESS
)
2323 mach_port_deallocate (gdb_task
, local_name
);
2325 for (darwin_thread_t
*t
: priv
->threads
)
2327 if (t
->gdb_port
== local_name
)
2329 t
->inf_port
= names
[i
];
2330 if (names
[i
] == lwp
)
2336 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2337 names_count
* sizeof (mach_port_t
));
2340 return ptid_build (ptid_get_pid (inferior_ptid
), 0, res
);
2346 darwin_supports_multi_process (struct target_ops
*self
)
2352 _initialize_darwin_inferior (void)
2356 gdb_task
= mach_task_self ();
2357 darwin_host_self
= mach_host_self ();
2359 /* Read page size. */
2360 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2361 if (kret
!= KERN_SUCCESS
)
2363 mach_page_size
= 0x1000;
2364 MACH_CHECK_ERROR (kret
);
2367 darwin_ops
= inf_child_target ();
2369 darwin_ops
->to_create_inferior
= darwin_create_inferior
;
2370 darwin_ops
->to_attach
= darwin_attach
;
2371 darwin_ops
->to_attach_no_wait
= 0;
2372 darwin_ops
->to_detach
= darwin_detach
;
2373 darwin_ops
->to_files_info
= darwin_files_info
;
2374 darwin_ops
->to_wait
= darwin_wait_to
;
2375 darwin_ops
->to_mourn_inferior
= darwin_mourn_inferior
;
2376 darwin_ops
->to_kill
= darwin_kill_inferior
;
2377 darwin_ops
->to_interrupt
= darwin_interrupt
;
2378 darwin_ops
->to_resume
= darwin_resume_to
;
2379 darwin_ops
->to_thread_alive
= darwin_thread_alive
;
2380 darwin_ops
->to_pid_to_str
= darwin_pid_to_str
;
2381 darwin_ops
->to_pid_to_exec_file
= darwin_pid_to_exec_file
;
2382 darwin_ops
->to_load
= NULL
;
2383 darwin_ops
->to_xfer_partial
= darwin_xfer_partial
;
2384 darwin_ops
->to_supports_multi_process
= darwin_supports_multi_process
;
2385 darwin_ops
->to_get_ada_task_ptid
= darwin_get_ada_task_ptid
;
2387 darwin_complete_target (darwin_ops
);
2389 add_target (darwin_ops
);
2391 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2392 (unsigned long) mach_task_self (), getpid ());
2394 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2395 &darwin_debug_flag
, _("\
2396 Set if printing inferior communication debugging statements."), _("\
2397 Show if printing inferior communication debugging statements."), NULL
,
2399 &setdebuglist
, &showdebuglist
);
2401 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2402 &enable_mach_exceptions
, _("\
2403 Set if mach exceptions are caught."), _("\
2404 Show if mach exceptions are caught."), _("\
2405 When this mode is on, all low level exceptions are reported before being\n\
2406 reported by the kernel."),
2407 &set_enable_mach_exceptions
, NULL
,
2408 &setlist
, &showlist
);