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
   3    Free Software Foundation, Inc.
   4
   5    Contributed by the Center for Software Science at the
   6    University of Utah ([email protected]).
   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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  23
  24 /* Target system byte order. */
  25
  26 #define TARGET_BYTE_ORDER       BIG_ENDIAN
  27
  28 /* Get at various relevent fields of an instruction word. */
  29
  30 #define MASK_5 0x1f
  31 #define MASK_11 0x7ff
  32 #define MASK_14 0x3fff
  33 #define MASK_21 0x1fffff
  34
  35 /* This macro gets bit fields using HP's numbering (MSB = 0) */
  36
  37 #define GET_FIELD(X, FROM, TO) \
  38   ((X) >> 31 - (TO) & (1 << ((TO) - (FROM) + 1)) - 1)
  39
  40 /* Watch out for NaNs */
  41
  42 #define IEEE_FLOAT
  43
  44 /* When passing a structure to a function, GCC passes the address
  45    in a register, not the structure itself. */
  46
  47 /* FIXME: I believe this is wrong.  I believe passing the address
  48    depends only on the size of the argument being > 8, not on its type
  49    (which is a much more sane way than the REG_STRUCT_HAS_ADDR way,
  50    IMHO).  Also, as far as I know it is not dependent on it being
  51    passed in a register.  This should be verified before changing
  52    anything (in fact, printing structure arguments of
  53    2,4,6,8,12,16,and 20 bytes should all be in the test suite).  */
  54
  55 #define REG_STRUCT_HAS_ADDR(gcc_p) (1)
  56
  57 /* Offset from address of function to start of its code.
  58    Zero on most machines.  */
  59
  60 #define FUNCTION_START_OFFSET 0
  61
  62 /* Advance PC across any function entry prologue instructions
  63    to reach some "real" code.  */
  64
  65 /* skip (stw rp, -20(0,sp)); copy 4,1; copy sp, 4; stwm 1,framesize(sp)
  66    for gcc, or (stw rp, -20(0,sp); stwm 1, framesize(sp) for hcc */
  67
  68 #define SKIP_PROLOGUE(pc) pc = skip_prologue (pc)
  69
  70 /* If PC is in some function-call trampoline code, return the PC
  71    where the function itself actually starts.  If not, return NULL.  */
  72
  73 #define SKIP_TRAMPOLINE_CODE(pc) skip_trampoline_code (pc, NULL)
  74
  75 /* Return non-zero if we are in some sort of a trampoline. */
  76
  77 #define IN_SOLIB_TRAMPOLINE(pc, name) skip_trampoline_code (pc, name)
  78
  79 /* Immediately after a function call, return the saved pc.
  80    Can't go through the frames for this because on some machines
  81    the new frame is not set up until the new function executes
  82    some instructions.  */
  83
  84 #undef  SAVED_PC_AFTER_CALL
  85 #define SAVED_PC_AFTER_CALL(frame) saved_pc_after_call (frame)
  86
  87 /* Stack grows upward */
  88
  89 #define INNER_THAN >
  90
  91
  92 /* Sequence of bytes for breakpoint instruction.  */
  93
  94 /*#define BREAKPOINT {0x00, 0x00, 0x00, 0x00}*/
  95 #ifdef  KERNELDEBUG     /* XXX */
  96 #define BREAKPOINT {0x00, 0x00, 0xa0, 0x00}
  97 #else
  98 #define BREAKPOINT {0x00, 0x01, 0x00, 0x04}
  99 #endif
 100
 101 /* Amount PC must be decremented by after a breakpoint.
 102    This is often the number of bytes in BREAKPOINT
 103    but not always.
 104
 105    Not on the PA-RISC */
 106
 107 #define DECR_PC_AFTER_BREAK 0
 108
 109 /* return instruction is bv r0(rp) or bv,n r0(rp)*/
 110
 111 #define ABOUT_TO_RETURN(pc) ((read_memory_integer (pc, 4) | 0x2) == 0xE840C002)
 112
 113 /* Return 1 if P points to an invalid floating point value.  */
 114
 115 #define INVALID_FLOAT(p, len) 0   /* Just a first guess; not checked */
 116
 117 /* Largest integer type */
 118 #define LONGEST long
 119
 120 /* Name of the builtin type for the LONGEST type above. */
 121 #define BUILTIN_TYPE_LONGEST builtin_type_long
 122
 123 /* Say how long (ordinary) registers are.  This is a piece of bogosity
 124    used in push_word and a few other places; REGISTER_RAW_SIZE is the
 125    real way to know how big a register is.  */
 126
 127 #define REGISTER_SIZE 4
 128
 129 /* Number of machine registers */
 130
 131 #define NUM_REGS 100
 132
 133 /* Initializer for an array of names of registers.
 134    There should be NUM_REGS strings in this initializer.  */
 135
 136 #define REGISTER_NAMES  \
 137  {"flags", "r1", "rp", "r3", "r4", "r5", "r6", "r7", "r8", "r9",        \
 138   "r10", "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19", \
 139   "r20", "r21", "r22", "arg3", "arg2", "arg1", "arg0", "dp", "ret0", "ret1", \
 140   "sp", "r31", "sar", "pcoqh", "pcsqh", "pcoqt", "pcsqt", \
 141   "eiem", "iir", "isr", "ior", "ipsw", "goto", "sr4", "sr0", "sr1", "sr2", \
 142   "sr3", "sr5", "sr6", "sr7", "cr0", "cr8", "cr9", "ccr", "cr12", "cr13", \
 143   "cr24", "cr25", "cr26", "mpsfu_high", "mpsfu_low", "mpsfu_ovflo", "pad", \
 144   "fpsr", "fpe1", "fpe2", "fpe3", "fpe4", "fpe5", "fpe6", "fpe7", \
 145   "fr4", "fr5", "fr6", "fr7", "fr8", \
 146   "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15", \
 147   "fr16", "fr17", "fr18", "fr19", "fr20", "fr21", "fr22", "fr23", \
 148   "fr24", "fr25", "fr26", "fr27", "fr28", "fr29", "fr30", "fr31"}
 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 FLAGS_REGNUM 0          /* Various status flags */
 158 #define RP_REGNUM 2             /* return pointer */
 159 #define FP_REGNUM 4             /* Contains address of executing stack */
 160                                 /* frame */
 161 #define SP_REGNUM 30            /* Contains address of top of stack */
 162 #define SAR_REGNUM 32           /* shift amount register */
 163 #define IPSW_REGNUM 41          /* processor status word. ? */
 164 #define PCOQ_HEAD_REGNUM 33     /* instruction offset queue head */
 165 #define PCSQ_HEAD_REGNUM 34     /* instruction space queue head */
 166 #define PCOQ_TAIL_REGNUM 35     /* instruction offset queue tail */
 167 #define PCSQ_TAIL_REGNUM 36     /* instruction space queue tail */
 168 #define FP0_REGNUM 64           /* floating point reg. 0 */
 169 #define FP4_REGNUM 72
 170
 171 /* compatibility with the rest of gdb. */
 172 #define PC_REGNUM PCOQ_HEAD_REGNUM
 173 #define NPC_REGNUM PCOQ_TAIL_REGNUM
 174
 175 /* When fetching register values from an inferior or a core file,
 176    clean them up using this macro.  BUF is a char pointer to
 177    the raw value of the register in the registers[] array.  */
 178
 179 #define CLEAN_UP_REGISTER_VALUE(regno, buf) \
 180   do {  \
 181     if ((regno) == PCOQ_HEAD_REGNUM || (regno) == PCOQ_TAIL_REGNUM) \
 182       (buf)[3] &= ~0x3; \
 183   } while (0)
 184
 185 /* Define DO_REGISTERS_INFO() to do machine-specific formatting
 186    of register dumps. */
 187
 188 #define DO_REGISTERS_INFO(_regnum, fp) pa_do_registers_info (_regnum, fp)
 189
 190 /* PA specific macro to see if the current instruction is nullified. */
 191 #define INSTRUCTION_NULLIFIED ((int)read_register (IPSW_REGNUM) & 0x00200000)
 192
 193 /* Total amount of space needed to store our copies of the machine's
 194    register state, the array `registers'.  */
 195 #define REGISTER_BYTES (32 * 4 + 11 * 4 + 8 * 4 + 12 * 4 + 4 + 32 * 8)
 196
 197 /* Index within `registers' of the first byte of the space for
 198    register N.  */
 199
 200 #define REGISTER_BYTE(N) \
 201  ((N) >= FP4_REGNUM ? ((N) - FP4_REGNUM) * 8 + 288 : (N) * 4)
 202
 203 /* Number of bytes of storage in the actual machine representation
 204    for register N.  On the PA-RISC, all regs are 4 bytes
 205    except the floating point regs which are 8 bytes.  */
 206
 207 #define REGISTER_RAW_SIZE(N) ((N) < FP4_REGNUM ? 4 : 8)
 208
 209 /* Number of bytes of storage in the program's representation
 210    for register N. */
 211
 212 #define REGISTER_VIRTUAL_SIZE(N) REGISTER_RAW_SIZE(N)
 213
 214 /* Largest value REGISTER_RAW_SIZE can have.  */
 215
 216 #define MAX_REGISTER_RAW_SIZE 8
 217
 218 /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
 219
 220 #define MAX_REGISTER_VIRTUAL_SIZE 8
 221
 222 /* Return the GDB type object for the "standard" data type
 223    of data in register N.  */
 224
 225 #define REGISTER_VIRTUAL_TYPE(N) \
 226  ((N) < FP4_REGNUM ? builtin_type_int : builtin_type_double)
 227
 228 /* Store the address of the place in which to copy the structure the
 229    subroutine will return.  This is called from call_function. */
 230
 231 #define STORE_STRUCT_RETURN(ADDR, SP) {write_register (28, (ADDR)); }
 232
 233 /* Extract from an array REGBUF containing the (raw) register state
 234    a function return value of type TYPE, and copy that, in virtual format,
 235    into VALBUF.  */
 236
 237 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 238   memcpy (VALBUF, (REGBUF) + REGISTER_BYTE(TYPE_LENGTH(TYPE) > 4 ? \
 239                                           FP4_REGNUM :28), TYPE_LENGTH (TYPE))
 240
 241 /* Write into appropriate registers a function return value
 242    of type TYPE, given in virtual format.  */
 243
 244 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
 245   write_register_bytes ((TYPE_LENGTH(TYPE) > 4 \
 246                          ? REGISTER_BYTE (FP4_REGNUM) \
 247                          : REGISTER_BYTE (28)),         \
 248                         (VALBUF), TYPE_LENGTH (TYPE))
 249
 250 /* Extract from an array REGBUF containing the (raw) register state
 251    the address in which a function should return its structure value,
 252    as a CORE_ADDR (or an expression that can be used as one).  */
 253
 254 #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)((REGBUF) + 28))
 255
 256 /*
 257  * This macro defines the register numbers (from REGISTER_NAMES) that
 258  * are effectively unavailable to the user through ptrace().  It allows
 259  * us to include the whole register set in REGISTER_NAMES (inorder to
 260  * better support remote debugging).  If it is used in
 261  * fetch/store_inferior_registers() gdb will not complain about I/O errors
 262  * on fetching these registers.  If all registers in REGISTER_NAMES
 263  * are available, then return false (0).
 264  */
 265
 266 #define CANNOT_STORE_REGISTER(regno)            \
 267                    ((regno) == 0) ||     \
 268                    ((regno) == PCSQ_HEAD_REGNUM) || \
 269                    ((regno) >= PCSQ_TAIL_REGNUM && (regno) < IPSW_REGNUM) ||  \
 270                    ((regno) > IPSW_REGNUM && (regno) < FP4_REGNUM)
 271
 272 #define INIT_EXTRA_FRAME_INFO(fromleaf, frame) init_extra_frame_info (fromleaf, frame)
 273
 274 /* Describe the pointer in each stack frame to the previous stack frame
 275    (its caller).  */
 276
 277 /* FRAME_CHAIN takes a frame's nominal address
 278    and produces the frame's chain-pointer.
 279
 280    FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
 281    and produces the nominal address of the caller frame.
 282
 283    However, if FRAME_CHAIN_VALID returns zero,
 284    it means the given frame is the outermost one and has no caller.
 285    In that case, FRAME_CHAIN_COMBINE is not used.  */
 286
 287 /* In the case of the PA-RISC, the frame's nominal address
 288    is the address of a 4-byte word containing the calling frame's
 289    address (previous FP).  */
 290
 291 #define FRAME_CHAIN(thisframe) frame_chain (thisframe)
 292
 293 #define FRAME_CHAIN_VALID(chain, thisframe) \
 294   frame_chain_valid (chain, thisframe)
 295
 296 #define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
 297
 298 /* Define other aspects of the stack frame.  */
 299
 300 /* A macro that tells us whether the function invocation represented
 301    by FI does not have a frame on the stack associated with it.  If it
 302    does not, FRAMELESS is set to 1, else 0.  */
 303 #define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
 304   (FRAMELESS) = frameless_function_invocation(FI)
 305
 306 #define FRAME_SAVED_PC(FRAME) frame_saved_pc (FRAME)
 307
 308 #define FRAME_ARGS_ADDRESS(fi) ((fi)->frame)
 309
 310 #define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame)
 311 /* Set VAL to the number of args passed to frame described by FI.
 312    Can set VAL to -1, meaning no way to tell.  */
 313
 314 /* We can't tell how many args there are
 315    now that the C compiler delays popping them.  */
 316 #define FRAME_NUM_ARGS(val,fi) (val = -1)
 317
 318 /* Return number of bytes at start of arglist that are not really args.  */
 319
 320 #define FRAME_ARGS_SKIP 0
 321
 322 /* Put here the code to store, into a struct frame_saved_regs,
 323    the addresses of the saved registers of frame described by FRAME_INFO.
 324    This includes special registers such as pc and fp saved in special
 325    ways in the stack frame.  sp is even more special:
 326    the address we return for it IS the sp for the next frame.  */
 327
 328 /* Deal with dummy functions later. */
 329
 330 #define STW_P(INSN) (((INSN) & 0xfc000000) == 0x68000000)
 331 #define ADDIL_P(INSN) (((INSN) & 0xfc000000) == 0x28000000)
 332 #define LDO_P(INSN) (((INSN) & 0xfc00c000) == 0x34000000)
 333
 334 #define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)             \
 335 { register int regnum;                                                  \
 336   register CORE_ADDR next_addr;                                         \
 337   register CORE_ADDR pc;                                                \
 338   unsigned this_insn;                                                   \
 339   unsigned address;                                                     \
 340                                                                         \
 341   memset (&frame_saved_regs, '\0', sizeof frame_saved_regs);                    \
 342   if ((frame_info->pc >= (frame_info)->frame                            \
 343        && (frame_info)->pc <= ((frame_info)->frame + CALL_DUMMY_LENGTH  \
 344                                + 32 * 4 + (NUM_REGS - FP0_REGNUM) * 8   \
 345                                + 6 * 4)))                               \
 346     find_dummy_frame_regs ((frame_info), &(frame_saved_regs));          \
 347   else                                                                  \
 348     { pc = get_pc_function_start ((frame_info)->pc);                    \
 349       if (read_memory_integer (pc, 4) == 0x6BC23FD9)                    \
 350         { (frame_saved_regs).regs[RP_REGNUM] = (frame_info)->frame - 20;\
 351           pc = pc + 4;                                                  \
 352         }                                                               \
 353       if (read_memory_integer (pc, 4) != 0x8040241) goto lose;          \
 354       pc += 8;                  /* skip "copy 4,1; copy 30, 4" */       \
 355       /* skip either "stw 1,0(4);addil L'fsize,30;ldo R'fsize(1),30"    \
 356          or "stwm 1,fsize(30)" */                                       \
 357       if ((read_memory_integer (pc, 4) & ~MASK_14) == 0x68810000)       \
 358         pc += 12;                                                       \
 359       else                                                              \
 360         pc += 4;                                                        \
 361       while (1)                                                         \
 362         { this_insn = read_memory_integer(pc, 4);                       \
 363           if (STW_P (this_insn)) /* stw */                              \
 364             { regnum = GET_FIELD (this_insn, 11, 15);                   \
 365               if (!regnum) goto lose;                                   \
 366               (frame_saved_regs).regs[regnum] = (frame_info)->frame +   \
 367                 extract_14 (this_insn);                                 \
 368               pc += 4;                                                  \
 369             }                                                           \
 370           else if (ADDIL_P (this_insn)) /* addil */                     \
 371             { int next_insn;                                            \
 372               next_insn = read_memory_integer(pc + 4, 4);               \
 373               if (STW_P (next_insn)) /* stw */                          \
 374                 { regnum = GET_FIELD (this_insn, 6, 10);                \
 375                   if (!regnum) goto lose;                               \
 376                   (frame_saved_regs).regs[regnum] = (frame_info)->frame +\
 377                     (extract_21 (this_insn) << 11) + extract_14 (next_insn);\
 378                   pc += 8;                                              \
 379                 }                                                       \
 380               else                                                      \
 381                 break;                                                  \
 382             }                                                           \
 383           else                                                          \
 384             { pc += 4;                                                  \
 385               break;                                                    \
 386             }                                                           \
 387         }                                                               \
 388       this_insn = read_memory_integer (pc, 4);                          \
 389       if (LDO_P (this_insn))                                            \
 390         { next_addr = (frame_info)->frame + extract_14 (this_insn);     \
 391           pc += 4;                                                      \
 392         }                                                               \
 393       else if (ADDIL_P (this_insn))                                     \
 394         { next_addr = (frame_info)->frame + (extract_21 (this_insn) << 11)\
 395             + extract_14 (read_memory_integer (pc + 4, 4));             \
 396             pc += 8;                                                    \
 397           }                                                             \
 398       while (1)                                                         \
 399         { this_insn = read_memory_integer (pc, 4);                      \
 400           if ((this_insn & 0xfc001fe0) == 0x2c001220) /* fstds,ma */    \
 401             { regnum = GET_FIELD (this_insn, 27, 31);                   \
 402               (frame_saved_regs).regs[regnum + FP0_REGNUM] = next_addr; \
 403               next_addr += 8;                                           \
 404               pc += 4;                                                  \
 405             }                                                           \
 406           else                                                          \
 407             break;                                                      \
 408         }                                                               \
 409     lose:                                                               \
 410       (frame_saved_regs).regs[FP_REGNUM] = (frame_info)->frame;         \
 411       (frame_saved_regs).regs[SP_REGNUM] = (frame_info)->frame -4;      \
 412     }}
 413 \f
 414 /* Things needed for making the inferior call functions.  */
 415
 416 /* Push an empty stack frame, to record the current PC, etc. */
 417
 418 #define PUSH_DUMMY_FRAME push_dummy_frame ()
 419
 420 /* Discard from the stack the innermost frame,
 421    restoring all saved registers.  */
 422 #define POP_FRAME  hppa_pop_frame ()
 423
 424 /* This sequence of words is the instructions
 425
 426 ; Call stack frame has already been built by gdb. Since we could be calling
 427 ; a varargs function, and we do not have the benefit of a stub to put things in
 428 ; the right place, we load the first 4 word of arguments into both the general
 429 ; and fp registers.
 430 call_dummy
 431         ldw -36(sp), arg0
 432         ldw -40(sp), arg1
 433         ldw -44(sp), arg2
 434         ldw -48(sp), arg3
 435         ldo -36(sp), r1
 436         fldws 0(0, r1), fr4
 437         fldds -4(0, r1), fr5
 438         fldws -8(0, r1), fr6
 439         fldds -12(0, r1), fr7
 440         ldil 0, r22                     ; target will be placed here.
 441         ldo 0(r22), r22
 442         ldsid (0,r22), r3
 443         ldil 0, r1                      ; _sr4export will be placed here.
 444         ldo 0(r1), r1
 445         ldsid (0,r1), r19
 446         combt,=,n r3, r19, text_space   ; If target is in data space, do a
 447         ble 0(sr5, r22)                 ; "normal" procedure call
 448         copy r31, r2
 449         break 4, 8
 450         mtsp r21, sr0
 451         ble,n 0(sr0, r22)
 452 text_space                              ; Otherwise, go through _sr4export,
 453         ble (sr4, r1)                   ; which will return back here.
 454         stw 31,-24(r30)
 455         break 4, 8
 456         mtsp r21, sr0
 457         ble,n 0(sr0, r22)
 458
 459    The dummy decides if the target is in text space or data space. If
 460    it's in data space, there's no problem because the target can
 461    return back to the dummy. However, if the target is in text space,
 462    the dummy calls the secret, undocumented routine _sr4export, which
 463    calls a function in text space and can return to any space. Instead
 464    of including fake instructions to represent saved registers, we
 465    know that the frame is associated with the call dummy and treat it
 466    specially. */
 467
 468 #define CALL_DUMMY {0x4BDA3FB9, 0x4BD93FB1, 0x4BD83FA9, 0x4BD73FA1,\
 469                     0x37C13FB9, 0x24201004, 0x2C391005, 0x24311006,\
 470                     0x2C291007, 0x22C00000, 0x36D60000, 0x02C010A3,\
 471                     0x20200000, 0x34210000, 0x002010b3, 0x82632022,\
 472                     0xe6c06000, 0x081f0242, 0x00010004, 0x00151820,\
 473                     0xe6c00002, 0xe4202000, 0x6bdf3fd1, 0x00010004,\
 474                     0x00151820, 0xe6c00002}
 475
 476 #define CALL_DUMMY_LENGTH 104
 477 #define CALL_DUMMY_START_OFFSET 0
 478
 479 /*
 480  * Insert the specified number of args and function address
 481  * into a call sequence of the above form stored at DUMMYNAME.
 482  *
 483  * On the hppa we need to call the stack dummy through $$dyncall.
 484  * Therefore our version of FIX_CALL_DUMMY takes an extra argument,
 485  * real_pc, which is the location where gdb should start up the
 486  * inferior to do the function call.
 487  */
 488
 489 #define FIX_CALL_DUMMY hppa_fix_call_dummy
 490
 491 CORE_ADDR hppa_fix_call_dummy();
 492
 493 #define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
 494     sp = hppa_push_arguments(nargs, args, sp, struct_return, struct_addr)
 495
 496 /* Symbol files have two symbol tables.  Rather than do this right,
 497    like the ELF symbol reading code, massive hackery was added
 498    to dbxread.c and partial-stab.h.  This flag turns on that
 499    hackery, which should all go away FIXME FIXME FIXME FIXME now.  */
 500
 501 #define GDB_TARGET_IS_HPPA
 502
 503 #define BELIEVE_PCC_PROMOTION 1
 504
 505 /*
 506  * Unwind table and descriptor.
 507  */
 508
 509 struct unwind_table_entry {
 510   unsigned int region_start;
 511   unsigned int region_end;
 512
 513   unsigned int Cannot_unwind         :  1;
 514   unsigned int Millicode             :  1;
 515   unsigned int Millicode_save_sr0    :  1;
 516   unsigned int Region_description    :  2;
 517   unsigned int reserverd1            :  1;
 518   unsigned int Entry_SR              :  1;
 519   unsigned int Entry_FR              :  4; /* number saved */
 520   unsigned int Entry_GR              :  5; /* number saved */
 521   unsigned int Args_stored           :  1;
 522   unsigned int Variable_Frame        :  1;
 523   unsigned int Separate_Package_Body :  1;
 524   unsigned int Frame_Extension_Millicode:1;
 525   unsigned int Stack_Overflow_Check  :  1;
 526   unsigned int Two_Instruction_SP_Increment:1;
 527   unsigned int Ada_Region            :  1;
 528   unsigned int reserved2             :  4;
 529   unsigned int Save_SP               :  1;
 530   unsigned int Save_RP               :  1;
 531   unsigned int Save_MRP_in_frame     :  1;
 532   unsigned int extn_ptr_defined      :  1;
 533   unsigned int Cleanup_defined       :  1;
 534
 535   unsigned int MPE_XL_interrupt_marker: 1;
 536   unsigned int HP_UX_interrupt_marker:  1;
 537   unsigned int Large_frame           :  1;
 538   unsigned int reserved4             :  2;
 539   unsigned int Total_frame_size      : 27;
 540 };
 541
 542 /* Info about the unwind table associated with an object file.  This is hung
 543    off of the objfile->obj_private pointer, and is allocated in the objfile's
 544    psymbol obstack.  This allows us to have unique unwind info for each
 545    executable and shared library that we are debugging.  */
 546
 547 struct obj_unwind_info {
 548   struct unwind_table_entry *table; /* Pointer to unwind info */
 549   struct unwind_table_entry *cache; /* Pointer to last entry we found */
 550   int last;                     /* Index of last entry */
 551 };
 552
 553 #define OBJ_UNWIND_INFO(obj) ((struct obj_unwind_info *)obj->obj_private)
 554
 555 extern CORE_ADDR target_read_pc PARAMS ((void));
 556 extern void target_write_pc PARAMS ((CORE_ADDR));
 557
 558 #define TARGET_READ_PC() target_read_pc ()
 559 #define TARGET_WRITE_PC(v) target_write_pc (v)