-/* 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 1996, 1998, 1999, 2000, 2001, 2004 Free Software
+ Foundation, Inc.
This file is part of GDB.
#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"
extern int child_suppress_run;
-extern struct target_ops child_ops; /* target vector for inftarg.c */
extern void _initialize_hpux_thread (void);
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 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_active_thread;
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;
- 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)
- | 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 *
-find_tcb (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;
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;
}
\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)
{
- child_ops.to_open (arg, from_tty);
+ deprecated_child_ops.to_open (arg, from_tty);
}
/* Attach to process PID, then initialize for debugging it
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. */
}
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
{
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 (ptid, step, signo);
+ deprecated_child_ops.to_resume (ptid, step, signo);
cached_thread = 0;
- cached_active_thread = 0;
do_cleanups (old_chain);
}
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 ();
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 */
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 ();
if (tcb_ptr->state == cma__c_state_running)
{
- child_ops.to_fetch_registers (regno);
+ deprecated_child_ops.to_fetch_registers (regno);
do_cleanups (old_chain);
for (regno = first_regno; regno <= last_regno; regno++)
{
if (regmap[regno] == -1)
- child_ops.to_fetch_registers (regno);
+ deprecated_child_ops.to_fetch_registers (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 (current_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 (current_gdbarch, regno));
else
- read_memory (sp + regmap[regno], buf, REGISTER_RAW_SIZE (regno));
+ read_memory (sp + regmap[regno], buf, register_size (current_gdbarch, regno));
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
}
}
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 ();
if (tcb_ptr->state == cma__c_state_running)
{
- child_ops.to_store_registers (regno);
+ deprecated_child_ops.to_store_registers (regno);
do_cleanups (old_chain);
for (regno = first_regno; regno <= last_regno; regno++)
{
if (regmap[regno] == -1)
- child_ops.to_store_registers (regno);
+ deprecated_child_ops.to_store_registers (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 (regno); /* Let lower layer handle this... */
+ else if (regno == HPPA_SP_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_read (current_regcache, regno, buf);
+ write_memory ((CORE_ADDR) &tcb_ptr->static_ctx.sp, buf,
+ register_size (current_gdbarch, regno));
+ 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);
+ write_memory (sp - 20, buf,
+ register_size (current_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_read (current_regcache, regno, buf);
+ write_memory (sp + regmap[regno], buf,
+ register_size (current_gdbarch, regno));
+ }
}
}
static void
hpux_thread_prepare_to_store (void)
{
- child_ops.to_prepare_to_store ();
+ deprecated_child_ops.to_prepare_to_store ();
}
static int
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);
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)
{
- child_ops.to_kill ();
+ deprecated_child_ops.to_kill ();
}
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
-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)
{
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. */
static void
hpux_thread_stop (void)
{
- child_ops.to_stop ();
+ deprecated_child_ops.to_stop ();
}
\f
/* Convert a pid to printable form. */
static char buf[100];
int pid = PIDGET (ptid);
- sprintf (buf, "Thread %d", pid >> 16);
+ sprintf (buf, "Thread %ld", ptid_get_tid (ptid));
return buf;
}
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;
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. */
+ target_new_objfile_chain = deprecated_target_new_objfile_hook;
+ deprecated_target_new_objfile_hook = hpux_thread_new_objfile;
}