| 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 | #define GDB_TARGET_IS_D10V |
| 23 | |
| 24 | /* Define the bit, byte, and word ordering of the machine. */ |
| 25 | |
| 26 | #define TARGET_BYTE_ORDER BIG_ENDIAN |
| 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 | /* these are the addresses the D10V-EVA board maps data */ |
| 34 | /* and instruction memory to. */ |
| 35 | |
| 36 | #define DMEM_START 0x0000000 |
| 37 | #define IMEM_START 0x1000000 |
| 38 | #define STACK_START 0x0007ffe |
| 39 | |
| 40 | #ifdef __STDC__ /* Forward decls for prototypes */ |
| 41 | struct frame_info; |
| 42 | struct frame_saved_regs; |
| 43 | struct type; |
| 44 | struct value; |
| 45 | #endif |
| 46 | |
| 47 | /* Advance PC across any function entry prologue instructions |
| 48 | to reach some "real" code. */ |
| 49 | |
| 50 | extern CORE_ADDR d10v_skip_prologue (); |
| 51 | #define SKIP_PROLOGUE(ip) \ |
| 52 | {(ip) = d10v_skip_prologue(ip);} |
| 53 | |
| 54 | |
| 55 | /* Stack grows downward. */ |
| 56 | #define INNER_THAN(lhs,rhs) ((lhs) < (rhs)) |
| 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 4 |
| 64 | |
| 65 | #define REGISTER_NAMES \ |
| 66 | { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \ |
| 67 | "r8", "r9", "r10","r11","r12", "r13", "r14","r15",\ |
| 68 | "psw","bpsw","pc","bpc", "cr4", "cr5", "cr6", "rpt_c",\ |
| 69 | "rpt_s","rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15",\ |
| 70 | "imap0","imap1","dmap","a0", "a1"\ |
| 71 | } |
| 72 | |
| 73 | #define NUM_REGS 37 |
| 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 PSW_REGNUM 16 |
| 88 | #define IMAP0_REGNUM 32 |
| 89 | #define IMAP1_REGNUM 33 |
| 90 | #define DMAP_REGNUM 34 |
| 91 | #define A0_REGNUM 35 |
| 92 | |
| 93 | /* Say how much memory is needed to store a copy of the register set */ |
| 94 | #define REGISTER_BYTES ((NUM_REGS-2)*2+16) |
| 95 | |
| 96 | /* Index within `registers' of the first byte of the space for |
| 97 | register N. */ |
| 98 | |
| 99 | #define REGISTER_BYTE(N) \ |
| 100 | ( ((N) > A0_REGNUM) ? ( ((N)-A0_REGNUM)*8 + A0_REGNUM*2 ) : ((N) * 2) ) |
| 101 | |
| 102 | /* Number of bytes of storage in the actual machine representation |
| 103 | for register N. */ |
| 104 | |
| 105 | #define REGISTER_RAW_SIZE(N) ( ((N) >= A0_REGNUM) ? 8 : 2 ) |
| 106 | |
| 107 | /* Number of bytes of storage in the program's representation |
| 108 | for register N. */ |
| 109 | #define REGISTER_VIRTUAL_SIZE(N) ( ((N) >= A0_REGNUM) ? 8 : ( ((N) == PC_REGNUM || (N) == SP_REGNUM) ? 4 : 2 )) |
| 110 | |
| 111 | /* Largest value REGISTER_RAW_SIZE can have. */ |
| 112 | |
| 113 | #define MAX_REGISTER_RAW_SIZE 8 |
| 114 | |
| 115 | /* Largest value REGISTER_VIRTUAL_SIZE can have. */ |
| 116 | |
| 117 | #define MAX_REGISTER_VIRTUAL_SIZE 8 |
| 118 | |
| 119 | /* Return the GDB type object for the "standard" data type |
| 120 | of data in register N. */ |
| 121 | |
| 122 | #define REGISTER_VIRTUAL_TYPE(N) \ |
| 123 | ( ((N) < A0_REGNUM ) ? ((N) == PC_REGNUM || (N) == SP_REGNUM ? builtin_type_long : builtin_type_short) : builtin_type_long_long) |
| 124 | |
| 125 | |
| 126 | /* convert $pc and $sp to/from virtual addresses */ |
| 127 | #define REGISTER_CONVERTIBLE(N) ((N) == PC_REGNUM || (N) == SP_REGNUM) |
| 128 | #define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,TYPE,FROM,TO) \ |
| 129 | { \ |
| 130 | ULONGEST x = extract_unsigned_integer ((FROM), REGISTER_RAW_SIZE (REGNUM)); \ |
| 131 | if (REGNUM == PC_REGNUM) x = (x << 2) | IMEM_START; \ |
| 132 | else x |= DMEM_START; \ |
| 133 | store_unsigned_integer ((TO), TYPE_LENGTH(TYPE), x); \ |
| 134 | } |
| 135 | #define REGISTER_CONVERT_TO_RAW(TYPE,REGNUM,FROM,TO) \ |
| 136 | { \ |
| 137 | ULONGEST x = extract_unsigned_integer ((FROM), TYPE_LENGTH(TYPE)); \ |
| 138 | x &= 0x3ffff; \ |
| 139 | if (REGNUM == PC_REGNUM) x >>= 2; \ |
| 140 | store_unsigned_integer ((TO), 2, x); \ |
| 141 | } |
| 142 | |
| 143 | #define D10V_MAKE_DADDR(x) ((x) | DMEM_START) |
| 144 | #define D10V_MAKE_IADDR(x) (((x) << 2) | IMEM_START) |
| 145 | |
| 146 | #define D10V_DADDR_P(X) (((X) & 0x3000000) == DMEM_START) |
| 147 | #define D10V_IADDR_P(X) (((X) & 0x3000000) == IMEM_START) |
| 148 | |
| 149 | #define D10V_CONVERT_IADDR_TO_RAW(X) (((X) >> 2) & 0xffff) |
| 150 | #define D10V_CONVERT_DADDR_TO_RAW(X) ((X) & 0xffff) |
| 151 | |
| 152 | #define ARG1_REGNUM R0_REGNUM |
| 153 | #define ARGN_REGNUM 3 |
| 154 | #define RET1_REGNUM R0_REGNUM |
| 155 | |
| 156 | /* Store the address of the place in which to copy the structure the |
| 157 | subroutine will return. This is called from call_function. |
| 158 | |
| 159 | We store structs through a pointer passed in the first Argument |
| 160 | register. */ |
| 161 | |
| 162 | #define STORE_STRUCT_RETURN(ADDR, SP) \ |
| 163 | { write_register (ARG1_REGNUM, (ADDR)); } |
| 164 | |
| 165 | |
| 166 | /* Write into appropriate registers a function return value |
| 167 | of type TYPE, given in virtual format. |
| 168 | |
| 169 | Things always get returned in RET1_REGNUM, RET2_REGNUM, ... */ |
| 170 | |
| 171 | #define STORE_RETURN_VALUE(TYPE,VALBUF) \ |
| 172 | write_register_bytes (REGISTER_BYTE(RET1_REGNUM), VALBUF, TYPE_LENGTH (TYPE)) |
| 173 | |
| 174 | |
| 175 | /* Extract from an array REGBUF containing the (raw) register state |
| 176 | the address in which a function should return its structure value, |
| 177 | as a CORE_ADDR (or an expression that can be used as one). */ |
| 178 | |
| 179 | #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \ |
| 180 | (extract_address ((REGBUF) + REGISTER_BYTE (ARG1_REGNUM), REGISTER_RAW_SIZE (ARG1_REGNUM)) | DMEM_START) |
| 181 | |
| 182 | /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of |
| 183 | EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc |
| 184 | and TYPE is the type (which is known to be struct, union or array). |
| 185 | |
| 186 | The d10v returns anything less than 8 bytes in size in |
| 187 | registers. */ |
| 188 | |
| 189 | extern use_struct_convention_fn d10v_use_struct_convention; |
| 190 | #define USE_STRUCT_CONVENTION(gcc_p, type) d10v_use_struct_convention (gcc_p, type) |
| 191 | |
| 192 | \f |
| 193 | |
| 194 | /* Define other aspects of the stack frame. |
| 195 | we keep a copy of the worked out return pc lying around, since it |
| 196 | is a useful bit of info */ |
| 197 | |
| 198 | #define EXTRA_FRAME_INFO \ |
| 199 | CORE_ADDR return_pc; \ |
| 200 | int frameless; \ |
| 201 | int size; |
| 202 | |
| 203 | #define INIT_EXTRA_FRAME_INFO(fromleaf, fi) \ |
| 204 | d10v_init_extra_frame_info(fromleaf, fi) |
| 205 | |
| 206 | extern void d10v_init_extra_frame_info PARAMS (( int fromleaf, struct frame_info *fi )); |
| 207 | |
| 208 | /* A macro that tells us whether the function invocation represented |
| 209 | by FI does not have a frame on the stack associated with it. If it |
| 210 | does not, FRAMELESS is set to 1, else 0. */ |
| 211 | |
| 212 | #define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \ |
| 213 | (FRAMELESS) = frameless_look_for_prologue(FI) |
| 214 | |
| 215 | #define FRAME_CHAIN(FRAME) d10v_frame_chain(FRAME) |
| 216 | extern int d10v_frame_chain_valid PARAMS ((CORE_ADDR, struct frame_info *)); |
| 217 | #define FRAME_CHAIN_VALID(chain, thisframe) d10v_frame_chain_valid (chain, thisframe) |
| 218 | #define FRAME_SAVED_PC(FRAME) ((FRAME)->return_pc) |
| 219 | #define FRAME_ARGS_ADDRESS(fi) (fi)->frame |
| 220 | #define FRAME_LOCALS_ADDRESS(fi) (fi)->frame |
| 221 | |
| 222 | /* Immediately after a function call, return the saved pc. We can't */ |
| 223 | /* use frame->return_pc beause that is determined by reading R13 off the */ |
| 224 | /*stack and that may not be written yet. */ |
| 225 | |
| 226 | #define SAVED_PC_AFTER_CALL(frame) ((read_register(LR_REGNUM) << 2) | IMEM_START) |
| 227 | |
| 228 | /* Set VAL to the number of args passed to frame described by FI. |
| 229 | Can set VAL to -1, meaning no way to tell. */ |
| 230 | /* We can't tell how many args there are */ |
| 231 | |
| 232 | #define FRAME_NUM_ARGS(val,fi) (val = -1) |
| 233 | |
| 234 | /* Return number of bytes at start of arglist that are not really args. */ |
| 235 | |
| 236 | #define FRAME_ARGS_SKIP 0 |
| 237 | |
| 238 | |
| 239 | /* Put here the code to store, into a struct frame_saved_regs, |
| 240 | the addresses of the saved registers of frame described by FRAME_INFO. |
| 241 | This includes special registers such as pc and fp saved in special |
| 242 | ways in the stack frame. sp is even more special: |
| 243 | the address we return for it IS the sp for the next frame. */ |
| 244 | |
| 245 | #define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \ |
| 246 | d10v_frame_find_saved_regs(frame_info, &(frame_saved_regs)) |
| 247 | |
| 248 | extern void d10v_frame_find_saved_regs PARAMS ((struct frame_info *, struct frame_saved_regs *)); |
| 249 | |
| 250 | #define NAMES_HAVE_UNDERSCORE |
| 251 | |
| 252 | |
| 253 | /* DUMMY FRAMES. Need these to support inferior function calls. They |
| 254 | work like this on D10V: First we set a breakpoint at 0 or __start. |
| 255 | Then we push all the registers onto the stack. Then put the |
| 256 | function arguments in the proper registers and set r13 to our |
| 257 | breakpoint address. Finally, the PC is set to the start of the |
| 258 | function being called (no JSR/BSR insn). When it hits the |
| 259 | breakpoint, clear the break point and pop the old register contents |
| 260 | off the stack. */ |
| 261 | |
| 262 | extern void d10v_pop_frame PARAMS ((struct frame_info *frame)); |
| 263 | #define POP_FRAME generic_pop_current_frame (d10v_pop_frame) |
| 264 | |
| 265 | #define USE_GENERIC_DUMMY_FRAMES |
| 266 | #define CALL_DUMMY {0} |
| 267 | #define CALL_DUMMY_START_OFFSET (0) |
| 268 | #define CALL_DUMMY_BREAKPOINT_OFFSET (0) |
| 269 | #define CALL_DUMMY_LOCATION AT_ENTRY_POINT |
| 270 | #define FIX_CALL_DUMMY(DUMMY, START, FUNADDR, NARGS, ARGS, TYPE, GCCP) |
| 271 | #define CALL_DUMMY_ADDRESS() entry_point_address () |
| 272 | extern CORE_ADDR d10v_push_return_address PARAMS ((CORE_ADDR pc, CORE_ADDR sp)); |
| 273 | #define PUSH_RETURN_ADDRESS(PC, SP) d10v_push_return_address (PC, SP) |
| 274 | |
| 275 | #define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP) |
| 276 | /* #define PC_IN_CALL_DUMMY(pc, sp, frame_address) ( pc == IMEM_START + 4 ) */ |
| 277 | |
| 278 | #define PUSH_DUMMY_FRAME generic_push_dummy_frame () |
| 279 | |
| 280 | /* override the default get_saved_register function with one that |
| 281 | takes account of generic CALL_DUMMY frames */ |
| 282 | #define GET_SAVED_REGISTER |
| 283 | #define get_saved_register generic_get_saved_register |
| 284 | |
| 285 | #define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \ |
| 286 | sp = d10v_push_arguments((nargs), (args), (sp), (struct_return), (struct_addr)) |
| 287 | extern CORE_ADDR d10v_push_arguments PARAMS ((int, struct value **, CORE_ADDR, int, CORE_ADDR)); |
| 288 | |
| 289 | |
| 290 | /* Extract from an array REGBUF containing the (raw) register state |
| 291 | a function return value of type TYPE, and copy that, in virtual format, |
| 292 | into VALBUF. */ |
| 293 | |
| 294 | #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ |
| 295 | d10v_extract_return_value(TYPE, REGBUF, VALBUF) |
| 296 | extern void |
| 297 | d10v_extract_return_value PARAMS ((struct type *, char *, char *)); |
| 298 | |
| 299 | |
| 300 | #define REGISTER_SIZE 2 |
| 301 | |
| 302 | #ifdef CC_HAS_LONG_LONG |
| 303 | # define LONGEST long long |
| 304 | #else |
| 305 | # define LONGEST long |
| 306 | #endif |
| 307 | #define ULONGEST unsigned LONGEST |
| 308 | |
| 309 | void d10v_write_pc PARAMS ((CORE_ADDR val, int pid)); |
| 310 | CORE_ADDR d10v_read_pc PARAMS ((int pid)); |
| 311 | void d10v_write_sp PARAMS ((CORE_ADDR val)); |
| 312 | CORE_ADDR d10v_read_sp PARAMS ((void)); |
| 313 | void d10v_write_fp PARAMS ((CORE_ADDR val)); |
| 314 | CORE_ADDR d10v_read_fp PARAMS ((void)); |
| 315 | |
| 316 | #define TARGET_READ_PC(pid) d10v_read_pc (pid) |
| 317 | #define TARGET_WRITE_PC(val,pid) d10v_write_pc (val, pid) |
| 318 | #define TARGET_READ_FP() d10v_read_fp () |
| 319 | #define TARGET_WRITE_FP(val) d10v_write_fp (val) |
| 320 | #define TARGET_READ_SP() d10v_read_sp () |
| 321 | #define TARGET_WRITE_SP(val) d10v_write_sp (val) |
| 322 | |
| 323 | /* Number of bits in the appropriate type */ |
| 324 | #define TARGET_INT_BIT (2 * TARGET_CHAR_BIT) |
| 325 | #define TARGET_PTR_BIT (4 * TARGET_CHAR_BIT) |
| 326 | #define TARGET_DOUBLE_BIT (4 * TARGET_CHAR_BIT) |
| 327 | #define TARGET_LONG_DOUBLE_BIT (8 * TARGET_CHAR_BIT) |
| 328 | |
| 329 | \f |
| 330 | /* For the d10v when talking to the remote d10v board, GDB addresses |
| 331 | need to be translated into a format that the d10v rom monitor |
| 332 | understands. */ |
| 333 | |
| 334 | int remote_d10v_translate_xfer_address PARAMS ((CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr)); |
| 335 | #define REMOTE_TRANSLATE_XFER_ADDRESS(GDB_ADDR, GDB_LEN, REM_ADDR, REM_LEN) \ |
| 336 | (REM_LEN) = remote_d10v_translate_xfer_address ((GDB_ADDR), (GDB_LEN), &(REM_ADDR)) |
| 337 | |