jit3-m68k.def

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

		}
	}
#else
	op_moveml_pr(REG_sp, RESTOREMASK);
#endif

	op_unlk_a(REG_fp);
	op_rts();
}

define_insn(eprologue, eprologue_xxx)
{
	label* l;

	l = (label*)const_int(1);
	l->type = Llnegframe|Labsolute|Lgeneral;

	/* Be careful not to dealocate our current frame even for
	   an instant.  */
	op_moveal_aa(REG_fp, REG_a0);
	l->at = (uintp)CODEPC+2;
	op_addal_ia(0, REG_a0);

#if	(0)		// don't destroy our good registers
#if !defined(HAVE_NO_SUBAW)
	op_subaw_ia(SRNR * SLOTSIZE, REG_a0);
#else
	op_subal_ia(SRNR * SLOTSIZE, REG_a0);
#endif
#endif		// end no-oped section

	op_moveal_aa(REG_a0, REG_sp);
}

define_insn(check_stack_limit, check_stack_limit_xRC)
{
        int r = rreg_ref(1);
        label* l = const_label(2);

	op_cmpal_aa(REG_sp, r);
	op_blo_16(8);
        l->type |= Llong|Labsolute;
        l->at = CODEPC+2;
        l->from = CODEPC+2;
	op_jsr_32((uintp)soft_stackoverflow);
}

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

define_insn(spill_int, spilli_RCx)
{
	int r = sreg_int(0);
	int o = const_int(1);

	op_movel_do(r, REG_fp, o);
}

define_insn(spill_ref, spillr_RCx)
{
	int r = sreg_ref(0);
	int o = const_int(1);

	op_movel_ao(r, REG_fp, o);
}

define_insn(spill_float, spillf_RCx)
{
	int r = sreg_float(0);
	int o = const_int(1);

	op_fmoves_fo(r, REG_fp, o);
}

define_insn(spill_double, spilld_RCx)
{
	int r = sreg_double(0);
	int o = const_int(1);

	op_fmoved_fo(r, REG_fp, o);
}

define_insn(reload_int, reloadi_RCx)
{
	int r = lreg_int(0);
	int o = const_int(1);

	op_movel_od(REG_fp, o, r);
}

define_insn(reload_ref, reloadr_RCx)
{
	int r = lreg_ref(0);
	int o = const_int(1);

	op_moveal_oa(REG_fp, o, r);
}

define_insn(reload_float, reloadf_RCx)
{
	int r = lreg_float(0);
	int o = const_int(1);

	op_fsmoves_of(REG_fp, o, r);
}

define_insn(reload_double, reloadd_RCx)
{
	int r = lreg_double(0);
	int o = const_int(1);

	op_fdmoved_of(REG_fp, o, r);
}

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

define_insn(move_int_const, movei_RxC)
{
	int i = const_int(2);
	int w = wreg_int(0);

	if (i >= -0x80 && i < 0x80)
		op_moveq_id(i, w);
	else
		op_movel_id(i, w);
}

define_insn(move_ref_const, mover_RxC)
{
	int i = const_int(2);
	int w = wreg_ref(0);

	op_moveal_ia(i, w);
}

define_insn(move_label_const, mover_RxL)
{
	label* l = const_label(2);
	int w = wreg_ref(0);

	l->type |= Labsolute | Llong;
	l->at = CODEPC+2;

	op_moveal_ia(0, w);
}

define_insn(move_any, movea_RxR)
{
	int r1, r2;

	/* If the source is already in a register, allocate the destination
	   to the same register type.  Otherwise arbitrarily load as int. */

	if (slotInRegister(2, Rref)) {
		r2 = rreg_ref(2);
		r1 = wreg_ref(0);
		if (r1 != r2) {
			op_moveal_aa(r2, r1);
		}
	}
	else if (slotInRegister(2, Rfloat)) {
		r2 = rreg_float(2);
		r1 = wreg_float(0);
		if (r1 != r2) {
			op_fsmovex_ff(r2, r1);
		}
	}
	else if (slotInRegister(2, Rint)) {
		r2 = rreg_int(2);
		r1 = wreg_int(0);
		if (r1 != r2) {
			op_movel_dd(r2, r1);
		}
	}
	else {
		r2 = rslot_int(2);
		r1 = wreg_int(0);
		op_movel_od(REG_fp, r2, r1);
	}
}

define_insn(move_int, movei_RxR)
{
	int r = rreg_int(2);
	int w = wreg_int(0);

	if (r != w) {
		op_movel_dd(r, w);
	}
}

define_insn(move_ref, mover_RxR)
{
	int r = rreg_ref(2);
	int w = wreg_ref(0);

	if (r != w) {
		op_moveal_aa(r, w);
	}
}

define_insn(move_float, movef_RxR)
{
	int r = rreg_float(2);
	int w = wreg_float(0);

	if (r != w) {
		op_fsmovex_ff(r, w);
	}
}

define_insn(move_double, moved_RxR)
{
	int r = rreg_double(2);
	int w = wreg_double(0);

	if (r != w) {
		op_fdmovex_ff(r, w);
	}
}

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

define_insn(add_int_const, addi_RRC)
{
	int o = const_int(2);
	int rw = rwreg_int(0);

	assert(rreg_int(1) == rw);

	if (o >= 1 && o <= 8) {
		op_addql_id(o, rw);
	}
	else {
		op_addl_id(o, rw);
	}
}

define_insn(add_int, addi_RRR)
{
	int r = rreg_int(2);
	int w = rwreg_int(0);

	assert(rreg_int(1) == w);

	op_addl_dd(r, w);
}

define_insn(adc_int, adci_RRR)
{
	int r = rreg_int(2);
	int w = rwreg_int(0);

	assert(rreg_int(1) == w);

	op_addxl_dd(r, w);
}

define_insn(add_ref_const, addr_RRC)
{
	int o = const_int(2);
	int rw = rwreg_ref(0);

	assert(rreg_ref(1) == rw);

	if (o >= 1 && o <= 8) {
		op_addql_ia(o, rw);
	}
#if !defined(HAVE_NO_ADDAW)
	else if (o >= -0x8000 && o < 0x8000) {
		op_addaw_ia(o, rw);
	}
#endif
	else {
		op_addal_ia(o, rw);
	}
}

define_insn(add_ref, addr_RRR)
{
	int r = rreg_int(2);
	int w = rwreg_ref(0);

	assert(rreg_ref(1) == w);

	op_addal_da(r, w);
}

define_insn(add_float, addf_RRR)
{
	int r = rreg_float(2);
	int w = rwreg_float(0);

	assert(rreg_float(1) == w);

	op_fsaddx_ff(r, w);
}

define_insn(add_double, addd_RRR)
{
	int r = rreg_double(2);
	int w = rwreg_double(0);

	assert(rreg_double(1) == w);

	op_fdaddx_ff(r, w);
}

define_insn(sub_int_const, subi_RRC)
{
	int o = const_int(2);
	int rw = rwreg_int(0);

	assert(rreg_int(1) == rw);

	if (o >= 1 && o <= 8) {
		op_subql_id(o, rw);
	}
	else {
		op_subl_id(o, rw);
	}
}

define_insn(sub_int, subi_RRR)
{
	int r = rreg_int(2);
	int w = rwreg_int(0);

	assert(rreg_int(1) == w);

	op_subl_dd(r, w);
}

define_insn(sbc_int, sbci_RRR)
{
	int r = rreg_int(2);
	int w = rwreg_int(0);

	assert(rreg_int(1) == w);

	op_subxl_dd(r, w);
}

define_insn(sub_float, subf_RRR)
{
	int r = rreg_float(2);
	int w = rwreg_float(0);

	assert(rreg_float(1) == w);

	op_fssubx_ff(r, w);
}

define_insn(sub_double, subd_RRR)
{
	int r = rreg_double(2);
	int w = rwreg_double(0);

	assert(rreg_double(1) == w);

	op_fdsubx_ff(r, w);
}

define_insn(neg_int, negi_RxR)
{
	int rw = rwreg_int(0);

	assert(rreg_int(2) == rw);

	op_negl_d(rw);
}

define_insn(ngc_int, ngci_RxR)
{
	int rw = rwreg_int(0);

	assert(rreg_int(2) == rw);

	op_negxl_d(rw);
}

define_insn(neg_float, negf_RxR)
{
	int r = rreg_float(2);
	int w = wreg_float(0);

	op_fsnegx_ff(r, w);
}

define_insn(neg_double, negd_RxR)
{
	int r = rreg_double(2);
	int w = wreg_double(0);

	op_fdnegx_ff(r, w);
}

define_insn(mul_int_const, muli_RRC)
{
	int o = const_int(2);
	int rw = rwreg_int(0);

	assert(rreg_int(1) == rw);

	op_mulsl_id(o, rw);
}

define_insn(mul_int, muli_RRR)
{
	int r = rreg_int(2);
	int w = rwreg_int(0);

	assert(rreg_int(1) == w);

	op_mulsl_dd(r, w);
}

define_insn(mul_float, mulf_RRR)
{
	int r = rreg_float(2);
	int w = rwreg_float(0);

	assert(rreg_float(1) == w);

	op_fsmulx_ff(r, w);
}

define_insn(mul_double, muld_RRR)
{
	int r = rreg_double(2);
	int w = rwreg_double(0);

	assert(rreg_double(1) == w);

	op_fdmulx_ff(r, w);
}

define_insn(div_int, divi_RRR)
{
	int r = rreg_int(2);
	int w = rwreg_int(0);

	assert(rreg_int(1) == w);

	op_divsl_ddd(r, w, w);
}

define_insn(div_float, divf_RRR)
{
	int r = rreg_float(2);
	int w = rwreg_float(0);

	assert(rreg_double(1) == w);

	op_fsdivx_ff(r, w);
}

define_insn(div_double, divd_RRR)
{
	int r = rreg_double(2);
	int w = rwreg_double(0);

	assert(rreg_double(1) == w);

	op_fddivx_ff(r, w);
}

define_insn(rem_int, remi_RRR)
{
	int d;
	int n;
	int x;

	/* If register is global then we cannot trash 'd' - we'll pick d0
	 * to trash instead (we can be assured d != d0).
	 */
	d = rreg_int(2);
	if (isRegisterGlobal(d)) {
		x = REG_d0;
	}
	else {
		x = d;
	}
	clobberRegister(x);

	/* Get destination - won't be in 'x' due to clobbering */
	n = rwreg_int(0);

	op_divsl_ddd(d, x, n);
	/* If destination or source is global then we cannot force the
	 * register.  In that case just copy the value in.
	 */
	if (isRegisterGlobal(n) || isRegisterGlobal(x)) {
		op_movel_dd(x, n);
	}
	else {
		forceRegister(seq_slot(s, 0), x, Rint);
	}
}

define_insn(rem_float, remf_RRR)
{
	int r = rreg_float(2);
	int w = rwreg_float(0);

	assert(rreg_float(1) == w);

	op_fremx_ff(r, w);
}

define_insn(rem_double, remd_RRR)
{
	int r = rreg_double(2);
	int w = rwreg_double(0);

	assert(rreg_double(1) == w);

	op_fremx_ff(r, w);
}

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

define_insn(and_int_const, andi_RRC)
{
	int o = const_int(2);
	int rw = rwreg_int(0);

	assert(rreg_int(1) == rw);

	op_andl_id(o, rw);
}

define_insn(and_int, andi_RRR)
{
	int r = rreg_int(2);
	int w = rwreg_int(0);

	assert(rreg_int(1) == w);

	op_andl_dd(r, w);
}

define_insn(or_int, ori_RRR)
{
	int r = rreg_int(2);
	int w = rwreg_int(0);

	assert(rreg_int(1) == w);

	op_orl_dd(r, w);
}

define_insn(xor_int, xori_RRR)
{
	int r = rreg_int(2);
	int w = rwreg_int(0);

	assert(rreg_int(1) == w);

	op_eorl_dd(r, w);
}

define_insn(ashr_int_const, ashri_RRC)
{
	int o = const_int(2);
	int rw = rwreg_int(0);

	assert(rreg_int(1) == rw);

	op_asr_id(o, rw);
}

define_insn(ashr_int, ashri_RRR)
{
	int r = rreg_int(2);
	int w = rwreg_int(0);

	assert(rreg_int(1) == w);

	op_asr_dd(r, w);
}

define_insn(lshr_int_const, lshri_RRC)
{
	int o = const_int(2);
	int rw = rwreg_int(0);

	assert(rreg_int(1) == rw);

	op_lsr_id(o, rw);
}

define_insn(lshr_int, lshri_RRR)
{
	int r = rreg_int(2);
	int w = rwreg_int(0);

	assert(rreg_int(1) == w);

	op_lsr_dd(r, w);
}

define_insn(lshl_int_const, lshli_RRC)
{
	int o = const_int(2);
	int rw = rwreg_int(0);

	assert(rreg_int(1) == rw);

	op_lsl_id(o, rw);
}

define_insn(lshl_int, lshli_RRR)
{
	int r = rreg_int(2);
	int w = rwreg_int(0);

	assert(rreg_int(1) == w);

	op_lsl_dd(r, w);
}

define_insn(cmp_int_const, cmpi_xRC)
{
	int v = const_int(2);
	int r = rreg_int(1);

	if (v != 0) {
		op_cmpil_id(v, r);
	}
	else {
		op_tst_d(r);
	}
}

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

	op_cmpl_dd(r2, r1);
}

define_insn(cmp_ref_const, cmpr_xRC)
{
	int v = const_int(2);
	int r = rreg_ref(1);

	if (v != 0) {
		op_cmpil_ia(v, r);