LLVM  6.0.0svn
Namespaces | Macros | Enumerations | Functions
InstructionSimplify.cpp File Reference
#include "llvm/Analysis/InstructionSimplify.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/AssumptionCache.h"
#include "llvm/Analysis/CaptureTracking.h"
#include "llvm/Analysis/CmpInstAnalysis.h"
#include "llvm/Analysis/ConstantFolding.h"
#include "llvm/Analysis/LoopAnalysisManager.h"
#include "llvm/Analysis/MemoryBuiltins.h"
#include "llvm/Analysis/OptimizationRemarkEmitter.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/Analysis/VectorUtils.h"
#include "llvm/IR/ConstantRange.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/GetElementPtrTypeIterator.h"
#include "llvm/IR/GlobalAlias.h"
#include "llvm/IR/Operator.h"
#include "llvm/IR/PatternMatch.h"
#include "llvm/IR/ValueHandle.h"
#include "llvm/Support/KnownBits.h"
#include <algorithm>
#include "llvm/IR/Instruction.def"
Include dependency graph for InstructionSimplify.cpp:

Go to the source code of this file.

Namespaces

 llvm
 Compute iterated dominance frontiers using a linear time algorithm.
 

Macros

#define DEBUG_TYPE   "instsimplify"
 
#define HANDLE_CAST_INST(num, opc, clas)   case Instruction::opc:
 

Enumerations

enum  { RecursionLimit = 3 }
 

Functions

 STATISTIC (NumExpand, "Number of expansions")
 
 STATISTIC (NumReassoc, "Number of reassociations")
 
static ValueSimplifyAndInst (Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for an And, see if we can fold the result. More...
 
static ValueSimplifyBinOp (unsigned Opcode, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for a BinaryOperator, see if we can fold the result. More...
 
static ValueSimplifyFPBinOp (unsigned Opcode, Value *LHS, Value *RHS, const FastMathFlags &FMF, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for a BinaryOperator, see if we can fold the result. More...
 
static ValueSimplifyCmpInst (unsigned Predicate, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for a CmpInst, see if we can fold the result. More...
 
static ValueSimplifyICmpInst (unsigned Predicate, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for an ICmpInst, see if we can fold the result. More...
 
static ValueSimplifyOrInst (Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for an Or, see if we can fold the result. More...
 
static ValueSimplifyXorInst (Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for a Xor, see if we can fold the result. More...
 
static ValueSimplifyCastInst (unsigned, Value *, Type *, const SimplifyQuery &, unsigned)
 
static ConstantgetFalse (Type *Ty)
 For a boolean type or a vector of boolean type, return false or a vector with every element false. More...
 
static ConstantgetTrue (Type *Ty)
 For a boolean type or a vector of boolean type, return true or a vector with every element true. More...
 
static bool isSameCompare (Value *V, CmpInst::Predicate Pred, Value *LHS, Value *RHS)
 isSameCompare - Is V equivalent to the comparison "LHS Pred RHS"? More...
 
static bool ValueDominatesPHI (Value *V, PHINode *P, const DominatorTree *DT)
 Does the given value dominate the specified phi node? More...
 
static ValueExpandBinOp (Instruction::BinaryOps Opcode, Value *LHS, Value *RHS, Instruction::BinaryOps OpcodeToExpand, const SimplifyQuery &Q, unsigned MaxRecurse)
 Simplify "A op (B op' C)" by distributing op over op', turning it into "(A op B) op' (A op C)". More...
 
static ValueSimplifyAssociativeBinOp (Instruction::BinaryOps Opcode, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
 Generic simplifications for associative binary operations. More...
 
static ValueThreadBinOpOverSelect (Instruction::BinaryOps Opcode, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
 In the case of a binary operation with a select instruction as an operand, try to simplify the binop by seeing whether evaluating it on both branches of the select results in the same value. More...
 
static ValueThreadCmpOverSelect (CmpInst::Predicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
 In the case of a comparison with a select instruction, try to simplify the comparison by seeing whether both branches of the select result in the same value. More...
 
static ValueThreadBinOpOverPHI (Instruction::BinaryOps Opcode, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
 In the case of a binary operation with an operand that is a PHI instruction, try to simplify the binop by seeing whether evaluating it on the incoming phi values yields the same result for every value. More...
 
static ValueThreadCmpOverPHI (CmpInst::Predicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
 In the case of a comparison with a PHI instruction, try to simplify the comparison by seeing whether comparing with all of the incoming phi values yields the same result every time. More...
 
static ConstantfoldOrCommuteConstant (Instruction::BinaryOps Opcode, Value *&Op0, Value *&Op1, const SimplifyQuery &Q)
 
static ValueSimplifyAddInst (Value *Op0, Value *Op1, bool isNSW, bool isNUW, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for an Add, see if we can fold the result. More...
 
static ConstantstripAndComputeConstantOffsets (const DataLayout &DL, Value *&V, bool AllowNonInbounds=false)
 Compute the base pointer and cumulative constant offsets for V. More...
 
static ConstantcomputePointerDifference (const DataLayout &DL, Value *LHS, Value *RHS)
 Compute the constant difference between two pointer values. More...
 
static ValueSimplifySubInst (Value *Op0, Value *Op1, bool isNSW, bool isNUW, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for a Sub, see if we can fold the result. More...
 
static ValueSimplifyMulInst (Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for a Mul, see if we can fold the result. More...
 
static ValuesimplifyDivRem (Value *Op0, Value *Op1, bool IsDiv)
 Check for common or similar folds of integer division or integer remainder. More...
 
static bool isICmpTrue (ICmpInst::Predicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given a predicate and two operands, return true if the comparison is true. More...
 
static bool isDivZero (Value *X, Value *Y, const SimplifyQuery &Q, unsigned MaxRecurse, bool IsSigned)
 Return true if we can simplify X / Y to 0. More...
 
static ValuesimplifyDiv (Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
 These are simplifications common to SDiv and UDiv. More...
 
static ValuesimplifyRem (Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
 These are simplifications common to SRem and URem. More...
 
static ValueSimplifySDivInst (Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for an SDiv, see if we can fold the result. More...
 
static ValueSimplifyUDivInst (Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for a UDiv, see if we can fold the result. More...
 
static ValueSimplifySRemInst (Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for an SRem, see if we can fold the result. More...
 
static ValueSimplifyURemInst (Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for a URem, see if we can fold the result. More...
 
static bool isUndefShift (Value *Amount)
 Returns true if a shift by Amount always yields undef. More...
 
static ValueSimplifyShift (Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for an Shl, LShr or AShr, see if we can fold the result. More...
 
static ValueSimplifyRightShift (Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, bool isExact, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for an Shl, LShr or AShr, see if we can fold the result. More...
 
static ValueSimplifyShlInst (Value *Op0, Value *Op1, bool isNSW, bool isNUW, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for an Shl, see if we can fold the result. More...
 
static ValueSimplifyLShrInst (Value *Op0, Value *Op1, bool isExact, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for an LShr, see if we can fold the result. More...
 
static ValueSimplifyAShrInst (Value *Op0, Value *Op1, bool isExact, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for an AShr, see if we can fold the result. More...
 
static ValuesimplifyUnsignedRangeCheck (ICmpInst *ZeroICmp, ICmpInst *UnsignedICmp, bool IsAnd)
 Commuted variants are assumed to be handled by calling this function again with the parameters swapped. More...
 
static ValuesimplifyAndOfICmpsWithSameOperands (ICmpInst *Op0, ICmpInst *Op1)
 Commuted variants are assumed to be handled by calling this function again with the parameters swapped. More...
 
static ValuesimplifyOrOfICmpsWithSameOperands (ICmpInst *Op0, ICmpInst *Op1)
 Commuted variants are assumed to be handled by calling this function again with the parameters swapped. More...
 
static ValuesimplifyAndOrOfICmpsWithConstants (ICmpInst *Cmp0, ICmpInst *Cmp1, bool IsAnd)
 Test if a pair of compares with a shared operand and 2 constants has an empty set intersection, full set union, or if one compare is a superset of the other. More...
 
static ValuesimplifyAndOfICmpsWithAdd (ICmpInst *Op0, ICmpInst *Op1)
 
static ValuesimplifyAndOfICmps (ICmpInst *Op0, ICmpInst *Op1)
 
static ValuesimplifyOrOfICmpsWithAdd (ICmpInst *Op0, ICmpInst *Op1)
 
static ValuesimplifyOrOfICmps (ICmpInst *Op0, ICmpInst *Op1)
 
static ValuesimplifyAndOrOfICmps (Value *Op0, Value *Op1, bool IsAnd)
 
static TypeGetCompareTy (Value *Op)
 
static ValueExtractEquivalentCondition (Value *V, CmpInst::Predicate Pred, Value *LHS, Value *RHS)
 Rummage around inside V looking for something equivalent to the comparison "LHS Pred RHS". More...
 
static ConstantcomputePointerICmp (const DataLayout &DL, const TargetLibraryInfo *TLI, const DominatorTree *DT, CmpInst::Predicate Pred, AssumptionCache *AC, const Instruction *CxtI, Value *LHS, Value *RHS)
 
static ValuesimplifyICmpOfBools (CmpInst::Predicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q)
 Fold an icmp when its operands have i1 scalar type. More...
 
static ValuesimplifyICmpWithZero (CmpInst::Predicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q)
 Try hard to fold icmp with zero RHS because this is a common case. More...
 
static void setLimitsForBinOp (BinaryOperator &BO, APInt &Lower, APInt &Upper)
 Many binary operators with a constant operand have an easy-to-compute range of outputs. More...
 
static ValuesimplifyICmpWithConstant (CmpInst::Predicate Pred, Value *LHS, Value *RHS)
 
static ValuesimplifyICmpWithBinOp (CmpInst::Predicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
 TODO: A large part of this logic is duplicated in InstCombine's foldICmpBinOp(). More...
 
static ValuesimplifyICmpWithMinMax (CmpInst::Predicate Pred, Value *LHS, Value *RHS, const SimplifyQuery &Q, unsigned MaxRecurse)
 Simplify integer comparisons where at least one operand of the compare matches an integer min/max idiom. More...
 
static ValueSimplifyFCmpInst (unsigned Predicate, Value *LHS, Value *RHS, FastMathFlags FMF, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for an FCmpInst, see if we can fold the result. More...
 
static const ValueSimplifyWithOpReplaced (Value *V, Value *Op, Value *RepOp, const SimplifyQuery &Q, unsigned MaxRecurse)
 See if V simplifies when its operand Op is replaced with RepOp. More...
 
static ValuesimplifySelectBitTest (Value *TrueVal, Value *FalseVal, Value *X, const APInt *Y, bool TrueWhenUnset)
 Try to simplify a select instruction when its condition operand is an integer comparison where one operand of the compare is a constant. More...
 
static ValuesimplifySelectWithFakeICmpEq (Value *CmpLHS, Value *CmpRHS, ICmpInst::Predicate Pred, Value *TrueVal, Value *FalseVal)
 An alternative way to test if a bit is set or not uses sgt/slt instead of eq/ne. More...
 
static ValuesimplifySelectWithICmpCond (Value *CondVal, Value *TrueVal, Value *FalseVal, const SimplifyQuery &Q, unsigned MaxRecurse)
 Try to simplify a select instruction when its condition operand is an integer comparison. More...
 
static ValueSimplifySelectInst (Value *CondVal, Value *TrueVal, Value *FalseVal, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for a SelectInst, see if we can fold the result. More...
 
static ValueSimplifyGEPInst (Type *SrcTy, ArrayRef< Value *> Ops, const SimplifyQuery &Q, unsigned)
 Given operands for an GetElementPtrInst, see if we can fold the result. More...
 
static ValueSimplifyInsertValueInst (Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const SimplifyQuery &Q, unsigned)
 Given operands for an InsertValueInst, see if we can fold the result. More...
 
static ValueSimplifyExtractValueInst (Value *Agg, ArrayRef< unsigned > Idxs, const SimplifyQuery &, unsigned)
 Given operands for an ExtractValueInst, see if we can fold the result. More...
 
static ValueSimplifyExtractElementInst (Value *Vec, Value *Idx, const SimplifyQuery &, unsigned)
 Given operands for an ExtractElementInst, see if we can fold the result. More...
 
static ValueSimplifyPHINode (PHINode *PN, const SimplifyQuery &Q)
 See if we can fold the given phi. If not, returns null. More...
 
static ValuefoldIdentityShuffles (int DestElt, Value *Op0, Value *Op1, int MaskVal, Value *RootVec, unsigned MaxRecurse)
 For the given destination element of a shuffle, peek through shuffles to match a root vector source operand that contains that element in the same vector lane (ie, the same mask index), so we can eliminate the shuffle(s). More...
 
static ValueSimplifyShuffleVectorInst (Value *Op0, Value *Op1, Constant *Mask, Type *RetTy, const SimplifyQuery &Q, unsigned MaxRecurse)
 
static ValueSimplifyFAddInst (Value *Op0, Value *Op1, FastMathFlags FMF, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for an FAdd, see if we can fold the result. More...
 
static ValueSimplifyFSubInst (Value *Op0, Value *Op1, FastMathFlags FMF, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given operands for an FSub, see if we can fold the result. More...
 
static ValueSimplifyFMulInst (Value *Op0, Value *Op1, FastMathFlags FMF, const SimplifyQuery &Q, unsigned MaxRecurse)
 Given the operands for an FMul, see if we can fold the result. More...
 
static ValueSimplifyFDivInst (Value *Op0, Value *Op1, FastMathFlags FMF, const SimplifyQuery &Q, unsigned)
 
static ValueSimplifyFRemInst (Value *Op0, Value *Op1, FastMathFlags FMF, const SimplifyQuery &Q, unsigned)
 
static bool IsIdempotent (Intrinsic::ID ID)
 
static ValueSimplifyRelativeLoad (Constant *Ptr, Constant *Offset, const DataLayout &DL)
 
static bool maskIsAllZeroOrUndef (Value *Mask)
 
template<typename IterTy >
static ValueSimplifyIntrinsic (Function *F, IterTy ArgBegin, IterTy ArgEnd, const SimplifyQuery &Q, unsigned MaxRecurse)
 
template<typename IterTy >
static ValueSimplifyCall (ImmutableCallSite CS, Value *V, IterTy ArgBegin, IterTy ArgEnd, const SimplifyQuery &Q, unsigned MaxRecurse)
 
static bool replaceAndRecursivelySimplifyImpl (Instruction *I, Value *SimpleV, const TargetLibraryInfo *TLI, const DominatorTree *DT, AssumptionCache *AC)
 Implementation of recursive simplification through an instruction's uses. More...
 
const SimplifyQuery llvm::getBestSimplifyQuery (Pass &, Function &)
 
const SimplifyQuery llvm::getBestSimplifyQuery (LoopStandardAnalysisResults &, const DataLayout &)
 
template<class T , class... TArgs>
const SimplifyQuery llvm::getBestSimplifyQuery (AnalysisManager< T, TArgs... > &, Function &)
 
template const SimplifyQuery llvm::getBestSimplifyQuery (AnalysisManager< Function > &, Function &)
 

Macro Definition Documentation

◆ DEBUG_TYPE

#define DEBUG_TYPE   "instsimplify"

Definition at line 46 of file InstructionSimplify.cpp.

◆ HANDLE_CAST_INST

#define HANDLE_CAST_INST (   num,
  opc,
  clas 
)    case Instruction::opc:

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
RecursionLimit 

Definition at line 48 of file InstructionSimplify.cpp.

Function Documentation

◆ computePointerDifference()

static Constant* computePointerDifference ( const DataLayout DL,
Value LHS,
Value RHS 
)
static

Compute the constant difference between two pointer values.

If the difference is not a constant, returns zero.

Definition at line 643 of file InstructionSimplify.cpp.

References llvm::ConstantExpr::getSub(), and stripAndComputeConstantOffsets().

Referenced by SimplifySubInst().

◆ computePointerICmp()

static Constant* computePointerICmp ( const DataLayout DL,
const TargetLibraryInfo TLI,
const DominatorTree DT,
CmpInst::Predicate  Pred,
AssumptionCache AC,
const Instruction CxtI,
Value LHS,
Value RHS 
)
static

◆ ExpandBinOp()

static Value* ExpandBinOp ( Instruction::BinaryOps  Opcode,
Value LHS,
Value RHS,
Instruction::BinaryOps  OpcodeToExpand,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

Simplify "A op (B op' C)" by distributing op over op', turning it into "(A op B) op' (A op C)".

Here "op" is given by Opcode and "op'" is given by OpcodeToExpand, while "A" corresponds to LHS and "B op' C" to RHS. Also performs the transform "(A op' B) op C" -> "(A op C) op' (B op C)". Returns the simplified value, or null if no simplification was performed.

Definition at line 124 of file InstructionSimplify.cpp.

References A, B, C, llvm::User::getOperand(), llvm::Instruction::isCommutative(), llvm::RISCVFenceField::R, and llvm::SimplifyBinOp().

Referenced by SimplifyAndInst(), SimplifyMulInst(), and SimplifyOrInst().

◆ ExtractEquivalentCondition()

static Value* ExtractEquivalentCondition ( Value V,
CmpInst::Predicate  Pred,
Value LHS,
Value RHS 
)
static

Rummage around inside V looking for something equivalent to the comparison "LHS Pred RHS".

Return such a value if found, otherwise return null. Helper function for analyzing max/min idioms.

Definition at line 1881 of file InstructionSimplify.cpp.

References llvm::dyn_cast(), llvm::SelectInst::getCondition(), llvm::User::getOperand(), llvm::CmpInst::getPredicate(), llvm::CmpInst::getSwappedPredicate(), and SI.

Referenced by simplifyICmpWithMinMax().

◆ foldIdentityShuffles()

static Value* foldIdentityShuffles ( int  DestElt,
Value Op0,
Value Op1,
int  MaskVal,
Value RootVec,
unsigned  MaxRecurse 
)
static

For the given destination element of a shuffle, peek through shuffles to match a root vector source operand that contains that element in the same vector lane (ie, the same mask index), so we can eliminate the shuffle(s).

Definition at line 3907 of file InstructionSimplify.cpp.

References llvm::Value::getType(), and llvm::Type::getVectorNumElements().

Referenced by SimplifyShuffleVectorInst().

◆ foldOrCommuteConstant()

static Constant* foldOrCommuteConstant ( Instruction::BinaryOps  Opcode,
Value *&  Op0,
Value *&  Op1,
const SimplifyQuery Q 
)
static

◆ GetCompareTy()

static Type* GetCompareTy ( Value Op)
static

◆ getFalse()

static Constant* getFalse ( Type Ty)
static

◆ getTrue()

static Constant* getTrue ( Type Ty)
static

◆ isDivZero()

static bool isDivZero ( Value X,
Value Y,
const SimplifyQuery Q,
unsigned  MaxRecurse,
bool  IsSigned 
)
static

◆ isICmpTrue()

static bool isICmpTrue ( ICmpInst::Predicate  Pred,
Value LHS,
Value RHS,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

Given a predicate and two operands, return true if the comparison is true.

This is a helper for div/rem simplification where we return some other value when we can prove a relationship between the operands.

Definition at line 911 of file InstructionSimplify.cpp.

References C, llvm::Constant::isAllOnesValue(), and llvm::SimplifyICmpInst().

Referenced by isDivZero().

◆ IsIdempotent()

static bool IsIdempotent ( Intrinsic::ID  ID)
static

Definition at line 4302 of file InstructionSimplify.cpp.

References round().

Referenced by SimplifyIntrinsic().

◆ isSameCompare()

static bool isSameCompare ( Value V,
CmpInst::Predicate  Pred,
Value LHS,
Value RHS 
)
static

isSameCompare - Is V equivalent to the comparison "LHS Pred RHS"?

Definition at line 80 of file InstructionSimplify.cpp.

References llvm::dyn_cast(), llvm::User::getOperand(), llvm::CmpInst::getPredicate(), and llvm::CmpInst::getSwappedPredicate().

Referenced by ThreadCmpOverSelect().

◆ isUndefShift()

static bool isUndefShift ( Value Amount)
static

Returns true if a shift by Amount always yields undef.

Definition at line 1109 of file InstructionSimplify.cpp.

References C, llvm::dyn_cast(), E, llvm::Constant::getAggregateElement(), llvm::Value::getType(), llvm::Type::getVectorNumElements(), and I.

Referenced by SimplifyShift().

◆ maskIsAllZeroOrUndef()

static bool maskIsAllZeroOrUndef ( Value Mask)
static

Definition at line 4375 of file InstructionSimplify.cpp.

References llvm::dyn_cast(), E, I, and llvm::BitmaskEnumDetail::Mask().

Referenced by SimplifyIntrinsic().

◆ replaceAndRecursivelySimplifyImpl()

static bool replaceAndRecursivelySimplifyImpl ( Instruction I,
Value SimpleV,
const TargetLibraryInfo TLI,
const DominatorTree DT,
AssumptionCache AC 
)
static

Implementation of recursive simplification through an instruction's uses.

This is the common implementation of the recursive simplification routines. If we have a pre-simplified value in 'SimpleV', that is forcibly used to replace the instruction 'I'. Otherwise, we simply add 'I' to the list of instructions to process and attempt to simplify it using InstructionSimplify.

This routine returns 'true' only when it simplifies something. The passed in simplified value does not count toward this.

Definition at line 4704 of file InstructionSimplify.cpp.

References llvm::Instruction::eraseFromParent(), llvm::Module::getDataLayout(), llvm::Instruction::getModule(), llvm::Instruction::getParent(), I, llvm::SetVector< T, SmallVector< T, N >, SmallDenseSet< T, N > >::insert(), llvm::Instruction::isEHPad(), llvm::Instruction::mayHaveSideEffects(), llvm::Value::replaceAllUsesWith(), llvm::JumpTable::Simplified, llvm::SimplifyInstruction(), llvm::SetVector< T, SmallVector< T, N >, SmallDenseSet< T, N > >::size(), and llvm::Value::users().

Referenced by llvm::recursivelySimplifyInstruction(), and llvm::replaceAndRecursivelySimplify().

◆ setLimitsForBinOp()

static void setLimitsForBinOp ( BinaryOperator BO,
APInt Lower,
APInt Upper 
)
static

◆ SimplifyAddInst()

static Value* SimplifyAddInst ( Value Op0,
Value Op1,
bool  isNSW,
bool  isNUW,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyAndInst()

static Value * SimplifyAndInst ( Value Op0,
Value Op1,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ simplifyAndOfICmps()

static Value* simplifyAndOfICmps ( ICmpInst Op0,
ICmpInst Op1 
)
static

◆ simplifyAndOfICmpsWithAdd()

static Value* simplifyAndOfICmpsWithAdd ( ICmpInst Op0,
ICmpInst Op1 
)
static

◆ simplifyAndOfICmpsWithSameOperands()

static Value* simplifyAndOfICmpsWithSameOperands ( ICmpInst Op0,
ICmpInst Op1 
)
static

◆ simplifyAndOrOfICmps()

static Value* simplifyAndOrOfICmps ( Value Op0,
Value Op1,
bool  IsAnd 
)
static

◆ simplifyAndOrOfICmpsWithConstants()

static Value* simplifyAndOrOfICmpsWithConstants ( ICmpInst Cmp0,
ICmpInst Cmp1,
bool  IsAnd 
)
static

Test if a pair of compares with a shared operand and 2 constants has an empty set intersection, full set union, or if one compare is a superset of the other.

Definition at line 1380 of file InstructionSimplify.cpp.

References getFalse(), llvm::User::getOperand(), llvm::CmpInst::getPredicate(), getTrue(), llvm::Value::getType(), llvm::PatternMatch::m_APInt(), llvm::ConstantRange::makeExactICmpRegion(), and llvm::PatternMatch::match().

Referenced by simplifyAndOfICmps(), and simplifyOrOfICmps().

◆ SimplifyAShrInst()

static Value* SimplifyAShrInst ( Value Op0,
Value Op1,
bool  isExact,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyAssociativeBinOp()

static Value* SimplifyAssociativeBinOp ( Instruction::BinaryOps  Opcode,
Value LHS,
Value RHS,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

Generic simplifications for associative binary operations.

Returns the simpler value, or null if none was found.

Definition at line 182 of file InstructionSimplify.cpp.

References A, assert(), B, C, llvm::dyn_cast(), llvm::BinaryOperator::getOpcode(), llvm::User::getOperand(), llvm::Instruction::isAssociative(), llvm::Instruction::isCommutative(), llvm::SimplifyBinOp(), and llvm::RISCVFenceField::W.

Referenced by SimplifyAddInst(), SimplifyAndInst(), SimplifyMulInst(), SimplifyOrInst(), and SimplifyXorInst().

◆ SimplifyBinOp()

static Value * SimplifyBinOp ( unsigned  Opcode,
Value LHS,
Value RHS,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyCall()

template<typename IterTy >
static Value* SimplifyCall ( ImmutableCallSite  CS,
Value V,
IterTy  ArgBegin,
IterTy  ArgEnd,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyCastInst()

static Value * SimplifyCastInst ( unsigned  CastOpc,
Value Op,
Type Ty,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyCmpInst()

static Value * SimplifyCmpInst ( unsigned  Predicate,
Value LHS,
Value RHS,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

Given operands for a CmpInst, see if we can fold the result.

Definition at line 4290 of file InstructionSimplify.cpp.

References llvm::CmpInst::isIntPredicate(), llvm::SimplifyFCmpInst(), and llvm::SimplifyICmpInst().

Referenced by llvm::SimplifyCmpInst().

◆ simplifyDiv()

static Value* simplifyDiv ( Instruction::BinaryOps  Opcode,
Value Op0,
Value Op1,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ simplifyDivRem()

static Value* simplifyDivRem ( Value Op0,
Value Op1,
bool  IsDiv 
)
static

◆ SimplifyExtractElementInst()

static Value* SimplifyExtractElementInst ( Value Vec,
Value Idx,
const SimplifyQuery ,
unsigned   
)
static

Given operands for an ExtractElementInst, see if we can fold the result.

If not, this returns null.

Definition at line 3804 of file InstructionSimplify.cpp.

References llvm::ConstantFoldExtractElementInstruction(), llvm::findScalarElement(), llvm::UndefValue::get(), llvm::Value::getType(), and llvm::Type::getVectorElementType().

Referenced by llvm::SimplifyExtractElementInst().

◆ SimplifyExtractValueInst()

static Value* SimplifyExtractValueInst ( Value Agg,
ArrayRef< unsigned Idxs,
const SimplifyQuery ,
unsigned   
)
static

Given operands for an ExtractValueInst, see if we can fold the result.

If not, this returns null.

Definition at line 3774 of file InstructionSimplify.cpp.

References llvm::ConstantFoldExtractValueInstruction(), llvm::dyn_cast(), llvm::ArrayRef< T >::size(), and llvm::ArrayRef< T >::slice().

Referenced by llvm::SimplifyExtractValueInst().

◆ SimplifyFAddInst()

static Value* SimplifyFAddInst ( Value Op0,
Value Op1,
FastMathFlags  FMF,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyFCmpInst()

static Value* SimplifyFCmpInst ( unsigned  Predicate,
Value LHS,
Value RHS,
FastMathFlags  FMF,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyFDivInst()

static Value* SimplifyFDivInst ( Value Op0,
Value Op1,
FastMathFlags  FMF,
const SimplifyQuery Q,
unsigned   
)
static

◆ SimplifyFMulInst()

static Value* SimplifyFMulInst ( Value Op0,
Value Op1,
FastMathFlags  FMF,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyFPBinOp()

static Value * SimplifyFPBinOp ( unsigned  Opcode,
Value LHS,
Value RHS,
const FastMathFlags FMF,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

Given operands for a BinaryOperator, see if we can fold the result.

If not, this returns null. In contrast to SimplifyBinOp, try to use FastMathFlag when folding the result. In case we don't need FastMathFlags, simply fall to SimplifyBinOp.

Definition at line 4262 of file InstructionSimplify.cpp.

References llvm::SimplifyBinOp(), llvm::SimplifyFAddInst(), llvm::SimplifyFDivInst(), llvm::SimplifyFMulInst(), and llvm::SimplifyFSubInst().

Referenced by llvm::SimplifyFPBinOp().

◆ SimplifyFRemInst()

static Value* SimplifyFRemInst ( Value Op0,
Value Op1,
FastMathFlags  FMF,
const SimplifyQuery Q,
unsigned   
)
static

◆ SimplifyFSubInst()

static Value* SimplifyFSubInst ( Value Op0,
Value Op1,
FastMathFlags  FMF,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyGEPInst()

static Value* SimplifyGEPInst ( Type SrcTy,
ArrayRef< Value *>  Ops,
const SimplifyQuery Q,
unsigned   
)
static

◆ SimplifyICmpInst()

static Value * SimplifyICmpInst ( unsigned  Predicate,
Value LHS,
Value RHS,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

Given operands for an ICmpInst, see if we can fold the result.

If not, this returns null.

Definition at line 2953 of file InstructionSimplify.cpp.

References llvm::SimplifyQuery::AC, assert(), C, computePointerICmp(), llvm::ConstantFoldCompareInstOperands(), llvm::SimplifyQuery::CxtI, llvm::SimplifyQuery::DL, llvm::SimplifyQuery::DT, llvm::ConstantInt::get(), llvm::ConstantExpr::getCast(), GetCompareTy(), llvm::getConstantRangeFromMetadata(), llvm::Value::getContext(), getFalse(), llvm::ConstantInt::getFalse(), llvm::ConstantExpr::getGetElementPtr(), llvm::ConstantExpr::getICmp(), llvm::ConstantExpr::getIntToPtr(), llvm::CmpInst::getInversePredicate(), llvm::Constant::getNullValue(), llvm::User::getOperand(), llvm::Type::getPrimitiveSizeInBits(), llvm::ICmpInst::getSignedPredicate(), llvm::CmpInst::getSwappedPredicate(), getTrue(), llvm::ConstantInt::getTrue(), llvm::ConstantExpr::getTrunc(), llvm::Value::getType(), llvm::DataLayout::getTypeSizeInBits(), llvm::ICmpInst::getUnsignedPredicate(), llvm::CmpInst::ICMP_EQ, llvm::CmpInst::ICMP_NE, llvm::CmpInst::ICMP_SGE, llvm::CmpInst::ICMP_SGT, llvm::CmpInst::ICMP_SLE, llvm::CmpInst::ICMP_SLT, llvm::CmpInst::ICMP_UGE, llvm::CmpInst::ICMP_UGT, llvm::CmpInst::ICMP_ULE, llvm::CmpInst::ICMP_ULT, llvm::ICmpInst::isEquality(), llvm::CmpInst::isIntPredicate(), llvm::isKnownNonEqual(), llvm::Type::isPointerTy(), llvm::CmpInst::isTrueWhenEqual(), llvm_unreachable, llvm::ConstantRange::makeSatisfyingICmpRegion(), llvm::LLVMContext::MD_range, llvm::SimplifyICmpInst(), simplifyICmpOfBools(), simplifyICmpWithBinOp(), simplifyICmpWithConstant(), simplifyICmpWithMinMax(), simplifyICmpWithZero(), std::swap(), ThreadCmpOverPHI(), ThreadCmpOverSelect(), and llvm::SimplifyQuery::TLI.

Referenced by llvm::SimplifyICmpInst().

◆ simplifyICmpOfBools()

static Value* simplifyICmpOfBools ( CmpInst::Predicate  Pred,
Value LHS,
Value RHS,
const SimplifyQuery Q 
)
static

Fold an icmp when its operands have i1 scalar type.

For signed comparison, the values for an i1 are 0 and -1 respectively. This maps into a truth table of: LHS | RHS | LHS >=s RHS | LHS implies RHS 0 | 0 | 1 (0 >= 0) | 1 0 | 1 | 1 (0 >= -1) | 1 1 | 0 | 0 (-1 >= 0) | 0 1 | 1 | 1 (-1 >= -1) | 1

Definition at line 2109 of file InstructionSimplify.cpp.

References llvm::SimplifyQuery::DL, GetCompareTy(), getFalse(), getTrue(), llvm::Value::getType(), llvm::Optional< T >::getValueOr(), llvm::CmpInst::ICMP_EQ, llvm::CmpInst::ICMP_NE, llvm::CmpInst::ICMP_SGE, llvm::CmpInst::ICMP_SGT, llvm::CmpInst::ICMP_SLE, llvm::CmpInst::ICMP_SLT, llvm::CmpInst::ICMP_UGE, llvm::CmpInst::ICMP_UGT, llvm::CmpInst::ICMP_ULE, llvm::CmpInst::ICMP_ULT, llvm::isImpliedCondition(), llvm::Type::isIntOrIntVectorTy(), llvm::PatternMatch::m_One(), llvm::PatternMatch::m_Zero(), and llvm::PatternMatch::match().

Referenced by SimplifyICmpInst().

◆ simplifyICmpWithBinOp()

static Value* simplifyICmpWithBinOp ( CmpInst::Predicate  Pred,
Value LHS,
Value RHS,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

TODO: A large part of this logic is duplicated in InstCombine's foldICmpBinOp().

We should be able to share that and avoid the code duplication.

Definition at line 2442 of file InstructionSimplify.cpp.

References A, llvm::SimplifyQuery::AC, llvm::MCID::Add, assert(), B, C, llvm::computeKnownBits(), llvm::SimplifyQuery::CxtI, D, llvm::SimplifyQuery::DL, llvm::SimplifyQuery::DT, llvm::dyn_cast(), GetCompareTy(), llvm::Value::getContext(), getFalse(), llvm::ConstantInt::getFalse(), llvm::Constant::getNullValue(), llvm::BinaryOperator::getOpcode(), llvm::User::getOperand(), getTrue(), llvm::ConstantInt::getTrue(), llvm::Value::getType(), llvm::Instruction::hasNoSignedWrap(), llvm::Instruction::hasNoUnsignedWrap(), llvm::CmpInst::ICMP_EQ, llvm::CmpInst::ICMP_NE, llvm::CmpInst::ICMP_SGE, llvm::CmpInst::ICMP_SGT, llvm::CmpInst::ICMP_SLE, llvm::CmpInst::ICMP_SLT, llvm::CmpInst::ICMP_UGE, llvm::CmpInst::ICMP_UGT, llvm::CmpInst::ICMP_ULE, llvm::CmpInst::ICMP_ULT, llvm::ICmpInst::isEquality(), llvm::Instruction::isExact(), llvm::KnownBits::isNegative(), llvm::KnownBits::isNonNegative(), llvm::APInt::isOneValue(), llvm::APInt::isPowerOf2(), llvm::CmpInst::isSigned(), llvm::APInt::isSignMask(), llvm::CmpInst::isUnsigned(), LLVM_FALLTHROUGH, llvm::PatternMatch::m_APInt(), llvm::PatternMatch::m_c_And(), llvm::PatternMatch::m_c_Or(), llvm::PatternMatch::m_LShr(), llvm::PatternMatch::m_Neg(), llvm::PatternMatch::m_Shl(), llvm::PatternMatch::m_Specific(), llvm::PatternMatch::m_UDiv(), llvm::PatternMatch::m_URem(), llvm::PatternMatch::m_Value(), llvm::PatternMatch::m_ZExt(), llvm::PatternMatch::match(), llvm::SimplifyICmpInst(), Y, and llvm::ARCCC::Z.

Referenced by SimplifyICmpInst().

◆ simplifyICmpWithConstant()

static Value* simplifyICmpWithConstant ( CmpInst::Predicate  Pred,
Value LHS,
Value RHS 
)
static

◆ simplifyICmpWithMinMax()

static Value* simplifyICmpWithMinMax ( CmpInst::Predicate  Pred,
Value LHS,
Value RHS,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ simplifyICmpWithZero()

static Value* simplifyICmpWithZero ( CmpInst::Predicate  Pred,
Value LHS,
Value RHS,
const SimplifyQuery Q 
)
static

◆ SimplifyInsertValueInst()

static Value* SimplifyInsertValueInst ( Value Agg,
Value Val,
ArrayRef< unsigned Idxs,
const SimplifyQuery Q,
unsigned   
)
static

Given operands for an InsertValueInst, see if we can fold the result.

If not, this returns null.

Definition at line 3739 of file InstructionSimplify.cpp.

References llvm::ConstantFoldInsertValueInstruction(), llvm::Value::getType(), llvm::PatternMatch::m_Undef(), and llvm::PatternMatch::match().

Referenced by llvm::SimplifyInsertValueInst().

◆ SimplifyIntrinsic()

template<typename IterTy >
static Value* SimplifyIntrinsic ( Function F,
IterTy  ArgBegin,
IterTy  ArgEnd,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyLShrInst()

static Value* SimplifyLShrInst ( Value Op0,
Value Op1,
bool  isExact,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

Given operands for an LShr, see if we can fold the result.

If not, this returns null.

Definition at line 1234 of file InstructionSimplify.cpp.

References llvm::PatternMatch::m_NUWShl(), llvm::PatternMatch::m_Specific(), llvm::PatternMatch::m_Value(), llvm::PatternMatch::match(), SimplifyRightShift(), and X.

Referenced by llvm::SimplifyLShrInst().

◆ SimplifyMulInst()

static Value* SimplifyMulInst ( Value Op0,
Value Op1,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyOrInst()

static Value * SimplifyOrInst ( Value Op0,
Value Op1,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ simplifyOrOfICmps()

static Value* simplifyOrOfICmps ( ICmpInst Op0,
ICmpInst Op1 
)
static

◆ simplifyOrOfICmpsWithAdd()

static Value* simplifyOrOfICmpsWithAdd ( ICmpInst Op0,
ICmpInst Op1 
)
static

◆ simplifyOrOfICmpsWithSameOperands()

static Value* simplifyOrOfICmpsWithSameOperands ( ICmpInst Op0,
ICmpInst Op1 
)
static

◆ SimplifyPHINode()

static Value* SimplifyPHINode ( PHINode PN,
const SimplifyQuery Q 
)
static

◆ SimplifyRelativeLoad()

static Value* SimplifyRelativeLoad ( Constant Ptr,
Constant Offset,
const DataLayout DL 
)
static

◆ simplifyRem()

static Value* simplifyRem ( Instruction::BinaryOps  Opcode,
Value Op0,
Value Op1,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyRightShift()

static Value* SimplifyRightShift ( Instruction::BinaryOps  Opcode,
Value Op0,
Value Op1,
bool  isExact,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifySDivInst()

static Value* SimplifySDivInst ( Value Op0,
Value Op1,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

Given operands for an SDiv, see if we can fold the result.

If not, this returns null.

Definition at line 1066 of file InstructionSimplify.cpp.

References simplifyDiv().

Referenced by llvm::SimplifySDivInst().

◆ simplifySelectBitTest()

static Value* simplifySelectBitTest ( Value TrueVal,
Value FalseVal,
Value X,
const APInt Y,
bool  TrueWhenUnset 
)
static

Try to simplify a select instruction when its condition operand is an integer comparison where one operand of the compare is a constant.

Definition at line 3456 of file InstructionSimplify.cpp.

References C, llvm::APInt::isPowerOf2(), llvm::PatternMatch::m_And(), llvm::PatternMatch::m_APInt(), llvm::PatternMatch::m_Or(), llvm::PatternMatch::m_Specific(), and llvm::PatternMatch::match().

Referenced by simplifySelectWithFakeICmpEq(), and simplifySelectWithICmpCond().

◆ SimplifySelectInst()

static Value* SimplifySelectInst ( Value CondVal,
Value TrueVal,
Value FalseVal,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

Given operands for a SelectInst, see if we can fold the result.

If not, this returns null.

Definition at line 3577 of file InstructionSimplify.cpp.

References llvm::ConstantFoldSelectInstruction(), and simplifySelectWithICmpCond().

Referenced by llvm::SimplifySelectInst().

◆ simplifySelectWithFakeICmpEq()

static Value* simplifySelectWithFakeICmpEq ( Value CmpLHS,
Value CmpRHS,
ICmpInst::Predicate  Pred,
Value TrueVal,
Value FalseVal 
)
static

An alternative way to test if a bit is set or not uses sgt/slt instead of eq/ne.

Definition at line 3491 of file InstructionSimplify.cpp.

References llvm::decomposeBitTestICmp(), llvm::CmpInst::ICMP_EQ, llvm::BitmaskEnumDetail::Mask(), simplifySelectBitTest(), and X.

Referenced by simplifySelectWithICmpCond().

◆ simplifySelectWithICmpCond()

static Value* simplifySelectWithICmpCond ( Value CondVal,
Value TrueVal,
Value FalseVal,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyShift()

static Value* SimplifyShift ( Instruction::BinaryOps  Opcode,
Value Op0,
Value Op1,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyShlInst()

static Value* SimplifyShlInst ( Value Op0,
Value Op1,
bool  isNSW,
bool  isNUW,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyShuffleVectorInst()

static Value* SimplifyShuffleVectorInst ( Value Op0,
Value Op1,
Constant Mask,
Type RetTy,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifySRemInst()

static Value* SimplifySRemInst ( Value Op0,
Value Op1,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

Given operands for an SRem, see if we can fold the result.

If not, this returns null.

Definition at line 1088 of file InstructionSimplify.cpp.

References simplifyRem().

Referenced by llvm::SimplifySRemInst().

◆ SimplifySubInst()

static Value* SimplifySubInst ( Value Op0,
Value Op1,
bool  isNSW,
bool  isNUW,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyUDivInst()

static Value* SimplifyUDivInst ( Value Op0,
Value Op1,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

Given operands for a UDiv, see if we can fold the result.

If not, this returns null.

Definition at line 1077 of file InstructionSimplify.cpp.

References simplifyDiv().

Referenced by llvm::SimplifyUDivInst().

◆ simplifyUnsignedRangeCheck()

static Value* simplifyUnsignedRangeCheck ( ICmpInst ZeroICmp,
ICmpInst UnsignedICmp,
bool  IsAnd 
)
static

◆ SimplifyURemInst()

static Value* SimplifyURemInst ( Value Op0,
Value Op1,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

Given operands for a URem, see if we can fold the result.

If not, this returns null.

Definition at line 1099 of file InstructionSimplify.cpp.

References simplifyRem().

Referenced by llvm::SimplifyURemInst().

◆ SimplifyWithOpReplaced()

static const Value* SimplifyWithOpReplaced ( Value V,
Value Op,
Value RepOp,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ SimplifyXorInst()

static Value * SimplifyXorInst ( Value Op0,
Value Op1,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ STATISTIC() [1/2]

STATISTIC ( NumExpand  ,
"Number of expansions"   
)

◆ STATISTIC() [2/2]

STATISTIC ( NumReassoc  ,
"Number of reassociations"   
)

◆ stripAndComputeConstantOffsets()

static Constant* stripAndComputeConstantOffsets ( const DataLayout DL,
Value *&  V,
bool  AllowNonInbounds = false 
)
static

Compute the base pointer and cumulative constant offsets for V.

This strips all constant offsets off of V, leaving it the base pointer, and accumulates the total constant offset applied in the returned constant. It returns 0 if V is not a pointer, and returns the constant '0' if there are no constant offsets applied.

This is very similar to GetPointerBaseWithConstantOffset except it doesn't follow non-inbounds geps. This allows it to remain usable for icmp ult/etc. folding.

Definition at line 600 of file InstructionSimplify.cpp.

References assert(), GEP, llvm::ConstantInt::get(), llvm::DataLayout::getIntPtrType(), llvm::APInt::getNullValue(), llvm::Operator::getOpcode(), llvm::ConstantVector::getSplat(), llvm::Value::getType(), llvm::Type::getVectorNumElements(), llvm::SmallPtrSetImpl< PtrType >::insert(), llvm::Type::isPtrOrPtrVectorTy(), and llvm::Type::isVectorTy().

Referenced by computePointerDifference(), and computePointerICmp().

◆ ThreadBinOpOverPHI()

static Value* ThreadBinOpOverPHI ( Instruction::BinaryOps  Opcode,
Value LHS,
Value RHS,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

In the case of a binary operation with an operand that is a PHI instruction, try to simplify the binop by seeing whether evaluating it on the incoming phi values yields the same result for every value.

If so returns the common value, otherwise returns null.

Definition at line 436 of file InstructionSimplify.cpp.

References assert(), llvm::SimplifyQuery::DT, llvm::PHINode::incoming_values(), llvm::SimplifyBinOp(), and ValueDominatesPHI().

Referenced by SimplifyAndInst(), simplifyDiv(), SimplifyMulInst(), SimplifyOrInst(), simplifyRem(), and SimplifyShift().

◆ ThreadBinOpOverSelect()

static Value* ThreadBinOpOverSelect ( Instruction::BinaryOps  Opcode,
Value LHS,
Value RHS,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

In the case of a binary operation with a select instruction as an operand, try to simplify the binop by seeing whether evaluating it on both branches of the select results in the same value.

Returns the common value if so, otherwise returns null.

Definition at line 282 of file InstructionSimplify.cpp.

References assert(), llvm::dyn_cast(), llvm::SelectInst::getFalseValue(), llvm::Instruction::getOpcode(), llvm::User::getOperand(), llvm::SelectInst::getTrueValue(), llvm::Instruction::isCommutative(), SI, llvm::JumpTable::Simplified, and llvm::SimplifyBinOp().

Referenced by SimplifyAndInst(), simplifyDiv(), SimplifyMulInst(), SimplifyOrInst(), simplifyRem(), and SimplifyShift().

◆ ThreadCmpOverPHI()

static Value* ThreadCmpOverPHI ( CmpInst::Predicate  Pred,
Value LHS,
Value RHS,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

In the case of a comparison with a PHI instruction, try to simplify the comparison by seeing whether comparing with all of the incoming phi values yields the same result every time.

If so returns the common result, otherwise returns null.

Definition at line 479 of file InstructionSimplify.cpp.

References assert(), llvm::SimplifyQuery::DT, llvm::CmpInst::getSwappedPredicate(), llvm::PHINode::incoming_values(), llvm::SimplifyCmpInst(), std::swap(), and ValueDominatesPHI().

Referenced by SimplifyFCmpInst(), and SimplifyICmpInst().

◆ ThreadCmpOverSelect()

static Value* ThreadCmpOverSelect ( CmpInst::Predicate  Pred,
Value LHS,
Value RHS,
const SimplifyQuery Q,
unsigned  MaxRecurse 
)
static

◆ ValueDominatesPHI()

static bool ValueDominatesPHI ( Value V,
PHINode P,
const DominatorTree DT 
)
static