gdb/config/h8500/tm-h8500.h

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