jit3-i386.def

基于LWVCL开发的库

		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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

	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);

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

	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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

        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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

        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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

        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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

        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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

        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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

        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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

        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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

	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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

	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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

	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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

	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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

	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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

	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);

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

	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);

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

	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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

	/* 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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

	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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

        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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

        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;

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

	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);

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

	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);

	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

        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)
{
	debug(("instr\t%s\n",__PRETTY_FUNCTION__));

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"));
	}
}