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 <[EMAIL PROTECTED]>
+
+ * 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 <[EMAIL PROTECTED]>
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 <[EMAIL PROTECTED]>
* 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 ***
_______________________________________________
kaffe mailing list
[email protected]
http://kaffe.org/cgi-bin/mailman/listinfo/kaffe
