[vmkit-commits] [vmkit] r61487 - in /vmkit/trunk: include/mvm/Threads/ lib/JnJVM/Classpath/ lib/JnJVM/VMCore/ lib/Mvm/Runtime/
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Tue Dec 30 01:32:06 PST 2008
Author: geoffray
Date: Tue Dec 30 03:31:45 2008
New Revision: 61487
URL: http://llvm.org/viewvc/llvm-project?rev=61487&view=rev
Log:
Major rewrite on how a the JVM walks the stack. When entering Java code or
enterring native code, the JVM pushes the return address in a thread-specific
stack. Therefore, we know if a frame belongs to a native function or a Java
function.
When the method pointer of a Java method is known, the JVM registers the
pointer in a map so that we know for a given instruction pointer which
method it beongs to.
Modified:
vmkit/trunk/include/mvm/Threads/Thread.h
vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h
vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h
vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp
vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp
vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h
vmkit/trunk/lib/Mvm/Runtime/JIT.cpp
Modified: vmkit/trunk/include/mvm/Threads/Thread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/Threads/Thread.h (original)
+++ vmkit/trunk/include/mvm/Threads/Thread.h Tue Dec 30 03:31:45 2008
@@ -51,6 +51,12 @@
};
+#if defined(__MACH__) && !defined(__i386__)
+#define FRAME_IP(fp) (fp[2])
+#else
+#define FRAME_IP(fp) (fp[1])
+#endif
+
/// Thread - This class is the base of custom virtual machines' Thread classes.
/// It provides static functions to manage threads. An instance of this class
/// contains all thread-specific informations.
Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp Tue Dec 30 03:31:45 2008
@@ -29,16 +29,22 @@
#endif
jclass Cl) {
+ bool res = false;
+ BEGIN_NATIVE_EXCEPTION(0)
+
verifyNull(Cl);
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, true);
- if (!cl->asClass()) return false;
- if (cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
+
+ if (cl->isClass() &&
+ cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
vm->bootstrapLoader->clinitType,
true, false, 0))
- return true;
-
- return false;
+ res = true;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
@@ -51,11 +57,16 @@
jclass clazz,
#endif
jobject Field, jobject obj, jboolean val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
verifyNull(obj);
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
field->setInt8Field((JavaObject*)obj, (uint8)val);
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
@@ -64,11 +75,16 @@
jclass clazz,
#endif
jobject Field, jobject obj, jbyte val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
verifyNull(obj);
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
field->setInt8Field((JavaObject*)obj, (uint8)val);
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
@@ -77,11 +93,16 @@
jclass clazz,
#endif
jobject Field, jobject obj, jchar val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
verifyNull(obj);
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
field->setInt16Field((JavaObject*)obj, (uint16)val);
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
@@ -90,11 +111,16 @@
jclass clazz,
#endif
jobject Field, jobject obj, jshort val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
verifyNull(obj);
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
field->setInt16Field((JavaObject*)obj, (sint16)val);
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
@@ -103,11 +129,16 @@
jclass clazz,
#endif
jobject Field, jobject obj, jint val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
verifyNull(obj);
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
field->setInt32Field((JavaObject*)obj, (sint32)val);
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
@@ -116,11 +147,16 @@
jclass clazz,
#endif
jobject Field, jobject obj, jlong val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
verifyNull(obj);
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
field->setLongField((JavaObject*)obj, (sint64)val);
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
@@ -129,11 +165,16 @@
jclass clazz,
#endif
jobject Field, jobject obj, jfloat val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
verifyNull(obj);
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
field->setFloatField((JavaObject*)obj, (float)val);
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
@@ -142,11 +183,16 @@
jclass clazz,
#endif
jobject Field, jobject obj, jdouble val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
verifyNull(obj);
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
field->setDoubleField((JavaObject*)obj, (double)val);
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
@@ -155,11 +201,16 @@
jclass clazz,
#endif
jobject Field, jobject obj, jobject val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
verifyNull(obj);
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
field->setObjectField((JavaObject*)obj, (JavaObject*)val);
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT jobject JNICALL Java_java_io_VMObjectInputStream_allocateObject(
@@ -168,13 +219,22 @@
jclass clazz,
#endif
jclass target, jclass constr, jobject cons) {
+
+ jobject res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, target, true);
- JavaObject* res = cl->doNew(vm);
+ JavaObject* obj = cl->doNew(vm);
JavaField* field = vm->upcalls->constructorSlot;
JavaMethod* meth = (JavaMethod*)(field->getInt32Field((JavaObject*)cons));
- meth->invokeIntSpecial(vm, cl, res);
- return (jobject)res;
+ meth->invokeIntSpecial(vm, cl, obj);
+ res = (jobject)obj;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jobject JNICALL Java_java_lang_reflect_VMArray_createObjectArray(
@@ -183,16 +243,26 @@
jclass thisClass,
#endif
jclass arrayType, jint arrayLength) {
+
+ jobject res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* base = NativeUtil::resolvedImplClass(vm, arrayType, true);
JnjvmClassLoader* loader = base->classLoader;
const UTF8* name = base->getName();
const UTF8* arrayName = loader->constructArrayName(1, name);
UserClassArray* array = loader->constructArray(arrayName, base);
- return (jobject)array->doNew(arrayLength, vm);
+ res = (jobject)array->doNew(arrayLength, vm);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
+// Never throws.
JNIEXPORT
bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
#ifdef NATIVE_JNI
@@ -203,6 +273,7 @@
return false;
}
+// Never throws.
JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
#ifdef NATIVE_JNI
JNIEnv *env,
@@ -225,6 +296,7 @@
}
+// Never throws.
JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
#ifdef NATIVE_JNI
JNIEnv *env,
@@ -238,6 +310,7 @@
return __sync_bool_compare_and_swap(ptr, expect, update);
}
+// Never throws.
JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
#ifdef NATIVE_JNI
JNIEnv *env,
@@ -252,6 +325,7 @@
return __sync_bool_compare_and_swap(ptr, expect, update);
}
+// Never throws.
JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
#ifdef NATIVE_JNI
JNIEnv *env,
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp Tue Dec 30 03:31:45 2008
@@ -45,6 +45,11 @@
JNIEnv *env,
#endif
jobject cons) {
+
+ jobject res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
verifyNull(cons);
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = vm->upcalls->constructorSlot;
@@ -52,7 +57,10 @@
UserClass* cl = internalGetClass(vm, meth, cons);
JnjvmClassLoader* loader = cl->classLoader;
- return (jobject)(NativeUtil::getParameterTypes(loader, meth));
+ res = (jobject)(NativeUtil::getParameterTypes(loader, meth));
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jint JNICALL Java_java_lang_reflect_Constructor_getModifiersInternal(
@@ -60,21 +68,31 @@
JNIEnv *env,
#endif
jobject cons) {
+
+ jint res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
verifyNull(cons);
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = vm->upcalls->constructorSlot;
JavaMethod* meth = (JavaMethod*)(field->getInt32Field((JavaObject*)cons));
- return meth->access;
+ res = meth->access;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jobject JNICALL Java_java_lang_reflect_Constructor_constructNative(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-jobject _cons,
-jobject _args,
-jclass Clazz,
-jint _meth) {
+jobject _cons, jobject _args, jclass Clazz, jint _meth) {
+
+ jobject res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
JavaMethod* meth = (JavaMethod*)_meth;
@@ -93,7 +111,8 @@
UserClass* cl = _cl->asClass();
if (cl) {
cl->initialiseClass(vm);
- JavaObject* res = cl->doNew(vm);
+ JavaObject* obj = cl->doNew(vm);
+ res = (jobject) obj;
JavaObject** ptr = (JavaObject**)(void*)(args->elements);
Typedef* const* arguments = sign->getArgumentsType();
@@ -104,7 +123,7 @@
JavaObject* excp = 0;
try {
- meth->invokeIntSpecialBuf(vm, cl, res, startBuf);
+ meth->invokeIntSpecialBuf(vm, cl, obj, startBuf);
}catch(...) {
excp = JavaThread::getJavaException();
JavaThread::clearException();
@@ -120,11 +139,16 @@
}
}
- return (jobject)res;
+ } else {
+ vm->illegalArgumentExceptionForMethod(meth, 0, 0);
}
+ } else {
+ vm->illegalArgumentExceptionForMethod(meth, 0, 0);
}
- vm->illegalArgumentExceptionForMethod(meth, 0, 0);
- return 0;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT
@@ -133,13 +157,22 @@
JNIEnv *env,
#endif
jobject cons) {
+
+ jobjectArray res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
verifyNull(cons);
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = vm->upcalls->constructorSlot;
JavaMethod* meth = (JavaMethod*)field->getInt32Field((JavaObject*)cons);
UserClass* cl = internalGetClass(vm, meth, cons);
- return (jobjectArray)NativeUtil::getExceptionTypes(cl, meth);
+ res = (jobjectArray)NativeUtil::getExceptionTypes(cl, meth);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp Tue Dec 30 03:31:45 2008
@@ -36,10 +36,18 @@
JNIEnv *env,
#endif
jobject obj) {
+ jint res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)obj);
- return field->access;
+ res = field->access;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jclass JNICALL Java_java_lang_reflect_Field_getType(
@@ -47,13 +55,22 @@
JNIEnv *env,
#endif
jobject obj) {
+
+ jclass res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)obj);
UserClass* fieldCl = internalGetClass(vm, field, obj);
JnjvmClassLoader* loader = fieldCl->classLoader;
UserCommonClass* cl = field->getSignature()->assocClass(loader);
- return (jclass)cl->getClassDelegatee(vm);
+ res = (jclass)cl->getClassDelegatee(vm);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getInt(
@@ -61,6 +78,11 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
+
+ jint res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -80,17 +102,22 @@
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isInt())
- return (sint32)field->getInt32Field(Obj);
- if (prim->isChar())
- return (uint32)field->getInt16Field(Obj);
- if (prim->isByte())
- return (sint32)field->getInt8Field(Obj);
- if (prim->isShort())
- return (sint32)field->getInt16Field(Obj);
+ res = (sint32)field->getInt32Field(Obj);
+ else if (prim->isChar())
+ res = (uint32)field->getInt16Field(Obj);
+ else if (prim->isByte())
+ res = (sint32)field->getInt8Field(Obj);
+ else if (prim->isShort())
+ res = (sint32)field->getInt16Field(Obj);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
- vm->illegalArgumentException("");
- return 0;
+ END_NATIVE_EXCEPTION
+
+ return res;
}
@@ -99,6 +126,11 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
+
+ jlong res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -118,19 +150,24 @@
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isInt())
- return (sint64)field->getInt32Field(Obj);
- if (prim->isChar())
- return (uint64)field->getInt16Field(Obj);
- if (prim->isByte())
- return (sint64)field->getInt8Field(Obj);
- if (prim->isShort())
- return (sint64)field->getInt16Field(Obj);
- if (prim->isLong())
- return (sint64)field->getLongField(Obj);
+ res = (sint64)field->getInt32Field(Obj);
+ else if (prim->isChar())
+ res = (uint64)field->getInt16Field(Obj);
+ else if (prim->isByte())
+ res = (sint64)field->getInt8Field(Obj);
+ else if (prim->isShort())
+ res = (sint64)field->getInt16Field(Obj);
+ else if (prim->isLong())
+ res = (sint64)field->getLongField(Obj);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
+
+ END_NATIVE_EXCEPTION
- vm->illegalArgumentException("");
- return 0;
+ return res;
}
JNIEXPORT jboolean JNICALL Java_java_lang_reflect_Field_getBoolean(
@@ -138,6 +175,11 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
+
+ jboolean res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -156,12 +198,16 @@
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isBool())
- return (uint8)field->getInt8Field(Obj);
+ res = (uint8)field->getInt8Field(Obj);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
- vm->illegalArgumentException("");
+ END_NATIVE_EXCEPTION
- return 0;
+ return res;
}
@@ -170,6 +216,11 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
+
+ jfloat res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -188,22 +239,27 @@
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isByte())
- return (jfloat)field->getInt8Field(Obj);
- if (prim->isInt())
- return (jfloat)field->getInt32Field((JavaObject*)obj);
- if (prim->isShort())
- return (jfloat)field->getInt16Field((JavaObject*)obj);
- if (prim->isLong())
- return (jfloat)field->getLongField((JavaObject*)obj);
- if (prim->isChar())
+ res = (jfloat)field->getInt8Field(Obj);
+ else if (prim->isInt())
+ res = (jfloat)field->getInt32Field((JavaObject*)obj);
+ else if (prim->isShort())
+ res = (jfloat)field->getInt16Field((JavaObject*)obj);
+ else if (prim->isLong())
+ res = (jfloat)field->getLongField((JavaObject*)obj);
+ else if (prim->isChar())
// Cast to uint32 because char is unsigned.
- return (jfloat)(uint32)field->getInt16Field((JavaObject*)obj);
- if (prim->isFloat())
- return (jfloat)field->getFloatField((JavaObject*)obj);
+ res = (jfloat)(uint32)field->getInt16Field((JavaObject*)obj);
+ else if (prim->isFloat())
+ res = (jfloat)field->getFloatField((JavaObject*)obj);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
- vm->illegalArgumentException("");
- return 0.0;
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jbyte JNICALL Java_java_lang_reflect_Field_getByte(
@@ -211,6 +267,11 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
+
+ jbyte res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -229,12 +290,16 @@
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isByte())
- return (sint8)field->getInt8Field(Obj);
+ res = (sint8)field->getInt8Field(Obj);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
- vm->illegalArgumentException("");
+ END_NATIVE_EXCEPTION
- return 0;
+ return res;
}
JNIEXPORT jchar JNICALL Java_java_lang_reflect_Field_getChar(
@@ -242,6 +307,12 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
+
+ jchar res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -260,12 +331,16 @@
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isChar())
- return (uint16)field->getInt16Field((JavaObject*)obj);
+ res = (uint16)field->getInt16Field((JavaObject*)obj);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
+
+ END_NATIVE_EXCEPTION
- vm->illegalArgumentException("");
-
- return 0;
+ return res;
}
@@ -274,6 +349,12 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
+
+
+ jshort res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -292,14 +373,18 @@
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isShort())
- return (sint16)field->getInt16Field(Obj);
- if (prim->isByte())
- return (sint16)field->getInt8Field(Obj);
+ res = (sint16)field->getInt16Field(Obj);
+ else if (prim->isByte())
+ res = (sint16)field->getInt8Field(Obj);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
- vm->illegalArgumentException("");
-
- return 0;
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jdouble JNICALL Java_java_lang_reflect_Field_getDouble(
@@ -307,6 +392,11 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
+
+ jdouble res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -325,23 +415,28 @@
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isByte())
- return (jdouble)(sint64)field->getInt8Field(Obj);
- if (prim->isInt())
- return (jdouble)(sint64)field->getInt32Field(Obj);
- if (prim->isShort())
- return (jdouble)(sint64)field->getInt16Field(Obj);
- if (prim->isLong())
- return (jdouble)(sint64)field->getLongField(Obj);
- if (prim->isChar())
- return (jdouble)(uint64)field->getInt16Field(Obj);
- if (prim->isFloat())
- return (jdouble)field->getFloatField(Obj);
- if (prim->isDouble())
- return (jdouble)field->getDoubleField(Obj);
+ res = (jdouble)(sint64)field->getInt8Field(Obj);
+ else if (prim->isInt())
+ res = (jdouble)(sint64)field->getInt32Field(Obj);
+ else if (prim->isShort())
+ res = (jdouble)(sint64)field->getInt16Field(Obj);
+ else if (prim->isLong())
+ res = (jdouble)(sint64)field->getLongField(Obj);
+ else if (prim->isChar())
+ res = (jdouble)(uint64)field->getInt16Field(Obj);
+ else if (prim->isFloat())
+ res = (jdouble)field->getFloatField(Obj);
+ else if (prim->isDouble())
+ res = (jdouble)field->getDoubleField(Obj);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
-
- vm->illegalArgumentException("");
- return 0.0;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jobject JNICALL Java_java_lang_reflect_Field_get(
@@ -349,6 +444,12 @@
JNIEnv *env,
#endif
jobject Field, jobject _obj) {
+
+
+ jobject res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -411,6 +512,8 @@
res = field->getObjectField(Obj);
}
+ END_NATIVE_EXCEPTION
+
return (jobject)res;
}
@@ -419,6 +522,9 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jobject val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -442,27 +548,26 @@
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isBool())
- return field->setInt8Field(Obj, ((uint8*)_buf)[0]);
- if (prim->isByte())
- return field->setInt8Field(Obj, ((sint8*)_buf)[0]);
- if (prim->isChar())
- return field->setInt16Field(Obj, ((uint16*)_buf)[0]);
- if (prim->isShort())
- return field->setInt16Field(Obj, ((sint16*)_buf)[0]);
- if (prim->isInt())
- return field->setInt32Field(Obj, ((sint32*)_buf)[0]);
- if (prim->isLong())
- return field->setLongField(Obj, ((sint64*)_buf)[0]);
- if (prim->isFloat())
- return field->setFloatField(Obj, ((float*)_buf)[0]);
- if (prim->isDouble())
- return field->setDoubleField(Obj, ((double*)_buf)[0]);
+ field->setInt8Field(Obj, ((uint8*)_buf)[0]);
+ else if (prim->isByte())
+ field->setInt8Field(Obj, ((sint8*)_buf)[0]);
+ else if (prim->isChar())
+ field->setInt16Field(Obj, ((uint16*)_buf)[0]);
+ else if (prim->isShort())
+ field->setInt16Field(Obj, ((sint16*)_buf)[0]);
+ else if (prim->isInt())
+ field->setInt32Field(Obj, ((sint32*)_buf)[0]);
+ else if (prim->isLong())
+ field->setLongField(Obj, ((sint64*)_buf)[0]);
+ else if (prim->isFloat())
+ field->setFloatField(Obj, ((float*)_buf)[0]);
+ else if (prim->isDouble())
+ field->setDoubleField(Obj, ((double*)_buf)[0]);
} else {
- return field->setObjectField(Obj, ((JavaObject**)_buf)[0]);
+ field->setObjectField(Obj, ((JavaObject**)_buf)[0]);
}
- // Unreachable code
- return;
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setBoolean(
@@ -470,6 +575,9 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jboolean val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -488,10 +596,14 @@
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isBool())
- return field->setInt8Field(Obj, (uint8)val);
+ field->setInt8Field(Obj, (uint8)val);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
- vm->illegalArgumentException("");
+ END_NATIVE_EXCEPTION
}
@@ -500,6 +612,9 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jbyte val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -518,20 +633,24 @@
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isByte())
- return field->setInt8Field(Obj, (sint8)val);
- if (prim->isShort())
- return field->setInt16Field(Obj, (sint16)val);
- if (prim->isInt())
- return field->setInt32Field(Obj, (sint32)val);
- if (prim->isLong())
- return field->setLongField(Obj, (sint64)val);
- if (prim->isFloat())
- return field->setFloatField(Obj, (float)val);
- if (prim->isDouble())
- return field->setDoubleField(Obj, (double)val);
+ field->setInt8Field(Obj, (sint8)val);
+ else if (prim->isShort())
+ field->setInt16Field(Obj, (sint16)val);
+ else if (prim->isInt())
+ field->setInt32Field(Obj, (sint32)val);
+ else if (prim->isLong())
+ field->setLongField(Obj, (sint64)val);
+ else if (prim->isFloat())
+ field->setFloatField(Obj, (float)val);
+ else if (prim->isDouble())
+ field->setDoubleField(Obj, (double)val);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
-
- vm->illegalArgumentException("");
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setChar(
@@ -539,6 +658,9 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jchar val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -556,18 +678,22 @@
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isChar())
- return field->setInt16Field(Obj, (uint16)val);
- if (prim->isInt())
- return field->setInt32Field(Obj, (uint32)val);
- if (prim->isLong())
- return field->setLongField(Obj, (uint64)val);
- if (prim->isFloat())
- return field->setFloatField(Obj, (float)(uint32)val);
- if (prim->isDouble())
- return field->setDoubleField(Obj, (double)(uint64)val);
+ field->setInt16Field(Obj, (uint16)val);
+ else if (prim->isInt())
+ field->setInt32Field(Obj, (uint32)val);
+ else if (prim->isLong())
+ field->setLongField(Obj, (uint64)val);
+ else if (prim->isFloat())
+ field->setFloatField(Obj, (float)(uint32)val);
+ else if (prim->isDouble())
+ field->setDoubleField(Obj, (double)(uint64)val);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
-
- vm->illegalArgumentException("");
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setShort(
@@ -575,6 +701,9 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jshort val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -593,18 +722,22 @@
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isShort())
- return field->setInt16Field(Obj, (sint16)val);
- if (prim->isInt())
- return field->setInt32Field(Obj, (sint32)val);
- if (prim->isLong())
- return field->setLongField(Obj, (sint64)val);
- if (prim->isFloat())
- return field->setFloatField(Obj, (float)val);
- if (prim->isDouble())
- return field->setDoubleField(Obj, (double)val);
+ field->setInt16Field(Obj, (sint16)val);
+ else if (prim->isInt())
+ field->setInt32Field(Obj, (sint32)val);
+ else if (prim->isLong())
+ field->setLongField(Obj, (sint64)val);
+ else if (prim->isFloat())
+ field->setFloatField(Obj, (float)val);
+ else if (prim->isDouble())
+ field->setDoubleField(Obj, (double)val);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
-
- vm->illegalArgumentException("");
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setInt(
@@ -612,6 +745,9 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jint val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -630,16 +766,20 @@
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isInt())
- return field->setInt32Field(Obj, (sint32)val);
- if (prim->isLong())
- return field->setLongField(Obj, (sint64)val);
- if (prim->isFloat())
- return field->setFloatField(Obj, (float)val);
- if (prim->isDouble())
- return field->setDoubleField(Obj, (double)val);
+ field->setInt32Field(Obj, (sint32)val);
+ else if (prim->isLong())
+ field->setLongField(Obj, (sint64)val);
+ else if (prim->isFloat())
+ field->setFloatField(Obj, (float)val);
+ else if (prim->isDouble())
+ field->setDoubleField(Obj, (double)val);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
-
- vm->illegalArgumentException("");
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setLong(
@@ -647,6 +787,9 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jlong val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -665,14 +808,18 @@
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isLong())
- return field->setLongField(Obj, (sint64)val);
- if (prim->isFloat())
- return field->setFloatField(Obj, (float)val);
- if (prim->isDouble())
- return field->setDoubleField(Obj, (double)val);
+ field->setLongField(Obj, (sint64)val);
+ else if (prim->isFloat())
+ field->setFloatField(Obj, (float)val);
+ else if (prim->isDouble())
+ field->setDoubleField(Obj, (double)val);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
-
- vm->illegalArgumentException("");
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setFloat(
@@ -680,6 +827,10 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jfloat val) {
+
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -698,12 +849,16 @@
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isFloat())
- return field->setFloatField(Obj, (float)val);
- if (prim->isDouble())
- return field->setDoubleField(Obj, (double)val);
+ field->setFloatField(Obj, (float)val);
+ else if (prim->isDouble())
+ field->setDoubleField(Obj, (double)val);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
-
- vm->illegalArgumentException("");
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setDouble(
@@ -711,6 +866,9 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jdouble val) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->fieldSlot;
JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field);
@@ -729,12 +887,17 @@
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isDouble())
- return field->setDoubleField(Obj, (double)val);
+ field->setDoubleField(Obj, (double)val);
+ else
+ vm->illegalArgumentException("");
+ } else {
+ vm->illegalArgumentException("");
}
-
- vm->illegalArgumentException("");
+
+ END_NATIVE_EXCEPTION
}
+// Never throws.
JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
#ifdef NATIVE_JNI
JNIEnv *env,
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp Tue Dec 30 03:31:45 2008
@@ -46,10 +46,20 @@
JNIEnv *env,
#endif
jobject Meth) {
+
+ jint res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->methodSlot;
JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)Meth);
- return meth->access;
+
+ res = meth->access;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jclass JNICALL Java_java_lang_reflect_Method_getReturnType(
@@ -57,13 +67,22 @@
JNIEnv *env,
#endif
jobject Meth) {
+
+ jclass res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->methodSlot;
JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)Meth);
UserClass* cl = internalGetClass(vm, meth, Meth);
JnjvmClassLoader* loader = cl->classLoader;
Typedef* ret = meth->getSignature()->getReturnType();
- return (jclass)NativeUtil::getClassType(loader, ret);
+ res = (jclass)NativeUtil::getClassType(loader, ret);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
@@ -72,12 +91,21 @@
JNIEnv *env,
#endif
jobject Meth) {
+
+ jobject res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->methodSlot;
JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)Meth);
UserClass* cl = internalGetClass(vm, meth, Meth);
JnjvmClassLoader* loader = cl->classLoader;
- return (jobject)(NativeUtil::getParameterTypes(loader, meth));
+ res = (jobject)(NativeUtil::getParameterTypes(loader, meth));
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jobject JNICALL Java_java_lang_reflect_Method_invokeNative(
@@ -85,6 +113,10 @@
JNIEnv *env,
#endif
jobject Meth, jobject _obj, jobject _args, jclass Cl, jint _meth) {
+
+ JavaObject* res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
JavaMethod* meth = (JavaMethod*)_meth;
@@ -151,7 +183,6 @@
} \
} \
- JavaObject* res = 0;
Typedef* retType = sign->getReturnType();
if (retType->isPrimitive()) {
PrimitiveTypedef* prim = (PrimitiveTypedef*)retType;
@@ -205,10 +236,13 @@
RUN_METH(JavaObject);
res = val;
}
- return (jobject)res;
+ } else {
+ vm->illegalArgumentExceptionForMethod(meth, 0, 0);
}
- vm->illegalArgumentExceptionForMethod(meth, 0, 0);
- return 0;
+
+ END_NATIVE_EXCEPTION
+
+ return (jobject) res;
}
#undef RUN_METH
@@ -218,12 +252,21 @@
JNIEnv *env,
#endif
jobject _meth) {
+
+ jobjectArray res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
verifyNull(_meth);
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* slot = vm->upcalls->methodSlot;
JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)_meth);
UserClass* cl = internalGetClass(vm, meth, _meth);
- return (jobjectArray)NativeUtil::getExceptionTypes(cl, meth);
+ res = (jobjectArray)NativeUtil::getExceptionTypes(cl, meth);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h Tue Dec 30 03:31:45 2008
@@ -20,7 +20,7 @@
namespace jnjvm {
class JavaObjectClass : public JavaObject {
-private:
+public:
JavaObject* signers;
JavaObject* pd;
UserCommonClass* vmdata;
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp Tue Dec 30 03:31:45 2008
@@ -29,6 +29,7 @@
extern "C" {
+// Never throws
JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isArray(
#ifdef NATIVE_JNI
JNIEnv *env,
@@ -51,6 +52,10 @@
jboolean clinit,
jobject loader) {
+ jclass res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JnjvmClassLoader* JCL =
JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm);
@@ -60,11 +65,14 @@
if (clinit && cl->asClass()) {
cl->asClass()->initialiseClass(vm);
}
- return (jclass)(cl->getClassDelegatee(vm));
+ res =(jclass)(cl->getClassDelegatee(vm));
} else {
vm->classNotFoundException((JavaString*)str);
- return 0;
}
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredConstructors(
@@ -75,11 +83,15 @@
jclass Cl,
jboolean publicOnly) {
+ jobject result = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false);
if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
- return (jobject)vm->upcalls->constructorArrayClass->doNew(0, vm);
+ result = (jobject)vm->upcalls->constructorArrayClass->doNew(0, vm);
} else {
UserClass* realCl = (Class*)cl;
std::vector<JavaMethod*> res;
@@ -97,8 +109,12 @@
vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp, Cl, meth);
ret->elements[index] = tmp;
}
- return (jobject)ret;
+ result = (jobject)ret;
}
+
+ END_NATIVE_EXCEPTION
+
+ return result;
}
JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredMethods(
@@ -109,12 +125,16 @@
jclass Cl,
jboolean publicOnly) {
+ jobject result = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false);
Classpath* upcalls = vm->upcalls;
if (cl->isArray() || cl->isPrimitive()) {
- return (jobject)upcalls->methodArrayClass->doNew(0, vm);
+ result = (jobject)upcalls->methodArrayClass->doNew(0, vm);
} else {
std::vector<JavaMethod*> res;
UserClass* realCl = cl->asClass();
@@ -134,8 +154,12 @@
upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, Cl, str, meth);
ret->elements[index] = tmp;
}
- return (jobject)ret;
+ result = (jobject)ret;
}
+
+ END_NATIVE_EXCEPTION
+
+ return result;
}
JNIEXPORT jint JNICALL Java_java_lang_VMClass_getModifiers(
@@ -145,10 +169,17 @@
#endif
jclass Cl,
jboolean ignore) {
+
+ jint res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false);
- return cl->getAccess();
+ res = cl->getAccess();
+
+ END_NATIVE_EXCEPTION
+ return res;
}
JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getName(
@@ -157,13 +188,22 @@
jclass clazz,
#endif
jobject Cl) {
+
+ jobject result = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass();
const UTF8* iname = cl->getName();
const UTF8* res = iname->internalToJava(vm, 0, iname->size);
- return (jobject)(vm->UTF8ToStr(res));
+ result = (jobject)(vm->UTF8ToStr(res));
+
+ END_NATIVE_EXCEPTION
+
+ return result;
}
JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isPrimitive(
@@ -172,9 +212,17 @@
jclass clazz,
#endif
jclass Cl) {
+
+ jboolean res = 0;
+ BEGIN_NATIVE_EXCEPTION(0)
+
UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass();
- return cl->isPrimitive();
+ res = cl->isPrimitive();
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isInterface(
@@ -183,10 +231,19 @@
jclass clazz,
#endif
jclass Cl) {
+
+ jboolean res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false);
- return cl->isInterface();
+ res = cl->isInterface();
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jclass JNICALL Java_java_lang_VMClass_getComponentType(
@@ -195,15 +252,23 @@
jclass clazz,
#endif
jclass Cl) {
+
+ jclass res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass();
if (cl->isArray()) {
UserCommonClass* bc = ((UserClassArray*)cl)->baseClass();
- return (jclass)(bc->getClassDelegatee(vm));
+ res = (jclass)(bc->getClassDelegatee(vm));
} else {
- return 0;
+ res = 0;
}
+
+ END_NATIVE_EXCEPTION
+ return res;
}
JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getClassLoader(
@@ -212,8 +277,17 @@
jclass clazz,
#endif
jclass Cl) {
+
+ jobject res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass();
- return (jobject)cl->classLoader->getJavaClassLoader();
+ res = (jobject)cl->classLoader->getJavaClassLoader();
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isAssignableFrom(
@@ -222,11 +296,20 @@
jclass clazz,
#endif
jclass Cl1, jclass Cl2) {
+
+ jboolean res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
UserCommonClass* cl1 = ((JavaObjectClass*)Cl1)->getClass();
UserCommonClass* cl2 = ((JavaObjectClass*)Cl2)->getClass();
if (cl2->asClass()) cl2->asClass()->resolveClass();
- return cl2->isAssignableFrom(cl1);
+ res = cl2->isAssignableFrom(cl1);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
@@ -236,15 +319,23 @@
jclass clazz,
#endif
jclass Cl) {
+
+ jobject res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass();
- if (cl->isInterface())
- return 0;
+ if (cl->isInterface()) res = 0;
else {
if (cl->asClass()) cl->asClass()->resolveClass();
- if (cl->getSuper()) return (jobject)cl->getSuper()->getClassDelegatee(vm);
- else return 0;
+ if (cl->getSuper()) res = (jobject)cl->getSuper()->getClassDelegatee(vm);
+ else res = 0;
}
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT bool JNICALL Java_java_lang_VMClass_isInstance(
@@ -253,8 +344,17 @@
jclass clazz,
#endif
jclass Cl, jobject obj) {
+
+ bool res = false;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass();
- return ((JavaObject*)obj)->instanceOf(cl);
+ res = ((JavaObject*)obj)->instanceOf(cl);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredFields(
@@ -263,11 +363,16 @@
jclass clazz,
#endif
jclass Cl, jboolean publicOnly) {
+
+ jobject result = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false)->asClass();
if (!cl) {
- return (jobject)vm->upcalls->fieldArrayClass->doNew(0, vm);
+ result = (jobject)vm->upcalls->fieldArrayClass->doNew(0, vm);
} else {
std::vector<JavaField*> res;
cl->getDeclaredFields(res, publicOnly);
@@ -285,8 +390,12 @@
vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, Cl, name, field);
ret->elements[index] = tmp;
}
- return (jobject)ret;
+ result = (jobject)ret;
}
+
+ END_NATIVE_EXCEPTION
+
+ return result;
}
JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getInterfaces(
@@ -295,6 +404,11 @@
jclass clazz,
#endif
jclass Cl) {
+
+ jobject res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false);
ArrayObject* ret =
@@ -303,7 +417,11 @@
UserClass* klass = cl->interfaces[i];
ret->elements[i] = klass->getClassDelegatee(vm);
}
- return (jobject)ret;
+ res = (jobject)ret;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
@@ -313,17 +431,24 @@
jclass clazz,
#endif
jclass Cl) {
+ jclass res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false)->asClass();
if (cl) {
cl->resolveInnerOuterClasses();
UserClass* outer = cl->getOuterClass();
if (outer) {
- return (jclass)outer->getClassDelegatee(vm);
+ res = (jclass)outer->getClassDelegatee(vm);
}
}
- return 0;
+ END_NATIVE_EXCEPTION
+
+ return res;
+
}
JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredClasses(
@@ -332,6 +457,12 @@
jclass clazz,
#endif
jclass Cl, bool publicOnly) {
+
+
+ jobject result = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false)->asClass();
if (cl) {
@@ -342,14 +473,17 @@
UserClass* klass = cl->innerClasses[i];
res->elements[i] = klass->getClassDelegatee(vm);
}
- return (jobject)res;
+ result = (jobject)res;
}
+
- return 0;
+ END_NATIVE_EXCEPTION
-}
+ return result;
+}
+// Only throws.
JNIEXPORT void JNICALL Java_java_lang_VMClass_throwException(
#ifdef NATIVE_JNI
JNIEnv *env,
@@ -366,8 +500,17 @@
#endif
jclass Cl) {
// TODO implement me
+
+ jobjectArray res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
- return (jobjectArray)array->doNew(0, vm);
+ res = (jobjectArray) array->doNew(0, vm);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp Tue Dec 30 03:31:45 2008
@@ -32,13 +32,21 @@
#endif
jchar byteId) {
+ jobject res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
UserClassPrimitive* prim =
UserClassPrimitive::byteIdToPrimitive(byteId, vm->upcalls);
if (!prim)
vm->unknownError("unknown byte primitive %c", byteId);
- return (jobject)prim->getClassDelegatee(vm);
+ res = (jobject)prim->getClassDelegatee(vm);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
@@ -49,6 +57,10 @@
#endif
jobject loader,
jobject _name) {
+
+ jclass res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
JavaString* name = (JavaString*)_name;
@@ -57,7 +69,11 @@
JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm);
UserCommonClass* cl = JCL->lookupClass(utf8);
- if (cl) return (jclass)(cl->getClassDelegatee(vm));
+ if (cl) res = (jclass)(cl->getClassDelegatee(vm));
+
+ END_NATIVE_EXCEPTION
+
+ return res;
return 0;
}
@@ -69,6 +85,11 @@
#endif
jobject _str,
jboolean doResolve) {
+
+ jclass res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaString* str = (JavaString*)_str;
@@ -77,9 +98,11 @@
false);
if (cl != 0)
- return (jclass)cl->getClassDelegatee(vm);
+ res = (jclass)cl->getClassDelegatee(vm);
- return 0;
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT jclass JNICALL Java_java_lang_VMClassLoader_defineClass(
@@ -93,6 +116,11 @@
jint off,
jint len,
jobject pd) {
+
+ jclass res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JnjvmClassLoader* JCL =
@@ -102,7 +130,11 @@
const UTF8* name = str->value->javaToInternal(vm, str->offset, str->count);
UserClass* cl = JCL->constructClass(name, (ArrayUInt8*)bytes);
- return (jclass)(cl->getClassDelegatee(vm, (JavaObject*)pd));
+ res = (jclass)(cl->getClassDelegatee(vm, (JavaObject*)pd));
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT void JNICALL Java_java_lang_VMClassLoader_resolveClass(
@@ -111,9 +143,14 @@
jclass clazz,
#endif
jclass Cl) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
verifyNull(Cl);
Jnjvm* vm = JavaThread::get()->getJVM();
NativeUtil::resolvedImplClass(vm, Cl, false);
+
+ END_NATIVE_EXCEPTION
}
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp Tue Dec 30 03:31:45 2008
@@ -30,6 +30,10 @@
#endif
jobject _src) {
+ JavaObject* res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
JavaObject* src = (JavaObject*)_src;
UserCommonClass* cl = src->classOf;
Jnjvm* vm = JavaThread::get()->getJVM();
@@ -46,10 +50,13 @@
assert(cl->isClass() && "Not a class!");
size = cl->asClass()->getVirtualSize();
}
- JavaObject* res = (JavaObject*)
+ res = (JavaObject*)
vm->gcAllocator.allocateManagedObject(size, src->getVirtualTable());
memcpy(res, src, size);
res->lock.initialise();
+
+ END_NATIVE_EXCEPTION
+
return (jobject)res;
}
@@ -60,9 +67,17 @@
#endif
jobject _obj) {
+ jobject res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
JavaObject* obj = (JavaObject*)_obj;
Jnjvm* vm = JavaThread::get()->getJVM();
- return (jobject)(obj->classOf->getClassDelegatee(vm));
+ res = (jobject)(obj->classOf->getClassDelegatee(vm));
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
JNIEXPORT void JNICALL Java_java_lang_VMObject_notifyAll(
@@ -71,8 +86,13 @@
jclass clazz,
#endif
jobject _obj) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
JavaObject* obj = (JavaObject*)_obj;
obj->notifyAll();
+
+ END_NATIVE_EXCEPTION
}
@@ -82,6 +102,9 @@
jclass clazz,
#endif
jobject _object, jlong ms, jint ns) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
uint32 sec = (uint32) (ms / 1000);
uint32 usec = (ns / 1000) + 1000 * (ms % 1000);
JavaObject* obj = (JavaObject*)_object;
@@ -93,6 +116,8 @@
} else {
obj->wait();
}
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_lang_VMObject_notify(
@@ -101,7 +126,12 @@
jclass clazz,
#endif
jobject obj) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
((JavaObject*)obj)->notify();
+
+ END_NATIVE_EXCEPTION
}
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp Tue Dec 30 03:31:45 2008
@@ -36,6 +36,10 @@
jclass clazz,
#endif
jobject _strLib) {
+
+ jobject res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
JavaString* strLib = (JavaString*)_strLib;
Jnjvm* vm = JavaThread::get()->getJVM();
@@ -57,7 +61,11 @@
memmove(&(elements[lgPre + lgLib]), vm->bootstrapLoader->postlib->elements,
lgPost * sizeof(uint16));
- return (jobject)(vm->UTF8ToStr((const UTF8*)array));
+ res = (jobject)(vm->UTF8ToStr((const UTF8*)array));
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
@@ -70,6 +78,11 @@
#endif
jobject _str,
jobject _loader) {
+
+ jint result = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
JavaString* str = (JavaString*)_str;
Jnjvm* vm = JavaThread::get()->getJVM();
JnjvmClassLoader* loader =
@@ -82,10 +95,14 @@
if (res != 0) {
onLoad_t onLoad = (onLoad_t)loader->loadInLib("JNI_OnLoad", res);
if (onLoad) onLoad(&vm->javavmEnv, 0);
- return 1;
+ result = 1;
} else {
- return 0;
+ result = 0;
}
+
+ END_NATIVE_EXCEPTION
+
+ return result;
}
@@ -95,7 +112,11 @@
jclass clazz,
#endif
) {
+ BEGIN_NATIVE_EXCEPTION(0)
+
Collector::collect();
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalization(
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp Tue Dec 30 03:31:45 2008
@@ -29,108 +29,40 @@
extern "C" {
-#ifdef ISOLATE_SHARING
-uint32 getPools(UserConstantPool** pools, uint32 size) {
- unsigned int* top;
- register unsigned int **cur = ⊤
- register unsigned int **max = (unsigned int**)mvm::Thread::get()->baseSP;
-
- uint32 i = 0;
- for(; cur<max && i < size; cur++) {
- void* obj = (void*)(*cur);
- obj = Collector::begOf(obj);
- if (obj && ((mvm::Object*)obj)->getVirtualTable() == UserConstantPool::VT) {
- UserConstantPool* ctp = (UserConstantPool*)obj;
- pools[i++] = ctp;
- }
- }
- return i;
-}
-
-JavaObject* getClassInContext(Jnjvm* vm, Class* cl, UserConstantPool** ctps,
- uint32& ctpIndex) {
- for (; ctpIndex < 100; ++ctpIndex) {
- UserClass* newCl = ctps[ctpIndex]->getClass();
- if (cl == newCl->classDef) return newCl->getClassDelegatee(vm);
- }
- return 0;
-}
-
-ArrayObject* recGetClassContext(Jnjvm* vm, int** stack, uint32 size,
- uint32 first, uint32 rec,
- UserConstantPool** ctps, uint32 ctpIndex) {
- if (size != first) {
- JavaMethod* meth = JavaJIT::IPToJavaMethod(stack[first]);
- if (meth) {
- JavaObject* obj = getClassInContext(vm, meth->classDef, ctps, ctpIndex);
- ArrayObject* res = recGetClassContext(vm, stack, size, first + 1,
- rec + 1, ctps, ctpIndex);
- res->elements[rec] = obj;
- assert(res->elements[rec] && "Did not found the user class");
- return res;
- } else {
- return recGetClassContext(vm, stack, size, first + 1, rec, ctps,
- ctpIndex);
- }
- } else {
- return (ArrayObject*)vm->upcalls->classArrayClass->doNew(rec, vm);
- }
-}
-
-#else
-ArrayObject* recGetClassContext(Jnjvm* vm, int** stack, uint32 size,
- uint32 first, uint32 rec) {
- if (size != first) {
- JavaMethod* meth = JavaJIT::IPToJavaMethod(stack[first]);
- if (meth) {
- ArrayObject* res = recGetClassContext(vm, stack, size, first + 1,
- rec + 1);
- res->elements[rec] = meth->classDef->getClassDelegatee(vm);
- return res;
- } else {
- return recGetClassContext(vm, stack, size, first + 1, rec);
- }
- } else {
- return (ArrayObject*)vm->upcalls->classArrayClass->doNew(rec, vm);
- }
-}
-#endif
-
JNIEXPORT jobject JNICALL Java_gnu_classpath_VMStackWalker_getClassContext(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
) {
- Jnjvm* vm = JavaThread::get()->getJVM();
- int* ips[100];
- int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 100);
-#ifdef ISOLATE_SHARING
- UserConstantPool* pools[100];
- getPools(pools, 100);
-#endif
- int i = 0;
- int first = 0;
- UserCommonClass* cl = vm->upcalls->vmStackWalker;
-
- while (i < real_size) {
- JavaMethod* meth = JavaJIT::IPToJavaMethod(ips[i++]);
-#ifdef ISOLATE_SHARING
- if (meth && meth->classDef == cl->classDef) {
-#else
- if (meth && meth->classDef == cl) {
-#endif
- first = i;
- break;
- }
+ jobject result = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ JavaThread* th = JavaThread::get();
+ Jnjvm* vm = th->getJVM();
+ std::vector<void*> stack;
+
+ th->getJavaFrameContext(stack);
+
+ ArrayObject* res = (ArrayObject*)
+ vm->upcalls->stackTraceArray->doNew(stack.size(), vm);
+
+ std::vector<void*>::iterator i = stack.begin(), e = stack.end();
+ uint32 index = 0;
+
+ for (; i != e; ++i) {
+ JavaMethod* meth = vm->IPToJavaMethod(*i);
+ assert(meth && "Wrong stack trace");
+ res->elements[index++] = meth->classDef->getClassDelegatee(vm);
}
+
+ result = (jobject)res;
+
+ END_NATIVE_EXCEPTION
-#ifdef ISOLATE_SHARING
- return (jobject)recGetClassContext(vm, ips, real_size, first, 0, pools, 0);
-#else
- return (jobject)recGetClassContext(vm, ips, real_size, first, 0);
-#endif
+ return result;
}
JNIEXPORT jobject JNICALL Java_gnu_classpath_VMStackWalker_getClassLoader(
@@ -139,19 +71,46 @@
jclass clazz,
#endif
jclass _Cl) {
+
+ jobject res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
JavaObject* Cl = (JavaObject*)_Cl;
UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass();
- return (jobject)cl->classLoader->getJavaClassLoader();
+ res = (jobject)cl->classLoader->getJavaClassLoader();
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
extern "C" JavaObject* getCallingClass() {
- UserClass* cl = JavaJIT::getCallingClass();
- if (cl) return cl->getClassDelegatee(JavaThread::get()->getJVM());
- return 0;
+
+ JavaObject* res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ JavaThread* th = JavaThread::get();
+ UserClass* cl = th->getCallingClass();
+ if (cl) res = cl->getClassDelegatee(th->getJVM());
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
extern "C" JavaObject* getCallingClassLoader() {
- return JavaJIT::getCallingClassLoader();
+
+ JavaObject *res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ JavaThread* th = JavaThread::get();
+ UserClass* cl = th->getCallingClass();
+ if (cl) res = cl->classLoader->getJavaClassLoader();
+ END_NATIVE_EXCEPTION
+
+ return res;
}
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp Tue Dec 30 03:31:45 2008
@@ -33,6 +33,8 @@
jobject _dst,
jint dstart,
jint len) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
jnjvm::Jnjvm *vm = JavaThread::get()->getJVM();
JavaArray* src = (JavaArray*)_src;
@@ -95,6 +97,8 @@
if (doThrow)
vm->arrayStoreException();
+
+ END_NATIVE_EXCEPTION
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp Tue Dec 30 03:31:45 2008
@@ -53,6 +53,8 @@
jclass clazz,
#endif
jobject _prop) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
JavaObject* prop = (JavaObject*)_prop;
Jnjvm* vm = JavaThread::get()->getJVM();
@@ -120,15 +122,20 @@
setProperty(vm, prop, "file.encoding", "ISO8859_1");
setProperty(vm, prop, "gnu.java.util.zoneinfo.dir", "/usr/share/zoneinfo");
-
+ END_NATIVE_EXCEPTION
}
extern "C" void propertiesPostInit(JavaObject* prop) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
for (std::vector<std::pair<char*, char*> >::iterator i =
vm->postProperties.begin(), e = vm->postProperties.end(); i!= e; i++) {
setProperty(vm, prop, i->first, i->second);
}
+
+ END_NATIVE_EXCEPTION
}
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp Tue Dec 30 03:31:45 2008
@@ -27,6 +27,8 @@
extern "C" {
+// Never throws.
+// Never calls Java code.
JNIEXPORT jobject JNICALL Java_java_lang_VMThread_currentThread(
#ifdef NATIVE_JNI
JNIEnv *env,
@@ -81,6 +83,9 @@
JNIEnv *env,
#endif
jobject _vmThread, sint64 stackSize) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaObject* vmThread = (JavaObject*)_vmThread;
@@ -91,6 +96,8 @@
JavaThread* th = new JavaThread(javaThread, vmThread, vm);
if (!th) vm->outOfMemoryError(0);
th->start((void (*)(mvm::Thread*))start);
+
+ END_NATIVE_EXCEPTION
}
JNIEXPORT void JNICALL Java_java_lang_VMThread_interrupt(
@@ -98,6 +105,9 @@
JNIEnv *env,
#endif
jobject _vmthread) {
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaObject* vmthread = (JavaObject*)_vmthread;
JavaField* field = vm->upcalls->vmdataVMThread;
@@ -117,8 +127,12 @@
}
th->lock.unlock();
+
+ END_NATIVE_EXCEPTION
}
+// Never throws.
+// Never calls Java code.
JNIEXPORT jboolean JNICALL Java_java_lang_VMThread_interrupted(
#ifdef NATIVE_JNI
JNIEnv *env,
@@ -131,6 +145,8 @@
return (jboolean)interrupt;
}
+// Never throws.
+// Never calls Java code.
JNIEXPORT jboolean JNICALL Java_java_lang_VMThread_isInterrupted(
#ifdef NATIVE_JNI
JNIEnv *env,
@@ -143,6 +159,8 @@
return (jboolean)th->interruptFlag;
}
+// Never throws.
+// Never calls Java code.
JNIEXPORT void JNICALL Java_java_lang_VMThread_nativeSetPriority(
#ifdef NATIVE_JNI
JNIEnv *env,
@@ -151,6 +169,8 @@
// Currently not implemented
}
+// Never throws.
+// Never calls Java code.
JNIEXPORT void JNICALL Java_java_lang_VMThread_nativeStop(
#ifdef NATIVE_JNI
JNIEnv *env,
@@ -159,6 +179,8 @@
// Currently not implemented
}
+// Never throws.
+// Never calls Java code.
JNIEXPORT void JNICALL Java_java_lang_VMThread_yield(
#ifdef NATIVE_JNI
JNIEnv *env,
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp Tue Dec 30 03:31:45 2008
@@ -8,6 +8,7 @@
//===----------------------------------------------------------------------===//
#include <cstring>
+#include <vector>
#include "types.h"
@@ -37,19 +38,33 @@
jclass clazz,
#endif
jobject throwable) {
- Jnjvm* vm = JavaThread::get()->getJVM();
- int** stack =
- (int**)vm->gcAllocator.allocateTemporaryMemory(sizeof(int*) * 100);
- int real_size = mvm::MvmModule::getBacktrace((void**)stack, 100);
- stack[real_size] = 0;
+
+ jobject res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ JavaThread* th = JavaThread::get();
+ Jnjvm* vm = th->getJVM();
+
+ // Allocate the temporary data.
+ std::vector<void*>* stack = new std::vector<void*>();
+
+ // Get the frame context.
+ th->getJavaFrameContext(*stack);
+
+ // Set the tempory data in the new VMThrowable object.
JavaObject* vmThrowable = vm->upcalls->newVMThrowable->doNew(vm);
uint64 ptr = (uint64)vmThrowable + vm->upcalls->vmDataVMThrowable->ptrOffset;
((JavaObject**)ptr)[0] = (JavaObject*)stack;
- return (jobject)vmThrowable;
+ res = (jobject)vmThrowable;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
-JavaObject* consStackElement(JavaMethod* meth, int* ip) {
+static JavaObject* consStackElement(JavaMethod* meth, void* ip) {
Jnjvm* vm = JavaThread::get()->getJVM();
JavaObject* methodName = vm->internalUTF8ToStr(meth->name);
Class* cl = meth->classDef;
@@ -77,47 +92,47 @@
return res;
}
-ArrayObject* recGetStackTrace(int** stack, uint32 first, uint32 rec) {
- Jnjvm* vm = JavaThread::get()->getJVM();
- if (stack[first] != 0) {
- JavaMethod* meth = JavaJIT::IPToJavaMethod(stack[first]);
- if (meth) {
- ArrayObject* res = recGetStackTrace(stack, first + 1, rec + 1);
- res->elements[rec] = consStackElement(meth, stack[first]);
- return res;
- } else {
- return recGetStackTrace(stack, first + 1, rec);
- }
- } else {
- return (ArrayObject*)vm->upcalls->stackTraceArray->doNew(rec, vm);
- }
-}
-
JNIEXPORT jobject JNICALL Java_java_lang_VMThrowable_getStackTrace(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
jobject vmthrow, jobject throwable) {
+
+ jobject result = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = vm->upcalls->vmDataVMThrowable;
- int** stack = (int**)field->getObjectField((JavaObject*)vmthrow);
- uint32 first = 0;
- sint32 i = 0;
-
- while (stack[i] != 0) {
- JavaMethod* meth = JavaJIT::IPToJavaMethod(stack[i++]);
-#ifdef ISOLATE_SHARING
- if (meth) {
-#else
- if (meth && !meth->classDef->subclassOf(vm->upcalls->newThrowable)) {
-#endif
- first = i - 1;
- break;
- }
+ std::vector<void*>* stack = (std::vector<void*>*)
+ field->getObjectField((JavaObject*)vmthrow);
+
+ std::vector<void*>::iterator i = stack->begin(), e = stack->end();
+ uint32 index = 0;
+ while (i != e) {
+ JavaMethod* meth = vm->IPToJavaMethod(*i);
+ assert(meth && "Wrong stack trace");
+ if (meth->classDef->subclassOf(vm->upcalls->newThrowable)) {
+ ++i;
+ ++index;
+ } else break;
}
- jobject res = (jobject)recGetStackTrace((int**)(uint32**)stack, first, 0);
- vm->gcAllocator.freeTemporaryMemory(stack);
- return res;
+
+ ArrayObject* res = (ArrayObject*)
+ vm->upcalls->stackTraceArray->doNew(stack->size() - index, vm);
+
+ index = 0;
+ for (; i != e; ++i) {
+ JavaMethod* meth = vm->IPToJavaMethod(*i);
+ assert(meth && "Wrong stack trace");
+ res->elements[index++] = consStackElement(meth, *i);
+ }
+
+ delete stack;
+ result = (jobject)res;
+
+ END_NATIVE_EXCEPTION
+
+ return result;
}
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp Tue Dec 30 03:31:45 2008
@@ -22,6 +22,7 @@
using namespace jnjvm;
+#if 0
JavaMethod* JavaJIT::IPToJavaMethod(void* begIp) {
const llvm::Function* F = mvm::MvmModule::getCodeFromPointer(begIp);
if (F) {
@@ -141,3 +142,5 @@
if (!cl) return 0;
else return cl->classLoader->getJavaClassLoader();
}
+
+#endif
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Tue Dec 30 03:31:45 2008
@@ -192,7 +192,6 @@
if (!natPtr && !module->isStaticCompiling()) {
fprintf(stderr, "Native function %s not found. Probably "
"not implemented by JnJVM?\n", compilingMethod->printString());
- JavaJIT::printBacktrace();
JavaThread::get()->getJVM()->unknownError("can not find native method %s",
compilingMethod->printString());
}
@@ -862,11 +861,6 @@
}
}
- // We don't need the lock here, and Java requires to load the classes in the
- // try clause, which may require compilation. Therefore we release the lock
- // and acquire it after the exception table is read.
- module->executionEngine->lock.release();
-
Exception* exceptions = (Exception*)alloca(sizeof(Exception) * (nbe - sync));
for (uint16 i = 0; i < nbe - sync; ++i) {
Exception* ex = &exceptions[i];
@@ -878,22 +872,8 @@
#ifndef ISOLATE_SHARING
if (ex->catche) {
- JavaObject* exc = 0;
- UserClass* cl = 0;
- try {
- cl = (UserClass*)(compilingClass->ctpInfo->loadClass(ex->catche));
- } catch(...) {
- compilingClass->release();
- exc = JavaThread::getJavaException();
- assert(exc && "no exception?");
- JavaThread::clearException();
- }
-
- if (exc) {
- Jnjvm* vm = JavaThread::get()->getJVM();
- vm->noClassDefFoundError(exc);
- }
-
+ UserClass* cl =
+ (UserClass*)(compilingClass->ctpInfo->isClassLoaded(ex->catche));
ex->catchClass = cl;
} else {
ex->catchClass = Classpath::newThrowable;
@@ -920,7 +900,6 @@
opcodeInfos[ex->handlerpc].reqSuppl = true;
}
- module->executionEngine->lock.acquire();
bool first = true;
for (sint16 i = 0; i < nbe - sync; ++i) {
@@ -991,8 +970,10 @@
else cl = CallInst::Create(module->GetJnjvmExceptionClassFunction,
isolateLocal, "", currentBlock);
#else
- assert(cur->catchClass);
- cl = module->getNativeClass(cur->catchClass);
+ if (cur->catchClass)
+ cl = module->getNativeClass(cur->catchClass);
+ else
+ cl = getResolvedClass(cur->catche, false, false, 0);
#endif
#ifdef SERVICE
@@ -1693,7 +1674,7 @@
node = module->getNativeClass(cl);
} else {
node = getConstantPoolAt(index, module->ClassLookupFunction,
- module->JavaCommonClassType, 0, doThrow);
+ module->JavaClassType, 0, doThrow);
}
if (!(!clinit || (cl && !needsInitialisationCheck(cl, compilingClass)))) {
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h Tue Dec 30 03:31:45 2008
@@ -76,12 +76,6 @@
JnjvmModule* module;
- static void invokeOnceVoid(Jnjvm* vm, JnjvmClassLoader* loader,
- const char* className,
- const char* func, const char* sign,
- int access, ...);
-
-
llvm::Function* javaCompile();
llvm::Function* nativeCompile(intptr_t natPtr = 0);
llvm::Instruction* inlineCompile(llvm::BasicBlock*& curBB,
@@ -272,12 +266,6 @@
#endif
static const char* OpcodeNames[256];
-
- static UserClass* getCallingClass();
- static UserClass* getCallingClassWalker();
- static JavaObject* getCallingClassLoader();
- static void printBacktrace();
- static JavaMethod* IPToJavaMethod(void* ip);
/// nbEnveloppes - Number of enveloppes (ie invokeinterface) in this
/// method.
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp Tue Dec 30 03:31:45 2008
@@ -24,33 +24,6 @@
using namespace jnjvm;
-void JavaJIT::invokeOnceVoid(Jnjvm* vm, JnjvmClassLoader* loader,
- char const* className, char const* func,
- char const* sign, int access, ...) {
-
- UserCommonClass* cl = loader->loadName(loader->asciizConstructUTF8(className),
- true, true);
-
- bool stat = access == ACC_STATIC ? true : false;
- UserClass* lookup = cl->isArray() ? cl->super : cl->asClass();
- lookup->initialiseClass(vm);
- JavaMethod* method = lookup->lookupMethod(loader->asciizConstructUTF8(func),
- loader->asciizConstructUTF8(sign),
- stat, true, 0);
- va_list ap;
- va_start(ap, access);
- if (stat) {
- method->invokeIntStaticAP(vm, (UserClass*)cl, ap);
- } else {
- JavaObject* obj = va_arg(ap, JavaObject*);
- method->invokeIntSpecialAP(vm, (UserClass*)cl, obj, ap);
- }
- va_end(ap);
-}
-
-
-
-
#define readArgs(buf, signature, ap) \
Typedef* const* arguments = signature->getArgumentsType(); \
for (uint32 i = 0; i < signature->nbArguments; ++i) { \
@@ -98,7 +71,22 @@
void* _buf = (void*)buf; \
readArgs(buf, sign, ap); \
void* func = (((void***)obj)[0])[offset];\
- return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, _buf);\
+ JavaObject* excp = 0; \
+ JavaThread* th = JavaThread::get(); \
+ th->startJava(); \
+ TYPE res = 0; \
+ try { \
+ res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, _buf);\
+ } catch (...) { \
+ excp = JavaThread::getJavaException(); \
+ JavaThread::clearException(); \
+ } \
+ if (excp) { \
+ th->pendingException = excp; \
+ th->returnFromJava(); \
+ } \
+ th->endJava(); \
+ return res; \
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##SpecialAP(Jnjvm* vm, UserClass* cl, JavaObject* obj, va_list ap) {\
@@ -113,7 +101,22 @@
void* _buf = (void*)buf; \
readArgs(buf, sign, ap); \
void* func = this->compiledPtr();\
- return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, _buf);\
+ JavaObject* excp = 0; \
+ JavaThread* th = JavaThread::get(); \
+ th->startJava(); \
+ TYPE res = 0; \
+ try { \
+ res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, _buf);\
+ } catch (...) { \
+ excp = JavaThread::getJavaException(); \
+ JavaThread::clearException(); \
+ } \
+ if (excp) { \
+ th->pendingException = excp; \
+ th->returnFromJava(); \
+ } \
+ th->endJava(); \
+ return res; \
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, UserClass* cl, va_list ap) {\
@@ -127,7 +130,22 @@
void* _buf = (void*)buf; \
readArgs(buf, sign, ap); \
void* func = this->compiledPtr();\
- return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(cl->getConstantPool(), func, _buf);\
+ JavaObject* excp = 0; \
+ JavaThread* th = JavaThread::get(); \
+ th->startJava(); \
+ TYPE res = 0; \
+ try { \
+ res = ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(cl->getConstantPool(), func, _buf);\
+ } catch (...) { \
+ excp = JavaThread::getJavaException(); \
+ JavaThread::clearException(); \
+ } \
+ if (excp) { \
+ th->pendingException = excp; \
+ th->returnFromJava(); \
+ } \
+ th->endJava(); \
+ return res; \
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##VirtualBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\
@@ -140,7 +158,22 @@
\
Signdef* sign = getSignature(); \
void* func = (((void***)obj)[0])[offset];\
- return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\
+ JavaObject* excp = 0; \
+ JavaThread* th = JavaThread::get(); \
+ th->startJava(); \
+ TYPE res = 0; \
+ try { \
+ res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\
+ } catch (...) { \
+ excp = JavaThread::getJavaException(); \
+ JavaThread::clearException(); \
+ } \
+ if (excp) { \
+ th->pendingException = excp; \
+ th->returnFromJava(); \
+ } \
+ th->endJava(); \
+ return res; \
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##SpecialBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\
@@ -152,7 +185,22 @@
verifyNull(obj);\
void* func = this->compiledPtr();\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\
+ JavaObject* excp = 0; \
+ JavaThread* th = JavaThread::get(); \
+ th->startJava(); \
+ TYPE res = 0; \
+ try { \
+ res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\
+ } catch (...) { \
+ excp = JavaThread::getJavaException(); \
+ JavaThread::clearException(); \
+ } \
+ if (excp) { \
+ th->pendingException = excp; \
+ th->returnFromJava(); \
+ } \
+ th->endJava(); \
+ return res; \
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##StaticBuf(Jnjvm* vm, UserClass* cl, void* buf) {\
@@ -163,7 +211,22 @@
\
void* func = this->compiledPtr();\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(cl->getConstantPool(), func, buf);\
+ JavaObject* excp = 0; \
+ JavaThread* th = JavaThread::get(); \
+ th->startJava(); \
+ TYPE res = 0; \
+ try { \
+ res = ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(cl->getConstantPool(), func, buf);\
+ } catch (...) { \
+ excp = JavaThread::getJavaException(); \
+ JavaThread::clearException(); \
+ } \
+ if (excp) { \
+ th->pendingException = excp; \
+ th->returnFromJava(); \
+ } \
+ th->endJava(); \
+ return res; \
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##Virtual(Jnjvm* vm, UserClass* cl, JavaObject* obj, ...) { \
@@ -203,7 +266,22 @@
verifyNull(obj); \
void* func = (((void***)obj)[0])[offset];\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(cl->getConstantPool(), func, obj, ap);\
+ JavaObject* excp = 0; \
+ JavaThread* th = JavaThread::get(); \
+ th->startJava(); \
+ TYPE res = 0; \
+ try { \
+ res = ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(cl->getConstantPool(), func, obj, ap);\
+ } catch (...) { \
+ excp = JavaThread::getJavaException(); \
+ JavaThread::clearException(); \
+ } \
+ if (excp) { \
+ th->pendingException = excp; \
+ th->returnFromJava(); \
+ } \
+ th->endJava(); \
+ return res; \
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##SpecialAP(Jnjvm* vm, UserClass* cl, JavaObject* obj, va_list ap) {\
@@ -215,7 +293,22 @@
verifyNull(obj);\
void* func = this->compiledPtr();\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(cl->getConstantPool(), func, obj, ap);\
+ JavaObject* excp = 0; \
+ JavaThread* th = JavaThread::get(); \
+ th->startJava(); \
+ TYPE res = 0; \
+ try { \
+ res = ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(cl->getConstantPool(), func, obj, ap);\
+ } catch (...) { \
+ excp = JavaThread::getJavaException(); \
+ JavaThread::clearException(); \
+ } \
+ if (excp) { \
+ th->pendingException = excp; \
+ th->returnFromJava(); \
+ } \
+ th->endJava(); \
+ return res; \
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, UserClass* cl, va_list ap) {\
@@ -226,7 +319,22 @@
\
void* func = this->compiledPtr();\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_STATIC_AP)sign->getStaticCallAP())(cl->getConstantPool(), func, ap);\
+ JavaObject* excp = 0; \
+ JavaThread* th = JavaThread::get(); \
+ th->startJava(); \
+ TYPE res = 0; \
+ try { \
+ res = ((FUNC_TYPE_STATIC_AP)sign->getStaticCallAP())(cl->getConstantPool(), func, ap);\
+ } catch (...) { \
+ excp = JavaThread::getJavaException(); \
+ JavaThread::clearException(); \
+ } \
+ if (excp) { \
+ th->pendingException = excp; \
+ th->returnFromJava(); \
+ } \
+ th->endJava(); \
+ return res; \
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##VirtualBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\
@@ -238,7 +346,22 @@
verifyNull(obj);\
void* func = (((void***)obj)[0])[offset];\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\
+ JavaObject* excp = 0; \
+ JavaThread* th = JavaThread::get(); \
+ th->startJava(); \
+ TYPE res = 0; \
+ try { \
+ res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\
+ } catch (...) { \
+ excp = JavaThread::getJavaException(); \
+ JavaThread::clearException(); \
+ } \
+ if (excp) { \
+ th->pendingException = excp; \
+ th->returnFromJava(); \
+ } \
+ th->endJava(); \
+ return res; \
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##SpecialBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\
@@ -250,7 +373,22 @@
verifyNull(obj);\
void* func = this->compiledPtr();\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\
+ JavaObject* excp = 0; \
+ JavaThread* th = JavaThread::get(); \
+ th->startJava(); \
+ TYPE res = 0; \
+ try { \
+ res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\
+ } catch (...) { \
+ excp = JavaThread::getJavaException(); \
+ JavaThread::clearException(); \
+ } \
+ if (excp) { \
+ th->pendingException = excp; \
+ th->returnFromJava(); \
+ } \
+ th->endJava(); \
+ return res; \
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##StaticBuf(Jnjvm* vm, UserClass* cl, void* buf) {\
@@ -261,7 +399,22 @@
\
void* func = this->compiledPtr();\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(cl->getConstantPool(), func, buf);\
+ JavaObject* excp = 0; \
+ JavaThread* th = JavaThread::get(); \
+ th->startJava(); \
+ TYPE res = 0; \
+ try { \
+ res = ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(cl->getConstantPool(), func, buf);\
+ } catch (...) { \
+ excp = JavaThread::getJavaException(); \
+ JavaThread::clearException(); \
+ } \
+ if (excp) { \
+ th->pendingException = excp; \
+ th->returnFromJava(); \
+ } \
+ th->endJava(); \
+ return res; \
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##Virtual(Jnjvm* vm, UserClass* cl, JavaObject* obj, ...) { \
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Tue Dec 30 03:31:45 2008
@@ -23,10 +23,18 @@
#include "JavaTypes.h"
#include "Jnjvm.h"
#include "LockedMap.h"
+#include "NativeUtil.h"
using namespace jnjvm;
+// Throws if the method is not found.
extern "C" void* jnjvmVirtualLookup(CacheNode* cache, JavaObject *obj) {
+
+ void* res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(1)
+
+
Enveloppe* enveloppe = cache->enveloppe;
UserCommonClass* ocl = obj->classOf;
@@ -86,10 +94,20 @@
enveloppe->cacheLock.release();
- return rcache->methPtr;
+ res = rcache->methPtr;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
+// Throws if the field is not found.
extern "C" void* virtualFieldLookup(UserClass* caller, uint32 index) {
+
+ void* res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(1)
+
UserConstantPool* ctpInfo = caller->getConstantPool();
if (ctpInfo->ctpRes[index]) {
return ctpInfo->ctpRes[index];
@@ -106,10 +124,20 @@
ctpInfo->ctpRes[index] = (void*)field->ptrOffset;
- return (void*)field->ptrOffset;
+ res = (void*)field->ptrOffset;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
+// Throws if the field or its class is not found.
extern "C" void* staticFieldLookup(UserClass* caller, uint32 index) {
+
+ void* res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(1)
+
UserConstantPool* ctpInfo = caller->getConstantPool();
if (ctpInfo->ctpRes[index]) {
@@ -135,73 +163,21 @@
void* ptr = (void*)((uint64)obj + field->ptrOffset);
ctpInfo->ctpRes[index] = ptr;
- return ptr;
-}
-
-#ifdef ISOLATE
-extern "C" void* stringLookup(UserClass* cl, uint32 index) {
- UserConstantPool* ctpInfo = cl->getConstantPool();
- const UTF8* utf8 = ctpInfo->UTF8AtForString(index);
- JavaString* str = JavaThread::get()->getJVM()->internalUTF8ToStr(utf8);
-#ifdef ISOLATE_SHARING
- ctpInfo->ctpRes[index] = str;
-#endif
- return (void*)str;
-}
-
-#ifdef ISOLATE_SHARING
-extern "C" void* enveloppeLookup(UserClass* cl, uint32 index) {
- UserConstantPool* ctpInfo = cl->getConstantPool();
- mvm::Allocator* allocator = cl->classLoader->allocator;
- Enveloppe* enveloppe = new(allocator) Enveloppe(ctpInfo, index);
- ctpInfo->ctpRes[index] = enveloppe;
- return (void*)enveloppe;
-}
-
-extern "C" void* staticCtpLookup(UserClass* cl, uint32 index) {
- UserConstantPool* ctpInfo = cl->getConstantPool();
- JavaConstantPool* shared = ctpInfo->getSharedPool();
- uint32 clIndex = shared->getClassIndexFromMethod(index);
- UserClass* refCl = (UserClass*)ctpInfo->loadClass(clIndex);
- refCl->initialiseClass(JavaThread::get()->getJVM());
+ res = ptr;
- CommonClass* baseCl = 0;
- const UTF8* utf8 = 0;
- Signdef* sign = 0;
+ END_NATIVE_EXCEPTION
- shared->resolveMethod(index, baseCl, utf8, sign);
- UserClass* methodCl = 0;
- refCl->lookupMethod(utf8, sign->keyName, true, true, &methodCl);
- ctpInfo->ctpRes[index] = methodCl->getConstantPool();
- shared->ctpRes[clIndex] = refCl->classDef;
- return (void*)methodCl->getConstantPool();
+ return res;
}
-extern "C" UserConstantPool* specialCtpLookup(UserConstantPool* ctpInfo,
- uint32 index,
- UserConstantPool** res) {
- JavaConstantPool* shared = ctpInfo->getSharedPool();
- uint32 clIndex = shared->getClassIndexFromMethod(index);
- UserClass* refCl = (UserClass*)ctpInfo->loadClass(clIndex);
-
- CommonClass* baseCl = 0;
- const UTF8* utf8 = 0;
- Signdef* sign = 0;
-
- shared->resolveMethod(index, baseCl, utf8, sign);
- UserClass* methodCl = 0;
- refCl->lookupMethod(utf8, sign->keyName, false, true, &methodCl);
- shared->ctpRes[clIndex] = refCl->classDef;
- *res = methodCl->getConstantPool();
- return methodCl->getConstantPool();
-}
-
-#endif
-
-#endif
-
#ifndef WITHOUT_VTABLE
+// Throws if the method is not found.
extern "C" void* vtableLookup(UserClass* caller, uint32 index, ...) {
+
+ void* res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(1)
+
UserCommonClass* cl = 0;
const UTF8* utf8 = 0;
Signdef* sign = 0;
@@ -232,11 +208,21 @@
"Class not ready in a virtual lookup.");
#endif
- return (void*)dmeth->offset;
+ res = (void*)dmeth->offset;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
#endif
+// Throws if the class is not found.
extern "C" void* classLookup(UserClass* caller, uint32 index) {
+
+ void* res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(1)
+
UserConstantPool* ctpInfo = caller->getConstantPool();
UserClass* cl = (UserClass*)ctpInfo->loadClass(index);
// We can not initialize here, because bytecodes such as CHECKCAST
@@ -244,77 +230,37 @@
// This is really sad, because we need to insert class initialization checks
// in the LLVM code.
assert(cl && "No cl after class lookup");
- return (void*)cl;
-}
+ res = (void*)cl;
+ END_NATIVE_EXCEPTION
-extern "C" void printMethodStart(JavaMethod* meth) {
- printf("[%p] executing %s\n", (void*)mvm::Thread::get(),
- meth->printString());
- fflush(stdout);
-}
-
-extern "C" void printMethodEnd(JavaMethod* meth) {
- printf("[%p] return from %s\n", (void*)mvm::Thread::get(),
- meth->printString());
- fflush(stdout);
-}
-
-extern "C" void printExecution(char* opcode, uint32 index, JavaMethod* meth) {
- printf("[%p] executing %s %s at %d\n", (void*)mvm::Thread::get(),
- meth->printString(), opcode, index);
- fflush(stdout);
-}
-
-extern "C" void jniProceedPendingException() {
- JavaThread* th = JavaThread::get();
- jmp_buf* buf = th->sjlj_buffers.back();
- th->sjlj_buffers.pop_back();
- mvm::Allocator& allocator = th->getJVM()->gcAllocator;
- allocator.freeTemporaryMemory(buf);
- if (JavaThread::get()->pendingException) {
- th->throwPendingException();
- }
-}
-
-extern "C" void* getSJLJBuffer() {
- JavaThread* th = JavaThread::get();
- mvm::Allocator& allocator = th->getJVM()->gcAllocator;
- void** buf = (void**)allocator.allocateTemporaryMemory(sizeof(jmp_buf));
- th->sjlj_buffers.push_back((jmp_buf*)buf);
- return (void*)buf;
-}
-
-extern "C" void jnjvmNullPointerException() {
- JavaThread::get()->getJVM()->nullPointerException("null");
-}
-
-extern "C" void negativeArraySizeException(sint32 val) {
- JavaThread::get()->getJVM()->negativeArraySizeException(val);
-}
-
-extern "C" void outOfMemoryError(sint32 val) {
- JavaThread::get()->getJVM()->outOfMemoryError(val);
-}
-
-extern "C" void jnjvmClassCastException(JavaObject* obj, UserCommonClass* cl) {
- JavaThread::get()->getJVM()->classCastException(obj, cl);
-}
-
-extern "C" void indexOutOfBoundsException(JavaObject* obj, sint32 index) {
- JavaThread::get()->getJVM()->indexOutOfBounds(obj, index);
+ return res;
}
+// Calls Java code.
+// Throws if initializing the class throws an exception.
extern "C" UserCommonClass* jnjvmRuntimeInitialiseClass(UserClass* cl) {
+ BEGIN_NATIVE_EXCEPTION(1)
+
cl->initialiseClass(JavaThread::get()->getJVM());
+
+ END_NATIVE_EXCEPTION
return cl;
}
+// Calls Java code.
extern "C" JavaObject* jnjvmRuntimeDelegatee(UserCommonClass* cl) {
+ JavaObject* res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(1)
Jnjvm* vm = JavaThread::get()->getJVM();
- return cl->getClassDelegatee(vm);
+ res = cl->getClassDelegatee(vm);
+ END_NATIVE_EXCEPTION
+
+ return res;
}
+// Throws if one of the dimension is negative.
static JavaArray* multiCallNewIntern(UserClassArray* cl, uint32 len,
sint32* dims, Jnjvm* vm) {
if (len <= 0) JavaThread::get()->getJVM()->unknownError("Can not happen");
@@ -342,7 +288,12 @@
return _res;
}
+// Throws if one of the dimension is negative.
extern "C" JavaArray* multiCallNew(UserClassArray* cl, uint32 len, ...) {
+ JavaArray* res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(1)
+
va_list ap;
va_start(ap, len);
sint32* dims = (sint32*)alloca(sizeof(sint32) * len);
@@ -350,69 +301,212 @@
dims[i] = va_arg(ap, int);
}
Jnjvm* vm = JavaThread::get()->getJVM();
- return multiCallNewIntern(cl, len, dims, vm);
+ res = multiCallNewIntern(cl, len, dims, vm);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
}
+// Throws if the class can not be resolved.
extern "C" UserClassArray* getArrayClass(UserCommonClass* cl,
UserClassArray** dcl) {
+ UserClassArray* res = 0;
+
+ BEGIN_NATIVE_EXCEPTION(1)
+
JnjvmClassLoader* JCL = cl->classLoader;
if (cl->asClass()) cl->asClass()->resolveClass();
const UTF8* arrayName = JCL->constructArrayName(1, cl->getName());
- UserClassArray* result = JCL->constructArray(arrayName);
- if (dcl) *dcl = result;
- return result;
+ res = JCL->constructArray(arrayName);
+ if (dcl) *dcl = res;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+// Does not call Java code.
+extern "C" void jniProceedPendingException() {
+ JavaThread* th = JavaThread::get();
+ jmp_buf* buf = th->sjlj_buffers.back();
+
+ // Remove the buffer.
+ th->sjlj_buffers.pop_back();
+
+ // We're going back to Java, remove the native address.
+ th->addresses.pop_back();
+
+ mvm::Allocator& allocator = th->getJVM()->gcAllocator;
+ allocator.freeTemporaryMemory(buf);
+
+ // If there's an exception, throw it now.
+ if (JavaThread::get()->pendingException) {
+ th->throwPendingException();
+ }
}
+// Never throws.
+extern "C" void* getSJLJBuffer() {
+ JavaThread* th = JavaThread::get();
+ mvm::Allocator& allocator = th->getJVM()->gcAllocator;
+ void** buf = (void**)allocator.allocateTemporaryMemory(sizeof(jmp_buf));
+ th->sjlj_buffers.push_back((jmp_buf*)buf);
+
+ // Start native because the next instruction after setjmp is a call to a
+ // native function.
+ th->startNative(1);
+
+ // Finally, return the buffer that the Java code will use to do the setjmp.
+ return (void*)buf;
+}
+
+// Never throws.
extern "C" void JavaObjectAquire(JavaObject* obj) {
obj->acquire();
}
+// Never throws.
extern "C" void JavaObjectRelease(JavaObject* obj) {
obj->release();
}
+// Never throws.
extern "C" bool instanceOf(JavaObject* obj, UserCommonClass* cl) {
return obj->instanceOf(cl);
}
+// Never throws.
extern "C" bool instantiationOfArray(UserCommonClass* cl1,
UserClassArray* cl2) {
return cl1->instantiationOfArray(cl2);
}
+// Never throws.
extern "C" bool implements(UserCommonClass* cl1, UserCommonClass* cl2) {
return cl1->implements(cl2);
}
+// Never throws.
extern "C" bool isAssignableFrom(UserCommonClass* cl1, UserCommonClass* cl2) {
return cl1->isAssignableFrom(cl2);
}
+// Never throws.
extern "C" void* JavaThreadGetException() {
return JavaThread::getException();
}
-extern "C" void JavaThreadThrowException(JavaObject* obj) {
- return JavaThread::throwException(obj);
-}
-
+// Never throws.
extern "C" JavaObject* JavaThreadGetJavaException() {
return JavaThread::getJavaException();
}
+// Does not call any Java code.
+extern "C" void JavaThreadThrowException(JavaObject* obj) {
+ return JavaThread::throwException(obj);
+}
+
+// Never throws.
extern "C" bool JavaThreadCompareException(UserClass* cl) {
return JavaThread::compareException(cl);
}
+// Never throws.
extern "C" void JavaThreadClearException() {
return JavaThread::clearException();
}
+// Never throws.
extern "C" void overflowThinLock(JavaObject* obj) {
obj->overflowThinLock();
}
+// Creates a Java object and then throws it.
+extern "C" void jnjvmNullPointerException() {
+
+ JavaObject *exc = 0;
+
+ BEGIN_NATIVE_EXCEPTION(1)
+
+ exc = JavaThread::get()->getJVM()->CreateNullPointerException();
+
+ END_NATIVE_EXCEPTION
+
+ JavaThread::throwException(exc);
+}
+
+// Creates a Java object and then throws it.
+extern "C" void negativeArraySizeException(sint32 val) {
+ JavaObject *exc = 0;
+
+ BEGIN_NATIVE_EXCEPTION(1)
+
+ exc = JavaThread::get()->getJVM()->CreateNegativeArraySizeException();
+
+ END_NATIVE_EXCEPTION
+
+ JavaThread::throwException(exc);
+}
+
+// Creates a Java object and then throws it.
+extern "C" void outOfMemoryError(sint32 val) {
+ JavaObject *exc = 0;
+
+ BEGIN_NATIVE_EXCEPTION(1)
+
+ exc = JavaThread::get()->getJVM()->CreateOutOfMemoryError();
+
+ END_NATIVE_EXCEPTION
+
+ JavaThread::throwException(exc);
+}
+
+// Creates a Java object and then throws it.
+extern "C" void jnjvmClassCastException(JavaObject* obj, UserCommonClass* cl) {
+ JavaObject *exc = 0;
+
+ BEGIN_NATIVE_EXCEPTION(1)
+
+ exc = JavaThread::get()->getJVM()->CreateClassCastException(obj, cl);
+
+ END_NATIVE_EXCEPTION
+
+ JavaThread::throwException(exc);
+}
+
+// Creates a Java object and then throws it.
+extern "C" void indexOutOfBoundsException(JavaObject* obj, sint32 index) {
+ JavaObject *exc = 0;
+
+ BEGIN_NATIVE_EXCEPTION(1)
+
+ exc = JavaThread::get()->getJVM()->CreateIndexOutOfBoundsException(index);
+
+ END_NATIVE_EXCEPTION
+
+ JavaThread::throwException(exc);
+}
+
+extern "C" void printMethodStart(JavaMethod* meth) {
+ printf("[%p] executing %s\n", (void*)mvm::Thread::get(),
+ meth->printString());
+ fflush(stdout);
+}
+
+extern "C" void printMethodEnd(JavaMethod* meth) {
+ printf("[%p] return from %s\n", (void*)mvm::Thread::get(),
+ meth->printString());
+ fflush(stdout);
+}
+
+extern "C" void printExecution(char* opcode, uint32 index, JavaMethod* meth) {
+ printf("[%p] executing %s %s at %d\n", (void*)mvm::Thread::get(),
+ meth->printString(), opcode, index);
+ fflush(stdout);
+}
+
#ifdef SERVICE
extern "C" void serviceCallStart(Jnjvm* OldService,
@@ -429,3 +523,65 @@
}
#endif
+
+#ifdef ISOLATE
+extern "C" void* stringLookup(UserClass* cl, uint32 index) {
+ UserConstantPool* ctpInfo = cl->getConstantPool();
+ const UTF8* utf8 = ctpInfo->UTF8AtForString(index);
+ JavaString* str = JavaThread::get()->getJVM()->internalUTF8ToStr(utf8);
+#ifdef ISOLATE_SHARING
+ ctpInfo->ctpRes[index] = str;
+#endif
+ return (void*)str;
+}
+
+#ifdef ISOLATE_SHARING
+extern "C" void* enveloppeLookup(UserClass* cl, uint32 index) {
+ UserConstantPool* ctpInfo = cl->getConstantPool();
+ mvm::Allocator* allocator = cl->classLoader->allocator;
+ Enveloppe* enveloppe = new(allocator) Enveloppe(ctpInfo, index);
+ ctpInfo->ctpRes[index] = enveloppe;
+ return (void*)enveloppe;
+}
+
+extern "C" void* staticCtpLookup(UserClass* cl, uint32 index) {
+ UserConstantPool* ctpInfo = cl->getConstantPool();
+ JavaConstantPool* shared = ctpInfo->getSharedPool();
+ uint32 clIndex = shared->getClassIndexFromMethod(index);
+ UserClass* refCl = (UserClass*)ctpInfo->loadClass(clIndex);
+ refCl->initialiseClass(JavaThread::get()->getJVM());
+
+ CommonClass* baseCl = 0;
+ const UTF8* utf8 = 0;
+ Signdef* sign = 0;
+
+ shared->resolveMethod(index, baseCl, utf8, sign);
+ UserClass* methodCl = 0;
+ refCl->lookupMethod(utf8, sign->keyName, true, true, &methodCl);
+ ctpInfo->ctpRes[index] = methodCl->getConstantPool();
+ shared->ctpRes[clIndex] = refCl->classDef;
+ return (void*)methodCl->getConstantPool();
+}
+
+extern "C" UserConstantPool* specialCtpLookup(UserConstantPool* ctpInfo,
+ uint32 index,
+ UserConstantPool** res) {
+ JavaConstantPool* shared = ctpInfo->getSharedPool();
+ uint32 clIndex = shared->getClassIndexFromMethod(index);
+ UserClass* refCl = (UserClass*)ctpInfo->loadClass(clIndex);
+
+ CommonClass* baseCl = 0;
+ const UTF8* utf8 = 0;
+ Signdef* sign = 0;
+
+ shared->resolveMethod(index, baseCl, utf8, sign);
+ UserClass* methodCl = 0;
+ refCl->lookupMethod(utf8, sign->keyName, false, true, &methodCl);
+ shared->ctpRes[clIndex] = refCl->classDef;
+ *res = methodCl->getConstantPool();
+ return methodCl->getConstantPool();
+}
+
+#endif
+
+#endif
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp Tue Dec 30 03:31:45 2008
@@ -76,3 +76,118 @@
th->internalPendingException = exc;
__cxa_throw(exc, 0, 0);
}
+
+void JavaThread::startNative(int level) {
+ // Call to this function.
+ void** cur = (void**)__builtin_frame_address(0);
+
+ // Caller (for native Classpath functions).
+ //if (level)
+ cur = (void**)cur[0];
+
+ // When entering, the number of addresses should be odd.
+ // Enable this when finalization gets proper support.
+ // assert((addresses.size() % 2) && "Wrong stack");
+
+ addresses.push_back(cur);
+}
+
+void JavaThread::startJava() {
+ // Call to this function.
+ void** cur = (void**)__builtin_frame_address(0);
+
+ // Caller in JavaMetaJIT.cpp
+ cur = (void**)cur[0];
+
+ addresses.push_back(cur);
+}
+
+UserClass* JavaThread::getCallingClass() {
+ // I'm a native function, so try to look at the last Java method.
+ // First Get the caller of this method.
+ void** addr = (void**)addresses.back();
+
+ // Get the caller of the Java getCallingClass method.
+ addr = (void**)addr[0];
+ void* ip = FRAME_IP(addr);
+
+ JavaMethod* meth = getJVM()->IPToJavaMethod(ip);
+
+ if (meth) return meth->classDef;
+ else return 0;
+}
+
+void JavaThread::getJavaFrameContext(std::vector<void*>& context) {
+ std::vector<void*>::iterator it = addresses.end();
+
+ // Loop until we cross the first Java frame.
+ while (it != addresses.begin()) {
+
+ // Get the last Java frame.
+ void** addr = (void**)*(--it);
+
+ // Set the iterator to the next native -> Java call.
+ --it;
+
+ do {
+ void* ip = FRAME_IP(addr);
+ context.push_back(ip);
+ addr = (void**)addr[0];
+ // End walking the stack when we cross a native -> Java call. Here
+ // the iterator points to a native -> Java call. We dereference addr twice
+ // because a native -> Java call always contains the signature function.
+ } while (((void***)addr)[0][0] != *it);
+ }
+}
+
+#include <dlfcn.h>
+
+static void printFunctionInfo(void* ip) {
+ Dl_info info;
+ int res = dladdr(ip, &info);
+ if (res != 0) {
+ fprintf(stderr, "; %p in %s\n", ip, info.dli_sname);
+ } else {
+ fprintf(stderr, "; %p in Native to Java Frame\n", ip);
+ }
+}
+
+void JavaThread::printBacktrace() {
+ std::vector<void*>::iterator it = addresses.end();
+ Jnjvm* vm = getJVM();
+
+ void** addr = (void**)__builtin_frame_address(0);
+
+ // Loop until we cross the first Java frame.
+ while (it != addresses.begin()) {
+
+ --it;
+ // Until we hit the last Java frame.
+ while (addr != (void**)*it) {
+ void* ip = FRAME_IP(addr);
+ printFunctionInfo(ip);
+ addr = (void**)addr[0];
+ }
+
+ // Set the iterator to the next native -> Java call.
+ --it;
+
+ do {
+ void* ip = FRAME_IP(addr);
+ JavaMethod* meth = vm->IPToJavaMethod(ip);
+ assert(meth && "Wrong stack");
+ fprintf(stderr, "; %p in %s\n", ip, meth->printString());
+ addr = (void**)addr[0];
+ // End walking the stack when we cross a native -> Java call. Here
+ // the iterator points to a native -> Java call. We dereference addr twice
+ // because a native -> Java call always contains the signature function.
+ } while (((void***)addr)[0][0] != *it);
+ }
+
+ while (addr < baseSP && addr < addr[0]) {
+ void* ip = FRAME_IP(addr);
+ printFunctionInfo(ip);
+ addr = (void**)addr[0];
+ }
+
+}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Tue Dec 30 03:31:45 2008
@@ -37,6 +37,7 @@
uint32 interruptFlag;
uint32 state;
std::vector<jmp_buf*> sjlj_buffers;
+ std::vector<void*> addresses;
static const unsigned int StateRunning;
static const unsigned int StateWaiting;
@@ -94,7 +95,7 @@
return JavaThread::get()->pendingException;
}
- void returnFromNative() {
+ void returnFromJNI() {
assert(sjlj_buffers.size());
#if defined(__MACH__)
longjmp((int*)sjlj_buffers.back(), 1);
@@ -102,6 +103,40 @@
longjmp((__jmp_buf_tag*)sjlj_buffers.back(), 1);
#endif
}
+
+ void returnFromNative() {
+ addresses.pop_back();
+ throwPendingException();
+ }
+
+ void returnFromJava() {
+ addresses.pop_back();
+ throwPendingException();
+ }
+
+ void startNative(int level);
+ void startJava();
+
+ void endNative() {
+ addresses.pop_back();
+ }
+
+ void endJava() {
+ addresses.pop_back();
+ }
+
+ /// getCallingClass - Get the Java method that called the last Java
+ /// method on the stack.
+ ///
+ UserClass* getCallingClass();
+
+ /// printBacktrace - Prints the backtrace of this thread.
+ ///
+ void printBacktrace();
+
+ /// getJavaFrameContext - Fill the vector with Java frames
+ /// currently on the stack.
+ void getJavaFrameContext(std::vector<void*>& context);
/// printString - Prints the class.
char *printString() const {
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Tue Dec 30 03:31:45 2008
@@ -45,26 +45,6 @@
extern "C" const struct JNIInvokeInterface_ JNI_JavaVMTable;
extern "C" struct JNINativeInterface_ JNI_JNIEnvTable;
-#define BEGIN_EXCEPTION \
- JavaObject* excp = 0; \
- try {
-
-#define END_EXCEPTION \
- } catch(...) { \
- excp = JavaThread::getJavaException(); \
- JavaThread::clearException(); \
- } \
- if (excp) { \
- JavaThread* th = JavaThread::get(); \
- th->pendingException = excp; \
- th->returnFromNative(); \
- }
-
-/*
-static void* ptr_jvm = (JavaVM) &JNI_JavaVMTable;
-static void *ptr_env = (void*) &JNI_JNIEnvTable;
-*/
-
jint GetVersion(JNIEnv *env) {
return JNI_VERSION_1_4;
}
@@ -79,11 +59,12 @@
jclass FindClass(JNIEnv *env, const char *asciiz) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JnjvmClassLoader* loader = 0;
- Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* currentClass = JavaJIT::getCallingClass();
+ JavaThread* th = JavaThread::get();
+ Jnjvm* vm = th->getJVM();
+ UserClass* currentClass = th->getCallingClass();
if (currentClass) loader = currentClass->classLoader;
else loader = vm->bootstrapLoader;
@@ -93,14 +74,14 @@
if (cl->asClass()) cl->asClass()->initialiseClass(vm);
return (jclass)(cl->getClassDelegatee(vm));
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jmethodID FromReflectedMethod(JNIEnv *env, jobject method) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = NativeUtil::myVM(env);
Classpath* upcalls = vm->upcalls;
@@ -115,7 +96,7 @@
meth->printString());
}
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -129,7 +110,7 @@
jboolean IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl2 = NativeUtil::resolvedImplClass(vm, sup, false);
@@ -137,7 +118,7 @@
return cl1->isAssignableFrom(cl2);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return false;
}
@@ -151,7 +132,7 @@
jint ThrowNew(JNIEnv* env, jclass clazz, const char *msg) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaThread* th = JavaThread::get();
Jnjvm* vm = th->getJVM();
@@ -164,10 +145,10 @@
false, true, 0);
init->invokeIntSpecial(vm, realCl, res, vm->asciizToStr(msg));
th->pendingException = res;
- th->returnFromNative();
+ th->returnFromJNI();
return 1;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -227,20 +208,20 @@
jobject AllocObject(JNIEnv *env, jclass clazz) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true);
if (cl->isArray()) JavaThread::get()->getJVM()->unknownError("implement me");
return (jobject)((UserClass*)cl)->doNew(JavaThread::get()->getJVM());
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jobject NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -252,7 +233,7 @@
va_end(ap);
return (jobject)res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -266,7 +247,7 @@
jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID,
const jvalue *args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaMethod* meth = (JavaMethod*)methodID;
@@ -275,20 +256,20 @@
meth->invokeIntSpecialBuf(vm, cl, res, (void*)args);
return (jobject)res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jclass GetObjectClass(JNIEnv *env, jobject obj) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
verifyNull((JavaObject*)obj);
Jnjvm* vm = JavaThread::get()->getJVM();
return (jclass)((JavaObject*)obj)->classOf->getClassDelegatee(vm);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -322,7 +303,7 @@
jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char *aname,
const char *atype) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true);
@@ -333,14 +314,14 @@
return (jmethodID)meth;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jobject CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -352,7 +333,7 @@
va_end(ap);
return (jobject)res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -360,7 +341,7 @@
jobject CallObjectMethodV(JNIEnv *env, jobject _obj, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaObject* obj = (JavaObject*)_obj;
JavaMethod* meth = (JavaMethod*)methodID;
@@ -368,7 +349,7 @@
UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf);
return (jobject)meth->invokeJavaObjectVirtualAP(vm, cl, obj, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -383,7 +364,7 @@
jboolean CallBooleanMethod(JNIEnv *env, jobject _obj, jmethodID methodID, ...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -395,7 +376,7 @@
va_end(ap);
return res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -403,7 +384,7 @@
jboolean CallBooleanMethodV(JNIEnv *env, jobject _obj, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaObject* obj = (JavaObject*)_obj;
JavaMethod* meth = (JavaMethod*)methodID;
@@ -411,7 +392,7 @@
UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf);
return (jboolean)meth->invokeIntVirtualAP(vm, cl, obj, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -432,7 +413,7 @@
jbyte CallByteMethodV(JNIEnv *env, jobject _obj, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaObject* obj = (JavaObject*)_obj;
JavaMethod* meth = (JavaMethod*)methodID;
@@ -440,7 +421,7 @@
UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf);
return (jbyte)meth->invokeIntVirtualAP(vm, cl, obj, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -462,7 +443,7 @@
jchar CallCharMethodV(JNIEnv *env, jobject _obj, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaObject* obj = (JavaObject*)_obj;
JavaMethod* meth = (JavaMethod*)methodID;
@@ -470,7 +451,7 @@
UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf);
return (jchar)meth->invokeIntVirtualAP(vm, cl, obj, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -492,7 +473,7 @@
jshort CallShortMethodV(JNIEnv *env, jobject _obj, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaObject* obj = (JavaObject*)_obj;
JavaMethod* meth = (JavaMethod*)methodID;
@@ -500,7 +481,7 @@
UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf);
return (jshort)meth->invokeIntVirtualAP(vm, cl, obj, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -516,7 +497,7 @@
jint CallIntMethod(JNIEnv *env, jobject _obj, jmethodID methodID, ...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -528,7 +509,7 @@
va_end(ap);
return res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -536,7 +517,7 @@
jint CallIntMethodV(JNIEnv *env, jobject _obj, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaObject* obj = (JavaObject*)_obj;
JavaMethod* meth = (JavaMethod*)methodID;
@@ -544,7 +525,7 @@
UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf);
return (jint)meth->invokeIntVirtualAP(vm, cl, obj, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -567,7 +548,7 @@
jlong CallLongMethodV(JNIEnv *env, jobject _obj, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaObject* obj = (JavaObject*)_obj;
JavaMethod* meth = (JavaMethod*)methodID;
@@ -575,7 +556,7 @@
UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf);
return (jlong)meth->invokeLongVirtualAP(vm, cl, obj, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -591,7 +572,7 @@
jfloat CallFloatMethod(JNIEnv *env, jobject _obj, jmethodID methodID, ...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -603,7 +584,7 @@
va_end(ap);
return res;
- END_EXCEPTION;
+ END_JNI_EXCEPTION;
return 0.0;
}
@@ -611,7 +592,7 @@
jfloat CallFloatMethodV(JNIEnv *env, jobject _obj, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaObject* obj = (JavaObject*)_obj;
JavaMethod* meth = (JavaMethod*)methodID;
@@ -619,7 +600,7 @@
UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf);
return (jfloat)meth->invokeFloatVirtualAP(vm, cl, obj, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0.0f;
}
@@ -635,7 +616,7 @@
jdouble CallDoubleMethod(JNIEnv *env, jobject _obj, jmethodID methodID, ...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -647,7 +628,7 @@
va_end(ap);
return res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0.0;
}
@@ -655,7 +636,7 @@
jdouble CallDoubleMethodV(JNIEnv *env, jobject _obj, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaObject* obj = (JavaObject*)_obj;
JavaMethod* meth = (JavaMethod*)methodID;
@@ -663,7 +644,7 @@
UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf);
return (jdouble)meth->invokeDoubleVirtualAP(vm, cl, obj, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0.0;
}
@@ -679,7 +660,7 @@
void CallVoidMethod(JNIEnv *env, jobject _obj, jmethodID methodID, ...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -690,14 +671,14 @@
meth->invokeIntVirtualAP(vm, cl, obj, ap);
va_end(ap);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void CallVoidMethodV(JNIEnv *env, jobject _obj, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaObject* obj = (JavaObject*)_obj;
JavaMethod* meth = (JavaMethod*)methodID;
@@ -705,7 +686,7 @@
UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf);
meth->invokeIntVirtualAP(vm, cl, obj, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
@@ -916,7 +897,7 @@
void CallNonvirtualVoidMethod(JNIEnv *env, jobject _obj, jclass clazz,
jmethodID methodID, ...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -927,7 +908,7 @@
meth->invokeIntSpecialAP(vm, cl, obj, ap);
va_end(ap);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
@@ -946,7 +927,7 @@
jfieldID GetFieldID(JNIEnv *env, jclass clazz, const char *name,
const char *sig) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true);
@@ -955,7 +936,7 @@
vm->asciizToUTF8(sig), 0, 1,
0) : 0);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -963,234 +944,234 @@
jobject GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
return (jobject)field->getObjectField(o);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jboolean GetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
return (uint8)field->getInt8Field(o);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jbyte GetByteField(JNIEnv *env, jobject obj, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
return (sint8)field->getInt8Field(o);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jchar GetCharField(JNIEnv *env, jobject obj, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
return (uint16)field->getInt16Field(o);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jshort GetShortField(JNIEnv *env, jobject obj, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
return (sint16)field->getInt16Field(o);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jint GetIntField(JNIEnv *env, jobject obj, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
return (sint32)field->getInt32Field(o);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jlong GetLongField(JNIEnv *env, jobject obj, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
return (sint64)field->getLongField(o);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jfloat GetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
return field->getFloatField(o);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jdouble GetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
return (jdouble)field->getDoubleField(o);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
void SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
field->setObjectField(o, (JavaObject*)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID,
jboolean value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
field->setInt8Field(o, (uint8)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetByteField(JNIEnv *env, jobject obj, jfieldID fieldID, jbyte value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
field->setInt8Field(o, (uint8)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetCharField(JNIEnv *env, jobject obj, jfieldID fieldID, jchar value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
field->setInt16Field(o, (uint16)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetShortField(JNIEnv *env, jobject obj, jfieldID fieldID, jshort value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
field->setInt16Field(o, (sint16)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetIntField(JNIEnv *env, jobject obj, jfieldID fieldID, jint value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
field->setInt32Field(o, (sint32)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetLongField(JNIEnv *env, jobject obj, jfieldID fieldID, jlong value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
field->setLongField(o, (sint64)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID, jfloat value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
field->setFloatField(o, (float)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID, jdouble value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
field->setDoubleField(o, (float)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
jmethodID GetStaticMethodID(JNIEnv *env, jclass clazz, const char *aname,
const char *atype) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true);
@@ -1201,7 +1182,7 @@
return (jmethodID)meth;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -1209,7 +1190,7 @@
jobject CallStaticObjectMethod(JNIEnv *env, jclass clazz, jmethodID methodID,
...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -1220,21 +1201,21 @@
va_end(ap);
return res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jobject CallStaticObjectMethodV(JNIEnv *env, jclass clazz, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaMethod* meth = (JavaMethod*)methodID;
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = getClassFromStaticMethod(vm, meth, clazz);
return (jobject)meth->invokeJavaObjectStaticAP(vm, cl, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -1249,7 +1230,7 @@
jboolean CallStaticBooleanMethod(JNIEnv *env, jclass clazz, jmethodID methodID,
...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -1260,7 +1241,7 @@
va_end(ap);
return res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -1268,14 +1249,14 @@
jboolean CallStaticBooleanMethodV(JNIEnv *env, jclass clazz, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaMethod* meth = (JavaMethod*)methodID;
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = getClassFromStaticMethod(vm, meth, clazz);
return (jboolean)meth->invokeIntStaticAP(vm, cl, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -1289,7 +1270,7 @@
jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -1300,7 +1281,7 @@
va_end(ap);
return res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -1308,14 +1289,14 @@
jbyte CallStaticByteMethodV(JNIEnv *env, jclass clazz, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaMethod* meth = (JavaMethod*)methodID;
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = getClassFromStaticMethod(vm, meth, clazz);
return (jbyte)meth->invokeIntStaticAP(vm, cl, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -1329,7 +1310,7 @@
jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -1340,21 +1321,21 @@
va_end(ap);
return res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jchar CallStaticCharMethodV(JNIEnv *env, jclass clazz, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaMethod* meth = (JavaMethod*)methodID;
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = getClassFromStaticMethod(vm, meth, clazz);
return (jchar)meth->invokeIntStaticAP(vm, cl, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -1369,7 +1350,7 @@
jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID,
...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -1380,7 +1361,7 @@
va_end(ap);
return res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -1388,14 +1369,14 @@
jshort CallStaticShortMethodV(JNIEnv *env, jclass clazz, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaMethod* meth = (JavaMethod*)methodID;
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = getClassFromStaticMethod(vm, meth, clazz);
return (jshort)meth->invokeIntStaticAP(vm, cl, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -1409,7 +1390,7 @@
jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -1420,21 +1401,21 @@
va_end(ap);
return res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jint CallStaticIntMethodV(JNIEnv *env, jclass clazz, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaMethod* meth = (JavaMethod*)methodID;
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = getClassFromStaticMethod(vm, meth, clazz);
return (jint)meth->invokeIntStaticAP(vm, cl, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -1449,7 +1430,7 @@
jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -1460,7 +1441,7 @@
va_end(ap);
return res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -1468,14 +1449,14 @@
jlong CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaMethod* meth = (JavaMethod*)methodID;
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = getClassFromStaticMethod(vm, meth, clazz);
return (jlong)meth->invokeLongStaticAP(vm, cl, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -1492,7 +1473,7 @@
jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID,
...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -1503,7 +1484,7 @@
va_end(ap);
return res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0.0f;
}
@@ -1511,14 +1492,14 @@
jfloat CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaMethod* meth = (JavaMethod*)methodID;
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = getClassFromStaticMethod(vm, meth, clazz);
return (jfloat)meth->invokeFloatStaticAP(vm, cl, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0.0f;
}
@@ -1534,7 +1515,7 @@
jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID,
...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -1545,21 +1526,21 @@
va_end(ap);
return res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0.0;
}
jdouble CallStaticDoubleMethodV(JNIEnv *env, jclass clazz, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaMethod* meth = (JavaMethod*)methodID;
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = getClassFromStaticMethod(vm, meth, clazz);
return (jdouble)meth->invokeDoubleStaticAP(vm, cl, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0.0;
}
@@ -1574,7 +1555,7 @@
void CallStaticVoidMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
va_list ap;
va_start(ap, methodID);
@@ -1584,21 +1565,21 @@
meth->invokeIntStaticAP(vm, cl, ap);
va_end(ap);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void CallStaticVoidMethodV(JNIEnv *env, jclass clazz, jmethodID methodID,
va_list args) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaMethod* meth = (JavaMethod*)methodID;
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = getClassFromStaticMethod(vm, meth, clazz);
meth->invokeIntStaticAP(vm, cl, args);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
@@ -1611,7 +1592,7 @@
jfieldID GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name,
const char *sig) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true);
@@ -1620,14 +1601,14 @@
vm->asciizToUTF8(sig),
true, true, 0) : 0);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jobject GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1635,14 +1616,14 @@
void* Stat = cl->getStaticInstance();
return (jobject)field->getObjectField(Stat);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jboolean GetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1650,14 +1631,14 @@
void* Stat = cl->getStaticInstance();
return (jboolean)field->getInt8Field(Stat);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jbyte GetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1665,14 +1646,14 @@
void* Stat = cl->getStaticInstance();
return (jbyte)field->getInt8Field(Stat);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jchar GetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1680,14 +1661,14 @@
void* Stat = cl->getStaticInstance();
return (jchar)field->getInt16Field(Stat);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jshort GetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1695,14 +1676,14 @@
void* Stat = cl->getStaticInstance();
return (jshort)field->getInt16Field(Stat);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jint GetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1710,14 +1691,14 @@
void* Stat = cl->getStaticInstance();
return (jint)field->getInt32Field(Stat);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jlong GetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1725,14 +1706,14 @@
void* Stat = cl->getStaticInstance();
return (jlong)field->getLongField(Stat);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jfloat GetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1740,14 +1721,14 @@
void* Stat = cl->getStaticInstance();
return (jfloat)field->getFloatField(Stat);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jdouble GetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1755,7 +1736,7 @@
void* Stat = cl->getStaticInstance();
return (jdouble)field->getDoubleField(Stat);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -1763,7 +1744,7 @@
void SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID,
jobject value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1771,14 +1752,14 @@
void* Stat = cl->getStaticInstance();
field->setObjectField(Stat, (JavaObject*)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID,
jboolean value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1786,14 +1767,14 @@
void* Stat = cl->getStaticInstance();
field->setInt8Field(Stat, (uint8)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID,
jbyte value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1801,14 +1782,14 @@
void* Stat = cl->getStaticInstance();
field->setInt8Field(Stat, (sint8)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID,
jchar value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1816,14 +1797,14 @@
void* Stat = cl->getStaticInstance();
field->setInt16Field(Stat, (uint16)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID,
jshort value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1831,14 +1812,14 @@
void* Stat = cl->getStaticInstance();
field->setInt16Field(Stat, (sint16)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID,
jint value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1846,14 +1827,14 @@
void* Stat = cl->getStaticInstance();
field->setInt32Field(Stat, (sint32)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID,
jlong value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1861,14 +1842,14 @@
void* Stat = cl->getStaticInstance();
field->setLongField(Stat, (sint64)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID,
jfloat value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1876,14 +1857,14 @@
void* Stat = cl->getStaticInstance();
field->setFloatField(Stat, (float)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
void SetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID,
jdouble value) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = (JavaField*)fieldID;
@@ -1891,7 +1872,7 @@
void* Stat = cl->getStaticInstance();
field->setDoubleField(Stat, (double)value);
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
@@ -1920,12 +1901,12 @@
jstring NewStringUTF(JNIEnv *env, const char *bytes) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = NativeUtil::myVM(env);
return (jstring)(vm->asciizToStr(bytes));
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -1938,12 +1919,12 @@
const char *GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
if (isCopy != 0) (*isCopy) = true;
return strdup(((JavaString*)string)->strToAsciiz());
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -1955,18 +1936,18 @@
jsize GetArrayLength(JNIEnv *env, jarray array) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
return ((JavaArray*)array)->size;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jobjectArray NewObjectArray(JNIEnv *env, jsize length, jclass elementClass,
jobject initialElement) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = NativeUtil::myVM(env);
if (length < 0) vm->negativeArraySizeException(length);
@@ -1982,20 +1963,20 @@
}
}
return (jobjectArray)res;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jobject GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
ArrayObject* JA = (ArrayObject*)array;
if (index >= JA->size)
JavaThread::get()->getJVM()->indexOutOfBounds(JA, index);
return (jobject)JA->elements[index];
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -2004,109 +1985,109 @@
void SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index,
jobject val) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
ArrayObject* JA = (ArrayObject*)array;
if (index >= JA->size)
JavaThread::get()->getJVM()->indexOutOfBounds(JA, index);
JA->elements[index] = (JavaObject*)val;
- END_EXCEPTION
+ END_JNI_EXCEPTION
}
jbooleanArray NewBooleanArray(JNIEnv *env, jsize len) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = NativeUtil::myVM(env);
return (jbooleanArray)vm->upcalls->ArrayOfByte->doNew(len, vm);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jbyteArray NewByteArray(JNIEnv *env, jsize len) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = NativeUtil::myVM(env);
return (jbyteArray)vm->upcalls->ArrayOfByte->doNew(len, vm);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jcharArray NewCharArray(JNIEnv *env, jsize len) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = NativeUtil::myVM(env);
return (jcharArray)vm->upcalls->ArrayOfChar->doNew(len, vm);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jshortArray NewShortArray(JNIEnv *env, jsize len) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = NativeUtil::myVM(env);
return (jshortArray)vm->upcalls->ArrayOfShort->doNew(len, vm);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jintArray NewIntArray(JNIEnv *env, jsize len) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = NativeUtil::myVM(env);
return (jintArray)vm->upcalls->ArrayOfInt->doNew(len, vm);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jlongArray NewLongArray(JNIEnv *env, jsize len) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = NativeUtil::myVM(env);
return (jlongArray)vm->upcalls->ArrayOfLong->doNew(len, vm);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jfloatArray NewFloatArray(JNIEnv *env, jsize len) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = NativeUtil::myVM(env);
return (jfloatArray)vm->upcalls->ArrayOfFloat->doNew(len, vm);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jdoubleArray NewDoubleArray(JNIEnv *env, jsize len) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = NativeUtil::myVM(env);
return (jdoubleArray)vm->upcalls->ArrayOfDouble->doNew(len, vm);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -2114,36 +2095,36 @@
jboolean *GetBooleanArrayElements(JNIEnv *env, jbooleanArray array,
jboolean *isCopy) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
if (isCopy) (*isCopy) = false;
return (jboolean*)((ArrayUInt8*)array)->elements;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jbyte *GetByteArrayElements(JNIEnv *env, jbyteArray array, jboolean *isCopy) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
if (isCopy) (*isCopy) = false;
return ((ArraySInt8*)array)->elements;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jchar *GetCharArrayElements(JNIEnv *env, jcharArray array, jboolean *isCopy) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
if (isCopy) (*isCopy) = false;
return ((ArrayUInt16*)array)->elements;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -2151,36 +2132,36 @@
jshort *GetShortArrayElements(JNIEnv *env, jshortArray array,
jboolean *isCopy) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
if (isCopy) (*isCopy) = false;
return ((ArraySInt16*)array)->elements;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jint *GetIntArrayElements(JNIEnv *env, jintArray array, jboolean *isCopy) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
if (isCopy) (*isCopy) = false;
return ((ArraySInt32*)array)->elements;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jlong *GetLongArrayElements(JNIEnv *env, jlongArray array, jboolean *isCopy) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
if (isCopy) (*isCopy) = false;
return (jlong*)(void*)(((ArrayLong*)array)->elements);
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -2188,12 +2169,12 @@
jfloat *GetFloatArrayElements(JNIEnv *env, jfloatArray array,
jboolean *isCopy) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
if (isCopy) (*isCopy) = false;
return ((ArrayFloat*)array)->elements;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -2201,12 +2182,12 @@
jdouble *GetDoubleArrayElements(JNIEnv *env, jdoubleArray array,
jboolean *isCopy) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
if (isCopy) (*isCopy) = false;
return ((ArrayDouble*)array)->elements;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -2377,34 +2358,34 @@
jint MonitorEnter(JNIEnv *env, jobject obj) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
((JavaObject*)obj)->acquire();
return 1;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jint MonitorExit(JNIEnv *env, jobject obj) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
((JavaObject*)obj)->release();
return 1;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
jint GetJavaVM(JNIEnv *env, JavaVM **vm) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* myvm = JavaThread::get()->getJVM();
(*vm) = (JavaVM*)(void*)(&(myvm->javavmEnv));
return 0;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -2422,12 +2403,12 @@
void *GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
if (isCopy) (*isCopy) = false;
return ((JavaArray*)array)->elements;
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -2497,7 +2478,7 @@
void *GetDirectBufferAddress(JNIEnv *env, jobject _buf) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
Jnjvm* vm = NativeUtil::myVM(env);
JavaObject* buf = (JavaObject*)_buf;
@@ -2509,7 +2490,7 @@
return 0;
}
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
@@ -2546,7 +2527,7 @@
jint GetEnv(JavaVM *vm, void **env, jint version) {
- BEGIN_EXCEPTION
+ BEGIN_JNI_EXCEPTION
JavaObject* th = JavaThread::currentThread();
Jnjvm* myvm = JavaThread::get()->getJVM();
@@ -2558,7 +2539,7 @@
return JNI_EDETACHED;
}
- END_EXCEPTION
+ END_JNI_EXCEPTION
return 0;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Tue Dec 30 03:31:45 2008
@@ -47,9 +47,6 @@
#endif
-typedef void (*clinit_t)(UserConstantPool*);
-
-
/// initialiseClass - Java class initialisation. Java specification §2.17.5.
void UserClass::initialiseClass(Jnjvm* vm) {
@@ -197,8 +194,7 @@
JavaObject* exc = 0;
if (meth) {
try{
- clinit_t pred = (clinit_t)(intptr_t)meth->compiledPtr();
- pred(cl->getConstantPool());
+ meth->invokeIntStatic(vm, cl);
} catch(...) {
exc = JavaThread::getJavaException();
assert(exc && "no exception?");
@@ -262,6 +258,13 @@
JavaThread::throwException(obj);
}
+JavaObject* Jnjvm::CreateError(UserClass* cl, JavaMethod* init,
+ const char* str) {
+ JavaObject* obj = cl->doNew(this);
+ init->invokeIntSpecial(this, cl, obj, str ? asciizToStr(str) : 0);
+ return obj;
+}
+
void Jnjvm::error(UserClass* cl, JavaMethod* init, const char* fmt, ...) {
char* tmp = (char*)alloca(4096);
va_list ap;
@@ -270,8 +273,7 @@
va_end(ap);
if (cl && !bootstrapLoader->getModule()->isStaticCompiling()) {
- JavaObject* obj = cl->doNew(this);
- init->invokeIntSpecial(this, cl, obj, asciizToStr(tmp));
+ JavaObject* obj = CreateError(cl, init, tmp);
JavaThread::throwException(obj);
} else {
throw std::string(tmp);
@@ -302,6 +304,37 @@
upcalls->InitNullPointerException, fmt, val);
}
+JavaObject* Jnjvm::CreateIndexOutOfBoundsException(sint32 entry) {
+
+ char* tmp = (char*)alloca(4096);
+ snprintf(tmp, 4096, "%d", entry);
+
+ return CreateError(upcalls->ArrayIndexOutOfBoundsException,
+ upcalls->InitArrayIndexOutOfBoundsException, tmp);
+}
+
+JavaObject* Jnjvm::CreateNegativeArraySizeException() {
+ return CreateError(upcalls->NegativeArraySizeException,
+ upcalls->InitNegativeArraySizeException, 0);
+}
+
+JavaObject* Jnjvm::CreateNullPointerException() {
+ return CreateError(upcalls->NullPointerException,
+ upcalls->InitNullPointerException, 0);
+}
+
+JavaObject* Jnjvm::CreateOutOfMemoryError() {
+ return CreateError(upcalls->OutOfMemoryError,
+ upcalls->InitOutOfMemoryError,
+ "Java heap space");
+}
+
+JavaObject* Jnjvm::CreateClassCastException(JavaObject* obj,
+ UserCommonClass* cl) {
+ return CreateError(upcalls->ClassCastException,
+ upcalls->InitClassCastException, "");
+}
+
void Jnjvm::illegalAccessException(const char* msg) {
error(upcalls->IllegalAccessException,
upcalls->InitIllegalAccessException, msg);
@@ -846,9 +879,17 @@
}
void Jnjvm::executeClass(const char* className, ArrayObject* args) {
+ const UTF8* name = appClassLoader->asciizConstructUTF8(className);
+ UserClass* cl = (UserClass*)appClassLoader->loadName(name, true, true);
+ cl->initialiseClass(this);
+
+ const UTF8* funcSign =
+ appClassLoader->asciizConstructUTF8("([Ljava/lang/String;)V");
+ const UTF8* funcName = appClassLoader->asciizConstructUTF8("main");
+ JavaMethod* method = cl->lookupMethod(funcName, funcSign, true, true, 0);
+
try {
- JavaJIT::invokeOnceVoid(this, appClassLoader, className, "main",
- "([Ljava/lang/String;)V", ACC_STATIC, args);
+ method->invokeIntStatic(this, method->classDef, args);
}catch(...) {
}
@@ -870,9 +911,16 @@
void Jnjvm::executePremain(const char* className, JavaString* args,
JavaObject* instrumenter) {
- JavaJIT::invokeOnceVoid(this, appClassLoader, className, "premain",
- "(Ljava/lang/String;Ljava/lang/instrument/Instrumentation;)V",
- ACC_STATIC, args, instrumenter);
+ const UTF8* name = appClassLoader->asciizConstructUTF8(className);
+ UserClass* cl = (UserClass*)appClassLoader->loadName(name, true, true);
+ cl->initialiseClass(this);
+
+ const UTF8* funcSign = appClassLoader->asciizConstructUTF8(
+ "(Ljava/lang/String;Ljava/lang/instrument/Instrumentation;)V");
+ const UTF8* funcName = appClassLoader->asciizConstructUTF8("premain");
+ JavaMethod* method = cl->lookupMethod(funcName, funcSign, true, true, 0);
+
+ method->invokeIntStatic(this, method->classDef, args, instrumenter);
}
void Jnjvm::waitForExit() {
@@ -1147,3 +1195,41 @@
bootstrapThread = new JavaThread(0, 0, this);
bootstrapThread->start((void (*)(mvm::Thread*))mainCompilerStart);
}
+
+
+
+void Jnjvm::addMethodInFunctionMap(JavaMethod* meth, void* addr) {
+ FunctionMapLock.acquire();
+ JavaFunctionMap.insert(std::make_pair(addr, meth));
+ FunctionMapLock.release();
+}
+
+void Jnjvm::removeMethodsInFunctionMap(JnjvmClassLoader* loader) {
+ // Loop over all methods in the map to find which ones belong
+ // to this class loader.
+ FunctionMapLock.acquire();
+ std::map<void*, JavaMethod*>::iterator temp;
+ for (std::map<void*, JavaMethod*>::iterator i = JavaFunctionMap.begin(),
+ e = JavaFunctionMap.end(); i != e;) {
+ if (i->second->classDef->classLoader == loader) {
+ temp = i;
+ ++i;
+ JavaFunctionMap.erase(temp);
+ } else {
+ ++i;
+ }
+ }
+ FunctionMapLock.release();
+}
+
+JavaMethod* Jnjvm::IPToJavaMethod(void* Addr) {
+ FunctionMapLock.acquire();
+ std::map<void*, JavaMethod*>::iterator I = JavaFunctionMap.upper_bound(Addr);
+ assert(I != JavaFunctionMap.begin() && "Wrong value in function map");
+ FunctionMapLock.release();
+
+ // Decrement because we had the "greater than" value.
+ I--;
+ return I->second;
+
+}
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Tue Dec 30 03:31:45 2008
@@ -115,6 +115,11 @@
/// bootstrapThread - The initial thread of this JVM.
///
JavaThread* bootstrapThread;
+
+ /// CreateError - Creates a Java object of the specified exception class
+ /// and calling its <init> function.
+ ///
+ JavaObject* CreateError(UserClass* cl, JavaMethod* meth, const char* str);
/// error - Throws an exception in the execution of a JVM for the thread
/// that calls this functions. This is used internally by Jnjvm to control
@@ -240,6 +245,16 @@
StringMap hashStr;
public:
+
+ /// CreateExceptions - These are the runtime exceptions thrown by Java code
+ /// compiled by VMKit.
+ ///
+ JavaObject* CreateNullPointerException();
+ JavaObject* CreateOutOfMemoryError();
+ JavaObject* CreateIndexOutOfBoundsException(sint32 entry);
+ JavaObject* CreateNegativeArraySizeException();
+ JavaObject* CreateClassCastException(JavaObject* obj, UserCommonClass* cl);
+
/// Exceptions - These are the only exceptions VMKit will make.
///
void arrayStoreException();
@@ -326,6 +341,32 @@
/// waitForExit - Waits that there are no more non-daemon threads in this JVM.
///
virtual void waitForExit();
+
+private:
+
+ /// JavaFunctionMap - Map of Java method to function pointers. This map is
+ /// used when walking the stack so that VMKit knows which Java method is
+ /// executing on the stack.
+ ///
+ std::map<void*, JavaMethod*> JavaFunctionMap;
+
+ /// FunctionMapLock - Spin lock to protect the JavaFunctionMap.
+ ///
+ mvm::SpinLock FunctionMapLock;
+
+public:
+ /// addMethodInFunctionMap - A new method pointer in the function map.
+ ///
+ void addMethodInFunctionMap(JavaMethod* meth, void* addr);
+
+ /// removeMethodsInFunctionMap - Removes all methods compiled by this
+ /// class loader from the function map.
+ ///
+ void removeMethodsInFunctionMap(JnjvmClassLoader* loader);
+
+ /// IPToJavaMethod - Map an instruction pointer to the Java method.
+ ///
+ JavaMethod* IPToJavaMethod(void* ip);
#ifdef ISOLATE
static Jnjvm* RunningIsolates[NR_ISOLATES];
@@ -336,6 +377,7 @@
virtual void stopService();
#endif
+
};
} // end namespace jnjvm
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Tue Dec 30 03:31:45 2008
@@ -736,6 +736,9 @@
JnjvmClassLoader::~JnjvmClassLoader() {
+ if (isolate)
+ isolate->removeMethodsInFunctionMap(this);
+
if (classes) {
classes->~ClassMap();
allocator.Deallocate(classes);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Tue Dec 30 03:31:45 2008
@@ -1627,6 +1627,7 @@
virtualBufFunction = createFunctionCallBuf(true);
signature->setVirtualCallBuf((intptr_t)
mvm::MvmModule::executionEngine->getPointerToGlobal(virtualBufFunction));
+ // Now that it's compiled, we don't need the IR anymore
virtualBufFunction->deleteBody();
}
return virtualBufFunction;
@@ -1639,6 +1640,7 @@
virtualAPFunction = createFunctionCallAP(true);
signature->setVirtualCallAP((intptr_t)
mvm::MvmModule::executionEngine->getPointerToGlobal(virtualAPFunction));
+ // Now that it's compiled, we don't need the IR anymore
virtualAPFunction->deleteBody();
}
return virtualAPFunction;
@@ -1651,6 +1653,7 @@
staticBufFunction = createFunctionCallBuf(false);
signature->setStaticCallBuf((intptr_t)
mvm::MvmModule::executionEngine->getPointerToGlobal(staticBufFunction));
+ // Now that it's compiled, we don't need the IR anymore
staticBufFunction->deleteBody();
}
return staticBufFunction;
@@ -1663,6 +1666,7 @@
staticAPFunction = createFunctionCallAP(false);
signature->setStaticCallAP((intptr_t)
mvm::MvmModule::executionEngine->getPointerToGlobal(staticAPFunction));
+ // Now that it's compiled, we don't need the IR anymore
staticAPFunction->deleteBody();
}
return staticAPFunction;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Tue Dec 30 03:31:45 2008
@@ -78,6 +78,8 @@
}
void* val = meth->compiledPtr();
+
+
if (F->isDeclaration())
mvm::MvmModule::executionEngine->updateGlobalMapping(F, val);
@@ -106,6 +108,9 @@
void* res = mvm::MvmModule::executionEngine->getPointerToGlobal(func);
func->deleteBody();
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ vm->addMethodInFunctionMap(meth, res);
return res;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h Tue Dec 30 03:31:45 2008
@@ -24,6 +24,38 @@
class Typedef;
+#define BEGIN_NATIVE_EXCEPTION(level) \
+ JavaObject* excp = 0; \
+ JavaThread* __th = JavaThread::get(); \
+ __th->startNative(level); \
+ try {
+
+#define END_NATIVE_EXCEPTION \
+ } catch(...) { \
+ excp = JavaThread::getJavaException(); \
+ JavaThread::clearException(); \
+ } \
+ if (excp) { \
+ __th->pendingException = excp; \
+ __th->returnFromNative(); \
+ } \
+ __th->endNative();
+
+#define BEGIN_JNI_EXCEPTION \
+ JavaObject* excp = 0; \
+ try {
+
+#define END_JNI_EXCEPTION \
+ } catch(...) { \
+ excp = JavaThread::getJavaException(); \
+ JavaThread::clearException(); \
+ } \
+ if (excp) { \
+ JavaThread* th = JavaThread::get(); \
+ th->pendingException = excp; \
+ th->returnFromJNI(); \
+ }
+
class NativeUtil {
public:
Modified: vmkit/trunk/lib/Mvm/Runtime/JIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/JIT.cpp?rev=61487&r1=61486&r2=61487&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Runtime/JIT.cpp (original)
+++ vmkit/trunk/lib/Mvm/Runtime/JIT.cpp Tue Dec 30 03:31:45 2008
@@ -266,12 +266,6 @@
pm->run(*func);
}
-#if defined(__MACH__) && !defined(__i386__)
-#define FRAME_IP(fp) (fp[2])
-#else
-#define FRAME_IP(fp) (fp[1])
-#endif
-
int MvmModule::getBacktrace(void** stack, int size) {
void** addr = (void**)__builtin_frame_address(0);
int cpt = 0;
More information about the vmkit-commits
mailing list