[vmkit-commits] [vmkit] r55535 - in /vmkit/branches/isolate/lib/JnJVM: Isolate/ LLVMRuntime/ VMCore/
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Fri Aug 29 04:53:07 PDT 2008
Author: geoffray
Date: Fri Aug 29 06:53:04 2008
New Revision: 55535
URL: http://llvm.org/viewvc/llvm-project?rev=55535&view=rev
Log:
Refactorize a bit, and materialize user constant pools.
Modified:
vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp
vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h
vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.cpp
vmkit/branches/isolate/lib/JnJVM/Isolate/SharedMaps.h
vmkit/branches/isolate/lib/JnJVM/LLVMRuntime/runtime-default.ll
vmkit/branches/isolate/lib/JnJVM/LLVMRuntime/runtime-isolate.ll
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaInitialise.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaJIT.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaMetaJIT.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.h
vmkit/branches/isolate/lib/JnJVM/VMCore/LowerConstantCalls.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/Reader.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/Reader.h
vmkit/branches/isolate/lib/JnJVM/VMCore/VirtualTables.cpp
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=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp Fri Aug 29 06:53:04 2008
@@ -11,6 +11,8 @@
#include "IsolateSharedLoader.h"
#include "JavaAllocator.h"
#include "JavaClass.h"
+#include "JavaThread.h"
+#include "Jnjvm.h"
#include "JnjvmModule.h"
using namespace jnjvm;
@@ -23,7 +25,8 @@
UserClass::UserClass(JnjvmClassLoader* JCL, const UTF8* name,
ArrayUInt8* bytes) {
- Class* cl = JnjvmSharedLoader::sharedLoader->constructSharedClass(name, bytes);
+ Class* cl = JnjvmSharedLoader::sharedLoader->constructSharedClass(name,
+ bytes);
if (!cl) {
cl = allocator_new(JCL->allocator, Class)(JCL, name, bytes);
}
@@ -32,6 +35,7 @@
classLoader = JCL;
delegatee = 0;
staticInstance = 0;
+ ctpInfo = new(JCL->allocator, cl->ctpInfo->ctpSize) UserConstantPool(this);
}
UserClassArray::UserClassArray(JnjvmClassLoader* JCL, const UTF8* name) {
@@ -112,18 +116,6 @@
}
}
-UserConstantPool* UserClass::getCtpCache() {
- fprintf(stderr, "implement me");
- abort();
- return 0;
-}
-
-UserConstantPool* UserClass::getConstantPool() {
- fprintf(stderr, "implement me");
- abort();
- return 0;
-}
-
UserClass* UserCommonClass::lookupClassFromMethod(JavaMethod* meth) {
fprintf(stderr, "implement me");
abort();
@@ -159,6 +151,11 @@
abort();
}
+void* UserConstantPool::operator new(size_t sz, JavaAllocator* alloc,
+ uint32 size){
+ return alloc->allocateObject(sz + size * sizeof(void*), VT);
+}
+
AssessorDesc* UserClassArray::funcs() {
fprintf(stderr, "implement me");
abort();
@@ -178,17 +175,95 @@
return 0;
}
-Class::Class(JnjvmClassLoader*, const UTF8*, ArrayUInt8*) {
- fprintf(stderr, "implement me");
- abort();
+JavaMethod* UserCommonClass::lookupMethodDontThrow(const UTF8* name,
+ const UTF8* type,
+ bool isStatic,
+ bool recurse) {
+
+ CommonClass::FieldCmp CC(name, type);
+ CommonClass::method_map* map = isStatic ? getStaticMethods() :
+ getVirtualMethods();
+ CommonClass::method_iterator End = map->end();
+ CommonClass::method_iterator I = map->find(CC);
+ if (I != End) return I->second;
+
+ JavaMethod *cur = 0;
+
+ if (recurse) {
+ if (super) cur = super->lookupMethodDontThrow(name, type, isStatic,
+ recurse);
+ if (cur) return cur;
+ if (isStatic) {
+ std::vector<UserClass*>* interfaces = getInterfaces();
+ for (std::vector<UserClass*>::iterator i = interfaces->begin(),
+ e = interfaces->end(); i!= e; i++) {
+ cur = (*i)->lookupMethodDontThrow(name, type, isStatic, recurse);
+ if (cur) return cur;
+ }
+ }
+ }
+
+ return 0;
}
-ClassPrimitive::ClassPrimitive(JnjvmClassLoader*, const UTF8*, uint32) {
- fprintf(stderr, "implement me");
- abort();
+JavaMethod* UserCommonClass::lookupMethod(const UTF8* name, const UTF8* type,
+ bool isStatic, bool recurse) {
+ JavaMethod* res = lookupMethodDontThrow(name, type, isStatic, recurse);
+ if (!res) {
+ JavaThread::get()->isolate->noSuchMethodError(this->classDef, name);
+ }
+ return res;
}
-ClassArray::ClassArray(JnjvmClassLoader*, const UTF8*) {
- fprintf(stderr, "implement me");
- abort();
+JavaField*
+UserCommonClass::lookupFieldDontThrow(const UTF8* name, const UTF8* type,
+ bool isStatic, bool recurse,
+ UserCommonClass*& definingClass) {
+
+ CommonClass::FieldCmp CC(name, type);
+ CommonClass::field_map* map = isStatic ? getStaticFields() :
+ getVirtualFields();
+ CommonClass::field_iterator End = map->end();
+ CommonClass::field_iterator I = map->find(CC);
+ if (I != End) {
+ definingClass = this;
+ return I->second;
+ }
+
+ JavaField *cur = 0;
+
+ if (recurse) {
+ if (super) cur = super->lookupFieldDontThrow(name, type, isStatic,
+ recurse, definingClass);
+ if (cur) {
+ definingClass = (UserClass*)super;
+ return cur;
+ }
+ if (isStatic) {
+ std::vector<UserClass*>* interfaces = getInterfaces();
+ for (std::vector<UserClass*>::iterator i = interfaces->begin(),
+ e = interfaces->end(); i!= e; i++) {
+ cur = (*i)->lookupFieldDontThrow(name, type, isStatic, recurse,
+ definingClass);
+ if (cur) {
+ definingClass = *i;
+ return cur;
+ }
+ }
+ }
+ }
+
+ return 0;
+}
+
+JavaField* UserCommonClass::lookupField(const UTF8* name, const UTF8* type,
+ bool isStatic, bool recurse,
+ UserCommonClass*& definingClass) {
+
+ JavaField* res = lookupFieldDontThrow(name, type, isStatic, recurse,
+ definingClass);
+ if (!res) {
+ JavaThread::get()->isolate->noSuchFieldError(this->classDef, name);
+ }
+ return res;
}
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=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h Fri Aug 29 06:53:04 2008
@@ -72,6 +72,10 @@
/// status - The loading/resolve/initialization state of the class.
///
JavaState status;
+
+ /// ctpInfo - The private constant pool of this class.
+ ///
+ UserConstantPool* ctpInfo;
//===----------------------------------------------------------------------===//
//
@@ -146,29 +150,37 @@
return classDef->getStaticFields();
}
+ CommonClass::field_map* getVirtualFields() {
+ return classDef->getVirtualFields();
+ }
+
+ CommonClass::method_map* getStaticMethods() {
+ return classDef->getStaticMethods();
+ }
+
+ CommonClass::method_map* getVirtualMethods() {
+ return classDef->getVirtualMethods();
+ }
+
void resolveStaticClass() {
((Class*)classDef)->resolveStaticClass();
}
JavaMethod* lookupMethodDontThrow(const UTF8* name, const UTF8* type,
- bool isStatic, bool recurse) {
- return classDef->lookupMethodDontThrow(name, type, isStatic, recurse);
- }
+ bool isStatic, bool recurse);
JavaMethod* lookupMethod(const UTF8* name, const UTF8* type,
- bool isStatic, bool recurse) {
- return classDef->lookupMethod(name, type, isStatic, recurse);
- }
+ bool isStatic, bool recurse);
JavaField* lookupField(const UTF8* name, const UTF8* type,
bool isStatic, bool recurse,
- UserCommonClass*& fieldCl) {
- CommonClass* cl = 0;
- JavaField* field = classDef->lookupField(name, type, isStatic, recurse, cl);
- fieldCl = getUserClass(cl);
- return field;
- }
+ UserCommonClass*& fieldCl);
+
+ JavaField* lookupFieldDontThrow(const UTF8* name, const UTF8* type,
+ bool isStatic, bool recurse,
+ UserCommonClass*& fieldCl);
+
uint64 getVirtualSize() {
return virtualSize;
@@ -297,9 +309,9 @@
staticInstance = obj;
}
- UserConstantPool* ctpInfo;
- UserConstantPool* getConstantPool();
- UserConstantPool* getCtpCache();
+ UserConstantPool* getConstantPool() {
+ return ctpInfo;
+ }
uint64 getStaticSize() {
return ((Class*)classDef)->getStaticSize();
@@ -352,13 +364,14 @@
UserClassPrimitive(JnjvmClassLoader* JCL, const UTF8* name, uint32 nb);
};
-class UserConstantPool {
+class UserConstantPool : public mvm::Object {
public:
+ static VirtualTable* VT;
/// ctpRes - Objects resolved dynamically, e.g. UTF8s, classes, methods,
/// fields, strings.
///
- void** ctpRes;
+ void* ctpRes[1];
/// resolveMethod - Resolve the class and the signature of the method. May
/// perform class loading. This function is called just in time, ie when
@@ -382,6 +395,14 @@
/// ie when the class will be used and not yet resolved.
///
UserCommonClass* loadClass(uint32 index);
+
+ void* operator new(size_t sz, JavaAllocator* alloc, uint32 size);
+
+ UserConstantPool(){}
+
+ UserConstantPool(UserClass* cl) {
+ ctpRes[0] = cl;
+ }
};
} // end namespace jnjvm
Modified: vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.cpp?rev=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.cpp Fri Aug 29 06:53:04 2008
@@ -29,7 +29,7 @@
JCL->hashUTF8 = new UTF8Map(JCL->allocator, 0);
JCL->classes = allocator_new(allocator, ClassMap)();
- JCL->nameClasses = allocator_new(allocator, SharedClassNameMap)();
+ JCL->nameClasses = new SharedClassNameMap();
JCL->byteClasses = allocator_new(allocator, SharedClassByteMap)();
JCL->javaTypes = new TypeMap();
JCL->javaSignatures = new SignMap();
@@ -44,7 +44,7 @@
SharedClassByteMap::iterator I = byteClasses->map.find(bytes);
Class* res = 0;
if (I == End) {
- res = allocator_new(allocator, Class)(this, name, bytes);
+ res = new Class(this, name, bytes);
byteClasses->map.insert(std::make_pair(bytes, res));
} else {
res = ((Class*)(I->second));
@@ -59,7 +59,7 @@
SharedClassNameMap::iterator I = nameClasses->map.find(name);
ClassArray* res = 0;
if (I == End) {
- res = allocator_new(allocator, ClassArray)(this, name);
+ res = new ClassArray(this, name);
nameClasses->map.insert(std::make_pair(name, res));
} else {
res = ((ClassArray*)(I->second));
Modified: vmkit/branches/isolate/lib/JnJVM/Isolate/SharedMaps.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Isolate/SharedMaps.h?rev=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Isolate/SharedMaps.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/Isolate/SharedMaps.h Fri Aug 29 06:53:04 2008
@@ -46,8 +46,6 @@
public LockedMap<const UTF8*, CommonClass*, ltutf8, JnjvmClassLoader* > {
public:
- static VirtualTable* VT;
-
SharedClassNameMap() {
lock = mvm::Lock::allocNormal();
}
@@ -55,8 +53,6 @@
~SharedClassNameMap() {
delete lock;
}
-
- virtual void TRACER;
};
Modified: vmkit/branches/isolate/lib/JnJVM/LLVMRuntime/runtime-default.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/LLVMRuntime/runtime-default.ll?rev=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/LLVMRuntime/runtime-default.ll (original)
+++ vmkit/branches/isolate/lib/JnJVM/LLVMRuntime/runtime-default.ll Fri Aug 29 06:53:04 2008
@@ -5,10 +5,10 @@
;;; A virtual table is an array of function pointers.
%VT = type i32**
-;;; The type of a constant pool. This is only used in a multi vm environment.
-;;; Field 1 - The VT of constant pools.
-;;; Field 2 - The constant pool cache.
-%ConstantPool = type { %VT, i8** }
+;;; The type of a constant pool. Jnjvm will make this into a i8**
+%ConstantPool = type i8*
+
+%Jnjvm = type {%VT, %JavaClass*, [9 x %JavaClass*]}
;;; The type of internal classes. This is not complete, but we only need
;;; the first fields for now.
@@ -104,8 +104,8 @@
;;; getConstantPoolAt - Get the value in the constant pool of this class.
;;; This function is removed by Jnjvm after the GVn pass, therefore it does
;;; not have an actual implementation.
-declare i8* @getConstantPoolAt(i8* (%JavaClass*, i32, ...)*, i8**, %JavaClass*,
- i32, ...) readnone
+declare i8* @getConstantPoolAt(i8* (%JavaClass*, i32, ...)*, %ConstantPool*,
+ %JavaClass*, i32, ...) readnone
;;; vtableLookup - Look up the offset in a virtual table of a specific
;;; function. This function takes a class and an index to lookup in the
Modified: vmkit/branches/isolate/lib/JnJVM/LLVMRuntime/runtime-isolate.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/LLVMRuntime/runtime-isolate.ll?rev=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/LLVMRuntime/runtime-isolate.ll (original)
+++ vmkit/branches/isolate/lib/JnJVM/LLVMRuntime/runtime-isolate.ll Fri Aug 29 06:53:04 2008
@@ -2,9 +2,6 @@
;;;;;;;;;;;;;;;;;;;;;;;; Isolate specific methods ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-%Jnjvm = type {%VT, %JavaClass*, [9 x %JavaClass*]}
-
-
;;; enveloppeLookup - Find the enveloppe for the current user class.
declare i8* @enveloppeLookup(%JavaClass*, i32, ...)
@@ -14,11 +11,11 @@
;;; getCtpCacheNode - Get the constant pool cache of a cache node. This is a
;;; constant call because the cache node never changes.
-declare i8** @getCtpCacheNode(%CacheNode*) readnone
+declare %ConstantPool* @getCtpCacheNode(%CacheNode*) readnone
;;; getCtpCacheNode - Get the constant pool cache of a class. This is a
;;; constant call because the constant pool never changes.
-declare i8** @getCtpClass(%JavaClass*) readnone
+declare %ConstantPool* @getCtpClass(%JavaClass*) readnone
;;; getJnjvmExceptionClass - Get the exception user class for the given
;;; isolate.
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=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp Fri Aug 29 06:53:04 2008
@@ -39,6 +39,9 @@
const UTF8* Attribut::innerClassesAttribut = 0;
const UTF8* Attribut::sourceFileAttribut = 0;
+CommonClass* ClassArray::SuperArray;
+std::vector<Class*> ClassArray::InterfacesArray;
+
Attribut::Attribut(const UTF8* name, uint32 length,
uint32 offset) {
@@ -210,18 +213,20 @@
this->classLoader = loader;
this->array = isArray;
this->primitive = false;
+ this->JInfo = 0;
#ifndef MULTIPLE_VM
this->delegatee = 0;
#endif
}
-#ifndef MULTIPLE_VM
ClassPrimitive::ClassPrimitive(JnjvmClassLoader* loader, const UTF8* n,
uint32 nb) :
CommonClass(loader, n, false) {
-
+
+#ifndef MULTIPLE_VM
display = (CommonClass**)malloc(sizeof(CommonClass*));
display[0] = this;
+#endif
primitive = true;
status = ready;
access = ACC_ABSTRACT | ACC_FINAL | ACC_PUBLIC;
@@ -233,21 +238,24 @@
bytes = B;
super = 0;
ctpInfo = 0;
+#ifndef MULTIPLE_VM
_staticInstance = 0;
+#endif
}
ClassArray::ClassArray(JnjvmClassLoader* loader, const UTF8* n) : CommonClass(loader, n, true) {
_funcs = 0;
_baseClass = 0;
- super = JnjvmBootstrapLoader::SuperArray;
- interfaces = JnjvmBootstrapLoader::InterfacesArray;
+ super = ClassArray::SuperArray;
+ interfaces = ClassArray::InterfacesArray;
+#ifndef MULTIPLE_VM
depth = 1;
display = (CommonClass**)malloc(2 * sizeof(CommonClass*));
display[0] = JnjvmBootstrapLoader::SuperArray;
display[1] = this;
+#endif
access = ACC_FINAL | ACC_ABSTRACT;
}
-#endif
void Class::print(mvm::PrintBuffer* buf) const {
buf->write("Class<");
@@ -321,13 +329,15 @@
}
JavaMethod* CommonClass::lookupMethodDontThrow(const UTF8* name,
- const UTF8* type, bool isStatic,
+ const UTF8* type,
+ bool isStatic,
bool recurse) {
- FieldCmp CC(name, type);
- method_map& map = isStatic ? staticMethods : virtualMethods;
- method_iterator End = map.end();
- method_iterator I = map.find(CC);
+ CommonClass::FieldCmp CC(name, type);
+ CommonClass::method_map* map = isStatic ? getStaticMethods() :
+ getVirtualMethods();
+ CommonClass::method_iterator End = map->end();
+ CommonClass::method_iterator I = map->find(CC);
if (I != End) return I->second;
JavaMethod *cur = 0;
@@ -337,8 +347,9 @@
recurse);
if (cur) return cur;
if (isStatic) {
- for (std::vector<Class*>::iterator i = interfaces.begin(),
- e = interfaces.end(); i!= e; i++) {
+ std::vector<Class*>* interfaces = getInterfaces();
+ for (std::vector<Class*>::iterator i = interfaces->begin(),
+ e = interfaces->end(); i!= e; i++) {
cur = (*i)->lookupMethodDontThrow(name, type, isStatic, recurse);
if (cur) return cur;
}
@@ -357,15 +368,16 @@
return res;
}
-JavaField* CommonClass::lookupFieldDontThrow(const UTF8* name,
- const UTF8* type, bool isStatic,
- bool recurse,
- CommonClass*& definingClass) {
-
- FieldCmp CC(name, type);
- field_map& map = isStatic ? staticFields : virtualFields;
- field_iterator End = map.end();
- field_iterator I = map.find(CC);
+JavaField*
+CommonClass::lookupFieldDontThrow(const UTF8* name, const UTF8* type,
+ bool isStatic, bool recurse,
+ CommonClass*& definingClass) {
+
+ CommonClass::FieldCmp CC(name, type);
+ CommonClass::field_map* map = isStatic ? getStaticFields() :
+ getVirtualFields();
+ CommonClass::field_iterator End = map->end();
+ CommonClass::field_iterator I = map->find(CC);
if (I != End) {
definingClass = this;
return I->second;
@@ -381,8 +393,9 @@
return cur;
}
if (isStatic) {
- for (std::vector<Class*>::iterator i = interfaces.begin(),
- e = interfaces.end(); i!= e; i++) {
+ std::vector<Class*>* interfaces = getInterfaces();
+ for (std::vector<Class*>::iterator i = interfaces->begin(),
+ e = interfaces->end(); i!= e; i++) {
cur = (*i)->lookupFieldDontThrow(name, type, isStatic, recurse,
definingClass);
if (cur) {
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=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h Fri Aug 29 06:53:04 2008
@@ -120,6 +120,9 @@
/// class loader finalizer method will be defined.
///
class CommonClass : public mvm::Object {
+#ifdef MULTIPLE_VM
+friend class UserCommonClass;
+#endif
private:
@@ -138,7 +141,7 @@
FieldCmp(const UTF8* n, const UTF8* t) : name(n), type(t) {}
- inline bool operator<(const FieldCmp &cmp) const;
+ bool operator<(const FieldCmp &cmp) const;
};
public:
@@ -223,12 +226,14 @@
bool isInterface() {
return jnjvm::isInterface(access);
}
-
-#ifndef MULTIPLE_VM
+
+ /// interfaces - The interfaces this class implements.
+ ///
+ std::vector<Class*> interfaces;
+
std::vector<Class*> * getInterfaces() {
return &interfaces;
}
-#endif
/// name - The name of the class.
///
@@ -254,10 +259,6 @@
return superUTF8;
}
- /// interfaces - The interfaces this class implements.
- ///
- std::vector<Class*> interfaces;
-
/// interfacesUTF8 - The names of the interfaces this class implements.
///
std::vector<const UTF8*> interfacesUTF8;
@@ -316,6 +317,8 @@
field_map* getStaticFields() { return &staticFields; }
field_map* getVirtualFields() { return &virtualFields; }
+ method_map* getStaticMethods() { return &staticMethods; }
+ method_map* getVirtualMethods() { return &virtualMethods; }
/// constructMethod - Add a new method in this class method map.
///
@@ -647,13 +650,6 @@
return ctpInfo;
}
- /// getCtpCache - A class does not have a ctp cache, hence
- /// this method always returns 0.
- ///
- JavaConstantPool* getCtpCache() {
- return 0;
- }
-
ArrayUInt8* getBytes() {
return bytes;
}
@@ -738,6 +734,9 @@
/// tracer - Tracer of array classes.
///
virtual void TRACER;
+
+ static CommonClass* SuperArray;
+ static std::vector<Class*> InterfacesArray;
};
/// JavaMethod - This class represents Java methods.
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaInitialise.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaInitialise.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaInitialise.cpp Fri Aug 29 06:53:04 2008
@@ -58,9 +58,9 @@
#ifdef MULTIPLE_VM
INIT(JnjvmSharedLoader);
INIT(SharedClassByteMap);
- INIT(SharedClassNameMap);
INIT(UserClass);
INIT(UserClassArray);
+ INIT(UserConstantPool);
#endif
#undef INIT
@@ -78,6 +78,12 @@
}
void Jnjvm::initialiseStatics() {
+
+#ifdef MULTIPLE_VM
+ if (!JnjvmSharedLoader::sharedLoader) {
+ JnjvmSharedLoader::sharedLoader = JnjvmSharedLoader::createSharedLoader();
+ }
+#endif
JnjvmBootstrapLoader* JCL = bootstrapLoader =
JnjvmBootstrapLoader::createBootstrapLoader();
@@ -100,6 +106,17 @@
JCL->loadName(JCL->asciizConstructUTF8("java/lang/Object"), false,
false);
+#ifdef MULTIPLE_VM
+ if (!ClassArray::SuperArray) {
+ ClassArray::SuperArray = JCL->SuperArray->classDef;
+ ClassArray::InterfacesArray.push_back((Class*)JCL->InterfacesArray[0]->classDef);
+ ClassArray::InterfacesArray.push_back((Class*)JCL->InterfacesArray[1]->classDef);
+ }
+#else
+ ClassArray::SuperArray = JCL->SuperArray;
+ ClassArray::InterfacesArray = JCL->InterfacesArray;
+#endif
+
JCL->upcalls->ArrayOfChar->setInterfaces(JCL->InterfacesArray);
JCL->upcalls->ArrayOfChar->setSuper(JCL->SuperArray);
@@ -179,6 +196,7 @@
#undef DEF_UTF8
JCL->upcalls->initialiseClasspath(JCL);
+
}
void mvm::VirtualMachine::initialiseJVM() {
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaJIT.cpp?rev=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaJIT.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaJIT.cpp Fri Aug 29 06:53:04 2008
@@ -1302,13 +1302,13 @@
void JavaJIT::makeArgs(FunctionType::param_iterator it,
uint32 index, std::vector<Value*>& Args, uint32 nb) {
#if defined(MULTIPLE_VM)
- nb += 2;
+ nb += 1;
#endif
Args.reserve(nb + 2);
Value** args = (Value**)alloca(nb*sizeof(Value*));
#if defined(MULTIPLE_VM)
- args[nb - 2] = isolateLocal;
- sint32 start = nb - 3;
+ args[nb - 1] = isolateLocal;
+ sint32 start = nb - 2;
it--;
it--;
#else
@@ -1574,10 +1574,16 @@
// This makes unswitch loop very unhappy time-wise, but makes GVN happy
// number-wise. IMO, it's better to have this than Unswitch.
#if 1
+ std::vector<Value*> Args;
#ifdef MULTIPLE_VM
Value* CTP = ctpCache;
- Value* Cl = new LoadInst(ctpCache, "", currentBlock);
+ std::vector<Value*> Args;
+ Args.push_back(mvm::jit::constantOne);
+ Value* Cl = GetElementPtrInst::Create(CTP, Args.begin(), Args.end(), "",
+ currentBlock);
+ Cl = new LoadInst(Cl, "", currentBlock);
Cl = new BitCastInst(Cl, JnjvmModule::JavaClassType, "", currentBlock);
+ Args.clear();
#else
JavaConstantPool* ctp = compilingClass->ctpInfo;
LLVMConstantPoolInfo* LCPI = module->getConstantPoolInfo(ctp);
@@ -1586,11 +1592,15 @@
Value* Cl = LCI->getVar(this);
#endif
- std::vector<Value*> Args;
Args.push_back(resolver);
Args.push_back(CTP);
Args.push_back(Cl);
+#ifndef MULTIPLE_VM
Args.push_back(ConstantInt::get(Type::Int32Ty, index));
+#else
+ // Add one to the index because of the VT
+ Args.push_back(ConstantInt::get(Type::Int32Ty, index + 1));
+#endif
if (additionalArg) Args.push_back(additionalArg);
Value* res = 0;
@@ -1621,7 +1631,12 @@
Value* CTP = LCPI->getDelegatee(this);
#endif
std::vector<Value*> indexes; //[3];
+#ifndef MULTIPLE_VM
indexes.push_back(ConstantInt::get(Type::Int32Ty, index));
+#else
+ // Add one to the index because of the VT
+ indexes.push_back(ConstantInt::get(Type::Int32Ty, index + 1));
+#endif
Value* arg1 = GetElementPtrInst::Create(CTP, indexes.begin(),
indexes.end(),
"", currentBlock);
@@ -1638,7 +1653,11 @@
currentBlock = falseCl;
std::vector<Value*> Args;
#ifdef MULTIPLE_VM
- Value* v = new LoadInst(ctpCache, "", currentBlock);
+ std::vector<Value*> Args;
+ Args.push_back(mvm::jit::constantOne);
+ Value* v = GetElementPtrInst::Create(ctpCache, Args.begin(), Args.end(), "",
+ currentBlock);
+ v = new LoadInst(v, "", currentBlock);
v = new BitCastInst(v, JnjvmModule::JavaClassType, "", currentBlock);
#else
LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass);
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaMetaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaMetaJIT.cpp?rev=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaMetaJIT.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaMetaJIT.cpp Fri Aug 29 06:53:04 2008
@@ -102,7 +102,7 @@
void* _buf = (void*)buf; \
readArgs(buf, sign, ap); \
void* func = (((void***)obj)[0])[offset];\
- return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getCtpCache(), func, obj, _buf);\
+ return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getConstantPool(), func, obj, _buf);\
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##SpecialAP(Jnjvm* vm, UserClass* cl, JavaObject* obj, va_list ap) {\
@@ -117,7 +117,7 @@
void* _buf = (void*)buf; \
readArgs(buf, sign, ap); \
void* func = this->compiledPtr();\
- return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getCtpCache(), func, obj, _buf);\
+ return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getConstantPool(), func, obj, _buf);\
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, UserClass* cl, va_list ap) {\
@@ -131,7 +131,7 @@
void* _buf = (void*)buf; \
readArgs(buf, sign, ap); \
void* func = this->compiledPtr();\
- return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(vm, cl->getCtpCache(), func, _buf);\
+ return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(vm, cl->getConstantPool(), func, _buf);\
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##VirtualBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\
@@ -145,7 +145,7 @@
\
Signdef* sign = getSignature(); \
void* func = meth->compiledPtr();\
- return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getCtpCache(), func, obj, buf);\
+ return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getConstantPool(), func, obj, buf);\
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##SpecialBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\
@@ -157,7 +157,7 @@
verifyNull(obj);\
void* func = this->compiledPtr();\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getCtpCache(), func, obj, buf);\
+ return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getConstantPool(), func, obj, buf);\
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##StaticBuf(Jnjvm* vm, UserClass* cl, void* buf) {\
@@ -168,7 +168,7 @@
\
void* func = this->compiledPtr();\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(vm, cl->getCtpCache(), func, buf);\
+ return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(vm, cl->getConstantPool(), func, buf);\
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##Virtual(Jnjvm* vm, UserClass* cl, JavaObject* obj, ...) { \
@@ -208,7 +208,7 @@
verifyNull(obj); \
void* func = (((void***)obj)[0])[offset];\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(vm, cl->getCtpCache(), func, obj, ap);\
+ return ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(vm, cl->getConstantPool(), func, obj, ap);\
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##SpecialAP(Jnjvm* vm, UserClass* cl, JavaObject* obj, va_list ap) {\
@@ -220,7 +220,7 @@
verifyNull(obj);\
void* func = this->compiledPtr();\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(vm, cl->getCtpCache(), func, obj, ap);\
+ return ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(vm, cl->getConstantPool(), func, obj, ap);\
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, UserClass* cl, va_list ap) {\
@@ -231,7 +231,7 @@
\
void* func = this->compiledPtr();\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_STATIC_AP)sign->getStaticCallAP())(vm, cl->getCtpCache(), func, ap);\
+ return ((FUNC_TYPE_STATIC_AP)sign->getStaticCallAP())(vm, cl->getConstantPool(), func, ap);\
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##VirtualBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\
@@ -243,7 +243,7 @@
verifyNull(obj);\
void* func = (((void***)obj)[0])[offset];\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getCtpCache(), func, obj, buf);\
+ return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getConstantPool(), func, obj, buf);\
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##SpecialBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\
@@ -255,7 +255,7 @@
verifyNull(obj);\
void* func = this->compiledPtr();\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getCtpCache(), func, obj, buf);\
+ return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getConstantPool(), func, obj, buf);\
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##StaticBuf(Jnjvm* vm, UserClass* cl, void* buf) {\
@@ -266,7 +266,7 @@
\
void* func = this->compiledPtr();\
Signdef* sign = getSignature(); \
- return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(vm, cl->getCtpCache(), func, buf);\
+ return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(vm, cl->getConstantPool(), func, buf);\
}\
\
TYPE JavaMethod::invoke##TYPE_NAME##Virtual(Jnjvm* vm, UserClass* cl, JavaObject* obj, ...) { \
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp?rev=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp Fri Aug 29 06:53:04 2008
@@ -86,7 +86,7 @@
JnjvmBootstrapLoader* Jnjvm::bootstrapLoader;
#endif
-typedef void (*clinit_t)(Jnjvm* vm);
+typedef void (*clinit_t)(Jnjvm* vm, UserConstantPool*);
void UserCommonClass::initialiseClass(Jnjvm* vm) {
// Primitives are initialized at boot time
@@ -133,7 +133,7 @@
JavaObject* exc = 0;
try{
clinit_t pred = (clinit_t)(intptr_t)meth->compiledPtr();
- pred(vm);
+ pred(vm, cl->getConstantPool());
} catch(...) {
exc = JavaThread::getJavaException();
assert(exc && "no exception?");
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Fri Aug 29 06:53:04 2008
@@ -46,7 +46,7 @@
JCL->allocator = new JavaAllocator();
- JCL->hashUTF8 = new UTF8Map(JCL->allocator, JCL->upcalls->ArrayOfChar);
+ JCL->hashUTF8 = new UTF8Map(JCL->allocator, 0);
JCL->classes = allocator_new(allocator, ClassMap)();
JCL->javaTypes = new TypeMap();
JCL->javaSignatures = new SignMap();
@@ -62,7 +62,8 @@
}
JCL->analyseClasspathEnv(JCL->bootClasspathEnv);
-
+
+ JCL->upcalls = new Classpath();
return JCL;
}
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=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp Fri Aug 29 06:53:04 2008
@@ -45,11 +45,8 @@
const llvm::Type* JnjvmModule::JavaArrayObjectType = 0;
const llvm::Type* JnjvmModule::CacheNodeType = 0;
const llvm::Type* JnjvmModule::EnveloppeType = 0;
-
-#ifdef MULTIPLE_VM
const llvm::Type* JnjvmModule::JnjvmType = 0;
-const llvm::Type* JnjvmModule::UserClassType = 0;
-#endif
+const llvm::Type* JnjvmModule::ConstantPoolType = 0;
llvm::Constant* JnjvmModule::JavaObjectNullConstant;
llvm::Constant* JnjvmModule::UTF8NullConstant;
@@ -62,6 +59,8 @@
llvm::ConstantInt* JnjvmModule::OffsetVTInClassConstant;
llvm::ConstantInt* JnjvmModule::OffsetDepthInClassConstant;
llvm::ConstantInt* JnjvmModule::OffsetDisplayInClassConstant;
+llvm::ConstantInt* JnjvmModule::OffsetStatusInClassConstant;
+llvm::ConstantInt* JnjvmModule::OffsetCtpInClassConstant;
const llvm::Type* JnjvmModule::JavaClassType;
const llvm::Type* JnjvmModule::VTType;
llvm::ConstantInt* JnjvmModule::JavaArrayElementsOffsetConstant;
@@ -583,8 +582,8 @@
}
#if defined(MULTIPLE_VM)
- llvmArgs.push_back(mvm::jit::ptrType); // domain
- llvmArgs.push_back(mvm::jit::ptrPtrType); // cached constant pool
+ llvmArgs.push_back(JnjvmModule::JnjvmType); // vm
+ llvmArgs.push_back(JnjvmModule::ConstantPoolType); // cached constant pool
#endif
uint8 id = signature->ret->funcs->numId;
@@ -608,8 +607,8 @@
}
#if defined(MULTIPLE_VM)
- llvmArgs.push_back(mvm::jit::ptrType); // domain
- llvmArgs.push_back(mvm::jit::ptrPtrType); // cached constant pool
+ llvmArgs.push_back(JnjvmModule::JnjvmType); // vm
+ llvmArgs.push_back(JnjvmModule::ConstantPoolType); // cached constant pool
#endif
uint8 id = signature->ret->funcs->numId;
@@ -636,8 +635,8 @@
}
#if defined(MULTIPLE_VM)
- llvmArgs.push_back(mvm::jit::ptrType); // domain
- llvmArgs.push_back(mvm::jit::ptrPtrType); // cached constant pool
+ llvmArgs.push_back(JnjvmModule::JnjvmType); // vm
+ llvmArgs.push_back(JnjvmModule::ConstantPoolType); // cached constant pool
#endif
uint8 id = signature->ret->funcs->numId;
@@ -787,8 +786,8 @@
// Lock here because we are called by arbitrary code
llvm::MutexGuard locked(mvm::jit::executionEngine->lock);
std::vector<const llvm::Type*> Args2;
- Args2.push_back(mvm::jit::ptrType); // vm
- Args2.push_back(mvm::jit::ptrPtrType); // ctp
+ Args2.push_back(JnjvmModule::JnjvmType); // vm
+ Args2.push_back(JnjvmModule::ConstantPoolType); // ctp
Args2.push_back(getVirtualPtrType());
Args2.push_back(JnjvmModule::JavaObjectType);
Args2.push_back(PointerType::getUnqual(Type::Int32Ty));
@@ -804,8 +803,8 @@
// Lock here because we are called by arbitrary code
llvm::MutexGuard locked(mvm::jit::executionEngine->lock);
std::vector<const llvm::Type*> Args;
- Args.push_back(mvm::jit::ptrType); // vm
- Args.push_back(mvm::jit::ptrPtrType); // ctp
+ Args.push_back(JnjvmModule::JnjvmType); // vm
+ Args.push_back(JnjvmModule::ConstantPoolType); // ctp
Args.push_back(getStaticPtrType());
Args.push_back(PointerType::getUnqual(Type::Int32Ty));
uint8 id = signature->ret->funcs->numId;
@@ -928,10 +927,10 @@
VTType = module->getTypeByName("VT");
-#ifdef MULTIPLE_VM
- UserClassType = module->getTypeByName("UserClass");
- JnjvmType = module->getTypeByName("Jnjvm");
-#endif
+ JnjvmType =
+ PointerType::getUnqual(module->getTypeByName("Jnjvm"));
+ ConstantPoolType =
+ PointerType::getUnqual(module->getTypeByName("ConstantPool"));
JavaObjectType =
PointerType::getUnqual(module->getTypeByName("JavaObject"));
@@ -1097,6 +1096,8 @@
OffsetVTInClassConstant = mvm::jit::constantTwo;
OffsetDisplayInClassConstant = mvm::jit::constantThree;
OffsetDepthInClassConstant = mvm::jit::constantFour;
+ OffsetStatusInClassConstant = mvm::jit::constantFive;
+ OffsetCtpInClassConstant = mvm::jit::constantSix;
LLVMAssessorInfo::initialise();
}
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.h?rev=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.h Fri Aug 29 06:53:04 2008
@@ -304,11 +304,8 @@
static const llvm::Type* JavaCacheType;
static const llvm::Type* EnveloppeType;
static const llvm::Type* CacheNodeType;
-
-#ifdef MULTIPLE_VM
static const llvm::Type* JnjvmType;
- static const llvm::Type* UserClassType;
-#endif
+ static const llvm::Type* ConstantPoolType;
#ifdef WITH_TRACER
static llvm::Function* MarkAndTraceFunction;
@@ -376,6 +373,8 @@
static llvm::ConstantInt* OffsetVTInClassConstant;
static llvm::ConstantInt* OffsetDepthInClassConstant;
static llvm::ConstantInt* OffsetDisplayInClassConstant;
+ static llvm::ConstantInt* OffsetStatusInClassConstant;
+ static llvm::ConstantInt* OffsetCtpInClassConstant;
static llvm::Constant* JavaClassNullConstant;
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/LowerConstantCalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/LowerConstantCalls.cpp Fri Aug 29 06:53:04 2008
@@ -310,6 +310,21 @@
CI->eraseFromParent();
}
#endif
+
+#ifdef MULTIPLE_VM
+ else if (V == jnjvm::JnjvmModule::GetCtpClassFunction) {
+ Changed = true;
+ Value* val = Call.getArgument(0);
+ std::vector<Value*> indexes;
+ indexes.push_back(mvm::jit::constantZero);
+ indexes.push_back(jnjvm::JnjvmModule::OffsetCtpInClassConstant);
+ Value* VTPtr = GetElementPtrInst::Create(val, indexes.begin(),
+ indexes.end(), "", CI);
+ Value* VT = new LoadInst(VTPtr, "", CI);
+ CI->replaceAllUsesWith(VT);
+ CI->eraseFromParent();
+ }
+#endif
}
}
}
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/Reader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/Reader.cpp?rev=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/Reader.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/Reader.cpp Fri Aug 29 06:53:04 2008
@@ -25,14 +25,14 @@
const int Reader::SeekCur = SEEK_CUR;
const int Reader::SeekEnd = SEEK_END;
-ArrayUInt8* Reader::openFile(JnjvmClassLoader* loader, char* path) {
+ArrayUInt8* Reader::openFile(JnjvmBootstrapLoader* loader, char* path) {
FILE* fp = fopen(path, "r");
ArrayUInt8* res = 0;
if (fp != 0) {
fseek(fp, 0, SeekEnd);
long nbb = ftell(fp);
fseek(fp, 0, SeekSet);
- UserClassArray* array = loader->bootstrapLoader->upcalls->ArrayOfByte;
+ UserClassArray* array = loader->upcalls->ArrayOfByte;
res = ArrayUInt8::acons(nbb, array, loader->allocator);
fread(res->elements, nbb, 1, fp);
fclose(fp);
@@ -40,12 +40,12 @@
return res;
}
-ArrayUInt8* Reader::openZip(JnjvmClassLoader* loader, ZipArchive* archive,
+ArrayUInt8* Reader::openZip(JnjvmBootstrapLoader* loader, ZipArchive* archive,
char* filename) {
ArrayUInt8* ret = 0;
ZipFile* file = archive->getFile(filename);
if (file != 0) {
- UserClassArray* array = loader->bootstrapLoader->upcalls->ArrayOfByte;
+ UserClassArray* array = loader->upcalls->ArrayOfByte;
ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, array, loader->allocator);
if (archive->readFile(res, file) != 0) {
ret = res;
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/Reader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/Reader.h?rev=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/Reader.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/Reader.h Fri Aug 29 06:53:04 2008
@@ -19,7 +19,7 @@
namespace jnjvm {
-class JnjvmClassLoader;
+class JnjvmBootstrapLoader;
class ZipArchive;
class Reader {
@@ -76,8 +76,8 @@
static const int SeekCur;
static const int SeekEnd;
- static ArrayUInt8* openFile(JnjvmClassLoader* loader, char* path);
- static ArrayUInt8* openZip(JnjvmClassLoader* loader, ZipArchive* archive, char* filename);
+ static ArrayUInt8* openFile(JnjvmBootstrapLoader* loader, char* path);
+ static ArrayUInt8* openZip(JnjvmBootstrapLoader* loader, ZipArchive* archive, char* filename);
uint8 readU1() {
return bytes->elements[cursor++];
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/VirtualTables.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/VirtualTables.cpp?rev=55535&r1=55534&r2=55535&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/VirtualTables.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/VirtualTables.cpp Fri Aug 29 06:53:04 2008
@@ -42,9 +42,9 @@
#ifdef MULTIPLE_VM
INIT(JnjvmSharedLoader);
INIT(SharedClassByteMap);
- INIT(SharedClassNameMap);
INIT(UserClass);
INIT(UserClassArray);
+ INIT(UserConstantPool);
#endif
#ifdef SERVICE_VM
INIT(ServiceDomain);
@@ -153,6 +153,7 @@
classLoader->MARK_AND_TRACE;
delegatee->MARK_AND_TRACE;
staticInstance->MARK_AND_TRACE;
+ ctpInfo->MARK_AND_TRACE;
}
void UserClassPrimitive::TRACER {
@@ -171,12 +172,8 @@
}
}
-void SharedClassNameMap::TRACER {
-}
-
void JnjvmSharedLoader::TRACER {
byteClasses->MARK_AND_TRACE;
- nameClasses->MARK_AND_TRACE;
}
#endif
More information about the vmkit-commits
mailing list