gdb/darwin-nat-info.c - gdb

Functions defined

Macros defined

Source code

  1. /* Darwin support for GDB, the GNU debugger.
  2.    Copyright (C) 1997-2015 Free Software Foundation, Inc.

  4.    Contributed by Apple Computer, Inc.

  6.    This file is part of GDB.

  8.    This program is free software; you can redistribute it and/or modify
  9.    it under the terms of the GNU General Public License as published by
  10.    the Free Software Foundation; either version 3 of the License, or
  11.    (at your option) any later version.

  13.    This program is distributed in the hope that it will be useful,
  14.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.    GNU General Public License for more details.

  18.    You should have received a copy of the GNU General Public License
  19.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  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.  */

  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"

  38. #include <sys/sysctl.h>

  40. #include "darwin-nat.h"

  42. #include <mach/thread_info.h>
  43. #include <mach/thread_act.h>
  44. #include <mach/task.h>
  45. #include <mach/vm_map.h>
  46. #include <mach/mach_port.h>
  47. #include <mach/mach_init.h>
  48. #include <mach/mach_vm.h>

  50. ‌#define CHECK_ARGS(what, args) do { \
  51.   if ((NULL == args) || ((args[0] != '0') && (args[1] != 'x'))) \
  52.     error(_("%s must be specified with 0x..."), what);                \
  53. } while (0)

  55. ‌#define PRINT_FIELD(structure, field) \
  56.   printf_unfiltered(_(#field":\t%#lx\n"), (unsigned long) (structure)->field)

  58. ‌#define PRINT_TV_FIELD(structure, field) \
  59.   printf_unfiltered(_(#field":\t%u.%06u sec\n"),        \
  60.   (unsigned) (structure)->field.seconds, \
  61.   (unsigned) (structure)->field.microseconds)

  63. ‌#define task_self mach_task_self
  64. ‌#define task_by_unix_pid task_for_pid
  65. ‌#define port_name_array_t mach_port_array_t
  66. ‌#define port_type_array_t mach_port_array_t

  68. static void
  69. ‌info_mach_tasks_command (char *args, int from_tty)
  70. {
  71.   int sysControl[4];
  72.   int count, index;
  73.   size_t length;
  74.   struct kinfo_proc *procInfo;

  76.   sysControl[0] = CTL_KERN;
  77.   sysControl[1] = KERN_PROC;
  78.   sysControl[2] = KERN_PROC_ALL;

  80.   sysctl (sysControl, 3, NULL, &length, NULL, 0);
  81.   procInfo = (struct kinfo_proc *) xmalloc (length);
  82.   sysctl (sysControl, 3, procInfo, &length, NULL, 0);

  84.   count = (length / sizeof (struct kinfo_proc));
  85.   printf_unfiltered (_("%d processes:\n"), count);
  86.   for (index = 0; index < count; ++index)
  87.     {
  88.       kern_return_t result;
  89.       mach_port_t taskPort;

  91.       result =
  92.         task_by_unix_pid (mach_task_self (), procInfo[index].kp_proc.p_pid,
  93.                           &taskPort);
  94.       if (KERN_SUCCESS == result)
  95.         {
  96.           printf_unfiltered (_("    %s is %d has task %#x\n"),
  97.                              procInfo[index].kp_proc.p_comm,
  98.                              procInfo[index].kp_proc.p_pid, taskPort);
  99.         }
  100.       else
  101.         {
  102.           printf_unfiltered (_("    %s is %d unknown task port\n"),
  103.                              procInfo[index].kp_proc.p_comm,
  104.                              procInfo[index].kp_proc.p_pid);
  105.         }
  106.     }

  108.   xfree (procInfo);
  109. }

  111. static task_t
  112. ‌get_task_from_args (char *args)
  113. {
  114.   task_t task;
  115.   char *eptr;

  117.   if (args == NULL || *args == 0)
  118.     {
  119.       if (ptid_equal (inferior_ptid, null_ptid))
  120.         printf_unfiltered (_("No inferior running\n"));
  121.       return current_inferior ()->private->task;
  122.     }
  123.   if (strcmp (args, "gdb") == 0)
  124.     return mach_task_self ();
  125.   task = strtoul (args, &eptr, 0);
  126.   if (*eptr)
  127.     {
  128.       printf_unfiltered (_("cannot parse task id '%s'\n"), args);
  129.       return TASK_NULL;
  130.     }
  131.   return task;
  132. }

  134. static void
  135. ‌info_mach_task_command (char *args, int from_tty)
  136. {
  137.   union
  138.   {
  139.     struct task_basic_info basic;
  140.     struct task_events_info events;
  141.     struct task_thread_times_info thread_times;
  142.   } task_info_data;

  144.   kern_return_t result;
  145.   unsigned int info_count;
  146.   task_t task;

  148.   task = get_task_from_args (args);
  149.   if (task == TASK_NULL)
  150.     return;

  152.   printf_unfiltered (_("TASK_BASIC_INFO for 0x%x:\n"), task);
  153.   info_count = TASK_BASIC_INFO_COUNT;
  154.   result = task_info (task,
  155.                       TASK_BASIC_INFO,
  156.                       (task_info_t) & task_info_data.basic, &info_count);
  157.   MACH_CHECK_ERROR (result);

  159.   PRINT_FIELD (&task_info_data.basic, suspend_count);
  160.   PRINT_FIELD (&task_info_data.basic, virtual_size);
  161.   PRINT_FIELD (&task_info_data.basic, resident_size);
  162.   PRINT_TV_FIELD (&task_info_data.basic, user_time);
  163.   PRINT_TV_FIELD (&task_info_data.basic, system_time);
  164.   printf_unfiltered (_("\nTASK_EVENTS_INFO:\n"));
  165.   info_count = TASK_EVENTS_INFO_COUNT;
  166.   result = task_info (task,
  167.                       TASK_EVENTS_INFO,
  168.                       (task_info_t) & task_info_data.events, &info_count);
  169.   MACH_CHECK_ERROR (result);

  171.   PRINT_FIELD (&task_info_data.events, faults);
  172. #if 0
  173.   PRINT_FIELD (&task_info_data.events, zero_fills);
  174.   PRINT_FIELD (&task_info_data.events, reactivations);
  175. #endif
  176.   PRINT_FIELD (&task_info_data.events, pageins);
  177.   PRINT_FIELD (&task_info_data.events, cow_faults);
  178.   PRINT_FIELD (&task_info_data.events, messages_sent);
  179.   PRINT_FIELD (&task_info_data.events, messages_received);
  180.   printf_unfiltered (_("\nTASK_THREAD_TIMES_INFO:\n"));
  181.   info_count = TASK_THREAD_TIMES_INFO_COUNT;
  182.   result = task_info (task,
  183.                       TASK_THREAD_TIMES_INFO,
  184.                       (task_info_t) & task_info_data.thread_times,
  185.                       &info_count);
  186.   MACH_CHECK_ERROR (result);
  187.   PRINT_TV_FIELD (&task_info_data.thread_times, user_time);
  188.   PRINT_TV_FIELD (&task_info_data.thread_times, system_time);
  189. }

  191. static void
  192. ‌info_mach_ports_command (char *args, int from_tty)
  193. {
  194.   port_name_array_t names;
  195.   port_type_array_t types;
  196.   unsigned int name_count, type_count;
  197.   kern_return_t result;
  198.   int index;
  199.   task_t task;

  201.   task = get_task_from_args (args);
  202.   if (task == TASK_NULL)
  203.     return;

  205.   result = mach_port_names (task, &names, &name_count, &types, &type_count);
  206.   MACH_CHECK_ERROR (result);

  208.   gdb_assert (name_count == type_count);

  210.   printf_unfiltered (_("Ports for task 0x%x:\n"), task);
  211.   printf_unfiltered (_("port   type\n"));
  212.   for (index = 0; index < name_count; ++index)
  213.     {
  214.       mach_port_t port = names[index];
  215.       unsigned int j;
  216.       struct type_descr
  217.       {
  218.         mach_port_type_t type;
  219.         const char *name;
  220.         mach_port_right_t right;
  221.       };
  222.       static struct type_descr descrs[] =
  223.         {
  224.           {MACH_PORT_TYPE_SEND, "send", MACH_PORT_RIGHT_SEND},
  225.           {MACH_PORT_TYPE_SEND_ONCE, "send-once", MACH_PORT_RIGHT_SEND_ONCE},
  226.           {MACH_PORT_TYPE_RECEIVE, "receive", MACH_PORT_RIGHT_RECEIVE},
  227.           {MACH_PORT_TYPE_PORT_SET, "port-set", MACH_PORT_RIGHT_PORT_SET},
  228.           {MACH_PORT_TYPE_DEAD_NAME, "dead", MACH_PORT_RIGHT_DEAD_NAME}
  229.         };

  231.       printf_unfiltered (_("%04x: %08x "), port, types[index]);
  232.       for (j = 0; j < sizeof(descrs) / sizeof(*descrs); j++)
  233.         if (types[index] & descrs[j].type)
  234.           {
  235.             mach_port_urefs_t ref;
  236.             kern_return_t ret;

  238.             printf_unfiltered (_(" %s("), descrs[j].name);
  239.             ret = mach_port_get_refs (task, port, descrs[j].right, &ref);
  240.             if (ret != KERN_SUCCESS)
  241.               printf_unfiltered (_("??"));
  242.             else
  243.               printf_unfiltered (_("%u"), ref);
  244.             printf_unfiltered (_(" refs)"));
  245.           }

  247.       if (task == task_self ())
  248.         {
  249.           if (port == task_self())
  250.             printf_unfiltered (_(" gdb-task"));
  251.           else if (port == darwin_host_self)
  252.             printf_unfiltered (_(" host-self"));
  253.           else if (port == darwin_ex_port)
  254.             printf_unfiltered (_(" gdb-exception"));
  255.           else if (port == darwin_port_set)
  256.             printf_unfiltered (_(" gdb-port_set"));
  257.           else if (!ptid_equal (inferior_ptid, null_ptid))
  258.             {
  259.               struct inferior *inf = current_inferior ();

  261.               if (port == inf->private->task)
  262.                 printf_unfiltered (_(" inferior-task"));
  263.               else if (port == inf->private->notify_port)
  264.                 printf_unfiltered (_(" inferior-notify"));
  265.               else
  266.                 {
  267.                   int k;
  268.                   darwin_thread_t *t;

  270.                   for (k = 0; k < inf->private->exception_info.count; k++)
  271.                     if (port == inf->private->exception_info.ports[k])
  272.                       {
  273.                         printf_unfiltered (_(" inferior-excp-port"));
  274.                         break;
  275.                       }

  277.                   if (inf->private->threads)
  278.                     {
  279.                       for (k = 0;
  280.                            VEC_iterate(darwin_thread_t,
  281.                                        inf->private->threads, k, t);
  282.                            k++)
  283.                         if (port == t->gdb_port)
  284.                           {
  285.                             printf_unfiltered (_(" inferior-thread for 0x%x"),
  286.                                                inf->private->task);
  287.                             break;
  288.                           }
  289.                     }
  290.                 }
  291.             }
  292.         }
  293.       printf_unfiltered (_("\n"));
  294.     }

  296.   vm_deallocate (task_self (), (vm_address_t) names,
  297.                  (name_count * sizeof (mach_port_t)));
  298.   vm_deallocate (task_self (), (vm_address_t) types,
  299.                  (type_count * sizeof (mach_port_type_t)));
  300. }


  303. static void
  304. ‌darwin_debug_port_info (task_t task, mach_port_t port)
  305. {
  306.   kern_return_t kret;
  307.   mach_port_status_t status;
  308.   mach_msg_type_number_t len = sizeof (status);

  310.   kret = mach_port_get_attributes
  311.     (task, port, MACH_PORT_RECEIVE_STATUS, (mach_port_info_t)&status, &len);
  312.   MACH_CHECK_ERROR (kret);

  314.   printf_unfiltered (_("Port 0x%lx in task 0x%lx:\n"), (unsigned long) port,
  315.                      (unsigned long) task);
  316.   printf_unfiltered (_("  port set: 0x%x\n"), status.mps_pset);
  317.   printf_unfiltered (_("     seqno: 0x%x\n"), status.mps_seqno);
  318.   printf_unfiltered (_("   mscount: 0x%x\n"), status.mps_mscount);
  319.   printf_unfiltered (_("    qlimit: 0x%x\n"), status.mps_qlimit);
  320.   printf_unfiltered (_("  msgcount: 0x%x\n"), status.mps_msgcount);
  321.   printf_unfiltered (_("  sorights: 0x%x\n"), status.mps_sorights);
  322.   printf_unfiltered (_("   srights: 0x%x\n"), status.mps_srights);
  323.   printf_unfiltered (_(" pdrequest: 0x%x\n"), status.mps_pdrequest);
  324.   printf_unfiltered (_(" nsrequest: 0x%x\n"), status.mps_nsrequest);
  325.   printf_unfiltered (_("     flags: 0x%x\n"), status.mps_flags);
  326. }

  328. static void
  329. ‌info_mach_port_command (char *args, int from_tty)
  330. {
  331.   task_t task;
  332.   mach_port_t port;

  334.   CHECK_ARGS (_("Task and port"), args);
  335.   sscanf (args, "0x%x 0x%x", &task, &port);

  337.   darwin_debug_port_info (task, port);
  338. }

  340. static void
  341. ‌info_mach_threads_command (char *args, int from_tty)
  342. {
  343.   thread_array_t threads;
  344.   unsigned int thread_count;
  345.   kern_return_t result;
  346.   task_t task;
  347.   int i;

  349.   task = get_task_from_args (args);
  350.   if (task == TASK_NULL)
  351.     return;

  353.   result = task_threads (task, &threads, &thread_count);
  354.   MACH_CHECK_ERROR (result);

  356.   printf_unfiltered (_("Threads in task %#x:\n"), task);
  357.   for (i = 0; i < thread_count; ++i)
  358.     {
  359.       printf_unfiltered (_("    %#x\n"), threads[i]);
  360.       mach_port_deallocate (task_self (), threads[i]);
  361.     }

  363.   vm_deallocate (task_self (), (vm_address_t) threads,
  364.                  (thread_count * sizeof (thread_t)));
  365. }

  367. static void
  368. ‌info_mach_thread_command (char *args, int from_tty)
  369. {
  370.   union
  371.   {
  372.     struct thread_basic_info basic;
  373.   } thread_info_data;

  375.   thread_t thread;
  376.   kern_return_t result;
  377.   unsigned int info_count;

  379.   CHECK_ARGS (_("Thread"), args);
  380.   sscanf (args, "0x%x", &thread);

  382.   printf_unfiltered (_("THREAD_BASIC_INFO\n"));
  383.   info_count = THREAD_BASIC_INFO_COUNT;
  384.   result = thread_info (thread,
  385.                         THREAD_BASIC_INFO,
  386.                         (thread_info_t) & thread_info_data.basic,
  387.                         &info_count);
  388.   MACH_CHECK_ERROR (result);

  390. #if 0
  391.   PRINT_FIELD (&thread_info_data.basic, user_time);
  392.   PRINT_FIELD (&thread_info_data.basic, system_time);
  393. #endif
  394.   PRINT_FIELD (&thread_info_data.basic, cpu_usage);
  395.   PRINT_FIELD (&thread_info_data.basic, run_state);
  396.   PRINT_FIELD (&thread_info_data.basic, flags);
  397.   PRINT_FIELD (&thread_info_data.basic, suspend_count);
  398.   PRINT_FIELD (&thread_info_data.basic, sleep_time);
  399. }

  401. static const char *
  402. ‌unparse_protection (vm_prot_t p)
  403. {
  404.   switch (p)
  405.     {
  406.     case VM_PROT_NONE:
  407.       return "---";
  408.     case VM_PROT_READ:
  409.       return "r--";
  410.     case VM_PROT_WRITE:
  411.       return "-w-";
  412.     case VM_PROT_READ | VM_PROT_WRITE:
  413.       return "rw-";
  414.     case VM_PROT_EXECUTE:
  415.       return "--x";
  416.     case VM_PROT_EXECUTE | VM_PROT_READ:
  417.       return "r-x";
  418.     case VM_PROT_EXECUTE | VM_PROT_WRITE:
  419.       return "-wx";
  420.     case VM_PROT_EXECUTE | VM_PROT_WRITE | VM_PROT_READ:
  421.       return "rwx";
  422.     default:
  423.       return "???";
  424.     }
  425. }

  427. static const char *
  428. ‌unparse_inheritance (vm_inherit_t i)
  429. {
  430.   switch (i)
  431.     {
  432.     case VM_INHERIT_SHARE:
  433.       return _("share");
  434.     case VM_INHERIT_COPY:
  435.       return _("copy ");
  436.     case VM_INHERIT_NONE:
  437.       return _("none ");
  438.     default:
  439.       return _("???  ");
  440.     }
  441. }

  443. static const char *
  444. ‌unparse_share_mode (unsigned char p)
  445. {
  446.   switch (p)
  447.     {
  448.     case SM_COW:
  449.       return _("cow");
  450.     case SM_PRIVATE:
  451.       return _("private");
  452.     case SM_EMPTY:
  453.       return _("empty");
  454.     case SM_SHARED:
  455.       return _("shared");
  456.     case SM_TRUESHARED:
  457.       return _("true-shrd");
  458.     case SM_PRIVATE_ALIASED:
  459.       return _("prv-alias");
  460.     case SM_SHARED_ALIASED:
  461.       return _("shr-alias");
  462.     default:
  463.       return _("???");
  464.     }
  465. }

  467. static const char *
  468. ‌unparse_user_tag (unsigned int tag)
  469. {
  470.   switch (tag)
  471.     {
  472.     case 0:
  473.       return _("default");
  474.     case VM_MEMORY_MALLOC:
  475.       return _("malloc");
  476.     case VM_MEMORY_MALLOC_SMALL:
  477.       return _("malloc_small");
  478.     case VM_MEMORY_MALLOC_LARGE:
  479.       return _("malloc_large");
  480.     case VM_MEMORY_MALLOC_HUGE:
  481.       return _("malloc_huge");
  482.     case VM_MEMORY_SBRK:
  483.       return _("sbrk");
  484.     case VM_MEMORY_REALLOC:
  485.       return _("realloc");
  486.     case VM_MEMORY_MALLOC_TINY:
  487.       return _("malloc_tiny");
  488.     case VM_MEMORY_ANALYSIS_TOOL:
  489.       return _("analysis_tool");
  490.     case VM_MEMORY_MACH_MSG:
  491.       return _("mach_msg");
  492.     case VM_MEMORY_IOKIT:
  493.       return _("iokit");
  494.     case VM_MEMORY_STACK:
  495.       return _("stack");
  496.     case VM_MEMORY_GUARD:
  497.       return _("guard");
  498.     case VM_MEMORY_SHARED_PMAP:
  499.       return _("shared_pmap");
  500.     case VM_MEMORY_DYLIB:
  501.       return _("dylib");
  502.     case VM_MEMORY_APPKIT:
  503.       return _("appkit");
  504.     case VM_MEMORY_FOUNDATION:
  505.       return _("foundation");
  506.     default:
  507.       return NULL;
  508.     }
  509. }

  511. static void
  512. ‌darwin_debug_regions (task_t task, mach_vm_address_t address, int max)
  513. {
  514.   kern_return_t kret;
  515.   vm_region_basic_info_data_64_t info, prev_info;
  516.   mach_vm_address_t prev_address;
  517.   mach_vm_size_t size, prev_size;

  519.   mach_port_t object_name;
  520.   mach_msg_type_number_t count;

  522.   int nsubregions = 0;
  523.   int num_printed = 0;

  525.   count = VM_REGION_BASIC_INFO_COUNT_64;
  526.   kret = mach_vm_region (task, &address, &size, VM_REGION_BASIC_INFO_64,
  527.                          (vm_region_info_t) &info, &count, &object_name);
  528.   if (kret != KERN_SUCCESS)
  529.     {
  530.       printf_filtered (_("No memory regions."));
  531.       return;
  532.     }
  533.   memcpy (&prev_info, &info, sizeof (vm_region_basic_info_data_64_t));
  534.   prev_address = address;
  535.   prev_size = size;
  536.   nsubregions = 1;

  538.   for (;;)
  539.     {
  540.       int print = 0;
  541.       int done = 0;

  543.       address = prev_address + prev_size;

  545.       /* Check to see if address space has wrapped around.  */
  546.       if (address == 0)
  547.         print = done = 1;

  549.       if (!done)
  550.         {
  551.           count = VM_REGION_BASIC_INFO_COUNT_64;
  552.           kret =
  553.             mach_vm_region (task, &address, &size, VM_REGION_BASIC_INFO_64,
  554.                                (vm_region_info_t) &info, &count, &object_name);
  555.           if (kret != KERN_SUCCESS)
  556.             {
  557.               size = 0;
  558.               print = done = 1;
  559.             }
  560.         }

  562.       if (address != prev_address + prev_size)
  563.         print = 1;

  565.       if ((info.protection != prev_info.protection)
  566.           || (info.max_protection != prev_info.max_protection)
  567.           || (info.inheritance != prev_info.inheritance)
  568.           || (info.shared != prev_info.reserved)
  569.           || (info.reserved != prev_info.reserved))
  570.         print = 1;

  572.       if (print)
  573.         {
  574.           printf_filtered (_("%s-%s %s/%s  %s %s %s"),
  575.                            paddress (target_gdbarch (), prev_address),
  576.                            paddress (target_gdbarch (), prev_address + prev_size),
  577.                            unparse_protection (prev_info.protection),
  578.                            unparse_protection (prev_info.max_protection),
  579.                            unparse_inheritance (prev_info.inheritance),
  580.                            prev_info.shared ? _("shrd") : _("priv"),
  581.                            prev_info.reserved ? _("reserved") : _("not-rsvd"));

  583.           if (nsubregions > 1)
  584.             printf_filtered (_(" (%d sub-rgn)"), nsubregions);

  586.           printf_filtered (_("\n"));

  588.           prev_address = address;
  589.           prev_size = size;
  590.           memcpy (&prev_info, &info, sizeof (vm_region_basic_info_data_64_t));
  591.           nsubregions = 1;

  593.           num_printed++;
  594.         }
  595.       else
  596.         {
  597.           prev_size += size;
  598.           nsubregions++;
  599.         }

  601.       if ((max > 0) && (num_printed >= max))
  602.         done = 1;

  604.       if (done)
  605.         break;
  606.     }
  607. }

  609. static void
  610. ‌darwin_debug_regions_recurse (task_t task)
  611. {
  612.   mach_vm_address_t r_addr;
  613.   mach_vm_address_t r_start;
  614.   mach_vm_size_t r_size;
  615.   natural_t r_depth;
  616.   mach_msg_type_number_t r_info_size;
  617.   vm_region_submap_short_info_data_64_t r_info;
  618.   kern_return_t kret;
  619.   int ret;
  620.   struct cleanup *table_chain;
  621.   struct ui_out *uiout = current_uiout;

  623.   table_chain = make_cleanup_ui_out_table_begin_end (uiout, 9, -1, "regions");

  625.   if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
  626.     {
  627.       ui_out_table_header (uiout, 10, ui_left, "start", "Start");
  628.       ui_out_table_header (uiout, 10, ui_left, "end", "End");
  629.     }
  630.   else
  631.     {
  632.       ui_out_table_header (uiout, 18, ui_left, "start", "Start");
  633.       ui_out_table_header (uiout, 18, ui_left, "end", "End");
  634.     }
  635.   ui_out_table_header (uiout, 3, ui_left, "min-prot", "Min");
  636.   ui_out_table_header (uiout, 3, ui_left, "max-prot", "Max");
  637.   ui_out_table_header (uiout, 5, ui_left, "inheritence", "Inh");
  638.   ui_out_table_header (uiout, 9, ui_left, "share-mode", "Shr");
  639.   ui_out_table_header (uiout, 1, ui_left, "depth", "D");
  640.   ui_out_table_header (uiout, 3, ui_left, "submap", "Sm");
  641.   ui_out_table_header (uiout, 0, ui_noalign, "tag", "Tag");

  643.   ui_out_table_body (uiout);

  645.   r_start = 0;
  646.   r_depth = 0;
  647.   while (1)
  648.     {
  649.       const char *tag;
  650.       struct cleanup *row_chain;

  652.       r_info_size = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
  653.       r_size = -1;
  654.       kret = mach_vm_region_recurse (task, &r_start, &r_size, &r_depth,
  655.                                      (vm_region_recurse_info_t) &r_info,
  656.                                      &r_info_size);
  657.       if (kret != KERN_SUCCESS)
  658.         break;
  659.       row_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "regions-row");

  661.       ui_out_field_core_addr (uiout, "start", target_gdbarch (), r_start);
  662.       ui_out_field_core_addr (uiout, "end", target_gdbarch (), r_start + r_size);
  663.       ui_out_field_string (uiout, "min-prot",
  664.                            unparse_protection (r_info.protection));
  665.       ui_out_field_string (uiout, "max-prot",
  666.                            unparse_protection (r_info.max_protection));
  667.       ui_out_field_string (uiout, "inheritence",
  668.                            unparse_inheritance (r_info.inheritance));
  669.       ui_out_field_string (uiout, "share-mode",
  670.                            unparse_share_mode (r_info.share_mode));
  671.       ui_out_field_int (uiout, "depth", r_depth);
  672.       ui_out_field_string (uiout, "submap",
  673.                            r_info.is_submap ? _("sm ") : _("obj"));
  674.       tag = unparse_user_tag (r_info.user_tag);
  675.       if (tag)
  676.         ui_out_field_string (uiout, "tag", tag);
  677.       else
  678.         ui_out_field_int (uiout, "tag", r_info.user_tag);

  680.       do_cleanups (row_chain);

  682.       if (!ui_out_is_mi_like_p (uiout))
  683.         ui_out_text (uiout, "\n");

  685.       if (r_info.is_submap)
  686.         r_depth++;
  687.       else
  688.         r_start += r_size;
  689.     }
  690.   do_cleanups (table_chain);

  692. }


  695. static void
  696. ‌darwin_debug_region (task_t task, mach_vm_address_t address)
  697. {
  698.   darwin_debug_regions (task, address, 1);
  699. }

  701. static void
  702. ‌info_mach_regions_command (char *args, int from_tty)
  703. {
  704.   task_t task;

  706.   task = get_task_from_args (args);
  707.   if (task == TASK_NULL)
  708.     return;

  710.   darwin_debug_regions (task, 0, -1);
  711. }

  713. static void
  714. ‌info_mach_regions_recurse_command (char *args, int from_tty)
  715. {
  716.   task_t task;

  718.   task = get_task_from_args (args);
  719.   if (task == TASK_NULL)
  720.     return;

  722.   darwin_debug_regions_recurse (task);
  723. }

  725. static void
  726. ‌info_mach_region_command (char *exp, int from_tty)
  727. {
  728.   struct expression *expr;
  729.   struct value *val;
  730.   mach_vm_address_t address;
  731.   struct inferior *inf;

  733.   expr = parse_expression (exp);
  734.   val = evaluate_expression (expr);
  735.   if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
  736.     {
  737.       val = value_ind (val);
  738.     }
  739.   address = value_as_address (val);

  741.   if (ptid_equal (inferior_ptid, null_ptid))
  742.     error (_("Inferior not available"));

  744.   inf = current_inferior ();
  745.   darwin_debug_region (inf->private->task, address);
  746. }

  748. static void
  749. ‌disp_exception (const darwin_exception_info *info)
  750. {
  751.   int i;

  753.   printf_filtered (_("%d exceptions:\n"), info->count);
  754.   for (i = 0; i < info->count; i++)
  755.     {
  756.       exception_mask_t mask = info->masks[i];

  758.       printf_filtered (_("port 0x%04x, behavior: "), info->ports[i]);
  759.       switch (info->behaviors[i])
  760.         {
  761.         case EXCEPTION_DEFAULT:
  762.           printf_unfiltered (_("default"));
  763.           break;
  764.         case EXCEPTION_STATE:
  765.           printf_unfiltered (_("state"));
  766.           break;
  767.         case EXCEPTION_STATE_IDENTITY:
  768.           printf_unfiltered (_("state-identity"));
  769.           break;
  770.         default:
  771.           printf_unfiltered (_("0x%x"), info->behaviors[i]);
  772.         }
  773.       printf_unfiltered (_(", masks:"));
  774.       if (mask & EXC_MASK_BAD_ACCESS)
  775.         printf_unfiltered (_(" BAD_ACCESS"));
  776.       if (mask & EXC_MASK_BAD_INSTRUCTION)
  777.         printf_unfiltered (_(" BAD_INSTRUCTION"));
  778.       if (mask & EXC_MASK_ARITHMETIC)
  779.         printf_unfiltered (_(" ARITHMETIC"));
  780.       if (mask & EXC_MASK_EMULATION)
  781.         printf_unfiltered (_(" EMULATION"));
  782.       if (mask & EXC_MASK_SOFTWARE)
  783.         printf_unfiltered (_(" SOFTWARE"));
  784.       if (mask & EXC_MASK_BREAKPOINT)
  785.         printf_unfiltered (_(" BREAKPOINT"));
  786.       if (mask & EXC_MASK_SYSCALL)
  787.         printf_unfiltered (_(" SYSCALL"));
  788.       if (mask & EXC_MASK_MACH_SYSCALL)
  789.         printf_unfiltered (_(" MACH_SYSCALL"));
  790.       if (mask & EXC_MASK_RPC_ALERT)
  791.         printf_unfiltered (_(" RPC_ALERT"));
  792.       if (mask & EXC_MASK_CRASH)
  793.         printf_unfiltered (_(" CRASH"));
  794.       printf_unfiltered (_("\n"));
  795.     }
  796. }

  798. static void
  799. ‌info_mach_exceptions_command (char *args, int from_tty)
  800. {
  801.   int i;
  802.   task_t task;
  803.   kern_return_t kret;
  804.   darwin_exception_info info;

  806.   info.count = sizeof (info.ports) / sizeof (info.ports[0]);

  808.   if (args != NULL)
  809.     {
  810.       if (strcmp (args, "saved") == 0)
  811.         {
  812.           if (ptid_equal (inferior_ptid, null_ptid))
  813.             printf_unfiltered (_("No inferior running\n"));
  814.           disp_exception (&current_inferior ()->private->exception_info);
  815.           return;
  816.         }
  817.       else if (strcmp (args, "host") == 0)
  818.         {
  819.           /* FIXME: This need a privilegied host port!  */
  820.           kret = host_get_exception_ports
  821.             (darwin_host_self, EXC_MASK_ALL, info.masks,
  822.              &info.count, info.ports, info.behaviors, info.flavors);
  823.           MACH_CHECK_ERROR (kret);
  824.           disp_exception (&info);
  825.         }
  826.       else
  827.         error (_("Parameter is saved, host or none"));
  828.     }
  829.   else
  830.     {
  831.       struct inferior *inf;

  833.       if (ptid_equal (inferior_ptid, null_ptid))
  834.         printf_unfiltered (_("No inferior running\n"));
  835.       inf = current_inferior ();

  837.       kret = task_get_exception_ports
  838.         (inf->private->task, EXC_MASK_ALL, info.masks,
  839.          &info.count, info.ports, info.behaviors, info.flavors);
  840.       MACH_CHECK_ERROR (kret);
  841.       disp_exception (&info);
  842.     }
  843. }

  845. /* -Wmissing-prototypes */
  846. extern initialize_file_ftype _initialize_darwin_info_commands;

  848. void
  849. ‌_initialize_darwin_info_commands (void)
  850. {
  851.   add_info ("mach-tasks", info_mach_tasks_command,
  852.             _("Get list of tasks in system."));
  853.   add_info ("mach-ports", info_mach_ports_command,
  854.             _("Get list of ports in a task."));
  855.   add_info ("mach-port", info_mach_port_command,
  856.             _("Get info on a specific port."));
  857.   add_info ("mach-task", info_mach_task_command,
  858.             _("Get info on a specific task."));
  859.   add_info ("mach-threads", info_mach_threads_command,
  860.             _("Get list of threads in a task."));
  861.   add_info ("mach-thread", info_mach_thread_command,
  862.             _("Get info on a specific thread."));

  864.   add_info ("mach-regions", info_mach_regions_command,
  865.             _("Get information on all mach region for the task."));
  866.   add_info ("mach-regions-rec", info_mach_regions_recurse_command,
  867.             _("Get information on all mach sub region for the task."));
  868.   add_info ("mach-region", info_mach_region_command,
  869.             _("Get information on mach region at given address."));

  871.   add_info ("mach-exceptions", info_mach_exceptions_command,
  872.             _("Disp mach exceptions."));
  873. }