fixup! rename CSA to ConditionalScalarAssignment

Author: michaelmaitland

llvm/include/llvm/Analysis/IVDescriptors.h

@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 //
 // This file "describes" induction, recurrence, and conditional scalar
-// assignment (CSA) variables.
+// assignment variables.
 //
 //===----------------------------------------------------------------------===//
 
@@ -424,54 +424,64 @@ class InductionDescriptor {
   SmallVector<Instruction *, 2> RedundantCasts;
 };
 
-/// A Conditional Scalar Assignment (CSA) is an assignment from an initial
+/// A Conditional Scalar Assignment is an assignment from an initial
 /// scalar that may or may not occur.
-class CSADescriptor {
+class ConditionalScalarAssignmentDescriptor {
   /// If the conditional assignment occurs inside a loop, then Phi chooses
   /// the value of the assignment from the entry block or the loop body block.
   PHINode *Phi = nullptr;
 
-  /// The initial value of the CSA. If the condition guarding the assignment is
-  /// not met, then the assignment retains this value.
+  /// The initial value of the ConditionalScalarAssignment. If the condition
+  /// guarding the assignment is not met, then the assignment retains this
+  /// value.
   Value *InitScalar = nullptr;
 
   /// The Instruction that conditionally assigned to inside the loop.
   Instruction *Assignment = nullptr;
 
-  /// Create a CSA Descriptor that models a valid CSA with its members
-  /// initialized correctly.
-  CSADescriptor(PHINode *Phi, Instruction *Assignment, Value *InitScalar)
+  /// Create a ConditionalScalarAssignmentDescriptor that models a valid
+  /// conditional scalar assignment with its members initialized correctly.
+  ConditionalScalarAssignmentDescriptor(PHINode *Phi, Instruction *Assignment,
+                                        Value *InitScalar)
       : Phi(Phi), InitScalar(InitScalar), Assignment(Assignment) {}
 
 public:
-  /// Create a CSA Descriptor that models an invalid CSA.
-  CSADescriptor() = default;
-
-  /// If Phi is the root of a CSA, set CSADesc as the CSA rooted by
-  /// Phi. Otherwise, return a false, leaving CSADesc unmodified.
-  static bool isCSAPhi(PHINode *Phi, Loop *TheLoop, CSADescriptor &CSADesc);
+  /// Create a ConditionalScalarAssignmentDescriptor that models an invalid
+  /// ConditionalScalarAssignment.
+  ConditionalScalarAssignmentDescriptor() = default;
+
+  /// If Phi is the root of a ConditionalScalarAssignment, set
+  /// ConditionalScalarAssignmentDesc as the ConditionalScalarAssignment rooted
+  /// by Phi. Otherwise, return a false, leaving ConditionalScalarAssignmentDesc
+  /// unmodified.
+  static bool
+  isConditionalScalarAssignmentPhi(PHINode *Phi, Loop *TheLoop,
+                                   ConditionalScalarAssignmentDescriptor &Desc);
 
   operator bool() const { return isValid(); }
 
-  /// Returns whether SI is the Assignment in CSA
-  static bool isCSASelect(CSADescriptor Desc, SelectInst *SI) {
+  /// Returns whether SI is the Assignment in ConditionalScalarAssignment
+  static bool isConditionalScalarAssignmentSelect(
+      ConditionalScalarAssignmentDescriptor Desc, SelectInst *SI) {
     return Desc.getAssignment() == SI;
   }
 
-  /// Return whether this CSADescriptor models a valid CSA.
+  /// Return whether this ConditionalScalarAssignmentDescriptor models a valid
+  /// ConditionalScalarAssignment.
   bool isValid() const { return Phi && InitScalar && Assignment; }
 
-  /// Return the PHI that roots this CSA.
+  /// Return the PHI that roots this ConditionalScalarAssignment.
   PHINode *getPhi() const { return Phi; }
 
-  /// Return the initial value of the CSA. This is the value if the conditional
-  /// assignment does not occur.
+  /// Return the initial value of the ConditionalScalarAssignment. This is the
+  /// value if the conditional assignment does not occur.
   Value *getInitScalar() const { return InitScalar; }
 
   /// The Instruction that is used after the loop
   Instruction *getAssignment() const { return Assignment; }
 
-  /// Return the condition that this CSA is conditional upon.
+  /// Return the condition that this ConditionalScalarAssignment is conditional
+  /// upon.
   Value *getCond() const {
     if (auto *SI = dyn_cast_or_null<SelectInst>(Assignment))
       return SI->getCondition();

llvm/include/llvm/Analysis/TargetTransformInfo.h

@@ -1836,7 +1836,7 @@ class TargetTransformInfo {
 
   /// \returns true if the loop vectorizer should vectorize conditional
   /// scalar assignments for the target.
-  bool enableCSAVectorization() const;
+  bool enableConditionalScalarAssignmentVectorization() const;
 
   /// \returns How the target needs this vector-predicated operation to be
   /// transformed.
@@ -2279,7 +2279,7 @@ class TargetTransformInfo::Concept {
                              SmallVectorImpl<Use *> &OpsToSink) const = 0;
 
   virtual bool isVectorShiftByScalarCheap(Type *Ty) const = 0;
-  virtual bool enableCSAVectorization() const = 0;
+  virtual bool enableConditionalScalarAssignmentVectorization() const = 0;
   virtual VPLegalization
   getVPLegalizationStrategy(const VPIntrinsic &PI) const = 0;
   virtual bool hasArmWideBranch(bool Thumb) const = 0;
@@ -3096,8 +3096,8 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept {
     return Impl.isVectorShiftByScalarCheap(Ty);
   }
 
-  bool enableCSAVectorization() const override {
-    return Impl.enableCSAVectorization();
+  bool enableConditionalScalarAssignmentVectorization() const override {
+    return Impl.enableConditionalScalarAssignmentVectorization();
   }
 
   VPLegalization

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

@@ -1021,7 +1021,7 @@ class TargetTransformInfoImplBase {
 
   bool isVectorShiftByScalarCheap(Type *Ty) const { return false; }
 
-  bool enableCSAVectorization() const { return false; }
+  bool enableConditionalScalarAssignmentVectorization() const { return false; }
 
   TargetTransformInfo::VPLegalization
   getVPLegalizationStrategy(const VPIntrinsic &PI) const {

llvm/include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h

@@ -269,9 +269,11 @@ class LoopVectorizationLegality {
   /// induction descriptor.
   using InductionList = MapVector<PHINode *, InductionDescriptor>;
 
-  /// CSAList contains the CSA descriptors for all the CSAs that were found
-  /// in the loop, rooted by their phis.
-  using CSAList = MapVector<PHINode *, CSADescriptor>;
+  /// ConditionalScalarAssignmentList contains the
+  /// ConditionalScalarAssignmentDescriptors for all the conditional scalar
+  /// assignments  that were found in the loop, rooted by their phis.
+  using ConditionalScalarAssignmentList =
+      MapVector<PHINode *, ConditionalScalarAssignmentDescriptor>;
 
   /// RecurrenceSet contains the phi nodes that are recurrences other than
   /// inductions and reductions.
@@ -325,11 +327,17 @@ class LoopVectorizationLegality {
   /// Returns True if V is a Phi node of an induction variable in this loop.
   bool isInductionPhi(const Value *V) const;
 
-  /// Returns the CSAs found in the loop.
-  const CSAList &getCSAs() const { return CSAs; }
+  /// Returns the conditional scalar assignments found in the loop.
+  const ConditionalScalarAssignmentList &
+  getConditionalScalarAssignments() const {
+    return ConditionalScalarAssignments;
+  }
 
-  /// Returns true if Phi is the root of a CSA in the loop.
-  bool isCSAPhi(PHINode *Phi) const { return CSAs.count(Phi) != 0; }
+  /// Returns true if Phi is the root of a conditional scalar assignments in the
+  /// loop.
+  bool isConditionalScalarAssignmentPhi(PHINode *Phi) const {
+    return ConditionalScalarAssignments.count(Phi) != 0;
+  }
 
   /// Returns a pointer to the induction descriptor, if \p Phi is an integer or
   /// floating point induction.
@@ -560,9 +568,11 @@ class LoopVectorizationLegality {
   void addInductionPhi(PHINode *Phi, const InductionDescriptor &ID,
                        SmallPtrSetImpl<Value *> &AllowedExit);
 
-  /// Updates the vetorization state by adding \p Phi to the CSA list.
-  void addCSAPhi(PHINode *Phi, const CSADescriptor &CSADesc,
-                 SmallPtrSetImpl<Value *> &AllowedExit);
+  /// Updates the vetorization state by adding \p Phi to the
+  /// ConditionalScalarAssignment list.
+  void addConditionalScalarAssignmentPhi(
+      PHINode *Phi, const ConditionalScalarAssignmentDescriptor &Desc,
+      SmallPtrSetImpl<Value *> &AllowedExit);
 
   /// The loop that we evaluate.
   Loop *TheLoop;
@@ -609,7 +619,7 @@ class LoopVectorizationLegality {
   InductionList Inductions;
 
   /// Holds the conditional scalar assignments
-  CSAList CSAs;
+  ConditionalScalarAssignmentList ConditionalScalarAssignments;
 
   /// Holds all the casts that participate in the update chain of the induction
   /// variables, and that have been proven to be redundant (possibly under a

llvm/lib/Analysis/IVDescriptors.cpp

@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 //
 // This file "describes" induction, recurrence, and conditional scalar
-// assignment (CSA) variables.
+// assignment variables.
 //
 //===----------------------------------------------------------------------===//
 
@@ -1572,15 +1572,17 @@ bool InductionDescriptor::isInductionPHI(
   return true;
 }
 
-/// Return CSADescriptor that describes a CSA that matches one of these
-/// patterns:
+/// Return ConditionalScalarAssignmentDescriptor that describes a
+/// ConditionalScalarAssignment that matches one of these patterns:
 ///   phi loop_inv, (select cmp, value, phi)
 ///   phi loop_inv, (select cmp, phi, value)
 ///   phi (select cmp, value, phi), loop_inv
 ///   phi (select cmp, phi, value), loop_inv
-/// If the CSA does not match any of these paterns, return a CSADescriptor
-/// that describes an InvalidCSA.
-bool CSADescriptor::isCSAPhi(PHINode *Phi, Loop *TheLoop, CSADescriptor &CSA) {
+/// If the ConditionalScalarAssignment does not match any of these paterns,
+/// return a ConditionalScalarAssignmentDescriptor that describes an
+/// InvalidConditionalScalarAssignment.
+bool ConditionalScalarAssignmentDescriptor::isConditionalScalarAssignmentPhi(
+    PHINode *Phi, Loop *TheLoop, ConditionalScalarAssignmentDescriptor &Desc) {
 
   // Must be a scalar.
   Type *Type = Phi->getType();
@@ -1623,6 +1625,6 @@ bool CSADescriptor::isCSAPhi(PHINode *Phi, Loop *TheLoop, CSADescriptor &CSA) {
       !IsOnlyUsedOutsideLoop(Select, Phi))
     return false;
 
-  CSA = CSADescriptor(Phi, Select, LoopInv);
+  Desc = ConditionalScalarAssignmentDescriptor(Phi, Select, LoopInv);
   return true;
 }

llvm/lib/Analysis/TargetTransformInfo.cpp

@@ -1356,8 +1356,9 @@ bool TargetTransformInfo::preferEpilogueVectorization() const {
   return TTIImpl->preferEpilogueVectorization();
 }
 
-bool TargetTransformInfo::enableCSAVectorization() const {
-  return TTIImpl->enableCSAVectorization();
+bool TargetTransformInfo::enableConditionalScalarAssignmentVectorization()
+    const {
+  return TTIImpl->enableConditionalScalarAssignmentVectorization();
 }
 
 TargetTransformInfo::VPLegalization

llvm/lib/Target/RISCV/RISCVTargetTransformInfo.cpp

@@ -2370,7 +2370,7 @@ bool RISCVTTIImpl::isLegalMaskedExpandLoad(Type *DataTy, Align Alignment) {
   return true;
 }
 
-bool RISCVTTIImpl::enableCSAVectorization() const {
+bool RISCVTTIImpl::enableConditionalScalarAssignmentVectorization() const {
   return ST->hasVInstructions() &&
          ST->getProcFamily() == RISCVSubtarget::SiFive7;
 }

llvm/lib/Target/RISCV/RISCVTargetTransformInfo.h

@@ -308,7 +308,7 @@ class RISCVTTIImpl : public BasicTTIImplBase<RISCVTTIImpl> {
 
   /// \returns true if the loop vectorizer should vectorize conditional
   /// scalar assignments for the target.
-  bool enableCSAVectorization() const;
+  bool enableConditionalScalarAssignmentVectorization() const;
 
   /// \returns How the target needs this vector-predicated operation to be
   /// transformed.

llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp

@@ -83,9 +83,9 @@ static cl::opt<bool> EnableHistogramVectorization(
     "enable-histogram-loop-vectorization", cl::init(false), cl::Hidden,
     cl::desc("Enables autovectorization of some loops containing histograms"));
 
-static cl::opt<bool>
-    EnableCSA("enable-csa-vectorization", cl::init(false), cl::Hidden,
-              cl::desc("Control whether CSA loop vectorization is enabled"));
+static cl::opt<bool> EnableConditionalScalarAssignment(
+    "enable-csa-vectorization", cl::init(false), cl::Hidden,
+    cl::desc("Control whether loop vectorization is enabled"));
 
 /// Maximum vectorization interleave count.
 static const unsigned MaxInterleaveFactor = 16;
@@ -753,13 +753,16 @@ bool LoopVectorizationLegality::setupOuterLoopInductions() {
   return llvm::all_of(Header->phis(), IsSupportedPhi);
 }
 
-void LoopVectorizationLegality::addCSAPhi(
-    PHINode *Phi, const CSADescriptor &CSADesc,
+void LoopVectorizationLegality::addConditionalScalarAssignmentPhi(
+    PHINode *Phi, const ConditionalScalarAssignmentDescriptor &Desc,
     SmallPtrSetImpl<Value *> &AllowedExit) {
-  assert(CSADesc.isValid() && "Expected Valid CSADescriptor");
-  LLVM_DEBUG(dbgs() << "LV: found legal CSA opportunity" << *Phi << "\n");
+  assert(Desc.isValid() &&
+         "Expected Valid ConditionalScalarAssignmentDescriptor");
+  LLVM_DEBUG(
+      dbgs() << "LV: found legal conditional scalar assignment opportunity"
+             << *Phi << "\n");
   AllowedExit.insert(Phi);
-  CSAs.insert({Phi, CSADesc});
+  ConditionalScalarAssignments.insert({Phi, Desc});
 }
 
 /// Checks if a function is scalarizable according to the TLI, in
@@ -887,12 +890,15 @@ bool LoopVectorizationLegality::canVectorizeInstrs() {
           continue;
         }
 
-        // Check if the PHI can be classified as a CSA PHI.
-        if (EnableCSA || (TTI->enableCSAVectorization() &&
-                          EnableCSA.getNumOccurrences() == 0)) {
-          CSADescriptor CSADesc;
-          if (CSADescriptor::isCSAPhi(Phi, TheLoop, CSADesc)) {
-            addCSAPhi(Phi, CSADesc, AllowedExit);
+        // Check if the PHI can be classified as a conditional scalar assignment
+        // PHI.
+        if (EnableConditionalScalarAssignment ||
+            (TTI->enableConditionalScalarAssignmentVectorization() &&
+             EnableConditionalScalarAssignment.getNumOccurrences() == 0)) {
+          ConditionalScalarAssignmentDescriptor Desc;
+          if (ConditionalScalarAssignmentDescriptor::
+                  isConditionalScalarAssignmentPhi(Phi, TheLoop, Desc)) {
+            addConditionalScalarAssignmentPhi(Phi, Desc, AllowedExit);
             continue;
           }
         }
@@ -1868,13 +1874,13 @@ bool LoopVectorizationLegality::canFoldTailByMasking() const {
     ReductionLiveOuts.insert(Reduction.second.getLoopExitInstr());
 
   SmallPtrSet<const Value *, 8> CSALiveOuts;
-  for (const auto &CSA : getCSAs())
+  for (const auto &CSA : getConditionalScalarAssignments())
     CSALiveOuts.insert(CSA.second.getAssignment());
 
   // TODO: handle non-reduction outside users when tail is folded by masking.
   for (auto *AE : AllowedExit) {
     // Check that all users of allowed exit values are inside the loop or
-    // are the live-out of a reduction or CSA.
+    // are the live-out of a reduction or conditional scalar assignment.
     if (ReductionLiveOuts.count(AE) || CSALiveOuts.count(AE))
       continue;
     for (User *U : AE->users()) {

llvm/lib/Transforms/Vectorize/LoopVectorizationPlanner.h

@@ -261,20 +261,24 @@ class VPBuilder {
         FPBinOp ? FPBinOp->getFastMathFlags() : FastMathFlags()));
   }
 
-  VPInstruction *createCSAMaskPhi(VPValue *InitMask, DebugLoc DL,
-                                  const Twine &Name) {
-    return createInstruction(VPInstruction::CSAMaskPhi, {InitMask}, DL, Name);
+  VPInstruction *createConditionalScalarAssignmentMaskPhi(VPValue *InitMask,
+                                                          DebugLoc DL,
+                                                          const Twine &Name) {
+    return createInstruction(VPInstruction::ConditionalScalarAssignmentMaskPhi,
+                             {InitMask}, DL, Name);
   }
 
   VPInstruction *createAnyOf(VPValue *Cond, DebugLoc DL, const Twine &Name) {
     return createInstruction(VPInstruction::AnyOf, {Cond}, DL, Name);
   }
 
-  VPInstruction *createCSAMaskSel(VPValue *Cond, VPValue *MaskPhi,
-                                  VPValue *AnyOf, DebugLoc DL,
-                                  const Twine &Name) {
-    return createInstruction(VPInstruction::CSAMaskSel, {Cond, MaskPhi, AnyOf},
-                             DL, Name);
+  VPInstruction *createConditionalScalarAssignmentMaskSel(VPValue *Cond,
+                                                          VPValue *MaskPhi,
+                                                          VPValue *AnyOf,
+                                                          DebugLoc DL,
+                                                          const Twine &Name) {
+    return createInstruction(VPInstruction::ConditionalScalarAssignmentMaskSel,
+                             {Cond, MaskPhi, AnyOf}, DL, Name);
   }
 
   //===--------------------------------------------------------------------===//