Lines Matching defs:Operands
523 // Compare the number of operands.
848 SmallVector<const SCEV *, 4> Operands;
853 Operands.push_back(S);
856 return getAddExpr(Operands);
863 SmallVector<const SCEV *, 4> Operands;
868 Operands.push_back(S);
871 return getMulExpr(Operands);
875 // If the input value is a chrec scev, truncate the chrec's operands.
877 Operands;
879 Operands.push_back(getTruncateExpr(AddRec->getOperand(i), Ty));
880 return getAddRecExpr(Operands, AddRec->getLoop(), SCEV::FlagAnyWrap);
933 // operands (often constants). This allows analysis of something like
1199 // operands (often constants). This allows analysis of something like
1333 // Force the cast to be folded into the operands of an addrec.
1351 /// a list of operands to be added under the given scale, update the given
1353 /// what it does, given a sequence of operands that would form an add
1384 // Iterate over the add operands. They are sorted, with constants first.
1465 // If FlagNSW is true and all the operands are non-negative, infer FlagNUW.
1513 // Scan ahead to count how many equal operands there are.
1530 // Check for truncates. If all the operands are truncated from the same
1540 // Check all the operands to see if they can be represented in the
1589 // If there are add operands they would be next.
1593 // If we have an add, expand the add operands onto the end of the operands
1600 // If we deleted at least one add, we added operands to the end of the list,
1602 // any operands we just acquired.
1612 // operands multiplied by constant values.
1622 // re-generate the operands list. Group the operands by constant scale,
1628 // Re-generate the operands list.
1659 // If the multiply has more than two operands, we must get the
1718 // If there are any add recurrences in the operands list, see if any other
1726 // Scan all of the other operands to this add and add them to the vector if
1753 // If all of the other operands were loop invariant, we are done.
1868 // If FlagNSW is true and all the operands are non-negative, infer FlagNUW.
1919 // add operands.
1936 SmallVector<const SCEV *, 4> Operands;
1939 Operands.push_back(getMulExpr(Ops[0], *I));
1941 return getAddRecExpr(Operands, AddRec->getLoop(),
1955 // If there are mul operands inline them all into this expression.
1959 // If we have an mul, expand the mul operands onto the end of the operands
1966 // If we deleted at least one mul, we added operands to the end of the list,
1968 // any operands we just acquired.
1973 // If there are any add recurrences in the operands list, see if any other
1981 // Scan all of the other operands to this mul and add them to the vector if
2010 // If all of the other operands were loop invariant, we are done.
2130 // Determine if the division can be folded into the operands of
2131 // its operands.
2153 SmallVector<const SCEV *, 4> Operands;
2155 Operands.push_back(getUDivExpr(AR->getOperand(i), RHS));
2156 return getAddRecExpr(Operands, AR->getLoop(),
2177 SmallVector<const SCEV *, 4> Operands;
2179 Operands.push_back(getZeroExtendExpr(M->getOperand(i), ExtTy));
2180 if (getZeroExtendExpr(M, ExtTy) == getMulExpr(Operands))
2186 Operands = SmallVector<const SCEV *, 4>(M->op_begin(),
2188 Operands[i] = Div;
2189 return getMulExpr(Operands);
2195 SmallVector<const SCEV *, 4> Operands;
2197 Operands.push_back(getZeroExtendExpr(A->getOperand(i), ExtTy));
2198 if (getZeroExtendExpr(A, ExtTy) == getAddExpr(Operands)) {
2199 Operands.clear();
2205 Operands.push_back(Op);
2207 if (Operands.size() == A->getNumOperands())
2208 return getAddExpr(Operands);
2212 // Fold if both operands are constant.
2240 SmallVector<const SCEV *, 4> Operands;
2241 Operands.push_back(Start);
2244 Operands.append(StepChrec->op_begin(), StepChrec->op_end());
2245 return getAddRecExpr(Operands, L, maskFlags(Flags, SCEV::FlagNW));
2248 Operands.push_back(Step);
2249 return getAddRecExpr(Operands, L, Flags);
2255 ScalarEvolution::getAddRecExpr(SmallVectorImpl<const SCEV *> &Operands,
2257 if (Operands.size() == 1) return Operands[0];
2259 Type *ETy = getEffectiveSCEVType(Operands[0]->getType());
2260 for (unsigned i = 1, e = Operands.size(); i != e; ++i)
2261 assert(getEffectiveSCEVType(Operands[i]->getType()) == ETy &&
2263 for (unsigned i = 0, e = Operands.size(); i != e; ++i)
2264 assert(isLoopInvariant(Operands[i], L) &&
2268 if (Operands.back()->isZero()) {
2269 Operands.pop_back();
2270 return getAddRecExpr(Operands, L, SCEV::FlagAnyWrap); // {X,+,0} --> X
2279 // If FlagNSW is true and all the operands are non-negative, infer FlagNUW.
2285 for (SmallVectorImpl<const SCEV *>::const_iterator I = Operands.begin(),
2286 E = Operands.end(); I != E; ++I)
2295 if (const SCEVAddRecExpr *NestedAR = dyn_cast<SCEVAddRecExpr>(Operands[0])) {
2303 Operands[0] = NestedAR->getStart();
2304 // AddRecs require their operands be loop-invariant with respect to their
2308 for (unsigned i = 0, e = Operands.size(); i != e; ++i)
2309 if (!isLoopInvariant(Operands[i], L)) {
2321 NestedOperands[0] = getAddRecExpr(Operands, L, OuterFlags);
2338 // Reset Operands to its original state.
2339 Operands[0] = NestedAR;
2347 for (unsigned i = 0, e = Operands.size(); i != e; ++i)
2348 ID.AddPointer(Operands[i]);
2354 const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Operands.size());
2355 std::uninitialized_copy(Operands.begin(), Operands.end(), O);
2357 O, Operands.size(), L);
2419 // Check to see if one of the operands is an SMax. If so, expand its operands
2523 // Check to see if one of the operands is a UMax. If so, expand its operands
2865 /// getUMaxFromMismatchedTypes - Promote the operands to the wider of
2881 /// getUMinFromMismatchedTypes - Promote the operands to the wider of
2897 /// getPointerBase - Transitively follow the chain of pointer-type operands
2914 // Cannot find the base of an expression with multiple pointer operands.
3210 // The result is the min of all operands results.
3218 // The result is the sum of all operands results.
3229 // The result is the min of all operands results.
3237 // The result is the min of all operands results.
3245 // The result is the min of all operands results.
3481 // If there's no signed wrap, and all the operands have the same sign or
3589 // The simple thing to do would be to just call getSCEV on both operands
3592 // because it leads to N-1 getAddExpr calls for N ultimate operands.
3593 // Instead, gather up all the operands and make a single getAddExpr call.
3594 // LLVM IR canonical form means we need only traverse the left operands.
4371 operands of the and.
4403 // Recurse on the operands of the or.
4498 // Simplify the operands before analyzing them.
4660 /// specified type, assuming that all operands were constants.
4674 /// assuming its operands can all constant evolve.
4688 // If we won't be able to constant fold this expression even if the operands
4699 // Otherwise, we can evaluate this instruction if all of its operands are
4732 /// way, but the operands of an operation must either be constants or a value
4772 std::vector<Constant*> Operands(I->getNumOperands());
4777 Operands[i] = dyn_cast<Constant>(I->getOperand(i));
4778 if (!Operands[i]) return 0;
4784 Operands[i] = C;
4788 return ConstantFoldCompareInstOperands(CI->getPredicate(), Operands[0],
4789 Operands[1], TD, TLI);
4792 return ConstantFoldLoadFromConstPtr(Operands[0], TD);
4794 return ConstantFoldInstOperands(I->getOpcode(), I->getType(), Operands, TD,
5120 SmallVector<Constant *, 4> Operands;
5125 Operands.push_back(C);
5129 // If any of the operands is non-constant and if they are
5146 Operands.push_back(C);
5154 Operands[0], Operands[1], TD,
5158 C = ConstantFoldLoadFromConstPtr(Operands[0], TD);
5161 Operands, TD, TLI);
5178 // Okay, at least one of these operands is loop variant but might be
5199 // If we got here, all operands are loop invariant.
5222 // Okay, at least one of these operands is loop variant but might be
5614 // Check for both operands constant.
5623 // Otherwise swap the operands to put the constant on the right.
5631 // as both operands could be addrecs loop-invariant in each other's loop.
5800 // adding or subtracting 1 from one of the operands.
6106 // Bail if the ICmp's operands' types are wider than the needed type
6417 SmallVector<const SCEV *, 4> Operands(op_begin(), op_end());
6418 Operands[0] = SE.getConstant(SC->getType(), 0);
6419 const SCEV *Shifted = SE.getAddRecExpr(Operands, getLoop(),
6762 // This recurrence is variant w.r.t. L if any of its operands
