Range-based cilk_for

clang/include/clang-c/Index.h

@@ -2590,7 +2590,11 @@ enum CXCursorKind {
    */
   CXCursor_CilkForStmt                   = 289,
 
-  CXCursor_LastStmt = CXCursor_CilkForStmt,
+  /** A _Cilk_for range statement.
+   */
+  CXCursor_CilkForRangeStmt                   = 290,
+
+  CXCursor_LastStmt = CXCursor_CilkForRangeStmt,
 
   /**
    * Cursor that represents the translation unit itself.

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -2669,6 +2669,7 @@ DEF_TRAVERSE_STMT(CilkSpawnStmt, {})
 DEF_TRAVERSE_STMT(CilkSpawnExpr, {})
 DEF_TRAVERSE_STMT(CilkSyncStmt, {})
 DEF_TRAVERSE_STMT(CilkForStmt, {})
+DEF_TRAVERSE_STMT(CilkForRangeStmt, {})
 
 // These operators (all of them) do not need any action except
 // iterating over the children.

clang/include/clang/AST/StmtCilk.h

@@ -14,6 +14,7 @@
 #define LLVM_CLANG_AST_STMTCILK_H
 
 #include "clang/AST/Stmt.h"
+#include "clang/AST/StmtCXX.h"
 #include "clang/Basic/SourceLocation.h"
 
 namespace clang {
@@ -84,6 +85,81 @@ class CilkSyncStmt : public Stmt {
   }
 };
 
+/// CilkForRangeStmt - This represents a '_Cilk_for(range-declarator :
+/// range-expression)' or a '_Cilk_for (init-statement range-declarator :
+/// range-expression)', based on a CXXForRangeStmt which is a C++0x
+/// [stmt.ranged]'s ranged for stmt
+///
+/// This is stored as a FORRANGE stmt embedded inside a CILKFORRANGE with some
+/// other necessary semantic components.
+class CilkForRangeStmt : public Stmt {
+  enum {
+    FORRANGE,
+    LOOPINDEX,
+    LOOPINDEXSTMT,
+    LOCALLOOPINDEX,
+    LIMIT,
+    COND,
+    INC,
+    END
+  };
+  Stmt *SubExprs[END];
+
+public:
+  CilkForRangeStmt(const ASTContext &C, CXXForRangeStmt *ForRange,
+                   VarDecl *LoopIndex, DeclStmt *LocalLoopIndex,
+                   DeclStmt *Limit, Expr *Cond, Expr *Inc,
+                   DeclStmt *LoopIndexStmt);
+
+  /// \brief Build an empty cilk for range statement.
+  explicit CilkForRangeStmt(EmptyShell Empty)
+      : Stmt(CilkForRangeStmtClass, Empty) {}
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == CilkForRangeStmtClass;
+  }
+
+  CXXForRangeStmt *getCXXForRangeStmt() const;
+
+  void setForRange(Stmt *S) { SubExprs[FORRANGE] = S; }
+
+  VarDecl *getLoopIndex() const;
+  void setLoopIndex(const ASTContext &C, VarDecl *V);
+
+  VarDecl *getLocalLoopIndex();
+  const VarDecl *getLocalLoopIndex() const;
+
+  Expr *getCond() { return reinterpret_cast<Expr *>(SubExprs[COND]); }
+  Expr *getInc() { return reinterpret_cast<Expr *>(SubExprs[INC]); }
+  DeclStmt *getLoopIndexStmt() {
+    return cast_or_null<DeclStmt>(SubExprs[LOOPINDEXSTMT]);
+  }
+  DeclStmt *getLimitStmt() { return cast_or_null<DeclStmt>(SubExprs[LIMIT]); }
+  DeclStmt *getLocalLoopIndexStmt() {
+    return cast<DeclStmt>(SubExprs[LOCALLOOPINDEX]);
+  }
+
+  const Expr *getCond() const {
+    return reinterpret_cast<Expr *>(SubExprs[COND]);
+  }
+  const Expr *getInc() const { return reinterpret_cast<Expr *>(SubExprs[INC]); }
+  const DeclStmt *getLoopIndexStmt() const {
+    return cast_or_null<DeclStmt>(SubExprs[LOOPINDEXSTMT]);
+  }
+  const DeclStmt *getLimitStmt() const {
+    return cast_or_null<DeclStmt>(SubExprs[LIMIT]);
+  }
+  const DeclStmt *getLocalLoopIndexStmt() const {
+    return cast<DeclStmt>(SubExprs[LOCALLOOPINDEX]);
+  }
+
+  SourceLocation getBeginLoc() const LLVM_READONLY;
+  SourceLocation getEndLoc() const LLVM_READONLY;
+
+  // Iterators
+  child_range children() { return child_range(&SubExprs[0], &SubExprs[END]); }
+};
+
 /// CilkForStmt - This represents a '_Cilk_for(init;cond;inc)' stmt.
 class CilkForStmt : public Stmt {
   SourceLocation CilkForLoc;

clang/include/clang/Basic/DiagnosticParseKinds.td

@@ -1221,8 +1221,6 @@ def err_cilk_for_missing_increment: Error<
   "missing loop increment expression in '_Cilk_for'">;
 def err_cilk_for_missing_semi: Error<
   "expected ';' in '_Cilk_for'">;
-def err_cilk_for_forrange_loop_not_supported: Error<
-  "'_Cilk_for' not supported on for-range loops">;
 def err_cilk_for_foreach_loop_not_supported: Error<
   "'_Cilk_for' not supported on for-each loops">;
 def err_pragma_cilk_invalid_option : Error<
@@ -1235,6 +1233,9 @@ def warn_cilk_for_following_grainsize: Warning<
 def warn_pragma_cilk_grainsize_equals: Warning<
   "'#pragma cilk grainsize' no longer requires '='">,
   InGroup<SourceUsesCilkPlus>;
+def warn_cilk_for_forrange_loop_experimental: Warning<
+  "'_Cilk_for' support for for-range loops is currently EXPERIMENTAL only!">,
+  InGroup<SourceUsesCilkPlus>;
 
 // OpenMP support.
 def warn_pragma_omp_ignored : Warning<

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -9519,7 +9519,13 @@ def note_exits_cilk_for : Note<
   "jump exits the scope of a '_Cilk_for'">;
 def err_jump_out_of_cilk_for : Error<
   "cannot jump out of '_Cilk_for' statement">;
-} // end of Cilk category
+
+// Cilk For Range errors
+
+def err_cilk_for_range_end_minus_begin : Error<
+  "Cannot determine length with '__end - __begin'. Please use a random access iterator.">;
+} 
+// end of Cilk category
 
 let CategoryName = "OpenMP Issue" in {
 // OpenMP support.

clang/include/clang/Basic/StmtNodes.td

@@ -215,6 +215,7 @@ def CilkSyncStmt : StmtNode<Stmt>;
 def CilkSpawnStmt : StmtNode<Stmt>;
 def CilkSpawnExpr : StmtNode<Expr>;
 def CilkForStmt : StmtNode<Stmt>;
+def CilkForRangeStmt: StmtNode<Stmt>;
 
 // OpenMP Directives.
 def OMPExecutableDirective : StmtNode<Stmt, 1>;

clang/include/clang/Sema/Sema.h

@@ -12093,6 +12093,13 @@ class Sema final {
     ConstructorDestructor,
     BuiltinFunction
   };
+  StmtResult ActOnCilkForRangeStmt(Scope *S, SourceLocation ForLoc,
+                                   Stmt *InitStmt, Stmt *First,
+                                   SourceLocation ColonLoc, Expr *Range,
+                                   SourceLocation RParenLoc,
+                                   BuildForRangeKind Kind);
+  StmtResult BuildCilkForRangeStmt(CXXForRangeStmt *S);
+  StmtResult FinishCilkForRangeStmt(Stmt *S, Stmt *B);
 };
 
 /// RAII object that enters a new expression evaluation context.

clang/include/clang/Serialization/ASTBitCodes.h

@@ -1877,6 +1877,7 @@ namespace serialization {
       EXPR_CILKSPAWN,
       STMT_CILKSYNC,
       STMT_CILKFOR,
+      STMT_CILKFORRANGE,
     };
 
     /// The kinds of designators that can occur in a

clang/lib/AST/StmtCXX.cpp

@@ -11,7 +11,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/StmtCXX.h"
-
+#include "clang/AST/Stmt.h"
+#include "clang/AST/StmtCilk.h"
 #include "clang/AST/ASTContext.h"
 
 using namespace clang;
@@ -125,3 +126,63 @@ CoroutineBodyStmt::CoroutineBodyStmt(CoroutineBodyStmt::CtorArgs const &Args)
   std::copy(Args.ParamMoves.begin(), Args.ParamMoves.end(),
             const_cast<Stmt **>(getParamMoves().data()));
 }
+
+/// Constructor for the CilkForRangeStmt
+CilkForRangeStmt::CilkForRangeStmt(const ASTContext &C,
+                                   CXXForRangeStmt *ForRange,
+                                   VarDecl *LoopIndex, DeclStmt *LocalLoopIndex,
+                                   DeclStmt *Limit, Expr *Cond, Expr *Inc,
+                                   DeclStmt *LoopIndexStmt)
+    : Stmt(CilkForRangeStmtClass) {
+  SubExprs[FORRANGE] = ForRange;
+  setLoopIndex(C, LoopIndex);
+  SubExprs[LOCALLOOPINDEX] = LocalLoopIndex;
+  SubExprs[COND] = Cond;
+  SubExprs[INC] = Inc;
+  SubExprs[LOOPINDEXSTMT] = LoopIndexStmt;
+  SubExprs[LIMIT] = Limit;
+}
+
+/// Gets the LOOPINDEX as a VarDecl.
+/// LOOPINDEX is stored as a DeclStmt for the purpose of clean manipulation.
+VarDecl *CilkForRangeStmt::getLoopIndex() const {
+  if (!SubExprs[LOOPINDEX])
+    return nullptr;
+
+  DeclStmt *DS = cast<DeclStmt>(SubExprs[LOOPINDEX]);
+  return cast<VarDecl>(DS->getSingleDecl());
+}
+
+void CilkForRangeStmt::setLoopIndex(const ASTContext &C, VarDecl *V) {
+  if (!V) {
+    SubExprs[LOOPINDEX] = nullptr;
+    return;
+  }
+
+  SourceRange VarRange = V->getSourceRange();
+  SubExprs[LOOPINDEX] =
+      new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(), VarRange.getEnd());
+}
+
+VarDecl *CilkForRangeStmt::getLocalLoopIndex() {
+  Decl *LV = cast<DeclStmt>(getLocalLoopIndexStmt())->getSingleDecl();
+  assert(LV && "No local loop index in CilkForRangeStmt");
+  return cast<VarDecl>(LV);
+}
+
+const VarDecl *CilkForRangeStmt::getLocalLoopIndex() const {
+  return const_cast<CilkForRangeStmt *>(this)->getLocalLoopIndex();
+}
+
+/// returns the FORRANGE stmt embedded in the CilkForRange. (May be null.)
+CXXForRangeStmt *CilkForRangeStmt::getCXXForRangeStmt() const {
+  return cast_or_null<CXXForRangeStmt>(SubExprs[FORRANGE]);
+}
+
+SourceLocation CilkForRangeStmt::getBeginLoc() const {
+  return getCXXForRangeStmt()->getBeginLoc();
+}
+
+SourceLocation CilkForRangeStmt::getEndLoc() const {
+  return getCXXForRangeStmt()->getEndLoc();
+}

clang/lib/AST/StmtPrinter.cpp

@@ -2562,6 +2562,24 @@ void StmtPrinter::VisitCilkForStmt(CilkForStmt *Node) {
     Indent() << "}";
 }
 
+void StmtPrinter::VisitCilkForRangeStmt(CilkForRangeStmt *Node) {
+  Indent() << "_Cilk_for (";
+
+  if (Node->getCXXForRangeStmt()->getInit())
+    PrintInitStmt(Node->getCXXForRangeStmt()->getInit(), 5);
+
+  PrintingPolicy SubPolicy(Policy);
+  SubPolicy.SuppressInitializers = true;
+  Node->getCXXForRangeStmt()->getLoopVariable()->print(OS, SubPolicy,
+                                                       IndentLevel);
+
+  OS << " : ";
+  PrintExpr(Node->getCXXForRangeStmt()->getRangeInit());
+  OS << ")";
+
+  PrintControlledStmt(Node->getCXXForRangeStmt()->getBody());
+}
+
 //===----------------------------------------------------------------------===//
 // Stmt method implementations
 //===----------------------------------------------------------------------===//

clang/lib/AST/StmtProfile.cpp

@@ -1982,6 +1982,10 @@ void StmtProfiler::VisitCilkForStmt(const CilkForStmt *S) {
   VisitStmt(S);
 }
 
+void StmtProfiler::VisitCilkForRangeStmt(const CilkForRangeStmt *S) {
+  VisitStmt(S);
+}
+
 void StmtProfiler::VisitCilkSpawnStmt(const CilkSpawnStmt *S) {
   VisitStmt(S);
 }