From 62e744b555d48b4c8b9023739fef8ae403bb20e8 Mon Sep 17 00:00:00 2001 From: Owen Anderson Date: Tue, 7 Jul 2009 21:33:58 +0000 Subject: LLVMContext-ifiy the implementation of the C API. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@74950 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/VMCore/Core.cpp | 161 +++++++++++++++++++++++++++++++++------------------- 1 file changed, 102 insertions(+), 59 deletions(-) (limited to 'lib/VMCore') diff --git a/lib/VMCore/Core.cpp b/lib/VMCore/Core.cpp index ac2dfcc..efc229d 100644 --- a/lib/VMCore/Core.cpp +++ b/lib/VMCore/Core.cpp @@ -128,7 +128,7 @@ LLVMTypeRef LLVMInt32Type(void) { return (LLVMTypeRef) Type::Int32Ty; } LLVMTypeRef LLVMInt64Type(void) { return (LLVMTypeRef) Type::Int64Ty; } LLVMTypeRef LLVMIntType(unsigned NumBits) { - return wrap(IntegerType::get(NumBits)); + return wrap(getGlobalContext().getIntegerType(NumBits)); } unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy) { @@ -152,7 +152,8 @@ LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType, for (LLVMTypeRef *I = ParamTypes, *E = ParamTypes + ParamCount; I != E; ++I) Tys.push_back(unwrap(*I)); - return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0)); + return wrap(getGlobalContext().getFunctionType(unwrap(ReturnType), Tys, + IsVarArg != 0)); } int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy) { @@ -183,7 +184,7 @@ LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, *E = ElementTypes + ElementCount; I != E; ++I) Tys.push_back(unwrap(*I)); - return wrap(StructType::get(Tys, Packed != 0)); + return wrap(getGlobalContext().getStructType(Tys, Packed != 0)); } unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy) { @@ -204,15 +205,18 @@ int LLVMIsPackedStruct(LLVMTypeRef StructTy) { /*--.. Operations on array, pointer, and vector types (sequence types) .....--*/ LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount) { - return wrap(ArrayType::get(unwrap(ElementType), ElementCount)); + return wrap(getGlobalContext().getArrayType(unwrap(ElementType), + ElementCount)); } LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace) { - return wrap(PointerType::get(unwrap(ElementType), AddressSpace)); + return wrap(getGlobalContext().getPointerType(unwrap(ElementType), + AddressSpace)); } LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount) { - return wrap(VectorType::get(unwrap(ElementType), ElementCount)); + return wrap(getGlobalContext().getVectorType(unwrap(ElementType), + ElementCount)); } LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty) { @@ -237,7 +241,7 @@ LLVMTypeRef LLVMVoidType(void) { return (LLVMTypeRef) Type::VoidTy; } LLVMTypeRef LLVMLabelType(void) { return (LLVMTypeRef) Type::LabelTy; } LLVMTypeRef LLVMOpaqueType(void) { - return wrap(llvm::OpaqueType::get()); + return wrap(getGlobalContext().getOpaqueType()); } /*--.. Operations on type handles ..........................................--*/ @@ -293,15 +297,15 @@ LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DEFINE_VALUE_CAST) /*--.. Operations on constants of any type .................................--*/ LLVMValueRef LLVMConstNull(LLVMTypeRef Ty) { - return wrap(Constant::getNullValue(unwrap(Ty))); + return wrap(getGlobalContext().getNullValue(unwrap(Ty))); } LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty) { - return wrap(Constant::getAllOnesValue(unwrap(Ty))); + return wrap(getGlobalContext().getAllOnesValue(unwrap(Ty))); } LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) { - return wrap(UndefValue::get(unwrap(Ty))); + return wrap(getGlobalContext().getUndef(unwrap(Ty))); } int LLVMIsConstant(LLVMValueRef Ty) { @@ -319,14 +323,16 @@ int LLVMIsUndef(LLVMValueRef Val) { } LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty) { - return wrap(ConstantPointerNull::get(unwrap(Ty))); + return + wrap(getGlobalContext().getConstantPointerNull(unwrap(Ty))); } /*--.. Operations on scalar constants ......................................--*/ LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N, int SignExtend) { - return wrap(ConstantInt::get(unwrap(IntTy), N, SignExtend != 0)); + return wrap(getGlobalContext().getConstantInt(unwrap(IntTy), N, + SignExtend != 0)); } static const fltSemantics &SemanticsForType(Type *Ty) { @@ -349,11 +355,12 @@ LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N) { bool ignored; APN.convert(SemanticsForType(unwrap(RealTy)), APFloat::rmNearestTiesToEven, &ignored); - return wrap(ConstantFP::get(APN)); + return wrap(getGlobalContext().getConstantFP(APN)); } LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text) { - return wrap(ConstantFP::get(APFloat(SemanticsForType(unwrap(RealTy)), Text))); + return wrap(getGlobalContext().getConstantFP( + APFloat(SemanticsForType(unwrap(RealTy)), Text))); } /*--.. Operations on composite constants ...................................--*/ @@ -362,221 +369,254 @@ LLVMValueRef LLVMConstString(const char *Str, unsigned Length, int DontNullTerminate) { /* Inverted the sense of AddNull because ', 0)' is a better mnemonic for null termination than ', 1)'. */ - return wrap(ConstantArray::get(std::string(Str, Length), + return wrap(getGlobalContext().getConstantArray(std::string(Str, Length), DontNullTerminate == 0)); } LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy, LLVMValueRef *ConstantVals, unsigned Length) { - return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length), + return wrap(getGlobalContext().getConstantArray( + getGlobalContext().getArrayType(unwrap(ElementTy), Length), unwrap(ConstantVals, Length), Length)); } LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count, int Packed) { - return wrap(ConstantStruct::get(unwrap(ConstantVals, Count), + return wrap(getGlobalContext().getConstantStruct( + unwrap(ConstantVals, Count), Count, Packed != 0)); } LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size) { - return wrap(ConstantVector::get(unwrap(ScalarConstantVals, Size), - Size)); + return wrap(getGlobalContext().getConstantVector( + unwrap(ScalarConstantVals, Size), Size)); } /*--.. Constant expressions ................................................--*/ LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty) { - return wrap(ConstantExpr::getAlignOf(unwrap(Ty))); + return wrap(getGlobalContext().getConstantExprAlignOf(unwrap(Ty))); } LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty) { - return wrap(ConstantExpr::getSizeOf(unwrap(Ty))); + return wrap(getGlobalContext().getConstantExprSizeOf(unwrap(Ty))); } LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal) { - return wrap(ConstantExpr::getNeg(unwrap(ConstantVal))); + return wrap(getGlobalContext().getConstantExprNeg( + unwrap(ConstantVal))); } LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal) { - return wrap(ConstantExpr::getNot(unwrap(ConstantVal))); + return wrap(getGlobalContext().getConstantExprNot( + unwrap(ConstantVal))); } LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getAdd(unwrap(LHSConstant), + return wrap(getGlobalContext().getConstantExprAdd( + unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getSub(unwrap(LHSConstant), + return wrap(getGlobalContext().getConstantExprSub( + unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getMul(unwrap(LHSConstant), + return wrap(getGlobalContext().getConstantExprMul( + unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getUDiv(unwrap(LHSConstant), + return wrap(getGlobalContext().getConstantExprUDiv( + unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getSDiv(unwrap(LHSConstant), + return wrap(getGlobalContext().getConstantExprSDiv( + unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getFDiv(unwrap(LHSConstant), + return wrap(getGlobalContext().getConstantExprFDiv( + unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getURem(unwrap(LHSConstant), + return wrap(getGlobalContext().getConstantExprURem( + unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getSRem(unwrap(LHSConstant), + return wrap(getGlobalContext().getConstantExprSRem( + unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getFRem(unwrap(LHSConstant), + return wrap(getGlobalContext().getConstantExprFRem( + unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getAnd(unwrap(LHSConstant), + return wrap(getGlobalContext().getConstantExprAnd( + unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getOr(unwrap(LHSConstant), + return wrap(getGlobalContext().getConstantExprOr( + unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getXor(unwrap(LHSConstant), + return wrap(getGlobalContext().getConstantExprXor( + unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getICmp(Predicate, + return wrap(getGlobalContext().getConstantExprICmp(Predicate, unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getFCmp(Predicate, + return wrap(getGlobalContext().getConstantExprFCmp(Predicate, unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getShl(unwrap(LHSConstant), + return wrap(getGlobalContext().getConstantExprShl( + unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getLShr(unwrap(LHSConstant), + return wrap(getGlobalContext().getConstantExprLShr( + unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getAShr(unwrap(LHSConstant), + return wrap(getGlobalContext().getConstantExprAShr( + unwrap(LHSConstant), unwrap(RHSConstant))); } LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, LLVMValueRef *ConstantIndices, unsigned NumIndices) { - return wrap(ConstantExpr::getGetElementPtr(unwrap(ConstantVal), + return wrap(getGlobalContext().getConstantExprGetElementPtr( + unwrap(ConstantVal), unwrap(ConstantIndices, NumIndices), NumIndices)); } LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { - return wrap(ConstantExpr::getTrunc(unwrap(ConstantVal), + return wrap(getGlobalContext().getConstantExprTrunc( + unwrap(ConstantVal), unwrap(ToType))); } LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { - return wrap(ConstantExpr::getSExt(unwrap(ConstantVal), + return wrap(getGlobalContext().getConstantExprSExt( + unwrap(ConstantVal), unwrap(ToType))); } LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { - return wrap(ConstantExpr::getZExt(unwrap(ConstantVal), + return wrap(getGlobalContext().getConstantExprZExt( + unwrap(ConstantVal), unwrap(ToType))); } LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { - return wrap(ConstantExpr::getFPTrunc(unwrap(ConstantVal), + return wrap(getGlobalContext().getConstantExprFPTrunc( + unwrap(ConstantVal), unwrap(ToType))); } LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { - return wrap(ConstantExpr::getFPExtend(unwrap(ConstantVal), + return wrap(getGlobalContext().getConstantExprFPExtend( + unwrap(ConstantVal), unwrap(ToType))); } LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { - return wrap(ConstantExpr::getUIToFP(unwrap(ConstantVal), + return wrap(getGlobalContext().getConstantExprUIToFP( + unwrap(ConstantVal), unwrap(ToType))); } LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { - return wrap(ConstantExpr::getSIToFP(unwrap(ConstantVal), + return wrap(getGlobalContext().getConstantExprSIToFP(unwrap(ConstantVal), unwrap(ToType))); } LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { - return wrap(ConstantExpr::getFPToUI(unwrap(ConstantVal), + return wrap(getGlobalContext().getConstantExprFPToUI(unwrap(ConstantVal), unwrap(ToType))); } LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { - return wrap(ConstantExpr::getFPToSI(unwrap(ConstantVal), + return wrap(getGlobalContext().getConstantExprFPToSI( + unwrap(ConstantVal), unwrap(ToType))); } LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { - return wrap(ConstantExpr::getPtrToInt(unwrap(ConstantVal), + return wrap(getGlobalContext().getConstantExprPtrToInt( + unwrap(ConstantVal), unwrap(ToType))); } LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { - return wrap(ConstantExpr::getIntToPtr(unwrap(ConstantVal), + return wrap(getGlobalContext().getConstantExprIntToPtr( + unwrap(ConstantVal), unwrap(ToType))); } LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { - return wrap(ConstantExpr::getBitCast(unwrap(ConstantVal), + return wrap(getGlobalContext().getConstantExprBitCast( + unwrap(ConstantVal), unwrap(ToType))); } LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, LLVMValueRef ConstantIfTrue, LLVMValueRef ConstantIfFalse) { - return wrap(ConstantExpr::getSelect(unwrap(ConstantCondition), + return wrap(getGlobalContext().getConstantExprSelect( + unwrap(ConstantCondition), unwrap(ConstantIfTrue), unwrap(ConstantIfFalse))); } LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, LLVMValueRef IndexConstant) { - return wrap(ConstantExpr::getExtractElement(unwrap(VectorConstant), + return wrap(getGlobalContext().getConstantExprExtractElement( + unwrap(VectorConstant), unwrap(IndexConstant))); } LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, LLVMValueRef ElementValueConstant, LLVMValueRef IndexConstant) { - return wrap(ConstantExpr::getInsertElement(unwrap(VectorConstant), + return wrap(getGlobalContext().getConstantExprInsertElement( + unwrap(VectorConstant), unwrap(ElementValueConstant), unwrap(IndexConstant))); } @@ -584,21 +624,24 @@ LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, LLVMValueRef VectorBConstant, LLVMValueRef MaskConstant) { - return wrap(ConstantExpr::getShuffleVector(unwrap(VectorAConstant), + return wrap(getGlobalContext().getConstantExprShuffleVector( + unwrap(VectorAConstant), unwrap(VectorBConstant), unwrap(MaskConstant))); } LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList, unsigned NumIdx) { - return wrap(ConstantExpr::getExtractValue(unwrap(AggConstant), + return wrap(getGlobalContext().getConstantExprExtractValue( + unwrap(AggConstant), IdxList, NumIdx)); } LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, LLVMValueRef ElementValueConstant, unsigned *IdxList, unsigned NumIdx) { - return wrap(ConstantExpr::getInsertValue(unwrap(AggConstant), + return wrap(getGlobalContext().getConstantExprInsertValue( + unwrap(AggConstant), unwrap(ElementValueConstant), IdxList, NumIdx)); } -- cgit v1.1