gdb/config/h8500/tm-h8500.h

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