X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=gdb%2Fgnu-nat.c;h=ddeaf7012670fb111840527aaf1fbf68467eaacd;hb=28439f5ef78fd28c36bfc8c4b262f44fdd1ec40f;hp=f50b64f326d516c239ebfaf0d9b5efdf05a4abf5;hpb=9846de1bb5d61521885ef51fa6b99121ec1be577;p=thirdparty%2Fbinutils-gdb.git diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c index f50b64f326d..ddeaf701267 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,37 +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 @@ -59,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" @@ -87,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); @@ -98,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); @@ -115,17 +116,15 @@ 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); -error_t proc_get_exception_port (struct proc *proc, mach_port_t *port); +error_t proc_get_exception_port (struct proc *proc, mach_port_t * port); error_t proc_set_exception_port (struct proc *proc, mach_port_t port); static mach_port_t _proc_get_exc_port (struct proc *proc); void proc_steal_exc_port (struct proc *proc, mach_port_t exc_port); void proc_restore_exc_port (struct proc *proc); int proc_trace (struct proc *proc, int set); -char *proc_string (struct proc *proc); /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound to INF's msg port and task port respectively. If it has no msg port, @@ -147,108 +146,109 @@ 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 -{ - int exception; /* The exception code */ - int code, subcode; - mach_port_t handler; /* The real exception port to handle this. */ - mach_port_t reply; /* The reply port from the exception call. */ -}; + { + int exception; /* The exception code */ + int code, subcode; + mach_port_t handler; /* The real exception port to handle this. */ + mach_port_t reply; /* The reply port from the exception call. */ + }; /* The results of the last wait an inf did. */ struct inf_wait -{ - struct target_waitstatus status; /* The status returned to gdb. */ - struct exc_state exc; /* The exception that caused us to return. */ - struct proc *thread; /* The thread in question. */ - int suppress; /* Something trivial happened. */ -}; + { + struct target_waitstatus status; /* The status returned to gdb. */ + struct exc_state exc; /* The exception that caused us to return. */ + struct proc *thread; /* The thread in question. */ + int suppress; /* Something trivial happened. */ + }; /* The state of an inferior. */ struct inf -{ - /* Fields describing the current inferior. */ + { + /* Fields describing the current inferior. */ - struct proc *task; /* The mach task. */ - struct proc *threads; /* A linked list of all threads in TASK. */ + struct proc *task; /* The mach task. */ + struct proc *threads; /* A linked list of all threads in TASK. */ - /* True if THREADS needn't be validated by querying the task. We assume that - we and the task in question are the only ones frobbing the thread list, - so as long as we don't let any code run, we don't have to worry about - THREADS changing. */ - int threads_up_to_date; + /* True if THREADS needn't be validated by querying the task. We assume that + we and the task in question are the only ones frobbing the thread list, + so as long as we don't let any code run, we don't have to worry about + THREADS changing. */ + int threads_up_to_date; - pid_t pid; /* The real system PID. */ + pid_t pid; /* The real system PID. */ - struct inf_wait wait; /* What to return from target_wait. */ + struct inf_wait wait; /* What to return from target_wait. */ - /* One thread proc in INF may be in `single-stepping mode'. This is it. */ - struct proc *step_thread; + /* One thread proc in INF may be in `single-stepping mode'. This is it. */ + struct proc *step_thread; - /* The thread we think is the signal thread. */ - struct proc *signal_thread; + /* The thread we think is the signal thread. */ + struct proc *signal_thread; - mach_port_t event_port; /* Where we receive various msgs. */ + mach_port_t event_port; /* Where we receive various msgs. */ - /* True if we think at least one thread in the inferior could currently be - running. */ - unsigned int running : 1; + /* True if we think at least one thread in the inferior could currently be + running. */ + unsigned int running:1; - /* True if the process has stopped (in the proc server sense). Note that - since a proc server `stop' leaves the signal thread running, the inf can - be RUNNING && STOPPED... */ - unsigned int stopped : 1; + /* True if the process has stopped (in the proc server sense). Note that + since a proc server `stop' leaves the signal thread running, the inf can + be RUNNING && STOPPED... */ + unsigned int stopped:1; - /* True if the inferior has no message port. */ - unsigned int nomsg : 1; + /* True if the inferior has no message port. */ + unsigned int nomsg:1; - /* True if the inferior is traced. */ - unsigned int traced : 1; + /* True if the inferior is traced. */ + unsigned int traced:1; - /* True if we shouldn't try waiting for the inferior, usually because we - can't for some reason. */ - unsigned int no_wait : 1; + /* True if we shouldn't try waiting for the inferior, usually because we + can't for some reason. */ + unsigned int no_wait:1; - /* When starting a new inferior, we don't try to validate threads until all - the proper execs have been done. This is a count of how many execs we - expect to happen. */ - unsigned pending_execs; + /* When starting a new inferior, we don't try to validate threads until all + the proper execs have been done. This is a count of how many execs we + expect to happen. */ + unsigned pending_execs; - /* Fields describing global state */ + /* Fields describing global state */ - /* The task suspend count used when gdb has control. This is normally 1 to - make things easier for us, but sometimes (like when attaching to vital - system servers) it may be desirable to let the task continue to run - (pausing individual threads as necessary). */ - int pause_sc; + /* The task suspend count used when gdb has control. This is normally 1 to + make things easier for us, but sometimes (like when attaching to vital + system servers) it may be desirable to let the task continue to run + (pausing individual threads as necessary). */ + int pause_sc; - /* The task suspend count left when detaching from a task. */ - int detach_sc; + /* The task suspend count left when detaching from a task. */ + int detach_sc; - /* The initial values used for the run_sc and pause_sc of newly discovered - threads -- see the definition of those fields in struct proc. */ - int default_thread_run_sc; - int default_thread_pause_sc; - int default_thread_detach_sc; + /* The initial values used for the run_sc and pause_sc of newly discovered + threads -- see the definition of those fields in struct proc. */ + int default_thread_run_sc; + int default_thread_pause_sc; + int default_thread_detach_sc; - /* True if the process should be traced when started/attached. Newly - started processes *must* be traced at first to exec them properly, but - if this is false, tracing is turned off as soon it has done so. */ - int want_signals; + /* True if the process should be traced when started/attached. Newly + started processes *must* be traced at first to exec them properly, but + if this is false, tracing is turned off as soon it has done so. */ + int want_signals; - /* True if exceptions from the inferior process should be trapped. This - must be on to use breakpoints. */ - int want_exceptions; -}; + /* True if exceptions from the inferior process should be trapped. This + must be on to use breakpoints. */ + int want_exceptions; + }; -int __proc_pid (struct proc *proc) +int +__proc_pid (struct proc *proc) { return proc->inf->pid; } + /* Update PROC's real suspend count to match it's desired one. Returns true if we think PROC is now in a runnable state. */ @@ -256,7 +256,7 @@ int proc_update_sc (struct proc *proc) { int running; - int err = 0; + int err = 0; int delta = proc->sc - proc->cur_sc; if (delta) @@ -265,28 +265,35 @@ 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); - if (! err) + (thread_state_t) &proc->state, THREAD_STATE_SIZE); + if (!err) proc->state_changed = 0; } if (delta > 0) - while (delta-- > 0 && !err) - if (proc_is_task (proc)) - err = task_suspend (proc->port); - else - err = thread_suspend (proc->port); + { + while (delta-- > 0 && !err) + { + if (proc_is_task (proc)) + err = task_suspend (proc->port); + else + err = thread_suspend (proc->port); + } + } else - while (delta++ < 0 && !err) - if (proc_is_task (proc)) - err = task_resume (proc->port); - else - err = thread_resume (proc->port); - - if (! err) + { + while (delta++ < 0 && !err) + { + if (proc_is_task (proc)) + err = task_resume (proc->port); + else + err = thread_resume (proc->port); + } + } + if (!err) proc->cur_sc = proc->sc; /* If we got an error, then the task/thread has disappeared. */ @@ -294,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) { @@ -305,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. @@ -313,9 +321,9 @@ 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) + if (!proc->aborted) { struct inf *inf = proc->inf; int running = (proc->cur_sc == 0 && inf->task->cur_sc == 0); @@ -325,13 +333,13 @@ 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. */ running = 1; - if (! running) + if (!running) /* We only abort the thread if it's not actually running. */ { thread_abort (proc->port); @@ -357,16 +365,16 @@ proc_get_state (struct proc *proc, int will_modify) proc_abort (proc, will_modify); - if (! was_aborted && proc->aborted) + if (!was_aborted && proc->aborted) /* PROC's state may have changed since we last fetched it. */ proc->state_valid = 0; - if (! proc->state_valid) + if (!proc->state_valid) { mach_msg_type_number_t state_size = THREAD_STATE_SIZE; error_t err = - thread_get_state (proc->port, THREAD_STATE_FLAVOR, - (thread_state_t)&proc->state, &state_size); + thread_get_state (proc->port, THREAD_STATE_FLAVOR, + (thread_state_t) &proc->state, &state_size); proc_debug (proc, "getting thread state"); proc->state_valid = !err; } @@ -375,15 +383,16 @@ 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 -proc_get_exception_port (struct proc *proc, mach_port_t *port) +proc_get_exception_port (struct proc * proc, mach_port_t * port) { if (proc_is_task (proc)) return task_get_exception_port (proc->port, port); @@ -393,7 +402,7 @@ proc_get_exception_port (struct proc *proc, mach_port_t *port) /* Set PROC's exception port to PORT. */ error_t -proc_set_exception_port (struct proc *proc, mach_port_t port) +proc_set_exception_port (struct proc * proc, mach_port_t port) { proc_debug (proc, "setting exception port: %d", port); if (proc_is_task (proc)) @@ -432,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); @@ -460,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)); } } @@ -490,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. */ @@ -502,15 +512,15 @@ proc_trace (struct proc *proc, int set) { thread_state_t state = proc_get_state (proc, 1); - if (! state) + if (!state) return 0; /* the thread must be dead. */ proc_debug (proc, "tracing %s", set ? "on" : "off"); - + if (set) { /* XXX We don't get the exception unless the thread has its own - exception port???? */ + exception port???? */ if (proc->exc_port == MACH_PORT_NULL) proc_steal_exc_port (proc, proc->inf->event_port); THREAD_STATE_SET_TRACED (state); @@ -520,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; @@ -531,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; @@ -559,14 +570,14 @@ make_proc (struct inf *inf, mach_port_t port, int tid) /* Get notified when things die. */ err = - mach_port_request_notification (mach_task_self(), port, + mach_port_request_notification (mach_task_self (), port, MACH_NOTIFY_DEAD_NAME, 1, inf->event_port, MACH_MSG_TYPE_MAKE_SEND_ONCE, &prev_port); if (err) - warning ("Couldn't request notification for port %d: %s", - port, strerror (err)); + warning (_("Couldn't request notification for port %d: %s"), + port, safe_strerror (err)); else { proc_debug (proc, "notifications to: %d", inf->event_port); @@ -575,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; } @@ -617,16 +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 () +struct inf * +make_inf (void) { - struct inf *inf = malloc (sizeof (struct inf)); - - if (!inf) - return 0; + struct inf *inf = xmalloc (sizeof (struct inf)); inf->task = 0; inf->threads = 0; @@ -656,7 +669,7 @@ struct inf *make_inf () return inf; } -/* clear INF's target wait status. */ +/* Clear INF's target wait status. */ void inf_clear_wait (struct inf *inf) { @@ -675,6 +688,7 @@ inf_clear_wait (struct inf *inf) inf->wait.exc.reply = MACH_PORT_NULL; } } + void inf_cleanup (struct inf *inf) @@ -712,16 +726,17 @@ 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 */ -void +/* Close current process, if any, and attach INF to process PORT. */ +void inf_set_pid (struct inf *inf, pid_t pid) { task_t task_port; @@ -735,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); @@ -760,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 @@ -779,84 +796,115 @@ 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) + if (!err) { inf->stopped = !!(pi->state & PI_STOPPED); inf->nomsg = !!(pi->state & PI_NOMSG); if (inf->nomsg) inf->traced = !!(pi->state & PI_TRACED); - vm_deallocate (mach_task_self (), (vm_address_t)pi, pi_len); + vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len); if (noise_len > 0) - vm_deallocate (mach_task_self (), (vm_address_t)noise, noise_len); + vm_deallocate (mach_task_self (), (vm_address_t) noise, noise_len); } } -/* Validates INF's task suspend count. If it's higher than we expect, verify - with the user before `stealing' the extra count. */ +/* Validates INF's task suspend count. If it's higher than we expect, + verify with the user before `stealing' the extra count. */ static void inf_validate_task_sc (struct inf *inf) { - struct task_basic_info info; - mach_msg_type_number_t info_len = TASK_BASIC_INFO_COUNT; - error_t err = - task_info (inf->task->port, TASK_BASIC_INFO, (task_info_t)&info, &info_len); + char *noise; + mach_msg_type_number_t noise_len = 0; + struct procinfo *pi; + mach_msg_type_number_t pi_len = 0; + int info_flags = PI_FETCH_TASKINFO; + int suspend_count = -1; + error_t err; + retry: + err = proc_getprocinfo (proc_server, inf->pid, &info_flags, + (procinfo_t *) &pi, &pi_len, &noise, &noise_len); if (err) - inf->task->dead = 1; /* oh well */ - else if (inf->task->cur_sc < info.suspend_count) + { + inf->task->dead = 1; /* oh well */ + return; + } + + if (inf->task->cur_sc < pi->taskinfo.suspend_count && suspend_count == -1) + { + /* The proc server might have suspended the task while stopping + it. This happens when the task is handling a traced signal. + Refetch the suspend count. The proc server should be + finished stopping the task by now. */ + suspend_count = pi->taskinfo.suspend_count; + goto retry; + } + + suspend_count = pi->taskinfo.suspend_count; + + vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len); + if (noise_len > 0) + vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len); + + if (inf->task->cur_sc < suspend_count) { int abort; target_terminal_ours (); /* Allow I/O. */ - abort = - !query ("Pid %d has an additional task suspend count of %d; clear it? ", - inf->pid, info.suspend_count - inf->task->cur_sc); - target_terminal_inferior (); /* Give it back to the child. */ + abort = !query ("Pid %d has an additional task suspend count of %d;" + " clear it? ", inf->pid, + suspend_count - inf->task->cur_sc); + target_terminal_inferior (); /* Give it back to the child. */ if (abort) - error ("Additional task suspend count left untouched."); + error (_("Additional task suspend count left untouched.")); - inf->task->cur_sc = info.suspend_count; + inf->task->cur_sc = suspend_count; } } -/* Turns tracing for INF on or off, depending on ON, unless it already is. - If INF is running, the resume_sc count of INF's threads will be modified, - and the signal thread will briefly be run to change the trace state. */ +/* Turns tracing for INF on or off, depending on ON, unless it already + is. If INF is running, the resume_sc count of INF's threads will + be modified, and the signal thread will briefly be run to change + the trace state. */ void inf_set_traced (struct inf *inf, int on) { - if (on != inf->traced) - if (inf->task && !inf->task->dead) - /* Make it take effect immediately. */ - { - sigset_t mask = on ? ~(sigset_t)0 : 0; - error_t err = - INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport, - INIT_TRACEMASK, mask)); - if (err == EIEIO) - { - if (on) - warning ("Can't modify tracing state for pid %d: No signal thread", - inf->pid); - inf->traced = on; - } - else if (err) - warning ("Can't modify tracing state for pid %d: %s", - inf->pid, strerror (err)); - else + if (on == inf->traced) + return; + + if (inf->task && !inf->task->dead) + /* Make it take effect immediately. */ + { + sigset_t mask = on ? ~(sigset_t) 0 : 0; + error_t err = + INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport, + INIT_TRACEMASK, mask)); + if (err == EIEIO) + { + if (on) + warning (_("Can't modify tracing state for pid %d: %s"), + inf->pid, "No signal thread"); inf->traced = on; - } - else - inf->traced = on; + } + else if (err) + warning (_("Can't modify tracing state for pid %d: %s"), + inf->pid, safe_strerror (err)); + else + inf->traced = on; + } + else + inf->traced = on; } + -/* 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) { @@ -896,7 +944,7 @@ inf_update_suspends (struct inf *inf) inf->running = thread_running && task_running; /* Once any thread has executed some code, we can't depend on the - threads list any more. */ + threads list any more. */ if (inf->running) inf->threads_up_to_date = 0; @@ -905,6 +953,7 @@ inf_update_suspends (struct inf *inf) return 0; } + /* Converts a GDB pid to a struct proc. */ struct proc * @@ -932,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 @@ -967,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. */ @@ -975,16 +1025,16 @@ 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--) { if (i >= num_threads) - i -= num_threads; /* I wrapped around. */ + i -= num_threads; /* I wrapped around. */ if (thread->port == threads[i]) /* We already know about this thread. */ { @@ -996,41 +1046,65 @@ inf_validate_procs (struct inf *inf) } } - if (! left) + if (!left) { proc_debug (thread, "died!"); thread->port = MACH_PORT_NULL; - thread = _proc_free (thread); /* THREAD is dead. */ - (last ? last->next : inf->threads) = thread; + thread = _proc_free (thread); /* THREAD is dead. */ + if (last) + last->next = thread; + else + inf->threads = thread; } } for (i = 0; i < num_threads; i++) - if (matched[i]) - /* Throw away the duplicate send right. */ - mach_port_deallocate (mach_task_self (), threads[i]); - else - /* THREADS[I] is a thread we don't know about yet! */ - { - thread = make_proc (inf, threads[i], next_thread_id++); - (last ? last->next : inf->threads) = thread; - last = thread; - proc_debug (thread, "new thread: %d", threads[i]); - add_thread (thread->tid); /* Tell GDB's generic thread code. */ - } + { + if (matched[i]) + /* Throw away the duplicate send right. */ + mach_port_deallocate (mach_task_self (), threads[i]); + else + /* THREADS[I] is a thread we don't know about yet! */ + { + ptid_t ptid; + + thread = make_proc (inf, threads[i], next_thread_id++); + if (last) + last->next = thread; + else + inf->threads = thread; + last = thread; + proc_debug (thread, "new thread: %d", threads[i]); + + ptid = ptid_build (inf->pid, 0, thread->tid); + + /* Tell GDB's generic thread code. */ + + if (ptid_equal (inferior_ptid, pid_to_ptid (inf->pid))) + /* This is the first time we're hearing about thread + ids, after a fork-child. */ + thread_change_ptid (inferior_ptid, ptid); + else if (inf->pending_execs != 0) + /* This is a shell thread. */ + add_thread_silent (ptid); + else + add_thread (ptid); + } + } - vm_deallocate(mach_task_self(), - (vm_address_t)threads, (num_threads * sizeof(thread_t))); + vm_deallocate (mach_task_self (), + (vm_address_t) threads, (num_threads * sizeof (thread_t))); } } + /* Makes sure that INF's thread list is synced with the actual process. */ -inline int +int inf_update_procs (struct inf *inf) { - if (! inf->task) + if (!inf->task) return 0; - if (! inf->threads_up_to_date) + if (!inf->threads_up_to_date) inf_validate_procs (inf); return !!inf->task; } @@ -1038,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) { @@ -1052,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; @@ -1067,7 +1142,7 @@ inf_resume (struct inf *inf) if (inf->task) { - if (! inf->pending_execs) + if (!inf->pending_execs) /* Try to make sure our task count is correct -- in the case where we're waiting for an exec though, things are too volatile, so just assume things will be reasonable (which they usually will be). */ @@ -1080,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; @@ -1095,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); @@ -1112,7 +1188,7 @@ inf_set_step_thread (struct inf *inf, struct proc *thread) if (inf->step_thread != thread) { if (inf->step_thread && inf->step_thread->port != MACH_PORT_NULL) - if (! proc_trace (inf->step_thread, 0)) + if (!proc_trace (inf->step_thread, 0)) return; if (thread && proc_trace (thread, 1)) inf->step_thread = thread; @@ -1120,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) @@ -1143,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 @@ -1185,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) { @@ -1197,9 +1275,11 @@ 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 inf_steal_exc_ports (struct inf *inf) +void +inf_steal_exc_ports (struct inf *inf) { struct proc *thread; @@ -1213,7 +1293,8 @@ void inf_steal_exc_ports (struct inf *inf) } /* Makes sure the process has its own exception ports. */ -void inf_restore_exc_ports (struct inf *inf) +void +inf_restore_exc_ports (struct inf *inf) { struct proc *thread; @@ -1225,6 +1306,7 @@ void 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 @@ -1265,50 +1347,53 @@ 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. */ - if (inf->stopped) - /* The process is stopped and expecting a signal. Just send off a - request and let it get handled when we resume everything. */ - { - inf_debug (inf, "sending %s to stopped process", NAME); - err = - INF_MSGPORT_RPC (inf, - msg_sig_post_untraced_request (msgport, - inf->event_port, - MACH_MSG_TYPE_MAKE_SEND_ONCE, - host_sig, 0, - refport)); - if (! err) - /* Posting an untraced signal automatically continues it. - We clear this here rather than when we get the reply - because we'd rather assume it's not stopped when it - actually is, than the reverse. */ - inf->stopped = 0; - } - else - /* It's not expecting it. We have to let just the signal thread - run, and wait for it to get into a reasonable state before we - can continue the rest of the process. When we finally resume the - process the signal we request will be the very first thing that - happens. */ - { - inf_debug (inf, "sending %s to unstopped process (so resuming signal thread)", NAME); - err = - INF_RESUME_MSGPORT_RPC (inf, msg_sig_post_untraced (msgport, - host_sig, 0, refport)); - } + if (inf->stopped) + /* The process is stopped and expecting a signal. Just send off a + request and let it get handled when we resume everything. */ + { + inf_debug (inf, "sending %s to stopped process", NAME); + err = + INF_MSGPORT_RPC (inf, + msg_sig_post_untraced_request (msgport, + inf->event_port, + MACH_MSG_TYPE_MAKE_SEND_ONCE, + host_sig, 0, + refport)); + if (!err) + /* Posting an untraced signal automatically continues it. + We clear this here rather than when we get the reply + because we'd rather assume it's not stopped when it + actually is, than the reverse. */ + inf->stopped = 0; + } + else + /* It's not expecting it. We have to let just the signal thread + run, and wait for it to get into a reasonable state before we + can continue the rest of the process. When we finally resume the + process the signal we request will be the very first thing that + happens. */ + { + inf_debug (inf, "sending %s to unstopped process" + " (so resuming signal thread)", NAME); + err = + INF_RESUME_MSGPORT_RPC (inf, + msg_sig_post_untraced (msgport, host_sig, + 0, refport)); + } if (err == EIEIO) /* Can't do too much... */ - warning ("Can't deliver signal %s: No signal thread.", NAME); + warning (_("Can't deliver signal %s: No signal thread."), NAME); else if (err) - warning ("Delivering signal %s: %s", NAME, strerror (err)); + warning (_("Delivering signal %s: %s"), NAME, safe_strerror (err)); #undef NAME } + /* Continue INF without delivering a signal. This is meant to be used when INF does not have a message port. */ @@ -1318,47 +1403,55 @@ inf_continue (struct inf *inf) process_t proc; error_t err = proc_pid2proc (proc_server, inf->pid, &proc); - if (! err) + if (!err) { inf_debug (inf, "continuing process"); err = proc_mark_cont (proc); - if (! err) + if (!err) { struct proc *thread; for (thread = inf->threads; thread; thread = thread->next) thread_resume (thread->port); - + inf->stopped = 0; } } if (err) - warning ("Can't continue process: %s", strerror (err)); + warning (_("Can't continue process: %s"), safe_strerror (err)); } + /* The inferior used for all gdb target ops. */ -struct inf *current_inferior = 0; +struct inf *gnu_current_inf = 0; /* The inferior being waited for by gnu_wait. Since GDB is decidely not multi-threaded, we don't bother to lock this. */ struct inf *waiting_inf; /* Wait for something to happen in the inferior, returning what in STATUS. */ -static int -gnu_wait (int tid, struct target_waitstatus *status) +static ptid_t +gnu_wait (struct target_ops *ops, + ptid_t ptid, struct target_waitstatus *status) { - struct msg { - mach_msg_header_t hdr; - mach_msg_type_t type; - int data[8000]; - } msg; + struct msg + { + mach_msg_header_t hdr; + mach_msg_type_t type; + int data[8000]; + } msg; error_t err; struct proc *thread; - struct inf *inf = current_inferior; + struct inf *inf = gnu_current_inf; + + extern int exc_server (mach_msg_header_t *, mach_msg_header_t *); + extern int msg_reply_server (mach_msg_header_t *, mach_msg_header_t *); + extern int notify_server (mach_msg_header_t *, mach_msg_header_t *); + extern int process_reply_server (mach_msg_header_t *, mach_msg_header_t *); - assert (inf->task); + gdb_assert (inf->task); if (!inf->threads && !inf->pending_execs) /* No threads! Assume that maybe some outside agency is frobbing our @@ -1367,14 +1460,14 @@ 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: +rewait: if (proc_wait_pid != inf->pid && !inf->no_wait) /* Always get information on events from the proc server. */ { @@ -1391,15 +1484,16 @@ gnu_wait (int tid, struct target_waitstatus *status) 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; } } @@ -1426,29 +1520,31 @@ gnu_wait (int tid, struct target_waitstatus *status) if (err == EMACH_RCV_INTERRUPTED) inf_debug (inf, "interrupted"); else if (err) - error ("Couldn't wait for an event: %s", strerror (err)); + error (_("Couldn't wait for an event: %s"), safe_strerror (err)); else { - struct { - mach_msg_header_t hdr; - mach_msg_type_t err_type; - kern_return_t err; - char noise[200]; - } reply; + struct + { + mach_msg_header_t hdr; + mach_msg_type_t err_type; + kern_return_t err; + char noise[200]; + } + reply; inf_debug (inf, "event: msgid = %d", msg.hdr.msgh_id); /* Handle what we got. */ - if (! notify_server (&msg.hdr, &reply.hdr) - && ! exc_server (&msg.hdr, &reply.hdr) - && ! process_reply_server (&msg.hdr, &reply.hdr) - && ! msg_reply_server (&msg.hdr, &reply.hdr)) + if (!notify_server (&msg.hdr, &reply.hdr) + && !exc_server (&msg.hdr, &reply.hdr) + && !process_reply_server (&msg.hdr, &reply.hdr) + && !msg_reply_server (&msg.hdr, &reply.hdr)) /* Whatever it is, it's something strange. */ - error ("Got a strange event, msg id = %d.", msg.hdr.msgh_id); + error (_("Got a strange event, msg id = %d."), msg.hdr.msgh_id); if (reply.err) - error ("Handling event, msgid = %d: %s", - msg.hdr.msgh_id, strerror (reply.err)); + error (_("Handling event, msgid = %d: %s"), + msg.hdr.msgh_id, safe_strerror (reply.err)); } if (inf->pending_execs) @@ -1474,9 +1570,9 @@ gnu_wait (int tid, struct target_waitstatus *status) if (--inf->pending_execs == 0) /* We're done! */ { -#if 0 /* do we need this? */ +#if 0 /* do we need this? */ prune_threads (1); /* Get rid of the old shell threads */ - renumber_threads (0); /* Give our threads reasonable names. */ + renumber_threads (0); /* Give our threads reasonable names. */ #endif } inf_debug (inf, "pending exec completed, pending_execs => %d", @@ -1501,30 +1597,38 @@ gnu_wait (int tid, struct target_waitstatus *status) } /* 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" @@ -1533,8 +1637,9 @@ gnu_wait (int tid, struct target_waitstatus *status) : "?", status->value.integer); - return tid; + return ptid; } + /* The rpc handler called by exc_server. */ error_t @@ -1547,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? */ @@ -1562,7 +1667,7 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port, mach_port_deallocate (mach_task_self (), thread_port); mach_port_deallocate (mach_task_self (), task_port); - if (! thread->aborted) + if (!thread->aborted) /* THREAD hasn't been aborted since this exception happened (abortion clears any exception state), so it must be real. */ { @@ -1582,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. */ @@ -1619,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; } @@ -1659,50 +1765,56 @@ 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); - inf->threads_up_to_date = 0; /* Just in case */ + inf->threads_up_to_date = 0; /* Just in case */ 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. */ @@ -1713,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 @@ -1734,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. */ @@ -1762,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. */ @@ -1789,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 @@ -1806,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 @@ -1815,13 +1929,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. @@ -1838,17 +1953,20 @@ port_msgs_queued (mach_port_t port) Note that a resume may not `take' if there are pending exceptions/&c still unprocessed from the last resume we did (any given resume may result in multiple events returned by wait). -*/ + */ static void -gnu_resume (int tid, int step, enum target_signal sig) +gnu_resume (struct target_ops *ops, + ptid_t ptid, int step, enum target_signal sig) { struct proc *step_thread = 0; - struct inf *inf = current_inferior; + int resume_all; + struct inf *inf = gnu_current_inf; - inf_debug (inf, "tid = %d, step = %d, sig = %d", tid, step, sig); + inf_debug (inf, "ptid = %s, step = %d, sig = %d", + target_pid_to_str (ptid), step, sig); inf_validate_procinfo (inf); - + if (sig != TARGET_SIGNAL_0 || inf->stopped) { if (sig == TARGET_SIGNAL_0 && inf->nomsg) @@ -1861,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)); } @@ -1873,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); - if (! thread) - error ("Can't run single thread id %d: no such thread!"); - inf_debug (inf, "running one thread: %d/%d", inf->pid, thread->tid); + struct proc *thread = inf_tid_to_thread (inf, ptid_get_tid (ptid)); + if (!thread) + error (_("Can't run single thread id %s: no such thread!"), + target_pid_to_str (ptid)); + inf_debug (inf, "running one thread: %s", target_pid_to_str (ptid)); inf_set_threads_resume_sc (inf, thread, 0); } if (step) { - step_thread = inf_tid_to_thread (inf, tid); - if (! step_thread) - warning ("Can't step thread id %d: no such thread.", tid); + step_thread = inf_tid_to_thread (inf, ptid_get_tid (ptid)); + if (!step_thread) + warning (_("Can't step thread id %s: no such thread."), + target_pid_to_str (ptid)); else - inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid); + inf_debug (inf, "stepping thread: %s", target_pid_to_str (ptid)); } if (step_thread != inf->step_thread) inf_set_step_thread (inf, step_thread); @@ -1904,89 +2027,91 @@ 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 (); void trace_me () - { - /* We're in the child; make this process stop as soon as it execs. */ - inf_debug (inf, "tracing self"); - if (ptrace (PTRACE_TRACEME) != 0) - error ("ptrace (PTRACE_TRACEME) failed!"); - } + { + /* We're in the child; make this process stop as soon as it execs. */ + inf_debug (inf, "tracing self"); + if (ptrace (PTRACE_TRACEME) != 0) + error (_("ptrace (PTRACE_TRACEME) failed!")); + } void attach_to_child (int pid) - { - /* Attach to the now stopped child, which is actually a shell... */ - inf_debug (inf, "attaching to child: %d", pid); + { + /* Attach to the now stopped child, which is actually a shell... */ + inf_debug (inf, "attaching to child: %d", pid); - inf_attach (inf, pid); + inf_attach (inf, pid); - attach_flag = 0; - push_target (&gnu_ops); + push_target (&gnu_ops); - inf->pending_execs = 2; - inf->nomsg = 1; - inf->traced = 1; + inf->pending_execs = 2; + inf->nomsg = 1; + inf->traced = 1; - /* Now let the child run again, knowing that it will stop immediately - because of the ptrace. */ - inf_resume (inf); - inferior_pid = inf_pick_first_thread (); + /* Now let the child run again, knowing that it will stop immediately + because of the ptrace. */ + inf_resume (inf); - startup_inferior (inf->pending_execs); - } + /* We now have thread info. */ + thread_change_ptid (inferior_ptid, + ptid_build (inf->pid, 0, inf_pick_first_thread ())); + + startup_inferior (inf->pending_execs); + } inf_debug (inf, "creating inferior"); @@ -2003,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!"); + if (pid == getpid ()) /* Trying to masturbate? */ + error (_("I refuse to debug myself!")); if (from_tty) { @@ -2053,17 +2173,20 @@ 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 (); - + /* If the process was stopped before we attached, make it continue the next time the user does a continue. */ inf_validate_procinfo (inf); @@ -2071,10 +2194,11 @@ gnu_attach (args, from_tty) inf_update_signal_thread (inf); inf_set_traced (inf, inf->want_signals); -#if 0 /* Do we need this? */ +#if 0 /* Do we need this? */ renumber_threads (0); /* Give our threads reasonable names. */ #endif } + /* Take a program previously attached to and detaches it. The program resumes execution and will no longer stop @@ -2084,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); - inferior_pid = 0; + pid = gnu_current_inf->pid; - unpush_target (&gnu_ops); /* Pop out of handling an inferior */ -} -#endif /* ATTACH_DETACH */ + inf_detach (gnu_current_inf); + inferior_ptid = null_ptid; + detach_inferior (pid); + + unpush_target (&gnu_ops); /* Pop out of handling an inferior */ +} + 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 @@ -2119,79 +2245,60 @@ 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 () +gnu_stop (ptid_t ptid) { - error ("to_stop target function not implemented"); + error (_("to_stop target function not implemented")); } -static char * -gnu_pid_to_exec_file () -{ - error ("to_pid_to_exec_file target function not implemented"); - return NULL; -} - - static int -gnu_thread_alive (int tid) +gnu_thread_alive (struct target_ops *ops, ptid_t ptid) { - inf_update_procs (current_inferior); - return !!inf_tid_to_thread (current_inferior, tid); + inf_update_procs (gnu_current_inf); + return !!inf_tid_to_thread (gnu_current_inf, + ptid_get_tid (ptid)); } + -/* - * Read inferior task's LEN bytes from ADDR and copy it to MYADDR - * in gdb's address space. - * - * Return 0 on failure; number of bytes read otherwise. - */ +/* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in + gdb's address space. Return 0 on failure; number of bytes read + otherwise. */ int -gnu_read_inferior (task, addr, myaddr, length) - task_t task; - CORE_ADDR addr; - char *myaddr; - int length; +gnu_read_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length) { error_t err; vm_address_t low_address = (vm_address_t) trunc_page (addr); vm_size_t aligned_length = - (vm_size_t) round_page (addr+length) - low_address; - pointer_t copied; - int copy_count; + (vm_size_t) round_page (addr + length) - low_address; + pointer_t copied; + int copy_count; /* Get memory from inferior with page aligned addresses */ err = vm_read (task, low_address, aligned_length, &copied, ©_count); if (err) return 0; - err = hurd_safe_copyin (myaddr, (void*)addr - low_address + copied, length); + err = hurd_safe_copyin (myaddr, (void *) (addr - low_address + copied), length); if (err) { - warning ("Read from inferior faulted: %s", strerror (err)); + warning (_("Read from inferior faulted: %s"), safe_strerror (err)); length = 0; } err = vm_deallocate (mach_task_self (), copied, copy_count); if (err) - warning ("gnu_read_inferior vm_deallocate failed: %s", strerror (err)); + warning (_("gnu_read_inferior vm_deallocate failed: %s"), safe_strerror (err)); return length; } @@ -2199,38 +2306,33 @@ gnu_read_inferior (task, addr, myaddr, length) #define CHK_GOTO_OUT(str,ret) \ do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0) -struct vm_region_list { +struct vm_region_list +{ struct vm_region_list *next; - vm_prot_t protection; - vm_address_t start; - vm_size_t length; + vm_prot_t protection; + vm_address_t start; + vm_size_t length; }; -struct obstack region_obstack; +struct obstack region_obstack; -/* - * Write gdb's LEN bytes from MYADDR and copy it to ADDR - * in inferior task's address space. - */ +/* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior + task's address space. */ int -gnu_write_inferior (task, addr, myaddr, length) - task_t task; - CORE_ADDR addr; - char *myaddr; - int length; +gnu_write_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length) { error_t err = 0; - vm_address_t low_address = (vm_address_t) trunc_page (addr); - vm_size_t aligned_length = - (vm_size_t) round_page (addr+length) - low_address; - pointer_t copied; - int copy_count; - int deallocate = 0; + vm_address_t low_address = (vm_address_t) trunc_page (addr); + vm_size_t aligned_length = + (vm_size_t) round_page (addr + length) - low_address; + pointer_t copied; + int copy_count; + int deallocate = 0; - char *errstr = "Bug in gnu_write_inferior"; + char *errstr = "Bug in gnu_write_inferior"; struct vm_region_list *region_element; - struct vm_region_list *region_head = (struct vm_region_list *)NULL; + struct vm_region_list *region_head = (struct vm_region_list *) NULL; /* Get memory from inferior with page aligned addresses */ err = vm_read (task, @@ -2242,21 +2344,21 @@ 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; + vm_size_t remaining_length = aligned_length; + vm_address_t region_address = low_address; struct vm_region_list *scan; - while(region_address < low_address + aligned_length) + while (region_address < low_address + aligned_length) { vm_prot_t protection; vm_prot_t max_protection; @@ -2264,9 +2366,9 @@ gnu_write_inferior (task, addr, myaddr, length) boolean_t shared; mach_port_t object_name; vm_offset_t offset; - vm_size_t region_length = remaining_length; - vm_address_t old_address = region_address; - + vm_size_t region_length = remaining_length; + vm_address_t old_address = region_address; + err = vm_region (task, ®ion_address, ®ion_length, @@ -2281,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; @@ -2290,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; @@ -2298,31 +2400,28 @@ gnu_write_inferior (task, addr, myaddr, length) } /* Chain the regions for later use */ - region_element = + region_element = (struct vm_region_list *) - obstack_alloc (®ion_obstack, sizeof (struct vm_region_list)); - + obstack_alloc (®ion_obstack, sizeof (struct vm_region_list)); + region_element->protection = protection; - region_element->start = region_address; - region_element->length = region_length; + region_element->start = region_address; + region_element->length = region_length; /* Chain the regions along with protections */ region_element->next = region_head; - region_head = region_element; - + region_head = region_element; + region_address += region_length; remaining_length = remaining_length - region_length; } /* If things fail after this, we give up. - * Somebody is messing up inferior_task's mappings. - */ - + Somebody is messing up inferior_task's mappings. */ + /* Enable writes to the chained vm regions */ for (scan = region_head; scan; scan = scan->next) { - boolean_t protection_changed = FALSE; - if (!(scan->protection & VM_PROT_WRITE)) { err = vm_protect (task, @@ -2339,12 +2438,10 @@ gnu_write_inferior (task, addr, myaddr, length) copied, aligned_length); CHK_GOTO_OUT ("vm_write failed", err); - + /* Set up the original region protections, if they were changed */ for (scan = region_head; scan; scan = scan->next) { - boolean_t protection_changed = FALSE; - if (!(scan->protection & VM_PROT_WRITE)) { err = vm_protect (task, @@ -2357,11 +2454,11 @@ gnu_write_inferior (task, addr, myaddr, length) } } - out: +out: if (deallocate) { obstack_free (®ion_obstack, 0); - + (void) vm_deallocate (mach_task_self (), copied, copy_count); @@ -2369,131 +2466,140 @@ gnu_write_inferior (task, addr, myaddr, length) 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); else - return gnu_read_inferior (task, memaddr, myaddr, len); + return gnu_read_inferior (task, memaddr, myaddr, len); } } - -extern void gnu_store_registers (int regno); -extern void gnu_fetch_registers (int regno); -struct target_ops gnu_ops ; +/* Call FUNC on each memory region in the task. */ +static int +gnu_find_memory_regions (int (*func) (CORE_ADDR, + unsigned long, + int, int, int, + void *), + void *data) +{ + error_t err; + task_t task; + vm_address_t region_address, last_region_address, last_region_end; + vm_prot_t last_protection; + + if (gnu_current_inf == 0 || gnu_current_inf->task == 0) + return 0; + task = gnu_current_inf->task->port; + if (task == MACH_PORT_NULL) + return 0; + + region_address = last_region_address = last_region_end = VM_MIN_ADDRESS; + last_protection = VM_PROT_NONE; + while (region_address < VM_MAX_ADDRESS) + { + vm_prot_t protection; + vm_prot_t max_protection; + vm_inherit_t inheritance; + boolean_t shared; + mach_port_t object_name; + vm_offset_t offset; + vm_size_t region_length = VM_MAX_ADDRESS - region_address; + vm_address_t old_address = region_address; + + err = vm_region (task, + ®ion_address, + ®ion_length, + &protection, + &max_protection, + &inheritance, + &shared, + &object_name, + &offset); + if (err == KERN_NO_SPACE) + break; + if (err != KERN_SUCCESS) + { + warning (_("vm_region failed: %s"), mach_error_string (err)); + return -1; + } + + if (protection == last_protection && region_address == last_region_end) + /* This region is contiguous with and indistinguishable from + the previous one, so we just extend that one. */ + last_region_end = region_address += region_length; + else + { + /* This region is distinct from the last one we saw, so report + that previous one. */ + if (last_protection != VM_PROT_NONE) + (*func) (last_region_address, + last_region_end - last_region_address, + last_protection & VM_PROT_READ, + last_protection & VM_PROT_WRITE, + last_protection & VM_PROT_EXECUTE, + data); + last_region_address = region_address; + last_region_end = region_address += region_length; + last_protection = protection; + } + } + + /* Report the final region. */ + if (last_region_end > last_region_address && last_protection != VM_PROT_NONE) + (*func) (last_region_address, last_region_end - last_region_address, + last_protection & VM_PROT_READ, + last_protection & VM_PROT_WRITE, + last_protection & VM_PROT_EXECUTE, + data); + + return 0; +} -static void -init_gnu_ops(void) -{ - gnu_ops.to_shortname = "GNU"; /* to_shortname */ - gnu_ops.to_longname = "GNU Hurd process"; /* to_longname */ - gnu_ops.to_doc = "GNU Hurd process"; /* to_doc */ - gnu_ops.to_open = gnu_open; /* to_open */ - gnu_ops.to_close = 0; /* to_close */ - gnu_ops.to_attach = gnu_attach; /* to_attach */ - gnu_ops.to_post_attach = NULL; - gnu_ops.to_require_attach = NULL; /* to_require_attach */ - gnu_ops.to_detach = gnu_detach; /* to_detach */ - gnu_ops.to_require_detach = NULL; /* to_require_detach */ - gnu_ops.to_resume = gnu_resume; /* to_resume */ - gnu_ops.to_wait = gnu_wait; /* to_wait */ - gnu_ops.to_post_wait = NULL; /* to_post_wait */ - gnu_ops.to_fetch_registers = gnu_fetch_registers; /* to_fetch_registers */ - gnu_ops.to_store_registers = gnu_store_registers; /* to_store_registers */ - gnu_ops.to_prepare_to_store = gnu_prepare_to_store; /* to_prepare_to_store */ - gnu_ops.to_xfer_memory = gnu_xfer_memory; /* to_xfer_memory */ - gnu_ops.to_files_info = 0; /* to_files_info */ - gnu_ops.to_insert_breakpoint = memory_insert_breakpoint; - gnu_ops.to_remove_breakpoint = memory_remove_breakpoint; - gnu_ops.to_terminal_init = gnu_terminal_init_inferior; - gnu_ops.to_terminal_inferior = terminal_inferior; - gnu_ops.to_terminal_ours_for_output = terminal_ours_for_output; - gnu_ops.to_terminal_ours = terminal_ours; - gnu_ops.to_terminal_info = child_terminal_info; - gnu_ops.to_kill = gnu_kill_inferior; /* to_kill */ - gnu_ops.to_load = 0; /* to_load */ - gnu_ops.to_lookup_symbol = 0; /* to_lookup_symbol */ - gnu_ops.to_create_inferior = gnu_create_inferior; /* to_create_inferior */ - gnu_ops.to_post_startup_inferior = NULL; /* to_post_startup_inferior */ - gnu_ops.to_acknowledge_created_inferior = NULL; /* to_acknowledge_created_inferior */ - gnu_ops.to_clone_and_follow_inferior = NULL; /* to_clone_and_follow_inferior */ - gnu_ops.to_post_follow_inferior_by_clone = NULL; /* to_post_follow_inferior_by_clone */ - gnu_ops.to_insert_fork_catchpoint = NULL; - gnu_ops.to_remove_fork_catchpoint = NULL; - gnu_ops.to_insert_vfork_catchpoint = NULL; - gnu_ops.to_remove_vfork_catchpoint = NULL; - gnu_ops.to_has_forked = NULL; /* to_has_forked */ - gnu_ops.to_has_vforked = NULL; /* to_has_vforked */ - gnu_ops.to_can_follow_vfork_prior_to_exec = NULL; - gnu_ops.to_post_follow_vfork = NULL; /* to_post_follow_vfork */ - gnu_ops.to_insert_exec_catchpoint = NULL; - gnu_ops.to_remove_exec_catchpoint = NULL; - gnu_ops.to_has_execd = NULL; - gnu_ops.to_reported_exec_events_per_exec_call = NULL; - gnu_ops.to_has_exited = NULL; - gnu_ops.to_mourn_inferior = gnu_mourn_inferior; /* to_mourn_inferior */ - gnu_ops.to_can_run = gnu_can_run; /* to_can_run */ - gnu_ops.to_notice_signals = 0; /* to_notice_signals */ - gnu_ops.to_thread_alive = gnu_thread_alive;/* to_thread_alive */ - gnu_ops.to_stop = gnu_stop; /* to_stop */ - gnu_ops.to_pid_to_exec_file = gnu_pid_to_exec_file; /* to_pid_to_exec_file */ - gnu_ops.to_core_file_to_sym_file = NULL; - gnu_ops.to_stratum = process_stratum; /* to_stratum */ - gnu_ops.DONT_USE = 0; /* to_next */ - gnu_ops.to_has_all_memory = 1; /* to_has_all_memory */ - gnu_ops.to_has_memory = 1; /* to_has_memory */ - gnu_ops.to_has_stack = 1; /* to_has_stack */ - gnu_ops.to_has_registers = 1; /* to_has_registers */ - gnu_ops.to_has_execution = 1; /* to_has_execution */ - gnu_ops.to_sections = 0; /* sections */ - gnu_ops.to_sections_end = 0; /* sections_end */ - gnu_ops.to_magic = OPS_MAGIC ; /* to_magic */ -} /* init_gnu_ops */ /* Return printable description of proc. */ -char *proc_string (struct proc *proc) +char * +proc_string (struct proc *proc) { static char tid_str[80]; if (proc_is_task (proc)) sprintf (tid_str, "process %d", proc->inf->pid); else - sprintf (tid_str, "thread %d.%d", - proc->inf->pid, pid_to_thread_id (proc->tid)); + sprintf (tid_str, "Thread %d.%d", + proc->inf->pid, proc->tid); return tid_str; } -char * -gnu_target_pid_to_str (int tid) +static char * +gnu_pid_to_str (struct target_ops *ops, ptid_t ptid) { - struct inf *inf = current_inferior; + struct inf *inf = gnu_current_inf; + int tid = ptid_get_tid (ptid); struct proc *thread = inf_tid_to_thread (inf, tid); if (thread) @@ -2505,6 +2611,56 @@ gnu_target_pid_to_str (int tid) return tid_str; } } + + +extern void gnu_store_registers (struct target_ops *ops, + struct regcache *regcache, int regno); +extern void gnu_fetch_registers (struct target_ops *ops, + struct regcache *regcache, int regno); + +struct target_ops gnu_ops; + +static void +init_gnu_ops (void) +{ + gnu_ops.to_shortname = "GNU"; /* to_shortname */ + gnu_ops.to_longname = "GNU Hurd process"; /* to_longname */ + gnu_ops.to_doc = "GNU Hurd process"; /* to_doc */ + gnu_ops.to_open = gnu_open; /* to_open */ + gnu_ops.to_attach = gnu_attach; /* to_attach */ + gnu_ops.to_attach_no_wait = 1; /* to_attach_no_wait */ + gnu_ops.to_detach = gnu_detach; /* to_detach */ + gnu_ops.to_resume = gnu_resume; /* to_resume */ + gnu_ops.to_wait = gnu_wait; /* to_wait */ + gnu_ops.to_fetch_registers = gnu_fetch_registers; /* to_fetch_registers */ + gnu_ops.to_store_registers = gnu_store_registers; /* to_store_registers */ + gnu_ops.to_prepare_to_store = gnu_prepare_to_store; /* to_prepare_to_store */ + gnu_ops.deprecated_xfer_memory = gnu_xfer_memory; + gnu_ops.to_find_memory_regions = gnu_find_memory_regions; + gnu_ops.to_insert_breakpoint = memory_insert_breakpoint; + gnu_ops.to_remove_breakpoint = memory_remove_breakpoint; + gnu_ops.to_terminal_init = gnu_terminal_init_inferior; + gnu_ops.to_terminal_inferior = terminal_inferior; + gnu_ops.to_terminal_ours_for_output = terminal_ours_for_output; + gnu_ops.to_terminal_save_ours = terminal_save_ours; + gnu_ops.to_terminal_ours = terminal_ours; + gnu_ops.to_terminal_info = child_terminal_info; + gnu_ops.to_kill = gnu_kill_inferior; /* to_kill */ + gnu_ops.to_create_inferior = gnu_create_inferior; /* to_create_inferior */ + gnu_ops.to_mourn_inferior = gnu_mourn_inferior; /* to_mourn_inferior */ + gnu_ops.to_can_run = gnu_can_run; /* to_can_run */ + gnu_ops.to_thread_alive = gnu_thread_alive; /* to_thread_alive */ + gnu_ops.to_pid_to_str = gnu_pid_to_str; /* to_pid_to_str */ + gnu_ops.to_stop = gnu_stop; /* to_stop */ + gnu_ops.to_stratum = process_stratum; /* to_stratum */ + gnu_ops.to_has_all_memory = 1; /* to_has_all_memory */ + gnu_ops.to_has_memory = 1; /* to_has_memory */ + gnu_ops.to_has_stack = 1; /* to_has_stack */ + gnu_ops.to_has_registers = 1; /* to_has_registers */ + gnu_ops.to_has_execution = 1; /* to_has_execution */ + gnu_ops.to_magic = OPS_MAGIC; /* to_magic */ +} /* init_gnu_ops */ + /* User task commands. */ @@ -2555,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 @@ -2566,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); } @@ -2577,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."); + if (!inf->task) + error (_("No current process.")); return inf; } + static void set_task_pause_cmd (char *args, int from_tty) @@ -2639,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) @@ -2690,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. */ @@ -2701,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. */ @@ -2716,27 +2876,27 @@ steal_exc_port (struct proc *proc, mach_port_t name) proc->saved_exc_port = port; - if (! proc->exc_port) + if (!proc->exc_port) /* If PROC is a thread, we may not have set its exception port before. We can't use proc_steal_exc_port because it also sets saved_exc_port. */ { - proc->exc_port = proc->inf->event_port; - err = proc_set_exception_port (proc, proc->exc_port); - error ("Can't set exception port for %s: %s", - proc_string (proc), strerror (err)); + proc->exc_port = proc->inf->event_port; + err = proc_set_exception_port (proc, proc->exc_port); + error (_("Can't set exception port for %s: %s"), + proc_string (proc), safe_strerror (err)); } } - + static void set_task_exc_port_cmd (char *args, int from_tty) { struct inf *inf = cur_inf (); if (!args) - error ("No argument to \"set task exception-port\" command."); + error (_("No argument to \"set task exception-port\" command.")); steal_exc_port (inf->task, parse_and_eval_address (args)); } -static void +static void set_stopped_cmd (char *args, int from_tty) { cur_inf ()->stopped = _parse_bool_arg (args, "yes", "no", "set stopped"); @@ -2751,24 +2911,23 @@ show_stopped_cmd (char *args, int from_tty) inf->stopped ? "is" : "isn't"); } -static void +static void set_sig_thread_cmd (char *args, int from_tty) { - int tid; struct inf *inf = cur_inf (); - if (!args || (! isdigit (*args) && strcmp (args, "none") != 0)) - error ("Illegal argument to \"set signal-thread\" command.\n" - "Should be an integer thread ID, or `none'."); + if (!args || (!isdigit (*args) && strcmp (args, "none") != 0)) + error (_("Illegal argument to \"set signal-thread\" command.\n" + "Should be an integer thread ID, or `none'.")); if (strcmp (args, "none") == 0) inf->signal_thread = 0; else { - int tid = thread_id_to_pid (atoi (args)); + int tid = ptid_get_tid (thread_id_to_pid (atoi (args))); if (tid < 0) - error ("Thread ID %s not known. Use the \"info threads\" command to\n" - "see the IDs of currently known threads.", args); + error (_("Thread ID %s not known. Use the \"info threads\" command to\n" + "see the IDs of currently known threads."), args); inf->signal_thread = inf_tid_to_thread (inf, tid); } } @@ -2784,11 +2943,11 @@ show_sig_thread_cmd (char *args, int from_tty) else printf_unfiltered ("There is no signal thread.\n"); } + -static void +static void set_signals_cmd (char *args, int from_tty) { - int trace; struct inf *inf = cur_inf (); inf->want_signals = parse_bool_arg (args, "set signals"); @@ -2809,7 +2968,7 @@ show_signals_cmd (char *args, int from_tty) : (inf->want_signals ? "will be" : "won't be")); } -static void +static void set_exceptions_cmd (char *args, int from_tty) { struct inf *inf = cur_inf (); @@ -2817,7 +2976,7 @@ set_exceptions_cmd (char *args, int from_tty) if (inf->task && inf->want_exceptions != val) /* Make this take effect immediately in a running process. */ - /* XXX */; + /* XXX */ ; inf->want_exceptions = val; } @@ -2832,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 @@ -2865,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) @@ -2876,35 +3038,36 @@ 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); @@ -2915,151 +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 () +static void +add_task_commands (void) { - add_cmd ("pause", class_run, set_thread_default_pause_cmd, - "Set whether the new threads are suspended while gdb has control.\n" - "This property normally has no effect because the whole task is\n" - "suspended, however, that may be disabled with \"set task pause off\".\n" - "The default value is \"off\".", + add_cmd ("pause", class_run, set_thread_default_pause_cmd, _("\ +Set whether the new threads are suspended while gdb has control.\n\ +This property normally has no effect because the whole task is\n\ +suspended, however, that may be disabled with \"set task pause off\".\n\ +The default value is \"off\"."), &set_thread_default_cmd_list); - add_cmd ("pause", no_class, show_thread_default_pause_cmd, - "Show whether new threads are suspended while gdb has control.", + add_cmd ("pause", no_class, show_thread_default_pause_cmd, _("\ +Show whether new threads are suspended while gdb has control."), &show_thread_default_cmd_list); - add_cmd ("run", class_run, set_thread_default_run_cmd, - "Set whether new threads are allowed to run (once gdb has noticed them).", + + add_cmd ("run", class_run, set_thread_default_run_cmd, _("\ +Set whether new threads are allowed to run (once gdb has noticed them)."), &set_thread_default_cmd_list); - add_cmd ("run", no_class, show_thread_default_run_cmd, - "Show whether new threads are allowed to run (once gdb has noticed them).", + add_cmd ("run", no_class, show_thread_default_run_cmd, _("\ +Show whether new threads are allowed to run (once gdb has noticed them)."), &show_thread_default_cmd_list); + add_cmd ("detach-suspend-count", class_run, set_thread_default_detach_sc_cmd, - "Set the default detach-suspend-count value for new threads.", + _("Set the default detach-suspend-count value for new threads."), &set_thread_default_cmd_list); add_cmd ("detach-suspend-count", no_class, show_thread_default_detach_sc_cmd, - "Show the default detach-suspend-count value for new threads.", + _("Show the default detach-suspend-count value for new threads."), &show_thread_default_cmd_list); - add_cmd ("signals", class_run, set_signals_cmd, - "Set whether the inferior process's signals will be intercepted.\n" - "Mach exceptions (such as breakpoint traps) are not affected.", + add_cmd ("signals", class_run, set_signals_cmd, _("\ +Set whether the inferior process's signals will be intercepted.\n\ +Mach exceptions (such as breakpoint traps) are not affected."), &setlist); add_alias_cmd ("sigs", "signals", class_run, 1, &setlist); - add_cmd ("signals", no_class, show_signals_cmd, - "Show whether the inferior process's signals will be intercepted.", + add_cmd ("signals", no_class, show_signals_cmd, _("\ +Show whether the inferior process's signals will be intercepted."), &showlist); add_alias_cmd ("sigs", "signals", no_class, 1, &showlist); - add_cmd ("signal-thread", class_run, set_sig_thread_cmd, - "Set the thread that gdb thinks is the libc signal thread.\n" - "This thread is run when delivering a signal to a non-stopped process.", + add_cmd ("signal-thread", class_run, set_sig_thread_cmd, _("\ +Set the thread that gdb thinks is the libc signal thread.\n\ +This thread is run when delivering a signal to a non-stopped process."), &setlist); add_alias_cmd ("sigthread", "signal-thread", class_run, 1, &setlist); - add_cmd ("signal-thread", no_class, show_sig_thread_cmd, - "Set the thread that gdb thinks is the libc signal thread.", + add_cmd ("signal-thread", no_class, show_sig_thread_cmd, _("\ +Set the thread that gdb thinks is the libc signal thread."), &showlist); add_alias_cmd ("sigthread", "signal-thread", no_class, 1, &showlist); - add_cmd ("stopped", class_run, set_stopped_cmd, - "Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n" - "Stopped process will be continued by sending them a signal.", + add_cmd ("stopped", class_run, set_stopped_cmd, _("\ +Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\ +Stopped process will be continued by sending them a signal."), &setlist); - add_cmd ("stopped", no_class, show_signals_cmd, - "Show whether gdb thinks the inferior process is stopped as with SIGSTOP.", + add_cmd ("stopped", no_class, show_signals_cmd, _("\ +Show whether gdb thinks the inferior process is stopped as with SIGSTOP."), &showlist); - add_cmd ("exceptions", class_run, set_exceptions_cmd, - "Set whether exceptions in the inferior process will be trapped.\n" - "When exceptions are turned off, neither breakpoints nor single-stepping\n" - "will work.", + add_cmd ("exceptions", class_run, set_exceptions_cmd, _("\ +Set whether exceptions in the inferior process will be trapped.\n\ +When exceptions are turned off, neither breakpoints nor single-stepping\n\ +will work."), &setlist); /* Allow `set exc' despite conflict with `set exception-port'. */ add_alias_cmd ("exc", "exceptions", class_run, 1, &setlist); - add_cmd ("exceptions", no_class, show_exceptions_cmd, - "Show whether exceptions in the inferior process will be trapped.", + add_cmd ("exceptions", no_class, show_exceptions_cmd, _("\ +Show whether exceptions in the inferior process will be trapped."), &showlist); add_prefix_cmd ("task", no_class, set_task_cmd, - "Command prefix for setting task attributes.", + _("Command prefix for setting task attributes."), &set_task_cmd_list, "set task ", 0, &setlist); add_prefix_cmd ("task", no_class, show_task_cmd, - "Command prefix for showing task attributes.", + _("Command prefix for showing task attributes."), &show_task_cmd_list, "show task ", 0, &showlist); - add_cmd ("pause", class_run, set_task_pause_cmd, - "Set whether the task is suspended while gdb has control.\n" - "A value of \"on\" takes effect immediately, otherwise nothing\n" - "happens until the next time the program is continued.\n" - "When setting this to \"off\", \"set thread default pause on\"\n" - "can be used to pause individual threads by default instead.", + add_cmd ("pause", class_run, set_task_pause_cmd, _("\ +Set whether the task is suspended while gdb has control.\n\ +A value of \"on\" takes effect immediately, otherwise nothing happens\n\ +until the next time the program is continued.\n\ +When setting this to \"off\", \"set thread default pause on\" can be\n\ +used to pause individual threads by default instead."), &set_task_cmd_list); add_cmd ("pause", no_class, show_task_pause_cmd, - "Show whether the task is suspended while gdb has control.", + _("Show whether the task is suspended while gdb has control."), &show_task_cmd_list); + add_cmd ("detach-suspend-count", class_run, set_task_detach_sc_cmd, - "Set the suspend count will leave on the thread when detaching.", + _("Set the suspend count will leave on the thread when detaching."), &set_task_cmd_list); add_cmd ("detach-suspend-count", no_class, show_task_detach_sc_cmd, - "Show the suspend count will leave on the thread when detaching.", + _("Show the suspend count will leave on the thread when detaching."), &show_task_cmd_list); - add_cmd ("exception-port", no_class, set_task_exc_port_cmd, - "Set the task exception port to which we forward exceptions.\n" - "The argument should be the value of the send right in the task.", + add_cmd ("exception-port", no_class, set_task_exc_port_cmd, _("\ +Set the task exception port to which we forward exceptions.\n\ +The argument should be the value of the send right in the task."), &set_task_cmd_list); add_alias_cmd ("excp", "exception-port", no_class, 1, &set_task_cmd_list); - add_alias_cmd ("exc-port", "exception-port", no_class, 1, &set_task_cmd_list); + add_alias_cmd ("exc-port", "exception-port", no_class, 1, + &set_task_cmd_list); /* A convenient way of turning on all options require to noninvasively debug running tasks. */ - add_cmd ("noninvasive", no_class, set_noninvasive_cmd, - "Set task options so that we interfere as little as possible.\n" - "This is the same as setting `task pause', `exceptions', and" - "`signals' to the opposite value.", + add_cmd ("noninvasive", no_class, set_noninvasive_cmd, _("\ +Set task options so that we interfere as little as possible.\n\ +This is the same as setting `task pause', `exceptions', and\n\ +`signals' to the opposite value."), &setlist); /* Commands to show information about the task's ports. */ add_cmd ("send-rights", class_info, info_send_rights_cmd, - "Show information about the task's send rights", + _("Show information about the task's send rights"), &infolist); add_cmd ("receive-rights", class_info, info_recv_rights_cmd, - "Show information about the task's receive rights", + _("Show information about the task's receive rights"), &infolist); - add_cmd ("port-rights", class_info, info_send_rights_cmd, - "Show information about the task's port rights", + add_cmd ("port-rights", class_info, info_port_rights_cmd, + _("Show information about the task's port rights"), &infolist); add_cmd ("port-sets", class_info, info_port_sets_cmd, - "Show information about the task's port sets", + _("Show information about the task's port sets"), &infolist); add_cmd ("dead-names", class_info, info_dead_names_cmd, - "Show information about the task's dead names", + _("Show information about the task's dead names"), &infolist); add_info_alias ("ports", "port-rights", 1); add_info_alias ("port", "port-rights", 1); add_info_alias ("psets", "port-sets", 1); } - + static void set_thread_pause_cmd (char *args, int from_tty) { @@ -3104,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 @@ -3112,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); } @@ -3122,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)); } @@ -3147,90 +3322,97 @@ thread_takeover_sc_cmd (char *args, int from_tty) thread_basic_info_t info = &_info; mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT; error_t err = - thread_info (thread->port, THREAD_BASIC_INFO, (int *)&info, &info_len); + thread_info (thread->port, THREAD_BASIC_INFO, (int *) &info, &info_len); if (err) - error ("%s.", strerror (err)); + error (("%s."), safe_strerror (err)); thread->sc = info->suspend_count; if (from_tty) printf_unfiltered ("Suspend count was %d.\n", thread->sc); if (info != &_info) - vm_deallocate (mach_task_self (), (vm_address_t)info, info_len * sizeof (int)); + vm_deallocate (mach_task_self (), (vm_address_t) info, + info_len * sizeof (int)); } -add_thread_commands () + +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() ; + + 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 @@ -3241,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, + error_t ret; + + ret = vm_machine_attribute (gnu_current_inf->task->port, pc, amount, MATTR_CACHE, &flush); if (ret != KERN_SUCCESS) - warning ("Error flushing inferior's cache : %s", strerror (ret)); + warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret)); } -#endif FLUSH_INFERIOR_CACHE +#endif /* FLUSH_INFERIOR_CACHE */