/* Interface GDB to the GNU Hurd.
- Copyright (C) 1992, 95, 96, 97, 1999, 2000 Free Software Foundation, Inc.
+ Copyright 1992, 1995, 1996, 1997, 1998, 1999, 2000
+ Free Software Foundation, Inc.
This file is part of GDB.
Boston, MA 02111-1307, USA.
*/
-#include <assert.h>
+#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <setjmp.h>
#include "gdbcmd.h"
#include "gdbcore.h"
#include "gdbthread.h"
+#include "gdb_assert.h"
#include "gnu-nat.h"
if (proc->sc == 0 && proc->state_changed)
/* Since PROC may start running, we must write back any state changes. */
{
- assert (proc_is_thread (proc));
+ gdb_assert (proc_is_thread (proc));
proc_debug (proc, "storing back changed thread state");
err = thread_set_state (proc->port, THREAD_STATE_FLAVOR,
- (thread_state_t) & proc->state, THREAD_STATE_SIZE);
+ (thread_state_t) &proc->state, THREAD_STATE_SIZE);
if (!err)
proc->state_changed = 0;
}
void
proc_abort (struct proc *proc, int force)
{
- assert (proc_is_thread (proc));
+ gdb_assert (proc_is_thread (proc));
if (!proc->aborted)
{
mach_msg_type_number_t state_size = THREAD_STATE_SIZE;
error_t err =
thread_get_state (proc->port, THREAD_STATE_FLAVOR,
- (thread_state_t) & proc->state, &state_size);
+ (thread_state_t) &proc->state, &state_size);
proc_debug (proc, "getting thread state");
proc->state_valid = !err;
}
{
if (will_modify)
proc->state_changed = 1;
- return (thread_state_t) & proc->state;
+ return (thread_state_t) &proc->state;
}
else
return 0;
{
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;
mach_port_deallocate (mach_task_self (), proc->port);
}
- free (proc);
+ xfree (proc);
return next;
}
\f
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;
int info_flags = 0;
error_t err =
proc_getprocinfo (proc_server, inf->pid, &info_flags,
- (procinfo_t *) & pi, &pi_len, &noise, &noise_len);
+ (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
if (!err)
{
(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 (pid_to_ptid (thread->tid)); /* Tell GDB's generic thread code. */
}
}
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);
struct inf *waiting_inf;
/* Wait for something to happen in the inferior, returning what in STATUS. */
-static int
-gnu_wait (int tid, struct target_waitstatus *status)
+static ptid_t
+gnu_wait (ptid_t tid, struct target_waitstatus *status)
{
struct msg
{
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
waiting_inf = inf;
- inf_debug (inf, "waiting for: %d", tid);
+ inf_debug (inf, "waiting for: %d", PIDGET (tid));
rewait:
if (proc_wait_pid != inf->pid && !inf->no_wait)
thread = inf->wait.thread;
if (thread)
- tid = thread->tid;
+ tid = pid_to_ptid (thread->tid);
else
- thread = inf_tid_to_thread (inf, tid);
+ thread = inf_tid_to_thread (inf, PIDGET (tid));
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. */
+ tid = pid_to_ptid (inf->threads->tid); /* The first available thread. */
else
- tid = inferior_pid; /* let wait_for_inferior handle exit case */
+ tid = inferior_ptid; /* let wait_for_inferior handle exit case */
}
- if (thread && tid >= 0 && status->kind != TARGET_WAITKIND_SPURIOUS
+ if (thread && PIDGET (tid) >= 0 && status->kind != TARGET_WAITKIND_SPURIOUS
&& inf->pause_sc == 0 && thread->pause_sc == 0)
/* If something actually happened to THREAD, make sure we
suspend it. */
inf_update_suspends (inf);
}
- inf_debug (inf, "returning tid = %d, status = %s (%d)", tid,
+ inf_debug (inf, "returning tid = %d, status = %s (%d)", PIDGET (tid),
status->kind == TARGET_WAITKIND_EXITED ? "EXITED"
: status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED"
: status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED"
{
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. */
in multiple events returned by wait).
*/
static void
-gnu_resume (int tid, int step, enum target_signal sig)
+gnu_resume (ptid_t tid, int step, enum target_signal sig)
{
struct proc *step_thread = 0;
struct inf *inf = current_inferior;
- inf_debug (inf, "tid = %d, step = %d, sig = %d", tid, step, sig);
+ inf_debug (inf, "tid = %d, step = %d, sig = %d", PIDGET (tid), step, sig);
inf_validate_procinfo (inf);
inf_update_procs (inf);
- if (tid < 0)
+ if (PIDGET (tid) < 0)
/* 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));
+ tid = 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, PIDGET (tid));
if (!thread)
error ("Can't run single thread id %d: no such thread!");
inf_debug (inf, "running one thread: %d/%d", inf->pid, thread->tid);
if (step)
{
- step_thread = inf_tid_to_thread (inf, tid);
+ step_thread = inf_tid_to_thread (inf, PIDGET (tid));
if (!step_thread)
- warning ("Can't step thread id %d: no such thread.", tid);
+ warning ("Can't step thread id %d: no such thread.", PIDGET (tid));
else
inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid);
}
\f
static void
-gnu_kill_inferior ()
+gnu_kill_inferior (void)
{
struct proc *task = current_inferior->task;
if (task)
/* Clean up after the inferior dies. */
static void
-gnu_mourn_inferior ()
+gnu_mourn_inferior (void)
{
inf_debug (current_inferior, "rip");
inf_detach (current_inferior);
/* 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)
/* The first thread. */
}
static struct inf *
-cur_inf ()
+cur_inf (void)
{
if (!current_inferior)
current_inferior = make_inf ();
}
static void
-gnu_create_inferior (exec_file, allargs, env)
- char *exec_file;
- char *allargs;
- char **env;
+gnu_create_inferior (char *exec_file, char *allargs, char **env)
{
struct inf *inf = cur_inf ();
/* 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 ();
+ inferior_ptid = pid_to_ptid (inf_pick_first_thread ());
startup_inferior (inf->pending_execs);
}
/* Mark our target-struct as eligible for stray "run" and "attach"
commands. */
static int
-gnu_can_run ()
+gnu_can_run (void)
{
return 1;
}
/* 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 (char *args, int from_tty)
{
int pid;
char *exec_file;
struct inf *inf = cur_inf ();
if (!args)
- error_no_arg ("PID to attach");
+ error_no_arg ("process-id to attach");
pid = atoi (args);
inf_attach (inf, pid);
inf_update_procs (inf);
- inferior_pid = inf_pick_first_thread ();
+ inferior_ptid = pid_to_ptid (inf_pick_first_thread ());
attach_flag = 1;
push_target (&gnu_ops);
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 (char *args, int from_tty)
{
if (from_tty)
{
inf_detach (current_inferior);
- inferior_pid = 0;
+ inferior_ptid = null_ptid;
unpush_target (&gnu_ops); /* Pop out of handling an inferior */
}
\f
static void
-gnu_terminal_init_inferior ()
+gnu_terminal_init_inferior (void)
{
- assert (current_inferior);
+ gdb_assert (current_inferior);
terminal_init_inferior_with_pgrp (current_inferior->pid);
}
that registers contains all the registers from the program being
debugged. */
static void
-gnu_prepare_to_store ()
+gnu_prepare_to_store (void)
{
#ifdef CHILD_PREPARE_TO_STORE
CHILD_PREPARE_TO_STORE ();
}
static void
-gnu_open (arg, from_tty)
- char *arg;
- int from_tty;
+gnu_open (char *arg, int from_tty)
{
error ("Use the \"run\" command to start a Unix child process.");
}
static void
-gnu_stop ()
+gnu_stop (void)
{
error ("to_stop target function not implemented");
}
static char *
-gnu_pid_to_exec_file ()
+gnu_pid_to_exec_file (int pid)
{
error ("to_pid_to_exec_file target function not implemented");
return NULL;
static int
-gnu_thread_alive (int tid)
+gnu_thread_alive (ptid_t tid)
{
inf_update_procs (current_inferior);
- return !!inf_tid_to_thread (current_inferior, tid);
+ return !!inf_tid_to_thread (current_inferior, PIDGET (tid));
}
\f
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);
/* 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);
}
\f
-/* 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 */
+gnu_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+ struct mem_attrib *attrib,
+ struct target_ops *target)
{
task_t task = (current_inferior
? (current_inferior->task
sprintf (tid_str, "process %d", proc->inf->pid);
else
sprintf (tid_str, "thread %d.%d",
- proc->inf->pid, pid_to_thread_id (proc->tid));
+ proc->inf->pid, pid_to_thread_id (MERGEPID (proc->tid, 0)));
return tid_str;
}
static char *
-gnu_pid_to_str (int tid)
+gnu_pid_to_str (ptid_t ptid)
{
struct inf *inf = current_inferior;
+ int tid = PIDGET (ptid);
struct proc *thread = inf_tid_to_thread (inf, tid);
if (thread)
gnu_ops.to_pid_to_str = gnu_pid_to_str; /* to_pid_to_str */
gnu_ops.to_stop = gnu_stop; /* to_stop */
gnu_ops.to_pid_to_exec_file = gnu_pid_to_exec_file; /* to_pid_to_exec_file */
- gnu_ops.to_core_file_to_sym_file = NULL;
gnu_ops.to_stratum = process_stratum; /* to_stratum */
gnu_ops.DONT_USE = 0; /* to_next */
gnu_ops.to_has_all_memory = 1; /* to_has_all_memory */
/* 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, PIDGET (inferior_ptid));
if (!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)
inf->signal_thread = 0;
else
{
- int tid = thread_id_to_pid (atoi (args));
+ int tid = PIDGET (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);
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;