* ada-tasks.c (read_known_tasks_array): Use target_gdbarch instead

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

diff --git a/gdb/hpux-thread.c b/gdb/hpux-thread.c
index 3100ddfef94c004699d2d12b3efd849012770055..fec7013cd9dafd8ebe3e9af44b2056493cd6fc67 100644 (file)
--- a/gdb/hpux-thread.c
+++ b/gdb/hpux-thread.c
@@ -1,7 +1,7 @@
 /* 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.
    Free Software Foundation, Inc.
 
    This file is part of GDB.


@@ -65,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;


@@ -144,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. */
 }


@@ -160,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


@@ -171,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;
 


@@ -180,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;
 


@@ -200,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;


@@ -212,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 ();
 


@@ -248,8 +239,10 @@ static char regmap[] =
 };
 
 static void
 };
 
 static void

-hpux_thread_fetch_registers (struct regcache *regcache, int regno)
+hpux_thread_fetch_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;


@@ -263,7 +256,8 @@ hpux_thread_fetch_registers (struct regcache *regcache, int regno)
 
   if (tcb_ptr->state == cma__c_state_running)
     {
 
   if (tcb_ptr->state == cma__c_state_running)
     {

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

 
       do_cleanups (old_chain);
 
 
       do_cleanups (old_chain);
 


@@ -273,7 +267,7 @@ hpux_thread_fetch_registers (struct regcache *regcache, int regno)
   if (regno == -1)
     {
       first_regno = 0;
   if (regno == -1)
     {
       first_regno = 0;

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

     }
   else
     {
     }
   else
     {


@@ -284,7 +278,8 @@ hpux_thread_fetch_registers (struct regcache *regcache, 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 (regcache, 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];


@@ -294,13 +289,14 @@ hpux_thread_fetch_registers (struct regcache *regcache, 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)
            store_unsigned_integer (buf, sizeof sp, sp);
          else if (regno == HPPA_PCOQ_HEAD_REGNUM)
          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 (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 (regcache, regno, buf);
        }
 
          regcache_raw_supply (regcache, regno, buf);
        }


@@ -310,8 +306,10 @@ hpux_thread_fetch_registers (struct regcache *regcache, int regno)
 }
 
 static void
 }
 
 static void

-hpux_thread_store_registers (struct regcache *regcache, 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;


@@ -325,7 +323,8 @@ hpux_thread_store_registers (struct regcache *regcache, int regno)
 
   if (tcb_ptr->state == cma__c_state_running)
     {
 
   if (tcb_ptr->state == cma__c_state_running)
     {

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

 
       do_cleanups (old_chain);
 
 
       do_cleanups (old_chain);
 


@@ -335,7 +334,7 @@ hpux_thread_store_registers (struct regcache *regcache, int regno)
   if (regno == -1)
     {
       first_regno = 0;
   if (regno == -1)
     {
       first_regno = 0;

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

     }
   else
     {
     }
   else
     {


@@ -355,12 +354,16 @@ hpux_thread_store_registers (struct regcache *regcache, 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 (regcache, 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)
            {
              regcache_raw_collect (regcache, regno, buf);
              write_memory ((CORE_ADDR) &tcb_ptr->static_ctx.sp, buf,
          else if (regno == HPPA_SP_REGNUM)
            {
              regcache_raw_collect (regcache, regno, 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);
            }
              tcb_ptr->static_ctx.sp
                = (cma__t_hppa_regs *) ((CORE_ADDR) buf + 160);
            }


@@ -368,13 +371,13 @@ hpux_thread_store_registers (struct regcache *regcache, int regno)
            {
              regcache_raw_collect (regcache, regno, buf);
              write_memory (sp - 20, buf,
            {
              regcache_raw_collect (regcache, regno, buf);
              write_memory (sp - 20, buf,

-                           register_size (current_gdbarch, regno));
+                           register_size (gdbarch, regno));

            }
          else
            {
              regcache_raw_collect (regcache, regno, buf);
              write_memory (sp + regmap[regno], buf,
            }
          else
            {
              regcache_raw_collect (regcache, regno, buf);
              write_memory (sp + regmap[regno], buf,

-                           register_size (current_gdbarch, regno));
+                           register_size (gdbarch, regno));

            }
        }
     }
            }
        }
     }


@@ -423,9 +426,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


@@ -437,10 +440,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)
     {


@@ -493,7 +497,7 @@ hpux_thread_new_objfile (struct objfile *objfile)
 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.  */


@@ -505,15 +509,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. */


@@ -561,11 +565,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;
 }