[vmkit-commits] [vmkit] r54779 - in /vmkit/trunk/lib/JnJVM: Classpath/ VMCore/
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Thu Aug 14 08:58:57 PDT 2008
Author: geoffray
Date: Thu Aug 14 10:58:53 2008
New Revision: 54779
URL: http://llvm.org/viewvc/llvm-project?rev=54779&view=rev
Log:
Major rewrite of class loading in jnjvm. Now, each class is
linked with a JnjvmClassLoader instead of the Java object loader.
The Java object loader is referenced by the JnjvmClassLoader.
All class loading, reading and resolution is done by a JnjvmClassLoader.
The default class loader, of type JnjvmBootstrapLoader contains
additional infos: the boot classpath and the classpath libraries
environment.
TODOs:
1) Find a clean way to protect the boot class loader from GC. Currently, it
is protected by instances of JavaIsolate.
2) Merge JavaIsolate and Jnjvm.
3) Clean which allocator is used when allocating UTF8 (and also Strings).
Added:
vmkit/trunk/lib/JnJVM/VMCore/JavaAllocator.h
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h
Modified:
vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp
vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc
vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h
vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h
vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h
vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.h
vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h
vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h
vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.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/JnjvmModule.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp
vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp
vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h
vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp
vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h
vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp
vmkit/trunk/lib/JnJVM/VMCore/Reader.h
vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp
vmkit/trunk/lib/JnJVM/VMCore/Zip.h
Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp Thu Aug 14 10:58:53 2008
@@ -166,11 +166,11 @@
{
Jnjvm* vm = JavaThread::get()->isolate;
CommonClass* base = NativeUtil::resolvedImplClass(arrayType, true);
- JavaObject* loader = base->classLoader;
+ JnjvmClassLoader* loader = base->classLoader;
const UTF8* name = base->name;
- const UTF8* arrayName = AssessorDesc::constructArrayName(vm, 0, 1, name);
- ClassArray* array = vm->constructArray(arrayName, loader);
- ArrayObject* res = ArrayObject::acons(arrayLength, array, vm);
+ const UTF8* arrayName = AssessorDesc::constructArrayName(loader, 0, 1, name);
+ ClassArray* array = loader->constructArray(arrayName);
+ ArrayObject* res = ArrayObject::acons(arrayLength, array, &(vm->allocator));
return (jobject) res;
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc Thu Aug 14 10:58:53 2008
@@ -19,6 +19,7 @@
#include "JavaThread.h"
#include "JavaUpcalls.h"
#include "Jnjvm.h"
+#include "JnjvmClassLoader.h"
#include "NativeUtil.h"
using namespace jnjvm;
@@ -32,7 +33,7 @@
#endif
jobject cons) {
JavaMethod* meth = (JavaMethod*)(Classpath::constructorSlot->getVirtualInt32Field((JavaObject*)cons));
- JavaObject* loader = meth->classDef->classLoader;
+ JnjvmClassLoader* loader = meth->classDef->classLoader;
return (jobject)(NativeUtil::getParameterTypes(loader, meth));
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc Thu Aug 14 10:58:53 2008
@@ -19,6 +19,7 @@
#include "JavaThread.h"
#include "JavaUpcalls.h"
#include "Jnjvm.h"
+#include "JnjvmClassLoader.h"
#include "NativeUtil.h"
using namespace jnjvm;
@@ -40,7 +41,7 @@
#endif
jobject Meth) {
JavaMethod* meth = (JavaMethod*)Classpath::methodSlot->getVirtualInt32Field((JavaObject*)Meth);
- JavaObject* loader = meth->classDef->classLoader;
+ JnjvmClassLoader* loader = meth->classDef->classLoader;
return (jclass)NativeUtil::getClassType(loader, meth->getSignature()->ret);
}
@@ -52,7 +53,7 @@
jobject Meth) {
JavaMethod* meth = (JavaMethod*)Classpath::methodSlot->getVirtualInt32Field((JavaObject*)Meth);
- JavaObject* loader = meth->classDef->classLoader;
+ JnjvmClassLoader* loader = meth->classDef->classLoader;
return (jobject)(NativeUtil::getParameterTypes(loader, meth));
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc Thu Aug 14 10:58:53 2008
@@ -52,17 +52,17 @@
jboolean clinit,
jobject loader) {
- Jnjvm* vm = JavaThread::get()->isolate;
- CommonClass* cl = vm->lookupClassFromJavaString((JavaString*)str,
- (JavaObject*)loader, true,
- false, false);
+
+ JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader);
+ CommonClass* cl = JCL->lookupClassFromJavaString((JavaString*)str,
+ true, false, false);
if (cl != 0) {
if (clinit) {
cl->initialiseClass();
}
return (jclass)(cl->getClassDelegatee());
} else {
- vm->error(Jnjvm::ClassNotFoundException, "unable to load %s",
+ JavaThread::get()->isolate->error(Jnjvm::ClassNotFoundException, "unable to load %s",
((JavaString*)str)->strToAsciiz());
return 0;
}
@@ -81,7 +81,7 @@
Jnjvm* vm = JavaThread::get()->isolate;
if (cl->isArray || isInterface(cl->access)) {
- return (jobject)ArrayObject::acons(0, Classpath::constructorArrayClass, vm);
+ return (jobject)ArrayObject::acons(0, Classpath::constructorArrayClass, &(vm->allocator));
} else {
CommonClass::method_map meths = cl->virtualMethods;
std::vector<JavaMethod*> res;
@@ -93,7 +93,7 @@
}
}
- ArrayObject* ret = ArrayObject::acons(res.size(), Classpath::constructorArrayClass, vm);
+ ArrayObject* ret = ArrayObject::acons(res.size(), Classpath::constructorArrayClass, &(vm->allocator));
sint32 index = 0;
for (std::vector<JavaMethod*>::iterator i = res.begin(), e = res.end();
i != e; ++i, ++index) {
@@ -120,7 +120,7 @@
CommonClass* cl = NativeUtil::resolvedImplClass(Cl, false);
if (cl->isArray) {
- return (jobject)ArrayObject::acons(0, Classpath::methodArrayClass, vm);
+ return (jobject)ArrayObject::acons(0, Classpath::methodArrayClass, &(vm->allocator));
} else {
CommonClass::method_map meths = cl->virtualMethods;
std::vector<JavaMethod*> res;
@@ -140,7 +140,7 @@
}
}
- ArrayObject* ret = ArrayObject::acons(res.size(), Classpath::methodArrayClass, vm);
+ ArrayObject* ret = ArrayObject::acons(res.size(), Classpath::methodArrayClass, &(vm->allocator));
sint32 index = 0;
for (std::vector<JavaMethod*>::iterator i = res.begin(), e = res.end();
i != e; ++i, ++index) {
@@ -178,7 +178,7 @@
(CommonClass*)Classpath::vmdataClass->getVirtualObjectField((JavaObject*)Cl);
const UTF8* iname = cl->name;
- const UTF8* res = iname->internalToJava(vm, 0, iname->size);
+ const UTF8* res = iname->internalToJava(cl->classLoader->hashUTF8, 0, iname->size);
return (jobject)(vm->UTF8ToStr(res));
}
@@ -231,7 +231,7 @@
jclass Cl) {
CommonClass* cl =
(CommonClass*)Classpath::vmdataClass->getVirtualObjectField((JavaObject*)Cl);
- return (jobject)cl->classLoader;
+ return (jobject)cl->classLoader->getJavaClassLoader();
}
JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isAssignableFrom(
@@ -288,7 +288,7 @@
CommonClass* cl = NativeUtil::resolvedImplClass(Cl, false);
if (cl->isArray) {
- return (jobject)ArrayObject::acons(0, Classpath::fieldArrayClass, vm);
+ return (jobject)ArrayObject::acons(0, Classpath::fieldArrayClass, &(vm->allocator));
} else {
CommonClass::field_map fields = cl->virtualFields;
std::vector<JavaField*> res;
@@ -309,7 +309,7 @@
}
ArrayObject* ret = ArrayObject::acons(res.size(),
- Classpath::fieldArrayClass, vm);
+ Classpath::fieldArrayClass, &(vm->allocator));
sint32 index = 0;
for (std::vector<JavaField*>::iterator i = res.begin(), e = res.end();
i != e; ++i, ++index) {
@@ -333,7 +333,7 @@
Jnjvm* vm = JavaThread::get()->isolate;
CommonClass* cl = NativeUtil::resolvedImplClass(Cl, false);
std::vector<Class*> & interfaces = cl->interfaces;
- ArrayObject* ret = ArrayObject::acons(interfaces.size(), Classpath::classArrayClass, vm);
+ ArrayObject* ret = ArrayObject::acons(interfaces.size(), Classpath::classArrayClass, &(vm->allocator));
sint32 index = 0;
for (std::vector<Class*>::iterator i = interfaces.begin(), e = interfaces.end();
i != e; ++i, ++index) {
@@ -397,7 +397,7 @@
Class* cl = (Class*)NativeUtil::resolvedImplClass(Cl, false);
if (!(cl->innerOuterResolved))
resolveInnerOuterClasses(cl);
- ArrayObject* res = ArrayObject::acons(cl->innerClasses.size(), Classpath::constructorArrayClass, vm);
+ ArrayObject* res = ArrayObject::acons(cl->innerClasses.size(), Classpath::constructorArrayClass, &(vm->allocator));
uint32 index = 0;
for (std::vector<Class*>::iterator i = cl->innerClasses.begin(),
e = cl->innerClasses.end(); i!= e; i++) {
@@ -425,7 +425,7 @@
jclass Cl) {
// TODO implement me
Jnjvm* vm = JavaThread::get()->isolate;
- ArrayObject* res = ArrayObject::acons(0, Classpath::constructorArrayAnnotation, vm);
+ ArrayObject* res = ArrayObject::acons(0, Classpath::constructorArrayAnnotation, &(vm->allocator));
return (jobjectArray)res;
}
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc Thu Aug 14 10:58:53 2008
@@ -52,7 +52,8 @@
Jnjvm* vm = JavaThread::get()->isolate;
JavaString* name = (JavaString*)_name;
const UTF8* utf8 = name->strToUTF8(vm);
- CommonClass* cl = vm->lookupClass(utf8, (JavaObject*)loader);
+ JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader);
+ CommonClass* cl = JCL->lookupClass(utf8);
if (cl) return (jclass)(cl->getClassDelegatee());
else return 0;
@@ -66,9 +67,9 @@
jobject _str,
jboolean doResolve) {
JavaString* str = (JavaString*)_str;
- Jnjvm* vm = JavaThread::get()->isolate;
- CommonClass* cl = vm->lookupClassFromJavaString(str, 0, doResolve, false, false);
+ JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader;
+ CommonClass* cl = JCL->lookupClassFromJavaString(str, doResolve, false, false);
if (cl != 0) {
return (jclass)cl->getClassDelegatee();
@@ -88,10 +89,10 @@
jint off,
jint len,
jobject pd) {
- Jnjvm* vm = JavaThread::get()->isolate;
+ JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader);
JavaString* str = (JavaString*)_str;
- const UTF8* name = str->value->javaToInternal(vm, str->offset, str->count);
- Class* cl = vm->constructClass(name, (JavaObject*)loader);
+ const UTF8* name = str->value->javaToInternal(JCL->hashUTF8, str->offset, str->count);
+ Class* cl = JCL->constructClass(name);
if (cl->status == hashed) {
cl->acquire();
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc Thu Aug 14 10:58:53 2008
@@ -34,7 +34,7 @@
#endif
jobject obj) {
JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)obj);
- JavaObject* loader = field->classDef->classLoader;
+ JnjvmClassLoader* loader = field->classDef->classLoader;
CommonClass* cl = field->getSignature()->assocClass(loader);
return (jclass)cl->getClassDelegatee();
}
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc Thu Aug 14 10:58:53 2008
@@ -40,7 +40,7 @@
size = cl->virtualSize;
}
JavaObject* res = (JavaObject*)
- JavaThread::get()->isolate->allocateObject(size, src->getVirtualTable());
+ JavaThread::get()->isolate->allocator.allocateObject(size, src->getVirtualTable());
memcpy(res, src, size);
res->lock = 0;
return (jobject)res;
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc Thu Aug 14 10:58:53 2008
@@ -51,7 +51,8 @@
memmove(&(elements[lgPre]), &(utf8Lib->elements[stLib]), lgLib * sizeof(uint16));
memmove(&(elements[lgPre + lgLib]), vm->postlib->elements, lgPost * sizeof(uint16));
- const UTF8* res = vm->readerConstructUTF8(elements, size);
+ // TODO: find a better place to store the UTF8
+ const UTF8* res = JnjvmClassLoader::bootstrapLoader->readerConstructUTF8(elements, size);
return (jobject)(vm->UTF8ToStr(res));
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc Thu Aug 14 10:58:53 2008
@@ -40,7 +40,7 @@
}
} else {
Jnjvm* vm = JavaThread::get()->isolate;
- return ArrayObject::acons(rec, Classpath::classArrayClass, vm);
+ return ArrayObject::acons(rec, Classpath::classArrayClass, &(vm->allocator));
}
}
@@ -75,7 +75,7 @@
jclass _Cl) {
JavaObject* Cl = (JavaObject*)_Cl;
CommonClass* cl = (CommonClass*)Classpath::vmdataClass->getVirtualObjectField(Cl);
- return (jobject)cl->classLoader;
+ return (jobject)cl->classLoader->getJavaClassLoader();
}
extern "C" JavaObject* getCallingClass() {
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc Thu Aug 14 10:58:53 2008
@@ -70,16 +70,17 @@
tmp = getenv("JAVA_HOME");
if (!tmp) tmp = "";
setProperty(vm, prop, "java.home", tmp);
-
+
+ JnjvmBootstrapLoader* JCL = JnjvmClassLoader::bootstrapLoader;
setProperty(vm, prop, "java.class.version", "49.0");
setProperty(vm, prop, "java.class.path", vm->classpath);
- setProperty(vm, prop, "java.boot.class.path", vm->bootClasspathEnv);
- setProperty(vm, prop, "sun.boot.class.path", vm->bootClasspathEnv);
+ setProperty(vm, prop, "java.boot.class.path", JCL->bootClasspathEnv);
+ setProperty(vm, prop, "sun.boot.class.path", JCL->bootClasspathEnv);
setProperty(vm, prop, "java.vm.version", "2.0");
setProperty(vm, prop, "java.vm.vendor", "VVM Project");
setProperty(vm, prop, "java.vm.name", "JnJVM");
setProperty(vm, prop, "java.specification.version", "1.5");
- setProperty(vm, prop, "java.library.path", vm->libClasspathEnv);
+ setProperty(vm, prop, "java.library.path", JCL->libClasspathEnv);
setProperty(vm, prop, "java.io.tmpdir", "/tmp");
tmp = getenv("JAVA_COMPILER");
@@ -87,7 +88,7 @@
setProperty(vm, prop, "java.compiler", tmp);
setProperty(vm, prop, "build.compiler", "gcj");
- setProperty(vm, prop, "gcj.class.path", vm->bootClasspathEnv);
+ setProperty(vm, prop, "gcj.class.path", JCL->bootClasspathEnv);
setUnameProp(vm, prop);
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc Thu Aug 14 10:58:53 2008
@@ -113,7 +113,7 @@
assert(javaThread);
Jnjvm* vm = JavaThread::get()->isolate;
- JavaThread* th = vm_new(vm, JavaThread)();
+ JavaThread* th = allocator_new(vm->allocator, JavaThread)();
th->initialise(javaThread, vm);
ClasspathThread::vmdata->setVirtualObjectField(vmThread, (JavaObject*)th);
int tid = 0;
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc Thu Aug 14 10:58:53 2008
@@ -51,7 +51,7 @@
Jnjvm* vm = JavaThread::get()->isolate;
JavaObject* methodName = vm->UTF8ToStr(meth->name);
Class* cl = meth->classDef;
- JavaObject* className = vm->UTF8ToStr(cl->name->internalToJava(vm, 0, cl->name->size));
+ JavaObject* className = vm->UTF8ToStr(cl->name->internalToJava(cl->classLoader->hashUTF8, 0, cl->name->size));
JavaObject* sourceName = 0;
Attribut* sourceAtt = cl->lookupAttribut(Attribut::sourceFileAttribut);
@@ -83,7 +83,7 @@
return recGetStackTrace(stack, first + 1, rec);
}
} else {
- return ArrayObject::acons(rec, Classpath::stackTraceArray, vm);
+ return ArrayObject::acons(rec, Classpath::stackTraceArray, &(vm->allocator));
}
}
Added: vmkit/trunk/lib/JnJVM/VMCore/JavaAllocator.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaAllocator.h?rev=54779&view=auto
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaAllocator.h (added)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaAllocator.h Thu Aug 14 10:58:53 2008
@@ -0,0 +1,45 @@
+//===------- JavaAllocator.h - A memory allocator for Jnjvm ---------------===//
+//
+// JnJVM
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef JNJVM_JAVA_ALLOCATOR_H
+#define JNJVM_JAVA_ALLOCATOR_H
+
+#include "MvmGC.h"
+
+#ifdef MULTIPLE_GC
+#define allocator_new(alloc, cl) collector_new(cl, alloc.GC)
+#else
+#define allocator_new(alloc, cl) gc_new(cl)
+#endif
+
+namespace jnjvm {
+
+class JavaAllocator {
+
+#ifdef MULTIPLE_GC
+ Collector* GC;
+#endif
+
+public:
+
+#ifndef MULTIPLE_GC
+ void* allocateObject(unsigned int sz, VirtualTable* VT) {
+ return gc::operator new(sz, VT);
+ }
+#else
+ void* allocateObject(unsigned int sz, VirtualTable* VT) {
+ return gc::operator new(sz, VT, GC);
+ }
+#endif
+
+};
+
+} // end namespace jnjvm
+
+#endif // JNJVM_JAVA_ALLOCATOR_H
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp Thu Aug 14 10:58:53 2008
@@ -16,6 +16,7 @@
#include "JavaTypes.h"
#include "Jnjvm.h"
#include "JavaThread.h"
+#include "LockedMap.h"
using namespace jnjvm;
@@ -49,30 +50,30 @@
extern "C" void outOfMemoryError(sint32 val);
#ifndef MULTIPLE_VM
-#define ACONS(name, elmt, primSize, VT) \
- name *name::acons(sint32 n, ClassArray* atype, Jnjvm* vm) { \
- if (n < 0) \
- negativeArraySizeException(n); \
- else if (n > JavaArray::MaxArraySize) \
- outOfMemoryError(n); \
- name* res = (name*) \
- (Object*) operator new(sizeof(name) + n * primSize, VT); \
- res->initialise(atype); \
- res->size = n; \
- return res; \
+#define ACONS(name, elmt, primSize, VT) \
+ name *name::acons(sint32 n, ClassArray* atype, JavaAllocator* allocator) { \
+ if (n < 0) \
+ negativeArraySizeException(n); \
+ else if (n > JavaArray::MaxArraySize) \
+ outOfMemoryError(n); \
+ name* res = (name*) \
+ (Object*) allocator->allocateObject(sizeof(name) + n * primSize, VT); \
+ res->initialise(atype); \
+ res->size = n; \
+ return res; \
}
#else
-#define ACONS(name, elmt, primSize, VT) \
- name *name::acons(sint32 n, ClassArray* atype, Jnjvm* vm) { \
- if (n < 0) \
- negativeArraySizeException(n); \
- else if (n > JavaArray::MaxArraySize) \
- outOfMemoryError(n); \
- name* res = (name*) \
- (Object*) vm->allocateObject(sizeof(name) + n * primSize, VT); \
- res->initialise(atype); \
- res->size = n; \
- return res; \
+#define ACONS(name, elmt, primSize, VT) \
+ name *name::acons(sint32 n, ClassArray* atype, JavaAllocator* allocator) { \
+ if (n < 0) \
+ negativeArraySizeException(n); \
+ else if (n > JavaArray::MaxArraySize) \
+ outOfMemoryError(n); \
+ name* res = (name*) \
+ (Object*) allocator->allocateObject(sizeof(name) + n * primSize, VT); \
+ res->initialise(atype); \
+ res->size = n; \
+ return res; \
}
#endif
@@ -100,7 +101,7 @@
buf->writeChar((char)elements[i]);
}
-const UTF8* UTF8::javaToInternal(Jnjvm* vm, unsigned int start,
+const UTF8* UTF8::javaToInternal(UTF8Map* map, unsigned int start,
unsigned int len) const {
uint16* java = (uint16*) alloca(len * sizeof(uint16));
for (uint32 i = 0; i < len; i++) {
@@ -109,10 +110,10 @@
else java[i] = cur;
}
- return readerConstruct(vm, java, len);
+ return map->lookupOrCreateReader(java, len);
}
-const UTF8* UTF8::internalToJava(Jnjvm *vm, unsigned int start,
+const UTF8* UTF8::internalToJava(UTF8Map* map, unsigned int start,
unsigned int len) const {
uint16* java = (uint16*) alloca(len * sizeof(uint16));
for (uint32 i = 0; i < len; i++) {
@@ -121,10 +122,10 @@
else java[i] = cur;
}
- return readerConstruct(vm, java, len);
+ return map->lookupOrCreateReader(java, len);
}
-const UTF8* UTF8::extract(Jnjvm *vm, uint32 start, uint32 end) const {
+const UTF8* UTF8::extract(UTF8Map* map, uint32 start, uint32 end) const {
uint32 len = end - start;
uint16* buf = (uint16*)alloca(sizeof(uint16) * len);
@@ -132,15 +133,7 @@
buf[i] = elements[i + start];
}
- return readerConstruct(vm, buf, len);
-}
-
-const UTF8* UTF8::asciizConstruct(Jnjvm* vm, char* asciiz) {
- return vm->asciizConstructUTF8(asciiz);
-}
-
-const UTF8* UTF8::readerConstruct(Jnjvm* vm, uint16* buf, uint32 n) {
- return vm->readerConstructUTF8(buf, n);
+ return map->lookupOrCreateReader(buf, len);
}
char* UTF8::UTF8ToAsciiz() const {
@@ -167,13 +160,13 @@
free(obj);
}
-const UTF8* UTF8::acons(sint32 n, ClassArray* cl, Jnjvm* vm) {
+const UTF8* UTF8::acons(sint32 n, ClassArray* cl, JavaAllocator* allocator) {
if (n < 0)
negativeArraySizeException(n);
else if (n > JavaArray::MaxArraySize)
outOfMemoryError(n);
UTF8* res = new (n) UTF8();
- res->initialise(cl);
+ res->initialise(cl);
res->size = n;
return (const UTF8*)res;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h Thu Aug 14 10:58:53 2008
@@ -24,6 +24,7 @@
class ClassArray;
class CommonClass;
+class JavaAllocator;
class JavaObject;
class Jnjvm;
@@ -91,7 +92,7 @@
#define ARRAYCLASS(name, elmt) \
class name : public TJavaArray<elmt> { \
public: \
- static name* acons(sint32 n, ClassArray* cl, Jnjvm* vm); \
+ static name* acons(sint32 n, ClassArray* cl, JavaAllocator* allocator); \
}
ARRAYCLASS(ArrayUInt8, uint8);
@@ -116,7 +117,7 @@
/// acons - Allocates a Java array of objects. The class given as argument is
/// the class of the array, not the class of its elements.
- static ArrayObject* acons(sint32 n, ClassArray* cl, Jnjvm* vm);
+ static ArrayObject* acons(sint32 n, ClassArray* cl, JavaAllocator* allocator);
/// tracer - The tracer method of Java arrays of objects. This method will
/// trace all objects in the array.
@@ -133,32 +134,25 @@
/// acons - Allocates an UTF8 in permanent memory. The class argument must be
/// JavaArray::ofChar.
- static const UTF8* acons(sint32 n, ClassArray* cl, Jnjvm* vm);
+ static const UTF8* acons(sint32 n, ClassArray* cl, JavaAllocator* allocator);
/// internalToJava - Creates a copy of the UTF8 at its given offset and size
/// woth all its '.' replaced by '/'. The JVM bytecode reference classes in
/// packages with the '.' as the separating character. The JVM language uses
/// the '/' character.
- const UTF8* internalToJava(Jnjvm *vm, unsigned int start,
+ const UTF8* internalToJava(UTF8Map* map, unsigned int start,
unsigned int len) const;
/// javaToInternal - Replaces all '/' into '.'.
- const UTF8* javaToInternal(Jnjvm *vm, unsigned int start,
+ const UTF8* javaToInternal(UTF8Map* map, unsigned int start,
unsigned int len) const;
/// UTF8ToAsciiz - Allocates a C string with the contents of this UTF8.
char* UTF8ToAsciiz() const;
- /// asciizConstruct - Constructs an UTF8 with the given C string.
- static const UTF8* asciizConstruct(Jnjvm *vm, char* asciiz);
-
- /// readerConstruct - Constructs an UTF8 with the given buffer and size.
- /// This function is called when parsing JVM bytecode.
- static const UTF8* readerConstruct(Jnjvm *vm, uint16* buf, uint32 n);
-
/// extract - Creates an UTF8 by extracting the contents at the given size
/// of this.
- const UTF8* extract(Jnjvm *vm, uint32 start, uint32 len) const;
+ const UTF8* extract(UTF8Map* map, uint32 start, uint32 len) const;
/// equals - Returns whether two UTF8s are equals. When the JnJVM executes
/// in single mode, equality is just a pointer comparison. When executing
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp Thu Aug 14 10:58:53 2008
@@ -106,5 +106,5 @@
JavaObject* JavaJIT::getCallingClassLoader() {
Class* cl = getCallingClassWalker();
if (!cl) return 0;
- else return cl->classLoader;
+ else return cl->classLoader->getJavaClassLoader();
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Thu Aug 14 10:58:53 2008
@@ -36,8 +36,6 @@
const UTF8* Attribut::innerClassesAttribut = 0;
const UTF8* Attribut::sourceFileAttribut = 0;
-JavaObject* CommonClass::jnjvmClassLoader = 0;
-
CommonClass* ClassArray::SuperArray = 0;
std::vector<Class*> ClassArray::InterfacesArray;
@@ -97,7 +95,6 @@
CommonClass::CommonClass() {
display = 0;
- isolate = 0;
lockVar = 0;
condVar = 0;
virtualVT = 0;
@@ -206,12 +203,12 @@
buf->write(">");
}
-CommonClass::CommonClass(Jnjvm* vm, const UTF8* n, bool isArray) {
+CommonClass::CommonClass(JnjvmClassLoader* loader, const UTF8* n, bool isArray) {
name = n;
this->lockVar = mvm::Lock::allocRecursive();
this->condVar = mvm::Cond::allocCond();
this->status = hashed;
- this->isolate = vm;
+ this->classLoader = loader;
this->isArray = isArray;
this->isPrimitive = false;
#ifndef MULTIPLE_VM
@@ -219,8 +216,8 @@
#endif
}
-ClassPrimitive::ClassPrimitive(Jnjvm* vm, const UTF8* n) :
- CommonClass(vm, n, false) {
+ClassPrimitive::ClassPrimitive(JnjvmClassLoader* loader, const UTF8* n) :
+ CommonClass(loader, n, false) {
display = (CommonClass**)malloc(sizeof(CommonClass*));
display[0] = this;
@@ -229,8 +226,7 @@
access = ACC_ABSTRACT | ACC_FINAL | ACC_PUBLIC;
}
-Class::Class(Jnjvm* vm, const UTF8* n) : CommonClass(vm, n, false) {
- classLoader = 0;
+Class::Class(JnjvmClassLoader* loader, const UTF8* n) : CommonClass(loader, n, false) {
bytes = 0;
super = 0;
ctpInfo = 0;
@@ -239,8 +235,7 @@
#endif
}
-ClassArray::ClassArray(Jnjvm* vm, const UTF8* n) : CommonClass(vm, n, true) {
- classLoader = 0;
+ClassArray::ClassArray(JnjvmClassLoader* loader, const UTF8* n) : CommonClass(loader, n, true) {
_funcs = 0;
_baseClass = 0;
super = ClassArray::SuperArray;
@@ -266,24 +261,24 @@
}
void ClassArray::resolveComponent() {
- AssessorDesc::introspectArray(isolate, classLoader, name, 0, _funcs,
+ AssessorDesc::introspectArray(classLoader, name, 0, _funcs,
_baseClass);
}
-JavaObject* ClassArray::arrayLoader(Jnjvm* isolate, const UTF8* name,
- JavaObject* loader,
- unsigned int start, unsigned int len) {
+JnjvmClassLoader* ClassArray::arrayLoader(const UTF8* name,
+ JnjvmClassLoader* loader,
+ unsigned int start,
+ unsigned int len) {
if (name->elements[start] == AssessorDesc::I_TAB) {
- return arrayLoader(isolate, name, loader, start + 1, len - 1);
+ return arrayLoader(name, loader, start + 1, len - 1);
} else if (name->elements[start] == AssessorDesc::I_REF) {
- const UTF8* componentName = name->javaToInternal(isolate, start + 1,
+ const UTF8* componentName = name->javaToInternal(loader->hashUTF8, start + 1,
len - 2);
- CommonClass* cl = isolate->loadName(componentName, loader, false, false,
- true);
+ CommonClass* cl = loader->loadName(componentName, false, false, true);
return cl->classLoader;
} else {
- return 0;
+ return JnjvmClassLoader::bootstrapLoader;
}
}
@@ -293,7 +288,7 @@
classDef->acquire();
if (code == 0) {
code =
- classDef->isolate->TheModuleProvider->materializeFunction(this);
+ classDef->classLoader->TheModuleProvider->materializeFunction(this);
}
classDef->release();
return code;
@@ -405,7 +400,7 @@
JavaObject* Class::doNew(Jnjvm* vm) {
assert(this->isReady() && "Uninitialized class when allocating.");
- JavaObject* res = (JavaObject*)vm->allocateObject(virtualSize, virtualVT);
+ JavaObject* res = (JavaObject*)vm->allocator.allocateObject(virtualSize, virtualVT);
res->classOf = this;
return res;
}
@@ -436,16 +431,14 @@
while (res && Tname->elements[prof] == AssessorDesc::I_TAB) {
CommonClass* cl = ((ClassArray*)curS)->baseClass();
- Jnjvm *vm = cl->isolate;
++prof;
- vm->resolveClass(cl, false);
+ classLoader->resolveClass(cl, false);
res = curS->isArray && cl && (prof < len);
curS = cl;
}
- Jnjvm *vm = this->isolate;
return (Tname->elements[prof] == AssessorDesc::I_REF) &&
- (res && curS->inheritName(Tname->extract(vm, prof + 1, len - 1)));
+ (res && curS->inheritName(Tname->extract(classLoader->hashUTF8, prof + 1, len - 1)));
} else {
return false;
}
@@ -540,11 +533,11 @@
}
void CommonClass::resolveClass(bool doClinit) {
- isolate->resolveClass(this, doClinit);
+ classLoader->resolveClass(this, doClinit);
}
void CommonClass::initialiseClass() {
- return isolate->initialiseClass(this);
+ return JavaThread::get()->isolate->initialiseClass(this);
}
#ifdef MULTIPLE_VM
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Thu Aug 14 10:58:53 2008
@@ -23,7 +23,7 @@
#include "mvm/Threads/Locks.h"
#include "JavaAccess.h"
-#include "Jnjvm.h"
+#include "JnjvmClassLoader.h"
namespace jnjvm {
@@ -200,10 +200,6 @@
///
const UTF8* name;
- /// isolate - Which isolate defined this class.
- ///
- Jnjvm *isolate;
-
/// status - The loading/resolve/initialization state of the class.
///
JavaState status;
@@ -233,9 +229,9 @@
/// process of this class, done by another thread.
mvm::Cond* condVar;
- /// classLoader - The Java class loader that loaded the class.
+ /// classLoader - The Jnjvm class loader that loaded the class.
///
- JavaObject* classLoader;
+ JnjvmClassLoader* classLoader;
#ifndef MULTIPLE_VM
/// delegatee - The java/lang/Class object representing this class
@@ -418,17 +414,13 @@
/// CommonClass - Create a class with th given name.
///
- CommonClass(Jnjvm* vm, const UTF8* name, bool isArray);
+ CommonClass(JnjvmClassLoader* loader, const UTF8* name, bool isArray);
/// VT - The virtual table of instances of this class (TODO: should be
/// removed).
///
static VirtualTable* VT;
- /// jnjvmClassLoader - The bootstrap class loader (null).
- ///
- static JavaObject* jnjvmClassLoader;
-
/// ~CommonClass - Free memory used by this class, and remove it from
/// metadata.
///
@@ -457,7 +449,7 @@
///
class ClassPrimitive : public CommonClass {
public:
- ClassPrimitive(Jnjvm* vm, const UTF8* name);
+ ClassPrimitive(JnjvmClassLoader* loader, const UTF8* name);
};
@@ -557,7 +549,7 @@
/// Class - Create a class in the given virtual machine and with the given
/// name.
- Class(Jnjvm* vm, const UTF8* name);
+ Class(JnjvmClassLoader* loader, const UTF8* name);
};
@@ -606,16 +598,17 @@
/// ClassArray - Construct a Java array class with the given name.
///
- ClassArray(Jnjvm* vm, const UTF8* name);
+ ClassArray(JnjvmClassLoader* loader, const UTF8* name);
/// arrayLoader - Return the class loader of the class with the name 'name'.
/// If the class has not been loaded, load it with the given loader and
/// return the real class loader that loaded this class.
///
- static JavaObject* arrayLoader(Jnjvm* isolate, const UTF8* name,
- JavaObject* loader, unsigned int start,
- unsigned int end);
+ static JnjvmClassLoader* arrayLoader(const UTF8* name,
+ JnjvmClassLoader* loader,
+ unsigned int start,
+ unsigned int end);
/// print - Print a string representation of this array class. Used for
/// debugging purposes.
@@ -704,7 +697,7 @@
///
Signdef* getSignature() {
if(!_signature)
- _signature = classDef->isolate->constructSign(type);
+ _signature = classDef->classLoader->constructSign(type);
return _signature;
}
@@ -838,7 +831,7 @@
///
Typedef* getSignature() {
if(!_signature)
- _signature = classDef->isolate->constructType(type);
+ _signature = classDef->classLoader->constructType(type);
return _signature;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Thu Aug 14 10:58:53 2008
@@ -25,6 +25,7 @@
#include "JnjvmModuleProvider.h"
#include "JavaThread.h"
#include "JavaTypes.h"
+#include "LockedMap.h"
#include "Reader.h"
using namespace jnjvm;
@@ -42,7 +43,7 @@
const uint32 JavaCtpInfo::ConstantNameAndType = 12;
-static uint32 unimplemented(Jnjvm* vm, uint32 type, uint32 e, Reader& reader,
+static uint32 unimplemented(Class* cl, uint32 type, uint32 e, Reader& reader,
sint32* ctpDef, void** ctpRes, uint8* ctpType) {
JavaThread::get()->isolate->error(Jnjvm::ClassFormatError,
"unknown constant pool type %d",
@@ -51,7 +52,7 @@
}
-uint32 JavaCtpInfo::CtpReaderClass(Jnjvm* vm, uint32 type, uint32 e,
+uint32 JavaCtpInfo::CtpReaderClass(Class* cl, uint32 type, uint32 e,
Reader& reader, sint32* ctpDef,
void** ctpRes, uint8* ctpType) {
uint16 entry = reader.readU2();
@@ -61,7 +62,7 @@
return 1;
}
-uint32 JavaCtpInfo::CtpReaderInteger(Jnjvm* vm, uint32 type, uint32 e,
+uint32 JavaCtpInfo::CtpReaderInteger(Class* cl, uint32 type, uint32 e,
Reader& reader, sint32* ctpDef,
void** ctpRes, uint8* ctpType) {
uint32 val = reader.readU4();
@@ -71,7 +72,7 @@
return 1;
}
-uint32 JavaCtpInfo::CtpReaderFloat(Jnjvm* vm, uint32 type, uint32 e,
+uint32 JavaCtpInfo::CtpReaderFloat(Class* cl, uint32 type, uint32 e,
Reader& reader, sint32* ctpDef,
void** ctpRes, uint8* ctpType) {
uint32 val = reader.readU4();
@@ -81,7 +82,7 @@
return 1;
}
-uint32 JavaCtpInfo::CtpReaderUTF8(Jnjvm* vm, uint32 type, uint32 e,
+uint32 JavaCtpInfo::CtpReaderUTF8(Class* cl, uint32 type, uint32 e,
Reader& reader, sint32* ctpDef, void** ctpRes,
uint8* ctpType) {
uint16 len = reader.readU2();
@@ -111,7 +112,7 @@
++n;
}
- const UTF8* utf8 = UTF8::readerConstruct(vm, buf, n);
+ const UTF8* utf8 = cl->classLoader->hashUTF8->lookupOrCreateReader(buf, n);
ctpRes[e] = (UTF8*)utf8;
PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, "; [%5d] <utf8>\t\t\"%s\"\n", e,
@@ -120,9 +121,10 @@
return 1;
}
-uint32 JavaCtpInfo::CtpReaderNameAndType(Jnjvm* vm, uint32 type, uint32 e,
- Reader& reader, sint32* ctpDef,
- void** ctpRes, uint8* ctpType) {
+uint32 JavaCtpInfo::CtpReaderNameAndType(Class* cl, uint32 type,
+ uint32 e, Reader& reader,
+ sint32* ctpDef, void** ctpRes,
+ uint8* ctpType) {
uint32 entry = reader.readU4();
ctpDef[e] = entry;
PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL,
@@ -131,8 +133,8 @@
return 1;
}
-uint32 JavaCtpInfo::CtpReaderFieldref(Jnjvm* vm, uint32 type, uint32 e,
- Reader& reader, sint32* ctpDef,
+uint32 JavaCtpInfo::CtpReaderFieldref(Class* cl, uint32 type,
+ uint32 e, Reader& reader, sint32* ctpDef,
void** ctpRes, uint8* ctpType) {
uint32 entry = reader.readU4();
ctpDef[e] = entry;
@@ -142,7 +144,7 @@
return 1;
}
-uint32 JavaCtpInfo::CtpReaderString(Jnjvm* vm, uint32 type, uint32 e,
+uint32 JavaCtpInfo::CtpReaderString(Class* cl, uint32 type, uint32 e,
Reader& reader, sint32* ctpDef,
void** ctpRes, uint8* ctpType) {
uint16 entry = reader.readU2();
@@ -152,8 +154,8 @@
return 1;
}
-uint32 JavaCtpInfo::CtpReaderMethodref(Jnjvm* vm, uint32 type, uint32 e,
- Reader& reader, sint32* ctpDef,
+uint32 JavaCtpInfo::CtpReaderMethodref(Class* cl, uint32 type,
+ uint32 e, Reader& reader, sint32* ctpDef,
void** ctpRes, uint8* ctpType) {
uint32 entry = reader.readU4();
ctpDef[e] = entry;
@@ -163,7 +165,8 @@
return 1;
}
-uint32 JavaCtpInfo::CtpReaderInterfaceMethodref(Jnjvm* vm, uint32 type,
+uint32 JavaCtpInfo::CtpReaderInterfaceMethodref(Class* cl,
+ uint32 type,
uint32 e, Reader& reader,
sint32* ctpDef, void** ctpRes,
uint8* ctpType) {
@@ -175,7 +178,7 @@
return 1;
}
-uint32 JavaCtpInfo::CtpReaderLong(Jnjvm* vm, uint32 type, uint32 e,
+uint32 JavaCtpInfo::CtpReaderLong(Class* cl, uint32 type, uint32 e,
Reader& reader, sint32* ctpDef, void** ctpRes,
uint8* ctpType) {
ctpDef[e + 1] = reader.readU4();
@@ -186,7 +189,7 @@
return 2;
}
-uint32 JavaCtpInfo::CtpReaderDouble(Jnjvm* vm, uint32 type, uint32 e,
+uint32 JavaCtpInfo::CtpReaderDouble(Class* cl, uint32 type, uint32 e,
Reader& reader, sint32* ctpDef,
void** ctpRes, uint8* ctpType) {
ctpDef[e + 1] = reader.readU4();
@@ -197,7 +200,7 @@
return 2;
}
-void JavaCtpInfo::read(Jnjvm *vm, Class* cl, Reader& reader) {
+void JavaCtpInfo::read(Class* cl, Reader& reader) {
uint32 nbCtp = reader.readU2();
JavaCtpInfo* res = new JavaCtpInfo();
@@ -216,7 +219,7 @@
while (cur < nbCtp) {
uint8 curType = reader.readU1();
res->ctpType[cur] = curType;
- cur += ((funcsReader[curType])(vm, curType, cur, reader, res->ctpDef,
+ cur += ((funcsReader[curType])(cl, curType, cur, reader, res->ctpDef,
res->ctpRes, res->ctpType));
}
}
@@ -284,15 +287,14 @@
CommonClass* JavaCtpInfo::loadClass(uint32 index) {
CommonClass* temp = isLoadedClassOrClassName(index);
if (!temp) {
- JavaObject* loader = classDef->classLoader;
+ JnjvmClassLoader* loader = classDef->classLoader;
const UTF8* name = UTF8At(ctpDef[index]);
if (name->elements[0] == AssessorDesc::I_TAB) {
// Don't put into ctpRes because the class can be isolate specific
- temp = JavaThread::get()->isolate->constructArray(name, loader);
+ temp = loader->constructArray(name);
} else {
// Put into ctpRes because there is only one representation of the class
- ctpRes[index] = temp = classDef->isolate->loadName(name, loader, false,
- false, false);
+ ctpRes[index] = temp = loader->loadName(name, false, false, false);
}
}
return temp;
@@ -301,12 +303,11 @@
CommonClass* JavaCtpInfo::getMethodClassIfLoaded(uint32 index) {
CommonClass* temp = isLoadedClassOrClassName(index);
if (!temp) {
- JavaObject* loader = classDef->classLoader;
+ JnjvmClassLoader* loader = classDef->classLoader;
const UTF8* name = UTF8At(ctpDef[index]);
- temp = JavaThread::get()->isolate->lookupClass(name, loader);
+ temp = loader->lookupClass(name);
if (!temp)
- temp = Jnjvm::bootstrapVM->lookupClass(name,
- CommonClass::jnjvmClassLoader);
+ temp = JnjvmClassLoader::bootstrapLoader->lookupClass(name);
}
return temp;
}
@@ -328,7 +329,7 @@
}
sint32 entry = ctpDef[index];
const UTF8* type = UTF8At(entry & 0xFFFF);
- Typedef* sign = classDef->isolate->constructType(type);
+ Typedef* sign = classDef->classLoader->constructType(type);
ctpRes[index] = sign;
return sign;
}
@@ -344,7 +345,7 @@
}
sint32 entry = ctpDef[index];
const UTF8* type = UTF8At(entry & 0xFFFF);
- Signdef* sign = classDef->isolate->constructSign(type);
+ Signdef* sign = classDef->classLoader->constructSign(type);
ctpRes[index] = sign;
return sign;
}
@@ -419,7 +420,7 @@
cl->lookupMethodDontThrow(utf8, sign->keyName, isStatic(access), false);
if (meth) {
// don't throw if no meth, the exception will be thrown just in time
- JnjvmModule* M = classDef->isolate->TheModule;
+ JnjvmModule* M = classDef->classLoader->TheModule;
void* F = M->getMethod(meth);
ctpRes[index] = (void*)F;
return F;
@@ -431,8 +432,8 @@
return ctpRes[index];
} else {
void* val =
- classDef->isolate->TheModuleProvider->addCallback(classDef, index, sign,
- isStatic(access));
+ classDef->classLoader->TheModuleProvider->addCallback(classDef, index, sign,
+ isStatic(access));
ctpRes[index] = val;
return val;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h Thu Aug 14 10:58:53 2008
@@ -17,14 +17,17 @@
namespace jnjvm {
class Class;
+class CommonClass;
class Jnjvm;
+class JavaField;
+class JavaMethod;
class JavaString;
class Reader;
class Signdef;
class Typedef;
class UTF8;
-typedef uint32 (*ctpReader)(Jnjvm*, uint32, uint32, Reader&, sint32*, void**, uint8*);
+typedef uint32 (*ctpReader)(Class*, uint32, uint32, Reader&, sint32*, void**, uint8*);
class JavaCtpInfo {
public:
@@ -48,42 +51,42 @@
static ctpReader funcsReader[16];
- static uint32 CtpReaderClass(Jnjvm* vm, uint32 type, uint32 e, Reader& reader,
+ static uint32 CtpReaderClass(Class*, uint32 type, uint32 e, Reader& reader,
sint32* ctpDef, void** ctpRes, uint8* ctpType);
- static uint32 CtpReaderInteger(Jnjvm* vm, uint32 type, uint32 e, Reader& reader,
+ static uint32 CtpReaderInteger(Class*, uint32 type, uint32 e, Reader& reader,
sint32* ctpDef, void** ctpRes, uint8* ctpType);
- static uint32 CtpReaderFloat(Jnjvm* vm, uint32 type, uint32 e, Reader& reader,
+ static uint32 CtpReaderFloat(Class*, uint32 type, uint32 e, Reader& reader,
sint32* ctpDef, void** ctpRes, uint8* ctpType);
- static uint32 CtpReaderUTF8(Jnjvm* vm, uint32 type, uint32 e, Reader& reader,
+ static uint32 CtpReaderUTF8(Class*, uint32 type, uint32 e, Reader& reader,
sint32* ctpDef, void** ctpRes, uint8* ctpType);
- static uint32 CtpReaderNameAndType(Jnjvm* vm, uint32 type, uint32 e, Reader& reader,
+ static uint32 CtpReaderNameAndType(Class*, uint32 type, uint32 e, Reader& reader,
sint32* ctpDef, void** ctpRes,
uint8* ctpType);
- static uint32 CtpReaderFieldref(Jnjvm* vm, uint32 type, uint32 e, Reader& reader,
+ static uint32 CtpReaderFieldref(Class*, uint32 type, uint32 e, Reader& reader,
sint32* ctpDef, void** ctpRes, uint8* ctpType);
- static uint32 CtpReaderString(Jnjvm* vm, uint32 type, uint32 e, Reader& reader,
+ static uint32 CtpReaderString(Class*, uint32 type, uint32 e, Reader& reader,
sint32* ctpDef, void** ctpRes, uint8* ctpType);
- static uint32 CtpReaderMethodref(Jnjvm* vm, uint32 type, uint32 e, Reader& reader,
+ static uint32 CtpReaderMethodref(Class*, uint32 type, uint32 e, Reader& reader,
sint32* ctpDef, void** ctpRes, uint8* ctpType);
- static uint32 CtpReaderInterfaceMethodref(Jnjvm* vm, uint32 type, uint32 e,
+ static uint32 CtpReaderInterfaceMethodref(Class*, uint32 type, uint32 e,
Reader& reader, sint32* ctpDef,
void** ctpRes, uint8* ctpType);
- static uint32 CtpReaderLong(Jnjvm* vm, uint32 type, uint32 e, Reader& reader,
+ static uint32 CtpReaderLong(Class*, uint32 type, uint32 e, Reader& reader,
sint32* ctpDef, void** ctpRes, uint8* ctpType);
- static uint32 CtpReaderDouble(Jnjvm* vm, uint32 type, uint32 e, Reader& reader,
+ static uint32 CtpReaderDouble(Class*, uint32 type, uint32 e, Reader& reader,
sint32* ctpDef, void** ctpRes, uint8* ctpType);
- static void read(Jnjvm *vm, Class* cl, Reader& reader);
+ static void read(Class* cl, Reader& reader);
bool isAStaticCall(uint32 index) {
return (ctpType[index] & 0x80) != 0;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Thu Aug 14 10:58:53 2008
@@ -7,7 +7,6 @@
//
//===----------------------------------------------------------------------===//
-#include <signal.h>
#include <vector>
#include "mvm/VirtualMachine.h"
@@ -51,6 +50,8 @@
INIT(StaticInstanceMap);
INIT(DelegateeMap);
INIT(JavaIsolate);
+ INIT(JnjvmBootstrapLoader);
+ INIT(JnjvmClassLoader);
#ifdef SERVICE_VM
INIT(ServiceDomain);
#endif
@@ -71,86 +72,73 @@
static void initialiseStatics() {
- Jnjvm* vm = JavaIsolate::bootstrapVM = JavaIsolate::allocateBootstrap();
+ JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader = JnjvmClassLoader::createBootstrapLoader();
// Array initialization
- const UTF8* utf8OfChar = vm->asciizConstructUTF8("[C");
- JavaArray::ofChar = vm->constructArray(utf8OfChar,
- CommonClass::jnjvmClassLoader);
+ const UTF8* utf8OfChar = JCL->asciizConstructUTF8("[C");
+ JavaArray::ofChar = JCL->constructArray(utf8OfChar);
((UTF8*)utf8OfChar)->classOf = JavaArray::ofChar;
ClassArray::InterfacesArray.push_back(
- vm->constructClass(vm->asciizConstructUTF8("java/lang/Cloneable"),
- CommonClass::jnjvmClassLoader));
+ JCL->constructClass(JCL->asciizConstructUTF8("java/lang/Cloneable")));
ClassArray::InterfacesArray.push_back(
- vm->constructClass(vm->asciizConstructUTF8("java/io/Serializable"),
- CommonClass::jnjvmClassLoader));
+ JCL->constructClass(JCL->asciizConstructUTF8("java/io/Serializable")));
ClassArray::SuperArray =
- vm->constructClass(vm->asciizConstructUTF8("java/lang/Object"),
- CommonClass::jnjvmClassLoader);
+ JCL->constructClass(JCL->asciizConstructUTF8("java/lang/Object"));
JavaArray::ofChar->interfaces = ClassArray::InterfacesArray;
JavaArray::ofChar->super = ClassArray::SuperArray;
- JavaArray::ofByte = vm->constructArray(vm->asciizConstructUTF8("[B"),
- CommonClass::jnjvmClassLoader);
+ JavaArray::ofByte = JCL->constructArray(JCL->asciizConstructUTF8("[B"));
JavaArray::ofString =
- vm->constructArray(vm->asciizConstructUTF8("[Ljava/lang/String;"),
- CommonClass::jnjvmClassLoader);
+ JCL->constructArray(JCL->asciizConstructUTF8("[Ljava/lang/String;"));
JavaArray::ofObject =
- vm->constructArray(vm->asciizConstructUTF8("[Ljava/lang/Object;"),
- CommonClass::jnjvmClassLoader);
+ JCL->constructArray(JCL->asciizConstructUTF8("[Ljava/lang/Object;"));
- JavaArray::ofInt = vm->constructArray(vm->asciizConstructUTF8("[I"),
- CommonClass::jnjvmClassLoader);
+ JavaArray::ofInt = JCL->constructArray(JCL->asciizConstructUTF8("[I"));
- JavaArray::ofBool = vm->constructArray(vm->asciizConstructUTF8("[Z"),
- CommonClass::jnjvmClassLoader);
+ JavaArray::ofBool = JCL->constructArray(JCL->asciizConstructUTF8("[Z"));
- JavaArray::ofLong = vm->constructArray(vm->asciizConstructUTF8("[J"),
- CommonClass::jnjvmClassLoader);
+ JavaArray::ofLong = JCL->constructArray(JCL->asciizConstructUTF8("[J"));
- JavaArray::ofFloat = vm->constructArray(vm->asciizConstructUTF8("[F"),
- CommonClass::jnjvmClassLoader);
+ JavaArray::ofFloat = JCL->constructArray(JCL->asciizConstructUTF8("[F"));
- JavaArray::ofDouble = vm->constructArray(vm->asciizConstructUTF8("[D"),
- CommonClass::jnjvmClassLoader);
+ JavaArray::ofDouble = JCL->constructArray(JCL->asciizConstructUTF8("[D"));
- JavaArray::ofShort = vm->constructArray(vm->asciizConstructUTF8("[S"),
- CommonClass::jnjvmClassLoader);
+ JavaArray::ofShort = JCL->constructArray(JCL->asciizConstructUTF8("[S"));
// End array initialization
- AssessorDesc::initialise(vm);
+ AssessorDesc::initialise(JCL);
- Attribut::codeAttribut = vm->asciizConstructUTF8("Code");
- Attribut::exceptionsAttribut = vm->asciizConstructUTF8("Exceptions");
- Attribut::constantAttribut = vm->asciizConstructUTF8("ConstantValue");
+ Attribut::codeAttribut = JCL->asciizConstructUTF8("Code");
+ Attribut::exceptionsAttribut = JCL->asciizConstructUTF8("Exceptions");
+ Attribut::constantAttribut = JCL->asciizConstructUTF8("ConstantValue");
Attribut::lineNumberTableAttribut =
- vm->asciizConstructUTF8("LineNumberTable");
- Attribut::innerClassesAttribut = vm->asciizConstructUTF8("InnerClasses");
- Attribut::sourceFileAttribut = vm->asciizConstructUTF8("SourceFile");
-
- Jnjvm::initName = vm->asciizConstructUTF8("<init>");
- Jnjvm::clinitName = vm->asciizConstructUTF8("<clinit>");
- Jnjvm::clinitType = vm->asciizConstructUTF8("()V");
- Jnjvm::runName = vm->asciizConstructUTF8("run");
- Jnjvm::prelib = vm->asciizConstructUTF8("lib");
+ JCL->asciizConstructUTF8("LineNumberTable");
+ Attribut::innerClassesAttribut = JCL->asciizConstructUTF8("InnerClasses");
+ Attribut::sourceFileAttribut = JCL->asciizConstructUTF8("SourceFile");
+
+ Jnjvm::initName = JCL->asciizConstructUTF8("<init>");
+ Jnjvm::clinitName = JCL->asciizConstructUTF8("<clinit>");
+ Jnjvm::clinitType = JCL->asciizConstructUTF8("()V");
+ Jnjvm::runName = JCL->asciizConstructUTF8("run");
+ Jnjvm::prelib = JCL->asciizConstructUTF8("lib");
#if defined(__MACH__)
- Jnjvm::postlib = vm->asciizConstructUTF8(".dylib");
+ Jnjvm::postlib = JCL->asciizConstructUTF8(".dylib");
#else
- Jnjvm::postlib = vm->asciizConstructUTF8(".so");
+ Jnjvm::postlib = JCL->asciizConstructUTF8(".so");
#endif
- Jnjvm::mathName = vm->asciizConstructUTF8("java/lang/Math");
+ Jnjvm::mathName = JCL->asciizConstructUTF8("java/lang/Math");
#define DEF_UTF8(var) \
- Jnjvm::var = vm->asciizConstructUTF8(#var)
+ Jnjvm::var = JCL->asciizConstructUTF8(#var)
DEF_UTF8(abs);
DEF_UTF8(sqrt);
@@ -184,12 +172,12 @@
extern "C" void ClasspathBoot();
void mvm::VirtualMachine::initialiseJVM() {
- if (!JavaIsolate::bootstrapVM) {
+ if (!JnjvmClassLoader::bootstrapLoader) {
initialiseVT();
initialiseStatics();
ClasspathBoot();
- Classpath::initialiseClasspath(JavaIsolate::bootstrapVM);
+ Classpath::initialiseClasspath(JnjvmClassLoader::bootstrapLoader);
}
}
@@ -199,15 +187,11 @@
}
mvm::VirtualMachine* mvm::VirtualMachine::createJVM() {
-#if !defined(MULTIPLE_VM)
- JavaIsolate* vm = (JavaIsolate*)JavaIsolate::bootstrapVM;
-#else
#ifdef SERVICE_VM
- ServiceDomain* vm = ServiceDomain::allocateService((JavaIsolate*)Jnjvm::bootstrapVM);
+ ServiceDomain* vm = ServiceDomain::allocateService();
vm->startExecution();
#else
- JavaIsolate* vm = JavaIsolate::allocateIsolate(JavaIsolate::bootstrapVM);
-#endif
+ JavaIsolate* vm = JavaIsolate::allocateIsolate();
#endif
return vm;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.cpp Thu Aug 14 10:58:53 2008
@@ -103,13 +103,14 @@
sprintf(temp, "%s:%s", vm->classpath, jarFile);
vm->setClasspath(temp);
- ArrayUInt8* bytes = Reader::openFile(vm, jarFile);
+ ArrayUInt8* bytes = Reader::openFile(JnjvmClassLoader::bootstrapLoader,
+ jarFile);
ZipArchive archive(bytes);
if (archive.getOfscd() != -1) {
ZipFile* file = archive.getFile(PATH_MANIFEST);
if (file) {
- ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, JavaArray::ofByte, vm);
+ ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, JavaArray::ofByte, &vm->allocator);
int ok = archive.readFile(res, file);
if (ok) {
char* mainClass = findInformation(res, MAIN_CLASS, LENGTH_MAIN_CLASS);
@@ -224,7 +225,7 @@
printInformation();
} else {
char* path = &cur[16];
- vm->analyseClasspathEnv(path);
+ JnjvmClassLoader::bootstrapLoader->analyseClasspathEnv(path);
}
} else if (!(strcmp(cur, "-enableassertions"))) {
nyi();
@@ -306,9 +307,10 @@
}
-JavaObject* JavaIsolate::loadAppClassLoader() {
+JnjvmClassLoader* JavaIsolate::loadAppClassLoader() {
if (appClassLoader == 0) {
- appClassLoader = Classpath::getSystemClassLoader->invokeJavaObjectStatic(this);
+ JavaObject* loader = Classpath::getSystemClassLoader->invokeJavaObjectStatic(this);
+ appClassLoader = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader);
}
return appClassLoader;
}
@@ -318,26 +320,27 @@
}
void JavaIsolate::loadBootstrap() {
- loadName(Classpath::newVMThrowable->name,
- CommonClass::jnjvmClassLoader, true, true, true);
- loadName(Classpath::newClass->name,
- CommonClass::jnjvmClassLoader, true, true, true);
- loadName(Classpath::newConstructor->name,
- CommonClass::jnjvmClassLoader, true, true, true);
- loadName(Classpath::newMethod->name,
- CommonClass::jnjvmClassLoader, true, true, true);
- loadName(Classpath::newField->name,
- CommonClass::jnjvmClassLoader, true, true, true);
- loadName(Classpath::newStackTraceElement->name,
- CommonClass::jnjvmClassLoader, true, true, true);
+ JnjvmClassLoader* loader = JnjvmClassLoader::bootstrapLoader;
+ loader->loadName(Classpath::newVMThrowable->name,
+ true, true, true);
+ loader->loadName(Classpath::newClass->name,
+ true, true, true);
+ loader->loadName(Classpath::newConstructor->name,
+ true, true, true);
+ loader->loadName(Classpath::newMethod->name,
+ true, true, true);
+ loader->loadName(Classpath::newField->name,
+ true, true, true);
+ loader->loadName(Classpath::newStackTraceElement->name,
+ true, true, true);
mapInitialThread();
loadAppClassLoader();
JavaObject* obj = JavaThread::currentThread();
- Classpath::setContextClassLoader->invokeIntSpecial(this, obj, appClassLoader);
+ Classpath::setContextClassLoader->invokeIntSpecial(this, obj, appClassLoader->getJavaClassLoader());
// load and initialise math since it is responsible for dlopen'ing
// libjavalang.so and we are optimizing some math operations
- loadName(asciizConstructUTF8("java/lang/Math"),
- CommonClass::jnjvmClassLoader, true, true, true);
+ loader->loadName(loader->asciizConstructUTF8("java/lang/Math"),
+ true, true, true);
}
void JavaIsolate::executeClass(const char* className, ArrayObject* args) {
@@ -408,7 +411,7 @@
}
}
- ArrayObject* args = ArrayObject::acons(argc - 2, JavaArray::ofString, this);
+ ArrayObject* args = ArrayObject::acons(argc - 2, JavaArray::ofString, &allocator);
for (int i = 2; i < argc; ++i) {
args->elements[i - 2] = (JavaObject*)asciizToStr(argv[i]);
}
@@ -419,17 +422,14 @@
}
void JavaIsolate::runIsolate(const char* className, ArrayObject* args) {
- JavaIsolate *isolate = allocateIsolate(bootstrapVM);
+ JavaIsolate *isolate = allocateIsolate();
isolate->loadBootstrap();
isolate->executeClass(className, args);
isolate->waitForExit();
}
-extern const char* GNUClasspathGlibj;
-extern const char* GNUClasspathLibs;
-
-JavaIsolate* JavaIsolate::allocateIsolate(Jnjvm* callingVM) {
- JavaIsolate *isolate= vm_new(callingVM, JavaIsolate)();
+JavaIsolate* JavaIsolate::allocateIsolate() {
+ JavaIsolate *isolate= gc_new(JavaIsolate)();
#ifdef MULTIPLE_GC
isolate->GC = Collector::allocate();
@@ -438,21 +438,8 @@
if (!(isolate->classpath)) {
isolate->classpath = ".";
}
- isolate->bootClasspathEnv = getenv("JNJVM_BOOTCLASSPATH");
- if (!(isolate->bootClasspathEnv)) {
- isolate->bootClasspathEnv = GNUClasspathGlibj;
- }
- isolate->libClasspathEnv = getenv("JNJVM_LIBCLASSPATH");
- if (!(isolate->libClasspathEnv)) {
- isolate->libClasspathEnv = GNUClasspathLibs;
- }
-
- isolate->analyseClasspathEnv(isolate->bootClasspathEnv);
-
- isolate->TheModule = new JnjvmModule("Isolate JnJVM");
- isolate->TheModuleProvider = new JnjvmModuleProvider(isolate->TheModule);
- isolate->bootstrapThread = vm_new(isolate, JavaThread)();
+ isolate->bootstrapThread = gc_new(JavaThread)();
isolate->bootstrapThread->initialise(0, isolate);
void* baseSP = mvm::Thread::get()->baseSP;
isolate->bootstrapThread->threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00;
@@ -471,12 +458,7 @@
isolate->javavmEnv = &JNI_JavaVMTable;
// We copy so that bootstrap utf8 such as "<init>" are unique
- isolate->hashUTF8 = new UTF8Map();
- bootstrapVM->hashUTF8->copy(isolate->hashUTF8);
isolate->hashStr = new StringMap();
- isolate->bootstrapClasses = callingVM->bootstrapClasses;
- isolate->javaTypes = new TypeMap();
- isolate->javaSignatures = new SignMap();
isolate->globalRefsLock = mvm::Lock::allocNormal();
#ifdef MULTIPLE_VM
isolate->statics = vm_new(isolate, StaticInstanceMap)();
@@ -486,66 +468,6 @@
return isolate;
}
-JavaIsolate* JavaIsolate::allocateBootstrap() {
- JavaIsolate *isolate= gc_new(JavaIsolate)();
-
-#ifdef MULTIPLE_GC
- isolate->GC = mvm::Thread::get()->GC;
- isolate->GC->enable(0);
-#endif
-
- isolate->classpath = getenv("CLASSPATH");
- if (!(isolate->classpath)) {
- isolate->classpath = ".";
- }
- isolate->bootClasspathEnv = getenv("JNJVM_BOOTCLASSPATH");
- if (!(isolate->bootClasspathEnv)) {
- isolate->bootClasspathEnv = GNUClasspathGlibj;
- }
- isolate->libClasspathEnv = getenv("JNJVM_LIBCLASSPATH");
- if (!(isolate->libClasspathEnv)) {
- isolate->libClasspathEnv = GNUClasspathLibs;
- }
-
- isolate->analyseClasspathEnv(isolate->bootClasspathEnv);
-
- isolate->TheModule = new JnjvmModule("Bootstrap JnJVM");
- isolate->TheModule->initialise();
- isolate->TheModuleProvider = new JnjvmModuleProvider(isolate->TheModule);
-
- isolate->bootstrapThread = vm_new(isolate, JavaThread)();
- isolate->bootstrapThread->initialise(0, isolate);
- void* baseSP = mvm::Thread::get()->baseSP;
- isolate->bootstrapThread->threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00;
-#ifdef MULTIPLE_GC
- isolate->bootstrapThread->GC = isolate->GC;
-#endif
- isolate->bootstrapThread->baseSP = baseSP;
- JavaThread::threadKey->set(isolate->bootstrapThread);
-
- isolate->name = "bootstrapVM";
- isolate->appClassLoader = 0;
- isolate->hashUTF8 = new UTF8Map();
- isolate->hashStr = new StringMap();
- isolate->bootstrapClasses = vm_new(isolate, ClassMap)();
- isolate->jniEnv = &JNI_JNIEnvTable;
- isolate->javavmEnv = &JNI_JavaVMTable;
- isolate->globalRefsLock = mvm::Lock::allocNormal();
- isolate->javaTypes = new TypeMap();
- isolate->javaSignatures = new SignMap();
-
-#ifdef MULTIPLE_VM
- isolate->statics = vm_new(isolate, StaticInstanceMap)();
- isolate->delegatees = vm_new(isolate, DelegateeMap)();
-#endif
-
-#if defined(SERVICE_VM) || !defined(MULTIPLE_VM)
- isolate->threadSystem = new ThreadSystem();
-#endif
-
- return isolate;
-}
-
JavaIsolate::~JavaIsolate() {
delete threadSystem;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.h?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaIsolate.h Thu Aug 14 10:58:53 2008
@@ -56,7 +56,7 @@
~JavaIsolate();
JavaIsolate();
- JavaObject* loadAppClassLoader();
+ JnjvmClassLoader* loadAppClassLoader();
void loadBootstrap();
void executeClass(const char* className, ArrayObject* args);
void executePremain(const char* className, JavaString* args,
@@ -65,8 +65,7 @@
void runMain(int argc, char** argv);
void mapInitialThread();
static void runIsolate(const char* className, ArrayObject* args);
- static JavaIsolate* allocateIsolate(Jnjvm* callingVM);
- static JavaIsolate* allocateBootstrap();
+ static JavaIsolate* allocateIsolate();
};
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Thu Aug 14 10:58:53 2008
@@ -221,7 +221,7 @@
uint32 nargs = func->arg_size() + 1 + (stat ? 1 : 0);
std::vector<Value*> nativeArgs;
- int64_t jniEnv = (int64_t)&(compilingClass->isolate->jniEnv);
+ int64_t jniEnv = (int64_t)&(JavaThread::get()->isolate->jniEnv);
nativeArgs.push_back(
ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, jniEnv),
mvm::jit::ptrType));
@@ -1096,7 +1096,7 @@
void* val = 0;
GlobalVariable* gv = 0;
#ifndef MULTIPLE_VM
- val = compilingClass->isolate->UTF8ToStr(utf8);
+ val = JavaThread::get()->isolate->UTF8ToStr(utf8);
gv =
new GlobalVariable(JnjvmModule::JavaObjectType, false,
GlobalValue::ExternalLinkage,
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h Thu Aug 14 10:58:53 2008
@@ -60,7 +60,7 @@
JnjvmModule* module;
- static void invokeOnceVoid(Jnjvm* vm, JavaObject* loader,
+ static void invokeOnceVoid(Jnjvm* vm, JnjvmClassLoader* loader,
const char* className,
const char* func, const char* sign,
int access, ...);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Thu Aug 14 10:58:53 2008
@@ -1823,7 +1823,7 @@
ClassArray* dcl = 0;
ConstantInt* sizeElement = 0;
GlobalVariable* TheVT = 0;
- Jnjvm* vm = compilingClass->isolate;
+ JnjvmClassLoader* JCL = compilingClass->classLoader;
if (bytecodes[i] == NEWARRAY) {
uint8 id = bytecodes[++i];
@@ -1838,9 +1838,9 @@
compilingClass->ctpInfo->resolveClassName(index);
const UTF8* arrayName =
- AssessorDesc::constructArrayName(vm, 0, 1, className);
+ AssessorDesc::constructArrayName(JCL, 0, 1, className);
- dcl = vm->constructArray(arrayName, compilingClass->classLoader);
+ dcl = JCL->constructArray(arrayName);
TheVT = JnjvmModule::ArrayObjectVirtualTableGV;
sizeElement = mvm::jit::constantPtrSize;
}
@@ -2062,15 +2062,14 @@
}
case MULTIANEWARRAY : {
- Jnjvm* vm = compilingClass->isolate;
+ JnjvmClassLoader* JCL = compilingClass->classLoader;
uint16 index = readU2(bytecodes, i);
uint8 dim = readU1(bytecodes, i);
const UTF8* className =
compilingClass->ctpInfo->resolveClassName(index);
- ClassArray* dcl =
- vm->constructArray(className, compilingClass->classLoader);
+ ClassArray* dcl = JCL->constructArray(className);
compilingClass->ctpInfo->loadClass(index);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp Thu Aug 14 10:58:53 2008
@@ -25,16 +25,16 @@
using namespace jnjvm;
-void JavaJIT::invokeOnceVoid(Jnjvm* vm, JavaObject* loader,
+void JavaJIT::invokeOnceVoid(Jnjvm* vm, JnjvmClassLoader* loader,
char const* className, char const* func,
char const* sign, int access, ...) {
- CommonClass* cl = vm->loadName(vm->asciizConstructUTF8(className), loader,
- true, true, true);
+ CommonClass* cl = loader->loadName(loader->asciizConstructUTF8(className),
+ true, true, true);
bool stat = access == ACC_STATIC ? true : false;
- JavaMethod* method = cl->lookupMethod(vm->asciizConstructUTF8(func),
- vm->asciizConstructUTF8(sign), stat,
+ JavaMethod* method = cl->lookupMethod(loader->asciizConstructUTF8(func),
+ loader->asciizConstructUTF8(sign), stat,
true);
va_list ap;
va_start(ap, access);
@@ -92,7 +92,7 @@
\
TYPE JavaMethod::invoke##TYPE_NAME##VirtualAP(Jnjvm* vm, JavaObject* obj, va_list ap) { \
if (!classDef->isReady()) \
- classDef->isolate->loadName(classDef->name, classDef->classLoader, true, true, true); \
+ classDef->classLoader->loadName(classDef->name, true, true, true); \
\
verifyNull(obj); \
Signdef* sign = getSignature(); \
@@ -105,7 +105,7 @@
\
TYPE JavaMethod::invoke##TYPE_NAME##SpecialAP(Jnjvm* vm, JavaObject* obj, va_list ap) {\
if (!classDef->isReady())\
- classDef->isolate->loadName(classDef->name, classDef->classLoader, true, true, true);\
+ classDef->classLoader->loadName(classDef->name, true, true, true);\
\
verifyNull(obj);\
Signdef* sign = getSignature(); \
@@ -118,7 +118,7 @@
\
TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, va_list ap) {\
if (!classDef->isReady())\
- classDef->isolate->loadName(classDef->name, classDef->classLoader, true, true, true);\
+ classDef->classLoader->loadName(classDef->name, true, true, true);\
\
Signdef* sign = getSignature(); \
void** buf = (void**)alloca(sign->args.size() * sizeof(uint64)); \
@@ -130,7 +130,7 @@
\
TYPE JavaMethod::invoke##TYPE_NAME##VirtualBuf(Jnjvm* vm, JavaObject* obj, void* buf) {\
if (!classDef->isReady())\
- classDef->isolate->loadName(classDef->name, classDef->classLoader, true, true, true);\
+ classDef->classLoader->loadName(classDef->name, true, true, true);\
\
verifyNull(obj);\
JavaMethod* meth = obj->classOf->lookupMethod(name, type, false, true);\
@@ -142,7 +142,7 @@
\
TYPE JavaMethod::invoke##TYPE_NAME##SpecialBuf(Jnjvm* vm, JavaObject* obj, void* buf) {\
if (!classDef->isReady())\
- classDef->isolate->loadName(classDef->name, classDef->classLoader, true, true, true);\
+ classDef->classLoader->loadName(classDef->name, true, true, true);\
\
verifyNull(obj);\
void* func = this->compiledPtr();\
@@ -152,7 +152,7 @@
\
TYPE JavaMethod::invoke##TYPE_NAME##StaticBuf(Jnjvm* vm, void* buf) {\
if (!classDef->isReady())\
- classDef->isolate->loadName(classDef->name, classDef->classLoader, true, true, true);\
+ classDef->classLoader->loadName(classDef->name, true, true, true);\
\
void* func = this->compiledPtr();\
Signdef* sign = getSignature(); \
@@ -189,7 +189,7 @@
\
TYPE JavaMethod::invoke##TYPE_NAME##VirtualAP(Jnjvm* vm, JavaObject* obj, va_list ap) { \
if (!classDef->isReady()) \
- classDef->isolate->loadName(classDef->name, classDef->classLoader, true, true, true); \
+ classDef->classLoader->loadName(classDef->name, true, true, true); \
\
verifyNull(obj); \
void* func = (((void***)obj)[0])[offset];\
@@ -199,7 +199,7 @@
\
TYPE JavaMethod::invoke##TYPE_NAME##SpecialAP(Jnjvm* vm, JavaObject* obj, va_list ap) {\
if (!classDef->isReady())\
- classDef->isolate->loadName(classDef->name, classDef->classLoader, true, true, true);\
+ classDef->classLoader->loadName(classDef->name, true, true, true);\
\
verifyNull(obj);\
void* func = this->compiledPtr();\
@@ -209,7 +209,7 @@
\
TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, va_list ap) {\
if (!classDef->isReady())\
- classDef->isolate->loadName(classDef->name, classDef->classLoader, true, true, true);\
+ classDef->classLoader->loadName(classDef->name, true, true, true);\
\
void* func = this->compiledPtr();\
Signdef* sign = getSignature(); \
@@ -218,7 +218,7 @@
\
TYPE JavaMethod::invoke##TYPE_NAME##VirtualBuf(Jnjvm* vm, JavaObject* obj, void* buf) {\
if (!classDef->isReady())\
- classDef->isolate->loadName(classDef->name, classDef->classLoader, true, true, true);\
+ classDef->classLoader->loadName(classDef->name, true, true, true);\
\
verifyNull(obj);\
void* func = (((void***)obj)[0])[offset];\
@@ -228,7 +228,7 @@
\
TYPE JavaMethod::invoke##TYPE_NAME##SpecialBuf(Jnjvm* vm, JavaObject* obj, void* buf) {\
if (!classDef->isReady())\
- classDef->isolate->loadName(classDef->name, classDef->classLoader, true, true, true);\
+ classDef->classLoader->loadName(classDef->name, true, true, true);\
\
verifyNull(obj);\
void* func = this->compiledPtr();\
@@ -238,7 +238,7 @@
\
TYPE JavaMethod::invoke##TYPE_NAME##StaticBuf(Jnjvm* vm, void* buf) {\
if (!classDef->isReady())\
- classDef->isolate->loadName(classDef->name, classDef->classLoader, true, true, true);\
+ classDef->classLoader->loadName(classDef->name, true, true, true);\
\
void* func = this->compiledPtr();\
Signdef* sign = getSignature(); \
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Thu Aug 14 10:58:53 2008
@@ -187,16 +187,12 @@
#endif
extern "C" CommonClass* initialisationCheck(CommonClass* cl) {
- cl->isolate->initialiseClass(cl);
+ JavaThread::get()->isolate->initialiseClass(cl);
return cl;
}
extern "C" JavaObject* getClassDelegatee(CommonClass* cl) {
-#ifdef MULTIPLE_VM
Jnjvm* vm = JavaThread::get()->isolate;
-#else
- Jnjvm* vm = cl->isolate;
-#endif
return vm->getClassDelegatee(cl);
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Thu Aug 14 10:58:53 2008
@@ -43,7 +43,8 @@
const UTF8* JavaString::strToUTF8(Jnjvm* vm) {
const UTF8* utf8 = this->value;
if (offset || (offset + count <= utf8->size)) {
- return utf8->extract(vm, offset, offset + count);
+ // TODO find a way to get a relevant hashUTF8
+ return utf8->extract(JnjvmClassLoader::bootstrapLoader->hashUTF8, offset, offset + count);
} else {
return utf8;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp Thu Aug 14 10:58:53 2008
@@ -54,7 +54,7 @@
AssessorDesc::AssessorDesc(bool dt, char bid, uint32 nb, uint32 nw,
const char* name,
- Jnjvm* vm, uint8 nid,
+ JnjvmClassLoader* loader, uint8 nid,
const char* assocName, ClassArray* cl,
arrayCtor_t ctor) {
AssessorDesc* res = this;
@@ -64,24 +64,24 @@
res->nbb = nb;
res->nbw = nw;
res->asciizName = name;
- res->UTF8Name = vm->asciizConstructUTF8(name);
+ res->UTF8Name = loader->asciizConstructUTF8(name);
res->arrayCtor = ctor;
res->arrayClass = cl;
if (assocName)
- res->assocClassName = vm->asciizConstructUTF8(assocName);
+ res->assocClassName = loader->asciizConstructUTF8(assocName);
else
res->assocClassName = 0;
if (bid != I_PARG && bid != I_PARD && bid != I_REF && bid != I_TAB) {
- res->classType = new ClassPrimitive(vm, res->UTF8Name);
+ res->classType = new ClassPrimitive(loader, res->UTF8Name);
res->classType->virtualSize = nb;
} else {
res->classType = 0;
}
}
-void AssessorDesc::initialise(Jnjvm* vm) {
+void AssessorDesc::initialise(JnjvmClassLoader* vm) {
dParg = new AssessorDesc(false, I_PARG, 0, 0, "(", vm, 0, 0, 0,
0);
@@ -226,7 +226,7 @@
}
}
-const UTF8* AssessorDesc::constructArrayName(Jnjvm *vm, AssessorDesc* ass,
+const UTF8* AssessorDesc::constructArrayName(JnjvmClassLoader *loader, AssessorDesc* ass,
uint32 steps,
const UTF8* className) {
if (ass) {
@@ -235,7 +235,7 @@
buf[i] = I_TAB;
}
buf[steps] = ass->byteId;
- return UTF8::readerConstruct(vm, buf, steps + 1);
+ return loader->readerConstructUTF8(buf, steps + 1);
} else {
uint32 len = className->size;
uint32 pos = steps;
@@ -260,10 +260,11 @@
buf[n - 1] = I_END_REF;
}
- return UTF8::readerConstruct(vm, buf, n);
+ return loader->readerConstructUTF8(buf, n);
}
}
+/*
void AssessorDesc::introspectArrayName(Jnjvm *vm, const UTF8* utf8,
uint32 start, AssessorDesc*& ass,
const UTF8*& res) {
@@ -290,8 +291,8 @@
res = 0;
}
}
-
-void AssessorDesc::introspectArray(Jnjvm *vm, JavaObject* loader,
+*/
+void AssessorDesc::introspectArray(JnjvmClassLoader* loader,
const UTF8* utf8, uint32 start,
AssessorDesc*& ass, CommonClass*& res) {
uint32 pos = 0;
@@ -301,18 +302,18 @@
analyseIntern(utf8, start, 1, funcs, intern);
if (funcs != dTab) {
- vm->unknownError("%s isn't an array", utf8->printString());
+ JavaThread::get()->isolate->unknownError("%s isn't an array", utf8->printString());
}
analyseIntern(utf8, intern, 0, funcs, pos);
if (funcs == dRef) {
ass = dRef;
- res = vm->loadName(utf8->extract(vm, intern + 1, pos - 1), loader, false,
+ res = loader->loadName(utf8->extract(loader->hashUTF8, intern + 1, pos - 1), false,
false, true);
} else if (funcs == dTab) {
ass = dTab;
- res = vm->constructArray(utf8->extract(vm, intern, pos), loader);
+ res = loader->constructArray(utf8->extract(loader->hashUTF8, intern, pos));
} else {
ass = funcs;
res = funcs->classType;
@@ -407,13 +408,13 @@
return buf->contents()->cString();
}
-CommonClass* Typedef::assocClass(JavaObject* loader) {
+CommonClass* Typedef::assocClass(JnjvmClassLoader* loader) {
if (pseudoAssocClassName == 0) {
return funcs->classType;
} else if (funcs == AssessorDesc::dRef) {
- return isolate->loadName(pseudoAssocClassName, loader, false, true, true);
+ return loader->loadName(pseudoAssocClassName, false, true, true);
} else {
- return isolate->constructArray(pseudoAssocClassName, loader);
+ return loader->constructArray(pseudoAssocClassName);
}
}
@@ -449,7 +450,8 @@
Typedef::humanPrintArgs(&args, buf);
}
-Signdef* Signdef::signDup(const UTF8* name, Jnjvm *vm) {
+Signdef::Signdef(const UTF8* name, JnjvmClassLoader* loader) {
+ Signdef* res = this;
std::vector<Typedef*> buf;
uint32 len = (uint32)name->size;
uint32 pos = 1;
@@ -461,7 +463,7 @@
AssessorDesc::analyseIntern(name, pos, 0, funcs, pos);
if (funcs == AssessorDesc::dPard) break;
else {
- buf.push_back(vm->constructType(name->extract(vm, pred, pos)));
+ buf.push_back(loader->constructType(name->extract(loader->hashUTF8, pred, pos)));
}
}
@@ -475,43 +477,42 @@
typeError(name, 0);
}
- Signdef* res = new Signdef();
res->args = buf;
- res->ret = vm->constructType(name->extract(vm, pos, pred));
- res->isolate = vm;
+ res->ret = loader->constructType(name->extract(loader->hashUTF8, pos, pred));
+ res->initialLoader = loader;
res->keyName = name;
res->_virtualCallBuf = 0;
res->_staticCallBuf = 0;
res->_virtualCallAP = 0;
res->_staticCallAP = 0;
res->JInfo = 0;
- return res;
}
-Typedef* Typedef::typeDup(const UTF8* name, Jnjvm *vm) {
+Typedef::Typedef(const UTF8* name, JnjvmClassLoader *loader) {
+ Typedef* res = this;
AssessorDesc* funcs = 0;
uint32 next;
AssessorDesc::analyseIntern(name, 0, 0, funcs, next);
assert(funcs != AssessorDesc::dParg &&
"Error: resolving a signature for a field");
- Typedef* res = new Typedef();
- res->isolate = vm;
+ res->initialLoader = loader;
res->keyName = name;
res->funcs = funcs;
if (funcs == AssessorDesc::dRef) {
- res->pseudoAssocClassName = name->extract(vm, 1, next - 1);
+ res->pseudoAssocClassName = name->extract(loader->hashUTF8, 1, next - 1);
} else if (funcs == AssessorDesc::dTab) {
res->pseudoAssocClassName = name;
+ } else {
+ res->pseudoAssocClassName = 0;
}
- return res;
}
intptr_t Signdef::staticCallBuf() {
if (!_staticCallBuf) {
- LLVMSignatureInfo* LSI = isolate->TheModule->getSignatureInfo(this);
+ LLVMSignatureInfo* LSI = initialLoader->TheModule->getSignatureInfo(this);
LSI->getStaticBuf();
}
return _staticCallBuf;
@@ -519,7 +520,7 @@
intptr_t Signdef::virtualCallBuf() {
if (!_virtualCallBuf) {
- LLVMSignatureInfo* LSI = isolate->TheModule->getSignatureInfo(this);
+ LLVMSignatureInfo* LSI = initialLoader->TheModule->getSignatureInfo(this);
LSI->getVirtualBuf();
}
return _virtualCallBuf;
@@ -527,7 +528,7 @@
intptr_t Signdef::staticCallAP() {
if (!_staticCallAP) {
- LLVMSignatureInfo* LSI = isolate->TheModule->getSignatureInfo(this);
+ LLVMSignatureInfo* LSI = initialLoader->TheModule->getSignatureInfo(this);
LSI->getStaticAP();
}
return _staticCallAP;
@@ -535,7 +536,7 @@
intptr_t Signdef::virtualCallAP() {
if (!_virtualCallAP) {
- LLVMSignatureInfo* LSI = isolate->TheModule->getSignatureInfo(this);
+ LLVMSignatureInfo* LSI = initialLoader->TheModule->getSignatureInfo(this);
LSI->getVirtualAP();
}
return _virtualCallAP;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h Thu Aug 14 10:58:53 2008
@@ -23,6 +23,7 @@
class JavaJIT;
class JavaObject;
class Jnjvm;
+class JnjvmClassLoader;
class UTF8;
#define VOID_ID 0
@@ -180,14 +181,14 @@
///
AssessorDesc(bool dt, char bid, uint32 nb, uint32 nw,
const char* name,
- Jnjvm* vm, uint8 nid,
+ JnjvmClassLoader* loader, uint8 nid,
const char* assocName, ClassArray* cl,
arrayCtor_t ctor);
/// initialise - Construct all assessors.
///
- static void initialise(Jnjvm* vm);
+ static void initialise(JnjvmClassLoader* loader);
/// printString - Print the assessor for debugging purposes.
@@ -198,13 +199,14 @@
uint32 meth, AssessorDesc*& ass,
uint32& ret);
- static const UTF8* constructArrayName(Jnjvm *vm, AssessorDesc* ass,
+ static const UTF8* constructArrayName(JnjvmClassLoader* loader, AssessorDesc* ass,
uint32 steps, const UTF8* className);
- static void introspectArrayName(Jnjvm *vm, const UTF8* utf8, uint32 start,
+ /*
+ static void introspectArrayName(const UTF8* utf8, uint32 start,
AssessorDesc*& ass, const UTF8*& res);
-
- static void introspectArray(Jnjvm *vm, JavaObject* loader, const UTF8* utf8,
+ */
+ static void introspectArray(JnjvmClassLoader* loader, const UTF8* utf8,
uint32 start, AssessorDesc*& ass,
CommonClass*& res);
@@ -238,9 +240,9 @@
///
const AssessorDesc* funcs;
- /// isolate - Which isolate constructed me?
+ /// initialLoader - The loader that first loaded this typedef.
///
- Jnjvm* isolate;
+ JnjvmClassLoader* initialLoader;
/// printString - Print the Typedef for debugging purposes.
///
@@ -249,16 +251,16 @@
/// assocClass - Given the loaded, try to load the class represented by this
/// Typedef.
///
- CommonClass* assocClass(JavaObject* loader);
+ CommonClass* assocClass(JnjvmClassLoader* loader);
/// humanPrintArgs - Prints the list of typedef in a human readable form.
///
static void humanPrintArgs(const std::vector<Typedef*>*,
mvm::PrintBuffer* buf);
- /// typeDup - Create a new Typedef.
+ /// Typedef - Create a new Typedef.
///
- static Typedef* typeDup(const UTF8* name, Jnjvm* vm);
+ Typedef(const UTF8* name, JnjvmClassLoader* loader);
/// tPrintBuf - Prints the name of the class this Typedef represents.
///
@@ -311,9 +313,9 @@
///
Typedef* ret;
- /// isolate - The isolate that defined the signature.
+ /// initialLoader - The loader that first loaded this typedef.
///
- Jnjvm* isolate;
+ JnjvmClassLoader* initialLoader;
/// keyName - The Java name of the signature, e.g. "()V".
///
@@ -328,9 +330,9 @@
///
void printWithSign(CommonClass* cl, const UTF8* name, mvm::PrintBuffer* buf);
- /// signDup - Create a new Signdef.
+ /// Signdef - Create a new Signdef.
///
- static Signdef* signDup(const UTF8* name, Jnjvm* vm);
+ Signdef(const UTF8* name, JnjvmClassLoader* loader);
//===----------------------------------------------------------------------===//
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp Thu Aug 14 10:58:53 2008
@@ -111,7 +111,7 @@
Class* Classpath::vmStackWalker;
-void ClasspathThread::initialise(Jnjvm* vm) {
+void ClasspathThread::initialise(JnjvmClassLoader* vm) {
newThread =
UPCALL_CLASS(vm, "java/lang/Thread");
@@ -169,7 +169,8 @@
}
void ClasspathThread::createInitialThread(Jnjvm* vm, JavaObject* th) {
- vm->loadName(newVMThread->name, newVMThread->classLoader, true, true, true);
+ JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader;
+ JCL->loadName(newVMThread->name, true, true, true);
JavaObject* vmth = newVMThread->doNew(vm);
name->setVirtualObjectField(th, (JavaObject*)vm->asciizToStr("main"));
@@ -179,16 +180,16 @@
assocThread->setVirtualObjectField(vmth, th);
running->setVirtualInt8Field(vmth, (uint32)1);
- rootGroup->classDef->isolate->loadName(rootGroup->classDef->name,
- rootGroup->classDef->classLoader,
- true, true, true);
+ JCL->loadName(rootGroup->classDef->name,
+ true, true, true);
JavaObject* RG = rootGroup->getStaticObjectField();
group->setVirtualObjectField(th, RG);
groupAddThread->invokeIntSpecial(vm, RG, th);
}
void ClasspathThread::mapInitialThread(Jnjvm* vm) {
- vm->loadName(newThread->name, newThread->classLoader, true, true, true);
+ JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader;
+ JCL->loadName(newThread->name, true, true, true);
JavaObject* th = newThread->doNew(vm);
createInitialThread(vm, th);
JavaThread* myth = JavaThread::get();
@@ -198,7 +199,7 @@
finaliseCreateInitialThread->invokeIntStatic(vm, th);
}
-void Classpath::initialiseClasspath(Jnjvm* vm) {
+void Classpath::initialiseClasspath(JnjvmClassLoader* vm) {
getSystemClassLoader =
UPCALL_METHOD(vm, "java/lang/ClassLoader", "getSystemClassLoader",
"()Ljava/lang/ClassLoader;", ACC_STATIC);
@@ -388,15 +389,14 @@
ClasspathThread::initialise(vm);
vm->loadName(vm->asciizConstructUTF8("java/lang/String"),
- CommonClass::jnjvmClassLoader, true,
- false, false);
+ true, false, false);
- CommonClass* object =
- vm->loadName(vm->asciizConstructUTF8("java/lang/Object"),
- CommonClass::jnjvmClassLoader, true,
- false, false);
- COMPILE_METHODS(object)
+ vm->loadName(vm->asciizConstructUTF8("java/lang/Object"),
+ true, false, false);
+ // Don't compile methods here, we still don't know where to allocate Java
+ // strings.
+
JavaMethod* getCallingClass =
UPCALL_METHOD(vm, "gnu/classpath/VMStackWalker", "getCallingClass",
"()Ljava/lang/Class;", ACC_STATIC);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h Thu Aug 14 10:58:53 2008
@@ -12,8 +12,7 @@
#define UPCALL_CLASS(vm, name) \
- vm->constructClass(vm->asciizConstructUTF8(name), \
- CommonClass::jnjvmClassLoader)
+ vm->constructClass(vm->asciizConstructUTF8(name)) \
#define UPCALL_FIELD(vm, cl, name, type, acc) \
UPCALL_CLASS(vm, cl)->constructField(vm->asciizConstructUTF8(name), \
@@ -26,8 +25,7 @@
#define UPCALL_ARRAY_CLASS(vm, name, depth) \
vm->constructArray( \
AssessorDesc::constructArrayName(vm, 0, depth, \
- vm->asciizConstructUTF8(name)), \
- CommonClass::jnjvmClassLoader)
+ vm->asciizConstructUTF8(name))) \
namespace jnjvm {
@@ -40,7 +38,7 @@
class ClasspathThread {
public:
- static void initialise(Jnjvm* vm);
+ static void initialise(JnjvmClassLoader* vm);
static Class* newThread;
static Class* newVMThread;
@@ -111,7 +109,7 @@
static ClassArray* stackTraceArray;
static JavaMethod* initStackTraceElement;
- static void initialiseClasspath(Jnjvm* vm);
+ static void initialiseClasspath(JnjvmClassLoader* loader);
static Class* voidClass;
static Class* boolClass;
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Thu Aug 14 10:58:53 2008
@@ -62,15 +62,16 @@
BEGIN_EXCEPTION
- Jnjvm *vm = NativeUtil::myVM(env);
- const UTF8* utf8 = vm->asciizConstructUTF8(asciiz);
- sint32 len = utf8->size;
-
- JavaObject* loader = 0;
+ JnjvmClassLoader* loader = 0;
Class* currentClass = JavaJIT::getCallingClass();
if (currentClass) loader = currentClass->classLoader;
+ else loader = JnjvmClassLoader::bootstrapLoader;
+
+ const UTF8* utf8 = loader->asciizConstructUTF8(asciiz);
+ sint32 len = utf8->size;
+
- CommonClass* cl = vm->lookupClassFromUTF8(utf8, 0, len, loader, true, true,
+ CommonClass* cl = loader->lookupClassFromUTF8(utf8, 0, len, true, true,
true);
return (jclass)(cl->getClassDelegatee());
@@ -139,7 +140,7 @@
JavaObject* res = ((Class*)cl)->doNew(vm);
JavaMethod* init =
cl->lookupMethod(Jnjvm::initName,
- vm->asciizConstructUTF8("(Ljava/lang/String;)V"), 0, 1);
+ cl->classLoader->asciizConstructUTF8("(Ljava/lang/String;)V"), 0, 1);
init->invokeIntSpecial(vm, res, vm->asciizToStr(msg));
th->pendingException = res;
th->returnFromNative();
@@ -291,14 +292,14 @@
const char *atype) {
BEGIN_EXCEPTION
-
- Jnjvm* vm = NativeUtil::myVM(env);
+
+ // TODO: find a better place for creating UTF8
CommonClass* cl = NativeUtil::resolvedImplClass(clazz, true);
- const UTF8* name = vm->asciizConstructUTF8(aname);
- const UTF8* type = vm->asciizConstructUTF8(atype);
+ const UTF8* name = cl->classLoader->asciizConstructUTF8(aname);
+ const UTF8* type = cl->classLoader->asciizConstructUTF8(atype);
JavaMethod* meth = cl->lookupMethod(
- name->javaToInternal(vm, 0, name->size),
- type->javaToInternal(vm, 0, type->size), false, true);
+ name->javaToInternal(cl->classLoader->hashUTF8, 0, name->size),
+ type->javaToInternal(cl->classLoader->hashUTF8, 0, type->size), false, true);
return (jmethodID)meth;
@@ -828,11 +829,11 @@
BEGIN_EXCEPTION
- Jnjvm* vm = NativeUtil::myVM(env);
- return (jfieldID)
- NativeUtil::resolvedImplClass(clazz, true)->lookupField(
- vm->asciizConstructUTF8(name),
- vm->asciizConstructUTF8(sig), 0, 1);
+ // TODO: find a better place to store the UTF8
+ CommonClass* cl = NativeUtil::resolvedImplClass(clazz, true);
+ return (jfieldID)
+ cl->lookupField(cl->classLoader->asciizConstructUTF8(name),
+ cl->classLoader->asciizConstructUTF8(sig), 0, 1);
END_EXCEPTION
return 0;
@@ -1070,14 +1071,14 @@
const char *atype) {
BEGIN_EXCEPTION
-
- Jnjvm* vm = NativeUtil::myVM(env);
+
+ // TODO: find a better place to store the UTF8
CommonClass* cl = NativeUtil::resolvedImplClass(clazz, true);
- const UTF8* name = vm->asciizConstructUTF8(aname);
- const UTF8* type = vm->asciizConstructUTF8(atype);
+ const UTF8* name = cl->classLoader->asciizConstructUTF8(aname);
+ const UTF8* type = cl->classLoader->asciizConstructUTF8(atype);
JavaMethod* meth = cl->lookupMethod(
- name->javaToInternal(vm, 0, name->size),
- type->javaToInternal(vm, 0, type->size), true, true);
+ name->javaToInternal(cl->classLoader->hashUTF8, 0, name->size),
+ type->javaToInternal(cl->classLoader->hashUTF8, 0, type->size), true, true);
return (jmethodID)meth;
@@ -1321,11 +1322,11 @@
BEGIN_EXCEPTION
- Jnjvm* vm = NativeUtil::myVM(env);
+ // TODO: find a better place to store the UTF8
+ CommonClass* cl = NativeUtil::resolvedImplClass(clazz, true);
return (jfieldID)
- NativeUtil::resolvedImplClass(clazz, true)->lookupField(
- vm->asciizConstructUTF8(name),
- vm->asciizConstructUTF8(sig), true, true);
+ cl->lookupField(cl->classLoader->asciizConstructUTF8(name),
+ cl->classLoader->asciizConstructUTF8(sig), true, true);
END_EXCEPTION
return 0;
@@ -1624,11 +1625,11 @@
if (length < 0) vm->negativeArraySizeException(length);
CommonClass* base = NativeUtil::resolvedImplClass(elementClass, true);
- JavaObject* loader = base->classLoader;
+ JnjvmClassLoader* loader = base->classLoader;
const UTF8* name = base->name;
- const UTF8* arrayName = AssessorDesc::constructArrayName(vm, 0, 1, name);
- ClassArray* array = vm->constructArray(arrayName, loader);
- ArrayObject* res = ArrayObject::acons(length, array, vm);
+ const UTF8* arrayName = AssessorDesc::constructArrayName(loader, 0, 1, name);
+ ClassArray* array = loader->constructArray(arrayName);
+ ArrayObject* res = ArrayObject::acons(length, array, &(vm->allocator));
if (initialElement) {
memset(res->elements, (int)initialElement,
length * sizeof(JavaObject*));
@@ -1672,7 +1673,7 @@
BEGIN_EXCEPTION
ArrayUInt8* res = 0;
- res = ArrayUInt8::acons(len, JavaArray::ofBool, NativeUtil::myVM(env));
+ res = ArrayUInt8::acons(len, JavaArray::ofBool, &NativeUtil::myVM(env)->allocator);
return (jbooleanArray)res;
END_EXCEPTION
@@ -1685,7 +1686,7 @@
BEGIN_EXCEPTION
ArraySInt8* res = 0;
- res = ArraySInt8::acons(len, JavaArray::ofByte, NativeUtil::myVM(env));
+ res = ArraySInt8::acons(len, JavaArray::ofByte, &NativeUtil::myVM(env)->allocator);
return (jbyteArray) res;
END_EXCEPTION
@@ -1698,7 +1699,7 @@
BEGIN_EXCEPTION
ArrayUInt16* res = 0;
- res = ArrayUInt16::acons(len, JavaArray::ofChar, NativeUtil::myVM(env));
+ res = ArrayUInt16::acons(len, JavaArray::ofChar, &NativeUtil::myVM(env)->allocator);
return (jcharArray) res;
END_EXCEPTION
@@ -1711,7 +1712,7 @@
BEGIN_EXCEPTION
ArraySInt16* res = 0;
- res = ArraySInt16::acons(len, JavaArray::ofShort, NativeUtil::myVM(env));
+ res = ArraySInt16::acons(len, JavaArray::ofShort, &NativeUtil::myVM(env)->allocator);
return (jshortArray) res;
END_EXCEPTION
@@ -1724,7 +1725,7 @@
BEGIN_EXCEPTION
ArraySInt32* res = 0;
- res = ArraySInt32::acons(len, JavaArray::ofInt, NativeUtil::myVM(env));
+ res = ArraySInt32::acons(len, JavaArray::ofInt, &NativeUtil::myVM(env)->allocator);
return (jintArray) res;
END_EXCEPTION
@@ -1737,7 +1738,7 @@
BEGIN_EXCEPTION
ArrayLong* res = 0;
- res = ArrayLong::acons(len, JavaArray::ofLong, NativeUtil::myVM(env));
+ res = ArrayLong::acons(len, JavaArray::ofLong, &NativeUtil::myVM(env)->allocator);
return (jlongArray) res;
END_EXCEPTION
@@ -1750,7 +1751,7 @@
BEGIN_EXCEPTION
ArrayFloat* res = 0;
- res = ArrayFloat::acons(len, JavaArray::ofFloat, NativeUtil::myVM(env));
+ res = ArrayFloat::acons(len, JavaArray::ofFloat, &NativeUtil::myVM(env)->allocator);
return (jfloatArray) res;
END_EXCEPTION
@@ -1763,7 +1764,7 @@
BEGIN_EXCEPTION
ArrayDouble* res = 0;
- res = ArrayDouble::acons(len, JavaArray::ofDouble, NativeUtil::myVM(env));
+ res = ArrayDouble::acons(len, JavaArray::ofDouble, &NativeUtil::myVM(env)->allocator);
return (jdoubleArray) res;
END_EXCEPTION
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Thu Aug 14 10:58:53 2008
@@ -15,8 +15,6 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include <sys/stat.h>
-
#include "debug.h"
#include "mvm/JIT.h"
@@ -40,8 +38,6 @@
using namespace jnjvm;
-Jnjvm* Jnjvm::bootstrapVM = 0;
-
#define DEF_UTF8(var) \
const UTF8* Jnjvm::var = 0
@@ -121,197 +117,6 @@
DECLARE_EXCEPTION(UnknownError);
DECLARE_EXCEPTION(ClassNotFoundException);
-
-void Jnjvm::analyseClasspathEnv(const char* str) {
- if (str != 0) {
- unsigned int len = strlen(str);
- char* buf = (char*)alloca(len + 1);
- const char* cur = str;
- int top = 0;
- char c = 1;
- while (c != 0) {
- while (((c = cur[top]) != 0) && c != envSeparator[0]) {
- top++;
- }
- if (top != 0) {
- memcpy(buf, cur, top);
- buf[top] = 0;
- char* rp = (char*)malloc(PATH_MAX);
- memset(rp, 0, PATH_MAX);
- rp = realpath(buf, rp);
- if (rp[PATH_MAX - 1] == 0 && strlen(rp) != 0) {
- struct stat st;
- stat(rp, &st);
- if ((st.st_mode & S_IFMT) == S_IFDIR) {
- unsigned int len = strlen(rp);
- char* temp = (char*)malloc(len + 2);
- memcpy(temp, rp, len);
- temp[len] = dirSeparator[0];
- temp[len + 1] = 0;
- bootClasspath.push_back(temp);
- free(rp);
- } else {
- ArrayUInt8* bytes = Reader::openFile(this, rp);
- free(rp);
- if (bytes) {
- ZipArchive *archive = new ZipArchive(bytes);
- if (archive) {
- bootArchives.push_back(archive);
- }
- }
- }
- } else {
- free(rp);
- }
- }
- cur = cur + top + 1;
- top = 0;
- }
- }
-}
-
-void Jnjvm::readParents(Class* cl, Reader& reader) {
- JavaCtpInfo* ctpInfo = cl->ctpInfo;
- unsigned short int superEntry = reader.readU2();
- const UTF8* super = superEntry ?
- ctpInfo->resolveClassName(superEntry) : 0;
-
- unsigned short int nbI = reader.readU2();
- cl->superUTF8 = super;
- for (int i = 0; i < nbI; i++)
- cl->interfacesUTF8.push_back(ctpInfo->resolveClassName(reader.readU2()));
-
-}
-
-void Jnjvm::loadParents(Class* cl) {
- const UTF8* super = cl->superUTF8;
- int nbI = cl->interfacesUTF8.size();
- JavaObject* classLoader = cl->classLoader;
- if (super == 0) {
- cl->depth = 0;
- cl->display = (CommonClass**)malloc(sizeof(CommonClass*));
- cl->display[0] = cl;
- cl->virtualTableSize = VT_SIZE / sizeof(void*);
- } else {
- cl->super = loadName(super, classLoader, true, false, true);
- int depth = cl->super->depth + 1;
- cl->depth = depth;
- cl->virtualTableSize = cl->super->virtualTableSize;
- cl->display = (CommonClass**)malloc((depth + 1) * sizeof(CommonClass*));
- memcpy(cl->display, cl->super->display, depth * sizeof(CommonClass*));
- cl->display[cl->depth] = cl;
- }
-
- for (int i = 0; i < nbI; i++)
- cl->interfaces.push_back((Class*)loadName(cl->interfacesUTF8[i],
- classLoader, true, false, true));
-}
-
-void Jnjvm::readAttributs(Class* cl, Reader& reader,
- std::vector<Attribut*>& attr) {
- JavaCtpInfo* ctpInfo = cl->ctpInfo;
- unsigned short int nba = reader.readU2();
-
- for (int i = 0; i < nba; i++) {
- const UTF8* attName = ctpInfo->UTF8At(reader.readU2());
- uint32 attLen = reader.readU4();
- Attribut* att = new Attribut(attName, attLen, reader.cursor);
- attr.push_back(att);
- reader.seek(attLen, Reader::SeekCur);
- }
-}
-
-void Jnjvm::readFields(Class* cl, Reader& reader) {
- uint16 nbFields = reader.readU2();
- JavaCtpInfo* ctpInfo = cl->ctpInfo;
- uint32 sindex = 0;
- uint32 vindex = 0;
- for (int i = 0; i < nbFields; i++) {
- uint16 access = reader.readU2();
- const UTF8* name = ctpInfo->UTF8At(reader.readU2());
- const UTF8* type = ctpInfo->UTF8At(reader.readU2());
- JavaField* field = cl->constructField(name, type, access);
- isStatic(access) ?
- field->num = sindex++ :
- field->num = vindex++;
- readAttributs(cl, reader, field->attributs);
- }
-}
-
-void Jnjvm::readMethods(Class* cl, Reader& reader) {
- uint16 nbMethods = reader.readU2();
- JavaCtpInfo* ctpInfo = cl->ctpInfo;
- for (int i = 0; i < nbMethods; i++) {
- uint16 access = reader.readU2();
- const UTF8* name = ctpInfo->UTF8At(reader.readU2());
- const UTF8* type = ctpInfo->UTF8At(reader.readU2());
- JavaMethod* meth = cl->constructMethod(name, type, access);
- readAttributs(cl, reader, meth->attributs);
- }
-}
-
-void Jnjvm::readClass(Class* cl) {
-
- PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "; ", 0);
- PRINT_DEBUG(JNJVM_LOAD, 0, LIGHT_GREEN, "reading ", 0);
- PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s::%s\n", printString(),
- cl->printString());
-
- Reader reader(cl->bytes);
- uint32 magic = reader.readU4();
- if (magic != Jnjvm::Magic) {
- Jnjvm::error(ClassFormatError, "bad magic number %p", magic);
- }
- cl->minor = reader.readU2();
- cl->major = reader.readU2();
- JavaCtpInfo::read(this, cl, reader);
- JavaCtpInfo* ctpInfo = cl->ctpInfo;
- cl->access = reader.readU2();
-
- const UTF8* thisClassName =
- ctpInfo->resolveClassName(reader.readU2());
-
- if (!(thisClassName->equals(cl->name))) {
- error(ClassFormatError, "try to load %s and found class named %s",
- cl->printString(), thisClassName->printString());
- }
-
- readParents(cl, reader);
- readFields(cl, reader);
- readMethods(cl, reader);
- readAttributs(cl, reader, cl->attributs);
-}
-
-ArrayUInt8* Jnjvm::openName(const UTF8* utf8) {
- char* asciiz = utf8->UTF8ToAsciiz();
- uint32 alen = strlen(asciiz);
- ArrayUInt8* res = 0;
-
- for (std::vector<const char*>::iterator i = bootClasspath.begin(),
- e = bootClasspath.end(); i != e; ++i) {
- const char* str = *i;
- unsigned int strLen = strlen(str);
- char* buf = (char*)alloca(strLen + alen + 7);
-
- sprintf(buf, "%s%s.class", str, asciiz);
- res = Reader::openFile(this, buf);
- if (res) return res;
- }
-
- for (std::vector<ZipArchive*>::iterator i = bootArchives.begin(),
- e = bootArchives.end(); i != e; ++i) {
-
- ZipArchive* archive = *i;
- char* buf = (char*)alloca(alen + 7);
- sprintf(buf, "%s.class", asciiz);
- res = Reader::openZip(this, archive, buf);
- if (res) return res;
- }
-
- return 0;
-}
-
-
typedef void (*clinit_t)(Jnjvm* vm);
void Jnjvm::initialiseClass(CommonClass* cl) {
@@ -331,7 +136,7 @@
cl->super->initialiseClass();
}
- TheModule->resolveStaticClass((Class*)cl);
+ cl->classLoader->TheModule->resolveStaticClass((Class*)cl);
*status = inClinit;
JavaMethod* meth = cl->lookupMethodDontThrow(clinitName, clinitType, true,
@@ -379,106 +184,29 @@
}
}
-void Jnjvm::resolveClass(CommonClass* cl, bool doClinit) {
- if (cl->status < resolved) {
- cl->acquire();
- int status = cl->status;
- if (status >= resolved) {
- cl->release();
- } else if (status < loaded) {
- cl->release();
- unknownError("try to resolve a not-read class");
- } else if (status == loaded || cl->ownerClass()) {
- if (cl->isArray) {
- ClassArray* arrayCl = (ClassArray*)cl;
- CommonClass* baseClass = arrayCl->baseClass();
- baseClass->resolveClass(doClinit);
- cl->status = resolved;
- } else {
- readClass((Class*)cl);
- cl->status = classRead;
- cl->release();
- loadParents((Class*)cl);
- cl->acquire();
- cl->status = prepared;
- TheModule->resolveVirtualClass((Class*)cl);
- cl->status = resolved;
- }
- cl->release();
- cl->broadcastClass();
- } else {
- while (status < resolved) {
- cl->waitClass();
- }
- cl->release();
- }
- }
- if (doClinit) cl->initialiseClass();
-}
-
-CommonClass* Jnjvm::loadName(const UTF8* name, JavaObject* loader,
- bool doResolve, bool doClinit, bool doThrow) {
-
-
- CommonClass* cl = lookupClass(name, loader);
- const UTF8* bootstrapName = name;
-
- if (!cl || cl->status == hashed) {
- if (!loader) { // I have to load it
- ArrayUInt8* bytes = openName(name);
- if (bytes) {
- if (!cl) cl = bootstrapVM->constructClass(bootstrapName, loader);
- if (cl->status == hashed) {
- cl->acquire();
- if (cl->status == hashed) {
- cl->status = loaded;
- ((Class*)cl)->bytes = bytes;
- }
- cl->release();
- }
- } else {
- cl = 0;
- }
- } else {
- cl = loadInClassLoader(name->internalToJava(this, 0, name->size), loader);
- }
- }
-
- if (!cl && doThrow) {
- if (!memcmp(name->UTF8ToAsciiz(), NoClassDefFoundError,
- strlen(NoClassDefFoundError))) {
- unknownError("Unable to load NoClassDefFoundError");
- }
- Jnjvm::error(NoClassDefFoundError, "unable to load %s", name->printString());
- }
-
- if (cl && doResolve) cl->resolveClass(doClinit);
-
- return cl;
-}
void Jnjvm::errorWithExcp(const char* className, const JavaObject* excp) {
- Class* cl = (Class*) this->loadName(this->asciizConstructUTF8(className),
- CommonClass::jnjvmClassLoader,
- true, true, true);
+ JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader;
+ Class* cl = (Class*) JCL->loadName(JCL->asciizConstructUTF8(className),
+ true, true, true);
JavaObject* obj = cl->doNew(this);
- JavaJIT::invokeOnceVoid(this, CommonClass::jnjvmClassLoader, className, "<init>",
+ JavaJIT::invokeOnceVoid(this, JCL, className, "<init>",
"(Ljava/lang/Throwable;)V", ACC_VIRTUAL, obj, excp);
JavaThread::throwException(obj);
}
void Jnjvm::error(const char* className, const char* fmt, ...) {
+ JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader;
char* tmp = (char*)alloca(4096);
- Class* cl = (Class*) this->loadName(this->asciizConstructUTF8(className),
- CommonClass::jnjvmClassLoader,
- true, true, true);
+ Class* cl = (Class*) JCL->loadName(JCL->asciizConstructUTF8(className),
+ true, true, true);
va_list ap;
va_start(ap, fmt);
vsnprintf(tmp, 4096, fmt, ap);
va_end(ap);
JavaObject* obj = cl->doNew(this);
- JavaJIT::invokeOnceVoid(this, CommonClass::jnjvmClassLoader, className, "<init>",
+ JavaJIT::invokeOnceVoid(this, JCL, className, "<init>",
"(Ljava/lang/String;)V", ACC_VIRTUAL, obj,
this->asciizToStr(tmp));
JavaThread::throwException(obj);
@@ -486,14 +214,14 @@
void Jnjvm::verror(const char* className, const char* fmt, va_list ap) {
+ JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader;
char* tmp = (char*)alloca(4096);
- Class* cl = (Class*) this->loadName(this->asciizConstructUTF8(className),
- CommonClass::jnjvmClassLoader,
- true, true, true);
+ Class* cl = (Class*) JCL->loadName(JCL->asciizConstructUTF8(className),
+ true, true, true);
vsnprintf(tmp, 4096, fmt, ap);
va_end(ap);
JavaObject* obj = cl->doNew(this);
- JavaJIT::invokeOnceVoid(this, CommonClass::jnjvmClassLoader, className, "<init>",
+ JavaJIT::invokeOnceVoid(this, JCL, className, "<init>",
"(Ljava/lang/String;)V", ACC_VIRTUAL, obj,
this->asciizToStr(tmp));
@@ -571,221 +299,16 @@
verror(UnknownError, fmt, ap);
}
-CommonClass* Jnjvm::lookupClassFromUTF8(const UTF8* utf8, unsigned int start,
- unsigned int len, JavaObject* loader,
- bool doResolve, bool doClinit,
- bool doThrow) {
- uint32 origLen = len;
- const UTF8* name = utf8->javaToInternal(this, start, len);
- bool doLoop = true;
- CommonClass* ret = 0;
-
- if (len == 0) {
- return 0;
- } else if (name->elements[0] == AssessorDesc::I_TAB) {
-
- while (doLoop) {
- --len;
- if (len == 0) {
- doLoop = false;
- } else {
- ++start;
- if (name->elements[start] != AssessorDesc::I_TAB) {
- if (name->elements[start] == AssessorDesc::I_REF) {
- uint32 size = (uint32)name->size;
- if ((size == (start + 1)) || (size == (start + 2)) ||
- (name->elements[start + 1] == AssessorDesc::I_TAB) ||
- (utf8->elements[origLen - 1] != AssessorDesc::I_END_REF)) {
- doLoop = false;
- } else {
- const UTF8* componentName = utf8->javaToInternal(this, start + 1,
- len - 2);
- if (loadName(componentName, loader, doResolve, doClinit,
- doThrow)) {
- ret = constructArray(name, loader);
- if (doResolve) ret->resolveClass(doClinit);
- doLoop = false;
- } else {
- doLoop = false;
- }
- }
- } else {
- uint16 cur = name->elements[start];
- if ((cur == AssessorDesc::I_BOOL || cur == AssessorDesc::I_BYTE ||
- cur == AssessorDesc::I_CHAR || cur == AssessorDesc::I_SHORT ||
- cur == AssessorDesc::I_INT || cur == AssessorDesc::I_FLOAT ||
- cur == AssessorDesc::I_DOUBLE || cur == AssessorDesc::I_LONG)
- && ((uint32)name->size) == start + 1) {
-
- ret = constructArray(name, loader);
- ret->resolveClass(doClinit);
- doLoop = false;
- } else {
- doLoop = false;
- }
- }
- }
- }
- }
-
- return ret;
-
- } else {
- return loadName(name, loader, doResolve, doClinit, doThrow);
- }
-}
-
-CommonClass* Jnjvm::lookupClassFromJavaString(JavaString* str,
- JavaObject* loader,
- bool doResolve, bool doClinit,
- bool doThrow) {
- return lookupClassFromUTF8(str->value, str->offset, str->count, loader,
- doResolve, doClinit, doThrow);
-}
-
-CommonClass* Jnjvm::lookupClass(const UTF8* utf8, JavaObject* loader) {
- if (loader) {
-#ifndef SERVICE_VM
- ClassMap* map =
- (ClassMap*)(Classpath::vmdataClassLoader->getVirtualObjectField(loader));
- if (!map) {
- map = vm_new(this, ClassMap)();
- Classpath::vmdataClassLoader->setVirtualObjectField(loader, (JavaObject*)map);
- }
-#else
- ClassMap* map = 0;
- ServiceDomain* vm =
- (ServiceDomain*)(Classpath::vmdataClassLoader->getVirtualObjectField(loader));
- if (!vm) {
- vm = ServiceDomain::allocateService((JavaIsolate*)Jnjvm::bootstrapVM);
- Classpath::vmdataClassLoader->setVirtualObjectField(loader, (JavaObject*)vm);
- }
- map = vm->classes;
-#endif
- return map->lookup(utf8);
- } else {
- return bootstrapClasses->lookup(utf8);
- }
-}
-
-static CommonClass* arrayDup(const UTF8*& name, Jnjvm *vm) {
- ClassArray* cl = vm_new(vm, ClassArray)(vm, name);
- return cl;
-}
-
-ClassArray* Jnjvm::constructArray(const UTF8* name, JavaObject* loader) {
- if (loader != 0)
- loader = ClassArray::arrayLoader(this, name, loader, 1, name->size - 1);
-
- if (loader) {
-#ifndef SERVICE_VM
- ClassMap* map =
- (ClassMap*)(Classpath::vmdataClassLoader->getVirtualObjectField(loader));
- if (!map) {
- map = vm_new(this, ClassMap)();
- Classpath::vmdataClassLoader->setVirtualObjectField(loader, (JavaObject*)map);
- }
- ClassArray* res = (ClassArray*)map->lookupOrCreate(name, this, arrayDup);
-#else
- ClassMap* map = 0;
- ServiceDomain* vm =
- (ServiceDomain*)(Classpath::vmdataClassLoader->getVirtualObjectField(loader));
- if (!vm) {
- vm = ServiceDomain::allocateService((JavaIsolate*)Jnjvm::bootstrapVM);
- Classpath::vmdataClassLoader->getVirtualObjectField(loader, (JavaObject*)vm);
- }
- map = vm->classes;
- ClassArray* res = (ClassArray*)map->lookupOrCreate(name, vm, arrayDup);
-#endif
- if (!res->classLoader) res->classLoader = loader;
- return res;
- } else {
- return (ClassArray*)bootstrapClasses->lookupOrCreate(name, this, arrayDup);
- }
-}
-
-
-static CommonClass* classDup(const UTF8*& name, Jnjvm *vm) {
- Class* cl = vm_new(vm, Class)(vm, name);
- return cl;
-}
-
-Class* Jnjvm::constructClass(const UTF8* name, JavaObject* loader) {
- if (loader) {
-#ifndef SERVICE_VM
- ClassMap* map =
- (ClassMap*)(Classpath::vmdataClassLoader->getVirtualObjectField(loader));
- if (!map) {
- map = vm_new(this, ClassMap)();
- (Classpath::vmdataClassLoader->setVirtualObjectField(loader, (JavaObject*)map));
- }
- Class* res = (Class*)map->lookupOrCreate(name, this, classDup);
-#else
- ClassMap* map = 0;
- ServiceDomain* vm =
- (ServiceDomain*)(Classpath::vmdataClassLoader->getVirtualObjectField(loader));
- if (!vm) {
- vm = ServiceDomain::allocateService((JavaIsolate*)Jnjvm::bootstrapVM);
- Classpath::vmdataClassLoader->setVirtualObjectField(loader, (JavaObject*)vm);
- }
- map = vm->classes;
- Class* res = (Class*)map->lookupOrCreate(name, vm, classDup);
-#endif
- if (!res->classLoader) res->classLoader = loader;
- return res;
- } else {
- return (Class*)bootstrapClasses->lookupOrCreate(name, this, classDup);
- }
-}
-
-const UTF8* Jnjvm::asciizConstructUTF8(const char* asciiz) {
- return hashUTF8->lookupOrCreateAsciiz(this, asciiz);
-}
-
-const UTF8* Jnjvm::readerConstructUTF8(const uint16* buf, uint32 size) {
- return hashUTF8->lookupOrCreateReader(this, buf, size);
-}
-
-Typedef* Jnjvm::constructType(const UTF8* name) {
- Typedef* res = javaTypes->lookup(name);
- if (res == 0) {
- res = Typedef::typeDup(name, this);
- javaTypes->lock->lock();
- Typedef* tmp = javaTypes->lookup(name);
- if (tmp == 0) javaTypes->hash(name, res);
- else res = tmp;
- javaTypes->lock->unlock();
- }
- return res;
-}
-
-Signdef* Jnjvm::constructSign(const UTF8* name) {
- Signdef* res = javaSignatures->lookup(name);
- if (res == 0) {
- res = Signdef::signDup(name, this);
- javaSignatures->lock->lock();
- Signdef* tmp = javaSignatures->lookup(name);
- if (tmp == 0) javaSignatures->hash(name, res);
- else res = tmp;
- javaSignatures->lock->unlock();
- }
- return res;
-}
-
-CommonClass* Jnjvm::loadInClassLoader(const UTF8* name, JavaObject* loader) {
- JavaString* str = this->UTF8ToStr(name);
- JavaObject* obj = (JavaObject*)
- Classpath::loadInClassLoader->invokeJavaObjectVirtual(this, loader, str);
- return (CommonClass*)(Classpath::vmdataClass->getVirtualObjectField(obj));
-}
-
JavaString* Jnjvm::UTF8ToStr(const UTF8* utf8) {
JavaString* res = hashStr->lookupOrCreate(utf8, this, JavaString::stringDup);
return res;
}
JavaString* Jnjvm::asciizToStr(const char* asciiz) {
- const UTF8* var = asciizConstructUTF8(asciiz);
+ // asciizToStr is called by jnjvm code, so utf8s created
+ // by this method are stored in the bootstrap class loader
+ JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader;
+ const UTF8* var = JCL->asciizConstructUTF8(asciiz);
return UTF8ToStr(var);
}
@@ -837,21 +360,14 @@
delete GC;
#endif
- delete hashUTF8;
- delete hashStr;
- delete javaTypes;
-
+ delete hashStr;
delete globalRefsLock;
- delete TheModuleProvider;
}
Jnjvm::Jnjvm() {
#ifdef MULTIPLE_GC
GC = 0;
#endif
- hashUTF8 = 0;
hashStr = 0;
- javaTypes = 0;
globalRefsLock = 0;
- TheModuleProvider = 0;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Thu Aug 14 10:58:53 2008
@@ -12,19 +12,15 @@
#include <vector>
+#include "types.h"
+
#include "mvm/Object.h"
#include "mvm/PrintBuffer.h"
#include "mvm/VirtualMachine.h"
#include "mvm/Threads/Cond.h"
#include "mvm/Threads/Locks.h"
-#include "types.h"
-
-#ifdef MULTIPLE_GC
-#define vm_new(vm, cl) collector_new(cl, vm->GC)
-#else
-#define vm_new(vm, cl) gc_new(cl)
-#endif
+#include "JavaAllocator.h"
namespace jnjvm {
@@ -37,6 +33,7 @@
class JavaMethod;
class JavaObject;
class JavaString;
+class JnjvmClassLoader;
class JnjvmModule;
class JnjvmModuleProvider;
class Reader;
@@ -63,8 +60,8 @@
#ifdef MULTIPLE_GC
Collector* GC;
#endif
+ JavaAllocator allocator;
static VirtualTable* VT;
- static Jnjvm* bootstrapVM;
static const char* dirSeparator;
static const char* envSeparator;
@@ -179,45 +176,14 @@
static const UTF8* tanh;
static const UTF8* finalize;
-
- void analyseClasspathEnv(const char*);
-
- // Loads a Class
- CommonClass* loadName(const UTF8* name, JavaObject* loader, bool doResolve,
- bool doClinit, bool doThrow);
-
- // Class lookup
- CommonClass* lookupClassFromUTF8(const UTF8* utf8, unsigned int start,
- unsigned int len, JavaObject* loader,
- bool doResolve, bool doClinit, bool doThrow);
- CommonClass* lookupClassFromJavaString(JavaString* str, JavaObject* loader,
- bool doResolve, bool doClinit,
- bool doThrow);
-
- void readParents(Class* cl, Reader& reader);
- void loadParents(Class* cl);
- void readAttributs(Class* cl, Reader& reader, std::vector<Attribut*> & attr);
- void readFields(Class* cl, Reader& reader);
- void readMethods(Class* cl, Reader& reader);
- void readClass(Class* cl);
+
void initialiseClass(CommonClass* cl);
- void resolveClass(CommonClass* cl, bool doClinit);
- ArrayUInt8* openName(const UTF8* utf8);
- CommonClass* lookupClass(const UTF8* utf8, JavaObject* loader);
-
- ClassArray* constructArray(const UTF8* name, JavaObject* loader);
- Class* constructClass(const UTF8* name, JavaObject* loader);
- const UTF8* asciizConstructUTF8(const char* asciiz);
- const UTF8* readerConstructUTF8(const uint16* buf, uint32 len);
JavaString* asciizToStr(const char* asciiz);
JavaString* UTF8ToStr(const UTF8* utf8);
- Typedef* constructType(const UTF8 * name);
- Signdef* constructSign(const UTF8 * name);
JavaObject* getClassDelegatee(CommonClass*);
- CommonClass* loadInClassLoader(const UTF8* utf8, JavaObject* loader);
virtual void TRACER;
virtual void print(mvm::PrintBuffer* buf) const {
@@ -232,12 +198,10 @@
void* jniEnv;
const void* javavmEnv;
std::vector< std::pair<char*, char*> > postProperties;
- std::vector<const char*> bootClasspath;
- std::vector<ZipArchive*> bootArchives;
std::vector<void*> nativeLibs;
const char* classpath;
- const char* libClasspathEnv;
- const char* bootClasspathEnv;
+
+
std::vector<JavaObject*, gc_allocator<JavaObject*> > globalRefs;
mvm::Lock* globalRefsLock;
@@ -246,32 +210,14 @@
}
const char* name;
- JavaObject* appClassLoader;
- UTF8Map * hashUTF8;
+ JnjvmClassLoader* appClassLoader;
StringMap * hashStr;
- ClassMap* bootstrapClasses;
- TypeMap* javaTypes;
- SignMap* javaSignatures;
#ifdef MULTIPLE_VM
StaticInstanceMap* statics;
DelegateeMap* delegatees;
#endif
- JnjvmModuleProvider* TheModuleProvider;
- JnjvmModule* TheModule;
-
-
-#ifndef MULTIPLE_GC
- void* allocateObject(unsigned int sz, VirtualTable* VT) {
- return gc::operator new(sz, VT);
- }
-#else
- void* allocateObject(unsigned int sz, VirtualTable* VT) {
- return gc::operator new(sz, VT, GC);
- }
-#endif
-
virtual void runApplication(int argc, char** argv);
};
Added: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=54779&view=auto
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (added)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Thu Aug 14 10:58:53 2008
@@ -0,0 +1,521 @@
+//===-- JnjvmClassLoader.cpp - Jnjvm representation of a class loader ------===//
+//
+// Jnjvm
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <sys/stat.h>
+
+#include "debug.h"
+
+#include "JavaAllocator.h"
+#include "JavaConstantPool.h"
+#include "JavaThread.h"
+#include "JavaUpcalls.h"
+#include "Jnjvm.h"
+#include "JnjvmClassLoader.h"
+#include "JnjvmModule.h"
+#include "JnjvmModuleProvider.h"
+#include "LockedMap.h"
+#include "Reader.h"
+
+using namespace jnjvm;
+
+JnjvmBootstrapLoader* JnjvmClassLoader::bootstrapLoader = 0;
+
+extern const char* GNUClasspathGlibj;
+extern const char* GNUClasspathLibs;
+
+JnjvmBootstrapLoader* JnjvmClassLoader::createBootstrapLoader() {
+
+ JnjvmBootstrapLoader* JCL = gc_new(JnjvmBootstrapLoader)();
+ JCL->TheModule = new JnjvmModule("Bootstrap JnJVM");
+ JCL->TheModuleProvider = new JnjvmModuleProvider(JCL->TheModule);
+ JCL->TheModule->initialise();
+
+ JCL->allocator = new JavaAllocator();
+
+ JCL->hashUTF8 = new UTF8Map(JCL->allocator);
+ JCL->classes = allocator_new(allocator, ClassMap)();
+ JCL->javaTypes = new TypeMap();
+ JCL->javaSignatures = new SignMap();
+
+ JCL->bootClasspathEnv = getenv("JNJVM_BOOTCLASSPATH");
+ if (!JCL->bootClasspathEnv) {
+ JCL->bootClasspathEnv = GNUClasspathGlibj;
+ }
+
+ JCL->libClasspathEnv = getenv("JNJVM_LIBCLASSPATH");
+ if (!JCL->libClasspathEnv) {
+ JCL->libClasspathEnv = GNUClasspathLibs;
+ }
+
+ JCL->analyseClasspathEnv(JCL->bootClasspathEnv);
+
+ return JCL;
+}
+
+JnjvmClassLoader::JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader, Jnjvm* I) {
+ TheModule = JCL.TheModule;
+ TheModuleProvider = JCL.TheModuleProvider;
+
+ allocator = &(isolate->allocator);
+
+ hashUTF8 = JCL.hashUTF8;
+ classes = allocator_new(allocator, ClassMap)();
+ javaTypes = JCL.javaTypes;
+ javaSignatures = JCL.javaSignatures;
+
+ javaLoader = loader;
+ isolate = I;
+
+}
+
+void JnjvmClassLoader::readParents(Class* cl, Reader& reader) {
+ JavaCtpInfo* ctpInfo = cl->ctpInfo;
+ unsigned short int superEntry = reader.readU2();
+ const UTF8* super = superEntry ?
+ ctpInfo->resolveClassName(superEntry) : 0;
+
+ unsigned short int nbI = reader.readU2();
+ cl->superUTF8 = super;
+ for (int i = 0; i < nbI; i++)
+ cl->interfacesUTF8.push_back(ctpInfo->resolveClassName(reader.readU2()));
+
+}
+
+void JnjvmClassLoader::loadParents(Class* cl) {
+ const UTF8* super = cl->superUTF8;
+ int nbI = cl->interfacesUTF8.size();
+ if (super == 0) {
+ cl->depth = 0;
+ cl->display = (CommonClass**)malloc(sizeof(CommonClass*));
+ cl->display[0] = cl;
+ cl->virtualTableSize = VT_SIZE / sizeof(void*);
+ } else {
+ cl->super = loadName(super, true, false, true);
+ int depth = cl->super->depth + 1;
+ cl->depth = depth;
+ cl->virtualTableSize = cl->super->virtualTableSize;
+ cl->display = (CommonClass**)malloc((depth + 1) * sizeof(CommonClass*));
+ memcpy(cl->display, cl->super->display, depth * sizeof(CommonClass*));
+ cl->display[cl->depth] = cl;
+ }
+
+ for (int i = 0; i < nbI; i++)
+ cl->interfaces.push_back((Class*)loadName(cl->interfacesUTF8[i],
+ true, false, true));
+}
+
+void JnjvmClassLoader::readAttributs(Class* cl, Reader& reader,
+ std::vector<Attribut*>& attr) {
+ JavaCtpInfo* ctpInfo = cl->ctpInfo;
+ unsigned short int nba = reader.readU2();
+
+ for (int i = 0; i < nba; i++) {
+ const UTF8* attName = ctpInfo->UTF8At(reader.readU2());
+ uint32 attLen = reader.readU4();
+ Attribut* att = new Attribut(attName, attLen, reader.cursor);
+ attr.push_back(att);
+ reader.seek(attLen, Reader::SeekCur);
+ }
+}
+
+void JnjvmClassLoader::readFields(Class* cl, Reader& reader) {
+ uint16 nbFields = reader.readU2();
+ JavaCtpInfo* ctpInfo = cl->ctpInfo;
+ uint32 sindex = 0;
+ uint32 vindex = 0;
+ for (int i = 0; i < nbFields; i++) {
+ uint16 access = reader.readU2();
+ const UTF8* name = ctpInfo->UTF8At(reader.readU2());
+ const UTF8* type = ctpInfo->UTF8At(reader.readU2());
+ JavaField* field = cl->constructField(name, type, access);
+ isStatic(access) ?
+ field->num = sindex++ :
+ field->num = vindex++;
+ readAttributs(cl, reader, field->attributs);
+ }
+}
+
+void JnjvmClassLoader::readMethods(Class* cl, Reader& reader) {
+ uint16 nbMethods = reader.readU2();
+ JavaCtpInfo* ctpInfo = cl->ctpInfo;
+ for (int i = 0; i < nbMethods; i++) {
+ uint16 access = reader.readU2();
+ const UTF8* name = ctpInfo->UTF8At(reader.readU2());
+ const UTF8* type = ctpInfo->UTF8At(reader.readU2());
+ JavaMethod* meth = cl->constructMethod(name, type, access);
+ readAttributs(cl, reader, meth->attributs);
+ }
+}
+
+void JnjvmClassLoader::readClass(Class* cl) {
+
+ PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "; ", 0);
+ PRINT_DEBUG(JNJVM_LOAD, 0, LIGHT_GREEN, "reading ", 0);
+ PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s::%s\n", printString(),
+ cl->printString());
+
+ Reader reader(cl->bytes);
+ uint32 magic = reader.readU4();
+ if (magic != Jnjvm::Magic) {
+ JavaThread::get()->isolate->error(Jnjvm::ClassFormatError, "bad magic number %p", magic);
+ }
+ cl->minor = reader.readU2();
+ cl->major = reader.readU2();
+ JavaCtpInfo::read(cl, reader);
+ JavaCtpInfo* ctpInfo = cl->ctpInfo;
+ cl->access = reader.readU2();
+
+ const UTF8* thisClassName =
+ ctpInfo->resolveClassName(reader.readU2());
+
+ if (!(thisClassName->equals(cl->name))) {
+ JavaThread::get()->isolate->error(Jnjvm::ClassFormatError, "try to load %s and found class named %s",
+ cl->printString(), thisClassName->printString());
+ }
+
+ readParents(cl, reader);
+ readFields(cl, reader);
+ readMethods(cl, reader);
+ readAttributs(cl, reader, cl->attributs);
+}
+
+ArrayUInt8* JnjvmBootstrapLoader::openName(const UTF8* utf8) {
+ char* asciiz = utf8->UTF8ToAsciiz();
+ uint32 alen = strlen(asciiz);
+ ArrayUInt8* res = 0;
+
+ for (std::vector<const char*>::iterator i = bootClasspath.begin(),
+ e = bootClasspath.end(); i != e; ++i) {
+ const char* str = *i;
+ unsigned int strLen = strlen(str);
+ char* buf = (char*)alloca(strLen + alen + 7);
+
+ sprintf(buf, "%s%s.class", str, asciiz);
+ res = Reader::openFile(this, buf);
+ if (res) return res;
+ }
+
+ for (std::vector<ZipArchive*>::iterator i = bootArchives.begin(),
+ e = bootArchives.end(); i != e; ++i) {
+
+ ZipArchive* archive = *i;
+ char* buf = (char*)alloca(alen + 7);
+ sprintf(buf, "%s.class", asciiz);
+ res = Reader::openZip(this, archive, buf);
+ if (res) return res;
+ }
+
+ return 0;
+}
+
+
+void JnjvmClassLoader::resolveClass(CommonClass* cl, bool doClinit) {
+ if (cl->status < resolved) {
+ cl->acquire();
+ int status = cl->status;
+ if (status >= resolved) {
+ cl->release();
+ } else if (status < loaded) {
+ cl->release();
+ JavaThread::get()->isolate->unknownError("try to resolve a not-read class");
+ } else if (status == loaded || cl->ownerClass()) {
+ if (cl->isArray) {
+ ClassArray* arrayCl = (ClassArray*)cl;
+ CommonClass* baseClass = arrayCl->baseClass();
+ baseClass->resolveClass(doClinit);
+ cl->status = resolved;
+ } else {
+ readClass((Class*)cl);
+ cl->status = classRead;
+ cl->release();
+ loadParents((Class*)cl);
+ cl->acquire();
+ cl->status = prepared;
+ TheModule->resolveVirtualClass((Class*)cl);
+ cl->status = resolved;
+ }
+ cl->release();
+ cl->broadcastClass();
+ } else {
+ while (status < resolved) {
+ cl->waitClass();
+ }
+ cl->release();
+ }
+ }
+ if (doClinit) cl->initialiseClass();
+}
+
+CommonClass* JnjvmBootstrapLoader::internalLoad(const UTF8* name) {
+
+ CommonClass* cl = lookupClass(name);
+
+ if (!cl || cl->status == hashed) {
+ ArrayUInt8* bytes = bootstrapLoader->openName(name);
+ if (bytes) {
+ if (!cl) cl = bootstrapLoader->constructClass(name);
+ if (cl->status == hashed) {
+ cl->acquire();
+ if (cl->status == hashed) {
+ cl->status = loaded;
+ ((Class*)cl)->bytes = bytes;
+ }
+ cl->release();
+ }
+ } else {
+ cl = 0;
+ }
+ }
+
+ return cl;
+}
+
+CommonClass* JnjvmClassLoader::internalLoad(const UTF8* name) {
+ CommonClass* cl = lookupClass(name);
+
+ if (!cl || cl->status == hashed) {
+ const UTF8* javaName = name->internalToJava(hashUTF8, 0, name->size);
+ JavaString* str = isolate->UTF8ToStr(javaName);
+ JavaObject* obj = (JavaObject*)
+ Classpath::loadInClassLoader->invokeJavaObjectVirtual(isolate, javaLoader,
+ str);
+ cl = (CommonClass*)(Classpath::vmdataClass->getVirtualObjectField(obj));
+ }
+
+ return cl;
+}
+
+CommonClass* JnjvmClassLoader::loadName(const UTF8* name, bool doResolve,
+ bool doClinit, bool doThrow) {
+
+
+ CommonClass* cl = internalLoad(name);
+
+ if (!cl && doThrow) {
+ if (!memcmp(name->UTF8ToAsciiz(), Jnjvm::NoClassDefFoundError,
+ strlen(Jnjvm::NoClassDefFoundError))) {
+ JavaThread::get()->isolate->unknownError("Unable to load NoClassDefFoundError");
+ }
+ JavaThread::get()->isolate->error(Jnjvm::NoClassDefFoundError, "unable to load %s", name->printString());
+ }
+
+ if (cl && doResolve) cl->resolveClass(doClinit);
+
+ return cl;
+}
+
+CommonClass* JnjvmClassLoader::lookupClassFromUTF8(const UTF8* utf8, unsigned int start,
+ unsigned int len,
+ bool doResolve, bool doClinit,
+ bool doThrow) {
+ uint32 origLen = len;
+ const UTF8* name = utf8->javaToInternal(hashUTF8, start, len);
+ bool doLoop = true;
+ CommonClass* ret = 0;
+
+ if (len == 0) {
+ return 0;
+ } else if (name->elements[0] == AssessorDesc::I_TAB) {
+
+ while (doLoop) {
+ --len;
+ if (len == 0) {
+ doLoop = false;
+ } else {
+ ++start;
+ if (name->elements[start] != AssessorDesc::I_TAB) {
+ if (name->elements[start] == AssessorDesc::I_REF) {
+ uint32 size = (uint32)name->size;
+ if ((size == (start + 1)) || (size == (start + 2)) ||
+ (name->elements[start + 1] == AssessorDesc::I_TAB) ||
+ (utf8->elements[origLen - 1] != AssessorDesc::I_END_REF)) {
+ doLoop = false;
+ } else {
+ const UTF8* componentName = utf8->javaToInternal(hashUTF8,
+ start + 1,
+ len - 2);
+ if (loadName(componentName, doResolve, doClinit,
+ doThrow)) {
+ ret = constructArray(name);
+ if (doResolve) ret->resolveClass(doClinit);
+ doLoop = false;
+ } else {
+ doLoop = false;
+ }
+ }
+ } else {
+ uint16 cur = name->elements[start];
+ if ((cur == AssessorDesc::I_BOOL || cur == AssessorDesc::I_BYTE ||
+ cur == AssessorDesc::I_CHAR || cur == AssessorDesc::I_SHORT ||
+ cur == AssessorDesc::I_INT || cur == AssessorDesc::I_FLOAT ||
+ cur == AssessorDesc::I_DOUBLE || cur == AssessorDesc::I_LONG)
+ && ((uint32)name->size) == start + 1) {
+
+ ret = constructArray(name);
+ ret->resolveClass(doClinit);
+ doLoop = false;
+ } else {
+ doLoop = false;
+ }
+ }
+ }
+ }
+ }
+
+ return ret;
+
+ } else {
+ return loadName(name, doResolve, doClinit, doThrow);
+ }
+}
+
+CommonClass* JnjvmClassLoader::lookupClassFromJavaString(JavaString* str,
+ bool doResolve, bool doClinit,
+ bool doThrow) {
+ return lookupClassFromUTF8(str->value, str->offset, str->count,
+ doResolve, doClinit, doThrow);
+}
+
+CommonClass* JnjvmClassLoader::lookupClass(const UTF8* utf8) {
+ return classes->lookup(utf8);
+}
+
+static CommonClass* arrayDup(const UTF8*& name, JnjvmClassLoader* loader) {
+ ClassArray* cl = allocator_new(loader->allocator, ClassArray)(loader, name);
+ return cl;
+}
+
+ClassArray* JnjvmClassLoader::constructArray(const UTF8* name) {
+ if (javaLoader != 0) {
+ JnjvmClassLoader * ld = ClassArray::arrayLoader(name, this, 1, name->size - 1);
+ ClassArray* res = (ClassArray*)ld->classes->lookupOrCreate(name, this, arrayDup);
+ return res;
+ } else {
+ return (ClassArray*)classes->lookupOrCreate(name, this, arrayDup);
+ }
+}
+
+
+static CommonClass* classDup(const UTF8*& name, JnjvmClassLoader* loader) {
+ Class* cl = allocator_new(loader->allocator, Class)(loader, name);
+ return cl;
+}
+
+Class* JnjvmClassLoader::constructClass(const UTF8* name) {
+ Class* res = (Class*)classes->lookupOrCreate(name, this, classDup);
+ return res;
+}
+
+Typedef* JnjvmClassLoader::constructType(const UTF8* name) {
+ Typedef* res = javaTypes->lookup(name);
+ if (res == 0) {
+ res = new Typedef(name, this);
+ javaTypes->lock->lock();
+ Typedef* tmp = javaTypes->lookup(name);
+ if (tmp == 0) javaTypes->hash(name, res);
+ else res = tmp;
+ javaTypes->lock->unlock();
+ }
+ return res;
+}
+
+Signdef* JnjvmClassLoader::constructSign(const UTF8* name) {
+ Signdef* res = javaSignatures->lookup(name);
+ if (res == 0) {
+ res = new Signdef(name, this);
+ javaSignatures->lock->lock();
+ Signdef* tmp = javaSignatures->lookup(name);
+ if (tmp == 0) javaSignatures->hash(name, res);
+ else res = tmp;
+ javaSignatures->lock->unlock();
+ }
+ return res;
+}
+
+
+JnjvmClassLoader* JnjvmClassLoader::getJnjvmLoaderFromJavaObject(JavaObject* loader) {
+
+ if (loader == 0)
+ return bootstrapLoader;
+
+ JnjvmClassLoader* JCL =
+ (JnjvmClassLoader*)(Classpath::vmdataClassLoader->getVirtualObjectField(loader));
+
+ if (!JCL) {
+ JCL = gc_new(JnjvmClassLoader)(*bootstrapLoader, loader, JavaThread::get()->isolate);
+ (Classpath::vmdataClassLoader->setVirtualObjectField(loader, (JavaObject*)JCL));
+ }
+
+ return JCL;
+}
+
+const UTF8* JnjvmClassLoader::asciizConstructUTF8(const char* asciiz) {
+ return hashUTF8->lookupOrCreateAsciiz(asciiz);
+}
+
+const UTF8* JnjvmClassLoader::readerConstructUTF8(const uint16* buf, uint32 size) {
+ return hashUTF8->lookupOrCreateReader(buf, size);
+}
+
+JnjvmClassLoader::~JnjvmClassLoader() {
+ /*delete hashUTF8;
+ delete javaTypes;
+ delete javaSignatures;
+ delete TheModuleProvider;*/
+}
+
+void JnjvmBootstrapLoader::analyseClasspathEnv(const char* str) {
+ if (str != 0) {
+ unsigned int len = strlen(str);
+ char* buf = (char*)alloca(len + 1);
+ const char* cur = str;
+ int top = 0;
+ char c = 1;
+ while (c != 0) {
+ while (((c = cur[top]) != 0) && c != Jnjvm::envSeparator[0]) {
+ top++;
+ }
+ if (top != 0) {
+ memcpy(buf, cur, top);
+ buf[top] = 0;
+ char* rp = (char*)malloc(PATH_MAX);
+ memset(rp, 0, PATH_MAX);
+ rp = realpath(buf, rp);
+ if (rp[PATH_MAX - 1] == 0 && strlen(rp) != 0) {
+ struct stat st;
+ stat(rp, &st);
+ if ((st.st_mode & S_IFMT) == S_IFDIR) {
+ unsigned int len = strlen(rp);
+ char* temp = (char*)malloc(len + 2);
+ memcpy(temp, rp, len);
+ temp[len] = Jnjvm::dirSeparator[0];
+ temp[len + 1] = 0;
+ bootClasspath.push_back(temp);
+ free(rp);
+ } else {
+ ArrayUInt8* bytes =
+ Reader::openFile(this, rp);
+ free(rp);
+ if (bytes) {
+ ZipArchive *archive = new ZipArchive(bytes);
+ if (archive) {
+ bootArchives.push_back(archive);
+ }
+ }
+ }
+ } else {
+ free(rp);
+ }
+ }
+ cur = cur + top + 1;
+ top = 0;
+ }
+ }
+}
+
Added: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=54779&view=auto
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (added)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Thu Aug 14 10:58:53 2008
@@ -0,0 +1,158 @@
+//===-- JnjvmClassLoader.h - Jnjvm representation of a class loader -------===//
+//
+// Jnjvm
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+#ifndef JNJVM_CLASSLOADER_H
+#define JNJVM_CLASSLOADER_H
+
+#include <vector>
+
+#include "types.h"
+
+namespace jnjvm {
+
+class ArrayUInt8;
+class Attribut;
+class Class;
+class ClassArray;
+class ClassMap;
+class CommonClass;
+class JavaAllocator;
+class JavaObject;
+class JavaString;
+class Jnjvm;
+class JnjvmBootstrapLoader;
+class JnjvmModule;
+class JnjvmModuleProvider;
+class Reader;
+class Signdef;
+class SignMap;
+class Typedef;
+class TypeMap;
+class UTF8;
+class UTF8Map;
+class ZipArchive;
+
+class JnjvmClassLoader : public mvm::Object {
+private:
+ virtual CommonClass* internalLoad(const UTF8* utf8);
+
+public:
+
+ static VirtualTable* VT;
+
+ virtual void TRACER;
+ virtual void print(mvm::PrintBuffer* buf) const {
+ buf->write("Java class loader<>");
+ }
+
+ Jnjvm* isolate;
+ JavaObject* javaLoader;
+
+ JavaObject* getJavaClassLoader() {
+ return javaLoader;
+ }
+
+ static JnjvmClassLoader* getJnjvmLoaderFromJavaObject(JavaObject*);
+
+ ClassMap* classes;
+
+ JavaAllocator* allocator;
+ JnjvmModule* TheModule;
+ JnjvmModuleProvider* TheModuleProvider;
+
+ // Loads a Class
+ virtual CommonClass* loadName(const UTF8* name, bool doResolve,
+ bool doClinit, bool doThrow);
+
+ // Class lookup
+ CommonClass* lookupClassFromUTF8(const UTF8* utf8, unsigned int start,
+ unsigned int len,
+ bool doResolve, bool doClinit, bool doThrow);
+ CommonClass* lookupClassFromJavaString(JavaString* str,
+ bool doResolve, bool doClinit,
+ bool doThrow);
+
+ void readParents(Class* cl, Reader& reader);
+ void loadParents(Class* cl);
+ void readAttributs(Class* cl, Reader& reader, std::vector<Attribut*> & attr);
+ void readFields(Class* cl, Reader& reader);
+ void readMethods(Class* cl, Reader& reader);
+ void readClass(Class* cl);
+ void initialiseClass(CommonClass* cl);
+ void resolveClass(CommonClass* cl, bool doClinit);
+
+ CommonClass* lookupClass(const UTF8* utf8);
+
+ ClassArray* constructArray(const UTF8* name);
+ Class* constructClass(const UTF8* name);
+
+
+
+ TypeMap* javaTypes;
+ SignMap* javaSignatures;
+ UTF8Map * hashUTF8;
+
+ static JnjvmBootstrapLoader* bootstrapLoader;
+
+#ifdef MULTIPLE_VM
+ static JnjvmClassLoader* SharedLoader;
+#endif
+
+ Typedef* constructType(const UTF8 * name);
+ Signdef* constructSign(const UTF8 * name);
+
+ ~JnjvmClassLoader();
+ JnjvmClassLoader() {
+ hashUTF8 = 0;
+ javaTypes = 0;
+ javaSignatures = 0;
+ TheModule = 0;
+ TheModuleProvider = 0;
+ isolate = 0;
+ }
+
+ JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader, Jnjvm* isolate);
+ static JnjvmBootstrapLoader* createBootstrapLoader();
+
+
+ const UTF8* asciizConstructUTF8(const char* asciiz);
+
+ const UTF8* readerConstructUTF8(const uint16* buf, uint32 size);
+
+
+};
+
+
+class JnjvmBootstrapLoader : public JnjvmClassLoader {
+private:
+ virtual CommonClass* internalLoad(const UTF8* utf8);
+
+public:
+
+ static VirtualTable* VT;
+
+ virtual void TRACER;
+ virtual void print(mvm::PrintBuffer* buf) const {
+ buf->write("Jnjvm bootstrap loader<>");
+ }
+
+ void analyseClasspathEnv(const char*);
+
+ const char* libClasspathEnv;
+ const char* bootClasspathEnv;
+ std::vector<const char*> bootClasspath;
+ std::vector<ZipArchive*> bootArchives;
+
+ ArrayUInt8* openName(const UTF8* utf8);
+};
+
+} // end namespace jnjvm
+
+#endif // JNJVM_CLASSLOADER_H
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Thu Aug 14 10:58:53 2008
@@ -135,7 +135,7 @@
classDef->isArray && classDef->isolate != Jnjvm::bootstrapVM) {
// We know the array class can belong to bootstrap
CommonClass* cl = Jnjvm::bootstrapVM->constructArray(classDef->name, 0);
- return cl->isolate->TheModule->getClassInfo(cl)->getVar(jit);
+ return cl->classLoader->TheModule->getClassInfo(cl)->getVar(jit);
}
#endif
@@ -147,7 +147,7 @@
varGV = new GlobalVariable(JnjvmModule::JavaClassType, true,
GlobalValue::ExternalLinkage,
cons, "",
- classDef->isolate->TheModule);
+ classDef->classLoader->TheModule);
}
return new LoadInst(varGV, "", jit->currentBlock);
}
@@ -162,7 +162,7 @@
delegateeGV = new GlobalVariable(JnjvmModule::JavaObjectType, true,
GlobalValue::ExternalLinkage,
cons, "",
- classDef->isolate->TheModule);
+ classDef->classLoader->TheModule);
}
return new LoadInst(delegateeGV, "", jit->currentBlock);
#else
@@ -195,7 +195,7 @@
if (meth->name->equals(Jnjvm::finalize)) {
VT = allocateVT(cl, ++meths);
meth->offset = 0;
- Function* func = cl->isolate->TheModuleProvider->parseFunction(meth);
+ Function* func = cl->classLoader->TheModuleProvider->parseFunction(meth);
if (!cl->super) meth->canBeInlined = true;
Function::iterator BB = func->begin();
BasicBlock::iterator I = BB->begin();
@@ -280,7 +280,7 @@
Function* func = Function::Create(JnjvmModule::MarkAndTraceType,
GlobalValue::ExternalLinkage,
"markAndTraceObject",
- cl->isolate->TheModule);
+ cl->classLoader->TheModule);
Constant* zero = mvm::jit::constantZero;
Argument* arg = func->arg_begin();
@@ -439,8 +439,8 @@
#ifndef MULTIPLE_VM
JavaObject* val =
- (JavaObject*)classDef->isolate->allocateObject(cl->staticSize,
- cl->staticVT);
+ (JavaObject*)JavaThread::get()->isolate->allocator.allocateObject(cl->staticSize,
+ cl->staticVT);
val->initialise(classDef);
for (CommonClass::field_iterator i = cl->staticFields.begin(),
e = cl->staticFields.end(); i!= e; ++i) {
@@ -466,7 +466,7 @@
staticVarGV = new GlobalVariable(JnjvmModule::JavaObjectType, true,
GlobalValue::ExternalLinkage,
cons, "",
- classDef->isolate->TheModule);
+ classDef->classLoader->TheModule);
}
return new LoadInst(staticVarGV, "", jit->currentBlock);
@@ -490,7 +490,7 @@
virtualTableGV = new GlobalVariable(JnjvmModule::VTType, true,
GlobalValue::ExternalLinkage,
cons, "",
- classDef->isolate->TheModule);
+ classDef->classLoader->TheModule);
}
return new LoadInst(virtualTableGV, "", jit->currentBlock);
}
@@ -520,12 +520,12 @@
Function* LLVMMethodInfo::getMethod() {
if (!methodFunction) {
- Jnjvm* vm = methodDef->classDef->isolate;
+ JnjvmClassLoader* JCL = methodDef->classDef->classLoader;
methodFunction = Function::Create(getFunctionType(),
GlobalValue::GhostLinkage,
methodDef->printString(),
- vm->TheModule);
- vm->TheModuleProvider->addFunction(methodFunction, methodDef);
+ JCL->TheModule);
+ JCL->TheModuleProvider->addFunction(methodFunction, methodDef);
}
return methodFunction;
}
@@ -651,7 +651,7 @@
getStaticBufType(),
GlobalValue::ExternalLinkage,
signature->printString(),
- signature->isolate->TheModule);
+ signature->initialLoader->TheModule);
BasicBlock* currentBlock = BasicBlock::Create("enter", res);
Function::arg_iterator i = res->arg_begin();
@@ -706,7 +706,7 @@
getStaticBufType(),
GlobalValue::ExternalLinkage,
signature->printString(),
- signature->isolate->TheModule);
+ signature->initialLoader->TheModule);
BasicBlock* currentBlock = BasicBlock::Create("enter", res);
Function::arg_iterator i = res->arg_begin();
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Thu Aug 14 10:58:53 2008
@@ -156,7 +156,7 @@
llvm::Function* JnjvmModuleProvider::addCallback(Class* cl, uint32 index,
Signdef* sign, bool stat) {
const llvm::FunctionType* type = 0;
- JnjvmModule* M = cl->isolate->TheModule;
+ JnjvmModule* M = cl->classLoader->TheModule;
LLVMSignatureInfo* LSI = M->getSignatureInfo(sign);
if (stat) {
Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp Thu Aug 14 10:58:53 2008
@@ -9,6 +9,7 @@
#include <map>
+#include "JavaAllocator.h"
#include "JavaArray.h"
#include "JavaClass.h"
#include "JavaString.h"
@@ -74,7 +75,7 @@
}
-const UTF8* UTF8Map::lookupOrCreateAsciiz(Jnjvm* vm, const char* asciiz) {
+const UTF8* UTF8Map::lookupOrCreateAsciiz(const char* asciiz) {
sint32 size = strlen(asciiz);
uint32 key = asciizHasher(asciiz, size);
const UTF8* res = 0;
@@ -90,7 +91,7 @@
}
if (res == 0) {
- UTF8* tmp = (UTF8*)UTF8::acons(size, JavaArray::ofChar, vm);
+ UTF8* tmp = (UTF8*)UTF8::acons(size, JavaArray::ofChar, allocator);
for (sint32 i = 0; i < size; i++) {
tmp->elements[i] = asciiz[i];
}
@@ -102,8 +103,7 @@
return res;
}
-const UTF8* UTF8Map::lookupOrCreateReader(Jnjvm* vm, const uint16* buf,
- uint32 len) {
+const UTF8* UTF8Map::lookupOrCreateReader(const uint16* buf, uint32 len) {
sint32 size = (sint32)len;
uint32 key = readerHasher(buf, size);
const UTF8* res = 0;
@@ -119,7 +119,7 @@
}
if (res == 0) {
- UTF8* tmp = (UTF8*)UTF8::acons(size, JavaArray::ofChar, vm);
+ UTF8* tmp = (UTF8*)UTF8::acons(size, JavaArray::ofChar, allocator);
memcpy(tmp->elements, buf, len * sizeof(uint16));
res = (const UTF8*)tmp;
map.insert(std::make_pair(key, res));
Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h Thu Aug 14 10:58:53 2008
@@ -29,7 +29,7 @@
namespace jnjvm {
class JavaObject;
-class Jnjvm;
+class Allocator;
struct ltutf8
{
@@ -39,22 +39,22 @@
}
};
-template<class Key, class Container, class Compare>
+template<class Key, class Container, class Compare, class Meta>
class LockedMap : public mvm::Object {
public:
typedef typename std::map<const Key, Container, Compare>::iterator iterator;
- typedef Container (*funcCreate)(Key& V, Jnjvm *vm);
+ typedef Container (*funcCreate)(Key& V, Meta meta);
mvm::Lock* lock;
std::map<const Key, Container, Compare,
gc_allocator<std::pair<const Key, Container> > > map;
- inline Container lookupOrCreate(Key& V, Jnjvm *vm, funcCreate func) {
+ inline Container lookupOrCreate(Key& V, Meta meta, funcCreate func) {
lock->lock();
iterator End = map.end();
iterator I = map.find(V);
if (I == End) {
- Container res = func(V, vm);
+ Container res = func(V, meta);
map.insert(std::make_pair(V, res));
lock->unlock();
return res;
@@ -96,14 +96,16 @@
typedef std::multimap<const uint32, const UTF8*>::iterator iterator;
mvm::Lock* lock;
+ JavaAllocator* allocator;
std::multimap<const uint32, const UTF8*> map;
- const UTF8* lookupOrCreateAsciiz(Jnjvm* vm, const char* asciiz);
- const UTF8* lookupOrCreateReader(Jnjvm* vm, const uint16* buf, uint32 size);
+ const UTF8* lookupOrCreateAsciiz(const char* asciiz);
+ const UTF8* lookupOrCreateReader(const uint16* buf, uint32 size);
const UTF8* lookupAsciiz(const char* asciiz);
const UTF8* lookupReader(const uint16* buf, uint32 size);
- UTF8Map() {
+ UTF8Map(JavaAllocator* A) {
lock = mvm::Lock::allocNormal();
+ allocator = A;
}
~UTF8Map() {
@@ -124,7 +126,7 @@
};
class ClassMap :
- public LockedMap<const UTF8*, CommonClass*, ltutf8 > {
+ public LockedMap<const UTF8*, CommonClass*, ltutf8, JnjvmClassLoader* > {
public:
static VirtualTable* VT;
@@ -244,7 +246,7 @@
};
class StaticInstanceMap :
- public LockedMap<Class*, std::pair<JavaState, JavaObject*>*, std::less<Class*> > {
+ public LockedMap<Class*, std::pair<JavaState, JavaObject*>*, std::less<Class*>, Jnjvm* > {
public:
static VirtualTable* VT;
@@ -263,7 +265,7 @@
};
class DelegateeMap :
- public LockedMap<CommonClass*, JavaObject*, std::less<CommonClass*> > {
+ public LockedMap<CommonClass*, JavaObject*, std::less<CommonClass*>, Jnjvm* > {
public:
static VirtualTable* VT;
Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Thu Aug 14 10:58:53 2008
@@ -19,6 +19,7 @@
#include "JavaTypes.h"
#include "JavaUpcalls.h"
#include "Jnjvm.h"
+#include "JnjvmClassLoader.h"
#include "NativeUtil.h"
#include "Reader.h"
@@ -375,15 +376,15 @@
return;
}
-JavaObject* NativeUtil::getClassType(JavaObject* loader, Typedef* type) {
+JavaObject* NativeUtil::getClassType(JnjvmClassLoader* loader, Typedef* type) {
CommonClass* res = type->assocClass(loader);
return res->getClassDelegatee();
}
-ArrayObject* NativeUtil::getParameterTypes(JavaObject* loader, JavaMethod* meth) {
+ArrayObject* NativeUtil::getParameterTypes(JnjvmClassLoader* loader, JavaMethod* meth) {
std::vector<Typedef*>& args = meth->getSignature()->args;
ArrayObject* res = ArrayObject::acons(args.size(), Classpath::classArrayClass,
- JavaThread::get()->isolate);
+ &(JavaThread::get()->isolate->allocator));
sint32 index = 0;
for (std::vector<Typedef*>::iterator i = args.begin(), e = args.end();
@@ -399,14 +400,14 @@
Attribut* exceptionAtt = meth->lookupAttribut(Attribut::exceptionsAttribut);
if (exceptionAtt == 0) {
return ArrayObject::acons(0, Classpath::classArrayClass,
- JavaThread::get()->isolate);
+ &(JavaThread::get()->isolate->allocator));
} else {
Class* cl = meth->classDef;
JavaCtpInfo* ctp = cl->ctpInfo;
Reader reader(exceptionAtt, cl->bytes);
uint16 nbe = reader.readU2();
ArrayObject* res = ArrayObject::acons(nbe, Classpath::classArrayClass,
- JavaThread::get()->isolate);
+ &(JavaThread::get()->isolate->allocator));
for (uint16 i = 0; i < nbe; ++i) {
uint16 idx = reader.readU2();
Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h Thu Aug 14 10:58:53 2008
@@ -19,6 +19,7 @@
class JavaMethod;
class JavaObject;
class Jnjvm;
+class JnjvmClassLoader;
class Signdef;
class Typedef;
@@ -32,8 +33,8 @@
static void decapsulePrimitive(Jnjvm *vm, void**&buf, JavaObject* obj,
Typedef* signature);
- static JavaObject* getClassType(JavaObject* loader, Typedef* type);
- static ArrayObject* getParameterTypes(JavaObject* loader, JavaMethod* meth);
+ static JavaObject* getClassType(JnjvmClassLoader* loader, Typedef* type);
+ static ArrayObject* getParameterTypes(JnjvmClassLoader* loader, JavaMethod* meth);
static ArrayObject* getExceptionTypes(JavaMethod* meth);
};
Modified: vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp Thu Aug 14 10:58:53 2008
@@ -24,25 +24,25 @@
const int Reader::SeekCur = SEEK_CUR;
const int Reader::SeekEnd = SEEK_END;
-ArrayUInt8* Reader::openFile(Jnjvm* vm, char* path) {
+ArrayUInt8* Reader::openFile(JnjvmClassLoader* loader, char* path) {
FILE* fp = fopen(path, "r");
ArrayUInt8* res = 0;
if (fp != 0) {
fseek(fp, 0, SeekEnd);
long nbb = ftell(fp);
fseek(fp, 0, SeekSet);
- res = ArrayUInt8::acons(nbb, JavaArray::ofByte, vm);
+ res = ArrayUInt8::acons(nbb, JavaArray::ofByte, loader->allocator);
fread(res->elements, nbb, 1, fp);
fclose(fp);
}
return res;
}
-ArrayUInt8* Reader::openZip(Jnjvm* vm, ZipArchive* archive, char* filename) {
+ArrayUInt8* Reader::openZip(JnjvmClassLoader* loader, ZipArchive* archive, char* filename) {
ArrayUInt8* ret = 0;
ZipFile* file = archive->getFile(filename);
if (file != 0) {
- ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, JavaArray::ofByte, vm);
+ ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, JavaArray::ofByte, loader->allocator);
if (archive->readFile(res, file) != 0) {
ret = res;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/Reader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Reader.h?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Reader.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Reader.h Thu Aug 14 10:58:53 2008
@@ -19,7 +19,7 @@
namespace jnjvm {
-class Jnjvm;
+class JnjvmClassLoader;
class ZipArchive;
class Reader {
@@ -76,8 +76,8 @@
static const int SeekCur;
static const int SeekEnd;
- static ArrayUInt8* openFile(Jnjvm* vm, char* path);
- static ArrayUInt8* openZip(Jnjvm* vm, ZipArchive* archive, char* filename);
+ static ArrayUInt8* openFile(JnjvmClassLoader* loader, char* path);
+ static ArrayUInt8* openZip(JnjvmClassLoader* loader, ZipArchive* archive, char* filename);
uint8 readU1() {
return bytes->elements[cursor++];
Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Thu Aug 14 10:58:53 2008
@@ -16,6 +16,7 @@
#include "JavaObject.h"
#include "JavaThread.h"
#include "Jnjvm.h"
+#include "JnjvmClassLoader.h"
#include "LockedMap.h"
#ifdef SERVICE_VM
#include "ServiceDomain.h"
@@ -37,6 +38,8 @@
INIT(StaticInstanceMap);
INIT(JavaIsolate);
INIT(DelegateeMap);
+ INIT(JnjvmBootstrapLoader);
+ INIT(JnjvmClassLoader);
#ifdef SERVICE_VM
INIT(ServiceDomain);
#endif
@@ -98,23 +101,18 @@
void Jnjvm::TRACER {
appClassLoader->MARK_AND_TRACE;
- bootstrapClasses->MARK_AND_TRACE;
TRACE_VECTOR(JavaObject*, gc_allocator, globalRefs);
#ifdef MULTIPLE_VM
statics->MARK_AND_TRACE;
delegatees->MARK_AND_TRACE;
#endif
- for (std::vector<ZipArchive*>::iterator i = bootArchives.begin(),
- e = bootArchives.end(); i != e; ++i) {
- (*i)->bytes->MARK_AND_TRACE;
- }
-
}
void JavaIsolate::TRACER {
Jnjvm::PARENT_TRACER;
bootstrapThread->MARK_AND_TRACE;
+ JnjvmClassLoader::bootstrapLoader->MARK_AND_TRACE;
}
void ClassMap::TRACER {
@@ -135,6 +133,21 @@
}
}
+void JnjvmClassLoader::TRACER {
+ javaLoader->MARK_AND_TRACE;
+ classes->MARK_AND_TRACE;
+ isolate->MARK_AND_TRACE;
+}
+
+void JnjvmBootstrapLoader::TRACER {
+ classes->MARK_AND_TRACE;
+
+ for (std::vector<ZipArchive*>::iterator i = bootArchives.begin(),
+ e = bootArchives.end(); i != e; ++i) {
+ (*i)->bytes->MARK_AND_TRACE;
+ }
+}
+
#ifdef SERVICE_VM
void ServiceDomain::TRACER {
JavaIsolate::PARENT_TRACER;
Modified: vmkit/trunk/lib/JnJVM/VMCore/Zip.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Zip.h?rev=54779&r1=54778&r2=54779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Zip.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Zip.h Thu Aug 14 10:58:53 2008
@@ -15,7 +15,7 @@
namespace jnjvm {
class ArrayUInt8;
-class Jnjvm;
+class JnjvmBootstrapLoader;
struct ZipFile {
char* filename;
@@ -31,7 +31,7 @@
class ZipArchive {
- friend class Jnjvm;
+ friend class JnjvmBootstrapLoader;
private:
struct ltstr
More information about the vmkit-commits
mailing list