diff options
Diffstat (limited to 'gdb/config/pa/nm-hppah.h')
| -rw-r--r-- | gdb/config/pa/nm-hppah.h | 281 |
1 files changed, 281 insertions, 0 deletions
diff --git a/gdb/config/pa/nm-hppah.h b/gdb/config/pa/nm-hppah.h new file mode 100644 index 00000000000..0f5ef018bad --- /dev/null +++ b/gdb/config/pa/nm-hppah.h @@ -0,0 +1,281 @@ +/* Native support for HPPA-RISC machine running HPUX, for GDB. + Copyright 1991, 1992 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 +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +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. */ + +#define U_REGS_OFFSET 0 + +#define KERNEL_U_ADDR 0 + +/* What a coincidence! */ +#define REGISTER_U_ADDR(addr, blockend, regno) \ +{ addr = (int)(blockend) + REGISTER_BYTE (regno);} + +/* HPUX 8.0, in its infinite wisdom, has chosen to prototype ptrace + with five arguments, so programs written for normal ptrace lose. */ +#define FIVE_ARG_PTRACE + +/* We need to figure out where the text region is so that we use the + appropriate ptrace operator to manipulate text. Simply reading/writing + user space will crap out HPUX. */ +#define NEED_TEXT_START_END 1 + +/* This macro defines the register numbers (from REGISTER_NAMES) that + are effectively unavailable to the user through ptrace(). It allows + us to include the whole register set in REGISTER_NAMES (inorder to + better support remote debugging). If it is used in + fetch/store_inferior_registers() gdb will not complain about I/O errors + on fetching these registers. If all registers in REGISTER_NAMES + are available, then return false (0). */ + +#define CANNOT_STORE_REGISTER(regno) \ + ((regno) == 0) || \ + ((regno) == PCSQ_HEAD_REGNUM) || \ + ((regno) >= PCSQ_TAIL_REGNUM && (regno) < IPSW_REGNUM) || \ + ((regno) > IPSW_REGNUM && (regno) < FP4_REGNUM) + +/* In hppah-nat.c: */ +#define FETCH_INFERIOR_REGISTERS +#define CHILD_XFER_MEMORY +#define CHILD_POST_FOLLOW_INFERIOR_BY_CLONE +#define CHILD_POST_FOLLOW_VFORK + +/* While this is for use by threaded programs, it doesn't appear + * to hurt non-threaded ones. This is used in infrun.c: */ +#define PREPARE_TO_PROCEED() hppa_prepare_to_proceed() +extern int hppa_prepare_to_proceed PARAMS(( void )); + +/* In infptrace.c or infttrace.c: */ +#define CHILD_PID_TO_EXEC_FILE +#define CHILD_POST_STARTUP_INFERIOR +#define CHILD_ACKNOWLEDGE_CREATED_INFERIOR +#define CHILD_INSERT_FORK_CATCHPOINT +#define CHILD_REMOVE_FORK_CATCHPOINT +#define CHILD_INSERT_VFORK_CATCHPOINT +#define CHILD_REMOVE_VFORK_CATCHPOINT +#define CHILD_HAS_FORKED +#define CHILD_HAS_VFORKED +#define CHILD_CAN_FOLLOW_VFORK_PRIOR_TO_EXEC +#define CHILD_INSERT_EXEC_CATCHPOINT +#define CHILD_REMOVE_EXEC_CATCHPOINT +#define CHILD_HAS_EXECD +#define CHILD_REPORTED_EXEC_EVENTS_PER_EXEC_CALL +#define CHILD_HAS_SYSCALL_EVENT +#define CHILD_POST_ATTACH +#define CHILD_THREAD_ALIVE + +#define REQUIRE_ATTACH(pid) hppa_require_attach(pid) +extern int hppa_require_attach PARAMS ((int)); + +#define REQUIRE_DETACH(pid,signal) hppa_require_detach(pid,signal) +extern int hppa_require_detach PARAMS ((int,int)); + +/* So we can cleanly use code in infptrace.c. */ +#define PT_KILL PT_EXIT +#define PT_STEP PT_SINGLE +#define PT_CONTINUE PT_CONTIN + +/* FIXME HP MERGE : Previously, PT_RDUAREA. this is actually fixed + in gdb-hp-snapshot-980509 */ +#define PT_READ_U PT_RUAREA +#define PT_WRITE_U PT_WUAREA +#define PT_READ_I PT_RIUSER +#define PT_READ_D PT_RDUSER +#define PT_WRITE_I PT_WIUSER +#define PT_WRITE_D PT_WDUSER + +/* attach/detach works to some extent under BSD and HPUX. So long + as the process you're attaching to isn't blocked waiting on io, + blocked waiting on a signal, or in a system call things work + fine. (The problems in those cases are related to the fact that + the kernel can't provide complete register information for the + target process... Which really pisses off GDB.) */ + +#define ATTACH_DETACH + +/* In infptrace or infttrace.c: */ + +/* Starting with HP-UX 10.30, support is provided (in the form of + ttrace requests) for memory-protection-based hardware watchpoints. + + The 10.30 implementation of these functions reside in infttrace.c. + + Stubs of these functions will be provided in infptrace.c, so that + 10.20 will at least link. However, the "can I use a fast watchpoint?" + query will always return "No" for 10.20. */ + +#define TARGET_HAS_HARDWARE_WATCHPOINTS + +/* The PA can watch any number of locations (generic routines already check + that all intermediates are in watchable memory locations). */ +#define TARGET_CAN_USE_HARDWARE_WATCHPOINT(type, cnt, ot) \ + hppa_can_use_hw_watchpoint(type, cnt, ot) + +/* The PA can also watch memory regions of arbitrary size, since we're using + a page-protection scheme. (On some targets, apparently watch registers + are used, which can only accomodate regions of REGISTER_SIZE.) */ +#define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(byte_count) \ + (1) + +/* However, some addresses may not be profitable to use hardware to watch, + or may be difficult to understand when the addressed object is out of + scope, and hence should be unwatched. On some targets, this may have + severe performance penalties, such that we might as well use regular + watchpoints, and save (possibly precious) hardware watchpoints for other + locations. + + On HP-UX, we choose not to watch stack-based addresses, because + + [1] Our implementation relies on page protection traps. The granularity + of these is large and so can generate many false hits, which are expensive + to respond to. + + [2] Watches of "*p" where we may not know the symbol that p points to, + make it difficult to know when the addressed object is out of scope, and + hence shouldn't be watched. Page protection that isn't removed when the + addressed object is out of scope will either degrade execution speed + (false hits) or give false triggers (when the address is recycled by + other calls). + + Since either of these points results in a slow-running inferior, we might + as well use normal watchpoints, aka single-step & test. */ +#define TARGET_RANGE_PROFITABLE_FOR_HW_WATCHPOINT(pid,start,len) \ + hppa_range_profitable_for_hw_watchpoint(pid, start, (LONGEST)(len)) + +/* On HP-UX, we're using page-protection to implement hardware watchpoints. + When an instruction attempts to write to a write-protected memory page, + a SIGBUS is raised. At that point, the write has not actually occurred. + + We must therefore remove page-protections; single-step the inferior (to + allow the write to happen); restore page-protections; and check whether + any watchpoint triggered. + + If none did, then the write was to a "nearby" location that just happens + to fall on the same page as a watched location, and so can be ignored. + + The only intended client of this macro is wait_for_inferior(), in infrun.c. + When HAVE_NONSTEPPABLE_WATCHPOINT is true, that function will take care + of the stepping & etc. */ + +#define STOPPED_BY_WATCHPOINT(W) \ + ((W.kind == TARGET_WAITKIND_STOPPED) && \ + (stop_signal == TARGET_SIGNAL_BUS) && \ + ! stepped_after_stopped_by_watchpoint && \ + bpstat_have_active_hw_watchpoints ()) + +/* When a hardware watchpoint triggers, we'll move the inferior past it + by removing all eventpoints; stepping past the instruction that caused + the trigger; reinserting eventpoints; and checking whether any watched + location changed. */ +#define HAVE_NONSTEPPABLE_WATCHPOINT + +/* Our implementation of "hardware" watchpoints uses memory page-protection + faults. However, HP-UX has unfortunate interactions between these and + system calls; basically, it's unsafe to have page protections on when a + syscall is running. Therefore, we also ask for notification of syscall + entries and returns. When the inferior enters a syscall, we disable + h/w watchpoints. When the inferior returns from a syscall, we reenable + h/w watchpoints. + + infptrace.c supplies dummy versions of these; infttrace.c is where the + meaningful implementations are. + */ +#define TARGET_ENABLE_HW_WATCHPOINTS(pid) \ + hppa_enable_page_protection_events (pid) +extern void hppa_enable_page_protection_events PARAMS ((int)); + +#define TARGET_DISABLE_HW_WATCHPOINTS(pid) \ + hppa_disable_page_protection_events (pid) +extern void hppa_disable_page_protection_events PARAMS ((int)); + +/* Use these macros for watchpoint insertion/deletion. */ +#define target_insert_watchpoint(addr, len, type) \ + hppa_insert_hw_watchpoint (inferior_pid, addr, (LONGEST)(len), type) + +#define target_remove_watchpoint(addr, len, type) \ + hppa_remove_hw_watchpoint (inferior_pid, addr, (LONGEST)(len), type) + +/* We call our k-thread processes "threads", rather + * than processes. So we need a new way to print + * the string. Code is in hppah-nat.c. + */ +#define target_pid_to_str( pid ) \ + hppa_pid_to_str( pid ) +extern char * hppa_pid_to_str PARAMS ((pid_t)); + +#define target_tid_to_str( pid ) \ + hppa_tid_to_str( pid ) +extern char * hppa_tid_to_str PARAMS ((pid_t)); + +/* For this, ID can be either a process or thread ID, and the function + will describe it appropriately, returning the description as a printable + string. + + The function that implements this macro is defined in infptrace.c and + infttrace.c. + */ +#define target_pid_or_tid_to_str(ID) \ + hppa_pid_or_tid_to_str (ID) +extern char * hppa_pid_or_tid_to_str PARAMS ((pid_t)); + +/* This is used when handling events caused by a call to vfork(). On ptrace- + based HP-UXs, when you resume the vforked child, the parent automagically + begins running again. To prevent this runaway, this function is used. + + Note that for vfork on HP-UX, we receive three events of interest: + + 1. the vfork event for the new child process + 2. the exit or exec event of the new child process (actually, you get + two exec events on ptrace-based HP-UXs) + 3. the vfork event for the original parent process + + The first is always received first. The other two may be received in any + order; HP-UX doesn't guarantee an order. + */ +#define ENSURE_VFORKING_PARENT_REMAINS_STOPPED(PID) \ + hppa_ensure_vforking_parent_remains_stopped (PID) +extern void hppa_ensure_vforking_parent_remains_stopped PARAMS((int)); + +/* This is used when handling events caused by a call to vfork(). + + On ttrace-based HP-UXs, the parent vfork and child exec arrive more or less + together. That is, you could do two wait()s without resuming either parent + or child, and get both events. + + On ptrace-based HP-UXs, you must resume the child after its exec event is + delivered or you won't get the parent's vfork. I.e., you can't just wait() + and get the parent vfork, after receiving the child exec. + */ +#define RESUME_EXECD_VFORKING_CHILD_TO_GET_PARENT_VFORK() \ + hppa_resume_execd_vforking_child_to_get_parent_vfork () +extern int hppa_resume_execd_vforking_child_to_get_parent_vfork PARAMS ((void)); + +#ifdef HAVE_HPUX_THREAD_SUPPORT + +#ifdef __STDC__ +struct objfile; +#endif + +void hpux_thread_new_objfile PARAMS ((struct objfile *objfile)); +#define target_new_objfile(OBJFILE) hpux_thread_new_objfile (OBJFILE) + +extern char *hpux_pid_to_str PARAMS ((int pid)); +#define target_pid_to_str(PID) hpux_pid_to_str (PID) + +#endif /* HAVE_HPUX_THREAD_SUPPORT */ + +#define HPUXHPPA |