[Fix] [Simplify] Fix r302986 that introduced non-inferrable templates.

[bollu]

Summary

• auto + decltype + template use waas not inferrable in Transform/Simplify.cpp accessesInOrder.

• changed code to explicitly construct required vector instead of using higher order iterator helpers.

• Failing compiler spec: Apple LLVM version 7.3.0 (clang-703.0.31) Target: x86_64-apple-darwin15.6.0

[Meinersbur]

LGTM

I hoped to use that iterator in more places, which unfortunately doesn't work if it doesn't compile everywhere. Most of the time MSVC is the compiler having problems compiling templates, not Apple's clang.

[Meinersbur]

Please don't forget the "[Polly]" prefix in reviews. Omit the "[Fix]", it is already in the title.

[bollu]

@Meinersbur: understood, sorry for the accident.

[bollu]

Closed by r303039

lib/Transform/Simplify.cpp

 static bool isExplicitAccess(MemoryAccess *MA) {
   return MA->isOriginalArrayKind();
 }
 
 static bool isImplicitWrite(MemoryAccess *MA) {
   return MA->isWrite() && MA->isOriginalScalarKind();
 }
 
-/// Return an iterator range that iterates over MemoryAccesses in the order in
+/// Return a vector that contains MemoryAccesses in the order in
 /// which they are executed.
 ///
 /// The order is:
 /// - Implicit reads (BlockGenerator::generateScalarLoads)
 /// - Explicit reads and writes (BlockGenerator::generateArrayLoad,
 ///   BlockGenerator::generateArrayStore)
 ///   - In block statements, the accesses are in order in which their
 ///     instructions are executed.
 ///   - In region statements, that order of execution is not predictable at
 ///     compile-time.
 /// - Implicit writes (BlockGenerator::generateScalarStores)
 ///   The order in which implicit writes are executed relative to each other is
 ///   undefined.
-static auto accessesInOrder(ScopStmt *Stmt) -> decltype(concat<MemoryAccess *>(
-    make_filter_range(make_range(Stmt->begin(), Stmt->end()), isImplicitRead),
-    make_filter_range(make_range(Stmt->begin(), Stmt->end()), isExplicitAccess),
-    make_filter_range(make_range(Stmt->begin(), Stmt->end()),
-                      isImplicitWrite))) {
-  auto AllRange = make_range(Stmt->begin(), Stmt->end());
-  return concat<MemoryAccess *>(make_filter_range(AllRange, isImplicitRead),
-                                make_filter_range(AllRange, isExplicitAccess),
-                                make_filter_range(AllRange, isImplicitWrite));
+static SmallVector<MemoryAccess *, 32> getAccessesInOrder(ScopStmt &Stmt) {
+
+  SmallVector<MemoryAccess *, 32> Accesses;
+
+  for (MemoryAccess *MemAcc : Stmt)
+    if (isImplicitRead(MemAcc))
+      Accesses.push_back(MemAcc);
+
+  for (MemoryAccess *MemAcc : Stmt)
+    if (isExplicitAccess(MemAcc))
+      Accesses.push_back(MemAcc);
+
+  for (MemoryAccess *MemAcc : Stmt)
+    if (isImplicitWrite(MemAcc))
+      Accesses.push_back(MemAcc);
+
+  return Accesses;
 }
 
 class Simplify : public ScopPass {
 private:
   /// The last/current SCoP that is/has been processed.
   Scop *S;
 
   /// Number of writes that are overwritten anyway.
private:
   /// There must be no read of the same value between the write (that is to be
   /// removed) and the overwrite.
   void removeOverwrites() {
     for (auto &Stmt : *S) {
       auto Domain = give(Stmt.getDomain());
       isl::union_map WillBeOverwritten =
           isl::union_map::empty(give(S->getParamSpace()));
 
-      auto AccRange = accessesInOrder(&Stmt);
-      SmallVector<MemoryAccess *, 32> Accesses{AccRange.begin(),
-                                               AccRange.end()};
+      SmallVector<MemoryAccess *, 32> Accesses(getAccessesInOrder(Stmt));
 
       // Iterate in reverse order, so the overwrite comes before the write that
       // is to be removed.
       for (auto *MA : reverse(Accesses)) {
 
         // In region statements, the explicit accesses can be in blocks that are
         // can be executed in any order. We therefore process only the implicit
         // writes and stop after that.