Copyright year update in most files of the GDB Project.
[external/binutils.git] / gdb / darwin-nat-info.c
1 /* Darwin support for GDB, the GNU debugger.
2    Copyright 1997-2002, 2008-2012 Free Software Foundation, Inc.
3
4    Contributed by Apple Computer, Inc.
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 /* The name of the ppc_thread_state structure, and the names of its
22    members, have been changed for Unix conformance reasons.  The easiest
23    way to have gdb build on systems with the older names and systems
24    with the newer names is to build this compilation unit with the
25    non-conformant define below.  This doesn't seem to cause the resulting
26    binary any problems but it seems like it could cause us problems in
27    the future.  It'd be good to remove this at some point when compiling on
28    Tiger is no longer important.  */
29
30 #include "defs.h"
31 #include "symtab.h"
32 #include "gdbtypes.h"
33 #include "gdbcore.h"
34 #include "value.h"
35 #include "gdbcmd.h"
36 #include "inferior.h"
37
38 #include <sys/param.h>
39 #include <sys/sysctl.h>
40
41 #include "darwin-nat.h"
42
43 #include <mach/thread_info.h>
44 #include <mach/thread_act.h>
45 #include <mach/task.h>
46 #include <mach/vm_map.h>
47 #include <mach/mach_port.h>
48 #include <mach/mach_init.h>
49 #include <mach/mach_vm.h>
50
51 #define CHECK_ARGS(what, args) do { \
52   if ((NULL == args) || ((args[0] != '0') && (args[1] != 'x'))) \
53     error(_("%s must be specified with 0x..."), what);          \
54 } while (0)
55
56 #define PRINT_FIELD(structure, field) \
57   printf_unfiltered(_(#field":\t%#lx\n"), (unsigned long) (structure)->field)
58
59 #define PRINT_TV_FIELD(structure, field) \
60   printf_unfiltered(_(#field":\t%u.%06u sec\n"),        \
61   (unsigned) (structure)->field.seconds, \
62   (unsigned) (structure)->field.microseconds)
63
64 #define task_self mach_task_self
65 #define task_by_unix_pid task_for_pid
66 #define port_name_array_t mach_port_array_t
67 #define port_type_array_t mach_port_array_t
68
69 static void
70 info_mach_tasks_command (char *args, int from_tty)
71 {
72   int sysControl[4];
73   int count, index;
74   size_t length;
75   struct kinfo_proc *procInfo;
76
77   sysControl[0] = CTL_KERN;
78   sysControl[1] = KERN_PROC;
79   sysControl[2] = KERN_PROC_ALL;
80
81   sysctl (sysControl, 3, NULL, &length, NULL, 0);
82   procInfo = (struct kinfo_proc *) xmalloc (length);
83   sysctl (sysControl, 3, procInfo, &length, NULL, 0);
84
85   count = (length / sizeof (struct kinfo_proc));
86   printf_unfiltered (_("%d processes:\n"), count);
87   for (index = 0; index < count; ++index)
88     {
89       kern_return_t result;
90       mach_port_t taskPort;
91
92       result =
93         task_by_unix_pid (mach_task_self (), procInfo[index].kp_proc.p_pid,
94                           &taskPort);
95       if (KERN_SUCCESS == result)
96         {
97           printf_unfiltered (_("    %s is %d has task %#x\n"),
98                              procInfo[index].kp_proc.p_comm,
99                              procInfo[index].kp_proc.p_pid, taskPort);
100         }
101       else
102         {
103           printf_unfiltered (_("    %s is %d unknown task port\n"),
104                              procInfo[index].kp_proc.p_comm,
105                              procInfo[index].kp_proc.p_pid);
106         }
107     }
108
109   xfree (procInfo);
110 }
111
112 static task_t
113 get_task_from_args (char *args)
114 {
115   task_t task;
116   char *eptr;
117
118   if (args == NULL || *args == 0)
119     {
120       if (ptid_equal (inferior_ptid, null_ptid))
121         printf_unfiltered (_("No inferior running\n"));
122       return current_inferior ()->private->task;
123     }
124   if (strcmp (args, "gdb") == 0)
125     return mach_task_self ();
126   task = strtoul (args, &eptr, 0);
127   if (*eptr)
128     {
129       printf_unfiltered (_("cannot parse task id '%s'\n"), args);
130       return TASK_NULL;
131     }
132   return task;
133 }
134
135 static void
136 info_mach_task_command (char *args, int from_tty)
137 {
138   union
139   {
140     struct task_basic_info basic;
141     struct task_events_info events;
142     struct task_thread_times_info thread_times;
143   } task_info_data;
144
145   kern_return_t result;
146   unsigned int info_count;
147   task_t task;
148
149   task = get_task_from_args (args);
150   if (task == TASK_NULL)
151     return;
152
153   printf_unfiltered (_("TASK_BASIC_INFO for 0x%x:\n"), task);
154   info_count = TASK_BASIC_INFO_COUNT;
155   result = task_info (task,
156                       TASK_BASIC_INFO,
157                       (task_info_t) & task_info_data.basic, &info_count);
158   MACH_CHECK_ERROR (result);
159
160   PRINT_FIELD (&task_info_data.basic, suspend_count);
161   PRINT_FIELD (&task_info_data.basic, virtual_size);
162   PRINT_FIELD (&task_info_data.basic, resident_size);
163   PRINT_TV_FIELD (&task_info_data.basic, user_time);
164   PRINT_TV_FIELD (&task_info_data.basic, system_time);
165   printf_unfiltered (_("\nTASK_EVENTS_INFO:\n"));
166   info_count = TASK_EVENTS_INFO_COUNT;
167   result = task_info (task,
168                       TASK_EVENTS_INFO,
169                       (task_info_t) & task_info_data.events, &info_count);
170   MACH_CHECK_ERROR (result);
171
172   PRINT_FIELD (&task_info_data.events, faults);
173 #if 0
174   PRINT_FIELD (&task_info_data.events, zero_fills);
175   PRINT_FIELD (&task_info_data.events, reactivations);
176 #endif
177   PRINT_FIELD (&task_info_data.events, pageins);
178   PRINT_FIELD (&task_info_data.events, cow_faults);
179   PRINT_FIELD (&task_info_data.events, messages_sent);
180   PRINT_FIELD (&task_info_data.events, messages_received);
181   printf_unfiltered (_("\nTASK_THREAD_TIMES_INFO:\n"));
182   info_count = TASK_THREAD_TIMES_INFO_COUNT;
183   result = task_info (task,
184                       TASK_THREAD_TIMES_INFO,
185                       (task_info_t) & task_info_data.thread_times,
186                       &info_count);
187   MACH_CHECK_ERROR (result);
188   PRINT_TV_FIELD (&task_info_data.thread_times, user_time);
189   PRINT_TV_FIELD (&task_info_data.thread_times, system_time);
190 }
191
192 static void
193 info_mach_ports_command (char *args, int from_tty)
194 {
195   port_name_array_t names;
196   port_type_array_t types;
197   unsigned int name_count, type_count;
198   kern_return_t result;
199   int index;
200   task_t task;
201
202   task = get_task_from_args (args);
203   if (task == TASK_NULL)
204     return;
205
206   result = mach_port_names (task, &names, &name_count, &types, &type_count);
207   MACH_CHECK_ERROR (result);
208
209   gdb_assert (name_count == type_count);
210
211   printf_unfiltered (_("Ports for task 0x%x:\n"), task);
212   printf_unfiltered (_("port   type\n"));
213   for (index = 0; index < name_count; ++index)
214     {
215       mach_port_t port = names[index];
216       unsigned int j;
217       struct type_descr
218       {
219         mach_port_type_t type;
220         const char *name;
221         mach_port_right_t right;
222       };
223       static struct type_descr descrs[] =
224         {
225           {MACH_PORT_TYPE_SEND, "send", MACH_PORT_RIGHT_SEND},
226           {MACH_PORT_TYPE_SEND_ONCE, "send-once", MACH_PORT_RIGHT_SEND_ONCE},
227           {MACH_PORT_TYPE_RECEIVE, "receive", MACH_PORT_RIGHT_RECEIVE},
228           {MACH_PORT_TYPE_PORT_SET, "port-set", MACH_PORT_RIGHT_PORT_SET},
229           {MACH_PORT_TYPE_DEAD_NAME, "dead", MACH_PORT_RIGHT_DEAD_NAME}
230         };
231
232       printf_unfiltered (_("%04x: %08x "), port, types[index]);
233       for (j = 0; j < sizeof(descrs) / sizeof(*descrs); j++)
234         if (types[index] & descrs[j].type)
235           {
236             mach_port_urefs_t ref;
237             kern_return_t ret;
238
239             printf_unfiltered (_(" %s("), descrs[j].name);
240             ret = mach_port_get_refs (task, port, descrs[j].right, &ref);
241             if (ret != KERN_SUCCESS)
242               printf_unfiltered (_("??"));
243             else
244               printf_unfiltered (_("%u"), ref);
245             printf_unfiltered (_(" refs)"));
246           }
247       
248       if (task == task_self ())
249         {
250           if (port == task_self())
251             printf_unfiltered (_(" gdb-task"));
252           else if (port == darwin_host_self)
253             printf_unfiltered (_(" host-self"));
254           else if (port == darwin_ex_port)
255             printf_unfiltered (_(" gdb-exception"));
256           else if (port == darwin_port_set)
257             printf_unfiltered (_(" gdb-port_set"));
258           else if (!ptid_equal (inferior_ptid, null_ptid))
259             {
260               struct inferior *inf = current_inferior ();
261
262               if (port == inf->private->task)
263                 printf_unfiltered (_(" inferior-task"));
264               else if (port == inf->private->notify_port)
265                 printf_unfiltered (_(" inferior-notify"));
266               else
267                 {
268                   int k;
269                   darwin_thread_t *t;
270
271                   for (k = 0; k < inf->private->exception_info.count; k++)
272                     if (port == inf->private->exception_info.ports[k])
273                       {
274                         printf_unfiltered (_(" inferior-excp-port"));
275                         break;
276                       }
277
278                   if (inf->private->threads)
279                     {
280                       for (k = 0;
281                            VEC_iterate(darwin_thread_t,
282                                        inf->private->threads, k, t);
283                            k++)
284                         if (port == t->gdb_port)
285                           {
286                             printf_unfiltered (_(" inferior-thread for 0x%x"),
287                                                inf->private->task);
288                             break;
289                           }
290                     }
291                 }
292             }
293         }
294       printf_unfiltered (_("\n"));
295     }
296
297   vm_deallocate (task_self (), (vm_address_t) names,
298                  (name_count * sizeof (mach_port_t)));
299   vm_deallocate (task_self (), (vm_address_t) types,
300                  (type_count * sizeof (mach_port_type_t)));
301 }
302
303
304 void
305 darwin_debug_port_info (task_t task, mach_port_t port)
306 {
307   kern_return_t kret;
308   mach_port_status_t status;
309   mach_msg_type_number_t len = sizeof (status);
310
311   kret = mach_port_get_attributes
312     (task, port, MACH_PORT_RECEIVE_STATUS, (mach_port_info_t)&status, &len);
313   MACH_CHECK_ERROR (kret);
314
315   printf_unfiltered (_("Port 0x%lx in task 0x%lx:\n"), (unsigned long) port,
316                      (unsigned long) task);
317   printf_unfiltered (_("  port set: 0x%x\n"), status.mps_pset);
318   printf_unfiltered (_("     seqno: 0x%x\n"), status.mps_seqno);
319   printf_unfiltered (_("   mscount: 0x%x\n"), status.mps_mscount);
320   printf_unfiltered (_("    qlimit: 0x%x\n"), status.mps_qlimit);
321   printf_unfiltered (_("  msgcount: 0x%x\n"), status.mps_msgcount);
322   printf_unfiltered (_("  sorights: 0x%x\n"), status.mps_sorights);
323   printf_unfiltered (_("   srights: 0x%x\n"), status.mps_srights);
324   printf_unfiltered (_(" pdrequest: 0x%x\n"), status.mps_pdrequest);
325   printf_unfiltered (_(" nsrequest: 0x%x\n"), status.mps_nsrequest);
326   printf_unfiltered (_("     flags: 0x%x\n"), status.mps_flags);
327 }
328
329 static void
330 info_mach_port_command (char *args, int from_tty)
331 {
332   task_t task;
333   mach_port_t port;
334
335   CHECK_ARGS (_("Task and port"), args);
336   sscanf (args, "0x%x 0x%x", &task, &port);
337
338   darwin_debug_port_info (task, port);
339 }
340
341 static void
342 info_mach_threads_command (char *args, int from_tty)
343 {
344   thread_array_t threads;
345   unsigned int thread_count;
346   kern_return_t result;
347   task_t task;
348   int i;
349
350   task = get_task_from_args (args);
351   if (task == TASK_NULL)
352     return;
353
354   result = task_threads (task, &threads, &thread_count);
355   MACH_CHECK_ERROR (result);
356
357   printf_unfiltered (_("Threads in task %#x:\n"), task);
358   for (i = 0; i < thread_count; ++i)
359     {
360       printf_unfiltered (_("    %#x\n"), threads[i]);
361       mach_port_deallocate (task_self (), threads[i]);
362     }
363
364   vm_deallocate (task_self (), (vm_address_t) threads,
365                  (thread_count * sizeof (thread_t)));
366 }
367
368 static void
369 info_mach_thread_command (char *args, int from_tty)
370 {
371   union
372   {
373     struct thread_basic_info basic;
374   } thread_info_data;
375
376   thread_t thread;
377   kern_return_t result;
378   unsigned int info_count;
379
380   CHECK_ARGS (_("Thread"), args);
381   sscanf (args, "0x%x", &thread);
382
383   printf_unfiltered (_("THREAD_BASIC_INFO\n"));
384   info_count = THREAD_BASIC_INFO_COUNT;
385   result = thread_info (thread,
386                         THREAD_BASIC_INFO,
387                         (thread_info_t) & thread_info_data.basic,
388                         &info_count);
389   MACH_CHECK_ERROR (result);
390
391 #if 0
392   PRINT_FIELD (&thread_info_data.basic, user_time);
393   PRINT_FIELD (&thread_info_data.basic, system_time);
394 #endif
395   PRINT_FIELD (&thread_info_data.basic, cpu_usage);
396   PRINT_FIELD (&thread_info_data.basic, run_state);
397   PRINT_FIELD (&thread_info_data.basic, flags);
398   PRINT_FIELD (&thread_info_data.basic, suspend_count);
399   PRINT_FIELD (&thread_info_data.basic, sleep_time);
400 }
401
402 static const char *
403 unparse_protection (vm_prot_t p)
404 {
405   switch (p)
406     {
407     case VM_PROT_NONE:
408       return "---";
409     case VM_PROT_READ:
410       return "r--";
411     case VM_PROT_WRITE:
412       return "-w-";
413     case VM_PROT_READ | VM_PROT_WRITE:
414       return "rw-";
415     case VM_PROT_EXECUTE:
416       return "--x";
417     case VM_PROT_EXECUTE | VM_PROT_READ:
418       return "r-x";
419     case VM_PROT_EXECUTE | VM_PROT_WRITE:
420       return "-wx";
421     case VM_PROT_EXECUTE | VM_PROT_WRITE | VM_PROT_READ:
422       return "rwx";
423     default:
424       return "???";
425     }
426 }
427
428 static const char *
429 unparse_inheritance (vm_inherit_t i)
430 {
431   switch (i)
432     {
433     case VM_INHERIT_SHARE:
434       return _("share");
435     case VM_INHERIT_COPY:
436       return _("copy ");
437     case VM_INHERIT_NONE:
438       return _("none ");
439     default:
440       return _("???  ");
441     }
442 }
443
444 static const char *
445 unparse_share_mode (unsigned char p)
446 {
447   switch (p)
448     {
449     case SM_COW:
450       return _("cow");
451     case SM_PRIVATE:
452       return _("private");
453     case SM_EMPTY:
454       return _("empty");
455     case SM_SHARED:
456       return _("shared");
457     case SM_TRUESHARED:
458       return _("true-shrd");
459     case SM_PRIVATE_ALIASED:
460       return _("prv-alias");
461     case SM_SHARED_ALIASED:
462       return _("shr-alias");
463     default:
464       return _("???");
465     }
466 }
467
468 static const char *
469 unparse_user_tag (unsigned int tag)
470 {
471   switch (tag)
472     {
473     case 0:
474       return _("default");
475     case VM_MEMORY_MALLOC:
476       return _("malloc");
477     case VM_MEMORY_MALLOC_SMALL:
478       return _("malloc_small");
479     case VM_MEMORY_MALLOC_LARGE:
480       return _("malloc_large");
481     case VM_MEMORY_MALLOC_HUGE:
482       return _("malloc_huge");
483     case VM_MEMORY_SBRK:
484       return _("sbrk");
485     case VM_MEMORY_REALLOC:
486       return _("realloc");
487     case VM_MEMORY_MALLOC_TINY:
488       return _("malloc_tiny");
489     case VM_MEMORY_ANALYSIS_TOOL:
490       return _("analysis_tool");
491     case VM_MEMORY_MACH_MSG:
492       return _("mach_msg");
493     case VM_MEMORY_IOKIT:
494       return _("iokit");
495     case VM_MEMORY_STACK:
496       return _("stack");
497     case VM_MEMORY_GUARD:
498       return _("guard");
499     case VM_MEMORY_SHARED_PMAP:
500       return _("shared_pmap");
501     case VM_MEMORY_DYLIB:
502       return _("dylib");
503     case VM_MEMORY_APPKIT:
504       return _("appkit");
505     case VM_MEMORY_FOUNDATION:
506       return _("foundation");
507     default:
508       return NULL;
509     }
510 }
511
512 static void
513 darwin_debug_regions (task_t task, mach_vm_address_t address, int max)
514 {
515   kern_return_t kret;
516   vm_region_basic_info_data_64_t info, prev_info;
517   mach_vm_address_t prev_address;
518   mach_vm_size_t size, prev_size;
519
520   mach_port_t object_name;
521   mach_msg_type_number_t count;
522
523   int nsubregions = 0;
524   int num_printed = 0;
525
526   count = VM_REGION_BASIC_INFO_COUNT_64;
527   kret = mach_vm_region (task, &address, &size, VM_REGION_BASIC_INFO_64,
528                          (vm_region_info_t) &info, &count, &object_name);
529   if (kret != KERN_SUCCESS)
530     {
531       printf_filtered (_("No memory regions."));
532       return;
533     }
534   memcpy (&prev_info, &info, sizeof (vm_region_basic_info_data_64_t));
535   prev_address = address;
536   prev_size = size;
537   nsubregions = 1;
538
539   for (;;)
540     {
541       int print = 0;
542       int done = 0;
543
544       address = prev_address + prev_size;
545
546       /* Check to see if address space has wrapped around.  */
547       if (address == 0)
548         print = done = 1;
549
550       if (!done)
551         {
552           count = VM_REGION_BASIC_INFO_COUNT_64;
553           kret =
554             mach_vm_region (task, &address, &size, VM_REGION_BASIC_INFO_64,
555                               (vm_region_info_t) &info, &count, &object_name);
556           if (kret != KERN_SUCCESS)
557             {
558               size = 0;
559               print = done = 1;
560             }
561         }
562
563       if (address != prev_address + prev_size)
564         print = 1;
565
566       if ((info.protection != prev_info.protection)
567           || (info.max_protection != prev_info.max_protection)
568           || (info.inheritance != prev_info.inheritance)
569           || (info.shared != prev_info.reserved)
570           || (info.reserved != prev_info.reserved))
571         print = 1;
572
573       if (print)
574         {
575           printf_filtered (_("%s-%s %s/%s  %s %s %s"),
576                            paddress (target_gdbarch, prev_address),
577                            paddress (target_gdbarch, prev_address + prev_size),
578                            unparse_protection (prev_info.protection),
579                            unparse_protection (prev_info.max_protection),
580                            unparse_inheritance (prev_info.inheritance),
581                            prev_info.shared ? _("shrd") : _("priv"),
582                            prev_info.reserved ? _("reserved") : _("not-rsvd"));
583
584           if (nsubregions > 1)
585             printf_filtered (_(" (%d sub-rgn)"), nsubregions);
586
587           printf_filtered (_("\n"));
588
589           prev_address = address;
590           prev_size = size;
591           memcpy (&prev_info, &info, sizeof (vm_region_basic_info_data_64_t));
592           nsubregions = 1;
593
594           num_printed++;
595         }
596       else
597         {
598           prev_size += size;
599           nsubregions++;
600         }
601
602       if ((max > 0) && (num_printed >= max))
603         done = 1;
604
605       if (done)
606         break;
607     }
608 }
609
610 static void
611 darwin_debug_regions_recurse (task_t task)
612 {
613   mach_vm_address_t r_addr;
614   mach_vm_address_t r_start;
615   mach_vm_size_t r_size;
616   natural_t r_depth;
617   mach_msg_type_number_t r_info_size;
618   vm_region_submap_short_info_data_64_t r_info;
619   kern_return_t kret;
620   int ret;
621   struct cleanup *table_chain;
622   struct ui_out *uiout = current_uiout;
623
624   table_chain = make_cleanup_ui_out_table_begin_end (uiout, 9, -1, "regions");
625
626   if (gdbarch_addr_bit (target_gdbarch) <= 32)
627     {
628       ui_out_table_header (uiout, 10, ui_left, "start", "Start");
629       ui_out_table_header (uiout, 10, ui_left, "end", "End");
630     }
631   else
632     {
633       ui_out_table_header (uiout, 18, ui_left, "start", "Start");
634       ui_out_table_header (uiout, 18, ui_left, "end", "End");
635     }
636   ui_out_table_header (uiout, 3, ui_left, "min-prot", "Min");
637   ui_out_table_header (uiout, 3, ui_left, "max-prot", "Max");
638   ui_out_table_header (uiout, 5, ui_left, "inheritence", "Inh");
639   ui_out_table_header (uiout, 9, ui_left, "share-mode", "Shr");
640   ui_out_table_header (uiout, 1, ui_left, "depth", "D");
641   ui_out_table_header (uiout, 3, ui_left, "submap", "Sm");
642   ui_out_table_header (uiout, 0, ui_noalign, "tag", "Tag");
643
644   ui_out_table_body (uiout);
645
646   r_start = 0;
647   r_depth = 0;
648   while (1)
649     {
650       const char *tag;
651       struct cleanup *row_chain;
652
653       r_info_size = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
654       r_size = -1;
655       kret = mach_vm_region_recurse (task, &r_start, &r_size, &r_depth,
656                                      (vm_region_recurse_info_t) &r_info,
657                                      &r_info_size);
658       if (kret != KERN_SUCCESS)
659         break;
660       row_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "regions-row");
661
662       ui_out_field_core_addr (uiout, "start", target_gdbarch, r_start);
663       ui_out_field_core_addr (uiout, "end", target_gdbarch, r_start + r_size);
664       ui_out_field_string (uiout, "min-prot", 
665                            unparse_protection (r_info.protection));
666       ui_out_field_string (uiout, "max-prot", 
667                            unparse_protection (r_info.max_protection));
668       ui_out_field_string (uiout, "inheritence",
669                            unparse_inheritance (r_info.inheritance));
670       ui_out_field_string (uiout, "share-mode",
671                            unparse_share_mode (r_info.share_mode));
672       ui_out_field_int (uiout, "depth", r_depth);
673       ui_out_field_string (uiout, "submap",
674                            r_info.is_submap ? _("sm ") : _("obj"));
675       tag = unparse_user_tag (r_info.user_tag);
676       if (tag)
677         ui_out_field_string (uiout, "tag", tag);
678       else
679         ui_out_field_int (uiout, "tag", r_info.user_tag);
680
681       do_cleanups (row_chain);
682
683       if (!ui_out_is_mi_like_p (uiout))
684         ui_out_text (uiout, "\n");
685
686       if (r_info.is_submap)
687         r_depth++;
688       else
689         r_start += r_size;
690     }
691   do_cleanups (table_chain);
692
693 }
694
695
696 static void
697 darwin_debug_region (task_t task, mach_vm_address_t address)
698 {
699   darwin_debug_regions (task, address, 1);
700 }
701
702 static void
703 info_mach_regions_command (char *args, int from_tty)
704 {
705   task_t task;
706
707   task = get_task_from_args (args);
708   if (task == TASK_NULL)
709     return;
710   
711   darwin_debug_regions (task, 0, -1);
712 }
713
714 static void
715 info_mach_regions_recurse_command (char *args, int from_tty)
716 {
717   task_t task;
718
719   task = get_task_from_args (args);
720   if (task == TASK_NULL)
721     return;
722   
723   darwin_debug_regions_recurse (task);
724 }
725
726 static void
727 info_mach_region_command (char *exp, int from_tty)
728 {
729   struct expression *expr;
730   struct value *val;
731   mach_vm_address_t address;
732   struct inferior *inf;
733
734   expr = parse_expression (exp);
735   val = evaluate_expression (expr);
736   if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
737     {
738       val = value_ind (val);
739     }
740   address = value_as_address (val);
741
742   if (ptid_equal (inferior_ptid, null_ptid))
743     error (_("Inferior not available"));
744
745   inf = current_inferior ();
746   darwin_debug_region (inf->private->task, address);
747 }
748
749 static void
750 disp_exception (const darwin_exception_info *info)
751 {
752   int i;
753
754   printf_filtered (_("%d exceptions:\n"), info->count);
755   for (i = 0; i < info->count; i++)
756     {
757       exception_mask_t mask = info->masks[i];
758
759       printf_filtered (_("port 0x%04x, behavior: "), info->ports[i]);
760       switch (info->behaviors[i])
761         {
762         case EXCEPTION_DEFAULT:
763           printf_unfiltered (_("default"));
764           break;
765         case EXCEPTION_STATE:
766           printf_unfiltered (_("state"));
767           break;
768         case EXCEPTION_STATE_IDENTITY:
769           printf_unfiltered (_("state-identity"));
770           break;
771         default:
772           printf_unfiltered (_("0x%x"), info->behaviors[i]);
773         }
774       printf_unfiltered (_(", masks:"));
775       if (mask & EXC_MASK_BAD_ACCESS)
776         printf_unfiltered (_(" BAD_ACCESS"));
777       if (mask & EXC_MASK_BAD_INSTRUCTION)
778         printf_unfiltered (_(" BAD_INSTRUCTION"));
779       if (mask & EXC_MASK_ARITHMETIC)
780         printf_unfiltered (_(" ARITHMETIC"));
781       if (mask & EXC_MASK_EMULATION)
782         printf_unfiltered (_(" EMULATION"));
783       if (mask & EXC_MASK_SOFTWARE)
784         printf_unfiltered (_(" SOFTWARE"));
785       if (mask & EXC_MASK_BREAKPOINT)
786         printf_unfiltered (_(" BREAKPOINT"));
787       if (mask & EXC_MASK_SYSCALL)
788         printf_unfiltered (_(" SYSCALL"));
789       if (mask & EXC_MASK_MACH_SYSCALL)
790         printf_unfiltered (_(" MACH_SYSCALL"));
791       if (mask & EXC_MASK_RPC_ALERT)
792         printf_unfiltered (_(" RPC_ALERT"));
793       if (mask & EXC_MASK_CRASH)
794         printf_unfiltered (_(" CRASH"));
795       printf_unfiltered (_("\n"));
796     }
797 }
798
799 static void
800 info_mach_exceptions_command (char *args, int from_tty)
801 {
802   int i;
803   task_t task;
804   kern_return_t kret;
805   darwin_exception_info info;
806
807   info.count = sizeof (info.ports) / sizeof (info.ports[0]);
808
809   if (args != NULL)
810     {
811       if (strcmp (args, "saved") == 0)
812         {
813           if (ptid_equal (inferior_ptid, null_ptid))
814             printf_unfiltered (_("No inferior running\n"));
815           disp_exception (&current_inferior ()->private->exception_info);
816           return;
817         }
818       else if (strcmp (args, "host") == 0)
819         {
820           /* FIXME: This need a privilegied host port!  */
821           kret = host_get_exception_ports
822             (darwin_host_self, EXC_MASK_ALL, info.masks,
823              &info.count, info.ports, info.behaviors, info.flavors);
824           MACH_CHECK_ERROR (kret);
825           disp_exception (&info);
826         }
827       else
828         error (_("Parameter is saved, host or none"));
829     }
830   else
831     {
832       struct inferior *inf;
833
834       if (ptid_equal (inferior_ptid, null_ptid))
835         printf_unfiltered (_("No inferior running\n"));
836       inf = current_inferior ();
837       
838       kret = task_get_exception_ports
839         (inf->private->task, EXC_MASK_ALL, info.masks,
840          &info.count, info.ports, info.behaviors, info.flavors);
841       MACH_CHECK_ERROR (kret);
842       disp_exception (&info);
843     }
844 }
845
846 void
847 _initialize_darwin_info_commands (void)
848 {
849   add_info ("mach-tasks", info_mach_tasks_command,
850             _("Get list of tasks in system."));
851   add_info ("mach-ports", info_mach_ports_command,
852             _("Get list of ports in a task."));
853   add_info ("mach-port", info_mach_port_command,
854             _("Get info on a specific port."));
855   add_info ("mach-task", info_mach_task_command,
856             _("Get info on a specific task."));
857   add_info ("mach-threads", info_mach_threads_command,
858             _("Get list of threads in a task."));
859   add_info ("mach-thread", info_mach_thread_command,
860             _("Get info on a specific thread."));
861
862   add_info ("mach-regions", info_mach_regions_command,
863             _("Get information on all mach region for the task."));
864   add_info ("mach-regions-rec", info_mach_regions_recurse_command,
865             _("Get information on all mach sub region for the task."));
866   add_info ("mach-region", info_mach_region_command,
867             _("Get information on mach region at given address."));
868
869   add_info ("mach-exceptions", info_mach_exceptions_command,
870             _("Disp mach exceptions."));
871 }