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;
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,
#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"
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;
}
}
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();
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;
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,
- const SimplifyQuery &Q) {
- return ::SimplifyCall(CS, V, ArgBegin, ArgEnd, Q, RecursionLimit);
+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(ImmutableCallSite CS, Value *V,
- ArrayRef<Value *> Args, const SimplifyQuery &Q) {
- return ::SimplifyCall(CS, V, Args.begin(), Args.end(), Q, RecursionLimit);
+Value *llvm::SimplifyCall(CallBase *Call, Value *V, ArrayRef<Value *> Args,
+ const SimplifyQuery &Q) {
+ return ::SimplifyCall(Call, 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.
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: