gdb/tm-convex.h

   1 /* Definitions to make GDB run on Convex Unix (4bsd)
   2    Copyright (C) 1989 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #define TARGET_BYTE_ORDER BIG_ENDIAN
  21
  22 /* I don't know if this will work for cross-debugging, even if you do get
  23    the right files.  */
  24 /* Include certain files for dbxread.c  */
  25 #include <convex/filehdr.h>
  26 #include <convex/opthdr.h>
  27 #include <convex/scnhdr.h>
  28 #include <nlist.h>
  29
  30 /* Define this if the C compiler puts an underscore at the front
  31    of external names before giving them to the linker.  */
  32
  33 #define NAMES_HAVE_UNDERSCORE
  34
  35 /* Debugger information will be in DBX format.  */
  36
  37 #define READ_DBX_FORMAT
  38
  39 /* There is come problem with the debugging symbols generated by the
  40    compiler such that the debugging symbol for the first line of a
  41    function overlap with the function prologue.  */
  42 #define PROLOGUE_FIRSTLINE_OVERLAP
  43
  44 /* When convex pcc says CHAR or SHORT, it provides the correct address.  */
  45
  46 #define BELIEVE_PCC_PROMOTION 1
  47
  48 /* Symbol types to ignore.  */
  49 /* 0xc4 is N_MONPT.  Use the numeric value for the benefit of people
  50    with (rather) old OS's.  */
  51 #define IGNORE_SYMBOL(TYPE) \
  52     (((TYPE) & ~N_EXT) == N_TBSS       \
  53      || ((TYPE) & ~N_EXT) == N_TDATA   \
  54      || ((TYPE) & ~N_EXT) == 0xc4)
  55
  56 /* Offset from address of function to start of its code.
  57    Zero on most machines.  */
  58
  59 #define FUNCTION_START_OFFSET 0
  60
  61 /* Advance PC across any function entry prologue instructions
  62    to reach some "real" code.
  63    Convex prolog is:
  64        [sub.w #-,sp]            in one of 3 possible sizes
  65        [mov psw,-               fc/vc main program prolog
  66         and #-,-                  (skip it because the "mov psw" saves the
  67         mov -,psw]                 T bit, so continue gets a surprise trap)
  68        [and #-,sp]              fc/vc O2 main program prolog
  69        [ld.- -(ap),-]           pcc/gcc register arg loads
  70 */
  71
  72 #define SKIP_PROLOGUE(pc)  \
  73 { int op, ix;                                                           \
  74   op = read_memory_integer (pc, 2);                                     \
  75   if ((op & 0xffc7) == 0x5ac0) pc += 2;                                 \
  76   else if (op == 0x1580) pc += 4;                                       \
  77   else if (op == 0x15c0) pc += 6;                                       \
  78   if ((read_memory_integer (pc, 2) & 0xfff8) == 0x7c40                  \
  79       && (read_memory_integer (pc + 2, 2) & 0xfff8) == 0x1240           \
  80       && (read_memory_integer (pc + 8, 2) & 0xfff8) == 0x7c48)          \
  81     pc += 10;                                                           \
  82   if (read_memory_integer (pc, 2) == 0x1240) pc += 6;                   \
  83   for (;;) {                                                            \
  84     op = read_memory_integer (pc, 2);                                   \
  85     ix = (op >> 3) & 7;                                                 \
  86     if (ix != 6) break;                                                 \
  87     if ((op & 0xfcc0) == 0x3000) pc += 4;                               \
  88     else if ((op & 0xfcc0) == 0x3040) pc += 6;                          \
  89     else if ((op & 0xfcc0) == 0x2800) pc += 4;                          \
  90     else if ((op & 0xfcc0) == 0x2840) pc += 6;                          \
  91     else break;}}
  92
  93 /* Immediately after a function call, return the saved pc.
  94    (ignore frame and return *$sp so we can handle both calls and callq) */
  95
  96 #define SAVED_PC_AFTER_CALL(frame) \
  97     read_memory_integer (read_register (SP_REGNUM), 4)
  98
  99 /* Address of end of stack space.
 100    This is ((USRSTACK + 0xfff) & -0x1000)) from <convex/vmparam.h> but
 101    that expression depends on the kernel version; instead, fetch a
 102    page-zero pointer and get it from that.  This will be invalid if
 103    they ever change the way bkpt signals are delivered.  */
 104
 105 #define STACK_END_ADDR (0xfffff000 & *(unsigned *) 0x80000050)
 106
 107 /* User-mode traps push an extended rtn block,
 108    then fault with one of the following PCs */
 109
 110 #define is_trace_pc(pc)  ((unsigned) ((pc) - (*(int *) 0x80000040)) <= 4)
 111 #define is_arith_pc(pc)  ((unsigned) ((pc) - (*(int *) 0x80000044)) <= 4)
 112 #define is_break_pc(pc)  ((unsigned) ((pc) - (*(int *) 0x80000050)) <= 4)
 113
 114 /* We need to manipulate trap bits in the psw */
 115
 116 #define PSW_TRAP_FLAGS  0x69670000
 117 #define PSW_T_BIT       0x08000000
 118 #define PSW_S_BIT       0x01000000
 119
 120 /* Stack grows downward.  */
 121
 122 #define INNER_THAN <
 123
 124 /* Sequence of bytes for breakpoint instruction. (bkpt)  */
 125
 126 #define BREAKPOINT {0x7d,0x50}
 127
 128 /* Amount PC must be decremented by after a breakpoint.
 129    This is often the number of bytes in BREAKPOINT but not always.
 130    (The break PC needs to be decremented by 2, but we do it when the
 131    break frame is recognized and popped.  That way gdb can tell breaks
 132    from trace traps with certainty.) */
 133
 134 #define DECR_PC_AFTER_BREAK 0
 135
 136 /* Nonzero if instruction at PC is a return instruction. (rtn or rtnq) */
 137
 138 #define ABOUT_TO_RETURN(pc) \
 139     ((read_memory_integer (pc, 2) & 0xffe0) == 0x7c80)
 140
 141 /* Return 1 if P points to an invalid floating point value. */
 142
 143 #define INVALID_FLOAT(p,len)   0
 144
 145 /* Say how long (ordinary) registers are.  */
 146
 147 #define REGISTER_TYPE long long
 148
 149 /* Number of machine registers */
 150
 151 #define NUM_REGS 26
 152
 153 /* Initializer for an array of names of registers.
 154    There should be NUM_REGS strings in this initializer.  */
 155
 156 #define REGISTER_NAMES {"pc","psw","fp","ap","a5","a4","a3","a2","a1","sp",\
 157                         "s7","s6","s5","s4","s3","s2","s1","s0",\
 158                         "S7","S6","S5","S4","S3","S2","S1","S0"}
 159
 160 /* Register numbers of various important registers.
 161    Note that some of these values are "real" register numbers,
 162    and correspond to the general registers of the machine,
 163    and some are "phony" register numbers which are too large
 164    to be actual register numbers as far as the user is concerned
 165    but do serve to get the desired values when passed to read_register.  */
 166
 167 #define S0_REGNUM 25            /* the real S regs */
 168 #define S7_REGNUM 18
 169 #define s0_REGNUM 17            /* low-order halves of S regs */
 170 #define s7_REGNUM 10
 171 #define SP_REGNUM 9             /* A regs */
 172 #define A1_REGNUM 8
 173 #define A5_REGNUM 4
 174 #define AP_REGNUM 3
 175 #define FP_REGNUM 2             /* Contains address of executing stack frame */
 176 #define PS_REGNUM 1             /* Contains processor status */
 177 #define PC_REGNUM 0             /* Contains program counter */
 178
 179 /* convert dbx stab register number (from `r' declaration) to a gdb REGNUM */
 180
 181 #define STAB_REG_TO_REGNUM(value) \
 182       ((value) < 8 ? S0_REGNUM - (value) : SP_REGNUM - ((value) - 8))
 183
 184 /* Vector register numbers, not handled as ordinary regs.
 185    They are treated as convenience variables whose values are read
 186    from the inferior when needed.  */
 187
 188 #define V0_REGNUM 0
 189 #define V7_REGNUM 7
 190 #define VM_REGNUM 8
 191 #define VS_REGNUM 9
 192 #define VL_REGNUM 10
 193
 194 /* Total amount of space needed to store our copies of the machine's
 195    register state, the array `registers'.  */
 196 #define REGISTER_BYTES (4*10 + 8*8)
 197
 198 /* Index within `registers' of the first byte of the space for
 199    register N.
 200    NB: must match structure of struct syscall_context for correct operation */
 201
 202 #define REGISTER_BYTE(N) ((N) < s7_REGNUM ? 4*(N) : \
 203                           (N) < S7_REGNUM ? 44 + 8 * ((N)-s7_REGNUM) : \
 204                                             40 + 8 * ((N)-S7_REGNUM))
 205
 206 /* Number of bytes of storage in the actual machine representation
 207    for register N. */
 208
 209 #define REGISTER_RAW_SIZE(N) ((N) < S7_REGNUM ? 4 : 8)
 210
 211 /* Number of bytes of storage in the program's representation
 212    for register N.   */
 213
 214 #define REGISTER_VIRTUAL_SIZE(N) REGISTER_RAW_SIZE(N)
 215
 216 /* Largest value REGISTER_RAW_SIZE can have.  */
 217
 218 #define MAX_REGISTER_RAW_SIZE 8
 219
 220 /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
 221
 222 #define MAX_REGISTER_VIRTUAL_SIZE 8
 223
 224 /* Nonzero if register N requires conversion
 225    from raw format to virtual format.  */
 226
 227 #define REGISTER_CONVERTIBLE(N) 0
 228
 229 /* Convert data from raw format for register REGNUM
 230    to virtual format for register REGNUM.  */
 231
 232 #define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)     \
 233    bcopy ((FROM), (TO), REGISTER_RAW_SIZE (REGNUM));
 234
 235 /* Convert data from virtual format for register REGNUM
 236    to raw format for register REGNUM.  */
 237
 238 #define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
 239   bcopy ((FROM), (TO), REGISTER_RAW_SIZE (REGNUM));
 240
 241 /* Return the GDB type object for the "standard" data type
 242    of data in register N.  */
 243
 244 #define REGISTER_VIRTUAL_TYPE(N) \
 245    ((N) < S7_REGNUM ? builtin_type_int : builtin_type_long_long)
 246
 247 /* Store the address of the place in which to copy the structure the
 248    subroutine will return.  This is called from call_function. */
 249
 250 #define STORE_STRUCT_RETURN(ADDR, SP) \
 251   { write_register (A1_REGNUM, (ADDR)); }
 252
 253 /* Extract from an array REGBUF containing the (raw) register state
 254    a function return value of type TYPE, and copy that, in virtual format,
 255    into VALBUF.  */
 256
 257 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 258   bcopy (&((char *) REGBUF) [REGISTER_BYTE (S0_REGNUM) + \
 259                              8 - TYPE_LENGTH (TYPE)],\
 260          VALBUF, TYPE_LENGTH (TYPE))
 261
 262 /* Write into appropriate registers a function return value
 263    of type TYPE, given in virtual format.  */
 264
 265 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
 266     write_register_bytes (REGISTER_BYTE (S0_REGNUM), VALBUF, 8)
 267
 268 /* Extract from an array REGBUF containing the (raw) register state
 269    the address in which a function should return its structure value,
 270    as a CORE_ADDR (or an expression that can be used as one).  */
 271
 272 #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
 273     (*(int *) & ((char *) REGBUF) [REGISTER_BYTE (s0_REGNUM)])
 274
 275 /* Define trapped internal variable hooks to read and write
 276    vector and communication registers.  */
 277
 278 #define IS_TRAPPED_INTERNALVAR is_trapped_internalvar
 279 #define VALUE_OF_TRAPPED_INTERNALVAR value_of_trapped_internalvar
 280 #define SET_TRAPPED_INTERNALVAR set_trapped_internalvar
 281
 282 extern struct value *value_of_trapped_internalvar ();
 283
 284 /* Hooks to read data from soff exec and core files,
 285    and to describe the files.  */
 286
 287 #define XFER_CORE_FILE
 288 #define FILES_INFO_HOOK print_maps
 289
 290 /* Hook to call to print a typeless integer value, normally printed in decimal.
 291    For convex, use hex instead if the number looks like an address.  */
 292
 293 #define PRINT_TYPELESS_INTEGER decout
 294
 295 /* For the native compiler, variables for a particular lexical context
 296    are listed after the beginning LBRAC instead of before in the
 297    executables list of symbols.  Using "gcc_compiled." to distinguish
 298    between GCC and native compiler doesn't work on Convex because the
 299    linker sorts the symbols to put "gcc_compiled." in the wrong place.
 300    desc is nonzero for native, zero for gcc.   */
 301 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) (desc != 0)
 302
 303 /* Pcc occaisionally puts an SO where there should be an SOL.   */
 304 #define PCC_SOL_BROKEN
 305
 306 /* Cannot execute with pc on the stack.  */
 307 #define CANNOT_EXECUTE_STACK
 308 \f
 309 /* Describe the pointer in each stack frame to the previous stack frame
 310    (its caller).  */
 311
 312 /* FRAME_CHAIN takes a frame_info with a frame's nominal address in fi->frame,
 313    and produces the frame's chain-pointer.
 314
 315    FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
 316    and produces the nominal address of the caller frame.
 317
 318    However, if FRAME_CHAIN_VALID returns zero,
 319    it means the given frame is the outermost one and has no caller.
 320    In that case, FRAME_CHAIN_COMBINE is not used.  */
 321
 322 /* (caller fp is saved at 8(fp)) */
 323
 324 #define FRAME_CHAIN(fi)   (read_memory_integer ((fi)->frame + 8, 4))
 325
 326 #define FRAME_CHAIN_VALID(chain, thisframe) \
 327   (chain != 0 && (outside_startup_file (FRAME_SAVED_PC (thisframe))))
 328
 329 #define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
 330
 331 /* Define other aspects of the stack frame.  */
 332
 333 /* A macro that tells us whether the function invocation represented
 334    by FI does not have a frame on the stack associated with it.  If it
 335    does not, FRAMELESS is set to 1, else 0.
 336    On convex, check at the return address for `callq' -- if so, frameless,
 337    otherwise, not.  */
 338
 339 #define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
 340 {                                                                       \
 341   extern CORE_ADDR text_start, text_end;                                \
 342   CORE_ADDR call_addr = SAVED_PC_AFTER_CALL (FI);                       \
 343   (FRAMELESS) = (call_addr >= text_start && call_addr < text_end        \
 344                  && read_memory_integer (call_addr - 6, 1) == 0x22);    \
 345 }
 346
 347 #define FRAME_SAVED_PC(fi) (read_memory_integer ((fi)->frame, 4))
 348
 349 #define FRAME_ARGS_ADDRESS(fi) (read_memory_integer ((fi)->frame + 12, 4))
 350
 351 #define FRAME_LOCALS_ADDRESS(fi) (fi)->frame
 352
 353 /* Return number of args passed to a frame.
 354    Can return -1, meaning no way to tell.  */
 355
 356 #define FRAME_NUM_ARGS(numargs, fi)  \
 357 { numargs = read_memory_integer (FRAME_ARGS_ADDRESS (fi) - 4, 4); \
 358   if (numargs < 0 || numargs >= 256) numargs = -1;}
 359
 360 /* Return number of bytes at start of arglist that are not really args.  */
 361
 362 #define FRAME_ARGS_SKIP 0
 363
 364 /* Put here the code to store, into a struct frame_saved_regs,
 365    the addresses of the saved registers of frame described by FRAME_INFO.
 366    This includes special registers such as pc and fp saved in special
 367    ways in the stack frame.  sp is even more special:
 368    the address we return for it IS the sp for the next frame.  */
 369
 370 /* Normal (short) frames save only PC, FP, (callee's) AP.  To reasonably
 371    handle gcc and pcc register variables, scan the code following the
 372    call for the instructions the compiler inserts to reload register
 373    variables from stack slots and record the stack slots as the saved
 374    locations of those registers.  This will occasionally identify some
 375    random load as a saved register; this is harmless.  vc does not
 376    declare its register allocation actions in the stabs.  */
 377
 378 #define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)             \
 379 { register int regnum;                                                  \
 380   register int frame_length =   /* 3 short, 2 long, 1 extended, 0 context */\
 381       (read_memory_integer ((frame_info)->frame + 4, 4) >> 25) & 3;     \
 382   register CORE_ADDR frame_fp =                                         \
 383       read_memory_integer ((frame_info)->frame + 8, 4);                 \
 384   register CORE_ADDR next_addr;                                         \
 385   bzero (&frame_saved_regs, sizeof frame_saved_regs);                   \
 386   (frame_saved_regs).regs[PC_REGNUM] = (frame_info)->frame + 0;         \
 387   (frame_saved_regs).regs[PS_REGNUM] = (frame_info)->frame + 4;         \
 388   (frame_saved_regs).regs[FP_REGNUM] = (frame_info)->frame + 8;         \
 389   (frame_saved_regs).regs[AP_REGNUM] = frame_fp + 12;                   \
 390   next_addr = (frame_info)->frame + 12;                                 \
 391   if (frame_length < 3)                                                 \
 392     for (regnum = A5_REGNUM; regnum < SP_REGNUM; ++regnum)              \
 393       (frame_saved_regs).regs[regnum] = (next_addr += 4);               \
 394   if (frame_length < 2)                                                 \
 395     (frame_saved_regs).regs[SP_REGNUM] = (next_addr += 4);              \
 396   next_addr -= 4;                                                       \
 397   if (frame_length < 3)                                                 \
 398     for (regnum = S7_REGNUM; regnum < S0_REGNUM; ++regnum)              \
 399       (frame_saved_regs).regs[regnum] = (next_addr += 8);               \
 400   if (frame_length < 2)                                                 \
 401     (frame_saved_regs).regs[S0_REGNUM] = (next_addr += 8);              \
 402   else                                                                  \
 403     (frame_saved_regs).regs[SP_REGNUM] = next_addr + 8;                 \
 404   if (frame_length == 3) {                                              \
 405     CORE_ADDR pc = read_memory_integer ((frame_info)->frame, 4);        \
 406     int op, ix, disp;                                                   \
 407     op = read_memory_integer (pc, 2);                                   \
 408     if ((op & 0xffc7) == 0x1480) pc += 4;       /* add.w #-,sp */       \
 409     else if ((op & 0xffc7) == 0x58c0) pc += 2;  /* add.w #-,sp */       \
 410     op = read_memory_integer (pc, 2);                                   \
 411     if ((op & 0xffc7) == 0x2a06) pc += 4;       /* ld.w -,ap */         \
 412     for (;;) {                                                          \
 413       op = read_memory_integer (pc, 2);                                 \
 414       ix = (op >> 3) & 7;                                               \
 415       if ((op & 0xfcc0) == 0x2800) {            /* ld.- -,ak */         \
 416         regnum = SP_REGNUM - (op & 7);                                  \
 417         disp = read_memory_integer (pc + 2, 2);                         \
 418         pc += 4;}                                                       \
 419       else if ((op & 0xfcc0) == 0x2840) {       /* ld.- -,ak */         \
 420         regnum = SP_REGNUM - (op & 7);                                  \
 421         disp = read_memory_integer (pc + 2, 4);                         \
 422         pc += 6;}                                                       \
 423       if ((op & 0xfcc0) == 0x3000) {            /* ld.- -,sk */         \
 424         regnum = S0_REGNUM - (op & 7);                                  \
 425         disp = read_memory_integer (pc + 2, 2);                         \
 426         pc += 4;}                                                       \
 427       else if ((op & 0xfcc0) == 0x3040) {       /* ld.- -,sk */         \
 428         regnum = S0_REGNUM - (op & 7);                                  \
 429         disp = read_memory_integer (pc + 2, 4);                         \
 430         pc += 6;}                                                       \
 431       else if ((op & 0xff00) == 0x7100) {       /* br crossjump */      \
 432         pc += 2 * (char) op;                                            \
 433         continue;}                                                      \
 434       else if (op == 0x0140) {                  /* jmp crossjump */     \
 435         pc = read_memory_integer (pc + 2, 4);                           \
 436         continue;}                                                      \
 437       else break;                                                       \
 438       if ((frame_saved_regs).regs[regnum])                              \
 439         break;                                                          \
 440       if (ix == 7) disp += frame_fp;                                    \
 441       else if (ix == 6) disp += read_memory_integer (frame_fp + 12, 4); \
 442       else if (ix != 0) break;                                          \
 443       (frame_saved_regs).regs[regnum] =                                 \
 444         disp - 8 + (1 << ((op >> 8) & 3));                              \
 445       if (regnum >= S7_REGNUM)                                          \
 446         (frame_saved_regs).regs[regnum - S0_REGNUM + s0_REGNUM] =       \
 447           disp - 4 + (1 << ((op >> 8) & 3));                            \
 448     }                                                                   \
 449   }                                                                     \
 450 }
 451 \f
 452 /* Things needed for making the inferior call functions.  */
 453
 454 /* Push an empty stack frame, to record the current PC, etc.  */
 455
 456 #define PUSH_DUMMY_FRAME \
 457 { register CORE_ADDR sp = read_register (SP_REGNUM);                    \
 458   register int regnum;                                                  \
 459   char buf[8];                                                          \
 460   long word;                                                            \
 461   for (regnum = S0_REGNUM; regnum >= S7_REGNUM; --regnum) {             \
 462     read_register_bytes (REGISTER_BYTE (regnum), buf, 8);               \
 463     sp = push_bytes (sp, buf, 8);}                                      \
 464   for (regnum = SP_REGNUM; regnum >= FP_REGNUM; --regnum) {             \
 465     word = read_register (regnum);                                      \
 466     sp = push_bytes (sp, &word, 4);}                                    \
 467   word = (read_register (PS_REGNUM) &~ (3<<25)) | (1<<25);              \
 468   sp = push_bytes (sp, &word, 4);                                       \
 469   word = read_register (PC_REGNUM);                                     \
 470   sp = push_bytes (sp, &word, 4);                                       \
 471   write_register (SP_REGNUM, sp);                                       \
 472   write_register (FP_REGNUM, sp);                                       \
 473   write_register (AP_REGNUM, sp);}
 474
 475 /* Discard from the stack the innermost frame, restoring all registers.  */
 476
 477 #define POP_FRAME  do {\
 478   register CORE_ADDR fp = read_register (FP_REGNUM);        \
 479   register int regnum;                                      \
 480   register int frame_length =   /* 3 short, 2 long, 1 extended, 0 context */ \
 481       (read_memory_integer (fp + 4, 4) >> 25) & 3;          \
 482   char buf[8];                                              \
 483   write_register (PC_REGNUM, read_memory_integer (fp, 4));  \
 484   write_register (PS_REGNUM, read_memory_integer (fp += 4, 4));  \
 485   write_register (FP_REGNUM, read_memory_integer (fp += 4, 4));  \
 486   write_register (AP_REGNUM, read_memory_integer (fp += 4, 4));  \
 487   if (frame_length < 3)                                      \
 488     for (regnum = A5_REGNUM; regnum < SP_REGNUM; ++regnum)   \
 489       write_register (regnum, read_memory_integer (fp += 4, 4)); \
 490   if (frame_length < 2)                                      \
 491     write_register (SP_REGNUM, read_memory_integer (fp += 4, 4)); \
 492   fp -= 4;                                                      \
 493   if (frame_length < 3)                                         \
 494     for (regnum = S7_REGNUM; regnum < S0_REGNUM; ++regnum) {    \
 495       read_memory (fp += 8, buf, 8);                            \
 496       write_register_bytes (REGISTER_BYTE (regnum), buf, 8);}   \
 497   if (frame_length < 2) {                                       \
 498     read_memory (fp += 8, buf, 8);                              \
 499     write_register_bytes (REGISTER_BYTE (regnum), buf, 8);}     \
 500   else write_register (SP_REGNUM, fp + 8);                      \
 501   flush_cached_frames ();                                       \
 502   set_current_frame (create_new_frame (read_register (FP_REGNUM), \
 503                                        read_pc ()));            \
 504 } while (0)
 505
 506 /* This sequence of words is the instructions
 507      mov sp,ap
 508      pshea 69696969
 509      calls 32323232
 510      bkpt
 511    Note this is 16 bytes.  */
 512
 513 #define CALL_DUMMY {0x50860d4069696969LL,0x2140323232327d50LL}
 514
 515 #define CALL_DUMMY_LENGTH 16
 516
 517 #define CALL_DUMMY_START_OFFSET 0
 518
 519 /* Insert the specified number of args and function address
 520    into a call sequence of the above form stored at DUMMYNAME.  */
 521
 522 #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p)   \
 523 { *(int *)((char *) dummyname + 4) = nargs;     \
 524   *(int *)((char *) dummyname + 10) = fun; }
 525 \f
 526 /* Defs to read soff symbol tables, see dbxread.c */
 527
 528 #define NUMBER_OF_SYMBOLS    ((long) opthdr.o_nsyms)
 529 #define STRING_TABLE_OFFSET  ((long) filehdr.h_strptr)
 530 #define SYMBOL_TABLE_OFFSET  ((long) opthdr.o_symptr)
 531 #define STRING_TABLE_SIZE    ((long) filehdr.h_strsiz)
 532 #define SIZE_OF_TEXT_SEGMENT ((long) txthdr.s_size)
 533 #define ENTRY_POINT          ((long) opthdr.o_entry)
 534
 535 #define READ_STRING_TABLE_SIZE(BUFFER) \
 536     (BUFFER = STRING_TABLE_SIZE)
 537
 538 #define DECLARE_FILE_HEADERS \
 539   FILEHDR filehdr;                                                      \
 540   OPTHDR opthdr;                                                        \
 541   SCNHDR txthdr
 542
 543 #define READ_FILE_HEADERS(DESC,NAME) \
 544 {                                                                       \
 545   int n;                                                                \
 546   val = myread (DESC, &filehdr, sizeof filehdr);                        \
 547   if (val < 0)                                                          \
 548     perror_with_name (NAME);                                            \
 549   if (! IS_SOFF_MAGIC (filehdr.h_magic))                                \
 550     error ("%s: not an executable file.", NAME);                        \
 551   lseek (DESC, 0L, 0);                                                  \
 552   if (myread (DESC, &filehdr, sizeof filehdr) < 0)                      \
 553     perror_with_name (NAME);                                            \
 554   if (myread (DESC, &opthdr, filehdr.h_opthdr) <= 0)                    \
 555     perror_with_name (NAME);                                            \
 556   for (n = 0; n < filehdr.h_nscns; n++)                                 \
 557     {                                                                   \
 558       if (myread (DESC, &txthdr, sizeof txthdr) < 0)                    \
 559         perror_with_name (NAME);                                        \
 560       if ((txthdr.s_flags & S_TYPMASK) == S_TEXT)                       \
 561         break;                                                          \
 562     }                                                                   \
 563 }