[llvm] r353661 - [CallSite removal] Migrate ConstantFolding APIs and implementation to
Chandler Carruth via llvm-commits
llvm-commits at lists.llvm.org
Sun Feb 10 23:51:44 PST 2019
Author: chandlerc
Date: Sun Feb 10 23:51:44 2019
New Revision: 353661
URL: http://llvm.org/viewvc/llvm-project?rev=353661&view=rev
Log:
[CallSite removal] Migrate ConstantFolding APIs and implementation to
`CallBase`.
Users have been updated. You can see how to update any out-of-tree
usages: pass `cast<CallBase>(CS.getInstruction())`.
Modified:
llvm/trunk/include/llvm/Analysis/ConstantFolding.h
llvm/trunk/lib/Analysis/ConstantFolding.cpp
llvm/trunk/lib/Analysis/InlineCost.cpp
llvm/trunk/lib/Analysis/InstructionSimplify.cpp
llvm/trunk/lib/Transforms/Scalar/SCCP.cpp
llvm/trunk/lib/Transforms/Utils/Evaluator.cpp
llvm/trunk/lib/Transforms/Utils/Local.cpp
Modified: llvm/trunk/include/llvm/Analysis/ConstantFolding.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/ConstantFolding.h?rev=353661&r1=353660&r2=353661&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Analysis/ConstantFolding.h (original)
+++ llvm/trunk/include/llvm/Analysis/ConstantFolding.h Sun Feb 10 23:51:44 2019
@@ -22,7 +22,7 @@
namespace llvm {
class APInt;
template <typename T> class ArrayRef;
-class CallSite;
+class CallBase;
class Constant;
class ConstantExpr;
class ConstantVector;
@@ -30,7 +30,6 @@ class DataLayout;
class Function;
class GlobalValue;
class Instruction;
-class ImmutableCallSite;
class TargetLibraryInfo;
class Type;
@@ -138,11 +137,11 @@ Constant *ConstantFoldLoadThroughGEPIndi
/// canConstantFoldCallTo - Return true if its even possible to fold a call to
/// the specified function.
-bool canConstantFoldCallTo(ImmutableCallSite CS, const Function *F);
+bool canConstantFoldCallTo(const CallBase *Call, const Function *F);
/// ConstantFoldCall - Attempt to constant fold a call to the specified function
/// with the specified arguments, returning null if unsuccessful.
-Constant *ConstantFoldCall(ImmutableCallSite CS, Function *F,
+Constant *ConstantFoldCall(const CallBase *Call, Function *F,
ArrayRef<Constant *> Operands,
const TargetLibraryInfo *TLI = nullptr);
@@ -154,7 +153,7 @@ Constant *ConstantFoldLoadThroughBitcast
/// Check whether the given call has no side-effects.
/// Specifically checks for math routimes which sometimes set errno.
-bool isMathLibCallNoop(CallSite CS, const TargetLibraryInfo *TLI);
+bool isMathLibCallNoop(const CallBase *Call, const TargetLibraryInfo *TLI);
}
#endif
Modified: llvm/trunk/lib/Analysis/ConstantFolding.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ConstantFolding.cpp?rev=353661&r1=353660&r2=353661&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/ConstantFolding.cpp (original)
+++ llvm/trunk/lib/Analysis/ConstantFolding.cpp Sun Feb 10 23:51:44 2019
@@ -1024,9 +1024,9 @@ Constant *ConstantFoldInstOperandsImpl(c
case Instruction::FCmp: llvm_unreachable("Invalid for compares");
case Instruction::Call:
if (auto *F = dyn_cast<Function>(Ops.back())) {
- ImmutableCallSite CS(cast<CallInst>(InstOrCE));
- if (canConstantFoldCallTo(CS, F))
- return ConstantFoldCall(CS, F, Ops.slice(0, Ops.size() - 1), TLI);
+ const auto *Call = cast<CallBase>(InstOrCE);
+ if (canConstantFoldCallTo(Call, F))
+ return ConstantFoldCall(Call, F, Ops.slice(0, Ops.size() - 1), TLI);
}
return nullptr;
case Instruction::Select:
@@ -1366,8 +1366,8 @@ llvm::ConstantFoldLoadThroughGEPIndices(
// Constant Folding for Calls
//
-bool llvm::canConstantFoldCallTo(ImmutableCallSite CS, const Function *F) {
- if (CS.isNoBuiltin() || CS.isStrictFP())
+bool llvm::canConstantFoldCallTo(const CallBase *Call, const Function *F) {
+ if (Call->isNoBuiltin() || Call->isStrictFP())
return false;
switch (F->getIntrinsicID()) {
case Intrinsic::fabs:
@@ -1643,7 +1643,7 @@ static bool getConstIntOrUndef(Value *Op
Constant *ConstantFoldScalarCall(StringRef Name, unsigned IntrinsicID, Type *Ty,
ArrayRef<Constant *> Operands,
const TargetLibraryInfo *TLI,
- ImmutableCallSite CS) {
+ const CallBase *Call) {
if (Operands.size() == 1) {
if (IntrinsicID == Intrinsic::is_constant) {
// We know we have a "Constant" argument. But we want to only
@@ -1671,9 +1671,10 @@ Constant *ConstantFoldScalarCall(StringR
if (IntrinsicID == Intrinsic::launder_invariant_group ||
IntrinsicID == Intrinsic::strip_invariant_group) {
// If instruction is not yet put in a basic block (e.g. when cloning
- // a function during inlining), CS caller may not be available.
- // So check CS's BB first before querying CS.getCaller.
- const Function *Caller = CS.getParent() ? CS.getCaller() : nullptr;
+ // a function during inlining), Call's caller may not be available.
+ // So check Call's BB first before querying Call->getCaller.
+ const Function *Caller =
+ Call->getParent() ? Call->getCaller() : nullptr;
if (Caller &&
!NullPointerIsDefined(
Caller, Operands[0]->getType()->getPointerAddressSpace())) {
@@ -2215,7 +2216,7 @@ Constant *ConstantFoldVectorCall(StringR
VectorType *VTy, ArrayRef<Constant *> Operands,
const DataLayout &DL,
const TargetLibraryInfo *TLI,
- ImmutableCallSite CS) {
+ const CallBase *Call) {
SmallVector<Constant *, 4> Result(VTy->getNumElements());
SmallVector<Constant *, 4> Lane(Operands.size());
Type *Ty = VTy->getElementType();
@@ -2278,7 +2279,8 @@ Constant *ConstantFoldVectorCall(StringR
}
// Use the regular scalar folding to simplify this column.
- Constant *Folded = ConstantFoldScalarCall(Name, IntrinsicID, Ty, Lane, TLI, CS);
+ Constant *Folded =
+ ConstantFoldScalarCall(Name, IntrinsicID, Ty, Lane, TLI, Call);
if (!Folded)
return nullptr;
Result[I] = Folded;
@@ -2289,11 +2291,10 @@ Constant *ConstantFoldVectorCall(StringR
} // end anonymous namespace
-Constant *
-llvm::ConstantFoldCall(ImmutableCallSite CS, Function *F,
- ArrayRef<Constant *> Operands,
- const TargetLibraryInfo *TLI) {
- if (CS.isNoBuiltin() || CS.isStrictFP())
+Constant *llvm::ConstantFoldCall(const CallBase *Call, Function *F,
+ ArrayRef<Constant *> Operands,
+ const TargetLibraryInfo *TLI) {
+ if (Call->isNoBuiltin() || Call->isStrictFP())
return nullptr;
if (!F->hasName())
return nullptr;
@@ -2303,17 +2304,19 @@ llvm::ConstantFoldCall(ImmutableCallSite
if (auto *VTy = dyn_cast<VectorType>(Ty))
return ConstantFoldVectorCall(Name, F->getIntrinsicID(), VTy, Operands,
- F->getParent()->getDataLayout(), TLI, CS);
+ F->getParent()->getDataLayout(), TLI, Call);
- return ConstantFoldScalarCall(Name, F->getIntrinsicID(), Ty, Operands, TLI, CS);
+ return ConstantFoldScalarCall(Name, F->getIntrinsicID(), Ty, Operands, TLI,
+ Call);
}
-bool llvm::isMathLibCallNoop(CallSite CS, const TargetLibraryInfo *TLI) {
+bool llvm::isMathLibCallNoop(const CallBase *Call,
+ const TargetLibraryInfo *TLI) {
// FIXME: Refactor this code; this duplicates logic in LibCallsShrinkWrap
// (and to some extent ConstantFoldScalarCall).
- if (CS.isNoBuiltin() || CS.isStrictFP())
+ if (Call->isNoBuiltin() || Call->isStrictFP())
return false;
- Function *F = CS.getCalledFunction();
+ Function *F = Call->getCalledFunction();
if (!F)
return false;
@@ -2321,8 +2324,8 @@ bool llvm::isMathLibCallNoop(CallSite CS
if (!TLI || !TLI->getLibFunc(*F, Func))
return false;
- if (CS.getNumArgOperands() == 1) {
- if (ConstantFP *OpC = dyn_cast<ConstantFP>(CS.getArgOperand(0))) {
+ if (Call->getNumArgOperands() == 1) {
+ if (ConstantFP *OpC = dyn_cast<ConstantFP>(Call->getArgOperand(0))) {
const APFloat &Op = OpC->getValueAPF();
switch (Func) {
case LibFunc_logl:
@@ -2420,9 +2423,9 @@ bool llvm::isMathLibCallNoop(CallSite CS
}
}
- if (CS.getNumArgOperands() == 2) {
- ConstantFP *Op0C = dyn_cast<ConstantFP>(CS.getArgOperand(0));
- ConstantFP *Op1C = dyn_cast<ConstantFP>(CS.getArgOperand(1));
+ if (Call->getNumArgOperands() == 2) {
+ ConstantFP *Op0C = dyn_cast<ConstantFP>(Call->getArgOperand(0));
+ ConstantFP *Op1C = dyn_cast<ConstantFP>(Call->getArgOperand(1));
if (Op0C && Op1C) {
const APFloat &Op0 = Op0C->getValueAPF();
const APFloat &Op1 = Op1C->getValueAPF();
Modified: llvm/trunk/lib/Analysis/InlineCost.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/InlineCost.cpp?rev=353661&r1=353660&r2=353661&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/InlineCost.cpp (original)
+++ llvm/trunk/lib/Analysis/InlineCost.cpp Sun Feb 10 23:51:44 2019
@@ -1177,7 +1177,7 @@ bool CallAnalyzer::simplifyCallSite(Func
// because we have to continually rebuild the argument list even when no
// simplifications can be performed. Until that is fixed with remapping
// inside of instsimplify, directly constant fold calls here.
- if (!canConstantFoldCallTo(CS, F))
+ if (!canConstantFoldCallTo(cast<CallBase>(CS.getInstruction()), F))
return false;
// Try to re-map the arguments to constants.
@@ -1193,7 +1193,8 @@ bool CallAnalyzer::simplifyCallSite(Func
ConstantArgs.push_back(C);
}
- if (Constant *C = ConstantFoldCall(CS, F, ConstantArgs)) {
+ if (Constant *C = ConstantFoldCall(cast<CallBase>(CS.getInstruction()), F,
+ ConstantArgs)) {
SimplifiedValues[CS.getInstruction()] = C;
return true;
}
Modified: llvm/trunk/lib/Analysis/InstructionSimplify.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/InstructionSimplify.cpp?rev=353661&r1=353660&r2=353661&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/InstructionSimplify.cpp (original)
+++ llvm/trunk/lib/Analysis/InstructionSimplify.cpp Sun Feb 10 23:51:44 2019
@@ -5166,7 +5166,7 @@ static Value *SimplifyCall(ImmutableCall
if (Value *Ret = simplifyIntrinsic(F, ArgBegin, ArgEnd, Q))
return Ret;
- if (!canConstantFoldCallTo(CS, F))
+ if (!canConstantFoldCallTo(cast<CallBase>(CS.getInstruction()), F))
return nullptr;
SmallVector<Constant *, 4> ConstantArgs;
@@ -5178,7 +5178,8 @@ static Value *SimplifyCall(ImmutableCall
ConstantArgs.push_back(C);
}
- return ConstantFoldCall(CS, F, ConstantArgs, Q.TLI);
+ return ConstantFoldCall(cast<CallBase>(CS.getInstruction()), F, ConstantArgs,
+ Q.TLI);
}
Value *llvm::SimplifyCall(ImmutableCallSite CS, Value *V,
Modified: llvm/trunk/lib/Transforms/Scalar/SCCP.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/SCCP.cpp?rev=353661&r1=353660&r2=353661&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/SCCP.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/SCCP.cpp Sun Feb 10 23:51:44 2019
@@ -1243,7 +1243,7 @@ CallOverdefined:
// Otherwise, if we have a single return value case, and if the function is
// a declaration, maybe we can constant fold it.
if (F && F->isDeclaration() && !I->getType()->isStructTy() &&
- canConstantFoldCallTo(CS, F)) {
+ canConstantFoldCallTo(cast<CallBase>(CS.getInstruction()), F)) {
SmallVector<Constant*, 8> Operands;
for (CallSite::arg_iterator AI = CS.arg_begin(), E = CS.arg_end();
AI != E; ++AI) {
@@ -1264,7 +1264,8 @@ CallOverdefined:
// If we can constant fold this, mark the result of the call as a
// constant.
- if (Constant *C = ConstantFoldCall(CS, F, Operands, TLI)) {
+ if (Constant *C = ConstantFoldCall(cast<CallBase>(CS.getInstruction()), F,
+ Operands, TLI)) {
// call -> undef.
if (isa<UndefValue>(C))
return;
Modified: llvm/trunk/lib/Transforms/Utils/Evaluator.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/Evaluator.cpp?rev=353661&r1=353660&r2=353661&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/Evaluator.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/Evaluator.cpp Sun Feb 10 23:51:44 2019
@@ -540,7 +540,8 @@ bool Evaluator::EvaluateBlock(BasicBlock
if (Callee->isDeclaration()) {
// If this is a function we can constant fold, do it.
- if (Constant *C = ConstantFoldCall(CS, Callee, Formals, TLI)) {
+ if (Constant *C = ConstantFoldCall(cast<CallBase>(CS.getInstruction()),
+ Callee, Formals, TLI)) {
InstResult = castCallResultIfNeeded(CS.getCalledValue(), C);
if (!InstResult)
return false;
Modified: llvm/trunk/lib/Transforms/Utils/Local.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/Local.cpp?rev=353661&r1=353660&r2=353661&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/Local.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/Local.cpp Sun Feb 10 23:51:44 2019
@@ -415,8 +415,8 @@ bool llvm::wouldInstructionBeTriviallyDe
if (Constant *C = dyn_cast<Constant>(CI->getArgOperand(0)))
return C->isNullValue() || isa<UndefValue>(C);
- if (CallSite CS = CallSite(I))
- if (isMathLibCallNoop(CS, TLI))
+ if (auto *Call = dyn_cast<CallBase>(I))
+ if (isMathLibCallNoop(Call, TLI))
return true;
return false;
More information about the llvm-commits
mailing list