/* Interface GDB to the GNU Hurd.
Copyright (C) 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2006, 2007,
- 2008 Free Software Foundation, Inc.
+ 2008, 2009, 2010 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdb_obstack.h"
#include "gnu-nat.h"
+#include "inf-child.h"
#include "exc_request_S.h"
#include "notify_S.h"
/* Forward decls */
-extern struct target_ops gnu_ops;
-
struct inf *make_inf ();
void inf_clear_wait (struct inf *inf);
void inf_cleanup (struct inf *inf);
#define inf_debug(_inf, msg, args...) \
do { struct inf *__inf = (_inf); \
- debug ("{inf %d %p}: " msg, __inf->pid, __inf , ##args); } while (0)
+ debug ("{inf %d %s}: " msg, __inf->pid, \
+ host_address_to_string (__inf) , ##args); } while (0)
void proc_abort (struct proc *proc, int force);
struct proc *make_proc (struct inf *inf, mach_port_t port, int tid);
{
mach_msg_type_number_t state_size = THREAD_STATE_SIZE;
error_t err =
- thread_get_state (proc->port, THREAD_STATE_FLAVOR,
- (thread_state_t) &proc->state, &state_size);
+ thread_get_state (proc->port, THREAD_STATE_FLAVOR,
+ (thread_state_t) &proc->state, &state_size);
+
proc_debug (proc, "getting thread state");
proc->state_valid = !err;
}
else
{
error_t err = proc_pid2task (proc_server, pid, &task_port);
+
if (err)
error (_("Error getting task for pid %d: %s"), pid, safe_strerror (err));
}
mach_msg_type_number_t pi_len = 0;
int info_flags = 0;
error_t err =
- proc_getprocinfo (proc_server, inf->pid, &info_flags,
- (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
+ proc_getprocinfo (proc_server, inf->pid, &info_flags,
+ (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
if (!err)
{
int abort;
target_terminal_ours (); /* Allow I/O. */
- abort = !query ("Pid %d has an additional task suspend count of %d;"
- " clear it? ", inf->pid,
+ abort = !query (_("Pid %d has an additional task suspend count of %d;"
+ " clear it? "), inf->pid,
suspend_count - inf->task->cur_sc);
target_terminal_inferior (); /* Give it back to the child. */
error_t err =
INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
INIT_TRACEMASK, mask));
+
if (err == EIEIO)
{
if (on)
inf_update_suspends (struct inf *inf)
{
struct proc *task = inf->task;
+
/* We don't have to update INF->threads even though we're iterating over it
because we'll change a thread only if it already has an existing proc
entry. */
-
inf_debug (inf, "updating suspend counts");
if (task)
inf_port_to_thread (struct inf *inf, mach_port_t port)
{
struct proc *thread = inf->threads;
+
while (thread)
if (thread->port == port)
return thread;
if (task)
{
error_t err = task_threads (task->port, &threads, &num_threads);
+
inf_debug (inf, "fetching threads");
if (err)
/* TASK must be dead. */
struct proc *run_thread, int run_others)
{
struct proc *thread;
+
inf_update_procs (inf);
for (thread = inf->threads; thread; thread = thread->next)
if (thread == run_thread)
extremely large)! */
{
struct inf_wait *w = &inf->wait;
+
if (w->status.kind == TARGET_WAITKIND_STOPPED
&& w->status.value.sig == sig
&& w->thread && !w->thread->aborted)
i.e., we pretend it's global. */
{
struct exc_state *e = &w->exc;
+
inf_debug (inf, "passing through exception:"
" task = %d, thread = %d, exc = %d"
", code = %d, subcode = %d",
\f
/* The inferior used for all gdb target ops. */
-struct inf *current_inferior = 0;
+struct inf *gnu_current_inf = 0;
/* The inferior being waited for by gnu_wait. Since GDB is decidely not
multi-threaded, we don't bother to lock this. */
/* Wait for something to happen in the inferior, returning what in STATUS. */
static ptid_t
-gnu_wait (ptid_t ptid, struct target_waitstatus *status)
+gnu_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status, int options)
{
struct msg
{
} msg;
error_t err;
struct proc *thread;
- struct inf *inf = current_inferior;
+ struct inf *inf = gnu_current_inf;
extern int exc_server (mach_msg_header_t *, mach_msg_header_t *);
extern int msg_reply_server (mach_msg_header_t *, mach_msg_header_t *);
else
{
struct proc *thread = inf_port_to_thread (inf, dead_port);
+
if (thread)
{
proc_debug (thread, "is dead");
{
struct mach_port_status status;
error_t err =
- mach_port_get_receive_status (mach_task_self (), port, &status);
+ mach_port_get_receive_status (mach_task_self (), port, &status);
if (err)
return 0;
in multiple events returned by wait).
*/
static void
-gnu_resume (ptid_t ptid, int step, enum target_signal sig)
+gnu_resume (struct target_ops *ops,
+ ptid_t ptid, int step, enum target_signal sig)
{
struct proc *step_thread = 0;
int resume_all;
- struct inf *inf = current_inferior;
+ struct inf *inf = gnu_current_inf;
inf_debug (inf, "ptid = %s, step = %d, sig = %d",
target_pid_to_str (ptid), step, sig);
/* Just allow a single thread to run. */
{
struct proc *thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
+
if (!thread)
error (_("Can't run single thread id %s: no such thread!"),
target_pid_to_str (ptid));
\f
static void
-gnu_kill_inferior (void)
+gnu_kill_inferior (struct target_ops *ops)
{
- struct proc *task = current_inferior->task;
+ struct proc *task = gnu_current_inf->task;
+
if (task)
{
proc_debug (task, "terminating...");
task_terminate (task->port);
- inf_set_pid (current_inferior, -1);
+ inf_set_pid (gnu_current_inf, -1);
}
target_mourn_inferior ();
}
/* Clean up after the inferior dies. */
static void
-gnu_mourn_inferior (void)
+gnu_mourn_inferior (struct target_ops *ops)
{
- inf_debug (current_inferior, "rip");
- inf_detach (current_inferior);
- unpush_target (&gnu_ops);
+ inf_debug (gnu_current_inf, "rip");
+ inf_detach (gnu_current_inf);
+ unpush_target (ops);
generic_mourn_inferior ();
}
static int
inf_pick_first_thread (void)
{
- if (current_inferior->task && current_inferior->threads)
+ if (gnu_current_inf->task && gnu_current_inf->threads)
/* The first thread. */
- return current_inferior->threads->tid;
+ return gnu_current_inf->threads->tid;
else
/* What may be the next thread. */
return next_thread_id;
static struct inf *
cur_inf (void)
{
- if (!current_inferior)
- current_inferior = make_inf ();
- return current_inferior;
+ if (!gnu_current_inf)
+ gnu_current_inf = make_inf ();
+ return gnu_current_inf;
}
static void
-gnu_create_inferior (char *exec_file, char *allargs, char **env,
+gnu_create_inferior (struct target_ops *ops,
+ char *exec_file, char *allargs, char **env,
int from_tty)
{
struct inf *inf = cur_inf ();
+ int pid;
void trace_me ()
{
if (ptrace (PTRACE_TRACEME) != 0)
error (_("ptrace (PTRACE_TRACEME) failed!"));
}
- void attach_to_child (int pid)
- {
- /* Attach to the now stopped child, which is actually a shell... */
- inf_debug (inf, "attaching to child: %d", pid);
- inf_attach (inf, pid);
+ inf_debug (inf, "creating inferior");
- attach_flag = 0;
- push_target (&gnu_ops);
+ pid = fork_inferior (exec_file, allargs, env, trace_me, NULL, NULL, NULL);
- inf->pending_execs = 2;
- inf->nomsg = 1;
- inf->traced = 1;
+ /* Attach to the now stopped child, which is actually a shell... */
+ inf_debug (inf, "attaching to child: %d", pid);
- /* Now let the child run again, knowing that it will stop immediately
- because of the ptrace. */
- inf_resume (inf);
+ inf_attach (inf, pid);
- /* We now have thread info. */
- thread_change_ptid (inferior_ptid,
- ptid_build (inf->pid, 0, inf_pick_first_thread ()));
+ push_target (ops);
- startup_inferior (inf->pending_execs);
- }
+ inf->pending_execs = 2;
+ inf->nomsg = 1;
+ inf->traced = 1;
- inf_debug (inf, "creating inferior");
+ /* Now let the child run again, knowing that it will stop
+ immediately because of the ptrace. */
+ inf_resume (inf);
- fork_inferior (exec_file, allargs, env, trace_me, attach_to_child,
- NULL, NULL);
+ /* We now have thread info. */
+ thread_change_ptid (inferior_ptid,
+ ptid_build (inf->pid, 0, inf_pick_first_thread ()));
+
+ startup_inferior (inf->pending_execs);
inf_validate_procinfo (inf);
inf_update_signal_thread (inf);
inf_restore_exc_ports (inf);
}
-/* Mark our target-struct as eligible for stray "run" and "attach"
- commands. */
-static int
-gnu_can_run (void)
-{
- return 1;
-}
-
\f
/* Attach to process PID, then initialize for debugging it
and wait for the trace-trap that results from attaching. */
static void
-gnu_attach (char *args, int from_tty)
+gnu_attach (struct target_ops *ops, char *args, int from_tty)
{
int pid;
char *exec_file;
struct inf *inf = cur_inf ();
+ struct inferior *inferior;
- if (!args)
- error_no_arg (_("process-id to attach"));
+ pid = parse_pid_to_attach (args);
- pid = atoi (args);
-
- if (pid == getpid ()) /* Trying to masturbate? */
+ if (pid == getpid ()) /* Trying to masturbate? */
error (_("I refuse to debug myself!"));
if (from_tty)
inf_attach (inf, pid);
- push_target (&gnu_ops);
+ push_target (ops);
+
+ inferior = current_inferior ();
+ inferior_appeared (inferior, pid);
+ inferior->attach_flag = 1;
inf_update_procs (inf);
inferior_ptid = ptid_build (pid, 0, inf_pick_first_thread ());
- attach_flag = 1;
-
/* We have to initialize the terminal settings now, since the code
below might try to restore them. */
target_terminal_init ();
previously attached. It *might* work if the program was
started via fork. */
static void
-gnu_detach (char *args, int from_tty)
+gnu_detach (struct target_ops *ops, char *args, int from_tty)
{
+ int pid;
+
if (from_tty)
{
char *exec_file = get_exec_file (0);
+
if (exec_file)
printf_unfiltered ("Detaching from program `%s' pid %d\n",
- exec_file, current_inferior->pid);
+ exec_file, gnu_current_inf->pid);
else
- printf_unfiltered ("Detaching from pid %d\n", current_inferior->pid);
+ printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf->pid);
gdb_flush (gdb_stdout);
}
- inf_detach (current_inferior);
+ pid = gnu_current_inf->pid;
+
+ inf_detach (gnu_current_inf);
inferior_ptid = null_ptid;
+ detach_inferior (pid);
- unpush_target (&gnu_ops); /* Pop out of handling an inferior */
+ unpush_target (ops); /* Pop out of handling an inferior */
}
\f
static void
gnu_terminal_init_inferior (void)
{
- gdb_assert (current_inferior);
- terminal_init_inferior_with_pgrp (current_inferior->pid);
-}
-
-/* Get ready to modify the registers array. On machines which store
- individual registers, this doesn't need to do anything. On machines
- which store all the registers in one fell swoop, this makes sure
- that registers contains all the registers from the program being
- debugged. */
-static void
-gnu_prepare_to_store (struct regcache *regcache)
-{
-}
-
-static void
-gnu_open (char *arg, int from_tty)
-{
- error (_("Use the \"run\" command to start a Unix child process."));
+ gdb_assert (gnu_current_inf);
+ terminal_init_inferior_with_pgrp (gnu_current_inf->pid);
}
static void
}
static int
-gnu_thread_alive (ptid_t ptid)
+gnu_thread_alive (struct target_ops *ops, ptid_t ptid)
{
- inf_update_procs (current_inferior);
- return !!inf_tid_to_thread (current_inferior,
+ inf_update_procs (gnu_current_inf);
+ return !!inf_tid_to_thread (gnu_current_inf,
ptid_get_tid (ptid));
}
struct mem_attrib *attrib,
struct target_ops *target)
{
- task_t task = (current_inferior
- ? (current_inferior->task
- ? current_inferior->task->port : 0)
+ task_t task = (gnu_current_inf
+ ? (gnu_current_inf->task
+ ? gnu_current_inf->task->port : 0)
: 0);
if (task == MACH_PORT_NULL)
return 0;
else
{
- inf_debug (current_inferior, "%s %p[%d] %s %p",
- write ? "writing" : "reading", (void *) memaddr, len,
- write ? "<--" : "-->", myaddr);
+ inf_debug (gnu_current_inf, "%s %s[%d] %s %s",
+ write ? "writing" : "reading",
+ paddress (target_gdbarch, memaddr), len,
+ write ? "<--" : "-->", host_address_to_string (myaddr));
if (write)
return gnu_write_inferior (task, memaddr, myaddr, len);
else
/* Call FUNC on each memory region in the task. */
static int
-gnu_find_memory_regions (int (*func) (CORE_ADDR,
- unsigned long,
- int, int, int,
- void *),
- void *data)
+gnu_find_memory_regions (find_memory_region_ftype func, void *data)
{
error_t err;
task_t task;
vm_address_t region_address, last_region_address, last_region_end;
vm_prot_t last_protection;
- if (current_inferior == 0 || current_inferior->task == 0)
+ if (gnu_current_inf == 0 || gnu_current_inf->task == 0)
return 0;
- task = current_inferior->task->port;
+ task = gnu_current_inf->task->port;
if (task == MACH_PORT_NULL)
return 0;
proc_string (struct proc *proc)
{
static char tid_str[80];
+
if (proc_is_task (proc))
sprintf (tid_str, "process %d", proc->inf->pid);
else
}
static char *
-gnu_pid_to_str (ptid_t ptid)
+gnu_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
- struct inf *inf = current_inferior;
+ struct inf *inf = gnu_current_inf;
int tid = ptid_get_tid (ptid);
struct proc *thread = inf_tid_to_thread (inf, tid);
else
{
static char tid_str[80];
+
sprintf (tid_str, "bogus thread id %d", tid);
return tid_str;
}
}
\f
-extern void gnu_store_registers (struct regcache *regcache, int regno);
-extern void gnu_fetch_registers (struct regcache *regcache, int regno);
+/* Create a prototype generic GNU/Hurd target. The client can
+ override it with local methods. */
-struct target_ops gnu_ops;
+struct target_ops *
+gnu_target (void)
+{
+ struct target_ops *t = inf_child_target ();
-static void
-init_gnu_ops (void)
-{
- gnu_ops.to_shortname = "GNU"; /* to_shortname */
- gnu_ops.to_longname = "GNU Hurd process"; /* to_longname */
- gnu_ops.to_doc = "GNU Hurd process"; /* to_doc */
- gnu_ops.to_open = gnu_open; /* to_open */
- gnu_ops.to_attach = gnu_attach; /* to_attach */
- gnu_ops.to_attach_no_wait = 1; /* to_attach_no_wait */
- gnu_ops.to_detach = gnu_detach; /* to_detach */
- gnu_ops.to_resume = gnu_resume; /* to_resume */
- gnu_ops.to_wait = gnu_wait; /* to_wait */
- gnu_ops.to_fetch_registers = gnu_fetch_registers; /* to_fetch_registers */
- gnu_ops.to_store_registers = gnu_store_registers; /* to_store_registers */
- gnu_ops.to_prepare_to_store = gnu_prepare_to_store; /* to_prepare_to_store */
- gnu_ops.deprecated_xfer_memory = gnu_xfer_memory;
- gnu_ops.to_find_memory_regions = gnu_find_memory_regions;
- gnu_ops.to_insert_breakpoint = memory_insert_breakpoint;
- gnu_ops.to_remove_breakpoint = memory_remove_breakpoint;
- gnu_ops.to_terminal_init = gnu_terminal_init_inferior;
- gnu_ops.to_terminal_inferior = terminal_inferior;
- gnu_ops.to_terminal_ours_for_output = terminal_ours_for_output;
- gnu_ops.to_terminal_save_ours = terminal_save_ours;
- gnu_ops.to_terminal_ours = terminal_ours;
- gnu_ops.to_terminal_info = child_terminal_info;
- gnu_ops.to_kill = gnu_kill_inferior; /* to_kill */
- gnu_ops.to_create_inferior = gnu_create_inferior; /* to_create_inferior */
- gnu_ops.to_mourn_inferior = gnu_mourn_inferior; /* to_mourn_inferior */
- gnu_ops.to_can_run = gnu_can_run; /* to_can_run */
- gnu_ops.to_thread_alive = gnu_thread_alive; /* to_thread_alive */
- gnu_ops.to_pid_to_str = gnu_pid_to_str; /* to_pid_to_str */
- gnu_ops.to_stop = gnu_stop; /* to_stop */
- gnu_ops.to_stratum = process_stratum; /* to_stratum */
- gnu_ops.to_has_all_memory = 1; /* to_has_all_memory */
- gnu_ops.to_has_memory = 1; /* to_has_memory */
- gnu_ops.to_has_stack = 1; /* to_has_stack */
- gnu_ops.to_has_registers = 1; /* to_has_registers */
- gnu_ops.to_has_execution = 1; /* to_has_execution */
- gnu_ops.to_magic = OPS_MAGIC; /* to_magic */
-} /* init_gnu_ops */
+ t->to_shortname = "GNU";
+ t->to_longname = "GNU Hurd process";
+ t->to_doc = "GNU Hurd process";
+
+ t->to_attach = gnu_attach;
+ t->to_attach_no_wait = 1;
+ t->to_detach = gnu_detach;
+ t->to_resume = gnu_resume;
+ t->to_wait = gnu_wait;
+ t->deprecated_xfer_memory = gnu_xfer_memory;
+ t->to_find_memory_regions = gnu_find_memory_regions;
+ t->to_terminal_init = gnu_terminal_init_inferior;
+ t->to_kill = gnu_kill_inferior;
+ t->to_create_inferior = gnu_create_inferior;
+ t->to_mourn_inferior = gnu_mourn_inferior;
+ t->to_thread_alive = gnu_thread_alive;
+ t->to_pid_to_str = gnu_pid_to_str;
+ t->to_stop = gnu_stop;
+
+ return t;
+}
\f
/* User task commands. */
{
char *arg_end;
int val = strtoul (args, &arg_end, 10);
+
if (*args && *arg_end == '\0')
return val;
}
active_inf (void)
{
struct inf *inf = cur_inf ();
+
if (!inf->task)
error (_("No current process."));
return inf;
show_task_pause_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
check_empty (args, "show task pause");
printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
inf->task
set_thread_default_pause_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
inf->default_thread_pause_sc =
parse_bool_arg (args, "set thread default pause") ? 0 : 1;
}
{
struct inf *inf = cur_inf ();
int sc = inf->default_thread_pause_sc;
+
check_empty (args, "show thread default pause");
printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
sc ? "are" : "aren't",
set_thread_default_run_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
inf->default_thread_run_sc =
parse_bool_arg (args, "set thread default run") ? 0 : 1;
}
show_thread_default_run_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
check_empty (args, "show thread default run");
printf_unfiltered ("New threads %s allowed to run.\n",
inf->default_thread_run_sc == 0 ? "are" : "aren't");
set_task_exc_port_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
if (!args)
error (_("No argument to \"set task exception-port\" command."));
steal_exc_port (inf->task, parse_and_eval_address (args));
show_stopped_cmd (char *args, int from_tty)
{
struct inf *inf = active_inf ();
+
check_empty (args, "show stopped");
printf_unfiltered ("The inferior process %s stopped.\n",
inf->stopped ? "is" : "isn't");
else
{
int tid = ptid_get_tid (thread_id_to_pid (atoi (args)));
+
if (tid < 0)
error (_("Thread ID %s not known. Use the \"info threads\" command to\n"
"see the IDs of currently known threads."), args);
show_sig_thread_cmd (char *args, int from_tty)
{
struct inf *inf = active_inf ();
+
check_empty (args, "show signal-thread");
if (inf->signal_thread)
printf_unfiltered ("The signal thread is %s.\n",
show_signals_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
check_empty (args, "show signals");
printf_unfiltered ("The inferior process's signals %s intercepted.\n",
inf->task
show_exceptions_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
check_empty (args, "show exceptions");
printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
inf->task
struct value *val = parse_to_comma_and_eval (&args);
long right = value_as_long (val);
error_t err =
- print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS,
- stdout);
+ print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS,
+ stdout);
+
if (err)
error (_("%ld: %s."), right, safe_strerror (err));
}
/* Print all of them. */
{
error_t err =
- print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS,
- stdout);
+ print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS,
+ stdout);
if (err)
error (_("%s."), safe_strerror (err));
}
Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
Stopped process will be continued by sending them a signal."),
&setlist);
- add_cmd ("stopped", no_class, show_signals_cmd, _("\
+ add_cmd ("stopped", no_class, show_stopped_cmd, _("\
Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
&showlist);
{
struct proc *thread = cur_thread ();
int old_sc = thread->pause_sc;
+
thread->pause_sc = parse_bool_arg (args, "set thread pause");
if (old_sc == 0 && thread->pause_sc != 0 && thread->inf->pause_sc == 0)
/* If the task is currently unsuspended, immediately suspend it,
{
struct proc *thread = cur_thread ();
int sc = thread->pause_sc;
+
check_empty (args, "show task pause");
printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
proc_string (thread),
set_thread_run_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
thread->run_sc = parse_bool_arg (args, "set thread run") ? 0 : 1;
}
show_thread_run_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
check_empty (args, "show thread run");
printf_unfiltered ("Thread %s %s allowed to run.",
proc_string (thread),
show_thread_detach_sc_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
check_empty (args, "show thread detach-suspend-count");
printf_unfiltered ("Thread %s will be left with a suspend count"
" of %d when detaching.\n",
set_thread_exc_port_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
if (!args)
error (_("No argument to \"set thread exception-port\" command."));
steal_exc_port (thread, parse_and_eval_address (args));
show_thread_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
check_empty (args, "show thread");
show_thread_run_cmd (0, from_tty);
show_thread_pause_cmd (0, from_tty);
thread_takeover_sc_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
thread_basic_info_data_t _info;
thread_basic_info_t info = &_info;
mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT;
_initialize_gnu_nat (void)
{
proc_server = getproc ();
-
- init_gnu_ops ();
- add_target (&gnu_ops);
add_task_commands ();
add_thread_commands ();
- deprecated_add_set_cmd ("gnu-debug", class_maintenance,
- var_boolean, (char *) &gnu_debug_flag,
- "Set debugging output for the gnu backend.",
- &maintenancelist);
+ add_setshow_boolean_cmd ("gnu-nat", class_maintenance,
+ &gnu_debug_flag,
+ _("Set debugging output for the gnu backend."),
+ _("Show debugging output for the gnu backend."),
+ NULL,
+ NULL,
+ NULL,
+ &setdebuglist,
+ &showdebuglist);
}
\f
#ifdef FLUSH_INFERIOR_CACHE
vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH;
error_t ret;
- ret = vm_machine_attribute (current_inferior->task->port,
+ ret = vm_machine_attribute (gnu_current_inf->task->port,
pc,
amount,
MATTR_CACHE,