/* Darwin support for GDB, the GNU debugger.
- Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2008, 2009, 2010, 2011
- Free Software Foundation, Inc.
+ Copyright (C) 1997-2022 Free Software Foundation, Inc.
Contributed by Apple Computer, Inc.
#include "value.h"
#include "gdbcmd.h"
#include "inferior.h"
+#include "gdbarch.h"
-#include <sys/param.h>
#include <sys/sysctl.h>
#include "darwin-nat.h"
#define CHECK_ARGS(what, args) do { \
if ((NULL == args) || ((args[0] != '0') && (args[1] != 'x'))) \
- error("%s must be specified with 0x...", what); \
+ error(_("%s must be specified with 0x..."), what); \
} while (0)
#define PRINT_FIELD(structure, field) \
- printf_unfiltered(_(#field":\t%#lx\n"), (unsigned long) (structure)->field)
+ printf_filtered(_(#field":\t%#lx\n"), (unsigned long) (structure)->field)
#define PRINT_TV_FIELD(structure, field) \
- printf_unfiltered(_(#field":\t%u.%06u sec\n"), \
+ printf_filtered(_(#field":\t%u.%06u sec\n"), \
(unsigned) (structure)->field.seconds, \
(unsigned) (structure)->field.microseconds)
#define port_type_array_t mach_port_array_t
static void
-info_mach_tasks_command (char *args, int from_tty)
+info_mach_tasks_command (const char *args, int from_tty)
{
int sysControl[4];
int count, index;
sysctl (sysControl, 3, procInfo, &length, NULL, 0);
count = (length / sizeof (struct kinfo_proc));
- printf_unfiltered (_("%d processes:\n"), count);
+ printf_filtered (_("%d processes:\n"), count);
for (index = 0; index < count; ++index)
{
kern_return_t result;
mach_port_t taskPort;
result =
- task_by_unix_pid (mach_task_self (), procInfo[index].kp_proc.p_pid,
- &taskPort);
+ task_by_unix_pid (mach_task_self (), procInfo[index].kp_proc.p_pid,
+ &taskPort);
if (KERN_SUCCESS == result)
- {
- printf_unfiltered (_(" %s is %d has task %#x\n"),
- procInfo[index].kp_proc.p_comm,
- procInfo[index].kp_proc.p_pid, taskPort);
- }
+ {
+ printf_filtered (_(" %s is %d has task %#x\n"),
+ procInfo[index].kp_proc.p_comm,
+ procInfo[index].kp_proc.p_pid, taskPort);
+ }
else
- {
- printf_unfiltered (_(" %s is %d unknown task port\n"),
- procInfo[index].kp_proc.p_comm,
- procInfo[index].kp_proc.p_pid);
- }
+ {
+ printf_filtered (_(" %s is %d unknown task port\n"),
+ procInfo[index].kp_proc.p_comm,
+ procInfo[index].kp_proc.p_pid);
+ }
}
xfree (procInfo);
}
static task_t
-get_task_from_args (char *args)
+get_task_from_args (const char *args)
{
task_t task;
char *eptr;
if (args == NULL || *args == 0)
{
- if (ptid_equal (inferior_ptid, null_ptid))
- printf_unfiltered (_("No inferior running\n"));
- return current_inferior ()->private->task;
+ if (inferior_ptid == null_ptid)
+ printf_filtered (_("No inferior running\n"));
+
+ darwin_inferior *priv = get_darwin_inferior (current_inferior ());
+
+ return priv->task;
}
if (strcmp (args, "gdb") == 0)
return mach_task_self ();
task = strtoul (args, &eptr, 0);
if (*eptr)
{
- printf_unfiltered (_("cannot parse task id '%s'\n"), args);
+ printf_filtered (_("cannot parse task id '%s'\n"), args);
return TASK_NULL;
}
return task;
}
static void
-info_mach_task_command (char *args, int from_tty)
+info_mach_task_command (const char *args, int from_tty)
{
union
{
if (task == TASK_NULL)
return;
- printf_unfiltered (_("TASK_BASIC_INFO for 0x%x:\n"), task);
+ printf_filtered (_("TASK_BASIC_INFO for 0x%x:\n"), task);
info_count = TASK_BASIC_INFO_COUNT;
result = task_info (task,
- TASK_BASIC_INFO,
- (task_info_t) & task_info_data.basic, &info_count);
+ TASK_BASIC_INFO,
+ (task_info_t) & task_info_data.basic, &info_count);
MACH_CHECK_ERROR (result);
PRINT_FIELD (&task_info_data.basic, suspend_count);
PRINT_FIELD (&task_info_data.basic, resident_size);
PRINT_TV_FIELD (&task_info_data.basic, user_time);
PRINT_TV_FIELD (&task_info_data.basic, system_time);
- printf_unfiltered (_("\nTASK_EVENTS_INFO:\n"));
+ printf_filtered (_("\nTASK_EVENTS_INFO:\n"));
info_count = TASK_EVENTS_INFO_COUNT;
result = task_info (task,
- TASK_EVENTS_INFO,
- (task_info_t) & task_info_data.events, &info_count);
+ TASK_EVENTS_INFO,
+ (task_info_t) & task_info_data.events, &info_count);
MACH_CHECK_ERROR (result);
PRINT_FIELD (&task_info_data.events, faults);
PRINT_FIELD (&task_info_data.events, cow_faults);
PRINT_FIELD (&task_info_data.events, messages_sent);
PRINT_FIELD (&task_info_data.events, messages_received);
- printf_unfiltered (_("\nTASK_THREAD_TIMES_INFO:\n"));
+ printf_filtered (_("\nTASK_THREAD_TIMES_INFO:\n"));
info_count = TASK_THREAD_TIMES_INFO_COUNT;
result = task_info (task,
- TASK_THREAD_TIMES_INFO,
- (task_info_t) & task_info_data.thread_times,
- &info_count);
+ TASK_THREAD_TIMES_INFO,
+ (task_info_t) & task_info_data.thread_times,
+ &info_count);
MACH_CHECK_ERROR (result);
PRINT_TV_FIELD (&task_info_data.thread_times, user_time);
PRINT_TV_FIELD (&task_info_data.thread_times, system_time);
}
static void
-info_mach_ports_command (char *args, int from_tty)
+info_mach_ports_command (const char *args, int from_tty)
{
port_name_array_t names;
port_type_array_t types;
gdb_assert (name_count == type_count);
- printf_unfiltered (_("Ports for task 0x%x:\n"), task);
- printf_unfiltered (_("port type\n"));
+ printf_filtered (_("Ports for task 0x%x:\n"), task);
+ printf_filtered (_("port type\n"));
for (index = 0; index < name_count; ++index)
{
mach_port_t port = names[index];
{MACH_PORT_TYPE_DEAD_NAME, "dead", MACH_PORT_RIGHT_DEAD_NAME}
};
- printf_unfiltered (_("%04x: %08x "), port, types[index]);
+ printf_filtered (_("%04x: %08x "), port, types[index]);
for (j = 0; j < sizeof(descrs) / sizeof(*descrs); j++)
if (types[index] & descrs[j].type)
{
mach_port_urefs_t ref;
kern_return_t ret;
- printf_unfiltered (_(" %s("), descrs[j].name);
+ printf_filtered (_(" %s("), descrs[j].name);
ret = mach_port_get_refs (task, port, descrs[j].right, &ref);
if (ret != KERN_SUCCESS)
- printf_unfiltered (_("??"));
+ printf_filtered (_("??"));
else
- printf_unfiltered (_("%u"), ref);
- printf_unfiltered (_(" refs)"));
+ printf_filtered (_("%u"), ref);
+ printf_filtered (_(" refs)"));
}
if (task == task_self ())
{
if (port == task_self())
- printf_unfiltered (_(" gdb-task"));
+ printf_filtered (_(" gdb-task"));
else if (port == darwin_host_self)
- printf_unfiltered (_(" host-self"));
+ printf_filtered (_(" host-self"));
else if (port == darwin_ex_port)
- printf_unfiltered (_(" gdb-exception"));
+ printf_filtered (_(" gdb-exception"));
else if (port == darwin_port_set)
- printf_unfiltered (_(" gdb-port_set"));
- else if (!ptid_equal (inferior_ptid, null_ptid))
+ printf_filtered (_(" gdb-port_set"));
+ else if (inferior_ptid != null_ptid)
{
struct inferior *inf = current_inferior ();
+ darwin_inferior *priv = get_darwin_inferior (inf);
- if (port == inf->private->task)
- printf_unfiltered (_(" inferior-task"));
- else if (port == inf->private->notify_port)
- printf_unfiltered (_(" inferior-notify"));
+ if (port == priv->task)
+ printf_filtered (_(" inferior-task"));
+ else if (port == priv->notify_port)
+ printf_filtered (_(" inferior-notify"));
else
{
- int k;
- darwin_thread_t *t;
-
- for (k = 0; k < inf->private->exception_info.count; k++)
- if (port == inf->private->exception_info.ports[k])
+ for (int k = 0; k < priv->exception_info.count; k++)
+ if (port == priv->exception_info.ports[k])
{
- printf_unfiltered (_(" inferior-excp-port"));
+ printf_filtered (_(" inferior-excp-port"));
break;
}
- if (inf->private->threads)
+ for (darwin_thread_t *t : priv->threads)
{
- for (k = 0;
- VEC_iterate(darwin_thread_t,
- inf->private->threads, k, t);
- k++)
- if (port == t->gdb_port)
- {
- printf_unfiltered (_(" inferior-thread for 0x%x"),
- inf->private->task);
- break;
- }
+ if (port == t->gdb_port)
+ {
+ printf_filtered (_(" inferior-thread for 0x%x"),
+ priv->task);
+ break;
+ }
}
+
}
}
}
- printf_unfiltered (_("\n"));
+ printf_filtered (_("\n"));
}
vm_deallocate (task_self (), (vm_address_t) names,
- (name_count * sizeof (mach_port_t)));
+ (name_count * sizeof (mach_port_t)));
vm_deallocate (task_self (), (vm_address_t) types,
- (type_count * sizeof (mach_port_type_t)));
+ (type_count * sizeof (mach_port_type_t)));
}
-void
+static void
darwin_debug_port_info (task_t task, mach_port_t port)
{
kern_return_t kret;
(task, port, MACH_PORT_RECEIVE_STATUS, (mach_port_info_t)&status, &len);
MACH_CHECK_ERROR (kret);
- printf_unfiltered (_("Port 0x%lx in task 0x%lx:\n"), (unsigned long) port,
- (unsigned long) task);
- printf_unfiltered (_(" port set: 0x%x\n"), status.mps_pset);
- printf_unfiltered (_(" seqno: 0x%x\n"), status.mps_seqno);
- printf_unfiltered (_(" mscount: 0x%x\n"), status.mps_mscount);
- printf_unfiltered (_(" qlimit: 0x%x\n"), status.mps_qlimit);
- printf_unfiltered (_(" msgcount: 0x%x\n"), status.mps_msgcount);
- printf_unfiltered (_(" sorights: 0x%x\n"), status.mps_sorights);
- printf_unfiltered (_(" srights: 0x%x\n"), status.mps_srights);
- printf_unfiltered (_(" pdrequest: 0x%x\n"), status.mps_pdrequest);
- printf_unfiltered (_(" nsrequest: 0x%x\n"), status.mps_nsrequest);
- printf_unfiltered (_(" flags: 0x%x\n"), status.mps_flags);
+ printf_filtered (_("Port 0x%lx in task 0x%lx:\n"), (unsigned long) port,
+ (unsigned long) task);
+ printf_filtered (_(" port set: 0x%x\n"), status.mps_pset);
+ printf_filtered (_(" seqno: 0x%x\n"), status.mps_seqno);
+ printf_filtered (_(" mscount: 0x%x\n"), status.mps_mscount);
+ printf_filtered (_(" qlimit: 0x%x\n"), status.mps_qlimit);
+ printf_filtered (_(" msgcount: 0x%x\n"), status.mps_msgcount);
+ printf_filtered (_(" sorights: 0x%x\n"), status.mps_sorights);
+ printf_filtered (_(" srights: 0x%x\n"), status.mps_srights);
+ printf_filtered (_(" pdrequest: 0x%x\n"), status.mps_pdrequest);
+ printf_filtered (_(" nsrequest: 0x%x\n"), status.mps_nsrequest);
+ printf_filtered (_(" flags: 0x%x\n"), status.mps_flags);
}
static void
-info_mach_port_command (char *args, int from_tty)
+info_mach_port_command (const char *args, int from_tty)
{
task_t task;
mach_port_t port;
}
static void
-info_mach_threads_command (char *args, int from_tty)
+info_mach_threads_command (const char *args, int from_tty)
{
thread_array_t threads;
unsigned int thread_count;
result = task_threads (task, &threads, &thread_count);
MACH_CHECK_ERROR (result);
- printf_unfiltered (_("Threads in task %#x:\n"), task);
+ printf_filtered (_("Threads in task %#x:\n"), task);
for (i = 0; i < thread_count; ++i)
{
- printf_unfiltered (_(" %#x\n"), threads[i]);
+ printf_filtered (_(" %#x\n"), threads[i]);
mach_port_deallocate (task_self (), threads[i]);
}
vm_deallocate (task_self (), (vm_address_t) threads,
- (thread_count * sizeof (thread_t)));
+ (thread_count * sizeof (thread_t)));
}
static void
-info_mach_thread_command (char *args, int from_tty)
+info_mach_thread_command (const char *args, int from_tty)
{
union
{
CHECK_ARGS (_("Thread"), args);
sscanf (args, "0x%x", &thread);
- printf_unfiltered (_("THREAD_BASIC_INFO\n"));
+ printf_filtered (_("THREAD_BASIC_INFO\n"));
info_count = THREAD_BASIC_INFO_COUNT;
result = thread_info (thread,
THREAD_BASIC_INFO,
/* Check to see if address space has wrapped around. */
if (address == 0)
- print = done = 1;
+ print = done = 1;
if (!done)
- {
- count = VM_REGION_BASIC_INFO_COUNT_64;
- kret =
- mach_vm_region (task, &address, &size, VM_REGION_BASIC_INFO_64,
- (vm_region_info_t) &info, &count, &object_name);
- if (kret != KERN_SUCCESS)
- {
- size = 0;
- print = done = 1;
- }
- }
+ {
+ count = VM_REGION_BASIC_INFO_COUNT_64;
+ kret =
+ mach_vm_region (task, &address, &size, VM_REGION_BASIC_INFO_64,
+ (vm_region_info_t) &info, &count, &object_name);
+ if (kret != KERN_SUCCESS)
+ {
+ size = 0;
+ print = done = 1;
+ }
+ }
if (address != prev_address + prev_size)
- print = 1;
+ print = 1;
if ((info.protection != prev_info.protection)
- || (info.max_protection != prev_info.max_protection)
- || (info.inheritance != prev_info.inheritance)
- || (info.shared != prev_info.reserved)
- || (info.reserved != prev_info.reserved))
- print = 1;
+ || (info.max_protection != prev_info.max_protection)
+ || (info.inheritance != prev_info.inheritance)
+ || (info.shared != prev_info.reserved)
+ || (info.reserved != prev_info.reserved))
+ print = 1;
if (print)
- {
- printf_filtered (_("%s-%s %s/%s %s %s %s"),
- paddress (target_gdbarch, prev_address),
- paddress (target_gdbarch, prev_address + prev_size),
- unparse_protection (prev_info.protection),
- unparse_protection (prev_info.max_protection),
- unparse_inheritance (prev_info.inheritance),
- prev_info.shared ? _("shrd") : _("priv"),
- prev_info.reserved ? _("reserved") : _("not-rsvd"));
-
- if (nsubregions > 1)
- printf_filtered (_(" (%d sub-rgn)"), nsubregions);
-
- printf_filtered (_("\n"));
-
- prev_address = address;
- prev_size = size;
- memcpy (&prev_info, &info, sizeof (vm_region_basic_info_data_64_t));
- nsubregions = 1;
-
- num_printed++;
- }
+ {
+ printf_filtered (_("%s-%s %s/%s %s %s %s"),
+ paddress (target_gdbarch (), prev_address),
+ paddress (target_gdbarch (), prev_address + prev_size),
+ unparse_protection (prev_info.protection),
+ unparse_protection (prev_info.max_protection),
+ unparse_inheritance (prev_info.inheritance),
+ prev_info.shared ? _("shrd") : _("priv"),
+ prev_info.reserved ? _("reserved") : _("not-rsvd"));
+
+ if (nsubregions > 1)
+ printf_filtered (_(" (%d sub-rgn)"), nsubregions);
+
+ printf_filtered (_("\n"));
+
+ prev_address = address;
+ prev_size = size;
+ memcpy (&prev_info, &info, sizeof (vm_region_basic_info_data_64_t));
+ nsubregions = 1;
+
+ num_printed++;
+ }
else
- {
- prev_size += size;
- nsubregions++;
- }
+ {
+ prev_size += size;
+ nsubregions++;
+ }
if ((max > 0) && (num_printed >= max))
- done = 1;
+ done = 1;
if (done)
- break;
+ break;
}
}
static void
darwin_debug_regions_recurse (task_t task)
{
- mach_vm_address_t r_addr;
mach_vm_address_t r_start;
mach_vm_size_t r_size;
natural_t r_depth;
mach_msg_type_number_t r_info_size;
vm_region_submap_short_info_data_64_t r_info;
kern_return_t kret;
- int ret;
- struct cleanup *table_chain;
+ struct ui_out *uiout = current_uiout;
- table_chain = make_cleanup_ui_out_table_begin_end (uiout, 9, -1, "regions");
+ ui_out_emit_table table_emitter (uiout, 9, -1, "regions");
- if (gdbarch_addr_bit (target_gdbarch) <= 32)
+ if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
{
- ui_out_table_header (uiout, 10, ui_left, "start", "Start");
- ui_out_table_header (uiout, 10, ui_left, "end", "End");
+ uiout->table_header (10, ui_left, "start", "Start");
+ uiout->table_header (10, ui_left, "end", "End");
}
else
{
- ui_out_table_header (uiout, 18, ui_left, "start", "Start");
- ui_out_table_header (uiout, 18, ui_left, "end", "End");
+ uiout->table_header (18, ui_left, "start", "Start");
+ uiout->table_header (18, ui_left, "end", "End");
}
- ui_out_table_header (uiout, 3, ui_left, "min-prot", "Min");
- ui_out_table_header (uiout, 3, ui_left, "max-prot", "Max");
- ui_out_table_header (uiout, 5, ui_left, "inheritence", "Inh");
- ui_out_table_header (uiout, 9, ui_left, "share-mode", "Shr");
- ui_out_table_header (uiout, 1, ui_left, "depth", "D");
- ui_out_table_header (uiout, 3, ui_left, "submap", "Sm");
- ui_out_table_header (uiout, 0, ui_noalign, "tag", "Tag");
+ uiout->table_header (3, ui_left, "min-prot", "Min");
+ uiout->table_header (3, ui_left, "max-prot", "Max");
+ uiout->table_header (5, ui_left, "inheritence", "Inh");
+ uiout->table_header (9, ui_left, "share-mode", "Shr");
+ uiout->table_header (1, ui_left, "depth", "D");
+ uiout->table_header (3, ui_left, "submap", "Sm");
+ uiout->table_header (0, ui_noalign, "tag", "Tag");
- ui_out_table_body (uiout);
+ uiout->table_body ();
r_start = 0;
r_depth = 0;
while (1)
{
const char *tag;
- struct cleanup *row_chain;
r_info_size = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
r_size = -1;
&r_info_size);
if (kret != KERN_SUCCESS)
break;
- row_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "regions-row");
-
- ui_out_field_core_addr (uiout, "start", target_gdbarch, r_start);
- ui_out_field_core_addr (uiout, "end", target_gdbarch, r_start + r_size);
- ui_out_field_string (uiout, "min-prot",
- unparse_protection (r_info.protection));
- ui_out_field_string (uiout, "max-prot",
- unparse_protection (r_info.max_protection));
- ui_out_field_string (uiout, "inheritence",
- unparse_inheritance (r_info.inheritance));
- ui_out_field_string (uiout, "share-mode",
- unparse_share_mode (r_info.share_mode));
- ui_out_field_int (uiout, "depth", r_depth);
- ui_out_field_string (uiout, "submap",
- r_info.is_submap ? _("sm ") : _("obj"));
- tag = unparse_user_tag (r_info.user_tag);
- if (tag)
- ui_out_field_string (uiout, "tag", tag);
- else
- ui_out_field_int (uiout, "tag", r_info.user_tag);
-
- do_cleanups (row_chain);
- if (!ui_out_is_mi_like_p (uiout))
- ui_out_text (uiout, "\n");
+ {
+ ui_out_emit_tuple tuple_emitter (uiout, "regions-row");
+
+ uiout->field_core_addr ("start", target_gdbarch (), r_start);
+ uiout->field_core_addr ("end", target_gdbarch (), r_start + r_size);
+ uiout->field_string ("min-prot",
+ unparse_protection (r_info.protection));
+ uiout->field_string ("max-prot",
+ unparse_protection (r_info.max_protection));
+ uiout->field_string ("inheritence",
+ unparse_inheritance (r_info.inheritance));
+ uiout->field_string ("share-mode",
+ unparse_share_mode (r_info.share_mode));
+ uiout->field_signed ("depth", r_depth);
+ uiout->field_string ("submap",
+ r_info.is_submap ? _("sm ") : _("obj"));
+ tag = unparse_user_tag (r_info.user_tag);
+ if (tag)
+ uiout->field_string ("tag", tag);
+ else
+ uiout->field_signed ("tag", r_info.user_tag);
+ }
+
+ uiout->text ("\n");
if (r_info.is_submap)
r_depth++;
else
r_start += r_size;
}
- do_cleanups (table_chain);
-
}
}
static void
-info_mach_regions_command (char *args, int from_tty)
+info_mach_regions_command (const char *args, int from_tty)
{
task_t task;
}
static void
-info_mach_regions_recurse_command (char *args, int from_tty)
+info_mach_regions_recurse_command (const char *args, int from_tty)
{
task_t task;
}
static void
-info_mach_region_command (char *exp, int from_tty)
+info_mach_region_command (const char *exp, int from_tty)
{
- struct expression *expr;
struct value *val;
mach_vm_address_t address;
struct inferior *inf;
- expr = parse_expression (exp);
- val = evaluate_expression (expr);
- if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
+ expression_up expr = parse_expression (exp);
+ val = evaluate_expression (expr.get ());
+ if (TYPE_IS_REFERENCE (value_type (val)))
{
val = value_ind (val);
}
address = value_as_address (val);
- if (ptid_equal (inferior_ptid, null_ptid))
+ if (inferior_ptid == null_ptid)
error (_("Inferior not available"));
inf = current_inferior ();
- darwin_debug_region (inf->private->task, address);
+ darwin_inferior *priv = get_darwin_inferior (inf);
+ darwin_debug_region (priv->task, address);
}
static void
switch (info->behaviors[i])
{
case EXCEPTION_DEFAULT:
- printf_unfiltered (_("default"));
+ printf_filtered (_("default"));
break;
case EXCEPTION_STATE:
- printf_unfiltered (_("state"));
+ printf_filtered (_("state"));
break;
case EXCEPTION_STATE_IDENTITY:
- printf_unfiltered (_("state-identity"));
+ printf_filtered (_("state-identity"));
break;
default:
- printf_unfiltered (_("0x%x"), info->behaviors[i]);
+ printf_filtered (_("0x%x"), info->behaviors[i]);
}
- printf_unfiltered (_(", masks:"));
+ printf_filtered (_(", masks:"));
if (mask & EXC_MASK_BAD_ACCESS)
- printf_unfiltered (_(" BAD_ACCESS"));
+ printf_filtered (_(" BAD_ACCESS"));
if (mask & EXC_MASK_BAD_INSTRUCTION)
- printf_unfiltered (_(" BAD_INSTRUCTION"));
+ printf_filtered (_(" BAD_INSTRUCTION"));
if (mask & EXC_MASK_ARITHMETIC)
- printf_unfiltered (_(" ARITHMETIC"));
+ printf_filtered (_(" ARITHMETIC"));
if (mask & EXC_MASK_EMULATION)
- printf_unfiltered (_(" EMULATION"));
+ printf_filtered (_(" EMULATION"));
if (mask & EXC_MASK_SOFTWARE)
- printf_unfiltered (_(" SOFTWARE"));
+ printf_filtered (_(" SOFTWARE"));
if (mask & EXC_MASK_BREAKPOINT)
- printf_unfiltered (_(" BREAKPOINT"));
+ printf_filtered (_(" BREAKPOINT"));
if (mask & EXC_MASK_SYSCALL)
- printf_unfiltered (_(" SYSCALL"));
+ printf_filtered (_(" SYSCALL"));
if (mask & EXC_MASK_MACH_SYSCALL)
- printf_unfiltered (_(" MACH_SYSCALL"));
+ printf_filtered (_(" MACH_SYSCALL"));
if (mask & EXC_MASK_RPC_ALERT)
- printf_unfiltered (_(" RPC_ALERT"));
+ printf_filtered (_(" RPC_ALERT"));
if (mask & EXC_MASK_CRASH)
- printf_unfiltered (_(" CRASH"));
- printf_unfiltered (_("\n"));
+ printf_filtered (_(" CRASH"));
+ printf_filtered (_("\n"));
}
}
static void
-info_mach_exceptions_command (char *args, int from_tty)
+info_mach_exceptions_command (const char *args, int from_tty)
{
- int i;
- task_t task;
kern_return_t kret;
darwin_exception_info info;
{
if (strcmp (args, "saved") == 0)
{
- if (ptid_equal (inferior_ptid, null_ptid))
- printf_unfiltered (_("No inferior running\n"));
- disp_exception (¤t_inferior ()->private->exception_info);
+ if (inferior_ptid == null_ptid)
+ printf_filtered (_("No inferior running\n"));
+
+ darwin_inferior *priv = get_darwin_inferior (current_inferior ());
+
+ disp_exception (&priv->exception_info);
return;
}
else if (strcmp (args, "host") == 0)
{
- /* FIXME: This need a privilegied host port! */
+ /* FIXME: This needs a privileged host port! */
kret = host_get_exception_ports
(darwin_host_self, EXC_MASK_ALL, info.masks,
&info.count, info.ports, info.behaviors, info.flavors);
{
struct inferior *inf;
- if (ptid_equal (inferior_ptid, null_ptid))
- printf_unfiltered (_("No inferior running\n"));
+ if (inferior_ptid == null_ptid)
+ printf_filtered (_("No inferior running\n"));
inf = current_inferior ();
+ darwin_inferior *priv = get_darwin_inferior (inf);
+
kret = task_get_exception_ports
- (inf->private->task, EXC_MASK_ALL, info.masks,
+ (priv->task, EXC_MASK_ALL, info.masks,
&info.count, info.ports, info.behaviors, info.flavors);
MACH_CHECK_ERROR (kret);
disp_exception (&info);
}
}
+void _initialize_darwin_info_commands ();
void
-_initialize_darwin_info_commands (void)
+_initialize_darwin_info_commands ()
{
add_info ("mach-tasks", info_mach_tasks_command,
- _("Get list of tasks in system."));
+ _("Get list of tasks in system."));
add_info ("mach-ports", info_mach_ports_command,
- _("Get list of ports in a task."));
+ _("Get list of ports in a task."));
add_info ("mach-port", info_mach_port_command,
- _("Get info on a specific port."));
+ _("Get info on a specific port."));
add_info ("mach-task", info_mach_task_command,
- _("Get info on a specific task."));
+ _("Get info on a specific task."));
add_info ("mach-threads", info_mach_threads_command,
- _("Get list of threads in a task."));
+ _("Get list of threads in a task."));
add_info ("mach-thread", info_mach_thread_command,
- _("Get info on a specific thread."));
+ _("Get info on a specific thread."));
add_info ("mach-regions", info_mach_regions_command,
- _("Get information on all mach region for the task."));
+ _("Get information on all mach region for the task."));
add_info ("mach-regions-rec", info_mach_regions_recurse_command,
- _("Get information on all mach sub region for the task."));
+ _("Get information on all mach sub region for the task."));
add_info ("mach-region", info_mach_region_command,
- _("Get information on mach region at given address."));
+ _("Get information on mach region at given address."));
add_info ("mach-exceptions", info_mach_exceptions_command,
- _("Disp mach exceptions."));
+ _("Disp mach exceptions."));
}