reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

lib/Analysis/DependenceAnalysis.cpp

  478     const SCEV *Prod1 = SE->getMulExpr(X->getA(), Y->getB());
  479     const SCEV *Prod2 = SE->getMulExpr(X->getB(), Y->getA());
  483       Prod1 = SE->getMulExpr(X->getC(), Y->getB());
  484       Prod2 = SE->getMulExpr(X->getB(), Y->getC());
  497       const SCEV *C1B2 = SE->getMulExpr(X->getC(), Y->getB());
  498       const SCEV *C1A2 = SE->getMulExpr(X->getC(), Y->getA());
  499       const SCEV *C2B1 = SE->getMulExpr(Y->getC(), X->getB());
  500       const SCEV *C2A1 = SE->getMulExpr(Y->getC(), X->getA());
  501       const SCEV *A1B2 = SE->getMulExpr(X->getA(), Y->getB());
  502       const SCEV *A2B1 = SE->getMulExpr(Y->getA(), X->getB());
  563     const SCEV *A1X1 = SE->getMulExpr(Y->getA(), X->getX());
  564     const SCEV *B1Y1 = SE->getMulExpr(Y->getB(), X->getY());
 1173     const SCEV *Product = SE->getMulExpr(UpperBound, AbsCoeff);
 1324       SE->getMulExpr(SE->getConstant(Delta->getType(), 2), ConstCoeff));
 1347     const SCEV *ML = SE->getMulExpr(SE->getMulExpr(ConstCoeff, UpperBound),
 1347     const SCEV *ML = SE->getMulExpr(SE->getMulExpr(ConstCoeff, UpperBound),
 1744     const SCEV *Product = SE->getMulExpr(AbsCoeff, UpperBound);
 1853     const SCEV *Product = SE->getMulExpr(AbsCoeff, UpperBound);
 2062         const SCEV *A1N1 = SE->getMulExpr(A1, N1);
 2071         const SCEV *A2N2 = SE->getMulExpr(A2, N2);
 2083         const SCEV *A1N1 = SE->getMulExpr(A1, N1);
 2084         const SCEV *A2N2 = SE->getMulExpr(A2, N2);
 2104         const SCEV *A1N1 = SE->getMulExpr(A1, N1);
 2105         const SCEV *A2N2 = SE->getMulExpr(A2, N2);
 2123         const SCEV *A1N1 = SE->getMulExpr(A1, N1);
 2132         const SCEV *A2N2 = SE->getMulExpr(A2, N2);
 2751       SE->getMulExpr(SE->getMinusSCEV(A[K].NegPart, B[K].PosPart),
 2754       SE->getMulExpr(SE->getMinusSCEV(A[K].PosPart, B[K].NegPart),
 2792       SE->getMulExpr(NegativePart, Bound[K].Iterations);
 2795       SE->getMulExpr(PositivePart, Bound[K].Iterations);
 2834       SE->getMinusSCEV(SE->getMulExpr(NegPart, Iter_1), B[K].Coeff);
 2838       SE->getMinusSCEV(SE->getMulExpr(PosPart, Iter_1), B[K].Coeff);
 2878       SE->getAddExpr(SE->getMulExpr(NegPart, Iter_1), A[K].Coeff);
 2882       SE->getAddExpr(SE->getMulExpr(PosPart, Iter_1), A[K].Coeff);
 3099   const SCEV *DA_K = SE->getMulExpr(A_K, CurConstraint.getD());
 3138     Src = SE->getMinusSCEV(Src, SE->getMulExpr(AP_K, SE->getConstant(CdivB)));
 3152     Src = SE->getAddExpr(Src, SE->getMulExpr(A_K, SE->getConstant(CdivA)));
 3166     Src = SE->getAddExpr(Src, SE->getMulExpr(A_K, SE->getConstant(CdivA)));
 3175     Src = SE->getMulExpr(Src, A);
 3176     Dst = SE->getMulExpr(Dst, A);
 3177     Src = SE->getAddExpr(Src, SE->getMulExpr(A_K, C));
 3179     Dst = addToCoefficient(Dst, CurLoop, SE->getMulExpr(A_K, B));
 3197   const SCEV *XA_K = SE->getMulExpr(A_K, CurConstraint.getX());
 3198   const SCEV *YAP_K = SE->getMulExpr(AP_K, CurConstraint.getY());

lib/Analysis/LoopAccessAnalysis.cpp

 1374   const SCEV *Product = SE.getMulExpr(&BackedgeTakenCount, Step);

lib/Analysis/LoopCacheAnalysis.cpp

  284     const SCEV *Stride = SE.getMulExpr(Coeff, ElemSize);
  286     const SCEV *Numerator = SE.getMulExpr(Stride, TripCount);
  392   const SCEV *Stride = SE.getMulExpr(Coeff, ElemSize);

lib/Analysis/ScalarEvolution.cpp

 1213     Dividend = SE.getMulExpr(Dividend,
 1222   return SE.getMulExpr(SE.getConstant(MultiplyFactor),
 1245     Result = SE.getAddExpr(Result, SE.getMulExpr(getOperand(i), Coeff));
 1728           const SCEV *ZMul = getMulExpr(CastedMaxBECount, Step,
 1739                        getMulExpr(WideMaxBECount,
 1757                        getMulExpr(WideMaxBECount,
 1925             return getMulExpr(
 2072           const SCEV *SMul = getMulExpr(CastedMaxBECount, Step,
 2083                        getMulExpr(WideMaxBECount,
 2101                        getMulExpr(WideMaxBECount,
 2464       const SCEV *Mul = getMulExpr(Scale, Ops[i], SCEV::FlagAnyWrap, Depth + 1);
 2597           Ops.push_back(getMulExpr(
 2632           const SCEV *OuterMul = getMulExpr(AddOne, MulOpSCEV,
 2674             const SCEV *OuterMul = getMulExpr(MulOpSCEV, InnerMulSum,
 2944           return getAddExpr(getMulExpr(LHSC, Add->getOperand(0),
 2946                             getMulExpr(LHSC, Add->getOperand(1),
 2976             const SCEV *Mul = getMulExpr(Ops[0], AddOp, SCEV::FlagAnyWrap,
 2987             Operands.push_back(getMulExpr(Ops[0], AddRecOp, SCEV::FlagAnyWrap,
 3051         NewOps.push_back(getMulExpr(Scale, AddRec->getOperand(i),
 3181   const SCEV *Mult = getMulExpr(UDiv, RHS, SCEV::FlagNUW);
 3254             if (!isa<SCEVUDivExpr>(Div) && getMulExpr(Div, RHSC) == Op) {
 3287                 getMulExpr(Op, RHS) != A->getOperand(i))
 3526       const SCEV *LocalOffset = getMulExpr(IndexExpr, ElementSize, Wrap);
 3954   return getMulExpr(
 6220                 getMulExpr(getSCEV(BO->LHS), getSCEV(BO->RHS), Flags));
 6288           return getMulExpr(
 6387         return getMulExpr(getSCEV(BO->LHS), getSCEV(X), Flags);
 6436                 getMulExpr(getTruncateExpr(ShlOp0SCEV, TruncTy),
 8429   return SE.getUDivExactExpr(SE.getMulExpr(B, SE.getConstant(I)), D);

lib/Analysis/ScalarEvolutionExpander.cpp

 1609         SE.getMulExpr(SE.getUnknown(CanonicalIV),

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

 2150     NumBytesS = SE->getMulExpr(NumBytesS, SE->getConstant(IntPtrTy, StoreSize),

lib/Transforms/Scalar/IndVarSimplify.cpp

 1190       WideUse = SE->getMulExpr(WideLHS, WideRHS);
 1244     return SE->getMulExpr(LHS, RHS);

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

 1686   const SCEV *Begin = SE.getMulExpr(ClampedSubtract(Zero, M), EndIsNonNegative);
 1687   const SCEV *End = SE.getMulExpr(ClampedSubtract(REnd, M), EndIsNonNegative);

lib/Transforms/Scalar/LoopDataPrefetch.cpp

  300       const SCEV *NextLSCEV = SE->getAddExpr(LSCEVAddRec, SE->getMulExpr(

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

  898     Index = SE->getMulExpr(Index, SE->getConstant(IntPtr, StoreSize),
  932     NumBytesS = SE->getMulExpr(NumBytesS, SE->getConstant(IntPtr, StoreSize),
 2193   NBytes = SE->getMulExpr(

lib/Transforms/Scalar/LoopRerollPass.cpp

  899   if (ADR->getStepRecurrence(*SE) != SE->getMulExpr(StepSCEV, ScaleSCEV))
 1464     auto ScaledTripCount = SE->getMulExpr(

lib/Transforms/Scalar/LoopStrengthReduce.cpp

  430         Good.push_back(SE.getMulExpr(NegOne, S));
  432         Bad.push_back(SE.getMulExpr(NegOne, S));
  672       return SE.getMulExpr(LHS, RC);
 3499         Ops.push_back(C ? SE.getMulExpr(C, Remainder) : Remainder);
 3512       Ops.push_back(C ? SE.getMulExpr(C, Remainder) : Remainder);
 3530       C = C ? cast<SCEVConstant>(SE.getMulExpr(C, Op0)) : Op0;
 3534         Ops.push_back(SE.getMulExpr(C, Remainder));
 3923       F.BaseRegs[i] = SE.getMulExpr(F.BaseRegs[i], FactorS);
 3930       F.ScaledReg = SE.getMulExpr(F.ScaledReg, FactorS);
 5205             SE.getMulExpr(ScaledS, SE.getConstant(ScaledS->getType(), F.Scale));

lib/Transforms/Scalar/NaryReassociate.cpp

  516     return SE->getMulExpr(LHS, RHS);

lib/Transforms/Utils/SimplifyIndVar.cpp

  148         SE->getSCEV(IVSrc) != SE->getMulExpr(FoldedExpr, SE->getSCEV(D)))
  419     Operation = &ScalarEvolution::getMulExpr;

tools/polly/lib/Analysis/ScopBuilder.cpp

 2346   auto *MulSCEV = SE.getMulExpr(UDivSCEV, SizeSCEV);
 2440         Size = SE.getMulExpr(Size, SE.getConstant(Size->getType(), Int[0]));

tools/polly/lib/Support/SCEVValidator.cpp

  765       ConstPart = cast<SCEVConstant>(SE.getMulExpr(ConstPart, Op));

unittests/Analysis/ScalarEvolutionTest.cpp

  300     EXPECT_EQ(SE.getMulExpr(A, B), SE.getMulExpr(B, A));
  300     EXPECT_EQ(SE.getMulExpr(A, B), SE.getMulExpr(B, A));
  301     EXPECT_EQ(SE.getMulExpr(B, C), SE.getMulExpr(C, B));
  301     EXPECT_EQ(SE.getMulExpr(B, C), SE.getMulExpr(C, B));
  302     EXPECT_EQ(SE.getMulExpr(A, C), SE.getMulExpr(C, A));
  302     EXPECT_EQ(SE.getMulExpr(A, C), SE.getMulExpr(C, A));