Lines Matching refs:Value
43 /// \brief Assign a complexity or rank value to LLVM Values.
52 static inline unsigned getComplexity(Value *V) {
73 /// \brief Return true if the specified value is free to invert (apply ~ to).
78 static inline bool IsFreeToInvert(Value *V, bool WillInvertAllUses) {
224 // Return Value:
231 Value *OptimizePointerDifference(Value *LHS, Value *RHS, Type *Ty);
235 Value *foldFMulConst(Instruction *FMulOrDiv, Constant *C,
249 Value *simplifyRangeCheck(ICmpInst *Cmp0, ICmpInst *Cmp1, bool Inverted);
250 Value *FoldAndOfICmps(ICmpInst *LHS, ICmpInst *RHS);
251 Value *FoldAndOfFCmps(FCmpInst *LHS, FCmpInst *RHS);
253 Value *FoldOrOfICmps(ICmpInst *LHS, ICmpInst *RHS, Instruction *CxtI);
254 Value *FoldOrOfFCmps(FCmpInst *LHS, FCmpInst *RHS);
255 Instruction *FoldOrWithConstants(BinaryOperator &I, Value *Op, Value *A,
256 Value *B, Value *C);
257 Instruction *FoldXorWithConstants(BinaryOperator &I, Value *Op, Value *A,
258 Value *B, Value *C);
279 Instruction *FoldICmpCstShrCst(ICmpInst &I, Value *Op, Value *A,
281 Instruction *FoldICmpCstShlCst(ICmpInst &I, Value *Op, Value *A,
283 Instruction *FoldICmpAddOpCst(Instruction &ICI, Value *X, ConstantInt *CI,
285 Instruction *FoldGEPICmp(GEPOperator *GEPLHS, Value *RHS,
287 Instruction *FoldAllocaCmp(ICmpInst &ICI, AllocaInst *Alloca, Value *Other);
288 Instruction *FoldShiftByConstant(Value *Op0, Constant *Op1,
306 Instruction *FoldSelectIntoOp(SelectInst &SI, Value *, Value *);
308 Value *A, Value *B, Instruction &Outer,
309 SelectPatternFlavor SPF2, Value *C);
352 Value *dyn_castNegVal(Value *V) const;
353 Value *dyn_castFNegVal(Value *V, bool NoSignedZero = false) const;
355 SmallVectorImpl<Value *> &NewIndices);
364 bool ShouldOptimizeCast(Instruction::CastOps opcode, const Value *V,
379 bool OptimizeOverflowCheck(OverflowCheckFlavor OCF, Value *LHS, Value *RHS,
380 Instruction &CtxI, Value *&OperationResult,
391 bool WillNotOverflowSignedAdd(Value *LHS, Value *RHS, Instruction &CxtI);
392 bool WillNotOverflowSignedSub(Value *LHS, Value *RHS, Instruction &CxtI);
393 bool WillNotOverflowUnsignedSub(Value *LHS, Value *RHS, Instruction &CxtI);
394 bool WillNotOverflowSignedMul(Value *LHS, Value *RHS, Instruction &CxtI);
395 Value *EmitGEPOffset(User *GEP);
397 Value *EvaluateInDifferentElementOrder(Value *V, ArrayRef<int> Mask);
424 /// I to the worklist, replace all uses of I with the new value, then return
426 Instruction *replaceInstUsesWith(Instruction &I, Value *V) {
446 /// \p Result and a constant \p Overflow value.
447 Instruction *CreateOverflowTuple(IntrinsicInst *II, Value *Result,
458 /// value, we can't rely on DCE to delete the instruction. Instead, visit
459 /// methods should return the value returned by this function.
477 void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
483 bool MaskedValueIsZero(Value *V, const APInt &Mask, unsigned Depth = 0,
487 unsigned ComputeNumSignBits(Value *Op, unsigned Depth = 0,
491 void ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne,
496 OverflowResult computeOverflowForUnsignedMul(Value *LHS, Value *RHS,
500 OverflowResult computeOverflowForUnsignedAdd(Value *LHS, Value *RHS,
516 /// value, or null if it didn't simplify.
517 Value *SimplifyUsingDistributiveLaws(BinaryOperator &I);
519 /// \brief Attempts to replace V with a simpler value based on the demanded
521 Value *SimplifyDemandedUseBits(Value *V, APInt DemandedMask, APInt &KnownZero,
528 Value *SimplifyShrShlDemandedBits(Instruction *Lsr, Instruction *Sftl,
536 Value *SimplifyDemandedVectorElts(Value *V, APInt DemandedElts,
539 Value *SimplifyVectorOp(BinaryOperator &Inst);
540 Value *SimplifyBSwap(BinaryOperator &Inst);
560 Value *FoldLogicalPlusAnd(Value *LHS, Value *RHS, ConstantInt *Mask,
562 Value *InsertRangeTest(Value *V, Constant *Lo, Constant *Hi, bool isSigned,
570 Value *EvaluateInDifferentType(Value *V, Type *Ty, bool isSigned);
572 /// \brief Returns a value X such that Val = X * Scale, or null if none.
575 Value *Descale(Value *Val, APInt Scale, bool &NoSignedWrap);
