[deliverable/binutils-gdb.git] / gdb / config / m32r / tm-m32r.h

/* Parameters for execution on a Mitsubishi m32r processor.
   Copyright 1996
   Free Software Foundation, Inc. 

This file is part of GDB.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

/* mvs_check TARGET_BYTE_ORDER BIG_ENDIAN */
#define TARGET_BYTE_ORDER BIG_ENDIAN

/* mvs_check REGISTER_NAMES */
#define REGISTER_NAMES \
{ "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \
  "r8", "r9", "r10", "r11", "r12", "fp", "lr", "sp", \
  "psw", "cbr", "spi", "spu", "bpc", "pc", "accl", "acch", \
    /*  "cond", "sm", "bsm", "ie", "bie", "bcarry",  */ \
}
/* mvs_check  NUM_REGS */
#define NUM_REGS 			24

/* mvs_check  REGISTER_SIZE */
#define REGISTER_SIZE 			4
/* mvs_check  MAX_REGISTER_RAW_SIZE */
#define MAX_REGISTER_RAW_SIZE		4

/* mvs_check  *_REGNUM */
#define R0_REGNUM	0
#define STRUCT_RETURN_REGNUM 0
#define ARG0_REGNUM	0
#define ARGLAST_REGNUM	3
#define V0_REGNUM	0
#define V1_REGNUM	1
#define FP_REGNUM	13
#define RP_REGNUM	14
#define SP_REGNUM	15
#define PSW_REGNUM	16
#define CBR_REGNUM	17
#define SPI_REGNUM	18
#define SPU_REGNUM	19
#define BPC_REGNUM	20
#define PC_REGNUM	21
#define ACCL_REGNUM	22
#define ACCH_REGNUM	23

/* mvs_check  REGISTER_BYTES */
#define REGISTER_BYTES			(NUM_REGS * 4)

/* mvs_check  REGISTER_VIRTUAL_TYPE */
#define REGISTER_VIRTUAL_TYPE(REG)	builtin_type_int

/* mvs_check  REGISTER_BYTE */
#define REGISTER_BYTE(REG) 		((REG) * 4)
/* mvs_check  REGISTER_VIRTUAL_SIZE */
#define REGISTER_VIRTUAL_SIZE(REG) 	4
/* mvs_check  REGISTER_RAW_SIZE */
#define REGISTER_RAW_SIZE(REG)     	4

/* mvs_check  MAX_REGISTER_VIRTUAL_SIZE */
#define MAX_REGISTER_VIRTUAL_SIZE 	4

/* mvs_check  BREAKPOINT */
#define BREAKPOINT {0x10, 0xf1}

/* mvs_no_check  FUNCTION_START_OFFSET */
#define FUNCTION_START_OFFSET 0

/* mvs_check  DECR_PC_AFTER_BREAK */
#define DECR_PC_AFTER_BREAK 0

/* mvs_check  INNER_THAN */
#define INNER_THAN <

/* mvs_check  SAVED_PC_AFTER_CALL */
#define SAVED_PC_AFTER_CALL(fi) read_register (RP_REGNUM)

#ifdef __STDC__
struct frame_info;
struct frame_saved_regs;
struct type;
struct value;
#endif

/* Define other aspects of the stack frame. 
   We keep the offsets of all saved registers, 'cause we need 'em a lot!
   We also keep the current size of the stack frame, and whether 
   the frame pointer is valid (for frameless functions, and when we're
   still in the prologue of a function with a frame) */

/* mvs_check  EXTRA_FRAME_INFO */
#define EXTRA_FRAME_INFO  	\
  struct frame_saved_regs fsr;	\
  int framesize;		\
  int using_frame_pointer;


extern void m32r_init_extra_frame_info PARAMS ((struct frame_info *fi));
/* mvs_check  INIT_EXTRA_FRAME_INFO */
#define INIT_EXTRA_FRAME_INFO(fromleaf, fi) m32r_init_extra_frame_info (fi)
/* mvs_no_check  INIT_FRAME_PC */
#define INIT_FRAME_PC		/* Not necessary */

extern void 
m32r_frame_find_saved_regs PARAMS ((struct frame_info *fi, 
				    struct frame_saved_regs *regaddr));

/* Put here the code to store, into a struct frame_saved_regs,
   the addresses of the saved registers of frame described by FRAME_INFO.
   This includes special registers such as pc and fp saved in special
   ways in the stack frame.  sp is even more special:
   the address we return for it IS the sp for the next frame.  */

/* mvs_check  FRAME_FIND_SAVED_REGS */
#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)	    \
   m32r_frame_find_saved_regs(frame_info, &(frame_saved_regs))

extern CORE_ADDR m32r_frame_chain PARAMS ((struct frame_info *fi));
/* mvs_check  FRAME_CHAIN */
#define FRAME_CHAIN(fi) m32r_frame_chain (fi)

extern int generic_frame_chain_valid PARAMS ((CORE_ADDR, struct frame_info *));
#define FRAME_CHAIN_VALID(fp, frame)	(generic_frame_chain_valid (fp, frame))

extern CORE_ADDR m32r_find_callers_reg PARAMS ((struct frame_info *fi, 
						int regnum));
extern CORE_ADDR m32r_frame_saved_pc PARAMS((struct frame_info *));
/* mvs_check  FRAME_SAVED_PC */
#define FRAME_SAVED_PC(fi) (m32r_frame_saved_pc (fi))

/* mvs_check  EXTRACT_RETURN_VALUE */
#define EXTRACT_RETURN_VALUE(TYPE, REGBUF, VALBUF) \
  memcpy ((VALBUF), \
	  (char *)(REGBUF) + REGISTER_BYTE (V0_REGNUM) + \
	  ((TYPE_LENGTH (TYPE) > 4 ? 8 : 4) - TYPE_LENGTH (TYPE)), \
	  TYPE_LENGTH (TYPE))

/* mvs_check  STORE_RETURN_VALUE */
#define STORE_RETURN_VALUE(TYPE, VALBUF) \
  write_register_bytes(REGISTER_BYTE (V0_REGNUM) + \
		       ((TYPE_LENGTH (TYPE) > 4 ? 8:4) - TYPE_LENGTH (TYPE)),\
		       (VALBUF), TYPE_LENGTH (TYPE));

extern CORE_ADDR m32r_skip_prologue PARAMS ((CORE_ADDR pc));
/* mvs_check  SKIP_PROLOGUE */
#define SKIP_PROLOGUE(pc) pc = m32r_skip_prologue (pc)

/* mvs_no_check  FRAME_ARGS_SKIP */
#define FRAME_ARGS_SKIP 0

/* mvs_no_check  FRAME_ARGS_ADDRESS */
#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame)
/* mvs_no_check  FRAME_LOCALS_ADDRESS */
#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame)
/* mvs_no_check  FRAME_NUM_ARGS */
#define FRAME_NUM_ARGS(val, fi) ((val) = -1)

#define COERCE_FLOAT_TO_DOUBLE 1

#define TARGET_WRITE_SP m32r_write_sp


/* struct passing and returning stuff */
#define STORE_STRUCT_RETURN(STRUCT_ADDR, SP)	\
	write_register (0, STRUCT_ADDR)

#define USE_STRUCT_CONVENTION(GCC_P, TYPE) \
	(TYPE_LENGTH (TYPE) > 8)

#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
  (extract_address (REGBUF + REGISTER_BYTE (V0_REGNUM), \
		    REGISTER_RAW_SIZE (V0_REGNUM)))

#define REG_STRUCT_HAS_ADDR(gcc_p,type)     (TYPE_LENGTH (type) > 8)


/* generic dummy frame stuff */

extern CORE_ADDR generic_read_register_dummy PARAMS ((struct frame_info *fi,
						      int regno));

extern void generic_push_dummy_frame    PARAMS ((void));
extern void generic_pop_dummy_frame     PARAMS ((void));

extern int  generic_pc_in_call_dummy    PARAMS ((CORE_ADDR pc, 
						 CORE_ADDR fp, 
						 CORE_ADDR sp));
extern char * generic_find_dummy_frame  PARAMS ((CORE_ADDR pc, 
						 CORE_ADDR fp, 
						 CORE_ADDR sp));

#define PUSH_DUMMY_FRAME             (generic_push_dummy_frame ())
#define PC_IN_CALL_DUMMY(PC, SP, FP) (generic_pc_in_call_dummy (PC, SP, FP))


/* target-specific dummy_frame stuff */

extern struct frame_info *m32r_pop_frame PARAMS ((struct frame_info *frame));
/* mvs_check  POP_FRAME */
#define POP_FRAME m32r_pop_frame (get_current_frame ())

/* mvs_no_check  STACK_ALIGN */
/* #define STACK_ALIGN(x) ((x + 3) & ~3) */

extern void m32r_push_return_address PARAMS ((CORE_ADDR));
extern CORE_ADDR m32r_push_arguments PARAMS ((int nargs, 
					      struct value **args, 
					      CORE_ADDR sp,
					      unsigned char struct_return,
					      CORE_ADDR struct_addr));


/* mvs_no_check  PUSH_ARGUMENTS */
#define PUSH_ARGUMENTS(NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) \
  (SP) = m32r_push_arguments (NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR)


#define CALL_DUMMY                 { } /* mvs_no_check  CALL_DUMMY */
#define CALL_DUMMY_ADDRESS() (entry_point_address ()) /* mvs_no_check  CALL_DUMMY_ADDRESS */

#define CALL_DUMMY_START_OFFSET    (0) /* mvs_no_check  CALL_DUMMY_START_OFFSET */
#define CALL_DUMMY_BREAKPOINT_OFFSET (0) /* mvs_no_check  CALL_DUMMY_BREAKPOINT_OFFSET */
#define CALL_DUMMY_LENGTH  (0)	/* mvs_no_check CALL_DUMMY_LENGTH */

/* mvs_no_check  FIX_CALL_DUMMY */
#define FIX_CALL_DUMMY(DUMMY1, START_SP, FUNADDR, NARGS, \
		       ARGS, VALUE_TYPE, USING_GCC)

#define CALL_DUMMY_LOCATION        AT_ENTRY_POINT
#define PUSH_RETURN_ADDRESS(pc)      (m32r_push_return_address (pc))
Commit	Line	Data
70ab088d MS	1	/* Parameters for execution on a Mitsubishi m32r processor.
	2	Copyright 1996
	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, Boston, MA 02111-1307, USA. */
	20
	21	/* mvs_check TARGET_BYTE_ORDER BIG_ENDIAN */
	22	#define TARGET_BYTE_ORDER BIG_ENDIAN
	23
	24	/* mvs_check REGISTER_NAMES */
	25	#define REGISTER_NAMES \
	26	{ "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \
	27	"r8", "r9", "r10", "r11", "r12", "fp", "lr", "sp", \
	28	"psw", "cbr", "spi", "spu", "bpc", "pc", "accl", "acch", \
	29	/* "cond", "sm", "bsm", "ie", "bie", "bcarry", */ \
	30	}
	31	/* mvs_check NUM_REGS */
	32	#define NUM_REGS 24
	33
	34	/* mvs_check REGISTER_SIZE */
	35	#define REGISTER_SIZE 4
	36	/* mvs_check MAX_REGISTER_RAW_SIZE */
	37	#define MAX_REGISTER_RAW_SIZE 4
	38
	39	/* mvs_check _REGNUM /
	40	#define R0_REGNUM 0
6f3eea2b	41	#define STRUCT_RETURN_REGNUM 0
70ab088d MS	42	#define ARG0_REGNUM 0
	43	#define ARGLAST_REGNUM 3
	44	#define V0_REGNUM 0
	45	#define V1_REGNUM 1
	46	#define FP_REGNUM 13
	47	#define RP_REGNUM 14
	48	#define SP_REGNUM 15
	49	#define PSW_REGNUM 16
	50	#define CBR_REGNUM 17
	51	#define SPI_REGNUM 18
	52	#define SPU_REGNUM 19
	53	#define BPC_REGNUM 20
	54	#define PC_REGNUM 21
	55	#define ACCL_REGNUM 22
	56	#define ACCH_REGNUM 23
	57
	58	/* mvs_check REGISTER_BYTES */
	59	#define REGISTER_BYTES (NUM_REGS * 4)
	60
	61	/* mvs_check REGISTER_VIRTUAL_TYPE */
	62	#define REGISTER_VIRTUAL_TYPE(REG) builtin_type_int
	63
	64	/* mvs_check REGISTER_BYTE */
	65	#define REGISTER_BYTE(REG) ((REG) * 4)
	66	/* mvs_check REGISTER_VIRTUAL_SIZE */
	67	#define REGISTER_VIRTUAL_SIZE(REG) 4
	68	/* mvs_check REGISTER_RAW_SIZE */
	69	#define REGISTER_RAW_SIZE(REG) 4
	70
	71	/* mvs_check MAX_REGISTER_VIRTUAL_SIZE */
	72	#define MAX_REGISTER_VIRTUAL_SIZE 4
	73
	74	/* mvs_check BREAKPOINT */
	75	#define BREAKPOINT {0x10, 0xf1}
	76
	77	/* mvs_no_check FUNCTION_START_OFFSET */
	78	#define FUNCTION_START_OFFSET 0
	79
	80	/* mvs_check DECR_PC_AFTER_BREAK */
	81	#define DECR_PC_AFTER_BREAK 0
	82
	83	/* mvs_check INNER_THAN */
	84	#define INNER_THAN <
	85
	86	/* mvs_check SAVED_PC_AFTER_CALL */
	87	#define SAVED_PC_AFTER_CALL(fi) read_register (RP_REGNUM)
	88
	89	#ifdef __STDC__
	90	struct frame_info;
	91	struct frame_saved_regs;
	92	struct type;
	93	struct value;
	94	#endif
	95
70ab088d	96	/* Define other aspects of the stack frame.
e1703d1f MS	97	We keep the offsets of all saved registers, 'cause we need 'em a lot!
	98	We also keep the current size of the stack frame, and whether
	99	the frame pointer is valid (for frameless functions, and when we're
	100	still in the prologue of a function with a frame) */
70ab088d MS	101
70ab088d MS	102	/* mvs_check EXTRA_FRAME_INFO */
e1703d1f MS	103	#define EXTRA_FRAME_INFO \
	104	struct frame_saved_regs fsr; \
	105	int framesize; \
	106	int using_frame_pointer;
	107
70ab088d MS	108
	109	extern void m32r_init_extra_frame_info PARAMS ((struct frame_info *fi));
	110	/* mvs_check INIT_EXTRA_FRAME_INFO */
	111	#define INIT_EXTRA_FRAME_INFO(fromleaf, fi) m32r_init_extra_frame_info (fi)
	112	/* mvs_no_check INIT_FRAME_PC */
	113	#define INIT_FRAME_PC /* Not necessary */
	114
	115	extern void
	116	m32r_frame_find_saved_regs PARAMS ((struct frame_info *fi,
	117	struct frame_saved_regs *regaddr));
	118
	119	/* Put here the code to store, into a struct frame_saved_regs,
	120	the addresses of the saved registers of frame described by FRAME_INFO.
	121	This includes special registers such as pc and fp saved in special
	122	ways in the stack frame. sp is even more special:
	123	the address we return for it IS the sp for the next frame. */
	124
	125	/* mvs_check FRAME_FIND_SAVED_REGS */
	126	#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
	127	m32r_frame_find_saved_regs(frame_info, &(frame_saved_regs))
	128
	129	extern CORE_ADDR m32r_frame_chain PARAMS ((struct frame_info *fi));
	130	/* mvs_check FRAME_CHAIN */
	131	#define FRAME_CHAIN(fi) m32r_frame_chain (fi)
	132
6f3eea2b MS	133	extern int generic_frame_chain_valid PARAMS ((CORE_ADDR, struct frame_info *));
	134	#define FRAME_CHAIN_VALID(fp, frame) (generic_frame_chain_valid (fp, frame))
	135
70ab088d MS	136	extern CORE_ADDR m32r_find_callers_reg PARAMS ((struct frame_info *fi,
70ab088d MS	137	int regnum));
6f3eea2b	138	extern CORE_ADDR m32r_frame_saved_pc PARAMS((struct frame_info *));
70ab088d	139	/* mvs_check FRAME_SAVED_PC */
6f3eea2b	140	#define FRAME_SAVED_PC(fi) (m32r_frame_saved_pc (fi))
70ab088d MS	141
	142	/* mvs_check EXTRACT_RETURN_VALUE */
	143	#define EXTRACT_RETURN_VALUE(TYPE, REGBUF, VALBUF) \
	144	memcpy ((VALBUF), \
	145	(char *)(REGBUF) + REGISTER_BYTE (V0_REGNUM) + \
	146	((TYPE_LENGTH (TYPE) > 4 ? 8 : 4) - TYPE_LENGTH (TYPE)), \
	147	TYPE_LENGTH (TYPE))
	148
	149	/* mvs_check STORE_RETURN_VALUE */
	150	#define STORE_RETURN_VALUE(TYPE, VALBUF) \
	151	write_register_bytes(REGISTER_BYTE (V0_REGNUM) + \
	152	((TYPE_LENGTH (TYPE) > 4 ? 8:4) - TYPE_LENGTH (TYPE)),\
	153	(VALBUF), TYPE_LENGTH (TYPE));
	154
70ab088d MS	155	extern CORE_ADDR m32r_skip_prologue PARAMS ((CORE_ADDR pc));
	156	/* mvs_check SKIP_PROLOGUE */
	157	#define SKIP_PROLOGUE(pc) pc = m32r_skip_prologue (pc)
	158
	159	/* mvs_no_check FRAME_ARGS_SKIP */
	160	#define FRAME_ARGS_SKIP 0
	161
	162	/* mvs_no_check FRAME_ARGS_ADDRESS */
	163	#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame)
	164	/* mvs_no_check FRAME_LOCALS_ADDRESS */
	165	#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame)
	166	/* mvs_no_check FRAME_NUM_ARGS */
	167	#define FRAME_NUM_ARGS(val, fi) ((val) = -1)
	168
6f3eea2b	169	#define COERCE_FLOAT_TO_DOUBLE 1
70ab088d	170
6f3eea2b	171	#define TARGET_WRITE_SP m32r_write_sp
70ab088d	172
70ab088d	173
70ab088d	174
70ab088d	175
70ab088d	176
6f3eea2b MS	177
	178	/* struct passing and returning stuff */
	179	#define STORE_STRUCT_RETURN(STRUCT_ADDR, SP) \
	180	write_register (0, STRUCT_ADDR)
	181
	182	#define USE_STRUCT_CONVENTION(GCC_P, TYPE) \
	183	(TYPE_LENGTH (TYPE) > 8)
	184
	185	#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
	186	(extract_address (REGBUF + REGISTER_BYTE (V0_REGNUM), \
	187	REGISTER_RAW_SIZE (V0_REGNUM)))
	188
	189	#define REG_STRUCT_HAS_ADDR(gcc_p,type) (TYPE_LENGTH (type) > 8)
	190
	191
	192
	193
	194
	195	/* generic dummy frame stuff */
	196
	197	extern CORE_ADDR generic_read_register_dummy PARAMS ((struct frame_info *fi,
	198	int regno));
	199
	200	extern void generic_push_dummy_frame PARAMS ((void));
	201	extern void generic_pop_dummy_frame PARAMS ((void));
	202
	203	extern int generic_pc_in_call_dummy PARAMS ((CORE_ADDR pc,
	204	CORE_ADDR fp,
	205	CORE_ADDR sp));
	206	extern char * generic_find_dummy_frame PARAMS ((CORE_ADDR pc,
	207	CORE_ADDR fp,
	208	CORE_ADDR sp));
	209
	210	#define PUSH_DUMMY_FRAME (generic_push_dummy_frame ())
	211	#define PC_IN_CALL_DUMMY(PC, SP, FP) (generic_pc_in_call_dummy (PC, SP, FP))
	212
	213
	214	/* target-specific dummy_frame stuff */
	215
	216	extern struct frame_info m32r_pop_frame PARAMS ((struct frame_info frame));
	217	/* mvs_check POP_FRAME */
	218	#define POP_FRAME m32r_pop_frame (get_current_frame ())
70ab088d MS	219
70ab088d MS	220	/* mvs_no_check STACK_ALIGN */
6f3eea2b MS	221	/* #define STACK_ALIGN(x) ((x + 3) & ~3) */
	222
	223	extern void m32r_push_return_address PARAMS ((CORE_ADDR));
	224	extern CORE_ADDR m32r_push_arguments PARAMS ((int nargs,
	225	struct value **args,
	226	CORE_ADDR sp,
	227	unsigned char struct_return,
	228	CORE_ADDR struct_addr));
	229
	230
70ab088d	231
70ab088d MS	232	/* mvs_no_check PUSH_ARGUMENTS */
	233	#define PUSH_ARGUMENTS(NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) \
	234	(SP) = m32r_push_arguments (NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR)
	235
70ab088d	236
70ab088d	237
6f3eea2b MS	238	#define CALL_DUMMY { } /* mvs_no_check CALL_DUMMY */
6f3eea2b MS	239	#define CALL_DUMMY_ADDRESS() (entry_point_address ()) /* mvs_no_check CALL_DUMMY_ADDRESS */
70ab088d	240
6f3eea2b MS	241	#define CALL_DUMMY_START_OFFSET (0) /* mvs_no_check CALL_DUMMY_START_OFFSET */
	242	#define CALL_DUMMY_BREAKPOINT_OFFSET (0) /* mvs_no_check CALL_DUMMY_BREAKPOINT_OFFSET */
	243	#define CALL_DUMMY_LENGTH (0) /* mvs_no_check CALL_DUMMY_LENGTH */
	244
	245	/* mvs_no_check FIX_CALL_DUMMY */
	246	#define FIX_CALL_DUMMY(DUMMY1, START_SP, FUNADDR, NARGS, \
	247	ARGS, VALUE_TYPE, USING_GCC)
	248
	249	#define CALL_DUMMY_LOCATION AT_ENTRY_POINT
	250	#define PUSH_RETURN_ADDRESS(pc) (m32r_push_return_address (pc))