gdb/config/d10v/tm-d10v.h

   1 /* Target-specific definition for the Mitsubishi D10V
   2    Copyright (C) 1996 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 /* Contributed by Martin Hunt, hunt@cygnus.com */
  21
  22
  23 #define GDB_TARGET_IS_D10V
  24
  25
  26 /* Define the bit, byte, and word ordering of the machine.  */
  27
  28 #define TARGET_BYTE_ORDER       BIG_ENDIAN
  29
  30
  31 /* Offset from address of function to start of its code.
  32    Zero on most machines.  */
  33
  34 #define FUNCTION_START_OFFSET 0
  35
  36 /* Advance PC across any function entry prologue instructions
  37    to reach some "real" code.  */
  38
  39 extern CORE_ADDR d10v_skip_prologue ();
  40 #define SKIP_PROLOGUE(ip) \
  41     {(ip) = d10v_skip_prologue(ip);}
  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    The return address is the value saved in the PR register + 4  */
  50
  51 #define SAVED_PC_AFTER_CALL(frame) \
  52   (ADDR_BITS_REMOVE(read_register(PR_REGNUM)))
  53
  54 /* Stack grows downward.  */
  55
  56 #define INNER_THAN <
  57
  58     /* for a breakpoint, use "dbt || nop" */
  59 #define BREAKPOINT {0x2f, 0x90, 0x5e, 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","sp",\
  68     "psw","bpsw","pc","bpc", "cr4", "cr5", "cr6", "rpt_c",\
  69     "rpt_s","rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15",\
  70     "a0", "a1"\
  71     }
  72
  73 #define NUM_REGS 34
  74
  75 /* Register numbers of various important registers.
  76    Note that some of these values are "real" register numbers,
  77    and correspond to the general registers of the machine,
  78    and some are "phony" register numbers which are too large
  79    to be actual register numbers as far as the user is concerned
  80    but do serve to get the desired values when passed to read_register.  */
  81
  82 #define R0_REGNUM       0
  83 #define LR_REGNUM       13
  84 #define SP_REGNUM       15
  85 #define FP_REGNUM       11
  86 #define PC_REGNUM       18
  87 #define PR_REGNUM       17
  88 #define PSW_REGNUM      16
  89 #define A0_REGNUM       32
  90
  91 /* Say how much memory is needed to store a copy of the register set */
  92 #define REGISTER_BYTES    ((NUM_REGS-2)*2+16)
  93
  94 /* Index within `registers' of the first byte of the space for
  95    register N.  */
  96
  97 #define REGISTER_BYTE(N)  \
  98 ( ((N) > A0_REGNUM) ? ( ((N)-A0_REGNUM)*8 + A0_REGNUM*2 ) : ((N) * 2) )
  99
 100 /* Number of bytes of storage in the actual machine representation
 101    for register N.  */
 102
 103 #define REGISTER_RAW_SIZE(N) ( ((N) >= A0_REGNUM) ? 8 : 2 )
 104
 105 /* Number of bytes of storage in the program's representation
 106    for register N.  */
 107 #define REGISTER_VIRTUAL_SIZE(N) ( ((N) >= A0_REGNUM) ? 8 : 2 )
 108
 109 /* Largest value REGISTER_RAW_SIZE can have.  */
 110
 111 #define MAX_REGISTER_RAW_SIZE 8
 112
 113 /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
 114
 115 #define MAX_REGISTER_VIRTUAL_SIZE 8
 116
 117 /* Return the GDB type object for the "standard" data type
 118    of data in register N.  */
 119
 120 #define REGISTER_VIRTUAL_TYPE(N) \
 121 ( ((N) < A0_REGNUM ) ? builtin_type_short : builtin_type_long_long)
 122
 123
 124 /* Store the address of the place in which to copy the structure the
 125    subroutine will return.  This is called from call_function.
 126
 127    We store structs through a pointer passed in R2 */
 128
 129 #define STORE_STRUCT_RETURN(ADDR, SP) \
 130     { write_register (2, (ADDR));  }
 131
 132 /* Extract from an array REGBUF containing the (raw) register state
 133    a function return value of type TYPE, and copy that, in virtual format,
 134    into VALBUF.  */
 135
 136 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 137   memcpy (VALBUF, (char *)(REGBUF), TYPE_LENGTH(TYPE))
 138
 139
 140 /* Write into appropriate registers a function return value
 141    of type TYPE, given in virtual format.
 142
 143    Things always get returned in R2/R3 */
 144
 145 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
 146   write_register_bytes (REGISTER_BYTE(2), VALBUF, TYPE_LENGTH (TYPE))
 147
 148
 149 /* Extract from an array REGBUF containing the (raw) register state
 150    the address in which a function should return its structure value,
 151    as a CORE_ADDR (or an expression that can be used as one).  */
 152
 153 #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(CORE_ADDR *)(REGBUF))
 154 \f
 155
 156 /* Define other aspects of the stack frame.
 157    we keep a copy of the worked out return pc lying around, since it
 158    is a useful bit of info */
 159
 160 #define EXTRA_FRAME_INFO \
 161     CORE_ADDR return_pc; \
 162     int leaf_function;   \
 163     int f_offset;
 164
 165 #define INIT_EXTRA_FRAME_INFO(fromleaf, fi) \
 166     d10v_init_extra_frame_info(fromleaf, fi)
 167
 168 /* A macro that tells us whether the function invocation represented
 169    by FI does not have a frame on the stack associated with it.  If it
 170    does not, FRAMELESS is set to 1, else 0.  */
 171
 172 #define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
 173   (FRAMELESS) = frameless_look_for_prologue(FI)
 174
 175 #define FRAME_CHAIN(FRAME)       d10v_frame_chain(FRAME)
 176 #define FRAME_SAVED_PC(FRAME)    ((FRAME)->return_pc)
 177 #define FRAME_ARGS_ADDRESS(fi)   (fi)->frame
 178 #define FRAME_LOCALS_ADDRESS(fi) (fi)->frame
 179
 180 /* Set VAL to the number of args passed to frame described by FI.
 181    Can set VAL to -1, meaning no way to tell.  */
 182
 183 /* We can't tell how many args there are */
 184
 185 #define FRAME_NUM_ARGS(val,fi) (val = -1)
 186
 187 /* Return number of bytes at start of arglist that are not really args.  */
 188
 189 #define FRAME_ARGS_SKIP 0
 190
 191 /* Put here the code to store, into a struct frame_saved_regs,
 192    the addresses of the saved registers of frame described by FRAME_INFO.
 193    This includes special registers such as pc and fp saved in special
 194    ways in the stack frame.  sp is even more special:
 195    the address we return for it IS the sp for the next frame.  */
 196
 197 #define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)         \
 198    d10v_frame_find_saved_regs(frame_info, &(frame_saved_regs))
 199
 200 #define NAMES_HAVE_UNDERSCORE
 201
 202 typedef unsigned short INSN_WORD;
 203
 204 #define ADDR_BITS_REMOVE(addr) ((addr))
 205
 206 #define CALL_DUMMY_LENGTH 10
 207
 208 /* Discard from the stack the innermost frame,
 209    restoring all saved registers.  */
 210
 211 #define POP_FRAME d10v_pop_frame();
 212
 213 #define REGISTER_SIZE 2
 214
 215 #  ifdef CC_HAS_LONG_LONG
 216 #    define LONGEST long long
 217 #  else
 218 #    define LONGEST long
 219 #  endif
 220
 221 void d10v_write_register_pid PARAMS (( int regno, LONGEST val, int pid));
 222 CORE_ADDR d10v_read_register_pid PARAMS ((int regno, int pid));
 223
 224 #define TARGET_READ_PC(pid)             d10v_read_register_pid (PC_REGNUM, pid)
 225 #define TARGET_WRITE_PC(val,pid)        d10v_write_register_pid (PC_REGNUM, val, pid)