class Type;
class Value;
- /// SimplifyAddInst - Given operands for an Add, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for an Add, fold the result or return null.
Value *SimplifyAddInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifySubInst - Given operands for a Sub, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for a Sub, fold the result or return null.
Value *SimplifySubInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// Given operands for an FAdd, see if we can fold the result. If not, this
- /// returns null.
+ /// Given operands for an FAdd, fold the result or return null.
Value *SimplifyFAddInst(Value *LHS, Value *RHS, FastMathFlags FMF,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// Given operands for an FSub, see if we can fold the result. If not, this
- /// returns null.
+ /// Given operands for an FSub, fold the result or return null.
Value *SimplifyFSubInst(Value *LHS, Value *RHS, FastMathFlags FMF,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// Given operands for an FMul, see if we can fold the result. If not, this
- /// returns null.
+ /// Given operands for an FMul, fold the result or return null.
Value *SimplifyFMulInst(Value *LHS, Value *RHS, FastMathFlags FMF,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyMulInst - Given operands for a Mul, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for a Mul, fold the result or return null.
Value *SimplifyMulInst(Value *LHS, Value *RHS, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifySDivInst - Given operands for an SDiv, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for an SDiv, fold the result or return null.
Value *SimplifySDivInst(Value *LHS, Value *RHS, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyUDivInst - Given operands for a UDiv, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for a UDiv, fold the result or return null.
Value *SimplifyUDivInst(Value *LHS, Value *RHS, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyFDivInst - Given operands for an FDiv, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for an FDiv, fold the result or return null.
Value *SimplifyFDivInst(Value *LHS, Value *RHS, FastMathFlags FMF,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifySRemInst - Given operands for an SRem, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for an SRem, fold the result or return null.
Value *SimplifySRemInst(Value *LHS, Value *RHS, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyURemInst - Given operands for a URem, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for a URem, fold the result or return null.
Value *SimplifyURemInst(Value *LHS, Value *RHS, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyFRemInst - Given operands for an FRem, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for an FRem, fold the result or return null.
Value *SimplifyFRemInst(Value *LHS, Value *RHS, FastMathFlags FMF,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyShlInst - Given operands for a Shl, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for a Shl, fold the result or return null.
Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyLShrInst - Given operands for a LShr, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for a LShr, fold the result or return null.
Value *SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyAShrInst - Given operands for a AShr, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for a AShr, fold the result or return nulll.
Value *SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyAndInst - Given operands for an And, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for an And, fold the result or return null.
Value *SimplifyAndInst(Value *LHS, Value *RHS, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyOrInst - Given operands for an Or, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for an Or, fold the result or return null.
Value *SimplifyOrInst(Value *LHS, Value *RHS, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyXorInst - Given operands for a Xor, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for an Xor, fold the result or return null.
Value *SimplifyXorInst(Value *LHS, Value *RHS, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyICmpInst - Given operands for an ICmpInst, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for an ICmpInst, fold the result or return null.
Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for an FCmpInst, fold the result or return null.
Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
FastMathFlags FMF, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifySelectInst - Given operands for a SelectInst, see if we can fold
- /// the result. If not, this returns null.
+ /// Given operands for a SelectInst, fold the result or return null.
Value *SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for a GetElementPtrInst, fold the result or return null.
Value *SimplifyGEPInst(Type *SrcTy, ArrayRef<Value *> Ops,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we
- /// can fold the result. If not, this returns null.
+ /// Given operands for an InsertValueInst, fold the result or return null.
Value *SimplifyInsertValueInst(Value *Agg, Value *Val,
ArrayRef<unsigned> Idxs, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// \brief Given operands for an ExtractValueInst, see if we can fold the
- /// result. If not, this returns null.
+ /// Given operands for an ExtractValueInst, fold the result or return null.
Value *SimplifyExtractValueInst(Value *Agg, ArrayRef<unsigned> Idxs,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// \brief Given operands for an ExtractElementInst, see if we can fold the
- /// result. If not, this returns null.
+ /// Given operands for an ExtractElementInst, fold the result or return null.
Value *SimplifyExtractElementInst(Value *Vec, Value *Idx,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyTruncInst - Given operands for an TruncInst, see if we can fold
- /// the result. If not, this returns null.
+ /// Given operands for an TruncInst, fold the result or return null.
Value *SimplifyTruncInst(Value *Op, Type *Ty, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr,
//=== Helper functions for higher up the class hierarchy.
- /// SimplifyCmpInst - Given operands for a CmpInst, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for a CmpInst, fold the result or return null.
Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyBinOp - Given operands for a BinaryOperator, see if we can
- /// fold the result. If not, this returns null.
+ /// Given operands for a BinaryOperator, fold the result or return null.
Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyFPBinOp - Given operands for a BinaryOperator, see if we can
- /// fold the result. If not, this returns null.
+
+ /// Given operands for an FP BinaryOperator, fold the result or return null.
/// In contrast to SimplifyBinOp, try to use FastMathFlag when folding the
/// result. In case we don't need FastMathFlags, simply fall to SimplifyBinOp.
Value *SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// \brief Given a function and iterators over arguments, see if we can fold
- /// the result.
- ///
- /// If this call could not be simplified returns null.
+ /// Given a function and iterators over arguments, fold the result or return
+ /// null.
Value *SimplifyCall(Value *V, User::op_iterator ArgBegin,
User::op_iterator ArgEnd, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// \brief Given a function and set of arguments, see if we can fold the
- /// result.
- ///
- /// If this call could not be simplified returns null.
+ /// Given a function and set of arguments, fold the result or return null.
Value *SimplifyCall(Value *V, ArrayRef<Value *> Args, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
- /// SimplifyInstruction - See if we can compute a simplified version of this
- /// instruction. If not, this returns null.
+ /// See if we can compute a simplified version of this instruction. If not,
+ /// return null.
Value *SimplifyInstruction(Instruction *I, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr);
- /// \brief Replace all uses of 'I' with 'SimpleV' and simplify the uses
- /// recursively.
+ /// Replace all uses of 'I' with 'SimpleV' and simplify the uses recursively.
///
/// This first performs a normal RAUW of I with SimpleV. It then recursively
/// attempts to simplify those users updated by the operation. The 'I'
const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr);
- /// \brief Recursively attempt to simplify an instruction.
+ /// Recursively attempt to simplify an instruction.
///
/// This routine uses SimplifyInstruction to simplify 'I', and if successful
/// replaces uses of 'I' with the simplified value. It then recurses on each
projects / llvm / commitdiff