X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgnu-nat.c;h=17b0a45e6f601abfbcc0c77e2ef34a09d71df6ff;hb=773fc868b7a1e33f29b9832a44aa1814f3d4c632;hp=24c0a009617fa73920ed3b05c935c1e3d019173b;hpb=2acceee2182a942e6a79a972009540990f4dfabf;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c index 24c0a00961..17b0a45e6f 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-2001, 2006-2012 Free Software Foundation, + Inc. This file is part of GDB. @@ -9,7 +10,7 @@ This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -18,38 +19,35 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. + along with this program. If not, see . */ -#include -#include +#include #include -#include -#include -#include #include +#include +#include +#include +#include "gdb_string.h" #include -/* We include this because we don't need the access macros and they conflict - with gdb's definitions (ick). This is very non standard! */ -#define _SYS_WAIT_H /* Inhibit warning from . */ -#include - #include -#include -#include #include #include +#include +#include #include -#include -#include +#include +#include #include #include +#include +/* Defined in , but we need forward declarations from + as well. */ +#undef _process_user_ +#include #include -#include #include #include @@ -60,11 +58,15 @@ #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" +#include "inf-child.h" #include "exc_request_S.h" #include "notify_S.h" @@ -86,9 +88,6 @@ int gnu_debug_flag = 0; /* Forward decls */ -extern struct target_ops gnu_ops; - -int inf_update_procs (struct inf *inf); struct inf *make_inf (); void inf_clear_wait (struct inf *inf); void inf_cleanup (struct inf *inf); @@ -99,12 +98,12 @@ void inf_validate_procs (struct inf *inf); void inf_steal_exc_ports (struct inf *inf); void inf_restore_exc_ports (struct inf *inf); struct proc *inf_tid_to_proc (struct inf *inf, int tid); -inline void inf_set_threads_resume_sc (struct inf *inf, - struct proc *run_thread, - int run_others); -inline int inf_set_threads_resume_sc_for_signal_thread (struct inf *inf); -inline void inf_suspend (struct inf *inf); -inline void inf_resume (struct inf *inf); +void inf_set_threads_resume_sc (struct inf *inf, + struct proc *run_thread, + int run_others); +int inf_set_threads_resume_sc_for_signal_thread (struct inf *inf); +void inf_suspend (struct inf *inf); +void inf_resume (struct inf *inf); void inf_set_step_thread (struct inf *inf, struct proc *proc); void inf_detach (struct inf *inf); void inf_attach (struct inf *inf, int pid); @@ -113,10 +112,10 @@ void inf_continue (struct inf *inf); #define inf_debug(_inf, msg, args...) \ do { struct inf *__inf = (_inf); \ - debug ("{inf %d %p}: " msg, __inf->pid, __inf , ##args); } while (0) + debug ("{inf %d %s}: " msg, __inf->pid, \ + host_address_to_string (__inf) , ##args); } while (0) void proc_abort (struct proc *proc, int force); -thread_state_t proc_get_state (struct proc *proc, int force); struct proc *make_proc (struct inf *inf, mach_port_t port, int tid); struct proc *_proc_free (struct proc *proc); int proc_update_sc (struct proc *proc); @@ -126,7 +125,6 @@ static mach_port_t _proc_get_exc_port (struct proc *proc); void proc_steal_exc_port (struct proc *proc, mach_port_t exc_port); void proc_restore_exc_port (struct proc *proc); int proc_trace (struct proc *proc, int set); -char *proc_string (struct proc *proc); /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound to INF's msg port and task port respectively. If it has no msg port, @@ -148,22 +146,21 @@ 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 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. */ + 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. */ +/* 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 exc_state exc; /* The exception that caused us to return. */ struct proc *thread; /* The thread in question. */ int suppress; /* Something trivial happened. */ }; @@ -176,17 +173,18 @@ struct inf 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. */ + /* 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. */ - /* One thread proc in INF may be in `single-stepping mode'. This is it. */ + /* 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. */ @@ -218,7 +216,7 @@ struct inf 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 @@ -251,6 +249,7 @@ __proc_pid (struct proc *proc) { return proc->inf->pid; } + /* Update PROC's real suspend count to match it's desired one. Returns true if we think PROC is now in a runnable state. */ @@ -265,29 +264,36 @@ proc_update_sc (struct proc *proc) proc_debug (proc, "sc: %d --> %d", proc->cur_sc, proc->sc); if (proc->sc == 0 && proc->state_changed) - /* Since PROC may start running, we must write back any state changes. */ + /* Since PROC may start running, we must write back any state changes. */ { - assert (proc_is_thread (proc)); + gdb_assert (proc_is_thread (proc)); proc_debug (proc, "storing back changed thread state"); err = thread_set_state (proc->port, THREAD_STATE_FLAVOR, - (thread_state_t) & proc->state, THREAD_STATE_SIZE); + (thread_state_t) &proc->state, THREAD_STATE_SIZE); if (!err) proc->state_changed = 0; } if (delta > 0) - while (delta-- > 0 && !err) - if (proc_is_task (proc)) - err = task_suspend (proc->port); - else - err = thread_suspend (proc->port); + { + while (delta-- > 0 && !err) + { + if (proc_is_task (proc)) + err = task_suspend (proc->port); + else + err = thread_suspend (proc->port); + } + } else - while (delta++ < 0 && !err) - if (proc_is_task (proc)) - err = task_resume (proc->port); - else - err = thread_resume (proc->port); - + { + while (delta++ < 0 && !err) + { + if (proc_is_task (proc)) + err = task_resume (proc->port); + else + err = thread_resume (proc->port); + } + } if (!err) proc->cur_sc = proc->sc; @@ -296,7 +302,7 @@ proc_update_sc (struct proc *proc) proc_debug (proc, "is %s", err ? "dead" : running ? "running" : "suspended"); if (err) - proc_debug (proc, "err = %s", strerror (err)); + proc_debug (proc, "err = %s", safe_strerror (err)); if (running) { @@ -307,6 +313,7 @@ proc_update_sc (struct proc *proc) return running; } + /* Thread_abort is called on PROC if needed. PROC must be a thread proc. If PROC is deemed `precious', then nothing is done unless FORCE is true. @@ -315,7 +322,7 @@ proc_update_sc (struct proc *proc) void proc_abort (struct proc *proc, int force) { - assert (proc_is_thread (proc)); + gdb_assert (proc_is_thread (proc)); if (!proc->aborted) { @@ -327,7 +334,7 @@ proc_abort (struct proc *proc, int force) proc->sc = 1; inf_update_suspends (proc->inf); running = 0; - warning ("Stopped %s.", proc_string (proc)); + warning (_("Stopped %s."), proc_string (proc)); } else if (proc == inf->wait.thread && inf->wait.exc.reply && !force) /* An exception is pending on PROC, which don't mess with. */ @@ -367,8 +374,9 @@ proc_get_state (struct proc *proc, int will_modify) { mach_msg_type_number_t state_size = THREAD_STATE_SIZE; error_t err = - thread_get_state (proc->port, THREAD_STATE_FLAVOR, - (thread_state_t) & proc->state, &state_size); + thread_get_state (proc->port, THREAD_STATE_FLAVOR, + (thread_state_t) &proc->state, &state_size); + proc_debug (proc, "getting thread state"); proc->state_valid = !err; } @@ -377,11 +385,12 @@ proc_get_state (struct proc *proc, int will_modify) { if (will_modify) proc->state_changed = 1; - return (thread_state_t) & proc->state; + return (thread_state_t) &proc->state; } else return 0; } + /* Set PORT to PROC's exception port. */ error_t @@ -425,8 +434,9 @@ _proc_get_exc_port (struct proc *proc) return exc_port; } -/* Replace PROC's exception port with EXC_PORT, unless it's already been - done. Stash away any existing exception port so we can restore it later. */ +/* Replace PROC's exception port with EXC_PORT, unless it's already + been done. Stash away any existing exception port so we can + restore it later. */ void proc_steal_exc_port (struct proc *proc, mach_port_t exc_port) { @@ -434,7 +444,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); @@ -450,7 +460,7 @@ proc_steal_exc_port (struct proc *proc, mach_port_t exc_port) mach_port_deallocate (mach_task_self (), cur_exc_port); } else - /* Keep a copy of PROC's old exception port so it can be restored. */ + /* Keep a copy of PROC's old exception port so it can be restored. */ { if (proc->saved_exc_port) mach_port_deallocate (mach_task_self (), proc->saved_exc_port); @@ -462,8 +472,8 @@ proc_steal_exc_port (struct proc *proc, mach_port_t exc_port) if (!err) proc->exc_port = exc_port; else - warning ("Error setting exception port for %s: %s", - proc_string (proc), strerror (err)); + warning (_("Error setting exception port for %s: %s"), + proc_string (proc), safe_strerror (err)); } } @@ -492,10 +502,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. */ @@ -505,14 +516,14 @@ proc_trace (struct proc *proc, int set) thread_state_t state = proc_get_state (proc, 1); if (!state) - return 0; /* the thread must be dead. */ + 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); @@ -522,6 +533,7 @@ proc_trace (struct proc *proc, int set) return 1; } + /* A variable from which to assign new TIDs. */ static int next_thread_id = 1; @@ -533,7 +545,7 @@ make_proc (struct inf *inf, mach_port_t port, int tid) { error_t err; mach_port_t prev_port = MACH_PORT_NULL; - struct proc *proc = malloc (sizeof (struct proc)); + struct proc *proc = xmalloc (sizeof (struct proc)); proc->port = port; proc->tid = tid; @@ -567,8 +579,8 @@ make_proc (struct inf *inf, mach_port_t port, int tid) MACH_MSG_TYPE_MAKE_SEND_ONCE, &prev_port); if (err) - warning ("Couldn't request notification for port %d: %s", - port, strerror (err)); + warning (_("Couldn't request notification for port %d: %s"), + port, safe_strerror (err)); else { proc_debug (proc, "notifications to: %d", inf->event_port); @@ -577,12 +589,15 @@ make_proc (struct inf *inf, mach_port_t port, int tid) } if (inf->want_exceptions) - if (proc_is_task (proc)) - /* Make the task exception port point to us. */ - proc_steal_exc_port (proc, inf->event_port); - else - /* Just clear thread exception ports -- they default to the task one. */ - proc_steal_exc_port (proc, MACH_PORT_NULL); + { + if (proc_is_task (proc)) + /* Make the task exception port point to us. */ + proc_steal_exc_port (proc, inf->event_port); + else + /* Just clear thread exception ports -- they default to the + task one. */ + proc_steal_exc_port (proc, MACH_PORT_NULL); + } return proc; } @@ -619,17 +634,15 @@ _proc_free (struct proc *proc) mach_port_deallocate (mach_task_self (), proc->port); } - free (proc); + xfree (proc); return next; } + struct inf * -make_inf () +make_inf (void) { - struct inf *inf = malloc (sizeof (struct inf)); - - if (!inf) - return 0; + struct inf *inf = xmalloc (sizeof (struct inf)); inf->task = 0; inf->threads = 0; @@ -659,7 +672,7 @@ make_inf () return inf; } -/* clear INF's target wait status. */ +/* Clear INF's target wait status. */ void inf_clear_wait (struct inf *inf) { @@ -678,6 +691,7 @@ inf_clear_wait (struct inf *inf) inf->wait.exc.reply = MACH_PORT_NULL; } } + void inf_cleanup (struct inf *inf) @@ -715,15 +729,16 @@ inf_startup (struct inf *inf, int pid) err = mach_port_allocate (mach_task_self (), MACH_PORT_RIGHT_RECEIVE, &inf->event_port); if (err) - error ("Error allocating event port: %s", strerror (err)); + error (_("Error allocating event port: %s"), safe_strerror (err)); /* Make a send right for it, so we can easily copy it for other people. */ mach_port_insert_right (mach_task_self (), inf->event_port, inf->event_port, MACH_MSG_TYPE_MAKE_SEND); inf_set_pid (inf, pid); } + -/* close current process, if any, and attach INF to process PORT */ +/* Close current process, if any, and attach INF to process PORT. */ void inf_set_pid (struct inf *inf, pid_t pid) { @@ -737,8 +752,10 @@ inf_set_pid (struct inf *inf, pid_t pid) else { error_t err = proc_pid2task (proc_server, pid, &task_port); + if (err) - error ("Error getting task for pid %d: %s", pid, strerror (err)); + error (_("Error getting task for pid %d: %s"), + pid, safe_strerror (err)); } inf_debug (inf, "setting task: %d", task_port); @@ -749,8 +766,8 @@ inf_set_pid (struct inf *inf, pid_t pid) if (task && task->port != task_port) { inf->task = 0; - inf_validate_procs (inf); /* Trash all the threads. */ - _proc_free (task); /* And the task. */ + inf_validate_procs (inf); /* Trash all the threads. */ + _proc_free (task); /* And the task. */ } if (task_port != MACH_PORT_NULL) @@ -763,11 +780,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 @@ -782,8 +801,8 @@ inf_validate_procinfo (struct inf *inf) mach_msg_type_number_t pi_len = 0; int info_flags = 0; error_t err = - proc_getprocinfo (proc_server, inf->pid, &info_flags, - (procinfo_t *) & pi, &pi_len, &noise, &noise_len); + proc_getprocinfo (proc_server, inf->pid, &info_flags, + (procinfo_t *) &pi, &pi_len, &noise, &noise_len); if (!err) { @@ -797,77 +816,109 @@ inf_validate_procinfo (struct inf *inf) } } -/* Validates INF's task suspend count. If it's higher than we expect, verify - with the user before `stealing' the extra count. */ +/* Validates INF's task suspend count. If it's higher than we expect, + verify with the user before `stealing' the extra count. */ static void inf_validate_task_sc (struct inf *inf) { - struct task_basic_info info; - mach_msg_type_number_t info_len = TASK_BASIC_INFO_COUNT; - error_t err = - task_info (inf->task->port, TASK_BASIC_INFO, (task_info_t) & info, &info_len); + char *noise; + mach_msg_type_number_t noise_len = 0; + struct procinfo *pi; + mach_msg_type_number_t pi_len = 0; + int info_flags = PI_FETCH_TASKINFO; + int suspend_count = -1; + error_t err; + retry: + err = proc_getprocinfo (proc_server, inf->pid, &info_flags, + (procinfo_t *) &pi, &pi_len, &noise, &noise_len); if (err) - inf->task->dead = 1; /* oh well */ - else if (inf->task->cur_sc < info.suspend_count) + { + inf->task->dead = 1; /* oh well */ + return; + } + + if (inf->task->cur_sc < pi->taskinfo.suspend_count && suspend_count == -1) + { + /* The proc server might have suspended the task while stopping + it. This happens when the task is handling a traced signal. + Refetch the suspend count. The proc server should be + finished stopping the task by now. */ + suspend_count = pi->taskinfo.suspend_count; + goto retry; + } + + suspend_count = pi->taskinfo.suspend_count; + + vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len); + if (noise_len > 0) + vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len); + + if (inf->task->cur_sc < suspend_count) { int abort; target_terminal_ours (); /* Allow I/O. */ - abort = - !query ("Pid %d has an additional task suspend count of %d; clear it? ", - inf->pid, info.suspend_count - inf->task->cur_sc); + abort = !query (_("Pid %d has an additional task suspend count of %d;" + " clear it? "), inf->pid, + suspend_count - inf->task->cur_sc); target_terminal_inferior (); /* Give it back to the child. */ if (abort) - error ("Additional task suspend count left untouched."); + error (_("Additional task suspend count left untouched.")); - inf->task->cur_sc = info.suspend_count; + inf->task->cur_sc = suspend_count; } } -/* Turns tracing for INF on or off, depending on ON, unless it already is. - If INF is running, the resume_sc count of INF's threads will be modified, - and the signal thread will briefly be run to change the trace state. */ +/* Turns tracing for INF on or off, depending on ON, unless it already + is. If INF is running, the resume_sc count of INF's threads will + be modified, and the signal thread will briefly be run to change + the trace state. */ void inf_set_traced (struct inf *inf, int on) { - if (on != inf->traced) - if (inf->task && !inf->task->dead) - /* Make it take effect immediately. */ - { - sigset_t mask = on ? ~(sigset_t) 0 : 0; - error_t err = + if (on == inf->traced) + return; + + if (inf->task && !inf->task->dead) + /* Make it take effect immediately. */ + { + sigset_t mask = on ? ~(sigset_t) 0 : 0; + error_t err = INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport, - INIT_TRACEMASK, mask)); - if (err == EIEIO) - { - if (on) - warning ("Can't modify tracing state for pid %d: No signal thread", - inf->pid); - inf->traced = on; - } - else if (err) - warning ("Can't modify tracing state for pid %d: %s", - inf->pid, strerror (err)); - else + INIT_TRACEMASK, mask)); + + if (err == EIEIO) + { + if (on) + warning (_("Can't modify tracing state for pid %d: %s"), + inf->pid, "No signal thread"); inf->traced = on; - } - else - inf->traced = on; + } + else if (err) + warning (_("Can't modify tracing state for pid %d: %s"), + inf->pid, safe_strerror (err)); + else + inf->traced = on; + } + else + inf->traced = on; } + -/* Makes all the real suspend count deltas of all the procs in INF match the - desired values. Careful to always do thread/task suspend counts in the - safe order. Returns true if at least one thread is thought to be running. */ +/* Makes all the real suspend count deltas of all the procs in INF + match the desired values. Careful to always do thread/task suspend + counts in the safe order. Returns true if at least one thread is + thought to be running. */ int inf_update_suspends (struct inf *inf) { struct proc *task = inf->task; + /* We don't have to update INF->threads even though we're iterating over it because we'll change a thread only if it already has an existing proc entry. */ - inf_debug (inf, "updating suspend counts"); if (task) @@ -908,6 +959,7 @@ inf_update_suspends (struct inf *inf) return 0; } + /* Converts a GDB pid to a struct proc. */ struct proc * @@ -928,6 +980,7 @@ struct proc * inf_port_to_thread (struct inf *inf, mach_port_t port) { struct proc *thread = inf->threads; + while (thread) if (thread->port == port) return thread; @@ -935,14 +988,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 @@ -954,6 +1007,7 @@ inf_validate_procs (struct inf *inf) if (task) { error_t err = task_threads (task->port, &threads, &num_threads); + inf_debug (inf, "fetching threads"); if (err) /* TASK must be dead. */ @@ -970,19 +1024,20 @@ 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. */ struct proc *last = 0; - /* The current thread we're considering. */ + /* The current thread we're considering. */ struct proc *thread = inf->threads; - bzero (matched, sizeof (matched)); + memset (matched, 0, sizeof (matched)); while (thread) { - unsigned left; + mach_msg_type_number_t left; for (i = search_start, left = num_threads; left; i++, left--) { @@ -1004,31 +1059,55 @@ inf_validate_procs (struct inf *inf) proc_debug (thread, "died!"); thread->port = MACH_PORT_NULL; thread = _proc_free (thread); /* THREAD is dead. */ - (last ? last->next : inf->threads) = thread; + if (last) + last->next = thread; + else + inf->threads = thread; } } for (i = 0; i < num_threads; i++) - if (matched[i]) - /* Throw away the duplicate send right. */ - mach_port_deallocate (mach_task_self (), threads[i]); - else - /* THREADS[I] is a thread we don't know about yet! */ - { - thread = make_proc (inf, threads[i], next_thread_id++); - (last ? last->next : inf->threads) = thread; - last = thread; - proc_debug (thread, "new thread: %d", threads[i]); - add_thread (thread->tid); /* Tell GDB's generic thread code. */ - } + { + if (matched[i]) + /* Throw away the duplicate send right. */ + mach_port_deallocate (mach_task_self (), threads[i]); + else + /* THREADS[I] is a thread we don't know about yet! */ + { + ptid_t ptid; + + thread = make_proc (inf, threads[i], next_thread_id++); + if (last) + last->next = thread; + else + inf->threads = thread; + last = thread; + proc_debug (thread, "new thread: %d", threads[i]); + + ptid = ptid_build (inf->pid, 0, thread->tid); + + /* Tell GDB's generic thread code. */ + + if (ptid_equal (inferior_ptid, pid_to_ptid (inf->pid))) + /* This is the first time we're hearing about thread + ids, after a fork-child. */ + thread_change_ptid (inferior_ptid, ptid); + else if (inf->pending_execs != 0) + /* This is a shell thread. */ + add_thread_silent (ptid); + else + add_thread (ptid); + } + } vm_deallocate (mach_task_self (), - (vm_address_t) threads, (num_threads * sizeof (thread_t))); + (vm_address_t) threads, (num_threads * sizeof (thread_t))); } } + /* Makes sure that INF's thread list is synced with the actual process. */ -inline int +int inf_update_procs (struct inf *inf) { if (!inf->task) @@ -1041,11 +1120,12 @@ inf_update_procs (struct inf *inf) /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0, and others are set to their run_sc if RUN_OTHERS is true, and otherwise their pause_sc. */ -inline void +void inf_set_threads_resume_sc (struct inf *inf, struct proc *run_thread, int run_others) { struct proc *thread; + inf_update_procs (inf); for (thread = inf->threads; thread; thread = thread->next) if (thread == run_thread) @@ -1055,10 +1135,11 @@ inf_set_threads_resume_sc (struct inf *inf, else thread->resume_sc = thread->pause_sc; } + /* Cause INF to continue execution immediately; individual threads may still be suspended (but their suspend counts will be updated). */ -inline void +void inf_resume (struct inf *inf) { struct proc *thread; @@ -1083,7 +1164,7 @@ inf_resume (struct inf *inf) /* Cause INF to stop execution immediately; individual threads may still be running. */ -inline void +void inf_suspend (struct inf *inf) { struct proc *thread; @@ -1098,14 +1179,15 @@ inf_suspend (struct inf *inf) inf_update_suspends (inf); } + -/* INF has one thread PROC that is in single-stepping mode. This function - changes it to be PROC, changing any old step_thread to be a normal one. A - PROC of 0 clears any existing value. */ +/* INF has one thread PROC that is in single-stepping mode. This + function changes it to be PROC, changing any old step_thread to be + a normal one. A PROC of 0 clears any existing value. */ void inf_set_step_thread (struct inf *inf, struct proc *thread) { - assert (!thread || proc_is_thread (thread)); + gdb_assert (!thread || proc_is_thread (thread)); if (thread) inf_debug (inf, "setting step thread: %d/%d", inf->pid, thread->tid); @@ -1123,11 +1205,12 @@ inf_set_step_thread (struct inf *inf, struct proc *thread) inf->step_thread = 0; } } + /* Set up the thread resume_sc's so that only the signal thread is running (plus whatever other thread are set to always run). Returns true if we did so, or false if we can't find a signal thread. */ -inline int +int inf_set_threads_resume_sc_for_signal_thread (struct inf *inf) { if (inf->signal_thread) @@ -1146,6 +1229,7 @@ inf_update_signal_thread (struct inf *inf) the signal thread. */ inf->signal_thread = inf->threads ? inf->threads->next : 0; } + /* Detachs from INF's inferior task, letting it run once again... */ void @@ -1188,8 +1272,8 @@ inf_detach (struct inf *inf) inf_cleanup (inf); } -/* Attaches INF to the process with process id PID, returning it in a suspended - state suitable for debugging. */ +/* Attaches INF to the process with process id PID, returning it in a + suspended state suitable for debugging. */ void inf_attach (struct inf *inf, int pid) { @@ -1200,8 +1284,9 @@ inf_attach (struct inf *inf, int pid) inf_startup (inf, pid); } + -/* Makes sure that we've got our exception ports entrenched in the process. */ +/* Makes sure that we've got our exception ports entrenched in the process. */ void inf_steal_exc_ports (struct inf *inf) { @@ -1209,7 +1294,7 @@ inf_steal_exc_ports (struct inf *inf) inf_debug (inf, "stealing exception ports"); - inf_set_step_thread (inf, 0); /* The step thread is special. */ + inf_set_step_thread (inf, 0); /* The step thread is special. */ proc_steal_exc_port (inf->task, inf->event_port); for (thread = inf->threads; thread; thread = thread->next) @@ -1224,12 +1309,13 @@ inf_restore_exc_ports (struct inf *inf) inf_debug (inf, "restoring exception ports"); - inf_set_step_thread (inf, 0); /* The step thread is special. */ + inf_set_step_thread (inf, 0); /* The step thread is special. */ proc_restore_exc_port (inf->task); 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 @@ -1248,6 +1334,7 @@ inf_signal (struct inf *inf, enum target_signal sig) extremely large)! */ { struct inf_wait *w = &inf->wait; + if (w->status.kind == TARGET_WAITKIND_STOPPED && w->status.value.sig == sig && w->thread && !w->thread->aborted) @@ -1258,6 +1345,7 @@ inf_signal (struct inf *inf, enum target_signal sig) i.e., we pretend it's global. */ { struct exc_state *e = &w->exc; + inf_debug (inf, "passing through exception:" " task = %d, thread = %d, exc = %d" ", code = %d, subcode = %d", @@ -1270,7 +1358,7 @@ inf_signal (struct inf *inf, enum target_signal sig) e->exception, e->code, e->subcode); } else - error ("Can't forward spontaneous exception (%s).", NAME); + error (_("Can't forward spontaneous exception (%s)."), NAME); } else /* A Unix signal. */ @@ -1298,22 +1386,25 @@ inf_signal (struct inf *inf, enum target_signal sig) 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. */ + happens. */ { - inf_debug (inf, "sending %s to unstopped process (so resuming signal thread)", NAME); + inf_debug (inf, "sending %s to unstopped process" + " (so resuming signal thread)", NAME); err = - INF_RESUME_MSGPORT_RPC (inf, msg_sig_post_untraced (msgport, - host_sig, 0, refport)); + INF_RESUME_MSGPORT_RPC (inf, + msg_sig_post_untraced (msgport, host_sig, + 0, refport)); } if (err == EIEIO) - /* Can't do too much... */ - warning ("Can't deliver signal %s: No signal thread.", NAME); + /* Can't do too much... */ + warning (_("Can't deliver signal %s: No signal thread."), NAME); else if (err) - warning ("Delivering signal %s: %s", NAME, strerror (err)); + warning (_("Delivering signal %s: %s"), NAME, safe_strerror (err)); #undef NAME } + /* Continue INF without delivering a signal. This is meant to be used when INF does not have a message port. */ @@ -1340,32 +1431,38 @@ inf_continue (struct inf *inf) } if (err) - warning ("Can't continue process: %s", strerror (err)); + warning (_("Can't continue process: %s"), safe_strerror (err)); } + /* The inferior used for all gdb target ops. */ -struct inf *current_inferior = 0; +struct inf *gnu_current_inf = 0; /* The inferior being waited for by gnu_wait. Since GDB is decidely not multi-threaded, we don't bother to lock this. */ struct inf *waiting_inf; -/* Wait for something to happen in the inferior, returning what in STATUS. */ -static int -gnu_wait (int tid, struct target_waitstatus *status) +/* Wait for something to happen in the inferior, returning what in STATUS. */ +static ptid_t +gnu_wait (struct target_ops *ops, + ptid_t ptid, struct target_waitstatus *status, int options) { struct msg { mach_msg_header_t hdr; mach_msg_type_t type; int data[8000]; - } - msg; + } msg; error_t err; struct proc *thread; - struct inf *inf = current_inferior; + struct inf *inf = gnu_current_inf; + + extern int exc_server (mach_msg_header_t *, mach_msg_header_t *); + extern int msg_reply_server (mach_msg_header_t *, mach_msg_header_t *); + extern int notify_server (mach_msg_header_t *, mach_msg_header_t *); + extern int process_reply_server (mach_msg_header_t *, mach_msg_header_t *); - assert (inf->task); + gdb_assert (inf->task); if (!inf->threads && !inf->pending_execs) /* No threads! Assume that maybe some outside agency is frobbing our @@ -1374,12 +1471,12 @@ gnu_wait (int tid, struct target_waitstatus *status) { inf_validate_procs (inf); if (!inf->threads && !inf->task->dead) - error ("There are no threads; try again later."); + error (_("There are no threads; try again later.")); } waiting_inf = inf; - inf_debug (inf, "waiting for: %d", tid); + inf_debug (inf, "waiting for: %s", target_pid_to_str (ptid)); rewait: if (proc_wait_pid != inf->pid && !inf->no_wait) @@ -1389,7 +1486,7 @@ rewait: if (proc_wait_pid) /* The proc server is single-threaded, and only allows a single - outstanding wait request, so we have to cancel the previous one. */ + outstanding wait request, so we have to cancel the previous one. */ { inf_debug (inf, "cancelling previous wait on pid %d", proc_wait_pid); interrupt_operation (proc_server, 0); @@ -1398,15 +1495,16 @@ rewait: err = proc_wait_request (proc_server, inf->event_port, inf->pid, WUNTRACED); if (err) - warning ("wait request failed: %s", strerror (err)); + warning (_("wait request failed: %s"), safe_strerror (err)); else { inf_debug (inf, "waits pending: %d", proc_waits_pending); proc_wait_pid = inf->pid; - /* Even if proc_waits_pending was > 0 before, we still won't get - any other replies, because it was either from a different INF, - or a different process attached to INF -- and the event port, - which is the wait reply port, changes when you switch processes. */ + /* Even if proc_waits_pending was > 0 before, we still won't + get any other replies, because it was either from a + different INF, or a different process attached to INF -- + and the event port, which is the wait reply port, changes + when you switch processes. */ proc_waits_pending = 1; } } @@ -1433,7 +1531,7 @@ rewait: if (err == EMACH_RCV_INTERRUPTED) inf_debug (inf, "interrupted"); else if (err) - error ("Couldn't wait for an event: %s", strerror (err)); + error (_("Couldn't wait for an event: %s"), safe_strerror (err)); else { struct @@ -1453,11 +1551,11 @@ rewait: && !process_reply_server (&msg.hdr, &reply.hdr) && !msg_reply_server (&msg.hdr, &reply.hdr)) /* Whatever it is, it's something strange. */ - error ("Got a strange event, msg id = %d.", msg.hdr.msgh_id); + error (_("Got a strange event, msg id = %d."), msg.hdr.msgh_id); if (reply.err) - error ("Handling event, msgid = %d: %s", - msg.hdr.msgh_id, strerror (reply.err)); + error (_("Handling event, msgid = %d: %s"), + msg.hdr.msgh_id, safe_strerror (reply.err)); } if (inf->pending_execs) @@ -1483,9 +1581,11 @@ rewait: if (--inf->pending_execs == 0) /* We're done! */ { -#if 0 /* do we need this? */ - prune_threads (1); /* Get rid of the old shell threads */ - renumber_threads (0); /* Give our threads reasonable names. */ +#if 0 /* do we need this? */ + prune_threads (1); /* Get rid of the old shell + threads. */ + renumber_threads (0); /* Give our threads reasonable + names. */ #endif } inf_debug (inf, "pending exec completed, pending_execs => %d", @@ -1510,30 +1610,40 @@ rewait: } /* Pass back out our results. */ - bcopy (&inf->wait.status, status, sizeof (*status)); + memcpy (status, &inf->wait.status, sizeof (*status)); thread = inf->wait.thread; if (thread) - tid = thread->tid; + ptid = ptid_build (inf->pid, 0, thread->tid); + else if (ptid_equal (ptid, minus_one_ptid)) + thread = inf_tid_to_thread (inf, -1); else - thread = inf_tid_to_thread (inf, tid); + thread = inf_tid_to_thread (inf, ptid_get_tid (ptid)); if (!thread || thread->port == MACH_PORT_NULL) - /* TID is dead; try and find a new thread. */ - if (inf_update_procs (inf) && inf->threads) - tid = inf->threads->tid; /* The first available thread. */ - else - tid = inferior_pid; /* let wait_for_inferior handle exit case */ + { + /* TID is dead; try and find a new thread. */ + if (inf_update_procs (inf) && inf->threads) + ptid = ptid_build (inf->pid, 0, inf->threads->tid); /* The first + available + thread. */ + else + ptid = inferior_ptid; /* let wait_for_inferior handle exit case */ + } - if (thread && tid >= 0 && status->kind != TARGET_WAITKIND_SPURIOUS + if (thread + && !ptid_equal (ptid, minus_one_ptid) + && status->kind != TARGET_WAITKIND_SPURIOUS && inf->pause_sc == 0 && thread->pause_sc == 0) - /* If something actually happened to THREAD, make sure we suspend it. */ + /* If something actually happened to THREAD, make sure we + suspend it. */ { thread->sc = 1; inf_update_suspends (inf); } - inf_debug (inf, "returning tid = %d, status = %s (%d)", tid, + inf_debug (inf, "returning ptid = %s, status = %s (%d)", + target_pid_to_str (ptid), status->kind == TARGET_WAITKIND_EXITED ? "EXITED" : status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED" : status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED" @@ -1542,8 +1652,9 @@ rewait: : "?", status->value.integer); - return tid; + return ptid; } + /* The rpc handler called by exc_server. */ error_t @@ -1556,7 +1667,7 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port, inf_debug (waiting_inf, "thread = %d, task = %d, exc = %d, code = %d, subcode = %d", - thread_port, task_port, exception, code); + thread_port, task_port, exception, code, subcode); if (!thread) /* We don't know about thread? */ @@ -1591,19 +1702,19 @@ 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. */ + /* Add a reference to the exception handler. */ mach_port_mod_refs (mach_task_self (), inf->wait.exc.handler, MACH_PORT_RIGHT_SEND, 1); @@ -1613,8 +1724,9 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port, inf->wait.exc.subcode = subcode; inf->wait.exc.reply = reply_port; - /* Exceptions are encoded in the signal space by putting them after - _NSIG; this assumes they're positive (and not extremely large)! */ + /* Exceptions are encoded in the signal space by putting + them after _NSIG; this assumes they're positive (and not + extremely large)! */ inf->wait.status.value.sig = target_signal_from_host (_NSIG + exception); } @@ -1628,13 +1740,15 @@ 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; } @@ -1663,55 +1777,62 @@ do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port) else { struct proc *thread = inf_port_to_thread (inf, dead_port); + if (thread) { proc_debug (thread, "is dead"); 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. */ @@ -1722,7 +1843,7 @@ S_proc_wait_reply (mach_port_t reply, error_t err, struct inf *inf = waiting_inf; inf_debug (inf, "err = %s, pid = %d, status = 0x%x, sigcode = %d", - err ? strerror (err) : "0", pid, status, sigcode); + err ? safe_strerror (err) : "0", pid, status, sigcode); if (err && proc_wait_pid && (!inf->task || !inf->task->port)) /* Ack. The task has died, but the task-died notification code didn't @@ -1743,7 +1864,8 @@ S_proc_wait_reply (mach_port_t reply, error_t err, { if (err != EINTR) { - warning ("Can't wait for pid %d: %s", inf->pid, strerror (err)); + warning (_("Can't wait for pid %d: %s"), + inf->pid, safe_strerror (err)); inf->no_wait = 1; /* Since we can't see the inferior's signals, don't trap them. */ @@ -1771,14 +1893,15 @@ error_t S_proc_setmsgport_reply (mach_port_t reply, error_t err, mach_port_t old_msg_port) { - return ill_rpc (__FUNCTION__); + return ill_rpc ("S_proc_setmsgport_reply"); } error_t S_proc_getmsgport_reply (mach_port_t reply, error_t err, mach_port_t msg_port) { - return ill_rpc (__FUNCTION__); + return ill_rpc ("S_proc_getmsgport_reply"); } + /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */ @@ -1798,7 +1921,7 @@ S_msg_sig_post_untraced_reply (mach_port_t reply, error_t err) inf->wait.status.value.sig = TARGET_SIGNAL_0; } else if (err) - warning ("Signal delivery failed: %s", strerror (err)); + warning (_("Signal delivery failed: %s"), safe_strerror (err)); if (err) /* We only get this reply when we've posted a signal to a process which we @@ -1815,8 +1938,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 @@ -1824,13 +1948,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. @@ -1846,15 +1971,18 @@ 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). - */ + in multiple events returned by wait). */ + static void -gnu_resume (int tid, int step, enum target_signal sig) +gnu_resume (struct target_ops *ops, + ptid_t ptid, int step, enum target_signal sig) { struct proc *step_thread = 0; - struct inf *inf = current_inferior; + int resume_all; + struct inf *inf = gnu_current_inf; - inf_debug (inf, "tid = %d, step = %d, sig = %d", tid, step, sig); + inf_debug (inf, "ptid = %s, step = %d, sig = %d", + target_pid_to_str (ptid), step, sig); inf_validate_procinfo (inf); @@ -1870,42 +1998,48 @@ 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)); } if (port_msgs_queued (inf->event_port)) /* If there are still messages in our event queue, don't bother resuming - the process, as we're just going to stop it right away anyway. */ + the process, as we're just going to stop it right away anyway. */ return; inf_update_procs (inf); - if (tid < 0) + /* A specific PTID means `step only this process id'. */ + resume_all = ptid_equal (ptid, minus_one_ptid); + + if (resume_all) /* Allow all threads to run, except perhaps single-stepping one. */ { - inf_debug (inf, "running all threads; tid = %d", inferior_pid); - tid = inferior_pid; /* What to step. */ + inf_debug (inf, "running all threads; tid = %d", PIDGET (inferior_ptid)); + ptid = inferior_ptid; /* What to step. */ inf_set_threads_resume_sc (inf, 0, 1); } else /* Just allow a single thread to run. */ { - struct proc *thread = inf_tid_to_thread (inf, tid); + struct proc *thread = inf_tid_to_thread (inf, ptid_get_tid (ptid)); + if (!thread) - error ("Can't run single thread id %d: no such thread!"); - inf_debug (inf, "running one thread: %d/%d", inf->pid, thread->tid); + error (_("Can't run single thread id %s: no such thread!"), + target_pid_to_str (ptid)); + inf_debug (inf, "running one thread: %s", target_pid_to_str (ptid)); inf_set_threads_resume_sc (inf, thread, 0); } if (step) { - step_thread = inf_tid_to_thread (inf, tid); + step_thread = inf_tid_to_thread (inf, ptid_get_tid (ptid)); if (!step_thread) - warning ("Can't step thread id %d: no such thread.", tid); + warning (_("Can't step thread id %s: no such thread."), + target_pid_to_str (ptid)); else - inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid); + inf_debug (inf, "stepping thread: %s", target_pid_to_str (ptid)); } if (step_thread != inf->step_thread) inf_set_step_thread (inf, step_thread); @@ -1913,94 +2047,96 @@ gnu_resume (int tid, int step, enum target_signal sig) inf_debug (inf, "here we go..."); inf_resume (inf); } + static void -gnu_kill_inferior () +gnu_kill_inferior (struct target_ops *ops) { - struct proc *task = current_inferior->task; + struct proc *task = gnu_current_inf->task; + if (task) { proc_debug (task, "terminating..."); task_terminate (task->port); - inf_set_pid (current_inferior, -1); + inf_set_pid (gnu_current_inf, -1); } target_mourn_inferior (); } /* Clean up after the inferior dies. */ - static void -gnu_mourn_inferior () +gnu_mourn_inferior (struct target_ops *ops) { - inf_debug (current_inferior, "rip"); - inf_detach (current_inferior); - unpush_target (&gnu_ops); + inf_debug (gnu_current_inf, "rip"); + inf_detach (gnu_current_inf); + unpush_target (ops); generic_mourn_inferior (); } + /* Fork an inferior process, and start debugging it. */ /* Set INFERIOR_PID to the first thread available in the child, if any. */ static int -inf_pick_first_thread () +inf_pick_first_thread (void) { - if (current_inferior->task && current_inferior->threads) + if (gnu_current_inf->task && gnu_current_inf->threads) /* The first thread. */ - return current_inferior->threads->tid; + return gnu_current_inf->threads->tid; else /* What may be the next thread. */ return next_thread_id; } static struct inf * -cur_inf () +cur_inf (void) { - if (!current_inferior) - current_inferior = make_inf (); - return current_inferior; + if (!gnu_current_inf) + gnu_current_inf = make_inf (); + return gnu_current_inf; } static void -gnu_create_inferior (exec_file, allargs, env) - char *exec_file; - char *allargs; - char **env; +gnu_create_inferior (struct target_ops *ops, + char *exec_file, char *allargs, char **env, + int from_tty) { struct inf *inf = cur_inf (); + int pid; void trace_me () { /* We're in the child; make this process stop as soon as it execs. */ inf_debug (inf, "tracing self"); if (ptrace (PTRACE_TRACEME) != 0) - error ("ptrace (PTRACE_TRACEME) failed!"); + error (_("ptrace (PTRACE_TRACEME) failed!")); } - void attach_to_child (int pid) - { - /* Attach to the now stopped child, which is actually a shell... */ - inf_debug (inf, "attaching to child: %d", pid); - inf_attach (inf, pid); + inf_debug (inf, "creating inferior"); - attach_flag = 0; - push_target (&gnu_ops); + pid = fork_inferior (exec_file, allargs, env, trace_me, + NULL, NULL, NULL, NULL); - inf->pending_execs = 2; - inf->nomsg = 1; - inf->traced = 1; + /* Attach to the now stopped child, which is actually a shell... */ + inf_debug (inf, "attaching to child: %d", pid); - /* Now let the child run again, knowing that it will stop immediately - because of the ptrace. */ - inf_resume (inf); - inferior_pid = inf_pick_first_thread (); + inf_attach (inf, pid); - startup_inferior (inf->pending_execs); - } + push_target (ops); - inf_debug (inf, "creating inferior"); + 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); - fork_inferior (exec_file, allargs, env, trace_me, attach_to_child, - NULL, NULL); + /* We now have thread info. */ + thread_change_ptid (inferior_ptid, + ptid_build (inf->pid, 0, inf_pick_first_thread ())); + + startup_inferior (inf->pending_execs); inf_validate_procinfo (inf); inf_update_signal_thread (inf); @@ -2012,39 +2148,23 @@ gnu_create_inferior (exec_file, allargs, env) inf_steal_exc_ports (inf); else inf_restore_exc_ports (inf); - - /* Here we go! */ - proceed ((CORE_ADDR) -1, 0, 0); } -/* Mark our target-struct as eligible for stray "run" and "attach" - commands. */ -static int -gnu_can_run () -{ - return 1; -} -#ifdef ATTACH_DETACH - /* Attach to process PID, then initialize for debugging it and wait for the trace-trap that results from attaching. */ static void -gnu_attach (args, from_tty) - char *args; - int from_tty; +gnu_attach (struct target_ops *ops, char *args, int from_tty) { int pid; char *exec_file; struct inf *inf = cur_inf (); + struct inferior *inferior; - if (!args) - error_no_arg ("PID to attach"); - - pid = atoi (args); + pid = parse_pid_to_attach (args); - if (pid == getpid ()) /* Trying to masturbate? */ - error ("I refuse to debug myself!"); + if (pid == getpid ()) /* Trying to masturbate? */ + error (_("I refuse to debug myself!")); if (from_tty) { @@ -2062,12 +2182,16 @@ gnu_attach (args, from_tty) inf_debug (inf, "attaching to pid: %d", pid); inf_attach (inf, pid); - inf_update_procs (inf); - inferior_pid = inf_pick_first_thread (); + push_target (ops); + + inferior = current_inferior (); + inferior_appeared (inferior, pid); + inferior->attach_flag = 1; + + inf_update_procs (inf); - attach_flag = 1; - push_target (&gnu_ops); + 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. */ @@ -2080,10 +2204,11 @@ gnu_attach (args, from_tty) inf_update_signal_thread (inf); inf_set_traced (inf, inf->want_signals); -#if 0 /* Do we need this? */ - renumber_threads (0); /* Give our threads reasonable names. */ +#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 @@ -2093,91 +2218,59 @@ gnu_attach (args, from_tty) previously attached. It *might* work if the program was started via fork. */ static void -gnu_detach (args, from_tty) - char *args; - int from_tty; +gnu_detach (struct target_ops *ops, char *args, int from_tty) { + int pid; + if (from_tty) { char *exec_file = get_exec_file (0); + if (exec_file) printf_unfiltered ("Detaching from program `%s' pid %d\n", - exec_file, current_inferior->pid); + exec_file, gnu_current_inf->pid); else - printf_unfiltered ("Detaching from pid %d\n", current_inferior->pid); + printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf->pid); gdb_flush (gdb_stdout); } - inf_detach (current_inferior); + pid = gnu_current_inf->pid; - inferior_pid = 0; + inf_detach (gnu_current_inf); - unpush_target (&gnu_ops); /* Pop out of handling an inferior */ -} -#endif /* ATTACH_DETACH */ + inferior_ptid = null_ptid; + detach_inferior (pid); -static void -gnu_terminal_init_inferior () -{ - assert (current_inferior); - terminal_init_inferior_with_pgrp (current_inferior->pid); + unpush_target (ops); /* Pop out of handling an inferior. */ } - -/* Get ready to modify the registers array. On machines which store - individual registers, this doesn't need to do anything. On machines - which store all the registers in one fell swoop, this makes sure - that registers contains all the registers from the program being - debugged. */ - -static void -gnu_prepare_to_store () -{ -#ifdef CHILD_PREPARE_TO_STORE - CHILD_PREPARE_TO_STORE (); -#endif -} - + static void -gnu_open (arg, from_tty) - char *arg; - int from_tty; +gnu_terminal_init_inferior (void) { - error ("Use the \"run\" command to start a Unix child process."); + gdb_assert (gnu_current_inf); + terminal_init_inferior_with_pgrp (gnu_current_inf->pid); } static void -gnu_stop () +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); @@ -2186,21 +2279,23 @@ gnu_read_inferior (task, addr, myaddr, length) pointer_t copied; int copy_count; - /* Get memory from inferior with page aligned addresses */ + /* 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; } @@ -2218,16 +2313,10 @@ struct vm_region_list struct obstack region_obstack; -/* - * Write gdb's LEN bytes from MYADDR and copy it to ADDR - * in inferior task's address space. - */ +/* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior + task's address space. */ int -gnu_write_inferior (task, addr, myaddr, length) - task_t task; - CORE_ADDR addr; - char *myaddr; - int length; +gnu_write_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length) { error_t err = 0; vm_address_t low_address = (vm_address_t) trunc_page (addr); @@ -2242,7 +2331,7 @@ gnu_write_inferior (task, addr, myaddr, length) struct vm_region_list *region_element; struct vm_region_list *region_head = (struct vm_region_list *) NULL; - /* Get memory from inferior with page aligned addresses */ + /* Get memory from inferior with page aligned addresses. */ err = vm_read (task, low_address, aligned_length, @@ -2252,14 +2341,14 @@ gnu_write_inferior (task, addr, myaddr, length) deallocate++; - err = hurd_safe_copyout ((void *) addr - low_address + copied, myaddr, length); + err = hurd_safe_copyout ((void *) (addr - low_address + copied), + myaddr, length); CHK_GOTO_OUT ("Write to inferior faulted", err); obstack_init (®ion_obstack); /* Do writes atomically. - * First check for holes and unwritable memory. - */ + First check for holes and unwritable memory. */ { vm_size_t remaining_length = aligned_length; vm_address_t region_address = low_address; @@ -2288,10 +2377,10 @@ gnu_write_inferior (task, addr, myaddr, length) &offset); CHK_GOTO_OUT ("vm_region failed", err); - /* Check for holes in memory */ + /* Check for holes in memory. */ if (old_address != region_address) { - warning ("No memory at 0x%x. Nothing written", + warning (_("No memory at 0x%x. Nothing written"), old_address); err = KERN_SUCCESS; length = 0; @@ -2300,14 +2389,15 @@ 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; goto out; } - /* Chain the regions for later use */ + /* Chain the regions for later use. */ region_element = (struct vm_region_list *) obstack_alloc (®ion_obstack, sizeof (struct vm_region_list)); @@ -2316,7 +2406,7 @@ gnu_write_inferior (task, addr, myaddr, length) region_element->start = region_address; region_element->length = region_length; - /* Chain the regions along with protections */ + /* Chain the regions along with protections. */ region_element->next = region_head; region_head = region_element; @@ -2325,14 +2415,11 @@ gnu_write_inferior (task, addr, myaddr, length) } /* If things fail after this, we give up. - * Somebody is messing up inferior_task's mappings. - */ + Somebody is messing up inferior_task's mappings. */ - /* Enable writes to the chained vm regions */ + /* 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, @@ -2350,11 +2437,9 @@ gnu_write_inferior (task, addr, myaddr, length) aligned_length); CHK_GOTO_OUT ("vm_write failed", err); - /* Set up the original region protections, if they were changed */ + /* Set up the original region protections, if they were changed. */ for (scan = region_head; scan; scan = scan->next) { - boolean_t protection_changed = FALSE; - if (!(scan->protection & VM_PROT_WRITE)) { err = vm_protect (task, @@ -2379,132 +2464,138 @@ out: if (err != KERN_SUCCESS) { - warning ("%s: %s", errstr, mach_error_string (err)); + warning (_("%s: %s"), errstr, mach_error_string (err)); return 0; } return length; } + -/* Return 0 on failure, number of bytes handled otherwise. */ +/* Return 0 on failure, number of bytes handled otherwise. TARGET + is ignored. */ static int -gnu_xfer_memory (memaddr, myaddr, len, write, target) - CORE_ADDR memaddr; - char *myaddr; - int len; - int write; - struct target_ops *target; /* IGNORED */ -{ - int result; - task_t task = - current_inferior - ? (current_inferior->task ? current_inferior->task->port : 0) - : 0; +gnu_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write, + struct mem_attrib *attrib, + struct target_ops *target) +{ + task_t task = (gnu_current_inf + ? (gnu_current_inf->task + ? gnu_current_inf->task->port : 0) + : 0); if (task == MACH_PORT_NULL) return 0; else { - inf_debug (current_inferior, "%s %p[%d] %s %p", - write ? "writing" : "reading", memaddr, len, - write ? "<--" : "-->", myaddr); + inf_debug (gnu_current_inf, "%s %s[%d] %s %s", + write ? "writing" : "reading", + paddress (target_gdbarch, memaddr), len, + write ? "<--" : "-->", host_address_to_string (myaddr)); if (write) return gnu_write_inferior (task, memaddr, myaddr, len); else return gnu_read_inferior (task, memaddr, myaddr, len); } } - -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 (find_memory_region_ftype func, void *data) +{ + error_t err; + task_t task; + vm_address_t region_address, last_region_address, last_region_end; + vm_prot_t last_protection; + + if (gnu_current_inf == 0 || gnu_current_inf->task == 0) + return 0; + task = gnu_current_inf->task->port; + if (task == MACH_PORT_NULL) + return 0; + + region_address = last_region_address = last_region_end = VM_MIN_ADDRESS; + last_protection = VM_PROT_NONE; + while (region_address < VM_MAX_ADDRESS) + { + vm_prot_t protection; + vm_prot_t max_protection; + vm_inherit_t inheritance; + boolean_t shared; + mach_port_t object_name; + vm_offset_t offset; + vm_size_t region_length = VM_MAX_ADDRESS - region_address; + vm_address_t old_address = region_address; + + err = vm_region (task, + ®ion_address, + ®ion_length, + &protection, + &max_protection, + &inheritance, + &shared, + &object_name, + &offset); + if (err == KERN_NO_SPACE) + break; + if (err != KERN_SUCCESS) + { + warning (_("vm_region failed: %s"), mach_error_string (err)); + return -1; + } + + if (protection == last_protection && region_address == last_region_end) + /* This region is contiguous with and indistinguishable from + the previous one, so we just extend that one. */ + last_region_end = region_address += region_length; + else + { + /* This region is distinct from the last one we saw, so report + that previous one. */ + if (last_protection != VM_PROT_NONE) + (*func) (last_region_address, + last_region_end - last_region_address, + last_protection & VM_PROT_READ, + last_protection & VM_PROT_WRITE, + last_protection & VM_PROT_EXECUTE, + data); + last_region_address = region_address; + last_region_end = region_address += region_length; + last_protection = protection; + } + } + + /* Report the final region. */ + if (last_region_end > last_region_address && last_protection != VM_PROT_NONE) + (*func) (last_region_address, last_region_end - last_region_address, + last_protection & VM_PROT_READ, + last_protection & VM_PROT_WRITE, + last_protection & VM_PROT_EXECUTE, + data); + + return 0; +} -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) { 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) @@ -2512,10 +2603,43 @@ gnu_target_pid_to_str (int tid) else { static char tid_str[80]; + sprintf (tid_str, "bogus thread id %d", tid); return tid_str; } } + + +/* Create a prototype generic GNU/Hurd target. The client can + override it with local methods. */ + +struct target_ops * +gnu_target (void) +{ + struct target_ops *t = inf_child_target (); + + t->to_shortname = "GNU"; + t->to_longname = "GNU Hurd process"; + t->to_doc = "GNU Hurd process"; + + t->to_attach = gnu_attach; + t->to_attach_no_wait = 1; + t->to_detach = gnu_detach; + t->to_resume = gnu_resume; + t->to_wait = gnu_wait; + t->deprecated_xfer_memory = gnu_xfer_memory; + t->to_find_memory_regions = gnu_find_memory_regions; + t->to_terminal_init = gnu_terminal_init_inferior; + t->to_kill = gnu_kill_inferior; + t->to_create_inferior = gnu_create_inferior; + t->to_mourn_inferior = gnu_mourn_inferior; + t->to_thread_alive = gnu_thread_alive; + t->to_pid_to_str = gnu_pid_to_str; + t->to_stop = gnu_stop; + + return t; +} + /* User task commands. */ @@ -2535,25 +2659,29 @@ struct cmd_list_element *show_thread_default_cmd_list = NULL; static void set_thread_cmd (char *args, int from_tty) { - printf_unfiltered ("\"set thread\" must be followed by the name of a thread property, or \"default\".\n"); + printf_unfiltered ("\"set thread\" must be followed by the " + "name of a thread property, or \"default\".\n"); } static void show_thread_cmd (char *args, int from_tty) { - printf_unfiltered ("\"show thread\" must be followed by the name of a thread property, or \"default\".\n"); + printf_unfiltered ("\"show thread\" must be followed by the " + "name of a thread property, or \"default\".\n"); } static void set_thread_default_cmd (char *args, int from_tty) { - printf_unfiltered ("\"set thread default\" must be followed by the name of a thread property.\n"); + printf_unfiltered ("\"set thread default\" must be followed " + "by the name of a thread property.\n"); } static void show_thread_default_cmd (char *args, int from_tty) { - printf_unfiltered ("\"show thread default\" must be followed by the name of a thread property.\n"); + printf_unfiltered ("\"show thread default\" must be followed " + "by the name of a thread property.\n"); } static int @@ -2563,10 +2691,12 @@ parse_int_arg (char *args, char *cmd_prefix) { char *arg_end; int val = strtoul (args, &arg_end, 10); + if (*args && *arg_end == '\0') return val; } - error ("Illegal argument for \"%s\" command, should be an integer.", cmd_prefix); + error (_("Illegal argument for \"%s\" command, should be an integer."), + cmd_prefix); } static int @@ -2577,7 +2707,8 @@ _parse_bool_arg (char *args, char *t_val, char *f_val, char *cmd_prefix) else if (strcmp (args, f_val) == 0) return 0; else - error ("Illegal argument for \"%s\" command, should be \"%s\" or \"%s\".", + error (_("Illegal argument for \"%s\" command, " + "should be \"%s\" or \"%s\"."), cmd_prefix, t_val, f_val); } @@ -2588,29 +2719,32 @@ static void check_empty (char *args, char *cmd_prefix) { if (args) - error ("Garbage after \"%s\" command: `%s'", cmd_prefix, args); + error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix, args); } /* Returns the alive thread named by INFERIOR_PID, or signals an error. */ static struct proc * -cur_thread () +cur_thread (void) { struct inf *inf = cur_inf (); - struct proc *thread = inf_tid_to_thread (inf, inferior_pid); + struct proc *thread = inf_tid_to_thread (inf, + ptid_get_tid (inferior_ptid)); if (!thread) - error ("No current thread."); + error (_("No current thread.")); return thread; } /* Returns the current inferior, but signals an error if it has no task. */ static struct inf * -active_inf () +active_inf (void) { struct inf *inf = cur_inf (); + if (!inf->task) - error ("No current process."); + error (_("No current process.")); return inf; } + static void set_task_pause_cmd (char *args, int from_tty) @@ -2630,6 +2764,7 @@ static void show_task_pause_cmd (char *args, int from_tty) { struct inf *inf = cur_inf (); + check_empty (args, "show task pause"); printf_unfiltered ("The inferior task %s suspended while gdb has control.\n", inf->task @@ -2640,21 +2775,25 @@ show_task_pause_cmd (char *args, int from_tty) static void set_task_detach_sc_cmd (char *args, int from_tty) { - cur_inf ()->detach_sc = parse_int_arg (args, "set task detach-suspend-count"); + cur_inf ()->detach_sc = parse_int_arg (args, + "set task detach-suspend-count"); } static void show_task_detach_sc_cmd (char *args, int from_tty) { check_empty (args, "show task detach-suspend-count"); - printf_unfiltered ("The inferior task will be left with a suspend count of %d when detaching.\n", + printf_unfiltered ("The inferior task will be left with a " + "suspend count of %d when detaching.\n", cur_inf ()->detach_sc); } + static void set_thread_default_pause_cmd (char *args, int from_tty) { struct inf *inf = cur_inf (); + inf->default_thread_pause_sc = parse_bool_arg (args, "set thread default pause") ? 0 : 1; } @@ -2664,6 +2803,7 @@ show_thread_default_pause_cmd (char *args, int from_tty) { struct inf *inf = cur_inf (); int sc = inf->default_thread_pause_sc; + check_empty (args, "show thread default pause"); printf_unfiltered ("New threads %s suspended while gdb has control%s.\n", sc ? "are" : "aren't", @@ -2674,6 +2814,7 @@ static void set_thread_default_run_cmd (char *args, int from_tty) { struct inf *inf = cur_inf (); + inf->default_thread_run_sc = parse_bool_arg (args, "set thread default run") ? 0 : 1; } @@ -2682,6 +2823,7 @@ static void show_thread_default_run_cmd (char *args, int from_tty) { struct inf *inf = cur_inf (); + check_empty (args, "show thread default run"); printf_unfiltered ("New threads %s allowed to run.\n", inf->default_thread_run_sc == 0 ? "are" : "aren't"); @@ -2701,6 +2843,7 @@ show_thread_default_detach_sc_cmd (char *args, int from_tty) printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n", cur_inf ()->default_thread_detach_sc); } + /* Steal a send right called NAME in the inferior task, and make it PROC's saved exception port. */ @@ -2712,14 +2855,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. */ @@ -2728,22 +2871,24 @@ steal_exc_port (struct proc *proc, mach_port_t name) proc->saved_exc_port = 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. */ + /* 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)); + 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)); } @@ -2757,6 +2902,7 @@ static void show_stopped_cmd (char *args, int from_tty) { struct inf *inf = active_inf (); + check_empty (args, "show stopped"); printf_unfiltered ("The inferior process %s stopped.\n", inf->stopped ? "is" : "isn't"); @@ -2765,21 +2911,22 @@ show_stopped_cmd (char *args, int from_tty) static void set_sig_thread_cmd (char *args, int from_tty) { - int tid; struct inf *inf = cur_inf (); if (!args || (!isdigit (*args) && strcmp (args, "none") != 0)) - error ("Illegal argument to \"set signal-thread\" command.\n" - "Should be an integer thread ID, or `none'."); + error (_("Illegal argument to \"set signal-thread\" command.\n" + "Should be an integer thread ID, or `none'.")); if (strcmp (args, "none") == 0) inf->signal_thread = 0; else { - int tid = thread_id_to_pid (atoi (args)); + int tid = ptid_get_tid (thread_id_to_pid (atoi (args))); + if (tid < 0) - error ("Thread ID %s not known. Use the \"info threads\" command to\n" - "see the IDs of currently known threads.", args); + error (_("Thread ID %s not known. " + "Use the \"info threads\" command to\n" + "see the IDs of currently known threads."), args); inf->signal_thread = inf_tid_to_thread (inf, tid); } } @@ -2788,6 +2935,7 @@ static void show_sig_thread_cmd (char *args, int from_tty) { struct inf *inf = active_inf (); + check_empty (args, "show signal-thread"); if (inf->signal_thread) printf_unfiltered ("The signal thread is %s.\n", @@ -2795,11 +2943,11 @@ show_sig_thread_cmd (char *args, int from_tty) else printf_unfiltered ("There is no signal thread.\n"); } + static void set_signals_cmd (char *args, int from_tty) { - int trace; struct inf *inf = cur_inf (); inf->want_signals = parse_bool_arg (args, "set signals"); @@ -2813,6 +2961,7 @@ static void show_signals_cmd (char *args, int from_tty) { struct inf *inf = cur_inf (); + check_empty (args, "show signals"); printf_unfiltered ("The inferior process's signals %s intercepted.\n", inf->task @@ -2837,17 +2986,20 @@ static void show_exceptions_cmd (char *args, int from_tty) { struct inf *inf = cur_inf (); + check_empty (args, "show exceptions"); printf_unfiltered ("Exceptions in the inferior %s trapped.\n", inf->task ? (inf->want_exceptions ? "are" : "aren't") : (inf->want_exceptions ? "will be" : "won't be")); } + static void set_task_cmd (char *args, int from_tty) { - printf_unfiltered ("\"set task\" must be followed by the name of a task property.\n"); + printf_unfiltered ("\"set task\" must be followed by the name" + " of a task property.\n"); } static void @@ -2876,6 +3028,7 @@ show_task_cmd (char *args, int from_tty) if (inf->default_thread_detach_sc != 0) show_thread_default_detach_sc_cmd (0, from_tty); } + static void set_noninvasive_cmd (char *args, int from_tty) @@ -2887,35 +3040,37 @@ set_noninvasive_cmd (char *args, int from_tty) set_signals_cmd (inv_args, from_tty); set_exceptions_cmd (inv_args, from_tty); } + static void info_port_rights (char *args, mach_port_type_t only) { struct inf *inf = active_inf (); - value_ptr vmark = value_mark (); + struct value *vmark = value_mark (); if (args) /* Explicit list of port rights. */ { while (*args) { - value_ptr val = parse_to_comma_and_eval (&args); + struct value *val = parse_to_comma_and_eval (&args); long right = value_as_long (val); error_t err = - print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS, - stdout); + print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS, + stdout); + if (err) - error ("%ld: %s.", right, strerror (err)); + error (_("%ld: %s."), right, safe_strerror (err)); } } else /* Print all of them. */ { error_t err = - print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS, - stdout); + print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS, + stdout); if (err) - error ("%s.", strerror (err)); + error (_("%s."), safe_strerror (err)); } value_free_to_mark (vmark); @@ -2926,157 +3081,168 @@ info_send_rights_cmd (char *args, int from_tty) { info_port_rights (args, MACH_PORT_TYPE_SEND); } + static void info_recv_rights_cmd (char *args, int from_tty) { info_port_rights (args, MACH_PORT_TYPE_RECEIVE); } + static void info_port_sets_cmd (char *args, int from_tty) { info_port_rights (args, MACH_PORT_TYPE_PORT_SET); } + static void info_dead_names_cmd (char *args, int from_tty) { info_port_rights (args, MACH_PORT_TYPE_DEAD_NAME); } + static void info_port_rights_cmd (char *args, int from_tty) { info_port_rights (args, ~0); } + static void -add_task_commands () +add_task_commands (void) { - add_cmd ("pause", class_run, set_thread_default_pause_cmd, - "Set whether the new threads are suspended while gdb has control.\n" - "This property normally has no effect because the whole task is\n" - "suspended, however, that may be disabled with \"set task pause off\".\n" - "The default value is \"off\".", + add_cmd ("pause", class_run, set_thread_default_pause_cmd, _("\ +Set whether the new threads are suspended while gdb has control.\n\ +This property normally has no effect because the whole task is\n\ +suspended, however, that may be disabled with \"set task pause off\".\n\ +The default value is \"off\"."), &set_thread_default_cmd_list); - add_cmd ("pause", no_class, show_thread_default_pause_cmd, - "Show whether new threads are suspended while gdb has control.", + add_cmd ("pause", no_class, show_thread_default_pause_cmd, _("\ +Show whether new threads are suspended while gdb has control."), &show_thread_default_cmd_list); - add_cmd ("run", class_run, set_thread_default_run_cmd, - "Set whether new threads are allowed to run (once gdb has noticed them).", + + add_cmd ("run", class_run, set_thread_default_run_cmd, _("\ +Set whether new threads are allowed to run (once gdb has noticed them)."), &set_thread_default_cmd_list); - add_cmd ("run", no_class, show_thread_default_run_cmd, - "Show whether new threads are allowed to run (once gdb has noticed them).", + add_cmd ("run", no_class, show_thread_default_run_cmd, _("\ +Show whether new threads are allowed to run (once gdb has noticed them)."), &show_thread_default_cmd_list); + add_cmd ("detach-suspend-count", class_run, set_thread_default_detach_sc_cmd, - "Set the default detach-suspend-count value for new threads.", + _("Set the default detach-suspend-count value for new threads."), &set_thread_default_cmd_list); add_cmd ("detach-suspend-count", no_class, show_thread_default_detach_sc_cmd, - "Show the default detach-suspend-count value for new threads.", + _("Show the default detach-suspend-count value for new threads."), &show_thread_default_cmd_list); - add_cmd ("signals", class_run, set_signals_cmd, - "Set whether the inferior process's signals will be intercepted.\n" - "Mach exceptions (such as breakpoint traps) are not affected.", + add_cmd ("signals", class_run, set_signals_cmd, _("\ +Set whether the inferior process's signals will be intercepted.\n\ +Mach exceptions (such as breakpoint traps) are not affected."), &setlist); add_alias_cmd ("sigs", "signals", class_run, 1, &setlist); - add_cmd ("signals", no_class, show_signals_cmd, - "Show whether the inferior process's signals will be intercepted.", + add_cmd ("signals", no_class, show_signals_cmd, _("\ +Show whether the inferior process's signals will be intercepted."), &showlist); add_alias_cmd ("sigs", "signals", no_class, 1, &showlist); - add_cmd ("signal-thread", class_run, set_sig_thread_cmd, - "Set the thread that gdb thinks is the libc signal thread.\n" - "This thread is run when delivering a signal to a non-stopped process.", + add_cmd ("signal-thread", class_run, set_sig_thread_cmd, _("\ +Set the thread that gdb thinks is the libc signal thread.\n\ +This thread is run when delivering a signal to a non-stopped process."), &setlist); add_alias_cmd ("sigthread", "signal-thread", class_run, 1, &setlist); - add_cmd ("signal-thread", no_class, show_sig_thread_cmd, - "Set the thread that gdb thinks is the libc signal thread.", + add_cmd ("signal-thread", no_class, show_sig_thread_cmd, _("\ +Set the thread that gdb thinks is the libc signal thread."), &showlist); add_alias_cmd ("sigthread", "signal-thread", no_class, 1, &showlist); - add_cmd ("stopped", class_run, set_stopped_cmd, - "Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n" - "Stopped process will be continued by sending them a signal.", + add_cmd ("stopped", class_run, set_stopped_cmd, _("\ +Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\ +Stopped process will be continued by sending them a signal."), &setlist); - add_cmd ("stopped", no_class, show_signals_cmd, - "Show whether gdb thinks the inferior process is stopped as with SIGSTOP.", + add_cmd ("stopped", no_class, show_stopped_cmd, _("\ +Show whether gdb thinks the inferior process is stopped as with SIGSTOP."), &showlist); - add_cmd ("exceptions", class_run, set_exceptions_cmd, - "Set whether exceptions in the inferior process will be trapped.\n" - "When exceptions are turned off, neither breakpoints nor single-stepping\n" - "will work.", + add_cmd ("exceptions", class_run, set_exceptions_cmd, _("\ +Set whether exceptions in the inferior process will be trapped.\n\ +When exceptions are turned off, neither breakpoints nor single-stepping\n\ +will work."), &setlist); /* Allow `set exc' despite conflict with `set exception-port'. */ add_alias_cmd ("exc", "exceptions", class_run, 1, &setlist); - add_cmd ("exceptions", no_class, show_exceptions_cmd, - "Show whether exceptions in the inferior process will be trapped.", + add_cmd ("exceptions", no_class, show_exceptions_cmd, _("\ +Show whether exceptions in the inferior process will be trapped."), &showlist); add_prefix_cmd ("task", no_class, set_task_cmd, - "Command prefix for setting task attributes.", + _("Command prefix for setting task attributes."), &set_task_cmd_list, "set task ", 0, &setlist); add_prefix_cmd ("task", no_class, show_task_cmd, - "Command prefix for showing task attributes.", + _("Command prefix for showing task attributes."), &show_task_cmd_list, "show task ", 0, &showlist); - add_cmd ("pause", class_run, set_task_pause_cmd, - "Set whether the task is suspended while gdb has control.\n" - "A value of \"on\" takes effect immediately, otherwise nothing\n" - "happens until the next time the program is continued.\n" - "When setting this to \"off\", \"set thread default pause on\"\n" - "can be used to pause individual threads by default instead.", + add_cmd ("pause", class_run, set_task_pause_cmd, _("\ +Set whether the task is suspended while gdb has control.\n\ +A value of \"on\" takes effect immediately, otherwise nothing happens\n\ +until the next time the program is continued.\n\ +When setting this to \"off\", \"set thread default pause on\" can be\n\ +used to pause individual threads by default instead."), &set_task_cmd_list); add_cmd ("pause", no_class, show_task_pause_cmd, - "Show whether the task is suspended while gdb has control.", + _("Show whether the task is suspended while gdb has control."), &show_task_cmd_list); + add_cmd ("detach-suspend-count", class_run, set_task_detach_sc_cmd, - "Set the suspend count will leave on the thread when detaching.", + _("Set the suspend count will leave on the thread when detaching."), &set_task_cmd_list); add_cmd ("detach-suspend-count", no_class, show_task_detach_sc_cmd, - "Show the suspend count will leave on the thread when detaching.", + _("Show the suspend count will leave " + "on the thread when detaching."), &show_task_cmd_list); - add_cmd ("exception-port", no_class, set_task_exc_port_cmd, - "Set the task exception port to which we forward exceptions.\n" - "The argument should be the value of the send right in the task.", + add_cmd ("exception-port", no_class, set_task_exc_port_cmd, _("\ +Set the task exception port to which we forward exceptions.\n\ +The argument should be the value of the send right in the task."), &set_task_cmd_list); add_alias_cmd ("excp", "exception-port", no_class, 1, &set_task_cmd_list); - add_alias_cmd ("exc-port", "exception-port", no_class, 1, &set_task_cmd_list); + add_alias_cmd ("exc-port", "exception-port", no_class, 1, + &set_task_cmd_list); /* A convenient way of turning on all options require to noninvasively debug running tasks. */ - add_cmd ("noninvasive", no_class, set_noninvasive_cmd, - "Set task options so that we interfere as little as possible.\n" - "This is the same as setting `task pause', `exceptions', and" - "`signals' to the opposite value.", + add_cmd ("noninvasive", no_class, set_noninvasive_cmd, _("\ +Set task options so that we interfere as little as possible.\n\ +This is the same as setting `task pause', `exceptions', and\n\ +`signals' to the opposite value."), &setlist); /* Commands to show information about the task's ports. */ add_cmd ("send-rights", class_info, info_send_rights_cmd, - "Show information about the task's send rights", + _("Show information about the task's send rights"), &infolist); add_cmd ("receive-rights", class_info, info_recv_rights_cmd, - "Show information about the task's receive rights", + _("Show information about the task's receive rights"), &infolist); - add_cmd ("port-rights", class_info, info_send_rights_cmd, - "Show information about the task's port rights", + add_cmd ("port-rights", class_info, info_port_rights_cmd, + _("Show information about the task's port rights"), &infolist); add_cmd ("port-sets", class_info, info_port_sets_cmd, - "Show information about the task's port sets", + _("Show information about the task's port sets"), &infolist); add_cmd ("dead-names", class_info, info_dead_names_cmd, - "Show information about the task's dead names", + _("Show information about the task's dead names"), &infolist); add_info_alias ("ports", "port-rights", 1); add_info_alias ("port", "port-rights", 1); add_info_alias ("psets", "port-sets", 1); } - + static void set_thread_pause_cmd (char *args, int from_tty) { struct proc *thread = cur_thread (); int old_sc = thread->pause_sc; + thread->pause_sc = parse_bool_arg (args, "set thread pause"); if (old_sc == 0 && thread->pause_sc != 0 && thread->inf->pause_sc == 0) /* If the task is currently unsuspended, immediately suspend it, @@ -3089,17 +3255,19 @@ show_thread_pause_cmd (char *args, int from_tty) { struct proc *thread = cur_thread (); int sc = thread->pause_sc; + check_empty (args, "show task pause"); printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n", proc_string (thread), sc ? "is" : "isn't", - !sc && thread->inf->pause_sc ? " (but the task is)" : ""); + !sc && thread->inf->pause_sc ? " (but the task is)" : ""); } static void set_thread_run_cmd (char *args, int from_tty) { struct proc *thread = cur_thread (); + thread->run_sc = parse_bool_arg (args, "set thread run") ? 0 : 1; } @@ -3107,6 +3275,7 @@ static void show_thread_run_cmd (char *args, int from_tty) { struct proc *thread = cur_thread (); + check_empty (args, "show thread run"); printf_unfiltered ("Thread %s %s allowed to run.", proc_string (thread), @@ -3116,15 +3285,18 @@ show_thread_run_cmd (char *args, int from_tty) static void set_thread_detach_sc_cmd (char *args, int from_tty) { - cur_thread ()->detach_sc = parse_int_arg (args, "set thread detach-suspend-count"); + cur_thread ()->detach_sc = parse_int_arg (args, + "set thread detach-suspend-count"); } static void show_thread_detach_sc_cmd (char *args, int from_tty) { struct proc *thread = cur_thread (); + check_empty (args, "show thread detach-suspend-count"); - printf_unfiltered ("Thread %s will be left with a suspend count of %d when detaching.\n", + printf_unfiltered ("Thread %s will be left with a suspend count" + " of %d when detaching.\n", proc_string (thread), thread->detach_sc); } @@ -3133,8 +3305,9 @@ static void set_thread_exc_port_cmd (char *args, int from_tty) { struct proc *thread = cur_thread (); + if (!args) - error ("No argument to \"set thread exception-port\" command."); + error (_("No argument to \"set thread exception-port\" command.")); steal_exc_port (thread, parse_and_eval_address (args)); } @@ -3143,6 +3316,7 @@ static void show_thread_cmd (char *args, int from_tty) { struct proc *thread = cur_thread (); + check_empty (args, "show thread"); show_thread_run_cmd (0, from_tty); show_thread_pause_cmd (0, from_tty); @@ -3155,94 +3329,104 @@ static void thread_takeover_sc_cmd (char *args, int from_tty) { struct proc *thread = cur_thread (); + thread_basic_info_data_t _info; thread_basic_info_t info = &_info; mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT; error_t err = thread_info (thread->port, THREAD_BASIC_INFO, (int *) &info, &info_len); if (err) - error ("%s.", strerror (err)); + error (("%s."), safe_strerror (err)); thread->sc = info->suspend_count; if (from_tty) printf_unfiltered ("Suspend count was %d.\n", thread->sc); if (info != &_info) - vm_deallocate (mach_task_self (), (vm_address_t) info, info_len * sizeof (int)); + vm_deallocate (mach_task_self (), (vm_address_t) info, + info_len * sizeof (int)); } -add_thread_commands () + +static void +add_thread_commands (void) { add_prefix_cmd ("thread", no_class, set_thread_cmd, - "Command prefix for setting thread properties.", + _("Command prefix for setting thread properties."), &set_thread_cmd_list, "set thread ", 0, &setlist); add_prefix_cmd ("default", no_class, show_thread_cmd, - "Command prefix for setting default thread properties.", + _("Command prefix for setting default thread properties."), &set_thread_default_cmd_list, "set thread default ", 0, &set_thread_cmd_list); add_prefix_cmd ("thread", no_class, set_thread_default_cmd, - "Command prefix for showing thread properties.", + _("Command prefix for showing thread properties."), &show_thread_cmd_list, "show thread ", 0, &showlist); add_prefix_cmd ("default", no_class, show_thread_default_cmd, - "Command prefix for showing default thread properties.", + _("Command prefix for showing default thread properties."), &show_thread_default_cmd_list, "show thread default ", 0, &show_thread_cmd_list); - add_cmd ("pause", class_run, set_thread_pause_cmd, - "Set whether the current thread is suspended while gdb has control.\n" - "A value of \"on\" takes effect immediately, otherwise nothing\n" - "happens until the next time the program is continued. This\n" - "property normally has no effect because the whole task is suspended,\n" - "however, that may be disabled with \"set task pause off\".\n" - "The default value is \"off\".", + add_cmd ("pause", class_run, set_thread_pause_cmd, _("\ +Set whether the current thread is suspended while gdb has control.\n\ +A value of \"on\" takes effect immediately, otherwise nothing happens\n\ +until the next time the program is continued. This property normally\n\ +has no effect because the whole task is suspended, however, that may\n\ +be disabled with \"set task pause off\".\n\ +The default value is \"off\"."), &set_thread_cmd_list); - add_cmd ("pause", no_class, show_thread_pause_cmd, - "Show whether the current thread is suspended while gdb has control.", + add_cmd ("pause", no_class, show_thread_pause_cmd, _("\ +Show whether the current thread is suspended while gdb has control."), &show_thread_cmd_list); add_cmd ("run", class_run, set_thread_run_cmd, - "Set whether the current thread is allowed to run.", + _("Set whether the current thread is allowed to run."), &set_thread_cmd_list); add_cmd ("run", no_class, show_thread_run_cmd, - "Show whether the current thread is allowed to run.", + _("Show whether the current thread is allowed to run."), &show_thread_cmd_list); - add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd, - "Set the suspend count will leave on the thread when detaching.\n" - "Note that this is relative to suspend count when gdb noticed the thread;\n" - "use the `thread takeover-suspend-count' to force it to an absolute value.", + add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd, _("\ +Set the suspend count will leave on the thread when detaching.\n\ +Note that this is relative to suspend count when gdb noticed the thread;\n\ +use the `thread takeover-suspend-count' to force it to an absolute value."), &set_thread_cmd_list); - add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd, - "Show the suspend count will leave on the thread when detaching." - "Note that this is relative to suspend count when gdb noticed the thread;\n" - "use the `thread takeover-suspend-count' to force it to an absolute value.", + add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd, _("\ +Show the suspend count will leave on the thread when detaching.\n\ +Note that this is relative to suspend count when gdb noticed the thread;\n\ +use the `thread takeover-suspend-count' to force it to an absolute value."), &show_thread_cmd_list); - add_cmd ("exception-port", no_class, set_thread_exc_port_cmd, - "Set the exception port to which we forward exceptions for the\n" - "current thread, overriding the task exception port.\n" - "The argument should be the value of the send right in the task.", + add_cmd ("exception-port", no_class, set_thread_exc_port_cmd, _("\ +Set the thread exception port to which we forward exceptions.\n\ +This overrides the task exception port.\n\ +The argument should be the value of the send right in the task."), &set_thread_cmd_list); add_alias_cmd ("excp", "exception-port", no_class, 1, &set_thread_cmd_list); - add_alias_cmd ("exc-port", "exception-port", no_class, 1, &set_thread_cmd_list); + add_alias_cmd ("exc-port", "exception-port", no_class, 1, + &set_thread_cmd_list); - add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd, - "Force the threads absolute suspend-count to be gdb's.\n" - "Prior to giving this command, gdb's thread suspend-counts are relative to\n" - "the thread's initial suspend-count when gdb notices the threads.", + add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd, _("\ +Force the threads absolute suspend-count to be gdb's.\n\ +Prior to giving this command, gdb's thread suspend-counts are relative\n\ +to the thread's initial suspend-count when gdb notices the threads."), &thread_cmd_list); } + void -_initialize_gnu_nat () +_initialize_gnu_nat (void) { proc_server = getproc (); - init_gnu_ops (); - add_target (&gnu_ops); + add_task_commands (); add_thread_commands (); - - add_set_cmd ("gnu-debug", class_maintenance, - var_boolean, (char *) &gnu_debug_flag, - "Set debugging output for the gnu backend.", &maintenancelist); + add_setshow_boolean_cmd ("gnu-nat", class_maintenance, + &gnu_debug_flag, + _("Set debugging output for the gnu backend."), + _("Show debugging output for the gnu backend."), + NULL, + NULL, + NULL, + &setdebuglist, + &showdebuglist); } #ifdef FLUSH_INFERIOR_CACHE @@ -3250,21 +3434,20 @@ _initialize_gnu_nat () /* When over-writing code on some machines the I-Cache must be flushed explicitly, because it is not kept coherent by the lazy hardware. This definitely includes breakpoints, for instance, or else we - end up looping in mysterious Bpt traps */ + end up looping in mysterious Bpt traps. */ void -flush_inferior_icache (pc, amount) - CORE_ADDR pc; +flush_inferior_icache (CORE_ADDR pc, int amount) { vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH; error_t ret; - ret = vm_machine_attribute (current_inferior->task->port, + ret = vm_machine_attribute (gnu_current_inf->task->port, pc, amount, MATTR_CACHE, &flush); if (ret != KERN_SUCCESS) - warning ("Error flushing inferior's cache : %s", strerror (ret)); + warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret)); } #endif /* FLUSH_INFERIOR_CACHE */