[vmkit-commits] [vmkit] r55474 - in /vmkit/branches/isolate/lib/JnJVM: Classpath/ClasspathVMField.cpp.inc Classpath/ClasspathVMSystemProperties.cpp.inc Isolate/IsolateCommonClass.cpp Isolate/IsolateCommonClass.h VMCore/JavaClass.cpp VMCore/JavaClass.h VMCore/JnjvmModule.cpp
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Thu Aug 28 09:28:18 PDT 2008
Author: geoffray
Date: Thu Aug 28 11:28:17 2008
New Revision: 55474
URL: http://llvm.org/viewvc/llvm-project?rev=55474&view=rev
Log:
Implement more functions for multi-vm.
Modified:
vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc
vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc
vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp
vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h
vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp
Modified: vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc?rev=55474&r1=55473&r2=55474&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc Thu Aug 28 11:28:17 2008
@@ -323,9 +323,6 @@
Obj = cl->getStaticInstance();
}
- if (isStatic(field->access))
- field->classDef->initialiseClass(vm);
-
JavaObject* res = 0;
switch (ass->numId) {
case BOOL_ID : {
Modified: vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc?rev=55474&r1=55473&r2=55474&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc Thu Aug 28 11:28:17 2008
@@ -73,7 +73,7 @@
if (!tmp) tmp = "";
setProperty(vm, prop, "java.home", tmp);
- JnjvmBootstrapLoader* JCL = JnjvmClassLoader::bootstrapLoader;
+ JnjvmBootstrapLoader* JCL = vm->bootstrapLoader;
setProperty(vm, prop, "java.class.version", "49.0");
setProperty(vm, prop, "java.class.path", vm->classpath);
setProperty(vm, prop, "java.boot.class.path", JCL->bootClasspathEnv);
Modified: vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp?rev=55474&r1=55473&r2=55474&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp Thu Aug 28 11:28:17 2008
@@ -54,4 +54,56 @@
delegatee = 0;
}
-
+void UserCommonClass::resolveClass() {
+ if (status < resolved) {
+ acquire();
+ if (status >= resolved) {
+ release();
+ } else if (status == loaded) {
+ if (isArray()) {
+ UserClassArray* arrayCl = (UserClassArray*)this;
+ UserCommonClass* baseClass = arrayCl->baseClass();
+ baseClass->resolveClass();
+ status = resolved;
+ } else {
+ UserClass* cl = (UserClass*)this;
+ Class* def = (Class*)classDef;
+ if (classDef->status < resolved) {
+ classDef->acquire();
+ if (classDef->status == loaded) {
+ def->readClass();
+ def->status = classRead;
+ status = classRead;
+ def->release();
+ release();
+ cl->loadParents();
+ acquire();
+ def->acquire();
+ def->status = prepared;
+ status = prepared;
+ def->classLoader->TheModule->resolveVirtualClass(cl);
+ def->status = resolved;
+ status = resolved;
+ classDef->broadcastClass();
+ } else {
+ while (classDef->status < resolved) {
+ classDef->waitClass();
+ }
+ classDef->release();
+ }
+ } else {
+ release();
+ status = classRead,
+ cl->loadParents();
+ status = resolved;
+ broadcastClass();
+ }
+ }
+ } else {
+ while (status < resolved) {
+ waitClass();
+ }
+ release();
+ }
+ }
+}
Modified: vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h?rev=55474&r1=55473&r2=55474&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h Thu Aug 28 11:28:17 2008
@@ -58,7 +58,7 @@
/// display - The class hierarchy of supers for this class. Array classes
/// do not need it.
///
- CommonClass** display;
+ UserCommonClass** display;
/// depth - The depth of this class in its class hierarchy.
/// display[depth] contains the class. Array classes do not need it.
@@ -78,9 +78,12 @@
JnjvmClassLoader* classLoader;
JavaObject* delegatee;
CommonClass* classDef;
+ UserClass* super;
+ std::vector<UserClass*> interfaces;
virtual void TRACER;
-
+
+ bool inheritName(const UTF8* Tname);
bool isOfTypeName(const UTF8* name);
bool isAssignableFrom(UserCommonClass* cl);
@@ -89,41 +92,97 @@
///
bool subclassOf(UserCommonClass* cl);
- bool isArray();
- bool isPrimitive();
- bool isInterface();
- bool isReady();
- uint8 getAccess();
- const UTF8* getName();
-
- void getDeclaredConstructors(std::vector<JavaMethod*>& res, bool publicOnly);
- void getDeclaredFields(std::vector<JavaField*>& res, bool publicOnly);
- void getDeclaredMethods(std::vector<JavaMethod*>& res, bool publicOnly);
+ bool isArray() {
+ return classDef->isArray();
+ }
+ bool isPrimitive() {
+ return classDef->isPrimitive();
+ }
+
+ bool isInterface() {
+ return classDef->isInterface();
+ }
+
+ bool isReady() {
+ return status >= inClinit;
+ }
+
+ uint8 getAccess() {
+ return classDef->access;
+ }
+
+ const UTF8* getName() {
+ return classDef->name;
+ }
+
+ void getDeclaredConstructors(std::vector<JavaMethod*>& res, bool publicOnly) {
+ classDef->getDeclaredConstructors(res, publicOnly);
+ }
+
+ void getDeclaredFields(std::vector<JavaField*>& res, bool publicOnly) {
+ classDef->getDeclaredFields(res, publicOnly);
+ }
+
+ void getDeclaredMethods(std::vector<JavaMethod*>& res, bool publicOnly) {
+ classDef->getDeclaredMethods(res, publicOnly);
+ }
void initialiseClass(Jnjvm* vm);
JavaObject* getClassDelegatee(Jnjvm* vm, JavaObject* pd = 0);
void resolveClass();
- UserClass* getSuper();
- std::vector<UserClass*>* getInterfaces();
- CommonClass::field_map* getStaticFields();
- void resolveStaticClass();
+ UserClass* getSuper() {
+ return super;
+ }
+
+ std::vector<UserClass*>* getInterfaces() {
+ return &interfaces;
+ }
+
+ CommonClass::field_map* getStaticFields() {
+ return classDef->getStaticFields();
+ }
+
+ void resolveStaticClass() {
+ ((Class*)classDef)->resolveStaticClass();
+ }
JavaMethod* lookupMethodDontThrow(const UTF8* name, const UTF8* type,
- bool isStatic, bool recurse);
+ bool isStatic, bool recurse) {
+ return classDef->lookupMethodDontThrow(name, type, isStatic, recurse);
+ }
+
JavaMethod* lookupMethod(const UTF8* name, const UTF8* type,
- bool isStatic, bool recurse);
+ bool isStatic, bool recurse) {
+ return classDef->lookupMethod(name, type, isStatic, recurse);
+ }
+
JavaField* lookupField(const UTF8* name, const UTF8* type,
bool isStatic, bool recurse,
- UserCommonClass*& fieldCl);
+ UserCommonClass*& fieldCl) {
+ CommonClass* cl = 0;
+ JavaField* field = classDef->lookupField(name, type, isStatic, recurse, cl);
+ fieldCl = getUserClass(cl);
+ return field;
+ }
- uint64 getVirtualSize();
- VirtualTable* getVirtualVT();
+ uint64 getVirtualSize() {
+ return virtualSize;
+ }
+
+ VirtualTable* getVirtualVT() {
+ return virtualVT;
+ }
- void setInterfaces(std::vector<UserClass*> Is);
- void setSuper(UserClass* S);
+ void setInterfaces(std::vector<UserClass*> Is) {
+ interfaces = Is;
+ }
+
+ void setSuper(UserClass* S) {
+ super = S;
+ }
bool instantiationOfArray(UserClassArray* cl);
bool implements(UserCommonClass* cl);
@@ -131,16 +190,21 @@
/// constructMethod - Add a new method in this class method map.
///
JavaMethod* constructMethod(const UTF8* name, const UTF8* type,
- uint32 access);
+ uint32 access) {
+ return classDef->constructMethod(name, type, access);
+ }
/// constructField - Add a new field in this class field map.
///
JavaField* constructField(const UTF8* name, const UTF8* type,
- uint32 access);
+ uint32 access) {
+ return classDef->constructField(name, type, access);
+ }
UserConstantPool* getCtpCache();
UserClass* lookupClassFromMethod(JavaMethod* meth);
+ UserCommonClass* getUserClass(CommonClass* cl);
/// lockVar - When multiple threads want to initialize a class,
/// they must be synchronized so that it is only performed once
@@ -182,6 +246,14 @@
return mvm::Lock::selfOwner(lockVar);
}
+ const UTF8* getSuperUTF8(){
+ return classDef->superUTF8;
+ }
+
+ std::vector<const UTF8*>* getInterfacesUTF8(){
+ return &classDef->interfacesUTF8;
+ }
+
};
class UserClass : public UserCommonClass {
@@ -195,29 +267,74 @@
JavaObject* doNew(Jnjvm* vm);
- std::vector<UserClass*>* getInnerClasses();
- UserClass* getOuterClass();
+ std::vector<UserClass*> innerClasses;
+ UserClass* outerClass;
+
+ std::vector<UserClass*>* getInnerClasses() {
+ return &innerClasses;
+ }
+
+ UserClass* getOuterClass() {
+ return outerClass;
+ }
+
+ bool innerOuterResolved;
+
void resolveInnerOuterClasses();
- JavaObject* getStaticInstance();
- void setStaticInstance(JavaObject* obj);
+
+ void setInnerAccess(uint32 access) {
+ ((Class*)classDef)->setInnerAccess(access);
+ }
+
+ JavaObject* getStaticInstance() {
+ return staticInstance;
+ }
+
+ void setStaticInstance(JavaObject* obj) {
+ staticInstance = obj;
+ }
+
+ UserConstantPool* ctpInfo;
UserConstantPool* getConstantPool();
- void setStaticSize(uint64 size);
- void setStaticVT(VirtualTable* VT);
+ uint64 getStaticSize() {
+ return ((Class*)classDef)->getStaticSize();
+ }
+
+ VirtualTable* getStaticVT() {
+ return ((Class*)classDef)->getStaticVT();
+ }
- uint64 getStaticSize();
- VirtualTable* getStaticVT();
+ /// loadParents - Loads and resolves the parents, i.e. super and interfarces,
+ /// of the class.
+ ///
+ void loadParents();
+
+ Attribut* lookupAttribut(const UTF8* Att) {
+ return ((Class*)classDef)->lookupAttribut(Att);
+ }
+
+ ArrayUInt8* getBytes() {
+ return ((Class*)classDef)->bytes;
+ }
};
class UserClassArray : public UserCommonClass {
public:
static VirtualTable* VT;
UserCommonClass* _baseClass;
-
+ AssessorDesc* _funcs;
+
virtual void TRACER;
UserClassArray(JnjvmClassLoader* JCL, const UTF8* name);
+
+ void resolveComponent();
- UserCommonClass* baseClass();
+ UserCommonClass* baseClass() {
+ if (_baseClass == 0)
+ resolveComponent();
+ return _baseClass;
+ }
AssessorDesc* funcs();
};
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp?rev=55474&r1=55473&r2=55474&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp Thu Aug 28 11:28:17 2008
@@ -261,12 +261,10 @@
buf->write(">");
}
-#ifndef MULTIPLE_VM
-void ClassArray::resolveComponent() {
- AssessorDesc::introspectArray(classLoader, name, 0, _funcs,
+void UserClassArray::resolveComponent() {
+ AssessorDesc::introspectArray(classLoader, getName(), 0, _funcs,
_baseClass);
}
-#endif
JnjvmClassLoader* ClassArray::arrayLoader(const UTF8* name,
JnjvmClassLoader* loader,
@@ -410,22 +408,21 @@
return res;
}
-#ifndef MULTIPLE_VM
-JavaObject* Class::doNew(Jnjvm* vm) {
+JavaObject* UserClass::doNew(Jnjvm* vm) {
assert(this->isReady() && "Uninitialized class when allocating.");
- JavaObject* res = (JavaObject*)vm->allocator.allocateObject(virtualSize, virtualVT);
+ JavaObject* res = (JavaObject*)vm->allocator.allocateObject(getVirtualSize(),
+ getVirtualVT());
res->classOf = this;
return res;
}
-#endif
-bool CommonClass::inheritName(const UTF8* Tname) {
- if (name->equals(Tname)) {
+bool UserCommonClass::inheritName(const UTF8* Tname) {
+ if (getName()->equals(Tname)) {
return true;
} else if (isPrimitive()) {
return false;
} else if (super) {
- if (super->inheritName(Tname)) return true;
+ if (getSuper()->inheritName(Tname)) return true;
}
for (uint32 i = 0; i < interfaces.size(); ++i) {
@@ -434,17 +431,17 @@
return false;
}
-bool CommonClass::isOfTypeName(const UTF8* Tname) {
+bool UserCommonClass::isOfTypeName(const UTF8* Tname) {
if (inheritName(Tname)) {
return true;
} else if (isArray()) {
- CommonClass* curS = this;
+ UserCommonClass* curS = this;
uint32 prof = 0;
uint32 len = Tname->size;
bool res = true;
while (res && Tname->elements[prof] == AssessorDesc::I_TAB) {
- CommonClass* cl = ((ClassArray*)curS)->baseClass();
+ UserCommonClass* cl = ((UserClassArray*)curS)->baseClass();
++prof;
cl->resolveClass();
res = curS->isArray() && cl && (prof < len);
@@ -458,10 +455,10 @@
}
}
-bool CommonClass::implements(CommonClass* cl) {
+bool UserCommonClass::implements(UserCommonClass* cl) {
if (this == cl) return true;
else {
- for (std::vector<Class*>::iterator i = interfaces.begin(),
+ for (std::vector<UserClass*>::iterator i = interfaces.begin(),
e = interfaces.end(); i!= e; i++) {
if (*i == cl) return true;
else if ((*i)->implements(cl)) return true;
@@ -473,12 +470,12 @@
return false;
}
-bool CommonClass::instantiationOfArray(ClassArray* cl) {
+bool UserCommonClass::instantiationOfArray(UserClassArray* cl) {
if (this == cl) return true;
else {
if (isArray()) {
- CommonClass* baseThis = ((ClassArray*)this)->baseClass();
- CommonClass* baseCl = ((ClassArray*)cl)->baseClass();
+ UserCommonClass* baseThis = ((UserClassArray*)this)->baseClass();
+ UserCommonClass* baseCl = ((UserClassArray*)cl)->baseClass();
if (baseThis->isInterface() && baseCl->isInterface()) {
return baseThis->implements(baseCl);
@@ -490,7 +487,7 @@
return false;
}
-bool CommonClass::subclassOf(CommonClass* cl) {
+bool UserCommonClass::subclassOf(UserCommonClass* cl) {
if (cl->depth <= depth) {
return display[cl->depth] == cl;
} else {
@@ -498,13 +495,13 @@
}
}
-bool CommonClass::isAssignableFrom(CommonClass* cl) {
+bool UserCommonClass::isAssignableFrom(UserCommonClass* cl) {
if (this == cl) {
return true;
} else if (cl->isInterface()) {
return this->implements(cl);
} else if (cl->isArray()) {
- return this->instantiationOfArray((ClassArray*)cl);
+ return this->instantiationOfArray((UserClassArray*)cl);
} else {
return this->subclassOf(cl);
}
@@ -600,28 +597,26 @@
}
-#ifndef MULTIPLE_VM
-void Class::loadParents() {
- int nbI = interfacesUTF8.size();
+void UserClass::loadParents() {
+ std::vector<const UTF8*>* interfacesUTF8 = getInterfacesUTF8();
+ unsigned nbI = interfacesUTF8->size();
+ const UTF8* superUTF8 = getSuperUTF8();
if (superUTF8 == 0) {
depth = 0;
- display = (CommonClass**)malloc(sizeof(CommonClass*));
+ display = (UserCommonClass**)malloc(sizeof(UserCommonClass*));
display[0] = this;
- virtualTableSize = VT_SIZE / sizeof(void*);
} else {
super = classLoader->loadName(superUTF8, true, true);
depth = super->depth + 1;
- virtualTableSize = super->virtualTableSize;
- display = (CommonClass**)malloc((depth + 1) * sizeof(CommonClass*));
- memcpy(display, super->display, depth * sizeof(CommonClass*));
+ display = (UserCommonClass**)malloc((depth + 1) * sizeof(UserCommonClass*));
+ memcpy(display, super->display, depth * sizeof(UserCommonClass*));
display[depth] = this;
}
- for (int i = 0; i < nbI; i++)
- interfaces.push_back((Class*)classLoader->loadName(interfacesUTF8[i],
- true, true));
+ for (unsigned i = 0; i < nbI; i++)
+ interfaces.push_back((UserClass*)classLoader->loadName((*interfacesUTF8)[i],
+ true, true));
}
-#endif
void Class::readAttributs(Reader& reader, std::vector<Attribut*>& attr) {
unsigned short int nba = reader.readU2();
@@ -692,6 +687,7 @@
readAttributs(reader, attributs);
}
+#ifndef MULTIPLE_VM
void CommonClass::resolveClass() {
if (status < resolved) {
acquire();
@@ -725,13 +721,13 @@
}
}
}
+#endif
-#ifndef MULTIPLE_VM
void UserClass::resolveInnerOuterClasses() {
if (!innerOuterResolved) {
Attribut* attribut = lookupAttribut(Attribut::innerClassesAttribut);
if (attribut != 0) {
- Reader reader(attribut, bytes);
+ Reader reader(attribut, getBytes());
uint16 nbi = reader.readU2();
for (uint16 i = 0; i < nbi; ++i) {
@@ -740,13 +736,13 @@
//uint16 innerName =
reader.readU2();
uint16 accessFlags = reader.readU2();
- Class* clInner = (Class*)ctpInfo->loadClass(inner);
- Class* clOuter = (Class*)ctpInfo->loadClass(outer);
+ UserClass* clInner = (UserClass*)ctpInfo->loadClass(inner);
+ UserClass* clOuter = (UserClass*)ctpInfo->loadClass(outer);
if (clInner == this) {
outerClass = clOuter;
} else if (clOuter == this) {
- clInner->innerAccess = accessFlags;
+ clInner->setInnerAccess(accessFlags);
innerClasses.push_back(clInner);
}
}
@@ -754,7 +750,6 @@
innerOuterResolved = true;
}
}
-#endif
void CommonClass::getDeclaredConstructors(std::vector<JavaMethod*>& res,
bool publicOnly) {
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h?rev=55474&r1=55473&r2=55474&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h Thu Aug 28 11:28:17 2008
@@ -250,6 +250,10 @@
///
const UTF8* superUTF8;
+ const UTF8* getSuperUTF8() {
+ return superUTF8;
+ }
+
/// interfaces - The interfaces this class implements.
///
std::vector<Class*> interfaces;
@@ -258,6 +262,10 @@
///
std::vector<const UTF8*> interfacesUTF8;
+ std::vector<const UTF8*>* getInterfacesUTF8() {
+ return &interfacesUTF8;
+ }
+
/// lockVar - When multiple threads want to load/resolve/initialize a class,
/// they must be synchronized so that these steps are only performed once
/// for a given class.
@@ -538,6 +546,10 @@
///
uint32 innerAccess;
+ void setInnerAccess(uint32 access) {
+ innerAccess = access;
+ }
+
/// innerOuterResolved - Is the inner/outer resolution done?
///
bool innerOuterResolved;
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=55474&r1=55473&r2=55474&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp Thu Aug 28 11:28:17 2008
@@ -262,6 +262,11 @@
memcpy(res, JavaObject::VT, VT_SIZE);
#ifndef WITHOUT_VTABLE
} else {
+ if (cl->super) {
+ cl->virtualTableSize = cl->super->virtualTableSize;
+ } else {
+ cl->virtualTableSize = VT_SIZE / sizeof(void*);
+ }
res = allocateVT(cl, cl->virtualMethods.begin());
if (!(cl->super)) {
More information about the vmkit-commits
mailing list