X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fhpux-thread.c;h=26d57ba258641b3edc187e6cee34cc7307dea411;hb=4c2acfeafe154bef75318a35c1112433d8717cb5;hp=5064d6869a1cb4194bb052d8747bb2ac3d239daa;hpb=ed288bb597072176e84fc8279707a3f2f475779b;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/hpux-thread.c b/gdb/hpux-thread.c index 5064d6869a..26d57ba258 100644 --- a/gdb/hpux-thread.c +++ b/gdb/hpux-thread.c @@ -1,5 +1,5 @@ /* Low level interface for debugging HPUX/DCE threads for GDB, the GNU debugger. - Copyright 1996, 1999 Free Software Foundation, Inc. + Copyright 1996, 1998, 1999, 2000, 2001 Free Software Foundation, Inc. This file is part of GDB. @@ -39,15 +39,15 @@ #include "gdbthread.h" #include "target.h" #include "inferior.h" +#include "regcache.h" #include -#include #include #include "gdbcore.h" extern int child_suppress_run; extern struct target_ops child_ops; /* target vector for inftarg.c */ -extern void _initialize_hpux_thread PARAMS ((void)); +extern void _initialize_hpux_thread (void); struct string_map { @@ -57,95 +57,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 PARAMS ((void)); +static void hpux_thread_resume (ptid_t ptid, int step, + enum target_signal signo); -static void restore_inferior_pid PARAMS ((int pid)); - -static void hpux_thread_resume PARAMS ((int pid, int step, - enum target_signal signo)); - -static void init_hpux_thread_ops PARAMS ((void)); +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 PARAMS ((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 PARAMS ((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; @@ -165,14 +117,14 @@ 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; } @@ -181,9 +133,7 @@ find_tcb (thread) /* 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); } @@ -192,9 +142,7 @@ hpux_thread_open (arg, from_tty) 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); @@ -210,9 +158,7 @@ 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); } @@ -223,16 +169,14 @@ 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) @@ -243,10 +187,9 @@ hpux_thread_resume (pid, step, signo) } #endif - child_ops.to_resume (pid, step, signo); + child_ops.to_resume (ptid, step, signo); cached_thread = 0; - cached_active_thread = 0; do_cleanups (old_chain); } @@ -254,22 +197,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 = child_ops.to_wait (ptid, ourstatus); rtnval = find_active_thread (); @@ -305,19 +246,18 @@ static char regmap[NUM_REGS] = }; static void -hpux_thread_fetch_registers (regno) - int regno; +hpux_thread_fetch_registers (int regno) { 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) { @@ -368,19 +308,18 @@ hpux_thread_fetch_registers (regno) } static void -hpux_thread_store_registers (regno) - int regno; +hpux_thread_store_registers (int regno) { 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) { @@ -418,18 +357,19 @@ hpux_thread_store_registers (regno) else if (regno == SP_REGNUM) { write_memory ((CORE_ADDR) & tcb_ptr->static_ctx.sp, - registers + REGISTER_BYTE (regno), + &deprecated_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); + (extract_address (&deprecated_registers[REGISTER_BYTE (regno)], + REGISTER_RAW_SIZE (regno)) + 160); } else if (regno == PC_REGNUM) write_memory (sp - 20, - registers + REGISTER_BYTE (regno), + &deprecated_registers[REGISTER_BYTE (regno)], REGISTER_RAW_SIZE (regno)); else write_memory (sp + regmap[regno], - registers + REGISTER_BYTE (regno), + &deprecated_registers[REGISTER_BYTE (regno)], REGISTER_RAW_SIZE (regno)); } } @@ -444,27 +384,25 @@ hpux_thread_store_registers (regno) debugged. */ static void -hpux_thread_prepare_to_store () +hpux_thread_prepare_to_store (void) { child_ops.to_prepare_to_store (); } 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 = + child_ops.to_xfer_memory (memaddr, myaddr, len, dowrite, attribs, target); do_cleanups (old_chain); @@ -474,44 +412,39 @@ 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); } static void -hpux_thread_kill_inferior () +hpux_thread_kill_inferior (void) { 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); + 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) { child_ops.to_create_inferior (exec_file, allargs, env); 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); } } @@ -521,40 +454,49 @@ 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; +hpux_thread_new_objfile (struct objfile *objfile) { struct minimal_symbol *ms; if (!objfile) { hpux_thread_active = 0; - - return; + goto quit; } ms = lookup_minimal_symbol ("cma__g_known_threads", NULL, objfile); if (!ms) - return; + goto quit; P_cma__g_known_threads = SYMBOL_VALUE_ADDRESS (ms); ms = lookup_minimal_symbol ("cma__g_current_thread", NULL, objfile); if (!ms) - return; + goto quit; 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 (); } @@ -562,20 +504,19 @@ hpux_thread_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 (); } @@ -583,18 +524,18 @@ hpux_thread_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."; @@ -614,6 +555,7 @@ init_hpux_thread_ops () 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; @@ -633,10 +575,13 @@ 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; }