gdb/tm-merlin.h

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