1 /* Native support for HPPA-RISC machine running HPUX, for GDB. 2 Copyright 1991, 1992, 1994, 1996, 1998, 1999, 2000, 2002 3 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 59 Temple Place - Suite 330, 20 Boston, MA 02111-1307, USA. */ 21 22 struct target_ops; 23 24 #define U_REGS_OFFSET 0 25 26 #define KERNEL_U_ADDR 0 27 28 /* What a coincidence! */ 29 #define REGISTER_U_ADDR(addr, blockend, regno) \ 30 { addr = (int)(blockend) + DEPRECATED_REGISTER_BYTE (regno);} 31 32 /* This isn't really correct, because ptrace is actually a 32-bit 33 interface. However, the modern HP-UX targets all really use 34 ttrace, which is a 64-bit interface --- a debugger running in 35 either 32- or 64-bit mode can debug a 64-bit process. BUT, the 36 code doesn't use ttrace directly --- it calls call_ptrace instead, 37 which is supposed to be drop-in substitute for ptrace. In other 38 words, they access a 64-bit system call (ttrace) through a 39 compatibility layer which is allegedly a 32-bit interface. 40 41 So I don't feel the least bit guilty about this. */ 42 #define PTRACE_ARG3_TYPE CORE_ADDR 43 44 /* HPUX 8.0, in its infinite wisdom, has chosen to prototype ptrace 45 with five arguments, so programs written for normal ptrace lose. */ 46 #define FIVE_ARG_PTRACE 47 48 /* We need to figure out where the text region is so that we use the 49 appropriate ptrace operator to manipulate text. Simply 50 reading/writing user space will crap out HPUX. */ 51 #define DEPRECATED_HPUX_TEXT_END deprecated_hpux_text_end 52 extern void deprecated_hpux_text_end (struct target_ops *exec_ops); 53 54 /* In hppah-nat.c: */ 55 #define FETCH_INFERIOR_REGISTERS 56 #define CHILD_XFER_MEMORY 57 #define CHILD_FOLLOW_FORK 58 59 /* In infptrace.c or infttrace.c: */ 60 #define CHILD_PID_TO_EXEC_FILE 61 #define CHILD_POST_STARTUP_INFERIOR 62 #define CHILD_ACKNOWLEDGE_CREATED_INFERIOR 63 #define CHILD_INSERT_FORK_CATCHPOINT 64 #define CHILD_REMOVE_FORK_CATCHPOINT 65 #define CHILD_INSERT_VFORK_CATCHPOINT 66 #define CHILD_REMOVE_VFORK_CATCHPOINT 67 #define CHILD_INSERT_EXEC_CATCHPOINT 68 #define CHILD_REMOVE_EXEC_CATCHPOINT 69 #define CHILD_REPORTED_EXEC_EVENTS_PER_EXEC_CALL 70 #define CHILD_POST_ATTACH 71 #define CHILD_THREAD_ALIVE 72 #define CHILD_PID_TO_STR 73 #define CHILD_WAIT 74 struct target_waitstatus; 75 extern ptid_t child_wait (ptid_t, struct target_waitstatus *); 76 77 extern int hppa_require_attach (int); 78 extern int hppa_require_detach (int, int); 79 80 /* So we can cleanly use code in infptrace.c. */ 81 #define PT_KILL PT_EXIT 82 #define PT_STEP PT_SINGLE 83 #define PT_CONTINUE PT_CONTIN 84 85 /* FIXME HP MERGE : Previously, PT_RDUAREA. this is actually fixed 86 in gdb-hp-snapshot-980509 */ 87 #define PT_READ_U PT_RUAREA 88 #define PT_WRITE_U PT_WUAREA 89 #define PT_READ_I PT_RIUSER 90 #define PT_READ_D PT_RDUSER 91 #define PT_WRITE_I PT_WIUSER 92 #define PT_WRITE_D PT_WDUSER 93 94 /* In infptrace or infttrace.c: */ 95 96 /* Starting with HP-UX 10.30, support is provided (in the form of 97 ttrace requests) for memory-protection-based hardware watchpoints. 98 99 The 10.30 implementation of these functions reside in infttrace.c. 100 101 Stubs of these functions will be provided in infptrace.c, so that 102 10.20 will at least link. However, the "can I use a fast watchpoint?" 103 query will always return "No" for 10.20. */ 104 105 #define TARGET_HAS_HARDWARE_WATCHPOINTS 106 107 /* The PA can watch any number of locations (generic routines already check 108 that all intermediates are in watchable memory locations). */ 109 extern int hppa_can_use_hw_watchpoint (int type, int cnt, int ot); 110 #define TARGET_CAN_USE_HARDWARE_WATCHPOINT(type, cnt, ot) \ 111 hppa_can_use_hw_watchpoint(type, cnt, ot) 112 113 /* The PA can also watch memory regions of arbitrary size, since we're 114 using a page-protection scheme. (On some targets, apparently watch 115 registers are used, which can only accomodate regions of 116 DEPRECATED_REGISTER_SIZE.) */ 117 #define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(byte_count) \ 118 (1) 119 120 /* However, some addresses may not be profitable to use hardware to watch, 121 or may be difficult to understand when the addressed object is out of 122 scope, and hence should be unwatched. On some targets, this may have 123 severe performance penalties, such that we might as well use regular 124 watchpoints, and save (possibly precious) hardware watchpoints for other 125 locations. 126 127 On HP-UX, we choose not to watch stack-based addresses, because 128 129 [1] Our implementation relies on page protection traps. The granularity 130 of these is large and so can generate many false hits, which are expensive 131 to respond to. 132 133 [2] Watches of "*p" where we may not know the symbol that p points to, 134 make it difficult to know when the addressed object is out of scope, and 135 hence shouldn't be watched. Page protection that isn't removed when the 136 addressed object is out of scope will either degrade execution speed 137 (false hits) or give false triggers (when the address is recycled by 138 other calls). 139 140 Since either of these points results in a slow-running inferior, we might 141 as well use normal watchpoints, aka single-step & test. */ 142 #define TARGET_RANGE_PROFITABLE_FOR_HW_WATCHPOINT(pid,start,len) \ 143 hppa_range_profitable_for_hw_watchpoint(pid, start, (LONGEST)(len)) 144 145 /* On HP-UX, we're using page-protection to implement hardware watchpoints. 146 When an instruction attempts to write to a write-protected memory page, 147 a SIGBUS is raised. At that point, the write has not actually occurred. 148 149 We must therefore remove page-protections; single-step the inferior (to 150 allow the write to happen); restore page-protections; and check whether 151 any watchpoint triggered. 152 153 If none did, then the write was to a "nearby" location that just happens 154 to fall on the same page as a watched location, and so can be ignored. 155 156 The only intended client of this macro is wait_for_inferior(), in infrun.c. 157 When HAVE_NONSTEPPABLE_WATCHPOINT is true, that function will take care 158 of the stepping & etc. */ 159 160 #define STOPPED_BY_WATCHPOINT(W) \ 161 ((W.kind == TARGET_WAITKIND_STOPPED) && \ 162 (stop_signal == TARGET_SIGNAL_BUS) && \ 163 ! stepped_after_stopped_by_watchpoint && \ 164 bpstat_have_active_hw_watchpoints ()) 165 166 /* Our implementation of "hardware" watchpoints uses memory page-protection 167 faults. However, HP-UX has unfortunate interactions between these and 168 system calls; basically, it's unsafe to have page protections on when a 169 syscall is running. Therefore, we also ask for notification of syscall 170 entries and returns. When the inferior enters a syscall, we disable 171 h/w watchpoints. When the inferior returns from a syscall, we reenable 172 h/w watchpoints. 173 174 infptrace.c supplies dummy versions of these; infttrace.c is where the 175 meaningful implementations are. 176 */ 177 #define TARGET_ENABLE_HW_WATCHPOINTS(pid) \ 178 hppa_enable_page_protection_events (pid) 179 extern void hppa_enable_page_protection_events (int); 180 181 #define TARGET_DISABLE_HW_WATCHPOINTS(pid) \ 182 hppa_disable_page_protection_events (pid) 183 extern void hppa_disable_page_protection_events (int); 184 185 /* Use these macros for watchpoint insertion/deletion. */ 186 extern int hppa_insert_hw_watchpoint (int pid, CORE_ADDR start, LONGEST len, 187 int type); 188 #define target_insert_watchpoint(addr, len, type) \ 189 hppa_insert_hw_watchpoint (PIDGET (inferior_ptid), addr, (LONGEST)(len), type) 190 191 extern int hppa_remove_hw_watchpoint (int pid, CORE_ADDR start, LONGEST len, 192 int type); 193 #define target_remove_watchpoint(addr, len, type) \ 194 hppa_remove_hw_watchpoint (PIDGET (inferior_ptid), addr, (LONGEST)(len), type) 195 196 /* We call our k-thread processes "threads", rather 197 * than processes. So we need a new way to print 198 * the string. Code is in hppah-nat.c. 199 */ 200 201 extern char *child_pid_to_str (ptid_t); 202 203 #define target_tid_to_str( ptid ) \ 204 hppa_tid_to_str( ptid ) 205 extern char *hppa_tid_to_str (ptid_t); 206 207 /* For this, ID can be either a process or thread ID, and the function 208 will describe it appropriately, returning the description as a printable 209 string. 210 211 The function that implements this macro is defined in infptrace.c and 212 infttrace.c. 213 */ 214 #define target_pid_or_tid_to_str(ID) \ 215 hppa_pid_or_tid_to_str (ID) 216 extern char *hppa_pid_or_tid_to_str (ptid_t); 217 218 /* This is used when handling events caused by a call to vfork(). On ptrace- 219 based HP-UXs, when you resume the vforked child, the parent automagically 220 begins running again. To prevent this runaway, this function is used. 221 222 Note that for vfork on HP-UX, we receive three events of interest: 223 224 1. the vfork event for the new child process 225 2. the exit or exec event of the new child process (actually, you get 226 two exec events on ptrace-based HP-UXs) 227 3. the vfork event for the original parent process 228 229 The first is always received first. The other two may be received in any 230 order; HP-UX doesn't guarantee an order. 231 */ 232 #define ENSURE_VFORKING_PARENT_REMAINS_STOPPED(PID) \ 233 hppa_ensure_vforking_parent_remains_stopped (PID) 234 extern void hppa_ensure_vforking_parent_remains_stopped (int); 235 236 /* This is used when handling events caused by a call to vfork(). 237 238 On ttrace-based HP-UXs, the parent vfork and child exec arrive more or less 239 together. That is, you could do two wait()s without resuming either parent 240 or child, and get both events. 241 242 On ptrace-based HP-UXs, you must resume the child after its exec event is 243 delivered or you won't get the parent's vfork. I.e., you can't just wait() 244 and get the parent vfork, after receiving the child exec. 245 */ 246 #define RESUME_EXECD_VFORKING_CHILD_TO_GET_PARENT_VFORK() \ 247 hppa_resume_execd_vforking_child_to_get_parent_vfork () 248 extern int hppa_resume_execd_vforking_child_to_get_parent_vfork (void); 249 250 #define HPUXHPPA 251 252 #define MAY_SWITCH_FROM_INFERIOR_PID (1) 253 254 #define MAY_FOLLOW_EXEC (1) 255 256 #define USE_THREAD_STEP_NEEDED (1) 257 258 #include "infttrace.h" /* For parent_attach_all. */ 259