jit3-arm.def

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

	op_store_offset(r0, r1, v);
	debug((DBOUT,"st %d, [%d+%d]\n", r1, r0, v));
}


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

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

	op_load_sb(w, r);

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

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

	op_load_sh(w, r);

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

	op_load_sh(w, r);

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

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

	op_load(w, r);

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

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

	op_fload(w, r);

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

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

	op_floadl(w, r);

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

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

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

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

	op_store_h(w, r);

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

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

	op_store(r, w);

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

	op_fstore(r, w);

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

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

	op_fstorel(r, w);

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

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

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

	op_cmp(r1, r2);

	debug((DBOUT,"cmp_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);

	op_cmp_const(r, o);

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

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

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

	op_cmp_const(r, o);

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


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

define_insn(cvt_int_float, cvtif_RxR)
{
	int r = rreg_int(2); /* CHECKME */
	int w = wreg_float(0);
	op_cvt_i2f(w,r);
	debug((DBOUT,"cvt_int_float %d, %d\n", w, r));
}

define_insn(cvt_int_double, cvtid_RxR)
{
	int r = rreg_int(2);
	int w = wreg_double(0);
	op_cvt_i2d(w,r);
	debug((DBOUT,"cvt_int_double %d, %d\n", w, r));
}

define_insn(cvt_float_int, cvtfi_RxR)
{
	int r = rreg_float(2);
	int w = wreg_int(0);
	op_cvt_f2i(w,r);
	debug((DBOUT,"cvt_float_int r%d, f%d\n", w, r));
}

define_insn(cvt_int_double, cvtdi_RxR)
{
	int r = rreg_double(2);
	int w = wreg_int(0);
	op_cvt_f2i(w,r);
	debug((DBOUT,"cvt_double_int %d, %d\n", w, r));
}

#if 0
/* these aren't being used */
define_insn(cvt_long_float, cvtlf_RxR)
{
	/* Is a long a 64-bit quantity? */
	debug((DBOUT,"NOT IMPLEMENTED: cvt_long_float\n"));
}

define_insn(cvt_long_double, cvtld_RxR)
{
	debug((DBOUT,"NOT IMPLEMENTED: cvt_long_double\n"));
    }
#endif

define_insn(cvt_float_double, cvtfd_RxR)
{
	int r = rreg_float(2);
	int w = wreg_double(0);
	op_fmovl(w,r);
	debug((DBOUT,"cvt_float_double f%d, f%d\n",w,r));
}

define_insn(cvt_double_float, cvtdf_RxR)
{
	int r = rreg_double(2);
	int w = wreg_float(0);
	op_fmov(w,r);
	debug((DBOUT,"cvt_double_float f%d, f%d\n",w,r));
}

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

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

	LOUT = val;

	debug((DBOUT,"build_key %d", val));
}

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

	l->type |= Llong|Labsolute;
	l->at = CODEPC;
	l->from = CODEPC;
	LOUT = 0;

	debug((DBOUT,"build_code_ref (@0x%x from 0x%x)\n", l->at, l->from));
}

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

define_insn(set_label, set_label_xxC)
{
	label* l = const_label(2);

	l->to = CODEPC;

	debug((DBOUT,"set_label (@0x%x to 0x%x)\n", l->at, l->to));
}

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

	l->type |= Llong26|Lrelative;

	l->at = CODEPC;
	l->from = CODEPC + 8;

	switch (bt) {
	case ba:
		op_branch(CC_AL, 0);
		break;
	case beq:
		op_branch(CC_EQ, 0);
		break;
	case bne:
		op_branch(CC_NE, 0);
		break;
	case blt:
		op_branch(CC_LT, 0);
		break;
	case ble:
		op_branch(CC_LE, 0);
		break;
	case bgt:
		op_branch(CC_GT, 0);
		break;
	case bge:
		op_branch(CC_GE, 0);
		break;
	case bult:
		op_branch(CC_CC, 0);
		break;
	case bugt:
		op_branch(CC_HI, 0);
		break;
	case buge:
		op_branch(CC_CS, 0);
		break;
	default:
		abort();
	}

	debug((DBOUT,"branch type %d at 0x%x from 0x%x\n", bt, l -> at, l -> from));
}

//
// This is currently not used..
//
define_insn(call_ref, call_xCC)
{
	label* l = const_label(1);
	unsigned long dest = 0;
	long relative = CODEPC-dest;
	long highpart = relative & 0xffffff;
	
	assert(const_int(2) == dest);

	//
	// Determine if the relative address will fit in a 24-bit displacement
	//
	if (  highpart == 0xff000000 || highpart == 0 ) {
	  //
	  // Yes, it's likely to fit
	  //
	  l->type |= Llong26|Lrelative;
	  l->at = CODEPC;
	  l->from = CODEPC + 8;
	  op_branch_linked(CC_AL, 0);
	} else {
	  int w = 0;
	  assert("Should not happen");
	  //
	  // No, it's not going to fit..
	  //
	  op_mov_c(w, dest & 0x000000FF, 0);
	  op_add_c(w, w, (dest >> 8) & 0x000000FF, 24);
	  op_add_c(w, w, (dest >> 16) & 0x000000FF, 16);
	  op_add_c(w, w, (dest >> 24) & 0x000000FF, 8);
	}
}

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

	op_mov(LR, PC);
	op_mov(PC, r);

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

define_insn(branch_indirect, branch_indirect_xRC)
{
	int r = rreg_int(1);
	assert(const_int(2) == ba);
	op_mov(PC, r);
	debug((DBOUT,"branch_indirect [r%d]\n", r));
}

define_insn(push_int, push_xRC)
{
	int a = const_int(2);
	int r;

	if (a < 4) {
		int w = R0 + a;
		r = rreg_ideal_int(1, w);
		if (r != w) {
			clobberRegister(w);
			op_mov(w, r);
		}
		register_reserve(w);
	}
	else {
		r = rreg_int(1);
		op_push(SP, r);
		debug((DBOUT,"push_int via push SP,r%d\n", r));
	}

}

define_insn(push_float, fpush_xRC)
{
	int r;
	int w;
	int a = const_int(2);


	switch (a) {
	case 0:
	case 1:
	case 2:
	case 3:
		w = R0 + a;
		clobberRegister(w);
		/*
		 * Push it on to the stack
		 */
		r = rreg_float(1);
		op_fpush(SP, r);
		/*
		 * Now pop it into the register pair
		 */
		op_pop_m(SP, (1 << w));
		register_reserve(w);
		debug((DBOUT,"push_float via elaborate mov r(%d) := f%d\n", w, r));
		break;

	default:
		/*
		 * Push it on to the stack
		 */
		r = rreg_float(1);
		op_fpush(SP, r);
		debug((DBOUT,"push_float via SP, f%d\n", r));
		break;
	}
}


define_insn(push_double, fpushl_xRC)
{
	int r;
	int w;
	int a = const_int(2);


	switch (a) {
	case 0:
	case 1:
	case 2:
		w = R0 + a;
		clobberRegister(w);
		clobberRegister(w+1);
		/*
		 * Push it on to the stack
		 */
		r = rreg_double(1);
		op_fpushl(SP, r);
		/*
		 * Now pop it into the register pair
		 */
		op_pop_m(SP, (1 << w) | (1 << (w+1)));
		register_reserve(w);
		register_reserve(w+1);
		debug((DBOUT,"push_double via elaborate mov r(%d,%d) := f%d\n", w, w+1, r));
		break;

	case 3:
		/*
		 * Pass half of the double in R3, half on the stack
		 */
		w = R3;
		clobberRegister(w);
		r = rreg_double(1);
		op_fpushl(SP, r);

		/* Pop the first word */
		op_pop_m(SP, (1 << w));
		register_reserve(w);
		debug((DBOUT,"push_double via partial register, partial stack SP, f%d\n", r));
		break;

	default:
		/*
		 * Push it on to the stack
		 */
		r = rreg_double(1);
		op_fpushl(SP, r);
		debug((DBOUT,"push_double via SP, f%d\n", r));
		break;
	}
}

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

	/* Reset reserve bit for all register arguments */
	for (i = 0; i < 4 && i < o; i++) {
		register_unreserve(R0 + i);
	}

	/* Don't bother if we have 4 or less arguments to pop */
	if (o > 4) {
		o = (o - 4) * SLOTSIZE;
		assert(__I8const_rangecheck(o >> 2));
		op_add_c(SP, SP, (o >> 2), 30);

		debug((DBOUT,"popargs SP, SP, %d\n", o));
	} else {
		debug((DBOUT,"null popargs with %d args\n", const_int(2)));
	}
}

define_insn(returnarg_int, returnarg_xxR)
{
	int r = rreg_int(2);

	xop_mov(R0, r);

	debug((DBOUT,"returnarg_int R0,%d\n", r));
}

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

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

	debug((DBOUT,"returnarg_long R0,%d,%d\n", r1, r2));

	/* Return long is a bit complicated since part of the source may
	 * be the destination.
	 */ 
	if (R0 != r2) {
		op_mov(R0, r1);
		op_mov(R1, r2);
	}
	else if (R1 != r1) {
		op_mov(R1, r2);
		op_mov(R0, r1);
	}
	else {
		/* Need to swap R0 and R1.  Force R0 into R2 (writing back
		 * R2 if necessary) and then move things about until the
		 * swap is done.
		 */
		forceRegister(r, R2, Rint);
		op_mov(R2, R0);
		op_mov(R0, R1);
		op_mov(R1, R2);
	}
}

define_insn(returnarg_float, freturnarg_xxR)
{
	int r = rreg_float(2);

	xop_fmov(F0, r);

	debug((DBOUT,"returnarg_float R0,%d\n", r));
}

define_insn(returnarg_double, freturnargl_xxR)
{
	int r = rreg_double(2);

	xop_fmovl(F0, r);

	debug((DBOUT,"returnarg_double R0,%d\n", r));
}

define_insn(return_int, return_Rxx)
{
	forceRegister(seq_dst(s), R0, Rint);

	debug((DBOUT,"return_int R0\n"));
}

define_insn(return_long, returnl_Rxx)
{
	forceRegister(seq_dst(s), R0, Rint);
	forceRegister(seq_dst(s)+1, R1, Rint);

	debug((DBOUT,"return_long R0,R1\n"));
}

define_insn(return_float, freturn_Rxx)
{
	forceRegister(seq_dst(s), Reg_F0, Rfloat);

	debug((DBOUT,"return_float F0\n"));
}

define_insn(return_double, freturnl_Rxx)
{
	forceRegister(seq_dst(s), Reg_F0, Rdouble);

	debug((DBOUT,"return_double F0\n"));
}

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

#if 0
/*
 * We use to use this version of the fakecall system but it uses way
 * to many constant pool entries.  Since it's not time critical we
 * use the new lower version which doesn't use the constant pool but
 * instead constructs the relevant addresses byte by byte.
 */
define_insn(fake_call_constpool, fakecall_xCC)
{
        label* tol = const_label(2);
        label* froml = const_label(1);

	froml->type = Lconstant | Labsolute | Loffset12;
        froml->at = CODEPC;

	op_load_offset(LR, CONSTPOOL_BASE, -128);
	debug((DBOUT,"load_label_const lr, ?\n"));

        tol->type = Lconstant | Labsolute | Loffset12;
        tol->at = CODEPC;

	op_load_offset(R0, CONSTPOOL_BASE, -128);
	debug((DBOUT,"load_label_const r0, ?\n"));

	op_mov(PC, R0);
}

#endif

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

	froml->type |= Labsolute | Llong8x8x8x8;
        froml->at = CODEPC;

	op_mov_c(LR, 0, 0);
	op_add_c(LR, LR, 0, 24);
	op_add_c(LR, LR, 0, 16);
	op_add_c(LR, LR, 0, 8);
	debug((DBOUT,"move_label_const lr, ?\n"));

        tol->type |= Labsolute | Llong8x8x8x8;
        tol->at = CODEPC;

	op_mov_c(R0, 0, 0);
	op_add_c(R0, R0, 0, 24);
	op_add_c(R0, R0, 0, 16);
	op_add_c(R0, R0, 0, 8);
	debug((DBOUT,"move_label_const r0, ?\n"));

	op_mov(PC, R0);
}