gdb/config/d30v/tm-d30v.h

   1 /* Target-specific definition for the Mitsubishi D30V
   2    Copyright (C) 1997 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #ifndef TM_D30V_H
  21 #define TM_D30V_H
  22
  23 /* Define the bit, byte, and word ordering of the machine.  */
  24
  25 #define TARGET_BYTE_ORDER       BIG_ENDIAN
  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 /* these are the addresses the D30V-EVA board maps data */
  33 /* and instruction memory to. */
  34
  35 #define DMEM_START      0x20000000
  36 #define IMEM_START      0x00000000 /* was 0x10000000 */
  37 #define STACK_START     0x20007ffe
  38
  39 #ifdef __STDC__         /* Forward decls for prototypes */
  40 struct frame_info;
  41 struct frame_saved_regs;
  42 struct type;
  43 struct value;
  44 #endif
  45
  46 /* Advance PC across any function entry prologue instructions
  47    to reach some "real" code.  */
  48
  49 extern CORE_ADDR d30v_skip_prologue ();
  50 #define SKIP_PROLOGUE(ip) \
  51     {(ip) = d30v_skip_prologue(ip);}
  52
  53
  54 /* Stack grows downward.  */
  55 #define INNER_THAN(lhs,rhs) ((lhs) < (rhs))
  56
  57 /* for a breakpoint, use "dbt || nop" */
  58 #define BREAKPOINT {0x00, 0xb0, 0x00, 0x00,\
  59                     0x00, 0xf0, 0x00, 0x00}
  60
  61 /* If your kernel resets the pc after the trap happens you may need to
  62    define this before including this file.  */
  63 #define DECR_PC_AFTER_BREAK 0
  64
  65 #define REGISTER_NAMES \
  66 {   "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",      \
  67     "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15",     \
  68     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",     \
  69     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",     \
  70     "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39",     \
  71     "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47",     \
  72     "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55",     \
  73     "r56", "r57", "r58", "r59", "r60", "r61", "r62", "r63",     \
  74     "spi", "spu", \
  75     "psw", "bpsw", "pc", "bpc", "dpsw", "dpc", "cr6", "rpt_c",  \
  76     "rpt_s", "rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "eit_vb",\
  77     "int_s", "int_m", "a0", "a1" \
  78     }
  79
  80 #define NUM_REGS 86
  81
  82 /* Register numbers of various important registers.
  83    Note that some of these values are "real" register numbers,
  84    and correspond to the general registers of the machine,
  85    and some are "phony" register numbers which are too large
  86    to be actual register numbers as far as the user is concerned
  87    but do serve to get the desired values when passed to read_register.  */
  88
  89 #define R0_REGNUM       0
  90 #define FP_REGNUM       61
  91 #define LR_REGNUM       62
  92 #define SP_REGNUM       63
  93 #define SPI_REGNUM      64      /* Interrupt stack pointer */
  94 #define SPU_REGNUM      65      /* User stack pointer */
  95 #define CREGS_START     66
  96
  97 #define PSW_REGNUM      (CREGS_START + 0) /* psw, bpsw, or dpsw??? */
  98 #define     PSW_SM (((unsigned long)0x80000000) >> 0)   /* Stack mode: 0/SPI */
  99                                                         /*             1/SPU */
 100 #define     PSW_EA (((unsigned long)0x80000000) >> 2)   /* Execution status */
 101 #define     PSW_DB (((unsigned long)0x80000000) >> 3)   /* Debug mode */
 102 #define     PSW_DS (((unsigned long)0x80000000) >> 4)   /* Debug EIT status */
 103 #define     PSW_IE (((unsigned long)0x80000000) >> 5)   /* Interrupt enable */
 104 #define     PSW_RP (((unsigned long)0x80000000) >> 6)   /* Repeat enable */
 105 #define     PSW_MD (((unsigned long)0x80000000) >> 7)   /* Modulo enable */
 106 #define     PSW_F0 (((unsigned long)0x80000000) >> 17)  /* F0 flag */
 107 #define     PSW_F1 (((unsigned long)0x80000000) >> 19)  /* F1 flag */
 108 #define     PSW_F2 (((unsigned long)0x80000000) >> 21)  /* F2 flag */
 109 #define     PSW_F3 (((unsigned long)0x80000000) >> 23)  /* F3 flag */
 110 #define     PSW_S  (((unsigned long)0x80000000) >> 25)  /* Saturation flag */
 111 #define     PSW_V  (((unsigned long)0x80000000) >> 27)  /* Overflow flag */
 112 #define     PSW_VA (((unsigned long)0x80000000) >> 29)  /* Accum. overflow */
 113 #define     PSW_C  (((unsigned long)0x80000000) >> 31)  /* Carry/Borrow flag */
 114
 115 #define BPSW_REGNUM     (CREGS_START + 1) /* Backup PSW (on interrupt) */
 116 #define PC_REGNUM       (CREGS_START + 2) /* pc, bpc, or dpc??? */
 117 #define BPC_REGNUM      (CREGS_START + 3) /* Backup PC (on interrupt) */
 118 #define DPSW_REGNUM     (CREGS_START + 4) /* Backup PSW (on debug trap) */
 119 #define DPC_REGNUM      (CREGS_START + 5) /* Backup PC (on debug trap) */
 120 #define RPT_C_REGNUM    (CREGS_START + 7) /* Loop count */
 121 #define RPT_S_REGNUM    (CREGS_START + 8) /* Loop start address*/
 122 #define RPT_E_REGNUM    (CREGS_START + 9) /* Loop end address */
 123 #define MOD_S_REGNUM    (CREGS_START + 10)
 124 #define MOD_E_REGNUM    (CREGS_START + 11)
 125 #define IBA_REGNUM      (CREGS_START + 14) /* Instruction break address */
 126 #define EIT_VB_REGNUM   (CREGS_START + 15) /* Vector base address */
 127 #define INT_S_REGNUM    (CREGS_START + 16) /* Interrupt status */
 128 #define INT_M_REGNUM    (CREGS_START + 17) /* Interrupt mask */
 129 #define A0_REGNUM       84
 130 #define A1_REGNUM       85
 131
 132 /* Say how much memory is needed to store a copy of the register set */
 133 #define REGISTER_BYTES    ((NUM_REGS - 2) * 4 + 2 * 8)
 134
 135 /* Index within `registers' of the first byte of the space for
 136    register N.  */
 137
 138 #define REGISTER_BYTE(N)  \
 139 ( ((N) >= A0_REGNUM) ? ( ((N) - A0_REGNUM) * 8 + A0_REGNUM * 4 ) : ((N) * 4) )
 140
 141 /* Number of bytes of storage in the actual machine representation
 142    for register N.  */
 143
 144 #define REGISTER_RAW_SIZE(N) ( ((N) >= A0_REGNUM) ? 8 : 4 )
 145
 146 /* Number of bytes of storage in the program's representation
 147    for register N.  */
 148 #define REGISTER_VIRTUAL_SIZE(N) REGISTER_RAW_SIZE(N)
 149
 150 /* Largest value REGISTER_RAW_SIZE can have.  */
 151
 152 #define MAX_REGISTER_RAW_SIZE 8
 153
 154 /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
 155
 156 #define MAX_REGISTER_VIRTUAL_SIZE 8
 157
 158 /* Return the GDB type object for the "standard" data type
 159    of data in register N.  */
 160
 161 #define REGISTER_VIRTUAL_TYPE(N) \
 162 ( ((N) < A0_REGNUM ) ? builtin_type_long : builtin_type_long_long)
 163
 164 /* Writing to r0 is a noop (not an error or exception or anything like
 165    that, however).  */
 166
 167 #define CANNOT_STORE_REGISTER(regno) ((regno) == R0_REGNUM)
 168
 169 void d30v_do_registers_info PARAMS ((int regnum, int fpregs));
 170
 171 #define DO_REGISTERS_INFO d30v_do_registers_info
 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    We store structs through a pointer passed in R2 */
 177
 178 #define STORE_STRUCT_RETURN(ADDR, SP) \
 179     { write_register (2, (ADDR));  }
 180
 181
 182 /* Write into appropriate registers a function return value
 183    of type TYPE, given in virtual format.
 184
 185    Things always get returned in R2/R3 */
 186
 187 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
 188   write_register_bytes (REGISTER_BYTE(2), VALBUF, TYPE_LENGTH (TYPE))
 189
 190
 191 /* Extract from an array REGBUF containing the (raw) register state
 192    the address in which a function should return its structure value,
 193    as a CORE_ADDR (or an expression that can be used as one).  */
 194 #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (((CORE_ADDR *)(REGBUF))[2])
 195 \f
 196
 197 /* Define other aspects of the stack frame.
 198    we keep a copy of the worked out return pc lying around, since it
 199    is a useful bit of info */
 200
 201 #define EXTRA_FRAME_INFO \
 202     CORE_ADDR return_pc; \
 203     CORE_ADDR dummy; \
 204     int frameless; \
 205     int size;
 206
 207 #define INIT_EXTRA_FRAME_INFO(fromleaf, fi) \
 208     d30v_init_extra_frame_info(fromleaf, fi)
 209
 210 extern void d30v_init_extra_frame_info PARAMS (( int fromleaf, struct frame_info *fi ));
 211
 212 /* A macro that tells us whether the function invocation represented
 213    by FI does not have a frame on the stack associated with it.  If it
 214    does not, FRAMELESS is set to 1, else 0.  */
 215
 216 #define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
 217   (FRAMELESS) = frameless_look_for_prologue(FI)
 218
 219 #define FRAME_CHAIN(FRAME)       d30v_frame_chain(FRAME)
 220 extern int d30v_frame_chain_valid PARAMS ((CORE_ADDR, struct frame_info *));
 221 #define FRAME_CHAIN_VALID(chain, thisframe) d30v_frame_chain_valid (chain, thisframe)
 222 #define FRAME_SAVED_PC(FRAME)    ((FRAME)->return_pc)
 223 #define FRAME_ARGS_ADDRESS(fi)   (fi)->frame
 224 #define FRAME_LOCALS_ADDRESS(fi) (fi)->frame
 225
 226 #define INIT_FRAME_PC_FIRST(fromleaf, prev)     d30v_init_frame_pc(fromleaf, prev)
 227 #define INIT_FRAME_PC(fromleaf, prev)   /* nada */
 228
 229 /* Immediately after a function call, return the saved pc.  We can't */
 230 /* use frame->return_pc beause that is determined by reading R62 off the */
 231 /* stack and that may not be written yet. */
 232
 233 #define SAVED_PC_AFTER_CALL(frame) (read_register(LR_REGNUM))
 234
 235 /* Set VAL to the number of args passed to frame described by FI.
 236    Can set VAL to -1, meaning no way to tell.  */
 237 /* We can't tell how many args there are */
 238
 239 #define FRAME_NUM_ARGS(val,fi) (val = -1)
 240
 241 /* Return number of bytes at start of arglist that are not really args.  */
 242
 243 #define FRAME_ARGS_SKIP 0
 244
 245
 246 /* Put here the code to store, into a struct frame_saved_regs,
 247    the addresses of the saved registers of frame described by FRAME_INFO.
 248    This includes special registers such as pc and fp saved in special
 249    ways in the stack frame.  sp is even more special:
 250    the address we return for it IS the sp for the next frame.  */
 251
 252 #define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)         \
 253    d30v_frame_find_saved_regs(frame_info, &(frame_saved_regs))
 254
 255 extern void d30v_frame_find_saved_regs PARAMS ((struct frame_info *, struct frame_saved_regs *));
 256
 257 #define NAMES_HAVE_UNDERSCORE
 258
 259 /* DUMMY FRAMES.  Need these to support inferior function calls.
 260    They work like this on D30V:
 261    First we set a breakpoint at 0 or __start.
 262    Then we push all the registers onto the stack.
 263    Then put the function arguments in the proper registers and set r13
 264    to our breakpoint address.
 265    Finally call the function directly.
 266    When it hits the breakpoint, clear the break point and pop the old
 267    register contents off the stack. */
 268
 269 #define CALL_DUMMY              { 0 }
 270 #define PUSH_DUMMY_FRAME
 271 #define CALL_DUMMY_START_OFFSET 0
 272 #define CALL_DUMMY_LOCATION     AT_ENTRY_POINT
 273 #define CALL_DUMMY_BREAKPOINT_OFFSET (0)
 274
 275 extern CORE_ADDR d30v_call_dummy_address PARAMS ((void));
 276 #define CALL_DUMMY_ADDRESS() d30v_call_dummy_address()
 277
 278 #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
 279 sp = d30v_fix_call_dummy (dummyname, pc, fun, nargs, args, type, gcc_p)
 280
 281 #define PC_IN_CALL_DUMMY(pc, sp, frame_address) ( pc == IMEM_START + 4 )
 282
 283 extern CORE_ADDR d30v_fix_call_dummy PARAMS ((char *, CORE_ADDR, CORE_ADDR,
 284                                            int, struct value **,
 285                                            struct type *, int));
 286 #define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
 287     sp = d30v_push_arguments((nargs), (args), (sp), (struct_return), (struct_addr))
 288 extern CORE_ADDR d30v_push_arguments PARAMS ((int, struct value **, CORE_ADDR, int, CORE_ADDR));
 289
 290
 291 /* Extract from an array REGBUF containing the (raw) register state
 292    a function return value of type TYPE, and copy that, in virtual format,
 293    into VALBUF.  */
 294
 295 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 296 d30v_extract_return_value(TYPE, REGBUF, VALBUF)
 297   extern void
 298 d30v_extract_return_value PARAMS ((struct type *, char *, char *));
 299
 300
 301 /* Discard from the stack the innermost frame,
 302    restoring all saved registers.  */
 303 #define POP_FRAME d30v_pop_frame();
 304 extern void d30v_pop_frame PARAMS((void));
 305
 306 #define REGISTER_SIZE 4
 307
 308 /* Need to handle SP special, as we need to select between spu and spi.  */
 309 #if 0                           /* XXX until the simulator is fixed */
 310 #define TARGET_READ_SP() ((read_register (PSW_REGNUM) & PSW_SM) \
 311                           ? read_register (SPU_REGNUM) \
 312                           : read_register (SPI_REGNUM))
 313
 314 #define TARGET_WRITE_SP(val) ((read_register (PSW_REGNUM) & PSW_SM) \
 315                           ? write_register (SPU_REGNUM, (val)) \
 316                           : write_register (SPI_REGNUM, (val)))
 317 #endif
 318
 319 #define STACK_ALIGN(len)        (((len) + 7 ) & ~7)
 320
 321 /* Turn this on to cause remote-sim.c to use sim_set/clear_breakpoint. */
 322
 323 #define SIM_HAS_BREAKPOINTS
 324
 325 #endif /* TM_D30V_H */