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