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

Declarations

include/llvm/Analysis/ScalarEvolution.h

  514   const SCEV *getZeroExtendExpr(const SCEV *Op, Type *Ty, unsigned Depth = 0);

References

include/llvm/Analysis/ScalarEvolutionExpressions.h

  687                  : SE.getZeroExtendExpr(Operand, Expr->getType());

lib/Analysis/LoopAccessAnalysis.cpp

 1385     CastedProduct = SE.getZeroExtendExpr(Product, Dist.getType());
 2326     CastedBECount = SE->getZeroExtendExpr(BETakenCount, StrideExpr->getType());

lib/Analysis/ScalarEvolution.cpp

 1425     SCEVZeroExtendExpr>::GetExtendExpr = &ScalarEvolution::getZeroExtendExpr;
 1652     return getZeroExtendExpr(SZ->getOperand(), Ty, Depth + 1);
 1704             getZeroExtendExpr(Step, Ty, Depth + 1), L, AR->getNoWrapFlags());
 1730           const SCEV *ZAdd = getZeroExtendExpr(getAddExpr(Start, ZMul,
 1734           const SCEV *WideStart = getZeroExtendExpr(Start, WideTy, Depth + 1);
 1736             getZeroExtendExpr(CastedMaxBECount, WideTy, Depth + 1);
 1740                                   getZeroExtendExpr(Step, WideTy, Depth + 1),
 1750                 getZeroExtendExpr(Step, Ty, Depth + 1), L,
 1801                 getZeroExtendExpr(Step, Ty, Depth + 1), L,
 1830           const SCEV *SZExtD = getZeroExtendExpr(getConstant(D), Ty, Depth);
 1833           const SCEV *SZExtR = getZeroExtendExpr(SResidual, Ty, Depth + 1);
 1844             getZeroExtendExpr(Step, Ty, Depth + 1), L, AR->getNoWrapFlags());
 1853       return getURemExpr(getZeroExtendExpr(LHS, Ty, Depth + 1),
 1854                          getZeroExtendExpr(RHS, Ty, Depth + 1));
 1859     return getUDivExpr(getZeroExtendExpr(Div->getLHS(), Ty, Depth + 1),
 1860                        getZeroExtendExpr(Div->getRHS(), Ty, Depth + 1));
 1869         Ops.push_back(getZeroExtendExpr(Op, Ty, Depth + 1));
 1884         const SCEV *SZExtD = getZeroExtendExpr(getConstant(D), Ty, Depth);
 1887         const SCEV *SZExtR = getZeroExtendExpr(SResidual, Ty, Depth + 1);
 1902         Ops.push_back(getZeroExtendExpr(Op, Ty, Depth + 1));
 1926                 getZeroExtendExpr(MulLHS, Ty),
 1927                 getZeroExtendExpr(
 1962     return getZeroExtendExpr(SZ->getOperand(), Ty, Depth + 1);
 2080             getZeroExtendExpr(CastedMaxBECount, WideTy, Depth + 1);
 2102                                   getZeroExtendExpr(Step, WideTy, Depth + 1),
 2120                 getZeroExtendExpr(Step, Ty, Depth + 1), L,
 2183     return getZeroExtendExpr(Op, Ty, Depth + 1);
 2219   const SCEV *ZExt = getZeroExtendExpr(Op, Ty);
 3175       return getZeroExtendExpr(getTruncateExpr(LHS, TruncTy), FullTy);
 3219               getZeroExtendExpr(AR, ExtTy) ==
 3220               getAddRecExpr(getZeroExtendExpr(AR->getStart(), ExtTy),
 3221                             getZeroExtendExpr(Step, ExtTy),
 3233               getZeroExtendExpr(AR, ExtTy) ==
 3234               getAddRecExpr(getZeroExtendExpr(AR->getStart(), ExtTy),
 3235                             getZeroExtendExpr(Step, ExtTy),
 3248           Operands.push_back(getZeroExtendExpr(Op, ExtTy));
 3249         if (getZeroExtendExpr(M, ExtTy) == getMulExpr(Operands))
 3281           Operands.push_back(getZeroExtendExpr(Op, ExtTy));
 3282         if (getZeroExtendExpr(A, ExtTy) == getAddExpr(Operands)) {
 4052   return getZeroExtendExpr(V, Ty, Depth);
 4076   return getZeroExtendExpr(V, Ty);
 4121     PromotedRHS = getZeroExtendExpr(RHS, LHS->getType());
 4839                          : getZeroExtendExpr(TruncatedExpr, Expr->getType());
 6289               getZeroExtendExpr(
 6349                   return getZeroExtendExpr(getNotSCEV(Z0), UTy);
 6357                   return getZeroExtendExpr(getAddExpr(Z0, getConstant(Trunc)),
 6451     return getZeroExtendExpr(getSCEV(U->getOperand(0)), U->getType());
 8353     return getZeroExtendExpr(Op, Cast->getType());
 9724       LHS = getZeroExtendExpr(LHS, FoundLHS->getType());
 9725       RHS = getZeroExtendExpr(RHS, FoundLHS->getType());
 9733       FoundLHS = getZeroExtendExpr(FoundLHS, LHS->getType());
 9734       FoundRHS = getZeroExtendExpr(FoundRHS, LHS->getType());
11973       NewBECount = SE2.getZeroExtendExpr(NewBECount, CurBECount->getType());
11976       CurBECount = SE2.getZeroExtendExpr(CurBECount, NewBECount->getType());
12139         return SE.getAddRecExpr(SE.getZeroExtendExpr(AR->getStart(), Ty),
12143     return SE.getZeroExtendExpr(Operand, Expr->getType());

lib/Analysis/ScalarEvolutionExpander.cpp

 1148   const SCEV *OpAfterExtend = SE.getAddExpr(SE.getZeroExtendExpr(Step, WideTy),
 1149                                             SE.getZeroExtendExpr(AR, WideTy));
 1151     SE.getZeroExtendExpr(SE.getAddExpr(AR, Step), WideTy);

lib/CodeGen/HardwareLoops.cpp

  325     ExitCount = SE.getZeroExtendExpr(ExitCount, CountType);

lib/Transforms/Scalar/IndVarSimplify.cpp

 1165       return SE->getZeroExtendExpr(S, Ty);
 1276     ExtendOperExpr = SE->getZeroExtendExpr(
 1326       WideExpr = SE->getZeroExtendExpr(NarrowExpr, WideType);
 1333     WideExpr = SE->getZeroExtendExpr(NarrowExpr, WideType);
 1440     ExtendOperExpr = SE->getZeroExtendExpr(
 1734                                : SE->getZeroExtendExpr(AddRec, WideType);
 2393         ExitCount = SE->getZeroExtendExpr(ExitCount, IVInit->getType());
 2514       SE->getZeroExtendExpr(TruncatedIV, CmpIndVar->getType());

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

  922     NumBytesS = SE->getZeroExtendExpr(

lib/Transforms/Scalar/NaryReassociate.cpp

  384         SE->getZeroExtendExpr(IndexExprs[I], GEP->getOperand(I)->getType());

lib/Transforms/Utils/SimplifyIndVar.cpp

  425              : &ScalarEvolution::getZeroExtendExpr;
  528   if (IVSCEV == SE->getZeroExtendExpr(TISCEV, IVTy))

tools/polly/lib/Support/ScopHelper.cpp

  338     return SE.getZeroExtendExpr(visit(E->getOperand()), E->getType());

unittests/Analysis/ScalarEvolutionTest.cpp

  719   SE.getZeroExtendExpr(S, I128Ty);