[Polly] Allow to link MemoryAccesses together (linked list fashion)

[grosser]

Hi Johannes,

I see that this patch makes it possible to model instruction that cause multiple memory accesses. However, it seems the patch is by itself not sufficient to actually trigger or test this code. Would it make sense to fold this patch into the code that makes use of this patch and with which we can actually test this patch?

Tobias

[jdoerfert]

Will do!

include/polly/ScopInfo.h

private:
   ReductionType RedType = RT_NONE;
 
   /// @brief The access instruction of this memory access.
   Instruction *Inst;
 
   /// Updated access relation read from JSCOP file.
   isl_map *newAccessRelation;
 
+  /// @brief Other memory effects which are linked to this one.
+  ///
+  /// If an instruction can cause multiple memory accesses or effects they are
+  /// linked together (linked list fashion).
+  MemoryAccess *NextMA;
+
   void assumeNoOutOfBound(const IRAccess &Access);
 
 public:
   /// @brief Create a memory access from an access in LLVM-IR.
   ///
   /// @param Access     The memory access.
   /// @param Statement  The statement that contains the access.
   /// @param SE         The ScalarEvolution analysis.
public:
   void setNewAccessRelation(__isl_take isl_map *newAccessRelation);
 
   /// @brief Mark this a reduction like access
   void markAsReductionLike(ReductionType RT) { RedType = RT; }
 
   /// @brief Align the parameters in the access relation to the scop context
   void realignParams();
 
+  /// @brief Set the next MemoryAccess (linked list fashion).
+  void setNextMA(MemoryAccess *MA) { NextMA = MA; }
+
+  /// @brief Get the next MemoryAccess (linked list fashion).
+  MemoryAccess *setNextMA() const { return NextMA; }
+
   /// @brief Print the MemoryAccess.
   ///
   /// @param OS The output stream the MemoryAccess is printed to.
   void print(raw_ostream &OS) const;
 
   /// @brief Print the MemoryAccess to stderr.
   void dump() const;
 };

lib/Analysis/ScopInfo.cpp

void ScopStmt::buildScattering(SmallVectorImpl<unsigned> &Scatter) {
   Scattering = isl_map_align_params(Scattering, Parent.getParamSpace());
 }
 
 void ScopStmt::buildAccesses(TempScop &tempScop, const Region &CurRegion) {
   for (auto &&Access : *tempScop.getAccessFunctions(BB)) {
     MemAccs.push_back(new MemoryAccess(Access.first, Access.second, this));
 
     // We do not track locations for scalar memory accesses at the moment.
-    //
-    // We do not have a use for this information at the moment. If we need this
-    // at some point, the "instruction -> access" mapping needs to be enhanced
-    // as a single instruction could then possibly perform multiple accesses.
     if (!Access.first.isScalar()) {
-      assert(!InstructionToAccess.count(Access.second) &&
-             "Unexpected 1-to-N mapping on instruction to access map!");
-      InstructionToAccess[Access.second] = MemAccs.back();
+      MemoryAccess *&MA = InstructionToAccess[Access.second];
+      if (MA)
+        MemAccs.back()->setNextMA(MA);
+      MA = MemAccs.back();
     }
   }
 }
 
 void ScopStmt::realignParams() {
   for (MemoryAccess *MA : *this)
     MA->realignParams();