Lines Matching refs:SE
79 assert(SE.DT->dominates(Ret, BIP));
94 assert(SE.getTypeSizeInBits(V->getType()) == SE.getTypeSizeInBits(Ty) &&
108 SE.getTypeSizeInBits(Ty) == SE.getTypeSizeInBits(V->getType())) {
112 SE.getTypeSizeInBits(CI->getType()) ==
113 SE.getTypeSizeInBits(CI->getOperand(0)->getType()))
118 SE.getTypeSizeInBits(CE->getType()) ==
119 SE.getTypeSizeInBits(CE->getOperand(0)->getType()))
183 while (const Loop *L = SE.LI->getLoopFor(Builder.GetInsertBlock())) {
214 ScalarEvolution &SE,
222 S = SE.getConstant(S->getType(), 1);
234 ConstantInt::get(SE.getContext(),
241 const SCEV *Div = SE.getConstant(CI);
244 SE.getAddExpr(Remainder,
245 SE.getConstant(C->getValue()->getValue().srem(
264 SE.getConstant(C->getValue()->getValue().sdiv(
266 S = SE.getMulExpr(NewMulOps);
274 const SCEV *Remainder = SE.getConstant(SOp->getType(), 0);
275 if (FactorOutConstant(SOp, Remainder, Factor, SE, TD) &&
279 S = SE.getMulExpr(NewMulOps);
288 const SCEV *Step = A->getStepRecurrence(SE);
289 const SCEV *StepRem = SE.getConstant(Step->getType(), 0);
290 if (!FactorOutConstant(Step, StepRem, Factor, SE, TD))
295 if (!FactorOutConstant(Start, Remainder, Factor, SE, TD))
298 S = SE.getAddRecExpr(Start, Step, A->getLoop(), SCEV::FlagAnyWrap);
311 ScalarEvolution &SE) {
320 SE.getConstant(Ty, 0) :
321 SE.getAddExpr(NoAddRecs);
340 ScalarEvolution &SE) {
347 const SCEV *Zero = SE.getConstant(Ty, 0);
348 AddRecs.push_back(SE.getAddRecExpr(Zero,
349 A->getStepRecurrence(SE),
365 SimplifyAddOperands(Ops, Ty, SE);
408 SplitAddRecs(Ops, Ty, SE);
420 const SCEV *ElSize = SE.getSizeOfExpr(ElTy);
425 const SCEV *Remainder = SE.getConstant(Ty, 0);
426 if (FactorOutConstant(Op, Remainder, ElSize, SE, SE.TD)) {
441 SimplifyAddOperands(Ops, Ty, SE);
452 expandCodeFor(SE.getAddExpr(ScaledOps), Ty);
460 if (SE.TD) {
465 if (SE.getTypeSizeInBits(C->getType()) <= 64) {
466 const StructLayout &SL = *SE.TD->getStructLayout(STy);
474 SE.getConstant(Ty, FullOffset - SL.getElementOffset(ElIdx));
490 Ops[i] = SE.getConstant(Ty, 0);
522 SE.DT->dominates(cast<Instruction>(V), Builder.GetInsertPoint()));
525 Value *Idx = expandCodeFor(SE.getAddExpr(Ops), Ty);
556 while (const Loop *L = SE.LI->getLoopFor(Builder.GetInsertBlock())) {
581 while (const Loop *L = SE.LI->getLoopFor(Builder.GetInsertBlock())) {
610 Ops.push_back(SE.getUnknown(GEP));
617 return expand(SE.getAddExpr(Ops));
648 return Pair.first->second = SE.LI->getLoopFor(I->getParent());
658 L = PickMostRelevantLoop(L, getRelevantLoop(*I), *SE.DT);
669 *SE.DT);
711 Type *Ty = SE.getEffectiveSCEVType(S->getType());
724 std::stable_sort(OpsAndLoops.begin(), OpsAndLoops.end(), LoopCompare(*SE.DT));
747 X = SE.getSCEV(U->getValue());
756 NewOps.push_back(isa<Instruction>(Sum) ? SE.getUnknown(Sum) :
757 SE.getSCEV(Sum));
763 Value *W = expandCodeFor(SE.getNegativeSCEV(Op), Ty);
782 Type *Ty = SE.getEffectiveSCEVType(S->getType());
792 std::stable_sort(OpsAndLoops.begin(), OpsAndLoops.end(), LoopCompare(*SE.DT));
824 Type *Ty = SE.getEffectiveSCEVType(S->getType());
842 ScalarEvolution &SE) {
845 Rest = SE.getAddExpr(Rest,
846 SE.getAddRecExpr(SE.getConstant(A->getType(), 0),
847 A->getStepRecurrence(SE),
856 Rest = SE.getAddExpr(NewAddOps);
857 ExposePointerBase(Base, Rest, SE);
875 if (!SE.DT->dominates(OInst, IVIncInsertPos))
914 if (!OInst || SE.DT->dominates(OInst, InsertPos))
926 if (!SE.DT->dominates(OInst, InsertPos))
940 if (IncV->getType() != Type::getInt1PtrTy(SE.getContext(), AS)
941 && IncV->getType() != Type::getInt8PtrTy(SE.getContext(), AS))
953 if (SE.DT->dominates(IncV, InsertPos))
959 || !SE.DT->dominates(InsertPos->getParent(), IncV->getParent()))
971 if (SE.DT->dominates(IncV, InsertPos))
1010 GEPPtrTy = PointerType::get(Type::getInt1Ty(SE.getContext()),
1012 const SCEV *const StepArray[1] = { SE.getSCEV(StepV) };
1042 if (!SE.isSCEVable(PN->getType()) ||
1043 (SE.getEffectiveSCEVType(PN->getType()) !=
1044 SE.getEffectiveSCEVType(Normalized->getType())) ||
1045 SE.getSCEV(PN) != Normalized)
1062 if (SE.DT->dominates(IncV, IVIncInsertPos))
1100 SE.DT->properlyDominates(cast<Instruction>(StartV)->getParent(),
1105 const SCEV *Step = Normalized->getStepRecurrence(SE);
1111 Step = SE.getNegativeSCEV(Step);
1160 Type *IntTy = SE.getEffectiveSCEVType(STy);
1171 Loops, SE, *SE.DT));
1177 if (!SE.properlyDominates(Start, L->getHeader())) {
1179 Start = SE.getConstant(Normalized->getType(), 0);
1181 SE.getAddRecExpr(Start, Normalized->getStepRecurrence(SE),
1188 const SCEV *Step = Normalized->getStepRecurrence(SE);
1190 if (!SE.dominates(Step, L->getHeader())) {
1192 Step = SE.getConstant(Normalized->getType(), 1);
1194 cast<SCEVAddRecExpr>(SE.getAddRecExpr(Start, Step,
1220 SE.DT->dominates(cast<Instruction>(Result),
1234 Step = SE.getNegativeSCEV(Step);
1273 Type *Ty = SE.getEffectiveSCEVType(S->getType());
1279 if (SE.getTypeSizeInBits(PN->getType()) >= SE.getTypeSizeInBits(Ty))
1285 SE.getTypeSizeInBits(CanonicalIV->getType()) >
1286 SE.getTypeSizeInBits(Ty)) {
1289 NewOps[i] = SE.getAnyExtendExpr(S->op_begin()[i], CanonicalIV->getType());
1290 Value *V = expand(SE.getAddRecExpr(NewOps, S->getLoop(),
1300 V = expandCodeFor(SE.getTruncateExpr(SE.getUnknown(V), Ty), 0,
1309 NewOps[0] = SE.getConstant(Ty, 0);
1311 const SCEV *Rest = SE.getAddRecExpr(NewOps, L, SCEV::FlagAnyWrap);
1318 ExposePointerBase(Base, RestArray[0], SE);
1332 return expand(SE.getAddExpr(SE.getUnknown(expand(S->getStart())),
1333 SE.getUnknown(expand(Rest))));
1366 assert(Ty == SE.getEffectiveSCEVType(CanonicalIV->getType()) &&
1377 expand(SE.getTruncateOrNoop(
1378 SE.getMulExpr(SE.getUnknown(CanonicalIV),
1379 SE.getNoopOrAnyExtend(S->getOperand(1),
1387 const SCEV *IH = SE.getUnknown(CanonicalIV); // Get I as a "symbolic" SCEV.
1391 const SCEV *Ext = SE.getNoopOrAnyExtend(S, CanonicalIV->getType());
1395 const SCEV *V = cast<SCEVAddRecExpr>(NewS)->evaluateAtIteration(IH, SE);
1399 const SCEV *T = SE.getTruncateOrNoop(V, Ty);
1404 Type *Ty = SE.getEffectiveSCEVType(S->getType());
1406 SE.getEffectiveSCEVType(S->getOperand()->getType()));
1413 Type *Ty = SE.getEffectiveSCEVType(S->getType());
1415 SE.getEffectiveSCEVType(S->getOperand()->getType()));
1422 Type *Ty = SE.getEffectiveSCEVType(S->getType());
1424 SE.getEffectiveSCEVType(S->getOperand()->getType()));
1437 Ty = SE.getEffectiveSCEVType(Ty);
1461 Ty = SE.getEffectiveSCEVType(Ty);
1488 assert(SE.getTypeSizeInBits(Ty) == SE.getTypeSizeInBits(SH->getType()) &&
1499 for (Loop *L = SE.LI->getLoopFor(Builder.GetInsertBlock()); ;
1501 if (SE.isLoopInvariant(S, L)) {
1515 if (L && SE.hasComputableLoopEvolution(S, L) && !PostIncLoops.count(L))
1572 const SCEV *H = SE.getAddRecExpr(SE.getConstant(Ty, 0),
1573 SE.getConstant(Ty, 1), L, SCEV::FlagAnyWrap);
1631 if (!SE.isSCEVable(Phi->getType()))
1634 PHINode *&OrigPhiRef = ExprToIVMap[SE.getSCEV(Phi)];
1642 SE.getTruncateExpr(SE.getSCEV(Phi), Phis.back()->getType());
1676 const SCEV *TruncExpr = SE.getTruncateOrNoop(SE.getSCEV(OrigInc),
1679 && TruncExpr == SE.getSCEV(IsomorphicInc)
