X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Faix-thread.c;h=693d6f6fae7c7852c74f63b2f72a7491a83deebb;hb=35fd2deb6916e972248d52b1bc1d584fa9059f8f;hp=3377d50c62561d02ea3e06a9e1027203200a8a5d;hpb=515630c5e5a3b481867b81031930664f8d1d9b77;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/aix-thread.c b/gdb/aix-thread.c index 3377d50c62..693d6f6fae 100644 --- a/gdb/aix-thread.c +++ b/gdb/aix-thread.c @@ -1,6 +1,6 @@ /* Low level interface for debugging AIX 4.3+ pthreads. - Copyright (C) 1999, 2000, 2002, 2007, 2008 Free Software Foundation, Inc. + Copyright (C) 1999-2016 Free Software Foundation, Inc. Written by Nick Duffek . This file is part of GDB. @@ -40,15 +40,14 @@ */ #include "defs.h" -#include "gdb_assert.h" #include "gdbthread.h" #include "target.h" #include "inferior.h" #include "regcache.h" #include "gdbcmd.h" #include "ppc-tdep.h" -#include "gdb_string.h" #include "observer.h" +#include "objfiles.h" #include #include @@ -57,6 +56,10 @@ #include #include +#if !HAVE_DECL_GETTHRDS +extern int getthrds (pid_t, struct thrdsinfo64 *, int, tid_t *, int); +#endif + /* Whether to emit debugging output. */ static int debug_aix_thread; @@ -69,12 +72,6 @@ static int debug_aix_thread; #define PD_TID(ptid) (pd_active && ptid_get_tid (ptid) != 0) -/* Build a thread ptid. */ -#define BUILD_THREAD(TID, PID) ptid_build (PID, 0, TID) - -/* Build and lwp ptid. */ -#define BUILD_LWP(LWP, PID) MERGEPID (PID, LWP) - /* pthdb_user_t value that we pass to pthdb functions. 0 causes PTHDB_BAD_USER errors, so use 1. */ @@ -104,12 +101,6 @@ struct pd_thread { static struct target_ops aix_thread_ops; -/* Copy of the target over which ops is pushed. This is more - convenient than a pointer to deprecated_child_ops or core_ops, - because they lack current_target's default callbacks. */ - -static struct target_ops base_target; - /* Address of the function that libpthread will call when libpthdebug is ready to be initialized. */ @@ -239,7 +230,14 @@ ptrace_check (int req, int id, int ret) return 0; /* Not reached. */ } -/* Call ptracex (REQ, ID, ADDR, DATA, BUF). Return success. */ +/* Call ptracex (REQ, ID, ADDR, DATA, BUF) or + ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64. + Return success. */ + +#ifdef HAVE_PTRACE64 +# define ptracex(request, pid, addr, data, buf) \ + ptrace64 (request, pid, addr, data, buf) +#endif static int ptrace64aix (int req, int id, long long addr, int data, int *buf) @@ -248,14 +246,24 @@ ptrace64aix (int req, int id, long long addr, int data, int *buf) return ptrace_check (req, id, ptracex (req, id, addr, data, buf)); } -/* Call ptrace (REQ, ID, ADDR, DATA, BUF). Return success. */ +/* Call ptrace (REQ, ID, ADDR, DATA, BUF) or + ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64. + Return success. */ + +#ifdef HAVE_PTRACE64 +# define ptrace(request, pid, addr, data, buf) \ + ptrace64 (request, pid, addr, data, buf) +# define addr_ptr long long +#else +# define addr_ptr int * +#endif static int -ptrace32 (int req, int id, int *addr, int data, int *buf) +ptrace32 (int req, int id, addr_ptr addr, int data, int *buf) { errno = 0; return ptrace_check (req, id, - ptrace (req, id, (int *) addr, data, buf)); + ptrace (req, id, addr, data, buf)); } /* If *PIDP is a composite process/thread id, convert it to a @@ -268,7 +276,7 @@ pid_to_prc (ptid_t *ptidp) ptid = *ptidp; if (PD_TID (ptid)) - *ptidp = pid_to_ptid (PIDGET (ptid)); + *ptidp = pid_to_ptid (ptid_get_pid (ptid)); } /* pthdb callback: for from 0 to COUNT, set SYMBOLS[].addr to @@ -277,7 +285,7 @@ pid_to_prc (ptid_t *ptidp) static int pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count) { - struct minimal_symbol *ms; + struct bound_minimal_symbol ms; int i; char *name; @@ -297,13 +305,14 @@ pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count) symbols[i].addr = 0; else { - if (!(ms = lookup_minimal_symbol (name, NULL, NULL))) + ms = lookup_minimal_symbol (name, NULL, NULL); + if (ms.minsym == NULL) { if (debug_aix_thread) fprintf_unfiltered (gdb_stdlog, " returning PDC_FAILURE\n"); return PDC_FAILURE; } - symbols[i].addr = SYMBOL_VALUE_ADDRESS (ms); + symbols[i].addr = BMSYMBOL_VALUE_ADDRESS (ms); } if (debug_aix_thread) fprintf_unfiltered (gdb_stdlog, " symbols[%d].addr = %s\n", @@ -354,7 +363,7 @@ pdc_read_regs (pthdb_user_t user, } else { - if (!ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL)) + if (!ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL)) memset (gprs32, 0, sizeof (gprs32)); memcpy (context->gpr, gprs32, sizeof(gprs32)); } @@ -363,7 +372,7 @@ pdc_read_regs (pthdb_user_t user, /* Floating-point registers. */ if (flags & PTHDB_FLAG_FPRS) { - if (!ptrace32 (PTT_READ_FPRS, tid, (void *) fprs, 0, NULL)) + if (!ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL)) memset (fprs, 0, sizeof (fprs)); memcpy (context->fpr, fprs, sizeof(fprs)); } @@ -380,7 +389,7 @@ pdc_read_regs (pthdb_user_t user, } else { - if (!ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL)) + if (!ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL)) memset (&sprs32, 0, sizeof (sprs32)); memcpy (&context->msr, &sprs32, sizeof(sprs32)); } @@ -389,7 +398,7 @@ pdc_read_regs (pthdb_user_t user, } /* Write register function should be able to write requested context - information to specified debuggee's kernel thread id. + information to specified debuggee's kernel thread id. If successful return 0, else non-zero is returned. */ static int @@ -415,13 +424,13 @@ pdc_write_regs (pthdb_user_t user, ptrace64aix (PTT_WRITE_GPRS, tid, (unsigned long) context->gpr, 0, NULL); else - ptrace32 (PTT_WRITE_GPRS, tid, (int *) context->gpr, 0, NULL); + ptrace32 (PTT_WRITE_GPRS, tid, (uintptr_t) 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, (uintptr_t) context->fpr, 0, NULL); } /* Special-purpose registers. */ @@ -434,7 +443,7 @@ pdc_write_regs (pthdb_user_t user, } else { - ptrace32 (PTT_WRITE_SPRS, tid, (void *) &context->msr, 0, NULL); + ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &context->msr, 0, NULL); } } return 0; @@ -453,7 +462,7 @@ pdc_read_data (pthdb_user_t user, void *buf, "pdc_read_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n", user, (long) buf, hex_string (addr), len); - status = target_read_memory (addr, buf, len); + status = target_read_memory (addr, (gdb_byte *) buf, len); ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE; if (debug_aix_thread) @@ -475,7 +484,7 @@ pdc_write_data (pthdb_user_t user, void *buf, "pdc_write_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n", user, (long) buf, hex_string (addr), len); - status = target_write_memory (addr, buf, len); + status = target_write_memory (addr, (gdb_byte *) buf, len); ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE; if (debug_aix_thread) @@ -575,22 +584,36 @@ pcmp (const void *p1v, const void *p2v) return p1->pthid < p2->pthid ? -1 : p1->pthid > p2->pthid; } -/* iterate_over_threads() callback for counting GDB threads. */ +/* iterate_over_threads() callback for counting GDB threads. + + Do not count the main thread (whose tid is zero). This matches + the list of threads provided by the pthreaddebug library, which + does not include that main thread either, and thus allows us + to compare the two lists. */ static int giter_count (struct thread_info *thread, void *countp) { - (*(int *) countp)++; + if (PD_TID (thread->ptid)) + (*(int *) countp)++; return 0; } -/* iterate_over_threads() callback for accumulating GDB thread pids. */ +/* iterate_over_threads() callback for accumulating GDB thread pids. + + Do not include the main thread (whose tid is zero). This matches + the list of threads provided by the pthreaddebug library, which + does not include that main thread either, and thus allows us + to compare the two lists. */ static int giter_accum (struct thread_info *thread, void *bufp) { - **(struct thread_info ***) bufp = thread; - (*(struct thread_info ***) bufp)++; + if (PD_TID (thread->ptid)) + { + **(struct thread_info ***) bufp = thread; + (*(struct thread_info ***) bufp)++; + } return 0; } @@ -635,16 +658,12 @@ static pthdb_tid_t get_signaled_thread (void) { struct thrdsinfo64 thrinf; - pthdb_tid_t ktid = 0; + tid_t ktid = 0; int result = 0; - /* getthrds(3) isn't prototyped in any AIX 4.3.3 #include file. */ - extern int getthrds (pid_t, struct thrdsinfo64 *, - int, pthdb_tid_t *, int); - while (1) { - if (getthrds (PIDGET (inferior_ptid), &thrinf, + if (getthrds (ptid_get_pid (inferior_ptid), &thrinf, sizeof (thrinf), &ktid, 1) != 1) break; @@ -684,7 +703,7 @@ sync_threadlists (void) pcount = 0; psize = 1; - pbuf = (struct pd_thread *) xmalloc (psize * sizeof *pbuf); + pbuf = XNEWVEC (struct pd_thread, psize); for (cmd = PTHDB_LIST_FIRST;; cmd = PTHDB_LIST_NEXT) { @@ -721,13 +740,13 @@ sync_threadlists (void) gcount = 0; iterate_over_threads (giter_count, &gcount); - g = gbuf = (struct thread_info **) xmalloc (gcount * sizeof *gbuf); + g = gbuf = XNEWVEC (struct thread_info *, gcount); iterate_over_threads (giter_accum, &g); qsort (gbuf, gcount, sizeof *gbuf, gcmp); /* Apply differences between the two arrays to GDB's thread list. */ - infpid = PIDGET (inferior_ptid); + infpid = ptid_get_pid (inferior_ptid); for (pi = gi = 0; pi < pcount || gi < gcount;) { if (pi == pcount) @@ -737,10 +756,10 @@ sync_threadlists (void) } else if (gi == gcount) { - thread = add_thread (BUILD_THREAD (pbuf[pi].pthid, infpid)); - thread->private = xmalloc (sizeof (struct private_thread_info)); - thread->private->pdtid = pbuf[pi].pdtid; - thread->private->tid = pbuf[pi].tid; + thread = add_thread (ptid_build (infpid, 0, pbuf[pi].pthid)); + thread->priv = XNEW (struct private_thread_info); + thread->priv->pdtid = pbuf[pi].pdtid; + thread->priv->tid = pbuf[pi].tid; pi++; } else @@ -748,7 +767,7 @@ sync_threadlists (void) ptid_t pptid, gptid; int cmp_result; - pptid = BUILD_THREAD (pbuf[pi].pthid, infpid); + pptid = ptid_build (infpid, 0, pbuf[pi].pthid); gptid = gbuf[gi]->ptid; pdtid = pbuf[pi].pdtid; tid = pbuf[pi].tid; @@ -757,8 +776,8 @@ sync_threadlists (void) if (cmp_result == 0) { - gbuf[gi]->private->pdtid = pdtid; - gbuf[gi]->private->tid = tid; + gbuf[gi]->priv->pdtid = pdtid; + gbuf[gi]->priv->tid = tid; pi++; gi++; } @@ -770,9 +789,9 @@ sync_threadlists (void) else { thread = add_thread (pptid); - thread->private = xmalloc (sizeof (struct private_thread_info)); - thread->private->pdtid = pdtid; - thread->private->tid = tid; + thread->priv = XNEW (struct private_thread_info); + thread->priv->pdtid = pdtid; + thread->priv->tid = tid; pi++; } } @@ -790,7 +809,7 @@ iter_tid (struct thread_info *thread, void *tidp) { const pthdb_tid_t tid = *(pthdb_tid_t *)tidp; - return (thread->private->tid == tid); + return (thread->priv->tid == tid); } /* Synchronize libpthdebug's state with the inferior and with GDB, @@ -830,7 +849,7 @@ pd_update (int set_infpid) return ptid; } -/* Try to start debugging threads in the current process. +/* Try to start debugging threads in the current process. If successful and SET_INFPID, set inferior_ptid to reflect the current thread. */ @@ -871,32 +890,32 @@ pd_enable (void) { int status; char *stub_name; - struct minimal_symbol *ms; + struct bound_minimal_symbol ms; /* Don't initialize twice. */ if (pd_able) return; /* Check application word size. */ - arch64 = register_size (current_gdbarch, 0) == 8; + arch64 = register_size (target_gdbarch (), 0) == 8; /* Check whether the application is pthreaded. */ stub_name = NULL; status = pthdb_session_pthreaded (PD_USER, PTHDB_FLAG_REGS, &pd_callbacks, &stub_name); - if ((status != PTHDB_SUCCESS && - status != PTHDB_NOT_PTHREADED) || !stub_name) + if ((status != PTHDB_SUCCESS + && status != PTHDB_NOT_PTHREADED) || !stub_name) return; /* Set a breakpoint on the returned stub function. */ - if (!(ms = lookup_minimal_symbol (stub_name, NULL, NULL))) + ms = lookup_minimal_symbol (stub_name, NULL, NULL); + if (ms.minsym == NULL) return; - pd_brk_addr = SYMBOL_VALUE_ADDRESS (ms); - if (!create_thread_event_breakpoint (pd_brk_addr)) + pd_brk_addr = BMSYMBOL_VALUE_ADDRESS (ms); + if (!create_thread_event_breakpoint (target_gdbarch (), pd_brk_addr)) return; /* Prepare for thread debugging. */ - base_target = current_target; push_target (&aix_thread_ops); pd_able = 1; @@ -938,26 +957,28 @@ new_objfile (struct objfile *objfile) /* Attach to process specified by ARGS. */ static void -aix_thread_attach (char *args, int from_tty) +aix_thread_inferior_created (struct target_ops *ops, int from_tty) { - base_target.to_attach (args, from_tty); - pd_activate (1); + pd_enable (); } /* Detach from the process attached to by aix_thread_attach(). */ static void -aix_thread_detach (char *args, int from_tty) +aix_thread_detach (struct target_ops *ops, const char *args, int from_tty) { + struct target_ops *beneath = find_target_beneath (ops); + pd_disable (); - base_target.to_detach (args, from_tty); + beneath->to_detach (beneath, args, from_tty); } /* Tell the inferior process to continue running thread PID if != -1 and all threads otherwise. */ static void -aix_thread_resume (ptid_t ptid, int step, enum target_signal sig) +aix_thread_resume (struct target_ops *ops, + ptid_t ptid, int step, enum gdb_signal sig) { struct thread_info *thread; pthdb_tid_t tid[2]; @@ -965,29 +986,31 @@ aix_thread_resume (ptid_t ptid, int step, enum target_signal sig) if (!PD_TID (ptid)) { struct cleanup *cleanup = save_inferior_ptid (); - inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid)); - base_target.to_resume (ptid, step, sig); + struct target_ops *beneath = find_target_beneath (ops); + + inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); + beneath->to_resume (beneath, ptid, step, sig); do_cleanups (cleanup); } else { - thread = find_thread_pid (ptid); + thread = find_thread_ptid (ptid); if (!thread) error (_("aix-thread resume: unknown pthread %ld"), - TIDGET (ptid)); + ptid_get_lwp (ptid)); - tid[0] = thread->private->tid; + tid[0] = thread->priv->tid; if (tid[0] == PTHDB_INVALID_TID) error (_("aix-thread resume: no tid for pthread %ld"), - TIDGET (ptid)); + ptid_get_lwp (ptid)); tid[1] = 0; if (arch64) - ptrace64aix (PTT_CONTINUE, tid[0], 1, - target_signal_to_host (sig), (void *) tid); + ptrace64aix (PTT_CONTINUE, tid[0], (long long) 1, + gdb_signal_to_host (sig), (PTRACE_TYPE_ARG5) tid); else - ptrace32 (PTT_CONTINUE, tid[0], (int *) 1, - target_signal_to_host (sig), (void *) tid); + ptrace32 (PTT_CONTINUE, tid[0], (addr_ptr) 1, + gdb_signal_to_host (sig), (PTRACE_TYPE_ARG5) tid); } } @@ -996,22 +1019,24 @@ aix_thread_resume (ptid_t ptid, int step, enum target_signal sig) thread. */ static ptid_t -aix_thread_wait (ptid_t ptid, struct target_waitstatus *status) +aix_thread_wait (struct target_ops *ops, + ptid_t ptid, struct target_waitstatus *status, int options) { struct cleanup *cleanup = save_inferior_ptid (); + struct target_ops *beneath = find_target_beneath (ops); pid_to_prc (&ptid); - inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid)); - ptid = base_target.to_wait (ptid, status); + inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); + ptid = beneath->to_wait (beneath, ptid, status, options); do_cleanups (cleanup); - if (PIDGET (ptid) == -1) + if (ptid_get_pid (ptid) == -1) return pid_to_ptid (-1); /* Check whether libpthdebug might be ready to be initialized. */ if (!pd_active && status->kind == TARGET_WAITKIND_STOPPED - && status->value.sig == TARGET_SIGNAL_TRAP) + && status->value.sig == GDB_SIGNAL_TRAP) { struct regcache *regcache = get_thread_regcache (ptid); struct gdbarch *gdbarch = get_regcache_arch (regcache); @@ -1058,9 +1083,11 @@ supply_fprs (struct regcache *regcache, double *vals) floating-point registers. */ gdb_assert (ppc_floating_point_unit_p (gdbarch)); - for (regno = 0; regno < ppc_num_fprs; regno++) - regcache_raw_supply (regcache, regno + tdep->ppc_fp0_regnum, - (char *) (vals + regno)); + for (regno = tdep->ppc_fp0_regnum; + regno < tdep->ppc_fp0_regnum + ppc_num_fprs; + regno++) + regcache_raw_supply (regcache, regno, + (char *) (vals + regno - tdep->ppc_fp0_regnum)); } /* Predicate to test whether given register number is a "special" register. */ @@ -1221,7 +1248,7 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno, } else { - if (!ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL)) + if (!ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL)) memset (gprs32, 0, sizeof (gprs32)); for (i = 0; i < ppc_num_gprs; i++) supply_reg32 (regcache, tdep->ppc_gp0_regnum + i, gprs32[i]); @@ -1235,7 +1262,7 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno, || (regno >= tdep->ppc_fp0_regnum && regno < tdep->ppc_fp0_regnum + ppc_num_fprs))) { - if (!ptrace32 (PTT_READ_FPRS, tid, (void *) fprs, 0, NULL)) + if (!ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL)) memset (fprs, 0, sizeof (fprs)); supply_fprs (regcache, fprs); } @@ -1257,7 +1284,7 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno, { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - if (!ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL)) + if (!ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL)) memset (&sprs32, 0, sizeof (sprs32)); supply_sprs32 (regcache, sprs32.pt_iar, sprs32.pt_msr, sprs32.pt_cr, sprs32.pt_lr, sprs32.pt_ctr, sprs32.pt_xer, @@ -1274,20 +1301,22 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno, thread/process specified by inferior_ptid. */ static void -aix_thread_fetch_registers (struct regcache *regcache, int regno) +aix_thread_fetch_registers (struct target_ops *ops, + struct regcache *regcache, int regno) { struct thread_info *thread; pthdb_tid_t tid; + struct target_ops *beneath = find_target_beneath (ops); if (!PD_TID (inferior_ptid)) - base_target.to_fetch_registers (regcache, regno); + beneath->to_fetch_registers (beneath, regcache, regno); else { - thread = find_thread_pid (inferior_ptid); - tid = thread->private->tid; + thread = find_thread_ptid (inferior_ptid); + tid = thread->priv->tid; if (tid == PTHDB_INVALID_TID) - fetch_regs_user_thread (regcache, thread->private->pdtid); + fetch_regs_user_thread (regcache, thread->priv->pdtid); else fetch_regs_kernel_thread (regcache, regno, tid); } @@ -1302,7 +1331,8 @@ fill_gprs64 (const struct regcache *regcache, uint64_t *vals) int regno; for (regno = 0; regno < ppc_num_gprs; regno++) - if (regcache_valid_p (regcache, tdep->ppc_gp0_regnum + regno)) + if (REG_VALID == regcache_register_status (regcache, + tdep->ppc_gp0_regnum + regno)) regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno, vals + regno); } @@ -1314,7 +1344,8 @@ fill_gprs32 (const struct regcache *regcache, uint32_t *vals) int regno; for (regno = 0; regno < ppc_num_gprs; regno++) - if (regcache_valid_p (regcache, tdep->ppc_gp0_regnum + regno)) + if (REG_VALID == regcache_register_status (regcache, + tdep->ppc_gp0_regnum + regno)) regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno, vals + regno); } @@ -1334,8 +1365,9 @@ fill_fprs (const struct regcache *regcache, double *vals) for (regno = tdep->ppc_fp0_regnum; regno < tdep->ppc_fp0_regnum + ppc_num_fprs; regno++) - if (regcache_valid_p (regcache, regno)) - regcache_raw_collect (regcache, regno, vals + regno); + if (REG_VALID == regcache_register_status (regcache, regno)) + regcache_raw_collect (regcache, regno, + vals + regno - tdep->ppc_fp0_regnum); } /* Store the special registers into the specified 64-bit and 32-bit @@ -1358,20 +1390,22 @@ fill_sprs64 (const struct regcache *regcache, gdb_assert (sizeof (*iar) == register_size (gdbarch, gdbarch_pc_regnum (gdbarch))); - if (regcache_valid_p (regcache, gdbarch_pc_regnum (gdbarch))) + if (REG_VALID == regcache_register_status (regcache, + gdbarch_pc_regnum (gdbarch))) regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar); - if (regcache_valid_p (regcache, tdep->ppc_ps_regnum)) + if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum)) regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr); - if (regcache_valid_p (regcache, tdep->ppc_cr_regnum)) + if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum)) regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr); - if (regcache_valid_p (regcache, tdep->ppc_lr_regnum)) + if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum)) regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr); - if (regcache_valid_p (regcache, tdep->ppc_ctr_regnum)) + if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ctr_regnum)) regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr); - if (regcache_valid_p (regcache, tdep->ppc_xer_regnum)) + if (REG_VALID == regcache_register_status (regcache, tdep->ppc_xer_regnum)) regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer); if (tdep->ppc_fpscr_regnum >= 0 - && regcache_valid_p (regcache, tdep->ppc_fpscr_regnum)) + && REG_VALID == regcache_register_status (regcache, + tdep->ppc_fpscr_regnum)) regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr); } @@ -1392,20 +1426,21 @@ fill_sprs32 (const struct regcache *regcache, gdb_assert (sizeof (*iar) == register_size (gdbarch, gdbarch_pc_regnum (gdbarch))); - if (regcache_valid_p (regcache, gdbarch_pc_regnum (gdbarch))) + if (REG_VALID == regcache_register_status (regcache, + gdbarch_pc_regnum (gdbarch))) regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar); - if (regcache_valid_p (regcache, tdep->ppc_ps_regnum)) + if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum)) regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr); - if (regcache_valid_p (regcache, tdep->ppc_cr_regnum)) + if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum)) regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr); - if (regcache_valid_p (regcache, tdep->ppc_lr_regnum)) + if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum)) regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr); - if (regcache_valid_p (regcache, tdep->ppc_ctr_regnum)) + if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ctr_regnum)) regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr); - if (regcache_valid_p (regcache, tdep->ppc_xer_regnum)) + if (REG_VALID == regcache_register_status (regcache, tdep->ppc_xer_regnum)) regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer); if (tdep->ppc_fpscr_regnum >= 0 - && regcache_valid_p (regcache, tdep->ppc_fpscr_regnum)) + && REG_VALID == regcache_register_status (regcache, tdep->ppc_fpscr_regnum)) regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr); } @@ -1440,7 +1475,8 @@ store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid) /* Collect general-purpose register values from the regcache. */ for (i = 0; i < ppc_num_gprs; i++) - if (regcache_valid_p (regcache, tdep->ppc_gp0_regnum + i)) + if (REG_VALID == regcache_register_status (regcache, + tdep->ppc_gp0_regnum + i)) { if (arch64) { @@ -1475,25 +1511,30 @@ store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid) fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr, &tmp_xer, &tmp_fpscr); - if (regcache_valid_p (regcache, gdbarch_pc_regnum (gdbarch))) + if (REG_VALID == regcache_register_status (regcache, + gdbarch_pc_regnum (gdbarch))) ctx.iar = tmp_iar; - if (regcache_valid_p (regcache, tdep->ppc_ps_regnum)) + if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum)) ctx.msr = tmp_msr; - if (regcache_valid_p (regcache, tdep->ppc_cr_regnum)) + if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum)) ctx.cr = tmp_cr; - if (regcache_valid_p (regcache, tdep->ppc_lr_regnum)) + if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum)) ctx.lr = tmp_lr; - if (regcache_valid_p (regcache, tdep->ppc_ctr_regnum)) + if (REG_VALID == regcache_register_status (regcache, + tdep->ppc_ctr_regnum)) ctx.ctr = tmp_ctr; - if (regcache_valid_p (regcache, tdep->ppc_xer_regnum)) + if (REG_VALID == regcache_register_status (regcache, + tdep->ppc_xer_regnum)) ctx.xer = tmp_xer; - if (regcache_valid_p (regcache, tdep->ppc_xer_regnum)) + if (REG_VALID == regcache_register_status (regcache, + tdep->ppc_xer_regnum)) ctx.fpscr = tmp_fpscr; } status = pthdb_pthread_setcontext (pd_session, pdtid, &ctx); if (status != PTHDB_SUCCESS) - error (_("aix-thread: store_registers: pthdb_pthread_setcontext returned %s"), + error (_("aix-thread: store_registers: " + "pthdb_pthread_setcontext returned %s"), pd_status2str (status)); } @@ -1538,9 +1579,9 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno, else { /* Pre-fetch: some regs may not be in the cache. */ - ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL); + ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL); fill_gprs32 (regcache, gprs32); - ptrace32 (PTT_WRITE_GPRS, tid, gprs32, 0, NULL); + ptrace32 (PTT_WRITE_GPRS, tid, (uintptr_t) gprs32, 0, NULL); } } @@ -1552,9 +1593,9 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno, && regno < tdep->ppc_fp0_regnum + ppc_num_fprs))) { /* Pre-fetch: some regs may not be in the cache. */ - ptrace32 (PTT_READ_FPRS, tid, (void *) fprs, 0, NULL); + ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL); fill_fprs (regcache, fprs); - ptrace32 (PTT_WRITE_FPRS, tid, (void *) fprs, 0, NULL); + ptrace32 (PTT_WRITE_FPRS, tid, (uintptr_t) fprs, 0, NULL); } /* Special-purpose registers. */ @@ -1586,7 +1627,7 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno, gdb_assert (sizeof (sprs32.pt_iar) == 4); /* Pre-fetch: some registers won't be in the cache. */ - ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL); + ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL); fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr, &tmp_xer, &tmp_fpscr); @@ -1600,11 +1641,12 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno, sprs32.pt_fpscr = tmp_fpscr; if (tdep->ppc_mq_regnum >= 0) - if (regcache_valid_p (regcache, tdep->ppc_mq_regnum)) + if (REG_VALID == regcache_register_status (regcache, + tdep->ppc_mq_regnum)) regcache_raw_collect (regcache, tdep->ppc_mq_regnum, &sprs32.pt_mq); - ptrace32 (PTT_WRITE_SPRS, tid, (int *) &sprs32, 0, NULL); + ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &sprs32, 0, NULL); } } } @@ -1613,73 +1655,67 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno, thread/process specified by inferior_ptid. */ static void -aix_thread_store_registers (struct regcache *regcache, int regno) +aix_thread_store_registers (struct target_ops *ops, + struct regcache *regcache, int regno) { struct thread_info *thread; pthdb_tid_t tid; + struct target_ops *beneath = find_target_beneath (ops); if (!PD_TID (inferior_ptid)) - base_target.to_store_registers (regcache, regno); + beneath->to_store_registers (beneath, regcache, regno); else { - thread = find_thread_pid (inferior_ptid); - tid = thread->private->tid; + thread = find_thread_ptid (inferior_ptid); + tid = thread->priv->tid; if (tid == PTHDB_INVALID_TID) - store_regs_user_thread (regcache, thread->private->pdtid); + store_regs_user_thread (regcache, thread->priv->pdtid); else store_regs_kernel_thread (regcache, regno, tid); } } -/* Attempt a transfer all LEN bytes starting at OFFSET between the - inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer. - Return the number of bytes actually transferred. */ +/* Implement the to_xfer_partial target_ops method. */ -static LONGEST +static enum target_xfer_status aix_thread_xfer_partial (struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, - const gdb_byte *writebuf, ULONGEST offset, LONGEST len) + const gdb_byte *writebuf, + ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) { struct cleanup *old_chain = save_inferior_ptid (); - LONGEST xfer; + enum target_xfer_status xfer; + struct target_ops *beneath = find_target_beneath (ops); - inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid)); - xfer = base_target.to_xfer_partial (ops, object, annex, - readbuf, writebuf, offset, len); + inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); + xfer = beneath->to_xfer_partial (beneath, object, annex, readbuf, + writebuf, offset, len, xfered_len); do_cleanups (old_chain); return xfer; } -/* Kill and forget about the inferior process. */ - -static void -aix_thread_kill (void) -{ - struct cleanup *cleanup = save_inferior_ptid (); - - inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid)); - base_target.to_kill (); - do_cleanups (cleanup); -} - /* Clean up after the inferior exits. */ static void -aix_thread_mourn_inferior (void) +aix_thread_mourn_inferior (struct target_ops *ops) { + struct target_ops *beneath = find_target_beneath (ops); + pd_deactivate (); - base_target.to_mourn_inferior (); + beneath->to_mourn_inferior (beneath); } /* Return whether thread PID is still valid. */ static int -aix_thread_thread_alive (ptid_t ptid) +aix_thread_thread_alive (struct target_ops *ops, ptid_t ptid) { + struct target_ops *beneath = find_target_beneath (ops); + if (!PD_TID (ptid)) - return base_target.to_thread_alive (ptid); + return beneath->to_thread_alive (beneath, ptid); /* We update the thread list every time the child stops, so all valid threads should be in the thread list. */ @@ -1690,12 +1726,13 @@ aix_thread_thread_alive (ptid_t ptid) "info threads" output. */ static char * -aix_thread_pid_to_str (ptid_t ptid) +aix_thread_pid_to_str (struct target_ops *ops, ptid_t ptid) { static char *ret = NULL; + struct target_ops *beneath = find_target_beneath (ops); if (!PD_TID (ptid)) - return base_target.to_pid_to_str (ptid); + return beneath->to_pid_to_str (beneath, ptid); /* Free previous return value; a new one will be allocated by xstrprintf(). */ @@ -1709,7 +1746,8 @@ aix_thread_pid_to_str (ptid_t ptid) THREAD, for use in "info threads" output. */ static char * -aix_thread_extra_thread_info (struct thread_info *thread) +aix_thread_extra_thread_info (struct target_ops *self, + struct thread_info *thread) { struct ui_file *buf; int status; @@ -1719,7 +1757,6 @@ aix_thread_extra_thread_info (struct thread_info *thread) pthdb_suspendstate_t suspendstate; pthdb_detachstate_t detachstate; int cancelpend; - long length; static char *ret = NULL; if (!PD_TID (thread->ptid)) @@ -1727,8 +1764,8 @@ aix_thread_extra_thread_info (struct thread_info *thread) buf = mem_fileopen (); - pdtid = thread->private->pdtid; - tid = thread->private->tid; + pdtid = thread->priv->pdtid; + tid = thread->priv->tid; if (tid != PTHDB_INVALID_TID) /* i18n: Like "thread-identifier %d, [state] running, suspended" */ @@ -1760,55 +1797,66 @@ aix_thread_extra_thread_info (struct thread_info *thread) xfree (ret); /* Free old buffer. */ - ret = ui_file_xstrdup (buf, &length); + ret = ui_file_xstrdup (buf, NULL); ui_file_delete (buf); return ret; } +static ptid_t +aix_thread_get_ada_task_ptid (struct target_ops *self, long lwp, long thread) +{ + return ptid_build (ptid_get_pid (inferior_ptid), 0, thread); +} + /* Initialize target aix_thread_ops. */ static void init_aix_thread_ops (void) { - 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_partial = aix_thread_xfer_partial; - /* No need for aix_thread_ops.to_create_inferior, because we activate thread - debugging when the inferior reaches pd_brk_addr. */ - 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; + 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_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_partial = aix_thread_xfer_partial; + 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_get_ada_task_ptid = aix_thread_get_ada_task_ptid; + aix_thread_ops.to_stratum = thread_stratum; + aix_thread_ops.to_magic = OPS_MAGIC; } /* Module startup initialization function, automagically called by init.c. */ +void _initialize_aix_thread (void); + void _initialize_aix_thread (void) { init_aix_thread_ops (); - add_target (&aix_thread_ops); + complete_target_initialization (&aix_thread_ops); /* Notice when object files get loaded and unloaded. */ observer_attach_new_objfile (new_objfile); + /* Add ourselves to inferior_created event chain. + This is needed to enable the thread target on "attach". */ + observer_attach_inferior_created (aix_thread_inferior_created); + add_setshow_boolean_cmd ("aix-thread", class_maintenance, &debug_aix_thread, - _("Set debugging of AIX thread module."), - _("Show debugging of AIX thread module."), - _("Enables debugging output (used to debug GDB)."), - NULL, NULL, /* FIXME: i18n: Debugging of AIX thread module is \"%d\". */ - &setdebuglist, &showdebuglist); + _("Set debugging of AIX thread module."), + _("Show debugging of AIX thread module."), + _("Enables debugging output (used to debug GDB)."), + NULL, NULL, + /* FIXME: i18n: Debugging of AIX thread + module is \"%d\". */ + &setdebuglist, &showdebuglist); }