X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgnu-nat.c;h=ddeaf7012670fb111840527aaf1fbf68467eaacd;hb=28439f5ef78fd28c36bfc8c4b262f44fdd1ec40f;hp=9a5b927c806ffc8a3a454727693f4a68f1c2e0ec;hpb=ed288bb597072176e84fc8279707a3f2f475779b;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c index 9a5b927c80..ddeaf70126 100644 --- a/gdb/gnu-nat.c +++ b/gdb/gnu-nat.c @@ -1,5 +1,6 @@ -/* 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. @@ -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,38 +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 -/* 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 . */ -#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 @@ -60,9 +58,12 @@ #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" @@ -88,7 +89,6 @@ int gnu_debug_flag = 0; 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); @@ -99,12 +99,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); @@ -116,7 +116,6 @@ void inf_continue (struct inf *inf); 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); @@ -126,7 +125,6 @@ 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, @@ -148,7 +146,6 @@ char *proc_string (struct proc *proc); __e; }) \ : EIEIO) -#define MIG_SERVER_DIED EMIG_SERVER_DIED /* XXX */ /* The state passed by an exception message. */ struct exc_state @@ -251,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. */ @@ -267,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; @@ -296,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) { @@ -307,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. @@ -315,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) { @@ -327,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. */ @@ -368,7 +374,7 @@ 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_state_t) &proc->state, &state_size); proc_debug (proc, "getting thread state"); proc->state_valid = !err; } @@ -377,11 +383,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 @@ -434,7 +441,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); @@ -462,8 +469,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)); } } @@ -492,10 +499,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. */ @@ -522,6 +530,7 @@ proc_trace (struct proc *proc, int set) return 1; } + /* A variable from which to assign new TIDs. */ static int next_thread_id = 1; @@ -533,7 +542,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; @@ -567,8 +576,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); @@ -577,12 +586,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; } @@ -619,17 +631,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; @@ -659,7 +669,7 @@ make_inf () return inf; } -/* clear INF's target wait status. */ +/* Clear INF's target wait status. */ void inf_clear_wait (struct inf *inf) { @@ -678,6 +688,7 @@ inf_clear_wait (struct inf *inf) inf->wait.exc.reply = MACH_PORT_NULL; } } + void inf_cleanup (struct inf *inf) @@ -715,15 +726,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) { @@ -738,7 +750,7 @@ inf_set_pid (struct inf *inf, pid_t pid) { 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); @@ -763,11 +775,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 @@ -783,7 +797,7 @@ inf_validate_procinfo (struct inf *inf) int info_flags = 0; error_t err = proc_getprocinfo (proc_server, inf->pid, &info_flags, - (procinfo_t *) & pi, &pi_len, &noise, &noise_len); + (procinfo_t *) &pi, &pi_len, &noise, &noise_len); if (!err) { @@ -797,69 +811,100 @@ inf_validate_procinfo (struct inf *inf) } } -/* 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); + 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 = + 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) { @@ -908,6 +953,7 @@ inf_update_suspends (struct inf *inf) return 0; } + /* Converts a GDB pid to a struct proc. */ struct proc * @@ -935,14 +981,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 @@ -970,7 +1016,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. */ @@ -978,11 +1025,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--) { @@ -1004,31 +1051,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) @@ -1041,7 +1112,7 @@ 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) { @@ -1055,10 +1126,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; @@ -1083,7 +1155,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; @@ -1098,14 +1170,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); @@ -1123,11 +1196,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) @@ -1146,6 +1220,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 @@ -1188,8 +1263,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) { @@ -1200,6 +1275,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 @@ -1230,6 +1306,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 @@ -1270,7 +1347,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. */ @@ -1300,20 +1377,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. */ @@ -1340,32 +1420,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) { 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; + + 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 @@ -1374,12 +1460,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) @@ -1398,15 +1484,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; } } @@ -1433,7 +1520,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 @@ -1453,11 +1540,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) @@ -1510,30 +1597,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" @@ -1542,8 +1637,9 @@ rewait: : "?", status->value.integer); - return tid; + return ptid; } + /* The rpc handler called by exc_server. */ error_t @@ -1556,7 +1652,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? */ @@ -1591,16 +1687,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. */ @@ -1628,13 +1724,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; } @@ -1668,6 +1765,10 @@ do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port) 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); @@ -1675,43 +1776,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. */ @@ -1722,7 +1825,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 @@ -1743,7 +1846,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. */ @@ -1771,14 +1874,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. */ @@ -1798,7 +1902,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 @@ -1815,8 +1919,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 @@ -1831,6 +1936,7 @@ port_msgs_queued (mach_port_t port) else return status.mps_msgcount; } + /* Resume execution of the inferior process. @@ -1849,12 +1955,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); @@ -1870,7 +1979,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)); } @@ -1882,30 +1991,35 @@ 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); @@ -1913,58 +2027,58 @@ 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 (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 (); } + /* 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 (); @@ -1973,7 +2087,7 @@ gnu_create_inferior (exec_file, allargs, env) /* 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) { @@ -1982,7 +2096,6 @@ gnu_create_inferior (exec_file, allargs, env) inf_attach (inf, pid); - attach_flag = 0; push_target (&gnu_ops); inf->pending_execs = 2; @@ -1992,7 +2105,10 @@ gnu_create_inferior (exec_file, allargs, env) /* 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 (); + + /* We now have thread info. */ + thread_change_ptid (inferior_ptid, + ptid_build (inf->pid, 0, inf_pick_first_thread ())); startup_inferior (inf->pending_execs); } @@ -2012,39 +2128,34 @@ 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 () +gnu_can_run (void) { 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"); + error_no_arg (_("process-id to attach")); pid = atoi (args); if (pid == getpid ()) /* Trying to masturbate? */ - error ("I refuse to debug myself!"); + error (_("I refuse to debug myself!")); if (from_tty) { @@ -2062,13 +2173,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 (); - - 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 (); @@ -2084,6 +2198,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 @@ -2093,34 +2208,36 @@ 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); + + inferior_ptid = null_ptid; + detach_inferior (pid); unpush_target (&gnu_ops); /* Pop out of handling an inferior */ } -#endif /* ATTACH_DETACH */ - + 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 @@ -2128,56 +2245,37 @@ gnu_terminal_init_inferior () 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 () -{ - 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); @@ -2191,16 +2289,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; } @@ -2218,16 +2316,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); @@ -2252,14 +2344,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; @@ -2291,7 +2383,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; @@ -2300,7 +2392,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; @@ -2325,14 +2417,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, @@ -2353,8 +2442,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, @@ -2379,34 +2466,32 @@ 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, + 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); @@ -2414,108 +2499,168 @@ gnu_xfer_memory (memaddr, myaddr, len, write, target) return gnu_read_inferior (task, memaddr, myaddr, len); } } + +/* 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; +} + + +/* 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, proc->tid); + return tid_str; +} + +static char * +gnu_pid_to_str (struct target_ops *ops, ptid_t ptid) +{ + struct inf *inf = gnu_current_inf; + int tid = ptid_get_tid (ptid); + struct proc *thread = inf_tid_to_thread (inf, tid); + + if (thread) + return proc_string (thread); + 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); +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_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_open = gnu_open; /* to_open */ 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_attach_no_wait = 1; /* to_attach_no_wait */ 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_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_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_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_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 */ + 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 */ - -/* 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)); - return tid_str; -} -char * -gnu_target_pid_to_str (int tid) -{ - struct inf *inf = current_inferior; - struct proc *thread = inf_tid_to_thread (inf, tid); - - if (thread) - return proc_string (thread); - else - { - static char tid_str[80]; - sprintf (tid_str, "bogus thread id %d", tid); - return tid_str; - } -} /* User task commands. */ @@ -2566,7 +2711,7 @@ parse_int_arg (char *args, char *cmd_prefix) 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 @@ -2577,7 +2722,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); } @@ -2588,29 +2733,31 @@ 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) @@ -2650,6 +2797,7 @@ 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) @@ -2701,6 +2849,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. */ @@ -2712,14 +2861,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. */ @@ -2733,17 +2882,17 @@ 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)); } @@ -2765,21 +2914,20 @@ 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); } } @@ -2795,11 +2943,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"); @@ -2843,11 +2991,13 @@ show_exceptions_cmd (char *args, int from_tty) ? (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 @@ -2876,6 +3026,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) @@ -2887,25 +3038,26 @@ 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); if (err) - error ("%ld: %s.", right, strerror (err)); + error (_("%ld: %s."), right, safe_strerror (err)); } } else @@ -2915,7 +3067,7 @@ info_port_rights (char *args, mach_port_type_t only) 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); @@ -2926,152 +3078,161 @@ 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_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); } - + static void set_thread_pause_cmd (char *args, int from_tty) { @@ -3093,7 +3254,7 @@ show_thread_pause_cmd (char *args, int from_tty) 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 @@ -3116,7 +3277,8 @@ 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 @@ -3124,7 +3286,8 @@ 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); } @@ -3134,7 +3297,7 @@ 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)); } @@ -3161,88 +3324,95 @@ thread_takeover_sc_cmd (char *args, int from_tty) 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); + deprecated_add_set_cmd ("gnu-debug", class_maintenance, + var_boolean, (char *) &gnu_debug_flag, + "Set debugging output for the gnu backend.", + &maintenancelist); } #ifdef FLUSH_INFERIOR_CACHE @@ -3253,18 +3423,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 */