[VPlan] Move mask handling to VPRecipeBase (NFCI).

[fhahn]

Summary

Consolidate mask handling to VPRecipeBase, buy letting subclasses define
the number of non-mask operations, if it is different than the total
number of operands.

This removes a bit of duplication, allows for generic printing of the
mask and potentially allows masking of any recipe (e.g. to use
vector predication).

[ABataev]

LG

llvm/lib/Transforms/Vectorize/VPlan.h

public:
 
   /// Returns true if the recipe may write to memory.
   bool mayWriteToMemory() const;
 
   /// Returns true if the recipe may read from or write to memory.
   bool mayReadOrWriteMemory() const {
     return mayReadFromMemory() || mayWriteToMemory();
   }
+
+  /// Returns the number of operands excluding mask operands, which must be the
+  /// last operand. Must be overwritten by sub-classes with mask operands.
+  virtual unsigned getNumNonMaskOperands() const { return getNumOperands(); }
+
+  /// Returns true if the recipe is masked.
+  bool isMasked() const { return getNumOperands() != getNumNonMaskOperands(); }
+
+  /// Return the mask used by this recipe. Note that a full mask is represented
+  /// by a nullptr.
+  VPValue *getMask() const {
+    // Mask is optional and therefore the last operand.
+    return isMasked() ? getOperand(getNumOperands() - 1) : nullptr;
+  }
 };
 
 // Helper macro to define common classof implementations for recipes.
 #define VP_CLASSOF_IMPL(VPDefID)                                               \
   static inline bool classof(const VPDef *D) {                                 \
     return D->getVPDefID() == VPDefID;                                         \
   }                                                                            \
   static inline bool classof(const VPValue *V) {                               \
public:
 
   VP_CLASSOF_IMPL(VPDef::VPInterleaveSC)
 
   /// Return the address accessed by this recipe.
   VPValue *getAddr() const {
     return getOperand(0); // Address is the 1st, mandatory operand.
   }
 
-  /// Return the mask used by this recipe. Note that a full mask is represented
-  /// by a nullptr.
-  VPValue *getMask() const {
-    // Mask is optional and therefore the last, currently 2nd operand.
-    return HasMask ? getOperand(getNumOperands() - 1) : nullptr;
-  }
-
   /// Return the VPValues stored by this interleave group. If it is a load
   /// interleave group, return an empty ArrayRef.
   ArrayRef<VPValue *> getStoredValues() const {
     // The first operand is the address, followed by the stored values, followed
     // by an optional mask.
     return ArrayRef<VPValue *>(op_begin(), getNumOperands())
         .slice(1, getNumStoreOperands());
   }
#endif
   }
 
   /// The recipe only uses the first lane of the address.
   bool onlyFirstLaneUsed(const VPValue *Op) const override {
     assert(is_contained(operands(), Op) &&
            "Op must be an operand of the recipe");
     return Op == getAddr() && !llvm::is_contained(getStoredValues(), Op);
   }
+
+  /// Returns the number of operands excluding mask operands.
+  unsigned getNumNonMaskOperands() const override {
+    return HasMask ? getNumOperands() - 1 : getNumOperands();
+  }
 };
 
 /// A recipe to represent inloop reduction operations, performing a reduction on
 /// a vector operand into a scalar value, and adding the result to a chain.
 /// The Operands are {ChainOp, VecOp, [Condition]}.
 class VPReductionRecipe : public VPRecipeBase, public VPValue {
   /// The recurrence decriptor for the reduction in question.
   const RecurrenceDescriptor *RdxDesc;
bool usesScalars(const VPValue *Op) const override {
     return true;
   }
 
   /// Returns true if the recipe is used by a widened recipe via an intervening
   /// VPPredInstPHIRecipe. In this case, the scalar values should also be packed
   /// in a vector.
   bool shouldPack() const;
 
-  /// Return the mask of a predicated VPReplicateRecipe.
-  VPValue *getMask() {
-    assert(isPredicated() && "Trying to get the mask of a unpredicated recipe");
-    return getOperand(getNumOperands() - 1);
+  /// Returns the number of operands excluding mask operands.
+  unsigned getNumNonMaskOperands() const override {
+    return isPredicated() ? getNumOperands() - 1 : getNumOperands();
   }
 };
 
 /// A recipe for generating conditional branches on the bits of a mask.
 class VPBranchOnMaskRecipe : public VPRecipeBase {
 public:
   VPBranchOnMaskRecipe(VPValue *BlockInMask)
       : VPRecipeBase(VPDef::VPBranchOnMaskSC, {}) {
class VPWidenMemoryInstructionRecipe : public VPRecipeBase {
   bool Reverse;
 
   void setMask(VPValue *Mask) {
     if (!Mask)
       return;
     addOperand(Mask);
   }
 
-  bool isMasked() const {
-    return isStore() ? getNumOperands() == 3 : getNumOperands() == 2;
-  }
-
 public:
   VPWidenMemoryInstructionRecipe(LoadInst &Load, VPValue *Addr, VPValue *Mask,
                                  bool Consecutive, bool Reverse)
       : VPRecipeBase(VPDef::VPWidenMemoryInstructionSC, {Addr}),
         Ingredient(Load), Consecutive(Consecutive), Reverse(Reverse) {
     assert((Consecutive || !Reverse) && "Reverse implies consecutive");
     new VPValue(this, &Load);
     setMask(Mask);
public:
 
   VP_CLASSOF_IMPL(VPDef::VPWidenMemoryInstructionSC)
 
   /// Return the address accessed by this recipe.
   VPValue *getAddr() const {
     return getOperand(0); // Address is the 1st, mandatory operand.
   }
 
-  /// Return the mask used by this recipe. Note that a full mask is represented
-  /// by a nullptr.
-  VPValue *getMask() const {
-    // Mask is optional and therefore the last operand.
-    return isMasked() ? getOperand(getNumOperands() - 1) : nullptr;
-  }
-
   /// Returns true if this recipe is a store.
   bool isStore() const { return isa<StoreInst>(Ingredient); }
 
   /// Return the address accessed by this recipe.
   VPValue *getStoredValue() const {
     assert(isStore() && "Stored value only available for store instructions");
     return getOperand(1); // Stored value is the 2nd, mandatory operand.
   }
bool onlyFirstLaneUsed(const VPValue *Op) const override {
     // Widened, consecutive memory operations only demand the first lane of
     // their address, unless the same operand is also stored. That latter can
     // happen with opaque pointers.
     return Op == getAddr() && isConsecutive() &&
            (!isStore() || Op != getStoredValue());
   }
 
   Instruction &getIngredient() const { return Ingredient; }
+
+  /// Returns the number of operands excluding mask operands.
+  unsigned getNumNonMaskOperands() const override { return isStore() ? 2 : 1; }
 };
 
 /// Recipe to expand a SCEV expression.
 class VPExpandSCEVRecipe : public VPRecipeBase, public VPValue {
   const SCEV *Expr;
   ScalarEvolution &SE;
 
 public: