maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[CallSite removal] Port InstSimplify over to use `CallBase` both in its 

interface and implementation.

Port code with: `cast<CallBase>(CS.getInstruction())`.

llvm-svn: 353662
This commit is contained in:
Chandler Carruth 2019-02-11 07:54:10 +00:00
parent 751d95fb9b
commit dac20a8254
2 changed files with 22 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
llvm/include/llvm/Analysis/InstructionSimplify.h
View File

@ -40,8 +40,8 @@ class Function;
template <typename T, typename... TArgs> class AnalysisManager;
template <class T> class ArrayRef;
class AssumptionCache;
class CallBase;
class DominatorTree;
class ImmutableCallSite;
class DataLayout;
class FastMathFlags;
struct LoopStandardAnalysisResults;
@ -238,15 +238,15 @@ Value *SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS,
FastMathFlags FMF, const SimplifyQuery &Q);
/// Given a callsite, fold the result or return null.
Value *SimplifyCall(ImmutableCallSite CS, const SimplifyQuery &Q);
Value *SimplifyCall(CallBase *Call, const SimplifyQuery &Q);
/// Given a function and iterators over arguments, fold the result or return
/// null.
Value *SimplifyCall(ImmutableCallSite CS, Value *V, User::op_iterator ArgBegin,
Value *SimplifyCall(CallBase *Call, Value *V, User::op_iterator ArgBegin,
User::op_iterator ArgEnd, const SimplifyQuery &Q);
/// Given a function and set of arguments, fold the result or return null.
Value *SimplifyCall(ImmutableCallSite CS, Value *V, ArrayRef<Value *> Args,
Value *SimplifyCall(CallBase *Call, Value *V, ArrayRef<Value *> Args,
const SimplifyQuery &Q);
/// See if we can compute a simplified version of this instruction. If not,

38
llvm/lib/Analysis/InstructionSimplify.cpp
View File

@ -33,6 +33,8 @@
#include "llvm/IR/Dominators.h"
#include "llvm/IR/GetElementPtrTypeIterator.h"
#include "llvm/IR/GlobalAlias.h"
#include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Operator.h"
#include "llvm/IR/PatternMatch.h"
#include "llvm/IR/ValueHandle.h"
@ -671,8 +673,8 @@ static Constant *stripAndComputeConstantOffsets(const DataLayout &DL, Value *&V,
break;
V = GA->getAliasee();
} else {
if (auto CS = CallSite(V))
if (Value *RV = CS.getReturnedArgOperand()) {
if (auto *Call = dyn_cast<CallBase>(V))
if (Value *RV = Call->getReturnedArgOperand()) {
V = RV;
continue;
}
@ -5145,7 +5147,7 @@ static Value *simplifyIntrinsic(Function *F, IterTy ArgBegin, IterTy ArgEnd,
}
template <typename IterTy>
static Value *SimplifyCall(ImmutableCallSite CS, Value *V, IterTy ArgBegin,
static Value *SimplifyCall(CallBase *Call, Value *V, IterTy ArgBegin,
IterTy ArgEnd, const SimplifyQuery &Q,
unsigned MaxRecurse) {
Type *Ty = V->getType();
@ -5166,7 +5168,7 @@ static Value *SimplifyCall(ImmutableCallSite CS, Value *V, IterTy ArgBegin,
if (Value *Ret = simplifyIntrinsic(F, ArgBegin, ArgEnd, Q))
return Ret;
if (!canConstantFoldCallTo(cast<CallBase>(CS.getInstruction()), F))
if (!canConstantFoldCallTo(Call, F))
return nullptr;
SmallVector<Constant *, 4> ConstantArgs;
@ -5178,25 +5180,22 @@ static Value *SimplifyCall(ImmutableCallSite CS, Value *V, IterTy ArgBegin,
ConstantArgs.push_back(C);
}
return ConstantFoldCall(cast<CallBase>(CS.getInstruction()), F, ConstantArgs,
Q.TLI);
return ConstantFoldCall(Call, F, ConstantArgs, Q.TLI);
}
Value *llvm::SimplifyCall(ImmutableCallSite CS, Value *V,
User::op_iterator ArgBegin, User::op_iterator ArgEnd,
Value *llvm::SimplifyCall(CallBase *Call, Value *V, User::op_iterator ArgBegin,
User::op_iterator ArgEnd, const SimplifyQuery &Q) {
return ::SimplifyCall(Call, V, ArgBegin, ArgEnd, Q, RecursionLimit);
}
Value *llvm::SimplifyCall(CallBase *Call, Value *V, ArrayRef<Value *> Args,
const SimplifyQuery &Q) {
return ::SimplifyCall(CS, V, ArgBegin, ArgEnd, Q, RecursionLimit);
return ::SimplifyCall(Call, V, Args.begin(), Args.end(), Q, RecursionLimit);
}
Value *llvm::SimplifyCall(ImmutableCallSite CS, Value *V,
ArrayRef<Value *> Args, const SimplifyQuery &Q) {
return ::SimplifyCall(CS, V, Args.begin(), Args.end(), Q, RecursionLimit);
}
Value *llvm::SimplifyCall(ImmutableCallSite ICS, const SimplifyQuery &Q) {
CallSite CS(const_cast<Instruction*>(ICS.getInstruction()));
return ::SimplifyCall(CS, CS.getCalledValue(), CS.arg_begin(), CS.arg_end(),
Q, RecursionLimit);
Value *llvm::SimplifyCall(CallBase *Call, const SimplifyQuery &Q) {
return ::SimplifyCall(Call, Call->getCalledValue(), Call->arg_begin(),
Call->arg_end(), Q, RecursionLimit);
}
/// See if we can compute a simplified version of this instruction.
@ -5335,8 +5334,7 @@ Value *llvm::SimplifyInstruction(Instruction *I, const SimplifyQuery &SQ,
Result = SimplifyPHINode(cast<PHINode>(I), Q);
break;
case Instruction::Call: {
CallSite CS(cast<CallInst>(I));
Result = SimplifyCall(CS, Q);
Result = SimplifyCall(cast<CallInst>(I), Q);
break;
}
#define HANDLE_CAST_INST(num, opc, clas) case Instruction::opc: