LLVM  mainline
Namespaces | Functions
InstructionSimplify.h File Reference
#include "llvm/IR/User.h"
Include dependency graph for InstructionSimplify.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces

namespace  llvm
 

Compute iterated dominance frontiers using a linear time algorithm.


Functions

Valuellvm::SimplifyAddInst (Value *LHS, Value *RHS, bool isNSW, bool isNUW, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 SimplifyAddInst - Given operands for an Add, see if we can fold the result.
Valuellvm::SimplifySubInst (Value *LHS, Value *RHS, bool isNSW, bool isNUW, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 SimplifySubInst - Given operands for a Sub, see if we can fold the result.
Valuellvm::SimplifyFAddInst (Value *LHS, Value *RHS, FastMathFlags FMF, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 Given operands for an FAdd, see if we can fold the result.
Valuellvm::SimplifyFSubInst (Value *LHS, Value *RHS, FastMathFlags FMF, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 Given operands for an FSub, see if we can fold the result.
Valuellvm::SimplifyFMulInst (Value *LHS, Value *RHS, FastMathFlags FMF, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 Given operands for an FMul, see if we can fold the result.
Valuellvm::SimplifyMulInst (Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 SimplifyMulInst - Given operands for a Mul, see if we can fold the result.
Valuellvm::SimplifySDivInst (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.
Valuellvm::SimplifyUDivInst (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.
Valuellvm::SimplifyFDivInst (Value *LHS, Value *RHS, FastMathFlags FMF, 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.
Valuellvm::SimplifySRemInst (Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 SimplifySRemInst - Given operands for an SRem, see if we can fold the result.
Valuellvm::SimplifyURemInst (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.
Valuellvm::SimplifyFRemInst (Value *LHS, Value *RHS, FastMathFlags FMF, 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.
Valuellvm::SimplifyShlInst (Value *Op0, Value *Op1, bool isNSW, bool isNUW, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 SimplifyShlInst - Given operands for a Shl, see if we can fold the result.
Valuellvm::SimplifyLShrInst (Value *Op0, Value *Op1, bool isExact, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 SimplifyLShrInst - Given operands for a LShr, see if we can fold the result.
Valuellvm::SimplifyAShrInst (Value *Op0, Value *Op1, bool isExact, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 SimplifyAShrInst - Given operands for a AShr, see if we can fold the result.
Valuellvm::SimplifyAndInst (Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 SimplifyAndInst - Given operands for an And, see if we can fold the result.
Valuellvm::SimplifyOrInst (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.
Valuellvm::SimplifyXorInst (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.
Valuellvm::SimplifyICmpInst (unsigned Predicate, Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, Instruction *CxtI=nullptr)
 SimplifyICmpInst - Given operands for an ICmpInst, see if we can fold the result.
Valuellvm::SimplifyFCmpInst (unsigned Predicate, Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 SimplifyFCmpInst - Given operands for an FCmpInst, see if we can fold the result.
Valuellvm::SimplifySelectInst (Value *Cond, Value *TrueVal, Value *FalseVal, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 SimplifySelectInst - Given operands for a SelectInst, see if we can fold the result.
Valuellvm::SimplifyGEPInst (ArrayRef< Value * > Ops, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can fold the result.
Valuellvm::SimplifyInsertValueInst (Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we can fold the result.
Valuellvm::SimplifyTruncInst (Value *Op, Type *Ty, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 SimplifyTruncInst - Given operands for an TruncInst, see if we can fold the result.
Valuellvm::SimplifyCmpInst (unsigned Predicate, Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 SimplifyCmpInst - Given operands for a CmpInst, see if we can fold the result.
Valuellvm::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)
 SimplifyBinOp - Given operands for a BinaryOperator, see if we can fold the result.
Valuellvm::SimplifyFPBinOp (unsigned Opcode, Value *LHS, Value *RHS, const FastMathFlags &FMF, 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.
Valuellvm::SimplifyCall (Value *V, User::op_iterator ArgBegin, User::op_iterator ArgEnd, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 Given a function and iterators over arguments, see if we can fold the result.
Valuellvm::SimplifyCall (Value *V, ArrayRef< Value * > Args, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
 Given a function and set of arguments, see if we can fold the result.
Valuellvm::SimplifyInstruction (Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
 SimplifyInstruction - See if we can compute a simplified version of this instruction.
bool llvm::replaceAndRecursivelySimplify (Instruction *I, Value *SimpleV, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
 Replace all uses of 'I' with 'SimpleV' and simplify the uses recursively.
bool llvm::recursivelySimplifyInstruction (Instruction *I, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
 Recursively attempt to simplify an instruction.