jit3-powerpc.def

基于LWVCL开发的库

define_insn(add_float, fadd_RRR)
{
	int r2 = rreg_float(2);
	int r1 = rreg_float(1);
	int w = wreg_float(0);

	LOUT(ppc_op_fadds(w, r1, r2));

	debug((DBOUT,"add_float %d, %d, %d\n", w, r1, r2));
}

define_insn(add_double, faddl_RRR)
{
	int r2 = rreg_double(2);
	int r1 = rreg_double(1);
	int w = wreg_double(0);

	LOUT(ppc_op_fadd(w, r1, r2));

	debug((DBOUT,"add_double %d, %d, %d\n", w, r1, r2));
}

define_insn(sub_int, sub_RRR)
{
	int r2 = rreg_int(2);
	int r1 = rreg_int(1);
	int w = wreg_int(0);

	LOUT(ppc_op_subfc(w, r2, r1));

	debug((DBOUT,"sub_int %d, %d, %d\n", w, r1, r2));
}

define_insn(sub_int_const, sub_RRC)
{
	int o = const_int(2);
	int r1 = rreg_int(1);
	int w = wreg_int(0);

	if ( o < 0 ) {
		debug((DBOUT,"add_int_const %d, %d, %d\n", w, r1, -o));
	} else {
		debug((DBOUT,"sub_int_const %d, %d, %d\n", w, r1, o));
	}
	LOUT(ppc_op_addi(w, r1, -o));
}

define_insn(sbc_int, sbc_RRR)
{
	int r2 = rreg_int(2);
	int r1 = rreg_int(1);
	int w = wreg_int(0);

	LOUT(ppc_op_subfe(w, r2, r1));

	debug((DBOUT,"sbc_int %d, %d, %d\n", w, r1, r2));
}

define_insn(sub_float, fsub_RRR)
{
	int r2 = rreg_float(2);
	int r1 = rreg_float(1);
	int w = wreg_float(0);

	LOUT(ppc_op_fsubs(w, r1, r2));

	debug((DBOUT,"sub_float %d, %d, %d\n", w, r1, r2));
}

define_insn(sub_double, fsubl_RRR)
{
	int r2 = rreg_double(2);
	int r1 = rreg_double(1);
	int w = wreg_double(0);

	LOUT(ppc_op_fsub(w, r1, r2));

	debug((DBOUT,"sub_double %d, %d, %d\n", w, r1, r2));
}

define_insn(mul_int, mul_RRR)
{
	int r2 = rreg_int(2);
	int r1 = rreg_int(1);
	int w = wreg_int(0);

	LOUT(ppc_op_mullw(w, r1, r2));

	debug((DBOUT,"mul_int %d, %d, %d\n", w, r1, r2));
}

define_insn(div_int, div_RRR)
{
	int r2 = rreg_int(2);
	int r1 = rreg_int(1);
	int w = wreg_int(0);

	LOUT(ppc_op_divw(w, r1, r2));

	debug((DBOUT,"div_int %d, %d, %d\n", w, r1, r2));
}

/* XXX Add rem_int? */

define_insn(mul_float, fmul_RRR)
{
	int r2 = rreg_float(2);
	int r1 = rreg_float(1);
	int w = wreg_float(0);

	LOUT(ppc_op_fmuls(w, r1, r2));

	debug((DBOUT,"mul_float %d, %d, %d\n", w, r1, r2));
}

define_insn(mul_double, fmull_RRR)
{
	int r2 = rreg_double(2);
	int r1 = rreg_double(1);
	int w = wreg_double(0);

	LOUT(ppc_op_fmul(w, r1, r2));

	debug((DBOUT,"mul_double %d, %d, %d\n", w, r1, r2));
}

define_insn(div_float, fdiv_RRR)
{
	int r2 = rreg_float(2);
	int r1 = rreg_float(1);
	int w = wreg_float(0);

	LOUT(ppc_op_fdivs(w, r1, r2));

	debug((DBOUT,"div_float %d, %d, %d\n", w, r1, r2));
}

define_insn(div_double, fdivl_RRR)
{
	int r2 = rreg_double(2);
	int r1 = rreg_double(1);
	int w = wreg_double(0);

	LOUT(ppc_op_fdiv(w, r1, r2));

	debug((DBOUT,"div_double %d, %d, %d\n", w, r1, r2));
}

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

define_insn(and_int, and_RRR)
{
	int r2 = rreg_int(2);
	int r1 = rreg_int(1);
	int w = wreg_int(0);

	LOUT(ppc_op_and(w, r1, r2));

	debug((DBOUT,"and_int %d, %d, %d\n", w, r1, r2));
}

define_insn(and_int_const, and_RRC)
{
	int o = const_int(2);
	int r1 = rreg_int(1);
	int w = wreg_int(0);

	LOUT(ppc_op_andi(w, r1, o));

	debug((DBOUT,"and_int_const %d, %d, %d\n", w, r1, 0));
}


define_insn(or_int, or_RRR)
{
	int r2 = rreg_int(2);
	int r1 = rreg_int(1);
	int w = wreg_int(0);

	LOUT(ppc_op_or(w, r1, r2));

	debug((DBOUT,"or_int %d, %d, %d\n", w, r1, r2));
}

define_insn(xor_int, xor_RRR)
{
	int r2 = rreg_int(2);
	int r1 = rreg_int(1);
	int w = wreg_int(0);

	LOUT(ppc_op_xor(w, r1, r2));
	
	debug((DBOUT,"xor_int %d, %d, %d\n", w, r1, r2));
}

define_insn(ashr_int, ashr_RRR)
{
	int r2 = rreg_int(2);
	int r1 = rreg_int(1);
	int w = wreg_int(0);

	LOUT(ppc_op_sraw(w, r1, r2));
	debug((DBOUT,"ashr_int %d, %d, %d\n", w, r1, r2));
}

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

	LOUT(ppc_op_srawi(w, r, v));
	
	debug((DBOUT,"ashr_int_const %d, %d, %d\n", w, r, v));
}

define_insn(lshr_int, lshr_RRR)
{
	int r2 = rreg_int(2);
	int r1 = rreg_int(1);
	int w = wreg_int(0);

	LOUT(ppc_op_srw(w, r1, r2));
	debug((DBOUT,"lshr_int %d, %d, %d\n", w, r1, r2));
}

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

	LOUT(ppc_op_rlwinm(w, r, 32 - v, v, 31));

	debug((DBOUT,"lshr_int_const %d, %d, %d\n", w, r, v));
}

define_insn(lshl_int, lshl_RRR)
{
	int r2 = rreg_int(2);
	int r1 = rreg_int(1);
	int w = wreg_int(0);

	LOUT(ppc_op_slw(w, r1, r2));

	debug((DBOUT,"lshl_int %d, %d, %d\n", w, r1, r2));
}

define_insn(lshl_int_const, lshl_RRC)
{
	/*
	 * XXX Oh, for fucks sake, if you reverse the order of these
	 * assignments you get bad code in the form of a bad destination
	 * register.
	 */
	int v = const_int(2);
	int r = rreg_int(1);
	int w = wreg_int(0);

	LOUT(ppc_op_slwi(w, r, v));
	debug((DBOUT,"shll %d, %d, LSL %d\n", w, r, v));
}


/* --------------------------------------------------------------------- */
//
// Load/store offset

/* XXX define the HAVE_'s */
define_insn(load_offset_int, load_RRC)
{
	int v = const_int(2);
	int r = rreg_int(1);
	int w = wreg_int(0);

	LOUT(ppc_op_lwz(w, r, v));

	debug((DBOUT,"ld %d, [%d+%d]\n", w, r, v));
}

define_insn(store_offset_int, store_RRC)
{
	int o = const_int(2);
	int a = rreg_ref(1);
	int r = rreg_int(0);

	LOUT(ppc_op_stw(r, a, o));

	debug((DBOUT,"st %d, [%d+%d]\n", r, a, o));
}


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

/* XXX Are there load_TYPE_offset versions? */
define_insn(load_byte, loadb_RxR)
{
	int r = rreg_int(2);
	int w = wreg_int(0);

	LOUT(ppc_op_lbz(w, r, 0));

	debug((DBOUT,"load_byte %d, [%d]\n", w, r));
}

define_insn(load_offset_byte, loadb_RRC)
{
	int o = const_int(2);
	int a = rreg_ref(1);
	int w = wreg_int(0);

	LOUT(ppc_op_lbz(w, a, o));

	debug((DBOUT,"load_offset_byte %d, [%d]\n", w, a));
}

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

	/* XXX lhz? */
	LOUT(ppc_op_lhz(w, r, 0));

	debug((DBOUT,"load_char %d, [%d]\n", w, r));
}

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

	/* XXX lhz? */
	LOUT(ppc_op_lhz(w, r, 0));

	debug((DBOUT,"load_short %d, [%d]\n", w, r));
}

define_insn(load_offset_short, loads_RRC)
{
	int o = const_int(2);
	int a = rreg_ref(1);
	int w = wreg_int(0);

	LOUT(ppc_op_lhz(w, a, o));

	debug((DBOUT,"load_offset_short %d, [%d]\n", w, a));
}

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

	LOUT(ppc_op_lwz(w, r, 0));

	debug((DBOUT,"ld %d, [%d]\n", w, r));
}

define_insn(load_float, fload_RxR)
{
	int r = rreg_int(2);
	int w = wreg_float(0);

	LOUT(ppc_op_lfs(w, r, 0));

	debug((DBOUT,"load_float %d, [%d]\n", w, r));
}

define_insn(load_offset_float, fload_RRC)
{
	int o = const_int(2);
	int a = rreg_ref(1);
	int w = wreg_float(0);

	LOUT(ppc_op_lfs(w, a, o));

	debug((DBOUT,"load_offset_float %d, [%d]\n", w, a));
}

define_insn(load_double, floadl_RxR)
{
	int r = rreg_int(2);
	int w = wreg_double(0);

	LOUT(ppc_op_lfd(w, r, 0));

	debug((DBOUT,"load_double %d, [%d]\n", w, r));
}

define_insn(load_offset_double, floadl_RRC)
{
	int o = const_int(2);
	int a = rreg_ref(1);
	int w = wreg_double(0);

	LOUT(ppc_op_lfd(w, a, o));

	debug((DBOUT,"load_offset_double %d, [%d]\n", w, a));
}

define_insn(store_byte, storeb_xRR)
{
	int r = rreg_int(2);
	int w = rreg_int(1);

	LOUT(ppc_op_stb(r, w, 0));

	debug((DBOUT,"store_byte %d, [%d]\n", r, w));
}

define_insn(store_offset_byte, storeb_RRC)
{
	int o = const_int(2);
	int a = rreg_ref(1);
	int r = rreg_int(0);

	LOUT(ppc_op_stb(r, a, o));

	debug((DBOUT,"store_offset_byte %d, [%d]\n", r, a));
}

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

	LOUT(ppc_op_sth(r, w, 0));

	debug((DBOUT,"store_short %d, [%d]\n", r, w));
}

define_insn(store_offset_short, stores_RRC)
{
	int o = const_int(2);
	int a = rreg_ref(1);
	int r = rreg_int(0);

	LOUT(ppc_op_sth(r, a, o));

	debug((DBOUT,"store_byte %d, [%d]\n", r, a));
}

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

	/* XXX swapped? */
	LOUT(ppc_op_stw(r, w, 0));

	debug((DBOUT,"store_int %d, [%d]\n", r, w));
}

define_insn(store_float, fstore_RxR)
{
	int r = rreg_float(2);
	int w = rreg_int(1);

	LOUT(ppc_op_stfs(r, w, 0));

	debug((DBOUT,"store_float %d, [%d]\n", r, w));
}

define_insn(store_offset_float, fstore_RRC)
{
	int o = const_int(2);
	int a = rreg_ref(1);
	int r = rreg_float(0);

	LOUT(ppc_op_stfs(r, a, o));

	debug((DBOUT,"store_offset_float %d, [%d]\n", r, a));
}

define_insn(store_double, fstorel_RxR)
{
	int r = rreg_double(2);
	int w = rreg_int(1);

	LOUT(ppc_op_stfd(r, w, 0));

	debug((DBOUT,"store_double %d, [%d]\n", r, w));
}

define_insn(store_offset_double, fstorel_RRC)
{
	int o = const_int(2);
	int a = rreg_ref(1);
	int r = rreg_double(0);

	LOUT(ppc_op_stfd(r, a, o));

	debug((DBOUT,"store_offset_double %d, [%d]\n", r, a));
}

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

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

	LOUT(ppc_op_cmp(PPC_CR_0, r1, r2));

	debug((DBOUT,"cmp_int r%d, r%d\n", r1, r2));
}

define_insn(cmpl_int, cmpl_xRR)
{
	int r1 = rreg_int(1);
	int r2 = rreg_int(2);

	LOUT(ppc_op_cmpl(PPC_CR_0, r1, r2));

	debug((DBOUT,"cmpl_int r%d, r%d\n", r1, r2));
}

define_insn(cmp_int_const, cmp_xRC)
{
	int r = rreg_int(1);
	int o = const_int(2);

	LOUT(ppc_op_cmpi(PPC_CR_0, r, o));

	debug((DBOUT,"cmp_int_const r%d, #%d\n", r, o));
}

define_insn(cmp_offset_int, cmpl_xRRC)
{
	int r = rreg_int(1);
	int a = rreg_ref(2);
	int o = const_int(3);

	LOUT(ppc_op_lwz(a, a, o));
	LOUT(ppc_op_cmpl(PPC_CR_0, r, a));

	debug((DBOUT,"cmp_offset_int r%d, #%d\n", r, o));
}

define_insn(cmp_ref, cmpref_xRR)
{
	int r1 = rreg_ref(1);
	int r2 = rreg_ref(2);

	LOUT(ppc_op_cmpl(PPC_CR_0, r1, r2));

	debug((DBOUT,"cmp_ref r%d, r%d\n", r1, r2));
}

define_insn(cmp_ref_const, cmpref_xRC)
{
	int r = rreg_ref(1);
	int o = const_int(2);

	LOUT(ppc_op_cmpi(PPC_CR_0, r, o));

	debug((DBOUT,"cmp_ref_const r%d, #%d\n", r, o));
}


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

static long long cvt_int_float_value = 0x4330000080000000LL;

/* XXX update have's */
define_insn(cvt_int_float, cvtif_RxR)
{
	int r = rreg_int(2); /* CHECKME */
	int i, j; // intermediate
	int w = wreg_float(0);
	SlotInfo *tmp_si_gpr, *tmp_si_fpr;
	SlotData *tmp_gpr, *tmp_fpr;
	int hi_offset, lo_offset;

	/* cwg 3.3.8.2 */
	
	/*
	 * Allocate two temporaries, one in gpr (holds the sign flipped version
	 * of the input) and one in fpr (for the 0x4330000080000000 constant).
	 */
	slot_alloctmp(tmp_si_gpr);
	tmp_gpr = tmp_si_gpr->slot;
	slot_alloc2tmp(tmp_si_fpr);
	tmp_fpr = tmp_si_fpr->slot;
	hi_offset = -8;
	lo_offset = -4;
	/* Build the most significant bits. */
	LOUT(ppc_op_lis(PPC_R0, 0x4330));
	/* Store them as if making a double. */
	if( !hi_offset )
	{
		label *l;

		l = KaffeJIT3_newLabel();
		l->type = Lsavedregs | Lrelative | Lgeneral;
		l->from = -8;
		l->to = 0;
		l->at = CODEPC;
	}
	LOUT(ppc_op_stw(PPC_R0, PPC_RSP, hi_offset));
	i = slotRegister(tmp_gpr, Rint, rwrite, NOREG);
	/* Flip the sign bit and put it in our temporary. */
	LOUT(ppc_op_xoris(i, r, 0x8000));
	/* Spill the temporary, just the low bits of the double this time. */
	if( !hi_offset )
	{
		label *l;

		l = KaffeJIT3_newLabel();
		l->type = Lsavedregs | Lrelative | Lgeneral;
		l->from = -4;
		l->to = 0;
		l->at = CODEPC;
	}
	LOUT(ppc_op_stw(i, PPC_RSP, lo_offset));
	/* XXX Load the cvs_int_float_value above. */
	LOUT(ppc_op_lis(i, ppc_ha16(&cvt_int_float_value)));
	/* Get our float temporary. */
	j = slotRegister(tmp_fpr, Rdouble, rwrite, NOREG);
	/* Load our constant. */
	LOUT(ppc_op_lfd(j, i, ppc_lo16(&cvt_int_float_value)));
	/* Load our constructed double. */
	if( !hi_offset )
	{
		label *l;

		l = KaffeJIT3_newLabel();
		l->type = Lsavedregs | Lrelative | Lgeneral;
		l->from = -8;
		l->to = 0;
		l->at = CODEPC;
	}
	LOUT(ppc_op_lfd(w, PPC_RSP, hi_offset));
	/* Subtract the constant to get our result. */
	LOUT(ppc_op_fsub(w, w, j));
	LOUT(ppc_op_frsp(w, w));
	slot_freetmp(tmp_si_gpr);
	slot_free2tmp(tmp_si_fpr);

	debug((DBOUT,"cvt_int_float %d, %d\n", w, r));
}

define_insn(cvt_int_double, cvtid_RxR)
{
	int r = rreg_int(2);
	int i, j; // intermediate
	int w = wreg_double(0);
	SlotInfo *tmp_si_gpr, *tmp_si_fpr;
	SlotData *tmp_gpr, *tmp_fpr;
	int hi_offset, lo_offset;

	slot_alloc2tmp(tmp_si_gpr);
	tmp_gpr = tmp_si_gpr->slot;
	slot_alloc2tmp(tmp_si_fpr);
	tmp_fpr = tmp_si_fpr->slot;
	hi_offset = -8;
	lo_offset = -4;
	LOUT(ppc_op_lis(PPC_R0, 0x4330));
	if( !hi_offset )
	{
		label *l;

		l = KaffeJIT3_newLabel();
		l->type = Lsavedregs | Lrelative | Lgeneral;
		l->from = -8;
		l->to = 0;
		l->at = CODEPC;
	}
	LOUT(ppc_op_stw(PPC_R0, PPC_RSP, hi_offset));
	i = slotRegister(tmp_gpr, Rint, rwrite, NOREG);
	LOUT(ppc_op_xoris(i, r, 0x8000));
	if( !hi_offset )
	{
		label *l;

		l = KaffeJIT3_newLabel();
		l->type = Lsavedregs | Lrelative | Lgeneral;
		l->from = -4;
		l->to = 0;
		l->at = CODEPC;
	}
	LOUT(ppc_op_stw(i, PPC_RSP, lo_offset));
	LOUT(ppc_op_lis(i, ppc_hi16(&cvt_int_float_value)));
	LOUT(ppc_op_ori(i, i, ppc_lo16(&cvt_int_float_value)));
	j = slotRegister(tmp_fpr, Rdouble, rwrite, NOREG);
	if( !hi_offset )
	{
		label *l;

		l = KaffeJIT3_newLabel();