1 /* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 1997-2023 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. */
39 #include <sys/sysctl.h>
41 #include "darwin-nat.h"
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>
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); \
56 #define PRINT_FIELD(structure, field) \
57 gdb_printf(_(#field":\t%#lx\n"), (unsigned long) (structure)->field)
59 #define PRINT_TV_FIELD(structure, field) \
60 gdb_printf(_(#field":\t%u.%06u sec\n"), \
61 (unsigned) (structure)->field.seconds, \
62 (unsigned) (structure)->field.microseconds)
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
70 info_mach_tasks_command (const char *args
, int from_tty
)
75 struct kinfo_proc
*procInfo
;
77 sysControl
[0] = CTL_KERN
;
78 sysControl
[1] = KERN_PROC
;
79 sysControl
[2] = KERN_PROC_ALL
;
81 sysctl (sysControl
, 3, NULL
, &length
, NULL
, 0);
82 procInfo
= (struct kinfo_proc
*) xmalloc (length
);
83 sysctl (sysControl
, 3, procInfo
, &length
, NULL
, 0);
85 count
= (length
/ sizeof (struct kinfo_proc
));
86 gdb_printf (_("%d processes:\n"), count
);
87 for (index
= 0; index
< count
; ++index
)
93 task_by_unix_pid (mach_task_self (), procInfo
[index
].kp_proc
.p_pid
,
95 if (KERN_SUCCESS
== result
)
97 gdb_printf (_(" %s is %d has task %#x\n"),
98 procInfo
[index
].kp_proc
.p_comm
,
99 procInfo
[index
].kp_proc
.p_pid
, taskPort
);
103 gdb_printf (_(" %s is %d unknown task port\n"),
104 procInfo
[index
].kp_proc
.p_comm
,
105 procInfo
[index
].kp_proc
.p_pid
);
113 get_task_from_args (const char *args
)
118 if (args
== NULL
|| *args
== 0)
120 if (inferior_ptid
== null_ptid
)
121 gdb_printf (_("No inferior running\n"));
123 darwin_inferior
*priv
= get_darwin_inferior (current_inferior ());
127 if (strcmp (args
, "gdb") == 0)
128 return mach_task_self ();
129 task
= strtoul (args
, &eptr
, 0);
132 gdb_printf (_("cannot parse task id '%s'\n"), args
);
139 info_mach_task_command (const char *args
, int from_tty
)
143 struct task_basic_info basic
;
144 struct task_events_info events
;
145 struct task_thread_times_info thread_times
;
148 kern_return_t result
;
149 unsigned int info_count
;
152 task
= get_task_from_args (args
);
153 if (task
== TASK_NULL
)
156 gdb_printf (_("TASK_BASIC_INFO for 0x%x:\n"), task
);
157 info_count
= TASK_BASIC_INFO_COUNT
;
158 result
= task_info (task
,
160 (task_info_t
) & task_info_data
.basic
, &info_count
);
161 MACH_CHECK_ERROR (result
);
163 PRINT_FIELD (&task_info_data
.basic
, suspend_count
);
164 PRINT_FIELD (&task_info_data
.basic
, virtual_size
);
165 PRINT_FIELD (&task_info_data
.basic
, resident_size
);
166 PRINT_TV_FIELD (&task_info_data
.basic
, user_time
);
167 PRINT_TV_FIELD (&task_info_data
.basic
, system_time
);
168 gdb_printf (_("\nTASK_EVENTS_INFO:\n"));
169 info_count
= TASK_EVENTS_INFO_COUNT
;
170 result
= task_info (task
,
172 (task_info_t
) & task_info_data
.events
, &info_count
);
173 MACH_CHECK_ERROR (result
);
175 PRINT_FIELD (&task_info_data
.events
, faults
);
177 PRINT_FIELD (&task_info_data
.events
, zero_fills
);
178 PRINT_FIELD (&task_info_data
.events
, reactivations
);
180 PRINT_FIELD (&task_info_data
.events
, pageins
);
181 PRINT_FIELD (&task_info_data
.events
, cow_faults
);
182 PRINT_FIELD (&task_info_data
.events
, messages_sent
);
183 PRINT_FIELD (&task_info_data
.events
, messages_received
);
184 gdb_printf (_("\nTASK_THREAD_TIMES_INFO:\n"));
185 info_count
= TASK_THREAD_TIMES_INFO_COUNT
;
186 result
= task_info (task
,
187 TASK_THREAD_TIMES_INFO
,
188 (task_info_t
) & task_info_data
.thread_times
,
190 MACH_CHECK_ERROR (result
);
191 PRINT_TV_FIELD (&task_info_data
.thread_times
, user_time
);
192 PRINT_TV_FIELD (&task_info_data
.thread_times
, system_time
);
196 info_mach_ports_command (const char *args
, int from_tty
)
198 port_name_array_t names
;
199 port_type_array_t types
;
200 unsigned int name_count
, type_count
;
201 kern_return_t result
;
205 task
= get_task_from_args (args
);
206 if (task
== TASK_NULL
)
209 result
= mach_port_names (task
, &names
, &name_count
, &types
, &type_count
);
210 MACH_CHECK_ERROR (result
);
212 gdb_assert (name_count
== type_count
);
214 gdb_printf (_("Ports for task 0x%x:\n"), task
);
215 gdb_printf (_("port type\n"));
216 for (index
= 0; index
< name_count
; ++index
)
218 mach_port_t port
= names
[index
];
222 mach_port_type_t type
;
224 mach_port_right_t right
;
226 static struct type_descr descrs
[] =
228 {MACH_PORT_TYPE_SEND
, "send", MACH_PORT_RIGHT_SEND
},
229 {MACH_PORT_TYPE_SEND_ONCE
, "send-once", MACH_PORT_RIGHT_SEND_ONCE
},
230 {MACH_PORT_TYPE_RECEIVE
, "receive", MACH_PORT_RIGHT_RECEIVE
},
231 {MACH_PORT_TYPE_PORT_SET
, "port-set", MACH_PORT_RIGHT_PORT_SET
},
232 {MACH_PORT_TYPE_DEAD_NAME
, "dead", MACH_PORT_RIGHT_DEAD_NAME
}
235 gdb_printf (_("%04x: %08x "), port
, types
[index
]);
236 for (j
= 0; j
< sizeof(descrs
) / sizeof(*descrs
); j
++)
237 if (types
[index
] & descrs
[j
].type
)
239 mach_port_urefs_t ref
;
242 gdb_printf (_(" %s("), descrs
[j
].name
);
243 ret
= mach_port_get_refs (task
, port
, descrs
[j
].right
, &ref
);
244 if (ret
!= KERN_SUCCESS
)
245 gdb_printf (_("??"));
247 gdb_printf (_("%u"), ref
);
248 gdb_printf (_(" refs)"));
251 if (task
== task_self ())
253 if (port
== task_self())
254 gdb_printf (_(" gdb-task"));
255 else if (port
== darwin_host_self
)
256 gdb_printf (_(" host-self"));
257 else if (port
== darwin_ex_port
)
258 gdb_printf (_(" gdb-exception"));
259 else if (port
== darwin_port_set
)
260 gdb_printf (_(" gdb-port_set"));
261 else if (inferior_ptid
!= null_ptid
)
263 struct inferior
*inf
= current_inferior ();
264 darwin_inferior
*priv
= get_darwin_inferior (inf
);
266 if (port
== priv
->task
)
267 gdb_printf (_(" inferior-task"));
268 else if (port
== priv
->notify_port
)
269 gdb_printf (_(" inferior-notify"));
272 for (int k
= 0; k
< priv
->exception_info
.count
; k
++)
273 if (port
== priv
->exception_info
.ports
[k
])
275 gdb_printf (_(" inferior-excp-port"));
279 for (darwin_thread_t
*t
: priv
->threads
)
281 if (port
== t
->gdb_port
)
283 gdb_printf (_(" inferior-thread for 0x%x"),
292 gdb_printf (_("\n"));
295 vm_deallocate (task_self (), (vm_address_t
) names
,
296 (name_count
* sizeof (mach_port_t
)));
297 vm_deallocate (task_self (), (vm_address_t
) types
,
298 (type_count
* sizeof (mach_port_type_t
)));
303 darwin_debug_port_info (task_t task
, mach_port_t port
)
306 mach_port_status_t status
;
307 mach_msg_type_number_t len
= sizeof (status
);
309 kret
= mach_port_get_attributes
310 (task
, port
, MACH_PORT_RECEIVE_STATUS
, (mach_port_info_t
)&status
, &len
);
311 MACH_CHECK_ERROR (kret
);
313 gdb_printf (_("Port 0x%lx in task 0x%lx:\n"), (unsigned long) port
,
314 (unsigned long) task
);
315 gdb_printf (_(" port set: 0x%x\n"), status
.mps_pset
);
316 gdb_printf (_(" seqno: 0x%x\n"), status
.mps_seqno
);
317 gdb_printf (_(" mscount: 0x%x\n"), status
.mps_mscount
);
318 gdb_printf (_(" qlimit: 0x%x\n"), status
.mps_qlimit
);
319 gdb_printf (_(" msgcount: 0x%x\n"), status
.mps_msgcount
);
320 gdb_printf (_(" sorights: 0x%x\n"), status
.mps_sorights
);
321 gdb_printf (_(" srights: 0x%x\n"), status
.mps_srights
);
322 gdb_printf (_(" pdrequest: 0x%x\n"), status
.mps_pdrequest
);
323 gdb_printf (_(" nsrequest: 0x%x\n"), status
.mps_nsrequest
);
324 gdb_printf (_(" flags: 0x%x\n"), status
.mps_flags
);
328 info_mach_port_command (const char *args
, int from_tty
)
333 CHECK_ARGS (_("Task and port"), args
);
334 sscanf (args
, "0x%x 0x%x", &task
, &port
);
336 darwin_debug_port_info (task
, port
);
340 info_mach_threads_command (const char *args
, int from_tty
)
342 thread_array_t threads
;
343 unsigned int thread_count
;
344 kern_return_t result
;
348 task
= get_task_from_args (args
);
349 if (task
== TASK_NULL
)
352 result
= task_threads (task
, &threads
, &thread_count
);
353 MACH_CHECK_ERROR (result
);
355 gdb_printf (_("Threads in task %#x:\n"), task
);
356 for (i
= 0; i
< thread_count
; ++i
)
358 gdb_printf (_(" %#x\n"), threads
[i
]);
359 mach_port_deallocate (task_self (), threads
[i
]);
362 vm_deallocate (task_self (), (vm_address_t
) threads
,
363 (thread_count
* sizeof (thread_t
)));
367 info_mach_thread_command (const char *args
, int from_tty
)
371 struct thread_basic_info basic
;
375 kern_return_t result
;
376 unsigned int info_count
;
378 CHECK_ARGS (_("Thread"), args
);
379 sscanf (args
, "0x%x", &thread
);
381 gdb_printf (_("THREAD_BASIC_INFO\n"));
382 info_count
= THREAD_BASIC_INFO_COUNT
;
383 result
= thread_info (thread
,
385 (thread_info_t
) & thread_info_data
.basic
,
387 MACH_CHECK_ERROR (result
);
390 PRINT_FIELD (&thread_info_data
.basic
, user_time
);
391 PRINT_FIELD (&thread_info_data
.basic
, system_time
);
393 PRINT_FIELD (&thread_info_data
.basic
, cpu_usage
);
394 PRINT_FIELD (&thread_info_data
.basic
, run_state
);
395 PRINT_FIELD (&thread_info_data
.basic
, flags
);
396 PRINT_FIELD (&thread_info_data
.basic
, suspend_count
);
397 PRINT_FIELD (&thread_info_data
.basic
, sleep_time
);
401 unparse_protection (vm_prot_t p
)
411 case VM_PROT_READ
| VM_PROT_WRITE
:
413 case VM_PROT_EXECUTE
:
415 case VM_PROT_EXECUTE
| VM_PROT_READ
:
417 case VM_PROT_EXECUTE
| VM_PROT_WRITE
:
419 case VM_PROT_EXECUTE
| VM_PROT_WRITE
| VM_PROT_READ
:
427 unparse_inheritance (vm_inherit_t i
)
431 case VM_INHERIT_SHARE
:
433 case VM_INHERIT_COPY
:
435 case VM_INHERIT_NONE
:
443 unparse_share_mode (unsigned char p
)
456 return _("true-shrd");
457 case SM_PRIVATE_ALIASED
:
458 return _("prv-alias");
459 case SM_SHARED_ALIASED
:
460 return _("shr-alias");
467 unparse_user_tag (unsigned int tag
)
473 case VM_MEMORY_MALLOC
:
475 case VM_MEMORY_MALLOC_SMALL
:
476 return _("malloc_small");
477 case VM_MEMORY_MALLOC_LARGE
:
478 return _("malloc_large");
479 case VM_MEMORY_MALLOC_HUGE
:
480 return _("malloc_huge");
483 case VM_MEMORY_REALLOC
:
485 case VM_MEMORY_MALLOC_TINY
:
486 return _("malloc_tiny");
487 case VM_MEMORY_ANALYSIS_TOOL
:
488 return _("analysis_tool");
489 case VM_MEMORY_MACH_MSG
:
490 return _("mach_msg");
491 case VM_MEMORY_IOKIT
:
493 case VM_MEMORY_STACK
:
495 case VM_MEMORY_GUARD
:
497 case VM_MEMORY_SHARED_PMAP
:
498 return _("shared_pmap");
499 case VM_MEMORY_DYLIB
:
501 case VM_MEMORY_APPKIT
:
503 case VM_MEMORY_FOUNDATION
:
504 return _("foundation");
511 darwin_debug_regions (task_t task
, mach_vm_address_t address
, int max
)
514 vm_region_basic_info_data_64_t info
, prev_info
;
515 mach_vm_address_t prev_address
;
516 mach_vm_size_t size
, prev_size
;
518 mach_port_t object_name
;
519 mach_msg_type_number_t count
;
524 count
= VM_REGION_BASIC_INFO_COUNT_64
;
525 kret
= mach_vm_region (task
, &address
, &size
, VM_REGION_BASIC_INFO_64
,
526 (vm_region_info_t
) &info
, &count
, &object_name
);
527 if (kret
!= KERN_SUCCESS
)
529 gdb_printf (_("No memory regions."));
532 memcpy (&prev_info
, &info
, sizeof (vm_region_basic_info_data_64_t
));
533 prev_address
= address
;
542 address
= prev_address
+ prev_size
;
544 /* Check to see if address space has wrapped around. */
550 count
= VM_REGION_BASIC_INFO_COUNT_64
;
552 mach_vm_region (task
, &address
, &size
, VM_REGION_BASIC_INFO_64
,
553 (vm_region_info_t
) &info
, &count
, &object_name
);
554 if (kret
!= KERN_SUCCESS
)
561 if (address
!= prev_address
+ prev_size
)
564 if ((info
.protection
!= prev_info
.protection
)
565 || (info
.max_protection
!= prev_info
.max_protection
)
566 || (info
.inheritance
!= prev_info
.inheritance
)
567 || (info
.shared
!= prev_info
.reserved
)
568 || (info
.reserved
!= prev_info
.reserved
))
573 gdbarch
*arch
= current_inferior ()->arch ();
574 gdb_printf (_("%s-%s %s/%s %s %s %s"),
575 paddress (arch
, prev_address
),
576 paddress (arch
, 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"));
584 gdb_printf (_(" (%d sub-rgn)"), nsubregions
);
586 gdb_printf (_("\n"));
588 prev_address
= address
;
590 memcpy (&prev_info
, &info
, sizeof (vm_region_basic_info_data_64_t
));
601 if ((max
> 0) && (num_printed
>= max
))
610 darwin_debug_regions_recurse (task_t task
)
612 mach_vm_address_t r_start
;
613 mach_vm_size_t r_size
;
615 mach_msg_type_number_t r_info_size
;
616 vm_region_submap_short_info_data_64_t r_info
;
618 struct ui_out
*uiout
= current_uiout
;
620 ui_out_emit_table
table_emitter (uiout
, 9, -1, "regions");
622 if (gdbarch_addr_bit (current_inferior ()->arch ()) <= 32)
624 uiout
->table_header (10, ui_left
, "start", "Start");
625 uiout
->table_header (10, ui_left
, "end", "End");
629 uiout
->table_header (18, ui_left
, "start", "Start");
630 uiout
->table_header (18, ui_left
, "end", "End");
632 uiout
->table_header (3, ui_left
, "min-prot", "Min");
633 uiout
->table_header (3, ui_left
, "max-prot", "Max");
634 uiout
->table_header (5, ui_left
, "inheritence", "Inh");
635 uiout
->table_header (9, ui_left
, "share-mode", "Shr");
636 uiout
->table_header (1, ui_left
, "depth", "D");
637 uiout
->table_header (3, ui_left
, "submap", "Sm");
638 uiout
->table_header (0, ui_noalign
, "tag", "Tag");
640 uiout
->table_body ();
648 r_info_size
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
650 kret
= mach_vm_region_recurse (task
, &r_start
, &r_size
, &r_depth
,
651 (vm_region_recurse_info_t
) &r_info
,
653 if (kret
!= KERN_SUCCESS
)
657 ui_out_emit_tuple
tuple_emitter (uiout
, "regions-row");
658 gdbarch
*arch
= current_inferior ()->arch ();
660 uiout
->field_core_addr ("start", arch
, r_start
);
661 uiout
->field_core_addr ("end", arch
, r_start
+ r_size
);
662 uiout
->field_string ("min-prot",
663 unparse_protection (r_info
.protection
));
664 uiout
->field_string ("max-prot",
665 unparse_protection (r_info
.max_protection
));
666 uiout
->field_string ("inheritence",
667 unparse_inheritance (r_info
.inheritance
));
668 uiout
->field_string ("share-mode",
669 unparse_share_mode (r_info
.share_mode
));
670 uiout
->field_signed ("depth", r_depth
);
671 uiout
->field_string ("submap",
672 r_info
.is_submap
? _("sm ") : _("obj"));
673 tag
= unparse_user_tag (r_info
.user_tag
);
675 uiout
->field_string ("tag", tag
);
677 uiout
->field_signed ("tag", r_info
.user_tag
);
682 if (r_info
.is_submap
)
691 darwin_debug_region (task_t task
, mach_vm_address_t address
)
693 darwin_debug_regions (task
, address
, 1);
697 info_mach_regions_command (const char *args
, int from_tty
)
701 task
= get_task_from_args (args
);
702 if (task
== TASK_NULL
)
705 darwin_debug_regions (task
, 0, -1);
709 info_mach_regions_recurse_command (const char *args
, int from_tty
)
713 task
= get_task_from_args (args
);
714 if (task
== TASK_NULL
)
717 darwin_debug_regions_recurse (task
);
721 info_mach_region_command (const char *exp
, int from_tty
)
724 mach_vm_address_t address
;
725 struct inferior
*inf
;
727 expression_up expr
= parse_expression (exp
);
728 val
= expr
->evaluate ();
729 if (TYPE_IS_REFERENCE (val
->type ()))
731 val
= value_ind (val
);
733 address
= value_as_address (val
);
735 if (inferior_ptid
== null_ptid
)
736 error (_("Inferior not available"));
738 inf
= current_inferior ();
739 darwin_inferior
*priv
= get_darwin_inferior (inf
);
740 darwin_debug_region (priv
->task
, address
);
744 disp_exception (const darwin_exception_info
*info
)
748 gdb_printf (_("%d exceptions:\n"), info
->count
);
749 for (i
= 0; i
< info
->count
; i
++)
751 exception_mask_t mask
= info
->masks
[i
];
753 gdb_printf (_("port 0x%04x, behavior: "), info
->ports
[i
]);
754 switch (info
->behaviors
[i
])
756 case EXCEPTION_DEFAULT
:
757 gdb_printf (_("default"));
759 case EXCEPTION_STATE
:
760 gdb_printf (_("state"));
762 case EXCEPTION_STATE_IDENTITY
:
763 gdb_printf (_("state-identity"));
766 gdb_printf (_("0x%x"), info
->behaviors
[i
]);
768 gdb_printf (_(", masks:"));
769 if (mask
& EXC_MASK_BAD_ACCESS
)
770 gdb_printf (_(" BAD_ACCESS"));
771 if (mask
& EXC_MASK_BAD_INSTRUCTION
)
772 gdb_printf (_(" BAD_INSTRUCTION"));
773 if (mask
& EXC_MASK_ARITHMETIC
)
774 gdb_printf (_(" ARITHMETIC"));
775 if (mask
& EXC_MASK_EMULATION
)
776 gdb_printf (_(" EMULATION"));
777 if (mask
& EXC_MASK_SOFTWARE
)
778 gdb_printf (_(" SOFTWARE"));
779 if (mask
& EXC_MASK_BREAKPOINT
)
780 gdb_printf (_(" BREAKPOINT"));
781 if (mask
& EXC_MASK_SYSCALL
)
782 gdb_printf (_(" SYSCALL"));
783 if (mask
& EXC_MASK_MACH_SYSCALL
)
784 gdb_printf (_(" MACH_SYSCALL"));
785 if (mask
& EXC_MASK_RPC_ALERT
)
786 gdb_printf (_(" RPC_ALERT"));
787 if (mask
& EXC_MASK_CRASH
)
788 gdb_printf (_(" CRASH"));
789 gdb_printf (_("\n"));
794 info_mach_exceptions_command (const char *args
, int from_tty
)
797 darwin_exception_info info
;
799 info
.count
= sizeof (info
.ports
) / sizeof (info
.ports
[0]);
803 if (strcmp (args
, "saved") == 0)
805 if (inferior_ptid
== null_ptid
)
806 gdb_printf (_("No inferior running\n"));
808 darwin_inferior
*priv
= get_darwin_inferior (current_inferior ());
810 disp_exception (&priv
->exception_info
);
813 else if (strcmp (args
, "host") == 0)
815 /* FIXME: This needs a privileged host port! */
816 kret
= host_get_exception_ports
817 (darwin_host_self
, EXC_MASK_ALL
, info
.masks
,
818 &info
.count
, info
.ports
, info
.behaviors
, info
.flavors
);
819 MACH_CHECK_ERROR (kret
);
820 disp_exception (&info
);
823 error (_("Parameter is saved, host or none"));
827 struct inferior
*inf
;
829 if (inferior_ptid
== null_ptid
)
830 gdb_printf (_("No inferior running\n"));
831 inf
= current_inferior ();
833 darwin_inferior
*priv
= get_darwin_inferior (inf
);
835 kret
= task_get_exception_ports
836 (priv
->task
, EXC_MASK_ALL
, info
.masks
,
837 &info
.count
, info
.ports
, info
.behaviors
, info
.flavors
);
838 MACH_CHECK_ERROR (kret
);
839 disp_exception (&info
);
843 void _initialize_darwin_info_commands ();
845 _initialize_darwin_info_commands ()
847 add_info ("mach-tasks", info_mach_tasks_command
,
848 _("Get list of tasks in system."));
849 add_info ("mach-ports", info_mach_ports_command
,
850 _("Get list of ports in a task."));
851 add_info ("mach-port", info_mach_port_command
,
852 _("Get info on a specific port."));
853 add_info ("mach-task", info_mach_task_command
,
854 _("Get info on a specific task."));
855 add_info ("mach-threads", info_mach_threads_command
,
856 _("Get list of threads in a task."));
857 add_info ("mach-thread", info_mach_thread_command
,
858 _("Get info on a specific thread."));
860 add_info ("mach-regions", info_mach_regions_command
,
861 _("Get information on all mach region for the task."));
862 add_info ("mach-regions-rec", info_mach_regions_recurse_command
,
863 _("Get information on all mach sub region for the task."));
864 add_info ("mach-region", info_mach_region_command
,
865 _("Get information on mach region at given address."));
867 add_info ("mach-exceptions", info_mach_exceptions_command
,
868 _("Disp mach exceptions."));