fourth and last patch to aix-thread.c

fourth and last patch to aix-thread.c

[Michael Snyder]

[-- Attachment #1: Type: text/plain, Size: 363 bytes --]

Hi Kevin, 

This is the last one, I promise.  I thought some of the identifiers in
aix-thread
were a little un-informative and/or inconsistant with other target
modules, so
I offer you this renaming.

And I humbly beg your pardon, but I was unable to resist sneaking a few
whitespace clean-ups in there too.  If you like, I'll re-submit them 
separately.

Michael

[-- Attachment #2: rename2.patch --]
[-- Type: text/plain, Size: 21680 bytes --]

2002-07-19  Michael Snyder  <msnyder@redhat.com>

	* aix-thread.c (ops): Rename to pthdebug_ops.
	(base_ops): Rename to base_target.
	(ops_attach): Rename to pthdebug_attach.
	(ops_detach): Rename to pthdebug_detach.
	(ops_resume): Rename to pthdebug_detach.
	(ops_wait):   Rename to pthdebug_wait.
	(ops_kill):   Rename to pthdebug_kill.
	(init_ops):   Rename to init_pthdebug_ops.
	(ops_fetch_register): Rename to pthdebug_fetch_register.
	(ops_store_register): Rename to pthdebug_store_register.
	(ops_mourn_inferior): Rename to pthdebug_mourn_inferior.
	(ops_thread_alive):   Rename to pthdebug_thread_alive.
	(ops_extra_thread_info: Rename to pthdebug_extra_thread_info.
	(ops_pid_to_str):  Rename to pthdebug_pid_to_str.
	(ops_xfer_memory): Rename to pthdebug_xfer_memory.
	(fetch_regs_lib):  Rename to fetch_regs_user_thread.
	(fetch_regs_kern): Rename to fetch_regs_kernel_thread.
	(store_regs_lib):  Rename to store_regs_user_thread.
	(store_regs_kern): Rename to store_regs_kernel_thread.

Index: aix-thread.c
===================================================================
RCS file: /es/scratch/msnyder/cvsroot/aix/threads/aix-thread.c,v
retrieving revision 1.4
retrieving revision 1.6
diff -p -r1.4 -r1.6
*** aix-thread.c	2002/07/18 17:02:13	1.4
--- aix-thread.c	2002/07/19 12:25:08	1.6
*************** struct pd_thread {
*** 108,120 ****
  
  /* This module's target-specific operations, active while pd_able is true.  */
  
! static struct target_ops 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;
  
  /* Address of the function that libpthread will call when libpthdebug
     is ready to be initialized.  */
--- 108,120 ----
  
  /* This module's target-specific operations, active while pd_able is true.  */
  
! static struct target_ops pthdebug_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_target;
  
  /* Address of the function that libpthread will call when libpthdebug
     is ready to be initialized.  */
*************** ptrace32 (int req, int id, int *addr, in
*** 265,271 ****
  {
    errno = 0;
    return ptrace_check (req, id, 
! 		       ptrace (req, id, (int *)addr, data, buf));
  }
  
  /* If *PIDP is a composite process/thread id, convert it to a
--- 265,271 ----
  {
    errno = 0;
    return ptrace_check (req, id, 
! 		       ptrace (req, id, (int *) addr, data, buf));
  }
  
  /* If *PIDP is a composite process/thread id, convert it to a
*************** pdc_read_regs (pthdb_user_t user, 
*** 350,356 ****
    
    if (debug_aix_thread)
      fprintf_unfiltered (gdb_stdlog, "pdc_read_regs tid=%d flags=%llx\n",
!                         (int)tid, flags);
  
    /* General-purpose registers.  */
    if (flags & PTHDB_FLAG_GPRS)
--- 350,356 ----
    
    if (debug_aix_thread)
      fprintf_unfiltered (gdb_stdlog, "pdc_read_regs tid=%d flags=%llx\n",
!                         (int) tid, flags);
  
    /* General-purpose registers.  */
    if (flags & PTHDB_FLAG_GPRS)
*************** pdc_write_regs (pthdb_user_t user,
*** 416,437 ****
  
    if (debug_aix_thread)
      fprintf_unfiltered (gdb_stdlog, "pdc_write_regs tid=%d flags=%llx\n",
!                         (int)tid, flags);
  
    /* General-purpose registers.  */
    if (flags & PTHDB_FLAG_GPRS)
      {
        if (arch64)
  	ptrace64aix (PTT_WRITE_GPRS, tid, 
! 		     (unsigned long)context->gpr, 0, NULL);
        else
! 	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);
      }
  
    /* Special-purpose registers.  */
--- 416,437 ----
  
    if (debug_aix_thread)
      fprintf_unfiltered (gdb_stdlog, "pdc_write_regs tid=%d flags=%llx\n",
!                         (int) tid, flags);
  
    /* General-purpose registers.  */
    if (flags & PTHDB_FLAG_GPRS)
      {
        if (arch64)
  	ptrace64aix (PTT_WRITE_GPRS, tid, 
! 		     (unsigned long) context->gpr, 0, NULL);
        else
! 	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);
      }
  
    /* Special-purpose registers.  */
*************** pdc_write_regs (pthdb_user_t user,
*** 444,450 ****
  	}
        else
  	{
! 	  ptrace32 (PTT_WRITE_SPRS, tid, (int *)&context->msr, 0, NULL);
  	}
      }
    return 0;
--- 444,450 ----
  	}
        else
  	{
! 	  ptrace32 (PTT_WRITE_SPRS, tid, (int *) &context->msr, 0, NULL);
  	}
      }
    return 0;
*************** pd_enable (void)
*** 875,882 ****
      return;
  
    /* Prepare for thread debugging.  */
!   base_ops = current_target;
!   push_target (&ops);
    pd_able = 1;
  
    /* If we're debugging a core file or an attached inferior, the
--- 875,882 ----
      return;
  
    /* Prepare for thread debugging.  */
!   base_target = current_target;
!   push_target (&pthdebug_ops);
    pd_able = 1;
  
    /* If we're debugging a core file or an attached inferior, the
*************** pd_disable (void)
*** 895,901 ****
    if (pd_active)
      pd_deactivate ();
    pd_able = 0;
!   unpush_target (&ops);
  }
  
  /* target_new_objfile_hook callback.
--- 895,901 ----
    if (pd_active)
      pd_deactivate ();
    pd_able = 0;
!   unpush_target (&pthdebug_ops);
  }
  
  /* target_new_objfile_hook callback.
*************** new_objfile (struct objfile *objfile)
*** 920,945 ****
  /* Attach to process specified by ARGS.  */
  
  static void
! ops_attach (char *args, int from_tty)
  {
!   base_ops.to_attach (args, from_tty);
    pd_activate (1);
  }
  
! /* Detach from the process attached to by ops_attach().  */
  
  static void
! ops_detach (char *args, int from_tty)
  {
    pd_deactivate ();
!   base_ops.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)
  {
    struct thread_info *thread;
    pthdb_tid_t tid[2];
--- 920,945 ----
  /* Attach to process specified by ARGS.  */
  
  static void
! pthdebug_attach (char *args, int from_tty)
  {
!   base_target.to_attach (args, from_tty);
    pd_activate (1);
  }
  
! /* Detach from the process attached to by pthdebug_attach().  */
  
  static void
! pthdebug_detach (char *args, int from_tty)
  {
    pd_deactivate ();
!   base_target.to_detach (args, from_tty);
  }
  
  /* Tell the inferior process to continue running thread PID if != -1
     and all threads otherwise.  */
  
  static void
! pthdebug_resume (ptid_t ptid, int step, enum target_signal sig)
  {
    struct thread_info *thread;
    pthdb_tid_t tid[2];
*************** ops_resume (ptid_t ptid, int step, enum 
*** 948,954 ****
      {
        struct cleanup *cleanup = save_inferior_ptid ();
        inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
!       base_ops.to_resume (ptid, step, sig);
        do_cleanups (cleanup);
      }
    else
--- 948,954 ----
      {
        struct cleanup *cleanup = save_inferior_ptid ();
        inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
!       base_target.to_resume (ptid, step, sig);
        do_cleanups (cleanup);
      }
    else
*************** ops_resume (ptid_t ptid, int step, enum 
*** 966,975 ****
  
        if (arch64)
  	ptrace64aix (PTT_CONTINUE, tid[0], 1, 
! 		     target_signal_to_host (sig), (int *)tid);
        else
  	ptrace32 (PTT_CONTINUE, tid[0], (int *) 1,
! 		  target_signal_to_host (sig), (int *)tid);
      }
  }
  
--- 966,975 ----
  
        if (arch64)
  	ptrace64aix (PTT_CONTINUE, tid[0], 1, 
! 		     target_signal_to_host (sig), (int *) tid);
        else
  	ptrace32 (PTT_CONTINUE, tid[0], (int *) 1,
! 		  target_signal_to_host (sig), (int *) tid);
      }
  }
  
*************** ops_resume (ptid_t ptid, int step, enum 
*** 978,991 ****
     thread.  */
  
  static ptid_t
! ops_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);
    do_cleanups (cleanup);
  
    if (PIDGET (ptid) == -1)
--- 978,991 ----
     thread.  */
  
  static ptid_t
! pthdebug_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_target.to_wait (ptid, status);
    do_cleanups (cleanup);
  
    if (PIDGET (ptid) == -1)
*************** supply_sprs32 (uint32_t iar, uint32_t ms
*** 1072,1084 ****
     function.  */
  
  static void
! fetch_regs_lib (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);
    status = pthdb_pthread_context (pd_session, pdtid, &ctx);
    if (status != PTHDB_SUCCESS)
      error ("aix-thread: fetch_registers: pthdb_pthread_context returned %s",
--- 1072,1085 ----
     function.  */
  
  static void
! 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_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",
*************** fetch_regs_lib (pthdb_pthread_t pdtid)
*** 1120,1126 ****
     be retrieved.  */
  
  static void
! fetch_regs_kern (int regno, pthdb_tid_t tid)
  {
    uint64_t gprs64[32];
    uint32_t gprs32[32];
--- 1121,1127 ----
     be retrieved.  */
  
  static void
! fetch_regs_kernel_thread (int regno, pthdb_tid_t tid)
  {
    uint64_t gprs64[32];
    uint32_t gprs32[32];
*************** fetch_regs_kern (int regno, pthdb_tid_t 
*** 1131,1138 ****
  
    if (debug_aix_thread)
      fprintf_unfiltered (gdb_stdlog,
! 			"fetch_regs_kern tid=%lx regno=%d arch64=%d\n",
! 			(long)tid, regno, arch64);
  
    /* General-purpose registers.  */
    if (regno == -1 || regno < FP0_REGNUM)
--- 1132,1139 ----
  
    if (debug_aix_thread)
      fprintf_unfiltered (gdb_stdlog,
! 	"fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n",
! 	(long) tid, regno, arch64);
  
    /* General-purpose registers.  */
    if (regno == -1 || regno < FP0_REGNUM)
*************** fetch_regs_kern (int regno, pthdb_tid_t 
*** 1192,1213 ****
     thread/process specified by inferior_ptid.  */
  
  static void
! ops_fetch_registers (int regno)
  {
    struct thread_info *thread;
    pthdb_tid_t tid;
  
    if (!PD_TID (inferior_ptid))
!     base_ops.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);
        else
! 	fetch_regs_kern (regno, tid);
      }
  }
  
--- 1193,1214 ----
     thread/process specified by inferior_ptid.  */
  
  static void
! pthdebug_fetch_registers (int regno)
  {
    struct thread_info *thread;
    pthdb_tid_t tid;
  
    if (!PD_TID (inferior_ptid))
!     base_target.to_fetch_registers (regno);
    else
      {
        thread = find_thread_pid (inferior_ptid);
        tid = thread->private->tid;
  
        if (tid == PTHDB_INVALID_TID)
! 	fetch_regs_user_thread (thread->private->pdtid);
        else
! 	fetch_regs_kernel_thread (regno, tid);
      }
  }
  
*************** fill_sprs32 (uint32_t *iar, uint32_t *ms
*** 1294,1300 ****
     but I doubt it's worth the effort.  */
  
  static void
! store_regs_lib (pthdb_pthread_t pdtid)
  {
    int status, i;
    pthdb_context_t ctx;
--- 1295,1301 ----
     but I doubt it's worth the effort.  */
  
  static void
! store_regs_user_thread (pthdb_pthread_t pdtid)
  {
    int status, i;
    pthdb_context_t ctx;
*************** store_regs_lib (pthdb_pthread_t pdtid)
*** 1304,1310 ****
  
    if (debug_aix_thread)
      fprintf_unfiltered (gdb_stdlog, 
! 			"store_regs_lib %lx\n", (long)pdtid);
  
    /* Retrieve the thread's current context for its non-register
       values.  */
--- 1305,1311 ----
  
    if (debug_aix_thread)
      fprintf_unfiltered (gdb_stdlog, 
! 			"store_regs_user_thread %lx\n", (long) pdtid);
  
    /* Retrieve the thread's current context for its non-register
       values.  */
*************** store_regs_lib (pthdb_pthread_t pdtid)
*** 1374,1380 ****
     group.  */
  
  static void
! store_regs_kern (int regno, pthdb_tid_t tid)
  {
    uint64_t gprs64[32];
    uint32_t gprs32[32];
--- 1375,1381 ----
     group.  */
  
  static void
! store_regs_kernel_thread (int regno, pthdb_tid_t tid)
  {
    uint64_t gprs64[32];
    uint32_t gprs32[32];
*************** store_regs_kern (int regno, pthdb_tid_t 
*** 1384,1391 ****
    int i;
  
    if (debug_aix_thread)
!     fprintf_unfiltered (gdb_stdlog, "store_regs_kern tid=%lx regno=%d\n",
!                         (long)tid, regno);
  
    /* General-purpose registers.  */
    if (regno == -1 || regno < FP0_REGNUM)
--- 1385,1393 ----
    int i;
  
    if (debug_aix_thread)
!     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)
*************** store_regs_kern (int regno, pthdb_tid_t 
*** 1452,1473 ****
     thread/process specified by inferior_ptid.  */
  
  static void
! ops_store_registers (int regno)
  {
    struct thread_info *thread;
    pthdb_tid_t tid;
  
    if (!PD_TID (inferior_ptid))
!     base_ops.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);
        else
! 	store_regs_kern (regno, tid);
      }
  }
  
--- 1454,1475 ----
     thread/process specified by inferior_ptid.  */
  
  static void
! pthdebug_store_registers (int regno)
  {
    struct thread_info *thread;
    pthdb_tid_t tid;
  
    if (!PD_TID (inferior_ptid))
!     base_target.to_store_registers (regno);
    else
      {
        thread = find_thread_pid (inferior_ptid);
        tid = thread->private->tid;
  
        if (tid == PTHDB_INVALID_TID)
! 	store_regs_user_thread (thread->private->pdtid);
        else
! 	store_regs_kernel_thread (regno, tid);
      }
  }
  
*************** ops_store_registers (int regno)
*** 1475,1490 ****
     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)
  {
    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);
    do_cleanups (cleanup);
  
    return n;
--- 1477,1492 ----
     address MEMADDR if WRITE and vice versa otherwise.  */
  
  static int
! pthdebug_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_target.to_xfer_memory (memaddr, myaddr, len, 
! 				  write, attrib, &base_target);
    do_cleanups (cleanup);
  
    return n;
*************** ops_xfer_memory (CORE_ADDR memaddr, char
*** 1493,1523 ****
  /* Kill and forget about the inferior process.  */
  
  static void
! ops_kill (void)
  {
    struct cleanup *cleanup = save_inferior_ptid ();
  
    inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
!   base_ops.to_kill ();
    do_cleanups (cleanup);
  }
  
  /* Clean up after the inferior exits.  */
  
  static void
! ops_mourn_inferior (void)
  {
    pd_deactivate ();
!   base_ops.to_mourn_inferior ();
  }
  
  /* Return whether thread PID is still valid.  */
  
  static int
! ops_thread_alive (ptid_t ptid)
  {
    if (!PD_TID (ptid))
!     return base_ops.to_thread_alive (ptid);
  
    /* We update the thread list every time the child stops, so all
       valid threads should be in the thread list.  */
--- 1495,1525 ----
  /* Kill and forget about the inferior process.  */
  
  static void
! pthdebug_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
! pthdebug_mourn_inferior (void)
  {
    pd_deactivate ();
!   base_target.to_mourn_inferior ();
  }
  
  /* Return whether thread PID is still valid.  */
  
  static int
! pthdebug_thread_alive (ptid_t ptid)
  {
    if (!PD_TID (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.  */
*************** ops_thread_alive (ptid_t ptid)
*** 1528,1539 ****
     "info threads" output.  */
  
  static char *
! ops_pid_to_str (ptid_t ptid)
  {
    static char *ret = NULL;
  
    if (!PD_TID (ptid))
!     return base_ops.to_pid_to_str (ptid);
  
    /* Free previous return value; a new one will be allocated by
       xasprintf().  */
--- 1530,1541 ----
     "info threads" output.  */
  
  static char *
! pthdebug_pid_to_str (ptid_t ptid)
  {
    static char *ret = NULL;
  
    if (!PD_TID (ptid))
!     return base_target.to_pid_to_str (ptid);
  
    /* Free previous return value; a new one will be allocated by
       xasprintf().  */
*************** ops_pid_to_str (ptid_t ptid)
*** 1547,1553 ****
     THREAD, for use in "info threads" output.  */
  
  static char *
! ops_extra_thread_info (struct thread_info *thread)
  {
    struct ui_file *buf;
    int status;
--- 1549,1555 ----
     THREAD, for use in "info threads" output.  */
  
  static char *
! pthdebug_extra_thread_info (struct thread_info *thread)
  {
    struct ui_file *buf;
    int status;
*************** ops_extra_thread_info (struct thread_inf
*** 1600,1630 ****
    return ret;
  }
  
! /* Initialize target ops.  */
  
  static void
! init_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
       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;
  }
  
  /* Module startup initialization function, automagically called by
--- 1602,1632 ----
    return ret;
  }
  
! /* Initialize target pthdebug_ops.  */
  
  static void
! init_pthdebug_ops (void)
  {
!   pthdebug_ops.to_shortname          = "aix-threads";
!   pthdebug_ops.to_longname           = "AIX pthread support";
!   pthdebug_ops.to_doc                = "AIX pthread support";
! 
!   pthdebug_ops.to_attach             = ops_attach;
!   pthdebug_ops.to_detach             = ops_detach;
!   pthdebug_ops.to_resume             = ops_resume;
!   pthdebug_ops.to_wait               = ops_wait;
!   pthdebug_ops.to_fetch_registers    = ops_fetch_registers;
!   pthdebug_ops.to_store_registers    = ops_store_registers;
!   pthdebug_ops.to_xfer_memory        = ops_xfer_memory;
!   /* No need for pthdebug_ops.to_create_inferior, because we activate thread
       debugging when the inferior reaches pd_brk_addr.  */
!   pthdebug_ops.to_kill               = ops_kill;
!   pthdebug_ops.to_mourn_inferior     = ops_mourn_inferior;
!   pthdebug_ops.to_thread_alive       = ops_thread_alive;
!   pthdebug_ops.to_pid_to_str         = ops_pid_to_str;
!   pthdebug_ops.to_extra_thread_info  = ops_extra_thread_info;
!   pthdebug_ops.to_stratum            = thread_stratum;
!   pthdebug_ops.to_magic              = OPS_MAGIC;
  }
  
  /* Module startup initialization function, automagically called by
*************** init_ops (void)
*** 1633,1640 ****
  void
  _initialize_aix_thread (void)
  {
!   init_ops ();
!   add_target (&ops);
  
    /* Notice when object files get loaded and unloaded.  */
    target_new_objfile_chain = target_new_objfile_hook;
--- 1635,1642 ----
  void
  _initialize_aix_thread (void)
  {
!   init_pthdebug_ops ();
!   add_target (&pthdebug_ops);
  
    /* Notice when object files get loaded and unloaded.  */
    target_new_objfile_chain = target_new_objfile_hook;

Adding %ll to ARI

[Andrew Cagney]

Just noticed this in aix-thread.c.  I'm adding %ll to the ARI.  I'm 
pretty sure that isn't ISO C. While valprint.c wrapped it up in:

#if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)

I think using %s and phex() and friends will be easier.

enjoy,
Andrew

Re: Adding %ll to ARI

[Kevin Buettner]

On Jul 19,  8:42pm, Andrew Cagney wrote:

> Just noticed this in aix-thread.c.  I'm adding %ll to the ARI.  I'm 
> pretty sure that isn't ISO C. While valprint.c wrapped it up in:
> 
> #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
> 
> I think using %s and phex() and friends will be easier.

I've fixed this problem in aix-thread.c.  I ended up using
local_hex_string() due to its simpler interface.

Kevin

Re: fourth and last patch to aix-thread.c

[Kevin Buettner]

On Jul 19,  3:46pm, Michael Snyder wrote:

> This is the last one, I promise.  I thought some of the identifiers in
> aix-thread
> were a little un-informative and/or inconsistant with other target
> modules, so
> I offer you this renaming.
> 
> And I humbly beg your pardon, but I was unable to resist sneaking a few
> whitespace clean-ups in there too.  If you like, I'll re-submit them 
> separately.
[...]
> 	* aix-thread.c (ops): Rename to pthdebug_ops.
> 	(base_ops): Rename to base_target.
> 	(ops_attach): Rename to pthdebug_attach.
> 	(ops_detach): Rename to pthdebug_detach.
> 	(ops_resume): Rename to pthdebug_detach.
> 	(ops_wait):   Rename to pthdebug_wait.
> 	(ops_kill):   Rename to pthdebug_kill.
> 	(init_ops):   Rename to init_pthdebug_ops.
> 	(ops_fetch_register): Rename to pthdebug_fetch_register.
> 	(ops_store_register): Rename to pthdebug_store_register.
> 	(ops_mourn_inferior): Rename to pthdebug_mourn_inferior.
> 	(ops_thread_alive):   Rename to pthdebug_thread_alive.
> 	(ops_extra_thread_info: Rename to pthdebug_extra_thread_info.
> 	(ops_pid_to_str):  Rename to pthdebug_pid_to_str.
> 	(ops_xfer_memory): Rename to pthdebug_xfer_memory.
> 	(fetch_regs_lib):  Rename to fetch_regs_user_thread.
> 	(fetch_regs_kern): Rename to fetch_regs_kernel_thread.
> 	(store_regs_lib):  Rename to store_regs_user_thread.
> 	(store_regs_kern): Rename to store_regs_kernel_thread.

I've check this in with a couple of modifications:

    1) I used ``aix_thread_'' instead of ``pthdebug_''.  If you check
       lin-lwp.c and thread-db.c, the use of ``aix_thread'' more closely
       corresponds (IMO) to what's done in those files.

    2) I fixed up a few places where a substition was missed.

Michael, thanks for all the work you did in reviewing and cleaning up
this code.  I really appreciate it.

(Now that I've been away from it for a few days and looked at it again,
I've found a few more things that I want to clean up...)

Kevin