gdb/config/h8500/tm-h8500.h

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