]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/darwin-nat.c
Fix build failure in darwin-nat.c
[thirdparty/binutils-gdb.git] / gdb / darwin-nat.c
CommitLineData
a80b95ba 1/* Darwin support for GDB, the GNU debugger.
61baf725 2 Copyright (C) 2008-2017 Free Software Foundation, Inc.
a80b95ba
TG
3
4 Contributed by AdaCore.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
47d48711 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
a80b95ba
TG
20
21#include "defs.h"
22#include "top.h"
23#include "inferior.h"
24#include "target.h"
25#include "symfile.h"
26#include "symtab.h"
27#include "objfiles.h"
a80b95ba
TG
28#include "gdbcmd.h"
29#include "gdbcore.h"
30#include "gdbthread.h"
31#include "regcache.h"
32#include "event-top.h"
33#include "inf-loop.h"
53ce3c39 34#include <sys/stat.h>
a80b95ba
TG
35#include "inf-child.h"
36#include "value.h"
37#include "arch-utils.h"
38#include "bfd.h"
ece0061f 39#include "bfd/mach-o.h"
a80b95ba
TG
40
41#include <sys/ptrace.h>
42#include <sys/signal.h>
4ac15b59 43#include <setjmp.h>
a80b95ba
TG
44#include <sys/types.h>
45#include <unistd.h>
46#include <signal.h>
a80b95ba 47#include <ctype.h>
a80b95ba
TG
48#include <sys/sysctl.h>
49#include <sys/proc.h>
bb00b29d
TG
50#include <libproc.h>
51#include <sys/syscall.h>
e69860f1 52#include <spawn.h>
a80b95ba
TG
53
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>
62
63#include "darwin-nat.h"
21ff4686 64#include "common/filestuff.h"
01ec7a27 65#include "nat/fork-inferior.h"
a80b95ba
TG
66
67/* Quick overview.
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).
70
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
77 on Mach ports.
78
79 Some Mach documentation is available for Apple xnu source package or
80 from the web. */
81
82
83#define PTRACE(CMD, PID, ADDR, SIG) \
84 darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
85
bfedc46a 86static void darwin_interrupt (struct target_ops *self, ptid_t);
a80b95ba 87
bb00b29d 88static void darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
2ea28649 89 enum gdb_signal signal);
bb00b29d 90static void darwin_resume (ptid_t ptid, int step,
2ea28649 91 enum gdb_signal signal);
bb00b29d
TG
92
93static ptid_t darwin_wait_to (struct target_ops *ops, ptid_t ptid,
94 struct target_waitstatus *status, int options);
95static ptid_t darwin_wait (ptid_t ptid, struct target_waitstatus *status);
96
a80b95ba
TG
97static void darwin_mourn_inferior (struct target_ops *ops);
98
2ab1c2d9 99static void darwin_kill_inferior (struct target_ops *ops);
a80b95ba
TG
100
101static void darwin_ptrace_me (void);
102
103static void darwin_ptrace_him (int pid);
104
7c5ded6a
SDJ
105static void darwin_create_inferior (struct target_ops *ops,
106 const char *exec_file,
107 const std::string &allargs,
108 char **env, int from_tty);
a80b95ba
TG
109
110static void darwin_files_info (struct target_ops *ops);
111
7a114964 112static const char *darwin_pid_to_str (struct target_ops *ops, ptid_t tpid);
bb00b29d
TG
113
114static int darwin_thread_alive (struct target_ops *ops, ptid_t tpid);
a80b95ba 115
a41f2563
TG
116static void darwin_encode_reply (mig_reply_error_t *reply,
117 mach_msg_header_t *hdr, integer_t code);
118
82b19a4d
TG
119static void darwin_setup_request_notification (struct inferior *inf);
120static void darwin_deallocate_exception_ports (darwin_inferior *inf);
121static void darwin_setup_exceptions (struct inferior *inf);
122static void darwin_deallocate_threads (struct inferior *inf);
123
a80b95ba
TG
124/* Target operations for Darwin. */
125static struct target_ops *darwin_ops;
126
127/* Task identifier of gdb. */
128static task_t gdb_task;
129
130/* A copy of mach_host_self (). */
131mach_port_t darwin_host_self;
132
133/* Exception port. */
134mach_port_t darwin_ex_port;
135
a6290449 136/* Port set, to wait for answer on all ports. */
a80b95ba
TG
137mach_port_t darwin_port_set;
138
0963b4bd 139/* Page size. */
a80b95ba
TG
140static vm_size_t mach_page_size;
141
142/* If Set, catch all mach exceptions (before they are converted to signals
143 by the kernel). */
144static int enable_mach_exceptions;
145
bb00b29d
TG
146/* Inferior that should report a fake stop event. */
147static struct inferior *darwin_inf_fake_stop;
148
a80b95ba
TG
149#define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
150#define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
151
bb00b29d 152/* This controls output of inferior debugging. */
ccce17b0 153static unsigned int darwin_debug_flag = 0;
a80b95ba 154
15c19d39
TG
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.
157
a6290449
TG
158 Once gdb is built, you must codesign it with any system-trusted signing
159 authority. See taskgated(8) for details. */
15c19d39
TG
160static 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"
166 "<dict>\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"
174 " <array>\n"
175 " <string>allowed</string>\n"
176 " <string>debug</string>\n"
177 " </array>\n"
178 "</dict>\n"
179 "</plist>\n";
180
77b64a49
PA
181static void inferior_debug (int level, const char *fmt, ...)
182 ATTRIBUTE_PRINTF (2, 3);
183
a80b95ba
TG
184static void
185inferior_debug (int level, const char *fmt, ...)
186{
187 va_list ap;
188
189 if (darwin_debug_flag < level)
190 return;
191
192 va_start (ap, fmt);
193 printf_unfiltered (_("[%d inferior]: "), getpid ());
194 vprintf_unfiltered (fmt, ap);
195 va_end (ap);
196}
197
198void
199mach_check_error (kern_return_t ret, const char *file,
200 unsigned int line, const char *func)
201{
202 if (ret == KERN_SUCCESS)
203 return;
204 if (func == NULL)
205 func = _("[UNKNOWN]");
bb00b29d 206
4f1cdeec 207 warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
bb00b29d 208 file, line, func, mach_error_string (ret), (unsigned long) ret);
a80b95ba
TG
209}
210
211static const char *
212unparse_exception_type (unsigned int i)
213{
214 static char unknown_exception_buf[32];
215
216 switch (i)
217 {
218 case EXC_BAD_ACCESS:
219 return "EXC_BAD_ACCESS";
220 case EXC_BAD_INSTRUCTION:
221 return "EXC_BAD_INSTRUCTION";
222 case EXC_ARITHMETIC:
223 return "EXC_ARITHMETIC";
224 case EXC_EMULATION:
225 return "EXC_EMULATION";
226 case EXC_SOFTWARE:
227 return "EXC_SOFTWARE";
228 case EXC_BREAKPOINT:
229 return "EXC_BREAKPOINT";
230 case EXC_SYSCALL:
231 return "EXC_SYSCALL";
232 case EXC_MACH_SYSCALL:
233 return "EXC_MACH_SYSCALL";
234 case EXC_RPC_ALERT:
235 return "EXC_RPC_ALERT";
236 case EXC_CRASH:
237 return "EXC_CRASH";
238 default:
239 snprintf (unknown_exception_buf, 32, _("unknown (%d)"), i);
240 return unknown_exception_buf;
241 }
242}
243
a7aa0d73
JB
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
246 trace.
247
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. */
252
a80b95ba
TG
253static int
254darwin_ptrace (const char *name,
aa14fb50 255 int request, int pid, caddr_t arg3, int arg4)
a80b95ba
TG
256{
257 int ret;
258
a7aa0d73 259 errno = 0;
aa14fb50 260 ret = ptrace (request, pid, arg3, arg4);
a7aa0d73
JB
261 if (ret == -1 && errno == 0)
262 ret = 0;
a80b95ba 263
3eb831e0
TG
264 inferior_debug (4, _("ptrace (%s, %d, 0x%lx, %d): %d (%s)\n"),
265 name, pid, (unsigned long) arg3, arg4, ret,
a3224241 266 (ret != 0) ? safe_strerror (errno) : _("no error"));
a80b95ba
TG
267 return ret;
268}
269
270static int
271cmp_thread_t (const void *l, const void *r)
272{
bb00b29d
TG
273 thread_t tl = *(const thread_t *)l;
274 thread_t tr = *(const thread_t *)r;
275 return (int)(tl - tr);
a80b95ba
TG
276}
277
278static void
bb00b29d 279darwin_check_new_threads (struct inferior *inf)
a80b95ba
TG
280{
281 kern_return_t kret;
282 unsigned int i;
283 thread_array_t thread_list;
284 unsigned int new_nbr;
285 unsigned int old_nbr;
286 unsigned int new_ix, old_ix;
fe978cb0 287 darwin_inferior *darwin_inf = inf->priv;
bb00b29d 288 VEC (darwin_thread_t) *thread_vec;
a80b95ba
TG
289
290 /* Get list of threads. */
bb00b29d 291 kret = task_threads (darwin_inf->task, &thread_list, &new_nbr);
a80b95ba
TG
292 MACH_CHECK_ERROR (kret);
293 if (kret != KERN_SUCCESS)
294 return;
295
bb00b29d 296 /* Sort the list. */
a80b95ba
TG
297 if (new_nbr > 1)
298 qsort (thread_list, new_nbr, sizeof (thread_t), cmp_thread_t);
299
bb00b29d
TG
300 if (darwin_inf->threads)
301 old_nbr = VEC_length (darwin_thread_t, darwin_inf->threads);
a80b95ba
TG
302 else
303 old_nbr = 0;
304
bb00b29d
TG
305 /* Quick check for no changes. */
306 if (old_nbr == new_nbr)
307 {
308 for (i = 0; i < new_nbr; i++)
309 if (thread_list[i]
310 != VEC_index (darwin_thread_t, darwin_inf->threads, i)->gdb_port)
311 break;
312 if (i == new_nbr)
313 {
15a9128a
TG
314 /* Deallocate ports. */
315 for (i = 0; i < new_nbr; i++)
316 {
317 kret = mach_port_deallocate (mach_task_self (), thread_list[i]);
318 MACH_CHECK_ERROR (kret);
319 }
320
321 /* Deallocate the buffer. */
bb00b29d
TG
322 kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
323 new_nbr * sizeof (int));
324 MACH_CHECK_ERROR (kret);
15a9128a 325
bb00b29d
TG
326 return;
327 }
328 }
329
82b19a4d 330 /* Full handling: detect new threads, remove dead threads. */
bb00b29d
TG
331 thread_vec = VEC_alloc (darwin_thread_t, new_nbr);
332
a80b95ba
TG
333 for (new_ix = 0, old_ix = 0; new_ix < new_nbr || old_ix < old_nbr;)
334 {
335 thread_t new_id = (new_ix < new_nbr) ?
336 thread_list[new_ix] : THREAD_NULL;
bb00b29d
TG
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;
340
341 inferior_debug
c8c9911f 342 (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
bb00b29d 343 new_ix, new_nbr, old_ix, old_nbr, new_id, old_id);
a80b95ba
TG
344
345 if (old_id == new_id)
346 {
347 /* Thread still exist. */
bb00b29d 348 VEC_safe_push (darwin_thread_t, thread_vec, old);
a80b95ba
TG
349 new_ix++;
350 old_ix++;
351
15a9128a
TG
352 /* Deallocate the port. */
353 kret = mach_port_deallocate (gdb_task, new_id);
a80b95ba 354 MACH_CHECK_ERROR (kret);
15a9128a 355
a80b95ba
TG
356 continue;
357 }
bb00b29d
TG
358 if (new_ix < new_nbr && new_id == MACH_PORT_DEAD)
359 {
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. */
363 new_ix++;
364 continue;
365 }
366 if (new_ix < new_nbr && (old_ix == old_nbr || new_id < old_id))
a80b95ba
TG
367 {
368 /* A thread was created. */
bb00b29d 369 struct private_thread_info *pti;
a80b95ba 370
41bf6aca 371 pti = XCNEW (struct private_thread_info);
bb00b29d
TG
372 pti->gdb_port = new_id;
373 pti->msg_state = DARWIN_RUNNING;
374
db665f42
SM
375 /* Add the new thread. */
376 add_thread_with_info (ptid_build (inf->pid, 0, new_id), pti);
bb00b29d 377 VEC_safe_push (darwin_thread_t, thread_vec, pti);
a80b95ba
TG
378 new_ix++;
379 continue;
380 }
bb00b29d 381 if (old_ix < old_nbr && (new_ix == new_nbr || new_id > old_id))
a80b95ba
TG
382 {
383 /* A thread was removed. */
384 delete_thread (ptid_build (inf->pid, 0, old_id));
385 kret = mach_port_deallocate (gdb_task, old_id);
386 MACH_CHECK_ERROR (kret);
387 old_ix++;
bb00b29d 388 continue;
a80b95ba 389 }
f3574227 390 gdb_assert_not_reached ("unexpected thread case");
a80b95ba
TG
391 }
392
bb00b29d
TG
393 if (darwin_inf->threads)
394 VEC_free (darwin_thread_t, darwin_inf->threads);
395 darwin_inf->threads = thread_vec;
a80b95ba 396
15a9128a 397 /* Deallocate the buffer. */
a80b95ba
TG
398 kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
399 new_nbr * sizeof (int));
400 MACH_CHECK_ERROR (kret);
401}
402
bb00b29d
TG
403static int
404find_inferior_task_it (struct inferior *inf, void *port_ptr)
a80b95ba 405{
82b19a4d 406 return inf->priv->task == *(task_t *)port_ptr;
bb00b29d 407}
a80b95ba 408
bb00b29d 409static int
82b19a4d 410find_inferior_pid_it (struct inferior *inf, void *pid_ptr)
bb00b29d 411{
82b19a4d 412 return inf->pid == *(int *)pid_ptr;
a80b95ba
TG
413}
414
bb00b29d
TG
415/* Return an inferior by task port. */
416static struct inferior *
417darwin_find_inferior_by_task (task_t port)
a80b95ba 418{
bb00b29d
TG
419 return iterate_over_inferiors (&find_inferior_task_it, &port);
420}
a80b95ba 421
82b19a4d 422/* Return an inferior by pid port. */
bb00b29d 423static struct inferior *
82b19a4d 424darwin_find_inferior_by_pid (int pid)
bb00b29d 425{
82b19a4d 426 return iterate_over_inferiors (&find_inferior_pid_it, &pid);
bb00b29d 427}
a80b95ba 428
bb00b29d
TG
429/* Return a thread by port. */
430static darwin_thread_t *
431darwin_find_thread (struct inferior *inf, thread_t thread)
432{
433 darwin_thread_t *t;
434 int k;
435
436 for (k = 0;
fe978cb0 437 VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
bb00b29d
TG
438 k++)
439 if (t->gdb_port == thread)
440 return t;
441 return NULL;
442}
a80b95ba 443
bb00b29d 444/* Suspend (ie stop) an inferior at Mach level. */
a80b95ba 445
bb00b29d
TG
446static void
447darwin_suspend_inferior (struct inferior *inf)
448{
fe978cb0 449 if (!inf->priv->suspended)
a80b95ba 450 {
bb00b29d 451 kern_return_t kret;
a80b95ba 452
fe978cb0 453 kret = task_suspend (inf->priv->task);
bb00b29d 454 MACH_CHECK_ERROR (kret);
a80b95ba 455
fe978cb0 456 inf->priv->suspended = 1;
bb00b29d
TG
457 }
458}
a80b95ba 459
bb00b29d 460/* Resume an inferior at Mach level. */
a80b95ba 461
bb00b29d
TG
462static void
463darwin_resume_inferior (struct inferior *inf)
464{
fe978cb0 465 if (inf->priv->suspended)
bb00b29d
TG
466 {
467 kern_return_t kret;
a80b95ba 468
fe978cb0 469 kret = task_resume (inf->priv->task);
bb00b29d
TG
470 MACH_CHECK_ERROR (kret);
471
fe978cb0 472 inf->priv->suspended = 0;
a80b95ba
TG
473 }
474}
475
bb00b29d
TG
476/* Iterator functions. */
477
478static int
479darwin_suspend_inferior_it (struct inferior *inf, void *arg)
a80b95ba 480{
bb00b29d
TG
481 darwin_suspend_inferior (inf);
482 darwin_check_new_threads (inf);
483 return 0;
484}
485
486static int
487darwin_resume_inferior_it (struct inferior *inf, void *arg)
488{
489 darwin_resume_inferior (inf);
490 return 0;
a80b95ba
TG
491}
492
bb00b29d
TG
493static void
494darwin_dump_message (mach_msg_header_t *hdr, int disp_body)
495{
496 printf_unfiltered (_("message header:\n"));
497 printf_unfiltered (_(" bits: 0x%x\n"), hdr->msgh_bits);
498 printf_unfiltered (_(" size: 0x%x\n"), hdr->msgh_size);
499 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr->msgh_remote_port);
500 printf_unfiltered (_(" local-port: 0x%x\n"), hdr->msgh_local_port);
501 printf_unfiltered (_(" reserved: 0x%x\n"), hdr->msgh_reserved);
502 printf_unfiltered (_(" id: 0x%x\n"), hdr->msgh_id);
503
504 if (disp_body)
505 {
506 const unsigned char *data;
a6290449 507 const unsigned int *ldata;
bb00b29d
TG
508 int size;
509 int i;
510
511 data = (unsigned char *)(hdr + 1);
512 size = hdr->msgh_size - sizeof (mach_msg_header_t);
513
514 if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
515 {
516 mach_msg_body_t *bod = (mach_msg_body_t*)data;
517 mach_msg_port_descriptor_t *desc =
518 (mach_msg_port_descriptor_t *)(bod + 1);
519 int k;
520 NDR_record_t *ndr;
521 printf_unfiltered (_("body: descriptor_count=%u\n"),
522 bod->msgh_descriptor_count);
523 data += sizeof (mach_msg_body_t);
524 size -= sizeof (mach_msg_body_t);
525 for (k = 0; k < bod->msgh_descriptor_count; k++)
526 switch (desc[k].type)
527 {
528 case MACH_MSG_PORT_DESCRIPTOR:
529 printf_unfiltered
530 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
531 k, desc[k].type, desc[k].name, desc[k].disposition);
532 break;
533 default:
534 printf_unfiltered (_(" descr %d: type=%u\n"),
535 k, desc[k].type);
536 break;
537 }
538 data += bod->msgh_descriptor_count
539 * sizeof (mach_msg_port_descriptor_t);
540 size -= bod->msgh_descriptor_count
541 * sizeof (mach_msg_port_descriptor_t);
542 ndr = (NDR_record_t *)(desc + bod->msgh_descriptor_count);
543 printf_unfiltered
544 (_("NDR: mig=%02x if=%02x encod=%02x "
545 "int=%02x char=%02x float=%02x\n"),
546 ndr->mig_vers, ndr->if_vers, ndr->mig_encoding,
547 ndr->int_rep, ndr->char_rep, ndr->float_rep);
548 data += sizeof (NDR_record_t);
549 size -= sizeof (NDR_record_t);
550 }
551
552 printf_unfiltered (_(" data:"));
a6290449
TG
553 ldata = (const unsigned int *)data;
554 for (i = 0; i < size / sizeof (unsigned int); i++)
555 printf_unfiltered (" %08x", ldata[i]);
bb00b29d
TG
556 printf_unfiltered (_("\n"));
557 }
558}
559
82b19a4d
TG
560/* Adjust inferior data when a new task was created. */
561
562static struct inferior *
563darwin_find_new_inferior (task_t task_port, thread_t thread_port)
564{
565 int task_pid;
566 struct inferior *inf;
567 kern_return_t kret;
568 mach_port_t prev;
569
570 /* Find the corresponding pid. */
571 kret = pid_for_task (task_port, &task_pid);
572 if (kret != KERN_SUCCESS)
573 {
574 MACH_CHECK_ERROR (kret);
575 return NULL;
576 }
577
578 /* Find the inferior for this pid. */
579 inf = darwin_find_inferior_by_pid (task_pid);
580 if (inf == NULL)
581 return NULL;
582
583 /* Deallocate saved exception ports. */
584 darwin_deallocate_exception_ports (inf->priv);
585
586 /* No need to remove dead_name notification, but still... */
587 kret = mach_port_request_notification (gdb_task, inf->priv->task,
588 MACH_NOTIFY_DEAD_NAME, 0,
589 MACH_PORT_NULL,
590 MACH_MSG_TYPE_MAKE_SEND_ONCE,
591 &prev);
592 if (kret != KERN_INVALID_ARGUMENT)
593 MACH_CHECK_ERROR (kret);
594
595 /* Replace old task port. */
596 kret = mach_port_deallocate (gdb_task, inf->priv->task);
597 MACH_CHECK_ERROR (kret);
598 inf->priv->task = task_port;
599
600 darwin_setup_request_notification (inf);
601 darwin_setup_exceptions (inf);
602
603 return inf;
604}
605
606/* Check data representation. */
607
608static int
609darwin_check_message_ndr (NDR_record_t *ndr)
610{
611 if (ndr->mig_vers != NDR_PROTOCOL_2_0
612 || ndr->if_vers != NDR_PROTOCOL_2_0
613 || ndr->mig_encoding != NDR_record.mig_encoding
614 || ndr->int_rep != NDR_record.int_rep
615 || ndr->char_rep != NDR_record.char_rep
616 || ndr->float_rep != NDR_record.float_rep)
617 return -1;
618 return 0;
619}
620
621/* Decode an exception message. */
622
bb00b29d
TG
623static int
624darwin_decode_exception_message (mach_msg_header_t *hdr,
625 struct inferior **pinf,
626 darwin_thread_t **pthread)
a80b95ba 627{
bb00b29d
TG
628 mach_msg_body_t *bod = (mach_msg_body_t*)(hdr + 1);
629 mach_msg_port_descriptor_t *desc = (mach_msg_port_descriptor_t *)(bod + 1);
630 NDR_record_t *ndr;
631 integer_t *data;
632 struct inferior *inf;
633 darwin_thread_t *thread;
634 task_t task_port;
635 thread_t thread_port;
a80b95ba 636 kern_return_t kret;
bb00b29d 637 int i;
a80b95ba 638
a41f2563
TG
639 /* Check message destination. */
640 if (hdr->msgh_local_port != darwin_ex_port)
bb00b29d
TG
641 return -1;
642
643 /* Check message header. */
644 if (!(hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX))
645 return -1;
646
647 /* Check descriptors. */
648 if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
649 + sizeof (*ndr) + 2 * sizeof (integer_t))
650 || bod->msgh_descriptor_count != 2
651 || desc[0].type != MACH_MSG_PORT_DESCRIPTOR
652 || desc[0].disposition != MACH_MSG_TYPE_MOVE_SEND
653 || desc[1].type != MACH_MSG_PORT_DESCRIPTOR
654 || desc[1].disposition != MACH_MSG_TYPE_MOVE_SEND)
655 return -1;
656
657 /* Check data representation. */
658 ndr = (NDR_record_t *)(desc + 2);
82b19a4d 659 if (darwin_check_message_ndr (ndr) != 0)
bb00b29d
TG
660 return -1;
661
662 /* Ok, the hard work. */
663 data = (integer_t *)(ndr + 1);
664
bb00b29d
TG
665 task_port = desc[1].name;
666 thread_port = desc[0].name;
a41f2563 667
a41f2563 668 /* Find process by port. */
bb00b29d 669 inf = darwin_find_inferior_by_task (task_port);
bb00b29d 670 *pinf = inf;
82b19a4d
TG
671
672 if (inf == NULL && data[0] == EXC_SOFTWARE && data[1] == 2
673 && data[2] == EXC_SOFT_SIGNAL && data[3] == SIGTRAP)
674 {
675 /* Not a known inferior, but a sigtrap. This happens on darwin 16.1.0,
676 as a new Mach task is created when a process exec. */
677 inf = darwin_find_new_inferior (task_port, thread_port);
678 *pinf = inf;
679
680 if (inf == NULL)
681 {
682 /* Deallocate task_port, unless it was saved. */
683 kret = mach_port_deallocate (mach_task_self (), task_port);
684 MACH_CHECK_ERROR (kret);
685 }
686 }
687 else
688 {
689 /* We got new rights to the task, get rid of it. Do not get rid of
690 thread right, as we will need it to find the thread. */
691 kret = mach_port_deallocate (mach_task_self (), task_port);
692 MACH_CHECK_ERROR (kret);
693 }
694
a41f2563
TG
695 if (inf == NULL)
696 {
697 /* Not a known inferior. This could happen if the child fork, as
698 the created process will inherit its exception port.
699 FIXME: should the exception port be restored ? */
700 kern_return_t kret;
701 mig_reply_error_t reply;
702
82b19a4d
TG
703 inferior_debug
704 (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
705 task_port);
706
15a9128a
TG
707 /* Free thread port (we don't know it). */
708 kret = mach_port_deallocate (mach_task_self (), thread_port);
709 MACH_CHECK_ERROR (kret);
710
a41f2563
TG
711 darwin_encode_reply (&reply, hdr, KERN_SUCCESS);
712
713 kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
714 reply.Head.msgh_size, 0,
715 MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
716 MACH_PORT_NULL);
717 MACH_CHECK_ERROR (kret);
718
719 return 0;
720 }
bb00b29d
TG
721
722 /* Find thread by port. */
723 /* Check for new threads. Do it early so that the port in the exception
724 message can be deallocated. */
725 darwin_check_new_threads (inf);
726
15a9128a
TG
727 /* Free the thread port (as gdb knows the thread, it has already has a right
728 for it, so this just decrement a reference counter). */
729 kret = mach_port_deallocate (mach_task_self (), thread_port);
730 MACH_CHECK_ERROR (kret);
731
bb00b29d
TG
732 thread = darwin_find_thread (inf, thread_port);
733 if (thread == NULL)
734 return -1;
735 *pthread = thread;
736
a6290449
TG
737 /* The thread should be running. However we have observed cases where a
738 thread got a SIGTTIN message after being stopped. */
484a26a8
TG
739 gdb_assert (thread->msg_state != DARWIN_MESSAGE);
740
bb00b29d 741 /* Finish decoding. */
bb00b29d
TG
742 thread->event.header = *hdr;
743 thread->event.thread_port = thread_port;
744 thread->event.task_port = task_port;
745 thread->event.ex_type = data[0];
746 thread->event.data_count = data[1];
747
748 if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
749 + sizeof (*ndr) + 2 * sizeof (integer_t)
750 + data[1] * sizeof (integer_t)))
751 return -1;
752 for (i = 0; i < data[1]; i++)
753 thread->event.ex_data[i] = data[2 + i];
754
755 thread->msg_state = DARWIN_MESSAGE;
756
757 return 0;
758}
759
82b19a4d
TG
760/* Decode dead_name notify message. */
761
762static int
763darwin_decode_notify_message (mach_msg_header_t *hdr, struct inferior **pinf)
764{
765 NDR_record_t *ndr = (NDR_record_t *)(hdr + 1);
766 integer_t *data = (integer_t *)(ndr + 1);
767 struct inferior *inf;
768 darwin_thread_t *thread;
769 task_t task_port;
770 thread_t thread_port;
771 kern_return_t kret;
772 int i;
773
774 /* Check message header. */
775 if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
776 return -1;
777
778 /* Check descriptors. */
779 if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*ndr) + sizeof (integer_t)))
780 return -2;
781
782 /* Check data representation. */
783 if (darwin_check_message_ndr (ndr) != 0)
784 return -3;
785
786 task_port = data[0];
787
788 /* Find process by port. */
789 inf = darwin_find_inferior_by_task (task_port);
790 *pinf = inf;
791
792 /* Check message destination. */
793 if (inf != NULL && hdr->msgh_local_port != inf->priv->notify_port)
794 return -4;
795
796 return 0;
797}
798
bb00b29d
TG
799static void
800darwin_encode_reply (mig_reply_error_t *reply, mach_msg_header_t *hdr,
801 integer_t code)
802{
803 mach_msg_header_t *rh = &reply->Head;
a6290449
TG
804
805 rh->msgh_bits = MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr->msgh_bits), 0);
bb00b29d 806 rh->msgh_remote_port = hdr->msgh_remote_port;
a6290449 807 rh->msgh_size = (mach_msg_size_t) sizeof (mig_reply_error_t);
bb00b29d
TG
808 rh->msgh_local_port = MACH_PORT_NULL;
809 rh->msgh_id = hdr->msgh_id + 100;
810
811 reply->NDR = NDR_record;
812 reply->RetCode = code;
a80b95ba
TG
813}
814
bb00b29d
TG
815static void
816darwin_send_reply (struct inferior *inf, darwin_thread_t *thread)
a80b95ba
TG
817{
818 kern_return_t kret;
bb00b29d 819 mig_reply_error_t reply;
a80b95ba 820
bb00b29d
TG
821 darwin_encode_reply (&reply, &thread->event.header, KERN_SUCCESS);
822
823 kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
824 reply.Head.msgh_size, 0,
825 MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
826 MACH_PORT_NULL);
a80b95ba
TG
827 MACH_CHECK_ERROR (kret);
828
fe978cb0 829 inf->priv->pending_messages--;
bb00b29d
TG
830}
831
832static void
833darwin_resume_thread (struct inferior *inf, darwin_thread_t *thread,
834 int step, int nsignal)
835{
836 kern_return_t kret;
837 int res;
838
a80b95ba 839 inferior_debug
bb00b29d
TG
840 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
841 thread->msg_state, thread->gdb_port, step, nsignal);
842
843 switch (thread->msg_state)
a80b95ba 844 {
bb00b29d
TG
845 case DARWIN_MESSAGE:
846 if (thread->event.ex_type == EXC_SOFTWARE
847 && thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
848 {
849 /* Either deliver a new signal or cancel the signal received. */
850 res = PTRACE (PT_THUPDATE, inf->pid,
597e448c 851 (caddr_t) (uintptr_t) thread->gdb_port, nsignal);
bb00b29d
TG
852 if (res < 0)
853 inferior_debug (1, _("ptrace THUP: res=%d\n"), res);
854 }
855 else if (nsignal)
856 {
857 /* Note: ptrace is allowed only if the process is stopped.
858 Directly send the signal to the thread. */
859 res = syscall (SYS___pthread_kill, thread->gdb_port, nsignal);
860 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
861 thread->gdb_port, nsignal, res);
862 thread->signaled = 1;
863 }
864
d987a266 865 /* Set or reset single step. */
aa14fb50
TG
866 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
867 thread->gdb_port, step);
868 darwin_set_sstep (thread->gdb_port, step);
869 thread->single_step = step;
bb00b29d
TG
870
871 darwin_send_reply (inf, thread);
872 thread->msg_state = DARWIN_RUNNING;
873 break;
874
875 case DARWIN_RUNNING:
876 break;
877
878 case DARWIN_STOPPED:
879 kret = thread_resume (thread->gdb_port);
880 MACH_CHECK_ERROR (kret);
881
882 thread->msg_state = DARWIN_RUNNING;
883 break;
a80b95ba 884 }
bb00b29d 885}
a80b95ba 886
bb00b29d 887/* Resume all threads of the inferior. */
a80b95ba 888
bb00b29d
TG
889static void
890darwin_resume_inferior_threads (struct inferior *inf, int step, int nsignal)
891{
892 darwin_thread_t *thread;
893 int k;
894
895 for (k = 0;
fe978cb0 896 VEC_iterate (darwin_thread_t, inf->priv->threads, k, thread);
bb00b29d
TG
897 k++)
898 darwin_resume_thread (inf, thread, step, nsignal);
a80b95ba
TG
899}
900
bb00b29d 901struct resume_inferior_threads_param
a80b95ba 902{
bb00b29d
TG
903 int step;
904 int nsignal;
905};
906
907static int
908darwin_resume_inferior_threads_it (struct inferior *inf, void *param)
909{
910 int step = ((struct resume_inferior_threads_param *)param)->step;
911 int nsignal = ((struct resume_inferior_threads_param *)param)->nsignal;
912
913 darwin_resume_inferior_threads (inf, step, nsignal);
914
915 return 0;
916}
917
918/* Suspend all threads of INF. */
919
920static void
921darwin_suspend_inferior_threads (struct inferior *inf)
922{
923 darwin_thread_t *thread;
a80b95ba 924 kern_return_t kret;
bb00b29d
TG
925 int k;
926
927 for (k = 0;
fe978cb0 928 VEC_iterate (darwin_thread_t, inf->priv->threads, k, thread);
bb00b29d
TG
929 k++)
930 switch (thread->msg_state)
931 {
932 case DARWIN_STOPPED:
933 case DARWIN_MESSAGE:
934 break;
935 case DARWIN_RUNNING:
936 kret = thread_suspend (thread->gdb_port);
937 MACH_CHECK_ERROR (kret);
938 thread->msg_state = DARWIN_STOPPED;
939 break;
940 }
941}
a80b95ba 942
bb00b29d 943static void
2ea28649 944darwin_resume (ptid_t ptid, int step, enum gdb_signal signal)
bb00b29d
TG
945{
946 struct target_waitstatus status;
947 int pid;
a80b95ba 948
bb00b29d
TG
949 kern_return_t kret;
950 int res;
951 int nsignal;
952 struct inferior *inf;
a80b95ba 953
bb00b29d 954 inferior_debug
3eb831e0 955 (2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
bb00b29d
TG
956 ptid_get_pid (ptid), ptid_get_tid (ptid), step, signal);
957
a493e3e2 958 if (signal == GDB_SIGNAL_0)
bb00b29d
TG
959 nsignal = 0;
960 else
2ea28649 961 nsignal = gdb_signal_to_host (signal);
a80b95ba 962
bb00b29d
TG
963 /* Don't try to single step all threads. */
964 if (step)
965 ptid = inferior_ptid;
966
967 /* minus_one_ptid is RESUME_ALL. */
968 if (ptid_equal (ptid, minus_one_ptid))
a80b95ba 969 {
bb00b29d
TG
970 struct resume_inferior_threads_param param;
971
972 param.nsignal = nsignal;
973 param.step = step;
a80b95ba 974
bb00b29d
TG
975 /* Resume threads. */
976 iterate_over_inferiors (darwin_resume_inferior_threads_it, &param);
977 /* Resume tasks. */
978 iterate_over_inferiors (darwin_resume_inferior_it, NULL);
979 }
980 else
a80b95ba 981 {
c9657e70 982 struct inferior *inf = find_inferior_ptid (ptid);
bb00b29d
TG
983 long tid = ptid_get_tid (ptid);
984
985 /* Stop the inferior (should be useless). */
986 darwin_suspend_inferior (inf);
987
988 if (tid == 0)
989 darwin_resume_inferior_threads (inf, step, nsignal);
990 else
991 {
992 darwin_thread_t *thread;
993
994 /* Suspend threads of the task. */
995 darwin_suspend_inferior_threads (inf);
996
997 /* Resume the selected thread. */
998 thread = darwin_find_thread (inf, tid);
999 gdb_assert (thread);
1000 darwin_resume_thread (inf, thread, step, nsignal);
1001 }
1002
1003 /* Resume the task. */
1004 darwin_resume_inferior (inf);
a80b95ba 1005 }
bb00b29d 1006}
a80b95ba 1007
bb00b29d
TG
1008static void
1009darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
2ea28649 1010 enum gdb_signal signal)
bb00b29d
TG
1011{
1012 return darwin_resume (ptid, step, signal);
1013}
1014
1015static ptid_t
1016darwin_decode_message (mach_msg_header_t *hdr,
1017 darwin_thread_t **pthread,
1018 struct inferior **pinf,
1019 struct target_waitstatus *status)
1020{
1021 darwin_thread_t *thread;
1022 struct inferior *inf;
a80b95ba 1023
a41f2563
TG
1024 /* Exception message. 2401 == 0x961 is exc. */
1025 if (hdr->msgh_id == 2401)
a80b95ba 1026 {
bb00b29d
TG
1027 int res;
1028
1029 /* Decode message. */
1030 res = darwin_decode_exception_message (hdr, &inf, &thread);
1031
1032 if (res < 0)
a80b95ba 1033 {
bb00b29d 1034 /* Should not happen... */
c8c9911f
JB
1035 printf_unfiltered
1036 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr->msgh_id);
bb00b29d 1037 /* FIXME: send a failure reply? */
a41f2563
TG
1038 status->kind = TARGET_WAITKIND_IGNORE;
1039 return minus_one_ptid;
1040 }
1041 if (inf == NULL)
1042 {
1043 status->kind = TARGET_WAITKIND_IGNORE;
a80b95ba
TG
1044 return minus_one_ptid;
1045 }
bb00b29d
TG
1046 *pinf = inf;
1047 *pthread = thread;
fe978cb0 1048 inf->priv->pending_messages++;
a80b95ba
TG
1049
1050 status->kind = TARGET_WAITKIND_STOPPED;
bb00b29d
TG
1051 thread->msg_state = DARWIN_MESSAGE;
1052
c8c9911f 1053 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
bb00b29d
TG
1054 thread->gdb_port,
1055 unparse_exception_type (thread->event.ex_type));
a80b95ba 1056
bb00b29d 1057 switch (thread->event.ex_type)
a80b95ba
TG
1058 {
1059 case EXC_BAD_ACCESS:
4e225075 1060 status->value.sig = GDB_EXC_BAD_ACCESS;
a80b95ba
TG
1061 break;
1062 case EXC_BAD_INSTRUCTION:
4e225075 1063 status->value.sig = GDB_EXC_BAD_INSTRUCTION;
a80b95ba
TG
1064 break;
1065 case EXC_ARITHMETIC:
4e225075 1066 status->value.sig = GDB_EXC_ARITHMETIC;
a80b95ba
TG
1067 break;
1068 case EXC_EMULATION:
4e225075 1069 status->value.sig = GDB_EXC_EMULATION;
a80b95ba
TG
1070 break;
1071 case EXC_SOFTWARE:
bb00b29d 1072 if (thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
a80b95ba 1073 {
bb00b29d 1074 status->value.sig =
2ea28649 1075 gdb_signal_from_host (thread->event.ex_data[1]);
bb00b29d
TG
1076 inferior_debug (5, _(" (signal %d: %s)\n"),
1077 thread->event.ex_data[1],
2ea28649 1078 gdb_signal_to_name (status->value.sig));
bb00b29d
TG
1079
1080 /* If the thread is stopped because it has received a signal
1081 that gdb has just sent, continue. */
1082 if (thread->signaled)
1083 {
1084 thread->signaled = 0;
1085 darwin_send_reply (inf, thread);
1086 thread->msg_state = DARWIN_RUNNING;
1087 status->kind = TARGET_WAITKIND_IGNORE;
1088 }
a80b95ba
TG
1089 }
1090 else
4e225075 1091 status->value.sig = GDB_EXC_SOFTWARE;
a80b95ba
TG
1092 break;
1093 case EXC_BREAKPOINT:
1094 /* Many internal GDB routines expect breakpoints to be reported
4e225075 1095 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
0963b4bd 1096 as a spurious signal. */
a493e3e2 1097 status->value.sig = GDB_SIGNAL_TRAP;
a80b95ba
TG
1098 break;
1099 default:
a493e3e2 1100 status->value.sig = GDB_SIGNAL_UNKNOWN;
a80b95ba
TG
1101 break;
1102 }
1103
bb00b29d
TG
1104 return ptid_build (inf->pid, 0, thread->gdb_port);
1105 }
a41f2563 1106 else if (hdr->msgh_id == 0x48)
bb00b29d 1107 {
a41f2563 1108 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
82b19a4d
TG
1109 int res;
1110
1111 res = darwin_decode_notify_message (hdr, &inf);
1112
1113 if (res < 0)
1114 {
1115 /* Should not happen... */
1116 printf_unfiltered
1117 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1118 hdr->msgh_id, res);
1119 }
1120
a41f2563
TG
1121 *pinf = NULL;
1122 *pthread = NULL;
bb00b29d 1123
82b19a4d
TG
1124 if (res < 0 || inf == NULL)
1125 {
1126 status->kind = TARGET_WAITKIND_IGNORE;
1127 return minus_one_ptid;
1128 }
1129
a41f2563
TG
1130 if (inf != NULL)
1131 {
fe978cb0 1132 if (!inf->priv->no_ptrace)
bb00b29d 1133 {
a41f2563
TG
1134 pid_t res;
1135 int wstatus;
1136
1137 res = wait4 (inf->pid, &wstatus, 0, NULL);
1138 if (res < 0 || res != inf->pid)
1139 {
1140 printf_unfiltered (_("wait4: res=%d: %s\n"),
1141 res, safe_strerror (errno));
1142 status->kind = TARGET_WAITKIND_IGNORE;
1143 return minus_one_ptid;
1144 }
1145 if (WIFEXITED (wstatus))
1146 {
1147 status->kind = TARGET_WAITKIND_EXITED;
1148 status->value.integer = WEXITSTATUS (wstatus);
1149 }
1150 else
1151 {
1152 status->kind = TARGET_WAITKIND_SIGNALLED;
5ae00552 1153 status->value.sig = gdb_signal_from_host (WTERMSIG (wstatus));
a41f2563
TG
1154 }
1155
1156 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1157 res, wstatus);
1158
1159 /* Looks necessary on Leopard and harmless... */
1160 wait4 (inf->pid, &wstatus, 0, NULL);
1161
82b19a4d
TG
1162 inferior_ptid = ptid_build (inf->pid, 0, 0);
1163 return inferior_ptid;
bb00b29d
TG
1164 }
1165 else
1166 {
a41f2563
TG
1167 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf->pid);
1168 status->kind = TARGET_WAITKIND_EXITED;
1169 status->value.integer = 0; /* Don't know. */
1170 return ptid_build (inf->pid, 0, 0);
bb00b29d 1171 }
bb00b29d
TG
1172 }
1173 }
1174
a41f2563 1175 /* Unknown message. */
86ad98c3 1176 warning (_("darwin: got unknown message, id: 0x%x"), hdr->msgh_id);
a41f2563 1177 status->kind = TARGET_WAITKIND_IGNORE;
bb00b29d
TG
1178 return minus_one_ptid;
1179}
1180
1181static int
1182cancel_breakpoint (ptid_t ptid)
1183{
0963b4bd 1184 /* Arrange for a breakpoint to be hit again later. We will handle
bb00b29d
TG
1185 the current event, eventually we will resume this thread, and this
1186 breakpoint will trap again.
1187
1188 If we do not do this, then we run the risk that the user will
1189 delete or disable the breakpoint, but the thread will have already
1190 tripped on it. */
1191
1192 struct regcache *regcache = get_thread_regcache (ptid);
ac7936df 1193 struct gdbarch *gdbarch = regcache->arch ();
bb00b29d 1194 CORE_ADDR pc;
a80b95ba 1195
527a273a 1196 pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
a01bda52 1197 if (breakpoint_inserted_here_p (regcache->aspace (), pc))
bb00b29d 1198 {
3eb831e0
TG
1199 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1200 (unsigned long) ptid_get_tid (ptid));
bb00b29d
TG
1201
1202 /* Back up the PC if necessary. */
527a273a 1203 if (gdbarch_decr_pc_after_break (gdbarch))
bb00b29d
TG
1204 regcache_write_pc (regcache, pc);
1205
1206 return 1;
a80b95ba 1207 }
bb00b29d
TG
1208 return 0;
1209}
1210
1211static ptid_t
1212darwin_wait (ptid_t ptid, struct target_waitstatus *status)
1213{
1214 kern_return_t kret;
1215 union
1216 {
1217 mach_msg_header_t hdr;
1218 char data[0x100];
1219 } msgin;
1220 mach_msg_header_t *hdr = &msgin.hdr;
1221 ptid_t res;
1222 darwin_thread_t *thread;
1223 struct inferior *inf;
1224
1225 inferior_debug
1226 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1227 ptid_get_pid (ptid), ptid_get_tid (ptid));
1228
1229 /* Handle fake stop events at first. */
1230 if (darwin_inf_fake_stop != NULL)
1231 {
1232 inf = darwin_inf_fake_stop;
1233 darwin_inf_fake_stop = NULL;
1234
1235 status->kind = TARGET_WAITKIND_STOPPED;
a493e3e2 1236 status->value.sig = GDB_SIGNAL_TRAP;
fe978cb0 1237 thread = VEC_index (darwin_thread_t, inf->priv->threads, 0);
bb00b29d
TG
1238 thread->msg_state = DARWIN_STOPPED;
1239 return ptid_build (inf->pid, 0, thread->gdb_port);
1240 }
1241
1242 do
1243 {
1244 /* set_sigint_trap (); */
1245
1246 /* Wait for a message. */
1247 kret = mach_msg (&msgin.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT, 0,
1248 sizeof (msgin.data), darwin_port_set, 0, MACH_PORT_NULL);
1249
1250 /* clear_sigint_trap (); */
1251
1252 if (kret == MACH_RCV_INTERRUPTED)
1253 {
1254 status->kind = TARGET_WAITKIND_IGNORE;
1255 return minus_one_ptid;
1256 }
1257
1258 if (kret != MACH_MSG_SUCCESS)
1259 {
c8c9911f 1260 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret);
bb00b29d
TG
1261 status->kind = TARGET_WAITKIND_SPURIOUS;
1262 return minus_one_ptid;
1263 }
1264
1265 /* Debug: display message. */
1266 if (darwin_debug_flag > 10)
1267 darwin_dump_message (hdr, darwin_debug_flag > 11);
1268
1269 res = darwin_decode_message (hdr, &thread, &inf, status);
a41f2563
TG
1270 if (ptid_equal (res, minus_one_ptid))
1271 continue;
bb00b29d 1272
a41f2563 1273 /* Early return in case an inferior has exited. */
bb00b29d
TG
1274 if (inf == NULL)
1275 return res;
1276 }
1277 while (status->kind == TARGET_WAITKIND_IGNORE);
1278
1279 /* Stop all tasks. */
1280 iterate_over_inferiors (darwin_suspend_inferior_it, NULL);
1281
1282 /* Read pending messages. */
1283 while (1)
a80b95ba 1284 {
bb00b29d
TG
1285 struct target_waitstatus status2;
1286 ptid_t ptid2;
1287
1288 kret = mach_msg (&msgin.hdr,
1289 MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0,
1290 sizeof (msgin.data), darwin_port_set, 1, MACH_PORT_NULL);
1291
1292 if (kret == MACH_RCV_TIMED_OUT)
1293 break;
1294 if (kret != MACH_MSG_SUCCESS)
1295 {
1296 inferior_debug
c8c9911f 1297 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret);
bb00b29d
TG
1298 break;
1299 }
1300
a41f2563
TG
1301 /* Debug: display message. */
1302 if (darwin_debug_flag > 10)
1303 darwin_dump_message (hdr, darwin_debug_flag > 11);
1304
bb00b29d 1305 ptid2 = darwin_decode_message (hdr, &thread, &inf, &status2);
a80b95ba 1306
bb00b29d
TG
1307 if (inf != NULL && thread != NULL
1308 && thread->event.ex_type == EXC_BREAKPOINT)
a80b95ba 1309 {
bb00b29d
TG
1310 if (thread->single_step
1311 || cancel_breakpoint (ptid_build (inf->pid, 0, thread->gdb_port)))
1312 {
1313 gdb_assert (thread->msg_state == DARWIN_MESSAGE);
1314 darwin_send_reply (inf, thread);
1315 thread->msg_state = DARWIN_RUNNING;
1316 }
1317 else
1318 inferior_debug
c8c9911f 1319 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
bb00b29d 1320 thread->gdb_port);
a80b95ba 1321 }
bb00b29d
TG
1322 else
1323 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1324 }
1325 return res;
1326}
a80b95ba 1327
bb00b29d 1328static ptid_t
a6290449 1329darwin_wait_to (struct target_ops *ops,
bb00b29d
TG
1330 ptid_t ptid, struct target_waitstatus *status, int options)
1331{
1332 return darwin_wait (ptid, status);
1333}
a80b95ba 1334
bb00b29d 1335static void
bfedc46a 1336darwin_interrupt (struct target_ops *self, ptid_t t)
bb00b29d
TG
1337{
1338 struct inferior *inf = current_inferior ();
a80b95ba 1339
bb00b29d 1340 /* FIXME: handle in no_ptrace mode. */
fe978cb0 1341 gdb_assert (!inf->priv->no_ptrace);
bb00b29d 1342 kill (inf->pid, SIGINT);
a80b95ba
TG
1343}
1344
82b19a4d
TG
1345/* Deallocate threads port and vector. */
1346
a80b95ba 1347static void
82b19a4d 1348darwin_deallocate_threads (struct inferior *inf)
a80b95ba 1349{
fe978cb0 1350 if (inf->priv->threads)
a80b95ba 1351 {
82b19a4d 1352 kern_return_t kret;
a80b95ba 1353 int k;
bb00b29d
TG
1354 darwin_thread_t *t;
1355 for (k = 0;
fe978cb0 1356 VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
bb00b29d 1357 k++)
a80b95ba 1358 {
bb00b29d 1359 kret = mach_port_deallocate (gdb_task, t->gdb_port);
a80b95ba
TG
1360 MACH_CHECK_ERROR (kret);
1361 }
fe978cb0
PA
1362 VEC_free (darwin_thread_t, inf->priv->threads);
1363 inf->priv->threads = NULL;
a80b95ba 1364 }
82b19a4d 1365}
a80b95ba 1366
82b19a4d
TG
1367static void
1368darwin_mourn_inferior (struct target_ops *ops)
1369{
1370 struct inferior *inf = current_inferior ();
1371 kern_return_t kret;
1372 mach_port_t prev;
1373 int i;
1374
1375 /* Deallocate threads. */
1376 darwin_deallocate_threads (inf);
1377
1378 /* Remove notify_port from darwin_port_set. */
bb00b29d 1379 kret = mach_port_move_member (gdb_task,
fe978cb0 1380 inf->priv->notify_port, MACH_PORT_NULL);
fda184b6 1381 MACH_CHECK_ERROR (kret);
bb00b29d 1382
82b19a4d 1383 /* Remove task port dead_name notification. */
fe978cb0 1384 kret = mach_port_request_notification (gdb_task, inf->priv->task,
a80b95ba 1385 MACH_NOTIFY_DEAD_NAME, 0,
bb00b29d 1386 MACH_PORT_NULL,
a80b95ba
TG
1387 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1388 &prev);
1389 /* This can fail if the task is dead. */
c8c9911f 1390 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
fe978cb0 1391 inf->priv->task, prev, inf->priv->notify_port);
bb00b29d 1392
a80b95ba
TG
1393 if (kret == KERN_SUCCESS)
1394 {
1395 kret = mach_port_deallocate (gdb_task, prev);
1396 MACH_CHECK_ERROR (kret);
1397 }
1398
82b19a4d 1399 /* Destroy notify_port. */
fe978cb0 1400 kret = mach_port_destroy (gdb_task, inf->priv->notify_port);
bb00b29d
TG
1401 MACH_CHECK_ERROR (kret);
1402
a80b95ba 1403 /* Deallocate saved exception ports. */
82b19a4d 1404 darwin_deallocate_exception_ports (inf->priv);
a80b95ba 1405
82b19a4d 1406 /* Deallocate task port. */
fe978cb0 1407 kret = mach_port_deallocate (gdb_task, inf->priv->task);
a80b95ba
TG
1408 MACH_CHECK_ERROR (kret);
1409
fe978cb0
PA
1410 xfree (inf->priv);
1411 inf->priv = NULL;
a80b95ba 1412
c1ee2fb3 1413 inf_child_mourn_inferior (ops);
a80b95ba
TG
1414}
1415
1416static void
bb00b29d 1417darwin_reply_to_all_pending_messages (struct inferior *inf)
a80b95ba 1418{
bb00b29d
TG
1419 int k;
1420 darwin_thread_t *t;
a80b95ba 1421
bb00b29d 1422 for (k = 0;
fe978cb0 1423 VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
bb00b29d
TG
1424 k++)
1425 {
1426 if (t->msg_state == DARWIN_MESSAGE)
1427 darwin_resume_thread (inf, t, 0, 0);
1428 }
a80b95ba
TG
1429}
1430
1431static void
bb00b29d 1432darwin_stop_inferior (struct inferior *inf)
a80b95ba
TG
1433{
1434 struct target_waitstatus wstatus;
1435 ptid_t ptid;
1436 kern_return_t kret;
1437 int status;
1438 int res;
1439
bb00b29d 1440 gdb_assert (inf != NULL);
a80b95ba 1441
bb00b29d 1442 darwin_suspend_inferior (inf);
a80b95ba 1443
bb00b29d 1444 darwin_reply_to_all_pending_messages (inf);
a80b95ba 1445
fe978cb0 1446 if (inf->priv->no_ptrace)
bb00b29d 1447 return;
a80b95ba 1448
bb00b29d
TG
1449 res = kill (inf->pid, SIGSTOP);
1450 if (res != 0)
b37520b6 1451 warning (_("cannot kill: %s"), safe_strerror (errno));
a80b95ba 1452
bb00b29d
TG
1453 /* Wait until the process is really stopped. */
1454 while (1)
a80b95ba 1455 {
bb00b29d
TG
1456 ptid = darwin_wait (inferior_ptid, &wstatus);
1457 if (wstatus.kind == TARGET_WAITKIND_STOPPED
a493e3e2 1458 && wstatus.value.sig == GDB_SIGNAL_STOP)
bb00b29d 1459 break;
a80b95ba
TG
1460 }
1461}
1462
1463static kern_return_t
1464darwin_save_exception_ports (darwin_inferior *inf)
1465{
1466 kern_return_t kret;
1467
1468 inf->exception_info.count =
1469 sizeof (inf->exception_info.ports) / sizeof (inf->exception_info.ports[0]);
1470
1471 kret = task_get_exception_ports
1472 (inf->task, EXC_MASK_ALL, inf->exception_info.masks,
1473 &inf->exception_info.count, inf->exception_info.ports,
1474 inf->exception_info.behaviors, inf->exception_info.flavors);
1475 return kret;
1476}
1477
1478static kern_return_t
1479darwin_restore_exception_ports (darwin_inferior *inf)
1480{
1481 int i;
1482 kern_return_t kret;
1483
1484 for (i = 0; i < inf->exception_info.count; i++)
1485 {
1486 kret = task_set_exception_ports
1487 (inf->task, inf->exception_info.masks[i], inf->exception_info.ports[i],
1488 inf->exception_info.behaviors[i], inf->exception_info.flavors[i]);
1489 if (kret != KERN_SUCCESS)
1490 return kret;
1491 }
1492
1493 return KERN_SUCCESS;
1494}
1495
82b19a4d
TG
1496/* Deallocate saved exception ports. */
1497
1498static void
1499darwin_deallocate_exception_ports (darwin_inferior *inf)
1500{
1501 int i;
1502 kern_return_t kret;
1503
1504 for (i = 0; i < inf->exception_info.count; i++)
1505 {
1506 kret = mach_port_deallocate (gdb_task, inf->exception_info.ports[i]);
1507 MACH_CHECK_ERROR (kret);
1508 }
1509 inf->exception_info.count = 0;
1510}
1511
1512static void
1513darwin_setup_exceptions (struct inferior *inf)
1514{
1515 kern_return_t kret;
1516 int traps_expected;
1517 exception_mask_t mask;
1518
1519 kret = darwin_save_exception_ports (inf->priv);
1520 if (kret != KERN_SUCCESS)
1521 error (_("Unable to save exception ports, task_get_exception_ports"
1522 "returned: %d"),
1523 kret);
1524
1525 /* Set exception port. */
1526 if (enable_mach_exceptions)
1527 mask = EXC_MASK_ALL;
1528 else
1529 mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
1530 kret = task_set_exception_ports (inf->priv->task, mask, darwin_ex_port,
1531 EXCEPTION_DEFAULT, THREAD_STATE_NONE);
1532 if (kret != KERN_SUCCESS)
1533 error (_("Unable to set exception ports, task_set_exception_ports"
1534 "returned: %d"),
1535 kret);
1536}
1537
a80b95ba 1538static void
bb00b29d
TG
1539darwin_kill_inferior (struct target_ops *ops)
1540{
1541 struct inferior *inf = current_inferior ();
1542 struct target_waitstatus wstatus;
1543 ptid_t ptid;
1544 kern_return_t kret;
1545 int status;
1546 int res;
1547
1548 if (ptid_equal (inferior_ptid, null_ptid))
1549 return;
1550
1551 gdb_assert (inf != NULL);
1552
fe978cb0 1553 kret = darwin_restore_exception_ports (inf->priv);
ee41036f 1554 MACH_CHECK_ERROR (kret);
bb00b29d 1555
ee41036f 1556 darwin_reply_to_all_pending_messages (inf);
bb00b29d 1557
ee41036f 1558 res = kill (inf->pid, 9);
bb00b29d 1559
ee41036f 1560 if (res == 0)
bb00b29d 1561 {
bb00b29d 1562 darwin_resume_inferior (inf);
a6290449 1563
bb00b29d
TG
1564 ptid = darwin_wait (inferior_ptid, &wstatus);
1565 }
ee41036f
TG
1566 else if (errno != ESRCH)
1567 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1568 inf->pid, safe_strerror (errno));
bb00b29d 1569
bc1e6c81 1570 target_mourn_inferior (inferior_ptid);
bb00b29d
TG
1571}
1572
82b19a4d
TG
1573static void
1574darwin_setup_request_notification (struct inferior *inf)
1575{
1576 kern_return_t kret;
1577 mach_port_t prev_not;
1578
1579 kret = mach_port_request_notification (gdb_task, inf->priv->task,
1580 MACH_NOTIFY_DEAD_NAME, 0,
1581 inf->priv->notify_port,
1582 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1583 &prev_not);
1584 if (kret != KERN_SUCCESS)
1585 error (_("Termination notification request failed, "
1586 "mach_port_request_notification\n"
1587 "returned: %d"),
1588 kret);
1589 if (prev_not != MACH_PORT_NULL)
1590 {
1591 /* This is unexpected, as there should not be any previously
1592 registered notification request. But this is not a fatal
1593 issue, so just emit a warning. */
1594 warning (_("\
1595A task termination request was registered before the debugger registered\n\
1596its own. This is unexpected, but should otherwise not have any actual\n\
1597impact on the debugging session."));
1598 }
1599}
1600
bb00b29d
TG
1601static void
1602darwin_attach_pid (struct inferior *inf)
a80b95ba 1603{
a80b95ba
TG
1604 kern_return_t kret;
1605 mach_port_t prev_port;
1606 int traps_expected;
bb00b29d 1607 mach_port_t prev_not;
a80b95ba
TG
1608 exception_mask_t mask;
1609
fe978cb0 1610 inf->priv = XCNEW (darwin_inferior);
bb00b29d 1611
fe978cb0 1612 kret = task_for_pid (gdb_task, inf->pid, &inf->priv->task);
a80b95ba
TG
1613 if (kret != KERN_SUCCESS)
1614 {
1615 int status;
a80b95ba
TG
1616
1617 if (!inf->attach_flag)
1618 {
bb00b29d
TG
1619 kill (inf->pid, 9);
1620 waitpid (inf->pid, &status, 0);
a80b95ba
TG
1621 }
1622
1623 error (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
15c19d39 1624 " (please check gdb is codesigned - see taskgated(8))"),
bb00b29d 1625 inf->pid, mach_error_string (kret), (unsigned long) kret);
a80b95ba
TG
1626 }
1627
bb00b29d 1628 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
fe978cb0 1629 inf->priv->task, inf->pid);
a80b95ba
TG
1630
1631 if (darwin_ex_port == MACH_PORT_NULL)
1632 {
1633 /* Create a port to get exceptions. */
1634 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1635 &darwin_ex_port);
fda184b6
JB
1636 if (kret != KERN_SUCCESS)
1637 error (_("Unable to create exception port, mach_port_allocate "
1638 "returned: %d"),
1639 kret);
a80b95ba
TG
1640
1641 kret = mach_port_insert_right (gdb_task, darwin_ex_port, darwin_ex_port,
1642 MACH_MSG_TYPE_MAKE_SEND);
fda184b6
JB
1643 if (kret != KERN_SUCCESS)
1644 error (_("Unable to create exception port, mach_port_insert_right "
1645 "returned: %d"),
1646 kret);
a80b95ba
TG
1647
1648 /* Create a port set and put ex_port in it. */
1649 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
1650 &darwin_port_set);
fda184b6
JB
1651 if (kret != KERN_SUCCESS)
1652 error (_("Unable to create port set, mach_port_allocate "
1653 "returned: %d"),
1654 kret);
a80b95ba
TG
1655
1656 kret = mach_port_move_member (gdb_task, darwin_ex_port, darwin_port_set);
fda184b6
JB
1657 if (kret != KERN_SUCCESS)
1658 error (_("Unable to move exception port into new port set, "
1659 "mach_port_move_member\n"
1660 "returned: %d"),
1661 kret);
bb00b29d 1662 }
a80b95ba 1663
bb00b29d
TG
1664 /* Create a port to be notified when the child task terminates. */
1665 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
fe978cb0 1666 &inf->priv->notify_port);
fda184b6
JB
1667 if (kret != KERN_SUCCESS)
1668 error (_("Unable to create notification port, mach_port_allocate "
1669 "returned: %d"),
1670 kret);
a80b95ba 1671
bb00b29d 1672 kret = mach_port_move_member (gdb_task,
fe978cb0 1673 inf->priv->notify_port, darwin_port_set);
fda184b6
JB
1674 if (kret != KERN_SUCCESS)
1675 error (_("Unable to move notification port into new port set, "
1676 "mach_port_move_member\n"
1677 "returned: %d"),
1678 kret);
a80b95ba 1679
82b19a4d 1680 darwin_setup_request_notification (inf);
a80b95ba 1681
82b19a4d 1682 darwin_setup_exceptions (inf);
a80b95ba 1683
6a3cb8e8
PA
1684 if (!target_is_pushed (darwin_ops))
1685 push_target (darwin_ops);
a80b95ba
TG
1686}
1687
db665f42
SM
1688/* Get the thread_info object corresponding to this private_thread_info. */
1689
1690static struct thread_info *
1691thread_info_from_private_thread_info (private_thread_info *pti)
1692{
1693 struct thread_info *it;
1694
1695 ALL_THREADS (it)
1696 {
1697 if (it->priv->gdb_port == pti->gdb_port)
1698 break;
1699 }
1700
1701 gdb_assert (it != NULL);
1702
1703 return it;
1704}
1705
a80b95ba 1706static void
bb00b29d 1707darwin_init_thread_list (struct inferior *inf)
a80b95ba 1708{
a80b95ba
TG
1709 darwin_check_new_threads (inf);
1710
db665f42
SM
1711 gdb_assert (inf->priv->threads != NULL);
1712 gdb_assert (VEC_length (darwin_thread_t, inf->priv->threads) > 0);
bb00b29d 1713
db665f42
SM
1714 private_thread_info *first_pti
1715 = VEC_index (darwin_thread_t, inf->priv->threads, 0);
1716 struct thread_info *first_thread
1717 = thread_info_from_private_thread_info (first_pti);
1718
1719 inferior_ptid = first_thread->ptid;
bb00b29d
TG
1720}
1721
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 ? */
1725static int ptrace_fds[2];
1726
1727static void
1728darwin_ptrace_me (void)
1729{
1730 int res;
1731 char c;
1732
1733 /* Close write end point. */
0db8980c
SDJ
1734 if (close (ptrace_fds[1]) < 0)
1735 trace_start_error_with_name ("close");
bb00b29d
TG
1736
1737 /* Wait until gdb is ready. */
1738 res = read (ptrace_fds[0], &c, 1);
fda184b6 1739 if (res != 0)
0db8980c
SDJ
1740 trace_start_error (_("unable to read from pipe, read returned: %d"), res);
1741
1742 if (close (ptrace_fds[0]) < 0)
1743 trace_start_error_with_name ("close");
bb00b29d
TG
1744
1745 /* Get rid of privileges. */
0db8980c
SDJ
1746 if (setegid (getgid ()) < 0)
1747 trace_start_error_with_name ("setegid");
bb00b29d
TG
1748
1749 /* Set TRACEME. */
0db8980c
SDJ
1750 if (PTRACE (PT_TRACE_ME, 0, 0, 0) < 0)
1751 trace_start_error_with_name ("PTRACE");
bb00b29d
TG
1752
1753 /* Redirect signals to exception port. */
0db8980c
SDJ
1754 if (PTRACE (PT_SIGEXC, 0, 0, 0) < 0)
1755 trace_start_error_with_name ("PTRACE");
bb00b29d
TG
1756}
1757
1758/* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1759static void
1760darwin_pre_ptrace (void)
1761{
1762 if (pipe (ptrace_fds) != 0)
1763 {
1764 ptrace_fds[0] = -1;
1765 ptrace_fds[1] = -1;
1766 error (_("unable to create a pipe: %s"), safe_strerror (errno));
1767 }
21ff4686
TT
1768
1769 mark_fd_no_cloexec (ptrace_fds[0]);
1770 mark_fd_no_cloexec (ptrace_fds[1]);
a80b95ba
TG
1771}
1772
1773static void
1774darwin_ptrace_him (int pid)
1775{
1776 task_t itask;
1777 kern_return_t kret;
1778 mach_port_t prev_port;
1779 int traps_expected;
bb00b29d 1780 struct inferior *inf = current_inferior ();
a80b95ba 1781
bb00b29d 1782 darwin_attach_pid (inf);
a80b95ba
TG
1783
1784 /* Let's the child run. */
1785 close (ptrace_fds[0]);
1786 close (ptrace_fds[1]);
1787
21ff4686
TT
1788 unmark_fd_no_cloexec (ptrace_fds[0]);
1789 unmark_fd_no_cloexec (ptrace_fds[1]);
1790
bb00b29d
TG
1791 darwin_init_thread_list (inf);
1792
2090129c 1793 gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
a80b95ba
TG
1794}
1795
e69860f1
TG
1796static void
1797darwin_execvp (const char *file, char * const argv[], char * const env[])
1798{
1799 posix_spawnattr_t attr;
1800 short ps_flags = 0;
f00c55f8 1801 int res;
e69860f1 1802
f00c55f8
TG
1803 res = posix_spawnattr_init (&attr);
1804 if (res != 0)
e69860f1
TG
1805 {
1806 fprintf_unfiltered
1807 (gdb_stderr, "Cannot initialize attribute for posix_spawn\n");
1808 return;
1809 }
1810
1811 /* Do like execve: replace the image. */
1812 ps_flags = POSIX_SPAWN_SETEXEC;
1813
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
1818#endif
1819 ps_flags |= _POSIX_SPAWN_DISABLE_ASLR;
f00c55f8
TG
1820 res = posix_spawnattr_setflags (&attr, ps_flags);
1821 if (res != 0)
e69860f1 1822 {
f00c55f8 1823 fprintf_unfiltered (gdb_stderr, "Cannot set posix_spawn flags\n");
e69860f1
TG
1824 return;
1825 }
1826
1827 posix_spawnp (NULL, argv[0], NULL, &attr, argv, env);
1828}
1829
a80b95ba 1830static void
7c5ded6a
SDJ
1831darwin_create_inferior (struct target_ops *ops,
1832 const char *exec_file,
1833 const std::string &allargs,
1834 char **env, int from_tty)
a80b95ba
TG
1835{
1836 /* Do the hard work. */
db665f42
SM
1837 fork_inferior (exec_file, allargs, env, darwin_ptrace_me,
1838 darwin_ptrace_him, darwin_pre_ptrace, NULL,
1839 darwin_execvp);
a80b95ba
TG
1840}
1841\f
1842
726ce67c
JB
1843/* Set things up such that the next call to darwin_wait will immediately
1844 return a fake stop event for inferior INF.
1845
1846 This assumes that the inferior's thread list has been initialized,
1847 as it will suspend the inferior's first thread. */
1848
1849static void
1850darwin_setup_fake_stop_event (struct inferior *inf)
1851{
1852 darwin_thread_t *thread;
1853 kern_return_t kret;
1854
1855 gdb_assert (darwin_inf_fake_stop == NULL);
1856 darwin_inf_fake_stop = inf;
1857
1858 /* When detecting a fake pending stop event, darwin_wait returns
1859 an event saying that the first thread is in a DARWIN_STOPPED
1860 state. To make that accurate, we need to suspend that thread
1861 as well. Otherwise, we'll try resuming it when resuming the
1862 inferior, and get a warning because the thread's suspend count
1863 is already zero, making the resume request useless. */
fe978cb0 1864 thread = VEC_index (darwin_thread_t, inf->priv->threads, 0);
726ce67c
JB
1865 kret = thread_suspend (thread->gdb_port);
1866 MACH_CHECK_ERROR (kret);
1867}
1868
a80b95ba
TG
1869/* Attach to process PID, then initialize for debugging it
1870 and wait for the trace-trap that results from attaching. */
1871static void
c0939df1 1872darwin_attach (struct target_ops *ops, const char *args, int from_tty)
a80b95ba
TG
1873{
1874 pid_t pid;
1875 pid_t pid2;
1876 int wstatus;
1877 int res;
1878 struct inferior *inf;
bb00b29d 1879 kern_return_t kret;
a80b95ba 1880
74164c56 1881 pid = parse_pid_to_attach (args);
a80b95ba 1882
74164c56 1883 if (pid == getpid ()) /* Trying to masturbate? */
a80b95ba
TG
1884 error (_("I refuse to debug myself!"));
1885
1886 if (from_tty)
bb00b29d
TG
1887 {
1888 char *exec_file = get_exec_file (0);
a80b95ba 1889
bb00b29d
TG
1890 if (exec_file)
1891 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
1892 target_pid_to_str (pid_to_ptid (pid)));
1893 else
1894 printf_unfiltered (_("Attaching to %s\n"),
1895 target_pid_to_str (pid_to_ptid (pid)));
1896
1897 gdb_flush (gdb_stdout);
1898 }
1899
1900 if (pid == 0 || kill (pid, 0) < 0)
1901 error (_("Can't attach to process %d: %s (%d)"),
1902 pid, safe_strerror (errno), errno);
a80b95ba 1903
bb00b29d 1904 inferior_ptid = pid_to_ptid (pid);
6c95b8df
PA
1905 inf = current_inferior ();
1906 inferior_appeared (inf, pid);
a80b95ba 1907 inf->attach_flag = 1;
6c95b8df 1908
bb00b29d 1909 darwin_attach_pid (inf);
a80b95ba 1910
bb00b29d 1911 darwin_suspend_inferior (inf);
a80b95ba 1912
bb00b29d 1913 darwin_init_thread_list (inf);
a80b95ba 1914
fe978cb0 1915 darwin_check_osabi (inf->priv, ptid_get_tid (inferior_ptid));
a80b95ba 1916
726ce67c
JB
1917 darwin_setup_fake_stop_event (inf);
1918
fe978cb0 1919 inf->priv->no_ptrace = 1;
a80b95ba
TG
1920}
1921
1922/* Take a program previously attached to and detaches it.
1923 The program resumes execution and will no longer stop
1924 on signals, etc. We'd better not have left any breakpoints
1925 in the program or it'll die when it hits one. For this
1926 to work, it may be necessary for the process to have been
1927 previously attached. It *might* work if the program was
1928 started via fork. */
1929static void
52554a0e 1930darwin_detach (struct target_ops *ops, const char *args, int from_tty)
a80b95ba 1931{
bb00b29d
TG
1932 pid_t pid = ptid_get_pid (inferior_ptid);
1933 struct inferior *inf = current_inferior ();
a80b95ba
TG
1934 kern_return_t kret;
1935 int res;
1936
bb00b29d 1937 /* Display message. */
0f48b757 1938 target_announce_detach (from_tty);
a80b95ba 1939
bb00b29d 1940 /* If ptrace() is in use, stop the process. */
fe978cb0 1941 if (!inf->priv->no_ptrace)
bb00b29d 1942 darwin_stop_inferior (inf);
a80b95ba 1943
fe978cb0 1944 kret = darwin_restore_exception_ports (inf->priv);
a80b95ba
TG
1945 MACH_CHECK_ERROR (kret);
1946
fe978cb0 1947 if (!inf->priv->no_ptrace)
a80b95ba 1948 {
bb00b29d
TG
1949 res = PTRACE (PT_DETACH, inf->pid, 0, 0);
1950 if (res != 0)
1951 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1952 inf->pid, safe_strerror (errno), errno);
a80b95ba
TG
1953 }
1954
bb00b29d 1955 darwin_reply_to_all_pending_messages (inf);
a80b95ba 1956
5e9bc145
JB
1957 /* When using ptrace, we have just performed a PT_DETACH, which
1958 resumes the inferior. On the other hand, when we are not using
1959 ptrace, we need to resume its execution ourselves. */
fe978cb0 1960 if (inf->priv->no_ptrace)
5e9bc145 1961 darwin_resume_inferior (inf);
a80b95ba
TG
1962
1963 darwin_mourn_inferior (ops);
1964}
1965
1966static void
1967darwin_files_info (struct target_ops *ops)
1968{
a80b95ba
TG
1969}
1970
7a114964 1971static const char *
117de6a9 1972darwin_pid_to_str (struct target_ops *ops, ptid_t ptid)
a80b95ba 1973{
bb00b29d
TG
1974 static char buf[80];
1975 long tid = ptid_get_tid (ptid);
1976
1977 if (tid != 0)
1978 {
1979 snprintf (buf, sizeof (buf), _("Thread 0x%lx of process %u"),
1980 tid, ptid_get_pid (ptid));
1981 return buf;
1982 }
a80b95ba 1983
bb00b29d 1984 return normal_pid_to_str (ptid);
a80b95ba
TG
1985}
1986
1987static int
28439f5e 1988darwin_thread_alive (struct target_ops *ops, ptid_t ptid)
a80b95ba
TG
1989{
1990 return 1;
1991}
1992
1993/* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
1994 copy it to RDADDR in gdb's address space.
1995 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
1996 to ADDR in inferior task's address space.
f00c55f8 1997 Return 0 on failure; number of bytes read / writen otherwise. */
3eb831e0 1998
a80b95ba
TG
1999static int
2000darwin_read_write_inferior (task_t task, CORE_ADDR addr,
b9dd1947 2001 gdb_byte *rdaddr, const gdb_byte *wraddr,
b55e14c7 2002 ULONGEST length)
a80b95ba 2003{
bb00b29d 2004 kern_return_t kret;
3eb831e0 2005 mach_vm_size_t res_length = 0;
a80b95ba 2006 pointer_t copied;
b9dd1947 2007 mach_msg_type_number_t copy_count;
a80b95ba
TG
2008 mach_vm_size_t remaining_length;
2009 mach_vm_address_t region_address;
2010 mach_vm_size_t region_length;
2011
b55e14c7
YQ
2012 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2013 task, core_addr_to_string (addr), pulongest (length));
bb00b29d 2014
3eb831e0
TG
2015 /* First read. */
2016 if (rdaddr != NULL)
a80b95ba 2017 {
3eb831e0 2018 mach_vm_size_t count;
a80b95ba 2019
3eb831e0
TG
2020 /* According to target.h(to_xfer_partial), one and only one may be
2021 non-null. */
2022 gdb_assert (wraddr == NULL);
a80b95ba 2023
3eb831e0
TG
2024 kret = mach_vm_read_overwrite (task, addr, length,
2025 (mach_vm_address_t) rdaddr, &count);
2026 if (kret != KERN_SUCCESS)
2027 {
2028 inferior_debug
2029 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2030 core_addr_to_string (addr), mach_error_string (kret));
2031 return 0;
2032 }
2033 return count;
2034 }
a80b95ba 2035
3eb831e0
TG
2036 /* See above. */
2037 gdb_assert (wraddr != NULL);
a80b95ba 2038
3eb831e0 2039 while (length != 0)
a80b95ba 2040 {
3eb831e0
TG
2041 mach_vm_address_t offset = addr & (mach_page_size - 1);
2042 mach_vm_address_t region_address = (mach_vm_address_t) (addr - offset);
2043 mach_vm_size_t aligned_length =
2044 (mach_vm_size_t) PAGE_ROUND (offset + length);
bb00b29d 2045 vm_region_submap_short_info_data_64_t info;
3eb831e0
TG
2046 mach_msg_type_number_t count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
2047 natural_t region_depth = 1000;
bb00b29d 2048 mach_vm_address_t region_start = region_address;
3eb831e0
TG
2049 mach_vm_size_t region_length;
2050 mach_vm_size_t write_length;
bb00b29d 2051
3eb831e0 2052 /* Read page protection. */
bb00b29d
TG
2053 kret = mach_vm_region_recurse
2054 (task, &region_start, &region_length, &region_depth,
2055 (vm_region_recurse_info_t) &info, &count);
2056
2057 if (kret != KERN_SUCCESS)
a80b95ba 2058 {
bb00b29d
TG
2059 inferior_debug (1, _("darwin_read_write_inferior: "
2060 "mach_vm_region_recurse failed at %s: %s\n"),
2061 core_addr_to_string (region_address),
2062 mach_error_string (kret));
3eb831e0 2063 return res_length;
a80b95ba
TG
2064 }
2065
bb00b29d
TG
2066 inferior_debug
2067 (9, _("darwin_read_write_inferior: "
2068 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2069 core_addr_to_string (region_address),
2070 core_addr_to_string (region_start),
2071 core_addr_to_string (region_length));
2072
0963b4bd 2073 /* Check for holes in memory. */
bb00b29d 2074 if (region_start > region_address)
a80b95ba 2075 {
0963b4bd 2076 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
a80b95ba 2077 core_addr_to_string (region_address),
bb00b29d 2078 core_addr_to_string (region_start),
a80b95ba 2079 (unsigned)region_length);
3eb831e0 2080 return res_length;
a80b95ba
TG
2081 }
2082
bb00b29d
TG
2083 /* Adjust the length. */
2084 region_length -= (region_address - region_start);
3eb831e0
TG
2085 if (region_length > aligned_length)
2086 region_length = aligned_length;
bb00b29d 2087
3eb831e0
TG
2088 /* Make the pages RW. */
2089 if (!(info.protection & VM_PROT_WRITE))
a80b95ba 2090 {
3eb831e0
TG
2091 vm_prot_t prot = VM_PROT_READ | VM_PROT_WRITE;
2092
2093 kret = mach_vm_protect (task, region_address, region_length,
2094 FALSE, prot);
bb00b29d
TG
2095 if (kret != KERN_SUCCESS)
2096 {
3eb831e0
TG
2097 prot |= VM_PROT_COPY;
2098 kret = mach_vm_protect (task, region_address, region_length,
2099 FALSE, prot);
2100 }
2101 if (kret != KERN_SUCCESS)
2102 {
2103 warning (_("darwin_read_write_inferior: "
2104 "mach_vm_protect failed at %s "
2105 "(len=0x%lx, prot=0x%x): %s"),
bb00b29d 2106 core_addr_to_string (region_address),
3eb831e0 2107 (unsigned long) region_length, (unsigned) prot,
bb00b29d 2108 mach_error_string (kret));
3eb831e0 2109 return res_length;
bb00b29d 2110 }
a80b95ba
TG
2111 }
2112
3eb831e0
TG
2113 if (offset + length > region_length)
2114 write_length = region_length - offset;
2115 else
2116 write_length = length;
2117
2118 /* Write. */
2119 kret = mach_vm_write (task, addr, (vm_offset_t) wraddr, write_length);
2120 if (kret != KERN_SUCCESS)
2121 {
2122 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2123 mach_error_string (kret));
2124 return res_length;
2125 }
2126
2127 /* Restore page rights. */
a80b95ba
TG
2128 if (!(info.protection & VM_PROT_WRITE))
2129 {
bb00b29d 2130 kret = mach_vm_protect (task, region_address, region_length,
3eb831e0 2131 FALSE, info.protection);
bb00b29d 2132 if (kret != KERN_SUCCESS)
a80b95ba 2133 {
3eb831e0
TG
2134 warning (_("darwin_read_write_inferior: "
2135 "mach_vm_protect restore failed at %s "
2136 "(len=0x%lx): %s"),
bb00b29d 2137 core_addr_to_string (region_address),
3eb831e0
TG
2138 (unsigned long) region_length,
2139 mach_error_string (kret));
a80b95ba
TG
2140 }
2141 }
a80b95ba 2142
3eb831e0
TG
2143 addr += write_length;
2144 wraddr += write_length;
2145 res_length += write_length;
2146 length -= write_length;
a80b95ba 2147 }
3eb831e0
TG
2148
2149 return res_length;
a80b95ba
TG
2150}
2151
f00c55f8 2152/* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
ad2073b0 2153 to RDADDR (in big endian).
569283d4 2154 Return 0 on failure; number of bytes read / written otherwise. */
f00c55f8 2155
b967eb24 2156#ifdef TASK_DYLD_INFO_COUNT
569283d4 2157/* This is not available in Darwin 9. */
9b409511 2158static enum target_xfer_status
b9dd1947 2159darwin_read_dyld_info (task_t task, CORE_ADDR addr, gdb_byte *rdaddr,
9b409511 2160 ULONGEST length, ULONGEST *xfered_len)
f00c55f8
TG
2161{
2162 struct task_dyld_info task_dyld_info;
2163 mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
2164 int sz = TASK_DYLD_INFO_COUNT * sizeof (natural_t);
2165 kern_return_t kret;
2166
ad2073b0 2167 if (addr != 0 || length > sizeof (mach_vm_address_t))
9b409511 2168 return TARGET_XFER_EOF;
f00c55f8 2169
ad2073b0
TG
2170 kret = task_info (task, TASK_DYLD_INFO,
2171 (task_info_t) &task_dyld_info, &count);
f00c55f8
TG
2172 MACH_CHECK_ERROR (kret);
2173 if (kret != KERN_SUCCESS)
2ed4b548 2174 return TARGET_XFER_E_IO;
ad2073b0
TG
2175
2176 store_unsigned_integer (rdaddr, length, BFD_ENDIAN_BIG,
2177 task_dyld_info.all_image_info_addr);
9b409511
YQ
2178 *xfered_len = (ULONGEST) length;
2179 return TARGET_XFER_OK;
f00c55f8 2180}
569283d4 2181#endif
f00c55f8 2182
a80b95ba 2183\f
a80b95ba 2184
1b281443 2185static enum target_xfer_status
a80b95ba
TG
2186darwin_xfer_partial (struct target_ops *ops,
2187 enum target_object object, const char *annex,
2188 gdb_byte *readbuf, const gdb_byte *writebuf,
9b409511 2189 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
a80b95ba 2190{
bb00b29d
TG
2191 struct inferior *inf = current_inferior ();
2192
2193 inferior_debug
b55e14c7
YQ
2194 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2195 core_addr_to_string (offset), pulongest (len),
854f4b0e
TG
2196 host_address_to_string (readbuf), host_address_to_string (writebuf),
2197 inf->pid);
a80b95ba 2198
f00c55f8
TG
2199 switch (object)
2200 {
2201 case TARGET_OBJECT_MEMORY:
9b409511 2202 {
fe978cb0 2203 int l = darwin_read_write_inferior (inf->priv->task, offset,
9b409511
YQ
2204 readbuf, writebuf, len);
2205
2206 if (l == 0)
2207 return TARGET_XFER_EOF;
2208 else
2209 {
2210 gdb_assert (l > 0);
2211 *xfered_len = (ULONGEST) l;
2212 return TARGET_XFER_OK;
2213 }
2214 }
569283d4 2215#ifdef TASK_DYLD_INFO_COUNT
f00c55f8
TG
2216 case TARGET_OBJECT_DARWIN_DYLD_INFO:
2217 if (writebuf != NULL || readbuf == NULL)
2218 {
2219 /* Support only read. */
2ed4b548 2220 return TARGET_XFER_E_IO;
f00c55f8 2221 }
fe978cb0 2222 return darwin_read_dyld_info (inf->priv->task, offset, readbuf, len,
9b409511 2223 xfered_len);
569283d4 2224#endif
f00c55f8 2225 default:
2ed4b548 2226 return TARGET_XFER_E_IO;
f00c55f8 2227 }
a80b95ba 2228
a80b95ba
TG
2229}
2230
2231static void
0fc76421 2232set_enable_mach_exceptions (const char *args, int from_tty,
a80b95ba
TG
2233 struct cmd_list_element *c)
2234{
bb00b29d 2235 if (!ptid_equal (inferior_ptid, null_ptid))
a80b95ba 2236 {
bb00b29d 2237 struct inferior *inf = current_inferior ();
a80b95ba
TG
2238 exception_mask_t mask;
2239 kern_return_t kret;
2240
2241 if (enable_mach_exceptions)
2242 mask = EXC_MASK_ALL;
2243 else
2244 {
fe978cb0 2245 darwin_restore_exception_ports (inf->priv);
bb00b29d 2246 mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
a80b95ba 2247 }
fe978cb0 2248 kret = task_set_exception_ports (inf->priv->task, mask, darwin_ex_port,
a80b95ba
TG
2249 EXCEPTION_DEFAULT, THREAD_STATE_NONE);
2250 MACH_CHECK_ERROR (kret);
2251 }
2252}
2253
bb00b29d 2254static char *
8dd27370 2255darwin_pid_to_exec_file (struct target_ops *self, int pid)
bb00b29d 2256{
b4ab256d 2257 static char path[PATH_MAX];
bb00b29d
TG
2258 int res;
2259
d8d2a3ee 2260 res = proc_pidinfo (pid, PROC_PIDPATHINFO, 0, path, PATH_MAX);
bb00b29d
TG
2261 if (res >= 0)
2262 return path;
2263 else
2264 return NULL;
2265}
2266
2267static ptid_t
1e6b91a4 2268darwin_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
bb00b29d
TG
2269{
2270 int i;
2271 darwin_thread_t *t;
2272 int k;
2273 struct inferior *inf = current_inferior ();
2274 kern_return_t kret;
2275 mach_port_name_array_t names;
2276 mach_msg_type_number_t names_count;
2277 mach_port_type_array_t types;
2278 mach_msg_type_number_t types_count;
2279 long res = 0;
2280
2281 /* First linear search. */
2282 for (k = 0;
fe978cb0 2283 VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
bb00b29d
TG
2284 k++)
2285 if (t->inf_port == lwp)
2286 return ptid_build (ptid_get_pid (inferior_ptid), 0, t->gdb_port);
2287
2288 /* Maybe the port was never extract. Do it now. */
2289
2290 /* First get inferior port names. */
fe978cb0 2291 kret = mach_port_names (inf->priv->task, &names, &names_count, &types,
bb00b29d
TG
2292 &types_count);
2293 MACH_CHECK_ERROR (kret);
2294 if (kret != KERN_SUCCESS)
2295 return null_ptid;
2296
2297 /* For each name, copy the right in the gdb space and then compare with
2298 our view of the inferior threads. We don't forget to deallocate the
2299 right. */
2300 for (i = 0; i < names_count; i++)
2301 {
2302 mach_port_t local_name;
2303 mach_msg_type_name_t local_type;
2304
2305 /* We just need to know the corresponding name in gdb name space.
2306 So extract and deallocate the right. */
fe978cb0 2307 kret = mach_port_extract_right (inf->priv->task, names[i],
bb00b29d
TG
2308 MACH_MSG_TYPE_COPY_SEND,
2309 &local_name, &local_type);
2310 if (kret != KERN_SUCCESS)
2311 continue;
2312 mach_port_deallocate (gdb_task, local_name);
2313
2314 for (k = 0;
fe978cb0 2315 VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
bb00b29d
TG
2316 k++)
2317 if (t->gdb_port == local_name)
2318 {
2319 t->inf_port = names[i];
2320 if (names[i] == lwp)
2321 res = t->gdb_port;
2322 }
2323 }
2324
2325 vm_deallocate (gdb_task, (vm_address_t) names,
2326 names_count * sizeof (mach_port_t));
2327
2328 if (res)
2329 return ptid_build (ptid_get_pid (inferior_ptid), 0, res);
2330 else
2331 return null_ptid;
2332}
2333
2334static int
86ce2668 2335darwin_supports_multi_process (struct target_ops *self)
bb00b29d
TG
2336{
2337 return 1;
2338}
2339
a80b95ba 2340void
bb00b29d 2341_initialize_darwin_inferior (void)
a80b95ba
TG
2342{
2343 kern_return_t kret;
2344
a80b95ba
TG
2345 gdb_task = mach_task_self ();
2346 darwin_host_self = mach_host_self ();
2347
2348 /* Read page size. */
2349 kret = host_page_size (darwin_host_self, &mach_page_size);
2350 if (kret != KERN_SUCCESS)
2351 {
2352 mach_page_size = 0x1000;
2353 MACH_CHECK_ERROR (kret);
2354 }
2355
a80b95ba
TG
2356 darwin_ops = inf_child_target ();
2357
a80b95ba
TG
2358 darwin_ops->to_create_inferior = darwin_create_inferior;
2359 darwin_ops->to_attach = darwin_attach;
2360 darwin_ops->to_attach_no_wait = 0;
2361 darwin_ops->to_detach = darwin_detach;
2362 darwin_ops->to_files_info = darwin_files_info;
bb00b29d 2363 darwin_ops->to_wait = darwin_wait_to;
a80b95ba
TG
2364 darwin_ops->to_mourn_inferior = darwin_mourn_inferior;
2365 darwin_ops->to_kill = darwin_kill_inferior;
bfedc46a 2366 darwin_ops->to_interrupt = darwin_interrupt;
bb00b29d 2367 darwin_ops->to_resume = darwin_resume_to;
a80b95ba
TG
2368 darwin_ops->to_thread_alive = darwin_thread_alive;
2369 darwin_ops->to_pid_to_str = darwin_pid_to_str;
bb00b29d 2370 darwin_ops->to_pid_to_exec_file = darwin_pid_to_exec_file;
a80b95ba 2371 darwin_ops->to_load = NULL;
a80b95ba 2372 darwin_ops->to_xfer_partial = darwin_xfer_partial;
bb00b29d
TG
2373 darwin_ops->to_supports_multi_process = darwin_supports_multi_process;
2374 darwin_ops->to_get_ada_task_ptid = darwin_get_ada_task_ptid;
a80b95ba
TG
2375
2376 darwin_complete_target (darwin_ops);
2377
2378 add_target (darwin_ops);
2379
3eb831e0
TG
2380 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2381 (unsigned long) mach_task_self (), getpid ());
a80b95ba 2382
ccce17b0
YQ
2383 add_setshow_zuinteger_cmd ("darwin", class_obscure,
2384 &darwin_debug_flag, _("\
a80b95ba
TG
2385Set if printing inferior communication debugging statements."), _("\
2386Show if printing inferior communication debugging statements."), NULL,
ccce17b0
YQ
2387 NULL, NULL,
2388 &setdebuglist, &showdebuglist);
a80b95ba
TG
2389
2390 add_setshow_boolean_cmd ("mach-exceptions", class_support,
2391 &enable_mach_exceptions, _("\
2392Set if mach exceptions are caught."), _("\
2393Show if mach exceptions are caught."), _("\
2394When this mode is on, all low level exceptions are reported before being\n\
2395reported by the kernel."),
2396 &set_enable_mach_exceptions, NULL,
2397 &setlist, &showlist);
2398}