gdb/config/pa/tm-hppa.h

   1 /* Parameters for execution on any Hewlett-Packard PA-RISC machine.
   2    Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   3    1998, 1999, 2000 Free Software Foundation, Inc.
   4
   5    Contributed by the Center for Software Science at the
   6    University of Utah (pa-gdb-bugs@cs.utah.edu).
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, USA.  */
  24
  25 #include "regcache.h"
  26
  27 #define GDB_MULTI_ARCH 0
  28
  29 /* NOTE: cagney/2002-11-24: This is a guess.  */
  30 #define DEPRECATED_USE_GENERIC_DUMMY_FRAMES 0
  31 #define CALL_DUMMY_LOCATION ON_STACK
  32 #define PC_IN_CALL_DUMMY(pc, sp, frame_address) deprecated_pc_in_call_dummy_on_stack (pc, sp, frame_address)
  33
  34 /* Forward declarations of some types we use in prototypes */
  35
  36 struct frame_info;
  37 struct frame_saved_regs;
  38 struct value;
  39 struct type;
  40 struct inferior_status;
  41
  42 /* By default assume we don't have to worry about software floating point.  */
  43 #ifndef SOFT_FLOAT
  44 #define SOFT_FLOAT 0
  45 #endif
  46
  47 /* Get at various relevent fields of an instruction word. */
  48
  49 #define MASK_5 0x1f
  50 #define MASK_11 0x7ff
  51 #define MASK_14 0x3fff
  52 #define MASK_21 0x1fffff
  53
  54 /* This macro gets bit fields using HP's numbering (MSB = 0) */
  55 #ifndef GET_FIELD
  56 #define GET_FIELD(X, FROM, TO) \
  57   ((X) >> (31 - (TO)) & ((1 << ((TO) - (FROM) + 1)) - 1))
  58 #endif
  59
  60 extern int hppa_reg_struct_has_addr (int gcc_p, struct type *type);
  61 #define REG_STRUCT_HAS_ADDR(gcc_p,type) hppa_reg_struct_has_addr (gcc_p,type)
  62
  63 /* Offset from address of function to start of its code.
  64    Zero on most machines.  */
  65
  66 #define FUNCTION_START_OFFSET 0
  67
  68 /* Advance PC across any function entry prologue instructions
  69    to reach some "real" code.  */
  70
  71 extern CORE_ADDR hppa_skip_prologue (CORE_ADDR);
  72 #define SKIP_PROLOGUE(pc) (hppa_skip_prologue (pc))
  73
  74 /* If PC is in some function-call trampoline code, return the PC
  75    where the function itself actually starts.  If not, return NULL.  */
  76
  77 #define SKIP_TRAMPOLINE_CODE(pc) skip_trampoline_code (pc, NULL)
  78 extern CORE_ADDR skip_trampoline_code (CORE_ADDR, char *);
  79
  80 /* Return non-zero if we are in an appropriate trampoline. */
  81
  82 #define IN_SOLIB_CALL_TRAMPOLINE(pc, name) \
  83    in_solib_call_trampoline (pc, name)
  84 extern int in_solib_call_trampoline (CORE_ADDR, char *);
  85
  86 #define IN_SOLIB_RETURN_TRAMPOLINE(pc, name) \
  87   in_solib_return_trampoline (pc, name)
  88 extern int in_solib_return_trampoline (CORE_ADDR, char *);
  89
  90 #undef  SAVED_PC_AFTER_CALL
  91 #define SAVED_PC_AFTER_CALL(frame) saved_pc_after_call (frame)
  92 extern CORE_ADDR saved_pc_after_call (struct frame_info *);
  93
  94 extern int hppa_inner_than (CORE_ADDR lhs, CORE_ADDR rhs);
  95 #define INNER_THAN(lhs,rhs) hppa_inner_than(lhs,rhs)
  96
  97 extern CORE_ADDR hppa_stack_align (CORE_ADDR sp);
  98 #define STACK_ALIGN(sp) hppa_stack_align (sp)
  99
 100 #define EXTRA_STACK_ALIGNMENT_NEEDED 0
 101
 102 /* Sequence of bytes for breakpoint instruction.  */
 103
 104 #define BREAKPOINT {0x00, 0x01, 0x00, 0x04}
 105 #define BREAKPOINT32 0x10004
 106
 107 /* Amount PC must be decremented by after a breakpoint.
 108    This is often the number of bytes in BREAKPOINT
 109    but not always.
 110
 111    Not on the PA-RISC */
 112
 113 #define DECR_PC_AFTER_BREAK 0
 114
 115 extern int hppa_pc_requires_run_before_use (CORE_ADDR pc);
 116 #define PC_REQUIRES_RUN_BEFORE_USE(pc) hppa_pc_requires_run_before_use (pc)
 117
 118 /* Say how long (ordinary) registers are.  This is a piece of bogosity
 119    used in push_word and a few other places; REGISTER_RAW_SIZE is the
 120    real way to know how big a register is.  */
 121
 122 #define REGISTER_SIZE 4
 123
 124 /* Number of machine registers */
 125
 126 #define NUM_REGS 128
 127
 128 /* Initializer for an array of names of registers.
 129    There should be NUM_REGS strings in this initializer.
 130    They are in rows of eight entries  */
 131
 132 #define REGISTER_NAMES  \
 133  {"flags",  "r1",      "rp",      "r3",    "r4",     "r5",      "r6",     "r7",    \
 134   "r8",     "r9",      "r10",     "r11",   "r12",    "r13",     "r14",    "r15",   \
 135   "r16",    "r17",     "r18",     "r19",   "r20",    "r21",     "r22",    "r23",   \
 136   "r24",    "r25",     "r26",     "dp",    "ret0",   "ret1",    "sp",     "r31",   \
 137   "sar",    "pcoqh",   "pcsqh",   "pcoqt", "pcsqt",  "eiem",    "iir",    "isr",   \
 138   "ior",    "ipsw",    "goto",    "sr4",   "sr0",    "sr1",     "sr2",    "sr3",   \
 139   "sr5",    "sr6",     "sr7",     "cr0",   "cr8",    "cr9",     "ccr",    "cr12",  \
 140   "cr13",   "cr24",    "cr25",    "cr26",  "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",\
 141   "fpsr",    "fpe1",   "fpe2",    "fpe3",  "fpe4",   "fpe5",    "fpe6",   "fpe7",  \
 142   "fr4",     "fr4R",   "fr5",     "fr5R",  "fr6",    "fr6R",    "fr7",    "fr7R",  \
 143   "fr8",     "fr8R",   "fr9",     "fr9R",  "fr10",   "fr10R",   "fr11",   "fr11R", \
 144   "fr12",    "fr12R",  "fr13",    "fr13R", "fr14",   "fr14R",   "fr15",   "fr15R", \
 145   "fr16",    "fr16R",  "fr17",    "fr17R", "fr18",   "fr18R",   "fr19",   "fr19R", \
 146   "fr20",    "fr20R",  "fr21",    "fr21R", "fr22",   "fr22R",   "fr23",   "fr23R", \
 147   "fr24",    "fr24R",  "fr25",    "fr25R", "fr26",   "fr26R",   "fr27",   "fr27R", \
 148   "fr28",    "fr28R",  "fr29",    "fr29R", "fr30",   "fr30R",   "fr31",   "fr31R"}
 149
 150 /* Register numbers of various important registers.
 151    Note that some of these values are "real" register numbers,
 152    and correspond to the general registers of the machine,
 153    and some are "phony" register numbers which are too large
 154    to be actual register numbers as far as the user is concerned
 155    but do serve to get the desired values when passed to read_register.  */
 156
 157 #define R0_REGNUM 0             /* Doesn't actually exist, used as base for
 158                                    other r registers.  */
 159 #define FLAGS_REGNUM 0          /* Various status flags */
 160 #define RP_REGNUM 2             /* return pointer */
 161 #define FP_REGNUM 3             /* Contains address of executing stack */
 162                                 /* frame */
 163 #define SP_REGNUM 30            /* Contains address of top of stack */
 164 #define SAR_REGNUM 32           /* Shift Amount Register */
 165 #define IPSW_REGNUM 41          /* Interrupt Processor Status Word */
 166 #define PCOQ_HEAD_REGNUM 33     /* instruction offset queue head */
 167 #define PCSQ_HEAD_REGNUM 34     /* instruction space queue head */
 168 #define PCOQ_TAIL_REGNUM 35     /* instruction offset queue tail */
 169 #define PCSQ_TAIL_REGNUM 36     /* instruction space queue tail */
 170 #define EIEM_REGNUM 37          /* External Interrupt Enable Mask */
 171 #define IIR_REGNUM 38           /* Interrupt Instruction Register */
 172 #define IOR_REGNUM 40           /* Interrupt Offset Register */
 173 #define SR4_REGNUM 43           /* space register 4 */
 174 #define RCR_REGNUM 51           /* Recover Counter (also known as cr0) */
 175 #define CCR_REGNUM 54           /* Coprocessor Configuration Register */
 176 #define TR0_REGNUM 57           /* Temporary Registers (cr24 -> cr31) */
 177 #define CR27_REGNUM 60          /* Base register for thread-local storage, cr27 */
 178 #define FP0_REGNUM 64           /* floating point reg. 0 (fspr) */
 179 #define FP4_REGNUM 72
 180
 181 #define ARG0_REGNUM 26          /* The first argument of a callee. */
 182 #define ARG1_REGNUM 25          /* The second argument of a callee. */
 183 #define ARG2_REGNUM 24          /* The third argument of a callee. */
 184 #define ARG3_REGNUM 23          /* The fourth argument of a callee. */
 185
 186 /* compatibility with the rest of gdb. */
 187 #define PC_REGNUM PCOQ_HEAD_REGNUM
 188 #define NPC_REGNUM PCOQ_TAIL_REGNUM
 189
 190 /*
 191  * Processor Status Word Masks
 192  */
 193
 194 #define PSW_T   0x01000000      /* Taken Branch Trap Enable */
 195 #define PSW_H   0x00800000      /* Higher-Privilege Transfer Trap Enable */
 196 #define PSW_L   0x00400000      /* Lower-Privilege Transfer Trap Enable */
 197 #define PSW_N   0x00200000      /* PC Queue Front Instruction Nullified */
 198 #define PSW_X   0x00100000      /* Data Memory Break Disable */
 199 #define PSW_B   0x00080000      /* Taken Branch in Previous Cycle */
 200 #define PSW_C   0x00040000      /* Code Address Translation Enable */
 201 #define PSW_V   0x00020000      /* Divide Step Correction */
 202 #define PSW_M   0x00010000      /* High-Priority Machine Check Disable */
 203 #define PSW_CB  0x0000ff00      /* Carry/Borrow Bits */
 204 #define PSW_R   0x00000010      /* Recovery Counter Enable */
 205 #define PSW_Q   0x00000008      /* Interruption State Collection Enable */
 206 #define PSW_P   0x00000004      /* Protection ID Validation Enable */
 207 #define PSW_D   0x00000002      /* Data Address Translation Enable */
 208 #define PSW_I   0x00000001      /* External, Power Failure, Low-Priority */
 209                                 /* Machine Check Interruption Enable */
 210
 211 /* When fetching register values from an inferior or a core file,
 212    clean them up using this macro.  BUF is a char pointer to
 213    the raw value of the register in the registers[] array.  */
 214
 215 #define DEPRECATED_CLEAN_UP_REGISTER_VALUE(regno, buf) \
 216   do {  \
 217     if ((regno) == PCOQ_HEAD_REGNUM || (regno) == PCOQ_TAIL_REGNUM) \
 218       (buf)[sizeof(CORE_ADDR) -1] &= ~0x3; \
 219   } while (0)
 220
 221 /* Define DEPRECATED_REGISTERS_INFO() to do machine-specific formatting
 222    of register dumps. */
 223
 224 #define DEPRECATED_REGISTERS_INFO(_regnum, fp) pa_do_registers_info (_regnum, fp)
 225 extern void pa_do_registers_info (int, int);
 226
 227 #if 0
 228 #define STRCAT_REGISTER(regnum, fpregs, stream, precision) pa_do_strcat_registers_info (regnum, fpregs, stream, precision)
 229 extern void pa_do_strcat_registers_info (int, int, struct ui_file *, enum precision_type);
 230 #endif
 231
 232 /* PA specific macro to see if the current instruction is nullified. */
 233 #ifndef INSTRUCTION_NULLIFIED
 234 extern int hppa_instruction_nullified (void);
 235 #define INSTRUCTION_NULLIFIED hppa_instruction_nullified ()
 236 #endif
 237
 238 /* Number of bytes of storage in the actual machine representation
 239    for register N.  On the PA-RISC, all regs are 4 bytes, including
 240    the FP registers (they're accessed as two 4 byte halves).  */
 241
 242 #define REGISTER_RAW_SIZE(N) 4
 243
 244 /* Total amount of space needed to store our copies of the machine's
 245    register state, the array `registers'.  */
 246 #define REGISTER_BYTES (NUM_REGS * 4)
 247
 248 extern int hppa_register_byte (int reg_nr);
 249 #define REGISTER_BYTE(N) hppa_register_byte (N)
 250
 251 /* Number of bytes of storage in the program's representation
 252    for register N. */
 253
 254 #define REGISTER_VIRTUAL_SIZE(N) REGISTER_RAW_SIZE(N)
 255
 256 /* Largest value REGISTER_RAW_SIZE can have.  */
 257
 258 #define MAX_REGISTER_RAW_SIZE 4
 259
 260 /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
 261
 262 #define MAX_REGISTER_VIRTUAL_SIZE 8
 263
 264 extern struct type * hppa_register_virtual_type (int reg_nr);
 265 #define REGISTER_VIRTUAL_TYPE(N) hppa_register_virtual_type (N)
 266
 267 extern void hppa_store_struct_return (CORE_ADDR addr, CORE_ADDR sp);
 268 #define STORE_STRUCT_RETURN(ADDR, SP) hppa_store_struct_return (ADDR, SP)
 269
 270 /* Extract from an array REGBUF containing the (raw) register state
 271    a function return value of type TYPE, and copy that, in virtual format,
 272    into VALBUF.  */
 273
 274 void hppa_extract_return_value (struct type *type, char *regbuf, char *valbuf);
 275 #define DEPRECATED_EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 276   hppa_extract_return_value (TYPE, REGBUF, VALBUF);
 277
 278  /* elz: decide whether the function returning a value of type type
 279     will put it on the stack or in the registers.
 280     The pa calling convention says that:
 281     register 28 (called ret0 by gdb) contains any ASCII char,
 282     and any non_floating point value up to 32-bits.
 283     reg 28 and 29 contain non-floating point up tp 64 bits and larger
 284     than 32 bits. (higer order word in reg 28).
 285     fr4: floating point up to 64 bits
 286     sr1: space identifier (32-bit)
 287     stack: any lager than 64-bit, with the address in r28
 288   */
 289 extern use_struct_convention_fn hppa_use_struct_convention;
 290 #define USE_STRUCT_CONVENTION(gcc_p,type) hppa_use_struct_convention (gcc_p,type)
 291
 292 /* Write into appropriate registers a function return value
 293    of type TYPE, given in virtual format.  */
 294
 295
 296 extern void hppa_store_return_value (struct type *type, char *valbuf);
 297 #define DEPRECATED_STORE_RETURN_VALUE(TYPE,VALBUF) \
 298   hppa_store_return_value (TYPE, VALBUF);
 299
 300 /* Extract from an array REGBUF containing the (raw) register state
 301    the address in which a function should return its structure value,
 302    as a CORE_ADDR (or an expression that can be used as one).  */
 303
 304 #define DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
 305   (*(int *)((REGBUF) + REGISTER_BYTE (28)))
 306
 307 /* elz: Return a large value, which is stored on the stack at addr.
 308    This is defined only for the hppa, at this moment.  The above macro
 309    DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS is not called anymore,
 310    because it assumes that on exit from a called function which
 311    returns a large structure on the stack, the address of the ret
 312    structure is still in register 28. Unfortunately this register is
 313    usually overwritten by the called function itself, on hppa. This is
 314    specified in the calling convention doc. As far as I know, the only
 315    way to get the return value is to have the caller tell us where it
 316    told the callee to put it, rather than have the callee tell us.  */
 317 struct value *hppa_value_returned_from_stack (register struct type *valtype,
 318                                               CORE_ADDR addr);
 319 #define VALUE_RETURNED_FROM_STACK(valtype,addr) \
 320   hppa_value_returned_from_stack (valtype, addr)
 321
 322 extern int hppa_cannot_store_register (int regnum);
 323 #define CANNOT_STORE_REGISTER(regno) hppa_cannot_store_register (regno)
 324
 325 #define INIT_EXTRA_FRAME_INFO(fromleaf, frame) init_extra_frame_info (fromleaf, frame)
 326 extern void init_extra_frame_info (int, struct frame_info *);
 327
 328 /* Describe the pointer in each stack frame to the previous stack frame
 329    (its caller).  */
 330
 331 /* FRAME_CHAIN takes a frame's nominal address and produces the
 332    frame's chain-pointer.  */
 333
 334 /* In the case of the PA-RISC, the frame's nominal address
 335    is the address of a 4-byte word containing the calling frame's
 336    address (previous FP).  */
 337
 338 #define FRAME_CHAIN(thisframe) frame_chain (thisframe)
 339 extern CORE_ADDR frame_chain (struct frame_info *);
 340
 341 extern int hppa_frame_chain_valid (CORE_ADDR, struct frame_info *);
 342 #define FRAME_CHAIN_VALID(chain, thisframe) hppa_frame_chain_valid (chain, thisframe)
 343
 344 /* Define other aspects of the stack frame.  */
 345
 346 /* A macro that tells us whether the function invocation represented
 347    by FI does not have a frame on the stack associated with it.  If it
 348    does not, FRAMELESS is set to 1, else 0.  */
 349 #define FRAMELESS_FUNCTION_INVOCATION(FI) \
 350   (frameless_function_invocation (FI))
 351 extern int frameless_function_invocation (struct frame_info *);
 352
 353 extern CORE_ADDR hppa_frame_saved_pc (struct frame_info *frame);
 354 #define FRAME_SAVED_PC(FRAME) hppa_frame_saved_pc (FRAME)
 355
 356 extern CORE_ADDR hppa_frame_args_address (struct frame_info *fi);
 357 #define FRAME_ARGS_ADDRESS(fi) hppa_frame_args_address (fi)
 358
 359 extern CORE_ADDR hppa_frame_locals_address (struct frame_info *fi);
 360 #define FRAME_LOCALS_ADDRESS(fi) hppa_frame_locals_address (fi)
 361
 362 /* Set VAL to the number of args passed to frame described by FI.
 363    Can set VAL to -1, meaning no way to tell.  */
 364
 365 /* We can't tell how many args there are
 366    now that the C compiler delays popping them.  */
 367 #define FRAME_NUM_ARGS(fi) (-1)
 368
 369 /* Return number of bytes at start of arglist that are not really args.  */
 370
 371 #define FRAME_ARGS_SKIP 0
 372
 373 #define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
 374   hppa_frame_find_saved_regs (frame_info, &frame_saved_regs)
 375 extern void
 376 hppa_frame_find_saved_regs (struct frame_info *, struct frame_saved_regs *);
 377 \f
 378
 379 /* Things needed for making the inferior call functions.  */
 380
 381 /* Push an empty stack frame, to record the current PC, etc. */
 382
 383 #define PUSH_DUMMY_FRAME push_dummy_frame (inf_status)
 384 extern void push_dummy_frame (struct inferior_status *);
 385
 386 /* Discard from the stack the innermost frame,
 387    restoring all saved registers.  */
 388 #define POP_FRAME  hppa_pop_frame ()
 389 extern void hppa_pop_frame (void);
 390
 391 #define INSTRUCTION_SIZE 4
 392
 393 #ifndef PA_LEVEL_0
 394
 395 /* Non-level zero PA's have space registers (but they don't always have
 396    floating-point, do they????  */
 397
 398 /* This sequence of words is the instructions
 399
 400    ; Call stack frame has already been built by gdb. Since we could be calling
 401    ; a varargs function, and we do not have the benefit of a stub to put things in
 402    ; the right place, we load the first 4 word of arguments into both the general
 403    ; and fp registers.
 404    call_dummy
 405    ldw -36(sp), arg0
 406    ldw -40(sp), arg1
 407    ldw -44(sp), arg2
 408    ldw -48(sp), arg3
 409    ldo -36(sp), r1
 410    fldws 0(0, r1), fr4
 411    fldds -4(0, r1), fr5
 412    fldws -8(0, r1), fr6
 413    fldds -12(0, r1), fr7
 414    ldil 0, r22                  ; FUNC_LDIL_OFFSET must point here
 415    ldo 0(r22), r22                      ; FUNC_LDO_OFFSET must point here
 416    ldsid (0,r22), r4
 417    ldil 0, r1                   ; SR4EXPORT_LDIL_OFFSET must point here
 418    ldo 0(r1), r1                        ; SR4EXPORT_LDO_OFFSET must point here
 419    ldsid (0,r1), r20
 420    combt,=,n r4, r20, text_space        ; If target is in data space, do a
 421    ble 0(sr5, r22)                      ; "normal" procedure call
 422    copy r31, r2
 423    break 4, 8
 424    mtsp r21, sr0
 425    ble,n 0(sr0, r22)
 426    text_space                           ; Otherwise, go through _sr4export,
 427    ble (sr4, r1)                        ; which will return back here.
 428    stw r31,-24(r30)
 429    break 4, 8
 430    mtsp r21, sr0
 431    ble,n 0(sr0, r22)
 432    nop                          ; To avoid kernel bugs
 433    nop                          ; and keep the dummy 8 byte aligned
 434
 435    The dummy decides if the target is in text space or data space. If
 436    it's in data space, there's no problem because the target can
 437    return back to the dummy. However, if the target is in text space,
 438    the dummy calls the secret, undocumented routine _sr4export, which
 439    calls a function in text space and can return to any space. Instead
 440    of including fake instructions to represent saved registers, we
 441    know that the frame is associated with the call dummy and treat it
 442    specially.
 443
 444    The trailing NOPs are needed to avoid a bug in HPUX, BSD and OSF1
 445    kernels.   If the memory at the location pointed to by the PC is
 446    0xffffffff then a ptrace step call will fail (even if the instruction
 447    is nullified).
 448
 449    The code to pop a dummy frame single steps three instructions
 450    starting with the last mtsp.  This includes the nullified "instruction"
 451    following the ble (which is uninitialized junk).  If the
 452    "instruction" following the last BLE is 0xffffffff, then the ptrace
 453    will fail and the dummy frame is not correctly popped.
 454
 455    By placing a NOP in the delay slot of the BLE instruction we can be
 456    sure that we never try to execute a 0xffffffff instruction and
 457    avoid the kernel bug.  The second NOP is needed to keep the call
 458    dummy 8 byte aligned.  */
 459
 460 /* Define offsets into the call dummy for the target function address */
 461 #define FUNC_LDIL_OFFSET (INSTRUCTION_SIZE * 9)
 462 #define FUNC_LDO_OFFSET (INSTRUCTION_SIZE * 10)
 463
 464 /* Define offsets into the call dummy for the _sr4export address */
 465 #define SR4EXPORT_LDIL_OFFSET (INSTRUCTION_SIZE * 12)
 466 #define SR4EXPORT_LDO_OFFSET (INSTRUCTION_SIZE * 13)
 467
 468 #define CALL_DUMMY {0x4BDA3FB9, 0x4BD93FB1, 0x4BD83FA9, 0x4BD73FA1,\
 469                     0x37C13FB9, 0x24201004, 0x2C391005, 0x24311006,\
 470                     0x2C291007, 0x22C00000, 0x36D60000, 0x02C010A4,\
 471                     0x20200000, 0x34210000, 0x002010b4, 0x82842022,\
 472                     0xe6c06000, 0x081f0242, 0x00010004, 0x00151820,\
 473                     0xe6c00002, 0xe4202000, 0x6bdf3fd1, 0x00010004,\
 474                     0x00151820, 0xe6c00002, 0x08000240, 0x08000240}
 475
 476 #define CALL_DUMMY_LENGTH (INSTRUCTION_SIZE * 28)
 477 #define REG_PARM_STACK_SPACE 16
 478
 479 #else /* defined PA_LEVEL_0 */
 480
 481 /* This is the call dummy for a level 0 PA.  Level 0's don't have space
 482    registers (or floating point?), so we skip all that inter-space call stuff,
 483    and avoid touching the fp regs.
 484
 485    call_dummy
 486
 487    ldw -36(%sp), %arg0
 488    ldw -40(%sp), %arg1
 489    ldw -44(%sp), %arg2
 490    ldw -48(%sp), %arg3
 491    ldil 0, %r31                 ; FUNC_LDIL_OFFSET must point here
 492    ldo 0(%r31), %r31            ; FUNC_LDO_OFFSET must point here
 493    ble 0(%sr0, %r31)
 494    copy %r31, %r2
 495    break 4, 8
 496    nop                          ; restore_pc_queue expects these
 497    bv,n 0(%r22)                 ; instructions to be here...
 498    nop
 499  */
 500
 501 /* Define offsets into the call dummy for the target function address */
 502 #define FUNC_LDIL_OFFSET (INSTRUCTION_SIZE * 4)
 503 #define FUNC_LDO_OFFSET (INSTRUCTION_SIZE * 5)
 504
 505 #define CALL_DUMMY {0x4bda3fb9, 0x4bd93fb1, 0x4bd83fa9, 0x4bd73fa1,\
 506                     0x23e00000, 0x37ff0000, 0xe7e00000, 0x081f0242,\
 507                     0x00010004, 0x08000240, 0xeac0c002, 0x08000240}
 508
 509 #define CALL_DUMMY_LENGTH (INSTRUCTION_SIZE * 12)
 510
 511 #endif
 512
 513 #define CALL_DUMMY_START_OFFSET 0
 514
 515 /* If we've reached a trap instruction within the call dummy, then
 516    we'll consider that to mean that we've reached the call dummy's
 517    end after its successful completion. */
 518 #define CALL_DUMMY_HAS_COMPLETED(pc, sp, frame_address) \
 519   (PC_IN_CALL_DUMMY((pc), (sp), (frame_address)) && \
 520    (read_memory_integer((pc), 4) == BREAKPOINT32))
 521
 522 /*
 523  * Insert the specified number of args and function address
 524  * into a call sequence of the above form stored at DUMMYNAME.
 525  *
 526  * On the hppa we need to call the stack dummy through $$dyncall.
 527  * Therefore our version of FIX_CALL_DUMMY takes an extra argument,
 528  * real_pc, which is the location where gdb should start up the
 529  * inferior to do the function call.
 530  */
 531
 532 #define FIX_CALL_DUMMY hppa_fix_call_dummy
 533
 534 extern CORE_ADDR
 535 hppa_fix_call_dummy (char *, CORE_ADDR, CORE_ADDR, int,
 536                      struct value **, struct type *, int);
 537
 538 #define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
 539   (hppa_push_arguments((nargs), (args), (sp), (struct_return), (struct_addr)))
 540 extern CORE_ADDR
 541 hppa_push_arguments (int, struct value **, CORE_ADDR, int, CORE_ADDR);
 542 \f
 543 extern CORE_ADDR hppa_smash_text_address (CORE_ADDR addr);
 544 #define SMASH_TEXT_ADDRESS(addr) hppa_smash_text_address (addr)
 545
 546 #define GDB_TARGET_IS_HPPA
 547
 548 #define BELIEVE_PCC_PROMOTION 1
 549
 550 /*
 551  * Unwind table and descriptor.
 552  */
 553
 554 struct unwind_table_entry
 555   {
 556     CORE_ADDR region_start;
 557     CORE_ADDR region_end;
 558
 559     unsigned int Cannot_unwind:1;       /* 0 */
 560     unsigned int Millicode:1;   /* 1 */
 561     unsigned int Millicode_save_sr0:1;  /* 2 */
 562     unsigned int Region_description:2;  /* 3..4 */
 563     unsigned int reserved1:1;   /* 5 */
 564     unsigned int Entry_SR:1;    /* 6 */
 565     unsigned int Entry_FR:4;    /* number saved *//* 7..10 */
 566     unsigned int Entry_GR:5;    /* number saved *//* 11..15 */
 567     unsigned int Args_stored:1; /* 16 */
 568     unsigned int Variable_Frame:1;      /* 17 */
 569     unsigned int Separate_Package_Body:1;       /* 18 */
 570     unsigned int Frame_Extension_Millicode:1;   /* 19 */
 571     unsigned int Stack_Overflow_Check:1;        /* 20 */
 572     unsigned int Two_Instruction_SP_Increment:1;        /* 21 */
 573     unsigned int Ada_Region:1;  /* 22 */
 574     unsigned int cxx_info:1;    /* 23 */
 575     unsigned int cxx_try_catch:1;       /* 24 */
 576     unsigned int sched_entry_seq:1;     /* 25 */
 577     unsigned int reserved2:1;   /* 26 */
 578     unsigned int Save_SP:1;     /* 27 */
 579     unsigned int Save_RP:1;     /* 28 */
 580     unsigned int Save_MRP_in_frame:1;   /* 29 */
 581     unsigned int extn_ptr_defined:1;    /* 30 */
 582     unsigned int Cleanup_defined:1;     /* 31 */
 583
 584     unsigned int MPE_XL_interrupt_marker:1;     /* 0 */
 585     unsigned int HP_UX_interrupt_marker:1;      /* 1 */
 586     unsigned int Large_frame:1; /* 2 */
 587     unsigned int Pseudo_SP_Set:1;       /* 3 */
 588     unsigned int reserved4:1;   /* 4 */
 589     unsigned int Total_frame_size:27;   /* 5..31 */
 590
 591     /* This is *NOT* part of an actual unwind_descriptor in an object
 592        file.  It is *ONLY* part of the "internalized" descriptors that
 593        we create from those in a file.
 594      */
 595     struct
 596       {
 597         unsigned int stub_type:4;       /* 0..3 */
 598         unsigned int padding:28;        /* 4..31 */
 599       }
 600     stub_unwind;
 601   };
 602
 603 /* HP linkers also generate unwinds for various linker-generated stubs.
 604    GDB reads in the stubs from the $UNWIND_END$ subspace, then
 605    "converts" them into normal unwind entries using some of the reserved
 606    fields to store the stub type.  */
 607
 608 struct stub_unwind_entry
 609   {
 610     /* The offset within the executable for the associated stub.  */
 611     unsigned stub_offset;
 612
 613     /* The type of stub this unwind entry describes.  */
 614     char type;
 615
 616     /* Unknown.  Not needed by GDB at this time.  */
 617     char prs_info;
 618
 619     /* Length (in instructions) of the associated stub.  */
 620     short stub_length;
 621   };
 622
 623 /* Sizes (in bytes) of the native unwind entries.  */
 624 #define UNWIND_ENTRY_SIZE 16
 625 #define STUB_UNWIND_ENTRY_SIZE 8
 626
 627 /* The gaps represent linker stubs used in MPE and space for future
 628    expansion.  */
 629 enum unwind_stub_types
 630   {
 631     LONG_BRANCH = 1,
 632     PARAMETER_RELOCATION = 2,
 633     EXPORT = 10,
 634     IMPORT = 11,
 635     IMPORT_SHLIB = 12,
 636   };
 637
 638 /* We use the objfile->obj_private pointer for two things:
 639
 640  * 1.  An unwind table;
 641  *
 642  * 2.  A pointer to any associated shared library object.
 643  *
 644  * #defines are used to help refer to these objects.
 645  */
 646
 647 /* Info about the unwind table associated with an object file.
 648
 649  * This is hung off of the "objfile->obj_private" pointer, and
 650  * is allocated in the objfile's psymbol obstack.  This allows
 651  * us to have unique unwind info for each executable and shared
 652  * library that we are debugging.
 653  */
 654 struct obj_unwind_info
 655   {
 656     struct unwind_table_entry *table;   /* Pointer to unwind info */
 657     struct unwind_table_entry *cache;   /* Pointer to last entry we found */
 658     int last;                   /* Index of last entry */
 659   };
 660
 661 typedef struct obj_private_struct
 662   {
 663     struct obj_unwind_info *unwind_info;        /* a pointer */
 664     struct so_list *so_info;    /* a pointer  */
 665     CORE_ADDR dp;
 666   }
 667 obj_private_data_t;
 668
 669 #if 0
 670 extern void target_write_pc (CORE_ADDR, int);
 671 extern CORE_ADDR target_read_pc (int);
 672 extern CORE_ADDR skip_trampoline_code (CORE_ADDR, char *);
 673 #endif
 674
 675 #define TARGET_READ_PC(pid) target_read_pc (pid)
 676 extern CORE_ADDR target_read_pc (ptid_t);
 677
 678 #define TARGET_WRITE_PC(v,pid) target_write_pc (v,pid)
 679 extern void target_write_pc (CORE_ADDR, ptid_t);
 680
 681 #define TARGET_READ_FP() target_read_fp (PIDGET (inferior_ptid))
 682 extern CORE_ADDR target_read_fp (int);
 683
 684 /* For a number of horrible reasons we may have to adjust the location
 685    of variables on the stack.  Ugh.  */
 686 #define HPREAD_ADJUST_STACK_ADDRESS(ADDR) hpread_adjust_stack_address(ADDR)
 687
 688 extern int hpread_adjust_stack_address (CORE_ADDR);
 689
 690 /* If the current gcc for for this target does not produce correct debugging
 691    information for float parameters, both prototyped and unprototyped, then
 692    define this macro.  This forces gdb to  always assume that floats are
 693    passed as doubles and then converted in the callee.  */
 694
 695 extern int hppa_coerce_float_to_double (struct type *formal,
 696                                         struct type *actual);
 697 #define COERCE_FLOAT_TO_DOUBLE(formal, actual) \
 698   hppa_coerce_float_to_double (formal, actual)
 699
 700 /* Here's how to step off a permanent breakpoint.  */
 701 #define SKIP_PERMANENT_BREAKPOINT (hppa_skip_permanent_breakpoint)
 702 extern void hppa_skip_permanent_breakpoint (void);
 703
 704 /* On HP-UX, certain system routines (millicode) have names beginning
 705    with $ or $$, e.g. $$dyncall, which handles inter-space procedure
 706    calls on PA-RISC.  Tell the expression parser to check for those
 707    when parsing tokens that begin with "$".  */
 708 #define SYMBOLS_CAN_START_WITH_DOLLAR (1)