Lines Matching defs:VF
78 /// Returns a calculation for the total number of elements for a given \p VF.
81 Value *getRuntimeVF(IRBuilderBase &B, Type *Ty, ElementCount VF);
83 /// Return a value for Step multiplied by VF.
84 Value *createStepForVF(IRBuilderBase &B, Type *Ty, ElementCount VF,
123 ElementCount VF;
126 iterator(ElementCount VF) : VF(VF) {}
128 bool operator==(const iterator &Other) const { return VF == Other.VF; }
130 ElementCount operator*() const { return VF; }
133 VF *= 2;
169 /// in [0..VF)
181 static VPLane getLaneFromEnd(const ElementCount &VF, unsigned Offset) {
182 assert(Offset > 0 && Offset <= VF.getKnownMinValue() &&
184 unsigned LaneOffset = VF.getKnownMinValue() - Offset;
186 if (VF.isScalable())
188 // last subvector with VF.getKnownMinValue() elements.
195 static VPLane getLastLaneForVF(const ElementCount &VF) {
196 return getLaneFromEnd(VF, 1);
208 Value *getAsRuntimeExpr(IRBuilderBase &Builder, const ElementCount &VF) const;
216 /// Maps the lane to a cache index based on \p VF.
217 unsigned mapToCacheIndex(const ElementCount &VF) const {
220 assert(VF.isScalable() && Lane < VF.getKnownMinValue());
221 return VF.getKnownMinValue() + Lane;
223 assert(Lane < VF.getKnownMinValue());
232 VPTransformState(const TargetTransformInfo *TTI, ElementCount VF, unsigned UF,
240 ElementCount VF;
268 unsigned CacheIdx = Lane.mapToCacheIndex(VF);
279 assert((VF.isScalar() || V->getType()->isVectorTy()) &&
293 unsigned CacheIdx = Lane.mapToCacheIndex(VF);
305 unsigned CacheIdx = Lane.mapToCacheIndex(VF);
633 virtual InstructionCost cost(ElementCount VF, VPCostContext &Ctx) = 0;
692 /// Return the cost for \p UI with \p VF using the legacy cost model as
694 InstructionCost getLegacyCost(Instruction *UI, ElementCount VF) const;
746 InstructionCost cost(ElementCount VF, VPCostContext &Ctx);
811 virtual InstructionCost computeCost(ElementCount VF,
1216 // last. The second operand must be a positive constant and <= VF.
1315 InstructionCost computeCost(ElementCount VF,
1398 InstructionCost computeCost(ElementCount VF,
1470 /// processing State.VF elements.
1474 InstructionCost computeCost(ElementCount VF,
1571 InstructionCost computeCost(ElementCount VF,
1612 InstructionCost computeCost(ElementCount VF,
1696 InstructionCost computeCost(ElementCount VF,
1729 /// between a given VF and the chosen vectorized variant, so there will be a
1730 /// different VPlan for each VF with a valid variant.
1757 InstructionCost computeCost(ElementCount VF,
1805 InstructionCost computeCost(ElementCount VF,
1842 InstructionCost computeCost(ElementCount VF,
1894 InstructionCost computeCost(ElementCount VF,
1914 VPReverseVectorPointerRecipe(VPValue *Ptr, VPValue *VF, Type *IndexedTy,
1917 ArrayRef<VPValue *>({Ptr, VF}), GEPFlags, DL),
1934 InstructionCost computeCost(ElementCount VF,
1997 InstructionCost computeCost(ElementCount VF,
2060 InstructionCost computeCost(ElementCount VF,
2153 VPValue *VF, const InductionDescriptor &IndDesc,
2158 addOperand(VF);
2162 VPValue *VF, const InductionDescriptor &IndDesc,
2167 addOperand(VF);
2205 /// incremented by UF * VF (= the original IV is incremented by 1) and has the
2372 InstructionCost computeCost(ElementCount VF,
2396 /// When expanding the reduction PHI, the plan's VF element count is divided
2397 /// by this factor to form the reduction phi's VF.
2484 InstructionCost computeCost(ElementCount VF,
2542 InstructionCost computeCost(ElementCount VF,
2631 InstructionCost computeCost(ElementCount VF,
2710 InstructionCost computeCost(ElementCount VF,
2817 InstructionCost computeCost(ElementCount VF,
2878 InstructionCost computeCost(ElementCount VF,
2933 InstructionCost computeCost(ElementCount VF,
3027 InstructionCost computeCost(ElementCount VF,
3092 InstructionCost computeCost(ElementCount VF,
3174 InstructionCost computeCost(ElementCount VF,
3219 InstructionCost computeCost(ElementCount VF,
3288 InstructionCost computeCost(ElementCount VF,
3357 InstructionCost computeCost(ElementCount VF,
3394 /// start = {<Part*VF, Part*VF+1, ..., Part*VF+VF-1> for 0 <= Part < UF}, and
3395 /// step = <VF*UF, VF*UF, ..., VF*UF>.
3399 InstructionCost computeCost(ElementCount VF,
3454 InstructionCost computeCost(ElementCount VF,
3516 InstructionCost computeCost(ElementCount VF,
3623 InstructionCost cost(ElementCount VF, VPCostContext &Ctx) override;
3714 /// scalar if-then code structure needs to be generated VF * UF times. Having
3716 /// candidate VF's. The actual replication takes place only once the desired VF
3793 InstructionCost cost(ElementCount VF, VPCostContext &Ctx) override;
3853 VPValue VF;
3855 /// Represents the loop-invariant VF * UF of the vector loop region.
3928 InstructionCost cost(ElementCount VF, VPCostContext &Ctx);
3994 /// Returns the VF of the vector loop region.
3995 VPValue &getVF() { return VF; };
3997 /// Returns VF * UF of the vector loop region.
4000 void addVF(ElementCount VF) { VFs.insert(VF); }
4002 void setVF(ElementCount VF) {
4003 assert(hasVF(VF) && "Cannot set VF not already in plan");
4005 VFs.insert(VF);
4008 bool hasVF(ElementCount VF) { return VFs.count(VF); }
4010 return any_of(VFs, [](ElementCount VF) { return VF.isScalable(); });