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, 2001, 2002, 2003 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 /* Wonder if this is correct?  Should be using push_dummy_call().  */
  28 #define DEPRECATED_DUMMY_WRITE_SP(SP) generic_target_write_sp (SP)
  29
  30 #ifndef GDB_MULTI_ARCH
  31 #define GDB_MULTI_ARCH 1
  32 #endif
  33
  34 /* NOTE: cagney/2002-11-24: This is a guess.  */
  35 #define DEPRECATED_USE_GENERIC_DUMMY_FRAMES 0
  36 #define CALL_DUMMY_LOCATION ON_STACK
  37 #define DEPRECATED_PC_IN_CALL_DUMMY(pc, sp, frame_address) deprecated_pc_in_call_dummy_on_stack (pc, sp, frame_address)
  38 #define DEPRECATED_INIT_FRAME_PC(l,f) (init_frame_pc_default (l, f))
  39
  40 /* Forward declarations of some types we use in prototypes */
  41
  42 struct frame_info;
  43 struct frame_saved_regs;
  44 struct value;
  45 struct type;
  46 struct inferior_status;
  47
  48 /* Get at various relevent fields of an instruction word. */
  49
  50 #define MASK_5 0x1f
  51 #define MASK_11 0x7ff
  52 #define MASK_14 0x3fff
  53 #define MASK_21 0x1fffff
  54
  55 /* This macro gets bit fields using HP's numbering (MSB = 0) */
  56 #ifndef GET_FIELD
  57 #define GET_FIELD(X, FROM, TO) \
  58   ((X) >> (31 - (TO)) & ((1 << ((TO) - (FROM) + 1)) - 1))
  59 #endif
  60
  61 /* Sequence of bytes for breakpoint instruction.  */
  62
  63 #define BREAKPOINT {0x00, 0x01, 0x00, 0x04}
  64 #define BREAKPOINT32 0x10004
  65
  66 extern int hppa_pc_requires_run_before_use (CORE_ADDR pc);
  67 #define PC_REQUIRES_RUN_BEFORE_USE(pc) hppa_pc_requires_run_before_use (pc)
  68
  69 /* Initializer for an array of names of registers.
  70    There should be NUM_REGS strings in this initializer.
  71    They are in rows of eight entries  */
  72
  73 #define REGISTER_NAMES  \
  74  {"flags",  "r1",      "rp",      "r3",    "r4",     "r5",      "r6",     "r7",    \
  75   "r8",     "r9",      "r10",     "r11",   "r12",    "r13",     "r14",    "r15",   \
  76   "r16",    "r17",     "r18",     "r19",   "r20",    "r21",     "r22",    "r23",   \
  77   "r24",    "r25",     "r26",     "dp",    "ret0",   "ret1",    "sp",     "r31",   \
  78   "sar",    "pcoqh",   "pcsqh",   "pcoqt", "pcsqt",  "eiem",    "iir",    "isr",   \
  79   "ior",    "ipsw",    "goto",    "sr4",   "sr0",    "sr1",     "sr2",    "sr3",   \
  80   "sr5",    "sr6",     "sr7",     "cr0",   "cr8",    "cr9",     "ccr",    "cr12",  \
  81   "cr13",   "cr24",    "cr25",    "cr26",  "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",\
  82   "fpsr",    "fpe1",   "fpe2",    "fpe3",  "fpe4",   "fpe5",    "fpe6",   "fpe7",  \
  83   "fr4",     "fr4R",   "fr5",     "fr5R",  "fr6",    "fr6R",    "fr7",    "fr7R",  \
  84   "fr8",     "fr8R",   "fr9",     "fr9R",  "fr10",   "fr10R",   "fr11",   "fr11R", \
  85   "fr12",    "fr12R",  "fr13",    "fr13R", "fr14",   "fr14R",   "fr15",   "fr15R", \
  86   "fr16",    "fr16R",  "fr17",    "fr17R", "fr18",   "fr18R",   "fr19",   "fr19R", \
  87   "fr20",    "fr20R",  "fr21",    "fr21R", "fr22",   "fr22R",   "fr23",   "fr23R", \
  88   "fr24",    "fr24R",  "fr25",    "fr25R", "fr26",   "fr26R",   "fr27",   "fr27R", \
  89   "fr28",    "fr28R",  "fr29",    "fr29R", "fr30",   "fr30R",   "fr31",   "fr31R"}
  90
  91 /* Register numbers of various important registers.
  92    Note that some of these values are "real" register numbers,
  93    and correspond to the general registers of the machine,
  94    and some are "phony" register numbers which are too large
  95    to be actual register numbers as far as the user is concerned
  96    but do serve to get the desired values when passed to read_register.  */
  97
  98 #define R0_REGNUM 0             /* Doesn't actually exist, used as base for
  99                                    other r registers.  */
 100 #define FLAGS_REGNUM 0          /* Various status flags */
 101 #define RP_REGNUM 2             /* return pointer */
 102 #define SAR_REGNUM 32           /* Shift Amount Register */
 103 #define IPSW_REGNUM 41          /* Interrupt Processor Status Word */
 104 #define PCOQ_HEAD_REGNUM 33     /* instruction offset queue head */
 105 #define PCSQ_HEAD_REGNUM 34     /* instruction space queue head */
 106 #define PCOQ_TAIL_REGNUM 35     /* instruction offset queue tail */
 107 #define PCSQ_TAIL_REGNUM 36     /* instruction space queue tail */
 108 #define EIEM_REGNUM 37          /* External Interrupt Enable Mask */
 109 #define IIR_REGNUM 38           /* Interrupt Instruction Register */
 110 #define IOR_REGNUM 40           /* Interrupt Offset Register */
 111 #define SR4_REGNUM 43           /* space register 4 */
 112 #define RCR_REGNUM 51           /* Recover Counter (also known as cr0) */
 113 #define CCR_REGNUM 54           /* Coprocessor Configuration Register */
 114 #define TR0_REGNUM 57           /* Temporary Registers (cr24 -> cr31) */
 115 #define CR27_REGNUM 60          /* Base register for thread-local storage, cr27 */
 116 #define FP4_REGNUM 72
 117
 118 #define ARG0_REGNUM 26          /* The first argument of a callee. */
 119 #define ARG1_REGNUM 25          /* The second argument of a callee. */
 120 #define ARG2_REGNUM 24          /* The third argument of a callee. */
 121 #define ARG3_REGNUM 23          /* The fourth argument of a callee. */
 122
 123 /*
 124  * Processor Status Word Masks
 125  */
 126
 127 #define PSW_T   0x01000000      /* Taken Branch Trap Enable */
 128 #define PSW_H   0x00800000      /* Higher-Privilege Transfer Trap Enable */
 129 #define PSW_L   0x00400000      /* Lower-Privilege Transfer Trap Enable */
 130 #define PSW_N   0x00200000      /* PC Queue Front Instruction Nullified */
 131 #define PSW_X   0x00100000      /* Data Memory Break Disable */
 132 #define PSW_B   0x00080000      /* Taken Branch in Previous Cycle */
 133 #define PSW_C   0x00040000      /* Code Address Translation Enable */
 134 #define PSW_V   0x00020000      /* Divide Step Correction */
 135 #define PSW_M   0x00010000      /* High-Priority Machine Check Disable */
 136 #define PSW_CB  0x0000ff00      /* Carry/Borrow Bits */
 137 #define PSW_R   0x00000010      /* Recovery Counter Enable */
 138 #define PSW_Q   0x00000008      /* Interruption State Collection Enable */
 139 #define PSW_P   0x00000004      /* Protection ID Validation Enable */
 140 #define PSW_D   0x00000002      /* Data Address Translation Enable */
 141 #define PSW_I   0x00000001      /* External, Power Failure, Low-Priority */
 142                                 /* Machine Check Interruption Enable */
 143
 144 /* When fetching register values from an inferior or a core file,
 145    clean them up using this macro.  BUF is a char pointer to
 146    the raw value of the register in the registers[] array.  */
 147
 148 #define DEPRECATED_CLEAN_UP_REGISTER_VALUE(regno, buf) \
 149   do {  \
 150     if ((regno) == PCOQ_HEAD_REGNUM || (regno) == PCOQ_TAIL_REGNUM) \
 151       (buf)[sizeof(CORE_ADDR) -1] &= ~0x3; \
 152   } while (0)
 153
 154 /* Define DEPRECATED_DO_REGISTERS_INFO() to do machine-specific
 155    formatting of register dumps. */
 156
 157 #define DEPRECATED_DO_REGISTERS_INFO(_regnum, fp) pa_do_registers_info (_regnum, fp)
 158 extern void pa_do_registers_info (int, int);
 159
 160 /* PA specific macro to see if the current instruction is nullified. */
 161 #ifndef INSTRUCTION_NULLIFIED
 162 extern int hppa_instruction_nullified (void);
 163 #define INSTRUCTION_NULLIFIED hppa_instruction_nullified ()
 164 #endif
 165
 166 /* elz: Return a large value, which is stored on the stack at addr.
 167    This is defined only for the hppa, at this moment.  The above macro
 168    DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS is not called anymore,
 169    because it assumes that on exit from a called function which
 170    returns a large structure on the stack, the address of the ret
 171    structure is still in register 28. Unfortunately this register is
 172    usually overwritten by the called function itself, on hppa. This is
 173    specified in the calling convention doc. As far as I know, the only
 174    way to get the return value is to have the caller tell us where it
 175    told the callee to put it, rather than have the callee tell us.  */
 176 struct value *hppa_value_returned_from_stack (register struct type *valtype,
 177                                               CORE_ADDR addr);
 178 #define VALUE_RETURNED_FROM_STACK(valtype,addr) \
 179   hppa_value_returned_from_stack (valtype, addr)
 180
 181 extern void hppa_frame_init_saved_regs (struct frame_info *);
 182 #define DEPRECATED_FRAME_INIT_SAVED_REGS(FI) \
 183   hppa_frame_init_saved_regs (FI)
 184
 185 #define INSTRUCTION_SIZE 4
 186
 187 /* Non-level zero PA's have space registers (but they don't always have
 188    floating-point, do they????  */
 189
 190 /* This sequence of words is the instructions
 191
 192    ; Call stack frame has already been built by gdb. Since we could be calling
 193    ; a varargs function, and we do not have the benefit of a stub to put things in
 194    ; the right place, we load the first 4 word of arguments into both the general
 195    ; and fp registers.
 196    call_dummy
 197    ldw -36(sp), arg0
 198    ldw -40(sp), arg1
 199    ldw -44(sp), arg2
 200    ldw -48(sp), arg3
 201    ldo -36(sp), r1
 202    fldws 0(0, r1), fr4
 203    fldds -4(0, r1), fr5
 204    fldws -8(0, r1), fr6
 205    fldds -12(0, r1), fr7
 206    ldil 0, r22                  ; FUNC_LDIL_OFFSET must point here
 207    ldo 0(r22), r22                      ; FUNC_LDO_OFFSET must point here
 208    ldsid (0,r22), r4
 209    ldil 0, r1                   ; SR4EXPORT_LDIL_OFFSET must point here
 210    ldo 0(r1), r1                        ; SR4EXPORT_LDO_OFFSET must point here
 211    ldsid (0,r1), r20
 212    combt,=,n r4, r20, text_space        ; If target is in data space, do a
 213    ble 0(sr5, r22)                      ; "normal" procedure call
 214    copy r31, r2
 215    break 4, 8
 216    mtsp r21, sr0
 217    ble,n 0(sr0, r22)
 218    text_space                           ; Otherwise, go through _sr4export,
 219    ble (sr4, r1)                        ; which will return back here.
 220    stw r31,-24(r30)
 221    break 4, 8
 222    mtsp r21, sr0
 223    ble,n 0(sr0, r22)
 224    nop                          ; To avoid kernel bugs
 225    nop                          ; and keep the dummy 8 byte aligned
 226
 227    The dummy decides if the target is in text space or data space. If
 228    it's in data space, there's no problem because the target can
 229    return back to the dummy. However, if the target is in text space,
 230    the dummy calls the secret, undocumented routine _sr4export, which
 231    calls a function in text space and can return to any space. Instead
 232    of including fake instructions to represent saved registers, we
 233    know that the frame is associated with the call dummy and treat it
 234    specially.
 235
 236    The trailing NOPs are needed to avoid a bug in HPUX, BSD and OSF1
 237    kernels.   If the memory at the location pointed to by the PC is
 238    0xffffffff then a ptrace step call will fail (even if the instruction
 239    is nullified).
 240
 241    The code to pop a dummy frame single steps three instructions
 242    starting with the last mtsp.  This includes the nullified "instruction"
 243    following the ble (which is uninitialized junk).  If the
 244    "instruction" following the last BLE is 0xffffffff, then the ptrace
 245    will fail and the dummy frame is not correctly popped.
 246
 247    By placing a NOP in the delay slot of the BLE instruction we can be
 248    sure that we never try to execute a 0xffffffff instruction and
 249    avoid the kernel bug.  The second NOP is needed to keep the call
 250    dummy 8 byte aligned.  */
 251
 252 /* Define offsets into the call dummy for the target function address */
 253 #define FUNC_LDIL_OFFSET (INSTRUCTION_SIZE * 9)
 254 #define FUNC_LDO_OFFSET (INSTRUCTION_SIZE * 10)
 255
 256 /* Define offsets into the call dummy for the _sr4export address */
 257 #define SR4EXPORT_LDIL_OFFSET (INSTRUCTION_SIZE * 12)
 258 #define SR4EXPORT_LDO_OFFSET (INSTRUCTION_SIZE * 13)
 259
 260 #define CALL_DUMMY {0x4BDA3FB9, 0x4BD93FB1, 0x4BD83FA9, 0x4BD73FA1,\
 261                     0x37C13FB9, 0x24201004, 0x2C391005, 0x24311006,\
 262                     0x2C291007, 0x22C00000, 0x36D60000, 0x02C010A4,\
 263                     0x20200000, 0x34210000, 0x002010b4, 0x82842022,\
 264                     0xe6c06000, 0x081f0242, 0x00010004, 0x00151820,\
 265                     0xe6c00002, 0xe4202000, 0x6bdf3fd1, 0x00010004,\
 266                     0x00151820, 0xe6c00002, 0x08000240, 0x08000240}
 267
 268 #define REG_PARM_STACK_SPACE 16
 269
 270 /* If we've reached a trap instruction within the call dummy, then
 271    we'll consider that to mean that we've reached the call dummy's
 272    end after its successful completion. */
 273 #define CALL_DUMMY_HAS_COMPLETED(pc, sp, frame_address) \
 274   (DEPRECATED_PC_IN_CALL_DUMMY((pc), (sp), (frame_address)) && \
 275    (read_memory_integer((pc), 4) == BREAKPOINT32))
 276
 277 /*
 278  * Insert the specified number of args and function address
 279  * into a call sequence of the above form stored at DUMMYNAME.
 280  *
 281  * On the hppa we need to call the stack dummy through $$dyncall.
 282  * Therefore our version of FIX_CALL_DUMMY takes an extra argument,
 283  * real_pc, which is the location where gdb should start up the
 284  * inferior to do the function call.
 285  */
 286
 287 /* FIXME: brobecker 2002-12-26.  This macro is going to cause us some
 288    problems before we can go to multiarch partial as it has been diverted
 289    on HPUX to return the value of the PC!  */
 290 #define FIX_CALL_DUMMY hppa_fix_call_dummy
 291 extern CORE_ADDR hppa_fix_call_dummy (char *, CORE_ADDR, CORE_ADDR, int,
 292                                       struct value **, struct type *, int);
 293
 294 #define GDB_TARGET_IS_HPPA
 295
 296 /*
 297  * Unwind table and descriptor.
 298  */
 299
 300 struct unwind_table_entry
 301   {
 302     CORE_ADDR region_start;
 303     CORE_ADDR region_end;
 304
 305     unsigned int Cannot_unwind:1;       /* 0 */
 306     unsigned int Millicode:1;   /* 1 */
 307     unsigned int Millicode_save_sr0:1;  /* 2 */
 308     unsigned int Region_description:2;  /* 3..4 */
 309     unsigned int reserved1:1;   /* 5 */
 310     unsigned int Entry_SR:1;    /* 6 */
 311     unsigned int Entry_FR:4;    /* number saved *//* 7..10 */
 312     unsigned int Entry_GR:5;    /* number saved *//* 11..15 */
 313     unsigned int Args_stored:1; /* 16 */
 314     unsigned int Variable_Frame:1;      /* 17 */
 315     unsigned int Separate_Package_Body:1;       /* 18 */
 316     unsigned int Frame_Extension_Millicode:1;   /* 19 */
 317     unsigned int Stack_Overflow_Check:1;        /* 20 */
 318     unsigned int Two_Instruction_SP_Increment:1;        /* 21 */
 319     unsigned int Ada_Region:1;  /* 22 */
 320     unsigned int cxx_info:1;    /* 23 */
 321     unsigned int cxx_try_catch:1;       /* 24 */
 322     unsigned int sched_entry_seq:1;     /* 25 */
 323     unsigned int reserved2:1;   /* 26 */
 324     unsigned int Save_SP:1;     /* 27 */
 325     unsigned int Save_RP:1;     /* 28 */
 326     unsigned int Save_MRP_in_frame:1;   /* 29 */
 327     unsigned int extn_ptr_defined:1;    /* 30 */
 328     unsigned int Cleanup_defined:1;     /* 31 */
 329
 330     unsigned int MPE_XL_interrupt_marker:1;     /* 0 */
 331     unsigned int HP_UX_interrupt_marker:1;      /* 1 */
 332     unsigned int Large_frame:1; /* 2 */
 333     unsigned int Pseudo_SP_Set:1;       /* 3 */
 334     unsigned int reserved4:1;   /* 4 */
 335     unsigned int Total_frame_size:27;   /* 5..31 */
 336
 337     /* This is *NOT* part of an actual unwind_descriptor in an object
 338        file.  It is *ONLY* part of the "internalized" descriptors that
 339        we create from those in a file.
 340      */
 341     struct
 342       {
 343         unsigned int stub_type:4;       /* 0..3 */
 344         unsigned int padding:28;        /* 4..31 */
 345       }
 346     stub_unwind;
 347   };
 348
 349 /* HP linkers also generate unwinds for various linker-generated stubs.
 350    GDB reads in the stubs from the $UNWIND_END$ subspace, then
 351    "converts" them into normal unwind entries using some of the reserved
 352    fields to store the stub type.  */
 353
 354 struct stub_unwind_entry
 355   {
 356     /* The offset within the executable for the associated stub.  */
 357     unsigned stub_offset;
 358
 359     /* The type of stub this unwind entry describes.  */
 360     char type;
 361
 362     /* Unknown.  Not needed by GDB at this time.  */
 363     char prs_info;
 364
 365     /* Length (in instructions) of the associated stub.  */
 366     short stub_length;
 367   };
 368
 369 /* Sizes (in bytes) of the native unwind entries.  */
 370 #define UNWIND_ENTRY_SIZE 16
 371 #define STUB_UNWIND_ENTRY_SIZE 8
 372
 373 /* The gaps represent linker stubs used in MPE and space for future
 374    expansion.  */
 375 enum unwind_stub_types
 376   {
 377     LONG_BRANCH = 1,
 378     PARAMETER_RELOCATION = 2,
 379     EXPORT = 10,
 380     IMPORT = 11,
 381     IMPORT_SHLIB = 12,
 382   };
 383
 384 /* We use the objfile->obj_private pointer for two things:
 385
 386  * 1.  An unwind table;
 387  *
 388  * 2.  A pointer to any associated shared library object.
 389  *
 390  * #defines are used to help refer to these objects.
 391  */
 392
 393 /* Info about the unwind table associated with an object file.
 394
 395  * This is hung off of the "objfile->obj_private" pointer, and
 396  * is allocated in the objfile's psymbol obstack.  This allows
 397  * us to have unique unwind info for each executable and shared
 398  * library that we are debugging.
 399  */
 400 struct obj_unwind_info
 401   {
 402     struct unwind_table_entry *table;   /* Pointer to unwind info */
 403     struct unwind_table_entry *cache;   /* Pointer to last entry we found */
 404     int last;                   /* Index of last entry */
 405   };
 406
 407 typedef struct obj_private_struct
 408   {
 409     struct obj_unwind_info *unwind_info;        /* a pointer */
 410     struct so_list *so_info;    /* a pointer  */
 411     CORE_ADDR dp;
 412   }
 413 obj_private_data_t;
 414
 415 /* For a number of horrible reasons we may have to adjust the location
 416    of variables on the stack.  Ugh.  */
 417 #define HPREAD_ADJUST_STACK_ADDRESS(ADDR) hpread_adjust_stack_address(ADDR)
 418 extern int hpread_adjust_stack_address (CORE_ADDR);
 419
 420 /* Here's how to step off a permanent breakpoint.  */
 421 #define SKIP_PERMANENT_BREAKPOINT (hppa_skip_permanent_breakpoint)
 422 extern void hppa_skip_permanent_breakpoint (void);
 423
 424 /* On HP-UX, certain system routines (millicode) have names beginning
 425    with $ or $$, e.g. $$dyncall, which handles inter-space procedure
 426    calls on PA-RISC.  Tell the expression parser to check for those
 427    when parsing tokens that begin with "$".  */
 428 #define SYMBOLS_CAN_START_WITH_DOLLAR (1)