-/* Interface GDB to the GNU Hurd
- Copyright (C) 1992, 1995, 1996, 1997, 1999 Free Software Foundation, Inc.
+/* Interface GDB to the GNU Hurd.
+ 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 <stdio.h>
-#include <string.h>
+#include <ctype.h>
#include <errno.h>
-#include <signal.h>
-#include <assert.h>
-#include <setjmp.h>
#include <limits.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <stdio.h>
+#include "gdb_string.h"
#include <sys/ptrace.h>
-/* We include this because we don't need the access macros and they conflict
- with gdb's definitions (ick). This is very non standard! */
-#define _SYS_WAIT_H /* Inhibit warning from <bits/waitflags.h>. */
-#include <bits/waitflags.h>
-
#include <mach.h>
-#include <mach/message.h>
-#include <mach/notify.h>
#include <mach_error.h>
#include <mach/exception.h>
+#include <mach/message.h>
+#include <mach/notify.h>
#include <mach/vm_attributes.h>
-#include <hurd/process.h>
-#include <hurd/process_request.h>
+#include <hurd.h>
+#include <hurd/interrupt.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/interrupt.h>
#include <hurd/sigpreempt.h>
#include <portinfo.h>
#include "value.h"
#include "language.h"
#include "target.h"
-#include "wait.h"
+#include "gdb_wait.h"
#include "gdbcmd.h"
#include "gdbcore.h"
+#include "gdbthread.h"
+#include "gdb_assert.h"
+#include "gdb_obstack.h"
#include "gnu-nat.h"
extern struct target_ops gnu_ops;
-int inf_update_procs (struct inf *inf);
struct inf *make_inf ();
void inf_clear_wait (struct inf *inf);
void inf_cleanup (struct inf *inf);
void inf_steal_exc_ports (struct inf *inf);
void inf_restore_exc_ports (struct inf *inf);
struct proc *inf_tid_to_proc (struct inf *inf, int tid);
-inline void inf_set_threads_resume_sc (struct inf *inf,
- struct proc *run_thread,
- int run_others);
-inline int inf_set_threads_resume_sc_for_signal_thread (struct inf *inf);
-inline void inf_suspend (struct inf *inf);
-inline void inf_resume (struct inf *inf);
+void inf_set_threads_resume_sc (struct inf *inf,
+ struct proc *run_thread,
+ int run_others);
+int inf_set_threads_resume_sc_for_signal_thread (struct inf *inf);
+void inf_suspend (struct inf *inf);
+void inf_resume (struct inf *inf);
void inf_set_step_thread (struct inf *inf, struct proc *proc);
void inf_detach (struct inf *inf);
void inf_attach (struct inf *inf, int pid);
debug ("{inf %d %p}: " msg, __inf->pid, __inf , ##args); } while (0)
void proc_abort (struct proc *proc, int force);
-thread_state_t proc_get_state (struct proc *proc, int force);
struct proc *make_proc (struct inf *inf, mach_port_t port, int tid);
struct proc *_proc_free (struct proc *proc);
int proc_update_sc (struct proc *proc);
-error_t proc_get_exception_port (struct proc *proc, mach_port_t *port);
+error_t proc_get_exception_port (struct proc *proc, mach_port_t * port);
error_t proc_set_exception_port (struct proc *proc, mach_port_t port);
static mach_port_t _proc_get_exc_port (struct proc *proc);
void proc_steal_exc_port (struct proc *proc, mach_port_t exc_port);
void proc_restore_exc_port (struct proc *proc);
int proc_trace (struct proc *proc, int set);
-char *proc_string (struct proc *proc);
/* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
to INF's msg port and task port respectively. If it has no msg port,
__e; }) \
: EIEIO)
-#define MIG_SERVER_DIED EMIG_SERVER_DIED /* XXX */
\f
/* The state passed by an exception message. */
struct exc_state
-{
- int exception; /* The exception code */
- int code, subcode;
- mach_port_t handler; /* The real exception port to handle this. */
- mach_port_t reply; /* The reply port from the exception call. */
-};
+ {
+ int exception; /* The exception code */
+ int code, subcode;
+ mach_port_t handler; /* The real exception port to handle this. */
+ mach_port_t reply; /* The reply port from the exception call. */
+ };
/* The results of the last wait an inf did. */
struct inf_wait
-{
- struct target_waitstatus status; /* The status returned to gdb. */
- struct exc_state exc; /* The exception that caused us to return. */
- struct proc *thread; /* The thread in question. */
- int suppress; /* Something trivial happened. */
-};
+ {
+ struct target_waitstatus status; /* The status returned to gdb. */
+ struct exc_state exc; /* The exception that caused us to return. */
+ struct proc *thread; /* The thread in question. */
+ int suppress; /* Something trivial happened. */
+ };
/* The state of an inferior. */
struct inf
-{
- /* Fields describing the current inferior. */
+ {
+ /* Fields describing the current inferior. */
- struct proc *task; /* The mach task. */
- struct proc *threads; /* A linked list of all threads in TASK. */
+ struct proc *task; /* The mach task. */
+ struct proc *threads; /* A linked list of all threads in TASK. */
- /* True if THREADS needn't be validated by querying the task. We assume that
- we and the task in question are the only ones frobbing the thread list,
- so as long as we don't let any code run, we don't have to worry about
- THREADS changing. */
- int threads_up_to_date;
+ /* True if THREADS needn't be validated by querying the task. We assume that
+ we and the task in question are the only ones frobbing the thread list,
+ so as long as we don't let any code run, we don't have to worry about
+ THREADS changing. */
+ int threads_up_to_date;
- pid_t pid; /* The real system PID. */
+ pid_t pid; /* The real system PID. */
- struct inf_wait wait; /* What to return from target_wait. */
+ struct inf_wait wait; /* What to return from target_wait. */
- /* One thread proc in INF may be in `single-stepping mode'. This is it. */
- struct proc *step_thread;
+ /* One thread proc in INF may be in `single-stepping mode'. This is it. */
+ struct proc *step_thread;
- /* The thread we think is the signal thread. */
- struct proc *signal_thread;
+ /* The thread we think is the signal thread. */
+ struct proc *signal_thread;
- mach_port_t event_port; /* Where we receive various msgs. */
+ mach_port_t event_port; /* Where we receive various msgs. */
- /* True if we think at least one thread in the inferior could currently be
- running. */
- unsigned int running : 1;
+ /* True if we think at least one thread in the inferior could currently be
+ running. */
+ unsigned int running:1;
- /* True if the process has stopped (in the proc server sense). Note that
- since a proc server `stop' leaves the signal thread running, the inf can
- be RUNNING && STOPPED... */
- unsigned int stopped : 1;
+ /* True if the process has stopped (in the proc server sense). Note that
+ since a proc server `stop' leaves the signal thread running, the inf can
+ be RUNNING && STOPPED... */
+ unsigned int stopped:1;
- /* True if the inferior has no message port. */
- unsigned int nomsg : 1;
+ /* True if the inferior has no message port. */
+ unsigned int nomsg:1;
- /* True if the inferior is traced. */
- unsigned int traced : 1;
+ /* True if the inferior is traced. */
+ unsigned int traced:1;
- /* True if we shouldn't try waiting for the inferior, usually because we
- can't for some reason. */
- unsigned int no_wait : 1;
+ /* True if we shouldn't try waiting for the inferior, usually because we
+ can't for some reason. */
+ unsigned int no_wait:1;
- /* When starting a new inferior, we don't try to validate threads until all
- the proper execs have been done. This is a count of how many execs we
- expect to happen. */
- unsigned pending_execs;
+ /* When starting a new inferior, we don't try to validate threads until all
+ the proper execs have been done. This is a count of how many execs we
+ expect to happen. */
+ unsigned pending_execs;
- /* Fields describing global state */
+ /* Fields describing global state */
- /* The task suspend count used when gdb has control. This is normally 1 to
- make things easier for us, but sometimes (like when attaching to vital
- system servers) it may be desirable to let the task continue to run
- (pausing individual threads as necessary). */
- int pause_sc;
+ /* The task suspend count used when gdb has control. This is normally 1 to
+ make things easier for us, but sometimes (like when attaching to vital
+ system servers) it may be desirable to let the task continue to run
+ (pausing individual threads as necessary). */
+ int pause_sc;
- /* The task suspend count left when detaching from a task. */
- int detach_sc;
+ /* The task suspend count left when detaching from a task. */
+ int detach_sc;
- /* The initial values used for the run_sc and pause_sc of newly discovered
- threads -- see the definition of those fields in struct proc. */
- int default_thread_run_sc;
- int default_thread_pause_sc;
- int default_thread_detach_sc;
+ /* The initial values used for the run_sc and pause_sc of newly discovered
+ threads -- see the definition of those fields in struct proc. */
+ int default_thread_run_sc;
+ int default_thread_pause_sc;
+ int default_thread_detach_sc;
- /* True if the process should be traced when started/attached. Newly
- started processes *must* be traced at first to exec them properly, but
- if this is false, tracing is turned off as soon it has done so. */
- int want_signals;
+ /* True if the process should be traced when started/attached. Newly
+ started processes *must* be traced at first to exec them properly, but
+ if this is false, tracing is turned off as soon it has done so. */
+ int want_signals;
- /* True if exceptions from the inferior process should be trapped. This
- must be on to use breakpoints. */
- int want_exceptions;
-};
+ /* True if exceptions from the inferior process should be trapped. This
+ must be on to use breakpoints. */
+ int want_exceptions;
+ };
-int __proc_pid (struct proc *proc)
+int
+__proc_pid (struct proc *proc)
{
return proc->inf->pid;
}
+
\f
/* Update PROC's real suspend count to match it's desired one. Returns true
if we think PROC is now in a runnable state. */
proc_update_sc (struct proc *proc)
{
int running;
- int err = 0;
+ int err = 0;
int delta = proc->sc - proc->cur_sc;
if (delta)
if (proc->sc == 0 && proc->state_changed)
/* Since PROC may start running, we must write back any state changes. */
{
- assert (proc_is_thread (proc));
+ gdb_assert (proc_is_thread (proc));
proc_debug (proc, "storing back changed thread state");
err = thread_set_state (proc->port, THREAD_STATE_FLAVOR,
- (thread_state_t)&proc->state, THREAD_STATE_SIZE);
- if (! err)
+ (thread_state_t) &proc->state, THREAD_STATE_SIZE);
+ if (!err)
proc->state_changed = 0;
}
if (delta > 0)
- while (delta-- > 0 && !err)
- if (proc_is_task (proc))
- err = task_suspend (proc->port);
- else
- err = thread_suspend (proc->port);
+ {
+ while (delta-- > 0 && !err)
+ {
+ if (proc_is_task (proc))
+ err = task_suspend (proc->port);
+ else
+ err = thread_suspend (proc->port);
+ }
+ }
else
- while (delta++ < 0 && !err)
- if (proc_is_task (proc))
- err = task_resume (proc->port);
- else
- err = thread_resume (proc->port);
-
- if (! err)
+ {
+ while (delta++ < 0 && !err)
+ {
+ if (proc_is_task (proc))
+ err = task_resume (proc->port);
+ else
+ err = thread_resume (proc->port);
+ }
+ }
+ if (!err)
proc->cur_sc = proc->sc;
/* If we got an error, then the task/thread has disappeared. */
proc_debug (proc, "is %s", err ? "dead" : running ? "running" : "suspended");
if (err)
- proc_debug (proc, "err = %s", strerror (err));
+ proc_debug (proc, "err = %s", safe_strerror (err));
if (running)
{
return running;
}
+
\f
/* Thread_abort is called on PROC if needed. PROC must be a thread proc.
If PROC is deemed `precious', then nothing is done unless FORCE is true.
void
proc_abort (struct proc *proc, int force)
{
- assert (proc_is_thread (proc));
+ gdb_assert (proc_is_thread (proc));
- if (! proc->aborted)
+ if (!proc->aborted)
{
struct inf *inf = proc->inf;
int running = (proc->cur_sc == 0 && inf->task->cur_sc == 0);
proc->sc = 1;
inf_update_suspends (proc->inf);
running = 0;
- warning ("Stopped %s.", proc_string (proc));
+ warning (_("Stopped %s."), proc_string (proc));
}
else if (proc == inf->wait.thread && inf->wait.exc.reply && !force)
/* An exception is pending on PROC, which don't mess with. */
running = 1;
- if (! running)
+ if (!running)
/* We only abort the thread if it's not actually running. */
{
thread_abort (proc->port);
proc_abort (proc, will_modify);
- if (! was_aborted && proc->aborted)
+ if (!was_aborted && proc->aborted)
/* PROC's state may have changed since we last fetched it. */
proc->state_valid = 0;
- if (! proc->state_valid)
+ if (!proc->state_valid)
{
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;
}
{
if (will_modify)
proc->state_changed = 1;
- return (thread_state_t)&proc->state;
+ return (thread_state_t) &proc->state;
}
else
return 0;
}
+
\f
/* Set PORT to PROC's exception port. */
error_t
-proc_get_exception_port (struct proc *proc, mach_port_t *port)
+proc_get_exception_port (struct proc * proc, mach_port_t * port)
{
if (proc_is_task (proc))
return task_get_exception_port (proc->port, port);
/* Set PROC's exception port to PORT. */
error_t
-proc_set_exception_port (struct proc *proc, mach_port_t port)
+proc_set_exception_port (struct proc * proc, mach_port_t port)
{
proc_debug (proc, "setting exception port: %d", port);
if (proc_is_task (proc))
if (cur_exc_port)
{
- error_t err;
+ error_t err = 0;
proc_debug (proc, "inserting exception port: %d", exc_port);
if (!err)
proc->exc_port = exc_port;
else
- warning ("Error setting exception port for %s: %s",
- proc_string (proc), strerror (err));
+ warning (_("Error setting exception port for %s: %s"),
+ proc_string (proc), safe_strerror (err));
}
}
if (!err)
proc->exc_port = MACH_PORT_NULL;
else
- warning ("Error setting exception port for %s: %s",
- proc_string (proc), strerror (err));
+ warning (_("Error setting exception port for %s: %s"),
+ proc_string (proc), safe_strerror (err));
}
}
+
\f
/* Turns hardware tracing in PROC on or off when SET is true or false,
respectively. Returns true on success. */
{
thread_state_t state = proc_get_state (proc, 1);
- if (! state)
+ if (!state)
return 0; /* the thread must be dead. */
proc_debug (proc, "tracing %s", set ? "on" : "off");
-
+
if (set)
{
/* XXX We don't get the exception unless the thread has its own
- exception port???? */
+ exception port???? */
if (proc->exc_port == MACH_PORT_NULL)
proc_steal_exc_port (proc, proc->inf->event_port);
THREAD_STATE_SET_TRACED (state);
return 1;
}
+
\f
/* A variable from which to assign new TIDs. */
static int next_thread_id = 1;
{
error_t err;
mach_port_t prev_port = MACH_PORT_NULL;
- struct proc *proc = malloc (sizeof (struct proc));
+ struct proc *proc = xmalloc (sizeof (struct proc));
proc->port = port;
proc->tid = tid;
/* Get notified when things die. */
err =
- mach_port_request_notification (mach_task_self(), port,
+ mach_port_request_notification (mach_task_self (), port,
MACH_NOTIFY_DEAD_NAME, 1,
inf->event_port,
MACH_MSG_TYPE_MAKE_SEND_ONCE,
&prev_port);
if (err)
- warning ("Couldn't request notification for port %d: %s",
- port, strerror (err));
+ warning (_("Couldn't request notification for port %d: %s"),
+ port, safe_strerror (err));
else
{
proc_debug (proc, "notifications to: %d", inf->event_port);
}
if (inf->want_exceptions)
- if (proc_is_task (proc))
- /* Make the task exception port point to us. */
- proc_steal_exc_port (proc, inf->event_port);
- else
- /* Just clear thread exception ports -- they default to the task one. */
- proc_steal_exc_port (proc, MACH_PORT_NULL);
+ {
+ if (proc_is_task (proc))
+ /* Make the task exception port point to us. */
+ proc_steal_exc_port (proc, inf->event_port);
+ else
+ /* Just clear thread exception ports -- they default to the
+ task one. */
+ proc_steal_exc_port (proc, MACH_PORT_NULL);
+ }
return proc;
}
mach_port_deallocate (mach_task_self (), proc->port);
}
- free (proc);
+ xfree (proc);
return next;
}
+
\f
-struct inf *make_inf ()
+struct inf *
+make_inf (void)
{
- struct inf *inf = malloc (sizeof (struct inf));
-
- if (!inf)
- return 0;
+ struct inf *inf = xmalloc (sizeof (struct inf));
inf->task = 0;
inf->threads = 0;
return inf;
}
-/* clear INF's target wait status. */
+/* Clear INF's target wait status. */
void
inf_clear_wait (struct inf *inf)
{
inf->wait.exc.reply = MACH_PORT_NULL;
}
}
+
\f
void
inf_cleanup (struct inf *inf)
err = mach_port_allocate (mach_task_self (),
MACH_PORT_RIGHT_RECEIVE, &inf->event_port);
if (err)
- error ("Error allocating event port: %s", strerror (err));
+ error (_("Error allocating event port: %s"), safe_strerror (err));
/* Make a send right for it, so we can easily copy it for other people. */
mach_port_insert_right (mach_task_self (), inf->event_port,
inf->event_port, MACH_MSG_TYPE_MAKE_SEND);
inf_set_pid (inf, pid);
}
+
\f
-/* close current process, if any, and attach INF to process PORT */
-void
+/* Close current process, if any, and attach INF to process PORT. */
+void
inf_set_pid (struct inf *inf, pid_t pid)
{
task_t task_port;
{
error_t err = proc_pid2task (proc_server, pid, &task_port);
if (err)
- error ("Error getting task for pid %d: %s", pid, strerror (err));
+ error (_("Error getting task for pid %d: %s"), pid, safe_strerror (err));
}
inf_debug (inf, "setting task: %d", task_port);
{
inf->pid = pid;
if (inf->pause_sc)
- inf->task->sc = inf->task->cur_sc = 1; /* Reflect task_suspend above */
+ /* Reflect task_suspend above. */
+ inf->task->sc = inf->task->cur_sc = 1;
}
else
inf->pid = -1;
}
+
\f
/* Validates INF's stopped, nomsg and traced field from the actual
proc server state. Note that the traced field is only updated from
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)
+ if (!err)
{
inf->stopped = !!(pi->state & PI_STOPPED);
inf->nomsg = !!(pi->state & PI_NOMSG);
if (inf->nomsg)
inf->traced = !!(pi->state & PI_TRACED);
- vm_deallocate (mach_task_self (), (vm_address_t)pi, pi_len);
+ vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
if (noise_len > 0)
- vm_deallocate (mach_task_self (), (vm_address_t)noise, noise_len);
+ vm_deallocate (mach_task_self (), (vm_address_t) noise, noise_len);
}
}
-/* Validates INF's task suspend count. If it's higher than we expect, verify
- with the user before `stealing' the extra count. */
+/* Validates INF's task suspend count. If it's higher than we expect,
+ verify with the user before `stealing' the extra count. */
static void
inf_validate_task_sc (struct inf *inf)
{
- struct task_basic_info info;
- mach_msg_type_number_t info_len = TASK_BASIC_INFO_COUNT;
- error_t err =
- task_info (inf->task->port, TASK_BASIC_INFO, (task_info_t)&info, &info_len);
+ char *noise;
+ mach_msg_type_number_t noise_len = 0;
+ struct procinfo *pi;
+ mach_msg_type_number_t pi_len = 0;
+ int info_flags = PI_FETCH_TASKINFO;
+ int suspend_count = -1;
+ error_t err;
+ retry:
+ err = proc_getprocinfo (proc_server, inf->pid, &info_flags,
+ (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
if (err)
- inf->task->dead = 1; /* oh well */
- else if (inf->task->cur_sc < info.suspend_count)
+ {
+ inf->task->dead = 1; /* oh well */
+ return;
+ }
+
+ if (inf->task->cur_sc < pi->taskinfo.suspend_count && suspend_count == -1)
+ {
+ /* The proc server might have suspended the task while stopping
+ it. This happens when the task is handling a traced signal.
+ Refetch the suspend count. The proc server should be
+ finished stopping the task by now. */
+ suspend_count = pi->taskinfo.suspend_count;
+ goto retry;
+ }
+
+ suspend_count = pi->taskinfo.suspend_count;
+
+ vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
+ if (noise_len > 0)
+ vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
+
+ if (inf->task->cur_sc < suspend_count)
{
int abort;
target_terminal_ours (); /* Allow I/O. */
- abort =
- !query ("Pid %d has an additional task suspend count of %d; clear it? ",
- inf->pid, info.suspend_count - inf->task->cur_sc);
- target_terminal_inferior (); /* Give it back to the child. */
+ 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. */
if (abort)
- error ("Additional task suspend count left untouched.");
+ error (_("Additional task suspend count left untouched."));
- inf->task->cur_sc = info.suspend_count;
+ inf->task->cur_sc = suspend_count;
}
}
-/* Turns tracing for INF on or off, depending on ON, unless it already is.
- If INF is running, the resume_sc count of INF's threads will be modified,
- and the signal thread will briefly be run to change the trace state. */
+/* Turns tracing for INF on or off, depending on ON, unless it already
+ is. If INF is running, the resume_sc count of INF's threads will
+ be modified, and the signal thread will briefly be run to change
+ the trace state. */
void
inf_set_traced (struct inf *inf, int on)
{
- if (on != inf->traced)
- if (inf->task && !inf->task->dead)
- /* Make it take effect immediately. */
- {
- sigset_t mask = on ? ~(sigset_t)0 : 0;
- error_t err =
- INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
- INIT_TRACEMASK, mask));
- if (err == EIEIO)
- {
- if (on)
- warning ("Can't modify tracing state for pid %d: No signal thread",
- inf->pid);
- inf->traced = on;
- }
- else if (err)
- warning ("Can't modify tracing state for pid %d: %s",
- inf->pid, strerror (err));
- else
+ if (on == inf->traced)
+ return;
+
+ if (inf->task && !inf->task->dead)
+ /* Make it take effect immediately. */
+ {
+ sigset_t mask = on ? ~(sigset_t) 0 : 0;
+ error_t err =
+ INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
+ INIT_TRACEMASK, mask));
+ if (err == EIEIO)
+ {
+ if (on)
+ warning (_("Can't modify tracing state for pid %d: %s"),
+ inf->pid, "No signal thread");
inf->traced = on;
- }
- else
- inf->traced = on;
+ }
+ else if (err)
+ warning (_("Can't modify tracing state for pid %d: %s"),
+ inf->pid, safe_strerror (err));
+ else
+ inf->traced = on;
+ }
+ else
+ inf->traced = on;
}
+
\f
-/* Makes all the real suspend count deltas of all the procs in INF match the
- desired values. Careful to always do thread/task suspend counts in the
- safe order. Returns true if at least one thread is thought to be running.*/
+/* Makes all the real suspend count deltas of all the procs in INF
+ match the desired values. Careful to always do thread/task suspend
+ counts in the safe order. Returns true if at least one thread is
+ thought to be running. */
int
inf_update_suspends (struct inf *inf)
{
inf->running = thread_running && task_running;
/* Once any thread has executed some code, we can't depend on the
- threads list any more. */
+ threads list any more. */
if (inf->running)
inf->threads_up_to_date = 0;
return 0;
}
+
\f
/* Converts a GDB pid to a struct proc. */
struct proc *
thread = thread->next;
return 0;
}
+
\f
/* Make INF's list of threads be consistent with reality of TASK. */
void
inf_validate_procs (struct inf *inf)
{
- int i;
thread_array_t threads;
- unsigned num_threads;
+ mach_msg_type_number_t num_threads, i;
struct proc *task = inf->task;
/* If no threads are currently running, this function will guarantee that
}
{
- unsigned search_start = 0; /* Make things normally linear. */
+ /* Make things normally linear. */
+ mach_msg_type_number_t search_start = 0;
/* Which thread in PROCS corresponds to each task thread, & the task. */
struct proc *matched[num_threads + 1];
/* The last thread in INF->threads, so we can add to the end. */
/* The current thread we're considering. */
struct proc *thread = inf->threads;
- bzero (matched, sizeof (matched));
+ memset (matched, 0, sizeof (matched));
while (thread)
{
- unsigned left;
+ mach_msg_type_number_t left;
for (i = search_start, left = num_threads; left; i++, left--)
{
if (i >= num_threads)
- i -= num_threads; /* I wrapped around. */
+ i -= num_threads; /* I wrapped around. */
if (thread->port == threads[i])
/* We already know about this thread. */
{
}
}
- if (! left)
+ if (!left)
{
proc_debug (thread, "died!");
thread->port = MACH_PORT_NULL;
- thread = _proc_free (thread); /* THREAD is dead. */
- (last ? last->next : inf->threads) = thread;
+ thread = _proc_free (thread); /* THREAD is dead. */
+ if (last)
+ last->next = thread;
+ else
+ inf->threads = thread;
}
}
for (i = 0; i < num_threads; i++)
- if (matched[i])
- /* Throw away the duplicate send right. */
- mach_port_deallocate (mach_task_self (), threads[i]);
- else
- /* THREADS[I] is a thread we don't know about yet! */
- {
- thread = make_proc (inf, threads[i], next_thread_id++);
- (last ? last->next : inf->threads) = thread;
- last = thread;
- proc_debug (thread, "new thread: %d", threads[i]);
- add_thread (thread->tid); /* Tell GDB's generic thread code. */
- }
+ {
+ if (matched[i])
+ /* Throw away the duplicate send right. */
+ mach_port_deallocate (mach_task_self (), threads[i]);
+ else
+ /* THREADS[I] is a thread we don't know about yet! */
+ {
+ ptid_t ptid;
+
+ thread = make_proc (inf, threads[i], next_thread_id++);
+ if (last)
+ last->next = thread;
+ else
+ inf->threads = thread;
+ last = thread;
+ proc_debug (thread, "new thread: %d", threads[i]);
+
+ 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);
+ }
+ }
- vm_deallocate(mach_task_self(),
- (vm_address_t)threads, (num_threads * sizeof(thread_t)));
+ vm_deallocate (mach_task_self (),
+ (vm_address_t) threads, (num_threads * sizeof (thread_t)));
}
}
+
\f
/* Makes sure that INF's thread list is synced with the actual process. */
-inline int
+int
inf_update_procs (struct inf *inf)
{
- if (! inf->task)
+ if (!inf->task)
return 0;
- if (! inf->threads_up_to_date)
+ if (!inf->threads_up_to_date)
inf_validate_procs (inf);
return !!inf->task;
}
/* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
and others are set to their run_sc if RUN_OTHERS is true, and otherwise
their pause_sc. */
-inline void
+void
inf_set_threads_resume_sc (struct inf *inf,
struct proc *run_thread, int run_others)
{
else
thread->resume_sc = thread->pause_sc;
}
+
\f
/* Cause INF to continue execution immediately; individual threads may still
be suspended (but their suspend counts will be updated). */
-inline void
+void
inf_resume (struct inf *inf)
{
struct proc *thread;
if (inf->task)
{
- if (! inf->pending_execs)
+ if (!inf->pending_execs)
/* Try to make sure our task count is correct -- in the case where
we're waiting for an exec though, things are too volatile, so just
assume things will be reasonable (which they usually will be). */
/* Cause INF to stop execution immediately; individual threads may still
be running. */
-inline void
+void
inf_suspend (struct inf *inf)
{
struct proc *thread;
inf_update_suspends (inf);
}
+
\f
-/* INF has one thread PROC that is in single-stepping mode. This function
- changes it to be PROC, changing any old step_thread to be a normal one. A
- PROC of 0 clears any existing value. */
+/* INF has one thread PROC that is in single-stepping mode. This
+ function changes it to be PROC, changing any old step_thread to be
+ a normal one. A PROC of 0 clears any existing value. */
void
inf_set_step_thread (struct inf *inf, struct proc *thread)
{
- assert (!thread || proc_is_thread (thread));
+ gdb_assert (!thread || proc_is_thread (thread));
if (thread)
inf_debug (inf, "setting step thread: %d/%d", inf->pid, thread->tid);
if (inf->step_thread != thread)
{
if (inf->step_thread && inf->step_thread->port != MACH_PORT_NULL)
- if (! proc_trace (inf->step_thread, 0))
+ if (!proc_trace (inf->step_thread, 0))
return;
if (thread && proc_trace (thread, 1))
inf->step_thread = thread;
inf->step_thread = 0;
}
}
+
\f
/* Set up the thread resume_sc's so that only the signal thread is running
(plus whatever other thread are set to always run). Returns true if we
did so, or false if we can't find a signal thread. */
-inline int
+int
inf_set_threads_resume_sc_for_signal_thread (struct inf *inf)
{
if (inf->signal_thread)
the signal thread. */
inf->signal_thread = inf->threads ? inf->threads->next : 0;
}
+
\f
/* Detachs from INF's inferior task, letting it run once again... */
void
inf_cleanup (inf);
}
-/* Attaches INF to the process with process id PID, returning it in a suspended
- state suitable for debugging. */
+/* Attaches INF to the process with process id PID, returning it in a
+ suspended state suitable for debugging. */
void
inf_attach (struct inf *inf, int pid)
{
inf_startup (inf, pid);
}
+
\f
/* Makes sure that we've got our exception ports entrenched in the process. */
-void inf_steal_exc_ports (struct inf *inf)
+void
+inf_steal_exc_ports (struct inf *inf)
{
struct proc *thread;
}
/* Makes sure the process has its own exception ports. */
-void inf_restore_exc_ports (struct inf *inf)
+void
+inf_restore_exc_ports (struct inf *inf)
{
struct proc *thread;
for (thread = inf->threads; thread; thread = thread->next)
proc_restore_exc_port (thread);
}
+
\f
/* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
signal 0, will continue it. INF is assumed to be in a paused state, and
e->exception, e->code, e->subcode);
}
else
- error ("Can't forward spontaneous exception (%s).", NAME);
+ error (_("Can't forward spontaneous exception (%s)."), NAME);
}
else
/* A Unix signal. */
- if (inf->stopped)
- /* The process is stopped and expecting a signal. Just send off a
- request and let it get handled when we resume everything. */
- {
- inf_debug (inf, "sending %s to stopped process", NAME);
- err =
- INF_MSGPORT_RPC (inf,
- msg_sig_post_untraced_request (msgport,
- inf->event_port,
- MACH_MSG_TYPE_MAKE_SEND_ONCE,
- host_sig, 0,
- refport));
- if (! err)
- /* Posting an untraced signal automatically continues it.
- We clear this here rather than when we get the reply
- because we'd rather assume it's not stopped when it
- actually is, than the reverse. */
- inf->stopped = 0;
- }
- else
- /* It's not expecting it. We have to let just the signal thread
- run, and wait for it to get into a reasonable state before we
- can continue the rest of the process. When we finally resume the
- process the signal we request will be the very first thing that
- happens. */
- {
- inf_debug (inf, "sending %s to unstopped process (so resuming signal thread)", NAME);
- err =
- INF_RESUME_MSGPORT_RPC (inf, msg_sig_post_untraced (msgport,
- host_sig, 0, refport));
- }
+ if (inf->stopped)
+ /* The process is stopped and expecting a signal. Just send off a
+ request and let it get handled when we resume everything. */
+ {
+ inf_debug (inf, "sending %s to stopped process", NAME);
+ err =
+ INF_MSGPORT_RPC (inf,
+ msg_sig_post_untraced_request (msgport,
+ inf->event_port,
+ MACH_MSG_TYPE_MAKE_SEND_ONCE,
+ host_sig, 0,
+ refport));
+ if (!err)
+ /* Posting an untraced signal automatically continues it.
+ We clear this here rather than when we get the reply
+ because we'd rather assume it's not stopped when it
+ actually is, than the reverse. */
+ inf->stopped = 0;
+ }
+ else
+ /* It's not expecting it. We have to let just the signal thread
+ run, and wait for it to get into a reasonable state before we
+ can continue the rest of the process. When we finally resume the
+ process the signal we request will be the very first thing that
+ happens. */
+ {
+ inf_debug (inf, "sending %s to unstopped process"
+ " (so resuming signal thread)", NAME);
+ err =
+ INF_RESUME_MSGPORT_RPC (inf,
+ msg_sig_post_untraced (msgport, host_sig,
+ 0, refport));
+ }
if (err == EIEIO)
/* Can't do too much... */
- warning ("Can't deliver signal %s: No signal thread.", NAME);
+ warning (_("Can't deliver signal %s: No signal thread."), NAME);
else if (err)
- warning ("Delivering signal %s: %s", NAME, strerror (err));
+ warning (_("Delivering signal %s: %s"), NAME, safe_strerror (err));
#undef NAME
}
+
\f
/* Continue INF without delivering a signal. This is meant to be used
when INF does not have a message port. */
process_t proc;
error_t err = proc_pid2proc (proc_server, inf->pid, &proc);
- if (! err)
+ if (!err)
{
inf_debug (inf, "continuing process");
err = proc_mark_cont (proc);
- if (! err)
+ if (!err)
{
struct proc *thread;
for (thread = inf->threads; thread; thread = thread->next)
thread_resume (thread->port);
-
+
inf->stopped = 0;
}
}
if (err)
- warning ("Can't continue process: %s", strerror (err));
+ warning (_("Can't continue process: %s"), safe_strerror (err));
}
+
\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. */
struct inf *waiting_inf;
/* Wait for something to happen in the inferior, returning what in STATUS. */
-static int
-gnu_wait (int tid, struct target_waitstatus *status)
+static ptid_t
+gnu_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
- struct msg {
- mach_msg_header_t hdr;
- mach_msg_type_t type;
- int data[8000];
- } msg;
+ struct msg
+ {
+ mach_msg_header_t hdr;
+ mach_msg_type_t type;
+ int data[8000];
+ } 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 *);
+ extern int notify_server (mach_msg_header_t *, mach_msg_header_t *);
+ extern int process_reply_server (mach_msg_header_t *, mach_msg_header_t *);
- assert (inf->task);
+ gdb_assert (inf->task);
if (!inf->threads && !inf->pending_execs)
/* No threads! Assume that maybe some outside agency is frobbing our
{
inf_validate_procs (inf);
if (!inf->threads && !inf->task->dead)
- error ("There are no threads; try again later.");
+ error (_("There are no threads; try again later."));
}
waiting_inf = inf;
- inf_debug (inf, "waiting for: %d", tid);
+ inf_debug (inf, "waiting for: %s", target_pid_to_str (ptid));
- rewait:
+rewait:
if (proc_wait_pid != inf->pid && !inf->no_wait)
/* Always get information on events from the proc server. */
{
err =
proc_wait_request (proc_server, inf->event_port, inf->pid, WUNTRACED);
if (err)
- warning ("wait request failed: %s", strerror (err));
+ warning (_("wait request failed: %s"), safe_strerror (err));
else
{
inf_debug (inf, "waits pending: %d", proc_waits_pending);
proc_wait_pid = inf->pid;
- /* Even if proc_waits_pending was > 0 before, we still won't get
- any other replies, because it was either from a different INF,
- or a different process attached to INF -- and the event port,
- which is the wait reply port, changes when you switch processes.*/
+ /* Even if proc_waits_pending was > 0 before, we still won't
+ get any other replies, because it was either from a
+ different INF, or a different process attached to INF --
+ and the event port, which is the wait reply port, changes
+ when you switch processes. */
proc_waits_pending = 1;
}
}
if (err == EMACH_RCV_INTERRUPTED)
inf_debug (inf, "interrupted");
else if (err)
- error ("Couldn't wait for an event: %s", strerror (err));
+ error (_("Couldn't wait for an event: %s"), safe_strerror (err));
else
{
- struct {
- mach_msg_header_t hdr;
- mach_msg_type_t err_type;
- kern_return_t err;
- char noise[200];
- } reply;
+ struct
+ {
+ mach_msg_header_t hdr;
+ mach_msg_type_t err_type;
+ kern_return_t err;
+ char noise[200];
+ }
+ reply;
inf_debug (inf, "event: msgid = %d", msg.hdr.msgh_id);
/* Handle what we got. */
- if (! notify_server (&msg.hdr, &reply.hdr)
- && ! exc_server (&msg.hdr, &reply.hdr)
- && ! process_reply_server (&msg.hdr, &reply.hdr)
- && ! msg_reply_server (&msg.hdr, &reply.hdr))
+ if (!notify_server (&msg.hdr, &reply.hdr)
+ && !exc_server (&msg.hdr, &reply.hdr)
+ && !process_reply_server (&msg.hdr, &reply.hdr)
+ && !msg_reply_server (&msg.hdr, &reply.hdr))
/* Whatever it is, it's something strange. */
- error ("Got a strange event, msg id = %d.", msg.hdr.msgh_id);
+ error (_("Got a strange event, msg id = %d."), msg.hdr.msgh_id);
if (reply.err)
- error ("Handling event, msgid = %d: %s",
- msg.hdr.msgh_id, strerror (reply.err));
+ error (_("Handling event, msgid = %d: %s"),
+ msg.hdr.msgh_id, safe_strerror (reply.err));
}
if (inf->pending_execs)
if (--inf->pending_execs == 0)
/* We're done! */
{
-#if 0 /* do we need this? */
+#if 0 /* do we need this? */
prune_threads (1); /* Get rid of the old shell threads */
- renumber_threads (0); /* Give our threads reasonable names. */
+ renumber_threads (0); /* Give our threads reasonable names. */
#endif
}
inf_debug (inf, "pending exec completed, pending_execs => %d",
}
/* Pass back out our results. */
- bcopy (&inf->wait.status, status, sizeof (*status));
+ memcpy (status, &inf->wait.status, sizeof (*status));
thread = inf->wait.thread;
if (thread)
- tid = 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, 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 = inf->threads->tid; /* The first available thread. */
- else
- tid = inferior_pid; /* let wait_for_inferior handle exit case */
+ {
+ /* TID is dead; try and find a new thread. */
+ if (inf_update_procs (inf) && inf->threads)
+ ptid = ptid_build (inf->pid, 0, inf->threads->tid); /* The first available thread. */
+ else
+ ptid = inferior_ptid; /* let wait_for_inferior handle exit case */
+ }
- if (thread && 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. */
+ /* If something actually happened to THREAD, make sure we
+ suspend it. */
{
thread->sc = 1;
inf_update_suspends (inf);
- }
+ }
- inf_debug (inf, "returning tid = %d, status = %s (%d)", 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
/* The rpc handler called by exc_server. */
error_t
inf_debug (waiting_inf,
"thread = %d, task = %d, exc = %d, code = %d, subcode = %d",
- thread_port, task_port, exception, code);
+ thread_port, task_port, exception, code, subcode);
if (!thread)
/* We don't know about thread? */
mach_port_deallocate (mach_task_self (), thread_port);
mach_port_deallocate (mach_task_self (), task_port);
- if (! thread->aborted)
+ if (!thread->aborted)
/* THREAD hasn't been aborted since this exception happened (abortion
clears any exception state), so it must be real. */
{
{
if (thread->exc_port == port)
{
- inf_debug (waiting_inf, "Handler is thread exeption port <%d>",
+ inf_debug (waiting_inf, "Handler is thread exception port <%d>",
thread->saved_exc_port);
inf->wait.exc.handler = thread->saved_exc_port;
}
else
{
- inf_debug (waiting_inf, "Handler is task exeption port <%d>",
+ inf_debug (waiting_inf, "Handler is task exception port <%d>",
inf->task->saved_exc_port);
inf->wait.exc.handler = inf->task->saved_exc_port;
- assert (inf->task->exc_port == port);
+ gdb_assert (inf->task->exc_port == port);
}
if (inf->wait.exc.handler != MACH_PORT_NULL)
/* Add a reference to the exception handler. */
return 0;
}
+
\f
/* Fill in INF's wait field after a task has died without giving us more
detailed information. */
void
inf_task_died_status (struct inf *inf)
{
- warning ("Pid %d died with unknown exit status, using SIGKILL.", inf->pid);
+ warning (_("Pid %d died with unknown exit status, using SIGKILL."), inf->pid);
inf->wait.status.kind = TARGET_WAITKIND_SIGNALLED;
inf->wait.status.value.sig = TARGET_SIGNAL_KILL;
}
proc_debug (thread, "is dead");
thread->port = MACH_PORT_NULL;
}
+
+ if (inf->task->dead)
+ /* Since the task is dead, its threads are dying with it. */
+ inf->wait.suppress = 1;
}
mach_port_deallocate (mach_task_self (), dead_port);
- inf->threads_up_to_date = 0; /* Just in case */
+ inf->threads_up_to_date = 0; /* Just in case */
return 0;
}
+
\f
static error_t
ill_rpc (char *fun)
{
- warning ("illegal rpc: %s", fun);
+ warning (_("illegal rpc: %s"), fun);
return 0;
}
error_t
do_mach_notify_no_senders (mach_port_t notify, mach_port_mscount_t count)
{
- return ill_rpc (__FUNCTION__);
+ return ill_rpc ("do_mach_notify_no_senders");
}
error_t
do_mach_notify_port_deleted (mach_port_t notify, mach_port_t name)
{
- return ill_rpc (__FUNCTION__);
+ return ill_rpc ("do_mach_notify_port_deleted");
}
error_t
do_mach_notify_msg_accepted (mach_port_t notify, mach_port_t name)
{
- return ill_rpc (__FUNCTION__);
+ return ill_rpc ("do_mach_notify_msg_accepted");
}
error_t
do_mach_notify_port_destroyed (mach_port_t notify, mach_port_t name)
{
- return ill_rpc (__FUNCTION__);
+ return ill_rpc ("do_mach_notify_port_destroyed");
}
error_t
do_mach_notify_send_once (mach_port_t notify)
{
- return ill_rpc (__FUNCTION__);
+ return ill_rpc ("do_mach_notify_send_once");
}
+
\f
/* Process_reply server routines. We only use process_wait_reply. */
struct inf *inf = waiting_inf;
inf_debug (inf, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
- err ? strerror (err) : "0", pid, status, sigcode);
+ err ? safe_strerror (err) : "0", pid, status, sigcode);
if (err && proc_wait_pid && (!inf->task || !inf->task->port))
/* Ack. The task has died, but the task-died notification code didn't
{
if (err != EINTR)
{
- warning ("Can't wait for pid %d: %s", inf->pid, strerror (err));
+ warning (_("Can't wait for pid %d: %s"), inf->pid, safe_strerror (err));
inf->no_wait = 1;
/* Since we can't see the inferior's signals, don't trap them. */
S_proc_setmsgport_reply (mach_port_t reply, error_t err,
mach_port_t old_msg_port)
{
- return ill_rpc (__FUNCTION__);
+ return ill_rpc ("S_proc_setmsgport_reply");
}
error_t
S_proc_getmsgport_reply (mach_port_t reply, error_t err, mach_port_t msg_port)
{
- return ill_rpc (__FUNCTION__);
+ return ill_rpc ("S_proc_getmsgport_reply");
}
+
\f
/* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
inf->wait.status.value.sig = TARGET_SIGNAL_0;
}
else if (err)
- warning ("Signal delivery failed: %s", strerror (err));
+ warning (_("Signal delivery failed: %s"), safe_strerror (err));
if (err)
/* We only get this reply when we've posted a signal to a process which we
error_t
S_msg_sig_post_reply (mach_port_t reply, error_t err)
{
- return ill_rpc (__FUNCTION__);
+ return ill_rpc ("S_msg_sig_post_reply");
}
+
\f
/* Returns the number of messages queued for the receive right PORT. */
static mach_port_msgcount_t
{
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;
else
return status.mps_msgcount;
}
+
\f
/* Resume execution of the inferior process.
Note that a resume may not `take' if there are pending exceptions/&c
still unprocessed from the last resume we did (any given resume may result
in multiple events returned by wait).
-*/
+ */
static void
-gnu_resume (int 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", tid, step, sig);
+ inf_debug (inf, "ptid = %s, step = %d, sig = %d",
+ target_pid_to_str (ptid), step, sig);
inf_validate_procinfo (inf);
-
+
if (sig != TARGET_SIGNAL_0 || inf->stopped)
{
if (sig == TARGET_SIGNAL_0 && inf->nomsg)
abort the faulting thread, which will perhaps retake it. */
{
proc_abort (inf->wait.thread, 1);
- warning ("Aborting %s with unforwarded exception %s.",
+ warning (_("Aborting %s with unforwarded exception %s."),
proc_string (inf->wait.thread),
target_signal_to_name (inf->wait.status.value.sig));
}
inf_update_procs (inf);
- if (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", inferior_pid);
- tid = inferior_pid; /* What to step. */
+ inf_debug (inf, "running all threads; tid = %d", PIDGET (inferior_ptid));
+ 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, tid);
- 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);
+ 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));
+ 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, tid);
- if (! step_thread)
- warning ("Can't step thread id %d: no such thread.", tid);
+ step_thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
+ if (!step_thread)
+ 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);
inf_debug (inf, "here we go...");
inf_resume (inf);
}
+
\f
static void
-gnu_kill_inferior ()
+gnu_kill_inferior (void)
{
- 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 ()
+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 ();
}
+
\f
/* Fork an inferior process, and start debugging it. */
/* Set INFERIOR_PID to the first thread available in the child, if any. */
static int
-inf_pick_first_thread ()
+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 ()
+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 (exec_file, allargs, env)
- 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 ();
void trace_me ()
- {
- /* We're in the child; make this process stop as soon as it execs. */
- inf_debug (inf, "tracing self");
- if (ptrace (PTRACE_TRACEME) != 0)
- error ("ptrace (PTRACE_TRACEME) failed!");
- }
+ {
+ /* We're in the child; make this process stop as soon as it execs. */
+ inf_debug (inf, "tracing self");
+ 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);
+ {
+ /* Attach to the now stopped child, which is actually a shell... */
+ inf_debug (inf, "attaching to child: %d", pid);
- inf_attach (inf, pid);
+ inf_attach (inf, pid);
- attach_flag = 0;
- push_target (&gnu_ops);
+ push_target (&gnu_ops);
- inf->pending_execs = 2;
- inf->nomsg = 1;
- inf->traced = 1;
+ inf->pending_execs = 2;
+ inf->nomsg = 1;
+ inf->traced = 1;
- /* Now let the child run again, knowing that it will stop immediately
- because of the ptrace. */
- inf_resume (inf);
- inferior_pid = inf_pick_first_thread ();
+ /* Now let the child run again, knowing that it will stop immediately
+ because of the ptrace. */
+ inf_resume (inf);
- startup_inferior (inf->pending_execs);
- }
+ /* 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_debug (inf, "creating inferior");
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"
commands. */
static int
-gnu_can_run ()
+gnu_can_run (void)
{
return 1;
}
-\f
-#ifdef ATTACH_DETACH
+\f
/* Attach to process PID, then initialize for debugging it
and wait for the trace-trap that results from attaching. */
static void
-gnu_attach (args, from_tty)
- 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 ("PID to attach");
+ error_no_arg (_("process-id to attach"));
pid = atoi (args);
- if (pid == getpid()) /* Trying to masturbate? */
- error ("I refuse to debug myself!");
+ if (pid == getpid ()) /* Trying to masturbate? */
+ error (_("I refuse to debug myself!"));
if (from_tty)
{
inf_debug (inf, "attaching to pid: %d", pid);
inf_attach (inf, pid);
- inf_update_procs (inf);
- inferior_pid = 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 ();
-
+
/* If the process was stopped before we attached, make it continue the next
time the user does a continue. */
inf_validate_procinfo (inf);
inf_update_signal_thread (inf);
inf_set_traced (inf, inf->want_signals);
-#if 0 /* Do we need this? */
+#if 0 /* Do we need this? */
renumber_threads (0); /* Give our threads reasonable names. */
#endif
}
+
\f
/* Take a program previously attached to and detaches it.
The program resumes execution and will no longer stop
previously attached. It *might* work if the program was
started via fork. */
static void
-gnu_detach (args, from_tty)
- 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);
- inferior_pid = 0;
+ pid = gnu_current_inf->pid;
- unpush_target (&gnu_ops); /* Pop out of handling an inferior */
-}
-#endif /* ATTACH_DETACH */
+ inf_detach (gnu_current_inf);
+ inferior_ptid = null_ptid;
+ detach_inferior (pid);
+
+ unpush_target (&gnu_ops); /* Pop out of handling an inferior */
+}
+\f
static void
-gnu_terminal_init_inferior ()
+gnu_terminal_init_inferior (void)
{
- 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
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 ()
+gnu_prepare_to_store (struct regcache *regcache)
{
-#ifdef CHILD_PREPARE_TO_STORE
- CHILD_PREPARE_TO_STORE ();
-#endif
}
static void
-gnu_open (arg, from_tty)
- char *arg;
- int from_tty;
+gnu_open (char *arg, int from_tty)
{
- error ("Use the \"run\" command to start a Unix child process.");
+ error (_("Use the \"run\" command to start a Unix child process."));
}
static void
-gnu_stop ()
+gnu_stop (ptid_t ptid)
{
- error ("to_stop target function not implemented");
+ error (_("to_stop target function not implemented"));
}
-static char *
-gnu_pid_to_exec_file ()
-{
- error ("to_pid_to_exec_file target function not implemented");
- return NULL;
-}
-
-
static int
-gnu_thread_alive (int tid)
+gnu_thread_alive (struct target_ops *ops, ptid_t ptid)
{
- inf_update_procs (current_inferior);
- return !!inf_tid_to_thread (current_inferior, tid);
+ inf_update_procs (gnu_current_inf);
+ return !!inf_tid_to_thread (gnu_current_inf,
+ ptid_get_tid (ptid));
}
+
\f
-/*
- * Read inferior task's LEN bytes from ADDR and copy it to MYADDR
- * in gdb's address space.
- *
- * Return 0 on failure; number of bytes read otherwise.
- */
+/* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
+ gdb's address space. Return 0 on failure; number of bytes read
+ otherwise. */
int
-gnu_read_inferior (task, addr, myaddr, length)
- task_t task;
- CORE_ADDR addr;
- char *myaddr;
- int length;
+gnu_read_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length)
{
error_t err;
vm_address_t low_address = (vm_address_t) trunc_page (addr);
vm_size_t aligned_length =
- (vm_size_t) round_page (addr+length) - low_address;
- pointer_t copied;
- int copy_count;
+ (vm_size_t) round_page (addr + length) - low_address;
+ pointer_t copied;
+ int copy_count;
/* Get memory from inferior with page aligned addresses */
err = vm_read (task, low_address, aligned_length, &copied, ©_count);
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", strerror (err));
+ warning (_("Read from inferior faulted: %s"), safe_strerror (err));
length = 0;
}
err = vm_deallocate (mach_task_self (), copied, copy_count);
if (err)
- warning ("gnu_read_inferior vm_deallocate failed: %s", strerror (err));
+ warning (_("gnu_read_inferior vm_deallocate failed: %s"), safe_strerror (err));
return length;
}
#define CHK_GOTO_OUT(str,ret) \
do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
-struct vm_region_list {
+struct vm_region_list
+{
struct vm_region_list *next;
- vm_prot_t protection;
- vm_address_t start;
- vm_size_t length;
+ vm_prot_t protection;
+ vm_address_t start;
+ vm_size_t length;
};
-struct obstack region_obstack;
+struct obstack region_obstack;
-/*
- * Write gdb's LEN bytes from MYADDR and copy it to ADDR
- * in inferior task's address space.
- */
+/* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
+ task's address space. */
int
-gnu_write_inferior (task, addr, myaddr, length)
- task_t task;
- CORE_ADDR addr;
- char *myaddr;
- int length;
+gnu_write_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length)
{
error_t err = 0;
- vm_address_t low_address = (vm_address_t) trunc_page (addr);
- vm_size_t aligned_length =
- (vm_size_t) round_page (addr+length) - low_address;
- pointer_t copied;
- int copy_count;
- int deallocate = 0;
+ vm_address_t low_address = (vm_address_t) trunc_page (addr);
+ vm_size_t aligned_length =
+ (vm_size_t) round_page (addr + length) - low_address;
+ pointer_t copied;
+ int copy_count;
+ int deallocate = 0;
- char *errstr = "Bug in gnu_write_inferior";
+ char *errstr = "Bug in gnu_write_inferior";
struct vm_region_list *region_element;
- struct vm_region_list *region_head = (struct vm_region_list *)NULL;
+ struct vm_region_list *region_head = (struct vm_region_list *) NULL;
/* Get memory from inferior with page aligned addresses */
err = vm_read (task,
deallocate++;
- err = hurd_safe_copyout ((void*)addr - low_address + copied, myaddr, length);
+ err = hurd_safe_copyout ((void *) (addr - low_address + copied),
+ myaddr, length);
CHK_GOTO_OUT ("Write to inferior faulted", err);
obstack_init (®ion_obstack);
/* Do writes atomically.
- * First check for holes and unwritable memory.
- */
+ First check for holes and unwritable memory. */
{
- vm_size_t remaining_length = aligned_length;
- vm_address_t region_address = low_address;
+ vm_size_t remaining_length = aligned_length;
+ vm_address_t region_address = low_address;
struct vm_region_list *scan;
- while(region_address < low_address + aligned_length)
+ while (region_address < low_address + aligned_length)
{
vm_prot_t protection;
vm_prot_t max_protection;
boolean_t shared;
mach_port_t object_name;
vm_offset_t offset;
- vm_size_t region_length = remaining_length;
- vm_address_t old_address = region_address;
-
+ vm_size_t region_length = remaining_length;
+ vm_address_t old_address = region_address;
+
err = vm_region (task,
®ion_address,
®ion_length,
/* Check for holes in memory */
if (old_address != region_address)
{
- warning ("No memory at 0x%x. Nothing written",
+ warning (_("No memory at 0x%x. Nothing written"),
old_address);
err = KERN_SUCCESS;
length = 0;
if (!(max_protection & VM_PROT_WRITE))
{
- warning ("Memory at address 0x%x is unwritable. Nothing written",
+ warning (_("Memory at address 0x%x is unwritable. Nothing written"),
old_address);
err = KERN_SUCCESS;
length = 0;
}
/* Chain the regions for later use */
- region_element =
+ region_element =
(struct vm_region_list *)
- obstack_alloc (®ion_obstack, sizeof (struct vm_region_list));
-
+ obstack_alloc (®ion_obstack, sizeof (struct vm_region_list));
+
region_element->protection = protection;
- region_element->start = region_address;
- region_element->length = region_length;
+ region_element->start = region_address;
+ region_element->length = region_length;
/* Chain the regions along with protections */
region_element->next = region_head;
- region_head = region_element;
-
+ region_head = region_element;
+
region_address += region_length;
remaining_length = remaining_length - region_length;
}
/* If things fail after this, we give up.
- * Somebody is messing up inferior_task's mappings.
- */
-
+ Somebody is messing up inferior_task's mappings. */
+
/* Enable writes to the chained vm regions */
for (scan = region_head; scan; scan = scan->next)
{
- boolean_t protection_changed = FALSE;
-
if (!(scan->protection & VM_PROT_WRITE))
{
err = vm_protect (task,
copied,
aligned_length);
CHK_GOTO_OUT ("vm_write failed", err);
-
+
/* Set up the original region protections, if they were changed */
for (scan = region_head; scan; scan = scan->next)
{
- boolean_t protection_changed = FALSE;
-
if (!(scan->protection & VM_PROT_WRITE))
{
err = vm_protect (task,
}
}
- out:
+out:
if (deallocate)
{
obstack_free (®ion_obstack, 0);
-
+
(void) vm_deallocate (mach_task_self (),
copied,
copy_count);
if (err != KERN_SUCCESS)
{
- warning ("%s: %s", errstr, mach_error_string (err));
+ warning (_("%s: %s"), errstr, mach_error_string (err));
return 0;
}
return length;
}
+
\f
-/* Return 0 on failure, number of bytes handled otherwise. */
+/* Return 0 on failure, number of bytes handled otherwise. TARGET
+ is ignored. */
static int
-gnu_xfer_memory (memaddr, myaddr, len, write, target)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int write;
- struct target_ops *target; /* IGNORED */
-{
- int result;
- task_t task =
- current_inferior
- ? (current_inferior->task ? current_inferior->task->port : 0)
- : 0;
+gnu_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
+ struct mem_attrib *attrib,
+ struct target_ops *target)
+{
+ 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", memaddr, len,
+ inf_debug (gnu_current_inf, "%s %p[%d] %s %p",
+ write ? "writing" : "reading", (void *) memaddr, len,
write ? "<--" : "-->", myaddr);
if (write)
return gnu_write_inferior (task, memaddr, myaddr, len);
else
- return gnu_read_inferior (task, memaddr, myaddr, len);
+ return gnu_read_inferior (task, memaddr, myaddr, len);
}
}
-\f
-extern void gnu_store_registers (int regno);
-extern void gnu_fetch_registers (int regno);
-struct target_ops gnu_ops ;
+/* 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)
+{
+ error_t err;
+ task_t task;
+ vm_address_t region_address, last_region_address, last_region_end;
+ vm_prot_t last_protection;
+
+ if (gnu_current_inf == 0 || gnu_current_inf->task == 0)
+ return 0;
+ task = gnu_current_inf->task->port;
+ if (task == MACH_PORT_NULL)
+ return 0;
+
+ region_address = last_region_address = last_region_end = VM_MIN_ADDRESS;
+ last_protection = VM_PROT_NONE;
+ while (region_address < VM_MAX_ADDRESS)
+ {
+ vm_prot_t protection;
+ vm_prot_t max_protection;
+ vm_inherit_t inheritance;
+ boolean_t shared;
+ mach_port_t object_name;
+ vm_offset_t offset;
+ vm_size_t region_length = VM_MAX_ADDRESS - region_address;
+ vm_address_t old_address = region_address;
+
+ err = vm_region (task,
+ ®ion_address,
+ ®ion_length,
+ &protection,
+ &max_protection,
+ &inheritance,
+ &shared,
+ &object_name,
+ &offset);
+ if (err == KERN_NO_SPACE)
+ break;
+ if (err != KERN_SUCCESS)
+ {
+ warning (_("vm_region failed: %s"), mach_error_string (err));
+ return -1;
+ }
+
+ if (protection == last_protection && region_address == last_region_end)
+ /* This region is contiguous with and indistinguishable from
+ the previous one, so we just extend that one. */
+ last_region_end = region_address += region_length;
+ else
+ {
+ /* This region is distinct from the last one we saw, so report
+ that previous one. */
+ if (last_protection != VM_PROT_NONE)
+ (*func) (last_region_address,
+ last_region_end - last_region_address,
+ last_protection & VM_PROT_READ,
+ last_protection & VM_PROT_WRITE,
+ last_protection & VM_PROT_EXECUTE,
+ data);
+ last_region_address = region_address;
+ last_region_end = region_address += region_length;
+ last_protection = protection;
+ }
+ }
+
+ /* Report the final region. */
+ if (last_region_end > last_region_address && last_protection != VM_PROT_NONE)
+ (*func) (last_region_address, last_region_end - last_region_address,
+ last_protection & VM_PROT_READ,
+ last_protection & VM_PROT_WRITE,
+ last_protection & VM_PROT_EXECUTE,
+ data);
+
+ return 0;
+}
-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_close = 0; /* to_close */
- gnu_ops.to_attach = gnu_attach; /* to_attach */
- gnu_ops.to_post_attach = NULL;
- gnu_ops.to_require_attach = NULL; /* to_require_attach */
- gnu_ops.to_detach = gnu_detach; /* to_detach */
- gnu_ops.to_require_detach = NULL; /* to_require_detach */
- gnu_ops.to_resume = gnu_resume; /* to_resume */
- gnu_ops.to_wait = gnu_wait; /* to_wait */
- gnu_ops.to_post_wait = NULL; /* to_post_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.to_xfer_memory = gnu_xfer_memory; /* to_xfer_memory */
- gnu_ops.to_files_info = 0; /* to_files_info */
- 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_ours = terminal_ours;
- gnu_ops.to_terminal_info = child_terminal_info;
- gnu_ops.to_kill = gnu_kill_inferior; /* to_kill */
- gnu_ops.to_load = 0; /* to_load */
- gnu_ops.to_lookup_symbol = 0; /* to_lookup_symbol */
- gnu_ops.to_create_inferior = gnu_create_inferior; /* to_create_inferior */
- gnu_ops.to_post_startup_inferior = NULL; /* to_post_startup_inferior */
- gnu_ops.to_acknowledge_created_inferior = NULL; /* to_acknowledge_created_inferior */
- gnu_ops.to_clone_and_follow_inferior = NULL; /* to_clone_and_follow_inferior */
- gnu_ops.to_post_follow_inferior_by_clone = NULL; /* to_post_follow_inferior_by_clone */
- gnu_ops.to_insert_fork_catchpoint = NULL;
- gnu_ops.to_remove_fork_catchpoint = NULL;
- gnu_ops.to_insert_vfork_catchpoint = NULL;
- gnu_ops.to_remove_vfork_catchpoint = NULL;
- gnu_ops.to_has_forked = NULL; /* to_has_forked */
- gnu_ops.to_has_vforked = NULL; /* to_has_vforked */
- gnu_ops.to_can_follow_vfork_prior_to_exec = NULL;
- gnu_ops.to_post_follow_vfork = NULL; /* to_post_follow_vfork */
- gnu_ops.to_insert_exec_catchpoint = NULL;
- gnu_ops.to_remove_exec_catchpoint = NULL;
- gnu_ops.to_has_execd = NULL;
- gnu_ops.to_reported_exec_events_per_exec_call = NULL;
- gnu_ops.to_has_exited = NULL;
- 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_notice_signals = 0; /* to_notice_signals */
- gnu_ops.to_thread_alive = gnu_thread_alive;/* to_thread_alive */
- 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_core_file_to_sym_file = NULL;
- gnu_ops.to_stratum = process_stratum; /* to_stratum */
- gnu_ops.DONT_USE = 0; /* to_next */
- 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_sections = 0; /* sections */
- gnu_ops.to_sections_end = 0; /* sections_end */
- gnu_ops.to_magic = OPS_MAGIC ; /* to_magic */
-} /* init_gnu_ops */
\f
/* Return printable description of proc. */
-char *proc_string (struct proc *proc)
+char *
+proc_string (struct proc *proc)
{
static char tid_str[80];
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 (proc->tid));
+ sprintf (tid_str, "Thread %d.%d",
+ proc->inf->pid, proc->tid);
return tid_str;
}
-char *
-gnu_target_pid_to_str (int tid)
+static char *
+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);
if (thread)
return tid_str;
}
}
+
+\f
+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;
+
+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 */
+
\f
/* User task commands. */
if (*args && *arg_end == '\0')
return val;
}
- error ("Illegal argument for \"%s\" command, should be an integer.", cmd_prefix);
+ error (_("Illegal argument for \"%s\" command, should be an integer."), cmd_prefix);
}
static int
else if (strcmp (args, f_val) == 0)
return 0;
else
- error ("Illegal argument for \"%s\" command, should be \"%s\" or \"%s\".",
+ error (_("Illegal argument for \"%s\" command, should be \"%s\" or \"%s\"."),
cmd_prefix, t_val, f_val);
}
check_empty (char *args, char *cmd_prefix)
{
if (args)
- error ("Garbage after \"%s\" command: `%s'", cmd_prefix, args);
+ error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix, args);
}
/* Returns the alive thread named by INFERIOR_PID, or signals an error. */
static struct proc *
-cur_thread ()
+cur_thread (void)
{
struct inf *inf = cur_inf ();
- struct proc *thread = inf_tid_to_thread (inf, inferior_pid);
+ struct proc *thread = inf_tid_to_thread (inf,
+ ptid_get_tid (inferior_ptid));
if (!thread)
- error ("No current thread.");
+ error (_("No current thread."));
return thread;
}
/* Returns the current inferior, but signals an error if it has no task. */
static struct inf *
-active_inf ()
+active_inf (void)
{
struct inf *inf = cur_inf ();
- if (! inf->task)
- error ("No current process.");
+ if (!inf->task)
+ error (_("No current process."));
return inf;
}
+
\f
static void
set_task_pause_cmd (char *args, int from_tty)
printf_unfiltered ("The inferior task will be left with a suspend count of %d when detaching.\n",
cur_inf ()->detach_sc);
}
+
\f
static void
set_thread_default_pause_cmd (char *args, int from_tty)
printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
cur_inf ()->default_thread_detach_sc);
}
+
\f
/* Steal a send right called NAME in the inferior task, and make it PROC's
saved exception port. */
mach_msg_type_name_t port_type;
if (!proc || !proc->inf->task)
- error ("No inferior task.");
+ error (_("No inferior task."));
err = mach_port_extract_right (proc->inf->task->port,
name, MACH_MSG_TYPE_COPY_SEND,
&port, &port_type);
if (err)
- error ("Couldn't extract send right %d from inferior: %s",
- name, strerror (err));
+ error (_("Couldn't extract send right %d from inferior: %s"),
+ name, safe_strerror (err));
if (proc->saved_exc_port)
/* Get rid of our reference to the old one. */
proc->saved_exc_port = port;
- if (! proc->exc_port)
+ if (!proc->exc_port)
/* If PROC is a thread, we may not have set its exception port before.
We can't use proc_steal_exc_port because it also sets saved_exc_port. */
{
- proc->exc_port = proc->inf->event_port;
- err = proc_set_exception_port (proc, proc->exc_port);
- error ("Can't set exception port for %s: %s",
- proc_string (proc), strerror (err));
+ proc->exc_port = proc->inf->event_port;
+ err = proc_set_exception_port (proc, proc->exc_port);
+ error (_("Can't set exception port for %s: %s"),
+ proc_string (proc), safe_strerror (err));
}
}
-\f
+
static void
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.");
+ error (_("No argument to \"set task exception-port\" command."));
steal_exc_port (inf->task, parse_and_eval_address (args));
}
-static void
+static void
set_stopped_cmd (char *args, int from_tty)
{
cur_inf ()->stopped = _parse_bool_arg (args, "yes", "no", "set stopped");
inf->stopped ? "is" : "isn't");
}
-static void
+static void
set_sig_thread_cmd (char *args, int from_tty)
{
- int tid;
struct inf *inf = cur_inf ();
- if (!args || (! isdigit (*args) && strcmp (args, "none") != 0))
- error ("Illegal argument to \"set signal-thread\" command.\n"
- "Should be an integer thread ID, or `none'.");
+ if (!args || (!isdigit (*args) && strcmp (args, "none") != 0))
+ error (_("Illegal argument to \"set signal-thread\" command.\n"
+ "Should be an integer thread ID, or `none'."));
if (strcmp (args, "none") == 0)
inf->signal_thread = 0;
else
{
- int tid = 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);
+ error (_("Thread ID %s not known. Use the \"info threads\" command to\n"
+ "see the IDs of currently known threads."), args);
inf->signal_thread = inf_tid_to_thread (inf, tid);
}
}
else
printf_unfiltered ("There is no signal thread.\n");
}
+
\f
-static void
+static void
set_signals_cmd (char *args, int from_tty)
{
- int trace;
struct inf *inf = cur_inf ();
inf->want_signals = parse_bool_arg (args, "set signals");
: (inf->want_signals ? "will be" : "won't be"));
}
-static void
+static void
set_exceptions_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
if (inf->task && inf->want_exceptions != val)
/* Make this take effect immediately in a running process. */
- /* XXX */;
+ /* XXX */ ;
inf->want_exceptions = val;
}
? (inf->want_exceptions ? "are" : "aren't")
: (inf->want_exceptions ? "will be" : "won't be"));
}
+
\f
static void
set_task_cmd (char *args, int from_tty)
{
- printf_unfiltered ("\"set task\" must be followed by the name of a task property.\n");
+ printf_unfiltered ("\"set task\" must be followed by the name"
+ " of a task property.\n");
}
static void
if (inf->default_thread_detach_sc != 0)
show_thread_default_detach_sc_cmd (0, from_tty);
}
+
\f
static void
set_noninvasive_cmd (char *args, int from_tty)
set_signals_cmd (inv_args, from_tty);
set_exceptions_cmd (inv_args, from_tty);
}
+
\f
static void
info_port_rights (char *args, mach_port_type_t only)
{
struct inf *inf = active_inf ();
- value_ptr vmark = value_mark ();
+ struct value *vmark = value_mark ();
if (args)
/* Explicit list of port rights. */
{
while (*args)
{
- value_ptr val = parse_to_comma_and_eval (&args);
+ 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, strerror (err));
+ error (_("%ld: %s."), right, safe_strerror (err));
}
}
else
/* 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.", strerror (err));
+ error (_("%s."), safe_strerror (err));
}
value_free_to_mark (vmark);
{
info_port_rights (args, MACH_PORT_TYPE_SEND);
}
+
static void
info_recv_rights_cmd (char *args, int from_tty)
{
info_port_rights (args, MACH_PORT_TYPE_RECEIVE);
}
+
static void
info_port_sets_cmd (char *args, int from_tty)
{
info_port_rights (args, MACH_PORT_TYPE_PORT_SET);
}
+
static void
info_dead_names_cmd (char *args, int from_tty)
{
info_port_rights (args, MACH_PORT_TYPE_DEAD_NAME);
}
+
static void
info_port_rights_cmd (char *args, int from_tty)
{
info_port_rights (args, ~0);
}
+
\f
-static void add_task_commands ()
+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"
- "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\".",
+ 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\"."),
&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"
- "When exceptions are turned off, neither breakpoints nor single-stepping\n"
- "will work.",
+ 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."),
&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"
- "A value of \"on\" takes effect immediately, otherwise nothing\n"
- "happens until the next time the program is continued.\n"
- "When setting this to \"off\", \"set thread default pause on\"\n"
- "can be used to pause individual threads by default instead.",
+ 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."),
&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, &set_task_cmd_list);
+ add_alias_cmd ("exc-port", "exception-port", no_class, 1,
+ &set_task_cmd_list);
/* 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"
- "This is the same as setting `task pause', `exceptions', and"
- "`signals' to the opposite value.",
+ 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."),
&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_send_rights_cmd,
- "Show information about the task's port rights",
+ add_cmd ("port-rights", class_info, info_port_rights_cmd,
+ _("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_info_alias ("psets", "port-sets", 1);
}
-\f
+\f
static void
set_thread_pause_cmd (char *args, int from_tty)
{
static void
set_thread_detach_sc_cmd (char *args, int from_tty)
{
- cur_thread ()->detach_sc = parse_int_arg (args, "set thread detach-suspend-count");
+ cur_thread ()->detach_sc = parse_int_arg (args,
+ "set thread detach-suspend-count");
}
static void
{
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",
+ printf_unfiltered ("Thread %s will be left with a suspend count"
+ " of %d when detaching.\n",
proc_string (thread),
thread->detach_sc);
}
{
struct proc *thread = cur_thread ();
if (!args)
- error ("No argument to \"set thread exception-port\" command.");
+ error (_("No argument to \"set thread exception-port\" command."));
steal_exc_port (thread, parse_and_eval_address (args));
}
thread_basic_info_t info = &_info;
mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT;
error_t err =
- thread_info (thread->port, THREAD_BASIC_INFO, (int *)&info, &info_len);
+ thread_info (thread->port, THREAD_BASIC_INFO, (int *) &info, &info_len);
if (err)
- error ("%s.", strerror (err));
+ error (("%s."), safe_strerror (err));
thread->sc = info->suspend_count;
if (from_tty)
printf_unfiltered ("Suspend count was %d.\n", thread->sc);
if (info != &_info)
- vm_deallocate (mach_task_self (), (vm_address_t)info, info_len * sizeof (int));
+ vm_deallocate (mach_task_self (), (vm_address_t) info,
+ info_len * sizeof (int));
}
-add_thread_commands ()
+\f
+static void
+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"
- "A value of \"on\" takes effect immediately, otherwise nothing\n"
- "happens until the next time the program is continued. This\n"
- "property normally has no effect because the whole task is suspended,\n"
- "however, that may be disabled with \"set task pause off\".\n"
- "The default value is \"off\".",
+ 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\"."),
&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"
- "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.",
+ 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."),
&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."
- "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.",
+ 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."),
&show_thread_cmd_list);
- add_cmd ("exception-port", no_class, set_thread_exc_port_cmd,
- "Set the exception port to which we forward exceptions for the\n"
- "current thread, overriding the task exception port.\n"
- "The argument should be the value of the send right in the task.",
+ 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."),
&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_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"
- "Prior to giving this command, gdb's thread suspend-counts are relative to\n"
- "the thread's initial suspend-count when gdb notices the threads.",
+ 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."),
&thread_cmd_list);
}
+
\f
void
-_initialize_gnu_nat ()
+_initialize_gnu_nat (void)
{
proc_server = getproc ();
- init_gnu_ops() ;
+
+ init_gnu_ops ();
add_target (&gnu_ops);
+
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);
+ deprecated_add_set_cmd ("gnu-debug", class_maintenance,
+ var_boolean, (char *) &gnu_debug_flag,
+ "Set debugging output for the gnu backend.",
+ &maintenancelist);
}
\f
#ifdef FLUSH_INFERIOR_CACHE
end up looping in mysterious Bpt traps */
void
-flush_inferior_icache(pc, amount)
- CORE_ADDR pc;
+flush_inferior_icache (CORE_ADDR pc, int amount)
{
vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH;
- error_t ret;
-
- ret = vm_machine_attribute (current_inferior->task->port,
+ error_t ret;
+
+ ret = vm_machine_attribute (gnu_current_inf->task->port,
pc,
amount,
MATTR_CACHE,
&flush);
if (ret != KERN_SUCCESS)
- warning ("Error flushing inferior's cache : %s", strerror (ret));
+ warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret));
}
-#endif FLUSH_INFERIOR_CACHE
+#endif /* FLUSH_INFERIOR_CACHE */
projects / thirdparty / binutils-gdb.git / blobdiff