fixup! [SLP] Use named structs in vectorizeStores() (NFC)

Author: gbossu

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

@@ -884,6 +884,42 @@ class InstructionsState {
   static InstructionsState invalid() { return {nullptr, nullptr}; }
 };
 
+/// A reference to a ld/st instruction and the distance of its address to a base
+/// pointer.
+struct MemInstAndPtrDist {
+  MemInstAndPtrDist(unsigned InstrIdx, int DistToBasePtr)
+      : InstrIdx(InstrIdx), DistToBasePtr(DistToBasePtr) {}
+  unsigned InstrIdx;
+  int DistToBasePtr;
+};
+struct PtrDistCompare {
+  bool operator()(const MemInstAndPtrDist &Op1,
+                  const MemInstAndPtrDist &Op2) const {
+    return Op1.DistToBasePtr < Op2.DistToBasePtr;
+  }
+};
+
+/// A group of memory instructions that we'll try to bundle together using
+/// vector ops. They are ordered using their signed distance to the address of
+/// this group's BaseInstr.
+struct RelatedMemInsts {
+  RelatedMemInsts(unsigned BaseInstrIdx) { reset(BaseInstrIdx); }
+  void reset(unsigned NewBaseInstr) {
+    BaseInstrIdx = NewBaseInstr;
+    Instrs.clear();
+    Instrs.emplace(NewBaseInstr, 0);
+  }
+
+  // TODO: This should probably just be an std::map
+  using InstSet = std::set<MemInstAndPtrDist, PtrDistCompare>;
+
+  /// The index of the Base instruction, i.e. the one with a 0 pointer distance.
+  unsigned BaseInstrIdx;
+
+  /// Maps an instruction index to a pointer distance from \p BaseInstrIdx.
+  InstSet Instrs;
+};
+
 } // end anonymous namespace
 
 /// \returns true if \p Opcode is allowed as part of the main/alternate
@@ -19923,37 +19959,7 @@ bool SLPVectorizerPass::vectorizeStores(
   BoUpSLP::ValueSet VectorizedStores;
   bool Changed = false;
 
-  /// A store instruction and the distance of its address to a base pointer.
-  struct CandidateInstr {
-    CandidateInstr(unsigned InstrIdx, int DistToBasePtr)
-        : InstrIdx(InstrIdx), DistToBasePtr(DistToBasePtr) {}
-    unsigned InstrIdx;
-    int DistToBasePtr;
-  };
-  struct StoreDistCompare {
-    bool operator()(const CandidateInstr &Op1,
-                    const CandidateInstr &Op2) const {
-      return Op1.DistToBasePtr < Op2.DistToBasePtr;
-    }
-  };
-
-  /// A group of store instructions that we'll try to bundle together.
-  /// They are ordered using their signed distance to the address of this
-  /// set's BaseInstr.
-  struct CandidateBundle {
-    CandidateBundle(unsigned BaseInstrIdx) { reset(BaseInstrIdx); }
-    void reset(unsigned NewBaseInstr) {
-      BaseInstrIdx = NewBaseInstr;
-      Instrs.clear();
-      Instrs.emplace(NewBaseInstr, 0);
-    }
-    // TODO: This should probably just be an std::map
-    using CandidateSet = std::set<CandidateInstr, StoreDistCompare>;
-    unsigned BaseInstrIdx;
-    CandidateSet Instrs;
-  };
-
-  auto TryToVectorize = [&](const CandidateBundle::CandidateSet &StoreSeq) {
+  auto TryToVectorize = [&](const RelatedMemInsts::InstSet &StoreSeq) {
     int PrevDist = -1;
     BoUpSLP::ValueList Operands;
     // Collect the chain into a list.
@@ -20234,7 +20240,7 @@ bool SLPVectorizerPass::vectorizeStores(
   // Need to store the index of the very first store separately, since the set
   // may be reordered after the insertion and the first store may be moved. This
   // container allows to reduce number of calls of getPointersDiff() function.
-  SmallVector<CandidateBundle> SortedStores;
+  SmallVector<RelatedMemInsts> SortedStores;
 
   // Inserts the specified store SI with the given index Idx to the set of the
   // stores. If the store with the same distance is found already - stop
@@ -20269,7 +20275,7 @@ bool SLPVectorizerPass::vectorizeStores(
   // dependencies and no need to waste compile time to try to vectorize them.
   // - Try to vectorize the sequence {1, {1, 0}, {3, 2}}.
   auto FillStoresSet = [&](unsigned Idx, StoreInst *SI) {
-    for (CandidateBundle &StoreSeq : SortedStores) {
+    for (RelatedMemInsts &StoreSeq : SortedStores) {
       std::optional<int> Diff = getPointersDiff(
           Stores[StoreSeq.BaseInstrIdx]->getValueOperand()->getType(),
           Stores[StoreSeq.BaseInstrIdx]->getPointerOperand(),
@@ -20286,9 +20292,9 @@ bool SLPVectorizerPass::vectorizeStores(
       TryToVectorize(StoreSeq.Instrs);
       unsigned ItIdx = It->InstrIdx;
       int ItDist = It->DistToBasePtr;
-      CandidateBundle::CandidateSet PrevSet;
+      RelatedMemInsts::InstSet PrevSet;
       copy_if(StoreSeq.Instrs, std::inserter(PrevSet, PrevSet.end()),
-              [&](const CandidateInstr &I) { return I.InstrIdx > ItIdx; });
+              [&](const MemInstAndPtrDist &I) { return I.InstrIdx > ItIdx; });
       StoreSeq.reset(Idx);
       // Insert stores that followed previous match to try to vectorize them
       // with this store.
@@ -20297,7 +20303,7 @@ bool SLPVectorizerPass::vectorizeStores(
       // Distances to previously found dup store (or this store, since they
       // store to the same addresses).
       SmallVector<int> Dists(Idx - StartIdx, 0);
-      for (const CandidateInstr &Store : reverse(PrevSet)) {
+      for (const MemInstAndPtrDist &Store : reverse(PrevSet)) {
         // Do not try to vectorize sequences, we already tried.
         if (VectorizedStores.contains(Stores[Store.InstrIdx]))
           break;
@@ -20323,7 +20329,7 @@ bool SLPVectorizerPass::vectorizeStores(
       PrevValTy = SI->getValueOperand()->getType();
     // Check that we do not try to vectorize stores of different types.
     if (PrevValTy != SI->getValueOperand()->getType()) {
-      for (CandidateBundle &StoreSeq : SortedStores)
+      for (RelatedMemInsts &StoreSeq : SortedStores)
         TryToVectorize(StoreSeq.Instrs);
       SortedStores.clear();
       PrevValTy = SI->getValueOperand()->getType();
@@ -20332,7 +20338,7 @@ bool SLPVectorizerPass::vectorizeStores(
   }
 
   // Final vectorization attempt.
-  for (CandidateBundle &StoreSeq : SortedStores)
+  for (RelatedMemInsts &StoreSeq : SortedStores)
     TryToVectorize(StoreSeq.Instrs);
 
   return Changed;