jit3-i386.def

kaffe Java 解释器语言,源码,Java的子集系统,开放源代码

	wreg_double(0);		/* Result will be in register stack */

	OUT = 0xDC;
	OUT = 0xA8|REG_ebp;
	LOUT = rm;

	debug(("fsubl %d(ebp)\n", rm));
}

define_insn(neg_float, negf_RxR)
{
	rreg_float(2);
	wreg_float(0);

	OUT = 0xD9;
	OUT = 0xe0;

	debug(("fchs\n"));
}

define_insn(neg_double, negd_RxR)
{
	rreg_double(2);
	wreg_double(0);

	OUT = 0xD9;
	OUT = 0xe0;

	debug(("fchsl\n"));
}

define_insn(mul_int, mul_RRR)
{
	int r;
	int w;

	check_reg_01();

	r = rreg_int(2);
	w = rwreg_int(0);

	OUT = 0x0F;
	OUT = 0xAF;
        OUT = 0xC0|(w<<3)|r;

	debug(("imull %s,%s\n", regname(r), regname(w)));
}

define_insn(mul_float, fmul_RRR)
{
	int rr, rm;

	rm = rslot_float(1);	/* Get slot 1 into memory */
	rr = rreg_float(2);	/* Load slot 2 into the register stack */
	wreg_float(0);		/* Result will be in register stack */

	OUT = 0xD8;
	OUT = 0x88|REG_ebp;
	LOUT = rm;

	debug(("fmul %d(ebp)\n", rm));
}

define_insn(mul_double, fmull_RRR)
{
	int rr, rm;

	rm = rslot_double(1);	/* Get slot 1 into memory */
	rr = rreg_double(2);	/* Load slot 2 into the register stack */
	wreg_double(0);		/* Result will be in register stack */

	OUT = 0xDC;
	OUT = 0x88|REG_ebp;
	LOUT = rm;

	debug(("fmull %d(ebp)\n", rm));
}

define_insn(div_int, div_RRR)
{
	int r;
	int w;
	label *l1;

	check_reg_01();

	w = rwreg_int(0);

	/* Can only divide accumulator. */
	force_move_int(seq_slot(s, 0), REG_eax, w);

	/* EDX is also used so get hold of it */
	clobberRegister(REG_edx);

	r = rreg_int(2);

	assert(r != REG_eax);
	assert(r != REG_edx);

	/* special case for LONG_MIN / -1l: r == -1 ? -eax : eax / r  */
	OUT = 0x83;
	OUT = 0xF8|r;
	OUT = 0xFF;
	debug(("cmp #0xFF,%s\n", regname(r)));

	l1 = newLabel();
	l1->type = Linternal| Llong8|Lrelative;
	OUT = 0x74;
	l1->at = CODEPC;
	OUT = 0;
	l1->from = CODEPC;
	debug(("je neg\n"));

	/* Setup EDX - should contains the sign of EAX */
	do_move_int(REG_edx, REG_eax);
#if 0
	OUT = 0xC1;
	OUT = 0xF8|REG_edx;
	OUT = 31;
	debug(("sarl #31,edx\n"));
#else
	OUT = 0x99;
	debug(("cltd\n"));
#endif

	OUT = 0xF7;
        OUT = 0xF8|r;
	debug(("idivl %s,%s\n", regname(r), regname(w)));

	OUT = 0xEB;
	OUT = 2;
	debug(("jmp +2\n"));

	debug(("neg:\n"));
	l1->to = CODEPC;
	OUT = 0xF7;
	OUT = 0xD8|REG_eax;
	debug(("neg eax\n"));
}

define_insn(div_float, fdiv_RRR)
{
	int rr, rm;

	rm = rslot_float(1);	/* Get slot 1 into memory */
	rr = rreg_float(2);	/* Load slot 2 into the register stack */
	wreg_float(0);		/* Result will be in register stack */

	OUT = 0xD8;
	OUT = 0xB8|REG_ebp;
	LOUT = rm;

	debug(("fdiv %d(ebp)\n", rm));
}

define_insn(div_double, fdivl_RRR)
{
	int rr, rm;

	rm = rslot_double(1);	/* Get slot 1 into memory */
	rr = rreg_double(2);	/* Load slot 2 into the register stack */
	wreg_double(0);		/* Result will be in register stack */

	OUT = 0xDC;
	OUT = 0xB8|REG_ebp;
	LOUT = rm;

	debug(("fdivl %d(ebp)\n", rm));
}

define_insn(rem_int, rem_RRR)
{
	int r;
	int w;
	label *l1;

	check_reg_01();

	w = rwreg_int(0);

	/* Can only divide accumulator. */
	force_move_int(seq_slot(s, 0), REG_eax, w);

	/* EDX is also used so get hold of it */
	clobberRegister(REG_edx);

	r = rreg_int(2);

	assert(r != REG_eax);
	assert(r != REG_edx);

	/* special case for LONG_MIN % -1l: r == -1 ? 0 : eax / r  */
	OUT = 0x83;
	OUT = 0xF8|r;
	OUT = 0xFF;
	debug(("cmp #0xFF,%s\n", regname(r)));

	l1 = newLabel();
	l1->type = Linternal| Llong8|Lrelative;
	OUT = 0x74;
	l1->at = CODEPC;
	OUT = 0;
	l1->from = CODEPC;
	debug(("je const0\n"));

	/* Setup EDX - should contains the sign of EAX */
	do_move_int(REG_edx, REG_eax);
#if 0
	OUT = 0xC1;
	OUT = 0xF8|REG_edx;
	OUT = 31;
	debug(("sarl #31,edx\n"));
#else
	OUT = 0x99;
	debug(("cltd\n"));
#endif

	OUT = 0xF7;
        OUT = 0xF8|r;
	debug(("idivl %s,%s\n", regname(r), regname(w)));

	OUT = 0xEB;
	OUT = 2;
	debug(("jmp +2\n"));

	debug(("const0:\n"));
	l1->to = CODEPC;
	OUT = 0x31;
        OUT = 0xC0|(REG_edx<<3)|REG_edx;
	debug(("xorl edx,edx\n"));

	/* Result is in EDX not EAX - we must force the slot register */
	set_slot_register(seq_dst(s), REG_edx, Rint);
}

/* --------------------------------------------------------------------- */

define_insn(and_int, and_RRR)
{
	int r;
	int w;

	check_reg_01();

	r = rreg_int(2);
	w = rwreg_int(0);

	OUT = 0x21;
        OUT = 0xC0|(r<<3)|w;

	debug(("andl %s,%s\n", regname(r), regname(w)));
}

define_insn(or_int, or_RRR)
{
	int r;
	int w;

	check_reg_01();

	r = rreg_int(2);
	w = rwreg_int(0);

	OUT = 0x09;
        OUT = 0xC0|(r<<3)|w;

	debug(("orl %s,%s\n", regname(r), regname(w)));
}

define_insn(xor_int, xor_RRR)
{
	int r;
	int w;

	check_reg_01();

	r = rreg_int(2);
	w = rwreg_int(0);

	OUT = 0x31;
        OUT = 0xC0|(r<<3)|w;

	debug(("xorl %s,%s\n", regname(r), regname(w)));
}

define_insn(ashr_int, ashr_RRR)
{
	int r;
	int w;

	check_reg_01();

	r = rreg_ideal_int(2, REG_ecx);

	/* Can only shift by ECX. */
	safe_move_int(REG_ecx, r);

	w = rwreg_int(0);

	OUT = 0xD3;
        OUT = 0xF8|w;

	debug(("sarl %s,%s\n", regname(r), regname(w)));
}

define_insn(lshr_int, lshr_RRR)
{
	int r;
	int w;

	check_reg_01();

	r = rreg_ideal_int(2, REG_ecx);

	/* Can only shift by ECX. */
	safe_move_int(REG_ecx, r);

	w = rwreg_int(0);

	OUT = 0xD3;
        OUT = 0xE8|w;

	debug(("shrl %s,%s\n", regname(r), regname(w)));
}

define_insn(lshl_int, lshl_RRR)
{
	int r;
	int w;

	check_reg_01();

	r = rreg_ideal_int(2, REG_ecx);

	/* Can only shift by ECX. */
	safe_move_int(REG_ecx, r);

	w = rwreg_int(0);

	OUT = 0xD3;
        OUT = 0xE0|w;

	debug(("shll %s,%s\n", regname(r), regname(w)));
}

/* --------------------------------------------------------------------- */

define_insn(load_int, load_RxR)
{
	int r = rreg_int(2);
	int w = wreg_int(0);

	OUT = 0x8B;
	OUT = 0x00|(w<<3)|r;
	if (r == REG_esp) {
		OUT = 0x20|REG_esp;
	}

	debug(("movl (%s),%s\n", regname(r), regname(w)));
}

define_insn(load_float, fload_RxR)
{
	int r;

	r = rreg_int(2);
	wreg_float(0);

	OUT = 0xD9;
	OUT = 0x00|r;

	debug(("fld (%s)\n", regname(r)));
}

define_insn(load_double, floadl_RxR)
{
	int r;

	r = rreg_int(2);
	wreg_double(0);

	OUT = 0xDD;
	OUT = 0x00|r;

	debug(("fldl (%s)\n", regname(r)));
}

define_insn(store_int, store_xRR)
{
	int r = rreg_int(2);
	int w = rreg_int(1);

	OUT = 0x89;
	OUT = 0x00|(r<<3)|w;
	if (w == REG_esp) {
		OUT = 0x20|REG_esp;
	}

	debug(("movl %s,(%s)\n", regname(r), regname(w)));
}

define_insn(store_float, fstore_RxR)
{
	int w;

	rreg_float(2);
	w = rreg_int(1);
	
	OUT = 0xD9;
	OUT = 0x18|w;
	
	debug(("fstp (%s)\n", regname(w)));
}

define_insn(store_double, fstorel_RxR)
{
	int w;

	rreg_double(2);
	w = rreg_int(1);

	OUT = 0xDD;
	OUT = 0x18|w;

	debug(("fstlp (%s)\n", regname(w)));
}

/* --------------------------------------------------------------------- */

define_insn(cmp_int, cmp_xRR)
{
	int r1 = rreg_int(1);
	int r2 = rreg_int(2);

	OUT = 0x39;
	OUT = 0xC0|(r2<<3)|r1;

	debug(("cmpl %s,%s\n", regname(r2), regname(r1)));
}

/* --------------------------------------------------------------------- */

define_insn(cvt_int_float, cvtif_RxR)
{
	int r;

	r = rslot_int(2);
	wreg_float(0);

	OUT = 0xDB;
	OUT = 0x80|REG_ebp;
	LOUT = r;

	debug(("fild %d(ebp)\n", r));
}

define_insn(cvt_int_double, cvtid_RxR)
{
	int r;

	r = rslot_int(2);
	wreg_double(0);

	OUT = 0xDB;
	OUT = 0x80|REG_ebp;
	LOUT = r;

	debug(("fild %d(ebp)\n", r));
}

#if 0

	We cannot use these functions since the long is store in the
	opposite order to what they expect.

define_insn(cvt_long_float, cvtlf_RxR)
{
	int r;

	r = rslot_long(2);
	wreg_float(0);

	OUT = 0xDF;
	OUT = 0xA8|REG_ebp;
	LOUT = r;

	debug(("fildll %d(ebp)\n", r));
}

define_insn(cvt_long_double, cvtld_RxR)
{
	int r;

	r = rslot_long(2);
	wreg_double(0);

	OUT = 0xDF;
	OUT = 0xA8|REG_ebp;
	LOUT = r;

	debug(("fildll %d(ebp)\n", r));
}

#endif

define_insn(cvt_float_double, cvtfd_RxR)
{
	int o;

	o = rslot_float(2);
	wreg_double(0);

	OUT = 0xD9;
	OUT = 0x80|REG_ebp;
	LOUT = o;

	debug(("fld %d(ebp)\n", o));
}

define_insn(cvt_double_float, cvtdf_RxR)
{
	int o;

	o = rslot_double(2);
	wreg_float(0);

	OUT = 0xDD;
	OUT = 0x80|REG_ebp;
	LOUT = o;

	debug(("fldl %d(ebp)\n", o));
}

/* --------------------------------------------------------------------- */

define_insn(build_key, set_word_xxC)
{
	jint val = const_int(2);

	LOUT = val;

	debug((".word %08x\n", val));
}

define_insn(build_code_ref, set_wordpc_xxC)
{
	label* l = const_label(2);

	l->type |= Llong|Labsolute;
	l->at = CODEPC;
	LOUT = 0;
	l->from = CODEPC;
	debug((".word %s\n", getLabelName(l)));
}

/* --------------------------------------------------------------------- */

define_insn(set_label, set_label_xxC)
{
	label* l = const_label(2);
	l->to = CODEPC;
}

define_insn(branch, branch_xCC)
{
	label* l = const_label(1);
	int bt = const_int(2);

	l->type |= Llong|Lrelative;
	switch (bt) {
	case ba:
		OUT = 0xE9;
		l->at = CODEPC;
		LOUT = 0;
		l->from = CODEPC;
		debug(("jmpl %s\n", getLabelName(l)));
		break;
	case beq:
		OUT = 0x0F;
		OUT = 0x84;
		l->at = CODEPC;
		LOUT = 0;
		l->from = CODEPC;
		debug(("je %s\n", getLabelName(l)));
		break;
	case bne:
		OUT = 0x0F;
		OUT = 0x85;
		l->at = CODEPC;
		LOUT = 0;
		l->from = CODEPC;
		debug(("jne %s\n", getLabelName(l)));
		break;
	case blt:
		OUT = 0x0F;
		OUT = 0x8C;
		l->at = CODEPC;
		LOUT = 0;
		l->from = CODEPC;
		debug(("jlt %s\n", getLabelName(l)));
		break;
	case ble:
		OUT = 0x0F;
		OUT = 0x8E;
		l->at = CODEPC;
		LOUT = 0;
		l->from = CODEPC;
		debug(("jle %s\n", getLabelName(l)));
		break;
	case bgt:
		OUT = 0x0F;
		OUT = 0x8F;
		l->at = CODEPC;
		LOUT = 0;
		l->from = CODEPC;
		debug(("jgt %s\n", getLabelName(l)));
		break;
	case bge:
		OUT = 0x0F;
		OUT = 0x8D;
		l->at = CODEPC;
		LOUT = 0;
		l->from = CODEPC;
		debug(("jge %s\n", getLabelName(l)));
		break;
	case bult:
		OUT = 0x0F;
		OUT = 0x82;
		l->at = CODEPC;
		LOUT = 0;
		l->from = CODEPC;
		debug(("jult %s\n", getLabelName(l)));
		break;
#if 0
	case bule:
		OUT = 0x0F;
		OUT = 0x86;
		l->at = CODEPC;
		LOUT = 0;
		l->from = CODEPC;
		debug(("jule %s\n", getLabelName(l)));
		break;
#endif
	case bugt:
		OUT = 0x0F;
		OUT = 0x87;
		l->at = CODEPC;
		LOUT = 0;
		l->from = CODEPC;
		debug(("jugt %s\n", getLabelName(l)));
		break;
	case buge:
		OUT = 0x0F;
		OUT = 0x83;
		l->at = CODEPC;
		LOUT = 0;
		l->from = CODEPC;
		debug(("juge %s\n", getLabelName(l)));
		break;
	default:
		ABORT();
	}
}

define_insn(branch_indirect, branch_indirect_xRC)
{
	int r = rreg_int(1);
	assert(const_int(2) == ba);

	OUT = 0xFF;
	OUT = 0xE0|r;

	debug(("jmp (%s)\n", regname(r)));
}

define_insn(call_ref, call_xCC)
{
	label* l = const_label(1);
	assert(const_int(2) == ba);

#if defined(KAFFE_PROFILER)
	if (profFlag && !(l->type & Lnoprofile)) {
		/*  don't profile call_soft */
		profiler_start(globalMethod->totalChildrenClicks, 1);
	}
#endif

	OUT = 0xE8;
	l->type |= Llong|Lrelative;
	l->at = CODEPC;
	LOUT = 0;
	l->from = CODEPC;

	debug(("call ?\n"));

#if defined(KAFFE_PROFILER)
	if (profFlag && !(l->type & Lnoprofile)) {
		/*  don't profile call_soft */
		profiler_end(globalMethod->totalChildrenClicks, 1);
	}
#endif
}

define_insn(call, call_xRC)
{
	int r = rreg_int(1);
	assert(const_int(2) == ba);

#if defined(KAFFE_PROFILER)
	if (profFlag) {
		profiler_start(globalMethod->totalChildrenClicks, 1);
	}
#endif

	OUT = 0xFF;
	OUT = 0xD0|r;

	debug(("call %s\n", regname(r)));

#if defined(KAFFE_PROFILER)
	if (profFlag) {
		profiler_end(globalMethod->totalChildrenClicks, 1);
	}
#endif
}

define_insn(call_indirect_const, call_ind_xCC)
{
	int m = const_int(1);
	assert(const_int(2) == ba);

#if defined(KAFFE_PROFILER)
	if (profFlag) {
		profiler_start(globalMethod->totalChildrenClicks, 1);
	}
#endif

	WOUT = 0x15FF;
	LOUT = m;

	debug(("call *%x\n", m));

#if defined(KAFFE_PROFILER)
	if (profFlag) {
		profiler_end(globalMethod->totalChildrenClicks, 1);
	}
#endif
}

define_insn(push_int, push_xRC)
{
	int r;

	if (inRegister(1, Rint|Rref)) {
		r = rreg_int(1);

		OUT = 0x50|r;

		debug(("pushl %s\n", regname(r)));
	}
	else {
		r = rslot_int(1);
		OUT = 0xFF;
		OUT = 0xB5;
		LOUT = r;
		debug(("pushl %d(ebp)\n", r));
	}
}

define_insn(push_float, fpush_xRC)
{
	int r = rreg_int(1);	/* Move the float into a register */

	OUT = 0x50|r;

	debug(("pushl %s\n", regname(r)));
}

define_insn(push_double, fpushl_xRC)
{
	int o = rslot_double(1);

	OUT = 0xFF;
	OUT = 0xB0|REG_ebp;
	LOUT = o+4;

	debug(("pushl %d(ebp)\n", (o+4)));

	OUT = 0xFF;
	OUT = 0xB0|REG_ebp;
	LOUT = o;

	debug(("pushl %d(ebp)\n", o));
}

define_insn(popargs, popargs_xxC)
{
	int o = const_int(2);
	o *= 4;

	OUT = 0x81;
	OUT = 0xC0|REG_esp;
	LOUT = o;

	debug(("addl %d,esp\n", o));
}

define_insn(return_int, return_Rxx)
{
DBG(REGFORCE,
    dprintf ("return_int()\n");
    )
	set_slot_register(seq_dst(s), REG_eax, Rint);
}

define_insn(return_long, returnl_Rxx)
{
DBG(REGFORCE,
    dprintf ("return_long()\n");
    )
	set_slot_register(seq_dst(s), REG_eax, Rint);
	set_slot_register(seq_dst(s)+1, REG_edx, Rint);
}

define_insn(return_float, freturn_Rxx)
{
DBG(REGFORCE,
    dprintf ("return_float()\n");
    )
	set_slot_register(seq_dst(s), REG_flt0, Rfloat);
}

define_insn(return_double, freturnl_Rxx)
{
DBG(REGFORCE,
    dprintf ("return_double()\n");
    )
	set_slot_register(seq_dst(s), REG_dbl0, Rdouble);
}

define_insn(returnarg_int, returnarg_xxR)
{
	int r;

	r = rreg_int(2);
	do_move_int(REG_eax, r);
}

define_insn(returnarg_long, returnargl_xxR)
{
	REGSLOT* r;
	int r1;
	int r2;