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