X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fhpux-thread.c;h=478b3db400dfb5193ad616d9ee9d45c227fe7fff;hb=8803a348f4267261665a4887d04ca45d77ef8423;hp=3de9c0b2191cc32b599fef8b255c3beea3ab31f9;hpb=8a3fe4f86c51d363e10efed1046ebcbdc853ae99;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/hpux-thread.c b/gdb/hpux-thread.c index 3de9c0b219..478b3db400 100644 --- 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. - Copyright 1996, 1998, 1999, 2000, 2001, 2004 Free Software - Foundation, Inc. + Copyright (C) 1996, 1998, 1999, 2000, 2001, 2004, 2007, 2008, 2009, 2010, + 2011 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, @@ -17,21 +17,17 @@ 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 . */ /* This module implements a sort of half target that sits between the machine-independent parts of GDB and the ptrace interface (infptrace.c) to provide access to the HPUX user-mode thread implementation. HPUX threads are true user-mode threads, which are invoked via the cma_* - and pthread_* (DCE and Posix respectivly) interfaces. These are mostly + and pthread_* (DCE and Posix respectively) interfaces. These are mostly implemented in user-space, with all thread context kept in various structures that live in the user's heap. For the most part, the kernel has - no knowlege of these threads. - - */ + no knowlege of these threads. */ #include "defs.h" @@ -48,6 +44,7 @@ #include "gdb_stat.h" #include "gdbcore.h" #include "hppa-tdep.h" +#include "observer.h" extern int child_suppress_run; @@ -66,9 +63,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 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; @@ -118,7 +112,8 @@ find_tcb (ptid_t ptid) tcb_ptr = cma__base (queue_ptr, threads, cma__t_int_tcb); - read_memory ((CORE_ADDR) tcb_ptr, (char *) &cached_tcb, sizeof 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) @@ -145,11 +140,11 @@ hpux_thread_open (char *arg, int from_tty) 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. */ } /* Take a program previously attached to and detaches it. @@ -161,9 +156,9 @@ hpux_thread_attach (char *args, int from_tty) 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 @@ -172,7 +167,8 @@ hpux_thread_detach (char *args, int from_tty) 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; @@ -181,16 +177,7 @@ hpux_thread_resume (ptid_t ptid, int step, enum target_signal signo) 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; @@ -201,7 +188,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 -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; @@ -213,7 +201,8 @@ hpux_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus) 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 (); @@ -249,8 +238,11 @@ static char regmap[] = }; 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; @@ -264,7 +256,8 @@ hpux_thread_fetch_registers (int regno) 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); @@ -274,7 +267,7 @@ hpux_thread_fetch_registers (int regno) if (regno == -1) { first_regno = 0; - last_regno = NUM_REGS - 1; + last_regno = gdbarch_num_regs (gdbarch) - 1; } else { @@ -285,7 +278,8 @@ hpux_thread_fetch_registers (int regno) 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]; @@ -294,16 +288,17 @@ hpux_thread_fetch_registers (int regno) sp = (CORE_ADDR) tcb_ptr->static_ctx.sp - 160; if (regno == HPPA_FLAGS_REGNUM) - /* Flags must be 0 to avoid bogus value for SS_INSYSCALL */ - memset (buf, '\000', register_size (current_gdbarch, regno)); + /* Flags must be 0 to avoid bogus value for SS_INSYSCALL. */ + memset (buf, '\000', register_size (gdbarch, regno)); 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) - read_memory (sp - 20, buf, register_size (current_gdbarch, regno)); + read_memory (sp - 20, buf, register_size (gdbarch, regno)); 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 +306,10 @@ hpux_thread_fetch_registers (int regno) } 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; @@ -326,7 +323,8 @@ hpux_thread_store_registers (int regno) 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); @@ -336,7 +334,7 @@ hpux_thread_store_registers (int regno) if (regno == -1) { first_regno = 0; - last_regno = NUM_REGS - 1; + last_regno = gdbarch_num_regs (gdbarch) - 1; } else { @@ -347,7 +345,7 @@ hpux_thread_store_registers (int regno) 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]; @@ -356,26 +354,30 @@ hpux_thread_store_registers (int regno) 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) { - regcache_raw_read (current_regcache, regno, buf); + 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); } 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, - register_size (current_gdbarch, regno)); + register_size (gdbarch, regno)); } else { - regcache_raw_read (current_regcache, regno, buf); + regcache_raw_collect (regcache, regno, buf); write_memory (sp + regmap[regno], buf, - register_size (current_gdbarch, regno)); + register_size (gdbarch, regno)); } } } @@ -390,9 +392,9 @@ hpux_thread_store_registers (int regno) 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 @@ -408,7 +410,8 @@ hpux_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, inferior_ptid = main_ptid; retval = - deprecated_child_ops.deprecated_xfer_memory (memaddr, myaddr, len, dowrite, attribs, target); + deprecated_child_ops.deprecated_xfer_memory (memaddr, myaddr, len, + dowrite, attribs, target); do_cleanups (old_chain); @@ -424,9 +427,9 @@ hpux_thread_files_info (struct target_ops *ignore) } 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 @@ -438,10 +441,11 @@ hpux_thread_notice_signals (ptid_t ptid) /* 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) { @@ -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. */ -/* 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; @@ -476,28 +473,24 @@ hpux_thread_new_objfile (struct objfile *objfile) 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. */ @@ -505,10 +498,11 @@ quit: 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. */ static int hpux_thread_can_run (void) @@ -517,18 +511,18 @@ hpux_thread_can_run (void) } static int -hpux_thread_alive (ptid_t ptid) +hpux_thread_alive (struct target_ops *ops, ptid_t ptid) { 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); } -/* Convert a pid to printable form. */ +/* Convert a pid to printable form. */ char * hpux_pid_to_str (ptid_t ptid) @@ -573,11 +567,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_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; } @@ -589,6 +583,5 @@ _initialize_hpux_thread (void) 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); }