projects / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix build failure in inf-ptrace.c.
[binutils-gdb.git] / gdb / hpux-thread.c
diff --git a/gdb/hpux-thread.c b/gdb/hpux-thread.c
index c5d48d026043b0d9aa73ab6f71bce25c6f5f42e8..df4c6da9e693f12eacb3f31a58e48eaaab7f2505 100644 (file)
--- a/gdb/hpux-thread.c
+++ b/gdb/hpux-thread.c
@@ -1,14 +1,14 @@
 /* Low level interface for debugging HPUX/DCE threads for GDB, the GNU
    debugger.
 
 /* Low level interface for debugging HPUX/DCE threads for GDB, the GNU
    debugger.
 
-   Copyright (C) 1996, 1998, 1999, 2000, 2001, 2004, 2007
+   Copyright (C) 1996, 1998, 1999, 2000, 2001, 2004, 2007, 2008, 2009
    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
    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,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -17,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., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, 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
@@ -48,6 +46,7 @@
 #include "gdb_stat.h"
 #include "gdbcore.h"
 #include "hppa-tdep.h"
 #include "gdb_stat.h"
 #include "gdbcore.h"
 #include "hppa-tdep.h"
+#include "observer.h"
 
 extern int child_suppress_run;
 
 
 extern int child_suppress_run;
 
@@ -66,9 +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 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;
 static void init_hpux_thread_ops (void);
 
 static struct target_ops hpux_thread_ops;
@@ -145,9 +141,9 @@ hpux_thread_open (char *arg, int from_tty)
    and wait for the trace-trap that results from attaching.  */
 
 static void
    and wait for the trace-trap that results from attaching.  */
 
 static void
-hpux_thread_attach (char *args, int from_tty)
+hpux_thread_attach (struct target_ops *ops, char *args, int from_tty)
 {
 {
-  deprecated_child_ops.to_attach (args, from_tty);
+  deprecated_child_ops.to_attach (&deprecated_child_ops, 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. */
 }
@@ -161,9 +157,9 @@ hpux_thread_attach (char *args, int from_tty)
    started via the normal ptrace (PTRACE_TRACEME).  */
 
 static void
    started via the normal ptrace (PTRACE_TRACEME).  */
 
 static void
-hpux_thread_detach (char *args, int from_tty)
+hpux_thread_detach (struct target_ops *ops, char *args, int from_tty)
 {
 {
-  deprecated_child_ops.to_detach (args, from_tty);
+  deprecated_child_ops.to_detach (&deprecated_child_ops, args, from_tty);
 }
 
 /* Resume execution of process PID.  If STEP is nozero, then
 }
 
 /* Resume execution of process PID.  If STEP is nozero, then
@@ -172,7 +168,8 @@ hpux_thread_detach (char *args, int from_tty)
    for procfs.  */
 
 static void
    for procfs.  */
 
 static void
-hpux_thread_resume (ptid_t ptid, int step, enum target_signal signo)
+hpux_thread_resume (struct target_ops *ops,
+                   ptid_t ptid, int step, enum target_signal signo)
 {
   struct cleanup *old_chain;
 
 {
   struct cleanup *old_chain;
 
@@ -181,16 +178,7 @@ hpux_thread_resume (ptid_t ptid, int step, enum target_signal signo)
   ptid = main_ptid;
   inferior_ptid = main_ptid;
 
   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."));
-    }
-#endif
-
-  deprecated_child_ops.to_resume (ptid, step, signo);
+  deprecated_child_ops.to_resume (&deprecated_child_ops, ptid, step, signo);
 
   cached_thread = 0;
 
 
   cached_thread = 0;
 
@@ -201,7 +189,8 @@ hpux_thread_resume (ptid_t ptid, int step, enum target_signal signo)
    to a LWP id, and vice versa on the way out.  */
 
 static ptid_t
    to a LWP id, and vice versa on the way out.  */
 
 static ptid_t
-hpux_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+hpux_thread_wait (struct target_ops *ops,
+                 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
 {
   ptid_t rtnval;
   struct cleanup *old_chain;
 {
   ptid_t rtnval;
   struct cleanup *old_chain;
@@ -213,7 +202,8 @@ 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 = deprecated_child_ops.to_wait (ptid, ourstatus);
+  rtnval = deprecated_child_ops.to_wait (&deprecated_child_ops,
+                                        ptid, ourstatus, options);
 
   rtnval = find_active_thread ();
 
 
   rtnval = find_active_thread ();
 
@@ -249,8 +239,11 @@ static char regmap[] =
 };
 
 static void
 };
 
 static void
-hpux_thread_fetch_registers (int regno)
+hpux_thread_fetch_registers (struct target_ops *ops,
+                            struct regcache *regcache, int regno)
 {
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   cma__t_int_tcb tcb, *tcb_ptr;
   struct cleanup *old_chain;
   int i;
   cma__t_int_tcb tcb, *tcb_ptr;
   struct cleanup *old_chain;
   int i;
@@ -264,7 +257,8 @@ hpux_thread_fetch_registers (int regno)
 
   if (tcb_ptr->state == cma__c_state_running)
     {
 
   if (tcb_ptr->state == cma__c_state_running)
     {
-      deprecated_child_ops.to_fetch_registers (regno);
+      deprecated_child_ops.to_fetch_registers (&deprecated_child_ops,
+                                              regcache, regno);
 
       do_cleanups (old_chain);
 
 
       do_cleanups (old_chain);
 
@@ -274,7 +268,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
     {
@@ -285,7 +279,8 @@ 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)
-       deprecated_child_ops.to_fetch_registers (regno);
+       deprecated_child_ops.to_fetch_registers (&deprecated_child_ops,
+                                                regcache, regno);
       else
        {
          unsigned char buf[MAX_REGISTER_SIZE];
       else
        {
          unsigned char buf[MAX_REGISTER_SIZE];
@@ -295,15 +290,16 @@ hpux_thread_fetch_registers (int regno)
 
          if (regno == HPPA_FLAGS_REGNUM)
            /* Flags must be 0 to avoid bogus value for SS_INSYSCALL */
 
          if (regno == HPPA_FLAGS_REGNUM)
            /* Flags must be 0 to avoid bogus value for SS_INSYSCALL */
-           memset (buf, '\000', register_size (current_gdbarch, regno));
+           memset (buf, '\000', register_size (gdbarch, regno));
          else if (regno == HPPA_SP_REGNUM)
          else if (regno == HPPA_SP_REGNUM)
-           store_unsigned_integer (buf, sizeof sp, sp);
+           store_unsigned_integer (buf, sizeof sp, byte_order, sp);
          else if (regno == HPPA_PCOQ_HEAD_REGNUM)
          else if (regno == HPPA_PCOQ_HEAD_REGNUM)
-           read_memory (sp - 20, buf, register_size (current_gdbarch, regno));
+           read_memory (sp - 20, buf, register_size (gdbarch, regno));
          else
          else
-           read_memory (sp + regmap[regno], buf, register_size (current_gdbarch, regno));
+           read_memory (sp + regmap[regno], buf,
+                        register_size (gdbarch, regno));
 
 
-         regcache_raw_supply (current_regcache, regno, buf);
+         regcache_raw_supply (regcache, regno, buf);
        }
     }
 
        }
     }
 
@@ -311,8 +307,10 @@ hpux_thread_fetch_registers (int regno)
 }
 
 static void
 }
 
 static void
-hpux_thread_store_registers (int regno)
+hpux_thread_store_registers (struct target_ops *ops,
+                            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;
   cma__t_int_tcb tcb, *tcb_ptr;
   struct cleanup *old_chain;
   int i;
@@ -326,7 +324,8 @@ hpux_thread_store_registers (int regno)
 
   if (tcb_ptr->state == cma__c_state_running)
     {
 
   if (tcb_ptr->state == cma__c_state_running)
     {
-      deprecated_child_ops.to_store_registers (regno);
+      deprecated_child_ops.to_store_registers (&deprecated_child_ops,
+                                              regcache, regno);
 
       do_cleanups (old_chain);
 
 
       do_cleanups (old_chain);
 
@@ -336,7 +335,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
     {
@@ -347,7 +346,7 @@ 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)
-       deprecated_child_ops.to_store_registers (regno);
+       deprecated_child_ops.to_store_registers (regcache, regno);
       else
        {
          unsigned char buf[MAX_REGISTER_SIZE];
       else
        {
          unsigned char buf[MAX_REGISTER_SIZE];
@@ -356,26 +355,30 @@ hpux_thread_store_registers (int regno)
          sp = (CORE_ADDR) tcb_ptr->static_ctx.sp - 160;
 
          if (regno == HPPA_FLAGS_REGNUM)
          sp = (CORE_ADDR) tcb_ptr->static_ctx.sp - 160;
 
          if (regno == HPPA_FLAGS_REGNUM)
-           deprecated_child_ops.to_store_registers (regno);    /* Let lower layer handle this... */
+           {
+             /* Let lower layer handle this... */
+             deprecated_child_ops.to_store_registers
+               (&deprecated_child_ops, regcache, regno);
+           }
          else if (regno == HPPA_SP_REGNUM)
            {
          else if (regno == HPPA_SP_REGNUM)
            {
-             regcache_raw_read (current_regcache, regno, buf);
+             regcache_raw_collect (regcache, regno, buf);
              write_memory ((CORE_ADDR) &tcb_ptr->static_ctx.sp, buf,
              write_memory ((CORE_ADDR) &tcb_ptr->static_ctx.sp, buf,
-                           register_size (current_gdbarch, regno));
+                           register_size (gdbarch, regno));
              tcb_ptr->static_ctx.sp
                = (cma__t_hppa_regs *) ((CORE_ADDR) buf + 160);
            }
          else if (regno == HPPA_PCOQ_HEAD_REGNUM)
            {
              tcb_ptr->static_ctx.sp
                = (cma__t_hppa_regs *) ((CORE_ADDR) buf + 160);
            }
          else if (regno == HPPA_PCOQ_HEAD_REGNUM)
            {
-             regcache_raw_read (current_regcache, regno, buf);
+             regcache_raw_collect (regcache, regno, buf);
              write_memory (sp - 20, buf,
              write_memory (sp - 20, buf,
-                           register_size (current_gdbarch, regno));
+                           register_size (gdbarch, regno));
            }
          else
            {
            }
          else
            {
-             regcache_raw_read (current_regcache, regno, buf);
+             regcache_raw_collect (regcache, regno, buf);
              write_memory (sp + regmap[regno], buf,
              write_memory (sp + regmap[regno], buf,
-                           register_size (current_gdbarch, regno));
+                           register_size (gdbarch, regno));
            }
        }
     }
            }
        }
     }
@@ -390,9 +393,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)
 {
 {
-  deprecated_child_ops.to_prepare_to_store ();
+  deprecated_child_ops.to_prepare_to_store (regcache);
 }
 
 static int
 }
 
 static int
@@ -424,9 +427,9 @@ hpux_thread_files_info (struct target_ops *ignore)
 }
 
 static void
 }
 
 static void
-hpux_thread_kill_inferior (void)
+hpux_thread_kill_inferior (struct target_ops *ops)
 {
 {
-  deprecated_child_ops.to_kill ();
+  deprecated_child_ops.to_kill (&deprecated_child_ops);
 }
 
 static void
 }
 
 static void
@@ -438,10 +441,11 @@ hpux_thread_notice_signals (ptid_t 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,
-                            int from_tty)
+hpux_thread_create_inferior (struct target_ops *ops, char *exec_file,
+                            char *allargs, char **env, int from_tty)
 {
 {
-  deprecated_child_ops.to_create_inferior (exec_file, allargs, env, from_tty);
+  deprecated_child_ops.to_create_inferior (&deprecated_child_ops, 
+                                          exec_file, allargs, env, from_tty);
 
   if (hpux_thread_active)
     {
 
   if (hpux_thread_active)
     {
@@ -461,14 +465,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;
@@ -476,28 +473,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.  */
@@ -505,7 +498,7 @@ quit:
 static void
 hpux_thread_mourn_inferior (void)
 {
 static void
 hpux_thread_mourn_inferior (void)
 {
-  deprecated_child_ops.to_mourn_inferior ();
+  deprecated_child_ops.to_mourn_inferior (&deprecated_child_ops);
 }
 
 /* Mark our target-struct as eligible for stray "run" and "attach" commands.  */
 }
 
 /* Mark our target-struct as eligible for stray "run" and "attach" commands.  */
@@ -517,15 +510,15 @@ hpux_thread_can_run (void)
 }
 
 static int
 }
 
 static int
-hpux_thread_alive (ptid_t ptid)
+hpux_thread_alive (struct target_ops *ops, ptid_t ptid)
 {
   return 1;
 }
 
 static void
 {
   return 1;
 }
 
 static void
-hpux_thread_stop (void)
+hpux_thread_stop (ptid_t ptid)
 {
 {
-  deprecated_child_ops.to_stop ();
+  deprecated_child_ops.to_stop (ptid);
 }
 \f
 /* Convert a pid to printable form. */
 }
 \f
 /* Convert a pid to printable form. */
@@ -573,11 +566,11 @@ init_hpux_thread_ops (void)
   hpux_thread_ops.to_thread_alive = hpux_thread_alive;
   hpux_thread_ops.to_stop = hpux_thread_stop;
   hpux_thread_ops.to_stratum = process_stratum;
   hpux_thread_ops.to_thread_alive = hpux_thread_alive;
   hpux_thread_ops.to_stop = hpux_thread_stop;
   hpux_thread_ops.to_stratum = process_stratum;
-  hpux_thread_ops.to_has_all_memory = 1;
-  hpux_thread_ops.to_has_memory = 1;
-  hpux_thread_ops.to_has_stack = 1;
-  hpux_thread_ops.to_has_registers = 1;
-  hpux_thread_ops.to_has_execution = 1;
+  hpux_thread_ops.to_has_all_memory = default_child_has_all_memory;
+  hpux_thread_ops.to_has_memory = default_child_has_memory;
+  hpux_thread_ops.to_has_stack = default_child_has_stack;
+  hpux_thread_ops.to_has_registers = default_child_has_registers;
+  hpux_thread_ops.to_has_execution = default_child_has_execution;
   hpux_thread_ops.to_magic = OPS_MAGIC;
 }
 
   hpux_thread_ops.to_magic = OPS_MAGIC;
 }
 
@@ -589,6 +582,5 @@ _initialize_hpux_thread (void)
 
   child_suppress_run = 1;
   /* Hook into new_objfile notification.  */
 
   child_suppress_run = 1;
   /* Hook into new_objfile notification.  */
-  target_new_objfile_chain = deprecated_target_new_objfile_hook;
-  deprecated_target_new_objfile_hook  = hpux_thread_new_objfile;
+  observer_attach_new_objfile (hpux_thread_new_objfile);
 }
 }