X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fhpux-thread.c;h=fe87382a51f74ba96657cdcb8d27fbaf991f9891;hb=9b254dd1ce46c19dde1dde5b8d1e22e862dfacce;hp=f27d12b72f2e5a91c1fa91ed287749c32a9d0cc0;hpb=d0352a18a504a4e7b761f6b3264cf11347d8d056;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/hpux-thread.c b/gdb/hpux-thread.c
index f27d12b72f..fe87382a51 100644
--- 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, 1999 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
-   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,
@@ -14,9 +17,7 @@
    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
@@ -39,12 +40,15 @@
 #include "gdbthread.h"
 #include "target.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 "hppa-tdep.h"
+#include "observer.h"
 
 extern int child_suppress_run;
-extern struct target_ops child_ops;	/* target vector for inftarg.c */
 
 extern void _initialize_hpux_thread (void);
 
@@ -56,94 +60,47 @@ struct string_map
 
 static int hpux_thread_active = 0;
 
-static int main_pid;		/* Real process ID */
+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 struct cleanup *save_inferior_pid (void);
-
-static void restore_inferior_pid (int pid);
-
-static void hpux_thread_resume (int pid, int step, enum target_signal signo);
+static void hpux_thread_resume (ptid_t ptid, int step,
+                                enum target_signal signo);
 
 static void init_hpux_thread_ops (void);
 
 static struct target_ops hpux_thread_ops;
 
-/*
-
-   LOCAL FUNCTION
-
-   save_inferior_pid - Save inferior_pid on the cleanup list
-   restore_inferior_pid - Restore inferior_pid from the cleanup list
-
-   SYNOPSIS
-
-   struct cleanup *save_inferior_pid ()
-   void restore_inferior_pid (int pid)
-
-   DESCRIPTION
-
-   These two functions act in unison to restore inferior_pid in
-   case of an error.
-
-   NOTES
-
-   inferior_pid 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_pid gets restored (in case of errors), you
-   need to call save_inferior_pid before changing it.  At the end of the
-   function, you should invoke do_cleanups to restore it.
-
- */
-
-
-static struct cleanup *
-save_inferior_pid ()
-{
-  return make_cleanup (restore_inferior_pid, inferior_pid);
-}
-
-static void
-restore_inferior_pid (pid)
-     int pid;
-{
-  inferior_pid = pid;
-}
-
-static int find_active_thread (void);
+static ptid_t find_active_thread (void);
 
 static int cached_thread;
-static int cached_active_thread;
 static cma__t_int_tcb cached_tcb;
 
-static int
-find_active_thread ()
+static ptid_t
+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);
 
-  return (cma_thread_get_unique (&tcb.prolog.client_thread) << 16) | main_pid;
+  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 *
-find_tcb (thread)
-     int thread;
+find_tcb (ptid_t ptid)
 {
   cma__t_known_object queue_header;
   cma__t_queue *queue_ptr;
+  int thread = ptid_get_tid (ptid);
 
   if (thread == cached_thread)
     return &cached_tcb;
@@ -163,38 +120,33 @@ find_tcb (thread)
       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;
 	  }
     }
 
-  error ("Can't find TCB %d,%d", thread >> 16, thread & 0xffff);
+  error (_("Can't find TCB %d"), thread);
   return NULL;
 }
 
 /* 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 (arg, from_tty)
-     char *arg;
-     int from_tty;
+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
    and wait for the trace-trap that results from attaching.  */
 
 static void
-hpux_thread_attach (args, from_tty)
-     char *args;
-     int from_tty;
+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. */
 }
@@ -208,11 +160,9 @@ hpux_thread_attach (args, from_tty)
    started via the normal ptrace (PTRACE_TRACEME).  */
 
 static void
-hpux_thread_detach (args, from_tty)
-     char *args;
-     int from_tty;
+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
@@ -221,30 +171,27 @@ hpux_thread_detach (args, from_tty)
    for procfs.  */
 
 static void
-hpux_thread_resume (pid, step, signo)
-     int pid;
-     int step;
-     enum target_signal signo;
+hpux_thread_resume (ptid_t ptid, int step, enum target_signal signo)
 {
   struct cleanup *old_chain;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  pid = inferior_pid = main_pid;
+  ptid = main_ptid;
+  inferior_ptid = main_ptid;
 
 #if 0
   if (pid != -1)
     {
       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
 
-  child_ops.to_resume (pid, step, signo);
+  deprecated_child_ops.to_resume (ptid, step, signo);
 
   cached_thread = 0;
-  cached_active_thread = 0;
 
   do_cleanups (old_chain);
 }
@@ -252,22 +199,20 @@ hpux_thread_resume (pid, step, signo)
 /* Wait for any threads to stop.  We may have to convert PID from a thread id
    to a LWP id, and vice versa on the way out.  */
 
-static int
-hpux_thread_wait (pid, ourstatus)
-     int pid;
-     struct target_waitstatus *ourstatus;
+static ptid_t
+hpux_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 {
-  int rtnval;
+  ptid_t rtnval;
   struct cleanup *old_chain;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = main_pid;
+  inferior_ptid = main_ptid;
 
-  if (pid != -1)
-    pid = main_pid;
+  if (!ptid_equal (ptid, minus_one_ptid))
+    ptid = main_ptid;
 
-  rtnval = child_ops.to_wait (pid, ourstatus);
+  rtnval = deprecated_child_ops.to_wait (ptid, ourstatus);
 
   rtnval = find_active_thread ();
 
@@ -276,7 +221,7 @@ hpux_thread_wait (pid, ourstatus)
   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 */
@@ -303,23 +248,23 @@ static char regmap[NUM_REGS] =
 };
 
 static void
-hpux_thread_fetch_registers (regno)
-     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;
 
-  tcb_ptr = find_tcb (inferior_pid);
+  tcb_ptr = find_tcb (inferior_ptid);
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = main_pid;
+  inferior_ptid = main_ptid;
 
   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);
 
@@ -329,7 +274,7 @@ hpux_thread_fetch_registers (regno)
   if (regno == -1)
     {
       first_regno = 0;
-      last_regno = NUM_REGS - 1;
+      last_regno = gdbarch_num_regs (gdbarch) - 1;
     }
   else
     {
@@ -340,25 +285,26 @@ hpux_thread_fetch_registers (regno)
   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
 	{
-	  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;
 
-	  if (regno == FLAGS_REGNUM)
+	  if (regno == HPPA_FLAGS_REGNUM)
 	    /* 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
-	    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);
 	}
     }
 
@@ -366,23 +312,23 @@ hpux_thread_fetch_registers (regno)
 }
 
 static void
-hpux_thread_store_registers (regno)
-     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;
 
-  tcb_ptr = find_tcb (inferior_pid);
+  tcb_ptr = find_tcb (inferior_ptid);
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = main_pid;
+  inferior_ptid = main_ptid;
 
   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);
 
@@ -392,7 +338,7 @@ hpux_thread_store_registers (regno)
   if (regno == -1)
     {
       first_regno = 0;
-      last_regno = NUM_REGS - 1;
+      last_regno = gdbarch_num_regs (gdbarch) - 1;
     }
   else
     {
@@ -403,32 +349,36 @@ hpux_thread_store_registers (regno)
   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
 	{
-	  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;
 
-	  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
-	    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));
+	    }
 	}
     }
 
@@ -442,27 +392,25 @@ hpux_thread_store_registers (regno)
    debugged.  */
 
 static void
-hpux_thread_prepare_to_store ()
+hpux_thread_prepare_to_store (struct regcache *regcache)
 {
-  child_ops.to_prepare_to_store ();
+  deprecated_child_ops.to_prepare_to_store (regcache);
 }
 
 static int
-hpux_thread_xfer_memory (memaddr, myaddr, len, dowrite, target)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
-     int dowrite;
-     struct target_ops *target;	/* ignored */
+hpux_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
+			 int dowrite, struct mem_attrib *attribs,
+			 struct target_ops *target)
 {
   int retval;
   struct cleanup *old_chain;
 
-  old_chain = save_inferior_pid ();
+  old_chain = save_inferior_ptid ();
 
-  inferior_pid = main_pid;
+  inferior_ptid = main_ptid;
 
-  retval = child_ops.to_xfer_memory (memaddr, myaddr, len, dowrite, target);
+  retval = 
+    deprecated_child_ops.deprecated_xfer_memory (memaddr, myaddr, len, dowrite, attribs, target);
 
   do_cleanups (old_chain);
 
@@ -472,44 +420,40 @@ hpux_thread_xfer_memory (memaddr, myaddr, len, dowrite, target)
 /* Print status information about what we're accessing.  */
 
 static void
-hpux_thread_files_info (ignore)
-     struct target_ops *ignore;
+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 ()
+hpux_thread_kill_inferior (void)
 {
-  child_ops.to_kill ();
+  deprecated_child_ops.to_kill ();
 }
 
 static void
-hpux_thread_notice_signals (pid)
-     int pid;
+hpux_thread_notice_signals (ptid_t ptid)
 {
-  child_ops.to_notice_signals (pid);
+  deprecated_child_ops.to_notice_signals (ptid);
 }
 
 /* Fork an inferior process, and start debugging it with /proc.  */
 
 static void
-hpux_thread_create_inferior (exec_file, allargs, env)
-     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)
     {
-      main_pid = inferior_pid;
+      main_ptid = inferior_ptid;
 
       push_target (&hpux_thread_ops);
 
-      inferior_pid = find_active_thread ();
+      inferior_ptid = find_active_thread ();
 
-      add_thread (inferior_pid);
+      add_thread (inferior_ptid);
     }
 }
 
@@ -519,90 +463,77 @@ hpux_thread_create_inferior (exec_file, allargs, env)
    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
-hpux_thread_new_objfile (objfile)
-     struct objfile *objfile;
+static void
+hpux_thread_new_objfile (struct objfile *objfile)
 {
   struct minimal_symbol *ms;
 
   if (!objfile)
     {
       hpux_thread_active = 0;
-      goto quit;
+      return;
     }
 
   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)
-    goto quit;
+    return;
 
   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.  */
 
 static void
-hpux_thread_mourn_inferior ()
+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.  */
 
 static int
-hpux_thread_can_run ()
+hpux_thread_can_run (void)
 {
   return child_suppress_run;
 }
 
 static int
-hpux_thread_alive (pid)
-     int pid;
+hpux_thread_alive (ptid_t ptid)
 {
   return 1;
 }
 
 static void
-hpux_thread_stop ()
+hpux_thread_stop (void)
 {
-  child_ops.to_stop ();
+  deprecated_child_ops.to_stop ();
 }
 
 /* Convert a pid to printable form. */
 
 char *
-hpux_pid_to_str (pid)
-     int pid;
+hpux_pid_to_str (ptid_t 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;
 }
 
 static void
-init_hpux_thread_ops ()
+init_hpux_thread_ops (void)
 {
   hpux_thread_ops.to_shortname = "hpux-threads";
   hpux_thread_ops.to_longname = "HPUX threads and pthread.";
@@ -615,13 +546,14 @@ init_hpux_thread_ops ()
   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_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;
@@ -641,13 +573,12 @@ init_hpux_thread_ops ()
 }
 
 void
-_initialize_hpux_thread ()
+_initialize_hpux_thread (void)
 {
   init_hpux_thread_ops ();
   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);
 }