/* Low level interface for debugging AIX 4.3+ pthreads.
- Copyright (C) 1999-2018 Free Software Foundation, Inc.
+ Copyright (C) 1999-2022 Free Software Foundation, Inc.
Written by Nick Duffek <nsd@redhat.com>.
This file is part of GDB.
#endif
/* Whether to emit debugging output. */
-static int debug_aix_thread;
+static bool debug_aix_thread;
/* In AIX 5.1, functions use pthdb_tid_t instead of tid_t. */
#ifndef PTHDB_VERSION_3
class aix_thread_target final : public target_ops
{
public:
- aix_thread_target ()
- { to_stratum = thread_stratum; }
-
const target_info &info () const override
{ return aix_thread_target_info; }
+ strata stratum () const override { return thread_stratum; }
+
void detach (inferior *, int) override;
void resume (ptid_t, int, enum gdb_signal) override;
- ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
+ ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override;
void fetch_registers (struct regcache *, int) override;
void store_registers (struct regcache *, int) override;
bool thread_alive (ptid_t ptid) override;
- const char *pid_to_str (ptid_t) override;
+ std::string pid_to_str (ptid_t) override;
const char *extra_thread_info (struct thread_info *) override;
- ptid_t get_ada_task_ptid (long lwp, long thread) override;
+ ptid_t get_ada_task_ptid (long lwp, ULONGEST thread) override;
};
static aix_thread_target aix_thread_ops;
if (ret == -1 && errno == EPERM)
{
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog,
- "ptrace (%d, %d) = %d (errno = %d)\n",
- req, id, ret, errno);
+ gdb_printf (gdb_stdlog,
+ "ptrace (%d, %d) = %d (errno = %d)\n",
+ req, id, ret, errno);
return ret == -1 ? 0 : 1;
}
break;
char *name;
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog,
- "pdc_symbol_addrs (user = %ld, symbols = 0x%lx, count = %d)\n",
- user, (long) symbols, count);
+ gdb_printf (gdb_stdlog,
+ "pdc_symbol_addrs (user = %ld, symbols = 0x%lx, count = %d)\n",
+ user, (long) symbols, count);
for (i = 0; i < count; i++)
{
name = symbols[i].name;
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog,
- " symbols[%d].name = \"%s\"\n", i, name);
+ gdb_printf (gdb_stdlog,
+ " symbols[%d].name = \"%s\"\n", i, name);
if (!*name)
symbols[i].addr = 0;
if (ms.minsym == NULL)
{
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog, " returning PDC_FAILURE\n");
+ gdb_printf (gdb_stdlog, " returning PDC_FAILURE\n");
return PDC_FAILURE;
}
- symbols[i].addr = BMSYMBOL_VALUE_ADDRESS (ms);
+ symbols[i].addr = ms.value_address ();
}
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog, " symbols[%d].addr = %s\n",
- i, hex_string (symbols[i].addr));
+ gdb_printf (gdb_stdlog, " symbols[%d].addr = %s\n",
+ i, hex_string (symbols[i].addr));
}
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog, " returning PDC_SUCCESS\n");
+ gdb_printf (gdb_stdlog, " returning PDC_SUCCESS\n");
return PDC_SUCCESS;
}
struct ptsprs sprs32;
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog, "pdc_read_regs tid=%d flags=%s\n",
- (int) tid, hex_string (flags));
+ gdb_printf (gdb_stdlog, "pdc_read_regs tid=%d flags=%s\n",
+ (int) tid, hex_string (flags));
/* General-purpose registers. */
if (flags & PTHDB_FLAG_GPRS)
if (!ptrace64aix (PTT_READ_SPRS, tid,
(unsigned long) &sprs64, 0, NULL))
memset (&sprs64, 0, sizeof (sprs64));
- memcpy (&context->msr, &sprs64, sizeof(sprs64));
+ memcpy (&context->msr, &sprs64, sizeof(sprs64));
}
else
{
if (!ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL))
memset (&sprs32, 0, sizeof (sprs32));
- memcpy (&context->msr, &sprs32, sizeof(sprs32));
+ memcpy (&context->msr, &sprs32, sizeof(sprs32));
}
}
return 0;
however this code is untested. */
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog, "pdc_write_regs tid=%d flags=%s\n",
- (int) tid, hex_string (flags));
+ gdb_printf (gdb_stdlog, "pdc_write_regs tid=%d flags=%s\n",
+ (int) tid, hex_string (flags));
/* General-purpose registers. */
if (flags & PTHDB_FLAG_GPRS)
int status, ret;
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog,
- "pdc_read_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
- user, (long) buf, hex_string (addr), len);
+ gdb_printf (gdb_stdlog,
+ "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, (gdb_byte *) buf, len);
ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog, " status=%d, returning %s\n",
- status, pd_status2str (ret));
+ gdb_printf (gdb_stdlog, " status=%d, returning %s\n",
+ status, pd_status2str (ret));
return ret;
}
int status, ret;
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog,
- "pdc_write_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n",
- user, (long) buf, hex_string (addr), len);
+ gdb_printf (gdb_stdlog,
+ "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, (gdb_byte *) buf, len);
ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE;
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog, " status=%d, returning %s\n", status,
- pd_status2str (ret));
+ gdb_printf (gdb_stdlog, " status=%d, returning %s\n", status,
+ pd_status2str (ret));
return ret;
}
pdc_alloc (pthdb_user_t user, size_t len, void **bufp)
{
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog,
- "pdc_alloc (user = %ld, len = %ld, bufp = 0x%lx)\n",
- user, len, (long) bufp);
+ gdb_printf (gdb_stdlog,
+ "pdc_alloc (user = %ld, len = %ld, bufp = 0x%lx)\n",
+ user, len, (long) bufp);
*bufp = xmalloc (len);
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog,
- " malloc returned 0x%lx\n", (long) *bufp);
+ gdb_printf (gdb_stdlog,
+ " malloc returned 0x%lx\n", (long) *bufp);
/* Note: xmalloc() can't return 0; therefore PDC_FAILURE will never
be returned. */
pdc_realloc (pthdb_user_t user, void *buf, size_t len, void **bufp)
{
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog,
- "pdc_realloc (user = %ld, buf = 0x%lx, len = %ld, bufp = 0x%lx)\n",
- user, (long) buf, len, (long) bufp);
+ gdb_printf (gdb_stdlog,
+ "pdc_realloc (user = %ld, buf = 0x%lx, len = %ld, bufp = 0x%lx)\n",
+ user, (long) buf, len, (long) bufp);
*bufp = xrealloc (buf, len);
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog,
- " realloc returned 0x%lx\n", (long) *bufp);
+ gdb_printf (gdb_stdlog,
+ " realloc returned 0x%lx\n", (long) *bufp);
return *bufp ? PDC_SUCCESS : PDC_FAILURE;
}
pdc_dealloc (pthdb_user_t user, void *buf)
{
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog,
- "pdc_free (user = %ld, buf = 0x%lx)\n", user,
- (long) buf);
+ gdb_printf (gdb_stdlog,
+ "pdc_free (user = %ld, buf = 0x%lx)\n", user,
+ (long) buf);
xfree (buf);
return PDC_SUCCESS;
}
static int
ptid_cmp (ptid_t ptid1, ptid_t ptid2)
{
- int pid1, pid2;
-
if (ptid1.pid () < ptid2.pid ())
return -1;
else if (ptid1.pid () > ptid2.pid ())
{
struct thrdsinfo64 thrinf;
tid_t ktid = 0;
- int result = 0;
while (1)
- {
- if (getthrds (inferior_ptid.pid (), &thrinf,
- sizeof (thrinf), &ktid, 1) != 1)
- break;
+ {
+ if (getthrds (inferior_ptid.pid (), &thrinf,
+ sizeof (thrinf), &ktid, 1) != 1)
+ break;
- if (thrinf.ti_cursig == SIGTRAP)
- return thrinf.ti_tid;
- }
+ if (thrinf.ti_cursig == SIGTRAP)
+ return thrinf.ti_tid;
+ }
/* Didn't find any thread stopped on a SIGTRAP signal. */
return 0;
priv->pdtid = pbuf[pi].pdtid;
priv->tid = pbuf[pi].tid;
- thread = add_thread_with_info (ptid_t (infpid, 0, pbuf[pi].pthid), priv);
+ process_stratum_target *proc_target
+ = current_inferior ()->process_target ();
+ thread = add_thread_with_info (proc_target,
+ ptid_t (infpid, 0, pbuf[pi].pthid),
+ priv);
pi++;
}
}
else
{
- thread = add_thread (pptid);
+ process_stratum_target *proc_target
+ = current_inferior ()->process_target ();
+ thread = add_thread (proc_target, pptid);
aix_thread_info *priv = new aix_thread_info;
thread->priv.reset (priv);
{
ptid = thread->ptid;
if (set_infpid)
- inferior_ptid = ptid;
+ switch_to_thread (thread);
}
return ptid;
}
ms = lookup_minimal_symbol (stub_name, NULL, NULL);
if (ms.minsym == NULL)
return;
- pd_brk_addr = BMSYMBOL_VALUE_ADDRESS (ms);
+ pd_brk_addr = ms.value_address ();
if (!create_thread_event_breakpoint (target_gdbarch (), pd_brk_addr))
return;
/* Prepare for thread debugging. */
- push_target (&aix_thread_ops);
+ current_inferior ()->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 (&aix_thread_ops);
+ current_inferior ()->unpush_target (&aix_thread_ops);
}
/* new_objfile observer callback.
/* Attach to process specified by ARGS. */
static void
-aix_thread_inferior_created (struct target_ops *ops, int from_tty)
+aix_thread_inferior_created (inferior *inf)
{
pd_enable ();
}
}
else
{
- thread = find_thread_ptid (ptid);
+ thread = find_thread_ptid (current_inferior (), ptid);
if (!thread)
error (_("aix-thread resume: unknown pthread %ld"),
ptid.lwp ());
ptid_t
aix_thread_target::wait (ptid_t ptid, struct target_waitstatus *status,
- int options)
+ target_wait_flags options)
{
{
scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
return ptid_t (-1);
/* Check whether libpthdebug might be ready to be initialized. */
- if (!pd_active && status->kind == TARGET_WAITKIND_STOPPED
- && status->value.sig == GDB_SIGNAL_TRAP)
+ if (!pd_active && status->kind () == TARGET_WAITKIND_STOPPED
+ && status->sig () == GDB_SIGNAL_TRAP)
{
- struct regcache *regcache = get_thread_regcache (ptid);
+ process_stratum_target *proc_target
+ = current_inferior ()->process_target ();
+ struct regcache *regcache = get_thread_regcache (proc_target, ptid);
struct gdbarch *gdbarch = regcache->arch ();
if (regcache_read_pc (regcache)
static void
supply_gprs64 (struct regcache *regcache, uint64_t *vals)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
+ ppc_gdbarch_tdep *tdep
+ = (ppc_gdbarch_tdep *) gdbarch_tdep (regcache->arch ());
int regno;
for (regno = 0; regno < ppc_num_gprs; regno++)
supply_fprs (struct regcache *regcache, double *vals)
{
struct gdbarch *gdbarch = regcache->arch ();
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch);
int regno;
/* This function should never be called on architectures without
static int
special_register_p (struct gdbarch *gdbarch, int regno)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch);
return regno == gdbarch_pc_regnum (gdbarch)
|| regno == tdep->ppc_ps_regnum
uint32_t fpscr)
{
struct gdbarch *gdbarch = regcache->arch ();
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch);
regcache->raw_supply (gdbarch_pc_regnum (gdbarch), (char *) &iar);
regcache->raw_supply (tdep->ppc_ps_regnum, (char *) &msr);
uint32_t fpscr)
{
struct gdbarch *gdbarch = regcache->arch ();
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch);
regcache->raw_supply (gdbarch_pc_regnum (gdbarch), (char *) &iar);
regcache->raw_supply (tdep->ppc_ps_regnum, (char *) &msr);
fetch_regs_user_thread (struct regcache *regcache, pthdb_pthread_t pdtid)
{
struct gdbarch *gdbarch = regcache->arch ();
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch);
int status, i;
pthdb_context_t ctx;
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog,
- "fetch_regs_user_thread %lx\n", (long) pdtid);
+ gdb_printf (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"),
- pd_status2str (status));
+ pd_status2str (status));
/* General-purpose registers. */
pthdb_tid_t tid)
{
struct gdbarch *gdbarch = regcache->arch ();
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch);
uint64_t gprs64[ppc_num_gprs];
uint32_t gprs32[ppc_num_gprs];
double fprs[ppc_num_fprs];
int i;
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog,
- "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
- (long) tid, regno, arch64);
+ gdb_printf (gdb_stdlog,
+ "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
+ (long) tid, regno, arch64);
/* General-purpose registers. */
if (regno == -1
|| (tdep->ppc_gp0_regnum <= regno
- && regno < tdep->ppc_gp0_regnum + ppc_num_gprs))
+ && regno < tdep->ppc_gp0_regnum + ppc_num_gprs))
{
if (arch64)
{
if (ppc_floating_point_unit_p (gdbarch)
&& (regno == -1
- || (regno >= tdep->ppc_fp0_regnum
- && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
+ || (regno >= tdep->ppc_fp0_regnum
+ && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
{
if (!ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL))
memset (fprs, 0, sizeof (fprs));
}
else
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
-
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,
beneath ()->fetch_registers (regcache, regno);
else
{
- thread = find_thread_ptid (regcache->ptid ());
+ thread = find_thread_ptid (current_inferior (), regcache->ptid ());
aix_thread_info *priv = get_aix_thread_info (thread);
tid = priv->tid;
static void
fill_gprs64 (const struct regcache *regcache, uint64_t *vals)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
+ ppc_gdbarch_tdep *tdep
+ = (ppc_gdbarch_tdep *) gdbarch_tdep (regcache->arch ());
int regno;
for (regno = 0; regno < ppc_num_gprs; regno++)
static void
fill_gprs32 (const struct regcache *regcache, uint32_t *vals)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
+ ppc_gdbarch_tdep *tdep
+ = (ppc_gdbarch_tdep *) gdbarch_tdep (regcache->arch ());
int regno;
for (regno = 0; regno < ppc_num_gprs; regno++)
fill_fprs (const struct regcache *regcache, double *vals)
{
struct gdbarch *gdbarch = regcache->arch ();
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch);
int regno;
/* This function should never be called on architectures without
uint32_t *fpscr)
{
struct gdbarch *gdbarch = regcache->arch ();
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch);
/* Verify that the size of the size of the IAR buffer is the
same as the raw size of the PC (in the register cache). If
uint32_t *fpscr)
{
struct gdbarch *gdbarch = regcache->arch ();
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch);
/* Verify that the size of the size of the IAR buffer is the
same as the raw size of the PC (in the register cache). If
store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)
{
struct gdbarch *gdbarch = regcache->arch ();
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch);
int status, i;
pthdb_context_t ctx;
uint32_t int32;
uint64_t int64;
- double dbl;
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog,
- "store_regs_user_thread %lx\n", (long) pdtid);
+ gdb_printf (gdb_stdlog,
+ "store_regs_user_thread %lx\n", (long) pdtid);
/* Retrieve the thread's current context for its non-register
values. */
status = pthdb_pthread_context (pd_session, pdtid, &ctx);
if (status != PTHDB_SUCCESS)
error (_("aix-thread: store_registers: pthdb_pthread_context returned %s"),
- pd_status2str (status));
+ pd_status2str (status));
/* Collect general-purpose register values from the regcache. */
if (status != PTHDB_SUCCESS)
error (_("aix-thread: store_registers: "
"pthdb_pthread_setcontext returned %s"),
- pd_status2str (status));
+ pd_status2str (status));
}
/* Store register REGNO if != -1 or all registers otherwise into
pthdb_tid_t tid)
{
struct gdbarch *gdbarch = regcache->arch ();
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch);
uint64_t gprs64[ppc_num_gprs];
uint32_t gprs32[ppc_num_gprs];
double fprs[ppc_num_fprs];
struct ptxsprs sprs64;
struct ptsprs sprs32;
- int i;
if (debug_aix_thread)
- fprintf_unfiltered (gdb_stdlog,
- "store_regs_kernel_thread tid=%lx regno=%d\n",
- (long) tid, regno);
+ gdb_printf (gdb_stdlog,
+ "store_regs_kernel_thread tid=%lx regno=%d\n",
+ (long) tid, regno);
/* General-purpose registers. */
if (regno == -1
|| (tdep->ppc_gp0_regnum <= regno
- && regno < tdep->ppc_gp0_regnum + ppc_num_fprs))
+ && regno < tdep->ppc_gp0_regnum + ppc_num_fprs))
{
if (arch64)
{
if (ppc_floating_point_unit_p (gdbarch)
&& (regno == -1
- || (regno >= tdep->ppc_fp0_regnum
- && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
+ || (regno >= tdep->ppc_fp0_regnum
+ && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
{
/* Pre-fetch: some regs may not be in the cache. */
ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL);
beneath ()->store_registers (regcache, regno);
else
{
- thread = find_thread_ptid (regcache->ptid ());
+ thread = find_thread_ptid (current_inferior (), regcache->ptid ());
aix_thread_info *priv = get_aix_thread_info (thread);
tid = priv->tid;
/* We update the thread list every time the child stops, so all
valid threads should be in the thread list. */
- return in_thread_list (ptid);
+ process_stratum_target *proc_target
+ = current_inferior ()->process_target ();
+ return in_thread_list (proc_target, ptid);
}
/* Return a printable representation of composite PID for use in
"info threads" output. */
-const char *
+std::string
aix_thread_target::pid_to_str (ptid_t ptid)
{
- static char *ret = NULL;
-
if (!PD_TID (ptid))
return beneath ()->pid_to_str (ptid);
- /* Free previous return value; a new one will be allocated by
- xstrprintf(). */
- xfree (ret);
-
- ret = xstrprintf (_("Thread %ld"), ptid.tid ());
- return ret;
+ return string_printf (_("Thread %ld"), ptid.tid ());
}
/* Return a printable representation of extra information about
}
ptid_t
-aix_thread_target::get_ada_task_ptid (long lwp, long thread)
+aix_thread_target::get_ada_task_ptid (long lwp, ULONGEST thread)
{
return ptid_t (inferior_ptid.pid (), 0, thread);
}
/* Module startup initialization function, automagically called by
init.c. */
+void _initialize_aix_thread ();
void
-_initialize_aix_thread (void)
+_initialize_aix_thread ()
{
/* Notice when object files get loaded and unloaded. */
- gdb::observers::new_objfile.attach (new_objfile);
+ gdb::observers::new_objfile.attach (new_objfile, "aix-thread");
/* Add ourselves to inferior_created event chain.
This is needed to enable the thread target on "attach". */
- gdb::observers::inferior_created.attach (aix_thread_inferior_created);
+ gdb::observers::inferior_created.attach (aix_thread_inferior_created,
+ "aix-thread");
add_setshow_boolean_cmd ("aix-thread", class_maintenance, &debug_aix_thread,
_("Set debugging of AIX thread module."),