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