Updated copyright notices for most files.

[deliverable/binutils-gdb.git] / gdb / hpux-thread.c

diff --git a/gdb/hpux-thread.c b/gdb/hpux-thread.c
index 4efeb4a5725aaf9486f3e76cf1fbc5b4b3edd0a5..fe87382a51f74ba96657cdcb8d27fbaf991f9891 100644 (file)
--- a/gdb/hpux-thread.c
+++ b/gdb/hpux-thread.c
@@ -1,11 +1,14 @@
-/* Low level interface for debugging HPUX/DCE threads for GDB, the GNU debugger.
-   Copyright 1996, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+/* Low level interface for debugging HPUX/DCE threads for GDB, the GNU
+   debugger.
+
+   Copyright (C) 1996, 1998, 1999, 2000, 2001, 2004, 2007, 2008
+   Free Software Foundation, Inc.

 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -14,9 +17,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    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.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 /* This module implements a sort of half target that sits between the
    machine-independent parts of GDB and the ptrace interface (infptrace.c) to
 
 /* This module implements a sort of half target that sits between the
    machine-independent parts of GDB and the ptrace interface (infptrace.c) to


@@ -41,11 +42,13 @@
 #include "inferior.h"
 #include "regcache.h"
 #include <fcntl.h>
 #include "inferior.h"
 #include "regcache.h"
 #include <fcntl.h>

-#include <sys/stat.h>
+#include <string.h>
+#include "gdb_stat.h"

 #include "gdbcore.h"
 #include "gdbcore.h"

+#include "hppa-tdep.h"
+#include "observer.h"

 
 extern int child_suppress_run;
 
 extern int child_suppress_run;

-extern struct target_ops child_ops;    /* target vector for inftarg.c */

 
 extern void _initialize_hpux_thread (void);
 
 
 extern void _initialize_hpux_thread (void);
 


@@ -62,10 +65,6 @@ static ptid_t main_ptid;             /* Real process ID */
 static CORE_ADDR P_cma__g_known_threads;
 static CORE_ADDR P_cma__g_current_thread;
 
 static CORE_ADDR P_cma__g_known_threads;
 static CORE_ADDR P_cma__g_current_thread;
 

-static struct cleanup *save_inferior_ptid (void);
-
-static void restore_inferior_ptid (ptid_t pid);
-

 static void hpux_thread_resume (ptid_t ptid, int step,
                                 enum target_signal signo);
 
 static void hpux_thread_resume (ptid_t ptid, int step,
                                 enum target_signal signo);
 


@@ -73,78 +72,35 @@ static void init_hpux_thread_ops (void);
 
 static struct target_ops hpux_thread_ops;
 \f
 
 static struct target_ops hpux_thread_ops;
 \f

-/*
-
-   LOCAL FUNCTION
-
-   save_inferior_ptid - Save inferior_ptid on the cleanup list
-   restore_inferior_ptid - Restore inferior_ptid from the cleanup list
-
-   SYNOPSIS
-
-   struct cleanup *save_inferior_ptid ()
-   void restore_inferior_ptid (int pid)
-
-   DESCRIPTION
-
-   These two functions act in unison to restore inferior_ptid in
-   case of an error.
-
-   NOTES
-
-   inferior_ptid is a global variable that needs to be changed by many of
-   these routines before calling functions in procfs.c.  In order to
-   guarantee that inferior_ptid gets restored (in case of errors), you
-   need to call save_inferior_ptid before changing it.  At the end of the
-   function, you should invoke do_cleanups to restore it.
-
- */
-
-
-static struct cleanup *
-save_inferior_ptid (void)
-{
-  return make_cleanup (restore_inferior_ptid, inferior_ptid);
-}
-
-static void
-restore_inferior_ptid (ptid_t ptid)
-{
-  inferior_ptid = ptid;
-}
-\f
-static int find_active_thread (void);
+static ptid_t find_active_thread (void);

 
 static int cached_thread;
 
 static int cached_thread;

-static int cached_active_thread;

 static cma__t_int_tcb cached_tcb;
 
 static cma__t_int_tcb cached_tcb;
 

-static int
+static ptid_t

 find_active_thread (void)
 {
   static cma__t_int_tcb tcb;
   CORE_ADDR tcb_ptr;
 
 find_active_thread (void)
 {
   static cma__t_int_tcb tcb;
   CORE_ADDR tcb_ptr;
 

-  if (cached_active_thread != 0)
-    return cached_active_thread;
-

   read_memory ((CORE_ADDR) P_cma__g_current_thread,
               (char *) &tcb_ptr,
               sizeof tcb_ptr);
 
   read_memory (tcb_ptr, (char *) &tcb, sizeof tcb);
 
   read_memory ((CORE_ADDR) P_cma__g_current_thread,
               (char *) &tcb_ptr,
               sizeof tcb_ptr);
 
   read_memory (tcb_ptr, (char *) &tcb, sizeof tcb);
 

-  return (cma_thread_get_unique (&tcb.prolog.client_thread) << 16) 
-         | PIDGET (main_ptid);
+  return (ptid_build (PIDGET (main_ptid), 0,
+                      cma_thread_get_unique (&tcb.prolog.client_thread)));

 }
 
 }
 

-static cma__t_int_tcb *find_tcb (int thread);
+static cma__t_int_tcb *find_tcb (ptid_t ptid);

 
 static cma__t_int_tcb *
 
 static cma__t_int_tcb *

-find_tcb (int thread)
+find_tcb (ptid_t ptid)

 {
   cma__t_known_object queue_header;
   cma__t_queue *queue_ptr;
 {
   cma__t_known_object queue_header;
   cma__t_queue *queue_ptr;

+  int thread = ptid_get_tid (ptid);

 
   if (thread == cached_thread)
     return &cached_tcb;
 
   if (thread == cached_thread)
     return &cached_tcb;


@@ -164,25 +120,24 @@ find_tcb (int thread)
       read_memory ((CORE_ADDR) tcb_ptr, (char *) &cached_tcb, sizeof cached_tcb);
 
       if (cached_tcb.header.type == cma__c_obj_tcb)
       read_memory ((CORE_ADDR) tcb_ptr, (char *) &cached_tcb, sizeof cached_tcb);
 
       if (cached_tcb.header.type == cma__c_obj_tcb)

-       if (cma_thread_get_unique (&cached_tcb.prolog.client_thread) == thread >> 16)
+       if (cma_thread_get_unique (&cached_tcb.prolog.client_thread) == thread)

          {
            cached_thread = thread;
            return &cached_tcb;
          }
     }
 
          {
            cached_thread = thread;
            return &cached_tcb;
          }
     }
 

-  error ("Can't find TCB %d,%d", thread >> 16, thread & 0xffff);
+  error (_("Can't find TCB %d"), thread);

   return NULL;
 }
 \f
 /* Most target vector functions from here on actually just pass through to
    inftarg.c, as they don't need to do anything specific for threads.  */
 
   return NULL;
 }
 \f
 /* Most target vector functions from here on actually just pass through to
    inftarg.c, as they don't need to do anything specific for threads.  */
 

-/* ARGSUSED */

 static void
 hpux_thread_open (char *arg, int from_tty)
 {
 static void
 hpux_thread_open (char *arg, int from_tty)
 {

-  child_ops.to_open (arg, from_tty);
+  deprecated_child_ops.to_open (arg, from_tty);

 }
 
 /* Attach to process PID, then initialize for debugging it
 }
 
 /* Attach to process PID, then initialize for debugging it


@@ -191,7 +146,7 @@ hpux_thread_open (char *arg, int from_tty)
 static void
 hpux_thread_attach (char *args, int from_tty)
 {
 static void
 hpux_thread_attach (char *args, int from_tty)
 {

-  child_ops.to_attach (args, from_tty);
+  deprecated_child_ops.to_attach (args, from_tty);

 
   /* XXX - might want to iterate over all the threads and register them. */
 }
 
   /* XXX - might want to iterate over all the threads and register them. */
 }


@@ -207,7 +162,7 @@ hpux_thread_attach (char *args, int from_tty)
 static void
 hpux_thread_detach (char *args, int from_tty)
 {
 static void
 hpux_thread_detach (char *args, int from_tty)
 {

-  child_ops.to_detach (args, from_tty);
+  deprecated_child_ops.to_detach (args, from_tty);

 }
 
 /* Resume execution of process PID.  If STEP is nozero, then
 }
 
 /* Resume execution of process PID.  If STEP is nozero, then


@@ -230,14 +185,13 @@ hpux_thread_resume (ptid_t ptid, int step, enum target_signal signo)
     {
       pid = thread_to_lwp (pid, -2);
       if (pid == -2)           /* Inactive thread */
     {
       pid = thread_to_lwp (pid, -2);
       if (pid == -2)           /* Inactive thread */

-       error ("This version of Solaris can't start inactive threads.");
+       error (_("This version of Solaris can't start inactive threads."));

     }
 #endif
 
     }
 #endif
 

-  child_ops.to_resume (ptid, step, signo);
+  deprecated_child_ops.to_resume (ptid, step, signo);

 
   cached_thread = 0;
 
   cached_thread = 0;

-  cached_active_thread = 0;

 
   do_cleanups (old_chain);
 }
 
   do_cleanups (old_chain);
 }


@@ -258,7 +212,7 @@ hpux_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
   if (!ptid_equal (ptid, minus_one_ptid))
     ptid = main_ptid;
 
   if (!ptid_equal (ptid, minus_one_ptid))
     ptid = main_ptid;
 

-  rtnval = child_ops.to_wait (ptid, ourstatus);
+  rtnval = deprecated_child_ops.to_wait (ptid, ourstatus);

 
   rtnval = find_active_thread ();
 
 
   rtnval = find_active_thread ();
 


@@ -267,7 +221,7 @@ hpux_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
   return rtnval;
 }
 
   return rtnval;
 }
 

-static char regmap[NUM_REGS] =
+static char regmap[] =

 {
   -2, -1, -1, 0, 4, 8, 12, 16, 20, 24, /* flags, r1 -> r9 */
   28, 32, 36, 40, 44, 48, 52, 56, 60, -1,      /* r10 -> r19 */
 {
   -2, -1, -1, 0, 4, 8, 12, 16, 20, 24, /* flags, r1 -> r9 */
   28, 32, 36, 40, 44, 48, 52, 56, 60, -1,      /* r10 -> r19 */


@@ -294,14 +248,15 @@ static char regmap[NUM_REGS] =
 };
 
 static void
 };
 
 static void

-hpux_thread_fetch_registers (int regno)
+hpux_thread_fetch_registers (struct regcache *regcache, int regno)

 {
 {

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);

   cma__t_int_tcb tcb, *tcb_ptr;
   struct cleanup *old_chain;
   int i;
   int first_regno, last_regno;
 
   cma__t_int_tcb tcb, *tcb_ptr;
   struct cleanup *old_chain;
   int i;
   int first_regno, last_regno;
 

-  tcb_ptr = find_tcb (PIDGET (inferior_ptid));
+  tcb_ptr = find_tcb (inferior_ptid);

 
   old_chain = save_inferior_ptid ();
 
 
   old_chain = save_inferior_ptid ();
 


@@ -309,7 +264,7 @@ hpux_thread_fetch_registers (int regno)
 
   if (tcb_ptr->state == cma__c_state_running)
     {
 
   if (tcb_ptr->state == cma__c_state_running)
     {

-      child_ops.to_fetch_registers (regno);
+      deprecated_child_ops.to_fetch_registers (regcache, regno);

 
       do_cleanups (old_chain);
 
 
       do_cleanups (old_chain);
 


@@ -319,7 +274,7 @@ hpux_thread_fetch_registers (int regno)
   if (regno == -1)
     {
       first_regno = 0;
   if (regno == -1)
     {
       first_regno = 0;

-      last_regno = NUM_REGS - 1;
+      last_regno = gdbarch_num_regs (gdbarch) - 1;

     }
   else
     {
     }
   else
     {


@@ -330,25 +285,26 @@ hpux_thread_fetch_registers (int regno)
   for (regno = first_regno; regno <= last_regno; regno++)
     {
       if (regmap[regno] == -1)
   for (regno = first_regno; regno <= last_regno; regno++)
     {
       if (regmap[regno] == -1)

-       child_ops.to_fetch_registers (regno);
+       deprecated_child_ops.to_fetch_registers (regcache, regno);

       else
        {
       else
        {

-         unsigned char buf[MAX_REGISTER_RAW_SIZE];
+         unsigned char buf[MAX_REGISTER_SIZE];

          CORE_ADDR sp;
 
          sp = (CORE_ADDR) tcb_ptr->static_ctx.sp - 160;
 
          CORE_ADDR sp;
 
          sp = (CORE_ADDR) tcb_ptr->static_ctx.sp - 160;
 

-         if (regno == FLAGS_REGNUM)
+         if (regno == HPPA_FLAGS_REGNUM)

            /* Flags must be 0 to avoid bogus value for SS_INSYSCALL */
            /* Flags must be 0 to avoid bogus value for SS_INSYSCALL */

-           memset (buf, '\000', REGISTER_RAW_SIZE (regno));
-         else if (regno == SP_REGNUM)
-           store_address (buf, sizeof sp, sp);
-         else if (regno == PC_REGNUM)
-           read_memory (sp - 20, buf, REGISTER_RAW_SIZE (regno));
+           memset (buf, '\000', register_size (gdbarch, regno));
+         else if (regno == HPPA_SP_REGNUM)
+           store_unsigned_integer (buf, sizeof sp, sp);
+         else if (regno == HPPA_PCOQ_HEAD_REGNUM)
+           read_memory (sp - 20, buf, register_size (gdbarch, regno));

          else
          else

-           read_memory (sp + regmap[regno], buf, REGISTER_RAW_SIZE (regno));
+           read_memory (sp + regmap[regno], buf,
+                        register_size (gdbarch, regno));

 
 

-         supply_register (regno, buf);
+         regcache_raw_supply (regcache, regno, buf);

        }
     }
 
        }
     }
 


@@ -356,14 +312,15 @@ hpux_thread_fetch_registers (int regno)
 }
 
 static void
 }
 
 static void

-hpux_thread_store_registers (int regno)
+hpux_thread_store_registers (struct regcache *regcache, int regno)

 {
 {

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);

   cma__t_int_tcb tcb, *tcb_ptr;
   struct cleanup *old_chain;
   int i;
   int first_regno, last_regno;
 
   cma__t_int_tcb tcb, *tcb_ptr;
   struct cleanup *old_chain;
   int i;
   int first_regno, last_regno;
 

-  tcb_ptr = find_tcb (PIDGET (inferior_ptid));
+  tcb_ptr = find_tcb (inferior_ptid);

 
   old_chain = save_inferior_ptid ();
 
 
   old_chain = save_inferior_ptid ();
 


@@ -371,7 +328,7 @@ hpux_thread_store_registers (int regno)
 
   if (tcb_ptr->state == cma__c_state_running)
     {
 
   if (tcb_ptr->state == cma__c_state_running)
     {

-      child_ops.to_store_registers (regno);
+      deprecated_child_ops.to_store_registers (regcache, regno);

 
       do_cleanups (old_chain);
 
 
       do_cleanups (old_chain);
 


@@ -381,7 +338,7 @@ hpux_thread_store_registers (int regno)
   if (regno == -1)
     {
       first_regno = 0;
   if (regno == -1)
     {
       first_regno = 0;

-      last_regno = NUM_REGS - 1;
+      last_regno = gdbarch_num_regs (gdbarch) - 1;

     }
   else
     {
     }
   else
     {


@@ -392,32 +349,36 @@ hpux_thread_store_registers (int regno)
   for (regno = first_regno; regno <= last_regno; regno++)
     {
       if (regmap[regno] == -1)
   for (regno = first_regno; regno <= last_regno; regno++)
     {
       if (regmap[regno] == -1)

-       child_ops.to_store_registers (regno);
+       deprecated_child_ops.to_store_registers (regcache, regno);

       else
        {
       else
        {

-         unsigned char buf[MAX_REGISTER_RAW_SIZE];
+         unsigned char buf[MAX_REGISTER_SIZE];

          CORE_ADDR sp;
 
          sp = (CORE_ADDR) tcb_ptr->static_ctx.sp - 160;
 
          CORE_ADDR sp;
 
          sp = (CORE_ADDR) tcb_ptr->static_ctx.sp - 160;
 

-         if (regno == FLAGS_REGNUM)
-           child_ops.to_store_registers (regno);       /* Let lower layer handle this... */
-         else if (regno == SP_REGNUM)
+         if (regno == HPPA_FLAGS_REGNUM)
+           deprecated_child_ops.to_store_registers (regcache, regno);  /* Let lower layer handle this... */
+         else if (regno == HPPA_SP_REGNUM)
+           {
+             regcache_raw_collect (regcache, regno, buf);
+             write_memory ((CORE_ADDR) &tcb_ptr->static_ctx.sp, buf,
+                           register_size (gdbarch, regno));
+             tcb_ptr->static_ctx.sp
+               = (cma__t_hppa_regs *) ((CORE_ADDR) buf + 160);
+           }
+         else if (regno == HPPA_PCOQ_HEAD_REGNUM)

            {
            {

-             write_memory ((CORE_ADDR) & tcb_ptr->static_ctx.sp,
-                           registers + REGISTER_BYTE (regno),
-                           REGISTER_RAW_SIZE (regno));
-             tcb_ptr->static_ctx.sp = (cma__t_hppa_regs *)
-               (extract_address (registers + REGISTER_BYTE (regno), REGISTER_RAW_SIZE (regno)) + 160);
+             regcache_raw_collect (regcache, regno, buf);
+             write_memory (sp - 20, buf,
+                           register_size (gdbarch, regno));

            }
            }

-         else if (regno == PC_REGNUM)
-           write_memory (sp - 20,
-                         registers + REGISTER_BYTE (regno),
-                         REGISTER_RAW_SIZE (regno));

          else
          else

-           write_memory (sp + regmap[regno],
-                         registers + REGISTER_BYTE (regno),
-                         REGISTER_RAW_SIZE (regno));
+           {
+             regcache_raw_collect (regcache, regno, buf);
+             write_memory (sp + regmap[regno], buf,
+                           register_size (gdbarch, regno));
+           }

        }
     }
 
        }
     }
 


@@ -431,9 +392,9 @@ hpux_thread_store_registers (int regno)
    debugged.  */
 
 static void
    debugged.  */
 
 static void

-hpux_thread_prepare_to_store (void)
+hpux_thread_prepare_to_store (struct regcache *regcache)

 {
 {

-  child_ops.to_prepare_to_store ();
+  deprecated_child_ops.to_prepare_to_store (regcache);

 }
 
 static int
 }
 
 static int


@@ -449,7 +410,7 @@ hpux_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
   inferior_ptid = main_ptid;
 
   retval = 
   inferior_ptid = main_ptid;
 
   retval = 

-    child_ops.to_xfer_memory (memaddr, myaddr, len, dowrite, attribs, target);
+    deprecated_child_ops.deprecated_xfer_memory (memaddr, myaddr, len, dowrite, attribs, target);

 
   do_cleanups (old_chain);
 
 
   do_cleanups (old_chain);
 


@@ -461,27 +422,28 @@ hpux_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
 static void
 hpux_thread_files_info (struct target_ops *ignore)
 {
 static void
 hpux_thread_files_info (struct target_ops *ignore)
 {

-  child_ops.to_files_info (ignore);
+  deprecated_child_ops.to_files_info (ignore);

 }
 
 static void
 hpux_thread_kill_inferior (void)
 {
 }
 
 static void
 hpux_thread_kill_inferior (void)
 {

-  child_ops.to_kill ();
+  deprecated_child_ops.to_kill ();

 }
 
 static void
 hpux_thread_notice_signals (ptid_t ptid)
 {
 }
 
 static void
 hpux_thread_notice_signals (ptid_t ptid)
 {

-  child_ops.to_notice_signals (ptid);
+  deprecated_child_ops.to_notice_signals (ptid);

 }
 
 /* Fork an inferior process, and start debugging it with /proc.  */
 
 static void
 }
 
 /* Fork an inferior process, and start debugging it with /proc.  */
 
 static void

-hpux_thread_create_inferior (char *exec_file, char *allargs, char **env)
+hpux_thread_create_inferior (char *exec_file, char *allargs, char **env,
+                            int from_tty)

 {
 {

-  child_ops.to_create_inferior (exec_file, allargs, env);
+  deprecated_child_ops.to_create_inferior (exec_file, allargs, env, from_tty);

 
   if (hpux_thread_active)
     {
 
   if (hpux_thread_active)
     {


@@ -501,14 +463,7 @@ hpux_thread_create_inferior (char *exec_file, char *allargs, char **env)
    those variables don't show up until the library gets mapped and the symbol
    table is read in.  */
 
    those variables don't show up until the library gets mapped and the symbol
    table is read in.  */
 

-/* This new_objfile event is now managed by a chained function pointer. 
- * It is the callee's responsability to call the next client on the chain.
- */
-
-/* Saved pointer to previous owner of the new_objfile event. */
-static void (*target_new_objfile_chain) (struct objfile *);
-
-void
+static void

 hpux_thread_new_objfile (struct objfile *objfile)
 {
   struct minimal_symbol *ms;
 hpux_thread_new_objfile (struct objfile *objfile)
 {
   struct minimal_symbol *ms;


@@ -516,28 +471,24 @@ hpux_thread_new_objfile (struct objfile *objfile)
   if (!objfile)
     {
       hpux_thread_active = 0;
   if (!objfile)
     {
       hpux_thread_active = 0;

-      goto quit;
+      return;

     }
 
   ms = lookup_minimal_symbol ("cma__g_known_threads", NULL, objfile);
 
   if (!ms)
     }
 
   ms = lookup_minimal_symbol ("cma__g_known_threads", NULL, objfile);
 
   if (!ms)

-    goto quit;
+    return;

 
   P_cma__g_known_threads = SYMBOL_VALUE_ADDRESS (ms);
 
   ms = lookup_minimal_symbol ("cma__g_current_thread", NULL, objfile);
 
   if (!ms)
 
   P_cma__g_known_threads = SYMBOL_VALUE_ADDRESS (ms);
 
   ms = lookup_minimal_symbol ("cma__g_current_thread", NULL, objfile);
 
   if (!ms)

-    goto quit;
+    return;

 
   P_cma__g_current_thread = SYMBOL_VALUE_ADDRESS (ms);
 
   hpux_thread_active = 1;
 
   P_cma__g_current_thread = SYMBOL_VALUE_ADDRESS (ms);
 
   hpux_thread_active = 1;

-quit:
-  /* Call predecessor on chain, if any. */
-  if (target_new_objfile_chain)
-    target_new_objfile_chain (objfile);

 }
 
 /* Clean up after the inferior dies.  */
 }
 
 /* Clean up after the inferior dies.  */


@@ -545,7 +496,7 @@ quit:
 static void
 hpux_thread_mourn_inferior (void)
 {
 static void
 hpux_thread_mourn_inferior (void)
 {

-  child_ops.to_mourn_inferior ();
+  deprecated_child_ops.to_mourn_inferior ();

 }
 
 /* Mark our target-struct as eligible for stray "run" and "attach" commands.  */
 }
 
 /* Mark our target-struct as eligible for stray "run" and "attach" commands.  */


@@ -565,7 +516,7 @@ hpux_thread_alive (ptid_t ptid)
 static void
 hpux_thread_stop (void)
 {
 static void
 hpux_thread_stop (void)
 {

-  child_ops.to_stop ();
+  deprecated_child_ops.to_stop ();

 }
 \f
 /* Convert a pid to printable form. */
 }
 \f
 /* Convert a pid to printable form. */


@@ -576,7 +527,7 @@ hpux_pid_to_str (ptid_t ptid)
   static char buf[100];
   int pid = PIDGET (ptid);
 
   static char buf[100];
   int pid = PIDGET (ptid);
 

-  sprintf (buf, "Thread %d", pid >> 16);
+  sprintf (buf, "Thread %ld", ptid_get_tid (ptid));

 
   return buf;
 }
 
   return buf;
 }


@@ -595,13 +546,14 @@ init_hpux_thread_ops (void)
   hpux_thread_ops.to_fetch_registers = hpux_thread_fetch_registers;
   hpux_thread_ops.to_store_registers = hpux_thread_store_registers;
   hpux_thread_ops.to_prepare_to_store = hpux_thread_prepare_to_store;
   hpux_thread_ops.to_fetch_registers = hpux_thread_fetch_registers;
   hpux_thread_ops.to_store_registers = hpux_thread_store_registers;
   hpux_thread_ops.to_prepare_to_store = hpux_thread_prepare_to_store;

-  hpux_thread_ops.to_xfer_memory = hpux_thread_xfer_memory;
+  hpux_thread_ops.deprecated_xfer_memory = hpux_thread_xfer_memory;

   hpux_thread_ops.to_files_info = hpux_thread_files_info;
   hpux_thread_ops.to_insert_breakpoint = memory_insert_breakpoint;
   hpux_thread_ops.to_remove_breakpoint = memory_remove_breakpoint;
   hpux_thread_ops.to_terminal_init = terminal_init_inferior;
   hpux_thread_ops.to_terminal_inferior = terminal_inferior;
   hpux_thread_ops.to_terminal_ours_for_output = terminal_ours_for_output;
   hpux_thread_ops.to_files_info = hpux_thread_files_info;
   hpux_thread_ops.to_insert_breakpoint = memory_insert_breakpoint;
   hpux_thread_ops.to_remove_breakpoint = memory_remove_breakpoint;
   hpux_thread_ops.to_terminal_init = terminal_init_inferior;
   hpux_thread_ops.to_terminal_inferior = terminal_inferior;
   hpux_thread_ops.to_terminal_ours_for_output = terminal_ours_for_output;

+  hpux_thread_ops.to_terminal_save_ours = terminal_save_ours;

   hpux_thread_ops.to_terminal_ours = terminal_ours;
   hpux_thread_ops.to_terminal_info = child_terminal_info;
   hpux_thread_ops.to_kill = hpux_thread_kill_inferior;
   hpux_thread_ops.to_terminal_ours = terminal_ours;
   hpux_thread_ops.to_terminal_info = child_terminal_info;
   hpux_thread_ops.to_kill = hpux_thread_kill_inferior;


@@ -627,7 +579,6 @@ _initialize_hpux_thread (void)
   add_target (&hpux_thread_ops);
 
   child_suppress_run = 1;
   add_target (&hpux_thread_ops);
 
   child_suppress_run = 1;

-  /* Hook into new_objfile notification. */
-  target_new_objfile_chain = target_new_objfile_hook;
-  target_new_objfile_hook  = hpux_thread_new_objfile;
+  /* Hook into new_objfile notification.  */
+  observer_attach_new_objfile (hpux_thread_new_objfile);

 }
 }