X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Faix-thread.c;h=5aeb02c32ee706b2f2c4d7b2fb35da9bf422ada4;hb=ff800d76d32087301f7aea21e6a030190f940809;hp=e5e8a9aac4ea4fbd3ab70d6d0daaaa0a9c3736c5;hpb=b435e160dd3606c70fee73fa1461cf26607e4d6f;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/aix-thread.c b/gdb/aix-thread.c index e5e8a9aac4..5aeb02c32e 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 1999, 2000, 2002 Free Software Foundation, Inc. + Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc. Written by Nick Duffek . This file is part of GDB. @@ -17,8 +17,8 @@ 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., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ /* This module uses the libpthdebug.a library provided by AIX 4.3+ for @@ -48,7 +48,6 @@ #include "inferior.h" #include "regcache.h" #include "gdbcmd.h" -#include "language.h" /* for local_hex_string() */ #include "ppc-tdep.h" #include "gdb_string.h" @@ -106,8 +105,8 @@ 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 child_ops or core_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; @@ -241,7 +240,7 @@ ptrace_check (int req, int id, int ret) } break; } - error ("aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)", + error (_("aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)"), req, id, ret, errno, safe_strerror (errno)); return 0; /* Not reached. */ } @@ -314,7 +313,7 @@ pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count) } if (debug_aix_thread) fprintf_unfiltered (gdb_stdlog, " symbols[%d].addr = %s\n", - i, local_hex_string (symbols[i].addr)); + i, hex_string (symbols[i].addr)); } if (debug_aix_thread) fprintf_unfiltered (gdb_stdlog, " returning PDC_SUCCESS\n"); @@ -347,7 +346,7 @@ pdc_read_regs (pthdb_user_t user, if (debug_aix_thread) fprintf_unfiltered (gdb_stdlog, "pdc_read_regs tid=%d flags=%s\n", - (int) tid, local_hex_string (flags)); + (int) tid, hex_string (flags)); /* General-purpose registers. */ if (flags & PTHDB_FLAG_GPRS) @@ -413,7 +412,7 @@ pdc_write_regs (pthdb_user_t user, if (debug_aix_thread) fprintf_unfiltered (gdb_stdlog, "pdc_write_regs tid=%d flags=%s\n", - (int) tid, local_hex_string (flags)); + (int) tid, hex_string (flags)); /* General-purpose registers. */ if (flags & PTHDB_FLAG_GPRS) @@ -458,7 +457,7 @@ pdc_read_data (pthdb_user_t user, void *buf, if (debug_aix_thread) fprintf_unfiltered (gdb_stdlog, "pdc_read_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n", - user, (long) buf, local_hex_string (addr), len); + user, (long) buf, hex_string (addr), len); status = target_read_memory (addr, buf, len); ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE; @@ -480,7 +479,7 @@ pdc_write_data (pthdb_user_t user, void *buf, if (debug_aix_thread) fprintf_unfiltered (gdb_stdlog, "pdc_write_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n", - user, (long) buf, local_hex_string (addr), len); + user, (long) buf, hex_string (addr), len); status = target_write_memory (addr, buf, len); ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE; @@ -551,12 +550,24 @@ state2str (pthdb_state_t state) { switch (state) { - case PST_IDLE: return "idle"; /* being created */ - case PST_RUN: return "running"; /* running */ - case PST_SLEEP: return "sleeping"; /* awaiting an event */ - case PST_READY: return "ready"; /* runnable */ - case PST_TERM: return "finished"; /* awaiting a join/detach */ - default: return "unknown"; + case PST_IDLE: + /* i18n: Like "Thread-Id %d, [state] idle" */ + return _("idle"); /* being created */ + case PST_RUN: + /* i18n: Like "Thread-Id %d, [state] running" */ + return _("running"); /* running */ + case PST_SLEEP: + /* i18n: Like "Thread-Id %d, [state] sleeping" */ + return _("sleeping"); /* awaiting an event */ + case PST_READY: + /* i18n: Like "Thread-Id %d, [state] ready" */ + return _("ready"); /* runnable */ + case PST_TERM: + /* i18n: Like "Thread-Id %d, [state] finished" */ + return _("finished"); /* awaiting a join/detach */ + default: + /* i18n: Like "Thread-Id %d, [state] unknown" */ + return _("unknown"); } } @@ -622,6 +633,35 @@ gcmp (const void *t1v, const void *t2v) return ptid_cmp (t1->ptid, t2->ptid); } +/* Search through the list of all kernel threads for the thread + that has stopped on a SIGTRAP signal, and return its TID. + Return 0 if none found. */ + +static pthdb_tid_t +get_signaled_thread (void) +{ + struct thrdsinfo64 thrinf; + pthdb_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, + sizeof (thrinf), &ktid, 1) != 1) + break; + + if (thrinf.ti_cursig == SIGTRAP) + return thrinf.ti_tid; + } + + /* Didn't find any thread stopped on a SIGTRAP signal. */ + return 0; +} + /* Synchronize GDB's thread list with libpthdebug's. There are some benefits of doing this every time the inferior stops: @@ -748,28 +788,15 @@ sync_threadlists (void) xfree (gbuf); } -/* Iterate_over_threads() callback for locating a thread whose kernel - thread just received a trap signal. */ +/* Iterate_over_threads() callback for locating a thread, using + the TID of its associated kernel thread. */ static int -iter_trap (struct thread_info *thread, void *unused) +iter_tid (struct thread_info *thread, void *tidp) { - struct thrdsinfo64 thrinf; - pthdb_tid_t tid; + const pthdb_tid_t tid = *(pthdb_tid_t *)tidp; - /* 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); - - tid = thread->private->tid; - if (tid == PTHDB_INVALID_TID) - return 0; - - if (getthrds (PIDGET (inferior_ptid), &thrinf, - sizeof (thrinf), &tid, 1) != 1) - return 0; - - return thrinf.ti_cursig == SIGTRAP; + return (thread->private->tid == tid); } /* Synchronize libpthdebug's state with the inferior and with GDB, @@ -781,7 +808,8 @@ pd_update (int set_infpid) { int status; ptid_t ptid; - struct thread_info *thread; + pthdb_tid_t tid; + struct thread_info *thread = NULL; if (!pd_active) return inferior_ptid; @@ -794,7 +822,9 @@ pd_update (int set_infpid) /* Define "current thread" as one that just received a trap signal. */ - thread = iterate_over_threads (iter_trap, NULL); + tid = get_signaled_thread (); + if (tid != 0) + thread = iterate_over_threads (iter_tid, &tid); if (!thread) ptid = inferior_ptid; else @@ -854,7 +884,7 @@ pd_enable (void) return; /* Check application word size. */ - arch64 = DEPRECATED_REGISTER_RAW_SIZE (0) == 8; + arch64 = register_size (current_gdbarch, 0) == 8; /* Check whether the application is pthreaded. */ stub_name = NULL; @@ -952,12 +982,12 @@ aix_thread_resume (ptid_t ptid, int step, enum target_signal sig) { thread = find_thread_pid (ptid); if (!thread) - error ("aix-thread resume: unknown pthread %ld", + error (_("aix-thread resume: unknown pthread %ld"), TIDGET (ptid)); tid[0] = thread->private->tid; if (tid[0] == PTHDB_INVALID_TID) - error ("aix-thread resume: no tid for pthread %ld", + error (_("aix-thread resume: no tid for pthread %ld"), TIDGET (ptid)); tid[1] = 0; @@ -1006,7 +1036,8 @@ supply_gprs64 (uint64_t *vals) int regno; for (regno = 0; regno < ppc_num_gprs; regno++) - supply_register (tdep->ppc_gp0_regnum + regno, (char *) (vals + regno)); + regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regno, + (char *) (vals + regno)); } /* Record that 32-bit register REGNO contains VAL. */ @@ -1014,7 +1045,7 @@ supply_gprs64 (uint64_t *vals) static void supply_reg32 (int regno, uint32_t val) { - supply_register (regno, (char *) &val); + regcache_raw_supply (current_regcache, regno, (char *) &val); } /* Record that the floating-point registers contain VALS. */ @@ -1030,7 +1061,8 @@ supply_fprs (double *vals) gdb_assert (ppc_floating_point_unit_p (current_gdbarch)); for (regno = 0; regno < ppc_num_fprs; regno++) - supply_register (regno + tdep->ppc_fp0_regnum, (char *) (vals + regno)); + regcache_raw_supply (current_regcache, regno + tdep->ppc_fp0_regnum, + (char *) (vals + regno)); } /* Predicate to test whether given register number is a "special" register. */ @@ -1060,14 +1092,15 @@ supply_sprs64 (uint64_t iar, uint64_t msr, uint32_t cr, { struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); - supply_register (PC_REGNUM, (char *) &iar); - supply_register (tdep->ppc_ps_regnum, (char *) &msr); - supply_register (tdep->ppc_cr_regnum, (char *) &cr); - supply_register (tdep->ppc_lr_regnum, (char *) &lr); - supply_register (tdep->ppc_ctr_regnum, (char *) &ctr); - supply_register (tdep->ppc_xer_regnum, (char *) &xer); + regcache_raw_supply (current_regcache, PC_REGNUM, (char *) &iar); + regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum, (char *) &msr); + regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum, (char *) &cr); + regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum, (char *) &lr); + regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum, (char *) &ctr); + regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum, (char *) &xer); if (tdep->ppc_fpscr_regnum >= 0) - supply_register (tdep->ppc_fpscr_regnum, (char *) &fpscr); + regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum, + (char *) &fpscr); } /* Record that the special registers contain the specified 32-bit @@ -1080,14 +1113,15 @@ supply_sprs32 (uint32_t iar, uint32_t msr, uint32_t cr, { struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); - supply_register (PC_REGNUM, (char *) &iar); - supply_register (tdep->ppc_ps_regnum, (char *) &msr); - supply_register (tdep->ppc_cr_regnum, (char *) &cr); - supply_register (tdep->ppc_lr_regnum, (char *) &lr); - supply_register (tdep->ppc_ctr_regnum, (char *) &ctr); - supply_register (tdep->ppc_xer_regnum, (char *) &xer); + regcache_raw_supply (current_regcache, PC_REGNUM, (char *) &iar); + regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum, (char *) &msr); + regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum, (char *) &cr); + regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum, (char *) &lr); + regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum, (char *) &ctr); + regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum, (char *) &xer); if (tdep->ppc_fpscr_regnum >= 0) - supply_register (tdep->ppc_fpscr_regnum, (char *) &fpscr); + regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum, + (char *) &fpscr); } /* Fetch all registers from pthread PDTID, which doesn't have a kernel @@ -1109,7 +1143,7 @@ fetch_regs_user_thread (pthdb_pthread_t pdtid) "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", + error (_("aix-thread: fetch_registers: pthdb_pthread_context returned %s"), pd_status2str (status)); /* General-purpose registers. */ @@ -1223,7 +1257,8 @@ fetch_regs_kernel_thread (int regno, pthdb_tid_t tid) sprs32.pt_fpscr); if (tdep->ppc_mq_regnum >= 0) - supply_register (tdep->ppc_mq_regnum, (char *) &sprs32.pt_mq); + regcache_raw_supply (current_regcache, tdep->ppc_mq_regnum, + (char *) &sprs32.pt_mq); } } } @@ -1261,7 +1296,8 @@ fill_gprs64 (uint64_t *vals) for (regno = 0; regno < ppc_num_gprs; regno++) if (register_cached (tdep->ppc_gp0_regnum + regno)) - regcache_collect (tdep->ppc_gp0_regnum + regno, vals + regno); + regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + regno, + vals + regno); } static void @@ -1272,7 +1308,8 @@ fill_gprs32 (uint32_t *vals) for (regno = 0; regno < ppc_num_gprs; regno++) if (register_cached (tdep->ppc_gp0_regnum + regno)) - regcache_collect (tdep->ppc_gp0_regnum + regno, vals + regno); + regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + regno, + vals + regno); } /* Store the floating point registers into a double array. */ @@ -1290,7 +1327,7 @@ fill_fprs (double *vals) regno < tdep->ppc_fp0_regnum + ppc_num_fprs; regno++) if (register_cached (regno)) - regcache_collect (regno, vals + regno); + regcache_raw_collect (current_regcache, regno, vals + regno); } /* Store the special registers into the specified 64-bit and 32-bit @@ -1308,23 +1345,23 @@ fill_sprs64 (uint64_t *iar, uint64_t *msr, uint32_t *cr, they're not, then either GDB has been built incorrectly, or there's some other kind of internal error. To be really safe, we should check all of the sizes. */ - gdb_assert (sizeof (*iar) == DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM)); + gdb_assert (sizeof (*iar) == register_size (current_gdbarch, PC_REGNUM)); if (register_cached (PC_REGNUM)) - regcache_collect (PC_REGNUM, iar); + regcache_raw_collect (current_regcache, PC_REGNUM, iar); if (register_cached (tdep->ppc_ps_regnum)) - regcache_collect (tdep->ppc_ps_regnum, msr); + regcache_raw_collect (current_regcache, tdep->ppc_ps_regnum, msr); if (register_cached (tdep->ppc_cr_regnum)) - regcache_collect (tdep->ppc_cr_regnum, cr); + regcache_raw_collect (current_regcache, tdep->ppc_cr_regnum, cr); if (register_cached (tdep->ppc_lr_regnum)) - regcache_collect (tdep->ppc_lr_regnum, lr); + regcache_raw_collect (current_regcache, tdep->ppc_lr_regnum, lr); if (register_cached (tdep->ppc_ctr_regnum)) - regcache_collect (tdep->ppc_ctr_regnum, ctr); + regcache_raw_collect (current_regcache, tdep->ppc_ctr_regnum, ctr); if (register_cached (tdep->ppc_xer_regnum)) - regcache_collect (tdep->ppc_xer_regnum, xer); + regcache_raw_collect (current_regcache, tdep->ppc_xer_regnum, xer); if (tdep->ppc_fpscr_regnum >= 0 && register_cached (tdep->ppc_fpscr_regnum)) - regcache_collect (tdep->ppc_fpscr_regnum, fpscr); + regcache_raw_collect (current_regcache, tdep->ppc_fpscr_regnum, fpscr); } static void @@ -1344,23 +1381,23 @@ fill_sprs32 (unsigned long *iar, unsigned long *msr, unsigned long *cr, built incorrectly. In order to make use of many of the header files in /usr/include/sys, GDB needs to be configured so that sizeof (long) == 4). */ - gdb_assert (sizeof (*iar) == DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM)); + gdb_assert (sizeof (*iar) == register_size (current_gdbarch, PC_REGNUM)); if (register_cached (PC_REGNUM)) - regcache_collect (PC_REGNUM, iar); + regcache_raw_collect (current_regcache, PC_REGNUM, iar); if (register_cached (tdep->ppc_ps_regnum)) - regcache_collect (tdep->ppc_ps_regnum, msr); + regcache_raw_collect (current_regcache, tdep->ppc_ps_regnum, msr); if (register_cached (tdep->ppc_cr_regnum)) - regcache_collect (tdep->ppc_cr_regnum, cr); + regcache_raw_collect (current_regcache, tdep->ppc_cr_regnum, cr); if (register_cached (tdep->ppc_lr_regnum)) - regcache_collect (tdep->ppc_lr_regnum, lr); + regcache_raw_collect (current_regcache, tdep->ppc_lr_regnum, lr); if (register_cached (tdep->ppc_ctr_regnum)) - regcache_collect (tdep->ppc_ctr_regnum, ctr); + regcache_raw_collect (current_regcache, tdep->ppc_ctr_regnum, ctr); if (register_cached (tdep->ppc_xer_regnum)) - regcache_collect (tdep->ppc_xer_regnum, xer); + regcache_raw_collect (current_regcache, tdep->ppc_xer_regnum, xer); if (tdep->ppc_fpscr_regnum >= 0 && register_cached (tdep->ppc_fpscr_regnum)) - regcache_collect (tdep->ppc_fpscr_regnum, fpscr); + regcache_raw_collect (current_regcache, tdep->ppc_fpscr_regnum, fpscr); } /* Store all registers into pthread PDTID, which doesn't have a kernel @@ -1387,7 +1424,7 @@ store_regs_user_thread (pthdb_pthread_t pdtid) values. */ status = pthdb_pthread_context (pd_session, pdtid, &ctx); if (status != PTHDB_SUCCESS) - error ("aix-thread: store_registers: pthdb_pthread_context returned %s", + error (_("aix-thread: store_registers: pthdb_pthread_context returned %s"), pd_status2str (status)); /* Collect general-purpose register values from the regcache. */ @@ -1397,12 +1434,14 @@ store_regs_user_thread (pthdb_pthread_t pdtid) { if (arch64) { - regcache_collect (tdep->ppc_gp0_regnum + i, (void *) &int64); + regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + i, + (void *) &int64); ctx.gpr[i] = int64; } else { - regcache_collect (tdep->ppc_gp0_regnum + i, (void *) &int32); + regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + i, + (void *) &int32); ctx.gpr[i] = int32; } } @@ -1446,7 +1485,7 @@ store_regs_user_thread (pthdb_pthread_t pdtid) 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)); } @@ -1534,7 +1573,8 @@ store_regs_kernel_thread (int regno, pthdb_tid_t tid) if (tdep->ppc_mq_regnum >= 0) if (register_cached (tdep->ppc_mq_regnum)) - regcache_collect (tdep->ppc_mq_regnum, &sprs32.pt_mq); + regcache_raw_collect (current_regcache, tdep->ppc_mq_regnum, + &sprs32.pt_mq); ptrace32 (PTT_WRITE_SPRS, tid, (int *) &sprs32, 0, NULL); } @@ -1576,8 +1616,8 @@ aix_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, struct cleanup *cleanup = save_inferior_ptid (); inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid)); - n = base_target.to_xfer_memory (memaddr, myaddr, len, - write, attrib, &base_target); + n = base_target.deprecated_xfer_memory (memaddr, myaddr, len, + write, attrib, &base_target); do_cleanups (cleanup); return n; @@ -1632,7 +1672,7 @@ aix_thread_pid_to_str (ptid_t ptid) xstrprintf(). */ xfree (ret); - ret = xstrprintf ("Thread %ld", ptid_get_tid (ptid)); + ret = xstrprintf (_("Thread %ld"), ptid_get_tid (ptid)); return ret; } @@ -1662,7 +1702,8 @@ aix_thread_extra_thread_info (struct thread_info *thread) tid = thread->private->tid; if (tid != PTHDB_INVALID_TID) - fprintf_unfiltered (buf, "tid %d", tid); + /* i18n: Like "thread-identifier %d, [state] running, suspended" */ + fprintf_unfiltered (buf, _("tid %d"), tid); status = pthdb_pthread_state (pd_session, pdtid, &state); if (status != PTHDB_SUCCESS) @@ -1672,16 +1713,19 @@ aix_thread_extra_thread_info (struct thread_info *thread) status = pthdb_pthread_suspendstate (pd_session, pdtid, &suspendstate); if (status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED) - fprintf_unfiltered (buf, ", suspended"); + /* i18n: Like "Thread-Id %d, [state] running, suspended" */ + fprintf_unfiltered (buf, _(", suspended")); status = pthdb_pthread_detachstate (pd_session, pdtid, &detachstate); if (status == PTHDB_SUCCESS && detachstate == PDS_DETACHED) - fprintf_unfiltered (buf, ", detached"); + /* i18n: Like "Thread-Id %d, [state] running, detached" */ + fprintf_unfiltered (buf, _(", detached")); pthdb_pthread_cancelpend (pd_session, pdtid, &cancelpend); if (status == PTHDB_SUCCESS && cancelpend) - fprintf_unfiltered (buf, ", cancel pending"); + /* i18n: Like "Thread-Id %d, [state] running, cancel pending" */ + fprintf_unfiltered (buf, _(", cancel pending")); ui_file_write (buf, "", 1); @@ -1699,8 +1743,8 @@ 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_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; @@ -1708,7 +1752,7 @@ init_aix_thread_ops (void) 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; + aix_thread_ops.deprecated_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. */ aix_thread_ops.to_kill = aix_thread_kill; @@ -1733,10 +1777,10 @@ _initialize_aix_thread (void) target_new_objfile_chain = deprecated_target_new_objfile_hook; deprecated_target_new_objfile_hook = new_objfile; - add_show_from_set (add_set_cmd ("aix-thread", no_class, var_zinteger, - (char *) &debug_aix_thread, - "Set debugging of AIX thread module.\n" - "Enables printf debugging output.\n", - &setdebuglist), - &showdebuglist); + add_setshow_zinteger_cmd ("aix-thread", no_class, (char *) &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); }