jvm.java

Java Op Processor java vhdl processor

	private static void f_d2i() { JVMHelp.noim();}
	private static void f_d2l() { JVMHelp.noim();}
	private static void f_d2f() { JVMHelp.noim();}

// i2x should be done in jvm.asm!!!
// just to lazy and stay compatible with OEBB project

	private static int f_i2b(int a) {

		a &= 0xff;
		if ((a & 0x80)!=0) {
			a |= 0xffffff00;
		}
		return a;
	}
	private static void f_i2c() { JVMHelp.noim(); /* jvm.asm */ }

	private static int f_i2s(int a) {

		a &= 0xffff;
		if ((a&0x8000) != 0) {
			a |= 0xffff0000;
		}
		return a;
	}
	private static int f_lcmp(long a, long b) {

		// is this really necessary?
		// Change by Peter & Christof
		int ah = (int)(a>>>32);
		int bh = (int)(b>>>32);
		//overflow, underflow, if a and b have different signs
		if(((ah & 0x80000000)==0)&&((bh & 0x80000000)!=0)) return 1;
		if(((ah & 0x80000000)!=0)&&((bh & 0x80000000)==0)) return -1;
		// I didn't have it in my first implementation
		
		a -= b;
		int al = (int) a;
		ah = (int) (a>>>32);

		if ((ah | al)==0) return 0;
		if ((ah & 0x80000000)==0) {
			return 1;
		} else {
			return -1;
		}
	}
	private static void f_fcmpl() { JVMHelp.noim();}
	private static void f_fcmpg() { JVMHelp.noim();}
	private static void f_dcmpl() { JVMHelp.noim();}
	private static void f_dcmpg() { JVMHelp.noim();}
	private static void f_ifeq() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_ifne() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_iflt() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_ifge() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_ifgt() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_ifle() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_if_icmpeq() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_if_icmpne() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_if_icmplt() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_if_icmpge() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_if_icmpgt() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_if_icmple() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_if_acmpeq() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_if_acmpne() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_goto() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_jsr() { JVMHelp.noim();}
	private static void f_ret() { JVMHelp.noim();}

	private static void f_tableswitch(int idx) { 

		int i;
		int sp = Native.getSP();			// sp of ();
		int pc = Native.rdIntMem(sp-3)-1;	// one to high
		i = Native.rdIntMem(sp);			// mp
		int start = Native.rdMem(i)>>>10;	// address of method

		// memory is addressed in 32 bit words!
		i = (pc>>>2)+1+start;	// points to default word

		int low = Native.rdMem(i+1);

		// if (idx<low || idx>high) {
		if (idx<low || idx>Native.rdMem(i+2)) {
			pc += Native.rdMem(i);		// default case
		} else {
			pc += Native.rdMem(i+3+idx-low);
		}
		Native.wrIntMem(pc, sp-3);
	}

	private static void f_lookupswitch(int key) {

		int i, j;
		int sp = Native.getSP();			// sp of ();
		int pc = Native.rdIntMem(sp-3)-1;	// one to high
		i = Native.rdIntMem(sp);			// mp
		int start = Native.rdMem(i)>>>10;	// address of method

		// memory is addressed in 32 bit words!
		i = (pc>>>2)+1+start;	// points to default word

		int off = Native.rdMem(i);	// default offset
		int cnt = Native.rdMem(i+1);

		i += 2;						// point to pairs
		for (j=0; j<cnt; ++j) {
			if (Native.rdMem(i+(j<<1)) == key) {
				off = Native.rdMem(i+(j<<1)+1);		// found match
				break;
			}
		}

		Native.wrIntMem(pc+off, sp-3);
	}

	private static void f_ireturn() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_lreturn() { JVMHelp.noim();}
	private static void f_freturn() { JVMHelp.noim();}
	private static void f_dreturn() { JVMHelp.noim();}
	private static void f_areturn() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_return() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_getstatic() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_putstatic() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_getfield() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_putfield() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_invokevirtual() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_invokespecial() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_invokestatic() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_invokeinterface() { JVMHelp.noim();}
	private static void f_unused_ba() { JVMHelp.noim();}

// TODO: synchronized on functions that change JVM state (e.g. heap pointer)
static Object o;

	private static int f_new(int cons) {

/* original non handle version
		int h, val, ret;

		// cons is a pointer to the class struct

synchronized (o) {
		h = Native.rdIntMem(2);				// get heap pointer
		Native.wrMem(cons+3, h);			// pointer to method table in objectref-1
		++h;								// one increment for ptr to mt
		ret = h;							// return pointer to object
		val = Native.rdMem(cons);			// instance size
		val += h;
		Native.wrIntMem(val, 2);			// write heap pointer
		for (; h<val; ++h) {
			Native.wrMem(0, h);				// zero object
		}
}
		return ret;
*/

/* Handle version:
*/
		int h, val, ret;

		// cons is pointer to class struct

		synchronized (o) {

			ret = GC.newObject(cons);
/*
			h = Native.rdIntMem(2);				// get heap pointer
			val = Native.rdMem(cons);			// instance size
			Native.wrIntMem(h+2+val, 2);		// write heap pointer
			// GC change:
			ret = h;
			Native.wrMem(h+2, h); 				// write handle
			++h;
			// end GC change
			Native.wrMem(cons+3, h);			// pointer to method table in objectref-1
			++h;								// one increment for ptr to mt
			// GC change:
			// ret = h;							// return pointer to object
			val += h;
			for (; h<val; ++h) {
				Native.wrMem(0, h);				// zero object
			}
*/
		}
		return ret;

	}

	static int f_newarray(int count, int type) {

/* original non handle version
		int h, ret;

		//	ignore cons (type info)

synchronized (o) {
		h = Native.rdIntMem(2);				// get heap pointer
		Native.wrMem(count, h);				// count as first element
		++h;								// one increment for count
		ret = h;							// return pointer to first element
		count += h;
		Native.wrIntMem(count, 2);			// write heap pointer
		for (; h<count; ++h) {
			Native.wrMem(0, h);				// zero array
		}
}
		return ret;
*/

/* Handle version
*/
				
		int h, ret;

		synchronized (o) {
			
			ret = GC.newArray(count, type, false);

/*
			h = Native.rdIntMem(2);				// get heap pointer
			Native.wrIntMem(h+2+count, 2);		// write heap pointer
			// GC change:
			ret = h;
			Native.wrMem(h+2, h); // write handle
	
			++h;
			// end GC change
			Native.wrMem(count, h);				// count as first element
			++h;								// one increment for count
	//		ret = h;							// return pointer to first element
			count += h;
			for (; h<count; ++h) {
				Native.wrMem(0, h);				// zero array
			}
*/
		}
		return ret;

	}

	private static int f_anewarray(int count, int cons) {

		// ignore cons (type info)
		// should be different for the GC!!!
		int h, ret;

		synchronized (o) {
			
			ret = GC.newArray(count, 0, true); //0..type not available=reference
		}
		return ret;
	}



	private static void f_arraylength() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_athrow() { JVMHelp.noim();}
	// private static void f_checkcast() { JVMHelp.noim();}
	private static int f_checkcast(int objref, int cons) {
// TODO: implement it
//JVMHelp.wr("checkcast");
// ECM needs it...
//JVMHelp.noim();
		return objref;
	}
	private static void f_instanceof() { JVMHelp.noim();}


	private static int enterCnt;

	private static void f_monitorenter(int objAddr) {

/* is now in jvm.asm
*/
		// is there a race condition???????????????? when timer int happens NOW!
		Native.wr(0, Const.IO_INT_ENA);
		++enterCnt;
		// JVMHelp.wr('M');
	}

	private static void f_monitorexit(int objAddr) {

/* is now in jvm.asm
*/
		// JVMHelp.wr('E');
		--enterCnt;
if (enterCnt<0) {
	JVMHelp.wr('^');
	for (;;);
}
		if (enterCnt==0) {
			Native.wr(1, Const.IO_INT_ENA);
		}
	}


	private static void f_wide() { JVMHelp.noim();}
	
	private static int f_multianewarray() {

		//
		// be careful! We have to manipulate the stack frame.
		// If the layout changes we have to change this method.
		//
		int ret = 0;
		int i, j;
		
		int sp = Native.getSP();			// sp after call of f_multi();
		int fp = sp-4;		// first frame point is easy, since last sp points to the end of the frame

		// pc points to the next byte - the first index byte
		int pc = Native.rdIntMem(fp+1);
		pc += 2;	// now to dimensions
		int mp = Native.rdIntMem(fp+4);
		int start = Native.rdMem(mp)>>>10;	// address of method

		// memory is addressed in 32 bit words!
		
		int dim = Native.rdMem(start+(pc>>2));
		for (i=(pc&0x03); i<3; ++i) dim >>= 8;
		dim &= 0xff;
		
		// correct pc to point to the next instruction
		Native.wrIntMem(pc+1, fp+1);

		// int vp = Native.rdIntMem(fp+2);
		// sp is now the previous sp
		sp = Native.rdIntMem(fp);
		sp -= dim;		// correct the sp
		Native.wrIntMem(sp, fp);
		if (dim!=2) {
//			System.out.print("multanewarray: ");
			System.out.print(dim);
			System.out.println("dimensions not supported");
			JVMHelp.noim();
		}
/*
		System.out.print("multianewarray: ");
		System.out.println(dim);
		for (i=1; i<=dim; ++i) {
			System.out.println(Native.rdIntMem(sp+i));
		}
*/
		// first dimension
		int cnt = Native.rdIntMem(sp+1);
		int cnt2 = Native.rdIntMem(sp+2);
		// we ignore type on anewarray
		ret = f_anewarray(cnt, 0);
		// handle
		int ref = Native.rdMem(ret);
		for (i=0; i<cnt; ++i) {
			Native.wrMem(f_newarray(cnt2,10), ref+i);
		}
		
		return ret;
	}

	private static void f_ifnull() { JVMHelp.noim();}
	private static void f_ifnonnull() { JVMHelp.noim();}
	private static void f_goto_w() { JVMHelp.noim();}
	private static void f_jsr_w() { JVMHelp.noim();}
	private static void f_breakpoint() { JVMHelp.noim();}
	private static void f_resCB() { JVMHelp.noim();}
	private static void f_resCC() { JVMHelp.noim();}
	private static void f_resCD() { JVMHelp.noim();}
	private static void f_resCE() { JVMHelp.noim();}
	private static void f_resCF() { JVMHelp.noim();}
	private static void f_jopsys_null() { JVMHelp.noim();}
	private static void f_jopsys_rd() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_jopsys_wr() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_jopsys_rdmem() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_jopsys_wrmem() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_jopsys_rdint() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_jopsys_wrint() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_jopsys_getsp() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_jopsys_setsp() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_jopsys_getvp() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_jopsys_setvp() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_resDB() { JVMHelp.noim();}
	private static void f_resDC() { JVMHelp.noim();}
	private static void f_resDD() { JVMHelp.noim();}
	private static void f_resDE() { JVMHelp.noim();}
	private static void f_resDF() { JVMHelp.noim();}
	private static void f_resE0() { JVMHelp.noim();}
	private static void f_resE1() { JVMHelp.noim();}
	private static void f_resE2() { JVMHelp.noim();}
	private static void f_resE3() { JVMHelp.noim();}
	private static void f_resE4() { JVMHelp.noim();}
	private static void f_resE5() { JVMHelp.noim();}
	private static void f_resE6() { JVMHelp.noim();}
	private static void f_resE7() { JVMHelp.noim();}
	private static void f_resE8() { JVMHelp.noim();}
	private static void f_resE9() { JVMHelp.noim();}
	private static void f_resEA() { JVMHelp.noim();}
	private static void f_resEB() { JVMHelp.noim();}
	private static void f_resEC() { JVMHelp.noim();}
	private static void f_resED() { JVMHelp.noim();}
	private static void f_resEE() { JVMHelp.noim();}
	private static void f_resEF() { JVMHelp.noim();}
	private static void f_resF0() { JVMHelp.noim();}
	private static void f_resF1() { JVMHelp.noim();}
	private static void f_resF2() { JVMHelp.noim();}
	private static void f_resF3() { JVMHelp.noim();}
	private static void f_resF4() { JVMHelp.noim();}
	private static void f_resF5() { JVMHelp.noim();}
	private static void f_resF6() { JVMHelp.noim();}
	private static void f_resF7() { JVMHelp.noim();}
	private static void f_resF8() { JVMHelp.noim();}
	private static void f_resF9() { JVMHelp.noim();}
	private static void f_resFA() { JVMHelp.noim();}
	private static void f_resFB() { JVMHelp.noim();}
	private static void f_resFC() { JVMHelp.noim();}
	private static void f_resFD() { JVMHelp.noim();}
	private static void f_sys_noim() { JVMHelp.noim(); /* jvm.asm */ }
	private static void f_sys_init() { JVMHelp.noim(); /* jvm.asm */ }
}