[vmkit-commits] [vmkit] r55176 - in /vmkit/trunk/lib/JnJVM: LLVMRuntime/runtime-default.ll LLVMRuntime/runtime-isolate.ll VMCore/JavaConstantPool.cpp VMCore/JavaConstantPool.h VMCore/JavaJIT.cpp VMCore/JavaJIT.h VMCore/JavaRuntimeJIT.cpp VMCore/JnjvmModule.cpp VMCore/JnjvmModule.h VMCore/JnjvmModuleProvider.cpp VMCore/JnjvmModuleProvider.h
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Fri Aug 22 06:24:22 PDT 2008
Author: geoffray
Date: Fri Aug 22 08:24:20 2008
New Revision: 55176
URL: http://llvm.org/viewvc/llvm-project?rev=55176&view=rev
Log:
Do not create global variables anymore, just use the constant pool cache.
Modified:
vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll
vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll
vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h
vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h
vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h
vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.h
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=55176&r1=55175&r2=55176&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll (original)
+++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll Fri Aug 22 08:24:20 2008
@@ -96,18 +96,16 @@
;;; 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
-;;; constant pool and returns and sets in the last argument the offset.
-declare i32 @vtableLookup(%JavaObject*, %JavaClass*, i32, i32*) readnone
+;;; constant pool and returns and stores it in the constant pool cache.
+declare i32 @vtableLookup(%JavaObject*, %JavaClass*, i32) readnone
;;; newLookup - Look up a specific class. The function takes a class and an
-;;; index to lookup in the constant pool and returns and sets in the third
-;;; argument the found class. The last argument tells if the class has to be
-;;; initialized.
-declare %JavaClass* @newLookup(%JavaClass*, i32, %JavaClass**, i32) readnone
+;;; index to lookup in the constant pool and returns and stores it in the
+;;; constant pool cache.
+declare %JavaClass* @newLookup(%JavaClass*, i32) readnone
;;; fieldLookup - Look up a specific field.
-declare i8* @fieldLookup(%JavaObject*, %JavaClass*, i32, i32, i8**, i32*)
- readnone
+declare i8* @fieldLookup(%JavaObject*, %JavaClass*, i32, i32) readnone
;;; JavaObjectAquire - This function is called when starting a synchronized
;;; block or method.
Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll?rev=55176&r1=55175&r2=55176&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll (original)
+++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll Fri Aug 22 08:24:20 2008
@@ -7,4 +7,4 @@
declare %JavaObject* @getStaticInstance(%JavaClass*, i8*) readnone
;;; runtimeUTF8ToStr - Convert the UTF8 in a string.
-declare %JavaObject* @runtimeUTF8ToStr(%ArraySInt16*)
+declare %JavaObject* @stringLookup(%JavaClass*, i32)
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=55176&r1=55175&r2=55176&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Fri Aug 22 08:24:20 2008
@@ -188,6 +188,7 @@
JavaConstantPool::JavaConstantPool(Class* cl, Reader& reader) {
ctpSize = reader.readU2();
classDef = cl;
+ JInfo = 0;
ctpRes = new void*[ctpSize];
ctpDef = new sint32[ctpSize];
@@ -271,9 +272,10 @@
const UTF8* name = UTF8At(ctpDef[index]);
if (name->elements[0] == AssessorDesc::I_TAB) {
temp = loader->constructArray(name);
+ loader->resolveClass(temp, false);
} else {
// Put into ctpRes because there is only one representation of the class
- temp = loader->loadName(name, false, false, false);
+ temp = loader->loadName(name, true, false, false);
}
ctpRes[index] = temp;
}
@@ -381,8 +383,6 @@
JavaThread::get()->isolate->classFormatError(
"bad constant pool number for method at entry %d", index);
- if (ctpRes[index]) return ctpRes[index];
-
sign = resolveNameAndSign(ctpDef[index] & 0xFFFF);
sint32 entry = ctpDef[index];
sint32 ntIndex = entry & 0xFFFF;
@@ -396,17 +396,15 @@
// don't throw if no meth, the exception will be thrown just in time
JnjvmModule* M = classDef->classLoader->TheModule;
void* F = M->getMethod(meth);
- ctpRes[index] = (void*)F;
return F;
}
}
- // Must be a callback
+ // Return the callback.
void* val =
classDef->classLoader->TheModuleProvider->addCallback(classDef, index, sign,
isStatic(access));
- ctpRes[index] = val;
return val;
}
@@ -446,25 +444,29 @@
}
JavaField* JavaConstantPool::lookupField(uint32 index, bool stat) {
- if (!(ctpRes[index])) {
- sint32 entry = ctpDef[index];
- sint32 ntIndex = entry & 0xFFFF;
- Typedef* sign = (Typedef*)ctpRes[ntIndex];
- const UTF8* utf8 = UTF8At(ctpDef[ntIndex] >> 16);
- CommonClass* cl = getMethodClassIfLoaded(entry >> 16);
- if (cl && cl->status >= resolved) {
- JavaField* field = cl->lookupFieldDontThrow(utf8, sign->keyName, stat,
+ sint32 entry = ctpDef[index];
+ sint32 ntIndex = entry & 0xFFFF;
+ Typedef* sign = (Typedef*)ctpRes[ntIndex];
+ const UTF8* utf8 = UTF8At(ctpDef[ntIndex] >> 16);
+ CommonClass* cl = getMethodClassIfLoaded(entry >> 16);
+ if (cl && cl->status >= resolved) {
+ JavaField* field = cl->lookupFieldDontThrow(utf8, sign->keyName, stat,
true);
- // don't throw if no field, the exception will be thrown just in time
- if (field) {
- ctpRes[index] = field;
- return field;
+ // don't throw if no field, the exception will be thrown just in time
+ if (field) {
+ if (!stat) {
+ ctpRes[index] = (void*)field->ptrOffset;
+ }
+#ifndef MULTIPLE_VM
+ else if (cl->isReady()) {
+ JavaObject* S = field->classDef->staticInstance();
+ ctpRes[index] = (void*)((uint64)S + field->ptrOffset);
}
- } else {
- return 0;
+#endif
}
- }
- return (JavaField*)ctpRes[index];
+ return field;
+ }
+ return 0;
}
JavaString* JavaConstantPool::resolveString(const UTF8* utf8, uint16 index) {
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h?rev=55176&r1=55175&r2=55176&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h Fri Aug 22 08:24:20 2008
@@ -10,6 +10,7 @@
#ifndef JNJVM_JAVA_CONSTANT_POOL_H
#define JNJVM_JAVA_CONSTANT_POOL_H
+#include "mvm/JIT.h"
#include "mvm/Object.h"
#include "types.h"
@@ -251,6 +252,7 @@
ctpRes = 0;
ctpType = 0;
ctpDef = 0;
+ JInfo = 0;
}
/// JavaConstantPool - Reads the bytecode of the class to get
@@ -265,6 +267,18 @@
delete ctpDef;
delete ctpType;
}
+
+ mvm::JITInfo* JInfo;
+ template<typename Ty>
+ Ty *getInfo() {
+ if (!JInfo) {
+ JInfo = new Ty(this);
+ }
+
+ assert((void*)dynamic_cast<Ty*>(JInfo) == (void*)JInfo &&
+ "Invalid concrete type or multiple inheritence for getInfo");
+ return static_cast<Ty*>(JInfo);
+ }
};
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=55176&r1=55175&r2=55176&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Fri Aug 22 08:24:20 2008
@@ -80,12 +80,10 @@
LLVMMethodInfo* LMI = module->getMethodInfo(meth);
indexes2.push_back(LMI->getOffset());
} else {
- GlobalVariable* gv =
- new GlobalVariable(Type::Int32Ty, false, GlobalValue::ExternalLinkage,
- zero, "", module);
- // set is volatile
- Value* val = new LoadInst(gv, "", true, currentBlock);
+ Value* val = getConstantPoolAt(index);
+ val = new PtrToIntInst(val, Type::Int32Ty, "", currentBlock);
+
Value * cmp = new ICmpInst(ICmpInst::ICMP_NE, val, zero, "", currentBlock);
BasicBlock* ifTrue = createBasicBlock("true vtable");
BasicBlock* ifFalse = createBasicBlock("false vtable");
@@ -105,7 +103,6 @@
Args.push_back(LCI->getVar(this));
Constant* CI = ConstantInt::get(Type::Int32Ty, index);
Args.push_back(CI);
- Args.push_back(gv);
val = invoke(JnjvmModule::VirtualLookupFunction, Args, "", currentBlock);
node->addIncoming(val, currentBlock);
llvm::BranchInst::Create(endBlock, currentBlock);
@@ -1088,54 +1085,49 @@
uint8 type = ctpInfo->typeAt(index);
if (type == JavaConstantPool::ConstantString) {
- Value* toPush = 0;
- if (ctpInfo->ctpRes[index] == 0) {
- compilingClass->acquire();
- if (ctpInfo->ctpRes[index] == 0) {
- const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[index]);
- void* val = 0;
- GlobalVariable* gv = 0;
-#ifndef MULTIPLE_VM
- val = JavaThread::get()->isolate->UTF8ToStr(utf8);
- gv =
- new GlobalVariable(JnjvmModule::JavaObjectType, false,
- GlobalValue::ExternalLinkage,
- JnjvmModule::JavaObjectNullConstant, "",
- module);
-#else
- val = (void*)utf8;
- gv =
- new GlobalVariable(JnjvmModule::JavaArrayUInt16Type, false,
- GlobalValue::ExternalLinkage,
- JnjvmModule::UTF8NullConstant, "",
- module);
-#endif
-
- // TODO: put an initialiser in here
- void* ptr = mvm::jit::executionEngine->getPointerToGlobal(gv);
- GenericValue Val = GenericValue(val);
- llvm::GenericValue * Ptr = (llvm::GenericValue*)ptr;
- mvm::jit::executionEngine->StoreValueToMemory(Val, Ptr,
- JnjvmModule::JavaObjectType);
- toPush = new LoadInst(gv, "", currentBlock);
- ctpInfo->ctpRes[index] = gv;
- compilingClass->release();
- } else {
- compilingClass->release();
- toPush = new LoadInst((GlobalVariable*)ctpInfo->ctpRes[index], "",
- currentBlock);
- }
- } else {
- toPush = new LoadInst((GlobalVariable*)ctpInfo->ctpRes[index], "",
- currentBlock);
- }
#ifdef MULTIPLE_VM
- CallInst* C = llvm::CallInst::Create(JnjvmModule::RuntimeUTF8ToStrFunction,
- toPush, "", currentBlock);
- push(C, AssessorDesc::dRef);
+ // Lookup the constant pool cache
+ Constant* nil = mvm::jit::constantPtrNull;
+ Value* val = getConstantPoolAt(index);
+ Value* cmp = new ICmpInst(ICmpInst::ICMP_NE, nil, val, "", currentBlock);
+ BasicBlock* ifTrue = createBasicBlock("true string");
+ BasicBlock* ifFalse = createBasicBlock("false string");
+ BasicBlock* endBlock = createBasicBlock("end string");
+
+ PHINode * node = PHINode::Create(JnjvmModule::JavaObjectType, "", endBlock);
+ BranchInst::Create(ifTrue, ifFalse, cmp, currentBlock);
+
+ // ---------- In case we already resolved something --------------------- //
+ currentBlock = ifTrue;
+ val = new BitCastInst(val, JnjvmModule::JavaObjectType, "", currentBlock);
+ node->addIncoming(val, currentBlock);
+ BranchInst::Create(endBlock, currentBlock);
+
+ // ---------------- In case we have to resolve -------------------------- //
+ currentBlock = ifFalse;
+ LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass);
+ Value* v = LCI->getVar(this);
+ std::vector<Value*> Args;
+ Args.push_back(v);
+ Args.push_back(ConstantInt::get(Type::Int32Ty, index));
+ CallInst* C = llvm::CallInst::Create(JnjvmModule::StringLookupFunction,
+ Args.begin(), Args.end(),
+ "", currentBlock);
+ node->addIncoming(C, currentBlock);
+ BranchInst::Create(endBlock, currentBlock);
+
+ // ---------------------------- The end ----------------------------------//
+ currentBlock = endBlock;
+ push(node, AssessorDesc::dRef);
+
#else
- push(toPush, AssessorDesc::dRef);
+ const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[index]);
+ JavaString* str = JavaThread::get()->isolate->UTF8ToStr(utf8);
+ LLVMStringInfo* LSI = module->getStringInfo(str);
+ Value* val = LSI->getDelegatee(this);
+ push(val, AssessorDesc::dRef);
#endif
+
} else if (type == JavaConstantPool::ConstantLong) {
push(ConstantInt::get(Type::Int64Ty, ctpInfo->LongAt(index)),
AssessorDesc::dLong);
@@ -1590,16 +1582,28 @@
}
}
}
-
-Value* JavaJIT::getResolvedClass(uint16 index, bool clinit) {
- GlobalVariable * gv =
- new GlobalVariable(JnjvmModule::JavaClassType, false,
- GlobalValue::ExternalLinkage,
- JnjvmModule::JavaClassNullConstant, "",
- module);
+Value* JavaJIT::getConstantPoolAt(uint32 index) {
+ JavaConstantPool* ctp = compilingClass->ctpInfo;
+ LLVMConstantPoolInfo* LCPI = module->getConstantPoolInfo(ctp);
+ Value* CTP = LCPI->getDelegatee(this);
+
+ std::vector<Value*> indexes; //[3];
+ indexes.push_back(ConstantInt::get(Type::Int32Ty, index));
+ Value* arg1 = GetElementPtrInst::Create(CTP, indexes.begin(),
+ indexes.end(),
+ "", currentBlock);
+ // We set as volatile because "readnone" calls may alter
+ // the constant pool cache.
+ arg1 = new LoadInst(arg1, "", true, currentBlock);
+
+ return arg1;
+}
+
+Value* JavaJIT::getResolvedClass(uint16 index, bool clinit) {
- Value* arg1 = new LoadInst(gv, "", false, currentBlock);
+ Value* arg1 = getConstantPoolAt(index);
+ arg1 = new BitCastInst(arg1, JnjvmModule::JavaClassType, "", currentBlock);
Value* test = new ICmpInst(ICmpInst::ICMP_EQ, arg1,
JnjvmModule::JavaClassNullConstant, "",
currentBlock);
@@ -1619,25 +1623,17 @@
Args.push_back(v);
ConstantInt* CI = ConstantInt::get(Type::Int32Ty, index);
Args.push_back(CI);
- Args.push_back(gv);
- if (clinit) {
- Args.push_back(mvm::jit::constantOne);
- } else {
- Args.push_back(mvm::jit::constantZero);
- }
Value* res = invoke(JnjvmModule::ClassLookupFunction, Args, "",
currentBlock);
node->addIncoming(res, currentBlock);
llvm::BranchInst::Create(trueCl, currentBlock);
currentBlock = trueCl;
-#ifdef MULTIPLE_VM
if (clinit)
return invoke(JnjvmModule::InitialisationCheckFunction, node, "",
currentBlock);
else
-#endif
- return node;
+ return node;
}
void JavaJIT::invokeNew(uint16 index) {
@@ -1712,36 +1708,34 @@
JavaConstantPool* info = compilingClass->ctpInfo;
JavaField* field = info->lookupField(index, stat);
- if (field && field->classDef->isResolved()
-#ifndef MULTIPLE_VM
- && field->classDef->isReady()
-#endif
- ) {
+ if (field && field->classDef->isResolved()) {
LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(field->classDef);
+ LLVMFieldInfo* LFI = module->getFieldInfo(field);
+ const Type* type = 0;
if (stat) {
- object = LCI->getStaticVar(this);
+
+#ifndef MULTIPLE_VM
+ if (field->classDef->isReady()) {
+#endif
+ object = LCI->getStaticVar(this);
+ type = LCI->getStaticType();
+ return fieldGetter(this, type, object, LFI->getOffset());
+#ifndef MULTIPLE_VM
+ }
+#endif
+ } else {
+ type = LCI->getVirtualType();
+ return fieldGetter(this, type, object, LFI->getOffset());
}
- const Type* type = stat ? LCI->getStaticType() :
- LCI->getVirtualType();
- LLVMFieldInfo* LFI = module->getFieldInfo(field);
- return fieldGetter(this, type, object, LFI->getOffset());
- } else {
+ }
+
const Type* Pty = mvm::jit::arrayPtrType;
- GlobalVariable* gvStaticInstance =
- new GlobalVariable(mvm::jit::ptrType, false,
- GlobalValue::ExternalLinkage,
- mvm::jit::constantPtrNull,
- "", module);
-
-
Constant* zero = mvm::jit::constantZero;
- GlobalVariable* gv =
- new GlobalVariable(Type::Int32Ty, false, GlobalValue::ExternalLinkage,
- zero, "", module);
+ Constant* nil = mvm::jit::constantPtrNull;
- // set is volatile
- Value* val = new LoadInst(gv, "", true, currentBlock);
- Value * cmp = new ICmpInst(ICmpInst::ICMP_NE, val, zero, "", currentBlock);
+ Value* val = getConstantPoolAt(index);
+ // a virtual field can never be zero.
+ Value * cmp = new ICmpInst(ICmpInst::ICMP_NE, val, nil, "", currentBlock);
BasicBlock* ifTrue = createBasicBlock("true ldResolved");
BasicBlock* ifFalse = createBasicBlock("false ldResolved");
BasicBlock* endBlock = createBasicBlock("end ldResolved");
@@ -1753,6 +1747,7 @@
Value* resPtr = 0;
if (object) {
Value* ptr = new BitCastInst(object, Pty, "", currentBlock);
+ val = new PtrToIntInst(val, Type::Int32Ty, "", currentBlock);
std::vector<Value*> gepArgs; // size = 1
gepArgs.push_back(zero);
gepArgs.push_back(val);
@@ -1760,7 +1755,7 @@
"", currentBlock);
} else {
- resPtr = new LoadInst(gvStaticInstance, "", currentBlock);
+ resPtr = val;
}
node->addIncoming(resPtr, currentBlock);
@@ -1779,15 +1774,12 @@
Constant* CI = ConstantInt::get(Type::Int32Ty, index);
args.push_back(CI);
args.push_back(stat ? mvm::jit::constantOne : mvm::jit::constantZero);
- args.push_back(gvStaticInstance);
- args.push_back(gv);
Value* tmp = invoke(JnjvmModule::FieldLookupFunction, args, "", currentBlock);
node->addIncoming(tmp, currentBlock);
llvm::BranchInst::Create(endBlock, currentBlock);
currentBlock = endBlock;;
return new BitCastInst(node, fieldTypePtr, "", currentBlock);
- }
}
void JavaJIT::convertValue(Value*& val, const Type* t1, BasicBlock* currentBlock,
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h?rev=55176&r1=55175&r2=55176&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h Fri Aug 22 08:24:20 2008
@@ -56,6 +56,10 @@
};
class JavaJIT {
+private:
+
+ llvm::Value* getConstantPoolAt(uint32 index);
+
public:
JnjvmModule* module;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=55176&r1=55175&r2=55176&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Fri Aug 22 08:24:20 2008
@@ -30,10 +30,13 @@
using namespace jnjvm;
-extern "C" JavaString* runtimeUTF8ToStr(const UTF8* val) {
- Jnjvm* vm = JavaThread::get()->isolate;
- return vm->UTF8ToStr(val);
+#ifdef MULTIPLE_VM
+extern "C" JavaString* stringLookup(Class* cl, uint32 index) {
+ const UTF8* utf8 = cl->ctpInfo->UTF8At(cl->ctpInfo->ctpDef[index]);
+ JavaString* str = JavaThread::get()->isolate->UTF8ToStr(utf8);
+ return str;
}
+#endif
extern "C" void* jnjvmVirtualLookup(CacheNode* cache, JavaObject *obj) {
Enveloppe* enveloppe = cache->enveloppe;
@@ -87,18 +90,10 @@
}
extern "C" void* fieldLookup(JavaObject* obj, Class* caller, uint32 index,
- uint32 stat, void** ifStatic, uint32* offset) {
+ uint32 stat) {
JavaConstantPool* ctpInfo = caller->ctpInfo;
if (ctpInfo->ctpRes[index]) {
- JavaField* field = (JavaField*)(ctpInfo->ctpRes[index]);
- field->classDef->initialiseClass();
- if (stat) obj = field->classDef->staticInstance();
- void* ptr = (void*)(field->ptrOffset + (uint64)obj);
-#ifndef MULTIPLE_VM
- if (stat) *ifStatic = ptr;
- *offset = (uint32)field->ptrOffset;
-#endif
- return ptr;
+ return ctpInfo->ctpRes[index];
}
CommonClass* cl = 0;
@@ -110,15 +105,17 @@
JavaField* field = cl->lookupField(utf8, sign->keyName, stat, true);
field->classDef->initialiseClass();
- if (stat) obj = ((Class*)cl)->staticInstance();
- void* ptr = (void*)((uint64)obj + field->ptrOffset);
-
- ctpInfo->ctpRes[index] = field;
+ void* ptr = 0;
+ if (stat) {
+ ptr = (void*)(((uint64)((Class*)cl)->staticInstance()) + field->ptrOffset);
#ifndef MULTIPLE_VM
- if (stat) *ifStatic = ptr;
- *offset = (uint32)field->ptrOffset;
+ ctpInfo->ctpRes[index] = ptr;
#endif
-
+ } else {
+ ptr = (void*)((uint64)obj + field->ptrOffset);
+ ctpInfo->ctpRes[index] = (void*)field->ptrOffset;
+ }
+
return ptr;
}
@@ -196,19 +193,14 @@
return vm->getClassDelegatee(cl);
}
-extern "C" Class* newLookup(Class* caller, uint32 index, Class** toAlloc,
- uint32 clinit) {
+extern "C" Class* newLookup(Class* caller, uint32 index) {
JavaConstantPool* ctpInfo = caller->ctpInfo;
Class* cl = (Class*)ctpInfo->loadClass(index);
- cl->resolveClass(clinit);
-
- *toAlloc = cl;
return cl;
}
#ifndef WITHOUT_VTABLE
-extern "C" uint32 vtableLookup(JavaObject* obj, Class* caller, uint32 index,
- uint32* offset) {
+extern "C" uint32 vtableLookup(JavaObject* obj, Class* caller, uint32 index) {
CommonClass* cl = 0;
const UTF8* utf8 = 0;
Signdef* sign = 0;
@@ -220,10 +212,11 @@
// Arg, it should have been an invoke interface.... Perform the lookup
// on the object class and do not update offset.
dmeth = obj->classOf->lookupMethod(utf8, sign->keyName, false, true);
- return dmeth->offset;
+ } else {
+ caller->ctpInfo->ctpRes[index] = (void*)dmeth->offset;
}
- *offset = dmeth->offset;
- return *offset;
+
+ return dmeth->offset;
}
#endif
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=55176&r1=55175&r2=55176&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Fri Aug 22 08:24:20 2008
@@ -102,8 +102,11 @@
llvm::Function* JnjvmModule::AquireObjectFunction = 0;
llvm::Function* JnjvmModule::ReleaseObjectFunction = 0;
llvm::Function* JnjvmModule::MultiCallNewFunction = 0;
-llvm::Function* JnjvmModule::RuntimeUTF8ToStrFunction = 0;
+
+#ifdef MULTIPLE_VM
+llvm::Function* JnjvmModule::StringLookupFunction = 0;
llvm::Function* JnjvmModule::GetStaticInstanceFunction = 0;
+#endif
llvm::Function* JnjvmModule::GetClassDelegateeFunction = 0;
llvm::Function* JnjvmModule::ArrayLengthFunction = 0;
llvm::Function* JnjvmModule::GetVTFunction = 0;
@@ -144,6 +147,20 @@
return new LoadInst(varGV, "", jit->currentBlock);
}
+Value* LLVMConstantPoolInfo::getDelegatee(JavaJIT* jit) {
+ if (!delegateeGV) {
+ void* ptr = ctp->ctpRes;
+ Constant* cons =
+ ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64(ptr)),
+ mvm::jit::ptrPtrType);
+ delegateeGV = new GlobalVariable(mvm::jit::ptrPtrType, true,
+ GlobalValue::ExternalLinkage,
+ cons, "",
+ ctp->classDef->classLoader->TheModule);
+ }
+ return new LoadInst(delegateeGV, "", jit->currentBlock);
+}
+
Value* LLVMCommonClassInfo::getDelegatee(JavaJIT* jit) {
#ifndef MULTIPLE_VM
if (!delegateeGV) {
@@ -864,6 +881,32 @@
#endif
+LLVMStringInfo* JnjvmModule::getStringInfo(JavaString* str) {
+ string_iterator SI = stringMap.find(str);
+ if (SI != stringMap.end()) {
+ return SI->second;
+ } else {
+ LLVMStringInfo* LSI = new LLVMStringInfo(str);
+ stringMap.insert(std::make_pair(str, LSI));
+ return LSI;
+ }
+}
+
+Value* LLVMStringInfo::getDelegatee(JavaJIT* jit) {
+ if (!delegateeGV) {
+ void* ptr = str;
+ Constant* cons =
+ ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64(ptr)),
+ JnjvmModule::JavaObjectType);
+ delegateeGV = new GlobalVariable(JnjvmModule::JavaObjectType, true,
+ GlobalValue::ExternalLinkage,
+ cons, "",
+ jit->module);
+ }
+ return new LoadInst(delegateeGV, "", jit->currentBlock);
+}
+
+
namespace jnjvm {
namespace llvm_runtime {
#include "LLVMRuntime.inc"
@@ -967,7 +1010,7 @@
#ifdef MULTIPLE_VM
GetStaticInstanceFunction = module->getFunction("getStaticInstance");
- RuntimeUTF8ToStrFunction = module->getFunction("runtimeUTF8ToStr");
+ StringLookupFunction = module->getFunction("stringLookup");
#endif
#ifdef SERVICE_VM
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=55176&r1=55175&r2=55176&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Fri Aug 22 08:24:20 2008
@@ -23,6 +23,7 @@
#include "mvm/JIT.h"
#include "JavaClass.h"
+#include "JavaConstantPool.h"
#include "JavaTypes.h"
namespace jnjvm {
@@ -223,10 +224,61 @@
};
#endif
+class LLVMConstantPoolInfo : public mvm::JITInfo {
+private:
+ JavaConstantPool* ctp;
+ llvm::GlobalVariable* delegateeGV;
+
+public:
+ llvm::Value* getDelegatee(JavaJIT* jit);
+
+ LLVMConstantPoolInfo(JavaConstantPool* c) :
+ ctp(c), delegateeGV(0) {}
+};
+
+class LLVMStringInfo : public mvm::JITInfo {
+private:
+ JavaString* str;
+ llvm::GlobalVariable* delegateeGV;
+
+public:
+ llvm::Value* getDelegatee(JavaJIT* jit);
+
+ LLVMStringInfo(JavaString* c) :
+ str(c), delegateeGV(0) {}
+};
+
class JnjvmModule : public llvm::Module {
friend class LLVMClassInfo;
private:
+ std::map<const CommonClass*, LLVMCommonClassInfo*> classMap;
+ std::map<const Signdef*, LLVMSignatureInfo*> signatureMap;
+ std::map<const JavaField*, LLVMFieldInfo*> fieldMap;
+ std::map<const JavaMethod*, LLVMMethodInfo*> methodMap;
+ std::map<const JavaString*, LLVMStringInfo*> stringMap;
+
+#ifdef SERVICE_VM
+ std::map<const ServiceDomain*, LLVMServiceInfo*> serviceMap;
+ typedef std::map<const ServiceDomain*, LLVMServiceInfo*>::iterator
+ class_iterator;
+#endif
+
+ typedef std::map<const CommonClass*, LLVMCommonClassInfo*>::iterator
+ class_iterator;
+ typedef std::map<const Signdef*, LLVMSignatureInfo*>::iterator
+ signature_iterator;
+
+ typedef std::map<const JavaMethod*, LLVMMethodInfo*>::iterator
+ method_iterator;
+
+ typedef std::map<const JavaField*, LLVMFieldInfo*>::iterator
+ field_iterator;
+
+ typedef std::map<const JavaString*, LLVMStringInfo*>::iterator
+ string_iterator;
+
+
static VirtualTable* makeVT(Class* cl, bool stat);
static VirtualTable* allocateVT(Class* cl, CommonClass::method_iterator meths);
@@ -292,8 +344,12 @@
static llvm::Function* ServiceCallStopFunction;
#endif
static llvm::Function* MultiCallNewFunction;
- static llvm::Function* RuntimeUTF8ToStrFunction;
+
+#ifdef MULTIPLE_VM
+ static llvm::Function* StringLookupFunction;
static llvm::Function* GetStaticInstanceFunction;
+#endif
+
static llvm::Function* GetClassDelegateeFunction;
static llvm::Function* ArrayLengthFunction;
static llvm::Function* GetVTFunction;
@@ -367,6 +423,12 @@
return method->getInfo<LLVMMethodInfo>();
}
+ static LLVMConstantPoolInfo* getConstantPoolInfo(JavaConstantPool* ctp) {
+ return ctp->getInfo<LLVMConstantPoolInfo>();
+ }
+
+ LLVMStringInfo* getStringInfo(JavaString* str);
+
#ifdef SERVICE_VM
static LLVMServiceInfo* getServiceInfo(ServiceDomain* service) {
return service->getInfo<LLVMServiceInfo>();
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=55176&r1=55175&r2=55176&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Fri Aug 22 08:24:20 2008
@@ -47,24 +47,21 @@
return meth;
}
-bool JnjvmModuleProvider::lookupCallback(Function* F, std::pair<Class*, uint32>& res) {
+std::pair<Class*, uint32>* JnjvmModuleProvider::lookupCallback(Function* F) {
callback_iterator CI = callbacks.find(F);
if (CI != callbacks.end()) {
- res.first = CI->second.first;
- res.second = CI->second.second;
- return true;
+ return &(CI->second);
} else {
- return false;
+ return 0;
}
}
-bool JnjvmModuleProvider::lookupFunction(Function* F, JavaMethod*& meth) {
+JavaMethod* JnjvmModuleProvider::lookupFunction(Function* F) {
function_iterator CI = functions.find(F);
if (CI != functions.end()) {
- meth = CI->second;
- return true;
+ return CI->second;
} else {
- return false;
+ return 0;
}
}
@@ -77,14 +74,13 @@
if (!(F->hasNotBeenReadFromBitcode()))
return false;
- JavaMethod* meth = 0;
- lookupFunction(F, meth);
+ JavaMethod* meth = lookupFunction(F);
if (!meth) {
// It's a callback
- std::pair<Class*, uint32> p;
- lookupCallback(F, p);
- meth = staticLookup(p.first, p.second);
+ std::pair<Class*, uint32> * p = lookupCallback(F);
+ assert(p && "No callback where there should be one");
+ meth = staticLookup(p->first, p->second);
}
void* val = meth->compiledPtr();
@@ -155,6 +151,14 @@
llvm::Function* JnjvmModuleProvider::addCallback(Class* cl, uint32 index,
Signdef* sign, bool stat) {
+
+ void* key = &(cl->ctpInfo->ctpRes[index]);
+
+ reverse_callback_iterator CI = reverseCallbacks.find(key);
+ if (CI != reverseCallbacks.end()) {
+ return CI->second;
+ }
+
const llvm::FunctionType* type = 0;
JnjvmModule* M = cl->classLoader->TheModule;
LLVMSignatureInfo* LSI = M->getSignatureInfo(sign);
@@ -164,12 +168,15 @@
} else {
type = LSI->getVirtualType();
}
+
Function* func = llvm::Function::Create(type,
llvm::GlobalValue::GhostLinkage,
"callback",
TheModule);
callbacks.insert(std::make_pair(func, std::make_pair(cl, index)));
+ reverseCallbacks.insert(std::make_pair(key, func));
+
return func;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.h?rev=55176&r1=55175&r2=55176&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.h Fri Aug 22 08:24:20 2008
@@ -28,15 +28,19 @@
std::map<llvm::Function*, JavaMethod*> functions;
std::map<llvm::Function*, std::pair<Class*, uint32> > callbacks;
+ std::map<void*, llvm::Function* > reverseCallbacks;
- bool lookupCallback(llvm::Function*, std::pair<Class*, uint32>&);
- bool lookupFunction(llvm::Function*, JavaMethod*& meth);
+ std::pair<Class*, uint32>* lookupCallback(llvm::Function*);
+ JavaMethod* lookupFunction(llvm::Function*);
typedef std::map<llvm::Function*, JavaMethod*>::iterator
function_iterator;
typedef std::map<llvm::Function*, std::pair<Class*, uint32> >::iterator
callback_iterator;
+
+ typedef std::map<void*, llvm::Function* >::iterator
+ reverse_callback_iterator;
llvm::FunctionPassManager* perFunctionPasses;
More information about the vmkit-commits
mailing list