[vmkit-commits] [vmkit] r121248 - in /vmkit/branches/multi-vm/lib/J3: Classpath/Classpath.inc Classpath/ClasspathVMClass.inc Classpath/ClasspathVMRuntime.inc Classpath/JavaUpcalls.cpp Classpath/JavaUpcalls.h Compiler/ExceptionsCheck.inc Compiler/ExceptionsDwarf.inc Compiler/JavaAOTCompiler.cpp Compiler/JavaJIT.cpp Compiler/JavaJIT.h Compiler/JavaJITOpcodes.cpp VMCore/JavaClass.cpp VMCore/JavaConstantPool.cpp VMCore/Jni.cpp VMCore/Jnjvm.cpp VMCore/JnjvmClassLoader.cpp VMCore/JnjvmClassLoader.h VMCore/VirtualTables.cpp
Gael Thomas
gael.thomas at lip6.fr
Wed Dec 8 02:29:13 PST 2010
Author: gthomas
Date: Wed Dec 8 04:29:13 2010
New Revision: 121248
URL: http://llvm.org/viewvc/llvm-project?rev=121248&view=rev
Log:
remove useless bootstrapLoader from classLoader, move the primitive classes in upcalls
Modified:
vmkit/branches/multi-vm/lib/J3/Classpath/Classpath.inc
vmkit/branches/multi-vm/lib/J3/Classpath/ClasspathVMClass.inc
vmkit/branches/multi-vm/lib/J3/Classpath/ClasspathVMRuntime.inc
vmkit/branches/multi-vm/lib/J3/Classpath/JavaUpcalls.cpp
vmkit/branches/multi-vm/lib/J3/Classpath/JavaUpcalls.h
vmkit/branches/multi-vm/lib/J3/Compiler/ExceptionsCheck.inc
vmkit/branches/multi-vm/lib/J3/Compiler/ExceptionsDwarf.inc
vmkit/branches/multi-vm/lib/J3/Compiler/JavaAOTCompiler.cpp
vmkit/branches/multi-vm/lib/J3/Compiler/JavaJIT.cpp
vmkit/branches/multi-vm/lib/J3/Compiler/JavaJIT.h
vmkit/branches/multi-vm/lib/J3/Compiler/JavaJITOpcodes.cpp
vmkit/branches/multi-vm/lib/J3/VMCore/JavaClass.cpp
vmkit/branches/multi-vm/lib/J3/VMCore/JavaConstantPool.cpp
vmkit/branches/multi-vm/lib/J3/VMCore/Jni.cpp
vmkit/branches/multi-vm/lib/J3/VMCore/Jnjvm.cpp
vmkit/branches/multi-vm/lib/J3/VMCore/JnjvmClassLoader.cpp
vmkit/branches/multi-vm/lib/J3/VMCore/JnjvmClassLoader.h
vmkit/branches/multi-vm/lib/J3/VMCore/VirtualTables.cpp
Modified: vmkit/branches/multi-vm/lib/J3/Classpath/Classpath.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/Classpath/Classpath.inc?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/Classpath/Classpath.inc (original)
+++ vmkit/branches/multi-vm/lib/J3/Classpath/Classpath.inc Wed Dec 8 04:29:13 2010
@@ -38,8 +38,8 @@
UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
if (cl->isClass() &&
- cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
- vm->bootstrapLoader->clinitType,
+ cl->asClass()->lookupMethodDontThrow(vm->upcalls->clinitName,
+ vm->upcalls->clinitType,
true, false, 0))
res = true;
Modified: vmkit/branches/multi-vm/lib/J3/Classpath/ClasspathVMClass.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/Classpath/ClasspathVMClass.inc?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/Classpath/ClasspathVMClass.inc (original)
+++ vmkit/branches/multi-vm/lib/J3/Classpath/ClasspathVMClass.inc Wed Dec 8 04:29:13 2010
@@ -100,13 +100,12 @@
ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
} else {
UserClass* realCl = cl->asClass();;
- JnjvmClassLoader* classLoader = cl->classLoader;
uint32 size = 0;
for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
JavaMethod* meth = &realCl->virtualMethods[i];
bool pub = isPublic(meth->access);
- if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
+ if (meth->name->equals(vm->upcalls->initName) &&
(!publicOnly || pub)) {
++size;
}
@@ -118,7 +117,7 @@
for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
JavaMethod* meth = &realCl->virtualMethods[i];
bool pub = isPublic(meth->access);
- if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
+ if (meth->name->equals(vm->upcalls->initName) &&
(!publicOnly || pub)) {
UserClass* Cons = vm->upcalls->newConstructor;
tmp = Cons->doNew(vm);
@@ -160,14 +159,13 @@
ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
} else {
UserClass* realCl = cl->asClass();
- JnjvmClassLoader* classLoader = cl->classLoader;
uint32 size = 0;
for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
++i) {
JavaMethod* meth = &realCl->virtualMethods[i];
bool pub = isPublic(meth->access);
- if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
+ if (!(meth->name->equals(vm->upcalls->initName)) &&
(!publicOnly || pub)) {
++size;
}
@@ -181,7 +179,7 @@
++i) {
JavaMethod* meth = &realCl->virtualMethods[i];
bool pub = isPublic(meth->access);
- if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
+ if (!(meth->name->equals(vm->upcalls->initName)) &&
(!publicOnly || pub)) {
// TODO: check parameter types
UserClass* Meth = vm->upcalls->newMethod;
Modified: vmkit/branches/multi-vm/lib/J3/Classpath/ClasspathVMRuntime.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/Classpath/ClasspathVMRuntime.inc?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/Classpath/ClasspathVMRuntime.inc (original)
+++ vmkit/branches/multi-vm/lib/J3/Classpath/ClasspathVMRuntime.inc Wed Dec 8 04:29:13 2010
@@ -52,18 +52,18 @@
utf8Lib = JavaString::getValue(strLib);
uint32 stLib = strLib->offset;
sint32 lgLib = strLib->count;
- sint32 lgPre = vm->bootstrapLoader->prelib->size;
- sint32 lgPost = vm->bootstrapLoader->postlib->size;
+ sint32 lgPre = vm->upcalls->prelib->size;
+ sint32 lgPost = vm->upcalls->postlib->size;
uint32 size = (uint32)(lgPre + lgLib + lgPost);
array = (ArrayUInt16*)vm->upcalls->ArrayOfChar->doNew(size, vm);
uint16* elements = ArrayUInt16::getElements(array);
- memmove(elements, vm->bootstrapLoader->prelib->elements,
+ memmove(elements, vm->upcalls->prelib->elements,
lgPre * sizeof(uint16));
memmove(&(elements[lgPre]), ArrayUInt16::getElements(utf8Lib) + stLib,
lgLib * sizeof(uint16));
- memmove(&(elements[lgPre + lgLib]), vm->bootstrapLoader->postlib->elements,
+ memmove(&(elements[lgPre + lgLib]), vm->upcalls->postlib->elements,
lgPost * sizeof(uint16));
res = vm->constructString(array);
Modified: vmkit/branches/multi-vm/lib/J3/Classpath/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/Classpath/JavaUpcalls.cpp?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/Classpath/JavaUpcalls.cpp (original)
+++ vmkit/branches/multi-vm/lib/J3/Classpath/JavaUpcalls.cpp Wed Dec 8 04:29:13 2010
@@ -17,6 +17,18 @@
#include "Jnjvm.h"
#include "mvm/SystemThreads.h"
#include "mvm/VMKit.h"
+#include "j3/JavaCompiler.h"
+#include "JavaTypes.h"
+
+// for dlopen and dlsym
+#include <dlfcn.h>
+
+using namespace j3;
+
+typedef void (*static_init_t)(JnjvmClassLoader*);
+
+const UTF8* JavaCompiler::InlinePragma = 0;
+const UTF8* JavaCompiler::NoInlinePragma = 0;
#define COMPILE_METHODS(cl) \
for (CommonClass::method_iterator i = cl->virtualMethods.begin(), \
@@ -29,203 +41,6 @@
i->second->compiledPtr(); \
}
-
-using namespace j3;
-
-Class* Classpath::newThread;
-Class* Classpath::newVMThread;
-JavaField* Classpath::assocThread;
-JavaField* Classpath::vmdataVMThread;
-JavaMethod* Classpath::finaliseCreateInitialThread;
-JavaMethod* Classpath::initVMThread;
-JavaMethod* Classpath::groupAddThread;
-JavaField* Classpath::threadName;
-JavaField* Classpath::groupName;
-JavaMethod* Classpath::initGroup;
-JavaField* Classpath::priority;
-JavaField* Classpath::daemon;
-JavaField* Classpath::group;
-JavaField* Classpath::running;
-Class* Classpath::threadGroup;
-JavaField* Classpath::rootGroup;
-JavaField* Classpath::vmThread;
-JavaMethod* Classpath::uncaughtException;
-Class* Classpath::inheritableThreadLocal;
-
-JavaMethod* Classpath::runVMThread;
-JavaMethod* Classpath::setContextClassLoader;
-JavaMethod* Classpath::getSystemClassLoader;
-Class* Classpath::newString;
-Class* Classpath::newClass;
-Class* Classpath::newThrowable;
-Class* Classpath::newException;
-JavaMethod* Classpath::initClass;
-JavaMethod* Classpath::initClassWithProtectionDomain;
-JavaField* Classpath::vmdataClass;
-JavaMethod* Classpath::setProperty;
-JavaMethod* Classpath::initString;
-JavaMethod* Classpath::getCallingClassLoader;
-JavaMethod* Classpath::initConstructor;
-Class* Classpath::newConstructor;
-ClassArray* Classpath::constructorArrayClass;
-ClassArray* Classpath::constructorArrayAnnotation;
-JavaField* Classpath::constructorSlot;
-JavaMethod* Classpath::initMethod;
-JavaMethod* Classpath::initField;
-Class* Classpath::newField;
-Class* Classpath::newMethod;
-ClassArray* Classpath::methodArrayClass;
-ClassArray* Classpath::fieldArrayClass;
-JavaField* Classpath::methodSlot;
-JavaField* Classpath::fieldSlot;
-ClassArray* Classpath::classArrayClass;
-JavaMethod* Classpath::loadInClassLoader;
-JavaMethod* Classpath::initVMThrowable;
-JavaField* Classpath::vmDataVMThrowable;
-Class* Classpath::newVMThrowable;
-JavaField* Classpath::bufferAddress;
-JavaField* Classpath::dataPointer32;
-JavaField* Classpath::dataPointer64;
-Class* Classpath::newPointer32;
-Class* Classpath::newPointer64;
-Class* Classpath::newDirectByteBuffer;
-JavaField* Classpath::vmdataClassLoader;
-JavaMethod* Classpath::InitDirectByteBuffer;
-Class* Classpath::newClassLoader;
-
-
-JavaField* Classpath::boolValue;
-JavaField* Classpath::byteValue;
-JavaField* Classpath::shortValue;
-JavaField* Classpath::charValue;
-JavaField* Classpath::intValue;
-JavaField* Classpath::longValue;
-JavaField* Classpath::floatValue;
-JavaField* Classpath::doubleValue;
-
-Class* Classpath::newStackTraceElement;
-ClassArray* Classpath::stackTraceArray;
-JavaMethod* Classpath::initStackTraceElement;
-
-Class* Classpath::voidClass;
-Class* Classpath::boolClass;
-Class* Classpath::byteClass;
-Class* Classpath::shortClass;
-Class* Classpath::charClass;
-Class* Classpath::intClass;
-Class* Classpath::floatClass;
-Class* Classpath::doubleClass;
-Class* Classpath::longClass;
-
-Class* Classpath::vmStackWalker;
-
-Class* Classpath::InvocationTargetException;
-Class* Classpath::ArrayStoreException;
-Class* Classpath::ClassCastException;
-Class* Classpath::IllegalMonitorStateException;
-Class* Classpath::IllegalArgumentException;
-Class* Classpath::InterruptedException;
-Class* Classpath::IndexOutOfBoundsException;
-Class* Classpath::ArrayIndexOutOfBoundsException;
-Class* Classpath::NegativeArraySizeException;
-Class* Classpath::NullPointerException;
-Class* Classpath::SecurityException;
-Class* Classpath::ClassFormatError;
-Class* Classpath::ClassCircularityError;
-Class* Classpath::NoClassDefFoundError;
-Class* Classpath::UnsupportedClassVersionError;
-Class* Classpath::NoSuchFieldError;
-Class* Classpath::NoSuchMethodError;
-Class* Classpath::InstantiationError;
-Class* Classpath::InstantiationException;
-Class* Classpath::IllegalAccessError;
-Class* Classpath::IllegalAccessException;
-Class* Classpath::VerifyError;
-Class* Classpath::ExceptionInInitializerError;
-Class* Classpath::LinkageError;
-Class* Classpath::AbstractMethodError;
-Class* Classpath::UnsatisfiedLinkError;
-Class* Classpath::InternalError;
-Class* Classpath::OutOfMemoryError;
-Class* Classpath::StackOverflowError;
-Class* Classpath::UnknownError;
-Class* Classpath::ClassNotFoundException;
-Class* Classpath::ArithmeticException;
-
-JavaMethod* Classpath::InitInvocationTargetException;
-JavaMethod* Classpath::InitArrayStoreException;
-JavaMethod* Classpath::InitClassCastException;
-JavaMethod* Classpath::InitIllegalMonitorStateException;
-JavaMethod* Classpath::InitIllegalArgumentException;
-JavaMethod* Classpath::InitInterruptedException;
-JavaMethod* Classpath::InitIndexOutOfBoundsException;
-JavaMethod* Classpath::InitArrayIndexOutOfBoundsException;
-JavaMethod* Classpath::InitNegativeArraySizeException;
-JavaMethod* Classpath::InitNullPointerException;
-JavaMethod* Classpath::InitSecurityException;
-JavaMethod* Classpath::InitClassFormatError;
-JavaMethod* Classpath::InitClassCircularityError;
-JavaMethod* Classpath::InitNoClassDefFoundError;
-JavaMethod* Classpath::InitUnsupportedClassVersionError;
-JavaMethod* Classpath::InitNoSuchFieldError;
-JavaMethod* Classpath::InitNoSuchMethodError;
-JavaMethod* Classpath::InitInstantiationError;
-JavaMethod* Classpath::InitInstantiationException;
-JavaMethod* Classpath::InitIllegalAccessError;
-JavaMethod* Classpath::InitIllegalAccessException;
-JavaMethod* Classpath::InitVerifyError;
-JavaMethod* Classpath::InitExceptionInInitializerError;
-JavaMethod* Classpath::InitLinkageError;
-JavaMethod* Classpath::InitAbstractMethodError;
-JavaMethod* Classpath::InitUnsatisfiedLinkError;
-JavaMethod* Classpath::InitInternalError;
-JavaMethod* Classpath::InitOutOfMemoryError;
-JavaMethod* Classpath::InitStackOverflowError;
-JavaMethod* Classpath::InitUnknownError;
-JavaMethod* Classpath::InitClassNotFoundException;
-JavaMethod* Classpath::InitArithmeticException;
-JavaMethod* Classpath::InitObject;
-JavaMethod* Classpath::FinalizeObject;
-JavaMethod* Classpath::IntToString;
-
-JavaMethod* Classpath::SystemArraycopy;
-JavaMethod* Classpath::VMSystemArraycopy;
-Class* Classpath::SystemClass;
-
-JavaMethod* Classpath::ErrorWithExcpNoClassDefFoundError;
-JavaMethod* Classpath::ErrorWithExcpExceptionInInitializerError;
-JavaMethod* Classpath::ErrorWithExcpInvocationTargetException;
-
-ClassArray* Classpath::ArrayOfByte;
-ClassArray* Classpath::ArrayOfChar;
-ClassArray* Classpath::ArrayOfString;
-ClassArray* Classpath::ArrayOfInt;
-ClassArray* Classpath::ArrayOfShort;
-ClassArray* Classpath::ArrayOfBool;
-ClassArray* Classpath::ArrayOfLong;
-ClassArray* Classpath::ArrayOfFloat;
-ClassArray* Classpath::ArrayOfDouble;
-ClassArray* Classpath::ArrayOfObject;
-
-ClassPrimitive* Classpath::OfByte;
-ClassPrimitive* Classpath::OfChar;
-ClassPrimitive* Classpath::OfInt;
-ClassPrimitive* Classpath::OfShort;
-ClassPrimitive* Classpath::OfBool;
-ClassPrimitive* Classpath::OfLong;
-ClassPrimitive* Classpath::OfFloat;
-ClassPrimitive* Classpath::OfDouble;
-ClassPrimitive* Classpath::OfVoid;
-
-Class* Classpath::OfObject;
-
-JavaField* Classpath::methodClass;
-JavaField* Classpath::fieldClass;
-JavaField* Classpath::constructorClass;
-
-JavaMethod* Classpath::EnqueueReference;
-Class* Classpath::newReference;
-
void Classpath::CreateJavaThread(Jnjvm* vm, JavaThread* myth,
const char* thName, JavaObject* Group) {
JavaObjectVMThread* vmth = NULL;
@@ -543,7 +358,162 @@
return ret;
}
-void Classpath::initialiseClasspath(JnjvmClassLoader* loader) {
+
+Classpath::Classpath(JnjvmBootstrapLoader* loader, bool dlLoad) {
+
+ // Try to find if we have a pre-compiled rt.jar
+ if (dlLoad) {
+ SuperArray = (Class*)dlsym(SELF_HANDLE, "java_lang_Object");
+ if (!SuperArray) {
+ loader->nativeHandle = dlopen("libvmjc"DYLD_EXTENSION, RTLD_LAZY | RTLD_GLOBAL);
+ if (loader->nativeHandle) {
+ // Found it!
+ SuperArray = (Class*)dlsym(loader->nativeHandle, "java_lang_Object");
+ }
+ }
+
+ if (SuperArray) {
+ assert(TheCompiler &&
+ "Loading libvmjc"DYLD_EXTENSION" requires a compiler");
+ ClassArray::SuperArray = (Class*)SuperArray->getInternal();
+
+ // Get the native classes.
+ OfVoid = (ClassPrimitive*)dlsym(loader->nativeHandle, "void");
+ OfBool = (ClassPrimitive*)dlsym(loader->nativeHandle, "boolean");
+ OfByte = (ClassPrimitive*)dlsym(loader->nativeHandle, "byte");
+ OfChar = (ClassPrimitive*)dlsym(loader->nativeHandle, "char");
+ OfShort = (ClassPrimitive*)dlsym(loader->nativeHandle, "short");
+ OfInt = (ClassPrimitive*)dlsym(loader->nativeHandle, "int");
+ OfFloat = (ClassPrimitive*)dlsym(loader->nativeHandle, "float");
+ OfLong = (ClassPrimitive*)dlsym(loader->nativeHandle, "long");
+ OfDouble = (ClassPrimitive*)dlsym(loader->nativeHandle, "double");
+
+
+ // We have the java/lang/Object class, execute the static initializer.
+ static_init_t init = (static_init_t)(uintptr_t)SuperArray->classLoader;
+ assert(init && "Loaded the wrong boot library");
+ init(loader);
+
+ // Get the base object arrays after the init, because init puts arrays
+ // in the class loader map.
+ ArrayOfString =
+ loader->constructArray(loader->asciizConstructUTF8("[Ljava/lang/String;"));
+
+ ArrayOfObject =
+ loader->constructArray(loader->asciizConstructUTF8("[Ljava/lang/Object;"));
+
+ InterfacesArray = ArrayOfObject->interfaces;
+ ClassArray::InterfacesArray = InterfacesArray;
+
+ }
+ }
+
+ if (!OfChar) {
+ // Allocate interfaces.
+ InterfacesArray = (Class**)loader->allocator.Allocate(2 * sizeof(UserClass*),
+ "Interface array");
+ ClassArray::InterfacesArray = InterfacesArray;
+
+ // Create the primitive classes.
+ OfChar = UPCALL_PRIMITIVE_CLASS(loader, "char", 1);
+ OfBool = UPCALL_PRIMITIVE_CLASS(loader, "boolean", 0);
+ OfShort = UPCALL_PRIMITIVE_CLASS(loader, "short", 1);
+ OfInt = UPCALL_PRIMITIVE_CLASS(loader, "int", 2);
+ OfLong = UPCALL_PRIMITIVE_CLASS(loader, "long", 3);
+ OfFloat = UPCALL_PRIMITIVE_CLASS(loader, "float", 2);
+ OfDouble = UPCALL_PRIMITIVE_CLASS(loader, "double", 3);
+ OfVoid = UPCALL_PRIMITIVE_CLASS(loader, "void", 0);
+ OfByte = UPCALL_PRIMITIVE_CLASS(loader, "byte", 0);
+ }
+
+ // Create the primitive arrays.
+ ArrayOfChar = loader->constructArray(loader->asciizConstructUTF8("[C"), OfChar);
+ ArrayOfByte = loader->constructArray(loader->asciizConstructUTF8("[B"), OfByte);
+ ArrayOfInt = loader->constructArray(loader->asciizConstructUTF8("[I"), OfInt);
+ ArrayOfBool = loader->constructArray(loader->asciizConstructUTF8("[Z"), OfBool);
+ ArrayOfLong = loader->constructArray(loader->asciizConstructUTF8("[J"), OfLong);
+ ArrayOfFloat = loader->constructArray(loader->asciizConstructUTF8("[F"), OfFloat);
+ ArrayOfDouble = loader->constructArray(loader->asciizConstructUTF8("[D"), OfDouble);
+ ArrayOfShort = loader->constructArray(loader->asciizConstructUTF8("[S"), OfShort);
+
+ // Fill the maps.
+ primitiveMap[I_VOID] = OfVoid;
+ primitiveMap[I_BOOL] = OfBool;
+ primitiveMap[I_BYTE] = OfByte;
+ primitiveMap[I_CHAR] = OfChar;
+ primitiveMap[I_SHORT] = OfShort;
+ primitiveMap[I_INT] = OfInt;
+ primitiveMap[I_FLOAT] = OfFloat;
+ primitiveMap[I_LONG] = OfLong;
+ primitiveMap[I_DOUBLE] = OfDouble;
+
+ arrayTable[JavaArray::T_BOOLEAN - 4] = ArrayOfBool;
+ arrayTable[JavaArray::T_BYTE - 4] = ArrayOfByte;
+ arrayTable[JavaArray::T_CHAR - 4] = ArrayOfChar;
+ arrayTable[JavaArray::T_SHORT - 4] = ArrayOfShort;
+ arrayTable[JavaArray::T_INT - 4] = ArrayOfInt;
+ arrayTable[JavaArray::T_FLOAT - 4] = ArrayOfFloat;
+ arrayTable[JavaArray::T_LONG - 4] = ArrayOfLong;
+ arrayTable[JavaArray::T_DOUBLE - 4] = ArrayOfDouble;
+
+ Attribut::annotationsAttribut = loader->asciizConstructUTF8("RuntimeVisibleAnnotations");
+ Attribut::codeAttribut = loader->asciizConstructUTF8("Code");
+ Attribut::exceptionsAttribut = loader->asciizConstructUTF8("Exceptions");
+ Attribut::constantAttribut = loader->asciizConstructUTF8("ConstantValue");
+ Attribut::lineNumberTableAttribut = loader->asciizConstructUTF8("LineNumberTable");
+ Attribut::innerClassesAttribut = loader->asciizConstructUTF8("InnerClasses");
+ Attribut::sourceFileAttribut = loader->asciizConstructUTF8("SourceFile");
+
+ JavaCompiler::InlinePragma = loader->asciizConstructUTF8("Lorg/vmmagic/pragma/Inline;");
+ JavaCompiler::NoInlinePragma = loader->asciizConstructUTF8("Lorg/vmmagic/pragma/NoInline;");
+
+ initName = loader->asciizConstructUTF8("<init>");
+ initExceptionSig = loader->asciizConstructUTF8("(Ljava/lang/String;)V");
+ clinitName = loader->asciizConstructUTF8("<clinit>");
+ clinitType = loader->asciizConstructUTF8("()V");
+ runName = loader->asciizConstructUTF8("run");
+ prelib = loader->asciizConstructUTF8("lib");
+#if defined(__MACH__)
+ postlib = loader->asciizConstructUTF8(".dylib");
+#else
+ postlib = loader->asciizConstructUTF8(".so");
+#endif
+ mathName = loader->asciizConstructUTF8("java/lang/Math");
+ stackWalkerName = loader->asciizConstructUTF8("gnu/classpath/VMStackWalker");
+ NoClassDefFoundErrorName = loader->asciizConstructUTF8("java/lang/NoClassDefFoundError");
+
+#define DEF_UTF8(var) \
+ var = loader->asciizConstructUTF8(#var)
+
+ DEF_UTF8(abs);
+ DEF_UTF8(sqrt);
+ DEF_UTF8(sin);
+ DEF_UTF8(cos);
+ DEF_UTF8(tan);
+ DEF_UTF8(asin);
+ DEF_UTF8(acos);
+ DEF_UTF8(atan);
+ DEF_UTF8(atan2);
+ DEF_UTF8(exp);
+ DEF_UTF8(log);
+ DEF_UTF8(pow);
+ DEF_UTF8(ceil);
+ DEF_UTF8(floor);
+ DEF_UTF8(rint);
+ DEF_UTF8(cbrt);
+ DEF_UTF8(cosh);
+ DEF_UTF8(expm1);
+ DEF_UTF8(hypot);
+ DEF_UTF8(log10);
+ DEF_UTF8(log1p);
+ DEF_UTF8(sinh);
+ DEF_UTF8(tanh);
+ DEF_UTF8(finalize);
+
+#undef DEF_UTF8
+}
+
+void Classpath::postInitialiseClasspath(JnjvmClassLoader* loader) {
newClassLoader =
UPCALL_CLASS(loader, "java/lang/ClassLoader");
Modified: vmkit/branches/multi-vm/lib/J3/Classpath/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/Classpath/JavaUpcalls.h?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/Classpath/JavaUpcalls.h (original)
+++ vmkit/branches/multi-vm/lib/J3/Classpath/JavaUpcalls.h Wed Dec 8 04:29:13 2010
@@ -59,216 +59,288 @@
class Class;
class ClassArray;
+#if defined(__MACH__)
+#define SELF_HANDLE RTLD_DEFAULT
+#define DYLD_EXTENSION ".dylib"
+#else
+#define SELF_HANDLE 0
+#define DYLD_EXTENSION ".so"
+#endif
+
class Classpath : public mvm::PermanentObject {
public:
- ISOLATE_STATIC UserClass* newClassLoader;
- ISOLATE_STATIC JavaMethod* getSystemClassLoader;
- ISOLATE_STATIC JavaMethod* setContextClassLoader;
- ISOLATE_STATIC UserClass* newString;
- ISOLATE_STATIC UserClass* newClass;
- ISOLATE_STATIC UserClass* newThrowable;
- ISOLATE_STATIC UserClass* newException;
- ISOLATE_STATIC JavaMethod* initClass;
- ISOLATE_STATIC JavaMethod* initClassWithProtectionDomain;
- ISOLATE_STATIC JavaField* vmdataClass;
- ISOLATE_STATIC JavaMethod* setProperty;
- ISOLATE_STATIC JavaMethod* initString;
- ISOLATE_STATIC JavaMethod* getCallingClassLoader;
- ISOLATE_STATIC JavaMethod* initConstructor;
- ISOLATE_STATIC UserClassArray* constructorArrayClass;
- ISOLATE_STATIC UserClassArray* constructorArrayAnnotation;
- ISOLATE_STATIC UserClass* newConstructor;
- ISOLATE_STATIC JavaField* constructorSlot;
- ISOLATE_STATIC JavaMethod* initMethod;
- ISOLATE_STATIC JavaMethod* initField;
- ISOLATE_STATIC UserClassArray* methodArrayClass;
- ISOLATE_STATIC UserClassArray* fieldArrayClass;
- ISOLATE_STATIC UserClass* newMethod;
- ISOLATE_STATIC UserClass* newField;
- ISOLATE_STATIC JavaField* methodSlot;
- ISOLATE_STATIC JavaField* fieldSlot;
- ISOLATE_STATIC UserClassArray* classArrayClass;
- ISOLATE_STATIC JavaMethod* loadInClassLoader;
- ISOLATE_STATIC JavaMethod* initVMThrowable;
- ISOLATE_STATIC JavaField* vmDataVMThrowable;
- ISOLATE_STATIC UserClass* newVMThrowable;
- ISOLATE_STATIC JavaField* bufferAddress;
- ISOLATE_STATIC JavaField* dataPointer32;
- ISOLATE_STATIC JavaField* dataPointer64;
- ISOLATE_STATIC UserClass* newPointer32;
- ISOLATE_STATIC UserClass* newPointer64;
- ISOLATE_STATIC UserClass* newDirectByteBuffer;
- ISOLATE_STATIC JavaMethod* InitDirectByteBuffer;
- ISOLATE_STATIC JavaField* vmdataClassLoader;
-
- ISOLATE_STATIC JavaField* boolValue;
- ISOLATE_STATIC JavaField* byteValue;
- ISOLATE_STATIC JavaField* shortValue;
- ISOLATE_STATIC JavaField* charValue;
- ISOLATE_STATIC JavaField* intValue;
- ISOLATE_STATIC JavaField* longValue;
- ISOLATE_STATIC JavaField* floatValue;
- ISOLATE_STATIC JavaField* doubleValue;
-
- ISOLATE_STATIC UserClass* newStackTraceElement;
- ISOLATE_STATIC UserClassArray* stackTraceArray;
- ISOLATE_STATIC JavaMethod* initStackTraceElement;
-
- ISOLATE_STATIC void initialiseClasspath(JnjvmClassLoader* loader);
-
- ISOLATE_STATIC UserClass* voidClass;
- ISOLATE_STATIC UserClass* boolClass;
- ISOLATE_STATIC UserClass* byteClass;
- ISOLATE_STATIC UserClass* shortClass;
- ISOLATE_STATIC UserClass* charClass;
- ISOLATE_STATIC UserClass* intClass;
- ISOLATE_STATIC UserClass* floatClass;
- ISOLATE_STATIC UserClass* doubleClass;
- ISOLATE_STATIC UserClass* longClass;
-
- ISOLATE_STATIC UserClass* vmStackWalker;
-
- ISOLATE_STATIC UserClass* newThread;
- ISOLATE_STATIC UserClass* newVMThread;
- ISOLATE_STATIC JavaField* assocThread;
- ISOLATE_STATIC JavaField* vmdataVMThread;
- ISOLATE_STATIC JavaMethod* finaliseCreateInitialThread;
- ISOLATE_STATIC JavaMethod* initVMThread;
- ISOLATE_STATIC JavaMethod* runVMThread;
- ISOLATE_STATIC JavaMethod* groupAddThread;
- ISOLATE_STATIC JavaField* threadName;
- ISOLATE_STATIC JavaField* groupName;
- ISOLATE_STATIC JavaMethod* initGroup;
- ISOLATE_STATIC JavaField* priority;
- ISOLATE_STATIC JavaField* daemon;
- ISOLATE_STATIC JavaField* group;
- ISOLATE_STATIC JavaField* running;
- ISOLATE_STATIC UserClass* threadGroup;
- ISOLATE_STATIC JavaField* rootGroup;
- ISOLATE_STATIC JavaField* vmThread;
- ISOLATE_STATIC JavaMethod* uncaughtException;
- ISOLATE_STATIC UserClass* inheritableThreadLocal;
-
-
- ISOLATE_STATIC UserClass* InvocationTargetException;
- ISOLATE_STATIC UserClass* ArrayStoreException;
- ISOLATE_STATIC UserClass* ClassCastException;
- ISOLATE_STATIC UserClass* IllegalMonitorStateException;
- ISOLATE_STATIC UserClass* IllegalArgumentException;
- ISOLATE_STATIC UserClass* InterruptedException;
- ISOLATE_STATIC UserClass* IndexOutOfBoundsException;
- ISOLATE_STATIC UserClass* ArrayIndexOutOfBoundsException;
- ISOLATE_STATIC UserClass* NegativeArraySizeException;
- ISOLATE_STATIC UserClass* NullPointerException;
- ISOLATE_STATIC UserClass* SecurityException;
- ISOLATE_STATIC UserClass* ClassFormatError;
- ISOLATE_STATIC UserClass* ClassCircularityError;
- ISOLATE_STATIC UserClass* NoClassDefFoundError;
- ISOLATE_STATIC UserClass* UnsupportedClassVersionError;
- ISOLATE_STATIC UserClass* NoSuchFieldError;
- ISOLATE_STATIC UserClass* NoSuchMethodError;
- ISOLATE_STATIC UserClass* InstantiationError;
- ISOLATE_STATIC UserClass* InstantiationException;
- ISOLATE_STATIC UserClass* IllegalAccessError;
- ISOLATE_STATIC UserClass* IllegalAccessException;
- ISOLATE_STATIC UserClass* VerifyError;
- ISOLATE_STATIC UserClass* ExceptionInInitializerError;
- ISOLATE_STATIC UserClass* LinkageError;
- ISOLATE_STATIC UserClass* AbstractMethodError;
- ISOLATE_STATIC UserClass* UnsatisfiedLinkError;
- ISOLATE_STATIC UserClass* InternalError;
- ISOLATE_STATIC UserClass* OutOfMemoryError;
- ISOLATE_STATIC UserClass* StackOverflowError;
- ISOLATE_STATIC UserClass* UnknownError;
- ISOLATE_STATIC UserClass* ClassNotFoundException;
- ISOLATE_STATIC UserClass* ArithmeticException;
-
- ISOLATE_STATIC JavaMethod* InitInvocationTargetException;
- ISOLATE_STATIC JavaMethod* InitArrayStoreException;
- ISOLATE_STATIC JavaMethod* InitClassCastException;
- ISOLATE_STATIC JavaMethod* InitIllegalMonitorStateException;
- ISOLATE_STATIC JavaMethod* InitIllegalArgumentException;
- ISOLATE_STATIC JavaMethod* InitInterruptedException;
- ISOLATE_STATIC JavaMethod* InitIndexOutOfBoundsException;
- ISOLATE_STATIC JavaMethod* InitArrayIndexOutOfBoundsException;
- ISOLATE_STATIC JavaMethod* InitNegativeArraySizeException;
- ISOLATE_STATIC JavaMethod* InitNullPointerException;
- ISOLATE_STATIC JavaMethod* InitSecurityException;
- ISOLATE_STATIC JavaMethod* InitClassFormatError;
- ISOLATE_STATIC JavaMethod* InitClassCircularityError;
- ISOLATE_STATIC JavaMethod* InitNoClassDefFoundError;
- ISOLATE_STATIC JavaMethod* InitUnsupportedClassVersionError;
- ISOLATE_STATIC JavaMethod* InitNoSuchFieldError;
- ISOLATE_STATIC JavaMethod* InitNoSuchMethodError;
- ISOLATE_STATIC JavaMethod* InitInstantiationError;
- ISOLATE_STATIC JavaMethod* InitInstantiationException;
- ISOLATE_STATIC JavaMethod* InitIllegalAccessError;
- ISOLATE_STATIC JavaMethod* InitIllegalAccessException;
- ISOLATE_STATIC JavaMethod* InitVerifyError;
- ISOLATE_STATIC JavaMethod* InitExceptionInInitializerError;
- ISOLATE_STATIC JavaMethod* InitLinkageError;
- ISOLATE_STATIC JavaMethod* InitAbstractMethodError;
- ISOLATE_STATIC JavaMethod* InitUnsatisfiedLinkError;
- ISOLATE_STATIC JavaMethod* InitInternalError;
- ISOLATE_STATIC JavaMethod* InitOutOfMemoryError;
- ISOLATE_STATIC JavaMethod* InitStackOverflowError;
- ISOLATE_STATIC JavaMethod* InitUnknownError;
- ISOLATE_STATIC JavaMethod* InitClassNotFoundException;
- ISOLATE_STATIC JavaMethod* InitArithmeticException;
-
- ISOLATE_STATIC JavaMethod* SystemArraycopy;
- ISOLATE_STATIC JavaMethod* VMSystemArraycopy;
- ISOLATE_STATIC Class* SystemClass;
-
- ISOLATE_STATIC JavaMethod* IntToString;
-
- ISOLATE_STATIC JavaMethod* InitObject;
- ISOLATE_STATIC JavaMethod* FinalizeObject;
-
- ISOLATE_STATIC JavaMethod* ErrorWithExcpNoClassDefFoundError;
- ISOLATE_STATIC JavaMethod* ErrorWithExcpExceptionInInitializerError;
- ISOLATE_STATIC JavaMethod* ErrorWithExcpInvocationTargetException;
-
-
-
- ISOLATE_STATIC UserClassArray* ArrayOfByte;
- ISOLATE_STATIC UserClassArray* ArrayOfChar;
- ISOLATE_STATIC UserClassArray* ArrayOfInt;
- ISOLATE_STATIC UserClassArray* ArrayOfShort;
- ISOLATE_STATIC UserClassArray* ArrayOfBool;
- ISOLATE_STATIC UserClassArray* ArrayOfLong;
- ISOLATE_STATIC UserClassArray* ArrayOfFloat;
- ISOLATE_STATIC UserClassArray* ArrayOfDouble;
- ISOLATE_STATIC UserClassArray* ArrayOfObject;
- ISOLATE_STATIC UserClassArray* ArrayOfString;
-
- ISOLATE_STATIC UserClassPrimitive* OfByte;
- ISOLATE_STATIC UserClassPrimitive* OfChar;
- ISOLATE_STATIC UserClassPrimitive* OfInt;
- ISOLATE_STATIC UserClassPrimitive* OfShort;
- ISOLATE_STATIC UserClassPrimitive* OfBool;
- ISOLATE_STATIC UserClassPrimitive* OfLong;
- ISOLATE_STATIC UserClassPrimitive* OfFloat;
- ISOLATE_STATIC UserClassPrimitive* OfDouble;
- ISOLATE_STATIC UserClassPrimitive* OfVoid;
-
- ISOLATE_STATIC UserClass* OfObject;
-
- ISOLATE_STATIC JavaField* methodClass;
- ISOLATE_STATIC JavaField* fieldClass;
- ISOLATE_STATIC JavaField* constructorClass;
-
- ISOLATE_STATIC JavaMethod* EnqueueReference;
- ISOLATE_STATIC Class* newReference;
+ Classpath(JnjvmBootstrapLoader* loader, bool dlLoad);
+
+ void postInitialiseClasspath(JnjvmClassLoader* loader);
+
+ UserClass* newClassLoader;
+ JavaMethod* getSystemClassLoader;
+ JavaMethod* setContextClassLoader;
+ UserClass* newString;
+ UserClass* newClass;
+ UserClass* newThrowable;
+ UserClass* newException;
+ JavaMethod* initClass;
+ JavaMethod* initClassWithProtectionDomain;
+ JavaField* vmdataClass;
+ JavaMethod* setProperty;
+ JavaMethod* initString;
+ JavaMethod* getCallingClassLoader;
+ JavaMethod* initConstructor;
+ UserClassArray* constructorArrayClass;
+ UserClassArray* constructorArrayAnnotation;
+ UserClass* newConstructor;
+ JavaField* constructorSlot;
+ JavaMethod* initMethod;
+ JavaMethod* initField;
+ UserClassArray* methodArrayClass;
+ UserClassArray* fieldArrayClass;
+ UserClass* newMethod;
+ UserClass* newField;
+ JavaField* methodSlot;
+ JavaField* fieldSlot;
+ UserClassArray* classArrayClass;
+ JavaMethod* loadInClassLoader;
+ JavaMethod* initVMThrowable;
+ JavaField* vmDataVMThrowable;
+ UserClass* newVMThrowable;
+ JavaField* bufferAddress;
+ JavaField* dataPointer32;
+ JavaField* dataPointer64;
+ UserClass* newPointer32;
+ UserClass* newPointer64;
+ UserClass* newDirectByteBuffer;
+ JavaMethod* InitDirectByteBuffer;
+ JavaField* vmdataClassLoader;
+
+ JavaField* boolValue;
+ JavaField* byteValue;
+ JavaField* shortValue;
+ JavaField* charValue;
+ JavaField* intValue;
+ JavaField* longValue;
+ JavaField* floatValue;
+ JavaField* doubleValue;
+
+ UserClass* newStackTraceElement;
+ UserClassArray* stackTraceArray;
+ JavaMethod* initStackTraceElement;
+
+ UserClass* voidClass;
+ UserClass* boolClass;
+ UserClass* byteClass;
+ UserClass* shortClass;
+ UserClass* charClass;
+ UserClass* intClass;
+ UserClass* floatClass;
+ UserClass* doubleClass;
+ UserClass* longClass;
+
+ UserClass* vmStackWalker;
+
+ UserClass* newThread;
+ UserClass* newVMThread;
+ JavaField* assocThread;
+ JavaField* vmdataVMThread;
+ JavaMethod* finaliseCreateInitialThread;
+ JavaMethod* initVMThread;
+ JavaMethod* runVMThread;
+ JavaMethod* groupAddThread;
+ JavaField* threadName;
+ JavaField* groupName;
+ JavaMethod* initGroup;
+ JavaField* priority;
+ JavaField* daemon;
+ JavaField* group;
+ JavaField* running;
+ UserClass* threadGroup;
+ JavaField* rootGroup;
+ JavaField* vmThread;
+ JavaMethod* uncaughtException;
+ UserClass* inheritableThreadLocal;
+
+
+ UserClass* InvocationTargetException;
+ UserClass* ArrayStoreException;
+ UserClass* ClassCastException;
+ UserClass* IllegalMonitorStateException;
+ UserClass* IllegalArgumentException;
+ UserClass* InterruptedException;
+ UserClass* IndexOutOfBoundsException;
+ UserClass* ArrayIndexOutOfBoundsException;
+ UserClass* NegativeArraySizeException;
+ UserClass* NullPointerException;
+ UserClass* SecurityException;
+ UserClass* ClassFormatError;
+ UserClass* ClassCircularityError;
+ UserClass* NoClassDefFoundError;
+ UserClass* UnsupportedClassVersionError;
+ UserClass* NoSuchFieldError;
+ UserClass* NoSuchMethodError;
+ UserClass* InstantiationError;
+ UserClass* InstantiationException;
+ UserClass* IllegalAccessError;
+ UserClass* IllegalAccessException;
+ UserClass* VerifyError;
+ UserClass* ExceptionInInitializerError;
+ UserClass* LinkageError;
+ UserClass* AbstractMethodError;
+ UserClass* UnsatisfiedLinkError;
+ UserClass* InternalError;
+ UserClass* OutOfMemoryError;
+ UserClass* StackOverflowError;
+ UserClass* UnknownError;
+ UserClass* ClassNotFoundException;
+ UserClass* ArithmeticException;
+
+ JavaMethod* InitInvocationTargetException;
+ JavaMethod* InitArrayStoreException;
+ JavaMethod* InitClassCastException;
+ JavaMethod* InitIllegalMonitorStateException;
+ JavaMethod* InitIllegalArgumentException;
+ JavaMethod* InitInterruptedException;
+ JavaMethod* InitIndexOutOfBoundsException;
+ JavaMethod* InitArrayIndexOutOfBoundsException;
+ JavaMethod* InitNegativeArraySizeException;
+ JavaMethod* InitNullPointerException;
+ JavaMethod* InitSecurityException;
+ JavaMethod* InitClassFormatError;
+ JavaMethod* InitClassCircularityError;
+ JavaMethod* InitNoClassDefFoundError;
+ JavaMethod* InitUnsupportedClassVersionError;
+ JavaMethod* InitNoSuchFieldError;
+ JavaMethod* InitNoSuchMethodError;
+ JavaMethod* InitInstantiationError;
+ JavaMethod* InitInstantiationException;
+ JavaMethod* InitIllegalAccessError;
+ JavaMethod* InitIllegalAccessException;
+ JavaMethod* InitVerifyError;
+ JavaMethod* InitExceptionInInitializerError;
+ JavaMethod* InitLinkageError;
+ JavaMethod* InitAbstractMethodError;
+ JavaMethod* InitUnsatisfiedLinkError;
+ JavaMethod* InitInternalError;
+ JavaMethod* InitOutOfMemoryError;
+ JavaMethod* InitStackOverflowError;
+ JavaMethod* InitUnknownError;
+ JavaMethod* InitClassNotFoundException;
+ JavaMethod* InitArithmeticException;
+
+ JavaMethod* SystemArraycopy;
+ JavaMethod* VMSystemArraycopy;
+ Class* SystemClass;
+
+ JavaMethod* IntToString;
+
+ JavaMethod* InitObject;
+ JavaMethod* FinalizeObject;
+
+ JavaMethod* ErrorWithExcpNoClassDefFoundError;
+ JavaMethod* ErrorWithExcpExceptionInInitializerError;
+ JavaMethod* ErrorWithExcpInvocationTargetException;
+
+
+
+ UserClassArray* ArrayOfByte;
+ UserClassArray* ArrayOfChar;
+ UserClassArray* ArrayOfInt;
+ UserClassArray* ArrayOfShort;
+ UserClassArray* ArrayOfBool;
+ UserClassArray* ArrayOfLong;
+ UserClassArray* ArrayOfFloat;
+ UserClassArray* ArrayOfDouble;
+ UserClassArray* ArrayOfObject;
+ UserClassArray* ArrayOfString;
+
+ UserClassPrimitive* OfByte;
+ UserClassPrimitive* OfChar;
+ UserClassPrimitive* OfInt;
+ UserClassPrimitive* OfShort;
+ UserClassPrimitive* OfBool;
+ UserClassPrimitive* OfLong;
+ UserClassPrimitive* OfFloat;
+ UserClassPrimitive* OfDouble;
+ UserClassPrimitive* OfVoid;
+
+ UserClass* OfObject;
+
+ JavaField* methodClass;
+ JavaField* fieldClass;
+ JavaField* constructorClass;
+
+ JavaMethod* EnqueueReference;
+ Class* newReference;
+
+ /// upcalls - Upcall classes, fields and methods so that C++ code can call
+ /// Java code.
+ ///
+ Classpath* upcalls;
+
+ /// InterfacesArray - The interfaces that array classes implement.
+ ///
+ UserClass** InterfacesArray;
+
+ /// SuperArray - The super of array classes.
+ UserClass* SuperArray;
+
+ /// Lists of UTF8s used internaly in VMKit.
+ const UTF8* NoClassDefFoundErrorName;
+ const UTF8* initName;
+ const UTF8* clinitName;
+ const UTF8* clinitType;
+ const UTF8* initExceptionSig;
+ const UTF8* runName;
+ const UTF8* prelib;
+ const UTF8* postlib;
+ const UTF8* mathName;
+ const UTF8* stackWalkerName;
+ const UTF8* abs;
+ const UTF8* sqrt;
+ const UTF8* sin;
+ const UTF8* cos;
+ const UTF8* tan;
+ const UTF8* asin;
+ const UTF8* acos;
+ const UTF8* atan;
+ const UTF8* atan2;
+ const UTF8* exp;
+ const UTF8* log;
+ const UTF8* pow;
+ const UTF8* ceil;
+ const UTF8* floor;
+ const UTF8* rint;
+ const UTF8* cbrt;
+ const UTF8* cosh;
+ const UTF8* expm1;
+ const UTF8* hypot;
+ const UTF8* log10;
+ const UTF8* log1p;
+ const UTF8* sinh;
+ const UTF8* tanh;
+ const UTF8* finalize;
+
+ /// primitiveMap - Map of primitive classes, hashed by id.
+ std::map<const char, UserClassPrimitive*> primitiveMap;
+
+ UserClassPrimitive* getPrimitiveClass(char id) {
+ return primitiveMap[id];
+ }
+
+ /// arrayTable - Table of array classes.
+ UserClassArray* arrayTable[8];
+
+ UserClassArray* getArrayClass(unsigned id) {
+ return arrayTable[id - 4];
+ }
private:
- ISOLATE_STATIC void CreateJavaThread(Jnjvm* vm, JavaThread* myth,
+ void CreateJavaThread(Jnjvm* vm, JavaThread* myth,
const char* name, JavaObject* Group);
public:
- ISOLATE_STATIC void InitializeThreading(Jnjvm* vm);
+ void InitializeThreading(Jnjvm* vm);
- ISOLATE_STATIC void CreateForeignJavaThread(Jnjvm* vm, JavaThread* myth);
+ void CreateForeignJavaThread(Jnjvm* vm, JavaThread* myth);
};
Modified: vmkit/branches/multi-vm/lib/J3/Compiler/ExceptionsCheck.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/Compiler/ExceptionsCheck.inc?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/Compiler/ExceptionsCheck.inc (original)
+++ vmkit/branches/multi-vm/lib/J3/Compiler/ExceptionsCheck.inc Wed Dec 8 04:29:13 2010
@@ -314,7 +314,7 @@
assert(cl && "exception class has not been loaded");
ex->catchClass = cl;
} else {
- ex->catchClass = Classpath::newThrowable;
+ ex->catchClass = upcalls->newThrowable;
}
ex->tester = createBasicBlock("testException");
Modified: vmkit/branches/multi-vm/lib/J3/Compiler/ExceptionsDwarf.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/Compiler/ExceptionsDwarf.inc?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/Compiler/ExceptionsDwarf.inc (original)
+++ vmkit/branches/multi-vm/lib/J3/Compiler/ExceptionsDwarf.inc Wed Dec 8 04:29:13 2010
@@ -245,7 +245,7 @@
assert(cl && "exception class has not been loaded");
ex->catchClass = cl;
} else {
- ex->catchClass = Classpath::newThrowable;
+ ex->catchClass = upcalls->newThrowable;
}
ex->catcher = createBasicBlock("testException");
Modified: vmkit/branches/multi-vm/lib/J3/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/Compiler/JavaAOTCompiler.cpp?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/branches/multi-vm/lib/J3/Compiler/JavaAOTCompiler.cpp Wed Dec 8 04:29:13 2010
@@ -204,7 +204,7 @@
final_object_iterator I = finalObjects.find(cl->delegatee[0]);
if (I == End) {
- Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
+ Class* javaClass = cl->classLoader->vm->upcalls->newClass;
LLVMClassInfo* LCI = getClassInfo(javaClass);
const llvm::Type* Ty = LCI->getVirtualType();
Module& Mod = *getLLVMModule();
@@ -313,7 +313,7 @@
CommonClass* cl = JavaObject::getClass(obj);
if (cl->isArray()) {
- Classpath* upcalls = cl->classLoader->bootstrapLoader->upcalls;
+ Classpath* upcalls = cl->classLoader->vm->upcalls;
CommonClass* subClass = cl->asArrayClass()->baseClass();
if (subClass->isPrimitive()) {
if (subClass == upcalls->OfBool) {
@@ -581,7 +581,7 @@
}
Constant* JavaAOTCompiler::CreateConstantFromJavaClass(CommonClass* cl) {
- Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
+ Class* javaClass = cl->classLoader->vm->upcalls->newClass;
LLVMClassInfo* LCI = getClassInfo(javaClass);
const StructType* STy =
dyn_cast<StructType>(LCI->getVirtualType()->getContainedType(0));
@@ -613,7 +613,7 @@
CommonClass* cl = JavaObject::getClass(obj);
if (cl->isArray()) {
- Classpath* upcalls = cl->classLoader->bootstrapLoader->upcalls;
+ Classpath* upcalls = cl->classLoader->vm->upcalls;
CommonClass* subClass = cl->asArrayClass()->baseClass();
if (subClass->isPrimitive()) {
if (subClass == upcalls->OfBool) {
@@ -1395,8 +1395,7 @@
Tracer = ArrayObjectTracer;
}
} else if (classDef->isClass()) {
- if (classDef->isAssignableFrom(
- classDef->classLoader->bootstrapLoader->upcalls->newReference)) {
+ if (classDef->isAssignableFrom(classDef->classLoader->vm->upcalls->newReference)) {
Tracer = ReferenceObjectTracer;
} else {
Tracer = RegularObjectTracer;
@@ -1928,7 +1927,7 @@
bootstrapLoader->analyseClasspathEnv(vm->classpath);
} else {
bootstrapLoader->analyseClasspathEnv(vm->classpath);
- bootstrapLoader->upcalls->initialiseClasspath(bootstrapLoader);
+ vm->upcalls->postInitialiseClasspath(bootstrapLoader);
}
@@ -2052,15 +2051,15 @@
if (M->compileRT) {
// Make sure that if we compile RT, the native classes are emitted.
- M->getNativeClass(bootstrapLoader->upcalls->OfVoid);
- M->getNativeClass(bootstrapLoader->upcalls->OfBool);
- M->getNativeClass(bootstrapLoader->upcalls->OfByte);
- M->getNativeClass(bootstrapLoader->upcalls->OfChar);
- M->getNativeClass(bootstrapLoader->upcalls->OfShort);
- M->getNativeClass(bootstrapLoader->upcalls->OfInt);
- M->getNativeClass(bootstrapLoader->upcalls->OfFloat);
- M->getNativeClass(bootstrapLoader->upcalls->OfLong);
- M->getNativeClass(bootstrapLoader->upcalls->OfDouble);
+ M->getNativeClass(vm->upcalls->OfVoid);
+ M->getNativeClass(vm->upcalls->OfBool);
+ M->getNativeClass(vm->upcalls->OfByte);
+ M->getNativeClass(vm->upcalls->OfChar);
+ M->getNativeClass(vm->upcalls->OfShort);
+ M->getNativeClass(vm->upcalls->OfInt);
+ M->getNativeClass(vm->upcalls->OfFloat);
+ M->getNativeClass(vm->upcalls->OfLong);
+ M->getNativeClass(vm->upcalls->OfDouble);
// Also do not allow inling of some functions.
#define SET_INLINE(NAME) { \
Modified: vmkit/branches/multi-vm/lib/J3/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/Compiler/JavaJIT.cpp?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/Compiler/JavaJIT.cpp (original)
+++ vmkit/branches/multi-vm/lib/J3/Compiler/JavaJIT.cpp Wed Dec 8 04:29:13 2010
@@ -65,7 +65,7 @@
return (meth->canBeInlined &&
meth != compilingMethod && inlineMethods[meth] == 0 &&
(loader == compilingClass->classLoader ||
- loader == compilingClass->classLoader->bootstrapLoader));
+ loader == compilingClass->classLoader->vm->bootstrapLoader));
}
void JavaJIT::invokeVirtual(uint16 index) {
@@ -1363,8 +1363,7 @@
Instruction* JavaJIT::lowerMathOps(const UTF8* name,
std::vector<Value*>& args) {
- JnjvmBootstrapLoader* loader = compilingClass->classLoader->bootstrapLoader;
- if (name->equals(loader->abs)) {
+ if (name->equals(upcalls->abs)) {
const Type* Ty = args[0]->getType();
if (Ty == Type::getInt32Ty(*llvmContext)) {
Constant* const_int32_9 = intrinsics->constantZero;
@@ -1397,71 +1396,71 @@
return llvm::CallInst::Create(intrinsics->func_llvm_fabs_f64, args[0],
"tmp1", currentBlock);
}
- } else if (name->equals(loader->sqrt)) {
+ } else if (name->equals(upcalls->sqrt)) {
return llvm::CallInst::Create(intrinsics->func_llvm_sqrt_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->sin)) {
+ } else if (name->equals(upcalls->sin)) {
return llvm::CallInst::Create(intrinsics->func_llvm_sin_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->cos)) {
+ } else if (name->equals(upcalls->cos)) {
return llvm::CallInst::Create(intrinsics->func_llvm_cos_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->tan)) {
+ } else if (name->equals(upcalls->tan)) {
return llvm::CallInst::Create(intrinsics->func_llvm_tan_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->asin)) {
+ } else if (name->equals(upcalls->asin)) {
return llvm::CallInst::Create(intrinsics->func_llvm_asin_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->acos)) {
+ } else if (name->equals(upcalls->acos)) {
return llvm::CallInst::Create(intrinsics->func_llvm_acos_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->atan)) {
+ } else if (name->equals(upcalls->atan)) {
return llvm::CallInst::Create(intrinsics->func_llvm_atan_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->atan2)) {
+ } else if (name->equals(upcalls->atan2)) {
return llvm::CallInst::Create(intrinsics->func_llvm_atan2_f64,
args.begin(), args.end(), "tmp1",
currentBlock);
- } else if (name->equals(loader->exp)) {
+ } else if (name->equals(upcalls->exp)) {
return llvm::CallInst::Create(intrinsics->func_llvm_exp_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->log)) {
+ } else if (name->equals(upcalls->log)) {
return llvm::CallInst::Create(intrinsics->func_llvm_log_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->pow)) {
+ } else if (name->equals(upcalls->pow)) {
return llvm::CallInst::Create(intrinsics->func_llvm_pow_f64, args.begin(),
args.end(), "tmp1", currentBlock);
- } else if (name->equals(loader->ceil)) {
+ } else if (name->equals(upcalls->ceil)) {
return llvm::CallInst::Create(intrinsics->func_llvm_ceil_f64, args[0], "tmp1",
currentBlock);
- } else if (name->equals(loader->floor)) {
+ } else if (name->equals(upcalls->floor)) {
return llvm::CallInst::Create(intrinsics->func_llvm_floor_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->rint)) {
+ } else if (name->equals(upcalls->rint)) {
return llvm::CallInst::Create(intrinsics->func_llvm_rint_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->cbrt)) {
+ } else if (name->equals(upcalls->cbrt)) {
return llvm::CallInst::Create(intrinsics->func_llvm_cbrt_f64, args[0], "tmp1",
currentBlock);
- } else if (name->equals(loader->cosh)) {
+ } else if (name->equals(upcalls->cosh)) {
return llvm::CallInst::Create(intrinsics->func_llvm_cosh_f64, args[0], "tmp1",
currentBlock);
- } else if (name->equals(loader->expm1)) {
+ } else if (name->equals(upcalls->expm1)) {
return llvm::CallInst::Create(intrinsics->func_llvm_expm1_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->hypot)) {
+ } else if (name->equals(upcalls->hypot)) {
return llvm::CallInst::Create(intrinsics->func_llvm_hypot_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->log10)) {
+ } else if (name->equals(upcalls->log10)) {
return llvm::CallInst::Create(intrinsics->func_llvm_log10_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->log1p)) {
+ } else if (name->equals(upcalls->log1p)) {
return llvm::CallInst::Create(intrinsics->func_llvm_log1p_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->sinh)) {
+ } else if (name->equals(upcalls->sinh)) {
return llvm::CallInst::Create(intrinsics->func_llvm_sinh_f64, args[0],
"tmp1", currentBlock);
- } else if (name->equals(loader->tanh)) {
+ } else if (name->equals(upcalls->tanh)) {
return llvm::CallInst::Create(intrinsics->func_llvm_tanh_f64, args[0],
"tmp1", currentBlock);
}
@@ -1524,7 +1523,7 @@
makeArgs(it, index, args, signature->nbArguments + 1);
JITVerifyNull(args[0]);
- if (meth == compilingClass->classLoader->bootstrapLoader->upcalls->InitObject) {
+ if (meth == upcalls->InitObject) {
return;
}
@@ -1558,10 +1557,9 @@
LLVMSignatureInfo* LSI = TheCompiler->getSignatureInfo(signature);
const llvm::FunctionType* staticType = LSI->getStaticType();
ctpInfo->markAsStaticCall(index);
- JnjvmBootstrapLoader* loader = compilingClass->classLoader->bootstrapLoader;
llvm::Instruction* val = 0;
- if (className->equals(loader->stackWalkerName)) {
+ if (className->equals(upcalls->stackWalkerName)) {
callsStackWalker = true;
}
@@ -1590,7 +1588,7 @@
FunctionType::param_iterator it = staticType->param_end();
makeArgs(it, index, args, signature->nbArguments);
- if (className->equals(loader->mathName)) {
+ if (className->equals(upcalls->mathName)) {
val = lowerMathOps(name, args);
}
@@ -1873,8 +1871,7 @@
bool final = false;
- JnjvmBootstrapLoader* JBL = compilingClass->classLoader->bootstrapLoader;
- if (!compilingMethod->name->equals(JBL->clinitName)) {
+ if (!compilingMethod->name->equals(upcalls->clinitName)) {
JavaField* field = compilingClass->ctpInfo->lookupField(index, true);
if (field && field->classDef->isReady()) final = isFinal(field->access);
if (final) {
@@ -1975,11 +1972,10 @@
Value* ptr = ldResolved(index, false, obj, LAI.llvmTypePtr);
- JnjvmBootstrapLoader* JBL = compilingClass->classLoader->bootstrapLoader;
bool final = false;
// In init methods, the fields have not been set yet.
- if (!compilingMethod->name->equals(JBL->initName)) {
+ if (!compilingMethod->name->equals(upcalls->initName)) {
JavaField* field = compilingClass->ctpInfo->lookupField(index, false);
if (field) {
final = isFinal(field->access) && sign->isPrimitive();
Modified: vmkit/branches/multi-vm/lib/J3/Compiler/JavaJIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/Compiler/JavaJIT.h?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/Compiler/JavaJIT.h (original)
+++ vmkit/branches/multi-vm/lib/J3/Compiler/JavaJIT.h Wed Dec 8 04:29:13 2010
@@ -29,6 +29,7 @@
#include "JavaClass.h"
#include "JavaUpcalls.h"
+#include "Jnjvm.h"
namespace j3 {
@@ -71,7 +72,7 @@
JavaJIT(JavaLLVMCompiler* C, JavaMethod* meth, llvm::Function* func) {
compilingMethod = meth;
compilingClass = meth->classDef;
- upcalls = compilingClass->classLoader->bootstrapLoader->upcalls;
+ upcalls = compilingClass->classLoader->vm->upcalls;
TheCompiler = C;
intrinsics = TheCompiler->getIntrinsics();
llvmFunction = func;
Modified: vmkit/branches/multi-vm/lib/J3/Compiler/JavaJITOpcodes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/Compiler/JavaJITOpcodes.cpp?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/Compiler/JavaJITOpcodes.cpp (original)
+++ vmkit/branches/multi-vm/lib/J3/Compiler/JavaJITOpcodes.cpp Wed Dec 8 04:29:13 2010
@@ -2056,10 +2056,8 @@
uint8 id = reader.readU1();
i += 1;
uint8 charId = arrayType(compilingMethod, id);
- JnjvmBootstrapLoader* loader =
- compilingClass->classLoader->bootstrapLoader;
- dcl = loader->getArrayClass(id);
+ dcl = upcalls->getArrayClass(id);
valCl = TheCompiler->getNativeClass(dcl);
LLVMAssessorInfo& LAI = TheCompiler->AssessorInfo[charId];
Modified: vmkit/branches/multi-vm/lib/J3/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/VMCore/JavaClass.cpp?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/VMCore/JavaClass.cpp (original)
+++ vmkit/branches/multi-vm/lib/J3/VMCore/JavaClass.cpp Wed Dec 8 04:29:13 2010
@@ -319,7 +319,7 @@
isSuper(current->access) &&
current != meth->classDef &&
meth->classDef->isAssignableFrom(current) &&
- !name->equals(classLoader->bootstrapLoader->initName)) {
+ !name->equals(classLoader->vm->upcalls->initName)) {
meth = current->super->lookupMethodDontThrow(name, type, false, true, NULL);
}
@@ -781,8 +781,8 @@
for (uint32 i = 0; i < nbVirtualMethods; ++i) {
JavaMethod& meth = virtualMethods[i];
- if (meth.name->equals(classLoader->bootstrapLoader->finalize) &&
- meth.type->equals(classLoader->bootstrapLoader->clinitType)) {
+ if (meth.name->equals(classLoader->vm->upcalls->finalize) &&
+ meth.type->equals(classLoader->vm->upcalls->clinitType)) {
meth.offset = 0;
} else {
JavaMethod* parent = super?
@@ -1286,8 +1286,8 @@
if (nbStaticFields) return true;
JavaMethod* meth =
- lookupMethodDontThrow(classLoader->bootstrapLoader->clinitName,
- classLoader->bootstrapLoader->clinitType,
+ lookupMethodDontThrow(classLoader->vm->upcalls->clinitName,
+ classLoader->vm->upcalls->clinitType,
true, false, 0);
if (meth) return true;
@@ -1300,7 +1300,7 @@
ClassArray::SuperArray = javaLangObject;
JnjvmClassLoader* JCL = javaLangObject->classLoader;
- Classpath* upcalls = JCL->bootstrapLoader->upcalls;
+ Classpath* upcalls = JCL->vm->upcalls;
assert(javaLangObject->virtualVT->init &&
"Initializing array VT before JavaObjectVT");
@@ -1354,7 +1354,7 @@
if (C->super) {
Class* referenceClass =
- C->classLoader->bootstrapLoader->upcalls->newReference;
+ C->classLoader->vm->upcalls->newReference;
if (referenceClass != NULL && C->super->isAssignableFrom(referenceClass)) {
tracer = (uintptr_t)ReferenceObjectTracer;
} else {
@@ -1466,7 +1466,7 @@
// Set depth and display for fast dynamic type checking.
JnjvmClassLoader* JCL = cl->classLoader;
- Classpath* upcalls = JCL->bootstrapLoader->upcalls;
+ Classpath* upcalls = JCL->vm->upcalls;
if (upcalls->ArrayOfObject) {
UserCommonClass* base = C->baseClass();
Modified: vmkit/branches/multi-vm/lib/J3/VMCore/JavaConstantPool.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/VMCore/JavaConstantPool.cpp?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/VMCore/JavaConstantPool.cpp (original)
+++ vmkit/branches/multi-vm/lib/J3/VMCore/JavaConstantPool.cpp Wed Dec 8 04:29:13 2010
@@ -25,6 +25,7 @@
#include "JavaTypes.h"
#include "LockedMap.h"
#include "Reader.h"
+#include "JnjvmClassLoader.h"
using namespace j3;
Modified: vmkit/branches/multi-vm/lib/J3/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/VMCore/Jni.cpp?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/VMCore/Jni.cpp (original)
+++ vmkit/branches/multi-vm/lib/J3/VMCore/Jni.cpp Wed Dec 8 04:29:13 2010
@@ -160,8 +160,8 @@
UserClass* realCl = cl->asClass();
res = realCl->doNew(vm);
- JavaMethod* init = realCl->lookupMethod(vm->bootstrapLoader->initName,
- vm->bootstrapLoader->initExceptionSig,
+ JavaMethod* init = realCl->lookupMethod(vm->upcalls->initName,
+ vm->upcalls->initExceptionSig,
false, true, 0);
str = vm->asciizToStr(msg);
init->invokeIntSpecial(vm, realCl, res, &str);
Modified: vmkit/branches/multi-vm/lib/J3/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/VMCore/Jnjvm.cpp?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/VMCore/Jnjvm.cpp (original)
+++ vmkit/branches/multi-vm/lib/J3/VMCore/Jnjvm.cpp Wed Dec 8 04:29:13 2010
@@ -177,8 +177,8 @@
- JavaMethod* meth = lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
- vm->bootstrapLoader->clinitType,
+ JavaMethod* meth = lookupMethodDontThrow(vm->upcalls->clinitName,
+ vm->upcalls->clinitType,
true, false, 0);
if (meth) {
@@ -213,7 +213,7 @@
// in place of E in the following step.
jexc = Jnjvm::asJavaException(exc);
if (jexc && JavaObject::getClass(jexc)->isAssignableFrom(vm->upcalls->newException)) {
- Classpath* upcalls = classLoader->bootstrapLoader->upcalls;
+ Classpath* upcalls = vm->upcalls;
UserClass* clExcp = upcalls->ExceptionInInitializerError;
Jnjvm* vm = JavaThread::get()->getJVM();
obj = clExcp->doNew(vm);
@@ -1064,7 +1064,7 @@
JavaThread* th = new JavaThread(this, mut);
mut->allVmsData[vmID] = th; // will be done by my caller but I have to call java code before
mut->vmData = th; // will be done by my caller but I have to call java code before
- bootstrapLoader->upcalls->CreateForeignJavaThread(this, th);
+ upcalls->CreateForeignJavaThread(this, th);
return th;
}
@@ -1077,8 +1077,8 @@
// Initialise the bootstrap class loader if it's not
// done already.
- if (bootstrapLoader->upcalls->newString == NULL) {
- bootstrapLoader->upcalls->initialiseClasspath(bootstrapLoader);
+ if (upcalls->newString == NULL) {
+ upcalls->postInitialiseClasspath(bootstrapLoader);
}
#define LOAD_CLASS(cl) \
@@ -1308,7 +1308,7 @@
}
}
- UserClassArray* array = vm->bootstrapLoader->upcalls->ArrayOfString;
+ UserClassArray* array = vm->upcalls->ArrayOfString;
args = (ArrayObject*)array->doNew(info.argc - 2, vm);
for (int i = 2; i < info.argc; ++i) {
ArrayObject::setElement(args, (JavaObject*)vm->asciizToStr(info.argv[i]), i - 2);
@@ -1343,8 +1343,10 @@
VirtualMachine(Alloc, vmkit),
lockSystem(Alloc) {
- bootstrapLoader = new(Alloc, "bootstrap loader") JnjvmBootstrapLoader(Alloc, this, Comp, dlLoad);
+ bootstrapLoader = new(Alloc, "bootstrap loader") JnjvmBootstrapLoader(Alloc, this, Comp);
bootstrapLoader->isolate = this;
+
+ upcalls = new(allocator, "Classpath") Classpath(bootstrapLoader, dlLoad);
initialiseInternalVTs();
@@ -1354,8 +1356,6 @@
appClassLoader = 0;
jniEnv = &JNI_JNIEnvTable;
javavmEnv = &JNI_JavaVMTable;
-
- upcalls = bootstrapLoader->upcalls;
throwable = upcalls->newThrowable;
Modified: vmkit/branches/multi-vm/lib/J3/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/VMCore/JnjvmClassLoader.cpp?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/branches/multi-vm/lib/J3/VMCore/JnjvmClassLoader.cpp Wed Dec 8 04:29:13 2010
@@ -23,15 +23,6 @@
#include <string>
-
-#if defined(__MACH__)
-#define SELF_HANDLE RTLD_DEFAULT
-#define DYLD_EXTENSION ".dylib"
-#else
-#define SELF_HANDLE 0
-#define DYLD_EXTENSION ".so"
-#endif
-
#include "debug.h"
#include "mvm/Allocator.h"
#include "mvm/VMKit.h"
@@ -51,19 +42,13 @@
#include "Reader.h"
#include "Zip.h"
-
using namespace j3;
typedef void (*static_init_t)(JnjvmClassLoader*);
-const UTF8* JavaCompiler::InlinePragma = 0;
-const UTF8* JavaCompiler::NoInlinePragma = 0;
-
-
JnjvmBootstrapLoader::JnjvmBootstrapLoader(mvm::BumpPtrAllocator& Alloc,
Jnjvm* vm,
- JavaCompiler* Comp,
- bool dlLoad) :
+ JavaCompiler* Comp) :
JnjvmClassLoader(Alloc, vm) {
TheCompiler = Comp;
@@ -83,185 +68,10 @@
if (!libClasspathEnv) {
libClasspathEnv = GNUClasspathLibs;
}
-
-
- upcalls = new(allocator, "Classpath") Classpath();
- bootstrapLoader = this;
-
- // Try to find if we have a pre-compiled rt.jar
- if (dlLoad) {
- SuperArray = (Class*)dlsym(SELF_HANDLE, "java_lang_Object");
- if (!SuperArray) {
- nativeHandle = dlopen("libvmjc"DYLD_EXTENSION, RTLD_LAZY | RTLD_GLOBAL);
- if (nativeHandle) {
- // Found it!
- SuperArray = (Class*)dlsym(nativeHandle, "java_lang_Object");
- }
- }
-
- if (SuperArray) {
- assert(TheCompiler &&
- "Loading libvmjc"DYLD_EXTENSION" requires a compiler");
- ClassArray::SuperArray = (Class*)SuperArray->getInternal();
-
- // Get the native classes.
- upcalls->OfVoid = (ClassPrimitive*)dlsym(nativeHandle, "void");
- upcalls->OfBool = (ClassPrimitive*)dlsym(nativeHandle, "boolean");
- upcalls->OfByte = (ClassPrimitive*)dlsym(nativeHandle, "byte");
- upcalls->OfChar = (ClassPrimitive*)dlsym(nativeHandle, "char");
- upcalls->OfShort = (ClassPrimitive*)dlsym(nativeHandle, "short");
- upcalls->OfInt = (ClassPrimitive*)dlsym(nativeHandle, "int");
- upcalls->OfFloat = (ClassPrimitive*)dlsym(nativeHandle, "float");
- upcalls->OfLong = (ClassPrimitive*)dlsym(nativeHandle, "long");
- upcalls->OfDouble = (ClassPrimitive*)dlsym(nativeHandle, "double");
-
-
- // We have the java/lang/Object class, execute the static initializer.
- static_init_t init = (static_init_t)(uintptr_t)SuperArray->classLoader;
- assert(init && "Loaded the wrong boot library");
- init(this);
-
- // Get the base object arrays after the init, because init puts arrays
- // in the class loader map.
- upcalls->ArrayOfString =
- constructArray(asciizConstructUTF8("[Ljava/lang/String;"));
-
- upcalls->ArrayOfObject =
- constructArray(asciizConstructUTF8("[Ljava/lang/Object;"));
-
- InterfacesArray = upcalls->ArrayOfObject->interfaces;
- ClassArray::InterfacesArray = InterfacesArray;
-
- }
- }
-
- if (!upcalls->OfChar) {
- // Allocate interfaces.
- InterfacesArray = (Class**)allocator.Allocate(2 * sizeof(UserClass*),
- "Interface array");
- ClassArray::InterfacesArray = InterfacesArray;
-
- // Create the primitive classes.
- upcalls->OfChar = UPCALL_PRIMITIVE_CLASS(this, "char", 1);
- upcalls->OfBool = UPCALL_PRIMITIVE_CLASS(this, "boolean", 0);
- upcalls->OfShort = UPCALL_PRIMITIVE_CLASS(this, "short", 1);
- upcalls->OfInt = UPCALL_PRIMITIVE_CLASS(this, "int", 2);
- upcalls->OfLong = UPCALL_PRIMITIVE_CLASS(this, "long", 3);
- upcalls->OfFloat = UPCALL_PRIMITIVE_CLASS(this, "float", 2);
- upcalls->OfDouble = UPCALL_PRIMITIVE_CLASS(this, "double", 3);
- upcalls->OfVoid = UPCALL_PRIMITIVE_CLASS(this, "void", 0);
- upcalls->OfByte = UPCALL_PRIMITIVE_CLASS(this, "byte", 0);
- }
-
- // Create the primitive arrays.
- upcalls->ArrayOfChar = constructArray(asciizConstructUTF8("[C"),
- upcalls->OfChar);
-
- upcalls->ArrayOfByte = constructArray(asciizConstructUTF8("[B"),
- upcalls->OfByte);
-
- upcalls->ArrayOfInt = constructArray(asciizConstructUTF8("[I"),
- upcalls->OfInt);
-
- upcalls->ArrayOfBool = constructArray(asciizConstructUTF8("[Z"),
- upcalls->OfBool);
-
- upcalls->ArrayOfLong = constructArray(asciizConstructUTF8("[J"),
- upcalls->OfLong);
-
- upcalls->ArrayOfFloat = constructArray(asciizConstructUTF8("[F"),
- upcalls->OfFloat);
-
- upcalls->ArrayOfDouble = constructArray(asciizConstructUTF8("[D"),
- upcalls->OfDouble);
-
- upcalls->ArrayOfShort = constructArray(asciizConstructUTF8("[S"),
- upcalls->OfShort);
-
- // Fill the maps.
- primitiveMap[I_VOID] = upcalls->OfVoid;
- primitiveMap[I_BOOL] = upcalls->OfBool;
- primitiveMap[I_BYTE] = upcalls->OfByte;
- primitiveMap[I_CHAR] = upcalls->OfChar;
- primitiveMap[I_SHORT] = upcalls->OfShort;
- primitiveMap[I_INT] = upcalls->OfInt;
- primitiveMap[I_FLOAT] = upcalls->OfFloat;
- primitiveMap[I_LONG] = upcalls->OfLong;
- primitiveMap[I_DOUBLE] = upcalls->OfDouble;
-
- arrayTable[JavaArray::T_BOOLEAN - 4] = upcalls->ArrayOfBool;
- arrayTable[JavaArray::T_BYTE - 4] = upcalls->ArrayOfByte;
- arrayTable[JavaArray::T_CHAR - 4] = upcalls->ArrayOfChar;
- arrayTable[JavaArray::T_SHORT - 4] = upcalls->ArrayOfShort;
- arrayTable[JavaArray::T_INT - 4] = upcalls->ArrayOfInt;
- arrayTable[JavaArray::T_FLOAT - 4] = upcalls->ArrayOfFloat;
- arrayTable[JavaArray::T_LONG - 4] = upcalls->ArrayOfLong;
- arrayTable[JavaArray::T_DOUBLE - 4] = upcalls->ArrayOfDouble;
-
- Attribut::annotationsAttribut =
- asciizConstructUTF8("RuntimeVisibleAnnotations");
- Attribut::codeAttribut = asciizConstructUTF8("Code");
- Attribut::exceptionsAttribut = asciizConstructUTF8("Exceptions");
- Attribut::constantAttribut = asciizConstructUTF8("ConstantValue");
- Attribut::lineNumberTableAttribut = asciizConstructUTF8("LineNumberTable");
- Attribut::innerClassesAttribut = asciizConstructUTF8("InnerClasses");
- Attribut::sourceFileAttribut = asciizConstructUTF8("SourceFile");
-
- JavaCompiler::InlinePragma =
- asciizConstructUTF8("Lorg/vmmagic/pragma/Inline;");
- JavaCompiler::NoInlinePragma =
- asciizConstructUTF8("Lorg/vmmagic/pragma/NoInline;");
-
- initName = asciizConstructUTF8("<init>");
- initExceptionSig = asciizConstructUTF8("(Ljava/lang/String;)V");
- clinitName = asciizConstructUTF8("<clinit>");
- clinitType = asciizConstructUTF8("()V");
- runName = asciizConstructUTF8("run");
- prelib = asciizConstructUTF8("lib");
-#if defined(__MACH__)
- postlib = asciizConstructUTF8(".dylib");
-#else
- postlib = asciizConstructUTF8(".so");
-#endif
- mathName = asciizConstructUTF8("java/lang/Math");
- stackWalkerName = asciizConstructUTF8("gnu/classpath/VMStackWalker");
- NoClassDefFoundError = asciizConstructUTF8("java/lang/NoClassDefFoundError");
-
-#define DEF_UTF8(var) \
- var = asciizConstructUTF8(#var)
-
- DEF_UTF8(abs);
- DEF_UTF8(sqrt);
- DEF_UTF8(sin);
- DEF_UTF8(cos);
- DEF_UTF8(tan);
- DEF_UTF8(asin);
- DEF_UTF8(acos);
- DEF_UTF8(atan);
- DEF_UTF8(atan2);
- DEF_UTF8(exp);
- DEF_UTF8(log);
- DEF_UTF8(pow);
- DEF_UTF8(ceil);
- DEF_UTF8(floor);
- DEF_UTF8(rint);
- DEF_UTF8(cbrt);
- DEF_UTF8(cosh);
- DEF_UTF8(expm1);
- DEF_UTF8(hypot);
- DEF_UTF8(log10);
- DEF_UTF8(log1p);
- DEF_UTF8(sinh);
- DEF_UTF8(tanh);
- DEF_UTF8(finalize);
-
-#undef DEF_UTF8
-
-
}
JnjvmClassLoader::JnjvmClassLoader(mvm::BumpPtrAllocator& Alloc,
- JnjvmClassLoader& JCL, JavaObject* loader,
+ JavaObject* loader,
VMClassLoader* vmdata,
Jnjvm* I,
Jnjvm* v) : allocator(Alloc) {
@@ -270,8 +80,7 @@
vm = v;
- bootstrapLoader = JCL.bootstrapLoader;
- TheCompiler = bootstrapLoader->getCompiler()->Create("Applicative loader");
+ TheCompiler = vm->bootstrapLoader->getCompiler()->Create("Applicative loader");
hashUTF8 = new(allocator, "UTF8Map") UTF8Map(allocator);
classes = new(allocator, "ClassMap") ClassMap();
@@ -283,7 +92,7 @@
javaLoader = loader;
isolate = I;
- JavaMethod* meth = bootstrapLoader->upcalls->loadInClassLoader;
+ JavaMethod* meth = vm->upcalls->loadInClassLoader;
loadClassMethod =
JavaObject::getClass(loader)->asClass()->lookupMethodDontThrow(
meth->name, meth->type, false, true, &loadClass);
@@ -389,7 +198,7 @@
if (!cl && doThrow) {
Jnjvm* vm = JavaThread::get()->getJVM();
- if (name->equals(bootstrapLoader->NoClassDefFoundError)) {
+ if (name->equals(vm->upcalls->NoClassDefFoundErrorName)) {
fprintf(stderr, "Unable to load NoClassDefFoundError");
abort();
}
@@ -469,8 +278,8 @@
UserCommonClass* temp = lookupClass(name);
if (temp) return temp;
- if (this != bootstrapLoader) {
- temp = bootstrapLoader->lookupClassOrArray(name);
+ if (this != vm->bootstrapLoader) {
+ temp = vm->bootstrapLoader->lookupClassOrArray(name);
if (temp) return temp;
}
@@ -522,7 +331,7 @@
const UTF8* name = hashUTF8->lookupAsciiz(asciiz);
mvm::ThreadAllocator threadAllocator;
UserCommonClass* result = NULL;
- if (!name) name = bootstrapLoader->hashUTF8->lookupAsciiz(asciiz);
+ if (!name) name = vm->bootstrapLoader->hashUTF8->lookupAsciiz(asciiz);
if (!name) {
uint32 size = strlen(asciiz);
UTF8* temp = (UTF8*)threadAllocator.Allocate(
@@ -536,8 +345,8 @@
}
result = lookupClass(name);
- if ((result == NULL) && (this != bootstrapLoader)) {
- result = bootstrapLoader->lookupClassOrArray(name);
+ if ((result == NULL) && (this != vm->bootstrapLoader)) {
+ result = vm->bootstrapLoader->lookupClassOrArray(name);
if (result != NULL) {
if (result->isClass() && doResolve) {
result->asClass()->resolveClass();
@@ -622,7 +431,7 @@
UserCommonClass* cl = loadName(componentName, false, true, NULL);
return cl;
} else {
- Classpath* upcalls = bootstrapLoader->upcalls;
+ Classpath* upcalls = vm->upcalls;
UserClassPrimitive* prim =
UserClassPrimitive::byteIdToPrimitive(name->elements[start], upcalls);
assert(prim && "No primitive found");
@@ -728,10 +537,10 @@
break;
default :
UserClassPrimitive* cl =
- bootstrapLoader->getPrimitiveClass((char)name->elements[0]);
+ vm->upcalls->getPrimitiveClass((char)name->elements[0]);
assert(cl && "No primitive");
- bool unsign = (cl == bootstrapLoader->upcalls->OfChar ||
- cl == bootstrapLoader->upcalls->OfBool);
+ bool unsign = (cl == vm->upcalls->OfChar ||
+ cl == vm->upcalls->OfBool);
res = new(allocator, "PrimitiveTypedef") PrimitiveTypedef(name, cl,
unsign, cur);
}
@@ -855,35 +664,34 @@
JnjvmClassLoader*
-JnjvmClassLoader::getJnjvmLoaderFromJavaObject(JavaObject* loader, Jnjvm* vm) {
+JnjvmClassLoader::getJnjvmLoaderFromJavaObject(JavaObject* jloader, Jnjvm* vm) {
VMClassLoader* vmdata = 0;
- llvm_gcroot(loader, 0);
+ llvm_gcroot(jloader, 0);
llvm_gcroot(vmdata, 0);
- if (loader == NULL) return vm->bootstrapLoader;
+ if (jloader == NULL) return vm->bootstrapLoader;
JnjvmClassLoader* JCL = 0;
- Classpath* upcalls = vm->bootstrapLoader->upcalls;
+ Classpath* upcalls = vm->upcalls;
vmdata =
- (VMClassLoader*)(upcalls->vmdataClassLoader->getInstanceObjectField(loader));
+ (VMClassLoader*)(upcalls->vmdataClassLoader->getInstanceObjectField(jloader));
if (vmdata == NULL) {
- JavaObject::acquire(loader);
+ JavaObject::acquire(jloader);
vmdata =
- (VMClassLoader*)(upcalls->vmdataClassLoader->getInstanceObjectField(loader));
+ (VMClassLoader*)(upcalls->vmdataClassLoader->getInstanceObjectField(jloader));
if (!vmdata) {
vmdata = VMClassLoader::allocate(vm);
mvm::BumpPtrAllocator* A = new mvm::BumpPtrAllocator();
- JCL = new(*A, "Class loader") JnjvmClassLoader(*A, *vm->bootstrapLoader,
- loader, vmdata, vm, vm);
- upcalls->vmdataClassLoader->setInstanceObjectField(loader, (JavaObject*)vmdata);
+ JCL = new(*A, "Class loader") JnjvmClassLoader(*A, jloader, vmdata, vm, vm);
+ upcalls->vmdataClassLoader->setInstanceObjectField(jloader, (JavaObject*)vmdata);
}
- JavaObject::release(loader);
+ JavaObject::release(jloader);
} else {
JCL = vmdata->getClassLoader();
- assert(JCL->javaLoader == loader);
+ assert(JCL->javaLoader == jloader);
}
return JCL;
@@ -1049,8 +857,8 @@
j3 = true;
}
- if (!res && this != bootstrapLoader)
- res = bootstrapLoader->loadInLib(buf, j3);
+ if (!res && this != vm->bootstrapLoader)
+ res = vm->bootstrapLoader->loadInLib(buf, j3);
return (intptr_t)res;
}
Modified: vmkit/branches/multi-vm/lib/J3/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/VMCore/JnjvmClassLoader.h?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/VMCore/JnjvmClassLoader.h (original)
+++ vmkit/branches/multi-vm/lib/J3/VMCore/JnjvmClassLoader.h Wed Dec 8 04:29:13 2010
@@ -58,10 +58,12 @@
///
Jnjvm* isolate;
+public:
/// vm - my vm
///
Jnjvm* vm;
+private:
/// javaLoder - The Java representation of the class loader. Null for the
/// bootstrap class loader.
///
@@ -80,8 +82,7 @@
/// JnjvmClassLoader - Allocate a user-defined class loader. Called on
/// first use of a Java class loader.
///
- JnjvmClassLoader(mvm::BumpPtrAllocator& Alloc, JnjvmClassLoader& JCL,
- JavaObject* loader, VMClassLoader* vmdata, Jnjvm* isolate, Jnjvm* vm);
+ JnjvmClassLoader(mvm::BumpPtrAllocator& Alloc, JavaObject* loader, VMClassLoader* vmdata, Jnjvm* isolate, Jnjvm* vm);
/// lookupComponentName - Try to find the component name of the given array
/// name. If the component name is not in the table of UTF8s and holder
@@ -234,11 +235,6 @@
///
const UTF8* readerConstructUTF8(const uint16* buf, uint32 size);
- /// bootstrapLoader - The bootstrap loader of the JVM. Loads the base
- /// classes.
- ///
- JnjvmBootstrapLoader* bootstrapLoader;
-
/// ~JnjvmClassLoader - Destroy the loader: destroy the tables, JIT module and
/// module provider.
///
@@ -353,10 +349,9 @@
void analyseClasspathEnv(const char*);
/// createBootstrapLoader - Creates the bootstrap loader, first thing
- /// to do before any execution of a JVM. Also try to load libvmjc.so
- /// if dlLoad is not false.
+ /// to do before any execution of a JVM.
///
- JnjvmBootstrapLoader(mvm::BumpPtrAllocator& Alloc, Jnjvm* vm, JavaCompiler* Comp, bool dlLoad);
+ JnjvmBootstrapLoader(mvm::BumpPtrAllocator& Alloc, Jnjvm* vm, JavaCompiler* Comp);
virtual JavaString** UTF8ToStr(const UTF8* utf8);
@@ -365,68 +360,6 @@
///
void* nativeHandle;
- /// upcalls - Upcall classes, fields and methods so that C++ code can call
- /// Java code.
- ///
- Classpath* upcalls;
-
- /// InterfacesArray - The interfaces that array classes implement.
- ///
- UserClass** InterfacesArray;
-
- /// SuperArray - The super of array classes.
- UserClass* SuperArray;
-
- /// Lists of UTF8s used internaly in VMKit.
- const UTF8* NoClassDefFoundError;
- const UTF8* initName;
- const UTF8* clinitName;
- const UTF8* clinitType;
- const UTF8* initExceptionSig;
- const UTF8* runName;
- const UTF8* prelib;
- const UTF8* postlib;
- const UTF8* mathName;
- const UTF8* stackWalkerName;
- const UTF8* abs;
- const UTF8* sqrt;
- const UTF8* sin;
- const UTF8* cos;
- const UTF8* tan;
- const UTF8* asin;
- const UTF8* acos;
- const UTF8* atan;
- const UTF8* atan2;
- const UTF8* exp;
- const UTF8* log;
- const UTF8* pow;
- const UTF8* ceil;
- const UTF8* floor;
- const UTF8* rint;
- const UTF8* cbrt;
- const UTF8* cosh;
- const UTF8* expm1;
- const UTF8* hypot;
- const UTF8* log10;
- const UTF8* log1p;
- const UTF8* sinh;
- const UTF8* tanh;
- const UTF8* finalize;
-
- /// primitiveMap - Map of primitive classes, hashed by id.
- std::map<const char, UserClassPrimitive*> primitiveMap;
-
- UserClassPrimitive* getPrimitiveClass(char id) {
- return primitiveMap[id];
- }
-
- /// arrayTable - Table of array classes.
- UserClassArray* arrayTable[8];
-
- UserClassArray* getArrayClass(unsigned id) {
- return arrayTable[id - 4];
- }
-
virtual ~JnjvmBootstrapLoader();
friend class ClArgumentsInfo;
Modified: vmkit/branches/multi-vm/lib/J3/VMCore/VirtualTables.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/multi-vm/lib/J3/VMCore/VirtualTables.cpp?rev=121248&r1=121247&r2=121248&view=diff
==============================================================================
--- vmkit/branches/multi-vm/lib/J3/VMCore/VirtualTables.cpp (original)
+++ vmkit/branches/multi-vm/lib/J3/VMCore/VirtualTables.cpp Wed Dec 8 04:29:13 2010
@@ -232,20 +232,6 @@
void JnjvmBootstrapLoader::tracer(uintptr_t closure) {
JnjvmClassLoader::tracer(closure);
-
-#define TRACE_DELEGATEE(prim) \
- prim->tracer(closure);
-
- TRACE_DELEGATEE(upcalls->OfVoid);
- TRACE_DELEGATEE(upcalls->OfBool);
- TRACE_DELEGATEE(upcalls->OfByte);
- TRACE_DELEGATEE(upcalls->OfChar);
- TRACE_DELEGATEE(upcalls->OfShort);
- TRACE_DELEGATEE(upcalls->OfInt);
- TRACE_DELEGATEE(upcalls->OfFloat);
- TRACE_DELEGATEE(upcalls->OfLong);
- TRACE_DELEGATEE(upcalls->OfDouble);
-#undef TRACE_DELEGATEE
}
//===----------------------------------------------------------------------===//
@@ -289,8 +275,23 @@
ArrayUInt16** key = const_cast<ArrayUInt16**>(&(i->first));
mvm::Collector::markAndTraceRoot(key, closure);
}
+
+ // (5) Trace the delegatees.
+#define TRACE_DELEGATEE(prim) \
+ prim->tracer(closure);
+
+ TRACE_DELEGATEE(upcalls->OfVoid);
+ TRACE_DELEGATEE(upcalls->OfBool);
+ TRACE_DELEGATEE(upcalls->OfByte);
+ TRACE_DELEGATEE(upcalls->OfChar);
+ TRACE_DELEGATEE(upcalls->OfShort);
+ TRACE_DELEGATEE(upcalls->OfInt);
+ TRACE_DELEGATEE(upcalls->OfFloat);
+ TRACE_DELEGATEE(upcalls->OfLong);
+ TRACE_DELEGATEE(upcalls->OfDouble);
+#undef TRACE_DELEGATEE
- // (7) Trace the locks and their associated object.
+ // (6) Trace the locks and their associated object.
uint32 i = 0;
for (; i < mvm::LockSystem::GlobalSize; i++) {
mvm::FatLock** array = lockSystem.LockTable[i];
More information about the vmkit-commits
mailing list