[vmkit-commits] [vmkit] r135187 - in /vmkit/trunk: include/j3/J3Intrinsics.h include/j3/JavaAOTCompiler.h include/j3/LLVMInfo.h include/mvm/JIT.h lib/J3/Compiler/J3Intrinsics.cpp lib/J3/Compiler/JavaAOTCompiler.cpp lib/J3/Compiler/JavaJIT.cpp lib/J3/Compiler/LLVMInfo.cpp lib/J3/LLVMRuntime/runtime-default.ll mmtk/inline/Makefile mmtk/magic/LowerMagic.cpp
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Thu Jul 14 14:06:14 PDT 2011
Author: geoffray
Date: Thu Jul 14 16:06:13 2011
New Revision: 135187
URL: http://llvm.org/viewvc/llvm-project?rev=135187&view=rev
Log:
API changes from LLVM after type-system-rewrite commit.
Modified:
vmkit/trunk/include/j3/J3Intrinsics.h
vmkit/trunk/include/j3/JavaAOTCompiler.h
vmkit/trunk/include/j3/LLVMInfo.h
vmkit/trunk/include/mvm/JIT.h
vmkit/trunk/lib/J3/Compiler/J3Intrinsics.cpp
vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp
vmkit/trunk/lib/J3/LLVMRuntime/runtime-default.ll
vmkit/trunk/mmtk/inline/Makefile
vmkit/trunk/mmtk/magic/LowerMagic.cpp
Modified: vmkit/trunk/include/j3/J3Intrinsics.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/J3Intrinsics.h?rev=135187&r1=135186&r2=135187&view=diff
==============================================================================
--- vmkit/trunk/include/j3/J3Intrinsics.h (original)
+++ vmkit/trunk/include/j3/J3Intrinsics.h Thu Jul 14 16:06:13 2011
@@ -17,34 +17,34 @@
class J3Intrinsics : public mvm::BaseIntrinsics {
public:
- const llvm::Type* JavaArrayUInt8Type;
- const llvm::Type* JavaArraySInt8Type;
- const llvm::Type* JavaArrayUInt16Type;
- const llvm::Type* JavaArraySInt16Type;
- const llvm::Type* JavaArrayUInt32Type;
- const llvm::Type* JavaArraySInt32Type;
- const llvm::Type* JavaArrayLongType;
- const llvm::Type* JavaArrayFloatType;
- const llvm::Type* JavaArrayDoubleType;
- const llvm::Type* JavaArrayObjectType;
-
- const llvm::Type* VTType;
- const llvm::Type* JavaObjectType;
- const llvm::Type* JavaArrayType;
- const llvm::Type* JavaCommonClassType;
- const llvm::Type* JavaClassType;
- const llvm::Type* JavaClassArrayType;
- const llvm::Type* JavaClassPrimitiveType;
- const llvm::Type* ClassBytesType;
- const llvm::Type* JavaConstantPoolType;
- const llvm::Type* ResolvedConstantPoolType;
- const llvm::Type* CodeLineInfoType;
- const llvm::Type* UTF8Type;
- const llvm::Type* JavaMethodType;
- const llvm::Type* JavaFieldType;
- const llvm::Type* AttributType;
- const llvm::Type* JavaThreadType;
- const llvm::Type* MutatorThreadType;
+ llvm::Type* JavaArrayUInt8Type;
+ llvm::Type* JavaArraySInt8Type;
+ llvm::Type* JavaArrayUInt16Type;
+ llvm::Type* JavaArraySInt16Type;
+ llvm::Type* JavaArrayUInt32Type;
+ llvm::Type* JavaArraySInt32Type;
+ llvm::Type* JavaArrayLongType;
+ llvm::Type* JavaArrayFloatType;
+ llvm::Type* JavaArrayDoubleType;
+ llvm::Type* JavaArrayObjectType;
+
+ llvm::Type* VTType;
+ llvm::Type* JavaObjectType;
+ llvm::Type* JavaArrayType;
+ llvm::Type* JavaCommonClassType;
+ llvm::Type* JavaClassType;
+ llvm::Type* JavaClassArrayType;
+ llvm::Type* JavaClassPrimitiveType;
+ llvm::Type* ClassBytesType;
+ llvm::Type* JavaConstantPoolType;
+ llvm::Type* ResolvedConstantPoolType;
+ llvm::Type* CodeLineInfoType;
+ llvm::Type* UTF8Type;
+ llvm::Type* JavaMethodType;
+ llvm::Type* JavaFieldType;
+ llvm::Type* AttributType;
+ llvm::Type* JavaThreadType;
+ llvm::Type* MutatorThreadType;
llvm::Function* StartJNIFunction;
llvm::Function* EndJNIFunction;
Modified: vmkit/trunk/include/j3/JavaAOTCompiler.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/JavaAOTCompiler.h?rev=135187&r1=135186&r2=135187&view=diff
==============================================================================
--- vmkit/trunk/include/j3/JavaAOTCompiler.h (original)
+++ vmkit/trunk/include/j3/JavaAOTCompiler.h Thu Jul 14 16:06:13 2011
@@ -102,10 +102,10 @@
llvm::Constant* getUTF8(const UTF8* val);
template<typename T>
- llvm::Constant* CreateConstantFromIntArray(const T* val, const llvm::Type* Ty);
+ llvm::Constant* CreateConstantFromIntArray(const T* val, llvm::Type* Ty);
template<typename T>
- llvm::Constant* CreateConstantFromFPArray(const T* val, const llvm::Type* Ty);
+ llvm::Constant* CreateConstantFromFPArray(const T* val, llvm::Type* Ty);
llvm::Constant* CreateConstantFromObjectArray(const ArrayObject* val);
Modified: vmkit/trunk/include/j3/LLVMInfo.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/LLVMInfo.h?rev=135187&r1=135186&r2=135187&view=diff
==============================================================================
--- vmkit/trunk/include/j3/LLVMInfo.h (original)
+++ vmkit/trunk/include/j3/LLVMInfo.h Thu Jul 14 16:06:13 2011
@@ -31,8 +31,8 @@
class LLVMAssessorInfo {
public:
- const llvm::Type* llvmType;
- const llvm::Type* llvmTypePtr;
+ llvm::Type* llvmType;
+ llvm::Type* llvmTypePtr;
uint8_t logSizeInBytesConstant;
};
@@ -50,16 +50,16 @@
llvm::Constant* virtualSizeConstant;
/// virtualType - The LLVM type of instance of this class.
- const llvm::Type * virtualType;
+ llvm::Type * virtualType;
/// staticType - The LLVM type of the static instance of this class.
- const llvm::Type * staticType;
+ llvm::Type * staticType;
public:
llvm::Value* getVirtualSize();
- const llvm::Type* getVirtualType();
- const llvm::Type* getStaticType();
+ llvm::Type* getVirtualType();
+ llvm::Type* getStaticType();
LLVMClassInfo(Class* cl, JavaLLVMCompiler* comp) :
Compiler(comp),
@@ -84,13 +84,13 @@
llvm::Function* methodFunction;
llvm::Constant* offsetConstant;
- const llvm::FunctionType* functionType;
+ llvm::FunctionType* functionType;
llvm::MDNode* DbgSubprogram;
public:
llvm::Function* getMethod();
llvm::Constant* getOffset();
- const llvm::FunctionType* getFunctionType();
+ llvm::FunctionType* getFunctionType();
LLVMMethodInfo(JavaMethod* M, JavaLLVMCompiler* comp) : Compiler(comp),
methodDef(M), methodFunction(0), offsetConstant(0), functionType(0),
@@ -135,16 +135,16 @@
/// Compiler - The compiler for this signature info.
JavaLLVMCompiler* Compiler;
- const llvm::FunctionType* staticType;
- const llvm::FunctionType* virtualType;
- const llvm::FunctionType* nativeType;
-
- const llvm::FunctionType* virtualBufType;
- const llvm::FunctionType* staticBufType;
-
- const llvm::PointerType* staticPtrType;
- const llvm::PointerType* virtualPtrType;
- const llvm::PointerType* nativePtrType;
+ llvm::FunctionType* staticType;
+ llvm::FunctionType* virtualType;
+ llvm::FunctionType* nativeType;
+
+ llvm::FunctionType* virtualBufType;
+ llvm::FunctionType* staticBufType;
+
+ llvm::PointerType* staticPtrType;
+ llvm::PointerType* virtualPtrType;
+ llvm::PointerType* nativePtrType;
llvm::Function* virtualBufFunction;
llvm::Function* virtualAPFunction;
@@ -163,16 +163,16 @@
public:
- const llvm::FunctionType* getVirtualType();
- const llvm::FunctionType* getStaticType();
- const llvm::FunctionType* getNativeType();
-
- const llvm::FunctionType* getVirtualBufType();
- const llvm::FunctionType* getStaticBufType();
-
- const llvm::PointerType* getStaticPtrType();
- const llvm::PointerType* getNativePtrType();
- const llvm::PointerType* getVirtualPtrType();
+ llvm::FunctionType* getVirtualType();
+ llvm::FunctionType* getStaticType();
+ llvm::FunctionType* getNativeType();
+
+ llvm::FunctionType* getVirtualBufType();
+ llvm::FunctionType* getStaticBufType();
+
+ llvm::PointerType* getStaticPtrType();
+ llvm::PointerType* getNativePtrType();
+ llvm::PointerType* getVirtualPtrType();
llvm::Function* getVirtualBuf();
llvm::Function* getVirtualAP();
Modified: vmkit/trunk/include/mvm/JIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/JIT.h?rev=135187&r1=135186&r2=135187&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/JIT.h (original)
+++ vmkit/trunk/include/mvm/JIT.h Thu Jul 14 16:06:13 2011
@@ -171,11 +171,11 @@
llvm::Constant* constantPtrOne;
llvm::Constant* constantPtrZero;
- const llvm::PointerType* ptrType;
- const llvm::PointerType* ptr32Type;
- const llvm::PointerType* ptrPtrType;
- const llvm::Type* arrayPtrType;
- const llvm::Type* pointerSizeType;
+ llvm::PointerType* ptrType;
+ llvm::PointerType* ptr32Type;
+ llvm::PointerType* ptrPtrType;
+ llvm::Type* arrayPtrType;
+ llvm::Type* pointerSizeType;
};
Modified: vmkit/trunk/lib/J3/Compiler/J3Intrinsics.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/J3Intrinsics.cpp?rev=135187&r1=135186&r2=135187&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/J3Intrinsics.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/J3Intrinsics.cpp Thu Jul 14 16:06:13 2011
@@ -35,8 +35,9 @@
BaseIntrinsics(module) {
j3::llvm_runtime::makeLLVMModuleContents(module);
- VTType = PointerType::getUnqual(module->getTypeByName("VT"));
LLVMContext& Context = module->getContext();
+ VTType = PointerType::getUnqual(ArrayType::get(
+ PointerType::getUnqual(FunctionType::get(Type::getInt32Ty(Context), true)), 0));
ResolvedConstantPoolType = ptrPtrType;
Modified: vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp?rev=135187&r1=135186&r2=135187&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp Thu Jul 14 16:06:13 2011
@@ -71,7 +71,7 @@
native_class_iterator End = nativeClasses.end();
native_class_iterator I = nativeClasses.find(classDef);
if (I == End) {
- const llvm::Type* Ty = 0;
+ llvm::Type* Ty = NULL;
if (classDef->isArray()) {
Ty = JavaIntrinsics.JavaClassArrayType->getContainedType(0);
@@ -100,7 +100,7 @@
array_class_iterator End = arrayClasses.end();
array_class_iterator I = arrayClasses.find(classDef->asArrayClass());
if (I == End) {
- const llvm::Type* Ty = JavaIntrinsics.JavaClassArrayType;
+ llvm::Type* Ty = JavaIntrinsics.JavaClassArrayType;
Module& Mod = *getLLVMModule();
GlobalVariable* varGV =
@@ -120,7 +120,7 @@
}
Constant* JavaAOTCompiler::CreateConstantFromJavaConstantPool(JavaConstantPool* ctp) {
- const StructType* STy =
+ StructType* STy =
dyn_cast<StructType>(JavaIntrinsics.JavaConstantPoolType->getContainedType(0));
Module& Mod = *getLLVMModule();
@@ -133,7 +133,7 @@
Elemts.push_back(ConstantInt::get(Type::getInt32Ty(getLLVMContext()), ctp->ctpSize));
// ctpType
- const ArrayType* ATy = ArrayType::get(Type::getInt8Ty(getLLVMContext()), ctp->ctpSize);
+ ArrayType* ATy = ArrayType::get(Type::getInt8Ty(getLLVMContext()), ctp->ctpSize);
std::vector<Constant*> Vals;
for (uint32 i = 0; i < ctp->ctpSize; ++i) {
Vals.push_back(ConstantInt::get(Type::getInt8Ty(getLLVMContext()), ctp->ctpType[i]));
@@ -177,7 +177,7 @@
if (I == End) {
Module& Mod = *getLLVMModule();
- const ArrayType* ATy = ArrayType::get(JavaIntrinsics.ptrType, ctp->ctpSize);
+ ArrayType* ATy = ArrayType::get(JavaIntrinsics.ptrType, ctp->ctpSize);
std::vector<Constant*> Vals;
for (uint32 i = 0; i < ctp->ctpSize; ++i) {
Vals.push_back(Constant::getNullValue(JavaIntrinsics.ptrType));
@@ -218,7 +218,7 @@
std::string name(UTF8Buffer(cl->name).toCompileName()->cString());
name += "_VirtualMethods";
Module& Mod = *getLLVMModule();
- const Type* ATy =
+ Type* ATy =
ArrayType::get(JavaIntrinsics.JavaMethodType->getContainedType(0),
cl->nbVirtualMethods + cl->nbStaticMethods);
@@ -239,7 +239,7 @@
} else {
assert(str && "No string given");
LLVMClassInfo* LCI = getClassInfo(JavaObject::getClass(str)->asClass());
- const llvm::Type* Ty = LCI->getVirtualType();
+ llvm::Type* Ty = LCI->getVirtualType();
Module& Mod = *getLLVMModule();
const char* name = JavaString::strToAsciiz(str);
@@ -264,7 +264,7 @@
Constant* JavaAOTCompiler::getJavaClass(CommonClass* cl) {
Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
LLVMClassInfo* LCI = getClassInfo(javaClass);
- const llvm::Type* Ty = LCI->getVirtualType();
+ llvm::Type* Ty = LCI->getVirtualType();
if (useCooperativeGC()) {
return Constant::getNullValue(JavaIntrinsics.JavaObjectType);
@@ -342,8 +342,8 @@
intptr_t* realObj = (intptr_t*)obj;
intptr_t size = realObj[0];
- const ArrayType* ATy = ArrayType::get(JavaIntrinsics.JavaObjectType,
- size + 1);
+ ArrayType* ATy = ArrayType::get(JavaIntrinsics.JavaObjectType,
+ size + 1);
std::vector<Constant*> Vals;
for (sint32 i = 0; i < size + 1; ++i) {
@@ -379,7 +379,7 @@
if (I == End) {
if (mvm::Collector::begOf(obj)) {
- const Type* Ty = 0;
+ Type* Ty = 0;
CommonClass* cl = JavaObject::getClass(obj);
if (cl->isArray()) {
@@ -409,8 +409,8 @@
Ty = JavaIntrinsics.JavaObjectType;
}
- std::vector<const Type*> Elemts;
- const ArrayType* ATy = ArrayType::get(Ty, JavaArray::getSize(obj));
+ std::vector<Type*> Elemts;
+ ArrayType* ATy = ArrayType::get(Ty, JavaArray::getSize(obj));
Elemts.push_back(JavaIntrinsics.JavaObjectType->getContainedType(0));
Elemts.push_back(JavaIntrinsics.pointerSizeType);
Elemts.push_back(ATy);
@@ -446,8 +446,8 @@
Constant* JavaAOTCompiler::CreateConstantFromStaticInstance(Class* cl) {
LLVMClassInfo* LCI = getClassInfo(cl);
- const Type* Ty = LCI->getStaticType();
- const StructType* STy = dyn_cast<StructType>(Ty->getContainedType(0));
+ Type* Ty = LCI->getStaticType();
+ StructType* STy = dyn_cast<StructType>(Ty->getContainedType(0));
std::vector<Constant*> Elts;
@@ -455,7 +455,7 @@
JavaField& field = cl->staticFields[i];
const Typedef* type = field.getSignature();
LLVMAssessorInfo& LAI = getTypedefInfo(type);
- const Type* Ty = LAI.llvmType;
+ Type* Ty = LAI.llvmType;
Attribut* attribut = field.lookupAttribut(Attribut::constantAttribut);
@@ -550,7 +550,7 @@
if (I == End) {
LLVMClassInfo* LCI = getClassInfo(classDef);
- const Type* Ty = LCI->getStaticType();
+ Type* Ty = LCI->getStaticType();
Ty = Ty->getContainedType(0);
std::string name(UTF8Buffer(classDef->name).toCompileName()->cString());
name += "_static";
@@ -589,9 +589,9 @@
virtual_table_iterator I = virtualTables.find(VT);
if (I == End) {
- const ArrayType* ATy =
+ ArrayType* ATy =
dyn_cast<ArrayType>(JavaIntrinsics.VTType->getContainedType(0));
- const PointerType* PTy = dyn_cast<PointerType>(ATy->getContainedType(0));
+ PointerType* PTy = dyn_cast<PointerType>(ATy->getContainedType(0));
ATy = ArrayType::get(PTy, size);
std::string name(UTF8Buffer(classDef->name).toCompileName()->cString());
name += "_VT";
@@ -624,7 +624,7 @@
if (I == End) {
LLVMSignatureInfo* LSI = getSignatureInfo(meth->getSignature());
- const llvm::Type* valPtrType = LSI->getNativePtrType();
+ llvm::Type* valPtrType = LSI->getNativePtrType();
Module& Mod = *getLLVMModule();
varGV = new GlobalVariable(Mod, valPtrType, false,
@@ -640,7 +640,7 @@
Constant* JavaAOTCompiler::CreateConstantForBaseObject(CommonClass* cl) {
assert(!useCooperativeGC());
- const StructType* STy =
+ StructType* STy =
dyn_cast<StructType>(JavaIntrinsics.JavaObjectType->getContainedType(0));
std::vector<Constant*> Elmts;
@@ -659,7 +659,7 @@
assert(!useCooperativeGC());
Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass;
LLVMClassInfo* LCI = getClassInfo(javaClass);
- const StructType* STy =
+ StructType* STy =
dyn_cast<StructType>(LCI->getVirtualType()->getContainedType(0));
std::vector<Constant*> Elmts;
@@ -737,7 +737,7 @@
TempElts.push_back(CurConstant);
Class* curCl = cl->virtualVT->display[j]->cl->asClass();
LLVMClassInfo* LCI = getClassInfo(curCl);
- const StructType* STy =
+ StructType* STy =
dyn_cast<StructType>(LCI->getVirtualType()->getContainedType(0));
for (uint32 i = 0; i < curCl->nbVirtualFields; ++i) {
@@ -780,7 +780,7 @@
Constant* C = getFinalObject(val, FieldCl);
TempElts.push_back(C);
} else {
- const llvm::Type* Ty = JavaIntrinsics.JavaObjectType;
+ llvm::Type* Ty = JavaIntrinsics.JavaObjectType;
TempElts.push_back(Constant::getNullValue(Ty));
}
}
@@ -796,7 +796,7 @@
assert(!useCooperativeGC());
Class* cl = JavaObject::getClass(str)->asClass();
LLVMClassInfo* LCI = getClassInfo(cl);
- const StructType* STy =
+ StructType* STy =
dyn_cast<StructType>(LCI->getVirtualType()->getContainedType(0));
std::vector<Constant*> Elmts;
@@ -828,7 +828,7 @@
Constant* JavaAOTCompiler::CreateConstantFromAttribut(Attribut& attribut) {
- const StructType* STy =
+ StructType* STy =
dyn_cast<StructType>(JavaIntrinsics.AttributType->getContainedType(0));
@@ -847,21 +847,21 @@
}
Constant* JavaAOTCompiler::CreateConstantFromCommonClass(CommonClass* cl) {
- const StructType* STy =
+ StructType* STy =
dyn_cast<StructType>(JavaIntrinsics.JavaCommonClassType->getContainedType(0));
Module& Mod = *getLLVMModule();
- const llvm::Type* TempTy = 0;
+ llvm::Type* TempTy = NULL;
std::vector<Constant*> CommonClassElts;
std::vector<Constant*> TempElmts;
// delegatee
- const ArrayType* ATy = dyn_cast<ArrayType>(STy->getContainedType(0));
+ ArrayType* ATy = dyn_cast<ArrayType>(STy->getContainedType(0));
assert(ATy && "Malformed type");
Constant* TCM[1] = { getJavaClass(cl) };
- CommonClassElts.push_back(ConstantArray::get(ATy, TCM, 1));
+ CommonClassElts.push_back(ConstantArray::get(ATy, TCM));
// access
CommonClassElts.push_back(ConstantInt::get(Type::getInt16Ty(getLLVMContext()), cl->access));
@@ -882,7 +882,7 @@
CommonClassElts.push_back(interfaces);
} else {
- const Type* Ty = PointerType::getUnqual(JavaIntrinsics.JavaClassType);
+ Type* Ty = PointerType::getUnqual(JavaIntrinsics.JavaClassType);
CommonClassElts.push_back(Constant::getNullValue(Ty));
}
@@ -917,7 +917,7 @@
}
Constant* JavaAOTCompiler::CreateConstantFromJavaField(JavaField& field) {
- const StructType* STy =
+ StructType* STy =
dyn_cast<StructType>(JavaIntrinsics.JavaFieldType->getContainedType(0));
std::vector<Constant*> FieldElts;
@@ -937,8 +937,8 @@
// attributs
if (field.nbAttributs) {
- const llvm::Type* AttrTy = JavaIntrinsics.AttributType->getContainedType(0);
- const ArrayType* ATy = ArrayType::get(AttrTy, field.nbAttributs);
+ llvm::Type* AttrTy = JavaIntrinsics.AttributType->getContainedType(0);
+ ArrayType* ATy = ArrayType::get(AttrTy, field.nbAttributs);
for (uint32 i = 0; i < field.nbAttributs; ++i) {
TempElts.push_back(CreateConstantFromAttribut(field.attributs[i]));
}
@@ -972,7 +972,7 @@
}
Constant* JavaAOTCompiler::CreateConstantFromJavaMethod(JavaMethod& method) {
- const StructType* STy =
+ StructType* STy =
dyn_cast<StructType>(JavaIntrinsics.JavaMethodType->getContainedType(0));
Module& Mod = *getLLVMModule();
@@ -987,8 +987,8 @@
// attributs
if (method.nbAttributs) {
- const llvm::Type* AttrTy = JavaIntrinsics.AttributType->getContainedType(0);
- const ArrayType* ATy = ArrayType::get(AttrTy, method.nbAttributs);
+ llvm::Type* AttrTy = JavaIntrinsics.AttributType->getContainedType(0);
+ ArrayType* ATy = ArrayType::get(AttrTy, method.nbAttributs);
for (uint32 i = 0; i < method.nbAttributs; ++i) {
TempElts.push_back(CreateConstantFromAttribut(method.attributs[i]));
}
@@ -1044,9 +1044,9 @@
}
Constant* JavaAOTCompiler::CreateConstantFromClassPrimitive(ClassPrimitive* cl) {
- const llvm::Type* JCPTy =
+ llvm::Type* JCPTy =
JavaIntrinsics.JavaClassPrimitiveType->getContainedType(0);
- const StructType* STy = dyn_cast<StructType>(JCPTy);
+ StructType* STy = dyn_cast<StructType>(JCPTy);
std::vector<Constant*> ClassElts;
@@ -1060,7 +1060,7 @@
}
Constant* JavaAOTCompiler::CreateConstantFromClassArray(ClassArray* cl) {
- const StructType* STy =
+ StructType* STy =
dyn_cast<StructType>(JavaIntrinsics.JavaClassArrayType->getContainedType(0));
std::vector<Constant*> ClassElts;
@@ -1081,7 +1081,7 @@
}
Constant* JavaAOTCompiler::CreateConstantFromClass(Class* cl) {
- const StructType* STy =
+ StructType* STy =
dyn_cast<StructType>(JavaIntrinsics.JavaClassType->getContainedType(0));
Module& Mod = *getLLVMModule();
@@ -1100,10 +1100,10 @@
cl->alignment));
// IsolateInfo
- const ArrayType* ATy = dyn_cast<ArrayType>(STy->getContainedType(3));
+ ArrayType* ATy = dyn_cast<ArrayType>(STy->getContainedType(3));
assert(ATy && "Malformed type");
- const StructType* TCMTy = dyn_cast<StructType>(ATy->getContainedType(0));
+ StructType* TCMTy = dyn_cast<StructType>(ATy->getContainedType(0));
assert(TCMTy && "Malformed type");
uint32 status = cl->needsInitialisationCheck() ? vmjc : ready;
@@ -1114,7 +1114,7 @@
TempElts.push_back(getStaticInstance(cl));
Constant* CStr[1] = { ConstantStruct::get(TCMTy, TempElts) };
TempElts.clear();
- ClassElts.push_back(ConstantArray::get(ATy, CStr, 1));
+ ClassElts.push_back(ConstantArray::get(ATy, CStr));
if (cl->nbVirtualFields + cl->nbStaticFields) {
ATy = ArrayType::get(JavaIntrinsics.JavaFieldType->getContainedType(0),
@@ -1274,7 +1274,7 @@
TempElts.push_back(getNativeClass(cl->innerClasses[i]));
}
- const llvm::Type* TempTy = JavaIntrinsics.JavaClassType;
+ llvm::Type* TempTy = JavaIntrinsics.JavaClassType;
ATy = ArrayType::get(TempTy, cl->nbInnerClasses);
Constant* innerClasses = ConstantArray::get(ATy, TempElts);
innerClasses = new GlobalVariable(*getLLVMModule(), ATy, true,
@@ -1285,7 +1285,7 @@
ClassElts.push_back(innerClasses);
} else {
- const Type* Ty = PointerType::getUnqual(JavaIntrinsics.JavaClassType);
+ Type* Ty = PointerType::getUnqual(JavaIntrinsics.JavaClassType);
ClassElts.push_back(Constant::getNullValue(Ty));
}
@@ -1318,12 +1318,12 @@
}
Constant* JavaAOTCompiler::CreateConstantFromClassBytes(ClassBytes* bytes) {
- std::vector<const Type*> Elemts;
- const ArrayType* ATy = ArrayType::get(Type::getInt8Ty(getLLVMContext()), bytes->size);
+ std::vector<Type*> Elemts;
+ ArrayType* ATy = ArrayType::get(Type::getInt8Ty(getLLVMContext()), bytes->size);
Elemts.push_back(Type::getInt32Ty(getLLVMContext()));
Elemts.push_back(ATy);
- const StructType* STy = StructType::get(getLLVMContext(), Elemts);
+ StructType* STy = StructType::get(getLLVMContext(), Elemts);
std::vector<Constant*> Cts;
Cts.push_back(ConstantInt::get(Type::getInt32Ty(getLLVMContext()), bytes->size));
@@ -1339,17 +1339,17 @@
}
template<typename T>
-Constant* JavaAOTCompiler::CreateConstantFromIntArray(const T* val, const Type* Ty) {
+Constant* JavaAOTCompiler::CreateConstantFromIntArray(const T* val, Type* Ty) {
assert(!useCooperativeGC());
- std::vector<const Type*> Elemts;
- const ArrayType* ATy = ArrayType::get(Ty, T::getSize(val));
+ std::vector<Type*> Elemts;
+ ArrayType* ATy = ArrayType::get(Ty, T::getSize(val));
Elemts.push_back(JavaIntrinsics.JavaObjectType->getContainedType(0));
Elemts.push_back(JavaIntrinsics.pointerSizeType);
Elemts.push_back(ATy);
- const StructType* STy = StructType::get(getLLVMModule()->getContext(), Elemts);
+ StructType* STy = StructType::get(getLLVMModule()->getContext(), Elemts);
std::vector<Constant*> Cts;
Cts.push_back(CreateConstantForBaseObject(JavaObject::getClass(val)));
@@ -1366,17 +1366,17 @@
}
template<typename T>
-Constant* JavaAOTCompiler::CreateConstantFromFPArray(const T* val, const Type* Ty) {
+Constant* JavaAOTCompiler::CreateConstantFromFPArray(const T* val, Type* Ty) {
assert(!useCooperativeGC());
- std::vector<const Type*> Elemts;
- const ArrayType* ATy = ArrayType::get(Ty, T::getSize(val));
+ std::vector<Type*> Elemts;
+ ArrayType* ATy = ArrayType::get(Ty, T::getSize(val));
Elemts.push_back(JavaIntrinsics.JavaObjectType->getContainedType(0));
Elemts.push_back(JavaIntrinsics.pointerSizeType);
Elemts.push_back(ATy);
- const StructType* STy = StructType::get(getLLVMModule()->getContext(), Elemts);
+ StructType* STy = StructType::get(getLLVMModule()->getContext(), Elemts);
std::vector<Constant*> Cts;
Cts.push_back(CreateConstantForBaseObject(JavaObject::getClass(val)));
@@ -1394,16 +1394,16 @@
Constant* JavaAOTCompiler::CreateConstantFromObjectArray(const ArrayObject* val) {
assert(!useCooperativeGC());
- std::vector<const Type*> Elemts;
- const llvm::Type* Ty = JavaIntrinsics.JavaObjectType;
- const ArrayType* ATy = ArrayType::get(Ty, ArrayObject::getSize(val));
+ std::vector<Type*> Elemts;
+ llvm::Type* Ty = JavaIntrinsics.JavaObjectType;
+ ArrayType* ATy = ArrayType::get(Ty, ArrayObject::getSize(val));
Elemts.push_back(JavaIntrinsics.JavaObjectType->getContainedType(0));
Elemts.push_back(JavaIntrinsics.pointerSizeType);
Elemts.push_back(ATy);
- const StructType* STy = StructType::get(getLLVMModule()->getContext(), Elemts);
+ StructType* STy = StructType::get(getLLVMModule()->getContext(), Elemts);
std::vector<Constant*> Cts;
Cts.push_back(CreateConstantForBaseObject(JavaObject::getClass(val)));
@@ -1426,13 +1426,13 @@
}
Constant* JavaAOTCompiler::CreateConstantFromUTF8(const UTF8* val) {
- std::vector<const Type*> Elemts;
- const ArrayType* ATy = ArrayType::get(Type::getInt16Ty(getLLVMContext()), val->size);
+ std::vector<Type*> Elemts;
+ ArrayType* ATy = ArrayType::get(Type::getInt16Ty(getLLVMContext()), val->size);
Elemts.push_back(JavaIntrinsics.pointerSizeType);
Elemts.push_back(ATy);
- const StructType* STy = StructType::get(getLLVMModule()->getContext(),
+ StructType* STy = StructType::get(getLLVMModule()->getContext(),
Elemts);
std::vector<Constant*> Cts;
@@ -1495,9 +1495,9 @@
JavaVirtualTable* RealVT = classDef->isClass() ?
VT : ClassArray::SuperArray->virtualVT;
- const ArrayType* ATy =
+ ArrayType* ATy =
dyn_cast<ArrayType>(JavaIntrinsics.VTType->getContainedType(0));
- const PointerType* PTy = dyn_cast<PointerType>(ATy->getContainedType(0));
+ PointerType* PTy = dyn_cast<PointerType>(ATy->getContainedType(0));
ATy = ArrayType::get(PTy, size);
ConstantPointerNull* N = ConstantPointerNull::get(PTy);
@@ -1572,8 +1572,8 @@
ConstantInt::get(Type::getInt64Ty(getLLVMContext()), VT->nbSecondaryTypes), PTy));
// secondaryTypes
- const ArrayType* DTy = ArrayType::get(JavaIntrinsics.VTType,
- VT->nbSecondaryTypes);
+ ArrayType* DTy = ArrayType::get(JavaIntrinsics.VTType,
+ VT->nbSecondaryTypes);
std::vector<Constant*> TempElmts;
for (uint32 i = 0; i < VT->nbSecondaryTypes; ++i) {
@@ -1612,9 +1612,9 @@
classDef->asClass()->fillIMT(contents);
- const ArrayType* ATy =
+ ArrayType* ATy =
dyn_cast<ArrayType>(JavaIntrinsics.VTType->getContainedType(0));
- const PointerType* PTy = dyn_cast<PointerType>(ATy->getContainedType(0));
+ PointerType* PTy = dyn_cast<PointerType>(ATy->getContainedType(0));
ATy = ArrayType::get(PTy, InterfaceMethodTable::NumIndexes);
ConstantPointerNull* N = ConstantPointerNull::get(PTy);
@@ -1656,7 +1656,7 @@
uint32_t length = 2 * size;
- const ArrayType* ATy =
+ ArrayType* ATy =
dyn_cast<ArrayType>(JavaIntrinsics.VTType->getContainedType(0));
ATy = ArrayType::get(PTy, length);
std::vector<Constant*> InternalElemts;
@@ -1725,10 +1725,10 @@
compileRT = false;
precompile = false;
- std::vector<const llvm::Type*> llvmArgs;
+ std::vector<llvm::Type*> llvmArgs;
llvmArgs.push_back(JavaIntrinsics.ptrType); // class loader.
- const FunctionType* FTy = FunctionType::get(Type::getVoidTy(getLLVMContext()),
- llvmArgs, false);
+ FunctionType* FTy = FunctionType::get(Type::getVoidTy(getLLVMContext()),
+ llvmArgs, false);
StaticInitializer = Function::Create(FTy, GlobalValue::InternalLinkage,
"Init", getLLVMModule());
@@ -1799,10 +1799,10 @@
void JavaAOTCompiler::CreateStaticInitializer() {
- std::vector<const llvm::Type*> llvmArgs;
+ std::vector<llvm::Type*> llvmArgs;
llvmArgs.push_back(JavaIntrinsics.ptrType); // class loader
llvmArgs.push_back(JavaIntrinsics.JavaCommonClassType); // cl
- const FunctionType* FTy =
+ FunctionType* FTy =
FunctionType::get(Type::getVoidTy(getLLVMContext()), llvmArgs, false);
Function* AddClass = Function::Create(FTy, GlobalValue::ExternalLinkage,
@@ -1929,8 +1929,8 @@
LLVMSignatureInfo* LSI = getSignatureInfo(sign);
- const FunctionType* type = stat ? LSI->getStaticType() :
- LSI->getVirtualType();
+ FunctionType* type = stat ? LSI->getStaticType() :
+ LSI->getVirtualType();
Value* func = ConstantExpr::getBitCast(Callback,
PointerType::getUnqual(type));
@@ -2234,7 +2234,7 @@
void JavaAOTCompiler::generateMain(const char* name, bool jit) {
// Type Definitions
- std::vector<const Type*> FuncArgs;
+ std::vector<Type*> FuncArgs;
FuncArgs.push_back(Type::getInt32Ty(getLLVMContext()));
FuncArgs.push_back(PointerType::getUnqual(JavaIntrinsics.ptrType));
Modified: vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp?rev=135187&r1=135186&r2=135187&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp Thu Jul 14 16:06:13 2011
@@ -1305,12 +1305,13 @@
for (sint32 i = start; i >= 0; --i) {
it--;
- if (it->get() == Type::getInt64Ty(*llvmContext) || it->get() == Type::getDoubleTy(*llvmContext)) {
+ if (*it == Type::getInt64Ty(*llvmContext)
+ || *it == Type::getDoubleTy(*llvmContext)) {
pop();
}
Value* tmp = pop();
- const Type* type = it->get();
+ Type* type = *it;
if (tmp->getType() != type) { // int8 or int16
convertValue(tmp, type, currentBlock, false);
}
Modified: vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp?rev=135187&r1=135186&r2=135187&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp Thu Jul 14 16:06:13 2011
@@ -35,17 +35,17 @@
using namespace j3;
using namespace llvm;
-const Type* LLVMClassInfo::getVirtualType() {
+Type* LLVMClassInfo::getVirtualType() {
if (!virtualType) {
- std::vector<const llvm::Type*> fields;
+ std::vector<llvm::Type*> fields;
const TargetData* targetData = mvm::MvmModule::TheTargetData;
const StructLayout* sl = 0;
- const StructType* structType = 0;
+ StructType* structType = 0;
LLVMContext& context = Compiler->getLLVMModule()->getContext();
if (classDef->super) {
LLVMClassInfo* CLI = Compiler->getClassInfo(classDef->super);
- const llvm::Type* Ty = CLI->getVirtualType()->getContainedType(0);
+ llvm::Type* Ty = CLI->getVirtualType()->getContainedType(0);
fields.push_back(Ty);
for (uint32 i = 0; i < classDef->nbVirtualFields; ++i) {
@@ -63,7 +63,7 @@
} else {
virtualType = Compiler->getIntrinsics()->JavaObjectType;
assert(virtualType && "intrinsics not initalized");
- structType = dyn_cast<const StructType>(virtualType->getContainedType(0));
+ structType = dyn_cast<StructType>(virtualType->getContainedType(0));
sl = targetData->getStructLayout(structType);
}
@@ -90,11 +90,11 @@
return virtualType;
}
-const Type* LLVMClassInfo::getStaticType() {
+Type* LLVMClassInfo::getStaticType() {
if (!staticType) {
Class* cl = (Class*)classDef;
- std::vector<const llvm::Type*> fields;
+ std::vector<llvm::Type*> fields;
LLVMContext& context = Compiler->getLLVMModule()->getContext();
@@ -179,7 +179,7 @@
return methodFunction;
}
-const FunctionType* LLVMMethodInfo::getFunctionType() {
+FunctionType* LLVMMethodInfo::getFunctionType() {
if (!functionType) {
Signdef* sign = methodDef->getSignature();
LLVMSignatureInfo* LSI = Compiler->getSignatureInfo(sign);
@@ -219,11 +219,11 @@
return offsetConstant;
}
-const llvm::FunctionType* LLVMSignatureInfo::getVirtualType() {
+llvm::FunctionType* LLVMSignatureInfo::getVirtualType() {
if (!virtualType) {
// Lock here because we are called by arbitrary code
mvm::MvmModule::protectIR();
- std::vector<const llvm::Type*> llvmArgs;
+ std::vector<llvm::Type*> llvmArgs;
uint32 size = signature->nbArguments;
Typedef* const* arguments = signature->getArgumentsType();
@@ -243,11 +243,11 @@
return virtualType;
}
-const llvm::FunctionType* LLVMSignatureInfo::getStaticType() {
+llvm::FunctionType* LLVMSignatureInfo::getStaticType() {
if (!staticType) {
// Lock here because we are called by arbitrary code
mvm::MvmModule::protectIR();
- std::vector<const llvm::Type*> llvmArgs;
+ std::vector<llvm::Type*> llvmArgs;
uint32 size = signature->nbArguments;
Typedef* const* arguments = signature->getArgumentsType();
@@ -265,15 +265,15 @@
return staticType;
}
-const llvm::FunctionType* LLVMSignatureInfo::getNativeType() {
+llvm::FunctionType* LLVMSignatureInfo::getNativeType() {
if (!nativeType) {
// Lock here because we are called by arbitrary code
mvm::MvmModule::protectIR();
- std::vector<const llvm::Type*> llvmArgs;
+ std::vector<llvm::Type*> llvmArgs;
uint32 size = signature->nbArguments;
Typedef* const* arguments = signature->getArgumentsType();
- const llvm::Type* Ty =
+ llvm::Type* Ty =
PointerType::getUnqual(Compiler->getIntrinsics()->JavaObjectType);
llvmArgs.push_back(Compiler->getIntrinsics()->ptrType); // JNIEnv
@@ -282,7 +282,7 @@
for (uint32 i = 0; i < size; ++i) {
Typedef* type = arguments[i];
LLVMAssessorInfo& LAI = Compiler->getTypedefInfo(type);
- const llvm::Type* Ty = LAI.llvmType;
+ llvm::Type* Ty = LAI.llvmType;
if (Ty == Compiler->getIntrinsics()->JavaObjectType) {
llvmArgs.push_back(LAI.llvmTypePtr);
} else {
@@ -292,7 +292,7 @@
LLVMAssessorInfo& LAI =
Compiler->getTypedefInfo(signature->getReturnType());
- const llvm::Type* RetType =
+ llvm::Type* RetType =
LAI.llvmType == Compiler->getIntrinsics()->JavaObjectType ?
LAI.llvmTypePtr : LAI.llvmType;
nativeType = FunctionType::get(RetType, llvmArgs, false);
@@ -564,21 +564,21 @@
return stub;
}
-const PointerType* LLVMSignatureInfo::getStaticPtrType() {
+PointerType* LLVMSignatureInfo::getStaticPtrType() {
if (!staticPtrType) {
staticPtrType = PointerType::getUnqual(getStaticType());
}
return staticPtrType;
}
-const PointerType* LLVMSignatureInfo::getVirtualPtrType() {
+PointerType* LLVMSignatureInfo::getVirtualPtrType() {
if (!virtualPtrType) {
virtualPtrType = PointerType::getUnqual(getVirtualType());
}
return virtualPtrType;
}
-const PointerType* LLVMSignatureInfo::getNativePtrType() {
+PointerType* LLVMSignatureInfo::getNativePtrType() {
if (!nativePtrType) {
nativePtrType = PointerType::getUnqual(getNativeType());
}
@@ -586,11 +586,11 @@
}
-const FunctionType* LLVMSignatureInfo::getVirtualBufType() {
+FunctionType* LLVMSignatureInfo::getVirtualBufType() {
if (!virtualBufType) {
// Lock here because we are called by arbitrary code
mvm::MvmModule::protectIR();
- std::vector<const llvm::Type*> Args;
+ std::vector<llvm::Type*> Args;
Args.push_back(Compiler->getIntrinsics()->ResolvedConstantPoolType); // ctp
Args.push_back(getVirtualPtrType());
Args.push_back(Compiler->getIntrinsics()->JavaObjectType);
@@ -603,11 +603,11 @@
return virtualBufType;
}
-const FunctionType* LLVMSignatureInfo::getStaticBufType() {
+FunctionType* LLVMSignatureInfo::getStaticBufType() {
if (!staticBufType) {
// Lock here because we are called by arbitrary code
mvm::MvmModule::protectIR();
- std::vector<const llvm::Type*> Args;
+ std::vector<llvm::Type*> Args;
Args.push_back(Compiler->getIntrinsics()->ResolvedConstantPoolType); // ctp
Args.push_back(getStaticPtrType());
Args.push_back(Compiler->AssessorInfo[I_LONG].llvmTypePtr);
Modified: vmkit/trunk/lib/J3/LLVMRuntime/runtime-default.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/LLVMRuntime/runtime-default.ll?rev=135187&r1=135186&r2=135187&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/LLVMRuntime/runtime-default.ll (original)
+++ vmkit/trunk/lib/J3/LLVMRuntime/runtime-default.ll Thu Jul 14 16:06:13 2011
@@ -64,7 +64,37 @@
%JavaClassArray = type { %JavaCommonClass, %JavaCommonClass* }
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;; Constant calls for Jnjvm runtime internal objects field accesses ;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;; Make sure all named types are emitted ;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+declare void @listAllTypes(%JavaObject,
+ %JavaArray,
+ %JavaCommonClass,
+ %JavaClassPrimitive,
+ %JavaClassArray,
+ %JavaClass,
+ %ClassBytes,
+ %JavaConstantPool,
+ %ArrayUInt8,
+ %ArraySInt8,
+ %ArrayUInt16,
+ %ArraySInt16,
+ %ArrayUInt32,
+ %ArraySInt32,
+ %ArrayLong,
+ %ArrayDouble,
+ %ArrayFloat,
+ %ArrayObject,
+ %JavaField,
+ %JavaMethod,
+ %UTF8,
+ %Attribut,
+ %JavaThread,
+ %MutatorThread,
+ %CodeLineInfo);
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;; Constant calls for J3 runtime internal objects field accesses ;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; j3RuntimeInitialiseClass - Initialises the class.
Modified: vmkit/trunk/mmtk/inline/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/inline/Makefile?rev=135187&r1=135186&r2=135187&view=diff
==============================================================================
--- vmkit/trunk/mmtk/inline/Makefile (original)
+++ vmkit/trunk/mmtk/inline/Makefile Thu Jul 14 16:06:13 2011
@@ -17,3 +17,6 @@
# Use CompileCommonOpts instead of CXX.Flags to make sure the flag is added
# after the -Wall added by LLVM.
CompileCommonOpts += -Wno-unused-variable
+
+clean-local::
+ $(Verb) $(RM) -f *.inc
Modified: vmkit/trunk/mmtk/magic/LowerMagic.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/magic/LowerMagic.cpp?rev=135187&r1=135186&r2=135187&view=diff
==============================================================================
--- vmkit/trunk/mmtk/magic/LowerMagic.cpp (original)
+++ vmkit/trunk/mmtk/magic/LowerMagic.cpp Thu Jul 14 16:06:13 2011
@@ -382,22 +382,22 @@
Module* globalModule = F.getParent();
LLVMContext& Context = globalModule->getContext();
bool Changed = false;
- const llvm::Type* pointerSizeType =
+ llvm::Type* pointerSizeType =
globalModule->getPointerSize() == llvm::Module::Pointer32 ?
Type::getInt32Ty(Context) : Type::getInt64Ty(Context);
Constant* constantPtrLogSize =
ConstantInt::get(Type::getInt32Ty(Context), sizeof(void*) == 8 ? 3 : 2);
- const llvm::Type* ptrType = PointerType::getUnqual(Type::getInt8Ty(Context));
- const llvm::Type* ptrSizeType = PointerType::getUnqual(pointerSizeType);
+ llvm::Type* ptrType = PointerType::getUnqual(Type::getInt8Ty(Context));
+ llvm::Type* ptrSizeType = PointerType::getUnqual(pointerSizeType);
initialiseFunctions(globalModule);
Function* MMalloc = globalModule->getFunction("AllocateMagicArray");
if (!MMalloc) {
- std::vector<const Type*>FuncTyArgs;
+ std::vector<Type*>FuncTyArgs;
FuncTyArgs.push_back(Type::getInt32Ty(Context));
FuncTyArgs.push_back(ptrType);
FunctionType* FuncTy = FunctionType::get(ptrType, FuncTyArgs, false);
More information about the vmkit-commits
mailing list