/* Interface GDB to the GNU Hurd.
- Copyright 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2001
- Free Software Foundation, Inc.
+ Copyright (C) 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2006, 2007,
+ 2008, 2009 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <ctype.h>
#include <hurd/msg.h>
#include <hurd/msg_request.h>
#include <hurd/process.h>
+/* Defined in <hurd/process.h>, but we need forward declarations from
+ <hurd/process_request.h> as well. */
+#undef _process_user_
#include <hurd/process_request.h>
#include <hurd/signal.h>
#include <hurd/sigpreempt.h>
#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);
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. */
proc_debug (thread, "died!");
thread->port = MACH_PORT_NULL;
thread = _proc_free (thread); /* THREAD is dead. */
- (last ? last->next : inf->threads) = thread;
+ if (last)
+ last->next = thread;
+ else
+ inf->threads = thread;
}
}
else
/* THREADS[I] is a thread we don't know about yet! */
{
+ ptid_t ptid;
+
thread = make_proc (inf, threads[i], next_thread_id++);
- (last ? last->next : inf->threads) = thread;
+ if (last)
+ last->next = thread;
+ else
+ inf->threads = thread;
last = thread;
proc_debug (thread, "new thread: %d", threads[i]);
- add_thread (pid_to_ptid (thread->tid)); /* Tell GDB's generic thread code. */
+
+ ptid = ptid_build (inf->pid, 0, thread->tid);
+
+ /* Tell GDB's generic thread code. */
+
+ if (ptid_equal (inferior_ptid, pid_to_ptid (inf->pid)))
+ /* This is the first time we're hearing about thread
+ ids, after a fork-child. */
+ thread_change_ptid (inferior_ptid, ptid);
+ else if (inf->pending_execs != 0)
+ /* This is a shell thread. */
+ add_thread_silent (ptid);
+ else
+ add_thread (ptid);
}
}
\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 tid, 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 *);
waiting_inf = inf;
- inf_debug (inf, "waiting for: %d", PIDGET (tid));
+ inf_debug (inf, "waiting for: %s", target_pid_to_str (ptid));
rewait:
if (proc_wait_pid != inf->pid && !inf->no_wait)
thread = inf->wait.thread;
if (thread)
- tid = pid_to_ptid (thread->tid);
+ ptid = ptid_build (inf->pid, 0, thread->tid);
+ else if (ptid_equal (ptid, minus_one_ptid))
+ thread = inf_tid_to_thread (inf, -1);
else
- thread = inf_tid_to_thread (inf, PIDGET (tid));
+ thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
if (!thread || thread->port == MACH_PORT_NULL)
{
/* TID is dead; try and find a new thread. */
if (inf_update_procs (inf) && inf->threads)
- tid = pid_to_ptid (inf->threads->tid); /* The first available thread. */
+ ptid = ptid_build (inf->pid, 0, inf->threads->tid); /* The first available thread. */
else
- tid = inferior_ptid; /* let wait_for_inferior handle exit case */
+ ptid = inferior_ptid; /* let wait_for_inferior handle exit case */
}
- if (thread && PIDGET (tid) >= 0 && status->kind != TARGET_WAITKIND_SPURIOUS
+ if (thread
+ && !ptid_equal (ptid, minus_one_ptid)
+ && status->kind != TARGET_WAITKIND_SPURIOUS
&& inf->pause_sc == 0 && thread->pause_sc == 0)
/* If something actually happened to THREAD, make sure we
suspend it. */
inf_update_suspends (inf);
}
- inf_debug (inf, "returning tid = %d, status = %s (%d)", PIDGET (tid),
+ inf_debug (inf, "returning ptid = %s, status = %s (%d)",
+ target_pid_to_str (ptid),
status->kind == TARGET_WAITKIND_EXITED ? "EXITED"
: status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED"
: status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED"
: "?",
status->value.integer);
- return tid;
+ return ptid;
}
\f
in multiple events returned by wait).
*/
static void
-gnu_resume (ptid_t tid, 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;
- struct inf *inf = current_inferior;
+ int resume_all;
+ struct inf *inf = gnu_current_inf;
- inf_debug (inf, "tid = %d, step = %d, sig = %d", PIDGET (tid), step, sig);
+ inf_debug (inf, "ptid = %s, step = %d, sig = %d",
+ target_pid_to_str (ptid), step, sig);
inf_validate_procinfo (inf);
inf_update_procs (inf);
- if (PIDGET (tid) < 0)
+ /* A specific PTID means `step only this process id'. */
+ resume_all = ptid_equal (ptid, minus_one_ptid);
+
+ if (resume_all)
/* Allow all threads to run, except perhaps single-stepping one. */
{
inf_debug (inf, "running all threads; tid = %d", PIDGET (inferior_ptid));
- tid = inferior_ptid; /* What to step. */
+ ptid = inferior_ptid; /* What to step. */
inf_set_threads_resume_sc (inf, 0, 1);
}
else
/* Just allow a single thread to run. */
{
- struct proc *thread = inf_tid_to_thread (inf, PIDGET (tid));
+ struct proc *thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
if (!thread)
- error (_("Can't run single thread id %d: no such thread!"));
- inf_debug (inf, "running one thread: %d/%d", inf->pid, thread->tid);
+ error (_("Can't run single thread id %s: no such thread!"),
+ target_pid_to_str (ptid));
+ inf_debug (inf, "running one thread: %s", target_pid_to_str (ptid));
inf_set_threads_resume_sc (inf, thread, 0);
}
if (step)
{
- step_thread = inf_tid_to_thread (inf, PIDGET (tid));
+ step_thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
if (!step_thread)
- warning (_("Can't step thread id %d: no such thread."), PIDGET (tid));
+ warning (_("Can't step thread id %s: no such thread."),
+ target_pid_to_str (ptid));
else
- inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid);
+ inf_debug (inf, "stepping thread: %s", target_pid_to_str (ptid));
}
if (step_thread != inf->step_thread)
inf_set_step_thread (inf, step_thread);
\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);
+ inf_debug (gnu_current_inf, "rip");
+ inf_detach (gnu_current_inf);
unpush_target (&gnu_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 ();
inf_attach (inf, pid);
- attach_flag = 0;
push_target (&gnu_ops);
inf->pending_execs = 2;
/* Now let the child run again, knowing that it will stop immediately
because of the ptrace. */
inf_resume (inf);
- inferior_ptid = pid_to_ptid (inf_pick_first_thread ());
+
+ /* 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_steal_exc_ports (inf);
else
inf_restore_exc_ports (inf);
-
- /* Here we go! */
- proceed ((CORE_ADDR) -1, 0, 0);
}
/* Mark our target-struct as eligible for stray "run" and "attach"
/* 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"));
inf_debug (inf, "attaching to pid: %d", pid);
inf_attach (inf, pid);
- inf_update_procs (inf);
-
- inferior_ptid = pid_to_ptid (inf_pick_first_thread ());
- attach_flag = 1;
push_target (&gnu_ops);
+ inferior = add_inferior (pid);
+ inferior->attach_flag = 1;
+
+ inf_update_procs (inf);
+
+ inferior_ptid = ptid_build (pid, 0, inf_pick_first_thread ());
+
/* 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 */
}
static void
gnu_terminal_init_inferior (void)
{
- gdb_assert (current_inferior);
- terminal_init_inferior_with_pgrp (current_inferior->pid);
+ gdb_assert (gnu_current_inf);
+ terminal_init_inferior_with_pgrp (gnu_current_inf->pid);
}
/* Get ready to modify the registers array. On machines which store
that registers contains all the registers from the program being
debugged. */
static void
-gnu_prepare_to_store (void)
+gnu_prepare_to_store (struct regcache *regcache)
{
-#ifdef CHILD_PREPARE_TO_STORE
- CHILD_PREPARE_TO_STORE ();
-#endif
}
static void
}
static void
-gnu_stop (void)
+gnu_stop (ptid_t ptid)
{
error (_("to_stop target function not implemented"));
}
-static char *
-gnu_pid_to_exec_file (int pid)
-{
- error (_("to_pid_to_exec_file target function not implemented"));
- return NULL;
-}
-
-
static int
-gnu_thread_alive (ptid_t tid)
+gnu_thread_alive (struct target_ops *ops, ptid_t ptid)
{
- inf_update_procs (current_inferior);
- return !!inf_tid_to_thread (current_inferior, PIDGET (tid));
+ inf_update_procs (gnu_current_inf);
+ return !!inf_tid_to_thread (gnu_current_inf,
+ ptid_get_tid (ptid));
}
\f
if (err)
return 0;
- err = hurd_safe_copyin (myaddr, (void *) addr - low_address + copied, length);
+ err = hurd_safe_copyin (myaddr, (void *) (addr - low_address + copied), length);
if (err)
{
warning (_("Read from inferior faulted: %s"), safe_strerror (err));
deallocate++;
- err = hurd_safe_copyout ((void *) addr - low_address + copied,
+ err = hurd_safe_copyout ((void *) (addr - low_address + copied),
myaddr, length);
CHK_GOTO_OUT ("Write to inferior faulted", err);
/* Return 0 on failure, number of bytes handled otherwise. TARGET
is ignored. */
static int
-gnu_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+gnu_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
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", paddr (memaddr), len,
+ write ? "<--" : "-->", host_address_to_string (myaddr));
if (write)
return gnu_write_inferior (task, memaddr, myaddr, len);
else
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;
if (proc_is_task (proc))
sprintf (tid_str, "process %d", proc->inf->pid);
else
- sprintf (tid_str, "thread %d.%d",
- proc->inf->pid, pid_to_thread_id (MERGEPID (proc->tid, 0)));
+ sprintf (tid_str, "Thread %d.%d",
+ proc->inf->pid, proc->tid);
return tid_str;
}
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;
- int tid = PIDGET (ptid);
+ struct inf *inf = gnu_current_inf;
+ int tid = ptid_get_tid (ptid);
struct proc *thread = inf_tid_to_thread (inf, tid);
if (thread)
}
\f
-extern void gnu_store_registers (int regno);
-extern void gnu_fetch_registers (int regno);
+extern void gnu_store_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno);
+extern void gnu_fetch_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno);
struct target_ops gnu_ops;
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_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_pid_to_exec_file = gnu_pid_to_exec_file; /* to_pid_to_exec_file */
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_has_all_memory = default_child_has_all_memory;
+ gnu_ops.to_has_memory = default_child_has_memory;
+ gnu_ops.to_has_stack = default_child_has_stack;
+ gnu_ops.to_has_registers = default_child_has_registers;
+ gnu_ops.to_has_execution = default_child_has_execution;
gnu_ops.to_magic = OPS_MAGIC; /* to_magic */
} /* init_gnu_ops */
cur_thread (void)
{
struct inf *inf = cur_inf ();
- struct proc *thread = inf_tid_to_thread (inf, PIDGET (inferior_ptid));
+ struct proc *thread = inf_tid_to_thread (inf,
+ ptid_get_tid (inferior_ptid));
if (!thread)
error (_("No current thread."));
return thread;
inf->signal_thread = 0;
else
{
- int tid = PIDGET (thread_id_to_pid (atoi (args)));
+ 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);
static void
add_task_commands (void)
{
- add_cmd ("pause", class_run, set_thread_default_pause_cmd,
- "Set whether the new threads are suspended while gdb has control.\n\
+ add_cmd ("pause", class_run, set_thread_default_pause_cmd, _("\
+Set whether the new threads are suspended while gdb has control.\n\
This property normally has no effect because the whole task is\n\
suspended, however, that may be disabled with \"set task pause off\".\n\
-The default value is \"off\".",
+The default value is \"off\"."),
&set_thread_default_cmd_list);
- add_cmd ("pause", no_class, show_thread_default_pause_cmd,
- "Show whether new threads are suspended while gdb has control.",
+ add_cmd ("pause", no_class, show_thread_default_pause_cmd, _("\
+Show whether new threads are suspended while gdb has control."),
&show_thread_default_cmd_list);
- add_cmd ("run", class_run, set_thread_default_run_cmd,
- "Set whether new threads are allowed to run \
-(once gdb has noticed them).",
+ add_cmd ("run", class_run, set_thread_default_run_cmd, _("\
+Set whether new threads are allowed to run (once gdb has noticed them)."),
&set_thread_default_cmd_list);
- add_cmd ("run", no_class, show_thread_default_run_cmd,
- "Show whether new threads are allowed to run \
-(once gdb has noticed them).",
+ add_cmd ("run", no_class, show_thread_default_run_cmd, _("\
+Show whether new threads are allowed to run (once gdb has noticed them)."),
&show_thread_default_cmd_list);
add_cmd ("detach-suspend-count", class_run, set_thread_default_detach_sc_cmd,
- "Set the default detach-suspend-count value for new threads.",
+ _("Set the default detach-suspend-count value for new threads."),
&set_thread_default_cmd_list);
add_cmd ("detach-suspend-count", no_class, show_thread_default_detach_sc_cmd,
- "Show the default detach-suspend-count value for new threads.",
+ _("Show the default detach-suspend-count value for new threads."),
&show_thread_default_cmd_list);
- add_cmd ("signals", class_run, set_signals_cmd,
- "Set whether the inferior process's signals will be intercepted.\n\
-Mach exceptions (such as breakpoint traps) are not affected.",
+ add_cmd ("signals", class_run, set_signals_cmd, _("\
+Set whether the inferior process's signals will be intercepted.\n\
+Mach exceptions (such as breakpoint traps) are not affected."),
&setlist);
add_alias_cmd ("sigs", "signals", class_run, 1, &setlist);
- add_cmd ("signals", no_class, show_signals_cmd,
- "Show whether the inferior process's signals will be intercepted.",
+ add_cmd ("signals", no_class, show_signals_cmd, _("\
+Show whether the inferior process's signals will be intercepted."),
&showlist);
add_alias_cmd ("sigs", "signals", no_class, 1, &showlist);
- add_cmd ("signal-thread", class_run, set_sig_thread_cmd,
- "Set the thread that gdb thinks is the libc signal thread.\n\
-This thread is run when delivering a signal to a non-stopped process.",
+ add_cmd ("signal-thread", class_run, set_sig_thread_cmd, _("\
+Set the thread that gdb thinks is the libc signal thread.\n\
+This thread is run when delivering a signal to a non-stopped process."),
&setlist);
add_alias_cmd ("sigthread", "signal-thread", class_run, 1, &setlist);
- add_cmd ("signal-thread", no_class, show_sig_thread_cmd,
- "Set the thread that gdb thinks is the libc signal thread.",
+ add_cmd ("signal-thread", no_class, show_sig_thread_cmd, _("\
+Set the thread that gdb thinks is the libc signal thread."),
&showlist);
add_alias_cmd ("sigthread", "signal-thread", no_class, 1, &showlist);
- add_cmd ("stopped", class_run, set_stopped_cmd,
- "Set whether gdb thinks the inferior process is stopped \
-as with SIGSTOP.\n\
-Stopped process will be continued by sending them a signal.",
+ add_cmd ("stopped", class_run, set_stopped_cmd, _("\
+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,
- "Show whether gdb thinks the inferior process is stopped \
-as with SIGSTOP.",
+ add_cmd ("stopped", no_class, show_signals_cmd, _("\
+Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
&showlist);
- add_cmd ("exceptions", class_run, set_exceptions_cmd,
- "Set whether exceptions in the inferior process will be trapped.\n\
+ add_cmd ("exceptions", class_run, set_exceptions_cmd, _("\
+Set whether exceptions in the inferior process will be trapped.\n\
When exceptions are turned off, neither breakpoints nor single-stepping\n\
-will work.",
+will work."),
&setlist);
/* Allow `set exc' despite conflict with `set exception-port'. */
add_alias_cmd ("exc", "exceptions", class_run, 1, &setlist);
- add_cmd ("exceptions", no_class, show_exceptions_cmd,
- "Show whether exceptions in the inferior process will be trapped.",
+ add_cmd ("exceptions", no_class, show_exceptions_cmd, _("\
+Show whether exceptions in the inferior process will be trapped."),
&showlist);
add_prefix_cmd ("task", no_class, set_task_cmd,
- "Command prefix for setting task attributes.",
+ _("Command prefix for setting task attributes."),
&set_task_cmd_list, "set task ", 0, &setlist);
add_prefix_cmd ("task", no_class, show_task_cmd,
- "Command prefix for showing task attributes.",
+ _("Command prefix for showing task attributes."),
&show_task_cmd_list, "show task ", 0, &showlist);
- add_cmd ("pause", class_run, set_task_pause_cmd,
- "Set whether the task is suspended while gdb has control.\n\
+ add_cmd ("pause", class_run, set_task_pause_cmd, _("\
+Set whether the task is suspended while gdb has control.\n\
A value of \"on\" takes effect immediately, otherwise nothing happens\n\
until the next time the program is continued.\n\
When setting this to \"off\", \"set thread default pause on\" can be\n\
-used to pause individual threads by default instead.",
+used to pause individual threads by default instead."),
&set_task_cmd_list);
add_cmd ("pause", no_class, show_task_pause_cmd,
- "Show whether the task is suspended while gdb has control.",
+ _("Show whether the task is suspended while gdb has control."),
&show_task_cmd_list);
add_cmd ("detach-suspend-count", class_run, set_task_detach_sc_cmd,
- "Set the suspend count will leave on the thread when detaching.",
+ _("Set the suspend count will leave on the thread when detaching."),
&set_task_cmd_list);
add_cmd ("detach-suspend-count", no_class, show_task_detach_sc_cmd,
- "Show the suspend count will leave on the thread when detaching.",
+ _("Show the suspend count will leave on the thread when detaching."),
&show_task_cmd_list);
- add_cmd ("exception-port", no_class, set_task_exc_port_cmd,
- "Set the task exception port to which we forward exceptions.\n\
-The argument should be the value of the send right in the task.",
+ add_cmd ("exception-port", no_class, set_task_exc_port_cmd, _("\
+Set the task exception port to which we forward exceptions.\n\
+The argument should be the value of the send right in the task."),
&set_task_cmd_list);
add_alias_cmd ("excp", "exception-port", no_class, 1, &set_task_cmd_list);
add_alias_cmd ("exc-port", "exception-port", no_class, 1,
/* A convenient way of turning on all options require to noninvasively
debug running tasks. */
- add_cmd ("noninvasive", no_class, set_noninvasive_cmd,
- "Set task options so that we interfere as little as possible.\n\
+ add_cmd ("noninvasive", no_class, set_noninvasive_cmd, _("\
+Set task options so that we interfere as little as possible.\n\
This is the same as setting `task pause', `exceptions', and\n\
-`signals' to the opposite value.",
+`signals' to the opposite value."),
&setlist);
/* Commands to show information about the task's ports. */
add_cmd ("send-rights", class_info, info_send_rights_cmd,
- "Show information about the task's send rights",
+ _("Show information about the task's send rights"),
&infolist);
add_cmd ("receive-rights", class_info, info_recv_rights_cmd,
- "Show information about the task's receive rights",
+ _("Show information about the task's receive rights"),
&infolist);
add_cmd ("port-rights", class_info, info_port_rights_cmd,
- "Show information about the task's port rights",
+ _("Show information about the task's port rights"),
&infolist);
add_cmd ("port-sets", class_info, info_port_sets_cmd,
- "Show information about the task's port sets",
+ _("Show information about the task's port sets"),
&infolist);
add_cmd ("dead-names", class_info, info_dead_names_cmd,
- "Show information about the task's dead names",
+ _("Show information about the task's dead names"),
&infolist);
add_info_alias ("ports", "port-rights", 1);
add_info_alias ("port", "port-rights", 1);
add_thread_commands (void)
{
add_prefix_cmd ("thread", no_class, set_thread_cmd,
- "Command prefix for setting thread properties.",
+ _("Command prefix for setting thread properties."),
&set_thread_cmd_list, "set thread ", 0, &setlist);
add_prefix_cmd ("default", no_class, show_thread_cmd,
- "Command prefix for setting default thread properties.",
+ _("Command prefix for setting default thread properties."),
&set_thread_default_cmd_list, "set thread default ", 0,
&set_thread_cmd_list);
add_prefix_cmd ("thread", no_class, set_thread_default_cmd,
- "Command prefix for showing thread properties.",
+ _("Command prefix for showing thread properties."),
&show_thread_cmd_list, "show thread ", 0, &showlist);
add_prefix_cmd ("default", no_class, show_thread_default_cmd,
- "Command prefix for showing default thread properties.",
+ _("Command prefix for showing default thread properties."),
&show_thread_default_cmd_list, "show thread default ", 0,
&show_thread_cmd_list);
- add_cmd ("pause", class_run, set_thread_pause_cmd,
- "Set whether the current thread is suspended \
-while gdb has control.\n\
+ add_cmd ("pause", class_run, set_thread_pause_cmd, _("\
+Set whether the current thread is suspended while gdb has control.\n\
A value of \"on\" takes effect immediately, otherwise nothing happens\n\
until the next time the program is continued. This property normally\n\
has no effect because the whole task is suspended, however, that may\n\
be disabled with \"set task pause off\".\n\
-The default value is \"off\".",
+The default value is \"off\"."),
&set_thread_cmd_list);
- add_cmd ("pause", no_class, show_thread_pause_cmd,
- "Show whether the current thread is suspended \
-while gdb has control.",
+ add_cmd ("pause", no_class, show_thread_pause_cmd, _("\
+Show whether the current thread is suspended while gdb has control."),
&show_thread_cmd_list);
add_cmd ("run", class_run, set_thread_run_cmd,
- "Set whether the current thread is allowed to run.",
+ _("Set whether the current thread is allowed to run."),
&set_thread_cmd_list);
add_cmd ("run", no_class, show_thread_run_cmd,
- "Show whether the current thread is allowed to run.",
+ _("Show whether the current thread is allowed to run."),
&show_thread_cmd_list);
- add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd,
- "Set the suspend count will leave on the thread when detaching.\n\
+ add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd, _("\
+Set the suspend count will leave on the thread when detaching.\n\
Note that this is relative to suspend count when gdb noticed the thread;\n\
-use the `thread takeover-suspend-count' to force it to an absolute value.",
+use the `thread takeover-suspend-count' to force it to an absolute value."),
&set_thread_cmd_list);
- add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd,
- "Show the suspend count will leave on the thread when detaching.\n\
+ add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd, _("\
+Show the suspend count will leave on the thread when detaching.\n\
Note that this is relative to suspend count when gdb noticed the thread;\n\
-use the `thread takeover-suspend-count' to force it to an absolute value.",
+use the `thread takeover-suspend-count' to force it to an absolute value."),
&show_thread_cmd_list);
- add_cmd ("exception-port", no_class, set_thread_exc_port_cmd,
- "Set the thread exception port to which we forward exceptions.\n\
+ add_cmd ("exception-port", no_class, set_thread_exc_port_cmd, _("\
+Set the thread exception port to which we forward exceptions.\n\
This overrides the task exception port.\n\
-The argument should be the value of the send right in the task.",
+The argument should be the value of the send right in the task."),
&set_thread_cmd_list);
add_alias_cmd ("excp", "exception-port", no_class, 1, &set_thread_cmd_list);
add_alias_cmd ("exc-port", "exception-port", no_class, 1,
&set_thread_cmd_list);
- add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd,
- "Force the threads absolute suspend-count to be gdb's.\n\
+ add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd, _("\
+Force the threads absolute suspend-count to be gdb's.\n\
Prior to giving this command, gdb's thread suspend-counts are relative\n\
-to the thread's initial suspend-count when gdb notices the threads.",
+to the thread's initial suspend-count when gdb notices the threads."),
&thread_cmd_list);
}
add_task_commands ();
add_thread_commands ();
- 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,
projects / platform / upstream / binutils.git / blobdiff