cilk-builtins.def (__cilkrts_cilk_for_32): New.

gcc/
	* cilk-builtins.def (__cilkrts_cilk_for_32): New.
	(__cilkrts_cilk_for_64): Likewise.
	* cilk-common.c (declare_cilk_for_builtin): New function.
	(cilk_init_builtins): Declare __cilkrts_cilk_for_32 and
	__cilkrts_cilk_for_64 bultins.
	* cilk.h (enum cilk_tree_index): Added CILK_TI_F_LOOP_32 and
	CILK_TI_F_LOOP_64.
	(cilk_for_32_fndecl): New define.
	(cilk_for_64_fndecl): Likewise.
	* gimple-pretty-print.c (dump_gimple_omp_for): Correct hadling of
	GF_OMP_FOR_KIND_CILKFOR cases; Added NE_EXPR case.
	* gimple.h (enum gf_mask): Added GF_OMP_FOR_KIND_CILKFOR; adjusted
	GF_OMP_FOR_KIND_MASK, GF_OMP_FOR_SIMD, GF_OMP_FOR_COMBINED,
	GF_OMP_FOR_COMBINED_INTO.
	* gimplify.c (gimplify_scan_omp_clauses): Added
	OMP_CLAUSE__CILK_FOR_COUNT_ case.
	(gimplify_adjust_omp_clauses): Ditto.
	(gimplify_omp_for): Added CILK_FOR case.
	(gimplify_expr): Ditto.
	* omp-low.c: Include cilk.h.
	(extract_omp_for_data): Set appropriate kind for
	GF_OMP_FOR_KIND_CILKFOR; added check for GF_OMP_FOR_KIND_CILKFOR.
	(scan_sharing_clauses): Added OMP_CLAUSE__CILK_FOR_COUNT_ cases.
	(create_omp_child_function_name): Added second argument to handle
	cilk_for case.
	(cilk_for_check_loop_diff_type): New function.
	(expand_cilk_for_call): Likewise.
	(expand_cilk_for): Likewise.
	(create_omp_child_function): Set cilk_for_count; handle the cases when
	it is true; call create_omp_child_function_name with second argument.
	(expand_omp_taskreg): Set is_cilk_for and handle cases when it's true.
	(expand_omp_for): Handle case of GF_OMP_FOR_KIND_CILKFOR.
	* tree-core.h (omp_clause_code): Added OMP_CLAUSE__CILK_FOR_COUNT_.
	* tree-nested.c (convert_nonlocal_omp_clauses): Added
	OMP_CLAUSE__CILK_FOR_COUNT_ case.
	(convert_local_omp_clauses): Ditto.
	* tree-pretty-print.c (dump_omp_clause): Added
	OMP_CLAUSE__CILK_FOR_COUNT_ and OMP_CLAUSE_SCHEDULE_CILKFOR cases.
	(dump_generic_node): Added CILK_FOR case.
	* tree.c (omp_clause_num_ops): New element
	OMP_CLAUSE__CILK_FOR_COUNT_ (1).
	(omp_clause_code_name): New element _Cilk_for_count_.
	(walk_tree_1): Added OMP_CLAUSE__CILK_FOR_COUNT_ case.
	* tree.def: Add tree code for CILK_FOR.

gcc/c/
	* c-parser.c (c_parser_cilk_for): New function.
	(c_parser_cilk_grainsize): Likewise.
	(c_get_temp_regvar): Likewise.
	(c_parser_statement_after_labels): Added RID_CILK_FOR case.
	(c_parser_pragma): Added PRAGMA_CILK_GRAINSIZE case.
	(c_parser_omp_for_loop): Added CILK_FOR and CILK_SIMD checks.
	* c-typeck.c (c_finish_omp_clauses): Added OMP_CLAUSE__CILK_FOR_COUNT_
	case.

gcc/cp/
	* cp-cilkplus.c (cpp_validate_cilk_plus_loop_aux): Loc definition
	simplified.
	* parser.c (cp_parser_cilk_for): New function.
	(cp_parser_cilk_grainsize): Likewise.
	(cp_parser_statement): Added RID_CILK_FOR case.
	(cp_parser_omp_for_cond): Added CILK_FOR check.
	(cp_parser_omp_for_loop_init): Change function argument to accept
	tree_code instead just a bool flag; change the check to use that
	tree_code; check for initialization declaration in case of Cilk_for.
	(cp_parser_omp_for_loop): Added checks for CILK_FOR and RID_CILK_FOR;
	changed call to cp_parser_omp_for_loop_init according new arguments'
	list.
	(cp_parser_pragma): Added PRAGMA_CILK_GRAINSIZE case.
	* pt.c (tsubst_expr): Added CILK_FOR case.
	* semantics.c: Include convert.h.
	(finish_omp_clauses): Properly handle OMP_CLAUSE_SCHEDULE_CILKFOR
	case; added OMP_CLAUSE__CILK_FOR_COUNT_.
	(handle_omp_for_class_iterator): New argument lastp and its usage;
	added NE_EXPR case.
	(finish_omp_for): Changed call to handle_omp_for_class_iterator
	according new arguments' list; in case of Cilk_for save very first
	decl and create empty stmt_list block; use block to build correct
	statement tree.

gcc/c-family/
	* c-cilkplus.c (cilk_for_number_of_iterations): New function.
	* c-common.c (c_common_reswords): Added _Cilk_for.
	* c-common.h (enum rid): Added RID_CILK_FOR.
	(cilk_for_number_of_iterations): Add declaration.
	* c-omp.c (c_finish_omp_for): Added checks for CILK_SIMD and
	CILK_FOR.
	* c-pragma.c (init_pragma): Register "grainsize" pragma.
	* c-pragma.h (enum pragma_kind): Add PRAGMA_CILK_GRAINSIZE.

gcc/testsuite/
	* c-c++-common/cilk-plus/CK/cilk-fors.c: New test.
	* c-c++-common/cilk-plus/CK/cilk-for-2.c: New test.
	* c-c++-common/cilk-plus/CK/cilk-for-3.c: New test.
	* c-c++-common/cilk-plus/CK/cilk_for_errors.c: New test.
	* c-c++-common/cilk-plus/CK/cilk_for_grain.c: New test.
	* c-c++-common/cilk-plus/CK/cilk_for_grain_errors.c: New test.
	* c-c++-common/cilk-plus/CK/cilk_for_ptr_iter.c: New test.
	* c-c++-common/cilk-plus/CK/nested_cilk_for.c: New test.
	* g++.dg/cilk-plus/CK/cf3.cc: New test.
	* g++.dg/cilk-plus/CK/cilk-for-tplt.cc: New test.
	* g++.dg/cilk-plus/CK/for1.cc: New test.
	* g++.dg/cilk-plus/CK/stl_iter.cc: New test.
	* g++.dg/cilk-plus/CK/stl_rev_iter.cc: New test.
	* g++.dg/cilk-plus/CK/stl_test.cc: New test.

Co-Authored-By: Balaji V. Iyer <balaji.v.iyer@intel.com>
Co-Authored-By: Igor Zamyatin <igor.zamyatin@intel.com>

From-SVN: r214818

1 files changed, 145 insertions, 7 deletions

diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 168bde8..01748da 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -49,6 +49,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "bitmap.h"
 #include "omp-low.h"
 #include "builtins.h"
+#include "convert.h"
 
 static bool verify_constant (tree, bool, bool *, bool *);
 #define VERIFY_CONSTANT(X)						\
@@ -5424,6 +5425,8 @@ finish_omp_clauses (tree clauses)
 	  else if (t == error_mark_node)
 	    remove = true;
 	  else if (!type_dependent_expression_p (t)
+		   && (OMP_CLAUSE_SCHEDULE_KIND (c)
+		       != OMP_CLAUSE_SCHEDULE_CILKFOR)
 		   && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
 	    {
 	      error ("schedule chunk size expression must be integral");
@@ -5433,7 +5436,19 @@ finish_omp_clauses (tree clauses)
 	    {
 	      t = mark_rvalue_use (t);
 	      if (!processing_template_decl)
-		t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
+		{
+		  if (OMP_CLAUSE_SCHEDULE_KIND (c)
+		      == OMP_CLAUSE_SCHEDULE_CILKFOR)
+		    {
+		      t = convert_to_integer (long_integer_type_node, t);
+		      if (t == error_mark_node)
+			{
+			  remove = true;
+			  break;
+			}
+		    }
+		  t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
+		}
 	      OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
 	    }
 	  break;
@@ -5734,6 +5749,7 @@ finish_omp_clauses (tree clauses)
 	case OMP_CLAUSE_SECTIONS:
 	case OMP_CLAUSE_TASKGROUP:
 	case OMP_CLAUSE_PROC_BIND:
+	case OMP_CLAUSE__CILK_FOR_COUNT_:
 	  break;
 
 	case OMP_CLAUSE_INBRANCH:
@@ -6053,7 +6069,7 @@ finish_omp_task (tree clauses, tree body)
 static bool
 handle_omp_for_class_iterator (int i, location_t locus, tree declv, tree initv,
 			       tree condv, tree incrv, tree *body,
-			       tree *pre_body, tree clauses)
+			       tree *pre_body, tree clauses, tree *lastp)
 {
   tree diff, iter_init, iter_incr = NULL, last;
   tree incr_var = NULL, orig_pre_body, orig_body, c;
@@ -6073,6 +6089,7 @@ handle_omp_for_class_iterator (int i, location_t locus, tree declv, tree initv,
     case GE_EXPR:
     case LT_EXPR:
     case LE_EXPR:
+    case NE_EXPR:
       if (TREE_OPERAND (cond, 1) == iter)
 	cond = build2 (swap_tree_comparison (TREE_CODE (cond)),
 		       TREE_TYPE (cond), iter, TREE_OPERAND (cond, 0));
@@ -6285,6 +6302,7 @@ handle_omp_for_class_iterator (int i, location_t locus, tree declv, tree initv,
   TREE_VEC_ELT (initv, i) = init;
   TREE_VEC_ELT (condv, i) = cond;
   TREE_VEC_ELT (incrv, i) = incr;
+  *lastp = last;
 
   return false;
 }
@@ -6301,7 +6319,8 @@ finish_omp_for (location_t locus, enum tree_code code, tree declv, tree initv,
 		tree condv, tree incrv, tree body, tree pre_body, tree clauses)
 {
   tree omp_for = NULL, orig_incr = NULL;
-  tree decl, init, cond, incr;
+  tree decl = NULL, init, cond, incr, orig_decl = NULL_TREE, block = NULL_TREE;
+  tree last = NULL_TREE;
   location_t elocus;
   int i;
 
@@ -6431,8 +6450,11 @@ finish_omp_for (location_t locus, enum tree_code code, tree declv, tree initv,
 				"iteration variable %qE", decl);
 	      return NULL;
 	    }
+	  if (code == CILK_FOR && i == 0)
+	    orig_decl = decl;
 	  if (handle_omp_for_class_iterator (i, locus, declv, initv, condv,
-					     incrv, &body, &pre_body, clauses))
+					     incrv, &body, &pre_body,
+					     clauses, &last))
 	    return NULL;
 	  continue;
 	}
@@ -6485,11 +6507,18 @@ finish_omp_for (location_t locus, enum tree_code code, tree declv, tree initv,
   if (IS_EMPTY_STMT (pre_body))
     pre_body = NULL;
 
+  if (code == CILK_FOR && !processing_template_decl)
+    block = push_stmt_list ();
+
   omp_for = c_finish_omp_for (locus, code, declv, initv, condv, incrv,
 			      body, pre_body);
 
   if (omp_for == NULL)
-    return NULL;
+    {
+      if (block)
+	pop_stmt_list (block);
+      return NULL;
+    }
 
   for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for)); i++)
     {
@@ -6523,8 +6552,117 @@ finish_omp_for (location_t locus, enum tree_code code, tree declv, tree initv,
       if (orig_incr)
 	TREE_VEC_ELT (OMP_FOR_INCR (omp_for), i) = TREE_VEC_ELT (orig_incr, i);
     }
-  if (omp_for != NULL)
-    OMP_FOR_CLAUSES (omp_for) = clauses;
+  OMP_FOR_CLAUSES (omp_for) = clauses;
+
+  if (block)
+    {
+      tree omp_par = make_node (OMP_PARALLEL);
+      TREE_TYPE (omp_par) = void_type_node;
+      OMP_PARALLEL_CLAUSES (omp_par) = NULL_TREE;
+      tree bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
+      TREE_SIDE_EFFECTS (bind) = 1;
+      BIND_EXPR_BODY (bind) = pop_stmt_list (block);
+      OMP_PARALLEL_BODY (omp_par) = bind;
+      if (OMP_FOR_PRE_BODY (omp_for))
+	{
+	  add_stmt (OMP_FOR_PRE_BODY (omp_for));
+	  OMP_FOR_PRE_BODY (omp_for) = NULL_TREE;
+	}
+      init = TREE_VEC_ELT (OMP_FOR_INIT (omp_for), 0);
+      decl = TREE_OPERAND (init, 0);
+      cond = TREE_VEC_ELT (OMP_FOR_COND (omp_for), 0);
+      incr = TREE_VEC_ELT (OMP_FOR_INCR (omp_for), 0);
+      tree t = TREE_OPERAND (cond, 1), c, clauses, *pc;
+      clauses = OMP_FOR_CLAUSES (omp_for);
+      OMP_FOR_CLAUSES (omp_for) = NULL_TREE;
+      for (pc = &clauses; *pc; )
+	if (OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_SCHEDULE)
+	  {
+	    gcc_assert (OMP_FOR_CLAUSES (omp_for) == NULL_TREE);
+	    OMP_FOR_CLAUSES (omp_for) = *pc;
+	    *pc = OMP_CLAUSE_CHAIN (*pc);
+	    OMP_CLAUSE_CHAIN (OMP_FOR_CLAUSES (omp_for)) = NULL_TREE;
+	  }
+	else
+	  {
+	    gcc_assert (OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_FIRSTPRIVATE);
+	    pc = &OMP_CLAUSE_CHAIN (*pc);
+	  }
+      if (TREE_CODE (t) != INTEGER_CST)
+	{
+	  TREE_OPERAND (cond, 1) = get_temp_regvar (TREE_TYPE (t), t);
+	  c = build_omp_clause (input_location, OMP_CLAUSE_FIRSTPRIVATE);
+	  OMP_CLAUSE_DECL (c) = TREE_OPERAND (cond, 1);
+	  OMP_CLAUSE_CHAIN (c) = clauses;
+	  clauses = c;
+	}
+      if (TREE_CODE (incr) == MODIFY_EXPR)
+	{
+	  t = TREE_OPERAND (TREE_OPERAND (incr, 1), 1);
+	  if (TREE_CODE (t) != INTEGER_CST)
+	    {
+	      TREE_OPERAND (TREE_OPERAND (incr, 1), 1)
+		= get_temp_regvar (TREE_TYPE (t), t);
+	      c = build_omp_clause (input_location, OMP_CLAUSE_FIRSTPRIVATE);
+	      OMP_CLAUSE_DECL (c) = TREE_OPERAND (TREE_OPERAND (incr, 1), 1);
+	      OMP_CLAUSE_CHAIN (c) = clauses;
+	      clauses = c;
+	    }
+	}
+      t = TREE_OPERAND (init, 1);
+      if (TREE_CODE (t) != INTEGER_CST)
+	{
+	  TREE_OPERAND (init, 1) = get_temp_regvar (TREE_TYPE (t), t);
+	  c = build_omp_clause (input_location, OMP_CLAUSE_FIRSTPRIVATE);
+	  OMP_CLAUSE_DECL (c) = TREE_OPERAND (init, 1);
+	  OMP_CLAUSE_CHAIN (c) = clauses;
+	  clauses = c;
+	}
+      if (orig_decl && orig_decl != decl)
+	{
+	  c = build_omp_clause (input_location, OMP_CLAUSE_FIRSTPRIVATE);
+	  OMP_CLAUSE_DECL (c) = orig_decl;
+	  OMP_CLAUSE_CHAIN (c) = clauses;
+	  clauses = c;
+	}
+      if (last)
+	{
+	  c = build_omp_clause (input_location, OMP_CLAUSE_FIRSTPRIVATE);
+	  OMP_CLAUSE_DECL (c) = last;
+	  OMP_CLAUSE_CHAIN (c) = clauses;
+	  clauses = c;
+	}
+      c = build_omp_clause (input_location, OMP_CLAUSE_PRIVATE);
+      OMP_CLAUSE_DECL (c) = decl;
+      OMP_CLAUSE_CHAIN (c) = clauses;
+      clauses = c;
+      c = build_omp_clause (input_location, OMP_CLAUSE__CILK_FOR_COUNT_);
+      OMP_CLAUSE_OPERAND (c, 0)
+	= cilk_for_number_of_iterations (omp_for);
+      OMP_CLAUSE_CHAIN (c) = clauses;
+      OMP_PARALLEL_CLAUSES (omp_par) = finish_omp_clauses (c);
+      add_stmt (omp_par);
+      return omp_par;
+    }
+  else if (code == CILK_FOR && processing_template_decl)
+    {
+      tree c, clauses = OMP_FOR_CLAUSES (omp_for);
+      if (orig_decl && orig_decl != decl)
+	{
+	  c = build_omp_clause (input_location, OMP_CLAUSE_FIRSTPRIVATE);
+	  OMP_CLAUSE_DECL (c) = orig_decl;
+	  OMP_CLAUSE_CHAIN (c) = clauses;
+	  clauses = c;
+	}
+      if (last)
+	{
+	  c = build_omp_clause (input_location, OMP_CLAUSE_FIRSTPRIVATE);
+	  OMP_CLAUSE_DECL (c) = last;
+	  OMP_CLAUSE_CHAIN (c) = clauses;
+	  clauses = c;
+	}
+      OMP_FOR_CLAUSES (omp_for) = clauses;
+    }
   return omp_for;
 }