| /src/external/apache2/llvm/dist/llvm/include/llvm/Analysis/ |
| DependenceAnalysis.h | 53 class SCEV;
102 const SCEV *Distance; // NULL implies no distance available.
162 virtual const SCEV *getDistance(unsigned Level) const { return nullptr; }
243 const SCEV *getDistance(unsigned Level) const override;
332 const SCEV *getSplitIteration(const Dependence &Dep, unsigned Level);
346 const SCEV *Src;
347 const SCEV *Dst;
355 const SCEV *Coeff;
356 const SCEV *PosPart;
357 const SCEV *NegPart
[all...] |
| ScalarEvolutionNormalization.h | 45 class SCEV;
54 const SCEV *normalizeForPostIncUse(const SCEV *S, const PostIncLoopSet &Loops,
59 const SCEV *normalizeForPostIncUseIf(const SCEV *S, NormalizePredTy Pred,
64 const SCEV *denormalizeForPostIncUse(const SCEV *S, const PostIncLoopSet &Loops,
|
| ScalarEvolution.h | 12 // SCEV class. Given this analysis, trip counts of loops and other important
78 class SCEV : public FoldingSetNode {
79 friend struct FoldingSetTrait<SCEV>;
85 // The SCEV baseclass this node corresponds to
123 explicit SCEV(const FoldingSetNodeIDRef ID, SCEVTypes SCEVTy,
126 SCEV(const SCEV &) = delete;
127 SCEV &operator=(const SCEV &) = delete;
131 /// Return the LLVM type of this SCEV expression
[all...] |
| ScalarEvolutionDivision.h | 9 // This file defines the class that knows how to divide SCEV's.
20 class SCEV;
30 static void divide(ScalarEvolution &SE, const SCEV *Numerator,
31 const SCEV *Denominator, const SCEV **Quotient,
32 const SCEV **Remainder);
57 SCEVDivision(ScalarEvolution &S, const SCEV *Numerator,
58 const SCEV *Denominator);
62 void cannotDivide(const SCEV *Numerator);
65 const SCEV *Denominator, *Quotient, *Remainder, *Zero, *One
[all...] |
| ScalarEvolutionExpressions.h | 1 //===- llvm/Analysis/ScalarEvolutionExpressions.h - SCEV Exprs --*- C++ -*-===//
47 class SCEVConstant : public SCEV {
53 SCEV(ID, scConstant, 1), V(v) {}
62 static bool classof(const SCEV *S) {
67 inline unsigned short computeExpressionSize(ArrayRef<const SCEV *> Args) {
75 class SCEVCastExpr : public SCEV {
77 std::array<const SCEV *, 1> Operands;
80 SCEVCastExpr(const FoldingSetNodeIDRef ID, SCEVTypes SCEVTy, const SCEV *op,
84 const SCEV *getOperand() const { return Operands[0]; }
85 const SCEV *getOperand(unsigned i) const
[all...] |
| LoopCacheAnalysis.h | 28 class SCEV;
54 const SCEV *getBasePointer() const { return BasePointer; }
56 const SCEV *getSubscript(unsigned SubNum) const {
60 const SCEV *getFirstSubscript() const {
64 const SCEV *getLastSubscript() const {
109 const SCEV *getLastCoefficient() const;
113 bool isCoeffForLoopZeroOrInvariant(const SCEV &Subscript,
118 bool isSimpleAddRecurrence(const SCEV &Subscript, const Loop &L) const;
132 const SCEV *BasePointer = nullptr;
135 SmallVector<const SCEV *, 3> Subscripts
[all...] |
| IVUsers.h | 29 class SCEV;
127 /// reducible SCEV, recursively add its users to the IVUsesByStride set and
133 /// getReplacementExpr - Return a SCEV expression which computes the
135 const SCEV *getReplacementExpr(const IVStrideUse &IU) const;
138 const SCEV *getExpr(const IVStrideUse &IU) const;
140 const SCEV *getStride(const IVStrideUse &IU, const Loop *L) const;
|
| LoopAccessAnalysis.h | 31 class SCEV;
262 /// A wrapper around ScalarEvolution, used to add runtime SCEV checks, and
263 /// applies dynamic knowledge to simplify SCEV expressions and convert them
264 /// to a more usable form. We need this in case assumptions about SCEV
355 /// The SCEV expression which represents the upper bound of all the
357 const SCEV *High;
358 /// The SCEV expression which represents the lower bound of all the
360 const SCEV *Low;
381 const SCEV *Start;
384 const SCEV *End
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Analysis/ |
| ScalarEvolutionNormalization.cpp | 42 const SCEV *visitAddRecExpr(const SCEVAddRecExpr *Expr);
46 const SCEV *
48 SmallVector<const SCEV *, 8> Operands;
51 [&](const SCEV *Op) { return visit(Op); });
54 return SE.getAddRecExpr(Operands, AR->getLoop(), SCEV::FlagAnyWrap);
57 // incrementing a SCEV expression with respect to a set of loops. Since
71 // incrementing a SCEV expression (in general) changes the step of the SCEV
93 return SE.getAddRecExpr(Operands, AR->getLoop(), SCEV::FlagAnyWrap);
96 const SCEV *llvm::normalizeForPostIncUse(const SCEV *S
[all...] |
| ScalarEvolutionDivision.cpp | 9 // This file defines the class that knows how to divide SCEV's.
32 static inline int sizeOfSCEV(const SCEV *S) {
38 bool follow(const SCEV *S) {
57 void SCEVDivision::divide(ScalarEvolution &SE, const SCEV *Numerator,
58 const SCEV *Denominator, const SCEV **Quotient,
59 const SCEV **Remainder) {
60 assert(Numerator && Denominator && "Uninitialized SCEV");
87 const SCEV *Q, *R;
89 for (const SCEV *Op : T->operands())
[all...] |
| ScalarEvolution.cpp | 14 // scalar expressions, which are represented as subclasses of the SCEV class.
16 // can handle. We only create one SCEV of a particular shape, so
19 // One important aspect of the SCEV objects is that they are never cyclic, even
154 cl::desc("Maximum number of iterations SCEV will "
161 "verify-scev", cl::Hidden,
164 "verify-scev-strict", cl::Hidden,
165 cl::desc("Enable stricter verification with -verify-scev is passed"));
167 VerifySCEVMap("verify-scev-maps", cl::Hidden,
172 "scev-verify-ir", cl::Hidden,
173 cl::desc("Verify IR correctness when making sensitive SCEV queries (slow)")
[all...] |
| DependenceAnalysis.cpp | 27 // analysis is using SCEV->delinearize to recover the representation of multiple
33 // Subtract, or Multiply, with both APInt's and SCEV's.
39 // Finally, it seems like certain test cases expose weaknesses in the SCEV
276 const SCEV *FullDependence::getDistance(unsigned Level) const {
319 const SCEV *DependenceInfo::Constraint::getX() const {
327 const SCEV *DependenceInfo::Constraint::getY() const {
335 const SCEV *DependenceInfo::Constraint::getA() const {
344 const SCEV *DependenceInfo::Constraint::getB() const {
353 const SCEV *DependenceInfo::Constraint::getC() const {
362 const SCEV *DependenceInfo::Constraint::getD() const
[all...] |
| LoopCacheAnalysis.cpp | 80 static bool isOneDimensionalArray(const SCEV &AccessFn, const SCEV &ElemSize,
89 const SCEV *Start = AR->getStart();
90 const SCEV *Step = AR->getStepRecurrence(SE);
98 const SCEV *StepRec = AR->getStepRecurrence(SE);
105 /// Compute the trip count for the given loop \p L. Return the SCEV expression
107 static const SCEV *computeTripCount(const Loop &L, ScalarEvolution &SE) {
108 const SCEV *BackedgeTakenCount = SE.getBackedgeTakenCount(&L);
128 for (const SCEV *Subscript : R.Subscripts)
132 for (const SCEV *Size : R.Sizes
[all...] |
| ScalarEvolutionAliasAnalysis.cpp | 1 //===- ScalarEvolutionAliasAnalysis.cpp - SCEV-based Alias Analysis -------===//
35 const SCEV *AS = SE.getSCEV(const_cast<Value *>(LocA.Ptr));
36 const SCEV *BS = SE.getSCEV(const_cast<Value *>(LocB.Ptr));
55 const SCEV *BA = SE.getMinusSCEV(BS, AS);
69 const SCEV *AB = SE.getMinusSCEV(AS, BS);
103 Value *SCEVAAResult::GetBaseValue(const SCEV *S) {
110 const SCEV *Last = A->getOperand(A->getNumOperands() - 1);
135 INITIALIZE_PASS_BEGIN(SCEVAAWrapperPass, "scev-aa",
138 INITIALIZE_PASS_END(SCEVAAWrapperPass, "scev-aa",
|
| LoopAccessAnalysis.cpp | 143 const SCEV *llvm::replaceSymbolicStrideSCEV(PredicatedScalarEvolution &PSE,
146 const SCEV *OrigSCEV = PSE.getSCEV(Ptr);
148 // If there is an entry in the map return the SCEV of the pointer with the
166 LLVM_DEBUG(dbgs() << "LAA: Replacing SCEV: " << *OrigSCEV
195 // Get the stride replaced scev.
196 const SCEV *Sc = replaceSymbolicStrideSCEV(PSE, Strides, Ptr);
199 const SCEV *ScStart;
200 const SCEV *ScEnd;
207 const SCEV *Ex = PSE.getBackedgeTakenCount();
211 const SCEV *Step = AR->getStepRecurrence(*SE)
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/Transforms/Scalar/ |
| AlignmentFromAssumptions.h | 27 class SCEV;
41 const SCEV *&AlignSCEV, const SCEV *&OffSCEV);
|
| NaryReassociate.h | 39 // an expression is computed before, we store each instruction seen and its SCEV
40 // into an SCEV-to-instruction map.
96 class SCEV;
117 Instruction *tryReassociate(Instruction *I, const SCEV *&OrigSCEV);
146 Instruction *tryReassociatedBinaryOp(const SCEV *LHS, Value *RHS,
152 // Gets SCEV for (LHS op RHS).
153 const SCEV *getBinarySCEV(BinaryOperator *I, const SCEV *LHS,
154 const SCEV *RHS);
158 Instruction *findClosestMatchingDominator(const SCEV *CandidateExpr
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/Transforms/Utils/ |
| ScalarEvolutionExpander.h | 1 //===---- llvm/Analysis/ScalarEvolutionExpander.h - SCEV Exprs --*- C++ -*-===//
36 bool isSafeToExpand(const SCEV *S, ScalarEvolution &SE);
41 bool isSafeToExpandAt(const SCEV *S, const Instruction *InsertionPoint,
45 /// given SCEV when expanded into IR.
47 explicit SCEVOperand(unsigned Opc, int Idx, const SCEV *S) :
53 /// The SCEV operand to be costed.
54 const SCEV* S;
74 DenseMap<std::pair<const SCEV *, Instruction *>, TrackingVH<Value>>
86 /// A memoization of the "relevant" loop for a given SCEV.
87 DenseMap<const SCEV *, const Loop *> RelevantLoops
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Scalar/ |
| AlignmentFromAssumptions.cpp | 92 // to a constant. Using SCEV to compute alignment handles the case where
95 static MaybeAlign getNewAlignmentDiff(const SCEV *DiffSCEV,
96 const SCEV *AlignSCEV,
99 const SCEV *DiffUnitsSCEV = SE->getURemExpr(DiffSCEV, AlignSCEV);
127 static Align getNewAlignment(const SCEV *AASCEV, const SCEV *AlignSCEV,
128 const SCEV *OffSCEV, Value *Ptr,
130 const SCEV *PtrSCEV = SE->getSCEV(Ptr);
132 // (*cough* AMDGPU), the effective SCEV type of AASCEV and PtrSCEV
136 const SCEV *DiffSCEV = SE->getMinusSCEV(PtrSCEV, AASCEV)
[all...] |
| InductiveRangeCheckElimination.cpp | 145 const SCEV *Begin = nullptr;
146 const SCEV *Step = nullptr;
147 const SCEV *End = nullptr;
160 const SCEV *getBegin() const { return Begin; }
161 const SCEV *getStep() const { return Step; }
162 const SCEV *getEnd() const { return End; }
188 const SCEV *Begin;
189 const SCEV *End;
192 Range(const SCEV *Begin, const SCEV *End) : Begin(Begin), End(End)
[all...] |
| LoopStrengthReduce.cpp | 28 // The SCEV for %i is {0,+,1}<%L>. The SCEV for %i.next is {1,+,1}<%L>, however
250 using RegUsesTy = DenseMap<const SCEV *, RegSortData>;
253 SmallVector<const SCEV *, 16> RegSequence;
256 void countRegister(const SCEV *Reg, size_t LUIdx);
257 void dropRegister(const SCEV *Reg, size_t LUIdx);
260 bool isRegUsedByUsesOtherThan(const SCEV *Reg, size_t LUIdx) const;
262 const SmallBitVector &getUsedByIndices(const SCEV *Reg) const;
266 using iterator = SmallVectorImpl<const SCEV *>::iterator;
267 using const_iterator = SmallVectorImpl<const SCEV *>::const_iterator
[all...] |
| LoopPredication.cpp | 36 // It's tempting to rely on SCEV here, but it has proven to be problematic.
37 // Generally the facts SCEV provides about the increment step of add
241 const SCEV *Limit;
243 const SCEV *Limit)
264 bool isSupportedStep(const SCEV* Step);
273 /// Same as above, *except* that this uses the SCEV definition of invariant
277 Instruction *findInsertPt(Instruction *User, ArrayRef<const SCEV*> Ops);
282 bool isLoopInvariantValue(const SCEV* S);
285 ICmpInst::Predicate Pred, const SCEV *LHS,
286 const SCEV *RHS)
[all...] |
| NaryReassociate.cpp | 39 // an expression is computed before, we store each instruction seen and its SCEV
40 // into an SCEV-to-instruction map.
228 const SCEV *OrigSCEV = nullptr;
237 const SCEV *NewSCEV = SE->getSCEV(NewI);
255 // map both SCEV before and after tryReassociate(I) to I.
276 const SCEV *&OrigSCEV) {
292 const SCEV *&OrigSCEV) {
394 // Look for GEP's closest dominator that has the same SCEV as GEP except that
396 SmallVector<const SCEV *, 4> IndexExprs;
411 const SCEV *CandidateExpr = SE->getGEPExpr(cast<GEPOperator>(GEP)
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Utils/ |
| ScalarEvolutionExpander.cpp | 35 "scev-cheap-expansion-budget", cl::Hidden, cl::init(4),
36 cl::desc("When performing SCEV expansion only if it is cheap to do, this "
215 SCEV::NoWrapFlags Flags, bool IsSafeToHoist) {
237 if (I->hasNoSignedWrap() != (Flags & SCEV::FlagNSW))
239 if (I->hasNoUnsignedWrap() != (Flags & SCEV::FlagNUW))
274 if (Flags & SCEV::FlagNUW)
276 if (Flags & SCEV::FlagNSW)
286 static bool FactorOutConstant(const SCEV *&S, const SCEV *&Remainder,
287 const SCEV *Factor, ScalarEvolution &SE
[all...] |
| SimplifyIndVar.cpp | 51 /// other loop passes that preserve SCEV.
131 const SCEV *FoldedExpr = nullptr;
175 // Bypass the operand if SCEV can prove it has no effect.
183 assert(SE->getSCEV(UseInst) == FoldedExpr && "bad SCEV with folded oper");
209 const SCEV *S = SE->getSCEVAtScope(ICmp->getOperand(IVOperIdx), ICmpLoop);
210 const SCEV *X = SE->getSCEVAtScope(ICmp->getOperand(1 - IVOperIdx), ICmpLoop);
219 const SCEV *InvariantLHS = LIP->LHS;
220 const SCEV *InvariantRHS = LIP->RHS;
226 SmallDenseMap<const SCEV*, Value*> CheapExpansions;
236 const SCEV *IncomingS = SE->getSCEV(Incoming)
[all...] |
