[vmkit-commits] [vmkit] r198487 - Simplify J3Signature management
Gael Thomas
gael.thomas at lip6.fr
Sat Jan 4 05:40:10 PST 2014
Author: gthomas
Date: Sat Jan 4 07:40:09 2014
New Revision: 198487
URL: http://llvm.org/viewvc/llvm-project?rev=198487&view=rev
Log:
Simplify J3Signature management
Modified:
vmkit/branches/mcjit/include/j3/j3.h
vmkit/branches/mcjit/include/j3/j3codegen.h
vmkit/branches/mcjit/include/j3/j3signature.h
vmkit/branches/mcjit/lib/j3/vm/j3codegen.cc
vmkit/branches/mcjit/lib/j3/vm/j3method.cc
vmkit/branches/mcjit/lib/j3/vm/j3signature.cc
Modified: vmkit/branches/mcjit/include/j3/j3.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/mcjit/include/j3/j3.h?rev=198487&r1=198486&r2=198487&view=diff
==============================================================================
--- vmkit/branches/mcjit/include/j3/j3.h (original)
+++ vmkit/branches/mcjit/include/j3/j3.h Sat Jan 4 07:40:09 2014
@@ -8,13 +8,16 @@
#include "vmkit/vmkit.h"
#include "vmkit/allocator.h"
-#include "j3/j3signature.h"
#include "j3/j3options.h"
#include "j3/j3typesdef.h"
#include "j3/j3jni.h"
#include "j3/j3monitor.h"
#include "j3/j3constants.h"
+namespace llvm {
+ class FunctionType;
+}
+
namespace j3 {
class J3InitialClassLoader;
class J3Class;
@@ -25,6 +28,7 @@ namespace j3 {
class J3Primitive;
class J3Lib;
class J3Method;
+ class J3LLVMSignature;
class J3Signature;
class J3 : public vmkit::VMKit {
Modified: vmkit/branches/mcjit/include/j3/j3codegen.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/mcjit/include/j3/j3codegen.h?rev=198487&r1=198486&r2=198487&view=diff
==============================================================================
--- vmkit/branches/mcjit/include/j3/j3codegen.h (original)
+++ vmkit/branches/mcjit/include/j3/j3codegen.h Sat Jan 4 07:40:09 2014
@@ -82,7 +82,6 @@ namespace j3 {
uint32_t wideReadU1();
uint32_t wideReadS1();
- llvm::FunctionType* llvmFunctionType(J3Method* method);
llvm::Function* buildFunction(J3Method* method, bool isStub=1);
llvm::Value* methodDescriptor(J3Method* method);
llvm::Value* typeDescriptor(J3ObjectType* objectType, llvm::Type* type);
Modified: vmkit/branches/mcjit/include/j3/j3signature.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/mcjit/include/j3/j3signature.h?rev=198487&r1=198486&r2=198487&view=diff
==============================================================================
--- vmkit/branches/mcjit/include/j3/j3signature.h (original)
+++ vmkit/branches/mcjit/include/j3/j3signature.h Sat Jan 4 07:40:09 2014
@@ -27,13 +27,13 @@ namespace j3 {
J3ClassLoader* _loader;
const vmkit::Name* _name;
J3LLVMSignature* _staticLLVMSignature;
- J3LLVMSignature* _virtualLLVMSignature;
+ J3LLVMSignature* volatile _virtualLLVMSignature;
J3Type* volatile _out;
- uint32_t _nbIns;
J3Type** _ins;
- llvm::FunctionType* _staticFunctionType;
- llvm::FunctionType* volatile _virtualFunctionType;
+ J3LLVMSignature* buildLLVMSignature(llvm::FunctionType* fType);
+ J3LLVMSignature* llvmSignature(uint32_t access);
+
void checkInOut();
void checkFunctionType();
public:
@@ -41,30 +41,24 @@ namespace j3 {
const vmkit::Name* name() { return _name; }
J3ClassLoader* loader() { return _loader; }
- llvm::FunctionType* functionType(uint32_t access); /* has to be called when compiler lock is held */
- void setLLVMSignature(uint32_t access, J3LLVMSignature* llvmSignature);
- J3LLVMSignature* llvmSignature(uint32_t access);
- J3Type* out() { checkInOut(); return _out; }
- uint32_t nbIns() { checkInOut(); return _nbIns; }
- J3Type* ins(uint32_t idx) { checkInOut(); return _ins[idx]; }
+ J3Type* javaOut() { checkInOut(); return _out; }
+ J3Type* javaIns(uint32_t idx) { checkInOut(); return _ins[idx]; }
+ uint32_t nbIns();
+
+ function_t caller(uint32_t access);
+
+ /* only call this function outside the compiler when the functionType already exists */
+ llvm::FunctionType* functionType(uint32_t access);
- J3Signature::function_t caller(uint32_t access);
+ /* only call the remaining functions while the compiler lock is held */
void generateCallerIR(uint32_t access, J3CodeGen* codeGen, llvm::Module* module, const char* id);
void setCaller(uint32_t access, J3Signature::function_t caller);
};
class J3LLVMSignature : public vmkit::PermanentObject {
- private:
- llvm::FunctionType* _functionType;
- J3Signature::function_t _caller;
-
public:
- J3LLVMSignature(llvm::FunctionType* functionType);
-
- void z_setCaller(J3Signature::function_t caller) { _caller = caller; }
- J3Signature::function_t z_caller() { return _caller; }
-
- llvm::FunctionType* functionType() { return _functionType; }
+ llvm::FunctionType* functionType;
+ J3Signature::function_t caller;
};
}
Modified: vmkit/branches/mcjit/lib/j3/vm/j3codegen.cc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/mcjit/lib/j3/vm/j3codegen.cc?rev=198487&r1=198486&r2=198487&view=diff
==============================================================================
--- vmkit/branches/mcjit/lib/j3/vm/j3codegen.cc (original)
+++ vmkit/branches/mcjit/lib/j3/vm/j3codegen.cc Sat Jan 4 07:40:09 2014
@@ -108,15 +108,14 @@ J3CodeGen::J3CodeGen(vmkit::BumpAllocato
}
uint32_t access = method->access();
- if(withCaller && !signature->caller(access))
+ uint32_t needsCaller = withCaller && !signature->caller(access);
+ if(needsCaller)
signature->generateCallerIR(access, this, module, "generic-caller");
loader->compileModule(module);
-
- if(withCaller && !signature->caller(access)) {
- J3Signature::function_t caller = (J3Signature::function_t)loader->ee()->getFunctionAddress("generic-caller");
- signature->setCaller(access, caller);
- }
+
+ if(needsCaller)
+ signature->setCaller(access, (J3Signature::function_t)loader->ee()->getFunctionAddress("generic-caller"));
if(withMethod) {
void* fnPtr = (void*)loader->ee()->getFunctionAddress(llvmFunction->getName().data());
@@ -136,7 +135,7 @@ void J3CodeGen::operator delete(void* pt
void J3CodeGen::translate(J3Method* method, bool withMethod, bool withCaller) {
method->cl()->loader()->vm()->lockCompiler();
-
+
vmkit::BumpAllocator* allocator = vmkit::BumpAllocator::create();
delete new(allocator) J3CodeGen(allocator, method, withMethod, withCaller);
vmkit::BumpAllocator::destroy(allocator);
@@ -191,34 +190,9 @@ llvm::Value* J3CodeGen::unflatten(llvm::
}
}
-llvm::FunctionType* J3CodeGen::llvmFunctionType(J3Method* method) {
- // return method->functionType(method->access());
-
- J3Signature* type = method->signature();
- J3LLVMSignature* res = type->llvmSignature(method->access());
-
- if(!res) {
- std::vector<llvm::Type*> in;
-
- if(!J3Cst::isStatic(method->access()))
- in.push_back(vm->typeJ3ObjectPtr);
-
- for(uint32_t i=0; i<type->nbIns(); i++)
- in.push_back(type->ins(i)->llvmType());
-
- llvm::FunctionType* funcType = llvm::FunctionType::get(type->out()->llvmType(), in, 0);
- res = vm->llvmSignatures[funcType];
- if(!res)
- vm->llvmSignatures[funcType] = res = new(vm->allocator()) J3LLVMSignature(funcType);
- type->setLLVMSignature(method->access(), res);
- }
-
- return res->functionType();
-}
-
llvm::Function* J3CodeGen::buildFunction(J3Method* method, bool isStub) {
const char* id = (isStub && !method->fnPtr()) ? method->llvmStubName(cl) : method->llvmFunctionName(cl);
- return (llvm::Function*)module->getOrInsertFunction(id, llvmFunctionType(method));
+ return (llvm::Function*)module->getOrInsertFunction(id, method->signature()->functionType(method->access()));
}
llvm::Value* J3CodeGen::typeDescriptor(J3ObjectType* objectType, llvm::Type* type) {
@@ -405,7 +379,7 @@ void J3CodeGen::invoke(uint32_t access,
}
for(uint32_t i=0; i<type->nbIns(); i++)
- args.push_back(unflatten(stack.top(type->nbIns() - i - 1), type->ins(i)));
+ args.push_back(unflatten(stack.top(type->nbIns() - i - 1), type->javaIns(i)));
stack.drop(d + type->nbIns());
@@ -420,8 +394,8 @@ void J3CodeGen::invoke(uint32_t access,
} else
res = builder->CreateCall(func, args);
- if(type->out() != vm->typeVoid) {
- stack.push(flatten(res, type->out()));
+ if(type->javaOut() != vm->typeVoid) {
+ stack.push(flatten(res, type->javaOut()));
}
}
@@ -439,7 +413,7 @@ void J3CodeGen::invokeInterface(uint32_t
builder->getInt32(J3VirtualTable::gepInterfaceMethods),
builder->getInt32(index % J3VirtualTable::nbInterfaceMethodTable) };
llvm::Value* func = builder->CreateBitCast(builder->CreateLoad(builder->CreateGEP(vt(obj), gepFunc)),
- llvmFunctionType(target)->getPointerTo());
+ target->signature()->functionType(target->access())->getPointerTo());
invoke(0, target, func);
}
@@ -459,7 +433,7 @@ void J3CodeGen::invokeVirtual(uint32_t i
builder->getInt32(J3VirtualTable::gepVirtualMethods),
funcEntry };
llvm::Value* func = builder->CreateBitCast(builder->CreateLoad(builder->CreateGEP(vt(obj), gepFunc)),
- llvmFunctionType(target)->getPointerTo());
+ target->signature()->functionType(target->access())->getPointerTo());
char buf[65536]; snprintf(buf, 65536, "%s::%s%s",
target->cl()->name()->cStr(),
@@ -1631,7 +1605,7 @@ void J3CodeGen::generateJava() {
if(!pos && !J3Cst::isStatic(method->access()))
type = method->cl();
else
- type = signature->ins(n++);
+ type = signature->javaIns(n++);
locals.setAt(flatten(cur, type), pos);
@@ -1664,11 +1638,11 @@ void J3CodeGen::generateJava() {
buildString("%s\n"),
buildString(buf));
}
- if(signature->out() == vm->typeVoid) {
+ if(signature->javaOut() == vm->typeVoid) {
builder->CreateRetVoid();
} else {
- ret.metaStack[0] = signature->out()->llvmType();
- builder->CreateRet(unflatten(ret.at(0), signature->out()));
+ ret.metaStack[0] = signature->javaOut()->llvmType();
+ builder->CreateRet(unflatten(ret.at(0), signature->javaOut()));
}
if(J3Cst::isSynchronized(method->access())) {
@@ -1731,9 +1705,9 @@ llvm::Function* J3CodeGen::lookupNative(
nativeIns.push_back(vm->typeJ3ObjectHandlePtr);
for(int i=0; i<signature->nbIns(); i++)
- nativeIns.push_back(doNativeType(signature->ins(i)));
+ nativeIns.push_back(doNativeType(signature->javaIns(i)));
- nativeOut = doNativeType(signature->out());
+ nativeOut = doNativeType(signature->javaOut());
char* buf = (char*)loader->allocator()->allocate(mangler.length()+1);
memcpy(buf, mangler.cStr(), mangler.length()+1);
@@ -1778,8 +1752,8 @@ void J3CodeGen::generateNative() {
selfDone = 1;
a = builder->CreateCall2(funcJ3ThreadPush, thread, flatten(cur, method->cl()));
} else {
- if(signature->ins(i)->llvmType()->isPointerTy())
- a = builder->CreateCall2(funcJ3ThreadPush, thread, flatten(cur, signature->ins(i)));
+ if(signature->javaIns(i)->llvmType()->isPointerTy())
+ a = builder->CreateCall2(funcJ3ThreadPush, thread, flatten(cur, signature->javaIns(i)));
else
a = cur;
i++;
@@ -1789,22 +1763,22 @@ void J3CodeGen::generateNative() {
res = builder->CreateCall(nat, args);
- if(signature->out() == vm->typeVoid) {
+ if(signature->javaOut() == vm->typeVoid) {
builder->CreateCall2(funcJ3ThreadRestore, thread, frame);
builder->CreateRetVoid();
} else {
builder->CreateCall2(funcJ3ThreadRestore, thread, frame);
- if(signature->out()->llvmType()->isPointerTy()) {
+ if(signature->javaOut()->llvmType()->isPointerTy()) {
llvm::BasicBlock* ifnull = newBB("ifnull");
llvm::BasicBlock* ifnotnull = newBB("ifnotnull");
builder->CreateCondBr(builder->CreateIsNull(res), ifnull, ifnotnull);
builder->SetInsertPoint(bb = ifnull);
- builder->CreateRet(unflatten(nullValue, signature->out()));
+ builder->CreateRet(unflatten(nullValue, signature->javaOut()));
builder->SetInsertPoint(bb = ifnotnull);
- res = unflatten(handleToObject(res), signature->out());
+ res = unflatten(handleToObject(res), signature->javaOut());
}
builder->CreateRet(res);
}
Modified: vmkit/branches/mcjit/lib/j3/vm/j3method.cc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/mcjit/lib/j3/vm/j3method.cc?rev=198487&r1=198486&r2=198487&view=diff
==============================================================================
--- vmkit/branches/mcjit/lib/j3/vm/j3method.cc (original)
+++ vmkit/branches/mcjit/lib/j3/vm/j3method.cc Sat Jan 4 07:40:09 2014
@@ -113,7 +113,7 @@ J3Method* J3Method::resolve(J3ObjectHand
}
J3Value J3Method::internalInvoke(J3ObjectHandle* handle, J3Value* inArgs) {
- ensureCompiled(1);
+ ensureCompiled(1); /* force the generation of the code and thus of the functionType */
J3Value* reIn;
if(handle) {
@@ -127,7 +127,7 @@ J3Value J3Method::internalInvoke(J3Objec
}
J3Value J3Method::internalInvoke(J3ObjectHandle* handle, va_list va) {
- ensureCompiled(1);
+ ensureCompiled(1); /* force the generation of the code and thus of the functionType */
llvm::FunctionType* fType = signature()->functionType(J3Cst::ACC_STATIC); /* static signature for va */
J3Value* args = (J3Value*)alloca(sizeof(J3Value)*(fType->getNumParams() + 1));
@@ -269,7 +269,7 @@ J3ObjectHandle* J3Method::javaMethod() {
J3ObjectHandle* parameters = J3ObjectHandle::doNewArray(vm->classClass->getArray(), nbIns);
for(uint32_t i=0; i<nbIns; i++)
- parameters->setObjectAt(i, signature()->ins(i)->javaClass());
+ parameters->setObjectAt(i, signature()->javaIns(i)->javaClass());
J3Attribute* exceptionAttribute = attributes()->lookup(vm->exceptionsAttribute);
J3ObjectHandle* exceptions;
Modified: vmkit/branches/mcjit/lib/j3/vm/j3signature.cc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/mcjit/lib/j3/vm/j3signature.cc?rev=198487&r1=198486&r2=198487&view=diff
==============================================================================
--- vmkit/branches/mcjit/lib/j3/vm/j3signature.cc (original)
+++ vmkit/branches/mcjit/lib/j3/vm/j3signature.cc Sat Jan 4 07:40:09 2014
@@ -17,8 +17,41 @@ J3Signature::J3Signature(J3ClassLoader*
_name = name;
}
+void J3Signature::checkInOut() {
+ if(!_out) {
+ J3Type* args[1+name()->length()];
+ uint32_t nbArgs = 0;
+ uint32_t cur = 1;
+
+ if(name()->cStr()[0] != J3Cst::ID_Left)
+ loader()->wrongType(0, name());
+
+ while(name()->cStr()[cur] != J3Cst::ID_Right)
+ args[nbArgs++] = loader()->getTypeInternal(0, name(), cur, &cur, 0);
+
+ if(nbArgs != nbIns())
+ J3::internalError("should not happen %d %d", nbArgs, nbIns());
+
+ _ins = (J3Type**)loader()->allocator()->allocate(nbArgs*sizeof(J3Type*));
+ memcpy(_ins, args, nbArgs*sizeof(J3Type*));
+
+ _out = loader()->getTypeInternal(0, name(), cur+1, &cur, 0); /* out has to be the last (thread safety) */
+ if(cur != name()->length())
+ loader()->wrongType(0, name());
+ }
+}
+
+J3LLVMSignature* J3Signature::buildLLVMSignature(llvm::FunctionType* fType) {
+ J3LLVMSignature* res = loader()->vm()->llvmSignatures[fType];
+ if(!res) {
+ loader()->vm()->llvmSignatures[fType] = res = new(loader()->vm()->allocator()) J3LLVMSignature();
+ res->functionType = fType;
+ }
+ return res;
+}
+
void J3Signature::checkFunctionType() {
- if(!_virtualFunctionType) {
+ if(!_virtualLLVMSignature) {
std::vector<llvm::Type*> vins;
std::vector<llvm::Type*> sins;
uint32_t cur = 1;
@@ -35,41 +68,33 @@ void J3Signature::checkFunctionType() {
}
llvm::Type* out = loader()->getTypeInternal(0, name(), cur+1, &cur, 1)->llvmType();
-
- _staticFunctionType = llvm::FunctionType::get(out, sins, 0);
- _virtualFunctionType = llvm::FunctionType::get(out, vins, 0);
+
+ _staticLLVMSignature = buildLLVMSignature(llvm::FunctionType::get(out, sins, 0));
+ _virtualLLVMSignature = buildLLVMSignature(llvm::FunctionType::get(out, vins, 0));
}
}
-llvm::FunctionType* J3Signature::functionType(uint32_t access) {
+J3LLVMSignature* J3Signature::llvmSignature(uint32_t access) {
checkFunctionType();
- return J3Cst::isStatic(access) ? _staticFunctionType : _virtualFunctionType;
+ return J3Cst::isStatic(access) ? _staticLLVMSignature : _virtualLLVMSignature;
}
-void J3Signature::checkInOut() {
- if(!_out) {
- J3Type* args[1+name()->length()];
- uint32_t nbArgs = 0;
- uint32_t cur = 1;
-
- if(name()->cStr()[0] != J3Cst::ID_Left)
- loader()->wrongType(0, name());
-
- while(name()->cStr()[cur] != J3Cst::ID_Right)
- args[nbArgs++] = loader()->getTypeInternal(0, name(), cur, &cur, 0);
+llvm::FunctionType* J3Signature::functionType(uint32_t access) {
+ return llvmSignature(access)->functionType;
+}
- _nbIns = nbArgs;
- _ins = (J3Type**)loader()->allocator()->allocate(nbArgs*sizeof(J3Type*));
- memcpy(_ins, args, nbArgs*sizeof(J3Type*));
+uint32_t J3Signature::nbIns() {
+ return functionType(J3Cst::ACC_STATIC)->getNumParams();
+}
- _out = loader()->getTypeInternal(0, name(), cur+1, &cur, 0); /* has to be the last (thread safety) */
- if(cur != name()->length())
- loader()->wrongType(0, name());
- }
+J3Signature::function_t J3Signature::caller(uint32_t access) {
+ if(!_virtualLLVMSignature)
+ J3::internalError("sould not happen");
+ return llvmSignature(access)->caller;
}
-J3Signature::function_t J3Signature::caller(uint32_t access) {
- return llvmSignature(access)->z_caller();
+void J3Signature::setCaller(uint32_t access, J3Signature::function_t caller) {
+ llvmSignature(access)->caller = caller;
}
void J3Signature::generateCallerIR(uint32_t access, J3CodeGen* codeGen, llvm::Module* module, const char* id) {
@@ -145,23 +170,3 @@ void J3Signature::generateCallerIR(uint3
builder.CreateRet(res);
}
-
-void J3Signature::setCaller(uint32_t access, J3Signature::function_t caller) {
- llvmSignature(access)->z_setCaller(caller);
-}
-
-void J3Signature::setLLVMSignature(uint32_t access, J3LLVMSignature* llvmSignature) {
- if(J3Cst::isStatic(access))
- _staticLLVMSignature = llvmSignature;
- else
- _virtualLLVMSignature = llvmSignature;
-}
-
-J3LLVMSignature* J3Signature::llvmSignature(uint32_t access) {
- checkFunctionType();
- return J3Cst::isStatic(access) ? _staticLLVMSignature : _virtualLLVMSignature;
-}
-
-J3LLVMSignature::J3LLVMSignature(llvm::FunctionType* functionType) {
- _functionType = functionType;
-}
More information about the vmkit-commits
mailing list