[vmkit-commits] [vmkit] r68779 - in /vmkit/trunk: include/jnjvm/ include/mvm/ include/mvm/GC/ lib/JnJVM/Compiler/ lib/JnJVM/LLVMRuntime/ lib/JnJVM/VMCore/ tools/llcj/
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Fri Apr 10 06:05:11 PDT 2009
Author: geoffray
Date: Fri Apr 10 08:05:01 2009
New Revision: 68779
URL: http://llvm.org/viewvc/llvm-project?rev=68779&view=rev
Log:
Move from a 3-word header to a 2-word header for Java objects.
Modified:
vmkit/trunk/include/jnjvm/JnjvmModule.h
vmkit/trunk/include/mvm/GC/GC.h
vmkit/trunk/include/mvm/Object.h
vmkit/trunk/lib/JnJVM/Compiler/JavaAOTCompiler.cpp
vmkit/trunk/lib/JnJVM/Compiler/JavaJIT.cpp
vmkit/trunk/lib/JnJVM/Compiler/JavaJITCompiler.cpp
vmkit/trunk/lib/JnJVM/Compiler/JavaJITOpcodes.cpp
vmkit/trunk/lib/JnJVM/Compiler/JnjvmModule.cpp
vmkit/trunk/lib/JnJVM/Compiler/LowerConstantCalls.cpp
vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll
vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h
vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h
vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaString.h
vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp
vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
vmkit/trunk/tools/llcj/LinkPaths.h.in
Modified: vmkit/trunk/include/jnjvm/JnjvmModule.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/jnjvm/JnjvmModule.h?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/include/jnjvm/JnjvmModule.h (original)
+++ vmkit/trunk/include/jnjvm/JnjvmModule.h Fri Apr 10 08:05:01 2009
@@ -45,6 +45,7 @@
class JavaMethod;
class JavaObject;
class JavaString;
+class JavaVirtualTable;
class JnjvmClassLoader;
class JnjvmModule;
class Typedef;
@@ -194,7 +195,7 @@
static llvm::ConstantInt* JavaArraySizeOffsetConstant;
static llvm::ConstantInt* JavaArrayElementsOffsetConstant;
static llvm::ConstantInt* JavaObjectLockOffsetConstant;
- static llvm::ConstantInt* JavaObjectClassOffsetConstant;
+ static llvm::ConstantInt* JavaObjectVTOffsetConstant;
static const llvm::Type* JavaArrayUInt8Type;
static const llvm::Type* JavaArraySInt8Type;
@@ -291,6 +292,7 @@
llvm::Function* GetClassFunction;
llvm::Function* JavaObjectAllocateFunction;
llvm::Function* GetVTFromClassFunction;
+ llvm::Function* GetVTFromClassArrayFunction;
llvm::Function* GetObjectSizeFromClassFunction;
llvm::Function* GetLockFunction;
@@ -306,6 +308,7 @@
static llvm::ConstantInt* OffsetObjectSizeInClassConstant;
static llvm::ConstantInt* OffsetVTInClassConstant;
+ static llvm::ConstantInt* OffsetVTInClassArrayConstant;
static llvm::ConstantInt* OffsetDepthInClassConstant;
static llvm::ConstantInt* OffsetDisplayInClassConstant;
static llvm::ConstantInt* OffsetTaskClassMirrorInClassConstant;
@@ -316,6 +319,10 @@
static llvm::ConstantInt* OffsetJavaExceptionInThreadConstant;
static llvm::ConstantInt* OffsetCXXExceptionInThreadConstant;
+ static llvm::ConstantInt* OffsetClassInVTConstant;
+ static llvm::ConstantInt* OffsetDepthInVTConstant;
+ static llvm::ConstantInt* OffsetDisplayInVTConstant;
+
static llvm::ConstantInt* ClassReadyConstant;
static llvm::Constant* JavaObjectNullConstant;
@@ -353,9 +360,6 @@
}
#endif
- llvm::Constant* PrimitiveArrayVT;
- llvm::Constant* ReferenceArrayVT;
-
void internalMakeVT(Class* cl);
void addJavaPasses();
@@ -400,9 +404,6 @@
virtual ~JavaLLVMCompiler();
- llvm::Constant* getReferenceArrayVT();
- llvm::Constant* getPrimitiveArrayVT();
-
void resolveVirtualClass(Class* cl);
void resolveStaticClass(Class* cl);
static llvm::Function* getMethod(JavaMethod* meth);
@@ -419,7 +420,7 @@
virtual llvm::Constant* getNativeClass(CommonClass* cl) = 0;
virtual llvm::Constant* getJavaClass(CommonClass* cl) = 0;
virtual llvm::Constant* getStaticInstance(Class* cl) = 0;
- virtual llvm::Constant* getVirtualTable(Class* cl) = 0;
+ virtual llvm::Constant* getVirtualTable(JavaVirtualTable*) = 0;
virtual llvm::Constant* getMethodInClass(JavaMethod* meth) = 0;
virtual llvm::Constant* getEnveloppe(Enveloppe* enveloppe) = 0;
@@ -484,7 +485,7 @@
virtual llvm::Constant* getNativeClass(CommonClass* cl);
virtual llvm::Constant* getJavaClass(CommonClass* cl);
virtual llvm::Constant* getStaticInstance(Class* cl);
- virtual llvm::Constant* getVirtualTable(Class* cl);
+ virtual llvm::Constant* getVirtualTable(JavaVirtualTable*);
virtual llvm::Constant* getMethodInClass(JavaMethod* meth);
virtual llvm::Constant* getEnveloppe(Enveloppe* enveloppe);
@@ -534,7 +535,7 @@
virtual llvm::Constant* getNativeClass(CommonClass* cl);
virtual llvm::Constant* getJavaClass(CommonClass* cl);
virtual llvm::Constant* getStaticInstance(Class* cl);
- virtual llvm::Constant* getVirtualTable(Class* cl);
+ virtual llvm::Constant* getVirtualTable(JavaVirtualTable*);
virtual llvm::Constant* getMethodInClass(JavaMethod* meth);
virtual llvm::Constant* getEnveloppe(Enveloppe* enveloppe);
@@ -558,7 +559,7 @@
#endif
//--------------- Static compiler specific functions -----------------------//
- llvm::Constant* CreateConstantFromVT(Class* classDef);
+ llvm::Constant* CreateConstantFromVT(JavaVirtualTable* VT);
llvm::Constant* CreateConstantFromUTF8(const UTF8* val);
llvm::Constant* CreateConstantFromEnveloppe(Enveloppe* val);
llvm::Constant* CreateConstantFromCacheNode(CacheNode* CN);
@@ -582,7 +583,7 @@
std::map<const CommonClass*, llvm::Constant*> nativeClasses;
std::map<const ClassArray*, llvm::GlobalVariable*> arrayClasses;
std::map<const CommonClass*, llvm::Constant*> javaClasses;
- std::map<const CommonClass*, llvm::Constant*> virtualTables;
+ std::map<const JavaVirtualTable*, llvm::Constant*> virtualTables;
std::map<const Class*, llvm::Constant*> staticInstances;
std::map<const JavaConstantPool*, llvm::Constant*> constantPools;
std::map<const JavaString*, llvm::Constant*> strings;
@@ -607,7 +608,7 @@
typedef std::map<const CommonClass*, llvm::Constant*>::iterator
java_class_iterator;
- typedef std::map<const CommonClass*, llvm::Constant*>::iterator
+ typedef std::map<const JavaVirtualTable*, llvm::Constant*>::iterator
virtual_table_iterator;
typedef std::map<const Class*, llvm::Constant*>::iterator
Modified: vmkit/trunk/include/mvm/GC/GC.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/GC/GC.h?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/GC/GC.h (original)
+++ vmkit/trunk/include/mvm/GC/GC.h Fri Apr 10 08:05:01 2009
@@ -19,6 +19,10 @@
uintptr_t destructor;
uintptr_t operatorDelete;
uintptr_t tracer;
+
+ uintptr_t* getFunctions() {
+ return &destructor;
+ }
};
class gcRoot {
@@ -29,6 +33,18 @@
#else
virtual void tracer(void) {}
#endif
+
+ /// getVirtualTable - Returns the virtual table of this object.
+ ///
+ VirtualTable* getVirtualTable() const {
+ return ((VirtualTable**)(this))[0];
+ }
+
+ /// setVirtualTable - Sets the virtual table of this object.
+ ///
+ void setVirtualTable(VirtualTable* VT) {
+ ((VirtualTable**)(this))[0] = VT;
+ }
};
typedef void (*destructor_t)(void*);
Modified: vmkit/trunk/include/mvm/Object.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Object.h?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/Object.h (original)
+++ vmkit/trunk/include/mvm/Object.h Fri Apr 10 08:05:01 2009
@@ -33,18 +33,6 @@
class Object : public gc {
public:
- /// getVirtualTable - Returns the virtual table of this object.
- ///
- VirtualTable* getVirtualTable() const {
- return ((VirtualTable**)(this))[0];
- }
-
- /// setVirtualTable - Sets the virtual table of this object.
- ///
- void setVirtualTable(VirtualTable* VT) {
- ((VirtualTable**)(this))[0] = VT;
- }
-
/// printString - Returns a string representation of this object.
///
char *printString(void) const;
Modified: vmkit/trunk/lib/JnJVM/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/JavaAOTCompiler.cpp?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JavaAOTCompiler.cpp Fri Apr 10 08:05:01 2009
@@ -33,9 +33,9 @@
using namespace jnjvm;
using namespace llvm;
-extern void* JavaArrayVT[];
-extern void* ArrayObjectVT[];
-extern void* JavaObjectVT[];
+extern JavaVirtualTable JavaArrayVT;
+extern JavaVirtualTable ArrayObjectVT;
+extern JavaVirtualTable JavaObjectVT;
extern ClassArray ArrayOfBool;
extern ClassArray ArrayOfByte;
@@ -153,7 +153,7 @@
return SI->second;
} else {
assert(str && "No string given");
- LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo((Class*)str->getClass());
+ LLVMClassInfo* LCI = getClassInfo((Class*)str->getClass());
const llvm::Type* Ty = LCI->getVirtualType();
GlobalVariable* varGV =
new GlobalVariable(Ty->getContainedType(0), false,
@@ -302,18 +302,25 @@
}
}
-Constant* JavaAOTCompiler::getVirtualTable(Class* classDef) {
- LLVMClassInfo* LCI = getClassInfo((Class*)classDef);
- LCI->getVirtualType();
+Constant* JavaAOTCompiler::getVirtualTable(JavaVirtualTable* VT) {
+ CommonClass* classDef = VT->cl;
+ uint32 size = 0;
+ if (classDef->isClass()) {
+ LLVMClassInfo* LCI = getClassInfo(classDef->asClass());
+ LCI->getVirtualType();
+ size = classDef->asClass()->virtualTableSize;
+ } else {
+ size = classDef->super->virtualTableSize;
+ }
llvm::Constant* res = 0;
virtual_table_iterator End = virtualTables.end();
- virtual_table_iterator I = virtualTables.find(classDef);
+ virtual_table_iterator I = virtualTables.find(VT);
if (I == End) {
const ArrayType* ATy =
dyn_cast<ArrayType>(JnjvmModule::VTType->getContainedType(0));
const PointerType* PTy = dyn_cast<PointerType>(ATy->getContainedType(0));
- ATy = ArrayType::get(PTy, classDef->virtualTableSize);
+ ATy = ArrayType::get(PTy, size);
// Do not set a virtual table as a constant, because the runtime may
// modify it.
GlobalVariable* varGV = new GlobalVariable(ATy, false,
@@ -324,10 +331,10 @@
res = ConstantExpr::getCast(Instruction::BitCast, varGV,
JnjvmModule::VTType);
- virtualTables.insert(std::make_pair(classDef, res));
+ virtualTables.insert(std::make_pair(VT, res));
if (isCompiling(classDef)) {
- Constant* C = CreateConstantFromVT(classDef);
+ Constant* C = CreateConstantFromVT(VT);
varGV->setInitializer(C);
}
@@ -365,24 +372,11 @@
// virtual table
if (cl->isClass()) {
- Elmts.push_back(getVirtualTable(cl->asClass()));
+ Elmts.push_back(getVirtualTable(cl->asClass()->virtualVT));
} else {
- ClassArray* clA = cl->asArrayClass();
- if (clA->baseClass()->isPrimitive()) {
- Elmts.push_back(PrimitiveArrayVT);
- } else {
- Elmts.push_back(ReferenceArrayVT);
- }
+ Elmts.push_back(getVirtualTable(cl->asArrayClass()->virtualVT));
}
- // classof
- Constant* Cl = getNativeClass(cl);
- Constant* ClGEPs[2] = { JnjvmModule::constantZero,
- JnjvmModule::constantZero };
- Cl = ConstantExpr::getGetElementPtr(Cl, ClGEPs, 2);
-
- Elmts.push_back(Cl);
-
// lock
Constant* L = ConstantInt::get(Type::Int64Ty, 0);
Elmts.push_back(ConstantExpr::getIntToPtr(L, JnjvmModule::ptrType));
@@ -848,6 +842,9 @@
Cl = ConstantExpr::getGetElementPtr(Cl, ClGEPs, 2);
ClassElts.push_back(Cl);
+
+ // virtualTable
+ ClassElts.push_back(getVirtualTable(cl->virtualVT));
return ConstantStruct::get(STy, ClassElts);
}
@@ -866,7 +863,7 @@
ClassElts.push_back(ConstantInt::get(Type::Int32Ty, cl->virtualSize));
// virtualTable
- ClassElts.push_back(getVirtualTable(cl));
+ ClassElts.push_back(getVirtualTable(cl->virtualVT));
// IsolateInfo
const ArrayType* ATy = dyn_cast<ArrayType>(STy->getContainedType(3));
@@ -1151,9 +1148,12 @@
}
}
-Constant* JavaAOTCompiler::CreateConstantFromVT(Class* classDef) {
- uint32 size = classDef->virtualTableSize;
- VirtualTable* VT = classDef->virtualVT;
+Constant* JavaAOTCompiler::CreateConstantFromVT(JavaVirtualTable* VT) {
+ CommonClass* classDef = VT->cl;
+ uint32 size = classDef->isArray() ? classDef->super->virtualTableSize :
+ classDef->asClass()->virtualTableSize;
+ JavaVirtualTable* RealVT = classDef->isArray() ? classDef->super->virtualVT :
+ VT;
const ArrayType* ATy =
dyn_cast<ArrayType>(JnjvmModule::VTType->getContainedType(0));
const PointerType* PTy = dyn_cast<PointerType>(ATy->getContainedType(0));
@@ -1164,7 +1164,7 @@
// Destructor
Function* Finalizer = 0;
- JavaMethod* meth = ((JavaMethod**)VT)[0];
+ JavaMethod* meth = (JavaMethod*)(RealVT->destructor);
if (meth) {
LLVMMethodInfo* LMI = getMethodInfo(meth);
Finalizer = LMI->getMethod();
@@ -1177,21 +1177,61 @@
// Tracer
#ifdef WITH_TRACER
- Function* Tracer = makeTracer(classDef, false);
+ Function* Tracer = 0;
+ if (classDef->isArray()) {
+ if (classDef->asArrayClass()->baseClass()->isPrimitive()) {
+ Tracer = JavaIntrinsics.JavaArrayTracerFunction;
+ } else {
+ Tracer = JavaIntrinsics.ArrayObjectTracerFunction;
+ }
+ } else {
+ Tracer = makeTracer(classDef->asClass(), false);
+ }
+
Elemts.push_back(Tracer ?
ConstantExpr::getCast(Instruction::BitCast, Tracer, PTy) : N);
#else
Elemts.push_back(N);
#endif
- // Printer
- Elemts.push_back(ConstantExpr::getBitCast(ObjectPrinter, PTy));
+ // Class
+ Elemts.push_back(ConstantExpr::getCast(Instruction::BitCast,
+ getNativeClass(classDef), PTy));
+
+ // depth
+ Elemts.push_back(ConstantExpr::getIntToPtr(
+ ConstantInt::get(Type::Int64Ty, VT->depth), PTy));
- // Hashcode
- Elemts.push_back(N);
+ // display
+ const ArrayType* DTy = ArrayType::get(JnjvmModule::JavaCommonClassType,
+ VT->depth + 1);
+
+ std::vector<Constant*> TempElmts;
+ Constant* ClGEPs[2] = { JnjvmModule::constantZero,
+ JnjvmModule::constantZero };
- for (uint32 i = VT_NB_FUNCS; i < size; ++i) {
- JavaMethod* meth = ((JavaMethod**)VT)[i];
+
+ for (uint32 i = 0; i <= VT->depth; ++i) {
+ Constant* Cl = getNativeClass(VT->display[i]);
+ if (Cl->getType() != JnjvmModule::JavaCommonClassType)
+ Cl = ConstantExpr::getGetElementPtr(Cl, ClGEPs, 2);
+
+ TempElmts.push_back(Cl);
+ }
+
+ Constant* display = ConstantArray::get(DTy, TempElmts);
+ TempElmts.clear();
+ display = new GlobalVariable(DTy, true, GlobalValue::InternalLinkage,
+ display, "", getLLVMModule());
+
+ display = ConstantExpr::getCast(Instruction::BitCast, display, PTy);
+
+ Elemts.push_back(display);
+
+
+ // methods
+ for (uint32 i = JavaVirtualTable::getFirstJavaMethodIndex(); i < size; ++i) {
+ JavaMethod* meth = ((JavaMethod**)RealVT)[i];
LLVMMethodInfo* LMI = getMethodInfo(meth);
Function* F = LMI->getMethod();
if (isAbstract(meth->access)) {
@@ -1231,18 +1271,7 @@
generateStubs = true;
assumeCompiled = false;
- const Type* ATy = JnjvmModule::VTType->getContainedType(0);
- PrimitiveArrayVT = new GlobalVariable(ATy, true,
- GlobalValue::ExternalLinkage,
- 0, "JavaArrayVT", getLLVMModule());
-
- ReferenceArrayVT = new GlobalVariable(ATy, true,
- GlobalValue::ExternalLinkage,
- 0, "ArrayObjectVT", getLLVMModule());
-
-
-
- ATy = JnjvmModule::JavaClassArrayType->getContainedType(0);
+ const Type* ATy = JnjvmModule::JavaClassArrayType->getContainedType(0);
GlobalVariable* varGV = 0;
#define PRIMITIVE_ARRAY(name) \
@@ -1444,7 +1473,11 @@
JavaMethod& meth = cl->virtualMethods[i];
((void**)VT)[meth.offset] = &meth;
}
- if (!cl->super) ((void**)VT)[0] = 0;
+
+ if (!cl->super) {
+ VT->destructor = 0;
+ ClassArray::initialiseVT();
+ }
#endif
}
Modified: vmkit/trunk/lib/JnJVM/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/JavaJIT.cpp?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JavaJIT.cpp Fri Apr 10 08:05:01 2009
@@ -1564,9 +1564,16 @@
Value* Size = 0;
if (cl) {
- VT = TheCompiler->getVirtualTable(cl);
+ VT = TheCompiler->getVirtualTable(cl->virtualVT);
LLVMClassInfo* LCI = TheCompiler->getClassInfo(cl);
Size = LCI->getVirtualSize();
+
+ bool needsCheck = needsInitialisationCheck(cl, compilingClass);
+ if (needsCheck) {
+ Cl = invoke(module->ForceInitialisationCheckFunction, Cl, "",
+ currentBlock);
+ }
+
} else {
VT = CallInst::Create(module->GetVTFromClassFunction, Cl, "",
currentBlock);
@@ -1577,15 +1584,6 @@
Value* val = invoke(module->JavaObjectAllocateFunction, Size, VT, "",
currentBlock);
- // Set the class
-
- Value* gep[2] = { module->constantZero,
- module->JavaObjectClassOffsetConstant };
- Value* GEP = GetElementPtrInst::Create(val, gep, gep + 2, "",
- currentBlock);
- Cl = new BitCastInst(Cl, module->JavaCommonClassType, "", currentBlock);
- new StoreInst(Cl, GEP, currentBlock);
-
push(val, false);
}
Modified: vmkit/trunk/lib/JnJVM/Compiler/JavaJITCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/JavaJITCompiler.cpp?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JavaJITCompiler.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JavaJITCompiler.cpp Fri Apr 10 08:05:01 2009
@@ -27,8 +27,8 @@
using namespace jnjvm;
using namespace llvm;
-extern void* JavaArrayVT[];
-extern void* ArrayObjectVT[];
+extern JavaVirtualTable JavaArrayVT;
+extern JavaVirtualTable ArrayObjectVT;
Constant* JavaJITCompiler::getNativeClass(CommonClass* classDef) {
const llvm::Type* Ty = classDef->isClass() ? JnjvmModule::JavaClassType :
@@ -103,13 +103,13 @@
return ConstantExpr::getIntToPtr(CI, JnjvmModule::ptrType);
}
-Constant* JavaJITCompiler::getVirtualTable(Class* classDef) {
- LLVMClassInfo* LCI = getClassInfo((Class*)classDef);
- LCI->getVirtualType();
+Constant* JavaJITCompiler::getVirtualTable(JavaVirtualTable* VT) {
+ if (VT->cl->isClass()) {
+ LLVMClassInfo* LCI = getClassInfo(VT->cl->asClass());
+ LCI->getVirtualType();
+ }
- assert(classDef->virtualVT && "Virtual VT not created");
- void* ptr = classDef->virtualVT;
- ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64_t(ptr));
+ ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64_t(VT));
return ConstantExpr::getIntToPtr(CI, JnjvmModule::VTType);
}
@@ -126,12 +126,6 @@
JavaJITCompiler::JavaJITCompiler(const std::string &ModuleID) :
JavaLLVMCompiler(ModuleID) {
- ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64(JavaArrayVT));
- PrimitiveArrayVT = ConstantExpr::getIntToPtr(CI, JnjvmModule::VTType);
-
- CI = ConstantInt::get(Type::Int64Ty, uint64(ArrayObjectVT));
- ReferenceArrayVT = ConstantExpr::getIntToPtr(CI, JnjvmModule::VTType);
-
TheModuleProvider = new JnjvmModuleProvider(TheModule);
addJavaPasses();
}
@@ -147,7 +141,7 @@
internalMakeVT(cl);
#ifndef WITHOUT_VTABLE
- VirtualTable* VT = cl->virtualVT;
+ JavaVirtualTable* VT = cl->virtualVT;
assert(VT);
// Fill the virtual table with function pointers.
@@ -161,25 +155,26 @@
// if there is none, or if it is empty.
if (meth.offset == 0) {
#if defined(ISOLATE_SHARING) || defined(USE_GC_BOEHM)
- ((void**)VT)[0] = 0;
+ VT->destructor = 0;
#else
Function* func = parseFunction(&meth);
if (!cl->super) {
meth.canBeInlined = true;
- ((void**)VT)[0] = 0;
+ VT->destructor = 0;
} else {
Function::iterator BB = func->begin();
BasicBlock::iterator I = BB->begin();
if (isa<ReturnInst>(I)) {
- ((void**)VT)[0] = 0;
+ VT->destructor = 0;
} else {
// LLVM does not allow recursive compilation. Create the code now.
- ((void**)VT)[0] = EE->getPointerToFunction(func);
+ VT->destructor = (uintptr_t)EE->getPointerToFunction(func);
}
}
#endif
} else {
- ((void**)VT)[meth.offset] = EE->getPointerToFunctionOrStub(func);
+ VT->getFunctions()[meth.offset] =
+ (uintptr_t)EE->getPointerToFunctionOrStub(func);
}
}
@@ -187,14 +182,14 @@
Function* func = makeTracer(cl, false);
void* codePtr = mvm::MvmModule::executionEngine->getPointerToFunction(func);
- ((void**)VT)[VT_TRACER_OFFSET] = codePtr;
+ VT->tracer = (uintptr_t)codePtr;
func->deleteBody();
#endif
// If there is no super, then it's the first VT that we allocate. Assign
// this VT to native types.
if (!(cl->super)) {
- ClassArray::initialiseVT(cl);
+ ClassArray::initialiseVT();
}
#endif
}
Modified: vmkit/trunk/lib/JnJVM/Compiler/JavaJITOpcodes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/JavaJITOpcodes.cpp?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JavaJITOpcodes.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JavaJITOpcodes.cpp Fri Apr 10 08:05:01 2009
@@ -1861,7 +1861,7 @@
LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[charId];
sizeElement = LAI.sizeInBytesConstant;
- TheVT = TheCompiler->getPrimitiveArrayVT();
+ TheVT = TheCompiler->getVirtualTable(dcl->virtualVT);
} else {
uint16 index = readU2(bytecodes, i);
CommonClass* cl = 0;
@@ -1886,17 +1886,21 @@
valCl = new BitCastInst(valCl, module->JavaCommonClassType, "",
currentBlock);
}
+ TheVT = TheCompiler->getVirtualTable(dcl->virtualVT);
} else {
const llvm::Type* Ty =
- PointerType::getUnqual(module->JavaCommonClassType);
+ PointerType::getUnqual(module->JavaClassArrayType);
Value* args[2]= { valCl, Constant::getNullValue(Ty) };
valCl = CallInst::Create(module->GetArrayClassFunction, args,
args + 2, "", currentBlock);
+ TheVT = CallInst::Create(module->GetVTFromClassArrayFunction, valCl, "",
+ currentBlock);
+ valCl = new BitCastInst(valCl, module->JavaCommonClassType, "",
+ currentBlock);
}
sizeElement = module->constantPtrSize;
- TheVT = TheCompiler->getReferenceArrayVT();
}
Value* arg1 = popAsInt();
@@ -1944,12 +1948,6 @@
arg1 = new IntToPtrInst(arg1, module->ptrType, "", currentBlock);
new StoreInst(arg1, GEP, currentBlock);
- // Set the class
- Value* gep[2] = { module->constantZero,
- module->JavaObjectClassOffsetConstant };
- GEP = GetElementPtrInst::Create(res, gep, gep + 2, "", currentBlock);
- new StoreInst(valCl, GEP, currentBlock);
-
push(res, false);
break;
Modified: vmkit/trunk/lib/JnJVM/Compiler/JnjvmModule.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/JnjvmModule.cpp?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JnjvmModule.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JnjvmModule.cpp Fri Apr 10 08:05:01 2009
@@ -29,7 +29,7 @@
using namespace llvm;
-extern void* JavaObjectVT[];
+extern JavaVirtualTable JavaObjectVT;
#ifdef WITH_TRACER
const llvm::FunctionType* JnjvmModule::MarkAndTraceType = 0;
@@ -65,6 +65,7 @@
llvm::Constant* JnjvmModule::JavaArraySizeConstant;
llvm::ConstantInt* JnjvmModule::OffsetObjectSizeInClassConstant;
llvm::ConstantInt* JnjvmModule::OffsetVTInClassConstant;
+llvm::ConstantInt* JnjvmModule::OffsetVTInClassArrayConstant;
llvm::ConstantInt* JnjvmModule::OffsetDepthInClassConstant;
llvm::ConstantInt* JnjvmModule::OffsetDisplayInClassConstant;
llvm::ConstantInt* JnjvmModule::OffsetTaskClassMirrorInClassConstant;
@@ -82,7 +83,10 @@
llvm::ConstantInt* JnjvmModule::JavaArrayElementsOffsetConstant;
llvm::ConstantInt* JnjvmModule::JavaArraySizeOffsetConstant;
llvm::ConstantInt* JnjvmModule::JavaObjectLockOffsetConstant;
-llvm::ConstantInt* JnjvmModule::JavaObjectClassOffsetConstant;
+llvm::ConstantInt* JnjvmModule::JavaObjectVTOffsetConstant;
+llvm::ConstantInt* JnjvmModule::OffsetClassInVTConstant;
+llvm::ConstantInt* JnjvmModule::OffsetDepthInVTConstant;
+llvm::ConstantInt* JnjvmModule::OffsetDisplayInVTConstant;
JavaLLVMCompiler::JavaLLVMCompiler(const std::string& str) :
@@ -114,18 +118,22 @@
}
}
- VirtualTable* VT = 0;
+ JavaVirtualTable* VT = 0;
if (cl->super) {
- uint64 size = cl->virtualTableSize;
+ uint32 size = cl->virtualTableSize;
mvm::BumpPtrAllocator& allocator = cl->classLoader->allocator;
- VT = (VirtualTable*)allocator.Allocate(size * sizeof(void*));
- Class* super = (Class*)cl->super;
- assert(cl->virtualTableSize >= cl->super->virtualTableSize &&
+ Class* super = cl->super;
+ assert(cl->virtualTableSize >= super->virtualTableSize &&
"Super VT bigger than own VT");
assert(super->virtualVT && "Super does not have a VT!");
- memcpy(VT, super->virtualVT, cl->super->virtualTableSize * sizeof(void*));
+ VT = new(allocator, size) JavaVirtualTable(cl);
} else {
- VT = (VirtualTable*)JavaObjectVT;
+ VT = &JavaObjectVT;
+ VT->depth = 0;
+ VT->display = (CommonClass**)
+ cl->classLoader->allocator.Allocate(sizeof(CommonClass*));
+ VT->display[0] = cl;
+
}
cl->virtualVT = VT;
@@ -220,10 +228,10 @@
void JavaLLVMCompiler::internalMakeVT(Class* cl) {
- VirtualTable* VT = 0;
+ JavaVirtualTable* VT = 0;
#ifdef WITHOUT_VTABLE
mvm::BumpPtrAllocator& allocator = cl->classLoader->allocator;
- VT = (VirtualTable*)allocator.Allocate(VT_SIZE);
+ VT = (JavaVirtualTable*)allocator.Allocate(VT_SIZE);
memcpy(VT, JavaObjectVT, VT_SIZE);
cl->virtualVT = VT;
#else
@@ -234,7 +242,7 @@
cl->virtualTableSize = cl->super->virtualTableSize;
} else {
- cl->virtualTableSize = VT_NB_FUNCS;
+ cl->virtualTableSize = JavaVirtualTable::getFirstJavaMethodIndex();
}
// Allocate the virtual table.
@@ -344,14 +352,18 @@
JavaArrayElementsOffsetConstant = mvm::MvmModule::constantTwo;
JavaArraySizeOffsetConstant = mvm::MvmModule::constantOne;
- JavaObjectLockOffsetConstant = mvm::MvmModule::constantTwo;
- JavaObjectClassOffsetConstant = mvm::MvmModule::constantOne;
+ JavaObjectLockOffsetConstant = mvm::MvmModule::constantOne;
+ JavaObjectVTOffsetConstant = mvm::MvmModule::constantZero;
+ OffsetClassInVTConstant = mvm::MvmModule::constantThree;
+ OffsetDepthInVTConstant = mvm::MvmModule::constantFour;
+ OffsetDisplayInVTConstant = mvm::MvmModule::constantFive;
OffsetDisplayInClassConstant = mvm::MvmModule::constantZero;
OffsetDepthInClassConstant = mvm::MvmModule::constantOne;
OffsetObjectSizeInClassConstant = mvm::MvmModule::constantOne;
OffsetVTInClassConstant = mvm::MvmModule::constantTwo;
+ OffsetVTInClassArrayConstant = mvm::MvmModule::constantTwo;
OffsetTaskClassMirrorInClassConstant = mvm::MvmModule::constantThree;
OffsetStaticInstanceInTaskClassMirrorConstant = mvm::MvmModule::constantTwo;
OffsetStatusInTaskClassMirrorConstant = mvm::MvmModule::constantZero;
@@ -365,14 +377,6 @@
LLVMAssessorInfo::initialise();
}
-Constant* JavaLLVMCompiler::getReferenceArrayVT() {
- return ReferenceArrayVT;
-}
-
-Constant* JavaLLVMCompiler::getPrimitiveArrayVT() {
- return PrimitiveArrayVT;
-}
-
Function* JavaLLVMCompiler::getMethod(JavaMethod* meth) {
return getMethodInfo(meth)->getMethod();
}
@@ -417,6 +421,7 @@
GetClassFunction = module->getFunction("getClass");
ClassLookupFunction = module->getFunction("classLookup");
GetVTFromClassFunction = module->getFunction("getVTFromClass");
+ GetVTFromClassArrayFunction = module->getFunction("getVTFromClassArray");
GetObjectSizeFromClassFunction =
module->getFunction("getObjectSizeFromClass");
Modified: vmkit/trunk/lib/JnJVM/Compiler/LowerConstantCalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/LowerConstantCalls.cpp?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/LowerConstantCalls.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/LowerConstantCalls.cpp Fri Apr 10 08:05:01 2009
@@ -177,10 +177,18 @@
Changed = true;
Value* val = Call.getArgument(0); // get the object
Value* args2[2] = { module->constantZero,
- module->JavaObjectClassOffsetConstant };
- Value* classPtr = GetElementPtrInst::Create(val, args2, args2 + 2,
- "", CI);
- Value* cl = new LoadInst(classPtr, "", CI);
+ module->JavaObjectVTOffsetConstant };
+ Value* VTPtr = GetElementPtrInst::Create(val, args2, args2 + 2,
+ "", CI);
+ Value* VT = new LoadInst(VTPtr, "", CI);
+ Value* args3[2] = { module->constantZero,
+ module->OffsetClassInVTConstant };
+
+ Value* clPtr = GetElementPtrInst::Create(VT, args3, args3 + 2,
+ "", CI);
+ Value* cl = new LoadInst(clPtr, "", CI);
+ cl = new BitCastInst(cl, module->JavaCommonClassType, "", CI);
+
CI->replaceAllUsesWith(cl);
CI->eraseFromParent();
} else if (V == module->GetVTFromClassFunction) {
@@ -194,6 +202,17 @@
Value* VT = new LoadInst(VTPtr, "", CI);
CI->replaceAllUsesWith(VT);
CI->eraseFromParent();
+ } else if (V == module->GetVTFromClassArrayFunction) {
+ Changed = true;
+
+ Value* val = Call.getArgument(0);
+ Value* indexes[2] = { module->constantZero,
+ module->OffsetVTInClassArrayConstant };
+ Value* VTPtr = GetElementPtrInst::Create(val, indexes, indexes + 2,
+ "", CI);
+ Value* VT = new LoadInst(VTPtr, "", CI);
+ CI->replaceAllUsesWith(VT);
+ CI->eraseFromParent();
} else if (V == module->GetObjectSizeFromClassFunction) {
Changed = true;
@@ -432,9 +451,9 @@
I->getParent()->getTerminator()->eraseFromParent();
Constant* init =
- Constant::getNullValue(module->JavaCommonClassType);
+ Constant::getNullValue(module->JavaClassArrayType);
GlobalVariable* GV =
- new GlobalVariable(module->JavaCommonClassType, false,
+ new GlobalVariable(module->JavaClassArrayType, false,
GlobalValue::ExternalLinkage,
init, "", TheCompiler->getLLVMModule());
@@ -444,7 +463,7 @@
BasicBlock* OKBlock = BasicBlock::Create("", &F);
BasicBlock* NotOKBlock = BasicBlock::Create("", &F);
- PHINode* node = PHINode::Create(module->JavaCommonClassType, "",
+ PHINode* node = PHINode::Create(module->JavaClassArrayType, "",
OKBlock);
node->addIncoming(LoadedGV, CI->getParent());
Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll (original)
+++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll Fri Apr 10 08:05:01 2009
@@ -5,8 +5,8 @@
;;; A virtual table is an array of function pointers.
%VT = type [0 x i32 (...)*]
-;;; The root of all Java Objects: a VT, a class and a lock.
-%JavaObject = type { %VT*, %JavaCommonClass*, i8* }
+;;; The root of all Java Objects: a VT and a lock.
+%JavaObject = type { %VT*, i8* }
;;; Types for Java arrays. A size of 0 means an undefined size.
%JavaArray = type { %JavaObject, i8* }
@@ -61,7 +61,7 @@
%UTF8*, %UTF8*, i8, i8*, i32, i8* }
%JavaClassPrimitive = type { %JavaCommonClass, i32 }
-%JavaClassArray = type { %JavaCommonClass, %JavaCommonClass* }
+%JavaClassArray = type { %JavaCommonClass, %JavaCommonClass*, %VT* }
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;; Constant calls for Jnjvm runtime internal objects field accesses ;;;;;;;;;
@@ -85,6 +85,10 @@
;;; getVTFromClass - Get the VT of a class from its runtime representation.
declare %VT* @getVTFromClass(%JavaClass*) readnone
+;;; getVTFromClassArray - Get the VT of an array class from its runtime
+;;; representation.
+declare %VT* @getVTFromClassArray(%JavaClassArray*) readnone
+
;;; getObjectSizeFromClass - Get the size of a class from its runtime
;;; representation.
declare i32 @getObjectSizeFromClass(%JavaClass*) readnone
@@ -188,8 +192,8 @@
declare %JavaObject* @jnjvmRuntimeDelegatee(%JavaCommonClass*) readnone
;;; getArrayClass - Get the array user class of the user class.
-declare %JavaCommonClass* @getArrayClass(%JavaCommonClass*,
- %JavaCommonClass**) readnone
+declare %JavaClassArray* @getArrayClass(%JavaCommonClass*,
+ %JavaClassArray**) readnone
declare i8 @getFinalInt8Field(i8*) readnone
declare i16 @getFinalInt16Field(i16*) readnone
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Fri Apr 10 08:05:01 2009
@@ -40,8 +40,10 @@
Class* ClassArray::SuperArray;
Class** ClassArray::InterfacesArray;
-extern void* JavaArrayVT[];
-extern void* ArrayObjectVT[];
+extern JavaVirtualTable JavaObjectVT;
+
+extern "C" void JavaArrayTracer(JavaObject*);
+extern "C" void ArrayObjectTracer(JavaObject*);
Attribut::Attribut(const UTF8* name, uint32 length,
uint32 offset) {
@@ -255,7 +257,7 @@
}
}
-CommonClass::CommonClass(JnjvmClassLoader* loader, const UTF8* n) {
+void CommonClass::init(JnjvmClassLoader* loader, const UTF8* n) {
name = n;
classLoader = loader;
nbInterfaces = 0;
@@ -302,13 +304,17 @@
memset(IsolateInfo, 0, sizeof(TaskClassMirror) * NR_ISOLATES);
}
-ClassArray::ClassArray(JnjvmClassLoader* loader, const UTF8* n,
- UserCommonClass* base) :
- CommonClass(loader, n) {
+void ClassArray::init(JnjvmClassLoader* loader, const UTF8* n,
+ UserCommonClass* base) {
_baseClass = base;
super = ClassArray::SuperArray;
interfaces = ClassArray::InterfacesArray;
nbInterfaces = 2;
+
+ uint32 size = JavaVirtualTable::getNumMethods();
+ virtualVT = new(loader->allocator, size) JavaVirtualTable(this);
+ virtualVT->tracer = (uintptr_t)ArrayObjectTracer;
+
depth = 1;
display = (CommonClass**)loader->allocator.Allocate(2 * sizeof(CommonClass*));
display[0] = ClassArray::SuperArray;
@@ -330,8 +336,7 @@
uint32 primSize = cl->isPrimitive() ?
cl->asPrimitiveClass()->primSize : sizeof(JavaObject*);
- VirtualTable* VT = (VirtualTable*)
- (cl->isPrimitive() ? JavaArrayVT : ArrayObjectVT);
+ VirtualTable* VT = virtualVT;
uint32 size = sizeof(JavaObject) + sizeof(ssize_t) + n * primSize;
JavaArray* res = (JavaArray*)allocator.allocateManagedObject(size, VT);
res->initialise(this);
@@ -344,8 +349,7 @@
uint32 primSize = cl->isPrimitive() ?
cl->asPrimitiveClass()->primSize : sizeof(JavaObject*);
- VirtualTable* VT = (VirtualTable*)
- (cl->isPrimitive() ? JavaArrayVT : ArrayObjectVT);
+ VirtualTable* VT = virtualVT;
uint32 size = sizeof(JavaObject) + sizeof(ssize_t) + n * primSize;
JavaArray* res = (JavaArray*)allocator.Allocate(size);
@@ -537,6 +541,7 @@
assert((this->isInitializing() ||
classLoader->getCompiler()->isStaticCompiling())
&& "Uninitialized class when allocating.");
+ assert(getVirtualVT() && "No VT\n");
JavaObject* res =
(JavaObject*)vm->gcAllocator.allocateManagedObject(getVirtualSize(),
getVirtualVT());
@@ -1257,15 +1262,75 @@
}
-void ClassArray::initialiseVT(Class* cl) {
- uint32 size = (cl->virtualTableSize - VT_NB_FUNCS) * sizeof(void*);
-
- #define COPY(CLASS) \
- memcpy((void*)((uintptr_t)CLASS + VT_SIZE), \
- (void*)((uintptr_t)cl->virtualVT + VT_SIZE), size);
+void ClassArray::initialiseVT() {
+
+ Class* cl = ClassArray::SuperArray;
+ assert(cl && "Initializing array VT without a super for arrays");
+ assert(cl->virtualVT->init && "Initializing array VT before JavaObjectVT");
+
+ // Set the values in the JavaObject VT
+ cl->virtualVT->depth = 0;
+ cl->virtualVT->cl = cl;
+ cl->virtualVT->display = cl->display;
+
+ Classpath* upcalls = cl->classLoader->bootstrapLoader->upcalls;
- COPY(JavaArrayVT)
- COPY(ArrayObjectVT)
+ #define COPY(CLASS) \
+ memcpy(CLASS->virtualVT->getFirstJavaMethod(), \
+ cl->virtualVT->getFirstJavaMethod(), \
+ sizeof(uintptr_t) * JavaVirtualTable::getNumJavaMethods()); \
+ CLASS->super = cl; \
+ CLASS->display[0] = cl; \
+ CLASS->display[1] = CLASS;
+
+ COPY(upcalls->ArrayOfBool)
+ COPY(upcalls->ArrayOfByte)
+ COPY(upcalls->ArrayOfChar)
+ COPY(upcalls->ArrayOfShort)
+ COPY(upcalls->ArrayOfInt)
+ COPY(upcalls->ArrayOfFloat)
+ COPY(upcalls->ArrayOfDouble)
+ COPY(upcalls->ArrayOfLong)
+ COPY(upcalls->ArrayOfObject)
+ COPY(upcalls->ArrayOfString)
#undef COPY
+
+}
+
+JavaVirtualTable::JavaVirtualTable(Class* C) {
+
+ // (1) Copy the super VT into the current VT.
+ uint32 size = C->super->virtualTableSize * sizeof(uintptr_t);
+ memcpy(this, C->super->virtualVT, size);
+
+ // (2) Set the class of this VT.
+ cl = C;
+
+ // (3) Set depth and display for fast dynamic type checking.
+ depth = cl->super->virtualVT->depth + 1;
+ mvm::BumpPtrAllocator& allocator = cl->classLoader->allocator;
+ display = (CommonClass**)
+ allocator.Allocate(sizeof(CommonClass*) * (depth + 1));
+ size = depth * sizeof(UserCommonClass*);
+ memcpy(display, cl->super->virtualVT->display, size);
+ display[depth] = C;
}
+
+JavaVirtualTable::JavaVirtualTable(ClassArray* C) {
+
+ // (1) Copy the super VT into the current VT.
+ uint32 size = getNumMethods() * sizeof(uintptr_t);
+ memcpy(this, &JavaObjectVT, size);
+
+ // (2) Set the class of this VT.
+ cl = C;
+
+ // (3) Set depth and display for fast dynamic type checking.
+ depth = 1;
+ mvm::BumpPtrAllocator& allocator = cl->classLoader->allocator;
+ display = (CommonClass**)allocator.Allocate(sizeof(CommonClass*) * 2);
+ display[0] = C->super;
+ display[1] = C;
+}
+
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Fri Apr 10 08:05:01 2009
@@ -37,6 +37,7 @@
class JavaField;
class JavaMethod;
class JavaObject;
+class JavaVirtualTable;
class Reader;
class Signdef;
class Typedef;
@@ -114,7 +115,6 @@
};
-
/// TaskClassMirror - The isolate specific class information: the initialization
/// state and the static instance. In a non-isolate environment, there is only
/// one instance of a TaskClassMirror per Class.
@@ -305,7 +305,9 @@
/// CommonClass - Create a class with th given name.
///
- CommonClass(JnjvmClassLoader* loader, const UTF8* name);
+ CommonClass(JnjvmClassLoader* loader, const UTF8* name) {
+ init(loader, name);
+ }
/// ~CommonClass - Free memory used by this class, and remove it from
/// metadata.
@@ -316,19 +318,16 @@
///
CommonClass();
+ /// init - initialize the class.
+ ///
+ void init(JnjvmClassLoader* JCL, const UTF8* n);
+
/// setInterfaces - Set the interfaces of the class.
///
void setInterfaces(Class** I) {
interfaces = I;
}
-
- /// setSuper - Set the super of the class.
- ///
- void setSuper(Class* S) {
- super = S;
- display[0] = (CommonClass*)S;
- }
-
+
/// toPrimitive - Returns the primitive class which represents
/// this class, ie void for java/lang/Void.
///
@@ -367,6 +366,7 @@
return GC_MALLOC(sz);
}
#endif
+
};
/// ClassPrimitive - This class represents internal classes for primitive
@@ -447,7 +447,7 @@
/// virtualVT - The virtual table of instances of this class.
///
- VirtualTable* virtualVT;
+ JavaVirtualTable* virtualVT;
/// IsolateInfo - Per isolate informations for static instances and
/// initialization state.
@@ -553,7 +553,7 @@
/// getVirtualVT - Get the virtual VT of instances of this class.
///
- VirtualTable* getVirtualVT() { return virtualVT; }
+ JavaVirtualTable* getVirtualVT() { return virtualVT; }
/// getOwnerClass - Get the thread that is currently initializing the class.
///
@@ -897,6 +897,10 @@
///
CommonClass* _baseClass;
+ /// virtualVT - The virtual table of this array class.
+ ///
+ JavaVirtualTable* virtualVT;
+
/// baseClass - Get the base class of this array class.
///
CommonClass* baseClass() const {
@@ -906,15 +910,22 @@
/// doNew - Allocate a new array in the given vm.
///
JavaArray* doNew(sint32 n, Jnjvm* vm);
-
- /// ClassArray - Empty constructor for VT.
+
+ /// init - Initialize the array class.
+ ///
+ void init(JnjvmClassLoader* loader, const UTF8* name,
+ UserCommonClass* baseClass);
+
+ /// ClassArray - Empty constructor.
///
ClassArray() {}
/// ClassArray - Construct a Java array class with the given name.
///
ClassArray(JnjvmClassLoader* loader, const UTF8* name,
- UserCommonClass* baseClass);
+ UserCommonClass* baseClass) : CommonClass (loader, name) {
+ init(loader, name, baseClass);
+ }
/// SuperArray - The super of class arrays. Namely java/lang/Object.
///
@@ -927,7 +938,8 @@
/// initialiseVT - Initialise the primitive and reference array VT.
/// super is the java/lang/Object class.
///
- static void initialiseVT(Class* super);
+ static void initialiseVT();
+
};
/// JavaMethod - This class represents Java methods.
@@ -1317,6 +1329,53 @@
};
+class JavaVirtualTable : public VirtualTable {
+public:
+ CommonClass* cl;
+ size_t depth;
+ CommonClass** display;
+
+ uintptr_t init;
+ uintptr_t equals;
+ uintptr_t hashCode;
+ uintptr_t toString;
+ uintptr_t clone;
+ uintptr_t getClass;
+ uintptr_t notify;
+ uintptr_t notifyAll;
+ uintptr_t waitIndefinitely;
+ uintptr_t waitMs;
+ uintptr_t waitMsNs;
+
+ void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator,
+ uint32 nbMethods) {
+ return allocator.Allocate(sizeof(uintptr_t) * (nbMethods));
+ }
+
+ JavaVirtualTable(Class* C);
+
+ JavaVirtualTable(ClassArray* C);
+
+ JavaVirtualTable() {}
+
+ uintptr_t* getFirstJavaMethod() {
+ return &init;
+ }
+
+ static uint32_t getFirstJavaMethodIndex() {
+ return 6;
+ }
+
+ static uint32_t getNumMethods() {
+ return 17;
+ }
+
+ static uint32_t getNumJavaMethods() {
+ return 11;
+ }
+
+};
+
} // end namespace jnjvm
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Fri Apr 10 08:05:01 2009
@@ -10,6 +10,7 @@
#include "mvm/VirtualMachine.h"
#include "JavaArray.h"
+#include "JavaClass.h"
#include "JavaObject.h"
#include "Jnjvm.h"
#include "JnjvmClassLoader.h"
@@ -22,9 +23,7 @@
using namespace jnjvm;
-void* JavaArrayVT[12 + VT_SIZE];
-void* ArrayObjectVT[12 + VT_SIZE];
-void* JavaObjectVT[12 + VT_SIZE];
+JavaVirtualTable JavaObjectVT;
static void initialiseVT() {
@@ -47,12 +46,10 @@
#define INIT(X) { \
X fake; \
void* V = ((void**)(void*)(&fake))[0]; \
- memcpy(X##VT, V, VT_SIZE); \
- ((void**)X##VT)[0] = 0; }
+ memcpy(&(X##VT), V, sizeof(VirtualTable)); \
+ X##VT.destructor = 0; }
INIT(JavaObject);
- INIT(JavaArray);
- INIT(ArrayObject);
#undef INIT
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp Fri Apr 10 08:05:01 2009
@@ -75,17 +75,6 @@
return res;
}
-extern "C" void printJavaObject(const JavaObject* obj, mvm::PrintBuffer* buf) {
- buf->write("JavaObject<");
- CommonClass::printClassName(obj->getClass()->getName(), buf);
- buf->write(">");
-}
-
-void JavaObject::print(mvm::PrintBuffer* buf) const {
- printJavaObject(this, buf);
-}
-
-
void JavaObject::waitIntern(struct timeval* info, bool timed) {
if (owner()) {
@@ -164,7 +153,7 @@
JavaObject* obj = this;
if (!signature->isPrimitive()) {
- if (obj && !(obj->classOf->isOfTypeName(vm, signature->getName()))) {
+ if (obj && !(obj->getClass()->isOfTypeName(vm, signature->getName()))) {
vm->illegalArgumentException("wrong type argument");
}
((JavaObject**)buf)[0] = obj;
@@ -173,7 +162,7 @@
} else if (obj == 0) {
vm->illegalArgumentException("");
} else {
- UserCommonClass* cl = obj->classOf;
+ UserCommonClass* cl = obj->getClass();
UserClassPrimitive* value = cl->toPrimitive(vm);
PrimitiveTypedef* prim = (PrimitiveTypedef*)signature;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h Fri Apr 10 08:05:01 2009
@@ -57,7 +57,7 @@
/// LockObj - This class represents a Java monitor.
///
-class LockObj : public mvm::Object {
+class LockObj : public gc {
friend class JavaObject;
private:
@@ -105,6 +105,8 @@
return &varcond;
}
+ /// VT - LockObj is GC-allocated, so we must make the VT explicit.
+ ///
static VirtualTable* VT;
~LockObj() {}
@@ -114,26 +116,21 @@
/// JavaObject - This class represents a Java object.
///
-class JavaObject : public mvm::Object {
+class JavaObject : public gc {
private:
/// waitIntern - internal wait on a monitor
///
void waitIntern(struct timeval *info, bool timed);
- /// classOf - The class of this object.
- ///
- UserCommonClass* classOf;
-
public:
/// getClass - Returns the class of this object.
///
UserCommonClass* getClass() const {
- return classOf;
+ return ((JavaVirtualTable*)getVirtualTable())->cl;
}
-
/// lock - The monitor of this object. Most of the time null.
///
mvm::ThinLock<LockObj, JavaObject> lock;
@@ -157,7 +154,7 @@
///
void notifyAll();
- /// overflowThinLokc - Notify that the thin lock has overflowed.
+ /// overflowThinLock - Notify that the thin lock has overflowed.
///
void overflowThinLock() {
lock.overflowThinLock();
@@ -166,14 +163,13 @@
/// initialise - Initialises the object.
///
void initialise(UserCommonClass* cl) {
- this->classOf = cl;
}
/// instanceOf - Is this object's class of type the given class?
///
bool instanceOf(UserCommonClass* cl) {
if (!this) return false;
- else return this->classOf->isAssignableFrom(cl);
+ else return this->getClass()->isAssignableFrom(cl);
}
/// acquire - Acquire the lock on this object.
@@ -199,7 +195,6 @@
if (obj == 0) JavaThread::get()->getJVM()->nullPointerException("");
#endif
- virtual void print(mvm::PrintBuffer* buf) const;
virtual void TRACER;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Fri Apr 10 08:05:01 2009
@@ -17,15 +17,16 @@
using namespace jnjvm;
-VirtualTable* JavaString::internStringVT = 0;
+JavaVirtualTable* JavaString::internStringVT = 0;
JavaString* JavaString::stringDup(const UTF8*& utf8, Jnjvm* vm) {
UserClass* cl = vm->upcalls->newString;
JavaString* res = (JavaString*)cl->doNew(vm);
// It's a hashed string, set the destructor so that the string
- // removes itself from the vm string map.
- res->setVirtualTable(internStringVT);
+ // removes itself from the vm string map. Do this ony if
+ // internStringVT exists (in case of AOT).
+ if (internStringVT) res->setVirtualTable(internStringVT);
// No need to call the Java function: both the Java function and
// this function do the same thing.
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.h?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaString.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.h Fri Apr 10 08:05:01 2009
@@ -16,7 +16,6 @@
namespace jnjvm {
-class ArrayUInt16;
class Jnjvm;
class JavaString : public JavaObject {
@@ -33,7 +32,7 @@
char* strToAsciiz();
const UTF8* strToUTF8(Jnjvm* vm);
- static VirtualTable* internStringVT;
+ static JavaVirtualTable* internStringVT;
};
} // end namespace jnjvm
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Fri Apr 10 08:05:01 2009
@@ -95,8 +95,8 @@
} else if (cl == upcalls->newMethod) {
return (jmethodID)((JavaObjectConstructor*)meth)->getInternalMethod();
} else {
- vm->unknownError("%s is not a constructor or a method",
- meth->printString());
+ vm->unknownError("Not a constructor or a method: %s",
+ meth->getClass()->printString());
}
END_JNI_EXCEPTION
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Fri Apr 10 08:05:01 2009
@@ -784,14 +784,17 @@
// placed in the hashmap. This VT will have its destructor set so
// that the string is removed when deallocated.
upcalls->newString->resolveClass();
- void* stringVT = ((void*)upcalls->newString->getVirtualVT());
- uint32 size = upcalls->newString->virtualTableSize * sizeof(void*);
if (!JavaString::internStringVT) {
+ JavaVirtualTable* stringVT = upcalls->newString->getVirtualVT();
+ uint32 size = upcalls->newString->virtualTableSize * sizeof(uintptr_t);
+
JavaString::internStringVT =
- (VirtualTable*)bootstrapLoader->allocator.Allocate(size);
+ (JavaVirtualTable*)bootstrapLoader->allocator.Allocate(size);
+
memcpy(JavaString::internStringVT, stringVT, size);
- ((void**)(JavaString::internStringVT))[VT_DESTRUCTOR_OFFSET] =
- (void*)(uintptr_t)JavaString::stringDestructor;
+
+ JavaString::internStringVT->destructor =
+ (uintptr_t)JavaString::stringDestructor;
}
upcalls->newString->initialiseClass(this);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Fri Apr 10 08:05:01 2009
@@ -61,6 +61,8 @@
ClassArray ArrayOfDouble;
ClassArray ArrayOfLong;
+extern "C" void JavaArrayTracer(JavaObject*);
+
typedef void (*static_init_t)(JnjvmClassLoader*);
JnjvmBootstrapLoader::JnjvmBootstrapLoader(mvm::BumpPtrAllocator& Alloc,
@@ -179,7 +181,7 @@
static_init_t init = (static_init_t)(uintptr_t)SuperArray->classLoader;
assert(init && "Loaded the wrong boot library");
init(this);
- ClassArray::initialiseVT(SuperArray);
+ ClassArray::initialiseVT();
}
}
}
@@ -193,20 +195,6 @@
}
- // Set the super of array classes.
-#define SET_PARENT(CLASS) \
- CLASS.setSuper(SuperArray); \
-
- SET_PARENT(ArrayOfBool)
- SET_PARENT(ArrayOfByte)
- SET_PARENT(ArrayOfChar)
- SET_PARENT(ArrayOfShort)
- SET_PARENT(ArrayOfInt)
- SET_PARENT(ArrayOfFloat)
- SET_PARENT(ArrayOfDouble)
- SET_PARENT(ArrayOfLong)
-#undef SET_PARENT
-
// Initialize interfaces of array classes.
InterfacesArray[0] = loadName(asciizConstructUTF8("java/lang/Cloneable"),
false, false);
@@ -632,8 +620,10 @@
JnjvmBootstrapLoader::constructPrimitiveArray(ClassArray& cl, const UTF8* name,
ClassPrimitive* baseClass) {
- cl = ClassArray(this, name, baseClass);
+ cl.CommonClass::init(this, name);
+ cl.ClassArray::init(this, name, baseClass);
classes->map.insert(std::make_pair(name, &cl));
+ cl.virtualVT->tracer = (uintptr_t)JavaArrayTracer;
return &cl;
}
Modified: vmkit/trunk/tools/llcj/LinkPaths.h.in
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/llcj/LinkPaths.h.in?rev=68779&r1=68778&r2=68779&view=diff
==============================================================================
--- vmkit/trunk/tools/llcj/LinkPaths.h.in (original)
+++ vmkit/trunk/tools/llcj/LinkPaths.h.in Fri Apr 10 08:05:01 2009
@@ -8,7 +8,7 @@
//===----------------------------------------------------------------------===//
-#define LLVMLibs "@LLVM_OBJ@"
+#define LLVMLibs "-L at LLVM_OBJ@/Release/lib"
#define VMKITLibs1 "-L at abs_top_objdir@/Release/lib"
#define VMKITLibs2 "-L at abs_top_srcdir@/Release/lib"
#define VMKITLibs3 "-L at PROJ_INSTALL_ROOT@/lib"
More information about the vmkit-commits
mailing list