diff options
Diffstat (limited to 'gdb/gnu-nat.c')
| -rw-r--r-- | gdb/gnu-nat.c | 712 |
1 files changed, 362 insertions, 350 deletions
diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c index f50b64f..9a5b927 100644 --- a/gdb/gnu-nat.c +++ b/gdb/gnu-nat.c @@ -19,8 +19,9 @@ 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. -*/ + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. + */ #include <stdio.h> #include <string.h> @@ -98,8 +99,8 @@ 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, +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); @@ -119,7 +120,7 @@ thread_state_t proc_get_state (struct proc *proc, int force); struct proc *make_proc (struct inf *inf, mach_port_t port, int tid); struct proc *_proc_free (struct proc *proc); int proc_update_sc (struct proc *proc); -error_t proc_get_exception_port (struct proc *proc, mach_port_t *port); +error_t proc_get_exception_port (struct proc *proc, mach_port_t * port); error_t proc_set_exception_port (struct proc *proc, mach_port_t port); static mach_port_t _proc_get_exc_port (struct proc *proc); void proc_steal_exc_port (struct proc *proc, mach_port_t exc_port); @@ -147,105 +148,106 @@ char *proc_string (struct proc *proc); __e; }) \ : EIEIO) -#define MIG_SERVER_DIED EMIG_SERVER_DIED /* XXX */ +#define MIG_SERVER_DIED EMIG_SERVER_DIED /* XXX */ /* The state passed by an exception message. */ struct exc_state -{ - int exception; /* The exception code */ - int code, subcode; - mach_port_t handler; /* The real exception port to handle this. */ - mach_port_t reply; /* The reply port from the exception call. */ -}; + { + int exception; /* The exception code */ + int code, subcode; + mach_port_t handler; /* The real exception port to handle this. */ + mach_port_t reply; /* The reply port from the exception call. */ + }; /* The results of the last wait an inf did. */ struct inf_wait -{ - struct target_waitstatus status; /* The status returned to gdb. */ - struct exc_state exc; /* The exception that caused us to return. */ - struct proc *thread; /* The thread in question. */ - int suppress; /* Something trivial happened. */ -}; + { + struct target_waitstatus status; /* The status returned to gdb. */ + struct exc_state exc; /* The exception that caused us to return. */ + struct proc *thread; /* The thread in question. */ + int suppress; /* Something trivial happened. */ + }; /* The state of an inferior. */ struct inf -{ - /* Fields describing the current inferior. */ + { + /* Fields describing the current inferior. */ - struct proc *task; /* The mach task. */ - struct proc *threads; /* A linked list of all threads in TASK. */ + struct proc *task; /* The mach task. */ + struct proc *threads; /* A linked list of all threads in TASK. */ - /* True if THREADS needn't be validated by querying the task. We assume that - we and the task in question are the only ones frobbing the thread list, - so as long as we don't let any code run, we don't have to worry about - THREADS changing. */ - int threads_up_to_date; + /* True if THREADS needn't be validated by querying the task. We assume that + we and the task in question are the only ones frobbing the thread list, + so as long as we don't let any code run, we don't have to worry about + THREADS changing. */ + int threads_up_to_date; - pid_t pid; /* The real system PID. */ + pid_t pid; /* The real system PID. */ - struct inf_wait wait; /* What to return from target_wait. */ + struct inf_wait wait; /* What to return from target_wait. */ - /* One thread proc in INF may be in `single-stepping mode'. This is it. */ - struct proc *step_thread; + /* One thread proc in INF may be in `single-stepping mode'. This is it. */ + struct proc *step_thread; - /* The thread we think is the signal thread. */ - struct proc *signal_thread; + /* The thread we think is the signal thread. */ + struct proc *signal_thread; - mach_port_t event_port; /* Where we receive various msgs. */ + mach_port_t event_port; /* Where we receive various msgs. */ - /* True if we think at least one thread in the inferior could currently be - running. */ - unsigned int running : 1; + /* True if we think at least one thread in the inferior could currently be + running. */ + unsigned int running:1; - /* True if the process has stopped (in the proc server sense). Note that - since a proc server `stop' leaves the signal thread running, the inf can - be RUNNING && STOPPED... */ - unsigned int stopped : 1; + /* True if the process has stopped (in the proc server sense). Note that + since a proc server `stop' leaves the signal thread running, the inf can + be RUNNING && STOPPED... */ + unsigned int stopped:1; - /* True if the inferior has no message port. */ - unsigned int nomsg : 1; + /* True if the inferior has no message port. */ + unsigned int nomsg:1; - /* True if the inferior is traced. */ - unsigned int traced : 1; + /* True if the inferior is traced. */ + unsigned int traced:1; - /* True if we shouldn't try waiting for the inferior, usually because we - can't for some reason. */ - unsigned int no_wait : 1; + /* True if we shouldn't try waiting for the inferior, usually because we + can't for some reason. */ + unsigned int no_wait:1; - /* When starting a new inferior, we don't try to validate threads until all - the proper execs have been done. This is a count of how many execs we - expect to happen. */ - unsigned pending_execs; + /* When starting a new inferior, we don't try to validate threads until all + the proper execs have been done. This is a count of how many execs we + expect to happen. */ + unsigned pending_execs; - /* Fields describing global state */ + /* Fields describing global state */ - /* The task suspend count used when gdb has control. This is normally 1 to - make things easier for us, but sometimes (like when attaching to vital - system servers) it may be desirable to let the task continue to run - (pausing individual threads as necessary). */ - int pause_sc; + /* The task suspend count used when gdb has control. This is normally 1 to + make things easier for us, but sometimes (like when attaching to vital + system servers) it may be desirable to let the task continue to run + (pausing individual threads as necessary). */ + int pause_sc; - /* The task suspend count left when detaching from a task. */ - int detach_sc; + /* The task suspend count left when detaching from a task. */ + int detach_sc; - /* The initial values used for the run_sc and pause_sc of newly discovered - threads -- see the definition of those fields in struct proc. */ - int default_thread_run_sc; - int default_thread_pause_sc; - int default_thread_detach_sc; + /* The initial values used for the run_sc and pause_sc of newly discovered + threads -- see the definition of those fields in struct proc. */ + int default_thread_run_sc; + int default_thread_pause_sc; + int default_thread_detach_sc; - /* True if the process should be traced when started/attached. Newly - started processes *must* be traced at first to exec them properly, but - if this is false, tracing is turned off as soon it has done so. */ - int want_signals; + /* True if the process should be traced when started/attached. Newly + started processes *must* be traced at first to exec them properly, but + if this is false, tracing is turned off as soon it has done so. */ + int want_signals; - /* True if exceptions from the inferior process should be trapped. This - must be on to use breakpoints. */ - int want_exceptions; -}; + /* True if exceptions from the inferior process should be trapped. This + must be on to use breakpoints. */ + int want_exceptions; + }; -int __proc_pid (struct proc *proc) +int +__proc_pid (struct proc *proc) { return proc->inf->pid; } @@ -256,7 +258,7 @@ int proc_update_sc (struct proc *proc) { int running; - int err = 0; + int err = 0; int delta = proc->sc - proc->cur_sc; if (delta) @@ -268,8 +270,8 @@ proc_update_sc (struct proc *proc) assert (proc_is_thread (proc)); proc_debug (proc, "storing back changed thread state"); err = thread_set_state (proc->port, THREAD_STATE_FLAVOR, - (thread_state_t)&proc->state, THREAD_STATE_SIZE); - if (! err) + (thread_state_t) & proc->state, THREAD_STATE_SIZE); + if (!err) proc->state_changed = 0; } @@ -286,7 +288,7 @@ proc_update_sc (struct proc *proc) else err = thread_resume (proc->port); - if (! err) + if (!err) proc->cur_sc = proc->sc; /* If we got an error, then the task/thread has disappeared. */ @@ -315,7 +317,7 @@ proc_abort (struct proc *proc, int force) { assert (proc_is_thread (proc)); - if (! proc->aborted) + if (!proc->aborted) { struct inf *inf = proc->inf; int running = (proc->cur_sc == 0 && inf->task->cur_sc == 0); @@ -331,7 +333,7 @@ proc_abort (struct proc *proc, int force) /* An exception is pending on PROC, which don't mess with. */ running = 1; - if (! running) + if (!running) /* We only abort the thread if it's not actually running. */ { thread_abort (proc->port); @@ -357,16 +359,16 @@ proc_get_state (struct proc *proc, int will_modify) proc_abort (proc, will_modify); - if (! was_aborted && proc->aborted) + if (!was_aborted && proc->aborted) /* PROC's state may have changed since we last fetched it. */ proc->state_valid = 0; - if (! proc->state_valid) + if (!proc->state_valid) { mach_msg_type_number_t state_size = THREAD_STATE_SIZE; error_t err = - thread_get_state (proc->port, THREAD_STATE_FLAVOR, - (thread_state_t)&proc->state, &state_size); + thread_get_state (proc->port, THREAD_STATE_FLAVOR, + (thread_state_t) & proc->state, &state_size); proc_debug (proc, "getting thread state"); proc->state_valid = !err; } @@ -375,7 +377,7 @@ 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; @@ -383,7 +385,7 @@ proc_get_state (struct proc *proc, int will_modify) /* Set PORT to PROC's exception port. */ error_t -proc_get_exception_port (struct proc *proc, mach_port_t *port) +proc_get_exception_port (struct proc * proc, mach_port_t * port) { if (proc_is_task (proc)) return task_get_exception_port (proc->port, port); @@ -393,7 +395,7 @@ proc_get_exception_port (struct proc *proc, mach_port_t *port) /* Set PROC's exception port to PORT. */ error_t -proc_set_exception_port (struct proc *proc, mach_port_t port) +proc_set_exception_port (struct proc * proc, mach_port_t port) { proc_debug (proc, "setting exception port: %d", port); if (proc_is_task (proc)) @@ -502,15 +504,15 @@ proc_trace (struct proc *proc, int set) { thread_state_t state = proc_get_state (proc, 1); - if (! state) + if (!state) return 0; /* the thread must be dead. */ proc_debug (proc, "tracing %s", set ? "on" : "off"); - + if (set) { /* XXX We don't get the exception unless the thread has its own - exception port???? */ + exception port???? */ if (proc->exc_port == MACH_PORT_NULL) proc_steal_exc_port (proc, proc->inf->event_port); THREAD_STATE_SET_TRACED (state); @@ -559,7 +561,7 @@ make_proc (struct inf *inf, mach_port_t port, int tid) /* Get notified when things die. */ err = - mach_port_request_notification (mach_task_self(), port, + mach_port_request_notification (mach_task_self (), port, MACH_NOTIFY_DEAD_NAME, 1, inf->event_port, MACH_MSG_TYPE_MAKE_SEND_ONCE, @@ -621,7 +623,8 @@ _proc_free (struct proc *proc) return next; } -struct inf *make_inf () +struct inf * +make_inf () { struct inf *inf = malloc (sizeof (struct inf)); @@ -721,7 +724,7 @@ inf_startup (struct inf *inf, int pid) } /* close current process, if any, and attach INF to process PORT */ -void +void inf_set_pid (struct inf *inf, pid_t pid) { task_t task_port; @@ -760,7 +763,7 @@ 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 */ + inf->task->sc = inf->task->cur_sc = 1; /* Reflect task_suspend above */ } else inf->pid = -1; @@ -779,18 +782,18 @@ inf_validate_procinfo (struct inf *inf) mach_msg_type_number_t pi_len = 0; int info_flags = 0; error_t err = - proc_getprocinfo (proc_server, inf->pid, &info_flags, - (procinfo_t *)&pi, &pi_len, &noise, &noise_len); + proc_getprocinfo (proc_server, inf->pid, &info_flags, + (procinfo_t *) & pi, &pi_len, &noise, &noise_len); - if (! err) + if (!err) { inf->stopped = !!(pi->state & PI_STOPPED); inf->nomsg = !!(pi->state & PI_NOMSG); if (inf->nomsg) inf->traced = !!(pi->state & PI_TRACED); - vm_deallocate (mach_task_self (), (vm_address_t)pi, pi_len); + vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len); if (noise_len > 0) - vm_deallocate (mach_task_self (), (vm_address_t)noise, noise_len); + vm_deallocate (mach_task_self (), (vm_address_t) noise, noise_len); } } @@ -802,7 +805,7 @@ 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); + task_info (inf->task->port, TASK_BASIC_INFO, (task_info_t) & info, &info_len); if (err) inf->task->dead = 1; /* oh well */ @@ -814,7 +817,7 @@ inf_validate_task_sc (struct inf *inf) abort = !query ("Pid %d has an additional task suspend count of %d; clear it? ", inf->pid, info.suspend_count - inf->task->cur_sc); - target_terminal_inferior (); /* Give it back to the child. */ + target_terminal_inferior (); /* Give it back to the child. */ if (abort) error ("Additional task suspend count left untouched."); @@ -833,10 +836,10 @@ inf_set_traced (struct inf *inf, int on) if (inf->task && !inf->task->dead) /* Make it take effect immediately. */ { - sigset_t mask = on ? ~(sigset_t)0 : 0; + 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)); + INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport, + INIT_TRACEMASK, mask)); if (err == EIEIO) { if (on) @@ -856,7 +859,7 @@ inf_set_traced (struct inf *inf, int 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.*/ + safe order. Returns true if at least one thread is thought to be running. */ int inf_update_suspends (struct inf *inf) { @@ -896,7 +899,7 @@ inf_update_suspends (struct inf *inf) inf->running = thread_running && task_running; /* Once any thread has executed some code, we can't depend on the - threads list any more. */ + threads list any more. */ if (inf->running) inf->threads_up_to_date = 0; @@ -984,7 +987,7 @@ inf_validate_procs (struct inf *inf) for (i = search_start, left = num_threads; left; i++, left--) { if (i >= num_threads) - i -= num_threads; /* I wrapped around. */ + i -= num_threads; /* I wrapped around. */ if (thread->port == threads[i]) /* We already know about this thread. */ { @@ -996,11 +999,11 @@ inf_validate_procs (struct inf *inf) } } - if (! left) + if (!left) { proc_debug (thread, "died!"); thread->port = MACH_PORT_NULL; - thread = _proc_free (thread); /* THREAD is dead. */ + thread = _proc_free (thread); /* THREAD is dead. */ (last ? last->next : inf->threads) = thread; } } @@ -1016,11 +1019,11 @@ inf_validate_procs (struct inf *inf) (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. */ + add_thread (thread->tid); /* Tell GDB's generic thread code. */ } - vm_deallocate(mach_task_self(), - (vm_address_t)threads, (num_threads * sizeof(thread_t))); + vm_deallocate (mach_task_self (), + (vm_address_t) threads, (num_threads * sizeof (thread_t))); } } @@ -1028,9 +1031,9 @@ inf_validate_procs (struct inf *inf) inline int inf_update_procs (struct inf *inf) { - if (! inf->task) + if (!inf->task) return 0; - if (! inf->threads_up_to_date) + if (!inf->threads_up_to_date) inf_validate_procs (inf); return !!inf->task; } @@ -1038,7 +1041,7 @@ inf_update_procs (struct inf *inf) /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0, and others are set to their run_sc if RUN_OTHERS is true, and otherwise their pause_sc. */ -inline void +inline void inf_set_threads_resume_sc (struct inf *inf, struct proc *run_thread, int run_others) { @@ -1067,7 +1070,7 @@ inf_resume (struct inf *inf) if (inf->task) { - if (! inf->pending_execs) + if (!inf->pending_execs) /* Try to make sure our task count is correct -- in the case where we're waiting for an exec though, things are too volatile, so just assume things will be reasonable (which they usually will be). */ @@ -1112,7 +1115,7 @@ inf_set_step_thread (struct inf *inf, struct proc *thread) if (inf->step_thread != thread) { if (inf->step_thread && inf->step_thread->port != MACH_PORT_NULL) - if (! proc_trace (inf->step_thread, 0)) + if (!proc_trace (inf->step_thread, 0)) return; if (thread && proc_trace (thread, 1)) inf->step_thread = thread; @@ -1199,7 +1202,8 @@ inf_attach (struct inf *inf, int pid) } /* Makes sure that we've got our exception ports entrenched in the process. */ -void inf_steal_exc_ports (struct inf *inf) +void +inf_steal_exc_ports (struct inf *inf) { struct proc *thread; @@ -1213,7 +1217,8 @@ void inf_steal_exc_ports (struct inf *inf) } /* Makes sure the process has its own exception ports. */ -void inf_restore_exc_ports (struct inf *inf) +void +inf_restore_exc_ports (struct inf *inf) { struct proc *thread; @@ -1269,37 +1274,37 @@ inf_signal (struct inf *inf, enum target_signal sig) } else /* A Unix signal. */ - if (inf->stopped) - /* The process is stopped and expecting a signal. Just send off a - request and let it get handled when we resume everything. */ - { - inf_debug (inf, "sending %s to stopped process", NAME); - err = - INF_MSGPORT_RPC (inf, - msg_sig_post_untraced_request (msgport, - inf->event_port, - MACH_MSG_TYPE_MAKE_SEND_ONCE, - host_sig, 0, - refport)); - if (! err) - /* Posting an untraced signal automatically continues it. - We clear this here rather than when we get the reply - because we'd rather assume it's not stopped when it - actually is, than the reverse. */ - inf->stopped = 0; - } - else - /* It's not expecting it. We have to let just the signal thread - run, and wait for it to get into a reasonable state before we - can continue the rest of the process. When we finally resume the - process the signal we request will be the very first thing that - happens. */ - { - inf_debug (inf, "sending %s to unstopped process (so resuming signal thread)", NAME); - err = - INF_RESUME_MSGPORT_RPC (inf, msg_sig_post_untraced (msgport, - host_sig, 0, refport)); - } + if (inf->stopped) + /* The process is stopped and expecting a signal. Just send off a + request and let it get handled when we resume everything. */ + { + inf_debug (inf, "sending %s to stopped process", NAME); + err = + INF_MSGPORT_RPC (inf, + msg_sig_post_untraced_request (msgport, + inf->event_port, + MACH_MSG_TYPE_MAKE_SEND_ONCE, + host_sig, 0, + refport)); + if (!err) + /* Posting an untraced signal automatically continues it. + We clear this here rather than when we get the reply + because we'd rather assume it's not stopped when it + actually is, than the reverse. */ + inf->stopped = 0; + } + else + /* It's not expecting it. We have to let just the signal thread + run, and wait for it to get into a reasonable state before we + can continue the rest of the process. When we finally resume the + process the signal we request will be the very first thing that + happens. */ + { + inf_debug (inf, "sending %s to unstopped process (so resuming signal thread)", NAME); + err = + INF_RESUME_MSGPORT_RPC (inf, msg_sig_post_untraced (msgport, + host_sig, 0, refport)); + } if (err == EIEIO) /* Can't do too much... */ @@ -1318,18 +1323,18 @@ inf_continue (struct inf *inf) process_t proc; error_t err = proc_pid2proc (proc_server, inf->pid, &proc); - if (! err) + if (!err) { inf_debug (inf, "continuing process"); err = proc_mark_cont (proc); - if (! err) + if (!err) { struct proc *thread; for (thread = inf->threads; thread; thread = thread->next) thread_resume (thread->port); - + inf->stopped = 0; } } @@ -1349,11 +1354,13 @@ struct inf *waiting_inf; static int gnu_wait (int tid, struct target_waitstatus *status) { - struct msg { - mach_msg_header_t hdr; - mach_msg_type_t type; - int data[8000]; - } msg; + struct msg + { + mach_msg_header_t hdr; + mach_msg_type_t type; + int data[8000]; + } + msg; error_t err; struct proc *thread; struct inf *inf = current_inferior; @@ -1374,7 +1381,7 @@ gnu_wait (int tid, struct target_waitstatus *status) inf_debug (inf, "waiting for: %d", tid); - rewait: +rewait: if (proc_wait_pid != inf->pid && !inf->no_wait) /* Always get information on events from the proc server. */ { @@ -1399,7 +1406,7 @@ gnu_wait (int tid, struct target_waitstatus *status) /* 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.*/ + which is the wait reply port, changes when you switch processes. */ proc_waits_pending = 1; } } @@ -1429,20 +1436,22 @@ gnu_wait (int tid, struct target_waitstatus *status) error ("Couldn't wait for an event: %s", strerror (err)); else { - struct { - mach_msg_header_t hdr; - mach_msg_type_t err_type; - kern_return_t err; - char noise[200]; - } reply; + struct + { + mach_msg_header_t hdr; + mach_msg_type_t err_type; + kern_return_t err; + char noise[200]; + } + reply; inf_debug (inf, "event: msgid = %d", msg.hdr.msgh_id); /* Handle what we got. */ - if (! notify_server (&msg.hdr, &reply.hdr) - && ! exc_server (&msg.hdr, &reply.hdr) - && ! process_reply_server (&msg.hdr, &reply.hdr) - && ! msg_reply_server (&msg.hdr, &reply.hdr)) + if (!notify_server (&msg.hdr, &reply.hdr) + && !exc_server (&msg.hdr, &reply.hdr) + && !process_reply_server (&msg.hdr, &reply.hdr) + && !msg_reply_server (&msg.hdr, &reply.hdr)) /* Whatever it is, it's something strange. */ error ("Got a strange event, msg id = %d.", msg.hdr.msgh_id); @@ -1474,9 +1483,9 @@ gnu_wait (int tid, struct target_waitstatus *status) if (--inf->pending_execs == 0) /* We're done! */ { -#if 0 /* do we need this? */ +#if 0 /* do we need this? */ prune_threads (1); /* Get rid of the old shell threads */ - renumber_threads (0); /* Give our threads reasonable names. */ + renumber_threads (0); /* Give our threads reasonable names. */ #endif } inf_debug (inf, "pending exec completed, pending_execs => %d", @@ -1514,7 +1523,7 @@ gnu_wait (int tid, struct target_waitstatus *status) 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 = inferior_pid; /* let wait_for_inferior handle exit case */ if (thread && tid >= 0 && status->kind != TARGET_WAITKIND_SPURIOUS && inf->pause_sc == 0 && thread->pause_sc == 0) @@ -1522,7 +1531,7 @@ gnu_wait (int tid, struct target_waitstatus *status) { thread->sc = 1; inf_update_suspends (inf); - } + } inf_debug (inf, "returning tid = %d, status = %s (%d)", tid, status->kind == TARGET_WAITKIND_EXITED ? "EXITED" @@ -1562,7 +1571,7 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port, mach_port_deallocate (mach_task_self (), thread_port); mach_port_deallocate (mach_task_self (), task_port); - if (! thread->aborted) + if (!thread->aborted) /* THREAD hasn't been aborted since this exception happened (abortion clears any exception state), so it must be real. */ { @@ -1662,7 +1671,7 @@ do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port) } 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; } @@ -1815,7 +1824,7 @@ 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; @@ -1838,7 +1847,7 @@ port_msgs_queued (mach_port_t port) Note that a resume may not `take' if there are pending exceptions/&c still unprocessed from the last resume we did (any given resume may result in multiple events returned by wait). -*/ + */ static void gnu_resume (int tid, int step, enum target_signal sig) { @@ -1848,7 +1857,7 @@ gnu_resume (int tid, int step, enum target_signal sig) inf_debug (inf, "tid = %d, step = %d, sig = %d", tid, step, sig); inf_validate_procinfo (inf); - + if (sig != TARGET_SIGNAL_0 || inf->stopped) { if (sig == TARGET_SIGNAL_0 && inf->nomsg) @@ -1884,7 +1893,7 @@ gnu_resume (int tid, int step, enum target_signal sig) /* Just allow a single thread to run. */ { struct proc *thread = inf_tid_to_thread (inf, tid); - if (! thread) + 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); inf_set_threads_resume_sc (inf, thread, 0); @@ -1893,7 +1902,7 @@ gnu_resume (int tid, int step, enum target_signal sig) if (step) { step_thread = inf_tid_to_thread (inf, tid); - if (! step_thread) + if (!step_thread) warning ("Can't step thread id %d: no such thread.", tid); else inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid); @@ -1946,7 +1955,7 @@ inf_pick_first_thread () static struct inf * cur_inf () { - if (! current_inferior) + if (!current_inferior) current_inferior = make_inf (); return current_inferior; } @@ -1960,33 +1969,33 @@ gnu_create_inferior (exec_file, allargs, env) struct inf *inf = cur_inf (); void trace_me () - { - /* We're in the child; make this process stop as soon as it execs. */ - inf_debug (inf, "tracing self"); - if (ptrace (PTRACE_TRACEME) != 0) - error ("ptrace (PTRACE_TRACEME) failed!"); - } + { + /* We're in the child; make this process stop as soon as it execs. */ + inf_debug (inf, "tracing self"); + if (ptrace (PTRACE_TRACEME) != 0) + error ("ptrace (PTRACE_TRACEME) failed!"); + } void attach_to_child (int pid) - { - /* Attach to the now stopped child, which is actually a shell... */ - inf_debug (inf, "attaching to child: %d", pid); + { + /* Attach to the now stopped child, which is actually a shell... */ + inf_debug (inf, "attaching to child: %d", pid); - inf_attach (inf, pid); + inf_attach (inf, pid); - attach_flag = 0; - push_target (&gnu_ops); + attach_flag = 0; + push_target (&gnu_ops); - inf->pending_execs = 2; - inf->nomsg = 1; - inf->traced = 1; + inf->pending_execs = 2; + inf->nomsg = 1; + inf->traced = 1; - /* Now let the child run again, knowing that it will stop immediately - because of the ptrace. */ - inf_resume (inf); - inferior_pid = inf_pick_first_thread (); + /* Now let the child run again, knowing that it will stop immediately + because of the ptrace. */ + inf_resume (inf); + inferior_pid = inf_pick_first_thread (); - startup_inferior (inf->pending_execs); - } + startup_inferior (inf->pending_execs); + } inf_debug (inf, "creating inferior"); @@ -2005,7 +2014,7 @@ gnu_create_inferior (exec_file, allargs, env) inf_restore_exc_ports (inf); /* Here we go! */ - proceed ((CORE_ADDR) -1, 0, 0); + proceed ((CORE_ADDR) - 1, 0, 0); } /* Mark our target-struct as eligible for stray "run" and "attach" @@ -2034,7 +2043,7 @@ gnu_attach (args, from_tty) pid = atoi (args); - if (pid == getpid()) /* Trying to masturbate? */ + if (pid == getpid ()) /* Trying to masturbate? */ error ("I refuse to debug myself!"); if (from_tty) @@ -2063,7 +2072,7 @@ gnu_attach (args, from_tty) /* We have to initialize the terminal settings now, since the code below might try to restore them. */ target_terminal_init (); - + /* If the process was stopped before we attached, make it continue the next time the user does a continue. */ inf_validate_procinfo (inf); @@ -2071,7 +2080,7 @@ gnu_attach (args, from_tty) inf_update_signal_thread (inf); inf_set_traced (inf, inf->want_signals); -#if 0 /* Do we need this? */ +#if 0 /* Do we need this? */ renumber_threads (0); /* Give our threads reasonable names. */ #endif } @@ -2098,12 +2107,12 @@ gnu_detach (args, from_tty) printf_unfiltered ("Detaching from pid %d\n", current_inferior->pid); gdb_flush (gdb_stdout); } - + inf_detach (current_inferior); inferior_pid = 0; - unpush_target (&gnu_ops); /* Pop out of handling an inferior */ + unpush_target (&gnu_ops); /* Pop out of handling an inferior */ } #endif /* ATTACH_DETACH */ @@ -2148,7 +2157,7 @@ gnu_pid_to_exec_file () error ("to_pid_to_exec_file target function not implemented"); return NULL; } - + static int gnu_thread_alive (int tid) @@ -2173,16 +2182,16 @@ gnu_read_inferior (task, addr, myaddr, length) error_t err; vm_address_t low_address = (vm_address_t) trunc_page (addr); vm_size_t aligned_length = - (vm_size_t) round_page (addr+length) - low_address; - pointer_t copied; - int copy_count; + (vm_size_t) round_page (addr + length) - low_address; + pointer_t copied; + int copy_count; /* Get memory from inferior with page aligned addresses */ err = vm_read (task, low_address, aligned_length, &copied, ©_count); if (err) return 0; - err = hurd_safe_copyin (myaddr, (void*)addr - low_address + copied, length); + err = hurd_safe_copyin (myaddr, (void *) addr - low_address + copied, length); if (err) { warning ("Read from inferior faulted: %s", strerror (err)); @@ -2199,14 +2208,15 @@ gnu_read_inferior (task, addr, myaddr, length) #define CHK_GOTO_OUT(str,ret) \ do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0) -struct vm_region_list { +struct vm_region_list +{ struct vm_region_list *next; - vm_prot_t protection; - vm_address_t start; - vm_size_t length; + vm_prot_t protection; + vm_address_t start; + vm_size_t length; }; -struct obstack region_obstack; +struct obstack region_obstack; /* * Write gdb's LEN bytes from MYADDR and copy it to ADDR @@ -2220,17 +2230,17 @@ gnu_write_inferior (task, addr, myaddr, length) int length; { error_t err = 0; - vm_address_t low_address = (vm_address_t) trunc_page (addr); - vm_size_t aligned_length = - (vm_size_t) round_page (addr+length) - low_address; - pointer_t copied; - int copy_count; - int deallocate = 0; + vm_address_t low_address = (vm_address_t) trunc_page (addr); + vm_size_t aligned_length = + (vm_size_t) round_page (addr + length) - low_address; + pointer_t copied; + int copy_count; + int deallocate = 0; - char *errstr = "Bug in gnu_write_inferior"; + char *errstr = "Bug in gnu_write_inferior"; struct vm_region_list *region_element; - struct vm_region_list *region_head = (struct vm_region_list *)NULL; + struct vm_region_list *region_head = (struct vm_region_list *) NULL; /* Get memory from inferior with page aligned addresses */ err = vm_read (task, @@ -2242,7 +2252,7 @@ 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); @@ -2251,12 +2261,12 @@ gnu_write_inferior (task, addr, myaddr, length) * First check for holes and unwritable memory. */ { - vm_size_t remaining_length = aligned_length; - vm_address_t region_address = low_address; + vm_size_t remaining_length = aligned_length; + vm_address_t region_address = low_address; struct vm_region_list *scan; - while(region_address < low_address + aligned_length) + while (region_address < low_address + aligned_length) { vm_prot_t protection; vm_prot_t max_protection; @@ -2264,9 +2274,9 @@ gnu_write_inferior (task, addr, myaddr, length) boolean_t shared; mach_port_t object_name; vm_offset_t offset; - vm_size_t region_length = remaining_length; - vm_address_t old_address = region_address; - + vm_size_t region_length = remaining_length; + vm_address_t old_address = region_address; + err = vm_region (task, ®ion_address, ®ion_length, @@ -2298,18 +2308,18 @@ gnu_write_inferior (task, addr, myaddr, length) } /* Chain the regions for later use */ - region_element = + region_element = (struct vm_region_list *) - obstack_alloc (®ion_obstack, sizeof (struct vm_region_list)); - + obstack_alloc (®ion_obstack, sizeof (struct vm_region_list)); + region_element->protection = protection; - region_element->start = region_address; - region_element->length = region_length; + region_element->start = region_address; + region_element->length = region_length; /* Chain the regions along with protections */ region_element->next = region_head; - region_head = region_element; - + region_head = region_element; + region_address += region_length; remaining_length = remaining_length - region_length; } @@ -2317,12 +2327,12 @@ gnu_write_inferior (task, addr, myaddr, length) /* If things fail after this, we give up. * Somebody is messing up inferior_task's mappings. */ - + /* Enable writes to the chained vm regions */ for (scan = region_head; scan; scan = scan->next) { boolean_t protection_changed = FALSE; - + if (!(scan->protection & VM_PROT_WRITE)) { err = vm_protect (task, @@ -2339,12 +2349,12 @@ gnu_write_inferior (task, addr, myaddr, length) copied, aligned_length); CHK_GOTO_OUT ("vm_write failed", err); - + /* Set up the original region protections, if they were changed */ for (scan = region_head; scan; scan = scan->next) { boolean_t protection_changed = FALSE; - + if (!(scan->protection & VM_PROT_WRITE)) { err = vm_protect (task, @@ -2357,11 +2367,11 @@ gnu_write_inferior (task, addr, myaddr, length) } } - out: +out: if (deallocate) { obstack_free (®ion_obstack, 0); - + (void) vm_deallocate (mach_task_self (), copied, copy_count); @@ -2387,9 +2397,9 @@ gnu_xfer_memory (memaddr, myaddr, len, write, target) { int result; task_t task = - current_inferior - ? (current_inferior->task ? current_inferior->task->port : 0) - : 0; + current_inferior + ? (current_inferior->task ? current_inferior->task->port : 0) + : 0; if (task == MACH_PORT_NULL) return 0; @@ -2401,85 +2411,86 @@ gnu_xfer_memory (memaddr, myaddr, len, write, target) if (write) return gnu_write_inferior (task, memaddr, myaddr, len); else - return gnu_read_inferior (task, memaddr, myaddr, len); + return gnu_read_inferior (task, memaddr, myaddr, len); } } extern void gnu_store_registers (int regno); extern void gnu_fetch_registers (int regno); -struct target_ops gnu_ops ; +struct target_ops gnu_ops; static void -init_gnu_ops(void) -{ - gnu_ops.to_shortname = "GNU"; /* to_shortname */ - gnu_ops.to_longname = "GNU Hurd process"; /* to_longname */ - gnu_ops.to_doc = "GNU Hurd process"; /* to_doc */ - gnu_ops.to_open = gnu_open; /* to_open */ - gnu_ops.to_close = 0; /* to_close */ - gnu_ops.to_attach = gnu_attach; /* to_attach */ +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_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_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_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_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 */ + gnu_ops.to_stratum = process_stratum; /* to_stratum */ + gnu_ops.DONT_USE = 0; /* to_next */ + gnu_ops.to_has_all_memory = 1; /* to_has_all_memory */ + gnu_ops.to_has_memory = 1; /* to_has_memory */ + gnu_ops.to_has_stack = 1; /* to_has_stack */ + gnu_ops.to_has_registers = 1; /* to_has_registers */ + gnu_ops.to_has_execution = 1; /* to_has_execution */ + gnu_ops.to_sections = 0; /* sections */ + gnu_ops.to_sections_end = 0; /* sections_end */ + gnu_ops.to_magic = OPS_MAGIC; /* to_magic */ +} /* init_gnu_ops */ /* Return printable description of proc. */ -char *proc_string (struct proc *proc) +char * +proc_string (struct proc *proc) { static char tid_str[80]; if (proc_is_task (proc)) @@ -2596,7 +2607,7 @@ static struct inf * active_inf () { struct inf *inf = cur_inf (); - if (! inf->task) + if (!inf->task) error ("No current process."); return inf; } @@ -2716,14 +2727,14 @@ steal_exc_port (struct proc *proc, mach_port_t name) proc->saved_exc_port = port; - if (! proc->exc_port) + if (!proc->exc_port) /* If PROC is a thread, we may not have set its exception port before. We can't use proc_steal_exc_port because it also sets saved_exc_port. */ { - proc->exc_port = proc->inf->event_port; - err = proc_set_exception_port (proc, proc->exc_port); - error ("Can't set exception port for %s: %s", - proc_string (proc), strerror (err)); + proc->exc_port = proc->inf->event_port; + err = proc_set_exception_port (proc, proc->exc_port); + error ("Can't set exception port for %s: %s", + proc_string (proc), strerror (err)); } } @@ -2736,7 +2747,7 @@ set_task_exc_port_cmd (char *args, int from_tty) steal_exc_port (inf->task, parse_and_eval_address (args)); } -static void +static void set_stopped_cmd (char *args, int from_tty) { cur_inf ()->stopped = _parse_bool_arg (args, "yes", "no", "set stopped"); @@ -2751,13 +2762,13 @@ show_stopped_cmd (char *args, int from_tty) inf->stopped ? "is" : "isn't"); } -static void +static void set_sig_thread_cmd (char *args, int from_tty) { int tid; struct inf *inf = cur_inf (); - if (!args || (! isdigit (*args) && strcmp (args, "none") != 0)) + 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'."); @@ -2785,7 +2796,7 @@ show_sig_thread_cmd (char *args, int from_tty) printf_unfiltered ("There is no signal thread.\n"); } -static void +static void set_signals_cmd (char *args, int from_tty) { int trace; @@ -2809,7 +2820,7 @@ show_signals_cmd (char *args, int from_tty) : (inf->want_signals ? "will be" : "won't be")); } -static void +static void set_exceptions_cmd (char *args, int from_tty) { struct inf *inf = cur_inf (); @@ -2817,7 +2828,7 @@ set_exceptions_cmd (char *args, int from_tty) if (inf->task && inf->want_exceptions != val) /* Make this take effect immediately in a running process. */ - /* XXX */; + /* XXX */ ; inf->want_exceptions = val; } @@ -2891,8 +2902,8 @@ info_port_rights (char *args, mach_port_type_t only) value_ptr 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)); } @@ -2901,8 +2912,8 @@ info_port_rights (char *args, mach_port_type_t only) /* 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)); } @@ -2936,22 +2947,23 @@ info_port_rights_cmd (char *args, int from_tty) info_port_rights (args, ~0); } -static void add_task_commands () +static void +add_task_commands () { add_cmd ("pause", class_run, set_thread_default_pause_cmd, - "Set whether the new threads are suspended while gdb has control.\n" + "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" + "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.", &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).", + "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).", + "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.", @@ -2961,18 +2973,18 @@ static void add_task_commands () &show_thread_default_cmd_list); add_cmd ("signals", class_run, set_signals_cmd, - "Set whether the inferior process's signals will be intercepted.\n" + "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.", + "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.", + "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, @@ -2981,22 +2993,22 @@ static void add_task_commands () 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" + "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.", + "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" + "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.", + "Show whether exceptions in the inferior process will be trapped.", &showlist); add_prefix_cmd ("task", no_class, set_task_cmd, @@ -3081,7 +3093,7 @@ show_thread_pause_cmd (char *args, int from_tty) printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n", proc_string (thread), sc ? "is" : "isn't", - !sc && thread->inf->pause_sc ? " (but the task is)" : ""); + !sc && thread->inf->pause_sc ? " (but the task is)" : ""); } static void @@ -3147,14 +3159,14 @@ thread_takeover_sc_cmd (char *args, int from_tty) thread_basic_info_t info = &_info; mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT; error_t err = - thread_info (thread->port, THREAD_BASIC_INFO, (int *)&info, &info_len); + thread_info (thread->port, THREAD_BASIC_INFO, (int *) &info, &info_len); if (err) error ("%s.", strerror (err)); 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 () @@ -3175,15 +3187,15 @@ add_thread_commands () &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" + "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" + "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\".", &set_thread_cmd_list); add_cmd ("pause", no_class, show_thread_pause_cmd, - "Show whether the current thread is suspended while gdb has control.", + "Show whether the current thread is suspended while gdb has control.", &show_thread_cmd_list); add_cmd ("run", class_run, set_thread_run_cmd, @@ -3215,7 +3227,7 @@ add_thread_commands () 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.", + "the thread's initial suspend-count when gdb notices the threads.", &thread_cmd_list); } @@ -3223,14 +3235,14 @@ void _initialize_gnu_nat () { proc_server = getproc (); - init_gnu_ops() ; + init_gnu_ops (); add_target (&gnu_ops); add_task_commands (); add_thread_commands (); add_set_cmd ("gnu-debug", class_maintenance, - var_boolean, (char *)&gnu_debug_flag, - "Set debugging output for the gnu backend.", &maintenancelist); + var_boolean, (char *) &gnu_debug_flag, + "Set debugging output for the gnu backend.", &maintenancelist); } #ifdef FLUSH_INFERIOR_CACHE @@ -3241,12 +3253,12 @@ _initialize_gnu_nat () end up looping in mysterious Bpt traps */ void -flush_inferior_icache(pc, amount) +flush_inferior_icache (pc, amount) CORE_ADDR pc; { vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH; - error_t ret; - + error_t ret; + ret = vm_machine_attribute (current_inferior->task->port, pc, amount, @@ -3255,4 +3267,4 @@ flush_inferior_icache(pc, amount) if (ret != KERN_SUCCESS) warning ("Error flushing inferior's cache : %s", strerror (ret)); } -#endif FLUSH_INFERIOR_CACHE +#endif /* FLUSH_INFERIOR_CACHE */ |