Create VecOperandInfo

Author: SamTebbs33

llvm/lib/Transforms/Vectorize/VPlan.h

@@ -2493,13 +2493,6 @@ class VPExtendedReductionRecipe : public VPReductionRecipe {
 /// recipe is abstract and needs to be lowered to concrete recipes before
 /// codegen. The Operands are {ChainOp, VecOp1, VecOp2, [Condition]}.
 class VPMulAccumulateReductionRecipe : public VPReductionRecipe {
-  /// Opcodes of the extend recipes.
-  Instruction::CastOps ExtOp0;
-  Instruction::CastOps ExtOp1;
-
-  /// Non-neg flags of the extend recipe.
-  bool IsNonNeg0 = false;
-  bool IsNonNeg1 = false;
 
   Type *ResultTy;
 
@@ -2514,10 +2507,11 @@ class VPMulAccumulateReductionRecipe : public VPReductionRecipe {
             MulAcc->getCondOp(), MulAcc->isOrdered(),
             WrapFlagsTy(MulAcc->hasNoUnsignedWrap(), MulAcc->hasNoSignedWrap()),
             MulAcc->getDebugLoc()),
-        ExtOp0(MulAcc->getExt0Opcode()), ExtOp1(MulAcc->getExt1Opcode()),
-        IsNonNeg0(MulAcc->isNonNeg0()), IsNonNeg1(MulAcc->isNonNeg1()),
         ResultTy(MulAcc->getResultType()),
-        IsPartialReduction(MulAcc->isPartialReduction()) {}
+        IsPartialReduction(MulAcc->isPartialReduction()) {
+    VecOpInfo[0] = MulAcc->getVecOp0Info();
+    VecOpInfo[1] = MulAcc->getVecOp1Info();
+  }
 
 public:
   VPMulAccumulateReductionRecipe(VPReductionRecipe *R, VPWidenRecipe *Mul,
@@ -2529,14 +2523,14 @@ class VPMulAccumulateReductionRecipe : public VPReductionRecipe {
             R->getCondOp(), R->isOrdered(),
             WrapFlagsTy(Mul->hasNoUnsignedWrap(), Mul->hasNoSignedWrap()),
             R->getDebugLoc()),
-        ExtOp0(Ext0->getOpcode()), ExtOp1(Ext1->getOpcode()),
-        IsNonNeg0(Ext0->isNonNeg()), IsNonNeg1(Ext1->isNonNeg()),
         ResultTy(ResultTy),
         IsPartialReduction(isa<VPPartialReductionRecipe>(R)) {
     assert(RecurrenceDescriptor::getOpcode(getRecurrenceKind()) ==
                Instruction::Add &&
            "The reduction instruction in MulAccumulateteReductionRecipe must "
            "be Add");
+    VecOpInfo[0] = {Ext0->getOpcode(), Ext0->isNonNeg()};
+    VecOpInfo[1] = {Ext1->getOpcode(), Ext1->isNonNeg()};
   }
 
   VPMulAccumulateReductionRecipe(VPReductionRecipe *R, VPWidenRecipe *Mul)
@@ -2545,15 +2539,20 @@ class VPMulAccumulateReductionRecipe : public VPReductionRecipe {
             {R->getChainOp(), Mul->getOperand(0), Mul->getOperand(1)},
             R->getCondOp(), R->isOrdered(),
             WrapFlagsTy(Mul->hasNoUnsignedWrap(), Mul->hasNoSignedWrap()),
-            R->getDebugLoc()),
-        ExtOp0(Instruction::CastOps::CastOpsEnd),
-        ExtOp1(Instruction::CastOps::CastOpsEnd) {
+            R->getDebugLoc()) {
     assert(RecurrenceDescriptor::getOpcode(getRecurrenceKind()) ==
                Instruction::Add &&
            "The reduction instruction in MulAccumulateReductionRecipe must be "
            "Add");
   }
 
+  struct VecOperandInfo {
+    /// The operand's extend opcode.
+    Instruction::CastOps ExtOp{Instruction::CastOps::CastOpsEnd};
+    /// Non-neg portion of the operand's flags.
+    bool IsNonNeg = false;
+  };
+
   ~VPMulAccumulateReductionRecipe() override = default;
 
   VPMulAccumulateReductionRecipe *clone() override {
@@ -2591,29 +2590,21 @@ class VPMulAccumulateReductionRecipe : public VPReductionRecipe {
   VPValue *getVecOp1() const { return getOperand(2); }
 
   /// Return if this MulAcc recipe contains extend instructions.
-  bool isExtended() const { return ExtOp0 != Instruction::CastOps::CastOpsEnd; }
+  bool isExtended() const {
+    return getVecOp0Info().ExtOp != Instruction::CastOps::CastOpsEnd;
+  }
 
   /// Return if the operands of mul instruction come from same extend.
   bool isSameExtendVal() const { return getVecOp0() == getVecOp1(); }
 
-  /// Return the opcode of the underlying extends.
-  Instruction::CastOps getExt0Opcode() const { return ExtOp0; }
-  Instruction::CastOps getExt1Opcode() const { return ExtOp1; }
-
-  /// Return if the first extend's opcode is ZExt.
-  bool isZExt0() const { return ExtOp0 == Instruction::CastOps::ZExt; }
-
-  /// Return if the second extend's opcode is ZExt.
-  bool isZExt1() const { return ExtOp1 == Instruction::CastOps::ZExt; }
-
-  /// Return the non negative flag of the first ext recipe.
-  bool isNonNeg0() const { return IsNonNeg0; }
-
-  /// Return the non negative flag of the second ext recipe.
-  bool isNonNeg1() const { return IsNonNeg1; }
+  VecOperandInfo getVecOp0Info() const { return VecOpInfo[0]; }
+  VecOperandInfo getVecOp1Info() const { return VecOpInfo[1]; }
 
   /// Return if the underlying reduction recipe is a partial reduction.
   bool isPartialReduction() const { return IsPartialReduction; }
+
+protected:
+  VecOperandInfo VecOpInfo[2];
 };
 
 /// VPReplicateRecipe replicates a given instruction producing multiple scalar

llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp

@@ -2434,19 +2434,22 @@ VPExtendedReductionRecipe::computeCost(ElementCount VF,
 InstructionCost
 VPMulAccumulateReductionRecipe::computeCost(ElementCount VF,
                                             VPCostContext &Ctx) const {
+  VecOperandInfo Op0Info = getVecOp0Info();
+  VecOperandInfo Op1Info = getVecOp1Info();
   if (isPartialReduction()) {
     return Ctx.TTI.getPartialReductionCost(
         Instruction::Add, Ctx.Types.inferScalarType(getVecOp0()),
         Ctx.Types.inferScalarType(getVecOp1()), getResultType(), VF,
-        TTI::getPartialReductionExtendKind(getExt0Opcode()),
-        TTI::getPartialReductionExtendKind(getExt1Opcode()), Instruction::Mul);
+        TTI::getPartialReductionExtendKind(Op0Info.ExtOp),
+        TTI::getPartialReductionExtendKind(Op1Info.ExtOp), Instruction::Mul);
   }
 
   Type *RedTy = Ctx.Types.inferScalarType(this);
   auto *SrcVecTy =
       cast<VectorType>(toVectorTy(Ctx.Types.inferScalarType(getVecOp0()), VF));
-  return Ctx.TTI.getMulAccReductionCost(isZExt0(), RedTy, SrcVecTy,
-                                        Ctx.CostKind);
+  return Ctx.TTI.getMulAccReductionCost(Op0Info.ExtOp ==
+                                            Instruction::CastOps::ZExt,
+                                        RedTy, SrcVecTy, Ctx.CostKind);
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
@@ -2514,6 +2517,8 @@ void VPExtendedReductionRecipe::print(raw_ostream &O, const Twine &Indent,
 
 void VPMulAccumulateReductionRecipe::print(raw_ostream &O, const Twine &Indent,
                                            VPSlotTracker &SlotTracker) const {
+  VecOperandInfo Op0Info = getVecOp0Info();
+  VecOperandInfo Op1Info = getVecOp1Info();
   O << Indent << "MULACC-REDUCE ";
   printAsOperand(O, SlotTracker);
   O << " = ";
@@ -2532,7 +2537,7 @@ void VPMulAccumulateReductionRecipe::print(raw_ostream &O, const Twine &Indent,
   getVecOp0()->printAsOperand(O, SlotTracker);
   if (isExtended()) {
     O << " ";
-    if (isZExt0())
+    if (Op0Info.ExtOp == Instruction::CastOps::ZExt)
       O << "zero-";
     else
       O << "sign-";
@@ -2542,7 +2547,7 @@ void VPMulAccumulateReductionRecipe::print(raw_ostream &O, const Twine &Indent,
   getVecOp1()->printAsOperand(O, SlotTracker);
   if (isExtended()) {
     O << " ";
-    if (isZExt1())
+    if (Op1Info.ExtOp == Instruction::CastOps::ZExt)
       O << "zero-";
     else
       O << "sign-";

llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp

@@ -2120,28 +2120,29 @@ expandVPMulAccumulateReduction(VPMulAccumulateReductionRecipe *MulAcc) {
   // reduce.add(ext(mul(ext, ext))) to reduce.add(mul(ext, ext)).
   VPValue *Op0, *Op1;
   if (MulAcc->isExtended()) {
+    VPMulAccumulateReductionRecipe::VecOperandInfo Op0Info =
+        MulAcc->getVecOp0Info();
+    VPMulAccumulateReductionRecipe::VecOperandInfo Op1Info =
+        MulAcc->getVecOp1Info();
     Type *RedTy = MulAcc->getResultType();
-    if (MulAcc->isZExt0())
-      Op0 = new VPWidenCastRecipe(MulAcc->getExt0Opcode(), MulAcc->getVecOp0(),
-                                  RedTy, MulAcc->isNonNeg0(),
-                                  MulAcc->getDebugLoc());
+    if (Op0Info.ExtOp == Instruction::CastOps::ZExt)
+      Op0 = new VPWidenCastRecipe(Op0Info.ExtOp, MulAcc->getVecOp0(), RedTy,
+                                  Op0Info.IsNonNeg, MulAcc->getDebugLoc());
     else
-      Op0 = new VPWidenCastRecipe(MulAcc->getExt0Opcode(), MulAcc->getVecOp0(),
-                                  RedTy, MulAcc->getDebugLoc());
+      Op0 = new VPWidenCastRecipe(Op0Info.ExtOp, MulAcc->getVecOp0(), RedTy,
+                                  MulAcc->getDebugLoc());
     Op0->getDefiningRecipe()->insertBefore(MulAcc);
     // Prevent reduce.add(mul(ext(A), ext(A))) generate duplicate
     // VPWidenCastRecipe.
     if (MulAcc->getVecOp0() == MulAcc->getVecOp1()) {
       Op1 = Op0;
     } else {
-      if (MulAcc->isZExt1())
-        Op1 = new VPWidenCastRecipe(MulAcc->getExt1Opcode(),
-                                    MulAcc->getVecOp1(), RedTy,
-                                    MulAcc->isNonNeg1(), MulAcc->getDebugLoc());
+      if (Op1Info.ExtOp == Instruction::CastOps::ZExt)
+        Op1 = new VPWidenCastRecipe(Op1Info.ExtOp, MulAcc->getVecOp1(), RedTy,
+                                    Op1Info.IsNonNeg, MulAcc->getDebugLoc());
       else
-        Op1 =
-            new VPWidenCastRecipe(MulAcc->getExt1Opcode(), MulAcc->getVecOp1(),
-                                  RedTy, MulAcc->getDebugLoc());
+        Op1 = new VPWidenCastRecipe(Op1Info.ExtOp, MulAcc->getVecOp1(), RedTy,
+                                    MulAcc->getDebugLoc());
       Op1->getDefiningRecipe()->insertBefore(MulAcc);
     }
   } else {