jit-arm.def

基于LWVCL开发的库

#define	op_store_h(R,A)		op_store_h_offset(R,A,0)
#define	op_fstore(R,A)		op_fstore_offset(R,A,0)
#define	op_fstorel(R,A)		op_fstorel_offset(R,A,0)

#define	xop_mov(T,F)		if ((T) != (F)) op_mov(T,F)
#define	xop_fmov(T,F)		if ((T) != (F)) op_fmov(T,F)
#define	xop_fmovl(T,F)		if ((T) != (F)) op_fmovl(T,F)

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

define_insn(unimplemented, unimplemented)
{
	abort();
}

define_insn(nop, nop)
{
	op_mov(R0,R0);
}

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

define_insn(prologue, prologue_xxx)
{
	int i;
	int limit;
	label* l = const_label(1);

	l->type = Lframe|Labsolute|Lgeneral;

	op_mov(IP, SP);
	/*
	 * Every stack segment saves all callee saves registers
 	 * NB: this takes 4 * REGISTERS_SAVED = 40 bytes below the fp. 
	 */

	op_push_prologue(SP,BPC|BFP|BIP|BLR|BR4|BR5|BR6|BR7|BR8|BR9|BR10);
	debug(("maxStack = %d, maxLocal = %d, maxTemp = %d\n", maxStack, maxLocal, maxTemp));

	/*
	 * This effectively hides/removes the just-pushed
	 * PC from the stack pop
	 * and when the stack pop occurs, the FP over-write
	 * reclaims the storage.
	 */
	op_sub_c(FP, IP, 4, 0); 

	/* FOO:  Should save floating point state here !!! F4-F7 */

	l->at = (uintp)CODEPC;

	/* Framesize is filled in by Lframe */
	op_sub_const(SP,SP,0); 

	limit = 4;
	if (maxArgs < limit) {
		limit = maxArgs;
	}

	/* Force first 4 arguments into corresponding registers */
	for (i = 0; i < limit; i++) {
		forceRegister(&localinfo[i], R0+i, Rint /* ? */);
	}
}

define_insn(exception_prologue, eprologue_xxx)
{
	label* l = const_label(1);

	l->type = Lframe|Labsolute|Lgeneral;

	/* Initially, the FP is set --- see CALL_KAFFE_EXCEPTION
	 * We must restore the SP and we must do so in a way that never 
	 * frees anything on the stack.  We use IP as a temp register.
	 */
	op_mov(IP, FP);
	op_sub_c(IP, IP, (REGISTERS_SAVED * SLOTSIZE), 0);
	l->at = (uintp)CODEPC;
	op_sub_const(SP,IP,0); /* Framesize is filled in by Lframe */
}

define_insn(epilogue, epilogue_xxx)
{
	KaffeJIT_setEpilogueLabel ((uintp)CODEPC);

	/* Should restore floating point state here !!! F4-F7 */

	debug(("maxStack = %d, maxLocal = %d, maxTemp = %d\n", maxStack, maxLocal, maxTemp));
	/*
	 * Pushed as
	 * FP	-> FP
	 * IP 	-> SP (actually, SP -> SP)
	 * LR   -> PC
	 * Rest are caller-saves
	 */
	op_pop_epilogue(FP,BFP|BSP|BPC|BR4|BR5|BR6|BR7|BR8|BR9|BR10);
}

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

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

	assert(__I12const_rangecheck(o));
	op_store_offset(r, FP, o);

	debug(("spill_int %d, [FP, %d]\n", r, o));
}

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

	assert(__I10const_rangecheck(o));
	assert( (o & 0x3) == 0);
	op_fstore_offset(r, FP, o >> 2);

	debug(("spill_float %d, [FP, %d]\n", r, o));
}

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

	assert(__I10const_rangecheck(o));
	assert( (o & 0x3) == 0);
	op_fstorel_offset(r, FP, o >> 2);

	debug(("spill_double %d, [FP, %d]\n", r, o));
}

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

	assert(__I12const_rangecheck(o));
	op_load_offset(r, FP, o);

	debug(("reload_int %d, [FP, %d]\n", r, o));
}

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

	assert(__I10const_rangecheck(o));
	assert( (o & 0x3) == 0);
	op_fload_offset(r, FP, o >> 2);

	debug(("reload_float %d, [FP, %d]\n", r, o));
}

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

	assert(__I10const_rangecheck(o));
	assert( (o & 0x3) == 0);
	op_floadl_offset(r, FP, o >> 2);

	debug(("reload_double %d, [FP, %d]\n", r, o));
}

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

define_insn(move_int_const, move_RxC)
{
	int val = const_int(2);
	int w = wreg_int(0);
	int shift = 0;
	int sval = val;

	while (shift < 32) {
		/* Does sval fit in 8 bits after shifted by `shift' bits?
		 * NB: op_mov_c requires that the 8-bit immediate 
		 * be ROTATED to the right, hence the (32 - shift) % 32.
		 */
		if ((sval & 0xFFFFFF00) == 0) {
			op_mov_c(w, sval, (32 - shift) % 32);

			debug(("move_int_const %d, %d (0x%x) via shift (%d, %d)\n", w, val, val, sval, shift));

			return;
		}
		else if ((sval & 0x000000FF) != 0) {
			/* Can't handle this kind of number encoding */
			break;
		}
		sval = sval >> 2;
		shift += 2;
	}

	/* Fail to encode in a short fashion - fall back on a long one */
	op_mov_c(w, val & 0x000000FF, 0);
	op_add_c(w, w, (val >> 8) & 0x000000FF, 24);
	op_add_c(w, w, (val >> 16) & 0x000000FF, 16);
	op_add_c(w, w, (val >> 24) & 0x000000FF, 8);

	debug(("move_int_const %d, %d (0x%x)\n", w, val, val));
}

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

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

	/* Assemble constants with a move and four shifted adds */
	op_mov_c(w, 0, 0);
	op_add_c(w, w, 0, 24);
	op_add_c(w, w, 0, 16);
	op_add_c(w, w, 0, 8);

	debug(("move_label_const %d, ?\n", w));
}

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

	op_mov(w, r);

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

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

	op_fmov(w, r);

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

define_insn(move_float_const, fmove_RxC)
{
	float o = const_float(2);
	int w = wreg_float(0);

	int r = 0;

	if ( o == 0.0 ) {
	    r = 0x8 | 0;
	} else if (o == 1.0) {
	    r = 0x8 | 1;
	} else if (o == 2.0) {
	    r = 0x8 | 2;
	} else if (o == 3.0) {
	    r = 0x8 | 3;
	} else if (o == 4.0) {
	    r = 0x8 | 4;
	} else if (o == 5.0) {
	    r = 0x8 | 5;
	} else if (o == 0.5) {
	    r = 0x8 | 6;
	} else if (o == 10.0) {
	    r = 0x8 | 7;
	} else {
	    fprintf(stderr,"[%s:%d] Can't represent the floating value %f as a manifest constant\n",
		    __FILE__, __LINE__, o);
	    abort();
	}

	op_fmov_const(w, r);

	debug(("move_float_const %d, %f(0x%x)\n", w, o,r ));
}

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

	op_fmovl(w, r);

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

define_insn(move_double_const, fmovel_RxC)
{
	double o = const_double(2);
	int w = wreg_double(0);

	int r = 0;

	if ( o == 0.0 ) {
	    r = 0x8 | 0;
	} else if (o == 1.0) {
	    r = 0x8 | 1;
	} else if (o == 2.0) {
	    r = 0x8 | 2;
	} else if (o == 3.0) {
	    r = 0x8 | 3;
	} else if (o == 4.0) {
	    r = 0x8 | 4;
	} else if (o == 5.0) {
	    r = 0x8 | 5;
	} else if (o == 0.5) {
	    r = 0x8 | 6;
	} else if (o == 10.0) {
	    r = 0x8 | 7;
	} else {
	    fprintf(stderr,"[%s:%d] Can't represent the floating value %f as a manifest constant\n",
		    __FILE__, __LINE__, o);
	    abort();
	}

	op_fmovl_const(w, r);

	debug(("move_double_const %d, %f(0x%x)\n", w, o,r ));
}


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

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

	op_add(w, r1, r2);

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

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

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

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

	op_adc(w, r1, r2);

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

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

	op_fadd(w, r1, r2);

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

	op_faddl(w, r1, r2);

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

	op_sub(w, r1, r2);

	debug(("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 ) {
		op_add_const(w, r1, -o);
		debug(("add_int_const %d, %d, %d\n", w, r1, -o));
	} else {
		op_sub_const(w, r1, o);
		debug(("add_int_const %d, %d, %d\n", w, r1, o));
	}

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

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

	op_sbc(w, r1, r2);

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

	op_fsub(w, r1, r2);

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

	op_fsubl(w, r1, r2);

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

	op_mul(w, r1, r2);

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

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

	op_fmul(w, r1, r2);

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

	op_fmull(w, r1, r2);

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

	op_fdiv(w, r1, r2);

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

	op_fdivl(w, r1, r2);

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

	op_and(w, r1, r2);

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

	op_and_const(w, r1, o);

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

	op_or(w, r1, r2);

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

	op_eor(w, r1, r2);

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

	op_ashr(w, r1, r2);

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

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

	op_lshr(w, r1, r2);

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

define_insn(lshl_int, lshl_RRR)