/* This module's target-specific operations, active while pd_able is true. */
-static struct target_ops ops;
+static struct target_ops aix_thread_ops;
/* Copy of the target over which ops is pushed.
This is more convenient than a pointer to child_ops or core_ops,
because they lack current_target's default callbacks. */
-static struct target_ops base_ops;
+static struct target_ops base_target;
/* Address of the function that libpthread will call when libpthdebug
is ready to be initialized. */
{
errno = 0;
return ptrace_check (req, id,
- ptrace (req, id, (int *)addr, data, buf));
+ ptrace (req, id, (int *) addr, data, buf));
}
/* If *PIDP is a composite process/thread id, convert it to a
if (debug_aix_thread)
fprintf_unfiltered (gdb_stdlog, "pdc_read_regs tid=%d flags=%llx\n",
- (int)tid, flags);
+ (int) tid, flags);
/* General-purpose registers. */
if (flags & PTHDB_FLAG_GPRS)
if (debug_aix_thread)
fprintf_unfiltered (gdb_stdlog, "pdc_write_regs tid=%d flags=%llx\n",
- (int)tid, flags);
+ (int) tid, flags);
/* General-purpose registers. */
if (flags & PTHDB_FLAG_GPRS)
{
if (arch64)
ptrace64aix (PTT_WRITE_GPRS, tid,
- (unsigned long)context->gpr, 0, NULL);
+ (unsigned long) context->gpr, 0, NULL);
else
- ptrace32 (PTT_WRITE_GPRS, tid, (int *)context->gpr, 0, NULL);
+ ptrace32 (PTT_WRITE_GPRS, tid, (int *) context->gpr, 0, NULL);
}
/* Floating-point registers. */
if (flags & PTHDB_FLAG_FPRS)
{
- ptrace32 (PTT_WRITE_FPRS, tid, (int *)context->fpr, 0, NULL);
+ ptrace32 (PTT_WRITE_FPRS, tid, (int *) context->fpr, 0, NULL);
}
/* Special-purpose registers. */
}
else
{
- ptrace32 (PTT_WRITE_SPRS, tid, (int *)&context->msr, 0, NULL);
+ ptrace32 (PTT_WRITE_SPRS, tid, (int *) &context->msr, 0, NULL);
}
}
return 0;
return;
/* Prepare for thread debugging. */
- base_ops = current_target;
- push_target (&ops);
+ base_target = current_target;
+ push_target (&aix_thread_ops);
pd_able = 1;
/* If we're debugging a core file or an attached inferior, the
if (pd_active)
pd_deactivate ();
pd_able = 0;
- unpush_target (&ops);
+ unpush_target (&aix_thread_ops);
}
/* target_new_objfile_hook callback.
/* Attach to process specified by ARGS. */
static void
-ops_attach (char *args, int from_tty)
+aix_thread_attach (char *args, int from_tty)
{
- base_ops.to_attach (args, from_tty);
+ base_target.to_attach (args, from_tty);
pd_activate (1);
}
-/* Detach from the process attached to by ops_attach(). */
+/* Detach from the process attached to by aix_thread_attach(). */
static void
-ops_detach (char *args, int from_tty)
+aix_thread_detach (char *args, int from_tty)
{
pd_deactivate ();
- base_ops.to_detach (args, from_tty);
+ base_target.to_detach (args, from_tty);
}
/* Tell the inferior process to continue running thread PID if != -1
and all threads otherwise. */
static void
-ops_resume (ptid_t ptid, int step, enum target_signal sig)
+aix_thread_resume (ptid_t ptid, int step, enum target_signal sig)
{
struct thread_info *thread;
pthdb_tid_t tid[2];
{
struct cleanup *cleanup = save_inferior_ptid ();
inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
- base_ops.to_resume (ptid, step, sig);
+ base_target.to_resume (ptid, step, sig);
do_cleanups (cleanup);
}
else
if (arch64)
ptrace64aix (PTT_CONTINUE, tid[0], 1,
- target_signal_to_host (sig), (int *)tid);
+ target_signal_to_host (sig), (int *) tid);
else
ptrace32 (PTT_CONTINUE, tid[0], (int *) 1,
- target_signal_to_host (sig), (int *)tid);
+ target_signal_to_host (sig), (int *) tid);
}
}
thread. */
static ptid_t
-ops_wait (ptid_t ptid, struct target_waitstatus *status)
+aix_thread_wait (ptid_t ptid, struct target_waitstatus *status)
{
struct cleanup *cleanup = save_inferior_ptid ();
pid_to_prc (&ptid);
inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
- ptid = base_ops.to_wait (ptid, status);
+ ptid = base_target.to_wait (ptid, status);
do_cleanups (cleanup);
if (PIDGET (ptid) == -1)
function. */
static void
-fetch_regs_lib (pthdb_pthread_t pdtid)
+fetch_regs_user_thread (pthdb_pthread_t pdtid)
{
int status, i;
pthdb_context_t ctx;
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog, "fetch_regs_lib %lx\n", (long)pdtid);
+ fprintf_unfiltered (gdb_stdlog,
+ "fetch_regs_user_thread %lx\n", (long) pdtid);
status = pthdb_pthread_context (pd_session, pdtid, &ctx);
if (status != PTHDB_SUCCESS)
error ("aix-thread: fetch_registers: pthdb_pthread_context returned %s",
be retrieved. */
static void
-fetch_regs_kern (int regno, pthdb_tid_t tid)
+fetch_regs_kernel_thread (int regno, pthdb_tid_t tid)
{
uint64_t gprs64[32];
uint32_t gprs32[32];
if (debug_aix_thread)
fprintf_unfiltered (gdb_stdlog,
- "fetch_regs_kern tid=%lx regno=%d arch64=%d\n",
- (long)tid, regno, arch64);
+ "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
+ (long) tid, regno, arch64);
/* General-purpose registers. */
if (regno == -1 || regno < FP0_REGNUM)
thread/process specified by inferior_ptid. */
static void
-ops_fetch_registers (int regno)
+aix_thread_fetch_registers (int regno)
{
struct thread_info *thread;
pthdb_tid_t tid;
if (!PD_TID (inferior_ptid))
- base_ops.to_fetch_registers (regno);
+ base_target.to_fetch_registers (regno);
else
{
thread = find_thread_pid (inferior_ptid);
tid = thread->private->tid;
if (tid == PTHDB_INVALID_TID)
- fetch_regs_lib (thread->private->pdtid);
+ fetch_regs_user_thread (thread->private->pdtid);
else
- fetch_regs_kern (regno, tid);
+ fetch_regs_kernel_thread (regno, tid);
}
}
but I doubt it's worth the effort. */
static void
-store_regs_lib (pthdb_pthread_t pdtid)
+store_regs_user_thread (pthdb_pthread_t pdtid)
{
int status, i;
pthdb_context_t ctx;
if (debug_aix_thread)
fprintf_unfiltered (gdb_stdlog,
- "store_regs_lib %lx\n", (long)pdtid);
+ "store_regs_user_thread %lx\n", (long) pdtid);
/* Retrieve the thread's current context for its non-register
values. */
group. */
static void
-store_regs_kern (int regno, pthdb_tid_t tid)
+store_regs_kernel_thread (int regno, pthdb_tid_t tid)
{
uint64_t gprs64[32];
uint32_t gprs32[32];
int i;
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog, "store_regs_kern tid=%lx regno=%d\n",
- (long)tid, regno);
+ fprintf_unfiltered (gdb_stdlog,
+ "store_regs_kernel_thread tid=%lx regno=%d\n",
+ (long) tid, regno);
/* General-purpose registers. */
if (regno == -1 || regno < FP0_REGNUM)
thread/process specified by inferior_ptid. */
static void
-ops_store_registers (int regno)
+aix_thread_store_registers (int regno)
{
struct thread_info *thread;
pthdb_tid_t tid;
if (!PD_TID (inferior_ptid))
- base_ops.to_store_registers (regno);
+ base_target.to_store_registers (regno);
else
{
thread = find_thread_pid (inferior_ptid);
tid = thread->private->tid;
if (tid == PTHDB_INVALID_TID)
- store_regs_lib (thread->private->pdtid);
+ store_regs_user_thread (thread->private->pdtid);
else
- store_regs_kern (regno, tid);
+ store_regs_kernel_thread (regno, tid);
}
}
address MEMADDR if WRITE and vice versa otherwise. */
static int
-ops_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
- struct mem_attrib *attrib,
- struct target_ops *target)
+aix_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+ struct mem_attrib *attrib,
+ struct target_ops *target)
{
int n;
struct cleanup *cleanup = save_inferior_ptid ();
inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
- n = base_ops.to_xfer_memory (memaddr, myaddr, len,
- write, attrib, &base_ops);
+ n = base_target.to_xfer_memory (memaddr, myaddr, len,
+ write, attrib, &base_target);
do_cleanups (cleanup);
return n;
/* Kill and forget about the inferior process. */
static void
-ops_kill (void)
+aix_thread_kill (void)
{
struct cleanup *cleanup = save_inferior_ptid ();
inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
- base_ops.to_kill ();
+ base_target.to_kill ();
do_cleanups (cleanup);
}
/* Clean up after the inferior exits. */
static void
-ops_mourn_inferior (void)
+aix_thread_mourn_inferior (void)
{
pd_deactivate ();
- base_ops.to_mourn_inferior ();
+ base_target.to_mourn_inferior ();
}
/* Return whether thread PID is still valid. */
static int
-ops_thread_alive (ptid_t ptid)
+aix_thread_thread_alive (ptid_t ptid)
{
if (!PD_TID (ptid))
- return base_ops.to_thread_alive (ptid);
+ return base_target.to_thread_alive (ptid);
/* We update the thread list every time the child stops, so all
valid threads should be in the thread list. */
"info threads" output. */
static char *
-ops_pid_to_str (ptid_t ptid)
+aix_thread_pid_to_str (ptid_t ptid)
{
static char *ret = NULL;
if (!PD_TID (ptid))
- return base_ops.to_pid_to_str (ptid);
+ return base_target.to_pid_to_str (ptid);
/* Free previous return value; a new one will be allocated by
xasprintf(). */
THREAD, for use in "info threads" output. */
static char *
-ops_extra_thread_info (struct thread_info *thread)
+aix_thread_extra_thread_info (struct thread_info *thread)
{
struct ui_file *buf;
int status;
return ret;
}
-/* Initialize target ops. */
+/* Initialize target aix_thread_ops. */
static void
-init_ops (void)
+init_aix_thread_ops (void)
{
- ops.to_shortname = "aix-threads";
- ops.to_longname = "AIX pthread support";
- ops.to_doc = "AIX pthread support";
-
- ops.to_attach = ops_attach;
- ops.to_detach = ops_detach;
- ops.to_resume = ops_resume;
- ops.to_wait = ops_wait;
- ops.to_fetch_registers = ops_fetch_registers;
- ops.to_store_registers = ops_store_registers;
- ops.to_xfer_memory = ops_xfer_memory;
- /* No need for ops.to_create_inferior, because we activate thread
+ aix_thread_ops.to_shortname = "aix-threads";
+ aix_thread_ops.to_longname = "AIX pthread support";
+ aix_thread_ops.to_doc = "AIX pthread support";
+
+ aix_thread_ops.to_attach = aix_thread_attach;
+ aix_thread_ops.to_detach = aix_thread_detach;
+ aix_thread_ops.to_resume = aix_thread_resume;
+ aix_thread_ops.to_wait = aix_thread_wait;
+ aix_thread_ops.to_fetch_registers = aix_thread_fetch_registers;
+ aix_thread_ops.to_store_registers = aix_thread_store_registers;
+ aix_thread_ops.to_xfer_memory = aix_thread_xfer_memory;
+ /* No need for aix_thread_ops.to_create_inferior, because we activate thread
debugging when the inferior reaches pd_brk_addr. */
- ops.to_kill = ops_kill;
- ops.to_mourn_inferior = ops_mourn_inferior;
- ops.to_thread_alive = ops_thread_alive;
- ops.to_pid_to_str = ops_pid_to_str;
- ops.to_extra_thread_info = ops_extra_thread_info;
- ops.to_stratum = thread_stratum;
- ops.to_magic = OPS_MAGIC;
+ aix_thread_ops.to_kill = aix_thread_kill;
+ aix_thread_ops.to_mourn_inferior = aix_thread_mourn_inferior;
+ aix_thread_ops.to_thread_alive = aix_thread_thread_alive;
+ aix_thread_ops.to_pid_to_str = aix_thread_pid_to_str;
+ aix_thread_ops.to_extra_thread_info = aix_thread_extra_thread_info;
+ aix_thread_ops.to_stratum = thread_stratum;
+ aix_thread_ops.to_magic = OPS_MAGIC;
}
/* Module startup initialization function, automagically called by
void
_initialize_aix_thread (void)
{
- init_ops ();
- add_target (&ops);
+ init_aix_thread_ops ();
+ add_target (&aix_thread_ops);
/* Notice when object files get loaded and unloaded. */
target_new_objfile_chain = target_new_objfile_hook;
projects / binutils-gdb.git / commitdiff