diff --git a/include/llvm-c/Core.h b/include/llvm-c/Core.h index 40696e0aceb..95f3474a1e6 100644 --- a/include/llvm-c/Core.h +++ b/include/llvm-c/Core.h @@ -470,7 +470,6 @@ LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal); LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal); LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal); LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); @@ -478,7 +477,6 @@ LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); @@ -495,9 +493,6 @@ LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, LLVMValueRef *ConstantIndices, unsigned NumIndices); -LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal, - LLVMValueRef *ConstantIndices, - unsigned NumIndices); LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h index da6fe96a772..8566ba06ac9 100644 --- a/include/llvm/Constants.h +++ b/include/llvm/Constants.h @@ -648,9 +648,6 @@ public: static Constant *getIntToPtr(Constant *C, const Type *Ty); static Constant *getBitCast (Constant *C, const Type *Ty); - static Constant* getNSWAdd(Constant* C1, Constant* C2); - static Constant* getExactSDiv(Constant* C1, Constant* C2); - /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant); @@ -737,15 +734,6 @@ public: static Constant *getGetElementPtr(Constant *C, Value* const *IdxList, unsigned NumIdx); - /// Create an "inbounds" getelementptr. See the documentation for the - /// "inbounds" flag in LangRef.html for details. - static Constant *getInBoundsGetElementPtr(Constant *C, - Constant* const *IdxList, - unsigned NumIdx); - static Constant *getInBoundsGetElementPtr(Constant *C, - Value* const *IdxList, - unsigned NumIdx); - static Constant *getExtractElement(Constant *Vec, Constant *Idx); static Constant *getInsertElement(Constant *Vec, Constant *Elt,Constant *Idx); static Constant *getShuffleVector(Constant *V1, Constant *V2, Constant *Mask); diff --git a/include/llvm/Support/ConstantFolder.h b/include/llvm/Support/ConstantFolder.h index 3c9278aaa7a..8ce52379fc2 100644 --- a/include/llvm/Support/ConstantFolder.h +++ b/include/llvm/Support/ConstantFolder.h @@ -36,7 +36,7 @@ public: return ConstantExpr::getAdd(LHS, RHS); } Constant *CreateNSWAdd(Constant *LHS, Constant *RHS) const { - return ConstantExpr::getNSWAdd(LHS, RHS); + return ConstantExpr::getAdd(LHS, RHS); } Constant *CreateFAdd(Constant *LHS, Constant *RHS) const { return ConstantExpr::getFAdd(LHS, RHS); @@ -60,7 +60,7 @@ public: return ConstantExpr::getSDiv(LHS, RHS); } Constant *CreateExactSDiv(Constant *LHS, Constant *RHS) const { - return ConstantExpr::getExactSDiv(LHS, RHS); + return ConstantExpr::getSDiv(LHS, RHS); } Constant *CreateFDiv(Constant *LHS, Constant *RHS) const { return ConstantExpr::getFDiv(LHS, RHS); @@ -127,11 +127,11 @@ public: Constant *CreateInBoundsGetElementPtr(Constant *C, Constant* const *IdxList, unsigned NumIdx) const { - return ConstantExpr::getInBoundsGetElementPtr(C, IdxList, NumIdx); + return ConstantExpr::getGetElementPtr(C, IdxList, NumIdx); } Constant *CreateInBoundsGetElementPtr(Constant *C, Value* const *IdxList, unsigned NumIdx) const { - return ConstantExpr::getInBoundsGetElementPtr(C, IdxList, NumIdx); + return ConstantExpr::getGetElementPtr(C, IdxList, NumIdx); } //===--------------------------------------------------------------------===// diff --git a/include/llvm/Support/NoFolder.h b/include/llvm/Support/NoFolder.h index 4540f028cee..00724714271 100644 --- a/include/llvm/Support/NoFolder.h +++ b/include/llvm/Support/NoFolder.h @@ -131,7 +131,7 @@ public: Constant *CreateInBoundsGetElementPtr(Constant *C, Constant* const *IdxList, unsigned NumIdx) const { - return ConstantExpr::getInBoundsGetElementPtr(C, IdxList, NumIdx); + return ConstantExpr::getGetElementPtr(C, IdxList, NumIdx); } Value *CreateInBoundsGetElementPtr(Constant *C, Value* const *IdxList, unsigned NumIdx) const { diff --git a/include/llvm/Support/TargetFolder.h b/include/llvm/Support/TargetFolder.h index 77533c00b13..80ab900efa6 100644 --- a/include/llvm/Support/TargetFolder.h +++ b/include/llvm/Support/TargetFolder.h @@ -52,7 +52,7 @@ public: return Fold(ConstantExpr::getAdd(LHS, RHS)); } Constant *CreateNSWAdd(Constant *LHS, Constant *RHS) const { - return Fold(ConstantExpr::getNSWAdd(LHS, RHS)); + return Fold(ConstantExpr::getAdd(LHS, RHS)); } Constant *CreateFAdd(Constant *LHS, Constant *RHS) const { return Fold(ConstantExpr::getFAdd(LHS, RHS)); @@ -76,7 +76,7 @@ public: return Fold(ConstantExpr::getSDiv(LHS, RHS)); } Constant *CreateExactSDiv(Constant *LHS, Constant *RHS) const { - return Fold(ConstantExpr::getExactSDiv(LHS, RHS)); + return Fold(ConstantExpr::getSDiv(LHS, RHS)); } Constant *CreateFDiv(Constant *LHS, Constant *RHS) const { return Fold(ConstantExpr::getFDiv(LHS, RHS)); @@ -143,11 +143,11 @@ public: Constant *CreateInBoundsGetElementPtr(Constant *C, Constant* const *IdxList, unsigned NumIdx) const { - return Fold(ConstantExpr::getInBoundsGetElementPtr(C, IdxList, NumIdx)); + return Fold(ConstantExpr::getGetElementPtr(C, IdxList, NumIdx)); } Constant *CreateInBoundsGetElementPtr(Constant *C, Value* const *IdxList, unsigned NumIdx) const { - return Fold(ConstantExpr::getInBoundsGetElementPtr(C, IdxList, NumIdx)); + return Fold(ConstantExpr::getGetElementPtr(C, IdxList, NumIdx)); } //===--------------------------------------------------------------------===// diff --git a/lib/Analysis/ConstantFolding.cpp b/lib/Analysis/ConstantFolding.cpp index 109eaad4584..9bc00938816 100644 --- a/lib/Analysis/ConstantFolding.cpp +++ b/lib/Analysis/ConstantFolding.cpp @@ -203,15 +203,21 @@ static Constant *SymbolicallyEvaluateGEP(Constant* const* Ops, unsigned NumOps, if (Offset != 0) return 0; + // Create the GEP constant expr. + Constant *C = ConstantExpr::getGetElementPtr(Ptr, + &NewIdxs[0], NewIdxs.size()); + assert(cast(C->getType())->getElementType() == Ty && + "Computed GetElementPtr has unexpected type!"); + // If the base is the start of a GlobalVariable and all the array indices // remain in their static bounds, the GEP is inbounds. We can check that // all indices are in bounds by just checking the first index only - // because we've just normalized all the indices. - Constant *C = isa(Ptr) && NewIdxs[0]->isNullValue() ? - ConstantExpr::getInBoundsGetElementPtr(Ptr, &NewIdxs[0], NewIdxs.size()) : - ConstantExpr::getGetElementPtr(Ptr, &NewIdxs[0], NewIdxs.size()); - assert(cast(C->getType())->getElementType() == Ty && - "Computed GetElementPtr has unexpected type!"); + // because we've just normalized all the indices. We can mutate the + // Constant in place because we've proven that the indices are in bounds, + // so they'll always be in bounds. + if (isa(Ptr) && NewIdxs[0]->isNullValue()) + if (GEPOperator *GEP = dyn_cast(C)) + GEP->setIsInBounds(true); // If we ended up indexing a member with a type that doesn't match // the type of what the original indices indexed, add a cast. diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index 701a195f7fd..a8694672456 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -122,9 +122,7 @@ static Constant *FoldBitCast(LLVMContext &Context, } if (ElTy == DPTy->getElementType()) - // This GEP is inbounds because all indices are zero. - return ConstantExpr::getInBoundsGetElementPtr(V, &IdxList[0], - IdxList.size()); + return ConstantExpr::getGetElementPtr(V, &IdxList[0], IdxList.size()); } // Handle casts from one vector constant to another. We know that the src diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index 37efafc9b20..1ddc1e27b0e 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -631,24 +631,6 @@ Constant* ConstantVector::get(Constant* const* Vals, unsigned NumVals) { return get(std::vector(Vals, Vals+NumVals)); } -Constant* ConstantExpr::getNSWAdd(Constant* C1, Constant* C2) { - Constant *C = getAdd(C1, C2); - // Set nsw attribute, assuming constant folding didn't eliminate the - // Add. - if (AddOperator *Add = dyn_cast(C)) - Add->setHasNoSignedWrap(true); - return C; -} - -Constant* ConstantExpr::getExactSDiv(Constant* C1, Constant* C2) { - Constant *C = getSDiv(C1, C2); - // Set exact attribute, assuming constant folding didn't eliminate the - // SDiv. - if (SDivOperator *SDiv = dyn_cast(C)) - SDiv->setIsExact(true); - return C; -} - // Utility function for determining if a ConstantExpr is a CastOp or not. This // can't be inline because we don't want to #include Instruction.h into // Constant.h @@ -1491,28 +1473,11 @@ Constant *ConstantExpr::getGetElementPtr(Constant *C, Value* const *Idxs, return getGetElementPtrTy(PointerType::get(Ty, As), C, Idxs, NumIdx); } -Constant *ConstantExpr::getInBoundsGetElementPtr(Constant *C, - Value* const *Idxs, - unsigned NumIdx) { - Constant *Result = getGetElementPtr(C, Idxs, NumIdx); - // Set in bounds attribute, assuming constant folding didn't eliminate the - // GEP. - if (GEPOperator *GEP = dyn_cast(Result)) - GEP->setIsInBounds(true); - return Result; -} - Constant *ConstantExpr::getGetElementPtr(Constant *C, Constant* const *Idxs, unsigned NumIdx) { return getGetElementPtr(C, (Value* const *)Idxs, NumIdx); } -Constant *ConstantExpr::getInBoundsGetElementPtr(Constant *C, - Constant* const *Idxs, - unsigned NumIdx) { - return getInBoundsGetElementPtr(C, (Value* const *)Idxs, NumIdx); -} - Constant * ConstantExpr::getICmp(unsigned short pred, Constant* LHS, Constant* RHS) { assert(LHS->getType() == RHS->getType()); diff --git a/lib/VMCore/Core.cpp b/lib/VMCore/Core.cpp index 1dbf5c44efc..240b27af32b 100644 --- a/lib/VMCore/Core.cpp +++ b/lib/VMCore/Core.cpp @@ -535,13 +535,6 @@ LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { unwrap(RHSConstant))); } -LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, - LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getNSWAdd( - unwrap(LHSConstant), - unwrap(RHSConstant))); -} - LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { return wrap(ConstantExpr::getFAdd( unwrap(LHSConstant), @@ -583,13 +576,6 @@ LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { unwrap(RHSConstant))); } -LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, - LLVMValueRef RHSConstant) { - return wrap(ConstantExpr::getExactSDiv( - unwrap(LHSConstant), - unwrap(RHSConstant))); -} - LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) { return wrap(ConstantExpr::getFDiv( unwrap(LHSConstant), @@ -673,14 +659,6 @@ LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, NumIndices)); } -LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal, - LLVMValueRef *ConstantIndices, - unsigned NumIndices) { - Constant* Val = unwrap(ConstantVal); - Constant** Idxs = unwrap(ConstantIndices, NumIndices); - return wrap(ConstantExpr::getInBoundsGetElementPtr(Val, Idxs, NumIndices)); -} - LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) { return wrap(ConstantExpr::getTrunc( unwrap(ConstantVal),