Lines Matching refs:Value
55 Value *getValue(Type *) const;
113 /// represented as <C, V>, where the V is a symbolic value, and C is a
120 Value *getSymVal() const { return Val; }
126 void set(short Coefficient, Value *V) { Coeff.set(Coefficient), Val = V; }
127 void set(const APFloat& Coefficient, Value *V)
129 void set(const ConstantFP* Coefficient, Value *V)
136 static unsigned drillValueDownOneStep(Value* V, FAddend &A0, FAddend &A1);
138 /// Similar to FAddend::drillDownOneStep() except that the value being
150 // This addend has the value of "Coeff * Val".
151 Value *Val;
161 Value *simplify(Instruction *FAdd);
166 Value *simplifyFAdd(AddendVect& V, unsigned InstrQuota);
168 Value *performFactorization(Instruction *I);
170 /// Convert given addend to a Value
171 Value *createAddendVal(const FAddend &A, bool& NeedNeg);
175 Value *createFSub(Value *Opnd0, Value *Opnd1);
176 Value *createFAdd(Value *Opnd0, Value *Opnd1);
177 Value *createFMul(Value *Opnd0, Value *Opnd1);
178 Value *createFDiv(Value *Opnd0, Value *Opnd1);
179 Value *createFNeg(Value *V);
180 Value *createNaryFAdd(const AddendVect& Opnds, unsigned InstrQuota);
307 assert(!insaneIntVal(Res) && "Insane int value");
335 Value *FAddendCoef::getValue(Type *Ty) const {
353 (Value *Val, FAddend &Addend0, FAddend &Addend1) {
362 Value *Opnd0 = I->getOperand(0);
363 Value *Opnd1 = I->getOperand(1);
396 Value *V0 = I->getOperand(0);
397 Value *V1 = I->getOperand(1);
441 Value *FAddCombine::performFactorization(Instruction *I) {
457 Value *Opnd0_0 = I0->getOperand(0);
458 Value *Opnd0_1 = I0->getOperand(1);
459 Value *Opnd1_0 = I1->getOperand(0);
460 Value *Opnd1_1 = I1->getOperand(1);
467 Value *Factor = nullptr;
468 Value *AddSub0 = nullptr, *AddSub1 = nullptr;
495 Value *NewAddSub = (I->getOpcode() == Instruction::FAdd) ?
506 Value *RI = createFMul(Factor, NewAddSub);
512 Value *RI = createFDiv(NewAddSub, Factor);
518 Value *FAddCombine::simplify(Instruction *I) {
559 Value *V0 = I->getOperand(0);
560 Value *V1 = I->getOperand(1);
564 if (Value *R = simplifyFAdd(AllOpnds, InstQuota))
585 if (Value *R = simplifyFAdd(AllOpnds, 1))
597 if (Value *R = simplifyFAdd(AllOpnds, 1))
605 Value *FAddCombine::simplifyFAdd(AddendVect& Addends, unsigned InstrQuota) {
624 // The outer loop works on one symbolic-value at a time. Suppose the input
636 Value *Val = ThisAddend->getSymVal();
640 // The inner loop collects addends sharing same symbolic-value, and these
642 // example, if the symbolic value "y" is being processed, the inner loop
657 // If multiple addends share same symbolic value, fold them together.
684 Value *Result;
695 Value *FAddCombine::createNaryFAdd
715 Value *LastVal = nullptr;
722 Value *V = createAddendVal(**I, NeedNeg);
754 Value *FAddCombine::createFSub(Value *Opnd0, Value *Opnd1) {
755 Value *V = Builder->CreateFSub(Opnd0, Opnd1);
761 Value *FAddCombine::createFNeg(Value *V) {
762 Value *Zero = cast<Value>(ConstantFP::getZeroValueForNegation(V->getType()));
763 Value *NewV = createFSub(Zero, V);
769 Value *FAddCombine::createFAdd(Value *Opnd0, Value *Opnd1) {
770 Value *V = Builder->CreateFAdd(Opnd0, Opnd1);
776 Value *FAddCombine::createFMul(Value *Opnd0, Value *Opnd1) {
777 Value *V = Builder->CreateFMul(Opnd0, Opnd1);
783 Value *FAddCombine::createFDiv(Value *Opnd0, Value *Opnd1) {
784 Value *V = Builder->CreateFDiv(Opnd0, Opnd1);
821 // Let the addend be "c * x". If "c == +/-1", the value of the addend
823 // to evaluate the value.
832 // Input Addend Value NeedNeg(output)
840 Value *FAddCombine::createAddendVal(const FAddend &Opnd, bool &NeedNeg) {
848 Value *OpndVal = Opnd.getSymVal();
893 bool InstCombiner::WillNotOverflowSignedAdd(Value *LHS, Value *RHS,
945 bool InstCombiner::WillNotOverflowSignedSub(Value *LHS, Value *RHS,
974 bool InstCombiner::WillNotOverflowUnsignedSub(Value *LHS, Value *RHS,
994 static Value *checkForNegativeOperand(BinaryOperator &I,
996 Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
1003 Value *X = nullptr, *Y = nullptr, *Z = nullptr;
1019 Value *NewAnd = Builder->CreateAnd(Z, *C1);
1024 Value *NewOr = Builder->CreateOr(Z, ~(*C1));
1044 Value *NewOr = Builder->CreateOr(Z, ~(*C2));
1052 Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
1054 if (Value *V = SimplifyVectorOp(I))
1057 if (Value *V = SimplifyAddInst(LHS, RHS, I.hasNoSignedWrap(),
1062 if (Value *V = SimplifyUsingDistributiveLaws(I))
1081 Value *XorLHS = nullptr; ConstantInt *XorRHS = nullptr;
1103 Value *NewShl = Builder->CreateShl(XorLHS, ShAmt, "sext");
1144 if (Value *LHSV = dyn_castNegVal(LHS)) {
1146 if (Value *RHSV = dyn_castNegVal(RHS)) {
1147 Value *NewAdd = Builder->CreateAdd(LHSV, RHSV, "sum");
1156 if (Value *V = dyn_castNegVal(RHS))
1159 if (Value *V = checkForNegativeOperand(I, Builder))
1167 Value *X;
1174 Value *X;
1191 Value *NewAdd = Builder->CreateAdd(X, CRHS, LHS->getName());
1205 Value *A = RHS;
1211 Value *TV = SI->getTrueValue();
1212 Value *FV = SI->getFalseValue();
1213 Value *N;
1218 // Fold the add into the true select value.
1222 // Fold the add into the false select value.
1238 Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0),
1255 Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0),
1264 Value *A = nullptr, *B = nullptr;
1278 Value *A = nullptr, *B = nullptr;
1317 Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
1319 if (Value *V = SimplifyVectorOp(I))
1322 if (Value *V =
1338 if (Value *LHSV = dyn_castFNegVal(LHS)) {
1346 if (Value *V = dyn_castFNegVal(RHS)) {
1356 // ... if the constant fits in the integer value. This is useful for things
1367 Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0),
1384 Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0),
1393 Value *A1, *B1, *C1, *A2, *B2, *C2;
1398 Value *A, *B, *C=C1;
1417 if (Value *V = FAddCombine(Builder).simplify(&I))
1428 Value *InstCombiner::OptimizePointerDifference(Value *LHS, Value *RHS,
1476 Value *Result = EmitGEPOffset(GEP1);
1481 Value *Offset = EmitGEPOffset(GEP2);
1493 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1495 if (Value *V = SimplifyVectorOp(I))
1498 if (Value *V = SimplifySubInst(Op0, Op1, I.hasNoSignedWrap(),
1503 if (Value *V = SimplifyUsingDistributiveLaws(I))
1507 if (Value *V = dyn_castNegVal(Op1)) {
1532 Value *X = nullptr;
1564 Value *X;
1592 Value *Y;
1605 Value *A = nullptr, *B = nullptr;
1613 Value *Y = nullptr;
1622 Value *X = nullptr, *Y = nullptr, *Z = nullptr;
1645 if (Value *XNeg = dyn_castNegVal(X))
1650 Value *A, *B;
1659 Value *NewMul = Builder->CreateMul(A, ConstantExpr::getNeg(CI));
1666 Value *LHSOp, *RHSOp;
1669 if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType()))
1675 if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType()))
1692 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1694 if (Value *V = SimplifyVectorOp(I))
1697 if (Value *V =
1716 if (Value *V = dyn_castFNegVal(Op1)) {
1722 if (Value *V = dyn_castFNegVal(FPTI->getOperand(0))) {
1723 Value *NewTrunc = Builder->CreateFPTrunc(V, I.getType());
1729 if (Value *V = dyn_castFNegVal(FPEI->getOperand(0))) {
1730 Value *NewExt = Builder->CreateFPExt(V, I.getType());
1738 if (Value *V = FAddCombine(Builder).simplify(&I))
