Lines Matching refs:Ops
609 static void GroupByComplexity(SmallVectorImpl<const SCEV *> &Ops,
611 if (Ops.size() < 2) return; // Noop
612 if (Ops.size() == 2) {
615 const SCEV *&LHS = Ops[0], *&RHS = Ops[1];
622 std::stable_sort(Ops.begin(), Ops.end(), SCEVComplexityCompare(LI));
628 for (unsigned i = 0, e = Ops.size(); i != e-2; ++i) {
629 const SCEV *S = Ops[i];
634 for (unsigned j = i+1; j != e && Ops[j]->getSCEVType() == Complexity; ++j) {
635 if (Ops[j] == S) { // Found a duplicate.
637 std::swap(Ops[i+1], Ops[j]);
1322 SmallVector<const SCEV *, 4> Ops;
1325 Ops.push_back(getAnyExtendExpr(*I, Ty));
1326 return getAddRecExpr(Ops, AR->getLoop(), SCEV::FlagNW);
1344 /// CollectAddOperandsWithScales - Process the given Ops list, which is
1373 const SCEV *const *Ops, size_t NumOperands,
1380 while (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[i])) {
1391 const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(Ops[i]);
1421 M.insert(std::make_pair(Ops[i], Scale));
1446 const SCEV *ScalarEvolution::getAddExpr(SmallVectorImpl<const SCEV *> &Ops,
1450 assert(!Ops.empty() && "Cannot get empty add!");
1451 if (Ops.size() == 1) return Ops[0];
1453 Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
1454 for (unsigned i = 1, e = Ops.size(); i != e; ++i)
1455 assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
1465 for (SmallVectorImpl<const SCEV *>::const_iterator I = Ops.begin(),
1466 E = Ops.end(); I != E; ++I)
1475 GroupByComplexity(Ops, LI);
1479 if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
1481 assert(Idx < Ops.size());
1482 while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
1484 Ops[0] = getConstant(LHSC->getValue()->getValue() +
1486 if (Ops.size() == 2) return Ops[0];
1487 Ops.erase(Ops.begin()+1); // Erase the folded element
1488 LHSC = cast<SCEVConstant>(Ops[0]);
1493 Ops.erase(Ops.begin());
1497 if (Ops.size() == 1) return Ops[0];
1503 Type *Ty = Ops[0]->getType();
1505 for (unsigned i = 0, e = Ops.size(); i != e-1; ++i)
1506 if (Ops[i] == Ops[i+1]) { // X + Y + Y --> X + Y*2
1509 while (i+Count != e && Ops[i+Count] == Ops[i])
1513 const SCEV *Mul = getMulExpr(Scale, Ops[i]);
1514 if (Ops.size() == Count)
1516 Ops[i] = Mul;
1517 Ops.erase(Ops.begin()+i+1, Ops.begin()+i+Count);
1522 return getAddExpr(Ops, Flags);
1528 for (; Idx < Ops.size() && isa<SCEVTruncateExpr>(Ops[Idx]); ++Idx) {
1529 const SCEVTruncateExpr *Trunc = cast<SCEVTruncateExpr>(Ops[Idx]);
1536 for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
1537 if (const SCEVTruncateExpr *T = dyn_cast<SCEVTruncateExpr>(Ops[i])) {
1543 } else if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[i])) {
1545 } else if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(Ops[i])) {
1580 while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddExpr)
1584 if (Idx < Ops.size()) {
1586 while (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Ops[Idx])) {
1589 Ops.erase(Ops.begin()+Idx);
1590 Ops.append(Add->op_begin(), Add->op_end());
1598 return getAddExpr(Ops);
1602 while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scMulExpr)
1607 if (Idx < Ops.size() && isa<SCEVMulExpr>(Ops[Idx])) {
1613 Ops.data(), Ops.size(),
1623 Ops.clear();
1625 Ops.push_back(getConstant(AccumulatedConstant));
1629 Ops.push_back(getMulExpr(getConstant(I->first),
1631 if (Ops.empty())
1633 if (Ops.size() == 1)
1634 return Ops[0];
1635 return getAddExpr(Ops);
1642 for (; Idx < Ops.size() && isa<SCEVMulExpr>(Ops[Idx]); ++Idx) {
1643 const SCEVMulExpr *Mul = cast<SCEVMulExpr>(Ops[Idx]);
1648 for (unsigned AddOp = 0, e = Ops.size(); AddOp != e; ++AddOp)
1649 if (MulOpSCEV == Ops[AddOp]) {
1663 if (Ops.size() == 2) return OuterMul;
1665 Ops.erase(Ops.begin()+AddOp);
1666 Ops.erase(Ops.begin()+Idx-1);
1668 Ops.erase(Ops.begin()+Idx);
1669 Ops.erase(Ops.begin()+AddOp-1);
1671 Ops.push_back(OuterMul);
1672 return getAddExpr(Ops);
1677 OtherMulIdx < Ops.size() && isa<SCEVMulExpr>(Ops[OtherMulIdx]);
1679 const SCEVMulExpr *OtherMul = cast<SCEVMulExpr>(Ops[OtherMulIdx]);
1702 if (Ops.size() == 2) return OuterMul;
1703 Ops.erase(Ops.begin()+Idx);
1704 Ops.erase(Ops.begin()+OtherMulIdx-1);
1705 Ops.push_back(OuterMul);
1706 return getAddExpr(Ops);
1715 while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddRecExpr)
1719 for (; Idx < Ops.size() && isa<SCEVAddRecExpr>(Ops[Idx]); ++Idx) {
1723 const SCEVAddRecExpr *AddRec = cast<SCEVAddRecExpr>(Ops[Idx]);
1725 for (unsigned i = 0, e = Ops.size(); i != e; ++i)
1726 if (isLoopInvariant(Ops[i], AddRecLoop)) {
1727 LIOps.push_back(Ops[i]);
1728 Ops.erase(Ops.begin()+i);
1748 if (Ops.size() == 1) return NewRec;
1752 if (Ops[i] == AddRec) {
1753 Ops[i] = NewRec;
1756 return getAddExpr(Ops);
1763 OtherIdx < Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);
1765 if (AddRecLoop == cast<SCEVAddRecExpr>(Ops[OtherIdx])->getLoop()) {
1769 for (; OtherIdx != Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);
1772 dyn_cast<SCEVAddRecExpr>(Ops[OtherIdx]))
1784 Ops.erase(Ops.begin() + OtherIdx); --OtherIdx;
1787 Ops[Idx] = getAddRecExpr(AddRecOps, AddRecLoop, SCEV::FlagAnyWrap);
1788 return getAddExpr(Ops);
1799 for (unsigned i = 0, e = Ops.size(); i != e; ++i)
1800 ID.AddPointer(Ops[i]);
1805 const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
1806 std::uninitialized_copy(Ops.begin(), Ops.end(), O);
1808 O, Ops.size());
1849 const SCEV *ScalarEvolution::getMulExpr(SmallVectorImpl<const SCEV *> &Ops,
1853 assert(!Ops.empty() && "Cannot get empty mul!");
1854 if (Ops.size() == 1) return Ops[0];
1856 Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
1857 for (unsigned i = 1, e = Ops.size(); i != e; ++i)
1858 assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
1868 for (SmallVectorImpl<const SCEV *>::const_iterator I = Ops.begin(),
1869 E = Ops.end(); I != E; ++I)
1878 GroupByComplexity(Ops, LI);
1882 if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
1885 if (Ops.size() == 2)
1886 if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Ops[1]))
1893 while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
1898 Ops[0] = getConstant(Fold);
1899 Ops.erase(Ops.begin()+1); // Erase the folded element
1900 if (Ops.size() == 1) return Ops[0];
1901 LHSC = cast<SCEVConstant>(Ops[0]);
1905 if (cast<SCEVConstant>(Ops[0])->getValue()->equalsInt(1)) {
1906 Ops.erase(Ops.begin());
1908 } else if (cast<SCEVConstant>(Ops[0])->getValue()->isZero()) {
1910 return Ops[0];
1911 } else if (Ops[0]->isAllOnesValue()) {
1914 if (Ops.size() == 2) {
1915 if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Ops[1])) {
1920 const SCEV *Mul = getMulExpr(Ops[0], *I);
1928 AddRec = dyn_cast<SCEVAddRecExpr>(Ops[1])) {
1933 Operands.push_back(getMulExpr(Ops[0], *I));
1941 if (Ops.size() == 1)
1942 return Ops[0];
1946 while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scMulExpr)
1950 if (Idx < Ops.size()) {
1952 while (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(Ops[Idx])) {
1955 Ops.erase(Ops.begin()+Idx);
1956 Ops.append(Mul->op_begin(), Mul->op_end());
1964 return getMulExpr(Ops);
1970 while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddRecExpr)
1974 for (; Idx < Ops.size() && isa<SCEVAddRecExpr>(Ops[Idx]); ++Idx) {
1978 const SCEVAddRecExpr *AddRec = cast<SCEVAddRecExpr>(Ops[Idx]);
1980 for (unsigned i = 0, e = Ops.size(); i != e; ++i)
1981 if (isLoopInvariant(Ops[i], AddRecLoop)) {
1982 LIOps.push_back(Ops[i]);
1983 Ops.erase(Ops.begin()+i);
2005 if (Ops.size() == 1) return NewRec;
2009 if (Ops[i] == AddRec) {
2010 Ops[i] = NewRec;
2013 return getMulExpr(Ops);
2020 OtherIdx < Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);
2022 if (AddRecLoop == cast<SCEVAddRecExpr>(Ops[OtherIdx])->getLoop()) {
2034 for (; OtherIdx != Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);
2037 dyn_cast<SCEVAddRecExpr>(Ops[OtherIdx]))
2070 if (Ops.size() == 2) return NewAddRec;
2071 Ops[Idx] = AddRec = cast<SCEVAddRecExpr>(NewAddRec);
2072 Ops.erase(Ops.begin() + OtherIdx); --OtherIdx;
2077 return getMulExpr(Ops);
2089 for (unsigned i = 0, e = Ops.size(); i != e; ++i)
2090 ID.AddPointer(Ops[i]);
2095 const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
2096 std::uninitialized_copy(Ops.begin(), Ops.end(), O);
2098 O, Ops.size());
2356 SmallVector<const SCEV *, 2> Ops;
2357 Ops.push_back(LHS);
2358 Ops.push_back(RHS);
2359 return getSMaxExpr(Ops);
2363 ScalarEvolution::getSMaxExpr(SmallVectorImpl<const SCEV *> &Ops) {
2364 assert(!Ops.empty() && "Cannot get empty smax!");
2365 if (Ops.size() == 1) return Ops[0];
2367 Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
2368 for (unsigned i = 1, e = Ops.size(); i != e; ++i)
2369 assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
2374 GroupByComplexity(Ops, LI);
2378 if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
2380 assert(Idx < Ops.size());
2381 while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
2386 Ops[0] = getConstant(Fold);
2387 Ops.erase(Ops.begin()+1); // Erase the folded element
2388 if (Ops.size() == 1) return Ops[0];
2389 LHSC = cast<SCEVConstant>(Ops[0]);
2393 if (cast<SCEVConstant>(Ops[0])->getValue()->isMinValue(true)) {
2394 Ops.erase(Ops.begin());
2396 } else if (cast<SCEVConstant>(Ops[0])->getValue()->isMaxValue(true)) {
2399 return Ops[0];
2402 if (Ops.size() == 1) return Ops[0];
2406 while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scSMaxExpr)
2411 if (Idx < Ops.size()) {
2413 while (const SCEVSMaxExpr *SMax = dyn_cast<SCEVSMaxExpr>(Ops[Idx])) {
2414 Ops.erase(Ops.begin()+Idx);
2415 Ops.append(SMax->op_begin(), SMax->op_end());
2420 return getSMaxExpr(Ops);
2426 for (unsigned i = 0, e = Ops.size()-1; i != e; ++i)
2429 if (Ops[i] == Ops[i+1] ||
2430 isKnownPredicate(ICmpInst::ICMP_SGE, Ops[i], Ops[i+1])) {
2431 Ops.erase(Ops.begin()+i+1, Ops.begin()+i+2);
2433 } else if (isKnownPredicate(ICmpInst::ICMP_SLE, Ops[i], Ops[i+1])) {
2434 Ops.erase(Ops.begin()+i, Ops.begin()+i+1);
2438 if (Ops.size() == 1) return Ops[0];
2440 assert(!Ops.empty() && "Reduced smax down to nothing!");
2446 for (unsigned i = 0, e = Ops.size(); i != e; ++i)
2447 ID.AddPointer(Ops[i]);
2450 const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
2451 std::uninitialized_copy(Ops.begin(), Ops.end(), O);
2453 O, Ops.size());
2460 SmallVector<const SCEV *, 2> Ops;
2461 Ops.push_back(LHS);
2462 Ops.push_back(RHS);
2463 return getUMaxExpr(Ops);
2467 ScalarEvolution::getUMaxExpr(SmallVectorImpl<const SCEV *> &Ops) {
2468 assert(!Ops.empty() && "Cannot get empty umax!");
2469 if (Ops.size() == 1) return Ops[0];
2471 Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
2472 for (unsigned i = 1, e = Ops.size(); i != e; ++i)
2473 assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
2478 GroupByComplexity(Ops, LI);
2482 if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
2484 assert(Idx < Ops.size());
2485 while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
2490 Ops[0] = getConstant(Fold);
2491 Ops.erase(Ops.begin()+1); // Erase the folded element
2492 if (Ops.size() == 1) return Ops[0];
2493 LHSC = cast<SCEVConstant>(Ops[0]);
2497 if (cast<SCEVConstant>(Ops[0])->getValue()->isMinValue(false)) {
2498 Ops.erase(Ops.begin());
2500 } else if (cast<SCEVConstant>(Ops[0])->getValue()->isMaxValue(false)) {
2503 return Ops[0];
2506 if (Ops.size() == 1) return Ops[0];
2510 while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scUMaxExpr)
2515 if (Idx < Ops.size()) {
2517 while (const SCEVUMaxExpr *UMax = dyn_cast<SCEVUMaxExpr>(Ops[Idx])) {
2518 Ops.erase(Ops.begin()+Idx);
2519 Ops.append(UMax->op_begin(), UMax->op_end());
2524 return getUMaxExpr(Ops);
2530 for (unsigned i = 0, e = Ops.size()-1; i != e; ++i)
2533 if (Ops[i] == Ops[i+1] ||
2534 isKnownPredicate(ICmpInst::ICMP_UGE, Ops[i], Ops[i+1])) {
2535 Ops.erase(Ops.begin()+i+1, Ops.begin()+i+2);
2537 } else if (isKnownPredicate(ICmpInst::ICMP_ULE, Ops[i], Ops[i+1])) {
2538 Ops.erase(Ops.begin()+i, Ops.begin()+i+1);
2542 if (Ops.size() == 1) return Ops[0];
2544 assert(!Ops.empty() && "Reduced umax down to nothing!");
2550 for (unsigned i = 0, e = Ops.size(); i != e; ++i)
2551 ID.AddPointer(Ops[i]);
2554 const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
2555 std::uninitialized_copy(Ops.begin(), Ops.end(), O);
2557 O, Ops.size());
3027 SmallVector<const SCEV *, 8> Ops;
3030 Ops.push_back(Add->getOperand(i));
3031 const SCEV *Accum = getAddExpr(Ops);