gdb/config/h8500/tm-h8500.h

   1 /* Parameters for execution on a H8/500 series machine.
   2    Copyright (C) 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 /* Contributed by Steve Chamberlain sac@cygnus.com */
  21
  22 #define GDB_TARGET_IS_H8500
  23
  24 #define IEEE_FLOAT 1
  25
  26 /* Define the bit, byte, and word ordering of the machine.  */
  27
  28 #define TARGET_BYTE_ORDER BIG_ENDIAN
  29
  30 #define TARGET_INT_BIT 16
  31 #define TARGET_LONG_BIT 32
  32 #define TARGET_PTR_BIT (minimum_mode ? 16 : 32)
  33
  34
  35 /* Offset from address of function to start of its code.
  36    Zero on most machines.  */
  37
  38 #define FUNCTION_START_OFFSET 0
  39
  40 /* Advance PC across any function entry prologue instructions
  41    to reach some "real" code.  */
  42
  43 #define SKIP_PROLOGUE(ip)   {(ip) = h8500_skip_prologue(ip);}
  44 extern CORE_ADDR h8500_skip_prologue ();
  45
  46
  47 /* Immediately after a function call, return the saved pc.
  48    Can't always go through the frames for this because on some machines
  49    the new frame is not set up until the new function executes
  50    some instructions.  */
  51
  52 #define SAVED_PC_AFTER_CALL(frame) saved_pc_after_call(frame)
  53
  54
  55 /* Stack grows downward.  */
  56
  57 #define INNER_THAN <
  58
  59 /* Illegal instruction - used by the simulator for breakpoint
  60    detection */
  61 #define BREAKPOINT {0x0b}
  62
  63
  64 /* If your kernel resets the pc after the trap happens you may need to
  65    define this before including this file.  */
  66
  67 #define DECR_PC_AFTER_BREAK 0
  68
  69
  70 /* Nonzero if instruction at PC is a return instruction.  */
  71
  72 #define ABOUT_TO_RETURN(pc) about_to_return(pc)
  73
  74 /* Return 1 if P points to an invalid floating point value.  */
  75
  76 #define INVALID_FLOAT(p, len) 0   /* Just a first guess; not checked */
  77
  78 /* Say how long registers are.  */
  79
  80 #define REGISTER_TYPE  unsigned long
  81
  82 /* Say how much memory is needed to store a copy of the register set */
  83
  84 #define REGISTER_BYTES    (NUM_REGS * 4)
  85
  86 /* Index within `registers' of the first byte of the space for
  87    register N.  */
  88
  89 #define REGISTER_BYTE(N)  ((N)*4)
  90
  91 /* Number of bytes of storage in the actual machine representation
  92    for register N.  */
  93
  94 #define REGISTER_RAW_SIZE(N) h8500_register_size(N)
  95 int h8500_register_size PARAMS ((int regno));
  96
  97 #define REGISTER_VIRTUAL_SIZE(N) h8500_register_size(N)
  98
  99 /* Largest value REGISTER_RAW_SIZE can have.  */
 100
 101 #define MAX_REGISTER_RAW_SIZE 4
 102
 103 /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
 104
 105 #define MAX_REGISTER_VIRTUAL_SIZE 4
 106
 107 /* Return the GDB type object for the "standard" data type
 108    of data in register N.  */
 109
 110 #define REGISTER_VIRTUAL_TYPE(N) h8500_register_virtual_type(N)
 111 struct type *h8500_register_virtual_type PARAMS ((int regno));
 112
 113 /* Initializer for an array of names of registers.
 114    Entries beyond the first NUM_REGS are ignored.  */
 115
 116 #define REGISTER_NAMES \
 117   {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",   \
 118   "pr0", "pr1", "pr2","pr3","pr4","pr5","pr6","pr7","cp","dp","ep","tp","ccr","pc"}
 119
 120
 121 /* Register numbers of various important registers.
 122    Note that some of these values are "real" register numbers,
 123    and correspond to the general registers of the machine,
 124    and some are "phony" register numbers which are too large
 125    to be actual register numbers as far as the user is concerned
 126    but do serve to get the desired values when passed to read_register.  */
 127
 128
 129 #define R0_REGNUM       0
 130 #define R1_REGNUM       1
 131 #define R2_REGNUM       2
 132 #define R3_REGNUM       3
 133 #define R4_REGNUM       4
 134 #define R5_REGNUM       5
 135 #define R6_REGNUM       6
 136 #define R7_REGNUM       7
 137
 138
 139 #define PR0_REGNUM      8
 140 #define PR1_REGNUM      9
 141 #define PR2_REGNUM      10
 142 #define PR3_REGNUM      11
 143 #define PR4_REGNUM      12
 144 #define PR5_REGNUM      13
 145 #define PR6_REGNUM      14
 146 #define PR7_REGNUM      15
 147
 148 #define SEG_C_REGNUM    16      /* Segment registers */
 149 #define SEG_D_REGNUM    17
 150 #define SEG_E_REGNUM    18
 151 #define SEG_T_REGNUM    19
 152
 153
 154 #define CCR_REGNUM      20      /* Contains processor status */
 155 #define PC_REGNUM       21      /* Contains program counter */
 156
 157
 158 #define NUM_REGS        22
 159
 160
 161 #define SP_REGNUM       PR7_REGNUM /* Contains address of top of stack */
 162 #define FP_REGNUM       PR6_REGNUM /* Contains address of executing stack frame */
 163
 164 #define PTR_SIZE (minimum_mode ? 2: 4)
 165 #define PTR_MASK (minimum_mode ? 0x0000ffff : 0x00ffffff)
 166
 167 /* Store the address of the place in which to copy the structure the
 168    subroutine will return.  This is called from call_function. */
 169
 170 /*#define STORE_STRUCT_RETURN(ADDR, SP) \
 171   { write_register (0, (ADDR)); abort(); }*/
 172
 173 /* Extract from an array REGBUF containing the (raw) register state
 174    a function return value of type TYPE, and copy that, in virtual format,
 175    into VALBUF.  */
 176
 177 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
 178   memcpy (VALBUF, (char *)(REGBUF), TYPE_LENGTH(TYPE))
 179
 180
 181 /* Write into appropriate registers a function return value
 182    of type TYPE, given in virtual format.  Assumes floats are passed
 183    in d0/d1.  */
 184
 185
 186 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
 187   write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
 188
 189
 190 /* Extract from an array REGBUF containing the (raw) register state
 191    the address in which a function should return its structure value,
 192    as a CORE_ADDR (or an expression that can be used as one).  */
 193
 194 #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(CORE_ADDR *)(REGBUF))
 195 \f
 196
 197 /* Define other aspects of the stack frame.  */
 198
 199 /* A macro that tells us whether the function invocation represented
 200    by FI does not have a frame on the stack associated with it.  If it
 201    does not, FRAMELESS is set to 1, else 0.  */
 202 #define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
 203   (FRAMELESS) = frameless_look_for_prologue(FI)
 204
 205 /* Any function with a frame looks like this
 206    SECOND ARG
 207    FIRST ARG
 208    RET PC
 209    SAVED R2
 210    SAVED R3
 211    SAVED FP   <-FP POINTS HERE
 212    LOCALS0
 213    LOCALS1    <-SP POINTS HERE
 214
 215    */
 216
 217 CORE_ADDR h8500_frame_chain (/* FRAME thisframe */);
 218
 219 #define INIT_EXTRA_FRAME_INFO(fromleaf, fci)  ;
 220 /*       (fci)->frame |= read_register(SEG_T_REGNUM) << 16;*/
 221
 222 #define FRAME_CHAIN(FRAME) h8500_frame_chain(FRAME)
 223
 224 #define FRAME_SAVED_PC(FRAME) frame_saved_pc(FRAME)
 225
 226 #define FRAME_ARGS_ADDRESS(fi) frame_args_address(fi)
 227
 228 #define FRAME_LOCALS_ADDRESS(fi) frame_locals_address(fi);
 229
 230 /* Set VAL to the number of args passed to frame described by FI.
 231    Can set VAL to -1, meaning no way to tell.  */
 232
 233 /* We can't tell how many args there are
 234    now that the C compiler delays popping them.  */
 235
 236 #define FRAME_NUM_ARGS(val,fi) (val = -1)
 237
 238 /* Return number of bytes at start of arglist that are not really args.  */
 239
 240 #define FRAME_ARGS_SKIP 0
 241
 242 /* Put here the code to store, into a struct frame_saved_regs,
 243    the addresses of the saved registers of frame described by FRAME_INFO.
 244    This includes special registers such as pc and fp saved in special
 245    ways in the stack frame.  sp is even more special:
 246    the address we return for it IS the sp for the next frame.  */
 247
 248 #define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)         \
 249    frame_find_saved_regs(frame_info, &(frame_saved_regs))
 250 \f
 251
 252 /* Push an empty stack frame, to record the current PC, etc.  */
 253
 254 /*#define PUSH_DUMMY_FRAME      { h8300_push_dummy_frame (); }*/
 255
 256 /* Discard from the stack the innermost frame, restoring all registers.  */
 257
 258 #define POP_FRAME               { h8300_pop_frame (); }
 259
 260 #define SHORT_INT_MAX 32767
 261 #define SHORT_INT_MIN -32768
 262
 263
 264
 265 #define BEFORE_MAIN_LOOP_HOOK   \
 266   hms_before_main_loop();
 267
 268
 269 #define NAMES_HAVE_UNDERSCORE
 270
 271 typedef unsigned short INSN_WORD;
 272
 273 #define ADDR_BITS_REMOVE(addr) ((addr) & 0xffffff)
 274
 275 #define read_memory_short(x)  (read_memory_integer(x,2) & 0xffff)
 276 #define DONT_USE_REMOTE
 277
 278
 279 #define PRINT_REGISTER_HOOK(regno) print_register_hook(regno)
 280
 281 int minimum_mode;
 282
 283 #define CALL_DUMMY_LENGTH 10
 284
 285 /* Fake variables to make it easy to use 24 bit register pointers */
 286
 287 int h8500_is_trapped_internalvar PARAMS ((char *name));
 288 #define IS_TRAPPED_INTERNALVAR h8500_is_trapped_internalvar
 289
 290 struct value * h8500_value_of_trapped_internalvar (/* struct internalvar *var */);
 291 #define VALUE_OF_TRAPPED_INTERNALVAR h8500_value_of_trapped_internalvar
 292
 293 void h8500_set_trapped_internalvar (/* struct internalvar *var, value newval, int bitpos, int bitsize, int offset */);
 294 #define SET_TRAPPED_INTERNALVAR h8500_set_trapped_internalvar
 295
 296
 297
 298 int regoff[NUM_REGS];
 299
 300 CORE_ADDR target_read_sp();
 301 void target_write_sp PARAMS ((CORE_ADDR ));
 302
 303 CORE_ADDR target_read_fp();
 304 void target_write_fp PARAMS ((CORE_ADDR ));
 305
 306 CORE_ADDR target_read_pc();
 307 void target_write_pc PARAMS ((CORE_ADDR ));
 308
 309
 310 #define TARGET_READ_SP() target_read_sp()
 311 #define TARGET_WRITE_SP(x) target_write_sp(x)
 312 #define TARGET_READ_PC() target_read_pc()
 313 #define TARGET_WRITE_PC(x) target_write_pc(x)
 314
 315 #define TARGET_READ_FP() target_read_fp()
 316 #define TARGET_WRITE_FP(x) target_write_fp(x)