gdb/config/ns32k/tm-umax.h

   1 /* Definitions to make GDB run on an encore under umax 4.2
   2    Copyright 1987, 1989, 1991, 1993 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 /* This is also included by tm-ns32km3.h, as well as being used by umax.  */
  21
  22 #define TARGET_BYTE_ORDER LITTLE_ENDIAN
  23
  24 /* Need to get function ends by adding this to epilogue address from .bf
  25    record, not using x_fsize field.  */
  26 #define FUNCTION_EPILOGUE_SIZE 4
  27
  28 /* Offset from address of function to start of its code.
  29    Zero on most machines.  */
  30
  31 #define FUNCTION_START_OFFSET 0
  32
  33 /* Advance PC across any function entry prologue instructions
  34    to reach some "real" code.  */
  35
  36 #define SKIP_PROLOGUE(pc)                               \
  37 { register unsigned char op = read_memory_integer (pc, 1);      \
  38   if (op == 0x82) { op = read_memory_integer (pc+2,1);  \
  39                     if ((op & 0x80) == 0) pc += 3;      \
  40                     else if ((op & 0xc0) == 0x80) pc += 4;      \
  41                     else pc += 6;                       \
  42                    }                                    \
  43 }
  44
  45 /* Immediately after a function call, return the saved pc.
  46    Can't always go through the frames for this because on some machines
  47    the new frame is not set up until the new function executes
  48    some instructions.  */
  49
  50 #define SAVED_PC_AFTER_CALL(frame) \
  51         read_memory_integer (read_register (SP_REGNUM), 4)
  52
  53 /* Address of end of stack space.  */
  54
  55 #ifndef STACK_END_ADDR
  56 #define STACK_END_ADDR (0xfffff000)
  57 #endif
  58
  59 /* Stack grows downward.  */
  60
  61 #define INNER_THAN <
  62
  63 /* Sequence of bytes for breakpoint instruction.  */
  64
  65 #define BREAKPOINT {0xf2}
  66
  67 /* Amount PC must be decremented by after a breakpoint.
  68    This is often the number of bytes in BREAKPOINT
  69    but not always.  */
  70
  71 #define DECR_PC_AFTER_BREAK 0
  72
  73 /* Nonzero if instruction at PC is a return instruction.  */
  74
  75 #define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 0x12)
  76
  77 #ifndef INVALID_FLOAT
  78 #ifndef NaN
  79 #include <nan.h>
  80 #endif NaN
  81
  82 /* Return 1 if P points to an invalid floating point value.  */
  83 /* Surely wrong for cross-debugging.  */
  84 #define INVALID_FLOAT(p, s) \
  85          ((s == sizeof (float))?        \
  86                 NaF (*(float *) p) :    \
  87                 NaD (*(double *) p))
  88 #endif /* INVALID_FLOAT */
  89
  90 /* Say how long (ordinary) registers are.  This is a piece of bogosity
  91    used in push_word and a few other places; REGISTER_RAW_SIZE is the
  92    real way to know how big a register is.  */
  93
  94 #define REGISTER_SIZE 4
  95
  96 /* Number of machine registers */
  97
  98 #define NUM_REGS                25
  99
 100 #define NUM_GENERAL_REGS        8
 101
 102 /* Initializer for an array of names of registers.
 103    There should be NUM_REGS strings in this initializer.  */
 104
 105 #define REGISTER_NAMES {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \
 106                         "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
 107                         "sp", "fp", "pc", "ps",                         \
 108                         "fsr",                                          \
 109                         "l0", "l1", "l2", "l3", "xx",                   \
 110                         }
 111
 112 /* Register numbers of various important registers.
 113    Note that some of these values are "real" register numbers,
 114    and correspond to the general registers of the machine,
 115    and some are "phony" register numbers which are too large
 116    to be actual register numbers as far as the user is concerned
 117    but do serve to get the desired values when passed to read_register.  */
 118
 119 #define R0_REGNUM 0             /* General register 0 */
 120 #define FP0_REGNUM 8            /* Floating point register 0 */
 121 #define SP_REGNUM 16            /* Contains address of top of stack */
 122 #define AP_REGNUM FP_REGNUM
 123 #define FP_REGNUM 17            /* Contains address of executing stack frame */
 124 #define PC_REGNUM 18            /* Contains program counter */
 125 #define PS_REGNUM 19            /* Contains processor status */
 126 #define FPS_REGNUM 20           /* Floating point status register */
 127 #define LP0_REGNUM 21           /* Double register 0 (same as FP0) */
 128
 129 /* Total amount of space needed to store our copies of the machine's
 130    register state, the array `registers'.  */
 131 #define REGISTER_BYTES \
 132   ((NUM_REGS - 4) * REGISTER_RAW_SIZE(R0_REGNUM) \
 133    + 4            * REGISTER_RAW_SIZE(LP0_REGNUM))
 134
 135 /* Index within `registers' of the first byte of the space for
 136    register N.  */
 137
 138 #define REGISTER_BYTE(N) ((N) >= LP0_REGNUM ? \
 139         LP0_REGNUM * 4 + ((N) - LP0_REGNUM) * 8 : (N) * 4)
 140
 141 /* Number of bytes of storage in the actual machine representation
 142    for register N.  On the 32000, all regs are 4 bytes
 143    except for the doubled floating registers. */
 144
 145 #define REGISTER_RAW_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4)
 146
 147 /* Number of bytes of storage in the program's representation
 148    for register N.  On the 32000, all regs are 4 bytes
 149    except for the doubled floating registers. */
 150
 151 #define REGISTER_VIRTUAL_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4)
 152
 153 /* Largest value REGISTER_RAW_SIZE can have.  */
 154
 155 #define MAX_REGISTER_RAW_SIZE 8
 156
 157 /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
 158
 159 #define MAX_REGISTER_VIRTUAL_SIZE 8
 160
 161 /* Return the GDB type object for the "standard" data type
 162    of data in register N.  */
 163
 164 #define REGISTER_VIRTUAL_TYPE(N) \
 165         (((N) < FP0_REGNUM) ?                           \
 166                 builtin_type_int :                      \
 167                 ((N) < FP0_REGNUM + 8) ?                \
 168                         builtin_type_float :            \
 169                         ((N) < LP0_REGNUM) ?            \
 170                                 builtin_type_int :      \
 171                                 builtin_type_double)
 172
 173 /* Store the address of the place in which to copy the structure the
 174    subroutine will return.  This is called from call_function.
 175
 176    On this machine this is a no-op, because gcc isn't used on it
 177    yet.  So this calling convention is not used. */
 178
 179 #define STORE_STRUCT_RETURN(ADDR, SP)
 180
 181 /* Extract from an array REGBUF containing the (raw) register state
 182    a function return value of type TYPE, and copy that, in virtual format,
 183    into VALBUF.  */
 184
 185 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 186   memcpy (VALBUF, REGBUF+REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 0), TYPE_LENGTH (TYPE))
 187
 188 /* Write into appropriate registers a function return value
 189    of type TYPE, given in virtual format.  */
 190
 191 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
 192   write_register_bytes (REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 0), VALBUF, TYPE_LENGTH (TYPE))
 193
 194 /* Extract from an array REGBUF containing the (raw) register state
 195    the address in which a function should return its structure value,
 196    as a CORE_ADDR (or an expression that can be used as one).  */
 197
 198 #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
 199 \f
 200 /* Describe the pointer in each stack frame to the previous stack frame
 201    (its caller).  */
 202
 203 /* FRAME_CHAIN takes a frame's nominal address
 204    and produces the frame's chain-pointer. */
 205
 206 /* In the case of the ns32000 series, the frame's nominal address is the FP
 207    value, and at that address is saved previous FP value as a 4-byte word.  */
 208
 209 #define FRAME_CHAIN(thisframe)  \
 210   (!inside_entry_file ((thisframe)->pc) ? \
 211    read_memory_integer ((thisframe)->frame, 4) :\
 212    0)
 213
 214 /* Define other aspects of the stack frame.  */
 215
 216 #define FRAME_SAVED_PC(FRAME) (read_memory_integer ((FRAME)->frame + 4, 4))
 217
 218 /* Compute base of arguments. */
 219
 220 #define FRAME_ARGS_ADDRESS(fi)  \
 221   ((ns32k_get_enter_addr ((fi)->pc) > 1) ? \
 222         ((fi)->frame) : (read_register (SP_REGNUM) - 4))
 223
 224 #define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame)
 225
 226 /* Get the address of the enter opcode for this function, if it is active.
 227    Returns positive address > 1 if pc is between enter/exit,
 228    1 if pc before enter or after exit, 0 otherwise. */
 229
 230 extern CORE_ADDR ns32k_get_enter_addr ();
 231
 232 /* Return number of args passed to a frame.
 233    Can return -1, meaning no way to tell.
 234    Encore's C compiler often reuses same area on stack for args,
 235    so this will often not work properly.  If the arg names
 236    are known, it's likely most of them will be printed. */
 237
 238 #define FRAME_NUM_ARGS(numargs, fi)                     \
 239 { CORE_ADDR     pc;                                     \
 240   CORE_ADDR     enter_addr;                             \
 241   unsigned int  insn;                                   \
 242   unsigned int  addr_mode;                              \
 243   int width;                                            \
 244                                                         \
 245   numargs = -1;                                         \
 246   enter_addr = ns32k_get_enter_addr ((fi)->pc);         \
 247   if (enter_addr > 0)                                   \
 248     {                                                   \
 249       pc = (enter_addr == 1) ?                          \
 250         SAVED_PC_AFTER_CALL (fi) :                      \
 251         FRAME_SAVED_PC (fi);                            \
 252       insn = read_memory_integer (pc,2);                \
 253       addr_mode = (insn >> 11) & 0x1f;                  \
 254       insn = insn & 0x7ff;                              \
 255       if ((insn & 0x7fc) == 0x57c &&                    \
 256                 addr_mode == 0x14) /* immediate */      \
 257         {                                               \
 258           if (insn == 0x57c) /* adjspb */               \
 259                 width = 1;                              \
 260           else if (insn == 0x57d) /* adjspw */          \
 261                 width = 2;                              \
 262           else if (insn == 0x57f) /* adjspd */          \
 263                 width = 4;                              \
 264           numargs = read_memory_integer (pc+2,width);   \
 265           if (width > 1)                                \
 266             flip_bytes (&numargs, width);               \
 267           numargs = - sign_extend (numargs, width*8) / 4;\
 268         }                                               \
 269     }                                                   \
 270 }
 271
 272 /* Return number of bytes at start of arglist that are not really args.  */
 273
 274 #define FRAME_ARGS_SKIP 8
 275
 276 /* Put here the code to store, into a struct frame_saved_regs,
 277    the addresses of the saved registers of frame described by FRAME_INFO.
 278    This includes special registers such as pc and fp saved in special
 279    ways in the stack frame.  sp is even more special:
 280    the address we return for it IS the sp for the next frame.  */
 281
 282 #define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)     \
 283 {                                                               \
 284   register int  regmask, regnum;                                \
 285   int           localcount;                                     \
 286   register CORE_ADDR    enter_addr;                             \
 287   register CORE_ADDR    next_addr;                              \
 288                                                                 \
 289   memset (&(frame_saved_regs), '\0', sizeof (frame_saved_regs));        \
 290   enter_addr = ns32k_get_enter_addr ((frame_info)->pc);         \
 291   if (enter_addr > 1)                                           \
 292     {                                                           \
 293       regmask = read_memory_integer (enter_addr+1, 1) & 0xff;   \
 294       localcount = ns32k_localcount (enter_addr);               \
 295       next_addr = (frame_info)->frame + localcount;             \
 296       for (regnum = 0; regnum < 8; regnum++, regmask >>= 1)     \
 297         (frame_saved_regs).regs[regnum] = (regmask & 1) ?       \
 298                                           (next_addr -= 4) : 0; \
 299       (frame_saved_regs).regs[SP_REGNUM] = (frame_info)->frame + 4;\
 300       (frame_saved_regs).regs[PC_REGNUM] = (frame_info)->frame + 4;\
 301       (frame_saved_regs).regs[FP_REGNUM] =                      \
 302                   (read_memory_integer ((frame_info)->frame, 4));\
 303     }                                                           \
 304   else if (enter_addr == 1)                                     \
 305     {                                                           \
 306       CORE_ADDR sp = read_register (SP_REGNUM);                 \
 307       (frame_saved_regs).regs[PC_REGNUM] = sp;                  \
 308       (frame_saved_regs).regs[SP_REGNUM] = sp + 4;              \
 309     }                                                           \
 310 }
 311 \f
 312 /* Things needed for making the inferior call functions.  */
 313
 314 /* Push an empty stack frame, to record the current PC, etc.  */
 315
 316 #define PUSH_DUMMY_FRAME \
 317 { register CORE_ADDR sp = read_register (SP_REGNUM);\
 318   register int regnum;                              \
 319   sp = push_word (sp, read_register (PC_REGNUM));   \
 320   sp = push_word (sp, read_register (FP_REGNUM));   \
 321   write_register (FP_REGNUM, sp);                   \
 322   for (regnum = 0; regnum < 8; regnum++)  \
 323     sp = push_word (sp, read_register (regnum));    \
 324   write_register (SP_REGNUM, sp);                       \
 325 }
 326
 327 /* Discard from the stack the innermost frame, restoring all registers.  */
 328
 329 #define POP_FRAME  \
 330 { register FRAME frame = get_current_frame ();                   \
 331   register CORE_ADDR fp;                                         \
 332   register int regnum;                                           \
 333   struct frame_saved_regs fsr;                                   \
 334   struct frame_info *fi;                                                 \
 335   fi = get_frame_info (frame);                                   \
 336   fp = fi->frame;                                                \
 337   get_frame_saved_regs (fi, &fsr);                               \
 338   for (regnum = 0; regnum < 8; regnum++)                         \
 339     if (fsr.regs[regnum])                                        \
 340       write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
 341   write_register (FP_REGNUM, read_memory_integer (fp, 4));       \
 342   write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));   \
 343   write_register (SP_REGNUM, fp + 8);                            \
 344   flush_cached_frames ();                                        \
 345   set_current_frame (create_new_frame (read_register (FP_REGNUM),\
 346                                        read_pc ())); }
 347
 348 /* This sequence of words is the instructions
 349      enter      0xff,0          82 ff 00
 350      jsr        @0x00010203     7f ae c0 01 02 03
 351      adjspd     0x69696969      7f a5 01 02 03 04
 352      bpt                        f2
 353    Note this is 16 bytes.  */
 354
 355 #define CALL_DUMMY { 0x7f00ff82, 0x0201c0ae, 0x01a57f03, 0xf2040302 }
 356
 357 #define CALL_DUMMY_START_OFFSET 3
 358 #define CALL_DUMMY_LENGTH       16
 359 #define CALL_DUMMY_ADDR         5
 360 #define CALL_DUMMY_NARGS        11
 361
 362 /* Insert the specified number of args and function address
 363    into a call sequence of the above form stored at DUMMYNAME.  */
 364
 365 #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p)            \
 366 {                                                               \
 367         int     flipped;                                        \
 368         flipped = fun | 0xc0000000;                             \
 369         flip_bytes (&flipped, 4);                               \
 370         *((int *) (((char *) dummyname)+CALL_DUMMY_ADDR)) = flipped;    \
 371         flipped = - nargs * 4;                                  \
 372         flip_bytes (&flipped, 4);                               \
 373         *((int *) (((char *) dummyname)+CALL_DUMMY_NARGS)) = flipped;   \
 374 }