X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fgnu-nat.c;h=caeb6044bdf57290f5681806b9d394be4e81af44;hb=58b61394cfd1f96444c1debd9ba9e0ea69d439f2;hp=b39335f9904fde78a367c5f3ab444c92352c6893;hpb=f90b2b1da8e0f4412cc987415483c79232f905c8;p=binutils-gdb.git
diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c
index b39335f9904..caeb6044bdf 100644
--- a/gdb/gnu-nat.c
+++ b/gdb/gnu-nat.c
@@ -1,5 +1,6 @@
/* Interface GDB to the GNU Hurd.
- Copyright (C) 1992, 95, 96, 97, 1999, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2006, 2007,
+ 2008, 2009, 2010 Free Software Foundation, Inc.
This file is part of GDB.
@@ -9,7 +10,7 @@
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,
@@ -18,33 +19,35 @@
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 .
*/
-#include
-#include
+#include
#include
-#include
-#include
-#include
#include
+#include
+#include
+#include
+#include "gdb_string.h"
#include
#include
-#include
-#include
#include
#include
+#include
+#include
#include
-#include
-#include
+#include
+#include
#include
#include
+#include
+/* Defined in , but we need forward declarations from
+ as well. */
+#undef _process_user_
+#include
#include
-#include
#include
#include
@@ -58,8 +61,12 @@
#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"
+#include "inf-child.h"
#include "exc_request_S.h"
#include "notify_S.h"
@@ -81,8 +88,6 @@ int gnu_debug_flag = 0;
/* Forward decls */
-extern struct target_ops gnu_ops;
-
struct inf *make_inf ();
void inf_clear_wait (struct inf *inf);
void inf_cleanup (struct inf *inf);
@@ -93,12 +98,12 @@ void inf_validate_procs (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);
@@ -107,7 +112,8 @@ void inf_continue (struct inf *inf);
#define inf_debug(_inf, msg, args...) \
do { struct inf *__inf = (_inf); \
- debug ("{inf %d %p}: " msg, __inf->pid, __inf , ##args); } while (0)
+ debug ("{inf %d %s}: " msg, __inf->pid, \
+ host_address_to_string (__inf) , ##args); } while (0)
void proc_abort (struct proc *proc, int force);
struct proc *make_proc (struct inf *inf, mach_port_t port, int tid);
@@ -140,7 +146,6 @@ int proc_trace (struct proc *proc, int set);
__e; }) \
: EIEIO)
-#define MIG_SERVER_DIED EMIG_SERVER_DIED /* XXX */
/* The state passed by an exception message. */
struct exc_state
@@ -243,6 +248,7 @@ __proc_pid (struct proc *proc)
{
return proc->inf->pid;
}
+
/* Update PROC's real suspend count to match it's desired one. Returns true
if we think PROC is now in a runnable state. */
@@ -259,27 +265,34 @@ proc_update_sc (struct proc *proc)
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);
+ (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);
-
+ {
+ 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;
@@ -288,7 +301,7 @@ proc_update_sc (struct proc *proc)
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)
{
@@ -299,6 +312,7 @@ proc_update_sc (struct proc *proc)
return running;
}
+
/* 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.
@@ -307,7 +321,7 @@ proc_update_sc (struct proc *proc)
void
proc_abort (struct proc *proc, int force)
{
- assert (proc_is_thread (proc));
+ gdb_assert (proc_is_thread (proc));
if (!proc->aborted)
{
@@ -319,7 +333,7 @@ proc_abort (struct proc *proc, int force)
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. */
@@ -359,8 +373,9 @@ proc_get_state (struct proc *proc, int will_modify)
{
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;
}
@@ -369,11 +384,12 @@ proc_get_state (struct proc *proc, int will_modify)
{
if (will_modify)
proc->state_changed = 1;
- return (thread_state_t) & proc->state;
+ return (thread_state_t) &proc->state;
}
else
return 0;
}
+
/* Set PORT to PROC's exception port. */
error_t
@@ -426,7 +442,7 @@ proc_steal_exc_port (struct proc *proc, mach_port_t exc_port)
if (cur_exc_port)
{
- error_t err;
+ error_t err = 0;
proc_debug (proc, "inserting exception port: %d", exc_port);
@@ -454,8 +470,8 @@ proc_steal_exc_port (struct proc *proc, mach_port_t 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));
}
}
@@ -484,10 +500,11 @@ proc_restore_exc_port (struct proc *proc)
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));
}
}
+
/* Turns hardware tracing in PROC on or off when SET is true or false,
respectively. Returns true on success. */
@@ -514,6 +531,7 @@ proc_trace (struct proc *proc, int set)
return 1;
}
+
/* A variable from which to assign new TIDs. */
static int next_thread_id = 1;
@@ -525,7 +543,7 @@ make_proc (struct inf *inf, mach_port_t port, int tid)
{
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;
@@ -559,8 +577,8 @@ make_proc (struct inf *inf, mach_port_t port, int tid)
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);
@@ -569,12 +587,15 @@ make_proc (struct inf *inf, mach_port_t port, int tid)
}
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;
}
@@ -611,17 +632,15 @@ _proc_free (struct proc *proc)
mach_port_deallocate (mach_task_self (), proc->port);
}
- free (proc);
+ xfree (proc);
return next;
}
+
struct inf *
-make_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;
@@ -651,7 +670,7 @@ make_inf ()
return inf;
}
-/* clear INF's target wait status. */
+/* Clear INF's target wait status. */
void
inf_clear_wait (struct inf *inf)
{
@@ -670,6 +689,7 @@ inf_clear_wait (struct inf *inf)
inf->wait.exc.reply = MACH_PORT_NULL;
}
}
+
void
inf_cleanup (struct inf *inf)
@@ -707,15 +727,16 @@ inf_startup (struct inf *inf, int pid)
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);
}
+
-/* close current process, if any, and attach INF to process PORT */
+/* Close current process, if any, and attach INF to process PORT. */
void
inf_set_pid (struct inf *inf, pid_t pid)
{
@@ -729,8 +750,9 @@ inf_set_pid (struct inf *inf, pid_t pid)
else
{
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);
@@ -755,11 +777,13 @@ inf_set_pid (struct inf *inf, pid_t pid)
{
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;
}
+
/* Validates INF's stopped, nomsg and traced field from the actual
proc server state. Note that the traced field is only updated from
@@ -774,8 +798,8 @@ inf_validate_procinfo (struct inf *inf)
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)
{
@@ -804,7 +828,7 @@ inf_validate_task_sc (struct inf *inf)
retry:
err = proc_getprocinfo (proc_server, inf->pid, &info_flags,
- &pi, &pi_len, &noise, &noise_len);
+ (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
if (err)
{
inf->task->dead = 1; /* oh well */
@@ -832,60 +856,66 @@ inf_validate_task_sc (struct inf *inf)
int abort;
target_terminal_ours (); /* Allow I/O. */
- abort = !query ("Pid %d has an additional task suspend count of %d;"
- " clear it? ", inf->pid,
+ abort = !query (_("Pid %d has an additional task suspend count of %d;"
+ " clear it? "), inf->pid,
suspend_count - inf->task->cur_sc);
target_terminal_inferior (); /* Give it back to the child. */
if (abort)
- error ("Additional task suspend count left untouched.");
+ error (_("Additional task suspend count left untouched."));
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 =
+ 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: 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
+ 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;
}
+
-/* 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)
{
struct proc *task = inf->task;
+
/* We don't have to update INF->threads even though we're iterating over it
because we'll change a thread only if it already has an existing proc
entry. */
-
inf_debug (inf, "updating suspend counts");
if (task)
@@ -926,6 +956,7 @@ inf_update_suspends (struct inf *inf)
return 0;
}
+
/* Converts a GDB pid to a struct proc. */
struct proc *
@@ -946,6 +977,7 @@ struct proc *
inf_port_to_thread (struct inf *inf, mach_port_t port)
{
struct proc *thread = inf->threads;
+
while (thread)
if (thread->port == port)
return thread;
@@ -953,14 +985,14 @@ inf_port_to_thread (struct inf *inf, mach_port_t port)
thread = thread->next;
return 0;
}
+
/* 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
@@ -972,6 +1004,7 @@ inf_validate_procs (struct inf *inf)
if (task)
{
error_t err = task_threads (task->port, &threads, &num_threads);
+
inf_debug (inf, "fetching threads");
if (err)
/* TASK must be dead. */
@@ -988,7 +1021,8 @@ inf_validate_procs (struct inf *inf)
}
{
- 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. */
@@ -996,11 +1030,11 @@ inf_validate_procs (struct inf *inf)
/* 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--)
{
@@ -1022,31 +1056,55 @@ inf_validate_procs (struct inf *inf)
proc_debug (thread, "died!");
thread->port = MACH_PORT_NULL;
thread = _proc_free (thread); /* THREAD is dead. */
- (last ? last->next : inf->threads) = thread;
+ if (last)
+ last->next = thread;
+ else
+ inf->threads = thread;
}
}
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_address_t) threads, (num_threads * sizeof (thread_t)));
}
}
+
/* 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)
@@ -1059,11 +1117,12 @@ inf_update_procs (struct inf *inf)
/* 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)
{
struct proc *thread;
+
inf_update_procs (inf);
for (thread = inf->threads; thread; thread = thread->next)
if (thread == run_thread)
@@ -1073,10 +1132,11 @@ inf_set_threads_resume_sc (struct inf *inf,
else
thread->resume_sc = thread->pause_sc;
}
+
/* 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;
@@ -1101,7 +1161,7 @@ inf_resume (struct inf *inf)
/* Cause INF to stop execution immediately; individual threads may still
be running. */
-inline void
+void
inf_suspend (struct inf *inf)
{
struct proc *thread;
@@ -1116,14 +1176,15 @@ inf_suspend (struct inf *inf)
inf_update_suspends (inf);
}
+
-/* 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);
@@ -1141,11 +1202,12 @@ inf_set_step_thread (struct inf *inf, struct proc *thread)
inf->step_thread = 0;
}
}
+
/* 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)
@@ -1164,6 +1226,7 @@ inf_update_signal_thread (struct inf *inf)
the signal thread. */
inf->signal_thread = inf->threads ? inf->threads->next : 0;
}
+
/* Detachs from INF's inferior task, letting it run once again... */
void
@@ -1206,8 +1269,8 @@ inf_detach (struct inf *inf)
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)
{
@@ -1218,6 +1281,7 @@ inf_attach (struct inf *inf, int pid)
inf_startup (inf, pid);
}
+
/* Makes sure that we've got our exception ports entrenched in the process. */
void
@@ -1248,6 +1312,7 @@ inf_restore_exc_ports (struct inf *inf)
for (thread = inf->threads; thread; thread = thread->next)
proc_restore_exc_port (thread);
}
+
/* 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
@@ -1266,6 +1331,7 @@ inf_signal (struct inf *inf, enum target_signal sig)
extremely large)! */
{
struct inf_wait *w = &inf->wait;
+
if (w->status.kind == TARGET_WAITKIND_STOPPED
&& w->status.value.sig == sig
&& w->thread && !w->thread->aborted)
@@ -1276,6 +1342,7 @@ inf_signal (struct inf *inf, enum target_signal sig)
i.e., we pretend it's global. */
{
struct exc_state *e = &w->exc;
+
inf_debug (inf, "passing through exception:"
" task = %d, thread = %d, exc = %d"
", code = %d, subcode = %d",
@@ -1288,7 +1355,7 @@ inf_signal (struct inf *inf, enum target_signal sig)
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. */
@@ -1318,20 +1385,23 @@ inf_signal (struct inf *inf, enum target_signal sig)
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);
+ 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));
+ 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
}
+
/* Continue INF without delivering a signal. This is meant to be used
when INF does not have a message port. */
@@ -1358,32 +1428,38 @@ inf_continue (struct inf *inf)
}
if (err)
- warning ("Can't continue process: %s", strerror (err));
+ warning (_("Can't continue process: %s"), safe_strerror (err));
}
+
/* 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, int options)
{
struct msg
{
mach_msg_header_t hdr;
mach_msg_type_t type;
int data[8000];
- }
- msg;
+ } msg;
error_t err;
struct proc *thread;
- struct inf *inf = current_inferior;
+ struct inf *inf = gnu_current_inf;
- assert (inf->task);
+ 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 *);
+
+ gdb_assert (inf->task);
if (!inf->threads && !inf->pending_execs)
/* No threads! Assume that maybe some outside agency is frobbing our
@@ -1392,12 +1468,12 @@ gnu_wait (int tid, struct target_waitstatus *status)
{
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:
if (proc_wait_pid != inf->pid && !inf->no_wait)
@@ -1416,15 +1492,16 @@ rewait:
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;
}
}
@@ -1451,7 +1528,7 @@ rewait:
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
@@ -1471,11 +1548,11 @@ rewait:
&& !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)
@@ -1528,30 +1605,38 @@ rewait:
}
/* 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"
@@ -1560,8 +1645,9 @@ rewait:
: "?",
status->value.integer);
- return tid;
+ return ptid;
}
+
/* The rpc handler called by exc_server. */
error_t
@@ -1574,7 +1660,7 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
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? */
@@ -1609,16 +1695,16 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
{
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. */
@@ -1646,13 +1732,14 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
return 0;
}
+
/* 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;
}
@@ -1681,6 +1768,7 @@ do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
else
{
struct proc *thread = inf_port_to_thread (inf, dead_port);
+
if (thread)
{
proc_debug (thread, "is dead");
@@ -1697,43 +1785,45 @@ do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
return 0;
}
+
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");
}
+
/* Process_reply server routines. We only use process_wait_reply. */
@@ -1744,7 +1834,7 @@ S_proc_wait_reply (mach_port_t reply, error_t err,
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
@@ -1765,7 +1855,7 @@ S_proc_wait_reply (mach_port_t reply, error_t err,
{
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. */
@@ -1793,14 +1883,15 @@ error_t
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");
}
+
/* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
@@ -1820,7 +1911,7 @@ S_msg_sig_post_untraced_reply (mach_port_t reply, error_t err)
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
@@ -1837,8 +1928,9 @@ S_msg_sig_post_untraced_reply (mach_port_t reply, error_t err)
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");
}
+
/* Returns the number of messages queued for the receive right PORT. */
static mach_port_msgcount_t
@@ -1846,13 +1938,14 @@ port_msgs_queued (mach_port_t port)
{
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;
}
+
/* Resume execution of the inferior process.
@@ -1871,12 +1964,15 @@ port_msgs_queued (mach_port_t port)
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);
@@ -1892,7 +1988,7 @@ gnu_resume (int tid, int step, enum target_signal sig)
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));
}
@@ -1904,30 +2000,36 @@ gnu_resume (int tid, int step, enum target_signal 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);
+ struct proc *thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
+
if (!thread)
- error ("Can't run single thread id %d: no such thread!");
- inf_debug (inf, "running one thread: %d/%d", inf->pid, thread->tid);
+ error (_("Can't run single thread id %s: no such thread!"),
+ target_pid_to_str (ptid));
+ inf_debug (inf, "running one thread: %s", target_pid_to_str (ptid));
inf_set_threads_resume_sc (inf, thread, 0);
}
if (step)
{
- step_thread = inf_tid_to_thread (inf, tid);
+ step_thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
if (!step_thread)
- warning ("Can't step thread id %d: no such thread.", tid);
+ warning (_("Can't step thread id %s: no such thread."),
+ target_pid_to_str (ptid));
else
- inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid);
+ inf_debug (inf, "stepping thread: %s", target_pid_to_str (ptid));
}
if (step_thread != inf->step_thread)
inf_set_step_thread (inf, step_thread);
@@ -1935,94 +2037,95 @@ gnu_resume (int tid, int step, enum target_signal sig)
inf_debug (inf, "here we go...");
inf_resume (inf);
}
+
static void
-gnu_kill_inferior ()
+gnu_kill_inferior (struct target_ops *ops)
{
- struct proc *task = current_inferior->task;
+ struct proc *task = gnu_current_inf->task;
+
if (task)
{
proc_debug (task, "terminating...");
task_terminate (task->port);
- inf_set_pid (current_inferior, -1);
+ inf_set_pid (gnu_current_inf, -1);
}
target_mourn_inferior ();
}
/* Clean up after the inferior dies. */
-
static void
-gnu_mourn_inferior ()
+gnu_mourn_inferior (struct target_ops *ops)
{
- inf_debug (current_inferior, "rip");
- inf_detach (current_inferior);
- unpush_target (&gnu_ops);
+ inf_debug (gnu_current_inf, "rip");
+ inf_detach (gnu_current_inf);
+ unpush_target (ops);
generic_mourn_inferior ();
}
+
/* 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 ();
+ int pid;
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!");
+ error (_("ptrace (PTRACE_TRACEME) failed!"));
}
- void attach_to_child (int pid)
- {
- /* Attach to the now stopped child, which is actually a shell... */
- inf_debug (inf, "attaching to child: %d", pid);
- inf_attach (inf, pid);
+ inf_debug (inf, "creating inferior");
+
+ pid = fork_inferior (exec_file, allargs, env, trace_me, NULL, NULL, NULL);
- attach_flag = 0;
- push_target (&gnu_ops);
+ /* Attach to the now stopped child, which is actually a shell... */
+ inf_debug (inf, "attaching to child: %d", pid);
- inf->pending_execs = 2;
- inf->nomsg = 1;
- inf->traced = 1;
+ inf_attach (inf, pid);
- /* 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 ();
+ push_target (ops);
- startup_inferior (inf->pending_execs);
- }
+ inf->pending_execs = 2;
+ inf->nomsg = 1;
+ inf->traced = 1;
- inf_debug (inf, "creating inferior");
+ /* Now let the child run again, knowing that it will stop
+ immediately because of the ptrace. */
+ inf_resume (inf);
- fork_inferior (exec_file, allargs, env, trace_me, attach_to_child,
- NULL, NULL);
+ /* We now have thread info. */
+ thread_change_ptid (inferior_ptid,
+ ptid_build (inf->pid, 0, inf_pick_first_thread ()));
+
+ startup_inferior (inf->pending_execs);
inf_validate_procinfo (inf);
inf_update_signal_thread (inf);
@@ -2034,39 +2137,23 @@ gnu_create_inferior (exec_file, allargs, env)
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 ()
-{
- return 1;
-}
-#ifdef ATTACH_DETACH
-
/* 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");
-
- pid = atoi (args);
+ pid = parse_pid_to_attach (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)
{
@@ -2084,12 +2171,16 @@ gnu_attach (args, from_tty)
inf_debug (inf, "attaching to pid: %d", pid);
inf_attach (inf, pid);
- inf_update_procs (inf);
- inferior_pid = inf_pick_first_thread ();
+ push_target (ops);
- attach_flag = 1;
- push_target (&gnu_ops);
+ inferior = current_inferior ();
+ inferior_appeared (inferior, pid);
+ inferior->attach_flag = 1;
+
+ inf_update_procs (inf);
+
+ inferior_ptid = ptid_build (pid, 0, inf_pick_first_thread ());
/* We have to initialize the terminal settings now, since the code
below might try to restore them. */
@@ -2106,6 +2197,7 @@ gnu_attach (args, from_tty)
renumber_threads (0); /* Give our threads reasonable names. */
#endif
}
+
/* Take a program previously attached to and detaches it.
The program resumes execution and will no longer stop
@@ -2115,91 +2207,59 @@ gnu_attach (args, from_tty)
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);
+ pid = gnu_current_inf->pid;
- inferior_pid = 0;
+ inf_detach (gnu_current_inf);
- unpush_target (&gnu_ops); /* Pop out of handling an inferior */
-}
-#endif /* ATTACH_DETACH */
+ inferior_ptid = null_ptid;
+ detach_inferior (pid);
-static void
-gnu_terminal_init_inferior ()
-{
- assert (current_inferior);
- terminal_init_inferior_with_pgrp (current_inferior->pid);
+ unpush_target (ops); /* Pop out of handling an inferior */
}
-
-/* Get ready to modify the registers array. On machines which store
- individual registers, this doesn't need to do anything. On machines
- which store all the registers in one fell swoop, this makes sure
- that registers contains all the registers from the program being
- debugged. */
-
-static void
-gnu_prepare_to_store ()
-{
-#ifdef CHILD_PREPARE_TO_STORE
- CHILD_PREPARE_TO_STORE ();
-#endif
-}
-
+
static void
-gnu_open (arg, from_tty)
- char *arg;
- int from_tty;
+gnu_terminal_init_inferior (void)
{
- error ("Use the \"run\" command to start a Unix child process.");
+ gdb_assert (gnu_current_inf);
+ terminal_init_inferior_with_pgrp (gnu_current_inf->pid);
}
static void
-gnu_stop ()
-{
- error ("to_stop target function not implemented");
-}
-
-static char *
-gnu_pid_to_exec_file ()
+gnu_stop (ptid_t ptid)
{
- error ("to_pid_to_exec_file target function not implemented");
- return NULL;
+ error (_("to_stop target function not implemented"));
}
-
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));
}
+
-/*
- * 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);
@@ -2213,16 +2273,16 @@ gnu_read_inferior (task, addr, myaddr, length)
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;
}
@@ -2240,16 +2300,10 @@ struct vm_region_list
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);
@@ -2274,14 +2328,14 @@ gnu_write_inferior (task, addr, myaddr, length)
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;
@@ -2313,7 +2367,7 @@ gnu_write_inferior (task, addr, myaddr, 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;
@@ -2322,7 +2376,7 @@ gnu_write_inferior (task, addr, myaddr, length)
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;
@@ -2347,14 +2401,11 @@ gnu_write_inferior (task, addr, myaddr, 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,
@@ -2375,8 +2426,6 @@ gnu_write_inferior (task, addr, myaddr, length)
/* 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,
@@ -2401,59 +2450,138 @@ out:
if (err != KERN_SUCCESS)
{
- warning ("%s: %s", errstr, mach_error_string (err));
+ warning (_("%s: %s"), errstr, mach_error_string (err));
return 0;
}
return length;
}
+
-/* 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,
- write ? "<--" : "-->", myaddr);
+ inf_debug (gnu_current_inf, "%s %s[%d] %s %s",
+ write ? "writing" : "reading",
+ paddress (target_gdbarch, memaddr), len,
+ write ? "<--" : "-->", host_address_to_string (myaddr));
if (write)
return gnu_write_inferior (task, memaddr, myaddr, len);
else
return gnu_read_inferior (task, memaddr, myaddr, len);
}
}
+
+/* Call FUNC on each memory region in the task. */
+static int
+gnu_find_memory_regions (find_memory_region_ftype func, void *data)
+{
+ error_t err;
+ task_t task;
+ vm_address_t region_address, last_region_address, last_region_end;
+ vm_prot_t last_protection;
+
+ if (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;
+}
+
/* Return printable description of 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;
}
static char *
-gnu_pid_to_str (int tid)
+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)
@@ -2461,84 +2589,43 @@ gnu_pid_to_str (int tid)
else
{
static char tid_str[80];
+
sprintf (tid_str, "bogus thread id %d", tid);
return tid_str;
}
}
+
-extern void gnu_store_registers (int regno);
-extern void gnu_fetch_registers (int regno);
+/* Create a prototype generic GNU/Hurd target. The client can
+ override it with local methods. */
+
+struct target_ops *
+gnu_target (void)
+{
+ struct target_ops *t = inf_child_target ();
-struct target_ops gnu_ops;
+ t->to_shortname = "GNU";
+ t->to_longname = "GNU Hurd process";
+ t->to_doc = "GNU Hurd process";
+
+ t->to_attach = gnu_attach;
+ t->to_attach_no_wait = 1;
+ t->to_detach = gnu_detach;
+ t->to_resume = gnu_resume;
+ t->to_wait = gnu_wait;
+ t->deprecated_xfer_memory = gnu_xfer_memory;
+ t->to_find_memory_regions = gnu_find_memory_regions;
+ t->to_terminal_init = gnu_terminal_init_inferior;
+ t->to_kill = gnu_kill_inferior;
+ t->to_create_inferior = gnu_create_inferior;
+ t->to_mourn_inferior = gnu_mourn_inferior;
+ t->to_thread_alive = gnu_thread_alive;
+ t->to_pid_to_str = gnu_pid_to_str;
+ t->to_stop = gnu_stop;
+
+ return t;
+}
-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_pid_to_str = gnu_pid_to_str; /* to_pid_to_str */
- gnu_ops.to_stop = gnu_stop; /* to_stop */
- gnu_ops.to_pid_to_exec_file = gnu_pid_to_exec_file; /* to_pid_to_exec_file */
- gnu_ops.to_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 */
/* User task commands. */
@@ -2586,10 +2673,11 @@ parse_int_arg (char *args, char *cmd_prefix)
{
char *arg_end;
int val = strtoul (args, &arg_end, 10);
+
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
@@ -2600,7 +2688,7 @@ _parse_bool_arg (char *args, char *t_val, char *f_val, char *cmd_prefix)
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);
}
@@ -2611,29 +2699,32 @@ static void
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.");
+ error (_("No current process."));
return inf;
}
+
static void
set_task_pause_cmd (char *args, int from_tty)
@@ -2653,6 +2744,7 @@ static void
show_task_pause_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
check_empty (args, "show task pause");
printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
inf->task
@@ -2673,11 +2765,13 @@ show_task_detach_sc_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);
}
+
static void
set_thread_default_pause_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
inf->default_thread_pause_sc =
parse_bool_arg (args, "set thread default pause") ? 0 : 1;
}
@@ -2687,6 +2781,7 @@ show_thread_default_pause_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
int sc = inf->default_thread_pause_sc;
+
check_empty (args, "show thread default pause");
printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
sc ? "are" : "aren't",
@@ -2697,6 +2792,7 @@ static void
set_thread_default_run_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
inf->default_thread_run_sc =
parse_bool_arg (args, "set thread default run") ? 0 : 1;
}
@@ -2705,6 +2801,7 @@ static void
show_thread_default_run_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
check_empty (args, "show thread default run");
printf_unfiltered ("New threads %s allowed to run.\n",
inf->default_thread_run_sc == 0 ? "are" : "aren't");
@@ -2724,6 +2821,7 @@ show_thread_default_detach_sc_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);
}
+
/* Steal a send right called NAME in the inferior task, and make it PROC's
saved exception port. */
@@ -2735,14 +2833,14 @@ steal_exc_port (struct proc *proc, mach_port_t name)
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. */
@@ -2756,17 +2854,18 @@ steal_exc_port (struct proc *proc, mach_port_t name)
{
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));
+ error (_("Can't set exception port for %s: %s"),
+ proc_string (proc), safe_strerror (err));
}
}
-
+
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));
}
@@ -2780,6 +2879,7 @@ static void
show_stopped_cmd (char *args, int from_tty)
{
struct inf *inf = active_inf ();
+
check_empty (args, "show stopped");
printf_unfiltered ("The inferior process %s stopped.\n",
inf->stopped ? "is" : "isn't");
@@ -2788,21 +2888,21 @@ show_stopped_cmd (char *args, int from_tty)
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'.");
+ 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);
}
}
@@ -2811,6 +2911,7 @@ static void
show_sig_thread_cmd (char *args, int from_tty)
{
struct inf *inf = active_inf ();
+
check_empty (args, "show signal-thread");
if (inf->signal_thread)
printf_unfiltered ("The signal thread is %s.\n",
@@ -2818,11 +2919,11 @@ show_sig_thread_cmd (char *args, int from_tty)
else
printf_unfiltered ("There is no signal thread.\n");
}
+
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");
@@ -2836,6 +2937,7 @@ static void
show_signals_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
check_empty (args, "show signals");
printf_unfiltered ("The inferior process's signals %s intercepted.\n",
inf->task
@@ -2860,17 +2962,20 @@ static void
show_exceptions_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
check_empty (args, "show exceptions");
printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
inf->task
? (inf->want_exceptions ? "are" : "aren't")
: (inf->want_exceptions ? "will be" : "won't be"));
}
+
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
@@ -2899,6 +3004,7 @@ show_task_cmd (char *args, int from_tty)
if (inf->default_thread_detach_sc != 0)
show_thread_default_detach_sc_cmd (0, from_tty);
}
+
static void
set_noninvasive_cmd (char *args, int from_tty)
@@ -2910,35 +3016,37 @@ set_noninvasive_cmd (char *args, int from_tty)
set_signals_cmd (inv_args, from_tty);
set_exceptions_cmd (inv_args, from_tty);
}
+
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);
@@ -2949,157 +3057,167 @@ info_send_rights_cmd (char *args, int from_tty)
{
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);
}
+
static void
-add_task_commands ()
+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_stopped_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);
}
-
+
static void
set_thread_pause_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
int old_sc = thread->pause_sc;
+
thread->pause_sc = parse_bool_arg (args, "set thread pause");
if (old_sc == 0 && thread->pause_sc != 0 && thread->inf->pause_sc == 0)
/* If the task is currently unsuspended, immediately suspend it,
@@ -3112,17 +3230,19 @@ show_thread_pause_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
int sc = thread->pause_sc;
+
check_empty (args, "show task pause");
printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
proc_string (thread),
sc ? "is" : "isn't",
- !sc && thread->inf->pause_sc ? " (but the task is)" : "");
+ !sc && thread->inf->pause_sc ? " (but the task is)" : "");
}
static void
set_thread_run_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
thread->run_sc = parse_bool_arg (args, "set thread run") ? 0 : 1;
}
@@ -3130,6 +3250,7 @@ static void
show_thread_run_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
check_empty (args, "show thread run");
printf_unfiltered ("Thread %s %s allowed to run.",
proc_string (thread),
@@ -3139,15 +3260,18 @@ show_thread_run_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
show_thread_detach_sc_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
check_empty (args, "show thread detach-suspend-count");
- printf_unfiltered ("Thread %s will be left with a suspend count of %d when detaching.\n",
+ printf_unfiltered ("Thread %s will be left with a suspend count"
+ " of %d when detaching.\n",
proc_string (thread),
thread->detach_sc);
}
@@ -3156,8 +3280,9 @@ static void
set_thread_exc_port_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
if (!args)
- error ("No argument to \"set thread exception-port\" command.");
+ error (_("No argument to \"set thread exception-port\" command."));
steal_exc_port (thread, parse_and_eval_address (args));
}
@@ -3166,6 +3291,7 @@ static void
show_thread_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
check_empty (args, "show thread");
show_thread_run_cmd (0, from_tty);
show_thread_pause_cmd (0, from_tty);
@@ -3178,94 +3304,104 @@ static void
thread_takeover_sc_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
thread_basic_info_data_t _info;
thread_basic_info_t info = &_info;
mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT;
error_t err =
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 ()
+
+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);
}
+
void
-_initialize_gnu_nat ()
+_initialize_gnu_nat (void)
{
proc_server = getproc ();
- 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);
+ add_setshow_boolean_cmd ("gnu-nat", class_maintenance,
+ &gnu_debug_flag,
+ _("Set debugging output for the gnu backend."),
+ _("Show debugging output for the gnu backend."),
+ NULL,
+ NULL,
+ NULL,
+ &setdebuglist,
+ &showdebuglist);
}
#ifdef FLUSH_INFERIOR_CACHE
@@ -3276,18 +3412,17 @@ _initialize_gnu_nat ()
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,
+ 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 */