[vmkit-commits] [vmkit] r67186 - in /vmkit/trunk: include/jnjvm/ include/mvm/ lib/JnJVM/Compiler/ lib/JnJVM/VMCore/ lib/Mvm/Runtime/ lib/N3/Mono/ lib/N3/PNetLib/ lib/N3/VMCore/ tools/jnjvm/ tools/vmjc/ tools/vmkit/
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Wed Mar 18 01:31:45 PDT 2009
Author: geoffray
Date: Wed Mar 18 03:31:45 2009
New Revision: 67186
URL: http://llvm.org/viewvc/llvm-project?rev=67186&view=rev
Log:
Major code refactoring: move all llvm dependencies in jnjvm to
lib/JnJVM/Compiler. Add a new class JavaCompiler, which contains
the operations needed by VMCore. JIT and AOT compilers inherit
from this class. More refactoring to come.
Added:
vmkit/trunk/include/jnjvm/JavaCompiler.h
Modified:
vmkit/trunk/include/jnjvm/JnjvmModule.h
vmkit/trunk/include/jnjvm/JnjvmModuleProvider.h
vmkit/trunk/include/mvm/JIT.h
vmkit/trunk/include/mvm/VirtualMachine.h
vmkit/trunk/lib/JnJVM/Compiler/ExceptionsCheck.inc
vmkit/trunk/lib/JnJVM/Compiler/JITInfo.cpp
vmkit/trunk/lib/JnJVM/Compiler/JavaJIT.cpp
vmkit/trunk/lib/JnJVM/Compiler/JavaJIT.h
vmkit/trunk/lib/JnJVM/Compiler/JavaJITOpcodes.cpp
vmkit/trunk/lib/JnJVM/Compiler/JnjvmModule.cpp
vmkit/trunk/lib/JnJVM/Compiler/JnjvmModuleAOT.cpp
vmkit/trunk/lib/JnJVM/Compiler/JnjvmModuleJIT.cpp
vmkit/trunk/lib/JnJVM/Compiler/JnjvmModuleProvider.cpp
vmkit/trunk/lib/JnJVM/Compiler/LowerConstantCalls.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp
vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h
vmkit/trunk/lib/Mvm/Runtime/JIT.cpp
vmkit/trunk/lib/N3/Mono/MonoString.cpp
vmkit/trunk/lib/N3/PNetLib/PNetString.cpp
vmkit/trunk/lib/N3/VMCore/CLIJit.cpp
vmkit/trunk/lib/N3/VMCore/CLIJitMeta.cpp
vmkit/trunk/lib/N3/VMCore/N3.cpp
vmkit/trunk/lib/N3/VMCore/VMThread.cpp
vmkit/trunk/lib/N3/VMCore/VirtualMachine.h
vmkit/trunk/tools/jnjvm/Main.cpp
vmkit/trunk/tools/vmjc/vmjc.cpp
vmkit/trunk/tools/vmkit/CommandLine.cpp
vmkit/trunk/tools/vmkit/CommandLine.h
vmkit/trunk/tools/vmkit/Launcher.cpp
Added: vmkit/trunk/include/jnjvm/JavaCompiler.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/jnjvm/JavaCompiler.h?rev=67186&view=auto
==============================================================================
--- vmkit/trunk/include/jnjvm/JavaCompiler.h (added)
+++ vmkit/trunk/include/jnjvm/JavaCompiler.h Wed Mar 18 03:31:45 2009
@@ -0,0 +1,36 @@
+
+#ifndef JAVA_COMPILER_H
+#define JAVA_COMPILER_H
+
+namespace llvm {
+ class Function;
+}
+
+namespace jnjvm {
+
+class Class;
+class JavaMethod;
+class Signdef;
+
+class JavaCompiler {
+public:
+
+ virtual void* materializeFunction(JavaMethod* meth) = 0;
+ virtual llvm::Function* parseFunction(JavaMethod* meth) = 0;
+ virtual void setMethod(JavaMethod* meth, void* ptr, const char* name) = 0;
+ virtual bool isStaticCompiling() = 0;
+ virtual void resolveVirtualClass(Class* cl) = 0;
+ virtual void resolveStaticClass(Class* cl) = 0;
+
+ virtual JavaCompiler* Create(std::string) = 0;
+
+ virtual void staticCallBuf(Signdef* sign) = 0;
+ virtual void virtualCallBuf(Signdef* sign) = 0;
+ virtual void staticCallAP(Signdef* sign) = 0;
+ virtual void virtualCallAP(Signdef* sign) = 0;
+
+};
+
+}
+
+#endif
Modified: vmkit/trunk/include/jnjvm/JnjvmModule.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/jnjvm/JnjvmModule.h?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/include/jnjvm/JnjvmModule.h (original)
+++ vmkit/trunk/include/jnjvm/JnjvmModule.h Wed Mar 18 03:31:45 2009
@@ -17,6 +17,8 @@
#include "llvm/Support/Annotation.h"
+#include "JavaCompiler.h"
+
namespace llvm {
class Constant;
class ConstantInt;
@@ -62,7 +64,7 @@
class LLVMClassInfo : public mvm::JITInfo {
- friend class JnjvmModule;
+ friend class JavaLLVMCompiler;
private:
Class* classDef;
/// virtualSizeLLVM - The LLVM constant size of instances of this class.
@@ -186,7 +188,6 @@
};
class JnjvmModule : public mvm::MvmModule {
- friend class LLVMClassInfo;
public:
static llvm::ConstantInt* JavaArraySizeOffsetConstant;
@@ -327,9 +328,23 @@
llvm::Function* OutOfMemoryErrorFunction;
llvm::Function* NegativeArraySizeExceptionFunction;
- static llvm::Function* NativeLoader;
+
+ JnjvmModule(llvm::Module*);
+
+ static void initialise();
+
+};
+
+class JavaLLVMCompiler : public JavaCompiler {
+ friend class LLVMClassInfo;
+
protected:
+
+ llvm::Module* TheModule;
+ llvm::ModuleProvider* TheModuleProvider;
+ JnjvmModule JavaIntrinsics;
+
#ifdef WITH_TRACER
llvm::Function* internalMakeTracer(Class* cl, bool stat);
virtual llvm::Function* makeTracer(Class* cl, bool stat) {
@@ -346,7 +361,6 @@
private:
- static void initialise();
bool enabledException;
@@ -361,11 +375,18 @@
public:
- JnjvmModule(const std::string &ModuleID);
+ JavaLLVMCompiler(const std::string &ModuleID);
-
virtual bool isStaticCompiling() = 0;
+ llvm::Module* getLLVMModule() {
+ return TheModule;
+ }
+
+ JnjvmModule* getIntrinsics() {
+ return &JavaIntrinsics;
+ }
+
bool hasExceptionsEnabled() {
return enabledException;
}
@@ -374,15 +395,15 @@
enabledException = false;
}
- virtual JnjvmModule* Create(std::string ModuleID) = 0;
+ virtual JavaCompiler* Create(std::string ModuleID) = 0;
- virtual ~JnjvmModule();
+ virtual ~JavaLLVMCompiler();
llvm::Constant* getReferenceArrayVT();
llvm::Constant* getPrimitiveArrayVT();
- static void resolveVirtualClass(Class* cl);
- static void resolveStaticClass(Class* cl);
+ void resolveVirtualClass(Class* cl);
+ void resolveStaticClass(Class* cl);
static llvm::Function* getMethod(JavaMethod* meth);
static LLVMSignatureInfo* getSignatureInfo(Signdef* sign);
@@ -420,13 +441,30 @@
virtual llvm::Function* addCallback(Class* cl, uint16 index, Signdef* sign,
bool stat) = 0;
+
+ virtual void staticCallBuf(Signdef* sign) {
+ getSignatureInfo(sign)->getStaticBuf();
+ }
+
+ virtual void virtualCallBuf(Signdef* sign) {
+ getSignatureInfo(sign)->getVirtualBuf();
+ }
+ virtual void staticCallAP(Signdef* sign) {
+ getSignatureInfo(sign)->getStaticAP();
+ }
+
+ virtual void virtualCallAP(Signdef* sign) {
+ getSignatureInfo(sign)->getVirtualAP();
+ }
+
+ llvm::Function* NativeLoader;
};
-class JnjvmModuleJIT : public JnjvmModule {
+class JavaJITCompiler : public JavaLLVMCompiler {
public:
- JnjvmModuleJIT(const std::string &ModuleID);
+ JavaJITCompiler(const std::string &ModuleID);
virtual bool isStaticCompiling() {
return false;
@@ -434,8 +472,8 @@
virtual void makeVT(Class* cl);
- virtual JnjvmModule* Create(std::string ModuleID) {
- return new JnjvmModuleJIT(ModuleID);
+ virtual JavaCompiler* Create(std::string ModuleID) {
+ return new JavaJITCompiler(ModuleID);
}
virtual void* materializeFunction(JavaMethod* meth);
@@ -460,24 +498,24 @@
virtual llvm::Value* getIsolate(Jnjvm* vm, llvm::Value* Where);
#endif
- virtual ~JnjvmModuleJIT() {}
+ virtual ~JavaJITCompiler() {}
virtual llvm::Function* addCallback(Class* cl, uint16 index, Signdef* sign,
bool stat);
};
-class JnjvmModuleAOT : public JnjvmModule {
+class JavaAOTCompiler : public JavaLLVMCompiler {
public:
- JnjvmModuleAOT(const std::string &ModuleID);
+ JavaAOTCompiler(const std::string &ModuleID);
virtual bool isStaticCompiling() {
return true;
}
- virtual JnjvmModule* Create(std::string ModuleID) {
- return new JnjvmModuleAOT(ModuleID);
+ virtual JavaCompiler* Create(std::string ModuleID) {
+ return new JavaAOTCompiler(ModuleID);
}
virtual void* materializeFunction(JavaMethod* meth) {
@@ -510,7 +548,7 @@
virtual llvm::Value* getIsolate(Jnjvm* vm, llvm::Value* Where);
#endif
- virtual ~JnjvmModuleAOT() {}
+ virtual ~JavaAOTCompiler() {}
private:
@@ -612,7 +650,7 @@
static void setNoInline(Class* cl);
void printStats();
-
+
};
Modified: vmkit/trunk/include/jnjvm/JnjvmModuleProvider.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/jnjvm/JnjvmModuleProvider.h?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/include/jnjvm/JnjvmModuleProvider.h (original)
+++ vmkit/trunk/include/jnjvm/JnjvmModuleProvider.h Wed Mar 18 03:31:45 2009
@@ -14,12 +14,10 @@
namespace jnjvm {
-class JnjvmModuleJIT;
-
class JnjvmModuleProvider : public llvm::ModuleProvider {
public:
- JnjvmModuleProvider(JnjvmModuleJIT *m);
+ JnjvmModuleProvider(llvm::Module* M);
~JnjvmModuleProvider();
bool materializeFunction(llvm::Function *F, std::string *ErrInfo = 0);
Modified: vmkit/trunk/include/mvm/JIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/JIT.h?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/JIT.h (original)
+++ vmkit/trunk/include/mvm/JIT.h Wed Mar 18 03:31:45 2009
@@ -57,20 +57,11 @@
const double NaNDouble = NAN; //0.0 / 0.0;
class MvmModule {
-protected:
- llvm::Module* TheModule;
- llvm::ModuleProvider* TheModuleProvider;
public:
- explicit MvmModule(const std::string& ModuleID);
+ explicit MvmModule(llvm::Module*);
- virtual ~MvmModule();
-
- llvm::Module* getLLVMModule() {
- return TheModule;
- }
-
llvm::Function* exceptionEndCatch;
llvm::Function* exceptionBeginCatch;
llvm::Function* unwindResume;
@@ -188,6 +179,7 @@
static void copyDefinitions(llvm::Module* Dst, llvm::Module* Src);
+ static void AddStandardCompilePasses();
};
} // end namespace mvm
Modified: vmkit/trunk/include/mvm/VirtualMachine.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/VirtualMachine.h?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/VirtualMachine.h (original)
+++ vmkit/trunk/include/mvm/VirtualMachine.h Wed Mar 18 03:31:45 2009
@@ -23,6 +23,11 @@
#include <cassert>
#include <map>
+namespace jnjvm {
+ class JavaCompiler;
+ class JnjvmClassLoader;
+}
+
namespace mvm {
/// VirtualMachine - This class is the root of virtual machine classes. It
@@ -54,8 +59,8 @@
/// waitForExit - Wait until the virtual machine stops its execution.
virtual void waitForExit() = 0;
- static CompilationUnit* initialiseJVM();
- static VirtualMachine* createJVM(CompilationUnit* C = 0);
+ static jnjvm::JnjvmClassLoader* initialiseJVM(jnjvm::JavaCompiler* C = 0);
+ static VirtualMachine* createJVM(jnjvm::JnjvmClassLoader* C = 0);
static CompilationUnit* initialiseCLIVM();
static VirtualMachine* createCLIVM(CompilationUnit* C = 0);
Modified: vmkit/trunk/lib/JnJVM/Compiler/ExceptionsCheck.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/ExceptionsCheck.inc?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/ExceptionsCheck.inc (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/ExceptionsCheck.inc Wed Mar 18 03:31:45 2009
@@ -5,7 +5,7 @@
Instruction* res = CallInst::Create(F, args.begin(), args.end(), Name,
InsertAtEnd);
- if (module->hasExceptionsEnabled()) {
+ if (TheCompiler->hasExceptionsEnabled()) {
Value* threadId = getCurrentThread();
Value* geps[2] = { module->constantZero,
module->OffsetJavaExceptionInThreadConstant };
@@ -43,7 +43,7 @@
Instruction* res = CallInst::Create(F, arg1, Name, InsertAtEnd);
- if (module->hasExceptionsEnabled()) {
+ if (TheCompiler->hasExceptionsEnabled()) {
Value* threadId = getCurrentThread();
Value* geps[2] = { module->constantZero,
module->OffsetJavaExceptionInThreadConstant };
@@ -82,7 +82,7 @@
Instruction* res = CallInst::Create(F, args, args + 2, Name, InsertAtEnd);
- if (module->hasExceptionsEnabled()) {
+ if (TheCompiler->hasExceptionsEnabled()) {
Value* threadId = getCurrentThread();
Value* geps[2] = { module->constantZero,
module->OffsetJavaExceptionInThreadConstant };
@@ -118,7 +118,7 @@
BasicBlock *InsertAtEnd) {
Instruction* res = llvm::CallInst::Create(F, Name, InsertAtEnd);
- if (module->hasExceptionsEnabled()) {
+ if (TheCompiler->hasExceptionsEnabled()) {
Value* threadId = getCurrentThread();
Value* geps[2] = { module->constantZero,
module->OffsetJavaExceptionInThreadConstant };
@@ -343,7 +343,7 @@
#else
// We know catchClass exists because we have loaded all exceptions catched
// by the method when we loaded the class that defined this method.
- clVar = module->getNativeClass(cur->catchClass);
+ clVar = TheCompiler->getNativeClass(cur->catchClass);
#endif
if (clVar->getType() != module->JavaCommonClassType)
clVar = new BitCastInst(clVar, module->JavaCommonClassType, "",
Modified: vmkit/trunk/lib/JnJVM/Compiler/JITInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/JITInfo.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JITInfo.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JITInfo.cpp Wed Mar 18 03:31:45 2009
@@ -42,7 +42,7 @@
if (classDef->super && classDef->super->super) {
LLVMClassInfo* CLI =
- JnjvmModule::getClassInfo((Class*)classDef->super);
+ JavaLLVMCompiler::getClassInfo((Class*)classDef->super);
fields.push_back(CLI->getVirtualType()->getContainedType(0));
} else {
fields.push_back(JnjvmModule::JavaObjectType->getContainedType(0));
@@ -52,15 +52,16 @@
JavaField& field = classDef->virtualFields[i];
field.num = i + 1;
Typedef* type = field.getSignature();
- LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(type);
+ LLVMAssessorInfo& LAI = JavaLLVMCompiler::getTypedefInfo(type);
fields.push_back(LAI.llvmType);
}
- JnjvmModule* Mod = classDef->classLoader->getModule();
+ JavaLLVMCompiler* Mod =
+ (JavaLLVMCompiler*)classDef->classLoader->getModule();
StructType* structType = StructType::get(fields, false);
virtualType = PointerType::getUnqual(structType);
- const TargetData* targetData = Mod->TheTargetData;
+ const TargetData* targetData = JnjvmModule::TheTargetData;
const StructLayout* sl = targetData->getStructLayout(structType);
for (uint32 i = 0; i < classDef->nbVirtualFields; ++i) {
@@ -68,7 +69,7 @@
field.ptrOffset = sl->getElementOffset(i + 1);
}
- uint64 size = Mod->getTypeSize(structType);
+ uint64 size = JnjvmModule::getTypeSize(structType);
classDef->virtualSize = (uint32)size;
virtualSizeConstant = ConstantInt::get(Type::Int32Ty, size);
@@ -84,7 +85,7 @@
Mod->getLLVMModule());
void* ptr = ((void**)classDef->virtualVT)[VT_TRACER_OFFSET];
- Mod->executionEngine->addGlobalMapping(func, ptr);
+ JnjvmModule::executionEngine->addGlobalMapping(func, ptr);
virtualTracerFunction = func;
#endif
}
@@ -107,14 +108,15 @@
JavaField& field = classDef->staticFields[i];
field.num = i;
Typedef* type = field.getSignature();
- LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(type);
+ LLVMAssessorInfo& LAI = JavaLLVMCompiler::getTypedefInfo(type);
fields.push_back(LAI.llvmType);
}
- JnjvmModule* Mod = cl->classLoader->getModule();
+ JavaLLVMCompiler* Mod =
+ (JavaLLVMCompiler*)cl->classLoader->getModule();
StructType* structType = StructType::get(fields, false);
staticType = PointerType::getUnqual(structType);
- const TargetData* targetData = Mod->TheTargetData;
+ const TargetData* targetData = JnjvmModule::TheTargetData;
const StructLayout* sl = targetData->getStructLayout(structType);
for (uint32 i = 0; i < classDef->nbStaticFields; ++i) {
@@ -122,13 +124,13 @@
field.ptrOffset = sl->getElementOffset(i);
}
- uint64 size = Mod->getTypeSize(structType);
+ uint64 size = JnjvmModule::getTypeSize(structType);
cl->staticSize = size;
#ifdef WITH_TRACER
if (!Mod->isStaticCompiling()) {
Function* F = Mod->makeTracer(cl, true);
cl->staticTracer = (void (*)(void*)) (uintptr_t)
- Mod->executionEngine->getPointerToFunction(F);
+ JnjvmModule::executionEngine->getPointerToFunction(F);
F->deleteBody();
}
#endif
@@ -164,7 +166,7 @@
Function* LLVMMethodInfo::getMethod() {
if (!methodFunction) {
JnjvmClassLoader* JCL = methodDef->classDef->classLoader;
- JnjvmModule* Mod = JCL->getModule();
+ JavaLLVMCompiler* Mod = (JavaLLVMCompiler*)JCL->getModule();
if (Mod->isStaticCompiling()) {
const UTF8* jniConsClName = methodDef->classDef->name;
@@ -207,7 +209,7 @@
const FunctionType* LLVMMethodInfo::getFunctionType() {
if (!functionType) {
Signdef* sign = methodDef->getSignature();
- LLVMSignatureInfo* LSI = JnjvmModule::getSignatureInfo(sign);
+ LLVMSignatureInfo* LSI = JavaLLVMCompiler::getSignatureInfo(sign);
assert(LSI);
if (isStatic(methodDef->access)) {
functionType = LSI->getStaticType();
@@ -220,7 +222,9 @@
ConstantInt* LLVMMethodInfo::getOffset() {
if (!offsetConstant) {
- JnjvmModule::resolveVirtualClass(methodDef->classDef);
+ JnjvmClassLoader* JCL = methodDef->classDef->classLoader;
+ JavaCompiler* Mod = JCL->getModule();
+ Mod->resolveVirtualClass(methodDef->classDef);
offsetConstant = ConstantInt::get(Type::Int32Ty, methodDef->offset);
}
return offsetConstant;
@@ -228,10 +232,12 @@
ConstantInt* LLVMFieldInfo::getOffset() {
if (!offsetConstant) {
+ JnjvmClassLoader* JCL = fieldDef->classDef->classLoader;
+ JavaCompiler* Mod = JCL->getModule();
if (isStatic(fieldDef->access)) {
- JnjvmModule::resolveStaticClass(fieldDef->classDef);
+ Mod->resolveStaticClass(fieldDef->classDef);
} else {
- JnjvmModule::resolveVirtualClass(fieldDef->classDef);
+ Mod->resolveVirtualClass(fieldDef->classDef);
}
offsetConstant = ConstantInt::get(Type::Int32Ty, fieldDef->num);
@@ -251,7 +257,7 @@
for (uint32 i = 0; i < size; ++i) {
Typedef* type = arguments[i];
- LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(type);
+ LLVMAssessorInfo& LAI = JavaLLVMCompiler::getTypedefInfo(type);
llvmArgs.push_back(LAI.llvmType);
}
@@ -260,7 +266,7 @@
#endif
LLVMAssessorInfo& LAI =
- JnjvmModule::getTypedefInfo(signature->getReturnType());
+ JavaLLVMCompiler::getTypedefInfo(signature->getReturnType());
virtualType = FunctionType::get(LAI.llvmType, llvmArgs, false);
mvm::MvmModule::unprotectIR();
}
@@ -277,7 +283,7 @@
for (uint32 i = 0; i < size; ++i) {
Typedef* type = arguments[i];
- LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(type);
+ LLVMAssessorInfo& LAI = JavaLLVMCompiler::getTypedefInfo(type);
llvmArgs.push_back(LAI.llvmType);
}
@@ -286,7 +292,7 @@
#endif
LLVMAssessorInfo& LAI =
- JnjvmModule::getTypedefInfo(signature->getReturnType());
+ JavaLLVMCompiler::getTypedefInfo(signature->getReturnType());
staticType = FunctionType::get(LAI.llvmType, llvmArgs, false);
mvm::MvmModule::unprotectIR();
}
@@ -306,7 +312,7 @@
for (uint32 i = 0; i < size; ++i) {
Typedef* type = arguments[i];
- LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(type);
+ LLVMAssessorInfo& LAI = JavaLLVMCompiler::getTypedefInfo(type);
llvmArgs.push_back(LAI.llvmType);
}
@@ -315,7 +321,7 @@
#endif
LLVMAssessorInfo& LAI =
- JnjvmModule::getTypedefInfo(signature->getReturnType());
+ JavaLLVMCompiler::getTypedefInfo(signature->getReturnType());
nativeType = FunctionType::get(LAI.llvmType, llvmArgs, false);
mvm::MvmModule::unprotectIR();
}
@@ -327,7 +333,8 @@
std::vector<Value*> Args;
- JnjvmModule* Mod = signature->initialLoader->getModule();
+ JavaLLVMCompiler* Mod =
+ (JavaLLVMCompiler*)signature->initialLoader->getModule();
const char* name = 0;
if (Mod->isStaticCompiling()) {
name = virt ? signature->printString("virtual_buf") :
@@ -360,7 +367,7 @@
Typedef* const* arguments = signature->getArgumentsType();
for (uint32 i = 0; i < signature->nbArguments; ++i) {
- LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(arguments[i]);
+ LLVMAssessorInfo& LAI = JavaLLVMCompiler::getTypedefInfo(arguments[i]);
Value* val = new BitCastInst(ptr, LAI.llvmTypePtr, "", currentBlock);
Value* arg = new LoadInst(val, "", currentBlock);
Args.push_back(arg);
@@ -386,7 +393,8 @@
std::vector<Value*> Args;
- JnjvmModule* Mod = signature->initialLoader->getModule();
+ JavaLLVMCompiler* Mod =
+ (JavaLLVMCompiler*)signature->initialLoader->getModule();
const char* name = 0;
if (Mod->isStaticCompiling()) {
name = virt ? signature->printString("virtual_ap") :
@@ -418,7 +426,7 @@
Typedef* const* arguments = signature->getArgumentsType();
for (uint32 i = 0; i < signature->nbArguments; ++i) {
- LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(arguments[i]);
+ LLVMAssessorInfo& LAI = JavaLLVMCompiler::getTypedefInfo(arguments[i]);
Args.push_back(new VAArgInst(ap, LAI.llvmType, "", currentBlock));
}
@@ -468,7 +476,7 @@
Args2.push_back(JnjvmModule::JavaObjectType);
Args2.push_back(JnjvmModule::ptrType);
LLVMAssessorInfo& LAI =
- JnjvmModule::getTypedefInfo(signature->getReturnType());
+ JavaLLVMCompiler::getTypedefInfo(signature->getReturnType());
virtualBufType = FunctionType::get(LAI.llvmType, Args2, false);
mvm::MvmModule::unprotectIR();
}
@@ -484,7 +492,7 @@
Args.push_back(getStaticPtrType());
Args.push_back(JnjvmModule::ptrType);
LLVMAssessorInfo& LAI =
- JnjvmModule::getTypedefInfo(signature->getReturnType());
+ JavaLLVMCompiler::getTypedefInfo(signature->getReturnType());
staticBufType = FunctionType::get(LAI.llvmType, Args, false);
mvm::MvmModule::unprotectIR();
}
@@ -626,7 +634,7 @@
std::map<const char, LLVMAssessorInfo> LLVMAssessorInfo::AssessorInfo;
-LLVMAssessorInfo& JnjvmModule::getTypedefInfo(const Typedef* type) {
+LLVMAssessorInfo& JavaLLVMCompiler::getTypedefInfo(const Typedef* type) {
return LLVMAssessorInfo::AssessorInfo[type->getKey()->elements[0]];
}
@@ -644,18 +652,18 @@
return 0;
}
-LLVMSignatureInfo* JnjvmModule::getSignatureInfo(Signdef* sign) {
+LLVMSignatureInfo* JavaLLVMCompiler::getSignatureInfo(Signdef* sign) {
return sign->getInfo<LLVMSignatureInfo>();
}
-LLVMClassInfo* JnjvmModule::getClassInfo(Class* cl) {
+LLVMClassInfo* JavaLLVMCompiler::getClassInfo(Class* cl) {
return cl->getInfo<LLVMClassInfo>();
}
-LLVMFieldInfo* JnjvmModule::getFieldInfo(JavaField* field) {
+LLVMFieldInfo* JavaLLVMCompiler::getFieldInfo(JavaField* field) {
return field->getInfo<LLVMFieldInfo>();
}
-LLVMMethodInfo* JnjvmModule::getMethodInfo(JavaMethod* method) {
+LLVMMethodInfo* JavaLLVMCompiler::getMethodInfo(JavaMethod* method) {
return method->getInfo<LLVMMethodInfo>();
}
Modified: vmkit/trunk/lib/JnJVM/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/JavaJIT.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JavaJIT.cpp Wed Mar 18 03:31:45 2009
@@ -103,7 +103,7 @@
#if !defined(WITHOUT_VTABLE)
Typedef* retTypedef = signature->getReturnType();
std::vector<Value*> args; // size = [signature->nbIn + 3];
- LLVMSignatureInfo* LSI = module->getSignatureInfo(signature);
+ LLVMSignatureInfo* LSI = TheCompiler->getSignatureInfo(signature);
const llvm::FunctionType* virtualType = LSI->getVirtualType();
FunctionType::param_iterator it = virtualType->param_end();
makeArgs(it, index, args, signature->nbArguments + 1);
@@ -154,7 +154,7 @@
Value* indexesCtp; //[3];
#endif
if (meth) {
- LLVMMethodInfo* LMI = module->getMethodInfo(meth);
+ LLVMMethodInfo* LMI = TheCompiler->getMethodInfo(meth);
ConstantInt* Offset = LMI->getOffset();
indexes2[1] = Offset;
#ifdef ISOLATE_SHARING
@@ -247,7 +247,7 @@
natPtr = compilingClass->classLoader->nativeLookup(compilingMethod, jnjvm,
functionName);
- if (!natPtr && !module->isStaticCompiling()) {
+ if (!natPtr && !TheCompiler->isStaticCompiling()) {
fprintf(stderr, "Native function %s not found. Probably "
"not implemented by JnJVM?\n", compilingMethod->printString());
JavaThread::get()->getJVM()->unknownError("can not find native method %s",
@@ -309,7 +309,7 @@
val, "", currentBlock);
nativeArgs.push_back(res);
#else
- Value* cl = module->getJavaClass(compilingClass);
+ Value* cl = TheCompiler->getJavaClass(compilingClass);
nativeArgs.push_back(cl);
#endif
index = 2;
@@ -322,10 +322,10 @@
nativeArgs.push_back(i);
}
- Value* nativeFunc = module->getNativeFunction(compilingMethod, (void*)natPtr);
+ Value* nativeFunc = TheCompiler->getNativeFunction(compilingMethod, (void*)natPtr);
- if (module->isStaticCompiling()) {
- Value* Arg = module->getMethodInClass(compilingMethod);
+ if (TheCompiler->isStaticCompiling()) {
+ Value* Arg = TheCompiler->getMethodInClass(compilingMethod);
// If the global variable is null, then load it.
BasicBlock* unloadedBlock = createBasicBlock("");
@@ -339,7 +339,7 @@
BranchInst::Create(unloadedBlock, endBlock, cmp, currentBlock);
currentBlock = unloadedBlock;
- Value* res = CallInst::Create(module->NativeLoader, Arg, "", currentBlock);
+ Value* res = CallInst::Create(TheCompiler->NativeLoader, Arg, "", currentBlock);
res = new BitCastInst(res, Ty, "", currentBlock);
new StoreInst(res, nativeFunc, currentBlock);
@@ -490,7 +490,7 @@
if (isVirtual(compilingMethod->access)) {
obj = llvmFunction->arg_begin();
} else {
- obj = module->getJavaClass(compilingClass);
+ obj = TheCompiler->getJavaClass(compilingClass);
}
monitorEnter(obj);
}
@@ -500,7 +500,7 @@
if (isVirtual(compilingMethod->access)) {
obj = llvmFunction->arg_begin();
} else {
- obj = module->getJavaClass(compilingClass);
+ obj = TheCompiler->getJavaClass(compilingClass);
}
monitorExit(obj);
}
@@ -528,7 +528,7 @@
reader.seek(codeLen, Reader::SeekCur);
- LLVMMethodInfo* LMI = module->getMethodInfo(compilingMethod);
+ LLVMMethodInfo* LMI = TheCompiler->getMethodInfo(compilingMethod);
assert(LMI);
Function* func = LMI->getMethod();
@@ -887,7 +887,7 @@
compilingMethod->printString());
#ifndef DWARF_EXCEPTIONS
- if (codeLen < 5 && !callsStackWalker && !module->isStaticCompiling())
+ if (codeLen < 5 && !callsStackWalker && !TheCompiler->isStaticCompiling())
compilingMethod->canBeInlined = true;
#endif
@@ -939,7 +939,7 @@
const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[index]);
JavaString* str = compilingClass->classLoader->UTF8ToStr(utf8);
- Value* val = module->getString(str);
+ Value* val = TheCompiler->getString(str);
push(val, false);
#endif
@@ -960,7 +960,7 @@
Value* res = getResolvedCommonClass(index, false, &cl);
#ifndef ISOLATE
- if (cl) res = module->getJavaClass(cl);
+ if (cl) res = TheCompiler->getJavaClass(cl);
else
#endif
@@ -974,7 +974,7 @@
void JavaJIT::JITVerifyNull(Value* obj) {
- if (module->hasExceptionsEnabled()) {
+ if (TheCompiler->hasExceptionsEnabled()) {
Constant* zero = module->JavaObjectNullConstant;
Value* test = new ICmpInst(ICmpInst::ICMP_EQ, obj, zero, "",
currentBlock);
@@ -998,7 +998,7 @@
index = new SExtInst(index, Type::Int32Ty, "", currentBlock);
}
- if (module->hasExceptionsEnabled()) {
+ if (TheCompiler->hasExceptionsEnabled()) {
Value* size = arraySize(obj);
Value* cmp = new ICmpInst(ICmpInst::ICMP_ULT, index, size, "",
@@ -1234,14 +1234,13 @@
void JavaJIT::invokeSpecial(uint16 index, CommonClass* finalCl) {
JavaConstantPool* ctpInfo = compilingClass->ctpInfo;
- JnjvmClassLoader* JCL = compilingClass->classLoader;
JavaMethod* meth = 0;
Signdef* signature = 0;
const UTF8* name = 0;
const UTF8* cl = 0;
ctpInfo->nameOfStaticOrSpecialMethod(index, cl, name, signature);
- LLVMSignatureInfo* LSI = module->getSignatureInfo(signature);
+ LLVMSignatureInfo* LSI = TheCompiler->getSignatureInfo(signature);
const llvm::FunctionType* virtualType = LSI->getVirtualType();
llvm::Instruction* val = 0;
@@ -1300,10 +1299,9 @@
if (!cl) {
CallInst::Create(module->ForceLoadedCheckFunction, Cl, "", currentBlock);
}
- func = JCL->getModule()->addCallback(compilingClass, index,
- signature, false);
+ func = TheCompiler->addCallback(compilingClass, index, signature, false);
} else {
- func = JCL->getModule()->getMethod(meth);
+ func = TheCompiler->getMethod(meth);
}
if (meth && canBeInlined(meth)) {
@@ -1324,12 +1322,11 @@
void JavaJIT::invokeStatic(uint16 index) {
JavaConstantPool* ctpInfo = compilingClass->ctpInfo;
- JnjvmClassLoader* JCL = compilingClass->classLoader;
Signdef* signature = 0;
const UTF8* name = 0;
const UTF8* cl = 0;
ctpInfo->nameOfStaticOrSpecialMethod(index, cl, name, signature);
- LLVMSignatureInfo* LSI = module->getSignatureInfo(signature);
+ LLVMSignatureInfo* LSI = TheCompiler->getSignatureInfo(signature);
const llvm::FunctionType* staticType = LSI->getStaticType();
llvm::Instruction* val = 0;
@@ -1353,10 +1350,9 @@
Function* func = 0;
if (meth) {
- func = JCL->getModule()->getMethod(meth);
+ func = TheCompiler->getMethod(meth);
} else {
- func = JCL->getModule()->addCallback(compilingClass, index,
- signature, true);
+ func = TheCompiler->addCallback(compilingClass, index, signature, true);
}
#if defined(ISOLATE_SHARING)
@@ -1405,8 +1401,8 @@
Cl = new LoadInst(Cl, "", currentBlock);
#else
JavaConstantPool* ctp = compilingClass->ctpInfo;
- Value* CTP = module->getConstantPool(ctp);
- Value* Cl = module->getNativeClass(compilingClass);
+ Value* CTP = TheCompiler->getConstantPool(ctp);
+ Value* Cl = TheCompiler->getNativeClass(compilingClass);
#endif
std::vector<Value*> Args;
@@ -1444,11 +1440,11 @@
Value* node = 0;
if (cl && (!cl->isClass() || cl->asClass()->isResolved())) {
if (alreadyResolved) *alreadyResolved = cl;
- node = module->getNativeClass(cl);
+ node = TheCompiler->getNativeClass(cl);
// Since we only allocate for array classes that we own and
// ony primitive arrays are already allocated, verify that the class
// array is not external.
- if (module->isStaticCompiling() && cl->isArray() &&
+ if (TheCompiler->isStaticCompiling() && cl->isArray() &&
node->getType() != module->JavaClassArrayType) {
node = new LoadInst(node, "", currentBlock);
}
@@ -1472,7 +1468,7 @@
Value* node = 0;
if (cl && cl->isResolved()) {
if (alreadyResolved) (*alreadyResolved) = cl;
- node = module->getNativeClass(cl);
+ node = TheCompiler->getNativeClass(cl);
} else {
node = getConstantPoolAt(index, module->ClassLookupFunction,
module->JavaClassType, 0, doThrow);
@@ -1498,8 +1494,8 @@
Value* Size = 0;
if (cl) {
- VT = module->getVirtualTable(cl);
- LLVMClassInfo* LCI = module->getClassInfo(cl);
+ VT = TheCompiler->getVirtualTable(cl);
+ LLVMClassInfo* LCI = TheCompiler->getClassInfo(cl);
Size = LCI->getVirtualSize();
} else {
VT = CallInst::Create(module->GetVTFromClassFunction, Cl, "",
@@ -1537,12 +1533,12 @@
JavaField* field = info->lookupField(index, stat);
if (field && field->classDef->isResolved()) {
- LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(field->classDef);
- LLVMFieldInfo* LFI = module->getFieldInfo(field);
+ LLVMClassInfo* LCI = TheCompiler->getClassInfo(field->classDef);
+ LLVMFieldInfo* LFI = TheCompiler->getFieldInfo(field);
const Type* type = 0;
if (stat) {
type = LCI->getStaticType();
- Value* Cl = module->getNativeClass(field->classDef);
+ Value* Cl = TheCompiler->getNativeClass(field->classDef);
bool needsCheck = needsInitialisationCheck(field->classDef,
compilingClass);
if (needsCheck) {
@@ -1555,7 +1551,7 @@
currentBlock);
}
- object = module->getStaticInstance(field->classDef);
+ object = TheCompiler->getStaticInstance(field->classDef);
#else
object = CallInst::Create(module->GetStaticInstanceFunction, Cl, "",
currentBlock);
@@ -1627,7 +1623,7 @@
Value* val = pop();
Typedef* sign = compilingClass->ctpInfo->infoOfField(index);
- LLVMAssessorInfo& LAI = module->getTypedefInfo(sign);
+ LLVMAssessorInfo& LAI = TheCompiler->getTypedefInfo(sign);
const Type* type = LAI.llvmType;
if (type == Type::Int64Ty || type == Type::DoubleTy) {
@@ -1645,7 +1641,7 @@
void JavaJIT::getStaticField(uint16 index) {
Typedef* sign = compilingClass->ctpInfo->infoOfField(index);
- LLVMAssessorInfo& LAI = module->getTypedefInfo(sign);
+ LLVMAssessorInfo& LAI = TheCompiler->getTypedefInfo(sign);
const Type* type = LAI.llvmType;
Value* ptr = ldResolved(index, true, 0, type, LAI.llvmTypePtr);
@@ -1689,7 +1685,7 @@
}
} else {
JavaObject* val = field->getObjectField(Obj);
- Value* V = module->getFinalObject(val);
+ Value* V = TheCompiler->getFinalObject(val);
push(V, false);
}
}
@@ -1706,7 +1702,7 @@
bool unsign = topSign();
Value* val = pop();
Typedef* sign = compilingClass->ctpInfo->infoOfField(index);
- LLVMAssessorInfo& LAI = module->getTypedefInfo(sign);
+ LLVMAssessorInfo& LAI = TheCompiler->getTypedefInfo(sign);
const Type* type = LAI.llvmType;
if (type == Type::Int64Ty || type == Type::DoubleTy) {
@@ -1726,7 +1722,7 @@
void JavaJIT::getVirtualField(uint16 index) {
Typedef* sign = compilingClass->ctpInfo->infoOfField(index);
- LLVMAssessorInfo& LAI = module->getTypedefInfo(sign);
+ LLVMAssessorInfo& LAI = TheCompiler->getTypedefInfo(sign);
const Type* type = LAI.llvmType;
Value* obj = pop();
JITVerifyNull(obj);
@@ -1782,7 +1778,7 @@
const UTF8* name = 0;
Signdef* signature = ctpInfo->infoOfInterfaceOrVirtualMethod(index, name);
- LLVMSignatureInfo* LSI = module->getSignatureInfo(signature);
+ LLVMSignatureInfo* LSI = TheCompiler->getSignatureInfo(signature);
const llvm::FunctionType* virtualType = LSI->getVirtualType();
const llvm::PointerType* virtualPtrType = LSI->getVirtualPtrType();
@@ -1811,7 +1807,7 @@
if (!inlining)
enveloppe.initialise(compilingClass, name, signature->keyName);
- Value* llvmEnv = module->getEnveloppe(&enveloppe);
+ Value* llvmEnv = TheCompiler->getEnveloppe(&enveloppe);
#else
Value* llvmEnv = getConstantPoolAt(index,
module->EnveloppeLookupFunction,
Modified: vmkit/trunk/lib/JnJVM/Compiler/JavaJIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/JavaJIT.h?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JavaJIT.h (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JavaJIT.h Wed Mar 18 03:31:45 2009
@@ -59,7 +59,8 @@
nbEnveloppes = 0;
compilingMethod = meth;
compilingClass = meth->classDef;
- module = compilingClass->classLoader->getModule();
+ TheCompiler = (JavaLLVMCompiler*)compilingClass->classLoader->getModule();
+ module = TheCompiler->getIntrinsics();
llvmFunction = func;
inlining = false;
callsStackWalker = false;
@@ -89,6 +90,10 @@
/// module - The LLVM module where lives the compiling LLVM function.
JnjvmModule* module;
+
+ /// TheCompiler - The LLVM Java compiler.
+ ///
+ JavaLLVMCompiler* TheCompiler;
/// locals - The locals of the method.
std::vector<llvm::Value*> intLocals;
Modified: vmkit/trunk/lib/JnJVM/Compiler/JavaJITOpcodes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/JavaJITOpcodes.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JavaJITOpcodes.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JavaJITOpcodes.cpp Wed Mar 18 03:31:45 2009
@@ -1848,7 +1848,7 @@
JnjvmBootstrapLoader* loader =
compilingClass->classLoader->bootstrapLoader;
UserClassArray* dcl = loader->getArrayClass(id);
- valCl = module->getNativeClass(dcl);
+ valCl = TheCompiler->getNativeClass(dcl);
if (valCl->getType() != module->JavaCommonClassType)
valCl = new BitCastInst(valCl, module->JavaCommonClassType, "",
currentBlock);
@@ -1861,7 +1861,7 @@
LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[charId];
sizeElement = LAI.sizeInBytesConstant;
- TheVT = module->getPrimitiveArrayVT();
+ TheVT = TheCompiler->getPrimitiveArrayVT();
} else {
uint16 index = readU2(bytecodes, i);
CommonClass* cl = 0;
@@ -1872,12 +1872,12 @@
const UTF8* arrayName = JCL->constructArrayName(1, cl->name);
UserClassArray* dcl = JCL->constructArray(arrayName);
- valCl = module->getNativeClass(dcl);
+ valCl = TheCompiler->getNativeClass(dcl);
// If we're static compiling and the class is not a class we
// are compiling, the result of getNativeClass is a pointer to
// the class. Load it.
- if (module->isStaticCompiling() &&
+ if (TheCompiler->isStaticCompiling() &&
valCl->getType() != module->JavaClassArrayType) {
valCl = new LoadInst(valCl, "", currentBlock);
}
@@ -1896,11 +1896,11 @@
}
sizeElement = module->constantPtrSize;
- TheVT = module->getReferenceArrayVT();
+ TheVT = TheCompiler->getReferenceArrayVT();
}
Value* arg1 = popAsInt();
- if (module->hasExceptionsEnabled()) {
+ if (TheCompiler->hasExceptionsEnabled()) {
Value* cmp = new ICmpInst(ICmpInst::ICMP_SLT, arg1,
module->constantZero, "", currentBlock);
@@ -1979,7 +1979,7 @@
}
case CHECKCAST :
- if (!module->hasExceptionsEnabled()) {
+ if (!TheCompiler->hasExceptionsEnabled()) {
i += 2;
break;
}
Modified: vmkit/trunk/lib/JnJVM/Compiler/JnjvmModule.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/JnjvmModule.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JnjvmModule.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JnjvmModule.cpp Wed Mar 18 03:31:45 2009
@@ -31,8 +31,6 @@
extern void* JavaObjectVT[];
-llvm::Function* JnjvmModule::NativeLoader;
-
#ifdef WITH_TRACER
const llvm::FunctionType* JnjvmModule::MarkAndTraceType = 0;
#endif
@@ -87,8 +85,14 @@
llvm::ConstantInt* JnjvmModule::JavaObjectClassOffsetConstant;
+JavaLLVMCompiler::JavaLLVMCompiler(const std::string& str) :
+ TheModule(new llvm::Module(str)), JavaIntrinsics(TheModule) {
+
+ enabledException = true;
+}
+
#ifndef WITHOUT_VTABLE
-void JnjvmModule::allocateVT(Class* cl) {
+void JavaLLVMCompiler::allocateVT(Class* cl) {
for (uint32 i = 0; i < cl->nbVirtualMethods; ++i) {
JavaMethod& meth = cl->virtualMethods[i];
if (meth.name->equals(cl->classLoader->bootstrapLoader->finalize)) {
@@ -130,9 +134,9 @@
#ifdef WITH_TRACER
-llvm::Function* JnjvmModule::internalMakeTracer(Class* cl, bool stat) {
+llvm::Function* JavaLLVMCompiler::internalMakeTracer(Class* cl, bool stat) {
- LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl);
+ LLVMClassInfo* LCI = getClassInfo(cl);
const Type* type = stat ? LCI->getStaticType() : LCI->getVirtualType();
JavaField* fields = 0;
uint32 nbFields = 0;
@@ -161,8 +165,8 @@
#endif
if (!stat) {
if (cl->super == 0) {
- CallInst::Create(JavaObjectTracerFunction, Args.begin(), Args.end(),
- "", block);
+ CallInst::Create(JavaIntrinsics.JavaObjectTracerFunction, Args.begin(),
+ Args.end(), "", block);
} else {
LLVMClassInfo* LCP = (LLVMClassInfo*)getClassInfo((Class*)(cl->super));
@@ -196,7 +200,7 @@
#ifdef MULTIPLE_GC
Args.push_back(GC);
#endif
- CallInst::Create(JnjvmModule::MarkAndTraceFunction, Args.begin(),
+ CallInst::Create(JavaIntrinsics.MarkAndTraceFunction, Args.begin(),
Args.end(), "", block);
}
}
@@ -214,7 +218,7 @@
#endif
-void JnjvmModule::internalMakeVT(Class* cl) {
+void JavaLLVMCompiler::internalMakeVT(Class* cl) {
VirtualTable* VT = 0;
#ifdef WITHOUT_VTABLE
@@ -239,7 +243,7 @@
#endif
}
-void JnjvmModule::resolveVirtualClass(Class* cl) {
+void JavaLLVMCompiler::resolveVirtualClass(Class* cl) {
// Lock here because we may be called by a class resolver
mvm::MvmModule::protectIR();
LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl);
@@ -247,7 +251,7 @@
mvm::MvmModule::unprotectIR();
}
-void JnjvmModule::resolveStaticClass(Class* cl) {
+void JavaLLVMCompiler::resolveStaticClass(Class* cl) {
// Lock here because we may be called by a class initializer
mvm::MvmModule::protectIR();
LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl);
@@ -361,23 +365,21 @@
LLVMAssessorInfo::initialise();
}
-Constant* JnjvmModule::getReferenceArrayVT() {
+Constant* JavaLLVMCompiler::getReferenceArrayVT() {
return ReferenceArrayVT;
}
-Constant* JnjvmModule::getPrimitiveArrayVT() {
+Constant* JavaLLVMCompiler::getPrimitiveArrayVT() {
return PrimitiveArrayVT;
}
-Function* JnjvmModule::getMethod(JavaMethod* meth) {
+Function* JavaLLVMCompiler::getMethod(JavaMethod* meth) {
return getMethodInfo(meth)->getMethod();
}
-JnjvmModule::JnjvmModule(const std::string &ModuleID) :
- MvmModule(ModuleID) {
+JnjvmModule::JnjvmModule(llvm::Module* module) :
+ MvmModule(module) {
- Module* module = getLLVMModule();
- enabledException = true;
if (!VTType) {
initialise();
copyDefinitions(module, globalModule);
@@ -500,29 +502,30 @@
}
-Function* JnjvmModule::parseFunction(JavaMethod* meth) {
+Function* JavaLLVMCompiler::parseFunction(JavaMethod* meth) {
LLVMMethodInfo* LMI = getMethodInfo(meth);
Function* func = LMI->getMethod();
if (func->hasNotBeenReadFromBitcode()) {
// We are jitting. Take the lock.
- protectIR();
+ JnjvmModule::protectIR();
JavaJIT jit(meth, func);
if (isNative(meth->access)) {
jit.nativeCompile();
- runPasses(func, JavaNativeFunctionPasses);
+ JnjvmModule::runPasses(func, JavaNativeFunctionPasses);
} else {
jit.javaCompile();
- runPasses(func, globalFunctionPasses);
- runPasses(func, JavaFunctionPasses);
+ JnjvmModule::runPasses(func, JnjvmModule::globalFunctionPasses);
+ JnjvmModule::runPasses(func, JavaFunctionPasses);
}
- unprotectIR();
+ JnjvmModule::unprotectIR();
}
return func;
}
-JnjvmModule::~JnjvmModule() {
+JavaLLVMCompiler::~JavaLLVMCompiler() {
delete JavaFunctionPasses;
delete JavaNativeFunctionPasses;
+ delete TheModuleProvider;
}
namespace mvm {
@@ -533,7 +536,7 @@
llvm::FunctionPass* createLowerConstantCallsPass();
}
-void JnjvmModule::addJavaPasses() {
+void JavaLLVMCompiler::addJavaPasses() {
JavaNativeFunctionPasses = new FunctionPassManager(TheModuleProvider);
JavaNativeFunctionPasses->add(new TargetData(TheModule));
// Lower constant calls to lower things like getClass used
@@ -542,7 +545,7 @@
JavaFunctionPasses = new FunctionPassManager(TheModuleProvider);
JavaFunctionPasses->add(new TargetData(TheModule));
- Function* func = JavaObjectAllocateFunction;
+ Function* func = JavaIntrinsics.JavaObjectAllocateFunction;
JavaFunctionPasses->add(mvm::createEscapeAnalysisPass(func));
JavaFunctionPasses->add(createLowerConstantCallsPass());
}
Modified: vmkit/trunk/lib/JnJVM/Compiler/JnjvmModuleAOT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/JnjvmModuleAOT.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JnjvmModuleAOT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JnjvmModuleAOT.cpp Wed Mar 18 03:31:45 2009
@@ -1,4 +1,4 @@
-//===----- JnjvmModuleAOT.cpp - Support for Ahead of Time Compiler --------===//
+//===----- JavaAOTCompiler.cpp - Support for Ahead of Time Compiler --------===//
//
// JnJVM
//
@@ -43,7 +43,7 @@
extern ClassArray ArrayOfDouble;
extern ClassArray ArrayOfLong;
-bool JnjvmModuleAOT::isCompiling(const CommonClass* cl) const {
+bool JavaAOTCompiler::isCompiling(const CommonClass* cl) const {
if (cl->isClass()) {
// A class is being static compiled if owner class is not null.
return (((Class*)cl)->getOwnerClass() != 0);
@@ -54,7 +54,7 @@
}
}
-Constant* JnjvmModuleAOT::getNativeClass(CommonClass* classDef) {
+Constant* JavaAOTCompiler::getNativeClass(CommonClass* classDef) {
if (classDef->isClass() ||
(classDef->isArray() && isCompiling(classDef)) ||
@@ -66,9 +66,9 @@
const llvm::Type* Ty = 0;
if (classDef->isArray()) {
- Ty = JavaClassArrayType->getContainedType(0);
+ Ty = JnjvmModule::JavaClassArrayType->getContainedType(0);
} else {
- Ty = JavaClassType->getContainedType(0);
+ Ty = JnjvmModule::JavaClassType->getContainedType(0);
}
GlobalVariable* varGV =
@@ -94,7 +94,7 @@
array_class_iterator End = arrayClasses.end();
array_class_iterator I = arrayClasses.find((ClassArray*)classDef);
if (I == End) {
- const llvm::Type* Ty = JavaClassArrayType;
+ const llvm::Type* Ty = JnjvmModule::JavaClassArrayType;
GlobalVariable* varGV =
new GlobalVariable(Ty, false, GlobalValue::InternalLinkage,
@@ -112,12 +112,12 @@
return 0;
}
-Constant* JnjvmModuleAOT::getConstantPool(JavaConstantPool* ctp) {
+Constant* JavaAOTCompiler::getConstantPool(JavaConstantPool* ctp) {
llvm::Constant* varGV = 0;
constant_pool_iterator End = constantPools.end();
constant_pool_iterator I = constantPools.find(ctp);
if (I == End) {
- const Type* Ty = ConstantPoolType->getContainedType(0);
+ const Type* Ty = JnjvmModule::ConstantPoolType->getContainedType(0);
varGV = new GlobalVariable(Ty, false,
GlobalValue::InternalLinkage,
Constant::getNullValue(Ty), "", getLLVMModule());
@@ -128,7 +128,7 @@
}
}
-Constant* JnjvmModuleAOT::getMethodInClass(JavaMethod* meth) {
+Constant* JavaAOTCompiler::getMethodInClass(JavaMethod* meth) {
Class* cl = meth->classDef;
Constant* MOffset = 0;
Constant* Array = 0;
@@ -140,11 +140,11 @@
}
}
Array = SI->second;
- Constant* GEPs[2] = { constantZero, MOffset };
+ Constant* GEPs[2] = { JnjvmModule::constantZero, MOffset };
return ConstantExpr::getGetElementPtr(Array, GEPs, 2);
}
-Constant* JnjvmModuleAOT::getString(JavaString* str) {
+Constant* JavaAOTCompiler::getString(JavaString* str) {
string_iterator SI = strings.find(str);
if (SI != strings.end()) {
return SI->second;
@@ -157,7 +157,7 @@
GlobalValue::InternalLinkage,
0, "", getLLVMModule());
Constant* res = ConstantExpr::getCast(Instruction::BitCast, varGV,
- JavaObjectType);
+ JnjvmModule::JavaObjectType);
strings.insert(std::make_pair(str, res));
Constant* C = CreateConstantFromJavaString(str);
varGV->setInitializer(C);
@@ -165,13 +165,13 @@
}
}
-Constant* JnjvmModuleAOT::getEnveloppe(Enveloppe* enveloppe) {
+Constant* JavaAOTCompiler::getEnveloppe(Enveloppe* enveloppe) {
enveloppe_iterator SI = enveloppes.find(enveloppe);
if (SI != enveloppes.end()) {
return SI->second;
} else {
GlobalVariable* varGV =
- new GlobalVariable(EnveloppeType->getContainedType(0), false,
+ new GlobalVariable(JnjvmModule::EnveloppeType->getContainedType(0), false,
GlobalValue::InternalLinkage, 0, "", getLLVMModule());
enveloppes.insert(std::make_pair(enveloppe, varGV));
@@ -181,7 +181,7 @@
}
}
-Constant* JnjvmModuleAOT::getJavaClass(CommonClass* cl) {
+Constant* JavaAOTCompiler::getJavaClass(CommonClass* cl) {
java_class_iterator End = javaClasses.end();
java_class_iterator I = javaClasses.find(cl);
if (I == End) {
@@ -194,7 +194,7 @@
GlobalValue::InternalLinkage, 0, "", getLLVMModule());
Constant* res = ConstantExpr::getCast(Instruction::BitCast, varGV,
- JavaObjectType);
+ JnjvmModule::JavaObjectType);
javaClasses.insert(std::make_pair(cl, res));
varGV->setInitializer(CreateConstantFromJavaClass(cl));
@@ -204,13 +204,13 @@
}
}
-JavaObject* JnjvmModuleAOT::getFinalObject(llvm::Value* obj) {
+JavaObject* JavaAOTCompiler::getFinalObject(llvm::Value* obj) {
return 0;
}
-Constant* JnjvmModuleAOT::getFinalObject(JavaObject* obj) {
+Constant* JavaAOTCompiler::getFinalObject(JavaObject* obj) {
final_object_iterator End = finalObjects.end();
final_object_iterator I = finalObjects.find(obj);
if (I == End) {
@@ -221,7 +221,7 @@
}
}
-Constant* JnjvmModuleAOT::CreateConstantFromStaticInstance(Class* cl) {
+Constant* JavaAOTCompiler::CreateConstantFromStaticInstance(Class* cl) {
LLVMClassInfo* LCI = getClassInfo(cl);
const Type* Ty = LCI->getStaticType();
const StructType* STy = dyn_cast<StructType>(Ty->getContainedType(0));
@@ -256,7 +256,7 @@
const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[idx]);
JavaString* obj = ctpInfo->resolveString(utf8, idx);
Constant* C = getString(obj);
- C = ConstantExpr::getBitCast(C, JavaObjectType);
+ C = ConstantExpr::getBitCast(C, JnjvmModule::JavaObjectType);
Elts.push_back(C);
} else {
fprintf(stderr, "Implement me");
@@ -268,7 +268,7 @@
return ConstantStruct::get(STy, Elts);
}
-Constant* JnjvmModuleAOT::getStaticInstance(Class* classDef) {
+Constant* JavaAOTCompiler::getStaticInstance(Class* classDef) {
#ifdef ISOLATE
assert(0 && "Should not be here");
abort();
@@ -285,7 +285,7 @@
0, classDef->printString("<static>"), getLLVMModule());
Constant* res = ConstantExpr::getCast(Instruction::BitCast, varGV,
- ptrType);
+ JnjvmModule::ptrType);
staticInstances.insert(std::make_pair(classDef, res));
if (isCompiling(classDef)) {
@@ -299,7 +299,7 @@
}
}
-Constant* JnjvmModuleAOT::getVirtualTable(Class* classDef) {
+Constant* JavaAOTCompiler::getVirtualTable(Class* classDef) {
LLVMClassInfo* LCI = getClassInfo((Class*)classDef);
LCI->getVirtualType();
llvm::Constant* res = 0;
@@ -307,7 +307,8 @@
virtual_table_iterator I = virtualTables.find(classDef);
if (I == End) {
- const ArrayType* ATy = dyn_cast<ArrayType>(VTType->getContainedType(0));
+ 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);
// Do not set a virtual table as a constant, because the runtime may
@@ -318,7 +319,8 @@
classDef->printString("<VT>"),
getLLVMModule());
- res = ConstantExpr::getCast(Instruction::BitCast, varGV, VTType);
+ res = ConstantExpr::getCast(Instruction::BitCast, varGV,
+ JnjvmModule::VTType);
virtualTables.insert(std::make_pair(classDef, res));
if (isCompiling(classDef)) {
@@ -332,7 +334,7 @@
}
}
-Constant* JnjvmModuleAOT::getNativeFunction(JavaMethod* meth, void* ptr) {
+Constant* JavaAOTCompiler::getNativeFunction(JavaMethod* meth, void* ptr) {
llvm::Constant* varGV = 0;
native_function_iterator End = nativeFunctions.end();
native_function_iterator I = nativeFunctions.find(meth);
@@ -352,9 +354,9 @@
}
}
-Constant* JnjvmModuleAOT::CreateConstantForBaseObject(CommonClass* cl) {
+Constant* JavaAOTCompiler::CreateConstantForBaseObject(CommonClass* cl) {
const StructType* STy =
- dyn_cast<StructType>(JavaObjectType->getContainedType(0));
+ dyn_cast<StructType>(JnjvmModule::JavaObjectType->getContainedType(0));
std::vector<Constant*> Elmts;
@@ -372,7 +374,8 @@
// classof
Constant* Cl = getNativeClass(cl);
- Constant* ClGEPs[2] = { constantZero, constantZero };
+ Constant* ClGEPs[2] = { JnjvmModule::constantZero,
+ JnjvmModule::constantZero };
Cl = ConstantExpr::getGetElementPtr(Cl, ClGEPs, 2);
Elmts.push_back(Cl);
@@ -380,12 +383,12 @@
// lock
Constant* L = ConstantInt::get(Type::Int64Ty,
mvm::Thread::get()->getThreadID());
- Elmts.push_back(ConstantExpr::getIntToPtr(L, ptrType));
+ Elmts.push_back(ConstantExpr::getIntToPtr(L, JnjvmModule::ptrType));
return ConstantStruct::get(STy, Elmts);
}
-Constant* JnjvmModuleAOT::CreateConstantFromJavaClass(CommonClass* cl) {
+Constant* JavaAOTCompiler::CreateConstantFromJavaClass(CommonClass* cl) {
Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(javaClass);
const StructType* STy =
@@ -397,23 +400,24 @@
Elmts.push_back(CreateConstantForBaseObject(javaClass));
// signers
- Elmts.push_back(Constant::getNullValue(JavaObjectType));
+ Elmts.push_back(Constant::getNullValue(JnjvmModule::JavaObjectType));
// pd
- Elmts.push_back(Constant::getNullValue(JavaObjectType));
+ Elmts.push_back(Constant::getNullValue(JnjvmModule::JavaObjectType));
// vmdata
Constant* Cl = getNativeClass(cl);
- Cl = ConstantExpr::getCast(Instruction::BitCast, Cl, JavaObjectType);
+ Cl = ConstantExpr::getCast(Instruction::BitCast, Cl,
+ JnjvmModule::JavaObjectType);
Elmts.push_back(Cl);
// constructor
- Elmts.push_back(Constant::getNullValue(JavaObjectType));
+ Elmts.push_back(Constant::getNullValue(JnjvmModule::JavaObjectType));
return ConstantStruct::get(STy, Elmts);
}
-Constant* JnjvmModuleAOT::CreateConstantFromJavaObject(JavaObject* obj) {
+Constant* JavaAOTCompiler::CreateConstantFromJavaObject(JavaObject* obj) {
CommonClass* cl = obj->getClass();
if (cl->isArray()) {
@@ -449,7 +453,7 @@
}
} else {
return CreateConstantFromArray<ArrayObject>((ArrayObject*)obj,
- JavaObjectType);
+ JnjvmModule::JavaObjectType);
}
} else {
@@ -511,7 +515,7 @@
}
}
-Constant* JnjvmModuleAOT::CreateConstantFromJavaString(JavaString* str) {
+Constant* JavaAOTCompiler::CreateConstantFromJavaString(JavaString* str) {
Class* cl = (Class*)str->getClass();
LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl);
const StructType* STy =
@@ -522,7 +526,8 @@
Elmts.push_back(CreateConstantForBaseObject(cl));
Constant* Array = getUTF8(str->value);
- Constant* ObjGEPs[2] = { constantZero, constantZero };
+ Constant* ObjGEPs[2] = { JnjvmModule::constantZero,
+ JnjvmModule::constantZero };
Array = ConstantExpr::getGetElementPtr(Array, ObjGEPs, 2);
Elmts.push_back(Array);
@@ -534,9 +539,9 @@
}
-Constant* JnjvmModuleAOT::CreateConstantFromCacheNode(CacheNode* CN) {
+Constant* JavaAOTCompiler::CreateConstantFromCacheNode(CacheNode* CN) {
const StructType* STy =
- dyn_cast<StructType>(CacheNodeType->getContainedType(0));
+ dyn_cast<StructType>(JnjvmModule::CacheNodeType->getContainedType(0));
std::vector<Constant*> Elmts;
Elmts.push_back(Constant::getNullValue(STy->getContainedType(0)));
@@ -547,12 +552,12 @@
return ConstantStruct::get(STy, Elmts);
}
-Constant* JnjvmModuleAOT::CreateConstantFromEnveloppe(Enveloppe* val) {
+Constant* JavaAOTCompiler::CreateConstantFromEnveloppe(Enveloppe* val) {
const StructType* STy =
- dyn_cast<StructType>(EnveloppeType->getContainedType(0));
+ dyn_cast<StructType>(JnjvmModule::EnveloppeType->getContainedType(0));
const StructType* CNTy =
- dyn_cast<StructType>(CacheNodeType->getContainedType(0));
+ dyn_cast<StructType>(JnjvmModule::CacheNodeType->getContainedType(0));
std::vector<Constant*> Elmts;
@@ -571,9 +576,9 @@
}
-Constant* JnjvmModuleAOT::CreateConstantFromAttribut(Attribut& attribut) {
+Constant* JavaAOTCompiler::CreateConstantFromAttribut(Attribut& attribut) {
const StructType* STy =
- dyn_cast<StructType>(AttributType->getContainedType(0));
+ dyn_cast<StructType>(JnjvmModule::AttributType->getContainedType(0));
std::vector<Constant*> Elmts;
@@ -590,20 +595,22 @@
return ConstantStruct::get(STy, Elmts);
}
-Constant* JnjvmModuleAOT::CreateConstantFromCommonClass(CommonClass* cl) {
+Constant* JavaAOTCompiler::CreateConstantFromCommonClass(CommonClass* cl) {
const StructType* STy =
- dyn_cast<StructType>(JavaCommonClassType->getContainedType(0));
+ dyn_cast<StructType>(JnjvmModule::JavaCommonClassType->getContainedType(0));
- const ArrayType* ATy = ArrayType::get(JavaCommonClassType, cl->depth + 1);
+ const ArrayType* ATy = ArrayType::get(JnjvmModule::JavaCommonClassType,
+ cl->depth + 1);
std::vector<Constant*> CommonClassElts;
std::vector<Constant*> TempElmts;
- Constant* ClGEPs[2] = { constantZero, constantZero };
+ Constant* ClGEPs[2] = { JnjvmModule::constantZero,
+ JnjvmModule::constantZero };
// display
for (uint32 i = 0; i <= cl->depth; ++i) {
Constant* Cl = getNativeClass(cl->display[i]);
- if (Cl->getType() != JavaCommonClassType)
+ if (Cl->getType() != JnjvmModule::JavaCommonClassType)
Cl = ConstantExpr::getGetElementPtr(Cl, ClGEPs, 2);
TempElmts.push_back(Cl);
@@ -613,8 +620,10 @@
TempElmts.clear();
display = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage,
display, "", getLLVMModule());
+
+ const llvm::Type* TempTy = JnjvmModule::JavaCommonClassType;
display = ConstantExpr::getCast(Instruction::BitCast, display,
- PointerType::getUnqual(JavaCommonClassType));
+ PointerType::getUnqual(TempTy));
CommonClassElts.push_back(display);
// depth
@@ -636,16 +645,16 @@
TempElmts.push_back(getNativeClass(cl->interfaces[i]));
}
- ATy = ArrayType::get(JavaClassType, cl->nbInterfaces);
+ ATy = ArrayType::get(JnjvmModule::JavaClassType, cl->nbInterfaces);
Constant* interfaces = ConstantArray::get(ATy, TempElmts);
interfaces = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage,
interfaces, "", getLLVMModule());
interfaces = ConstantExpr::getCast(Instruction::BitCast, interfaces,
- PointerType::getUnqual(JavaClassType));
+ PointerType::getUnqual(JnjvmModule::JavaClassType));
CommonClassElts.push_back(interfaces);
} else {
- const Type* Ty = PointerType::getUnqual(JavaClassType);
+ const Type* Ty = PointerType::getUnqual(JnjvmModule::JavaClassType);
CommonClassElts.push_back(Constant::getNullValue(Ty));
}
@@ -659,26 +668,28 @@
if (cl->super) {
CommonClassElts.push_back(getNativeClass(cl->super));
} else {
- CommonClassElts.push_back(Constant::getNullValue(JavaClassType));
+ TempTy = JnjvmModule::JavaClassType;
+ CommonClassElts.push_back(Constant::getNullValue(TempTy));
}
// classLoader: store the static initializer, it will be overriden once
// the class is loaded.
- Constant* loader = ConstantExpr::getBitCast(StaticInitializer, ptrType);
+ Constant* loader = ConstantExpr::getBitCast(StaticInitializer,
+ JnjvmModule::ptrType);
CommonClassElts.push_back(loader);
return ConstantStruct::get(STy, CommonClassElts);
}
-Constant* JnjvmModuleAOT::CreateConstantFromJavaField(JavaField& field) {
+Constant* JavaAOTCompiler::CreateConstantFromJavaField(JavaField& field) {
const StructType* STy =
- dyn_cast<StructType>(JavaFieldType->getContainedType(0));
+ dyn_cast<StructType>(JnjvmModule::JavaFieldType->getContainedType(0));
std::vector<Constant*> FieldElts;
std::vector<Constant*> TempElts;
// signature
- FieldElts.push_back(Constant::getNullValue(ptrType));
+ FieldElts.push_back(Constant::getNullValue(JnjvmModule::ptrType));
// access
FieldElts.push_back(ConstantInt::get(Type::Int16Ty, field.access));
@@ -691,8 +702,8 @@
// attributs
if (field.nbAttributs) {
- const ArrayType* ATy = ArrayType::get(AttributType->getContainedType(0),
- field.nbAttributs);
+ const llvm::Type* AttrTy = JnjvmModule::AttributType->getContainedType(0);
+ const ArrayType* ATy = ArrayType::get(AttrTy, field.nbAttributs);
for (uint32 i = 0; i < field.nbAttributs; ++i) {
TempElts.push_back(CreateConstantFromAttribut(field.attributs[i]));
}
@@ -702,11 +713,11 @@
attributs = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage,
attributs, "", getLLVMModule());
attributs = ConstantExpr::getCast(Instruction::BitCast, attributs,
- AttributType);
+ JnjvmModule::AttributType);
FieldElts.push_back(attributs);
} else {
- FieldElts.push_back(Constant::getNullValue(AttributType));
+ FieldElts.push_back(Constant::getNullValue(JnjvmModule::AttributType));
}
// nbAttributs
@@ -722,28 +733,28 @@
FieldElts.push_back(ConstantInt::get(Type::Int16Ty, field.num));
//JInfo
- FieldElts.push_back(Constant::getNullValue(ptrType));
+ FieldElts.push_back(Constant::getNullValue(JnjvmModule::ptrType));
return ConstantStruct::get(STy, FieldElts);
}
-Constant* JnjvmModuleAOT::CreateConstantFromJavaMethod(JavaMethod& method) {
+Constant* JavaAOTCompiler::CreateConstantFromJavaMethod(JavaMethod& method) {
const StructType* STy =
- dyn_cast<StructType>(JavaMethodType->getContainedType(0));
+ dyn_cast<StructType>(JnjvmModule::JavaMethodType->getContainedType(0));
std::vector<Constant*> MethodElts;
std::vector<Constant*> TempElts;
// signature
- MethodElts.push_back(Constant::getNullValue(ptrType));
+ MethodElts.push_back(Constant::getNullValue(JnjvmModule::ptrType));
// access
MethodElts.push_back(ConstantInt::get(Type::Int16Ty, method.access));
// attributs
if (method.nbAttributs) {
- const ArrayType* ATy = ArrayType::get(AttributType->getContainedType(0),
- method.nbAttributs);
+ const llvm::Type* AttrTy = JnjvmModule::AttributType->getContainedType(0);
+ const ArrayType* ATy = ArrayType::get(AttrTy, method.nbAttributs);
for (uint32 i = 0; i < method.nbAttributs; ++i) {
TempElts.push_back(CreateConstantFromAttribut(method.attributs[i]));
}
@@ -753,11 +764,11 @@
attributs = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage,
attributs, "", getLLVMModule());
attributs = ConstantExpr::getCast(Instruction::BitCast, attributs,
- AttributType);
+ JnjvmModule::AttributType);
MethodElts.push_back(attributs);
} else {
- MethodElts.push_back(Constant::getNullValue(AttributType));
+ MethodElts.push_back(Constant::getNullValue(JnjvmModule::AttributType));
}
// nbAttributs
@@ -765,7 +776,7 @@
// enveloppes
// already allocated by the JIT, don't reallocate them.
- MethodElts.push_back(Constant::getNullValue(EnveloppeType));
+ MethodElts.push_back(Constant::getNullValue(JnjvmModule::EnveloppeType));
// nbEnveloppes
// 0 because we're not allocating here.
@@ -785,26 +796,27 @@
// code
if (isAbstract(method.access)) {
- MethodElts.push_back(Constant::getNullValue(ptrType));
+ MethodElts.push_back(Constant::getNullValue(JnjvmModule::ptrType));
} else {
LLVMMethodInfo* LMI = getMethodInfo(&method);
Function* func = LMI->getMethod();
MethodElts.push_back(ConstantExpr::getCast(Instruction::BitCast, func,
- ptrType));
+ JnjvmModule::ptrType));
}
// offset
MethodElts.push_back(ConstantInt::get(Type::Int32Ty, method.offset));
//JInfo
- MethodElts.push_back(Constant::getNullValue(ptrType));
+ MethodElts.push_back(Constant::getNullValue(JnjvmModule::ptrType));
return ConstantStruct::get(STy, MethodElts);
}
-Constant* JnjvmModuleAOT::CreateConstantFromClassPrimitive(ClassPrimitive* cl) {
- const StructType* STy =
- dyn_cast<StructType>(JavaClassPrimitiveType->getContainedType(0));
+Constant* JavaAOTCompiler::CreateConstantFromClassPrimitive(ClassPrimitive* cl) {
+ const llvm::Type* JCPTy =
+ JnjvmModule::JavaClassPrimitiveType->getContainedType(0);
+ const StructType* STy = dyn_cast<StructType>(JCPTy);
std::vector<Constant*> ClassElts;
@@ -817,19 +829,20 @@
return ConstantStruct::get(STy, ClassElts);
}
-Constant* JnjvmModuleAOT::CreateConstantFromClassArray(ClassArray* cl) {
+Constant* JavaAOTCompiler::CreateConstantFromClassArray(ClassArray* cl) {
const StructType* STy =
- dyn_cast<StructType>(JavaClassArrayType->getContainedType(0));
+ dyn_cast<StructType>(JnjvmModule::JavaClassArrayType->getContainedType(0));
std::vector<Constant*> ClassElts;
- Constant* ClGEPs[2] = { constantZero, constantZero };
+ Constant* ClGEPs[2] = { JnjvmModule::constantZero,
+ JnjvmModule::constantZero };
// common class
ClassElts.push_back(CreateConstantFromCommonClass(cl));
// baseClass
Constant* Cl = getNativeClass(cl->baseClass());
- if (Cl->getType() != JavaCommonClassType)
+ if (Cl->getType() != JnjvmModule::JavaCommonClassType)
Cl = ConstantExpr::getGetElementPtr(Cl, ClGEPs, 2);
ClassElts.push_back(Cl);
@@ -837,9 +850,9 @@
return ConstantStruct::get(STy, ClassElts);
}
-Constant* JnjvmModuleAOT::CreateConstantFromClass(Class* cl) {
+Constant* JavaAOTCompiler::CreateConstantFromClass(Class* cl) {
const StructType* STy =
- dyn_cast<StructType>(JavaClassType->getContainedType(0));
+ dyn_cast<StructType>(JnjvmModule::JavaClassType->getContainedType(0));
std::vector<Constant*> ClassElts;
std::vector<Constant*> TempElts;
@@ -869,10 +882,10 @@
ClassElts.push_back(ConstantArray::get(ATy, CStr, 1));
// thinlock
- ClassElts.push_back(Constant::getNullValue(ptrType));
+ ClassElts.push_back(Constant::getNullValue(JnjvmModule::ptrType));
if (cl->nbVirtualFields + cl->nbStaticFields) {
- ATy = ArrayType::get(JavaFieldType->getContainedType(0),
+ ATy = ArrayType::get(JnjvmModule::JavaFieldType->getContainedType(0),
cl->nbVirtualFields + cl->nbStaticFields);
}
@@ -901,9 +914,10 @@
TempElts.clear();
fields = new GlobalVariable(ATy, false, GlobalValue::InternalLinkage,
fields, "", getLLVMModule());
- fields = ConstantExpr::getCast(Instruction::BitCast, fields, JavaFieldType);
+ fields = ConstantExpr::getCast(Instruction::BitCast, fields,
+ JnjvmModule::JavaFieldType);
} else {
- fields = Constant::getNullValue(JavaFieldType);
+ fields = Constant::getNullValue(JnjvmModule::JavaFieldType);
}
// virtualFields
@@ -917,14 +931,14 @@
// staticFields
// Output null, getLLVMModule() will be set in the initializer. Otherwise, the
// assembly emitter of LLVM will try to align the data.
- ClassElts.push_back(Constant::getNullValue(JavaFieldType));
+ ClassElts.push_back(Constant::getNullValue(JnjvmModule::JavaFieldType));
// nbStaticFields
ClassElts.push_back(ConstantInt::get(Type::Int16Ty, cl->nbStaticFields));
// virtualMethods
if (cl->nbVirtualMethods + cl->nbStaticMethods) {
- ATy = ArrayType::get(JavaMethodType->getContainedType(0),
+ ATy = ArrayType::get(JnjvmModule::JavaMethodType->getContainedType(0),
cl->nbVirtualMethods + cl->nbStaticMethods);
}
@@ -949,9 +963,9 @@
methods, "", getLLVMModule());
virtualMethods.insert(std::make_pair(cl, GV));
methods = ConstantExpr::getCast(Instruction::BitCast, GV,
- JavaMethodType);
+ JnjvmModule::JavaMethodType);
} else {
- methods = Constant::getNullValue(JavaMethodType);
+ methods = Constant::getNullValue(JnjvmModule::JavaMethodType);
}
// virtualMethods
@@ -964,23 +978,23 @@
// staticMethods
// Output null, getLLVMModule() will be set in the initializer.
- ClassElts.push_back(Constant::getNullValue(JavaMethodType));
+ ClassElts.push_back(Constant::getNullValue(JnjvmModule::JavaMethodType));
// nbStaticMethods
ClassElts.push_back(ConstantInt::get(Type::Int16Ty, cl->nbStaticMethods));
// ownerClass
- ClassElts.push_back(Constant::getNullValue(ptrType));
+ ClassElts.push_back(Constant::getNullValue(JnjvmModule::ptrType));
// bytes
- ClassElts.push_back(Constant::getNullValue(JavaArrayUInt8Type));
+ ClassElts.push_back(Constant::getNullValue(JnjvmModule::JavaArrayUInt8Type));
// ctpInfo
- ClassElts.push_back(Constant::getNullValue(ptrType));
+ ClassElts.push_back(Constant::getNullValue(JnjvmModule::ptrType));
// attributs
if (cl->nbAttributs) {
- ATy = ArrayType::get(AttributType->getContainedType(0),
+ ATy = ArrayType::get(JnjvmModule::AttributType->getContainedType(0),
cl->nbAttributs);
for (uint32 i = 0; i < cl->nbAttributs; ++i) {
@@ -992,10 +1006,10 @@
attributs = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage,
attributs, "", getLLVMModule());
attributs = ConstantExpr::getCast(Instruction::BitCast, attributs,
- AttributType);
+ JnjvmModule::AttributType);
ClassElts.push_back(attributs);
} else {
- ClassElts.push_back(Constant::getNullValue(AttributType));
+ ClassElts.push_back(Constant::getNullValue(JnjvmModule::AttributType));
}
// nbAttributs
@@ -1007,16 +1021,17 @@
TempElts.push_back(getNativeClass(cl->innerClasses[i]));
}
- ATy = ArrayType::get(JavaClassType, cl->nbInnerClasses);
+ const llvm::Type* TempTy = JnjvmModule::JavaClassType;
+ ATy = ArrayType::get(TempTy, cl->nbInnerClasses);
Constant* innerClasses = ConstantArray::get(ATy, TempElts);
innerClasses = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage,
innerClasses, "", getLLVMModule());
innerClasses = ConstantExpr::getCast(Instruction::BitCast, innerClasses,
- PointerType::getUnqual(JavaClassType));
+ PointerType::getUnqual(TempTy));
ClassElts.push_back(innerClasses);
} else {
- const Type* Ty = PointerType::getUnqual(JavaClassType);
+ const Type* Ty = PointerType::getUnqual(JnjvmModule::JavaClassType);
ClassElts.push_back(Constant::getNullValue(Ty));
}
@@ -1027,7 +1042,7 @@
if (cl->outerClass) {
ClassElts.push_back(getNativeClass(cl->outerClass));
} else {
- ClassElts.push_back(Constant::getNullValue(JavaClassType));
+ ClassElts.push_back(Constant::getNullValue(JnjvmModule::JavaClassType));
}
// innerAccess
@@ -1043,7 +1058,7 @@
ClassElts.push_back(ConstantInt::get(Type::Int32Ty, cl->staticSize));
// JInfo
- ClassElts.push_back(Constant::getNullValue(ptrType));
+ ClassElts.push_back(Constant::getNullValue(JnjvmModule::ptrType));
// staticTracer
const Type* FTy = STy->getContainedType(STy->getNumContainedTypes() - 1);
@@ -1060,12 +1075,11 @@
}
template<typename T>
-Constant* JnjvmModuleAOT::CreateConstantFromArray(T* val, const Type* Ty) {
+Constant* JavaAOTCompiler::CreateConstantFromArray(T* val, const Type* Ty) {
std::vector<const Type*> Elemts;
const ArrayType* ATy = ArrayType::get(Ty, val->size);
- Elemts.push_back(JavaObjectType->getContainedType(0));
- Elemts.push_back(pointerSizeType == Type::Int32Ty ? Type::Int32Ty :
- Type::Int64Ty);
+ Elemts.push_back(JnjvmModule::JavaObjectType->getContainedType(0));
+ Elemts.push_back(JnjvmModule::pointerSizeType);
Elemts.push_back(ATy);
@@ -1073,7 +1087,7 @@
std::vector<Constant*> Cts;
Cts.push_back(CreateConstantForBaseObject(val->getClass()));
- Cts.push_back(ConstantInt::get(pointerSizeType, val->size));
+ Cts.push_back(ConstantInt::get(JnjvmModule::pointerSizeType, val->size));
std::vector<Constant*> Vals;
for (sint32 i = 0; i < val->size; ++i) {
@@ -1091,12 +1105,11 @@
return ConstantStruct::get(STy, Cts);
}
-Constant* JnjvmModuleAOT::CreateConstantFromUTF8(const UTF8* val) {
+Constant* JavaAOTCompiler::CreateConstantFromUTF8(const UTF8* val) {
std::vector<const Type*> Elemts;
const ArrayType* ATy = ArrayType::get(Type::Int16Ty, val->size);
- Elemts.push_back(JavaObjectType->getContainedType(0));
- Elemts.push_back(pointerSizeType == Type::Int32Ty ? Type::Int32Ty :
- Type::Int64Ty);
+ Elemts.push_back(JnjvmModule::JavaObjectType->getContainedType(0));
+ Elemts.push_back(JnjvmModule::pointerSizeType);
Elemts.push_back(ATy);
@@ -1104,7 +1117,7 @@
std::vector<Constant*> Cts;
Cts.push_back(CreateConstantForBaseObject(&ArrayOfChar));
- Cts.push_back(ConstantInt::get(pointerSizeType, val->size));
+ Cts.push_back(ConstantInt::get(JnjvmModule::pointerSizeType, val->size));
std::vector<Constant*> Vals;
for (sint32 i = 0; i < val->size; ++i) {
@@ -1117,7 +1130,7 @@
}
-Constant* JnjvmModuleAOT::getUTF8(const UTF8* val) {
+Constant* JavaAOTCompiler::getUTF8(const UTF8* val) {
utf8_iterator End = utf8s.end();
utf8_iterator I = utf8s.find(val);
if (I == End) {
@@ -1127,7 +1140,7 @@
C, "", getLLVMModule());
Constant* res = ConstantExpr::getCast(Instruction::BitCast, varGV,
- UTF8Type);
+ JnjvmModule::UTF8Type);
utf8s.insert(std::make_pair(val, res));
return res;
@@ -1136,10 +1149,11 @@
}
}
-Constant* JnjvmModuleAOT::CreateConstantFromVT(Class* classDef) {
+Constant* JavaAOTCompiler::CreateConstantFromVT(Class* classDef) {
uint32 size = classDef->virtualTableSize;
VirtualTable* VT = classDef->virtualVT;
- const ArrayType* ATy = dyn_cast<ArrayType>(VTType->getContainedType(0));
+ const ArrayType* ATy =
+ dyn_cast<ArrayType>(JnjvmModule::VTType->getContainedType(0));
const PointerType* PTy = dyn_cast<PointerType>(ATy->getContainedType(0));
ATy = ArrayType::get(PTy, size);
@@ -1188,9 +1202,9 @@
}
#ifdef WITH_TRACER
-llvm::Function* JnjvmModuleAOT::makeTracer(Class* cl, bool stat) {
+llvm::Function* JavaAOTCompiler::makeTracer(Class* cl, bool stat) {
if (!generateTracers) {
- return JavaObjectTracerFunction;
+ return JavaIntrinsics.JavaObjectTracerFunction;
} else {
return internalMakeTracer(cl, stat);
}
@@ -1205,14 +1219,14 @@
llvm::FunctionPass* createLowerConstantCallsPass();
}
-JnjvmModuleAOT::JnjvmModuleAOT(const std::string& ModuleID) :
- JnjvmModule(ModuleID) {
+JavaAOTCompiler::JavaAOTCompiler(const std::string& ModuleID) :
+ JavaLLVMCompiler(ModuleID) {
generateTracers = true;
generateStubs = true;
assumeCompiled = false;
- const Type* ATy = VTType->getContainedType(0);
+ const Type* ATy = JnjvmModule::VTType->getContainedType(0);
PrimitiveArrayVT = new GlobalVariable(ATy, true,
GlobalValue::ExternalLinkage,
0, "JavaArrayVT", getLLVMModule());
@@ -1223,7 +1237,7 @@
- ATy = JavaClassArrayType->getContainedType(0);
+ ATy = JnjvmModule::JavaClassArrayType->getContainedType(0);
GlobalVariable* varGV = 0;
#define PRIMITIVE_ARRAY(name) \
@@ -1243,16 +1257,16 @@
#undef PRIMITIVE_ARRAY
std::vector<const llvm::Type*> llvmArgs;
- llvmArgs.push_back(ptrType); // class loader.
+ llvmArgs.push_back(JnjvmModule::ptrType); // class loader.
const FunctionType* FTy = FunctionType::get(Type::VoidTy, llvmArgs, false);
StaticInitializer = Function::Create(FTy, GlobalValue::InternalLinkage,
"Init", getLLVMModule());
llvmArgs.clear();
- llvmArgs.push_back(JavaMethodType);
+ llvmArgs.push_back(JnjvmModule::JavaMethodType);
- FTy = FunctionType::get(ptrType, llvmArgs, false);
+ FTy = FunctionType::get(JnjvmModule::ptrType, llvmArgs, false);
NativeLoader = Function::Create(FTy, GlobalValue::ExternalLinkage,
"vmjcNativeLoader", getLLVMModule());
@@ -1267,7 +1281,7 @@
}
-void JnjvmModuleAOT::printStats() {
+void JavaAOTCompiler::printStats() {
fprintf(stderr, "----------------- Info from the module -----------------\n");
fprintf(stderr, "Number of native classes : %llu\n",
(unsigned long long int) nativeClasses.size());
@@ -1292,14 +1306,14 @@
Module* Mod = getLLVMModule();
for (Module::const_global_iterator i = Mod->global_begin(),
e = Mod->global_end(); i != e; ++i) {
- size += getTypeSize(i->getType());
+ size += JnjvmModule::getTypeSize(i->getType());
}
fprintf(stderr, "%lluB\n", (unsigned long long int)size);
}
#ifdef SERVICE
-Value* JnjvmModuleAOT::getIsolate(Jnjvm* isolate, Value* Where) {
+Value* JavaAOTCompiler::getIsolate(Jnjvm* isolate, Value* Where) {
llvm::Constant* varGV = 0;
isolate_iterator End = isolates.end();
isolate_iterator I = isolates.find(isolate);
@@ -1328,20 +1342,23 @@
}
#endif
-void JnjvmModuleAOT::CreateStaticInitializer() {
+void JavaAOTCompiler::CreateStaticInitializer() {
std::vector<const llvm::Type*> llvmArgs;
- llvmArgs.push_back(ptrType); // class loader
- llvmArgs.push_back(JavaCommonClassType); // cl
+ llvmArgs.push_back(JnjvmModule::ptrType); // class loader
+ llvmArgs.push_back(JnjvmModule::JavaCommonClassType); // cl
const FunctionType* FTy = FunctionType::get(Type::VoidTy, llvmArgs, false);
Function* AddClass = Function::Create(FTy, GlobalValue::ExternalLinkage,
"vmjcAddPreCompiledClass", getLLVMModule());
llvmArgs.clear();
- llvmArgs.push_back(ptrType); // class loader
- llvmArgs.push_back(PointerType::getUnqual(JavaClassArrayType)); // array ptr
- llvmArgs.push_back(UTF8Type); // name
+ // class loader
+ llvmArgs.push_back(JnjvmModule::ptrType);
+ // array ptr
+ llvmArgs.push_back(PointerType::getUnqual(JnjvmModule::JavaClassArrayType));
+ // name
+ llvmArgs.push_back(JnjvmModule::UTF8Type);
FTy = FunctionType::get(Type::VoidTy, llvmArgs, false);
Function* GetClassArray = Function::Create(FTy, GlobalValue::ExternalLinkage,
@@ -1354,7 +1371,7 @@
// If we have defined some strings.
if (strings.begin() != strings.end()) {
llvmArgs.clear();
- llvmArgs.push_back(ptrType); // class loader
+ llvmArgs.push_back(JnjvmModule::ptrType); // class loader
llvmArgs.push_back(strings.begin()->second->getType()); // val
FTy = FunctionType::get(Type::VoidTy, llvmArgs, false);
@@ -1374,7 +1391,8 @@
e = nativeClasses.end(); i != e; ++i) {
if (isCompiling(i->first)) {
Args[0] = loader;
- Args[1] = ConstantExpr::getBitCast(i->second, JavaCommonClassType);
+ Args[1] = ConstantExpr::getBitCast(i->second,
+ JnjvmModule::JavaCommonClassType);
CallInst::Create(AddClass, Args, Args + 2, "", currentBlock);
}
}
@@ -1393,7 +1411,7 @@
ReturnInst::Create(currentBlock);
}
-void JnjvmModuleAOT::setNoInline(Class* cl) {
+void JavaAOTCompiler::setNoInline(Class* cl) {
for (uint32 i = 0; i < cl->nbVirtualMethods; ++i) {
JavaMethod& meth = cl->virtualMethods[i];
if (!isAbstract(meth.access)) {
@@ -1413,7 +1431,7 @@
}
}
-void JnjvmModuleAOT::makeVT(Class* cl) {
+void JavaAOTCompiler::makeVT(Class* cl) {
internalMakeVT(cl);
#ifndef WITHOUT_VTABLE
VirtualTable* VT = cl->virtualVT;
@@ -1424,13 +1442,13 @@
#endif
}
-void JnjvmModuleAOT::setMethod(JavaMethod* meth, void* ptr, const char* name) {
+void JavaAOTCompiler::setMethod(JavaMethod* meth, void* ptr, const char* name) {
Function* func = getMethodInfo(meth)->getMethod();
func->setName(name);
func->setLinkage(GlobalValue::ExternalLinkage);
}
-Function* JnjvmModuleAOT::addCallback(Class* cl, uint16 index,
+Function* JavaAOTCompiler::addCallback(Class* cl, uint16 index,
Signdef* sign, bool stat) {
fprintf(stderr, "Warning: emitting a callback from %s (%d)\n",
Modified: vmkit/trunk/lib/JnJVM/Compiler/JnjvmModuleJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/JnjvmModuleJIT.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JnjvmModuleJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JnjvmModuleJIT.cpp Wed Mar 18 03:31:45 2009
@@ -1,4 +1,4 @@
-//===--------- JnjvmModuleJIT.cpp - Support for JIT compiling -------------===//
+//===--------- JavaJITCompiler.cpp - Support for JIT compiling -------------===//
//
// JnJVM
//
@@ -26,46 +26,46 @@
extern void* JavaArrayVT[];
extern void* ArrayObjectVT[];
-Constant* JnjvmModuleJIT::getNativeClass(CommonClass* classDef) {
- const llvm::Type* Ty = classDef->isClass() ? JavaClassType :
- JavaCommonClassType;
+Constant* JavaJITCompiler::getNativeClass(CommonClass* classDef) {
+ const llvm::Type* Ty = classDef->isClass() ? JnjvmModule::JavaClassType :
+ JnjvmModule::JavaCommonClassType;
ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64_t(classDef));
return ConstantExpr::getIntToPtr(CI, Ty);
}
-Constant* JnjvmModuleJIT::getConstantPool(JavaConstantPool* ctp) {
+Constant* JavaJITCompiler::getConstantPool(JavaConstantPool* ctp) {
void* ptr = ctp->ctpRes;
assert(ptr && "No constant pool found");
ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64_t(ptr));
- return ConstantExpr::getIntToPtr(CI, ConstantPoolType);
+ return ConstantExpr::getIntToPtr(CI, JnjvmModule::ConstantPoolType);
}
-Constant* JnjvmModuleJIT::getMethodInClass(JavaMethod* meth) {
+Constant* JavaJITCompiler::getMethodInClass(JavaMethod* meth) {
ConstantInt* CI = ConstantInt::get(Type::Int64Ty, (int64_t)meth);
- return ConstantExpr::getIntToPtr(CI, JavaMethodType);
+ return ConstantExpr::getIntToPtr(CI, JnjvmModule::JavaMethodType);
}
-Constant* JnjvmModuleJIT::getString(JavaString* str) {
+Constant* JavaJITCompiler::getString(JavaString* str) {
assert(str && "No string given");
ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64(str));
- return ConstantExpr::getIntToPtr(CI, JavaObjectType);
+ return ConstantExpr::getIntToPtr(CI, JnjvmModule::JavaObjectType);
}
-Constant* JnjvmModuleJIT::getEnveloppe(Enveloppe* enveloppe) {
+Constant* JavaJITCompiler::getEnveloppe(Enveloppe* enveloppe) {
assert(enveloppe && "No enveloppe given");
ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64(enveloppe));
- return ConstantExpr::getIntToPtr(CI, EnveloppeType);
+ return ConstantExpr::getIntToPtr(CI, JnjvmModule::EnveloppeType);
}
-Constant* JnjvmModuleJIT::getJavaClass(CommonClass* cl) {
+Constant* JavaJITCompiler::getJavaClass(CommonClass* cl) {
JavaObject* obj = cl->getClassDelegatee(JavaThread::get()->getJVM());
assert(obj && "Delegatee not created");
Constant* CI = ConstantInt::get(Type::Int64Ty, uint64(obj));
- return ConstantExpr::getIntToPtr(CI, JavaObjectType);
+ return ConstantExpr::getIntToPtr(CI, JnjvmModule::JavaObjectType);
}
-JavaObject* JnjvmModuleJIT::getFinalObject(llvm::Value* obj) {
+JavaObject* JavaJITCompiler::getFinalObject(llvm::Value* obj) {
if (ConstantExpr* CE = dyn_cast<ConstantExpr>(obj)) {
if (ConstantInt* C = dyn_cast<ConstantInt>(CE->getOperand(0))) {
return (JavaObject*)C->getZExtValue();
@@ -74,12 +74,12 @@
return 0;
}
-Constant* JnjvmModuleJIT::getFinalObject(JavaObject* obj) {
+Constant* JavaJITCompiler::getFinalObject(JavaObject* obj) {
Constant* CI = ConstantInt::get(Type::Int64Ty, uint64(obj));
- return ConstantExpr::getIntToPtr(CI, JavaObjectType);
+ return ConstantExpr::getIntToPtr(CI, JnjvmModule::JavaObjectType);
}
-Constant* JnjvmModuleJIT::getStaticInstance(Class* classDef) {
+Constant* JavaJITCompiler::getStaticInstance(Class* classDef) {
#ifdef ISOLATE
assert(0 && "Should not be here");
abort();
@@ -96,20 +96,20 @@
classDef->release();
}
Constant* CI = ConstantInt::get(Type::Int64Ty, (uint64_t(obj)));
- return ConstantExpr::getIntToPtr(CI, ptrType);
+ return ConstantExpr::getIntToPtr(CI, JnjvmModule::ptrType);
}
-Constant* JnjvmModuleJIT::getVirtualTable(Class* classDef) {
+Constant* JavaJITCompiler::getVirtualTable(Class* classDef) {
LLVMClassInfo* LCI = getClassInfo((Class*)classDef);
LCI->getVirtualType();
assert(classDef->virtualVT && "Virtual VT not created");
void* ptr = classDef->virtualVT;
ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64_t(ptr));
- return ConstantExpr::getIntToPtr(CI, VTType);
+ return ConstantExpr::getIntToPtr(CI, JnjvmModule::VTType);
}
-Constant* JnjvmModuleJIT::getNativeFunction(JavaMethod* meth, void* ptr) {
+Constant* JavaJITCompiler::getNativeFunction(JavaMethod* meth, void* ptr) {
LLVMSignatureInfo* LSI = getSignatureInfo(meth->getSignature());
const llvm::Type* valPtrType = LSI->getNativePtrType();
@@ -119,27 +119,27 @@
return ConstantExpr::getIntToPtr(CI, valPtrType);
}
-JnjvmModuleJIT::JnjvmModuleJIT(const std::string &ModuleID) :
- JnjvmModule(ModuleID) {
+JavaJITCompiler::JavaJITCompiler(const std::string &ModuleID) :
+ JavaLLVMCompiler(ModuleID) {
ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64(JavaArrayVT));
- PrimitiveArrayVT = ConstantExpr::getIntToPtr(CI, VTType);
+ PrimitiveArrayVT = ConstantExpr::getIntToPtr(CI, JnjvmModule::VTType);
CI = ConstantInt::get(Type::Int64Ty, uint64(ArrayObjectVT));
- ReferenceArrayVT = ConstantExpr::getIntToPtr(CI, VTType);
+ ReferenceArrayVT = ConstantExpr::getIntToPtr(CI, JnjvmModule::VTType);
- TheModuleProvider = new JnjvmModuleProvider(this);
+ TheModuleProvider = new JnjvmModuleProvider(TheModule);
addJavaPasses();
}
#ifdef SERVICE
-Value* JnjvmModuleJIT::getIsolate(Jnjvm* isolate, Value* Where) {
+Value* JavaJITCompiler::getIsolate(Jnjvm* isolate, Value* Where) {
ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64_t(isolate));
- return ConstantExpr::getIntToPtr(CI, ptrType);
+ return ConstantExpr::getIntToPtr(CI, JnjvmModule::ptrType);
}
#endif
-void JnjvmModuleJIT::makeVT(Class* cl) {
+void JavaJITCompiler::makeVT(Class* cl) {
internalMakeVT(cl);
#ifndef WITHOUT_VTABLE
@@ -158,8 +158,7 @@
#if defined(ISOLATE_SHARING) || defined(USE_GC_BOEHM)
((void**)VT)[0] = 0;
#else
- JnjvmClassLoader* loader = cl->classLoader;
- Function* func = loader->getModule()->parseFunction(&meth);
+ Function* func = parseFunction(&meth);
if (!cl->super) {
meth.canBeInlined = true;
((void**)VT)[0] = 0;
@@ -195,15 +194,15 @@
#endif
}
-void JnjvmModuleJIT::setMethod(JavaMethod* meth, void* ptr, const char* name) {
+void JavaJITCompiler::setMethod(JavaMethod* meth, void* ptr, const char* name) {
Function* func = getMethodInfo(meth)->getMethod();
func->setName(name);
assert(ptr && "No value given");
- executionEngine->addGlobalMapping(func, ptr);
+ JnjvmModule::executionEngine->addGlobalMapping(func, ptr);
func->setLinkage(GlobalValue::ExternalLinkage);
}
-void* JnjvmModuleJIT::materializeFunction(JavaMethod* meth) {
+void* JavaJITCompiler::materializeFunction(JavaMethod* meth) {
Function* func = parseFunction(meth);
void* res = mvm::MvmModule::executionEngine->getPointerToGlobal(func);
Modified: vmkit/trunk/lib/JnJVM/Compiler/JnjvmModuleProvider.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/JnjvmModuleProvider.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JnjvmModuleProvider.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JnjvmModuleProvider.cpp Wed Mar 18 03:31:45 2009
@@ -64,8 +64,8 @@
-Function* JnjvmModuleJIT::addCallback(Class* cl, uint16 index,
- Signdef* sign, bool stat) {
+Function* JavaJITCompiler::addCallback(Class* cl, uint16 index,
+ Signdef* sign, bool stat) {
Function* func = 0;
LLVMSignatureInfo* LSI = getSignatureInfo(sign);
@@ -111,7 +111,7 @@
mvm::MvmModule::executionEngine->updateGlobalMapping(F, val);
if (isVirtual(meth->access)) {
- LLVMMethodInfo* LMI = ((JnjvmModule*)TheModule)->getMethodInfo(meth);
+ LLVMMethodInfo* LMI = JavaLLVMCompiler::getMethodInfo(meth);
uint64_t offset = LMI->getOffset()->getZExtValue();
assert(meth->classDef->isResolved() && "Class not resolved");
#if !defined(ISOLATE_SHARING) && !defined(SERVICE)
@@ -130,15 +130,15 @@
return false;
}
-JnjvmModuleProvider::JnjvmModuleProvider(JnjvmModuleJIT *m) {
- TheModule = m->getLLVMModule();
- m->protectEngine.lock();
- m->executionEngine->addModuleProvider(this);
- m->protectEngine.unlock();
+JnjvmModuleProvider::JnjvmModuleProvider(llvm::Module* m) {
+ TheModule = m;
+ JnjvmModule::protectEngine.lock();
+ JnjvmModule::executionEngine->addModuleProvider(this);
+ JnjvmModule::protectEngine.unlock();
}
JnjvmModuleProvider::~JnjvmModuleProvider() {
- mvm::MvmModule::protectEngine.lock();
- mvm::MvmModule::executionEngine->removeModuleProvider(this);
- mvm::MvmModule::protectEngine.unlock();
+ JnjvmModule::protectEngine.lock();
+ JnjvmModule::executionEngine->removeModuleProvider(this);
+ JnjvmModule::protectEngine.unlock();
}
Modified: vmkit/trunk/lib/JnJVM/Compiler/LowerConstantCalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/LowerConstantCalls.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/LowerConstantCalls.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/LowerConstantCalls.cpp Wed Mar 18 03:31:45 2009
@@ -116,7 +116,9 @@
bool LowerConstantCalls::runOnFunction(Function& F) {
JavaMethod* meth = LLVMMethodInfo::get(&F);
- JnjvmModule* module = meth->classDef->classLoader->getModule();
+ JavaLLVMCompiler* TheCompiler =
+ (JavaLLVMCompiler*)meth->classDef->classLoader->getModule();
+ JnjvmModule* module = TheCompiler->getIntrinsics();
bool Changed = false;
for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; BI++) {
BasicBlock *Cur = BI;
@@ -434,7 +436,7 @@
GlobalVariable* GV =
new GlobalVariable(module->JavaCommonClassType, false,
GlobalValue::ExternalLinkage,
- init, "", module->getLLVMModule());
+ init, "", TheCompiler->getLLVMModule());
Value* LoadedGV = new LoadInst(GV, "", CI);
Value* cmp = new ICmpInst(ICmpInst::ICMP_EQ, LoadedGV, init,
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Wed Mar 18 03:31:45 2009
@@ -932,9 +932,9 @@
loadParents();
loadExceptions();
acquire();
- JnjvmModule *Mod = classLoader->getModule();
- Mod->resolveVirtualClass(this);
- Mod->resolveStaticClass(this);
+ JavaCompiler *Comp = classLoader->getModule();
+ Comp->resolveVirtualClass(this);
+ Comp->resolveStaticClass(this);
setResolved();
if (!needsInitialisationCheck()) {
setInitializationState(ready);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Wed Mar 18 03:31:45 2009
@@ -59,26 +59,27 @@
}
#ifdef ISOLATE_SHARING
-mvm::CompilationUnit* mvm::VirtualMachine::initialiseJVM(bool sc) {
+JnjvmClassLoader* mvm::VirtualMachine::initialiseJVM(JavaCompiler* Comp) {
initialiseVT();
- JnjvmSharedLoader::sharedLoader = JnjvmSharedLoader::createSharedLoader();
+ JnjvmSharedLoader::sharedLoader = JnjvmSharedLoader::createSharedLoader(Comp);
return JnjvmSharedLoader::sharedLoader;
}
-mvm::VirtualMachine* mvm::VirtualMachine::createJVM(mvm::CompilationUnit* C) {
- JnjvmBootstraLoader* bootstrapLoader = gc_new(JnjvmBootstrapLoader)(0, 0);
+mvm::VirtualMachine* mvm::VirtualMachine::createJVM(JnjvClassLoader* JCL) {
+ JnjvmBootstraLoader* bootstrapLoader =
+ gc_new(JnjvmBootstrapLoader)(JCL->getModule());
Jnjvm* vm = gc_new(Jnjvm)(bootstrapLoader);
return vm;
}
#else
-mvm::CompilationUnit*
-mvm::VirtualMachine::initialiseJVM() {
+JnjvmClassLoader*
+mvm::VirtualMachine::initialiseJVM(JavaCompiler* Comp) {
initialiseVT();
- return gc_new(JnjvmBootstrapLoader)(0);
+ return gc_new(JnjvmBootstrapLoader)(Comp);
}
-mvm::VirtualMachine* mvm::VirtualMachine::createJVM(mvm::CompilationUnit* C) {
+mvm::VirtualMachine* mvm::VirtualMachine::createJVM(JnjvmClassLoader* C) {
Jnjvm* vm = gc_new(Jnjvm)((JnjvmBootstrapLoader*)C);
return vm;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp Wed Mar 18 03:31:45 2009
@@ -105,32 +105,28 @@
intptr_t Signdef::staticCallBuf() {
if (!_staticCallBuf) {
- LLVMSignatureInfo* LSI = initialLoader->getModule()->getSignatureInfo(this);
- LSI->getStaticBuf();
+ initialLoader->getModule()->staticCallBuf(this);
}
return _staticCallBuf;
}
intptr_t Signdef::virtualCallBuf() {
if (!_virtualCallBuf) {
- LLVMSignatureInfo* LSI = initialLoader->getModule()->getSignatureInfo(this);
- LSI->getVirtualBuf();
+ initialLoader->getModule()->virtualCallBuf(this);
}
return _virtualCallBuf;
}
intptr_t Signdef::staticCallAP() {
if (!_staticCallAP) {
- LLVMSignatureInfo* LSI = initialLoader->getModule()->getSignatureInfo(this);
- LSI->getStaticAP();
+ initialLoader->getModule()->staticCallAP(this);
}
return _staticCallAP;
}
intptr_t Signdef::virtualCallAP() {
if (!_virtualCallAP) {
- LLVMSignatureInfo* LSI = initialLoader->getModule()->getSignatureInfo(this);
- LSI->getVirtualAP();
+ initialLoader->getModule()->virtualCallAP(this);
}
return _virtualCallAP;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Wed Mar 18 03:31:45 2009
@@ -1101,7 +1101,7 @@
static void compileClass(Class* cl) {
- JnjvmModuleAOT* Mod = (JnjvmModuleAOT*)cl->classLoader->getModule();
+ JavaAOTCompiler* Mod = (JavaAOTCompiler*)cl->classLoader->getModule();
// Make sure the class is emitted.
Mod->getNativeClass(cl);
@@ -1127,7 +1127,7 @@
Jnjvm* vm = th->getJVM();
JnjvmBootstrapLoader* bootstrapLoader = vm->bootstrapLoader;
- JnjvmModuleAOT* M = (JnjvmModuleAOT*)bootstrapLoader->getModule();
+ JavaAOTCompiler* M = (JavaAOTCompiler*)bootstrapLoader->getModule();
try {
bootstrapLoader->analyseClasspathEnv(vm->classpath);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Wed Mar 18 03:31:45 2009
@@ -62,7 +62,7 @@
typedef void (*static_init_t)(JnjvmClassLoader*);
-JnjvmBootstrapLoader::JnjvmBootstrapLoader(JnjvmModule* Mod) {
+JnjvmBootstrapLoader::JnjvmBootstrapLoader(JavaCompiler* Comp) {
hashUTF8 = new(allocator) UTF8Map(allocator, 0);
classes = new(allocator) ClassMap();
@@ -265,14 +265,14 @@
#undef DEF_UTF8
- TheModule = Mod;
+ TheCompiler = Comp;
}
JnjvmClassLoader::JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader,
Jnjvm* I) {
bootstrapLoader = JCL.bootstrapLoader;
- TheModule = bootstrapLoader->getModule()->Create("Applicative loader");
+ TheCompiler = bootstrapLoader->getModule()->Create("Applicative loader");
hashUTF8 = new(allocator) UTF8Map(allocator,
bootstrapLoader->upcalls->ArrayOfChar);
@@ -815,7 +815,7 @@
allocator.Deallocate(javaSignatures);
}
- delete TheModule;
+ delete TheCompiler;
}
@@ -953,7 +953,7 @@
}
void JnjvmClassLoader::insertAllMethodsInVM(Jnjvm* vm) {
- JnjvmModule* M = getModule();
+ JavaCompiler* M = getModule();
for (ClassMap::iterator i = classes->map.begin(), e = classes->map.end();
i != e; ++i) {
CommonClass* cl = i->second;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Wed Mar 18 03:31:45 2009
@@ -31,12 +31,12 @@
class ClassMap;
class Classpath;
class UserCommonClass;
+class JavaCompiler;
class JavaMethod;
class JavaObject;
class JavaString;
class Jnjvm;
class JnjvmBootstrapLoader;
-class JnjvmModule;
class Signdef;
class SignMap;
class Typedef;
@@ -49,7 +49,7 @@
/// its own tables (signatures, UTF8, types) which are mapped to a single
/// table for non-isolate environments.
///
-class JnjvmClassLoader : public mvm::CompilationUnit {
+class JnjvmClassLoader : public mvm::Object {
private:
/// isolate - Which isolate defined me? Null for the bootstrap class loader.
@@ -60,7 +60,7 @@
/// bootstrap class loader.
///
JavaObject* javaLoader;
-
+
/// internalLoad - Load the class with the given name.
///
virtual UserClass* internalLoad(const UTF8* utf8, bool doResolve);
@@ -76,6 +76,10 @@
JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader, Jnjvm* isolate);
protected:
+
+ /// TheCompiler - The Java compiler for this class loader.
+ ///
+ JavaCompiler* TheCompiler;
/// classes - The classes this class loader has loaded.
///
@@ -112,11 +116,13 @@
///
UTF8Map* hashUTF8;
- /// TheModule - JIT module for compiling methods.
+ /// getModule - Get the Java compiler of this class loader.
///
- JnjvmModule* getModule() {
- return reinterpret_cast<JnjvmModule*>(TheModule);
- }
+ JavaCompiler* getModule() { return TheCompiler; }
+
+ /// setCompiler - Set the compiler of classes loaded by this class loader.
+ ///
+ void setCompiler(JavaCompiler* Comp) { TheCompiler = Comp; }
/// tracer - Traces a JnjvmClassLoader for GC.
///
@@ -212,7 +218,7 @@
hashUTF8 = 0;
javaTypes = 0;
javaSignatures = 0;
- TheModule = 0;
+ TheCompiler = 0;
isolate = 0;
classes = 0;
}
@@ -333,7 +339,7 @@
/// createBootstrapLoader - Creates the bootstrap loader, first thing
/// to do before any execution of a JVM.
///
- JnjvmBootstrapLoader(JnjvmModule* Mod);
+ JnjvmBootstrapLoader(JavaCompiler* Comp);
JnjvmBootstrapLoader() {}
virtual JavaString* UTF8ToStr(const UTF8* utf8);
Modified: vmkit/trunk/lib/Mvm/Runtime/JIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/JIT.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Runtime/JIT.cpp (original)
+++ vmkit/trunk/lib/Mvm/Runtime/JIT.cpp Wed Mar 18 03:31:45 2009
@@ -127,12 +127,10 @@
}
-MvmModule::MvmModule(const std::string& ModuleID) {
- TheModule = new Module(ModuleID);
- Module* module = TheModule;
+MvmModule::MvmModule(llvm::Module* module) {
- TheModule->setDataLayout(globalModule->getDataLayout());
- TheModule->setTargetTriple(globalModule->getTargetTriple());
+ module->setDataLayout(globalModule->getDataLayout());
+ module->setTargetTriple(globalModule->getTargetTriple());
copyDefinitions(module, globalModule);
@@ -272,13 +270,13 @@
// -instcombine -gvn -sccp -simplifycfg -instcombine -condprop -dse -adce
// -simplifycfg
//
-void CompilationUnit::AddStandardCompilePasses() {
+void MvmModule::AddStandardCompilePasses() {
// TODO: enable this when
// - each module will have its declaration of external functions
//
//PM->add(llvm::createVerifierPass()); // Verify that input is correct
- FunctionPassManager* PM = TheModule->globalFunctionPasses;
+ FunctionPassManager* PM = globalFunctionPasses;
PM->add(new TargetData(*MvmModule::TheTargetData));
addPass(PM, createCFGSimplificationPass()); // Clean up disgusting code
@@ -337,7 +335,3 @@
SF->getName(), Dst);
}
}
-
-MvmModule::~MvmModule() {
- delete TheModuleProvider;
-}
Modified: vmkit/trunk/lib/N3/Mono/MonoString.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/Mono/MonoString.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/N3/Mono/MonoString.cpp (original)
+++ vmkit/trunk/lib/N3/Mono/MonoString.cpp Wed Mar 18 03:31:45 2009
@@ -56,7 +56,7 @@
str->_llvmVar = new GlobalVariable(pty, true,
GlobalValue::ExternalLinkage,
cons, "",
- vm->module->getLLVMModule());
+ vm->getLLVMModule());
}
}
return str->_llvmVar;
Modified: vmkit/trunk/lib/N3/PNetLib/PNetString.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/PNetLib/PNetString.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/N3/PNetLib/PNetString.cpp (original)
+++ vmkit/trunk/lib/N3/PNetLib/PNetString.cpp Wed Mar 18 03:31:45 2009
@@ -57,7 +57,7 @@
str->_llvmVar = new GlobalVariable(pty, true,
GlobalValue::ExternalLinkage,
cons, "",
- vm->module->getLLVMModule());
+ vm->getLLVMModule());
}
}
return str->_llvmVar;
Modified: vmkit/trunk/lib/N3/VMCore/CLIJit.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/CLIJit.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/N3/VMCore/CLIJit.cpp (original)
+++ vmkit/trunk/lib/N3/VMCore/CLIJit.cpp Wed Mar 18 03:31:45 2009
@@ -151,7 +151,7 @@
Function* func = Function::Create(markAndTraceLLVMType,
GlobalValue::ExternalLinkage,
"markAndTraceObject",
- cl->vm->module->getLLVMModule());
+ cl->vm->getLLVMModule());
Argument* arg = func->arg_begin();
#ifdef MULTIPLE_GC
Argument* GC = ++(func->arg_begin());
@@ -253,7 +253,7 @@
Function* func = Function::Create(markAndTraceLLVMType,
GlobalValue::ExternalLinkage,
"markAndTraceObject",
- cl->vm->module->getLLVMModule());
+ cl->vm->getLLVMModule());
Argument* arg = func->arg_begin();
#ifdef MULTIPLE_GC
@@ -1484,7 +1484,7 @@
classDef->aquire();
if (methPtr == 0) {
methPtr = Function::Create(getSignature(genMethod), GlobalValue::GhostLinkage,
- printString(), classDef->vm->module->getLLVMModule());
+ printString(), classDef->vm->getLLVMModule());
classDef->vm->functions->hash(methPtr, this);
N3Annotation* A = new N3Annotation(this);
methPtr->addAnnotation(A);
@@ -1534,7 +1534,7 @@
void CLIJit::initialiseBootstrapVM(N3* vm) {
mvm::MvmModule* M = vm->module;
- Module* module = M->getLLVMModule();
+ Module* module = vm->getLLVMModule();
M->protectEngine.lock();
M->executionEngine->addModuleProvider(vm->TheModuleProvider);
M->protectEngine.unlock();
Modified: vmkit/trunk/lib/N3/VMCore/CLIJitMeta.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/CLIJitMeta.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/N3/VMCore/CLIJitMeta.cpp (original)
+++ vmkit/trunk/lib/N3/VMCore/CLIJitMeta.cpp Wed Mar 18 03:31:45 2009
@@ -372,7 +372,7 @@
_llvmVar = new GlobalVariable(pty, true,
GlobalValue::ExternalLinkage,
cons, "",
- vm->module->getLLVMModule());
+ vm->getLLVMModule());
}
release();
@@ -392,7 +392,7 @@
_llvmVar = new GlobalVariable(pty, true,
GlobalValue::ExternalLinkage,
cons, "",
- classDef->vm->module->getLLVMModule());
+ classDef->vm->getLLVMModule());
}
classDef->release();
}
@@ -411,7 +411,7 @@
_llvmVar = new GlobalVariable(pty, true,
GlobalValue::ExternalLinkage,
cons, "",
- classDef->vm->module->getLLVMModule());
+ classDef->vm->getLLVMModule());
}
classDef->release();
Modified: vmkit/trunk/lib/N3/VMCore/N3.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/N3.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/N3/VMCore/N3.cpp (original)
+++ vmkit/trunk/lib/N3/VMCore/N3.cpp Wed Mar 18 03:31:45 2009
@@ -63,11 +63,12 @@
std::string str =
mvm::MvmModule::executionEngine->getTargetData()->getStringRepresentation();
- vm->module = new mvm::MvmModule("Bootstrap N3");
- vm->module->getLLVMModule()->setDataLayout(str);
+ vm->LLVMModule = new llvm::Module("Bootstrap N3");
+ vm->module = new mvm::MvmModule(vm->LLVMModule);
+ vm->getLLVMModule()->setDataLayout(str);
vm->protectModule = new mvm::LockNormal();
vm->functions = FunctionMap::allocate();
- vm->TheModuleProvider = new N3ModuleProvider(vm->module->getLLVMModule(), vm->functions);
+ vm->TheModuleProvider = new N3ModuleProvider(vm->LLVMModule, vm->functions);
CLIJit::initialiseBootstrapVM(vm);
vm->name = "bootstrapN3";
@@ -85,11 +86,12 @@
std::string str =
mvm::MvmModule::executionEngine->getTargetData()->getStringRepresentation();
- vm->module = new mvm::MvmModule("App Domain");
- vm->module->getLLVMModule()->setDataLayout(str);
+ vm->LLVMModule = new llvm::Module("Bootstrap N3");
+ vm->module = new mvm::MvmModule(vm->LLVMModule);
+ vm->LLVMModule->setDataLayout(str);
vm->protectModule = new mvm::LockNormal();
vm->functions = FunctionMap::allocate();
- vm->TheModuleProvider = new N3ModuleProvider(vm->module->getLLVMModule(), vm->functions);
+ vm->TheModuleProvider = new N3ModuleProvider(vm->LLVMModule, vm->functions);
CLIJit::initialiseAppDomain(vm);
Modified: vmkit/trunk/lib/N3/VMCore/VMThread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VMThread.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/N3/VMCore/VMThread.cpp (original)
+++ vmkit/trunk/lib/N3/VMCore/VMThread.cpp Wed Mar 18 03:31:45 2009
@@ -53,7 +53,7 @@
key->state = StateRunning;
key->pendingException = 0;
key->perFunctionPasses = new llvm::FunctionPassManager(vm->TheModuleProvider);
- key->perFunctionPasses->add(new llvm::TargetData(vm->module->getLLVMModule()));
+ key->perFunctionPasses->add(new llvm::TargetData(vm->getLLVMModule()));
AddStandardCompilePasses(key->perFunctionPasses);
return key;
}
Modified: vmkit/trunk/lib/N3/VMCore/VirtualMachine.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VirtualMachine.h?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/lib/N3/VMCore/VirtualMachine.h (original)
+++ vmkit/trunk/lib/N3/VMCore/VirtualMachine.h Wed Mar 18 03:31:45 2009
@@ -124,6 +124,7 @@
mvm::Lock* protectModule;
FunctionMap* functions;
mvm::MvmModule* module;
+ llvm::Module* LLVMModule;
N3ModuleProvider* TheModuleProvider;
VMThread* bootstrapThread;
@@ -135,6 +136,8 @@
VMMethod* lookupFunction(llvm::Function* F);
+ llvm::Module* getLLVMModule() { return LLVMModule; }
+
};
} // end namespace n3
Modified: vmkit/trunk/tools/jnjvm/Main.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/jnjvm/Main.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/tools/jnjvm/Main.cpp (original)
+++ vmkit/trunk/tools/jnjvm/Main.cpp Wed Mar 18 03:31:45 2009
@@ -30,10 +30,10 @@
Object::initialise();
Collector::initialise(0);
- CompilationUnit* CU = VirtualMachine::initialiseJVM();
- CU->TheModule = new JnjvmModuleJIT("JITModule");
- CU->AddStandardCompilePasses();
- VirtualMachine* vm = VirtualMachine::createJVM(CU);
+ JavaJITCompiler* Comp = new JavaJITCompiler("JITModule");
+ mvm::MvmModule::AddStandardCompilePasses();
+ JnjvmClassLoader* JCL = VirtualMachine::initialiseJVM(Comp);
+ VirtualMachine* vm = VirtualMachine::createJVM(JCL);
vm->runApplication(argc, argv);
vm->waitForExit();
Modified: vmkit/trunk/tools/vmjc/vmjc.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmjc/vmjc.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/tools/vmjc/vmjc.cpp (original)
+++ vmkit/trunk/tools/vmjc/vmjc.cpp Wed Mar 18 03:31:45 2009
@@ -44,6 +44,8 @@
#include "jnjvm/JnjvmModule.h"
#include "jnjvm/JnjvmModuleProvider.h"
+#include "../../lib/JnJVM/VMCore/JnjvmClassLoader.h"
+
#include <iostream>
#include <fstream>
#include <memory>
@@ -111,8 +113,8 @@
}
-void addCommandLinePass(mvm::CompilationUnit* CU, char** argv) {
- FunctionPassManager* Passes = CU->TheModule->globalFunctionPasses;
+void addCommandLinePass(char** argv) {
+ FunctionPassManager* Passes = mvm::MvmModule::globalFunctionPasses;
// Create a new optimization pass for each one specified on the command line
for (unsigned i = 0; i < PassList.size(); ++i) {
@@ -120,7 +122,7 @@
// so, handle it.
if (StandardCompileOpts &&
StandardCompileOpts.getPosition() < PassList.getPosition(i)) {
- if (!DisableOptimizations) CU->AddStandardCompilePasses();
+ if (!DisableOptimizations) mvm::MvmModule::AddStandardCompilePasses();
StandardCompileOpts = false;
}
@@ -143,7 +145,7 @@
// If -std-compile-opts was specified at the end of the pass list, add them.
if (StandardCompileOpts) {
- CU->AddStandardCompilePasses();
+ mvm::MvmModule::AddStandardCompilePasses();
}
}
@@ -164,7 +166,7 @@
return 0;
}
- JnjvmModule* Mod = 0;
+ JavaCompiler* Comp = 0;
if (WithClinit.empty()) {
Module* TheModule = new Module("bootstrap module");
if (!TargetTriple.empty())
@@ -191,32 +193,31 @@
mvm::MvmModule::initialise(false, TheModule, TheTarget);
- Mod = new JnjvmModuleAOT("AOT");
+ Comp = new JavaAOTCompiler("AOT");
} else {
mvm::MvmModule::initialise(true);
- Mod = new JnjvmModuleJIT("JIT");
+ Comp = new JavaJITCompiler("JIT");
}
mvm::Object::initialise();
Collector::initialise(0);
Collector::enable(0);
- mvm::CompilationUnit* CU = mvm::VirtualMachine::initialiseJVM();
- addCommandLinePass(CU, argv);
- CU->TheModule = Mod;
+ JnjvmClassLoader* JCL = mvm::VirtualMachine::initialiseJVM(Comp);
+ addCommandLinePass(argv);
if (!WithClinit.empty()) {
// TODO
- Mod = new JnjvmModuleAOT("AOT");
- CU->TheModule = Mod;
+ Comp = new JavaAOTCompiler("AOT");
+ JCL->setCompiler(Comp);
}
- JnjvmModuleAOT* MAOT = (JnjvmModuleAOT*)Mod;
+ JavaAOTCompiler* MAOT = (JavaAOTCompiler*)Comp;
if (DisableExceptions) MAOT->disableExceptions();
if (DisableTracers) MAOT->generateTracers = false;
if (DisableStubs) MAOT->generateStubs = false;
if (AssumeCompiled) MAOT->assumeCompiled = true;
- mvm::VirtualMachine* vm = mvm::VirtualMachine::createJVM(CU);
+ mvm::VirtualMachine* vm = mvm::VirtualMachine::createJVM(JCL);
vm->compile(InputFilename.c_str());
vm->waitForExit();
@@ -266,7 +267,7 @@
}
if (Force || !CheckBitcodeOutputToConsole(Out,true))
- WriteBitcodeToFile(CU->TheModule->getLLVMModule(), *Out);
+ WriteBitcodeToFile(MAOT->getLLVMModule(), *Out);
if (Out != &std::cout) {
((std::ofstream*)Out)->close();
Modified: vmkit/trunk/tools/vmkit/CommandLine.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmkit/CommandLine.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/tools/vmkit/CommandLine.cpp (original)
+++ vmkit/trunk/tools/vmkit/CommandLine.cpp Wed Mar 18 03:31:45 2009
@@ -154,7 +154,7 @@
} else {
create_vm_t func = vmlets[argv[0]];
- mvm::CompilationUnit* CU = compilers[argv[0]];
+ mvm::Object* CU = compilers[argv[0]];
if (!func) {
fprintf(stderr, "\t Unknown vm %s\n", argv[0]);
} else {
Modified: vmkit/trunk/tools/vmkit/CommandLine.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmkit/CommandLine.h?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/tools/vmkit/CommandLine.h (original)
+++ vmkit/trunk/tools/vmkit/CommandLine.h Wed Mar 18 03:31:45 2009
@@ -29,7 +29,7 @@
#endif
typedef int (*boot_t)();
-typedef mvm::VirtualMachine* (*create_vm_t)(mvm::CompilationUnit*);
+typedef mvm::VirtualMachine* (*create_vm_t)(mvm::Object*);
namespace mvm {
@@ -54,7 +54,7 @@
char _yyChar;
std::map<const char*, create_vm_t, ltstr> vmlets;
- std::map<const char*, mvm::CompilationUnit*, ltstr> compilers;
+ std::map<const char*, mvm::Object*, ltstr> compilers;
CommandLine();
Modified: vmkit/trunk/tools/vmkit/Launcher.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmkit/Launcher.cpp?rev=67186&r1=67185&r2=67186&view=diff
==============================================================================
--- vmkit/trunk/tools/vmkit/Launcher.cpp (original)
+++ vmkit/trunk/tools/vmkit/Launcher.cpp Wed Mar 18 03:31:45 2009
@@ -71,17 +71,17 @@
}
-void addCommandLinePass(mvm::CompilationUnit* CU, char** argv) {
- FunctionPassManager* Passes = CU->TheModule->globalFunctionPasses;
+void addCommandLinePass(char** argv) {
+ FunctionPassManager* Passes = mvm::MvmModule::globalFunctionPasses;
- Passes->add(new TargetData(*CU->TheModule->TheTargetData));
+ Passes->add(new TargetData(*mvm::MvmModule::TheTargetData));
// Create a new optimization pass for each one specified on the command line
for (unsigned i = 0; i < PassList.size(); ++i) {
// Check to see if -std-compile-opts was specified before this option. If
// so, handle it.
if (StandardCompileOpts &&
StandardCompileOpts.getPosition() < PassList.getPosition(i)) {
- if (!DisableOptimizations) CU->AddStandardCompilePasses();
+ if (!DisableOptimizations) mvm::MvmModule::AddStandardCompilePasses();
StandardCompileOpts = false;
}
@@ -104,7 +104,7 @@
// If -std-compile-opts was specified at the end of the pass list, add them.
if (StandardCompileOpts) {
- CU->AddStandardCompilePasses();
+ mvm::MvmModule::AddStandardCompilePasses();
}
}
@@ -138,10 +138,10 @@
if (VMToRun == RunJava) {
#if WITH_JNJVM
- mvm::CompilationUnit* CU = mvm::VirtualMachine::initialiseJVM();
- CU->TheModule = new JnjvmModuleJIT("JITModule");
- addCommandLinePass(CU, argv);
- mvm::VirtualMachine* vm = mvm::VirtualMachine::createJVM(CU);
+ JavaJITCompiler* Comp = new JavaJITCompiler("JITModule");
+ JnjvmClassLoader* JCL = mvm::VirtualMachine::initialiseJVM(Comp);
+ addCommandLinePass(argv);
+ mvm::VirtualMachine* vm = mvm::VirtualMachine::createJVM(JCL);
vm->runApplication(argc, argv);
vm->waitForExit();
#endif
@@ -155,12 +155,11 @@
} else {
mvm::CommandLine MyCl;
#if WITH_JNJVM
- mvm::CompilationUnit* JVMCompiler =
- mvm::VirtualMachine::initialiseJVM();
- JVMCompiler->TheModule = new JnjvmModuleJIT("JITModule");
- addCommandLinePass(JVMCompiler, argv);
- MyCl.vmlets["java"] = (mvm::VirtualMachine::createJVM);
- MyCl.compilers["java"] = JVMCompiler;
+ JavaJITCompiler* Comp = new JavaJITCompiler("JITModule");
+ JnjvmClassLoader* JCL = mvm::VirtualMachine::initialiseJVM(Comp);
+ addCommandLinePass(argv);
+ MyCl.vmlets["java"] = (create_vm_t)(mvm::VirtualMachine::createJVM);
+ MyCl.compilers["java"] = (mvm::Object*)JCL;
#endif
#if WITH_N3
mvm::CompilationUnit* CLICompiler =
More information about the vmkit-commits
mailing list