[vmkit-commits] [vmkit] r76430 - in /vmkit/trunk: include/mvm/ lib/JnJVM/Classpath/
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Mon Jul 20 10:07:01 PDT 2009
Author: geoffray
Date: Mon Jul 20 12:07:01 2009
New Revision: 76430
URL: http://llvm.org/viewvc/llvm-project?rev=76430&view=rev
Log:
Add llvm.gcroot intrinsic to references on stack.
Modified:
vmkit/trunk/include/mvm/Allocator.h
vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.inc
vmkit/trunk/lib/JnJVM/Classpath/JavaUpcalls.cpp
Modified: vmkit/trunk/include/mvm/Allocator.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Allocator.h?rev=76430&r1=76429&r2=76430&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/Allocator.h (original)
+++ vmkit/trunk/include/mvm/Allocator.h Mon Jul 20 12:07:01 2009
@@ -20,8 +20,13 @@
class VirtualTable;
-namespace mvm {
+#ifdef LLVM_GCC
+extern "C" void llvm_gcroot(const void*, void*) asm("llvm.gcroot");
+#else
+#define llvm_gcroot
+#endif
+namespace mvm {
class Allocator {
public:
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.inc?rev=76430&r1=76429&r2=76430&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.inc Mon Jul 20 12:07:01 2009
@@ -31,7 +31,10 @@
#endif
JavaObjectConstructor* cons) {
- jobject res = 0;
+ JavaObject* res = 0;
+
+ llvm_gcroot(cons, 0);
+ llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
@@ -40,10 +43,10 @@
JavaMethod* meth = cons->getInternalMethod();
JnjvmClassLoader* loader = cl->classLoader;
- res = (jobject)meth->getParameterTypes(loader);
+ res = meth->getParameterTypes(loader);
END_NATIVE_EXCEPTION
- return res;
+ return (jobject)res;
}
JNIEXPORT jint JNICALL Java_java_lang_reflect_Constructor_getModifiersInternal(
@@ -52,6 +55,7 @@
#endif
JavaObjectConstructor* cons) {
+ llvm_gcroot(cons, 0);
jint res = 0;
BEGIN_NATIVE_EXCEPTION(0)
@@ -65,17 +69,26 @@
return res;
}
-static jobject proceedConstructor(JavaObjectConstructor* cons, jobject _args,
- jclass Clazz, jint index)
+static JavaObject* proceedConstructor(JavaObjectConstructor* cons,
+ JavaArray* args,
+ JavaObject* Clazz, jint index)
__attribute__ ((noinline));
-static jobject proceedConstructor(JavaObjectConstructor* cons, jobject _args,
- jclass Clazz, jint index) {
- jobject res = 0;
+static JavaObject* proceedConstructor(JavaObjectConstructor* cons,
+ JavaArray* args,
+ JavaObject* Clazz, jint index) {
+ JavaObject* res = 0;
+ JavaObject* excp = 0;
+
+ llvm_gcroot(cons, 0);
+ llvm_gcroot(args, 0);
+ llvm_gcroot(Clazz, 0);
+ llvm_gcroot(res, 0);
+ llvm_gcroot(excp, 0);
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaMethod* meth = cons->getInternalMethod();
UserClass* cl = cons->getClass();
- JavaArray* args = (JavaArray*)_args;
sint32 nbArgs = args ? args->size : 0;
Signdef* sign = meth->getSignature();
sint32 size = sign->nbArguments;
@@ -90,13 +103,11 @@
// Do it after alloca
if (nbArgs == size) {
- UserCommonClass* _cl =
- UserCommonClass::resolvedImplClass(vm, (JavaObject*)Clazz, false);
+ UserCommonClass* _cl = UserCommonClass::resolvedImplClass(vm, Clazz, false);
UserClass* cl = _cl->asClass();
if (cl) {
cl->initialiseClass(vm);
- JavaObject* obj = cl->doNew(vm);
- res = (jobject) obj;
+ res = cl->doNew(vm);
JavaObject** ptr = (JavaObject**)(void*)(args->elements);
Typedef* const* arguments = sign->getArgumentsType();
@@ -105,10 +116,9 @@
ptr[i]->decapsulePrimitive(vm, buf, arguments[i]);
}
- JavaObject* excp = 0;
JavaThread* th = JavaThread::get();
try {
- meth->invokeIntSpecialBuf(vm, cl, obj, startBuf);
+ meth->invokeIntSpecialBuf(vm, cl, res, startBuf);
} catch(...) {
excp = th->getJavaException();
if (excp->getClass()->isAssignableFrom(vm->upcalls->newException)) {
@@ -132,18 +142,23 @@
return res;
}
-JNIEXPORT jobject JNICALL Java_java_lang_reflect_Constructor_constructNative(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Constructor_constructNative(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectConstructor* cons, jobject _args, jclass Clazz, jint index) {
+JavaObjectConstructor* cons, JavaArray* args, JavaObject* Clazz, jint index) {
- jobject res = 0;
+ JavaObject* res = 0;
+
+ llvm_gcroot(res, 0);
+ llvm_gcroot(cons, 0);
+ llvm_gcroot(args, 0);
+ llvm_gcroot(Clazz, 0);
BEGIN_NATIVE_EXCEPTION(0)
// Proceed in another function because we are using alloca.
- res = proceedConstructor(cons, _args, Clazz, index);
+ res = proceedConstructor(cons, args, Clazz, index);
END_NATIVE_EXCEPTION
@@ -151,13 +166,16 @@
}
JNIEXPORT
-jobjectArray JNICALL Java_java_lang_reflect_Constructor_getExceptionTypes(
+ArrayObject* JNICALL Java_java_lang_reflect_Constructor_getExceptionTypes(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
JavaObjectConstructor* cons) {
- jobjectArray res = 0;
+ ArrayObject* res = 0;
+
+ llvm_gcroot(res, 0);
+ llvm_gcroot(cons, 0);
BEGIN_NATIVE_EXCEPTION(0)
@@ -166,27 +184,30 @@
JavaMethod* meth = cons->getInternalMethod();
JnjvmClassLoader* loader = cl->classLoader;
- res = (jobjectArray)meth->getExceptionTypes(loader);
+ res = (ArrayObject*)meth->getExceptionTypes(loader);
END_NATIVE_EXCEPTION
return res;
}
-JNIEXPORT jobject JNICALL Java_java_lang_reflect_Constructor_getSignature(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Constructor_getSignature(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
JavaObjectConstructor* Meth) {
- jobject result = 0;
+ JavaObject* result = 0;
+
+ llvm_gcroot(result, 0);
+ llvm_gcroot(Meth, 0);
BEGIN_NATIVE_EXCEPTION(0)
verifyNull(Meth);
JavaMethod* meth = Meth->getInternalMethod();
Jnjvm* vm = JavaThread::get()->getJVM();
- result = (jobject)(vm->internalUTF8ToStr(meth->type));
+ result = vm->internalUTF8ToStr(meth->type);
END_NATIVE_EXCEPTION
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.inc?rev=76430&r1=76429&r2=76430&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.inc Mon Jul 20 12:07:01 2009
@@ -27,6 +27,8 @@
JavaObjectField* Field) {
jint res = 0;
+ llvm_gcroot(Field, 0);
+
BEGIN_NATIVE_EXCEPTION(0)
JavaField* field = Field->getInternalField();
@@ -37,13 +39,16 @@
return res;
}
-JNIEXPORT jclass JNICALL Java_java_lang_reflect_Field_getType(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Field_getType(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
JavaObjectField* Field) {
- jclass res = 0;
+ JavaObject* res = 0;
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
@@ -52,7 +57,7 @@
JavaField* field = Field->getInternalField();
JnjvmClassLoader* loader = cl->classLoader;
UserCommonClass* fieldCl = field->getSignature()->assocClass(loader);
- res = (jclass)fieldCl->getClassDelegatee(vm);
+ res = fieldCl->getClassDelegatee(vm);
END_NATIVE_EXCEPTION
@@ -63,37 +68,40 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj) {
+JavaObjectField* Field, JavaObject* obj) {
jint res = 0;
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
const Typedef* type = field->getSignature();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isInt())
- res = (sint32)field->getInt32Field(Obj);
+ res = (sint32)field->getInt32Field(stat ? StatPtr : obj);
else if (prim->isChar())
- res = (uint32)field->getInt16Field(Obj);
+ res = (uint32)field->getInt16Field(stat ? StatPtr : obj);
else if (prim->isByte())
- res = (sint32)field->getInt8Field(Obj);
+ res = (sint32)field->getInt8Field(stat ? StatPtr : obj);
else if (prim->isShort())
- res = (sint32)field->getInt16Field(Obj);
+ res = (sint32)field->getInt16Field(stat ? StatPtr : obj);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -110,23 +118,26 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj) {
+JavaObjectField* Field, JavaObject* obj) {
jlong res = 0;
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
const Typedef* type = field->getSignature();
@@ -134,15 +145,15 @@
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isInt())
- res = (sint64)field->getInt32Field(Obj);
+ res = (sint64)field->getInt32Field(stat ? StatPtr : obj);
else if (prim->isChar())
- res = (uint64)field->getInt16Field(Obj);
+ res = (uint64)field->getInt16Field(stat ? StatPtr : obj);
else if (prim->isByte())
- res = (sint64)field->getInt8Field(Obj);
+ res = (sint64)field->getInt8Field(stat ? StatPtr : obj);
else if (prim->isShort())
- res = (sint64)field->getInt16Field(Obj);
+ res = (sint64)field->getInt16Field(stat ? StatPtr : obj);
else if (prim->isLong())
- res = (sint64)field->getLongField(Obj);
+ res = (sint64)field->getLongField(stat ? StatPtr : obj);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -158,30 +169,33 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj) {
+JavaObjectField* Field, JavaObject* obj) {
jboolean res = 0;
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
-
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
+
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
const Typedef* type = field->getSignature();
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isBool())
- res = (uint8)field->getInt8Field(Obj);
+ res = (uint8)field->getInt8Field(stat ? StatPtr : obj);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -198,41 +212,43 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj) {
+JavaObjectField* Field, JavaObject* obj) {
jfloat res = 0;
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
const Typedef* type = field->getSignature();
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isByte())
- res = (jfloat)field->getInt8Field(Obj);
+ res = (jfloat)field->getInt8Field(stat ? StatPtr : obj);
else if (prim->isInt())
- res = (jfloat)field->getInt32Field(Obj);
+ res = (jfloat)field->getInt32Field(stat ? StatPtr : obj);
else if (prim->isShort())
- res = (jfloat)field->getInt16Field(Obj);
+ res = (jfloat)field->getInt16Field(stat ? StatPtr : obj);
else if (prim->isLong())
- res = (jfloat)field->getLongField(Obj);
+ res = (jfloat)field->getLongField(stat ? StatPtr : obj);
else if (prim->isChar())
// Cast to uint32 because char is unsigned.
- res = (jfloat)(uint32)field->getInt16Field(Obj);
+ res = (jfloat)(uint32)field->getInt16Field(stat ? StatPtr : obj);
else if (prim->isFloat())
- res = (jfloat)field->getFloatField(Obj);
+ res = (jfloat)field->getFloatField(stat ? StatPtr : obj);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -248,30 +264,32 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj) {
+JavaObjectField* Field, JavaObject* obj) {
jbyte res = 0;
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
const Typedef* type = field->getSignature();
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isByte())
- res = (sint8)field->getInt8Field(Obj);
+ res = (sint8)field->getInt8Field(stat ? StatPtr : obj);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -287,31 +305,32 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj) {
+JavaObjectField* Field, JavaObject* obj) {
jchar res = 0;
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
-
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
const Typedef* type = field->getSignature();
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isChar())
- res = (uint16)field->getInt16Field(Obj);
+ res = (uint16)field->getInt16Field(stat ? StatPtr : obj);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -328,33 +347,35 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj) {
+JavaObjectField* Field, JavaObject* obj) {
jshort res = 0;
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
const Typedef* type = field->getSignature();
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isShort())
- res = (sint16)field->getInt16Field(Obj);
+ res = (sint16)field->getInt16Field(stat ? StatPtr : obj);
else if (prim->isByte())
- res = (sint16)field->getInt8Field(Obj);
+ res = (sint16)field->getInt8Field(stat ? StatPtr : obj);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -370,42 +391,44 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj) {
+JavaObjectField* Field, JavaObject* obj) {
jdouble res = 0;
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
const Typedef* type = field->getSignature();
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isByte())
- res = (jdouble)(sint64)field->getInt8Field(Obj);
+ res = (jdouble)(sint64)field->getInt8Field(stat ? StatPtr : obj);
else if (prim->isInt())
- res = (jdouble)(sint64)field->getInt32Field(Obj);
+ res = (jdouble)(sint64)field->getInt32Field(stat ? StatPtr : obj);
else if (prim->isShort())
- res = (jdouble)(sint64)field->getInt16Field(Obj);
+ res = (jdouble)(sint64)field->getInt16Field(stat? StatPtr : obj);
else if (prim->isLong())
- res = (jdouble)(sint64)field->getLongField(Obj);
+ res = (jdouble)(sint64)field->getLongField(stat? StatPtr : obj);
else if (prim->isChar())
- res = (jdouble)(uint64)field->getInt16Field(Obj);
+ res = (jdouble)(uint64)field->getInt16Field(stat ? StatPtr : obj);
else if (prim->isFloat())
- res = (jdouble)field->getFloatField(Obj);
+ res = (jdouble)field->getFloatField(stat ? StatPtr : obj);
else if (prim->isDouble())
- res = (jdouble)field->getDoubleField(Obj);
+ res = (jdouble)field->getDoubleField(stat ? StatPtr : obj);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -417,135 +440,138 @@
return res;
}
-JNIEXPORT jobject JNICALL Java_java_lang_reflect_Field_get(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Field_get(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject _obj) {
+JavaObjectField* Field, JavaObject* obj) {
- jobject result = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+ llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)_obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
- JavaObject* res = 0;
const Typedef* type = field->getSignature();
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isBool()) {
- uint8 val = field->getInt8Field(Obj);
+ uint8 val = field->getInt8Field(stat ? StatPtr : obj);
res = vm->upcalls->boolClass->doNew(vm);
vm->upcalls->boolValue->setInt8Field(res, val);
}
else if (prim->isByte()) {
- sint8 val = field->getInt8Field(Obj);
+ sint8 val = field->getInt8Field(stat ? StatPtr : obj);
res = vm->upcalls->byteClass->doNew(vm);
vm->upcalls->byteValue->setInt8Field(res, val);
}
else if (prim->isChar()) {
- uint16 val = field->getInt16Field(Obj);
+ uint16 val = field->getInt16Field(stat ? StatPtr : obj);
res = vm->upcalls->charClass->doNew(vm);
vm->upcalls->charValue->setInt16Field(res, val);
}
else if (prim->isShort()) {
- sint16 val = field->getInt16Field(Obj);
+ sint16 val = field->getInt16Field(stat ? StatPtr : obj);
res = vm->upcalls->shortClass->doNew(vm);
vm->upcalls->shortValue->setInt16Field(res, val);
}
else if (prim->isInt()) {
- sint32 val = field->getInt32Field(Obj);
+ sint32 val = field->getInt32Field(stat ? StatPtr : obj);
res = vm->upcalls->intClass->doNew(vm);
vm->upcalls->intValue->setInt32Field(res, val);
}
else if (prim->isLong()) {
- sint64 val = field->getLongField(Obj);
+ sint64 val = field->getLongField(stat ? StatPtr : obj);
res = vm->upcalls->longClass->doNew(vm);
vm->upcalls->longValue->setLongField(res, val);
}
else if (prim->isFloat()) {
- float val = field->getFloatField(Obj);
+ float val = field->getFloatField(stat ? StatPtr : obj);
res = vm->upcalls->floatClass->doNew(vm);
vm->upcalls->floatValue->setFloatField(res, val);
}
else if (prim->isDouble()) {
- double val = field->getDoubleField(Obj);
+ double val = field->getDoubleField(stat ? StatPtr : obj);
res = vm->upcalls->doubleClass->doNew(vm);
vm->upcalls->doubleValue->setDoubleField(res, val);
}
} else {
- res = field->getObjectField(Obj);
+ res = field->getObjectField(stat ? StatPtr : obj);
}
- result = (jobject) res;
-
END_NATIVE_EXCEPTION
- return (jobject)result;
+ return res;
}
JNIEXPORT void JNICALL Java_java_lang_reflect_Field_set(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj, jobject val) {
+JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+ llvm_gcroot(val, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
- uintptr_t buf = (uintptr_t)alloca(sizeof(uint64));
+ uint64_t buf = 0;
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- // Do it after alloca
- BEGIN_NATIVE_EXCEPTION(0)
- void* _buf = (void*)buf;
- const Typedef* type = field->getSignature();
- ((JavaObject*)val)->decapsulePrimitive(vm, buf, type);
-
-
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
+
+ void* _buf = (void*)(&buf);
+ uintptr_t __buf = (uintptr_t)&buf;
+ const Typedef* type = field->getSignature();
+ val->decapsulePrimitive(vm, __buf, type);
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isBool())
- field->setInt8Field(Obj, ((uint8*)_buf)[0]);
+ field->setInt8Field(stat ? StatPtr : obj, ((uint8*)_buf)[0]);
else if (prim->isByte())
- field->setInt8Field(Obj, ((sint8*)_buf)[0]);
+ field->setInt8Field(stat ? StatPtr : obj, ((sint8*)_buf)[0]);
else if (prim->isChar())
- field->setInt16Field(Obj, ((uint16*)_buf)[0]);
+ field->setInt16Field(stat ? StatPtr : obj, ((uint16*)_buf)[0]);
else if (prim->isShort())
- field->setInt16Field(Obj, ((sint16*)_buf)[0]);
+ field->setInt16Field(stat ? StatPtr : obj, ((sint16*)_buf)[0]);
else if (prim->isInt())
- field->setInt32Field(Obj, ((sint32*)_buf)[0]);
+ field->setInt32Field(stat ? StatPtr : obj, ((sint32*)_buf)[0]);
else if (prim->isLong())
- field->setLongField(Obj, ((sint64*)_buf)[0]);
+ field->setLongField(stat ? StatPtr : obj, ((sint64*)_buf)[0]);
else if (prim->isFloat())
- field->setFloatField(Obj, ((float*)_buf)[0]);
+ field->setFloatField(stat ? StatPtr : obj, ((float*)_buf)[0]);
else if (prim->isDouble())
- field->setDoubleField(Obj, ((double*)_buf)[0]);
+ field->setDoubleField(stat ? StatPtr : obj, ((double*)_buf)[0]);
} else {
- field->setObjectField(Obj, ((JavaObject**)_buf)[0]);
+ field->setObjectField(stat ? StatPtr : obj, val);
}
END_NATIVE_EXCEPTION
@@ -555,28 +581,31 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj, jboolean val) {
+JavaObjectField* Field, JavaObject* obj, jboolean val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
const Typedef* type = field->getSignature();
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isBool())
- field->setInt8Field(Obj, (uint8)val);
+ field->setInt8Field(stat ? StatPtr : obj, (uint8)val);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -591,38 +620,41 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj, jbyte val) {
+JavaObjectField* Field, JavaObject* obj, jbyte val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
const Typedef* type = field->getSignature();
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isByte())
- field->setInt8Field(Obj, (sint8)val);
+ field->setInt8Field(stat ? StatPtr : obj, (sint8)val);
else if (prim->isShort())
- field->setInt16Field(Obj, (sint16)val);
+ field->setInt16Field(stat ? StatPtr : obj, (sint16)val);
else if (prim->isInt())
- field->setInt32Field(Obj, (sint32)val);
+ field->setInt32Field(stat ? StatPtr : obj, (sint32)val);
else if (prim->isLong())
- field->setLongField(Obj, (sint64)val);
+ field->setLongField(stat ? StatPtr : obj, (sint64)val);
else if (prim->isFloat())
- field->setFloatField(Obj, (float)val);
+ field->setFloatField(stat ? StatPtr : obj, (float)val);
else if (prim->isDouble())
- field->setDoubleField(Obj, (double)val);
+ field->setDoubleField(stat ? StatPtr : obj, (double)val);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -636,35 +668,38 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj, jchar val) {
+JavaObjectField* Field, JavaObject* obj, jchar val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
const Typedef* type = field->getSignature();
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isChar())
- field->setInt16Field(Obj, (uint16)val);
+ field->setInt16Field(stat ? StatPtr : obj, (uint16)val);
else if (prim->isInt())
- field->setInt32Field(Obj, (uint32)val);
+ field->setInt32Field(stat ? StatPtr : obj, (uint32)val);
else if (prim->isLong())
- field->setLongField(Obj, (uint64)val);
+ field->setLongField(stat ? StatPtr : obj, (uint64)val);
else if (prim->isFloat())
- field->setFloatField(Obj, (float)(uint32)val);
+ field->setFloatField(stat ? StatPtr : obj, (float)(uint32)val);
else if (prim->isDouble())
- field->setDoubleField(Obj, (double)(uint64)val);
+ field->setDoubleField(stat ? StatPtr : obj, (double)(uint64)val);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -678,36 +713,39 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj, jshort val) {
+JavaObjectField* Field, JavaObject* obj, jshort val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
const Typedef* type = field->getSignature();
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isShort())
- field->setInt16Field(Obj, (sint16)val);
+ field->setInt16Field(stat ? StatPtr : obj, (sint16)val);
else if (prim->isInt())
- field->setInt32Field(Obj, (sint32)val);
+ field->setInt32Field(stat ? StatPtr : obj, (sint32)val);
else if (prim->isLong())
- field->setLongField(Obj, (sint64)val);
+ field->setLongField(stat ? StatPtr : obj, (sint64)val);
else if (prim->isFloat())
- field->setFloatField(Obj, (float)val);
+ field->setFloatField(stat ? StatPtr : obj, (float)val);
else if (prim->isDouble())
- field->setDoubleField(Obj, (double)val);
+ field->setDoubleField(stat ? StatPtr : obj, (double)val);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -721,34 +759,37 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj, jint val) {
+JavaObjectField* Field, JavaObject* obj, jint val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
const Typedef* type = field->getSignature();
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isInt())
- field->setInt32Field(Obj, (sint32)val);
+ field->setInt32Field(stat ? StatPtr : obj, (sint32)val);
else if (prim->isLong())
- field->setLongField(Obj, (sint64)val);
+ field->setLongField(stat ? StatPtr : obj, (sint64)val);
else if (prim->isFloat())
- field->setFloatField(Obj, (float)val);
+ field->setFloatField(stat ? StatPtr : obj, (float)val);
else if (prim->isDouble())
- field->setDoubleField(Obj, (double)val);
+ field->setDoubleField(stat ? StatPtr : obj, (double)val);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -762,32 +803,35 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj, jlong val) {
+JavaObjectField* Field, JavaObject* obj, jlong val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
const Typedef* type = field->getSignature();
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isLong())
- field->setLongField(Obj, (sint64)val);
+ field->setLongField(stat ? StatPtr : obj, (sint64)val);
else if (prim->isFloat())
- field->setFloatField(Obj, (float)val);
+ field->setFloatField(stat ? StatPtr : obj, (float)val);
else if (prim->isDouble())
- field->setDoubleField(Obj, (double)val);
+ field->setDoubleField(stat ? StatPtr : obj, (double)val);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -801,31 +845,33 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, jobject obj, jfloat val) {
+JavaObjectField* Field, JavaObject* obj, jfloat val) {
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
const Typedef* type = field->getSignature();
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isFloat())
- field->setFloatField(Obj, (float)val);
+ field->setFloatField(stat ? StatPtr : obj, (float)val);
else if (prim->isDouble())
- field->setDoubleField(Obj, (double)val);
+ field->setDoubleField(stat ? StatPtr : obj, (double)val);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -840,27 +886,30 @@
JNIEnv *env,
#endif
JavaObjectField* Field, JavaObject* obj, jdouble val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClass* cl = Field->getClass();
JavaField* field = Field->getInternalField();
+ bool stat = isStatic(field->access);
+ void* StatPtr = 0;
- void* Obj = (void*)obj;
-
- if (isStatic(field->access)) {
+ if (stat) {
cl->initialiseClass(vm);
- Obj = cl->getStaticInstance();
+ StatPtr = cl->getStaticInstance();
} else {
- verifyNull(Obj);
+ verifyNull(obj);
}
const Typedef* type = field->getSignature();
if (type->isPrimitive()) {
const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;
if (prim->isDouble())
- field->setDoubleField(Obj, (double)val);
+ field->setDoubleField(stat ? StatPtr : obj, (double)val);
else
vm->illegalArgumentException("wrong type");
} else {
@@ -876,6 +925,10 @@
JNIEnv *env,
#endif
JavaObject* Unsafe, JavaObjectField* Field) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(Unsafe, 0);
+
JavaField* field = Field->getInternalField();
return (jlong)field->ptrOffset;
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.inc?rev=76430&r1=76429&r2=76430&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.inc Mon Jul 20 12:07:01 2009
@@ -32,6 +32,7 @@
JavaObjectMethod* Meth) {
jint res = 0;
+ llvm_gcroot(Meth, 0);
BEGIN_NATIVE_EXCEPTION(0)
@@ -43,20 +44,22 @@
return res;
}
-JNIEXPORT jclass JNICALL Java_java_lang_reflect_Method_getReturnType(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getReturnType(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
JavaObjectMethod* Meth) {
- jclass res = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(Meth, 0);
+ llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
UserClass* cl = Meth->getClass();
JavaMethod* meth = Meth->getInternalMethod();
JnjvmClassLoader* loader = cl->classLoader;
- res = (jclass)meth->getReturnType(loader);
+ res = meth->getReturnType(loader);
END_NATIVE_EXCEPTION
@@ -64,13 +67,15 @@
}
-JNIEXPORT jobject JNICALL Java_java_lang_reflect_Method_getParameterTypes(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getParameterTypes(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
JavaObjectMethod* Meth) {
- jobject res = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(Meth, 0);
+ llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
@@ -78,38 +83,44 @@
JavaMethod* meth = Meth->getInternalMethod();
JnjvmClassLoader* loader = cl->classLoader;
- res = (jobject)(meth->getParameterTypes(loader));
+ res = (meth->getParameterTypes(loader));
END_NATIVE_EXCEPTION
return res;
}
-static jobject proceedMethod(JavaObjectMethod* Meth, jobject _obj,
- jobject _args, jclass Cl, jint index)
+static JavaObject* proceedMethod(JavaObjectMethod* Meth, JavaObject* obj,
+ JavaArray* args, JavaObject* Cl, jint index)
__attribute__((noinline));
-static jobject proceedMethod(JavaObjectMethod* Meth, jobject _obj,
- jobject _args, jclass Cl, jint index) {
+static JavaObject* proceedMethod(JavaObjectMethod* Meth, JavaObject* obj,
+ JavaArray* args, JavaObject* Cl, jint index) {
JavaObject* res = 0;
+ JavaObject* exc = 0;
+
+ llvm_gcroot(res, 0);
+ llvm_gcroot(Meth, 0);
+ llvm_gcroot(obj, 0);
+ llvm_gcroot(args, 0);
+ llvm_gcroot(Cl, 0);
+ llvm_gcroot(exc, 0);
+
Jnjvm* vm = JavaThread::get()->getJVM();
JavaMethod* meth = Meth->getInternalMethod();
- JavaArray* args = (JavaArray*)_args;
sint32 nbArgs = args ? args->size : 0;
Signdef* sign = meth->getSignature();
sint32 size = sign->nbArguments;
- JavaObject* obj = (JavaObject*)_obj;
uintptr_t buf = size ? (uintptr_t)alloca(size * sizeof(uint64)) : 0;
void* _buf = (void*)buf;
if (nbArgs == size) {
- UserCommonClass* _cl =
- UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false);
+ UserCommonClass* _cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
UserClass* cl = (UserClass*)_cl;
if (isVirtual(meth->access)) {
@@ -136,20 +147,19 @@
ptr[i]->decapsulePrimitive(vm, buf, arguments[i]);
}
- JavaObject* exc = 0;
JavaThread* th = JavaThread::get();
-#define RUN_METH(TYPE) \
+#define RUN_METH(TYPE, VAR) \
try{ \
if (isVirtual(meth->access)) { \
if (isPublic(meth->access) && !isFinal(meth->access) && \
!isFinal(meth->classDef->access)) { \
- val = meth->invoke##TYPE##VirtualBuf(vm, cl, obj, _buf); \
+ VAR = meth->invoke##TYPE##VirtualBuf(vm, cl, obj, _buf); \
} else { \
- val = meth->invoke##TYPE##SpecialBuf(vm, cl, obj, _buf); \
+ VAR = meth->invoke##TYPE##SpecialBuf(vm, cl, obj, _buf); \
} \
} else { \
- val = meth->invoke##TYPE##StaticBuf(vm, cl, _buf); \
+ VAR = meth->invoke##TYPE##StaticBuf(vm, cl, _buf); \
} \
} catch(...) { \
exc = th->getJavaException(); \
@@ -167,87 +177,92 @@
if (prim->isVoid()) {
res = 0;
uint32 val = 0;
- RUN_METH(Int);
+ RUN_METH(Int, val);
} else if (prim->isBool()) {
uint32 val = 0;
- RUN_METH(Int);
+ RUN_METH(Int, val);
res = vm->upcalls->boolClass->doNew(vm);
vm->upcalls->boolValue->setInt8Field(res, val);
} else if (prim->isByte()) {
uint32 val = 0;
- RUN_METH(Int);
+ RUN_METH(Int, val);
res = vm->upcalls->byteClass->doNew(vm);
vm->upcalls->byteValue->setInt8Field(res, val);
} else if (prim->isChar()) {
uint32 val = 0;
- RUN_METH(Int);
+ RUN_METH(Int, val);
res = vm->upcalls->charClass->doNew(vm);
vm->upcalls->charValue->setInt16Field(res, val);
} else if (prim->isShort()) {
uint32 val = 0;
- RUN_METH(Int);
+ RUN_METH(Int, val);
res = vm->upcalls->shortClass->doNew(vm);
vm->upcalls->shortValue->setInt16Field(res, val);
} else if (prim->isInt()) {
uint32 val = 0;
- RUN_METH(Int);
+ RUN_METH(Int, val);
res = vm->upcalls->intClass->doNew(vm);
vm->upcalls->intValue->setInt32Field(res, val);
} else if (prim->isLong()) {
sint64 val = 0;
- RUN_METH(Long);
+ RUN_METH(Long, val);
res = vm->upcalls->longClass->doNew(vm);
vm->upcalls->longValue->setLongField(res, val);
} else if (prim->isFloat()) {
float val = 0;
- RUN_METH(Float);
+ RUN_METH(Float, val);
res = vm->upcalls->floatClass->doNew(vm);
vm->upcalls->floatValue->setFloatField(res, val);
} else if (prim->isDouble()) {
double val = 0;
- RUN_METH(Double);
+ RUN_METH(Double, val);
res = vm->upcalls->doubleClass->doNew(vm);
vm->upcalls->doubleValue->setDoubleField(res, val);
}
} else {
- JavaObject* val = 0;
- RUN_METH(JavaObject);
- res = val;
+ RUN_METH(JavaObject, res);
}
} else {
vm->illegalArgumentException("wrong number of arguments");
}
- return (jobject)res;
+ return res;
}
#undef RUN_METH
-JNIEXPORT jobject JNICALL Java_java_lang_reflect_Method_invokeNative(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_invokeNative(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectMethod* Meth, jobject _obj, jobject _args, jclass Cl, jint index) {
+JavaObjectMethod* Meth, JavaObject* obj, JavaArray* args, JavaObject* Cl, jint index) {
- jobject res = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(Meth, 0);
+ llvm_gcroot(obj, 0);
+ llvm_gcroot(args, 0);
+ llvm_gcroot(Cl, 0);
BEGIN_NATIVE_EXCEPTION(0)
// Create a new function because we use alloca.
- res = proceedMethod(Meth, _obj, _args, Cl, index);
+ res = proceedMethod(Meth, obj, args, Cl, index);
END_NATIVE_EXCEPTION
- return (jobject) res;
+ return res;
}
-JNIEXPORT jobjectArray JNICALL Java_java_lang_reflect_Method_getExceptionTypes(
+JNIEXPORT ArrayObject* JNICALL Java_java_lang_reflect_Method_getExceptionTypes(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
JavaObjectMethod* Meth) {
- jobjectArray res = 0;
+ ArrayObject* res = 0;
+ llvm_gcroot(Meth, 0);
+ llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
@@ -255,27 +270,29 @@
UserClass* cl = Meth->getClass();
JavaMethod* meth = Meth->getInternalMethod();
JnjvmClassLoader* loader = cl->classLoader;
- res = (jobjectArray)meth->getExceptionTypes(loader);
+ res = meth->getExceptionTypes(loader);
END_NATIVE_EXCEPTION
return res;
}
-JNIEXPORT jobject JNICALL Java_java_lang_reflect_Method_getSignature(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getSignature(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
JavaObjectMethod* Meth) {
- jobject result = 0;
+ JavaObject* result = 0;
+ llvm_gcroot(Meth, 0);
+ llvm_gcroot(result, 0);
BEGIN_NATIVE_EXCEPTION(0)
verifyNull(Meth);
JavaMethod* meth = Meth->getInternalMethod();
Jnjvm* vm = JavaThread::get()->getJVM();
- result = (jobject)(vm->internalUTF8ToStr(meth->type));
+ result = vm->internalUTF8ToStr(meth->type);
END_NATIVE_EXCEPTION
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.inc?rev=76430&r1=76429&r2=76430&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.inc Mon Jul 20 12:07:01 2009
@@ -31,15 +31,17 @@
JNIEnv *env,
jclass clazz,
#endif
-jobject klass) {
+JavaObjectClass* klass) {
- UserCommonClass* cl = ((JavaObjectClass*)klass)->getClass();
+ llvm_gcroot(klass, 0);
+
+ UserCommonClass* cl = klass->getClass();
return cl->isArray();
}
-JNIEXPORT jclass JNICALL Java_java_lang_VMClass_forName(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_forName(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
@@ -48,7 +50,10 @@
jboolean clinit,
JavaObject* loader) {
- jclass res = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(loader, 0);
+ llvm_gcroot(str, 0);
+ llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
@@ -62,7 +67,7 @@
if (clinit && cl->asClass()) {
cl->asClass()->initialiseClass(vm);
}
- res =(jclass)(cl->getClassDelegatee(vm));
+ res =cl->getClassDelegatee(vm);
} else {
vm->classNotFoundException(str);
}
@@ -72,26 +77,29 @@
return res;
}
-JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredConstructors(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredConstructors(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl,
+JavaObject* Cl,
jboolean publicOnly) {
- jobject result = 0;
+ ArrayObject* ret = 0;
+ JavaObject* tmp = 0;
+ llvm_gcroot(Cl, 0);
+ llvm_gcroot(ret, 0);
+ llvm_gcroot(tmp, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl =
- UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false);
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
- result = (jobject)vm->upcalls->constructorArrayClass->doNew(0, vm);
+ ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
} else {
- UserClass* realCl = (Class*)cl;
+ UserClass* realCl = cl->asClass();;
JnjvmClassLoader* classLoader = cl->classLoader;
uint32 size = 0;
@@ -104,9 +112,8 @@
}
}
+ ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
- ArrayObject* ret =
- (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
sint32 index = 0;
for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
JavaMethod* meth = &realCl->virtualMethods[i];
@@ -114,40 +121,44 @@
if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
(!publicOnly || pub)) {
UserClass* Cons = vm->upcalls->newConstructor;
- JavaObject* tmp = Cons->doNew(vm);
+ tmp = Cons->doNew(vm);
vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp, Cl, i);
ret->elements[index++] = tmp;
}
}
- result = (jobject)ret;
}
END_NATIVE_EXCEPTION
- return result;
+ return ret;
}
-JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredMethods(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredMethods(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl,
+JavaObject* Cl,
jboolean publicOnly) {
- jobject result = 0;
+ ArrayObject* ret = 0;
+ JavaObject* tmp = 0;
+ JavaString* str = 0;
+ llvm_gcroot(Cl, 0);
+ llvm_gcroot(ret, 0);
+ llvm_gcroot(tmp, 0);
+ llvm_gcroot(str, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl =
- UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false);
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
Classpath* upcalls = vm->upcalls;
if (cl->isArray() || cl->isPrimitive()) {
- result = (jobject)upcalls->methodArrayClass->doNew(0, vm);
+ ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
} else {
- UserClass* realCl = (Class*)cl;
+ UserClass* realCl = cl->asClass();
JnjvmClassLoader* classLoader = cl->classLoader;
uint32 size = 0;
@@ -162,7 +173,7 @@
}
- ArrayObject* ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
+ ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
sint32 index = 0;
for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
@@ -173,18 +184,17 @@
(!publicOnly || pub)) {
// TODO: check parameter types
UserClass* Meth = vm->upcalls->newMethod;
- JavaObject* tmp = Meth->doNew(vm);
- JavaString* str = vm->internalUTF8ToStr(meth->name);
+ tmp = Meth->doNew(vm);
+ str = vm->internalUTF8ToStr(meth->name);
upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, Cl, str, i);
ret->elements[index++] = tmp;
}
}
- result = (jobject)ret;
}
END_NATIVE_EXCEPTION
- return result;
+ return ret;
}
JNIEXPORT jint JNICALL Java_java_lang_VMClass_getModifiers(
@@ -192,38 +202,40 @@
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl,
+JavaObject* Cl,
jboolean ignore) {
jint res = 0;
+ llvm_gcroot(Cl, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl =
- UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false);
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
res = cl->getAccess();
END_NATIVE_EXCEPTION
return res;
}
-JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getName(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getName(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jobject Cl) {
+JavaObject* Cl) {
- jobject result = 0;
+ JavaObject* result = 0;
+ llvm_gcroot(Cl, 0);
+ llvm_gcroot(result, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass();
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
const UTF8* iname = cl->getName();
- result = (jobject)JavaString::internalToJava(iname, vm);
+ result = JavaString::internalToJava(iname, vm);
END_NATIVE_EXCEPTION
@@ -235,12 +247,15 @@
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl) {
+JavaObject* Cl) {
jboolean res = 0;
+ llvm_gcroot(Cl, 0);
+
BEGIN_NATIVE_EXCEPTION(0)
- UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass();
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
res = cl->isPrimitive();
@@ -254,15 +269,15 @@
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl) {
+JavaObject* Cl) {
jboolean res = 0;
+ llvm_gcroot(Cl, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl =
- UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false);
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
res = cl->isInterface();
@@ -271,23 +286,26 @@
return res;
}
-JNIEXPORT jclass JNICALL Java_java_lang_VMClass_getComponentType(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getComponentType(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl) {
+JavaObject* Cl) {
- jclass res = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(Cl, 0);
+
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass();
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
if (cl->isArray()) {
- UserCommonClass* bc = ((UserClassArray*)cl)->baseClass();
- res = (jclass)(bc->getClassDelegatee(vm));
+ UserCommonClass* bc = cl->asArrayClass()->baseClass();
+ res = bc->getClassDelegatee(vm);
} else {
res = 0;
}
@@ -296,19 +314,22 @@
return res;
}
-JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getClassLoader(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getClassLoader(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl) {
+JavaObject* Cl) {
- jobject res = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(Cl, 0);
BEGIN_NATIVE_EXCEPTION(0)
- UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass();
- res = (jobject)cl->classLoader->getJavaClassLoader();
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+ res = cl->classLoader->getJavaClassLoader();
END_NATIVE_EXCEPTION
@@ -320,19 +341,20 @@
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl1, jclass Cl2) {
+JavaObject* Cl1, JavaObject* Cl2) {
jboolean res = 0;
+ llvm_gcroot(Cl1, 0);
+ llvm_gcroot(Cl2, 0);
BEGIN_NATIVE_EXCEPTION(0)
- if (!Cl2) JavaThread::get()->getJVM()->nullPointerException();
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ if (!Cl2) vm->nullPointerException();
- UserCommonClass* cl1 = ((JavaObjectClass*)Cl1)->getClass();
- UserCommonClass* cl2 = ((JavaObjectClass*)Cl2)->getClass();
+ UserCommonClass* cl1 = UserCommonClass::resolvedImplClass(vm, Cl1, false);
+ UserCommonClass* cl2 = UserCommonClass::resolvedImplClass(vm, Cl2, false);
- if (cl1->isClass()) cl1->asClass()->resolveClass();
- if (cl2->asClass()) cl2->asClass()->resolveClass();
res = cl2->isAssignableFrom(cl1);
END_NATIVE_EXCEPTION
@@ -341,23 +363,24 @@
}
-JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getSuperclass(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getSuperclass(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl) {
+JavaObject* Cl) {
- jobject res = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(Cl, 0);
+ llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass();
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
if (cl->isInterface()) res = 0;
else {
- if (cl->asClass()) cl->asClass()->resolveClass();
- if (cl->getSuper()) res = (jobject)cl->getSuper()->getClassDelegatee(vm);
+ if (cl->getSuper()) res = cl->getSuper()->getClassDelegatee(vm);
else res = 0;
}
@@ -371,91 +394,100 @@
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl, jobject obj) {
+JavaObject* Cl, JavaObject* obj) {
bool res = false;
+ llvm_gcroot(Cl, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
- UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass();
- res = ((JavaObject*)obj)->instanceOf(cl);
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+ res = obj->instanceOf(cl);
END_NATIVE_EXCEPTION
return res;
}
-JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredFields(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredFields(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl, jboolean publicOnly) {
+JavaObject* Cl, jboolean publicOnly) {
- jobject result = 0;
+ ArrayObject* ret = 0;
+ JavaObject* tmp = 0;
+ JavaString* name = 0;
+ llvm_gcroot(Cl, 0);
+ llvm_gcroot(ret, 0);
+ llvm_gcroot(tmp, 0);
+ llvm_gcroot(name, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl =
- UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false)->asClass();
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
- if (!cl) {
- result = (jobject)vm->upcalls->fieldArrayClass->doNew(0, vm);
+ if (!cl->isClass()) {
+ ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
} else {
-
+ UserClass* realCl = cl->asClass();
uint32 size = 0;
- for (uint32 i = 0; i < cl->nbVirtualFields + cl->nbStaticFields; ++i) {
- JavaField* field = &cl->virtualFields[i];
+ for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
+ ++i) {
+ JavaField* field = &realCl->virtualFields[i];
if (!publicOnly || isPublic(field->access)) {
++size;
}
}
- ArrayObject* ret =
- (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
+ ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
+
sint32 index = 0;
- for (uint32 i = 0; i < cl->nbVirtualFields + cl->nbStaticFields; ++i) {
- JavaField* field = &cl->virtualFields[i];
+ for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
+ ++i) {
+ JavaField* field = &realCl->virtualFields[i];
if (!publicOnly || isPublic(field->access)) {
// TODO: check parameter types
UserClass* Field = vm->upcalls->newField;
- JavaObject* tmp = Field->doNew(vm);
- JavaString* name = vm->internalUTF8ToStr(field->name);
+ tmp = Field->doNew(vm);
+ name = vm->internalUTF8ToStr(field->name);
vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, Cl, name, i);
ret->elements[index++] = tmp;
}
}
- result = (jobject)ret;
}
END_NATIVE_EXCEPTION
- return result;
+ return ret;
}
-JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getInterfaces(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getInterfaces(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl) {
+JavaObject* Cl) {
- jobject res = 0;
+ ArrayObject* res = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(Cl, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl =
- UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false);
- ArrayObject* ret =
- (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces, vm);
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+ res = (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces, vm);
+
for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
UserClass* klass = cl->interfaces[i];
- ret->elements[i] = klass->getClassDelegatee(vm);
+ res->elements[i] = klass->getClassDelegatee(vm);
}
- res = (jobject)ret;
END_NATIVE_EXCEPTION
@@ -463,24 +495,27 @@
}
-JNIEXPORT jclass JNICALL Java_java_lang_VMClass_getDeclaringClass(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaringClass(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl) {
- jclass res = 0;
+JavaObject* Cl) {
+ JavaObject* res = 0;
+
+ llvm_gcroot(res, 0);
+ llvm_gcroot(Cl, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl =
- UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false)->asClass();
+ UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
+
if (cl) {
cl->resolveInnerOuterClasses();
UserClass* outer = cl->getOuterClass();
if (outer) {
- res = (jclass)outer->getClassDelegatee(vm);
+ res = outer->getClassDelegatee(vm);
}
}
@@ -490,21 +525,22 @@
}
-JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredClasses(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredClasses(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl, bool publicOnly) {
+JavaObject* Cl, bool publicOnly) {
- jobject result = 0;
+ ArrayObject* result = 0;
+ llvm_gcroot(result, 0);
+ llvm_gcroot(Cl, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl =
- UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false)->asClass();
+ UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
if (cl) {
cl->resolveInnerOuterClasses();
UserClassArray* array = vm->upcalls->constructorArrayClass;
@@ -520,13 +556,12 @@
sizeArray = cl->nbInnerClasses;
}
- ArrayObject* res = (ArrayObject*)array->doNew(sizeArray, vm);
+ result = (ArrayObject*)array->doNew(sizeArray, vm);
for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
UserClass* klass = cl->innerClasses[i];
if (!publicOnly || isPublic(klass->innerAccess))
- res->elements[i] = klass->getClassDelegatee(vm);
+ result->elements[i] = klass->getClassDelegatee(vm);
}
- result = (jobject)res;
}
@@ -542,26 +577,31 @@
JNIEnv *env,
jclass clazz,
#endif
-jobject throwable) {
+JavaObject* throwable) {
+
+ llvm_gcroot(throwable, 0);
+
assert(throwable && "Using internal VM throw exception without exception");
JavaThread::get()->pendingException = (JavaObject*)throwable;
}
-JNIEXPORT jobjectArray Java_java_lang_VMClass_getDeclaredAnnotations(
+JNIEXPORT ArrayObject* Java_java_lang_VMClass_getDeclaredAnnotations(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl) {
+JavaObject* Cl) {
// TODO implement me
- jobjectArray res = 0;
+ ArrayObject* res = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(Cl, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
- res = (jobjectArray) array->doNew(0, vm);
+ res = (ArrayObject*)array->doNew(0, vm);
END_NATIVE_EXCEPTION
@@ -573,15 +613,15 @@
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl) {
+JavaObject* Cl) {
jboolean res = false;
+ llvm_gcroot(Cl, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl =
- UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false)->asClass();
+ UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
if (cl) res = cl->isAnonymous;
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.inc?rev=76430&r1=76429&r2=76430&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.inc Mon Jul 20 12:07:01 2009
@@ -23,26 +23,28 @@
extern "C" {
-JNIEXPORT jobject JNICALL Java_java_lang_VMClassLoader_getPrimitiveClass(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_getPrimitiveClass(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
jchar byteId) {
- jobject res = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
UserClassPrimitive* prim =
UserClassPrimitive::byteIdToPrimitive(byteId, vm->upcalls);
+
if (!prim) {
fprintf(stderr, "unknown byte primitive %c", byteId);
abort();
}
- res = (jobject)prim->getClassDelegatee(vm);
+ res = prim->getClassDelegatee(vm);
END_NATIVE_EXCEPTION
@@ -50,25 +52,27 @@
}
-JNIEXPORT jclass JNICALL Java_java_lang_VMClassLoader_findLoadedClass(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_findLoadedClass(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jobject loader,
-jobject _name) {
+JavaObject* loader,
+JavaString* name) {
- jclass res = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(loader, 0);
+ llvm_gcroot(name, 0);
+ llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- JavaString* name = (JavaString*)_name;
JnjvmClassLoader* JCL =
- JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm);
+ JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
UserCommonClass* cl = JCL->lookupClassFromJavaString(name);
- if (cl) res = (jclass)(cl->getClassDelegatee(vm));
+ if (cl) res = cl->getClassDelegatee(vm);
END_NATIVE_EXCEPTION
@@ -77,69 +81,72 @@
return 0;
}
-JNIEXPORT jclass JNICALL Java_java_lang_VMClassLoader_loadClass(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_loadClass(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jobject _str,
+JavaString* str,
jboolean doResolve) {
- jclass res = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(str, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- JavaString* str = (JavaString*)_str;
JnjvmClassLoader* JCL = vm->bootstrapLoader;
UserCommonClass* cl = JCL->loadClassFromJavaString(str, doResolve, false);
- if (cl != 0)
- res = (jclass)cl->getClassDelegatee(vm);
+ if (cl != 0) res = cl->getClassDelegatee(vm);
END_NATIVE_EXCEPTION
return res;
}
-JNIEXPORT jclass JNICALL Java_java_lang_VMClassLoader_defineClass(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_defineClass(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jobject loader,
-jobject _str,
-jobject bytes,
+JavaObject* loader,
+JavaString* str,
+ArrayUInt8* bytes,
jint off,
jint len,
-jobject pd) {
+JavaObject* pd) {
- jclass res = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(loader, 0);
+ llvm_gcroot(str, 0);
+ llvm_gcroot(bytes, 0);
+ llvm_gcroot(pd, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
// Before creating a class, do a check on the bytes.
- Reader reader((ArrayUInt8*)bytes);
+ Reader reader(bytes);
uint32 magic = reader.readU4();
if (magic != Jnjvm::Magic) {
JavaThread::get()->getJVM()->classFormatError("bad magic number");
}
JnjvmClassLoader* JCL =
- JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm);
+ JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
- JavaString* str = (JavaString*)_str;
const UTF8* name = str->javaToInternal(JCL->hashUTF8);
UserCommonClass* cl = JCL->lookupClass(name);
if (!cl) {
- UserClass* cl = JCL->constructClass(name, (ArrayUInt8*)bytes);
+ UserClass* cl = JCL->constructClass(name, bytes);
cl->resolveClass();
- res = (jclass)(cl->getClassDelegatee(vm, (JavaObject*)pd));
+ res = cl->getClassDelegatee(vm, pd);
} else {
JavaObject* obj = vm->CreateLinkageError("duplicate class definition");
JavaThread::get()->throwException(obj);
@@ -155,13 +162,15 @@
JNIEnv *env,
jclass clazz,
#endif
-jclass Cl) {
+JavaObject* Cl) {
+
+ llvm_gcroot(Cl, 0);
BEGIN_NATIVE_EXCEPTION(0)
verifyNull(Cl);
Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false);
+ UserCommonClass::resolvedImplClass(vm, Cl, false);
END_NATIVE_EXCEPTION
}
@@ -340,9 +349,11 @@
};
extern "C" ArrayObject* nativeGetBootPackages() {
+ ArrayObject* obj = 0;
+ llvm_gcroot(obj, 0);
+
Jnjvm* vm = JavaThread::get()->getJVM();
- ArrayObject* obj =
- (ArrayObject*)vm->upcalls->ArrayOfString->doNew(NUM_BOOT_PACKAGES, vm);
+ obj = (ArrayObject*)vm->upcalls->ArrayOfString->doNew(NUM_BOOT_PACKAGES, vm);
for (uint32 i = 0; i < NUM_BOOT_PACKAGES; ++i) {
obj->elements[i] = vm->asciizToStr(bootPackages[i]);
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.inc?rev=76430&r1=76429&r2=76430&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.inc Mon Jul 20 12:07:01 2009
@@ -20,18 +20,19 @@
extern "C" {
-JNIEXPORT jobject JNICALL Java_java_lang_VMObject_clone(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMObject_clone(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jobject _src) {
+JavaObject* src) {
JavaObject* res = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(src, 0);
BEGIN_NATIVE_EXCEPTION(0)
- JavaObject* src = (JavaObject*)_src;
UserCommonClass* cl = src->getClass();
Jnjvm* vm = JavaThread::get()->getJVM();
uint64 size = 0;
@@ -54,23 +55,24 @@
END_NATIVE_EXCEPTION
- return (jobject)res;
+ return res;
}
-JNIEXPORT jobject JNICALL Java_java_lang_VMObject_getClass(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMObject_getClass(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jobject _obj) {
+JavaObject* obj) {
- jobject res = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
- JavaObject* obj = (JavaObject*)_obj;
Jnjvm* vm = JavaThread::get()->getJVM();
- res = (jobject)(obj->getClass()->getClassDelegatee(vm));
+ res = obj->getClass()->getClassDelegatee(vm);
END_NATIVE_EXCEPTION
@@ -82,11 +84,12 @@
JNIEnv *env,
jclass clazz,
#endif
-jobject _obj) {
+JavaObject* obj) {
+
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
- JavaObject* obj = (JavaObject*)_obj;
obj->notifyAll();
END_NATIVE_EXCEPTION
@@ -98,14 +101,15 @@
JNIEnv *env,
jclass clazz,
#endif
-jobject _object, jlong ms, jint ns) {
+JavaObject* obj, jlong ms, jint ns) {
+
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
uint32 sec = (uint32) (ms / 1000);
uint32 usec = (ns / 1000) + 1000 * (ms % 1000);
if (ns && !usec) usec = 1;
- JavaObject* obj = (JavaObject*)_object;
if (sec || usec) {
struct timeval t;
t.tv_sec = sec;
@@ -123,11 +127,13 @@
JNIEnv *env,
jclass clazz,
#endif
-jobject obj) {
+JavaObject* obj) {
+
+ llvm_gcroot(obj, 0);
BEGIN_NATIVE_EXCEPTION(0)
- ((JavaObject*)obj)->notify();
+ obj->notify();
END_NATIVE_EXCEPTION
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.inc?rev=76430&r1=76429&r2=76430&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.inc Mon Jul 20 12:07:01 2009
@@ -30,28 +30,33 @@
extern "C" {
-JNIEXPORT jobject JNICALL Java_java_lang_VMRuntime_mapLibraryName(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMRuntime_mapLibraryName(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jobject _strLib) {
+JavaString* strLib) {
- jobject res = 0;
+ JavaObject* res = 0;
+ ArrayUInt16* array = 0;
+ const ArrayUInt16* utf8Lib = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(array, 0);
+ llvm_gcroot(utf8Lib, 0);
+ llvm_gcroot(strLib, 0);
BEGIN_NATIVE_EXCEPTION(0)
- JavaString* strLib = (JavaString*)_strLib;
Jnjvm* vm = JavaThread::get()->getJVM();
- const ArrayUInt16* utf8Lib = strLib->value;
+ utf8Lib = strLib->value;
uint32 stLib = strLib->offset;
sint32 lgLib = strLib->count;
sint32 lgPre = vm->bootstrapLoader->prelib->size;
sint32 lgPost = vm->bootstrapLoader->postlib->size;
uint32 size = (uint32)(lgPre + lgLib + lgPost);
- ArrayUInt16* array = (ArrayUInt16*)vm->upcalls->ArrayOfChar->doNew(size, vm);
+ array = (ArrayUInt16*)vm->upcalls->ArrayOfChar->doNew(size, vm);
uint16* elements = array->elements;
memmove(elements, vm->bootstrapLoader->prelib->elements,
@@ -61,7 +66,7 @@
memmove(&(elements[lgPre + lgLib]), vm->bootstrapLoader->postlib->elements,
lgPost * sizeof(uint16));
- res = (jobject)(vm->constructString(array));
+ res = vm->constructString(array);
END_NATIVE_EXCEPTION
@@ -106,15 +111,17 @@
JNIEnv *env,
jclass clazz,
#endif
-jobject _str,
-jobject _loader) {
+JavaString* str,
+JavaObject* javaLoader) {
+ llvm_gcroot(str, 0);
+ llvm_gcroot(javaLoader, 0);
+
void* res = 0;
- JavaString* str = (JavaString*)_str;
Jnjvm* vm = JavaThread::get()->getJVM();
JnjvmClassLoader* loader =
- JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)_loader, vm);
+ JnjvmClassLoader::getJnjvmLoaderFromJavaObject(javaLoader, vm);
char* buf = str->strToAsciiz();
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.inc?rev=76430&r1=76429&r2=76430&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.inc Mon Jul 20 12:07:01 2009
@@ -23,14 +23,15 @@
extern "C" {
-JNIEXPORT jobject JNICALL Java_gnu_classpath_VMStackWalker_getClassContext(
+JNIEXPORT JavaObject* JNICALL Java_gnu_classpath_VMStackWalker_getClassContext(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
) {
- jobject result = 0;
+ ArrayObject* result = 0;
+ llvm_gcroot(result, 0);
BEGIN_NATIVE_EXCEPTION(0)
@@ -40,7 +41,7 @@
th->getJavaFrameContext(stack);
- ArrayObject* res = (ArrayObject*)
+ result = (ArrayObject*)
vm->upcalls->stackTraceArray->doNew(stack.size(), vm);
std::vector<void*>::iterator i = stack.begin(), e = stack.end();
@@ -49,30 +50,30 @@
for (; i != e; ++i) {
JavaMethod* meth = vm->IPToMethod<JavaMethod>(*i);
assert(meth && "Wrong stack trace");
- res->elements[index++] = meth->classDef->getClassDelegatee(vm);
+ result->elements[index++] = meth->classDef->getClassDelegatee(vm);
}
- result = (jobject)res;
-
END_NATIVE_EXCEPTION
return result;
}
-JNIEXPORT jobject JNICALL Java_gnu_classpath_VMStackWalker_getClassLoader(
+JNIEXPORT JavaObject* JNICALL Java_gnu_classpath_VMStackWalker_getClassLoader(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jclass _Cl) {
+JavaObject* Cl) {
- jobject res = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(Cl, 0);
BEGIN_NATIVE_EXCEPTION(0)
- JavaObject* Cl = (JavaObject*)_Cl;
- UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass();
- res = (jobject)cl->classLoader->getJavaClassLoader();
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+ res = cl->classLoader->getJavaClassLoader();
END_NATIVE_EXCEPTION
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.inc?rev=76430&r1=76429&r2=76430&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.inc Mon Jul 20 12:07:01 2009
@@ -25,17 +25,20 @@
JNIEnv *env,
jclass _cl,
#endif
-jobject _src,
+JavaArray* src,
jint sstart,
-jobject _dst,
+JavaArray* dst,
jint dstart,
jint len) {
-
+
+ JavaObject* cur = 0;
+ llvm_gcroot(src, 0);
+ llvm_gcroot(dst, 0);
+ llvm_gcroot(cur, 0);
+
BEGIN_NATIVE_EXCEPTION(0)
jnjvm::Jnjvm *vm = JavaThread::get()->getJVM();
- JavaArray* src = (JavaArray*)_src;
- JavaArray* dst = (JavaArray*)_dst;
verifyNull(src);
verifyNull(dst);
@@ -72,7 +75,7 @@
bool doThrow = false;
if (!(dstType->isPrimitive())) {
while (i < sstart + len && !doThrow) {
- JavaObject* cur = ((ArrayObject*)src)->elements[i];
+ cur = ((ArrayObject*)src)->elements[i];
if (cur) {
if (!(cur->getClass()->isAssignableFrom(dstType))) {
doThrow = true;
@@ -103,7 +106,9 @@
JNIEnv *env,
jclass clazz,
#endif
-jobject obj) {
+JavaObject* obj) {
+
+ llvm_gcroot(obj, 0);
return (jint)(intptr_t)obj;
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.inc?rev=76430&r1=76429&r2=76430&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.inc Mon Jul 20 12:07:01 2009
@@ -26,6 +26,9 @@
static void setProperty(Jnjvm* vm, JavaObject* prop, const char* key,
const char* val) {
+
+ llvm_gcroot(prop, 0);
+
vm->upcalls->setProperty->invokeIntSpecial(vm, (UserClass*)prop->getClass(),
prop,
vm->asciizToStr(key),
@@ -33,6 +36,9 @@
}
static void setUnameProp(Jnjvm* vm, JavaObject* prop) {
+
+ llvm_gcroot(prop, 0);
+
struct utsname infos;
uname(&infos);
setProperty(vm, prop, "os.name", infos.sysname);
@@ -50,11 +56,12 @@
JNIEnv *env,
jclass clazz,
#endif
-jobject _prop) {
+JavaObject* prop) {
+
+ llvm_gcroot(prop, 0);
BEGIN_NATIVE_EXCEPTION(0)
- JavaObject* prop = (JavaObject*)_prop;
Jnjvm* vm = JavaThread::get()->getJVM();
const char* tmp;
setProperty(vm, prop, "java.vm.specification.version", "1.0");
@@ -126,6 +133,8 @@
extern "C" void nativePropertiesPostInit(JavaObject* prop) {
+ llvm_gcroot(prop, 0);
+
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.inc?rev=76430&r1=76429&r2=76430&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.inc Mon Jul 20 12:07:01 2009
@@ -23,23 +23,26 @@
// Never throws.
// Never calls Java code.
-JNIEXPORT jobject JNICALL Java_java_lang_VMThread_currentThread(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMThread_currentThread(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz
#endif
) {
- return (jobject)(JavaThread::get()->currentThread());
+ return JavaThread::get()->currentThread();
}
static void start(JavaThread* thread) {
+ JavaObject* vmThread = 0;
+ llvm_gcroot(vmThread, 0);
+
Jnjvm* vm = thread->getJVM();
// Ok, now that the thread is created we can set the the value of vmdata,
// which is the JavaThread object.
JavaField* field = vm->upcalls->vmdataVMThread;
- JavaObject* vmThread = thread->vmThread;
+ vmThread = thread->vmThread;
assert(vmThread && "Didn't fix the vmThread of a jnjvm thread");
JavaObject* javaThread = thread->javaThread;
assert(javaThread && "Didn't fix the javaThread of a jnjvm thread");
@@ -76,15 +79,18 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-jobject _vmThread, sint64 stackSize) {
+JavaObject* vmThread, sint64 stackSize) {
+
+ JavaObject* javaThread = 0;
+ llvm_gcroot(vmThread, 0);
+ llvm_gcroot(javaThread, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- JavaObject* vmThread = (JavaObject*)_vmThread;
// Classpath has set this field.
- JavaObject* javaThread = vm->upcalls->assocThread->getObjectField(vmThread);
+ javaThread = vm->upcalls->assocThread->getObjectField(vmThread);
assert(javaThread && "VMThread with no Java equivalent");
JavaThread* th = new JavaThread(javaThread, vmThread, vm);
@@ -98,12 +104,13 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-jobject _vmthread) {
+JavaObject* vmthread) {
+
+ llvm_gcroot(vmthread, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- JavaObject* vmthread = (JavaObject*)_vmthread;
JavaField* field = vm->upcalls->vmdataVMThread;
// It's possible that the thread to be interrupted has not finished
@@ -161,9 +168,11 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-jobject _vmthread) {
+JavaObject* vmthread) {
+
+ llvm_gcroot(vmthread, 0);
+
Jnjvm* vm = JavaThread::get()->getJVM();
- JavaObject* vmthread = (JavaObject*)_vmthread;
JavaField* field = vm->upcalls->vmdataVMThread;
JavaThread* th = (JavaThread*)field->getObjectField(vmthread);
return (jboolean)th->interruptFlag;
@@ -175,8 +184,9 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-jobject vmthread, jint prio) {
+JavaObject* vmthread, jint prio) {
// Currently not implemented
+ llvm_gcroot(vmthread, 0);
}
// Never throws.
@@ -185,8 +195,9 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-jobject vmthread, jobject exc) {
+JavaObject* vmthread, jobject exc) {
// Currently not implemented
+ llvm_gcroot(vmthread, 0);
}
// Never throws.
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.inc?rev=76430&r1=76429&r2=76430&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.inc Mon Jul 20 12:07:01 2009
@@ -28,6 +28,11 @@
extern "C" {
JavaObject* internalFillInStackTrace(JavaObject* throwable) {
+
+ JavaObject* vmThrowable = 0;
+ llvm_gcroot(throwable, 0);
+ llvm_gcroot(vmThrowable, 0);
+
JavaThread* th = JavaThread::get();
Jnjvm* vm = th->getJVM();
@@ -38,24 +43,26 @@
th->getJavaFrameContext(*stack);
// Set the tempory data in the new VMThrowable object.
- JavaObject* vmThrowable = vm->upcalls->newVMThrowable->doNew(vm);
+ vmThrowable = vm->upcalls->newVMThrowable->doNew(vm);
uint64 ptr = (uint64)vmThrowable + vm->upcalls->vmDataVMThrowable->ptrOffset;
((JavaObject**)ptr)[0] = (JavaObject*)stack;
return vmThrowable;
}
-JNIEXPORT jobject JNICALL Java_java_lang_VMThrowable_fillInStackTrace(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMThrowable_fillInStackTrace(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
-jobject throwable) {
+JavaObject* throwable) {
- jobject res = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(throwable, 0);
BEGIN_NATIVE_EXCEPTION(0)
- res = (jobject)internalFillInStackTrace((JavaObject*)throwable);
+ res = internalFillInStackTrace(throwable);
END_NATIVE_EXCEPTION
@@ -64,11 +71,20 @@
static JavaObject* consStackElement(JavaMethod* meth, void* ip) {
+
+ JavaString* methodName = 0;
+ JavaString* className = 0;
+ JavaString* sourceName = 0;
+ JavaObject* res = 0;
+ llvm_gcroot(methodName, 0);
+ llvm_gcroot(className, 0);
+ llvm_gcroot(sourceName, 0);
+ llvm_gcroot(res, 0);
+
Jnjvm* vm = JavaThread::get()->getJVM();
- JavaObject* methodName = vm->internalUTF8ToStr(meth->name);
+ methodName = vm->internalUTF8ToStr(meth->name);
Class* cl = meth->classDef;
- JavaObject* className = JavaString::internalToJava(cl->name, vm);
- JavaObject* sourceName = 0;
+ className = JavaString::internalToJava(cl->name, vm);
Attribut* sourceAtt = cl->lookupAttribut(Attribut::sourceFileAttribut);
@@ -82,7 +98,7 @@
bool native = isNative(meth->access);
UserClass* newS = vm->upcalls->newStackTraceElement;
- JavaObject* res = newS->doNew(vm);
+ res = newS->doNew(vm);
vm->upcalls->initStackTraceElement->invokeIntSpecial(vm, newS, res,
sourceName,
0, // source line
@@ -91,19 +107,22 @@
return res;
}
-JNIEXPORT jobject JNICALL Java_java_lang_VMThrowable_getStackTrace(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMThrowable_getStackTrace(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-jobject vmthrow, jobject throwable) {
+JavaObject* vmthrow, JavaObject* throwable) {
- jobject result = 0;
+ ArrayObject* result = 0;
+ llvm_gcroot(vmthrow, 0);
+ llvm_gcroot(throwable, 0);
+ llvm_gcroot(result, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = vm->upcalls->vmDataVMThrowable;
std::vector<void*>* stack = (std::vector<void*>*)
- field->getObjectField((JavaObject*)vmthrow);
+ field->getObjectField(vmthrow);
std::vector<void*>::iterator i = stack->begin(), e = stack->end();
// remove the VMThrowable.fillInStackTrace method
@@ -118,18 +137,17 @@
} else break;
}
- ArrayObject* res = (ArrayObject*)
+ result = (ArrayObject*)
vm->upcalls->stackTraceArray->doNew(stack->size() - index, vm);
index = 0;
for (; i != e; ++i) {
JavaMethod* meth = vm->IPToMethod<JavaMethod>(*i);
assert(meth && "Wrong stack trace");
- res->elements[index++] = consStackElement(meth, *i);
+ result->elements[index++] = consStackElement(meth, *i);
}
delete stack;
- result = (jobject)res;
END_NATIVE_EXCEPTION
Modified: vmkit/trunk/lib/JnJVM/Classpath/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/JavaUpcalls.cpp?rev=76430&r1=76429&r2=76430&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/JavaUpcalls.cpp Mon Jul 20 12:07:01 2009
@@ -223,12 +223,17 @@
void Classpath::CreateJavaThread(Jnjvm* vm, JavaThread* myth,
const char* thName, JavaObject* Group) {
+ JavaObject* vmth = 0;
+ JavaObject* th = 0;
+ llvm_gcroot(Group, 0);
+ llvm_gcroot(vmth, 0);
+ llvm_gcroot(th, 0);
- JavaObject* th = newThread->doNew(vm);
+ th = newThread->doNew(vm);
myth->javaThread = th;
- JavaObject* vmth = newVMThread->doNew(vm);
+ vmth = newVMThread->doNew(vm);
- threadName->setObjectField(th, (JavaObject*)vm->asciizToStr(thName));
+ threadName->setObjectField(th, vm->asciizToStr(thName));
priority->setInt32Field(th, (uint32)1);
daemon->setInt8Field(th, (uint32)0);
vmThread->setObjectField(th, vmth);
@@ -243,6 +248,14 @@
}
void Classpath::InitializeThreading(Jnjvm* vm) {
+
+ JavaObject* RG = 0;
+ JavaObject* SystemGroup = 0;
+ JavaObject* systemName = 0;
+ llvm_gcroot(RG, 0);
+ llvm_gcroot(SystemGroup, 0);
+ llvm_gcroot(systemName, 0);
+
// Resolve and initialize classes first.
newThread->resolveClass();
newThread->initialiseClass(vm);
@@ -255,14 +268,14 @@
// Create the main thread
void* Stat = threadGroup->getStaticInstance();
- JavaObject* RG = rootGroup->getObjectField(Stat);
+ RG = rootGroup->getObjectField(Stat);
assert(vm->getMainThread() && "VM did not set its main thread");
CreateJavaThread(vm, vm->getMainThread(), "main", RG);
// Create the "system" group.
- JavaObject* SystemGroup = threadGroup->doNew(vm);
+ SystemGroup = threadGroup->doNew(vm);
initGroup->invokeIntSpecial(vm, threadGroup, SystemGroup);
- JavaObject* systemName = (JavaObject*)vm->asciizToStr("system");
+ systemName = vm->asciizToStr("system");
groupName->setObjectField(SystemGroup, systemName);
// Create the finalizer thread.
@@ -276,6 +289,10 @@
extern "C" void nativeInitWeakReference(JavaObjectReference* reference,
JavaObject* referent) {
+
+ llvm_gcroot(reference, 0);
+ llvm_gcroot(referent, 0);
+
reference->init(referent, 0);
JavaThread::get()->getJVM()->addWeakReference(reference);
@@ -284,6 +301,10 @@
extern "C" void nativeInitWeakReferenceQ(JavaObjectReference* reference,
JavaObject* referent,
JavaObject* queue) {
+ llvm_gcroot(reference, 0);
+ llvm_gcroot(referent, 0);
+ llvm_gcroot(queue, 0);
+
reference->init(referent, queue);
JavaThread::get()->getJVM()->addWeakReference(reference);
@@ -291,6 +312,9 @@
extern "C" void nativeInitSoftReference(JavaObjectReference* reference,
JavaObject* referent) {
+ llvm_gcroot(reference, 0);
+ llvm_gcroot(referent, 0);
+
reference->init(referent, 0);
JavaThread::get()->getJVM()->addSoftReference(reference);
@@ -299,6 +323,10 @@
extern "C" void nativeInitSoftReferenceQ(JavaObjectReference* reference,
JavaObject* referent,
JavaObject* queue) {
+ llvm_gcroot(reference, 0);
+ llvm_gcroot(referent, 0);
+ llvm_gcroot(queue, 0);
+
reference->init(referent, queue);
JavaThread::get()->getJVM()->addSoftReference(reference);
@@ -307,25 +335,36 @@
extern "C" void nativeInitPhantomReferenceQ(JavaObjectReference* reference,
JavaObject* referent,
JavaObject* queue) {
+ llvm_gcroot(reference, 0);
+ llvm_gcroot(referent, 0);
+ llvm_gcroot(queue, 0);
+
reference->init(referent, queue);
JavaThread::get()->getJVM()->addPhantomReference(reference);
}
extern "C" JavaString* nativeInternString(JavaString* obj) {
+ const ArrayUInt16* array = 0;
+ llvm_gcroot(obj, 0);
+ llvm_gcroot(array, 0);
+
Jnjvm* vm = JavaThread::get()->getJVM();
- const ArrayUInt16* array = obj->strToArray(vm);
+ array = obj->strToArray(vm);
return vm->constructString(array);
}
-extern "C" uint8 nativeIsArray(JavaObject* klass) {
- UserCommonClass* cl = ((JavaObjectClass*)klass)->getClass();
+extern "C" uint8 nativeIsArray(JavaObjectClass* klass) {
+ llvm_gcroot(klass, 0);
+
+ UserCommonClass* cl = klass->getClass();
return (uint8)cl->isArray();
}
extern "C" JavaObject* nativeGetCallingClass() {
JavaObject* res = 0;
+ llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
@@ -340,6 +379,7 @@
extern "C" JavaObject* nativeGetCallingClassLoader() {
JavaObject *res = 0;
+ llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
JavaThread* th = JavaThread::get();
@@ -352,6 +392,7 @@
extern "C" JavaObject* nativeFirstNonNullClassLoader() {
JavaObject *res = 0;
+ llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
JavaThread* th = JavaThread::get();
@@ -364,6 +405,7 @@
extern "C" JavaObject* nativeGetCallerClass(uint32 index) {
JavaObject *res = 0;
+ llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(0)
JavaThread* th = JavaThread::get();
@@ -376,6 +418,7 @@
}
extern "C" JavaObject* nativeGetAnnotation(JavaObject* obj) {
+ llvm_gcroot(obj, 0);
return 0;
}
@@ -416,6 +459,8 @@
extern "C" ArrayObject* nativeGetBootPackages();
extern "C" JavaString* nativeGetenv(JavaString* str) {
+ llvm_gcroot(str, 0);
+
char* buf = str->strToAsciiz();
char* res = getenv(buf);
delete[] buf;
More information about the vmkit-commits
mailing list