[kaffe] CVS kaffe (inaba): Remove unused macros HAVE_ref_eq_int and HAVE_ref_eq_long.

Kaffe CVS cvs-commits at kaffe.org
Fri May 27 20:07:14 PDT 2005


PatchSet 6580 
Date: 2005/05/28 03:01:41
Author: inaba
Branch: HEAD
Tag: (none) 
Log:
Remove unused macros HAVE_ref_eq_int and HAVE_ref_eq_long.

Members: 
	ChangeLog:1.4107->1.4108 
	config/m68k/jit-icode.h:1.2->1.3 
	config/m68k/jit3-icode.h:INITIAL->1.4 
	kaffe/kaffevm/jit3/funcs.h:INITIAL->1.4 

Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.4107 kaffe/ChangeLog:1.4108
--- kaffe/ChangeLog:1.4107	Thu May 26 13:33:37 2005
+++ kaffe/ChangeLog	Sat May 28 03:01:41 2005
@@ -1,3 +1,10 @@
+2005-05-28  Kiyo Inaba <inaba at src.ricoh.co.jp>
+
+	* config/m68k/jit-icode.h,
+	config/m68k/jit3-icode.h,
+	kaffe/kaffevm/jit3/funcs.h:
+	Remove unused macros HAVE_ref_eq_int and HAVE_ref_eq_long.
+
 2005-05-26  Dalibor Topic  <robilad at kaffe.org>
 
         Resynced with GNU Classpath.
@@ -1148,7 +1155,7 @@
 	(libreplace_ls_LIBADD) Add LTLIBINTL to fix a build failure
 	on darwin reported by the tinderbox.
 
-2005-05-21  Kiyo Inaba <inaba@@src.ricoh.co.jp>
+2005-05-21  Kiyo Inaba <inaba at src.ricoh.co.jp>
 
 	* kaffe/kaffevm/systems/unix-jthreads/jthread.c:
 	Fix build fail for '--with-threads=unix-jthreads'.
Index: kaffe/config/m68k/jit-icode.h
diff -u kaffe/config/m68k/jit-icode.h:1.2 kaffe/config/m68k/jit-icode.h:1.3
--- kaffe/config/m68k/jit-icode.h:1.2	Sun Jun 17 16:39:10 2001
+++ kaffe/config/m68k/jit-icode.h	Sat May 28 03:01:45 2005
@@ -11,14 +11,6 @@
 #ifndef __m68k_icode_h
 #define __m68k_icode_h
 
-/*
- * Refs and int/long registers are equivalent.
- * Neither is true on the m68k -- we put refs in aX and ints in dX.
- */
-
-#undef HAVE_ref_eq_int
-#undef HAVE_ref_eq_long
-
 /* Since it won't be set for us by virtue of having one of the above set... */
 #define pusharg_long_idx_inc		2
 
@@ -26,7 +18,6 @@
 /*
  * Define the range checking macros.
  */
-
 #define m68k_floatconst_rangecheck(v)	0
 #define m68k_s16_rangecheck(v)		((v) >= -0x8000 && (v) < 0x8000)
 #define m68k_1_8_rangecheck(v)		((v) >= 1 && (v) <= 8)
@@ -34,7 +25,6 @@
 /*
  * These must be defined for any architecture.
  */
-
 #define HAVE_prologue			prologue_xxC
 #define HAVE_epilogue			epilogue_xxx
 #define HAVE_exception_prologue		eprologue_xxx
@@ -118,7 +108,6 @@
 /*
  * These are required since we distinguish between refs and ints.
  */
-
 #define HAVE_spill_ref			spillr_RCx
 #define HAVE_reload_ref			reloadr_RCx
 
@@ -140,7 +129,6 @@
 /*
  * These are sometimes optional (if long operators are defined)
  */
-
 #define HAVE_adc_int			adci_RRR
 #define HAVE_sbc_int			sbci_RRR
 #define HAVE_ngc_int			ngci_RxR
===================================================================
Checking out kaffe/config/m68k/jit3-icode.h
RCS:  /home/cvs/kaffe/kaffe/config/m68k/jit3-icode.h,v
VERS: 1.4
***************
--- /dev/null	Sun Aug  4 19:57:58 2002
+++ kaffe/config/m68k/jit3-icode.h	Sat May 28 03:07:14 2005
@@ -0,0 +1,248 @@
+/* m68k/jit-icode.h
+ * Define the instructions which are present on the m68k.
+ *
+ * Copyright (c) 1996, 1997
+ *	Transvirtual Technologies, Inc.  All rights reserved.
+ *
+ * See the file "license.terms" for information on usage and redistribution 
+ * of this file. 
+ */
+
+#ifndef __m68k_icode_h
+#define __m68k_icode_h
+
+/* Since it won't be set for us by virtue of having one of the above set... */
+#define pusharg_long_idx_inc		2
+
+/*
+ * Define the range checking macros.
+ */
+#define m68k_s16_rangecheck(v)		((v) >= -0x8000 && (v) < 0x8000)
+#define m68k_1_8_rangecheck(v)		((v) >= 1 && (v) <= 8)
+
+/*
+ * These must be defined for any architecture.
+ */
+#define HAVE_prologue			prologue_xxC
+#define HAVE_epilogue			epilogue_xxx
+#define HAVE_exception_prologue		eprologue_xxx
+
+#define	HAVE_check_stack_limit		check_stack_limit_xRC
+
+#define HAVE_spill_int			spilli_RCx
+#define HAVE_reload_int			reloadi_RCx
+
+#define HAVE_move_int_const		movei_RxC
+#define HAVE_move_int			movei_RxR
+#define HAVE_move_label_const		mover_RxL
+
+#define HAVE_move_int_const_rangecheck(v)	(1)
+
+#define HAVE_add_int			addi_RRR
+#define HAVE_sub_int			subi_RRR
+#define HAVE_mul_int			muli_RRR
+#define HAVE_div_int			divi_RRR
+#define HAVE_rem_int			remi_RRR
+#define HAVE_and_int			andi_RRR
+#define HAVE_or_int			ori_RRR
+#define HAVE_xor_int			xori_RRR
+#define HAVE_ashr_int			ashri_RRR
+#define HAVE_lshr_int			lshri_RRR
+#define HAVE_lshl_int			lshli_RRR
+
+#define HAVE_load_int			loadi_RxR
+#define HAVE_store_int			storei_xRR
+
+#define HAVE_pusharg_int		pushi_xRC
+#define HAVE_popargs			popargs_xxC
+
+#define HAVE_cmp_int			cmpi_xRR
+
+#define HAVE_branch			branch_xCC
+#define HAVE_branch_indirect		branch_indirect_xRC
+#define HAVE_call_ref			call_xCC
+#define HAVE_call			call_xRC
+
+#define HAVE_return_int			returni_Rxx
+#define HAVE_return_long		returnl_Rxx
+
+#define HAVE_returnarg_int		returnargi_xxR
+#define HAVE_returnarg_long		returnargl_xxR
+
+#define HAVE_set_label			set_label_xxC
+#define HAVE_build_key			set_word_xxC
+#define HAVE_build_code_ref		set_wordpc_xxC
+#undef	HAVE_build_const_ref
+
+/*
+ * These are required since we distinguish between refs and ints.
+ */
+#define HAVE_spill_ref			spillr_RCx
+#define HAVE_reload_ref			reloadr_RCx
+
+#define HAVE_move_ref_const		mover_RxC
+#define HAVE_move_ref			mover_RxR
+#define HAVE_move_any			movea_RxR
+
+#define HAVE_move_ref_const_rangecheck(v)	(1)
+
+#define HAVE_add_ref			addr_RRR
+#define HAVE_cmp_ref			cmpr_xRR
+
+#define HAVE_load_ref			loadr_RxR
+#define HAVE_store_ref			storer_xRR
+#define HAVE_pusharg_ref		pushr_xRC
+#define HAVE_return_ref			returnr_Rxx
+#define HAVE_returnarg_ref		returnargr_xxR
+
+/*
+ * These are sometimes optional (if long operators are defined)
+ */
+#define HAVE_adc_int			adci_RRR
+#define HAVE_sbc_int			sbci_RRR
+#define HAVE_ngc_int			ngci_RxR
+
+/*
+ * These are optional but help to optimise the code generated.
+ */
+#define HAVE_add_int_const		addi_RRC
+#define HAVE_sub_int_const		subi_RRC
+#define HAVE_cmp_int_const		cmpi_xRC
+#define HAVE_pusharg_int_const		pushi_xCC
+#define HAVE_load_offset_int		loadi_RRC
+#define HAVE_store_offset_int		storei_xRRC
+#define HAVE_lshl_int_const		lshli_RRC
+
+#define HAVE_add_int_const_rangecheck(v)	(1)
+#define HAVE_sub_int_const_rangecheck(v)	(1)
+#define HAVE_cmp_int_const_rangecheck(v)	(1)
+#define HAVE_pusharg_int_const_rangecheck(v)	(1)
+#define HAVE_load_offset_int_rangecheck(v)	m68k_s16_rangecheck(v)
+#define HAVE_store_offset_int_rangecheck(v)	m68k_s16_rangecheck(v)
+#define HAVE_lshl_int_const_rangecheck(v)	m68k_1_8_rangecheck(v)
+
+#define HAVE_add_ref_const		addr_RRC
+#define HAVE_sub_ref_const		subr_RRC
+#undef	HAVE_cmp_ref_const
+#define HAVE_pusharg_ref_const		pushr_xCC
+#define HAVE_load_offset_ref		loadr_RRC
+#define HAVE_store_offset_ref		storer_xRRC
+
+#define HAVE_add_ref_const_rangecheck(v)	(1)
+#define HAVE_sub_ref_const_rangecheck(v)	(1)
+#undef	HAVE_cmp_ref_const_rangecheck(v)
+#define HAVE_pusharg_ref_const_rangecheck(v)	(1)
+#define HAVE_load_offset_ref_rangecheck(v)	m68k_s16_rangecheck(v)
+#define HAVE_store_offset_ref_rangecheck(v)	m68k_s16_rangecheck(v)
+
+#define HAVE_load_byte			loadb_RxR
+#define HAVE_load_char			loadc_RxR
+#define HAVE_load_short			loads_RxR
+#define HAVE_store_byte			storeb_xRR
+#define HAVE_store_char			stores_xRR
+#define HAVE_store_short		stores_xRR
+
+/*
+ * These are optional if the architecture supports them.
+ */
+#if !defined(HAVE_NO_SWAP_ANY)
+#define HAVE_swap_any			swap_RxR
+#endif
+
+#if !defined(HAVE_NO_MULINTCONST)
+#define HAVE_mul_int_const		muli_RRC
+#endif
+#define HAVE_neg_int			negi_RxR
+#define HAVE_and_int_const		andi_RRC
+#define HAVE_ashr_int_const		ashri_RRC
+#define HAVE_lshr_int_const		lshri_RRC
+
+#define HAVE_mul_int_const_rangecheck(v)	(1)
+#define HAVE_and_int_const_rangecheck(v)	(1)
+#define HAVE_ashr_int_const_rangecheck(v)	m68k_1_8_rangecheck(v)
+#define HAVE_lshr_int_const_rangecheck(v)	m68k_1_8_rangecheck(v)
+
+#undef	HAVE_move_long_const
+#undef	HAVE_move_long
+
+#undef	HAVE_add_long
+#undef	HAVE_sub_long
+#undef	HAVE_mul_long
+#undef	HAVE_div_long
+#undef	HAVE_rem_long
+#undef	HAVE_neg_long
+#undef	HAVE_and_long
+#undef	HAVE_or_long
+#undef	HAVE_xor_long
+#undef	HAVE_ashr_long
+#undef	HAVE_lshl_long
+#undef	HAVE_lshr_long
+
+#undef	HAVE_load_long
+#undef	HAVE_store_long
+
+#undef	HAVE_pusharg_long
+
+#undef	HAVE_lcmp
+
+#undef	HAVE_cvt_int_long
+#define HAVE_cvt_int_byte		cvtib_RxR
+#undef	HAVE_cvt_int_char
+#undef	HAVE_cvt_int_short		cvtis_RxR
+#undef	HAVE_cvt_long_int
+
+#undef	HAVE_get_arg_ptr
+
+#if !defined(HAVE_NO_FLOATING_POINT)
+
+#define m68k_floatconst_rangecheck(v)	0
+
+#define HAVE_spill_float		spillf_RCx
+#define HAVE_reload_float		reloadf_RCx
+#define HAVE_spill_double		spilld_RCx
+#define HAVE_reload_double		reloadd_RCx
+
+#define HAVE_move_float			movef_RxR
+#define HAVE_move_double		moved_RxR
+
+#define HAVE_add_float			addf_RRR
+#define HAVE_sub_float			subf_RRR
+#define HAVE_mul_float			mulf_RRR
+#define HAVE_div_float			divf_RRR
+
+#define HAVE_add_double			addd_RRR
+#define HAVE_sub_double			subd_RRR
+#define HAVE_mul_double			muld_RRR
+#define HAVE_div_double			divd_RRR
+
+#define HAVE_load_float			loadf_RxR
+#define HAVE_store_float		storef_xRR
+#define HAVE_load_double		loadd_RxR
+#define HAVE_store_double		stored_xRR
+
+#define HAVE_pusharg_float		pushf_xRC
+#define HAVE_pusharg_double		pushd_xRC
+
+#define HAVE_return_float		returnf_Rxx
+#define HAVE_return_double		returnd_Rxx
+#define HAVE_returnarg_float		returnargf_xxR
+#define HAVE_returnarg_double		returnargd_xxR
+
+#define HAVE_cvt_int_double		cvtid_RxR
+#define HAVE_cvt_int_float		cvtif_RxR
+#define HAVE_cvt_float_double		cvtfd_RxR
+#define HAVE_cvt_double_float		cvtdf_RxR
+
+#undef	HAVE_cmpg_float
+#undef	HAVE_cmpg_double
+#undef	HAVE_cmpl_float
+#undef	HAVE_cmpl_double
+
+#define HAVE_neg_float			negf_RxR
+#define HAVE_neg_double			negd_RxR
+#define HAVE_rem_float			remf_RRR
+#define HAVE_rem_double			remd_RRR
+
+#endif
+
+#endif
===================================================================
Checking out kaffe/kaffe/kaffevm/jit3/funcs.h
RCS:  /home/cvs/kaffe/kaffe/kaffe/kaffevm/jit3/funcs.h,v
VERS: 1.4
***************
--- /dev/null	Sun Aug  4 19:57:58 2002
+++ kaffe/kaffe/kaffevm/jit3/funcs.h	Sat May 28 03:07:14 2005
@@ -0,0 +1,933 @@
+/* funcs.h
+ *
+ * Copyright (c) 1996, 1997
+ *	Transvirtual Technologies, Inc.  All rights reserved.
+ *
+ * Copyright (c) 2004
+ *	Kaffe.org contributors, see ChangeLogs for details.  All rights reserved.
+ *
+ * See the file "license.terms" for information on usage and redistribution 
+ * of this file. 
+ */
+
+#ifndef __funcs_h
+#define __funcs_h
+
+extern void unimplemented (sequence* s);
+extern void nop (sequence* s);
+
+/* In the likely event that a jit3 implementation uses defines different HAVE_*
+ * macros for the same backend function, you may get compiler warnings about
+ * redundant declarations.
+ */
+#if defined(HAVE_adc_int)
+extern void HAVE_adc_int (sequence* s);
+#endif /* defined(HAVE_adc_int) */
+
+#if defined(HAVE_add_double)
+extern void HAVE_add_double (sequence* s);
+#endif /* defined(HAVE_add_double) */
+
+#if defined(HAVE_add_float)
+extern void HAVE_add_float (sequence* s);
+#endif /* defined(HAVE_add_float) */
+
+#if defined(HAVE_add_int)
+extern void HAVE_add_int (sequence* s);
+#endif /* defined(HAVE_add_int) */
+
+#if defined(HAVE_add_int_const)
+extern void HAVE_add_int_const (sequence* s);
+#endif /* defined(HAVE_add_int_const) */
+
+#if defined(HAVE_add_long)
+extern void HAVE_add_long (sequence* s);
+#endif /* defined(HAVE_add_long) */
+
+#if defined(HAVE_add_long_const)
+extern void HAVE_add_long_const (sequence* s);
+#endif /* defined(HAVE_add_long_const) */
+
+#if defined(HAVE_add_ref)
+extern void HAVE_add_ref (sequence* s);
+#endif /* defined(HAVE_add_ref) */
+
+#if defined(HAVE_add_ref_const)
+extern void HAVE_add_ref_const (sequence* s);
+#endif /* defined(HAVE_add_ref_const) */
+
+#if defined(HAVE_and_int)
+extern void HAVE_and_int (sequence* s);
+#endif /* defined(HAVE_and_int) */
+
+#if defined(HAVE_and_int_const)
+extern void HAVE_and_int_const (sequence* s);
+#endif /* defined(HAVE_and_int_const) */
+
+#if defined(HAVE_and_long)
+extern void HAVE_and_long (sequence* s);
+#endif /* defined(HAVE_and_long) */
+
+#if defined(HAVE_and_long_const)
+extern void HAVE_and_long_const (sequence* s);
+#endif /* defined(HAVE_and_long_const) */
+
+#if defined(HAVE_ashr_int)
+extern void HAVE_ashr_int (sequence* s);
+#endif /* defined(HAVE_ashr_int) */
+
+#if defined(HAVE_ashr_int_const)
+extern void HAVE_ashr_int_const (sequence* s);
+#endif /* defined(HAVE_ashr_int_const) */
+
+#if defined(HAVE_ashr_long)
+extern void HAVE_ashr_long (sequence* s);
+#endif /* defined(HAVE_ashr_long) */
+
+#if defined(HAVE_branch)
+extern void HAVE_branch (sequence* s);
+#endif /* defined(HAVE_branch) */
+
+#if defined(HAVE_branch_indirect)
+extern void HAVE_branch_indirect (sequence* s);
+#endif /* defined(HAVE_branch_indirect) */
+
+#if defined(HAVE_build_code_ref)
+extern void HAVE_build_code_ref (sequence* s);
+#endif /* defined(HAVE_build_code_ref) */
+
+#if defined(HAVE_build_const_ref)
+extern void HAVE_build_const_ref (sequence* s);
+#endif /* defined(HAVE_build_const_ref) */
+
+#if defined(HAVE_branch_and_link)
+extern void HAVE_branch_and_link (sequence* s);
+#endif /* defined(HAVE_branch_and_link) */
+
+#if defined(HAVE_build_key)
+extern void HAVE_build_key (sequence* s);
+#endif /* defined(HAVE_build_key) */
+
+#if defined(HAVE_call)
+extern void HAVE_call (sequence* s);
+#endif /* defined(HAVE_call) */
+
+#if defined(HAVE_call_indirect_const)
+extern void HAVE_call_indirect_const (sequence* s);
+#endif /* defined(HAVE_call_indirect_const) */
+
+#if defined(HAVE_call_ref)
+extern void HAVE_call_ref (sequence* s);
+#endif /* defined(HAVE_call_ref) */
+
+#if defined(HAVE_cbranch_int)
+extern void HAVE_cbranch_int (sequence* s);
+#endif /* defined(HAVE_cbranch_int) */
+
+#if defined(HAVE_cbranch_int_const)
+extern void HAVE_cbranch_int_const (sequence* s);
+#endif /* defined(HAVE_cbranch_int_const) */
+
+#if defined(HAVE_cbranch_ref)
+extern void HAVE_cbranch_ref (sequence* s);
+#endif /* defined(HAVE_cbranch_ref) */
+
+#if defined(HAVE_cbranch_ref_const)
+extern void HAVE_cbranch_ref_const (sequence* s);
+#endif /* defined(HAVE_cbranch_ref_const) */
+
+#if defined(HAVE_check_stack_limit)
+extern void HAVE_check_stack_limit (sequence* s);
+#endif /* defined(HAVE_check_stack_limit) */
+
+#if defined(HAVE_check_stack_limit_constpool)
+extern void HAVE_check_stack_limit_constpool (sequence* s);
+#endif /* defined(HAVE_check_stack_limit_constpool) */
+
+#if defined(HAVE_cmpg_double)
+extern void HAVE_cmpg_double (sequence* s);
+#endif /* defined(HAVE_cmpg_double) */
+
+#if defined(HAVE_cmpg_float)
+extern void HAVE_cmpg_float (sequence* s);
+#endif /* defined(HAVE_cmpg_float) */
+
+#if defined(HAVE_cmp_int)
+extern void HAVE_cmp_int (sequence* s);
+#endif /* defined(HAVE_cmp_int) */
+
+#if defined(HAVE_cmp_int_const)
+extern void HAVE_cmp_int_const (sequence* s);
+#endif /* defined(HAVE_cmp_int_const) */
+
+#if defined(HAVE_cmpl_int)
+extern void HAVE_cmpl_int (sequence* s);
+#endif /* defined(HAVE_cmpl_int) */
+
+#if defined(HAVE_cmpl_double)
+extern void HAVE_cmpl_double (sequence* s);
+#endif /* defined(HAVE_cmpl_double) */
+
+#if defined(HAVE_cmpl_float)
+extern void HAVE_cmpl_float (sequence* s);
+#endif /* defined(HAVE_cmpl_float) */
+
+#if defined(HAVE_cmp_long)
+extern void HAVE_cmp_long (sequence* s);
+#endif /* defined(HAVE_cmp_long) */
+
+#if defined(HAVE_cmp_offset_int)
+extern void HAVE_cmp_offset_int (sequence* s);
+#endif /* defined(HAVE_cmp_offset_int) */
+
+#if defined(HAVE_cmp_ref)
+extern void HAVE_cmp_ref (sequence* s);
+#endif /* defined(HAVE_cmp_ref) */
+
+#if defined(HAVE_cmp_ref_const)
+extern void HAVE_cmp_ref_const (sequence* s);
+#endif /* defined(HAVE_cmp_ref_const) */
+
+#if defined(HAVE_cvt_double_float)
+extern void HAVE_cvt_double_float (sequence* s);
+#endif /* defined(HAVE_cvt_double_float) */
+
+#if defined(HAVE_cvt_double_int)
+extern void HAVE_cvt_double_int (sequence* s);
+#endif /* defined(HAVE_cvt_double_int) */
+
+#if defined(HAVE_cvt_double_long)
+extern void HAVE_cvt_double_long (sequence* s);
+#endif /* defined(HAVE_cvt_double_long) */
+
+#if defined(HAVE_cvt_float_double)
+extern void HAVE_cvt_float_double (sequence* s);
+#endif /* defined(HAVE_cvt_float_double) */
+
+#if defined(HAVE_cvt_float_int)
+extern void HAVE_cvt_float_int (sequence* s);
+#endif /* defined(HAVE_cvt_float_int) */
+
+#if defined(HAVE_cvt_float_long)
+extern void HAVE_cvt_float_long (sequence* s);
+#endif /* defined(HAVE_cvt_float_long) */
+
+#if defined(HAVE_cvt_int_byte)
+extern void HAVE_cvt_int_byte (sequence* s);
+#endif /* defined(HAVE_cvt_int_byte) */
+
+#if defined(HAVE_cvt_int_char)
+extern void HAVE_cvt_int_char (sequence* s);
+#endif /* defined(HAVE_cvt_int_char) */
+
+#if defined(HAVE_cvt_int_double)
+extern void HAVE_cvt_int_double (sequence* s);
+#endif /* defined(HAVE_cvt_int_double) */
+
+#if defined(HAVE_cvt_int_float)
+extern void HAVE_cvt_int_float (sequence* s);
+#endif /* defined(HAVE_cvt_int_float) */
+
+#if defined(HAVE_cvt_int_long)
+extern void HAVE_cvt_int_long (sequence* s);
+#endif /* defined(HAVE_cvt_int_long) */
+
+#if defined(HAVE_cvt_int_short)
+extern void HAVE_cvt_int_short (sequence* s);
+#endif /* defined(HAVE_cvt_int_short) */
+
+#if defined(HAVE_cvt_long_double)
+extern void HAVE_cvt_long_double (sequence* s);
+#endif /* defined(HAVE_cvt_long_double) */
+
+#if defined(HAVE_cvt_long_float)
+extern void HAVE_cvt_long_float (sequence* s);
+#endif /* defined(HAVE_cvt_long_float) */
+
+#if defined(HAVE_cvt_long_int)
+extern void HAVE_cvt_long_int (sequence* s);
+#endif /* defined(HAVE_cvt_long_int) */
+
+#if defined(HAVE_div_double)
+extern void HAVE_div_double (sequence* s);
+#endif /* defined(HAVE_div_double) */
+
+#if defined(HAVE_div_float)
+extern void HAVE_div_float (sequence* s);
+#endif /* defined(HAVE_div_float) */
+
+#if defined(HAVE_div_int)
+extern void HAVE_div_int (sequence* s);
+#endif /* defined(HAVE_div_int) */
+
+#if defined(HAVE_div_long)
+extern void HAVE_div_long (sequence* s);
+#endif /* defined(HAVE_div_long) */
+
+#if defined(HAVE_epilogue)
+extern void HAVE_epilogue (sequence* s);
+#endif /* defined(HAVE_epilogue) */
+
+#if defined(HAVE_exception_prologue)
+extern void HAVE_exception_prologue (sequence* s);
+#endif /* defined(HAVE_exception_prologue) */
+
+#if defined(HAVE_fakecall)
+extern void HAVE_fakecall (sequence* s);
+#endif /* defined(HAVE_fakecall) */
+
+#if defined(HAVE_fakecall_constpool)
+extern void HAVE_fakecall_constpool (sequence* s);
+#endif /* defined(HAVE_fakecall_constpool) */
+
+#if defined(HAVE_get_arg_ptr)
+extern void HAVE_get_arg_ptr (sequence* s);
+#endif /* defined(HAVE_get_arg_ptr) */
+
+#if defined(HAVE_kill_readonce_register)
+extern void HAVE_kill_readonce_register (SlotData *s);
+#endif /* defined(HAVE_kill_readonce_register) */
+
+#if defined(HAVE_lcmp)
+extern void HAVE_lcmp (sequence* s);
+#endif /* defined(HAVE_lcmp) */
+
+#if defined(HAVE_load_addr_byte)
+extern void HAVE_load_addr_byte (sequence* s);
+#endif /* defined(HAVE_load_addr_byte) */
+
+#if defined(HAVE_load_addr_char)
+extern void HAVE_load_addr_char (sequence* s);
+#endif /* defined(HAVE_load_addr_char) */
+
+#if defined(HAVE_load_addr_double)
+extern void HAVE_load_addr_double (sequence* s);
+#endif /* defined(HAVE_load_addr_double) */
+
+#if defined(HAVE_load_addr_float)
+extern void HAVE_load_addr_float (sequence* s);
+#endif /* defined(HAVE_load_addr_float) */
+
+#if defined(HAVE_load_addr_int)
+extern void HAVE_load_addr_int (sequence* s);
+#endif /* defined(HAVE_load_addr_int) */
+
+#if defined(HAVE_load_addr_long)
+extern void HAVE_load_addr_long (sequence* s);
+#endif /* defined(HAVE_load_addr_long) */
+
+#if defined(HAVE_load_addr_ref)
+extern void HAVE_load_addr_ref (sequence* s);
+#endif /* defined(HAVE_load_addr_ref) */
+
+#if defined(HAVE_load_addr_short)
+extern void HAVE_load_addr_short (sequence* s);
+#endif /* defined(HAVE_load_addr_short) */
+
+#if defined(HAVE_load_byte)
+extern void HAVE_load_byte (sequence* s);
+#endif /* defined(HAVE_load_byte) */
+
+#if defined(HAVE_load_char)
+extern void HAVE_load_char (sequence* s);
+#endif /* defined(HAVE_load_char) */
+
+#if defined(HAVE_load_constpool_double)
+extern void HAVE_load_constpool_double (sequence* s);
+#endif /* defined(HAVE_load_constpool_double) */
+
+#if defined(HAVE_load_constpool_float)
+extern void HAVE_load_constpool_float (sequence* s);
+#endif /* defined(HAVE_load_constpool_float) */
+
+#if defined(HAVE_load_constpool_int)
+extern void HAVE_load_constpool_int (sequence* s);
+#endif /* defined(HAVE_load_constpool_int) */
+
+#if defined(HAVE_load_constpool_ref)
+extern void HAVE_load_constpool_ref (sequence* s);
+#endif /* defined(HAVE_load_constpool_ref) */
+
+#if defined(HAVE_load_double)
+extern void HAVE_load_double (sequence* s);
+#endif /* defined(HAVE_load_double) */
+
+#if defined(HAVE_load_float)
+extern void HAVE_load_float (sequence* s);
+#endif /* defined(HAVE_load_float) */
+
+#if defined(HAVE_load_int)
+extern void HAVE_load_int (sequence* s);
+#endif /* defined(HAVE_load_int) */
+
+#if defined(HAVE_load_long)
+extern void HAVE_load_long (sequence* s);
+#endif /* defined(HAVE_load_long) */
+
+#if defined(HAVE_load_offset_byte)
+extern void HAVE_load_offset_byte (sequence* s);
+#endif /* defined(HAVE_load_offset_byte) */
+
+#if defined(HAVE_load_offset_char)
+extern void HAVE_load_offset_char (sequence* s);
+#endif /* defined(HAVE_load_offset_char) */
+
+#if defined(HAVE_load_offset_int)
+extern void HAVE_load_offset_int (sequence* s);
+#endif /* defined(HAVE_load_offset_int) */
+
+#if defined(HAVE_load_offset_float)
+extern void HAVE_load_offset_float (sequence* s);
+#endif /* defined(HAVE_load_offset_float) */
+
+#if defined(HAVE_load_offset_long)
+extern void HAVE_load_offset_long (sequence* s);
+#endif /* defined(HAVE_load_offset_long) */
+
+#if defined(HAVE_load_offset_double)
+extern void HAVE_load_offset_double (sequence* s);
+#endif /* defined(HAVE_load_offset_double) */
+
+#if defined(HAVE_load_offset_ref)
+extern void HAVE_load_offset_ref (sequence* s);
+#endif /* defined(HAVE_load_offset_ref) */
+
+#if defined(HAVE_load_offset_scaled_byte)
+extern void HAVE_load_offset_scaled_byte (sequence* s);
+#endif /* defined(HAVE_load_offset_scaled_byte) */
+
+#if defined(HAVE_load_offset_scaled_char)
+extern void HAVE_load_offset_scaled_char (sequence* s);
+#endif /* defined(HAVE_load_offset_scaled_char) */
+
+#if defined(HAVE_load_offset_scaled_double)
+extern void HAVE_load_offset_scaled_double (sequence* s);
+#endif /* defined(HAVE_load_offset_scaled_double) */
+
+#if defined(HAVE_load_offset_scaled_float)
+extern void HAVE_load_offset_scaled_float (sequence* s);
+#endif /* defined(HAVE_load_offset_scaled_float) */
+
+#if defined(HAVE_load_offset_scaled_int)
+extern void HAVE_load_offset_scaled_int (sequence* s);
+#endif /* defined(HAVE_load_offset_scaled_int) */
+
+#if defined(HAVE_load_offset_scaled_long)
+extern void HAVE_load_offset_scaled_long (sequence* s);
+#endif /* defined(HAVE_load_offset_scaled_long) */
+
+#if defined(HAVE_load_offset_scaled_ref)
+extern void HAVE_load_offset_scaled_ref (sequence* s);
+#endif /* defined(HAVE_load_offset_scaled_ref) */
+
+#if defined(HAVE_load_offset_scaled_short)
+extern void HAVE_load_offset_scaled_short (sequence* s);
+#endif /* defined(HAVE_load_offset_scaled_short) */
+
+#if defined(HAVE_load_ref)
+extern void HAVE_load_ref (sequence* s);
+#endif /* defined(HAVE_load_ref) */
+
+#if defined(HAVE_load_short)
+extern void HAVE_load_short (sequence* s);
+#endif /* defined(HAVE_load_short) */
+
+#if defined(HAVE_lshl_int)
+extern void HAVE_lshl_int (sequence* s);
+#endif /* defined(HAVE_lshl_int) */
+
+#if defined(HAVE_lshl_int_const)
+extern void HAVE_lshl_int_const (sequence* s);
+#endif /* defined(HAVE_lshl_int_const) */
+
+#if defined(HAVE_lshl_long)
+extern void HAVE_lshl_long (sequence* s);
+#endif /* defined(HAVE_lshl_long) */
+
+#if defined(HAVE_lshl_long_const)
+extern void HAVE_lshl_long_const (sequence* s);
+#endif /* defined(HAVE_lshl_long_const) */
+
+#if defined(HAVE_lshr_int)
+extern void HAVE_lshr_int (sequence* s);
+#endif /* defined(HAVE_lshr_int) */
+
+#if defined(HAVE_lshr_int_const)
+extern void HAVE_lshr_int_const (sequence* s);
+#endif /* defined(HAVE_lshr_int_const) */
+
+#if defined(HAVE_lshr_long)
+extern void HAVE_lshr_long (sequence* s);
+#endif /* defined(HAVE_lshr_long) */
+
+#if defined(HAVE_mon_enter)
+extern void HAVE_mon_enter (sequence* s);
+#endif /* defined(HAVE_mon_enter) */
+
+#if defined(HAVE_mon_exit)
+extern void HAVE_mon_exit (sequence* s);
+#endif /* defined(HAVE_mon_exit) */
+
+#if defined(HAVE_move_any)
+extern void HAVE_move_any (sequence* s);
+#endif /* defined(HAVE_move_any) */
+
+#if defined(HAVE_move_double)
+extern void HAVE_move_double (sequence* s);
+#endif /* defined(HAVE_move_double) */
+
+#if defined(HAVE_move_double_const)
+extern void HAVE_move_double_const (sequence* s);
+#endif /* defined(HAVE_move_double_const) */
+
+#if defined(HAVE_move_float)
+extern void HAVE_move_float (sequence* s);
+#endif /* defined(HAVE_move_float) */
+
+#if defined(HAVE_move_float_const)
+extern void HAVE_move_float_const (sequence* s);
+#endif /* defined(HAVE_move_float_const) */
+
+#if defined(HAVE_move_int)
+extern void HAVE_move_int (sequence* s);
+#endif /* defined(HAVE_move_int) */
+
+#if defined(HAVE_move_int_const)
+extern void HAVE_move_int_const (sequence* s);
+#endif /* defined(HAVE_move_int_const) */
+
+#if defined(HAVE_move_int_const_incode)
+extern void HAVE_move_int_const_incode (sequence* s);
+#endif /* defined(HAVE_move_int_const_incode) */
+
+/*
+#if defined(HAVE_move_int_const_rangecheck)
+extern void HAVE_move_int_const_rangecheck (sequence* s);
+#endif *//* defined(HAVE_move_int_const_rangecheck) */
+
+
+#if defined(HAVE_move_label_const)
+extern void HAVE_move_label_const (sequence* s);
+#endif /* defined(HAVE_move_label_const) */
+
+#if defined(HAVE_move_long)
+extern void HAVE_move_long (sequence* s);
+#endif /* defined(HAVE_move_long) */
+
+#if defined(HAVE_move_long_const)
+extern void HAVE_move_long_const (sequence* s);
+#endif /* defined(HAVE_move_long_const) */
+
+#if defined(HAVE_move_ref)
+extern void HAVE_move_ref (sequence* s);
+#endif /* defined(HAVE_move_ref) */
+
+#if defined(HAVE_move_ref_const)
+extern void HAVE_move_ref_const (sequence* s);
+#endif /* defined(HAVE_move_ref_const) */
+
+#if defined(HAVE_move_register_int)
+extern void HAVE_move_register_int (int toreg, int fromreg);
+#endif /* defined(HAVE_move_register_int) */
+
+#if defined(HAVE_move_register_ref)
+extern void HAVE_move_register_ref (int toreg, int fromreg);
+#endif /* defined(HAVE_move_register_ref) */
+
+#if defined(HAVE_mul_double)
+extern void HAVE_mul_double (sequence* s);
+#endif /* defined(HAVE_mul_double) */
+
+#if defined(HAVE_mul_float)
+extern void HAVE_mul_float (sequence* s);
+#endif /* defined(HAVE_mul_float) */
+
+#if defined(HAVE_mul_int)
+extern void HAVE_mul_int (sequence* s);
+#endif /* defined(HAVE_mul_int) */
+
+#if defined(HAVE_mul_int_const)
+extern void HAVE_mul_int_const (sequence* s);
+#endif /* defined(HAVE_mul_int_const) */
+
+#if defined(HAVE_mul_long)
+extern void HAVE_mul_long (sequence* s);
+#endif /* defined(HAVE_mul_long) */
+
+#if defined(HAVE_neg_double)
+extern void HAVE_neg_double (sequence* s);
+#endif /* defined(HAVE_neg_double) */
+
+#if defined(HAVE_neg_float)
+extern void HAVE_neg_float (sequence* s);
+#endif /* defined(HAVE_neg_float) */
+
+#if defined(HAVE_neg_int)
+extern void HAVE_neg_int (sequence* s);
+#endif /* defined(HAVE_neg_int) */
+
+#if defined(HAVE_neg_long)
+extern void HAVE_neg_long (sequence* s);
+#endif /* defined(HAVE_neg_long) */
+
+#if defined(HAVE_ngc_int)
+extern void HAVE_ngc_int (sequence* s);
+#endif /* defined(HAVE_ngc_int) */
+
+#if defined(HAVE_nor_int)
+extern void HAVE_nor_int (sequence* s);
+#endif /* defined(HAVE_nor_int) */
+
+#if defined(HAVE_or_int)
+extern void HAVE_or_int (sequence* s);
+#endif /* defined(HAVE_or_int) */
+
+#if defined(HAVE_or_int_const)
+extern void HAVE_or_int_const (sequence* s);
+#endif /* defined(HAVE_or_int_const) */
+
+#if defined(HAVE_or_long)
+extern void HAVE_or_long (sequence* s);
+#endif /* defined(HAVE_or_long) */
+
+#if defined(HAVE_popargs)
+extern void HAVE_popargs (sequence* s);
+#endif /* defined(HAVE_popargs) */
+
+#if defined(HAVE_pop_frame)
+extern void HAVE_pop_frame (sequence* s);
+#endif /* defined(HAVE_pop_frame) */
+
+#if defined(HAVE_prologue)
+extern void HAVE_prologue (sequence* s);
+#endif /* defined(HAVE_prologue) */
+
+#if defined(HAVE_pusharg_double)
+extern void HAVE_pusharg_double (sequence* s);
+#endif /* defined(HAVE_pusharg_double) */
+
+#if defined(HAVE_pusharg_float)
+extern void HAVE_pusharg_float (sequence* s);
+#endif /* defined(HAVE_pusharg_float) */
+
+#if defined(HAVE_pusharg_int)
+extern void HAVE_pusharg_int (sequence* s);
+#endif /* defined(HAVE_pusharg_int) */
+
+#if defined(HAVE_pusharg_int_const)
+extern void HAVE_pusharg_int_const (sequence* s);
+#endif /* defined(HAVE_pusharg_int_const) */
+
+#if defined(HAVE_pusharg_long)
+extern void HAVE_pusharg_long (sequence* s);
+#endif /* defined(HAVE_pusharg_long) */
+
+#if defined(HAVE_pusharg_ref)
+extern void HAVE_pusharg_ref (sequence* s);
+#endif /* defined(HAVE_pusharg_ref) */
+
+#if defined(HAVE_pusharg_ref_const)
+extern void HAVE_pusharg_ref_const (sequence* s);
+#endif /* defined(HAVE_pusharg_ref_const) */
+
+#if defined(HAVE_push_frame)
+extern void HAVE_push_frame (sequence* s);
+#endif /* defined(HAVE_push_frame) */
+
+#if defined(HAVE_reload_double)
+extern void HAVE_reload_double (sequence* s);
+#endif /* defined(HAVE_reload_double) */
+
+#if defined(HAVE_reload_float)
+extern void HAVE_reload_float (sequence* s);
+#endif /* defined(HAVE_reload_float) */
+
+#if defined(HAVE_reload_int)
+extern void HAVE_reload_int (sequence* s);
+#endif /* defined(HAVE_reload_int) */

*** Patch too long, truncated ***




More information about the kaffe mailing list