[kaffe] CVS kaffe (guilhem): Integer optimization fix

Kaffe CVS cvs-commits at kaffe.org
Mon Apr 11 10:49:58 PDT 2005


PatchSet 5672 
Date: 2005/04/11 17:43:41
Author: guilhem
Branch: HEAD
Tag: (none) 
Log:
Integer optimization fix

2005-04-11  Rei Odaira  <ray at is.s.u-tokyo.ac.jp>

        * kaffe/kaffevm/jit3/icode.c
        (div_int_const_optimize): Fixed rounding.

        * test/regression/NegativeDivideConst.java:
        Check the rounding result.

Members: 
	ChangeLog:1.3838->1.3839 
	kaffe/kaffevm/jit3/icode.c:INITIAL->1.52 
	test/regression/NegativeDivideConst.java:1.1->1.2 

Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.3838 kaffe/ChangeLog:1.3839
--- kaffe/ChangeLog:1.3838	Mon Apr 11 14:46:09 2005
+++ kaffe/ChangeLog	Mon Apr 11 17:43:41 2005
@@ -1,3 +1,11 @@
+2005-04-11  Rei Odaira  <ray at is.s.u-tokyo.ac.jp>
+
+	* kaffe/kaffevm/jit3/icode.c
+	(div_int_const_optimize): Fixed rounding.
+
+	* test/regression/NegativeDivideConst.java:
+	Check the rounding result.
+	
 2005-04-11  Guilhem Lavaux  <guilhem at kaffe.org>
 	Rei Odaira <ray at is.s.u-tokyo.ac.jp>
 
===================================================================
Checking out kaffe/kaffe/kaffevm/jit3/icode.c
RCS:  /home/cvs/kaffe/kaffe/kaffe/kaffevm/jit3/icode.c,v
VERS: 1.52
***************
--- /dev/null	Sun Aug  4 19:57:58 2002
+++ kaffe/kaffe/kaffevm/jit3/icode.c	Mon Apr 11 17:49:58 2005
@@ -0,0 +1,5340 @@
+/* icode.c
+ * Define the instructions.
+ *
+ * Copyright (c) 1996, 1997
+ *	Transvirtual Technologies, Inc.  All rights reserved.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file.
+ */
+
+#include "config.h"
+#include "config-std.h"
+#include "config-mem.h"
+#include "gtypes.h"
+#include "slots.h"
+#include "seq.h"
+#include "md.h"
+#include "registers.h"
+#include "basecode.h"
+#include "labels.h"
+#include "constpool.h"
+#include "icode.h"
+#include "soft.h"
+#include "access.h"
+#include "object.h"
+#include "constants.h"
+#include "classMethod.h"
+#include "gc.h"
+#include "itypes.h"
+#include "locks.h"
+#include "machine.h"
+#include "codeproto.h"
+#include "thread.h"
+#include "jthread.h"
+#include "support.h"
+#include "code-analyse.h"
+#include "funcs.h"
+#include "kaffe_jni.h"
+
+#if defined(HAVE_branch_and_link)
+#define blink 0x8000000
+#else
+#define blink 0
+#endif
+
+/*
+ * This flag can turn off array bounds checking.
+ *  - for experimental purposes only.
+ */
+int noArrayBoundsChecks = 0;
+
+#if defined(WORDS_BIGENDIAN)
+#define	LSLOT(_s)	((_s)+1)
+#define	HSLOT(_s)	(_s)
+#else
+#define	LSLOT(_s)	(_s)
+#define	HSLOT(_s)	((_s)+1)
+#endif
+
+bool used_ieee_rounding;
+bool used_ieee_division;
+
+sequence* lastSpill;
+
+#define	MAXLABTAB	64
+label* labtab[MAXLABTAB];
+
+static void _call_soft(void *routine, int profiled);
+
+/* ----------------------------------------------------------------------- */
+/* Register loads and spills.						   */
+/*									   */
+
+#if defined(HAVE_spill_int)
+
+void
+spill_int(SlotData* src)
+{
+	sequence s;
+	seq_dst(&s) = src;
+	seq_value(&s, 1) = slotOffsetNoSpill(src, Rint);
+	HAVE_spill_int(&s);
+}
+#endif
+
+#if defined(HAVE_reload_int)
+
+void
+reload_int(SlotData* dst)
+{
+	sequence s;
+	seq_dst(&s) = dst;
+	seq_value(&s, 1) = slotOffsetNoSpill(dst, Rint);
+	HAVE_reload_int(&s);
+}
+#endif
+
+#if defined(HAVE_spill_ref)
+
+void
+spill_ref(SlotData* src)
+{
+	sequence s;
+	seq_dst(&s) = src;
+	seq_value(&s, 1) = slotOffsetNoSpill(src, Rref);
+	HAVE_spill_ref(&s);
+}
+#endif
+
+#if defined(HAVE_reload_ref)
+
+void
+reload_ref(SlotData* dst)
+{
+	sequence s;
+	seq_dst(&s) = dst;
+	seq_value(&s, 1) = slotOffsetNoSpill(dst, Rref);
+	HAVE_reload_ref(&s);
+}
+#endif
+
+#if defined(HAVE_spill_long)
+
+void
+spill_long(SlotData* src)
+{
+	sequence s;
+	seq_dst(&s) = src;
+	seq_value(&s, 1) = slotOffsetNoSpill(src, Rlong);
+	HAVE_spill_long(&s);
+}
+#endif
+
+#if defined(HAVE_reload_long)
+
+void
+reload_long(SlotData* dst)
+{
+	sequence s;
+	seq_dst(&s) = dst;
+	seq_value(&s, 1) = slotOffsetNoSpill(dst, Rlong);
+	HAVE_reload_long(&s);
+}
+#endif
+
+#if defined(HAVE_spill_float)
+
+void
+spill_float(SlotData* src)
+{
+	sequence s;
+	seq_dst(&s) = src;
+	seq_value(&s, 1) = slotOffsetNoSpill(src, Rfloat);
+	HAVE_spill_float(&s);
+}
+#endif
+
+#if defined(HAVE_reload_float)
+
+void
+reload_float(SlotData* dst)
+{
+	sequence s;
+	seq_dst(&s) = dst;
+	seq_value(&s, 1) = slotOffsetNoSpill(dst, Rfloat);
+	HAVE_reload_float(&s);
+}
+#endif
+
+#if defined(HAVE_spill_double)
+
+void
+spill_double(SlotData* src)
+{
+	sequence s;
+	seq_dst(&s) = src;
+	seq_value(&s, 1) = slotOffsetNoSpill(src, Rdouble);
+	HAVE_spill_double(&s);
+}
+#endif
+
+#if defined(HAVE_reload_double)
+
+void
+reload_double(SlotData* dst)
+{
+	sequence s;
+	seq_dst(&s) = dst;
+	seq_value(&s, 1) = slotOffsetNoSpill(dst, Rdouble);
+	HAVE_reload_double(&s);
+}
+#endif
+
+void
+copyslots(SlotInfo* dst, SlotInfo* src, int type)
+{
+	slot_slot_slot(dst, NULL, src, slotAlias, Tcopy);
+	activeSeq->u[1].value.i = type;
+}
+
+void
+copylslots(SlotInfo* dst, SlotInfo* src, int type)
+{
+	lslot_lslot_lslot(dst, NULL, src, slotAlias, Tcopy);
+	activeSeq->u[1].value.i = type;
+}
+
+/* ----------------------------------------------------------------------- */
+/* Prologues and epilogues.						   */
+/*									   */
+
+void
+prologue(Method* meth)
+{
+	label* l;
+
+	used_ieee_rounding = false;
+	used_ieee_division = false;
+
+	l = KaffeJIT3_newLabel();
+	l->type = Lnull;
+	l->at = 0;
+	l->to = 0;
+	l->from = 0;
+
+	setupSlotsForBasicBlock();
+	setupGlobalRegisters();
+	setupArgumentRegisters();
+
+	/* Emit prologue code */
+	slot_const_const(NULL, (jword)l, (jword)meth, HAVE_prologue, Tnull);
+        slot_const_const(NULL, (jword)createSpillMask(), SR_START, doReload, Tnull);
+	
+#if defined(ENABLE_JVMPI)
+	{
+		SlotInfo *tmp;
+
+		slot_alloctmp(tmp);
+		if( METHOD_IS_STATIC(meth) )
+			move_ref_const(tmp, NULL);
+		else
+			move_ref(tmp, local(0));
+		softcall_enter_method(tmp, meth);
+		slot_freetmp(tmp);
+	}
+#endif
+}
+
+void
+check_stack_limit(void)
+{
+#if defined(STACK_LIMIT)
+#if defined(HAVE_check_stack_limit_constpool)
+	label* l;
+	constpool* c;
+
+	l = KaffeJIT3_newLabel();
+	c = KaffeJIT3_newConstant(CPref, soft_stackoverflow);
+	l->type = Lexternal;
+	l->at = 0;
+	l->to = (uintp)c;
+	l->from = 0;
+
+	slot_slot_const(NULL, stack_limit, (jword)l, HAVE_check_stack_limit_constpool, Tnull);
+#elif defined(HAVE_check_stack_limit)
+	label* l;
+
+	l = KaffeJIT3_newLabel();
+	l->type = Lexternal;
+	l->at = 0;
+	l->to = (uintp)soft_stackoverflow;
+	l->from = 0;
+
+	slot_slot_const(NULL, stack_limit, (jword)l, HAVE_check_stack_limit, Tnull);
+#endif
+#endif /* STACK_LIMIT */
+}
+
+void
+exception_prologue(void)
+{
+	label* l;
+
+	l = KaffeJIT3_newLabel();
+	l->type = Lnull;
+	l->at = 0;
+	l->to = 0;
+	l->from = 0;
+
+	/* Emit exception prologue code */
+	slot_const_const(NULL, (jword)l, 0, HAVE_exception_prologue, Tnull);
+        slot_const_const(NULL, (jword)createSpillMask(), SR_EXCEPTION, doReload, Tnull);
+}
+
+void
+epilogue(Method* meth UNUSED)
+{
+	label* l;
+	
+	l = KaffeJIT3_newLabel();
+	l->type = Lnull;	/* Lnegframe|Labsolute|Lgeneral */
+	l->at = 0;
+	l->to = 0;
+	l->from = 0;
+#if defined(TRACE_METHOD_END)
+	if (Kaffe_JavaVMArgs.enableVerboseCall != 0) {
+                begin_func_sync();
+                call_soft(soft_end);
+                popargs();
+                end_func_sync();
+        }
+#endif
+
+	slot_const_const(NULL, (jword)l, 0, HAVE_epilogue, Tnull);
+}
+
+void
+ret(void)
+{
+	label *l;
+
+	l = KaffeJIT3_newLabel();
+	l->at = 0;
+	l->to = 0;
+	l->from = 0;
+
+	/* Jump to epilogue */
+	l->type = Lepilogue;
+	branch (l, ba);
+}
+
+
+/* ----------------------------------------------------------------------- */
+/* Conditional monitor management.					   */
+/*									   */
+
+void
+mon_enter(methods* meth, SlotInfo* obj)
+{
+	/* Emit monitor entry if required */
+	if ((meth->accflags & ACC_SYNCHRONISED) == 0) {
+		return;
+	}
+#if defined(HAVE_mon_enter)
+	{
+		label* l;
+
+		begin_func_sync();
+		l = KaffeJIT3_newLabel();
+		l->type = Lexternal;
+		l->at = 0;
+		l->to = (uintp)slowLockObject;
+		l->from = 0;
+		if (METHOD_IS_STATIC(meth) == 0) {
+			meth = NULL;
+		}
+		else {
+			obj = NULL;
+		}
+		slot_slot_slot_const_const(NULL, NULL, obj, (jword)meth, (jword)l, HAVE_mon_enter, Tnull);
+		end_func_sync();
+	}
+#else
+	begin_func_sync();
+	if ((meth->accflags & ACC_STATIC) != 0) {
+		pusharg_class_const(meth->class, 0);
+	}
+	else {
+		pusharg_ref(obj, 0);
+	}
+	call_soft(lockObject);
+	popargs();
+	end_func_sync();
+#endif
+}
+
+void
+mon_exit(methods* meth, SlotInfo* obj)
+{
+	/* Emit monitor entry if required */
+	if ((meth->accflags & ACC_SYNCHRONISED) == 0) {
+		return;
+	}
+#if defined(HAVE_mon_exit)
+	{
+		label* l;
+
+		begin_func_sync();
+		l = KaffeJIT3_newLabel();
+		l->type = Lexternal;
+		l->at = 0;
+		l->to = (uintp)slowUnlockObject;
+		l->from = 0;
+		if (METHOD_IS_STATIC(meth) == 0) {
+			meth = NULL;
+		}
+		else {
+			obj = NULL;
+		}
+		slot_slot_slot_const_const(NULL, NULL, obj, (jword)meth, (jword)l, HAVE_mon_exit, Tnull);
+		end_func_sync();
+	}
+#else
+	begin_func_sync();
+	if (METHOD_IS_STATIC(meth) != 0) {
+		pusharg_class_const(meth->class, 0);
+	}
+	else {
+		pusharg_ref(obj, 0);
+	}
+	call_soft(unlockObject);
+	popargs();
+	end_func_sync();
+#endif
+}
+
+void
+softcall_monitorenter(SlotInfo* mon)
+{
+#if defined(HAVE_mon_enter)
+	label* l;
+
+	l = KaffeJIT3_newLabel();
+	l->type = Lexternal;
+	l->at = 0;
+	l->to = (uintp)slowLockObject;
+	l->from = 0;
+	slot_slot_slot_const_const(NULL, NULL, mon, 0, (jword)l, HAVE_mon_enter, Tnull);
+#else
+	pusharg_ref(mon, 0);
+	call_soft(lockObject);
+	popargs();
+#endif
+}
+
+void
+softcall_monitorexit(SlotInfo* mon)
+{
+#if defined(HAVE_mon_exit)
+	label* l;
+
+	l = KaffeJIT3_newLabel();
+	l->type = Lexternal;
+	l->at = 0;
+	l->to = (uintp)slowUnlockObject;
+	l->from = 0;
+	slot_slot_slot_const_const(NULL, NULL, mon, 0, (jword)l, HAVE_mon_exit, Tnull);
+#else
+	pusharg_ref(mon, 0);
+	call_soft(unlockObject);
+	popargs();
+#endif
+}
+
+/* ----------------------------------------------------------------------- */
+/* Basic block and instruction management.				   */
+/*									   */
+
+void
+mark_all_writes(void)
+{
+	int i;
+	SlotData* sd;
+
+	/* We must reference all slots sequence since they may be used */
+	for (i = maxslot - 1; i >= 0; i--) {
+		sd = slotinfo[i].slot;
+		if (sd->wseq != 0) {
+			sd->wseq->refed = 1;
+		}
+	}
+}
+
+void
+_start_sub_block(void)
+{
+	slot_const_const(NULL, (jword)createSpillMask(), SR_SUBBASIC, doReload, Tnull);
+	setupSlotsForBasicBlock();
+}
+
+void
+_start_basic_block(void)
+{
+	slot_const_const(NULL, (jword)createSpillMask(), SR_BASIC, doReload, Tnull);
+	setupSlotsForBasicBlock();
+}
+
+void
+_end_sub_block(void)
+{
+	mark_all_writes();
+	slot_const_const(NULL, (jword)createSpillMask(), SR_SUBBASIC, doSpill, Tnull);
+}
+
+void
+_end_basic_block(void)
+{
+	mark_all_writes();
+	slot_const_const(NULL, (jword)createSpillMask(), SR_BASIC, doSpill, Tnull);
+}
+
+void
+_syncRegisters(uintp stk UNUSED, uintp temp UNUSED)
+{
+	slot_const_const(NULL, (jword)createSpillMask(), SR_SYNC, doSpill, Tnull);
+}
+
+void
+_start_instruction(uintp _pc)
+{
+	slot_const_const(NULL, 0, _pc, startInsn, Tnull);
+}
+
+void
+_start_exception_block(uintp stk)
+{
+	/* Exception blocks act like function returns - the return
+	 * value is the exception object.
+	 */
+	start_basic_block();
+	exception_prologue();
+	return_ref(&localinfo[stk]);
+}
+
+/*
+ * Begin a register/slot syncronization - this is the point we will
+ * store all our cached values back to where they belong.  We don't know
+ * which values to store yet - this is decided at the end_sync point.
+ */
+void
+begin_sync(void)
+{
+	assert(lastSpill == 0);
+	slot_const_const(NULL, 0, SR_BASIC, doSpill, Tnull);
+	lastSpill = activeSeq;
+}
+
+void
+end_sync(void)
+{
+	/* Make sure a sync is in progress */
+	assert(lastSpill != 0);
+	lastSpill->u[1].smask = createSpillMask();
+	lastSpill = NULL;
+	mark_all_writes();
+}
+
+void
+begin_func_sync(void)
+{
+	assert(lastSpill == 0);
+	slot_const_const(NULL, 0, SR_FUNCTION, doSpill, Tnull);
+	lastSpill = activeSeq;
+
+	/* If we might throw and catch and exception we better make everything
+	 * is written which should be.
+	 */
+	if (canCatch(ANY)) {
+		mark_all_writes();
+	}
+}
+
+void
+end_func_sync(void)
+{
+	SlotData** mask;
+
+	/* Build a mask of the slots to spill and reload */
+	mask = createSpillMask();
+
+	/* Save the slots to spill */
+	assert(lastSpill != 0);
+	lastSpill->u[1].smask = mask;
+	lastSpill = NULL;
+
+	/* Create a reload and save the slots to reload */
+	slot_const_const(NULL, (jword)mask, SR_FUNCTION, doReload, Tnull);
+}
+
+
+/* ----------------------------------------------------------------------- */
+/* Moves.								   */
+/*									   */
+
+void
+move_int_const(SlotInfo* dst, jint val)
+{
+#if defined(HAVE_move_int_const)
+	if (HAVE_move_int_const_rangecheck(val)) {
+		slot_slot_const(dst, NULL, val, HAVE_move_int_const, Tconst);
+	}
+	else
+#endif
+	{
+		constpool *c;
+		label* l;
+
+		c = KaffeJIT3_newConstant(CPint, val);
+		l = KaffeJIT3_newLabel();
+		l->type = Lconstant;
+		l->at = 0;
+		l->to = (uintp)c;
+		l->from = 0;
+
+#if defined(HAVE_load_constpool_int)
+		slot_slot_const(dst, 0, (jword)l, HAVE_load_constpool_int, Tnull);
+#else
+		{
+			SlotInfo* tmp;
+			slot_alloctmp(tmp);
+			move_label_const(tmp, l);
+			load_int(dst, tmp);
+			slot_freetmp(tmp);
+		}
+#endif
+	}
+}
+
+void
+move_ref_const(SlotInfo* dst, void *val)
+{
+#if defined(HAVE_move_ref_const)
+	if (HAVE_move_ref_const_rangecheck(val)) {
+		slot_slot_const(dst, NULL, (jword)val, HAVE_move_ref_const, Tconst);
+	}
+	else
+#endif
+	{
+		constpool *c;
+		label* l;
+
+		c = KaffeJIT3_newConstant(CPref, val);
+		l = KaffeJIT3_newLabel();
+		l->type = Lconstant;
+		l->at = 0;
+		l->to = (uintp)c;
+		l->from = 0;
+
+#if defined(HAVE_load_constpool_ref)
+		slot_slot_const(dst, 0, (jword)l, HAVE_load_constpool_ref, Tnull);
+#else
+		{
+			SlotInfo* tmp;
+			slot_alloctmp(tmp);
+			move_label_const(tmp, l);
+			load_ref(dst, tmp);
+			slot_freetmp(tmp);
+		}
+#endif
+	}
+}
+
+void
+move_string_const(SlotInfo* dst, void *val)
+{
+#if 1
+	move_ref_const(dst, val);
+#else
+	label* l;
+	constpool *c;
+	SlotInfo* tmp;
+
+	c = KaffeJIT3_newConstant(CPstring, val);
+	l = KaffeJIT3_newLabel();
+	l->type = Lconstant;
+	l->at = 0;
+	l->to = (uintp)c;
+	l->from = 0;
+
+#if defined(HAVE_load_constpool_ref)
+	slot_slot_const(dst, 0, (jword)l, HAVE_load_constpool_ref, Tnull);
+#else
+	slot_alloctmp(tmp);
+	move_label_const(tmp, l);
+	load_ref(dst, tmp);
+	slot_freetmp(tmp);
+#endif
+
+#endif
+}
+
+void
+move_long_const(SlotInfo* dst, jlong val)
+{
+#if defined(HAVE_move_long_const)
+	if (HAVE_move_long_const_rangecheck(val)) {
+		lslot_slot_lconst(dst, 0, val, HAVE_move_long_const, Tconst);
+	}
+	else {
+		constpool *c;
+		label* l;
+		SlotInfo* tmp;
+
+		c = KaffeJIT3_newConstant(CPlong, val);
+		l = KaffeJIT3_newLabel();
+		l->type = Lconstant;
+		l->at = 0;
+		l->to = (uintp)c;
+		l->from = 0;
+
+
+#if defined(HAVE_load_constpool_long)
+		slot_slot_const(dst, 0, (jword)l, HAVE_load_constpool_long, Tnull);
+#else
+		slot_alloctmp(tmp);
+		move_label_const(tmp, l);
+		load_long(dst, tmp);
+		slot_freetmp(tmp);
+#endif
+	}
+#else
+
+#if defined(WORDS_BIGENDIAN)
+	/*
+	 * Switch the ordering so that we get a better register allocation
+	 * ordering and don't have to swap immediately afterwards.  (sigh)
+	 */
+	move_int_const(HSLOT(dst), (jint)((val >> 32) & 0xFFFFFFFF));
+	move_int_const(LSLOT(dst), (jint)(val & 0xFFFFFFFF));
+#else
+	move_int_const(LSLOT(dst), (jint)(val & 0xFFFFFFFF));
+	move_int_const(HSLOT(dst), (jint)((val >> 32) & 0xFFFFFFFF));
+#endif
+	
+#endif
+}
+
+void
+move_float_const(SlotInfo* dst, float val)
+{
+#if defined(HAVE_move_float_const)
+	if (HAVE_move_float_const_rangecheck(val)) {
+		slot_slot_fconst(dst, NULL, val, HAVE_move_float_const, Tconst);
+	}
+	else
+#endif
+	{
+		constpool *c;
+		label* l;
+
+		c = KaffeJIT3_newConstant(CPfloat, val);
+		l = KaffeJIT3_newLabel();
+		l->type = Lconstant;
+		l->at = 0;
+		l->to = (uintp)c;
+		l->from = 0;
+
+#if defined(HAVE_load_constpool_float)
+		slot_slot_const(dst, NULL, (jword)l, HAVE_load_constpool_float, Tnull);
+#else
+		{
+			SlotInfo* tmp;
+			slot_alloctmp(tmp);
+			move_label_const(tmp, l);
+			load_float(dst, tmp);
+			slot_freetmp(tmp);
+		}
+#endif
+	}
+}
+
+void
+move_double_const(SlotInfo* dst, jdouble val)
+{
+#if defined(HAVE_move_double_const)
+	if (HAVE_move_double_const_rangecheck(val)) {
+		lslot_slot_fconst(dst, NULL, val, HAVE_move_double_const, Tconst);
+	}
+	else
+#endif
+	{
+		constpool *c;
+		label* l;
+
+		c = KaffeJIT3_newConstant(CPdouble, val);
+		l = KaffeJIT3_newLabel();
+		l->type = Lconstant;
+		l->at = 0;
+		l->to = (uintp)c;
+		l->from = 0;
+
+#if defined(HAVE_load_constpool_double)
+		lslot_lslot_const(dst, 0, (jword)l, HAVE_load_constpool_double, Tnull);
+#else
+		{
+			SlotInfo* tmp;
+			slot_alloctmp(tmp);
+			move_label_const(tmp, l);
+			load_double(dst, tmp);
+			slot_freetmp(tmp);
+		}
+#endif
+	}
+}
+
+#if defined(HAVE_move_any)
+void
+move_any(SlotInfo* dst, SlotInfo* src)
+{
+	if (dst == src) {
+	}
+	else if (isGlobal(dst->slot)) {
+		slot_slot_slot(dst, NULL, src, HAVE_move_any, Tcopy);
+	}
+	else {
+		copyslots(dst, src, Rref);
+	}
+}
+#endif
+
+#if defined(HAVE_move_int)
+void
+move_int(SlotInfo* dst, SlotInfo* src)
+{
+	if (dst == src) {
+	}
+#if defined(HAVE_move_int_const)
+	else if (slot_type(src) == Tconst) {
+		move_int_const(dst, slot_value(src)->i);
+	}
+#endif
+	else if (isGlobal(dst->slot)) {
+		slot_slot_slot(dst, NULL, src, HAVE_move_int, Tcopy);
+	}
+	else {
+		copyslots(dst, src, Rint);
+	}
+}
+#endif
+
+void
+move_ref(SlotInfo* dst, SlotInfo* src)
+{
+	if (dst == src) {
+	}
+#if defined(HAVE_move_ref_const)
+	else if (slot_type(src) == Tconst) {
+		move_ref_const(dst, slot_value(src)->l);
+	}
+#endif
+	else if (isGlobal(dst->slot)) {
+		slot_slot_slot(dst, NULL, src, HAVE_move_ref, Tcopy);
+	}
+	else {
+		copyslots(dst, src, Rref);
+	}
+}
+
+void
+move_anylong(SlotInfo* dst, SlotInfo* src)
+{
+#if defined(HAVE_move_anylong)
+	lslot_lslot_lslot(dst, 0, src, HAVE_move_anylong, Tcopy);
+#else
+	assert(LSLOT(dst) != HSLOT(src));
+	move_any(LSLOT(dst), LSLOT(src));
+	move_any(HSLOT(dst), HSLOT(src));
+#endif
+}
+
+void
+move_long(SlotInfo* dst, SlotInfo* src)
+{
+#if defined(HAVE_move_long)
+	lslot_lslot_lslot(dst, 0, src, HAVE_move_long, Tcopy);
+#else
+	assert(LSLOT(dst) != HSLOT(src));
+	move_int(LSLOT(dst), LSLOT(src));
+	move_int(HSLOT(dst), HSLOT(src));
+#endif
+}
+
+void
+move_float(SlotInfo* dst, SlotInfo* src)
+{
+	if (dst == src) {
+	}
+#if defined(HAVE_move_float_const)
+	else if (slot_type(src) == Tconst) {
+		move_float_const(dst, slot_value(src)->f);
+	}
+#endif
+	else if (isGlobal(dst->slot)) {
+#if defined(HAVE_move_float)
+		slot_slot_slot(dst, NULL, src, HAVE_move_float, Tcopy);
+#elif defined(HAVE_NO_FLOATING_POINT)
+		move_int(dst, src);
+#else
+	ABORT();
+#endif
+	}
+	else {
+		copyslots(dst, src, Rfloat);
+	}
+}
+
+void
+move_double(SlotInfo* dst, SlotInfo* src)
+{
+	if (dst == src) {
+	}
+#if defined(HAVE_move_double_const)
+	else if (slot_type(src) == Tconst) {
+		move_double_const(dst, slot_value(src)->d);
+	}
+#endif
+	else if (isGlobal(dst->slot)) {
+#if defined(HAVE_move_double)
+		lslot_lslot_lslot(dst, NULL, src, HAVE_move_double, Tcopy);
+#elif defined(HAVE_NO_FLOATING_POINT) || defined(PS2LINUX)
+		move_long(dst, src);
+#else
+		ABORT();
+#endif
+	}
+	else {
+		copylslots(dst, src, Rdouble);
+	}
+}
+
+#if defined(HAVE_move_label_const)
+void
+move_label_const(SlotInfo* dst, label* lab)
+{
+	slot_slot_const(dst, NULL, (jword)lab, HAVE_move_label_const, Tnull);
+}
+#endif
+
+void
+swap_any(SlotInfo* src, SlotInfo* src2)
+{
+#if defined(HAVE_swap_any)
+	slot_slot_slot(src, 0, src2, HAVE_swap_any, Tcomplex);
+#else
+	SlotInfo* tmp;
+	slot_alloctmp(tmp);
+	move_ref(tmp, src);
+	move_ref(src, src2);
+	move_ref(src2, tmp);
+	slot_freetmp(tmp);
+#endif
+}
+
+/* ----------------------------------------------------------------------- */
+/* Arithmetic operators - add, sub, etc.				   */
+/*									   */
+
+
+#if defined(HAVE_adc_int)
+void
+adc_int(SlotInfo* dst, SlotInfo* src, SlotInfo* src2)
+{
+	slot_slot_slot(dst, src, src2, HAVE_adc_int, Tcomplex);
+}
+#endif

*** Patch too long, truncated ***




More information about the kaffe mailing list