icode.c

linux下建立JAVA虚拟机的源码KAFFE

	}
	else
#if defined(HAVE_load_offset_scaled_ref)
	slot_slot_slot_const_const(dst, src, idx, offset, 0, HAVE_load_offset_scaled_ref, Tload);
#else
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		lshl_int_const(tmp, idx, SHIFT_jref);
		add_ref(tmp, src, tmp);
		load_offset_ref(dst, tmp, offset);
		slot_freetmp(tmp);
	}
#endif
}

void
load_offset_scaled_long(SlotInfo* dst, SlotInfo* src, SlotInfo* idx, int offset)
{
	if (slot_type(idx) == Tconst) {
		load_offset_long(dst, src, (jint)(slot_value(idx)->i * sizeof(jlong) + offset));
	}
	else
#if defined(HAVE_load_offset_scaled_long)
	slot_slot_slot_const_const(dst, src, idx, offset, 0, HAVE_load_offset_scaled_long, Tload);
#else
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		lshl_int_const(tmp, idx, SHIFT_jlong);
		add_ref(tmp, src, tmp);
		load_offset_long(dst, tmp, offset);
		slot_freetmp(tmp);
	}
#endif
}

void
load_offset_scaled_float(SlotInfo* dst, SlotInfo* src, SlotInfo* idx, int offset)
{
	if (slot_type(idx) == Tconst) {
		load_offset_float(dst, src, (jint)(slot_value(idx)->i * sizeof(jfloat) + offset));
	}
	else
#if defined(HAVE_load_offset_scaled_float)
	slot_slot_slot_const_const(dst, src, idx, offset, 0, HAVE_load_offset_scaled_float, Tload);
#else
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		lshl_int_const(tmp, idx, SHIFT_jfloat);
		add_ref(tmp, src, tmp);
		load_offset_float(dst, tmp, offset);
		slot_freetmp(tmp);
	}
#endif
}

void
load_offset_scaled_double(SlotInfo* dst, SlotInfo* src, SlotInfo* idx, int offset)
{
	if (slot_type(idx) == Tconst) {
		load_offset_double(dst, src, (jint)(slot_value(idx)->i * sizeof(jdouble) + offset));
	}
	else
#if defined(HAVE_load_offset_scaled_double)
	lslot_slot_slot_const_const(dst, src, idx, offset, 0, HAVE_load_offset_scaled_double, Tload);
#else
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		lshl_int_const(tmp, idx, SHIFT_jdouble);
		add_ref(tmp, src, tmp);
		load_offset_double(dst, tmp, offset);
		slot_freetmp(tmp);
	}
#endif
}

void
load_offset_scaled_byte(SlotInfo* dst, SlotInfo* src, SlotInfo* idx, int offset)
{
	if (slot_type(idx) == Tconst) {
		load_offset_byte(dst, src, (jint)(slot_value(idx)->i * sizeof(jbyte) + offset));
	}
	else
#if defined(HAVE_load_offset_scaled_byte)
	slot_slot_slot_const_const(dst, src, idx, offset, 0, HAVE_load_offset_scaled_byte, Tload);
#else
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		add_ref(tmp, src, idx);
		load_offset_byte(dst, tmp, offset);
		slot_freetmp(tmp);
	}
#endif
}

void
load_offset_scaled_char(SlotInfo* dst, SlotInfo* src, SlotInfo* idx, int offset)
{
	if (slot_type(idx) == Tconst) {
		load_offset_char(dst, src, (jint)(slot_value(idx)->i * sizeof(jchar) + offset));
	}
	else
#if defined(HAVE_load_offset_scaled_char)
	slot_slot_slot_const_const(dst, src, idx, offset, 0, HAVE_load_offset_scaled_char, Tload);
#else
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		lshl_int_const(tmp, idx, SHIFT_jchar);
		add_ref(tmp, src, tmp);
		load_offset_char(dst, tmp, offset);
		slot_freetmp(tmp);
	}
#endif
}

void
load_offset_scaled_short(SlotInfo* dst, SlotInfo* src, SlotInfo* idx, int offset)
{
	if (slot_type(idx) == Tconst) {
		load_offset_short(dst, src, (jint)(slot_value(idx)->i * sizeof(jshort) + offset));
	}
	else
#if defined(HAVE_load_offset_scaled_short)
	slot_slot_slot_const_const(dst, src, idx, offset, 0, HAVE_load_offset_scaled_short, Tload);
#else
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		lshl_int_const(tmp, idx, SHIFT_jshort);
		add_ref(tmp, src, tmp);
		load_offset_short(dst, tmp, offset);
		slot_freetmp(tmp);
	}
#endif
}

void
load_code_ref(SlotInfo* dst, SlotInfo* src)
{
#if defined(HAVE_load_code_ref)
	slot_slot_slot(dst, 0, src, HAVE_load_code_ref, Tload);
#else
	load_ref(dst, src);
#endif
}

void
load_key(SlotInfo* dst, SlotInfo* src)
{
	load_int(dst, src);
}

#if defined(HAVE_store_int)
void
store_int(SlotInfo* dst, SlotInfo* src)
{
	slot_slot_slot(NULL, dst, src, HAVE_store_int, Tstore);
}
#endif

void
store_offset_int(SlotInfo* dst, jint offset, SlotInfo* src)
{
	if (offset == 0) {
		store_int(dst, src);
	}
	else
#if defined(HAVE_store_const_offset_int)
	if (slot_type(src) == Tconst) {
		store_const_offset_int(dst, offset, slot_value(src)->i);
	}
	else
#endif
#if defined(HAVE_store_offset_int)
	if (HAVE_store_offset_int_rangecheck(offset)) {
		slot_slot_const(src, dst, offset, HAVE_store_offset_int, Tstore);
	}
	else
#endif
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		add_ref_const(tmp, dst, offset);
		store_int(tmp, src);
		slot_freetmp(tmp);
	}
}

void
store_addr_int(void* addr, SlotInfo* src)
{
#if defined(HAVE_store_addr_int)
	slot_slot_const(NULL, src, (uintp)addr, HAVE_store_addr_int, Tstore);
#else
	SlotInfo* tmp;
	slot_alloctmp(tmp);
	move_ref_const(tmp, addr);
	store_int(tmp, src);
	slot_freetmp(tmp);
#endif
}

#if defined(HAVE_store_ref)
void
store_ref(SlotInfo* dst, SlotInfo* src)
{
	slot_slot_slot(NULL, dst, src, HAVE_store_ref, Tstore);
}
#endif

void
store_offset_ref(SlotInfo* dst, jint offset, SlotInfo* src)
{
	if (offset == 0) {
		store_ref(dst, src);
	}
	else
#if defined(HAVE_store_offset_ref)
	if (HAVE_store_offset_ref_rangecheck(offset)) {
		slot_slot_const(src, dst, offset, HAVE_store_offset_ref, Tstore);
	}
	else
#endif
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		add_ref_const(tmp, dst, offset);
		store_ref(tmp, src);
		slot_freetmp(tmp);
	}
}

void
store_addr_ref(void* addr, SlotInfo* src)
{
#if defined(HAVE_store_addr_ref)
	slot_slot_const(NULL, src, (uintp)addr, HAVE_store_addr_ref, Tstore);
#else
	SlotInfo* tmp;
	slot_alloctmp(tmp);
	move_ref_const(tmp, addr);
	store_ref(tmp, src);
	slot_freetmp(tmp);
#endif
}

void
store_long(SlotInfo* dst, SlotInfo* src)
{
#if defined(HAVE_store_long)
	lslot_slot_lslot(0, dst, src, HAVE_store_long, Tstore);
#else
	SlotInfo* tmp;

	slot_alloctmp(tmp);
	add_ref_const(tmp, dst, 4);
	/* Don't use LSLOT & HSLOT here */
	store_int(dst, src);
	store_int(tmp, src+1);
	slot_freetmp(tmp);
#endif
}

void
store_offset_long(SlotInfo* dst, jint offset, SlotInfo* src)
{
	if (offset == 0) {
		store_long(dst, src);
	}
	else
#if defined(HAVE_store_offset_long)
	if (HAVE_store_offset_long_rangecheck(offset)) {
		lslot_slot_const(src, dst, offset, HAVE_store_offset_long, Tstore);
	}
	else
#endif
	{
                /* Don't use LSLOT & HSLOT here */
		store_offset_int(dst, offset, src);
		store_offset_int(dst, offset+4, src+1);
	}
}

void
store_addr_long(void* addr, SlotInfo* src)
{
#if defined(HAVE_store_addr_long)
	slot_slot_const(0, src, (uintp)addr, HAVE_store_addr_long, Tstore);
#else
	SlotInfo* tmp;
	slot_alloctmp(tmp);
	move_ref_const(tmp, addr);
	store_long(tmp, src);
	slot_freetmp(tmp);
#endif
}

void
store_float(SlotInfo* dst, SlotInfo* src)
{
#if defined(HAVE_store_float)
	slot_slot_slot(NULL, dst, src, HAVE_store_float, Tstore);
#elif defined(HAVE_NO_FLOATING_POINT)
	store_int(dst, src);
#else
	KAFFEVM_ABORT();
#endif
}

void
store_offset_float(SlotInfo* dst, jint offset, SlotInfo* src)
{
	if (offset == 0) {
		store_float(dst, src);
	}
	else
#if defined(HAVE_store_offset_float)
	if (HAVE_store_offset_float_rangecheck(offset)) {
		slot_slot_const(src, dst, offset, HAVE_store_offset_float, Tstore);
	}
	else
#endif
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		add_ref_const(tmp, dst, offset);
		store_float(tmp, src);
		slot_freetmp(tmp);
	}
}

void
store_addr_float(void* addr, SlotInfo* src)
{
#if defined(HAVE_store_addr_float)
	slot_slot_const(0, src, (uintp)addr, HAVE_store_addr_float, Tstore);
#else
	SlotInfo* tmp;
	slot_alloctmp(tmp);
	move_ref_const(tmp, addr);
	store_float(tmp, src);
	slot_freetmp(tmp);
#endif
}

void
store_double(SlotInfo* dst, SlotInfo* src)
{
#if defined(HAVE_store_double)
	slot_slot_lslot(NULL, dst, src, HAVE_store_double, Tstore);
#elif defined(HAVE_NO_FLOATING_POINT) || defined(PS2LINUX)
	store_long(dst, src);
#else
	KAFFEVM_ABORT();
#endif
}

void
store_offset_double(SlotInfo* dst, jint offset, SlotInfo* src)
{
	if (offset == 0) {
		store_double(dst, src);
	}
	else
#if defined(HAVE_store_offset_double)
	if (HAVE_store_offset_double_rangecheck(offset)) {
		lslot_slot_const(src, dst, offset, HAVE_store_offset_double, Tstore);
	}
	else
#endif
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		add_ref_const(tmp, dst, offset);
		store_double(tmp, src);
		slot_freetmp(tmp);
	}
}

void
store_addr_double(void* addr, SlotInfo* src)
{
#if defined(HAVE_store_addr_double)
	lslot_lslot_const(0, src, (uintp)addr, HAVE_store_addr_double, Tstore);
#else
	SlotInfo* tmp;
	slot_alloctmp(tmp);
	move_ref_const(tmp, addr);
	store_double(tmp, src);
	slot_freetmp(tmp);
#endif
}

void
store_byte(SlotInfo* dst, SlotInfo* src)
{
#if defined(HAVE_store_byte)
	slot_slot_slot(NULL, dst, src, HAVE_store_byte, Tstore);
#else
	/* FIXME -- this is unlikely to work as-is as it doesn't
	   allow for alignment requirements on the integer load.  */
	SlotInfo* tmp;
	SlotInfo* tmp2;
	slot_alloctmp(tmp);
	slot_alloctmp(tmp2);
	and_int_const(tmp, src, (1 << (8 * sizeof(jbyte))) - 1);
	load_int(tmp2, dst);
	and_int_const(tmp2, tmp2, -(1 << (8 * sizeof(jbyte))));
	or_int(tmp2, tmp2, tmp);
	store_int(dst, tmp2);
	slot_freetmp(tmp);
	slot_freetmp(tmp2);
#endif
}

void
store_offset_byte(SlotInfo* dst, jint offset, SlotInfo* src)
{
	if (offset == 0) {
		store_byte(dst, src);
	}
	else
#if defined(HAVE_store_const_offset_byte)
	if (slot_type(src) == Tconst) {
		store_const_offset_byte(dst, offset, slot_value(src)->i);
	}
	else
#endif
#if defined(HAVE_store_offset_byte)
	if (HAVE_store_offset_byte_rangecheck(offset)) {
		slot_slot_const(src, dst, offset, HAVE_store_offset_byte, Tstore);
	}
	else
#endif
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		add_ref_const(tmp, dst, offset);
		store_byte(tmp, src);
		slot_freetmp(tmp);
	}
}

void
store_addr_byte(void* addr, SlotInfo* src)
{
#if defined(HAVE_store_addr_byte)
	slot_slot_const(0, src, (uintp)addr, HAVE_store_addr_byte, Tstore);
#else
	SlotInfo* tmp;
	slot_alloctmp(tmp);
	move_ref_const(tmp, addr);
	store_byte(tmp, src);
	slot_freetmp(tmp);
#endif
}

void
store_char(SlotInfo* dst, SlotInfo* src)
{
#if defined(HAVE_store_char)
	slot_slot_slot(NULL, dst, src, HAVE_store_char, Tstore);
#else
	/* FIXME -- this is unlikely to work as-is as it doesn't
	   allow for alignment requirements on the integer load.  */
	SlotInfo* tmp;
	SlotInfo* tmp2;
	slot_alloctmp(tmp);
	slot_alloctmp(tmp2);
	and_int_const(tmp, src, (1 << (8 * sizeof(jchar))) - 1);
	load_int(tmp2, dst);
	and_int_const(tmp2, tmp2, -(1 << (8 * sizeof(jchar))));
	or_int(tmp2, tmp2, tmp);
	store_int(dst, tmp2);
	slot_freetmp(tmp);
	slot_freetmp(tmp2);
#endif
}

void
store_offset_char(SlotInfo* dst, jint offset, SlotInfo* src)
{
	if (offset == 0) {
		store_char(dst, src);
	}
	else
#if defined(HAVE_store_offset_char)
	if (HAVE_store_offset_char_rangecheck(offset)) {
		slot_slot_const(src, dst, offset, HAVE_store_offset_char, Tstore);
	}
	else
#endif
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		add_ref_const(tmp, dst, offset);
		store_char(tmp, src);
		slot_freetmp(tmp);
	}
}

void
store_addr_char(void* addr, SlotInfo* src)
{
#if defined(HAVE_store_addr_char)
	slot_slot_const(0, src, (uintp)addr, HAVE_store_addr_char, Tstore);
#else
	SlotInfo* tmp;
	slot_alloctmp(tmp);
	move_ref_const(tmp, addr);
	store_char(tmp, src);
	slot_freetmp(tmp);
#endif
}

void
store_short(SlotInfo* dst, SlotInfo* src)
{
#if defined(HAVE_store_short)
	slot_slot_slot(NULL, dst, src, HAVE_store_short, Tstore);
#else
	/* FIXME -- this is unlikely to work as-is as it doesn't
	   allow for alignment requirements on the integer load.  */
	SlotInfo* tmp;
	SlotInfo* tmp2;
	slot_alloctmp(tmp);
	slot_alloctmp(tmp2);
	and_int_const(tmp, src, (1 << (8 * sizeof(jshort))) - 1);
	load_int(tmp2, dst);
	and_int_const(tmp2, tmp2, -(1 << (8 * sizeof(jshort))));
	or_int(tmp2, tmp2, tmp);
	store_int(dst, tmp2);
	slot_freetmp(tmp);
	slot_freetmp(tmp2);
#endif
}

void
store_offset_short(SlotInfo* dst, jint offset, SlotInfo* src)
{
	if (offset == 0) {
		store_short(dst, src);
	}
	else
#if defined(HAVE_store_offset_short)
	if (HAVE_store_offset_short_rangecheck(offset)) {
		slot_slot_const(src, dst, offset, HAVE_store_offset_short, Tstore);
	}
	else
#endif
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		add_ref_const(tmp, dst, offset);
		store_short(tmp, src);
		slot_freetmp(tmp);
	}
}

void
store_addr_short(void* addr, SlotInfo* src)
{
#if defined(HAVE_store_addr_short)
	slot_slot_const(0, src, (uintp)addr, HAVE_store_addr_short, Tstore);
#else
	SlotInfo* tmp;
	slot_alloctmp(tmp);
	move_ref_const(tmp, addr);
	store_short(tmp, src);
	slot_freetmp(tmp);
#endif
}

void
store_offset_scaled_int(SlotInfo* dst, SlotInfo* idx, int offset, SlotInfo* src)
{
	if (slot_type(idx) == Tconst) {
		store_offset_int(dst, (jint)(slot_value(idx)->i * sizeof(jint) + offset), src);
	}
	else
#if defined(HAVE_store_offset_scaled_int)
	slot_slot_slot_const_const(dst, idx, src, offset, 0, HAVE_store_offset_scaled_int, Tstore);
#else
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		lshl_int_const(tmp, idx, SHIFT_jint);
		add_ref(tmp, dst, tmp);
		store_offset_int(tmp, offset, src);
		slot_freetmp(tmp);
	}
#endif
}

void
store_offset_scaled_ref(SlotInfo* dst, SlotInfo* idx, int offset, SlotInfo* src)
{
	if (slot_type(idx) == Tconst) {
		store_offset_ref(dst, (jint)(slot_value(idx)->i * sizeof(jref) + offset), src);
	}
	else
#if defined(HAVE_store_offset_scaled_ref)
	slot_slot_slot_const_const(dst, idx, src, offset, 0, HAVE_store_offset_scaled_ref, Tstore);
#else
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		lshl_int_const(tmp, idx, SHIFT_jref);
		add_ref(tmp, dst, tmp);
		store_offset_ref(tmp, offset, src);
		slot_freetmp(tmp);
	}
#endif
}

void
store_offset_scaled_long(SlotInfo* dst, SlotInfo* idx, int offset, SlotInfo* src)
{
	if (slot_type(idx) == Tconst) {
		store_offset_long(dst, (jint)(slot_value(idx)->i * sizeof(jlong) + offset), src);
	}
	else
#if defined(HAVE_store_offset_scaled_long)
	slot_slot_slot_const_const(dst, idx, src, offset, 0, HAVE_store_offset_scaled_long, Tstore);
#else
	{
		SlotInfo* tmp;
		slot_alloctmp(tmp);
		lshl_int_const(tmp, idx, SHIFT_jlong);
		add_ref(tmp, dst, tmp);
		store_offset_long(tmp, offset, src);
		slot_freetmp(tmp);
	}
#endif
}

void
store_offset_scaled_float(SlotInfo* dst, SlotInfo* idx, int offset, SlotInfo* src)
{
	if (slot_type(idx) == Tconst) {
		store_offset_float(dst, (jint)(slot_value(idx)->i * sizeof(jfloat) + offset), src);
	}
	else
#if defined(HAV