From: Chandler Carruth Date: Mon, 11 Feb 2019 07:51:44 +0000 (+0000) Subject: [CallSite removal] Migrate ConstantFolding APIs and implementation to X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=7fe8f82f542dba1ce6d3377a6adb4906d7503ff4;p=llvm [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(CS.getInstruction())`. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@353661 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Analysis/ConstantFolding.h b/include/llvm/Analysis/ConstantFolding.h index 479731eb1b4..43a2df0d853 100644 --- a/include/llvm/Analysis/ConstantFolding.h +++ b/include/llvm/Analysis/ConstantFolding.h @@ -22,7 +22,7 @@ namespace llvm { class APInt; template 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 *ConstantFoldLoadThroughGEPIndices(Constant *C, /// 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 Operands, const TargetLibraryInfo *TLI = nullptr); @@ -154,7 +153,7 @@ Constant *ConstantFoldLoadThroughBitcast(Constant *C, Type *DestTy, /// 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 diff --git a/lib/Analysis/ConstantFolding.cpp b/lib/Analysis/ConstantFolding.cpp index 69e1dda9e75..3b4e6031566 100644 --- a/lib/Analysis/ConstantFolding.cpp +++ b/lib/Analysis/ConstantFolding.cpp @@ -1024,9 +1024,9 @@ Constant *ConstantFoldInstOperandsImpl(const Value *InstOrCE, unsigned Opcode, case Instruction::FCmp: llvm_unreachable("Invalid for compares"); case Instruction::Call: if (auto *F = dyn_cast(Ops.back())) { - ImmutableCallSite CS(cast(InstOrCE)); - if (canConstantFoldCallTo(CS, F)) - return ConstantFoldCall(CS, F, Ops.slice(0, Ops.size() - 1), TLI); + const auto *Call = cast(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 *C, // 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, const APInt *&C) { Constant *ConstantFoldScalarCall(StringRef Name, unsigned IntrinsicID, Type *Ty, ArrayRef 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(StringRef Name, unsigned IntrinsicID, Type *Ty, 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(StringRef Name, unsigned IntrinsicID, VectorType *VTy, ArrayRef Operands, const DataLayout &DL, const TargetLibraryInfo *TLI, - ImmutableCallSite CS) { + const CallBase *Call) { SmallVector Result(VTy->getNumElements()); SmallVector Lane(Operands.size()); Type *Ty = VTy->getElementType(); @@ -2278,7 +2279,8 @@ Constant *ConstantFoldVectorCall(StringRef Name, unsigned IntrinsicID, } // 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(StringRef Name, unsigned IntrinsicID, } // end anonymous namespace -Constant * -llvm::ConstantFoldCall(ImmutableCallSite CS, Function *F, - ArrayRef Operands, - const TargetLibraryInfo *TLI) { - if (CS.isNoBuiltin() || CS.isStrictFP()) +Constant *llvm::ConstantFoldCall(const CallBase *Call, Function *F, + ArrayRef Operands, + const TargetLibraryInfo *TLI) { + if (Call->isNoBuiltin() || Call->isStrictFP()) return nullptr; if (!F->hasName()) return nullptr; @@ -2303,17 +2304,19 @@ llvm::ConstantFoldCall(ImmutableCallSite CS, Function *F, if (auto *VTy = dyn_cast(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, const TargetLibraryInfo *TLI) { if (!TLI || !TLI->getLibFunc(*F, Func)) return false; - if (CS.getNumArgOperands() == 1) { - if (ConstantFP *OpC = dyn_cast(CS.getArgOperand(0))) { + if (Call->getNumArgOperands() == 1) { + if (ConstantFP *OpC = dyn_cast(Call->getArgOperand(0))) { const APFloat &Op = OpC->getValueAPF(); switch (Func) { case LibFunc_logl: @@ -2420,9 +2423,9 @@ bool llvm::isMathLibCallNoop(CallSite CS, const TargetLibraryInfo *TLI) { } } - if (CS.getNumArgOperands() == 2) { - ConstantFP *Op0C = dyn_cast(CS.getArgOperand(0)); - ConstantFP *Op1C = dyn_cast(CS.getArgOperand(1)); + if (Call->getNumArgOperands() == 2) { + ConstantFP *Op0C = dyn_cast(Call->getArgOperand(0)); + ConstantFP *Op1C = dyn_cast(Call->getArgOperand(1)); if (Op0C && Op1C) { const APFloat &Op0 = Op0C->getValueAPF(); const APFloat &Op1 = Op1C->getValueAPF(); diff --git a/lib/Analysis/InlineCost.cpp b/lib/Analysis/InlineCost.cpp index 0e207394f4f..574a1b6c841 100644 --- a/lib/Analysis/InlineCost.cpp +++ b/lib/Analysis/InlineCost.cpp @@ -1177,7 +1177,7 @@ bool CallAnalyzer::simplifyCallSite(Function *F, CallSite CS) { // 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(CS.getInstruction()), F)) return false; // Try to re-map the arguments to constants. @@ -1193,7 +1193,8 @@ bool CallAnalyzer::simplifyCallSite(Function *F, CallSite CS) { ConstantArgs.push_back(C); } - if (Constant *C = ConstantFoldCall(CS, F, ConstantArgs)) { + if (Constant *C = ConstantFoldCall(cast(CS.getInstruction()), F, + ConstantArgs)) { SimplifiedValues[CS.getInstruction()] = C; return true; } diff --git a/lib/Analysis/InstructionSimplify.cpp b/lib/Analysis/InstructionSimplify.cpp index c83d62f1542..5145e277fb7 100644 --- a/lib/Analysis/InstructionSimplify.cpp +++ b/lib/Analysis/InstructionSimplify.cpp @@ -5166,7 +5166,7 @@ static Value *SimplifyCall(ImmutableCallSite CS, Value *V, IterTy ArgBegin, if (Value *Ret = simplifyIntrinsic(F, ArgBegin, ArgEnd, Q)) return Ret; - if (!canConstantFoldCallTo(CS, F)) + if (!canConstantFoldCallTo(cast(CS.getInstruction()), F)) return nullptr; SmallVector ConstantArgs; @@ -5178,7 +5178,8 @@ static Value *SimplifyCall(ImmutableCallSite CS, Value *V, IterTy ArgBegin, ConstantArgs.push_back(C); } - return ConstantFoldCall(CS, F, ConstantArgs, Q.TLI); + return ConstantFoldCall(cast(CS.getInstruction()), F, ConstantArgs, + Q.TLI); } Value *llvm::SimplifyCall(ImmutableCallSite CS, Value *V, diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp index 39d294f8602..e75a5dbddba 100644 --- a/lib/Transforms/Scalar/SCCP.cpp +++ b/lib/Transforms/Scalar/SCCP.cpp @@ -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(CS.getInstruction()), F)) { SmallVector 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(CS.getInstruction()), F, + Operands, TLI)) { // call -> undef. if (isa(C)) return; diff --git a/lib/Transforms/Utils/Evaluator.cpp b/lib/Transforms/Utils/Evaluator.cpp index 4a8ec438c28..fb8cb3ddea6 100644 --- a/lib/Transforms/Utils/Evaluator.cpp +++ b/lib/Transforms/Utils/Evaluator.cpp @@ -540,7 +540,8 @@ bool Evaluator::EvaluateBlock(BasicBlock::iterator CurInst, 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(CS.getInstruction()), + Callee, Formals, TLI)) { InstResult = castCallResultIfNeeded(CS.getCalledValue(), C); if (!InstResult) return false; diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp index b7e69669839..f10bc6520a8 100644 --- a/lib/Transforms/Utils/Local.cpp +++ b/lib/Transforms/Utils/Local.cpp @@ -415,8 +415,8 @@ bool llvm::wouldInstructionBeTriviallyDead(Instruction *I, if (Constant *C = dyn_cast(CI->getArgOperand(0))) return C->isNullValue() || isa(C); - if (CallSite CS = CallSite(I)) - if (isMathLibCallNoop(CS, TLI)) + if (auto *Call = dyn_cast(I)) + if (isMathLibCallNoop(Call, TLI)) return true; return false;