[VPlan] Helper to check if a recipe only uses scalar values of op.

[fhahn]

Summary

This patch adds a helper to check if a recipe only uses scalars of a
given operand. This is similar to onlyFirstLaneUsed, which was
introduced earlier.

By default, onlyScalarsUsed falls back on onlyFirstLaneUsed.

Will be used by a follow-up patch.

[Ayal]

How about VPScalarIVStepsRecipe, VPBlendRecipe, VPBranchOnMaskRecipe, VPPredInstPHIRecipe, VPExpandSCEVRecipe?

Is it worth distinguishing between recipes that can immediately tell they only use scalars (or only use first scalar lane) such as VPRepilcateRecipe - and those that don't care and need to check if all their users are of the former type, such as VPBlendRecipe and possibly VPPredInstPHIRecipe?

[fhahn]

In D120827#3367168, @Ayal wrote:

How about VPScalarIVStepsRecipe, VPBlendRecipe, VPBranchOnMaskRecipe, VPPredInstPHIRecipe, VPExpandSCEVRecipe?

I updated the patch to also support VPScalarIVStepsRecipe, VPPredInstPHIRecipe & VPExpandSCEVRecipe.

Is it worth distinguishing between recipes that can immediately tell they only use scalars (or only use first scalar lane) such as VPRepilcateRecipe - and those that don't care and need to check if all their users are of the former type, such as VPBlendRecipe and possibly VPPredInstPHIRecipe?

I am not sure if we need that at the moment, but it might be useful to have in the future if compile-time comes a concern for some analysis?

[Ayal]

llvm/lib/Transforms/Vectorize/VPlan.h

1644

VPPredInstPHIRecipe has only PredInst as an operand, which is surely scalar.

1779

Does VPExpandSCEVRecipe use only first lane?

1920

VPScalarIVStepsRecipe uses only the first lane of its three operands?

[Ayal]

Perhaps drop "only" - "usesScalars()" instead of "onlyScalarsUsed()"? As opposed to usesVectors.

In contrast, "onlyFirstLaneUsed()" as opposed to also using 2nd, 3rd, ... VFth lanes.

[fhahn]

Address comments, thanks!

In D120827#3370915, @Ayal wrote:

Perhaps drop "only" - "usesScalars()" instead of "onlyScalarsUsed()"? As opposed to usesVectors.

Adjusted, thanks!

[fhahn]

llvm/lib/Transforms/Vectorize/VPlan.h

1644

Yes. Are you referring to the generic comment?

1779

It doesn't use any VPValue operands, so this can never be called without asserting. I remove it.

1920

Yes, I changed the code, thanks!

[Ayal]

llvm/lib/Transforms/Vectorize/VPlan.h

776

Can drop "only" from comment too (here and below).
Add "Conservatively returns if only first (scalar) lane is used, as default" ?

1644

Just clarifying the behavior here.

1921

drop " /// Conservatively returns false."

[Ayal]

Looks good to me, with some last minor nits.
Can drop 'only' also from title.
Specifying VPScalarIVStepsRecipe::onlyFirstLaneUsed() could be committed separately, it belongs to previous patches introducing VPScalarIVStepsRecipe and/or onlyFirstLaneUsed().

[fhahn]

In D120827#3372613, @Ayal wrote:

Looks good to me, with some last minor nits.
Can drop 'only' also from title.

Thanks, I'll address them in the committed version.

Specifying VPScalarIVStepsRecipe::onlyFirstLaneUsed() could be committed separately, it belongs to previous patches introducing VPScalarIVStepsRecipe and/or onlyFirstLaneUsed().

Will do!

llvm/lib/Transforms/Vectorize/VPlan.h

1921

Will do ,thanks!

llvm/lib/Transforms/Vectorize/VPlan.h

public:
 
   /// Returns true if the recipe only uses the first lane of operand \p Op.
   /// Conservatively returns false.
   virtual bool onlyFirstLaneUsed(const VPValue *Op) const {
     assert(is_contained(operands(), Op) &&
            "Op must be an operand of the recipe");
     return false;
   }
+
+  /// Returns true if the recipe only uses scalars of operand \p Op.
+  virtual bool usesScalars(const VPValue *Op) const {
+    assert(is_contained(operands(), Op) &&
+           "Op must be an operand of the recipe");
+    return onlyFirstLaneUsed(Op);
+  }
 };
 
 inline bool VPUser::classof(const VPDef *Def) {
   return Def->getVPDefID() == VPRecipeBase::VPInstructionSC ||
          Def->getVPDefID() == VPRecipeBase::VPWidenSC ||
          Def->getVPDefID() == VPRecipeBase::VPWidenCallSC ||
          Def->getVPDefID() == VPRecipeBase::VPWidenSelectSC ||
          Def->getVPDefID() == VPRecipeBase::VPWidenGEPSC ||
#endif
   bool isPredicated() const { return IsPredicated; }
 
   /// Returns true if the recipe only uses the first lane of operand \p Op.
   bool onlyFirstLaneUsed(const VPValue *Op) const override {
     assert(is_contained(operands(), Op) &&
            "Op must be an operand of the recipe");
     return isUniform();
   }
+
+  /// Returns true if the recipe only uses scalars of operand \p Op.
+  bool usesScalars(const VPValue *Op) const override {
+    assert(is_contained(operands(), Op) &&
+           "Op must be an operand of the recipe");
+    return true;
+  }
 };
 
 /// A recipe for generating conditional branches on the bits of a mask.
 class VPBranchOnMaskRecipe : public VPRecipeBase {
 public:
   VPBranchOnMaskRecipe(VPValue *BlockInMask)
       : VPRecipeBase(VPBranchOnMaskSC, {}) {
     if (BlockInMask) // nullptr means all-one mask.
public:
   /// Generates phi nodes for live-outs as needed to retain SSA form.
   void execute(VPTransformState &State) override;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   /// Print the recipe.
   void print(raw_ostream &O, const Twine &Indent,
              VPSlotTracker &SlotTracker) const override;
 #endif
+
+  /// Returns true if the recipe only uses scalars of operand \p Op.
+  bool usesScalars(const VPValue *Op) const override {
+    assert(is_contained(operands(), Op) &&
+           "Op must be an operand of the recipe");
+    return true;
+  }
 };
 
 /// A Recipe for widening load/store operations.
 /// The recipe uses the following VPValues:
 /// - For load: Address, optional mask
 /// - For store: Address, stored value, optional mask
 /// TODO: We currently execute only per-part unless a specific instance is
 /// provided.
public:
   void execute(VPTransformState &State) override;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   /// Print the recipe.
   void print(raw_ostream &O, const Twine &Indent,
              VPSlotTracker &SlotTracker) const override;
 #endif
 };
 
 /// Canonical scalar induction phi of the vector loop. Starting at the specified
 /// start value (either 0 or the resume value when vectorizing the epilogue
 /// loop). VPWidenCanonicalIVRecipe represents the vector version of the
 /// canonical induction variable.
 class VPCanonicalIVPHIRecipe : public VPHeaderPHIRecipe {
   DebugLoc DL;
 
 public:
#endif
 
   /// Returns true if the induction is canonical, i.e. starting at 0 and
   /// incremented by UF * VF (= the original IV is incremented by 1).
   bool isCanonical() const;
 
   VPCanonicalIVPHIRecipe *getCanonicalIV() const;
   VPValue *getStartValue() const { return getOperand(1); }
   VPValue *getStepValue() const { return getOperand(2); }
+
+  /// Returns true if the recipe only uses the first lane of operand \p Op.
+  /// Conservatively returns false.
+  bool onlyFirstLaneUsed(const VPValue *Op) const override {
+    assert(is_contained(operands(), Op) &&
+           "Op must be an operand of the recipe");
+    return true;
+  }
 };
 
 /// VPBasicBlock serves as the leaf of the Hierarchical Control-Flow Graph. It
 /// holds a sequence of zero or more VPRecipe's each representing a sequence of
 /// output IR instructions. All PHI-like recipes must come before any non-PHI recipes.
 class VPBasicBlock : public VPBlockBase {
 public:
   using RecipeListTy = iplist<VPRecipeBase>;