jit3-i386.def

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

	r = seq_slot(s, 2);
	r1 = _slowSlotRegister(r, Rint, rread);
	r2 = _slowSlotRegister(r+1, Rint, rread);

	/* Return long is a bit complicated since part of the source may
	 * be the destination.
	 */
	if (REG_eax != r2) {
		do_move_int(REG_eax, r1);
		do_move_int(REG_edx, r2);
	}
	else if (REG_edx != r1) {
		do_move_int(REG_edx, r2);
		do_move_int(REG_eax, r1);
	}
	else {
		/* r1 == REG_edx && r2 == REG_eax - swap */
		OUT = 0x87;
		OUT = 0xC0|r1<<3|r2;
	}
}

define_insn(returnarg_float, freturnarg_xxR)
{
	/* Force value into float register */
	rreg_float(2);
}

define_insn(returnarg_double, freturnargl_xxR)
{
	/* Force value into double register */
	rreg_double(2);
}

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

define_insn(add_int_const, add_RRC)
{
	int rw;
	int v;

	check_reg_01();

	v = const_int(2);
	rw = rwreg_int(0);

	OUT = 0x81;
        OUT = 0xC0|rw;
	LOUT = v;

	debug(("addl #%d,%s\n", v, regname(rw)));
}

define_insn(sub_int_const, sub_RRC)
{
	int rw;
	int v;

	check_reg_01();

	v = const_int(2);
	rw = rwreg_int(0);

	OUT = 0x81;
        OUT = 0xE8|rw;
	LOUT = v;

	debug(("subl #%d,%s\n", v, regname(rw)));
}

define_insn(load_offset_int, load_RRC)
{
	int v = const_int(2);
	int r = rreg_int(1);
	int w = wreg_int(0);

	assert(r != REG_esp);
	OUT = 0x8B;
	OUT = 0x80|(w<<3)|r;
	LOUT = v;

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

define_insn(load_byte, loadb_RxR)
{
	int r = rreg_int(2);
	int w = wreg_int(0);

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

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

define_insn(load_char, loadc_RxR)
{
	int r = rreg_int(2);
	int w = wreg_int(0);

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

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

define_insn(load_short, loads_RxR)
{
	int r = rreg_int(2);
	int w = wreg_int(0);

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

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

define_insn(store_offset_int, store_xRRC)
{
	int v;
	int r1;
	int r0;

	v = const_int(2);
	r0 = rreg_int(0);
	r1 = rreg_int(1);

	assert(r0 != REG_esp);
	OUT = 0x89;
	OUT = 0x80|(r0<<3)|r1;
	LOUT = v;

	debug(("movl %s,%d(%s)\n", regname(r0), v, regname(r1)));
}

define_insn(store_byte, storeb_xRR)
{
	int r;
	int w;

	/* Can only store accumulators as bytes */
	r = rreg_subint(2);
	/* If we cannot get the register into the subint
	 * (it's probably global) then do it ourselves.
	 */
	if (r == NOREG) {
		r = rreg_int(2);
		safe_move_int(REG_eax, r);
	}

	w = rreg_int(1);

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

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

define_insn(store_short, stores_xRR)
{
	int r = rreg_int(2);
	int w = rreg_int(1);

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

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

define_insn(cmp_int_const, cmp_xRC)
{
	int r1 = rreg_int(1);
	int v = const_int(2);

	OUT = 0x81;
        OUT = 0xF8|r1;
	LOUT = v;

	debug(("cmpl #%d,%s\n", v, regname(r1)));
}

define_insn(push_int_const, push_xCC)
{
	int v = const_int(1);

	OUT = 0x68;
	LOUT = v;

	debug(("pushl #%d\n", v));
}

define_insn(lshl_int_const, lshl_RRC)
{
	int rw;
	int v;

	check_reg_01();

	rw = rreg_int(0);
	v = const_int(2);

	OUT = 0xC1;
        OUT = 0xE0|rw;
	OUT = v;

	debug(("shll #%d,%s\n", v, regname(rw)));
}

define_insn(mon_enter, monenter_xxRCC)
{
	Method* meth;
	label* l;
	int r;

	meth = (Method*)const_int(3);
	l = const_label(4);

	clobberRegister(REG_eax);
	clobberRegister(REG_ecx);

	if (meth == 0) {
		r = rreg_int(2);

		OUT = 0x8b;
		OUT = 0x40|r;
		OUT = 0x04;        debug(("movl   0x4(REG),eax\n"));
		OUT = 0x85;
		OUT = 0xc0;        debug(("testl  eax,eax\n"));
		OUT = 0x75;
		OUT = 0x0b;        debug(("jne    12 <start+12>\n"));
		OUT = 0x89;
		OUT = 0xe9;        debug(("movl   ebp,ecx\n"));
		OUT = 0xF0;	   debug(("lock"));
		OUT = 0x0f;
		OUT = 0xb1;
		OUT = 0x48|r;
		OUT = 0x04;        debug(("cmpxchgl ecx,0x4(REG)\n"));
		OUT = 0x74;
		OUT = 0x15;        debug(("je     27 <start+27>\n"));
		OUT = 0x75;
		OUT = 0x09;        debug(("jne    1a <start+1a>\n"));
		OUT = 0x29;
		OUT = 0xe8;        debug(("subl   ebp,eax\n"));
		OUT = 0x3d;
		LOUT = 0x400;      debug(("cmpl   $0x400,eax\n"));
		OUT = 0x72;
		OUT = 0x0a;        debug(("jb     27 <start+27>\n"));
		OUT = 0x55;        debug(("pushl  ebp\n"));
		OUT = 0x50|r;      debug(("pushl  REG\n"));
		OUT = 0xe8;
		l->type |= Llong|Lrelative;
		l->at = CODEPC;
		LOUT = 0;	   debug(("call   slowLockObject\n"));
		l->from = CODEPC;
		OUT = 0x83;
		OUT = 0xc4;
		OUT = 0x08;        debug(("addl   $0x8,esp\n"));
	}
	else {
		OUT = 0xa1;
		LOUT = (uintp)&meth->class->head.lock;
				   debug(("movl   ?,eax\n"));
		OUT = 0x85;
		OUT = 0xc0;        debug(("testl  eax,eax\n"));
		OUT = 0x75;
		OUT = 0x0e;        debug(("jne    17 <start+17>\n"));
		OUT = 0x89;
		OUT = 0xe9;	   debug(("movl   ebp,ecx\n"));
		OUT = 0xF0;	   debug(("lock"));
		OUT = 0x0f;
		OUT = 0xb1;
		OUT = 0x0d;
		LOUT = (uintp)&meth->class->head.lock;
				   debug(("cmpxchgl ecx,?\n"));
		OUT = 0x74;
		OUT = 0x19;        debug(("je     2d <start+2d>\n"));
		OUT = 0x75;
		OUT = 0x09;        debug(("jne    1f <start+1f>\n"));
		OUT = 0x29;
		OUT = 0xe8;        debug(("subl   ebp,eax\n"));
		OUT = 0x3d;
		LOUT = 0x400;      debug(("cmpl   $0x400,eax\n"));
		OUT = 0x72;
		OUT = 0x0e;        debug(("jb     2d <start+2d>\n"));
		OUT = 0x55;        debug(("pushl  ebp\n"));
		OUT = 0x68;
		LOUT = (uintp)meth->class;
				   debug(("pushl  $?\n"));
		OUT = 0xe8;
		l->type |= Llong|Lrelative;
		l->at = CODEPC;
		LOUT = 0;	   debug(("call   slowLockObject\n"));
		l->from = CODEPC;
		OUT = 0x83;
		OUT = 0xc4;
		OUT = 0x08;        debug(("addl   $0x4,esp\n"));
	}
}

define_insn(mon_exit, monexit_xxRCC)
{
	Method* meth;
	label* l;
	int r;

	meth = (Method*)const_int(3);
	l = const_label(4);

	clobberRegister(REG_eax);
	clobberRegister(REG_ecx);

	if (meth == 0) {
		r = rreg_int(2);

		OUT = 0x8b;
		OUT = 0x40|r;
		OUT = 0x04;        debug(("movl   0x4(REG),eax\n"));
		OUT = 0xa9;
		LOUT = 0x01;	   debug(("testl  $0x1,eax\n"));
		OUT = 0x75;
		OUT = 0x0d;        debug(("jne    17\n"));
		OUT = 0x39;
		OUT = 0xc5;        debug(("cmpl   eax,ebp\n"));
		OUT = 0x75;
		OUT = 0x13;        debug(("jne    24\n"));
		OUT = 0x31;
		OUT = 0xc9;        debug(("xorl   ecx,ecx\n"));
		OUT = 0xF0;	   debug(("lock"));
		OUT = 0x0f;
		OUT = 0xb1;
		OUT = 0x48|r;
		OUT = 0x04;        debug(("cmpxchgl ecx,0x4(REG)\n"));
		OUT = 0x74;
		OUT = 0x0a;        debug(("je     23\n"));
		OUT = 0x55;        debug(("pushl  ebp\n"));
		OUT = 0x50|r;      debug(("pushl  REG\n"));
		OUT = 0xe8;
		l->type |= Llong|Lrelative;
		l->at = CODEPC;
		LOUT = 0;	   debug(("call   slowUnlockObject\n"));
		l->from = CODEPC;
		OUT = 0x83;
		OUT = 0xc4;
		OUT = 0x08;        debug(("addl   $0x8,esp\n"));
	}
	else {
		OUT = 0xa1;
		LOUT = (uintp)&meth->class->head.lock;
				   debug(("movl   ?,eax\n"));
		OUT = 0xa9;
		LOUT = 0x01;	   debug(("testl  $0x1,eax\n"));
		OUT = 0x75;
		OUT = 0x10;        debug(("jne    1c\n"));
		OUT = 0x39;
		OUT = 0xc5;        debug(("cmpl   eax,ebp\n"));
		OUT = 0x75;
		OUT = 0x1a;        debug(("jne    2a\n"));
		OUT = 0x31;
		OUT = 0xc9;        debug(("xorl   ecx,ecx\n"));
		OUT = 0xF0;	   debug(("lock"));
		OUT = 0x0f;
		OUT = 0xb1;
		OUT = 0x0d;
		LOUT = (uintp)&meth->class->head.lock;
				   debug(("cmpxchgl ecx,?\n"));
		OUT = 0x74;
		OUT = 0x0e;        debug(("je     29\n"));
		OUT = 0x55;        debug(("pushl  ebp\n"));
		OUT = 0x68;
		LOUT = (uintp)meth->class;
				   debug(("pushl  $?\n"));
		OUT = 0xe8;
		l->type |= Llong|Lrelative;
		l->at = CODEPC;
		LOUT = 0;	   debug(("call   slowUnlockObject\n"));
		l->from = CODEPC;
		OUT = 0x83;
		OUT = 0xc4;
		OUT = 0x08;        debug(("addl   $0x8,esp\n"));
	}
}

define_insn(get_arg_ptr, get_arg_ptr_R)
{
	int rw = rwreg_int(0);

	OUT = 0x89;
	OUT = 0xC0|(REG_ebp<<3)|rw;
	debug(("movl %s,%s\n", regname(REG_ebp), regname(rw)));

	OUT = 0x81;
        OUT = 0xC0|rw;
	LOUT = 8;
	debug(("addl #%d,%s\n", 4, regname(rw)));
}

define_insn(and_int_const, and_RRC)
{
        int rw;
        int v;

        rw = rwreg_int(0);
        v = const_int(2);

        OUT = 0x81;
        OUT = 0xE0|rw;
        LOUT = v;

        debug(("andl #%d,%s\n", v, regname(rw)));
}

define_insn(or_int_const, or_RRC)
{
        int rw;
        int v;

        rw = rwreg_int(0);
        v = const_int(2);

        OUT = 0x81;
        OUT = 0xC8|rw;
        LOUT = v;

        debug(("orl #%d,%s\n", v, regname(rw)));
}

define_insn(xor_int_const, xor_RRC)
{
        int rw;
        int v;

        rw = rwreg_int(0);
        v = const_int(2);

        OUT = 0x81;
        OUT = 0xF0|rw;
        LOUT = v;

        debug(("xorl #%d,%s\n", v, regname(rw)));
}

define_insn(mul_int_const, mul_RRC)
{
        int rw;
        int v;

        rw = rwreg_int(0);
        v = const_int(2);

        OUT = 0x69;
        OUT = 0xC0|(rw<<3)|rw;
        LOUT = v;

        debug(("imull #%d,%s\n", v, regname(rw)));
}

define_insn(lshr_int_const, lshr_RRC)
{
        int rw;
        int v;

        rw = rwreg_int(0);
        v = const_int(2);

        OUT = 0xC1;
        OUT = 0xE8|rw;
        OUT = v;

        debug(("shrl #%d,%s\n", v, regname(rw)));
}

define_insn(ashr_int_const, ashr_RRC)
{
        int rw;
        int v;

        rw = rwreg_int(0);
        v = const_int(2);

        OUT = 0xC1;
        OUT = 0xF8|rw;
        OUT = v;

        debug(("sarl #%d,%s\n", v, regname(rw)));
}

define_insn(neg_int, neg_RxR)
{
        int r;
	int w;

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

	do_move_int(w, r);

        OUT = 0xF7;
        OUT = 0xD8|w;

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

define_insn(load_offset_scaled_byte, loadb_RRRC)
{
	int w;
	int v;
	int r1;
	int r2;

	r1 = rreg_int(1);
	r2 = rreg_int(2);
	w = wreg_int(0);
	v = const_int(3);

	assert(r1 != REG_esp);
	assert(r2 != REG_esp);
	OUT = 0x0F;
	OUT = 0xBE;
	OUT = 0x84|w<<3;
	OUT = r2<<3|r1;
	LOUT = v;

	debug(("movb %d(%s,%s,1),%s\n", v, regname(r1), regname(r2), regname(w)));
}

define_insn(load_offset_scaled_int, load_RRRC)
{
	int w;
	int v;
	int r1;
	int r2;

	r1 = rreg_int(1);
	r2 = rreg_int(2);
	w = wreg_int(0);
	v = const_int(3);

	assert(r1 != REG_esp);
	assert(r2 != REG_esp);
	OUT = 0x8B;
	OUT = 0x84|w<<3;
	OUT = 0x80|r2<<3|r1;
	LOUT = v;

	debug(("mov %d(%s,%s,4),%s\n", v, regname(r1), regname(r2), regname(w)));
}

define_insn(load_offset_scaled_char, loadc_RRRC)
{
	int w;
	int v;
	int r1;
	int r2;

	r1 = rreg_int(1);
	r2 = rreg_int(2);
	w = wreg_int(0);
	v = const_int(3);

	assert(r1 != REG_esp);
	assert(r2 != REG_esp);
	OUT = 0x0F;
	OUT = 0xB7;
	OUT = 0x84|w<<3;
	OUT = 0x40|r2<<3|r1;
	LOUT = v;

	debug(("movzw %d(%s,%s,2),%s\n", v, regname(r1), regname(r2), regname(w)));
}

define_insn(store_offset_scaled_byte, storeb_RRRC)
{
	int r;
	int v;
	int w1;
	int w2;

	r = rreg_subint(2);
	/* If we cannot get the register into the subint
	 * (it's probably global) then do it ourselves.
	 */
	if (r == NOREG) {
		r = rreg_int(2);
		safe_move_int(REG_eax, r);
	}

	w1 = rreg_int(0);
	w2 = rreg_int(1);
	v = const_int(3);

	assert(w1 != REG_esp);
	assert(w2 != REG_esp);
	assert(r >= REG_eax && r <= REG_ebx);
	OUT = 0x88;
	OUT = 0x84|r<<3;
	OUT = w2<<3|w1;
	LOUT = v;

	debug(("movb %s,%d(%s,%s,1)\n", regname(r), v, regname(w1), regname(w2)));
}

define_insn(store_offset_scaled_short, stores_RRRC)
{
	int r;
	int v;
	int w1;
	int w2;

	r = rreg_subint(2);
	/* If we cannot get the register into the subint
	 * (it's probably global) then do it ourselves.
	 */
	if (r == NOREG) {
		r = rreg_int(2);
		safe_move_int(REG_eax, r);
	}

	w1 = rreg_int(0);
	w2 = rreg_int(1);
	v = const_int(3);

	assert(w1 != REG_esp);
	assert(w2 != REG_esp);
	assert(r >= REG_eax && r <= REG_ebx);
	OUT = 0x66;
	OUT = 0x89;
	OUT = 0x84|r<<3;
	OUT = 0x40|w2<<3|w1;
	LOUT = v;

	debug(("movw %s,%d(%s,%s,2)\n", regname(r), v, regname(w1), regname(w2)));
}

define_insn(store_offset_scaled_int, store_RRRC)
{
	int r;
	int v;
	int w1;
	int w2;

	r = rreg_int(2);
	w1 = rreg_int(0);
	w2 = rreg_int(1);
	v = const_int(3);

	assert(w1 != REG_esp);
	assert(w2 != REG_esp);
	OUT = 0x89;
	OUT = 0x84|r<<3;
	OUT = 0x80|w2<<3|w1;
	LOUT = v;

	debug(("mov %s,%d(%s,%s,4)\n", regname(r), v, regname(w1), regname(w2)));
}

define_insn(load_addr_int, load_RxA)
{
	int o = const_int(2);
	int w = wreg_int(0);

	OUT = 0x8B;
	OUT = 0x05|(w<<3);
	LOUT = o;

	debug(("movl 0x%x,%s\n", o, regname(w)));
}

define_insn(store_addr_int, store_xRA)
{
	int r = rreg_int(1);
	int o = const_int(2);

	OUT = 0x89;
	OUT = 0x05|(r<<3);
	LOUT = o;

	debug(("movl %s,0x%x\n", regname(r), o));
}

define_insn(store_offset_byte, storeb_xRRC)
{
	int v;
	int r1;
	int r0;

	/* Can only store accumulators as bytes */
	r0 = rreg_subint(0);
	/* If we cannot get the register into the subint
	 * (it's probably global) then do it ourselves.
	 */
	if (r0 == NOREG) {
		r0 = rreg_int(0);
		safe_move_int(REG_eax, r0);
	}

	v = const_int(2);
	r1 = rreg_int(1);

	OUT = 0x88;
	OUT = 0x80|(r0<<3)|r1;
	LOUT = v;

	debug(("movb %s,%d(%s)\n", regname(r0), v, regname(r1)));
}

define_insn(store_offset_short, stores_xRRC)
{
	int v;
	int r1;
	int r0;

	v = const_int(2);
	r1 = rreg_int(1);
	r0 = rreg_int(0);

	OUT = 0x66;
	OUT = 0x89;
	OUT = 0x80|(r0<<3)|r1;
	LOUT = v;

	debug(("movw %s,%d(%s)\n", regname(r0), v, regname(r1)));
}

define_insn(store_const_offset_int, store_xRCC)
{
        int o;
        int v;
        int r;

        r = rreg_int(0);
        o = const_int(1);
        v = const_int(2);

	OUT = 0xC7;
	OUT = 0x80|r;
	LOUT = o;
        LOUT = v;

        debug(("movl %d,%d(%s)\n", v, o, regname(r)));
}

define_insn(store_const_offset_byte, storeb_xRCC)
{
        int o;
        int v;
        int r;

        r = rreg_int(0);
        o = const_int(1);
        v = const_int(2);

	OUT = 0xC6;
	OUT = 0x80|r;
	LOUT = o;
        OUT = v;

        debug(("movb %d,%d(%s)\n", v, o, regname(r)));
}

define_insn(store_const_offset_scaled_byte, storeb_RRCC)
{
	int o;
	int v;
	int r1;
	int r2;

	r1 = rreg_int(0);
	r2 = rreg_int(1);
	o = const_int(2);
	v = const_int(3);

	OUT = 0xC6;
	OUT = 0x84;
	OUT = (r2<<3)|r1;
	LOUT = o;
	OUT = v;

        debug(("movb $%d,%d(%s,%s)\n", v, o, regname(r1), regname(r2)));
}

define_insn(fake_call, fakecall_xCC)
{
	label* tol = const_label(2);
	label* froml = const_label(1);

	OUT = 0x68;
	froml->type |= Llong|Labsolute;
	froml->at = CODEPC;
	LOUT = 0;
	froml->from = 0;

	debug(("pushl <return_addr>\n"));

	OUT = 0xE9;
	tol->type |= Llong|Lrelative;
	tol->at = CODEPC;
	LOUT = 0;
	tol->from = CODEPC;
	debug(("jmpl ?\n"));
}

define_insn(cmp_int_offset, cmp_xRRC)
{
        int r1 = rreg_int(1);
        int r2 = rreg_int(2);
        int off = const_int(3);

        OUT = 0x3B;
        OUT = 0x80|(r1<<3)|r2;
	LOUT = off;

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

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

void
kill_readonce_register (SlotData *s)
{
DBG(REGFORCE,
    dprintf ("kill_readonce_register(%s)\n", regname(s->regno));
    )
	if (((reginfo[s->regno].ctype & Rdouble) && (s->regno == REG_dbl0)) ||
	    ((reginfo[s->regno].ctype & Rfloat) && (s->regno == REG_flt0))) {
	    	OUT = 0xDD;
		OUT = 0xD8;

		debug (("fstp %%st(0)\n"));
	}
}