gdb/config/pa/nm-hppah.h

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