[gomp4.1] Handle linear clause modifiers in declare simd

[gomp4.1] Handle linear clause modifiers in declare simd

[Jakub Jelinek]

Hi!

I've committed following patch, which per the new ABI additions
mangles and handles the various new linear clause modifiers in
declare simd functions.  The vectorizer side is not done yet,
for now we'll never use SIMD_CLONE_ARG_TYPE_LINEAR_*_CONSTANT_STEP
in vectorized routines, that waits first for resolution of
PR66718.

2015-07-01  Jakub Jelinek  <jakub@redhat.com>

	* cgraph.h (enum cgraph_simd_clone_arg_type): Add
	SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP,
	SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP,
	and SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP.
	(struct cgraph_simd_clone_arg): Adjust comment.
	* omp-low.c (simd_clone_clauses_extract): Honor
	OMP_CLAUSE_LINEAR_KIND.
	(simd_clone_mangle): Mangle the various linear kinds
	per the new ABI.
	(simd_clone_adjust_argument_types): Handle
	SIMD_CLONE_ARG_TYPE_LINEAR_*_CONSTANT_STEP.
	(simd_clone_init_simd_arrays): Don't do anything
	for uval.
	(simd_clone_adjust): Handle
	SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP like
	SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP.
	Handle SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP.
c/
	* c-tree.h (c_finish_omp_clauses): Add declare_simd argument.
	* c-parser.c (c_parser_omp_clause_linear): Don't handle uval
	modifier in C.
	(c_parser_omp_all_clauses): If mask includes uniform clause,
	pass true to c_finish_omp_clauses' declare_simd.
	* c-typeck.c (c_finish_omp_clauses): Add declare_simd argument,
	don't set need_implicitly_determined if it is true.
cp/
	* cp-tree.h (finish_omp_clauses): Add declare_simd argument.
	* parser.c (cp_parser_omp_all_clauses): If mask includes uniform
	clause, pass true to finish_omp_clauses' declare_simd.
	* pt.c (apply_late_template_attributes): Pass true to
	finish_omp_clauses' declare_simd.
	* semantics.c (finish_omp_clauses): Add declare_simd argument,
	don't set need_implicitly_determined if it is true.
testsuite/
	* gcc.dg/gomp/clause-1.c (foo): Add some linear clause tests.
	* g++.dg/gomp/clause-3.C (foo): Likewise.
	* g++.dg/gomp/declare-simd-3.C: New test.

--- gcc/cgraph.h.jj	2015-06-30 14:24:39.515064819 +0200
+++ gcc/cgraph.h	2015-06-30 15:12:25.534761008 +0200
@@ -645,8 +645,14 @@ enum cgraph_simd_clone_arg_type
 {
   SIMD_CLONE_ARG_TYPE_VECTOR,
   SIMD_CLONE_ARG_TYPE_UNIFORM,
+  /* These are only for integer/pointer arguments passed by value.  */
   SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP,
   SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP,
+  /* These 3 are only for reference type arguments or arguments passed
+     by reference.  */
+  SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP,
+  SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP,
+  SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP,
   SIMD_CLONE_ARG_TYPE_MASK
 };
 
@@ -686,7 +692,7 @@ struct GTY(()) cgraph_simd_clone_arg {
      variable), uniform, or vector.  */
   enum cgraph_simd_clone_arg_type arg_type;
 
-  /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP this is
+  /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_*CONSTANT_STEP this is
      the constant linear step, if arg_type is
      SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP, this is index of
      the uniform argument holding the step, otherwise 0.  */
--- gcc/omp-low.c.jj	2015-06-30 14:24:56.618812148 +0200
+++ gcc/omp-low.c	2015-06-30 17:35:21.700736990 +0200
@@ -14092,8 +14092,29 @@ simd_clone_clauses_extract (struct cgrap
 		  }
 		else
 		  {
-		    clone_info->args[argno].arg_type
-		      = SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP;
+		    enum cgraph_simd_clone_arg_type arg_type;
+		    if (TREE_CODE (args[argno]) == REFERENCE_TYPE)
+		      switch (OMP_CLAUSE_LINEAR_KIND (t))
+			{
+			case OMP_CLAUSE_LINEAR_REF:
+			  arg_type
+			    = SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP;
+			  break;
+			case OMP_CLAUSE_LINEAR_UVAL:
+			  arg_type
+			    = SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP;
+			  break;
+			case OMP_CLAUSE_LINEAR_VAL:
+			case OMP_CLAUSE_LINEAR_DEFAULT:
+			  arg_type
+			    = SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP;
+			  break;
+			default:
+			  gcc_unreachable ();
+			}
+		    else
+		      arg_type = SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP;
+		    clone_info->args[argno].arg_type = arg_type;
 		    clone_info->args[argno].linear_step = tree_to_shwi (step);
 		  }
 	      }
@@ -14195,12 +14216,25 @@ simd_clone_mangle (struct cgraph_node *n
     {
       struct cgraph_simd_clone_arg arg = clone_info->args[n];
 
-      if (arg.arg_type == SIMD_CLONE_ARG_TYPE_UNIFORM)
-	pp_character (&pp, 'u');
-      else if (arg.arg_type == SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP)
+      switch (arg.arg_type)
 	{
-	  gcc_assert (arg.linear_step != 0);
+	case SIMD_CLONE_ARG_TYPE_UNIFORM:
+	  pp_character (&pp, 'u');
+	  break;
+	case SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP:
 	  pp_character (&pp, 'l');
+	  goto mangle_linear;
+	case SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP:
+	  pp_character (&pp, 'R');
+	  goto mangle_linear;
+	case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP:
+	  pp_character (&pp, 'L');
+	  goto mangle_linear;
+	case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP:
+	  pp_character (&pp, 'U');
+	  goto mangle_linear;
+	mangle_linear:
+	  gcc_assert (arg.linear_step != 0);
 	  if (arg.linear_step > 1)
 	    pp_unsigned_wide_integer (&pp, arg.linear_step);
 	  else if (arg.linear_step < 0)
@@ -14209,14 +14243,14 @@ simd_clone_mangle (struct cgraph_node *n
 	      pp_unsigned_wide_integer (&pp, (-(unsigned HOST_WIDE_INT)
 					      arg.linear_step));
 	    }
-	}
-      else if (arg.arg_type == SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP)
-	{
+	  break;
+	case SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP:
 	  pp_character (&pp, 's');
 	  pp_unsigned_wide_integer (&pp, arg.linear_step);
+	  break;
+	default:
+	  pp_character (&pp, 'v');
 	}
-      else
-	pp_character (&pp, 'v');
       if (arg.alignment)
 	{
 	  pp_character (&pp, 'a');
@@ -14394,13 +14428,22 @@ simd_clone_adjust_argument_types (struct
       node->simdclone->args[i].orig_arg = node->definition ? parm : NULL_TREE;
       node->simdclone->args[i].orig_type = parm_type;
 
-      if (node->simdclone->args[i].arg_type != SIMD_CLONE_ARG_TYPE_VECTOR)
+      switch (node->simdclone->args[i].arg_type)
 	{
+	default:
 	  /* No adjustment necessary for scalar arguments.  */
 	  adj.op = IPA_PARM_OP_COPY;
-	}
-      else
-	{
+	  break;
+	case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP:
+	  if (node->definition)
+	    node->simdclone->args[i].simd_array
+	      = create_tmp_simd_array (IDENTIFIER_POINTER (DECL_NAME (parm)),
+				       TREE_TYPE (parm_type),
+				       node->simdclone->simdlen);
+	  adj.op = IPA_PARM_OP_COPY;
+	  break;
+	case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP:
+	case SIMD_CLONE_ARG_TYPE_VECTOR:
 	  if (INTEGRAL_TYPE_P (parm_type) || POINTER_TYPE_P (parm_type))
 	    veclen = node->simdclone->vecsize_int;
 	  else
@@ -14532,7 +14575,8 @@ simd_clone_init_simd_arrays (struct cgra
        arg;
        arg = DECL_CHAIN (arg), i++, j++)
     {
-      if (adjustments[j].op == IPA_PARM_OP_COPY)
+      if (adjustments[j].op == IPA_PARM_OP_COPY
+	  || POINTER_TYPE_P (TREE_TYPE (arg)))
 	continue;
 
       node->simdclone->args[i].vector_arg = arg;
@@ -15022,8 +15066,10 @@ simd_clone_adjust (struct cgraph_node *n
 		  SET_USE (use_p, repl);
 	  }
       }
-    else if (node->simdclone->args[i].arg_type
-	     == SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP)
+    else if ((node->simdclone->args[i].arg_type
+	      == SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP)
+	     || (node->simdclone->args[i].arg_type
+		 == SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP))
       {
 	tree orig_arg = node->simdclone->args[i].orig_arg;
 	gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (orig_arg))
@@ -15082,6 +15128,78 @@ simd_clone_adjust (struct cgraph_node *n
 		    SET_USE (use_p, iter1);
 	  }
       }
+    else if (node->simdclone->args[i].arg_type
+	     == SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP)
+      {
+	tree orig_arg = node->simdclone->args[i].orig_arg;
+	tree def = ssa_default_def (cfun, orig_arg);
+	gcc_assert (!TREE_ADDRESSABLE (orig_arg)
+		    && TREE_CODE (TREE_TYPE (orig_arg)) == REFERENCE_TYPE);
+	if (def && !has_zero_uses (def))
+	  {
+	    tree rtype = TREE_TYPE (TREE_TYPE (orig_arg));
+	    iter1 = make_ssa_name (orig_arg);
+	    iter2 = make_ssa_name (orig_arg);
+	    tree iter3 = make_ssa_name (rtype);
+	    tree iter4 = make_ssa_name (rtype);
+	    tree iter5 = make_ssa_name (rtype);
+	    gsi = gsi_after_labels (entry_bb);
+	    gimple load
+	      = gimple_build_assign (iter3, build_simple_mem_ref (def));
+	    gsi_insert_before (&gsi, load, GSI_NEW_STMT);
+
+	    tree array = node->simdclone->args[i].simd_array;
+	    TREE_ADDRESSABLE (array) = 1;
+	    tree ptr = build_fold_addr_expr (array);
+	    phi = create_phi_node (iter1, body_bb);
+	    add_phi_arg (phi, ptr, preheader_edge, UNKNOWN_LOCATION);
+	    add_phi_arg (phi, iter2, latch_edge, UNKNOWN_LOCATION);
+	    g = gimple_build_assign (iter2, POINTER_PLUS_EXPR, iter1,
+				     TYPE_SIZE_UNIT (TREE_TYPE (iter3)));
+	    gsi = gsi_last_bb (incr_bb);
+	    gsi_insert_before (&gsi, g, GSI_SAME_STMT);
+
+	    phi = create_phi_node (iter4, body_bb);
+	    add_phi_arg (phi, iter3, preheader_edge, UNKNOWN_LOCATION);
+	    add_phi_arg (phi, iter5, latch_edge, UNKNOWN_LOCATION);
+	    enum tree_code code = INTEGRAL_TYPE_P (TREE_TYPE (iter3))
+				  ? PLUS_EXPR : POINTER_PLUS_EXPR;
+	    tree addtype = INTEGRAL_TYPE_P (TREE_TYPE (iter3))
+			   ? TREE_TYPE (iter3) : sizetype;
+	    tree addcst
+	      = build_int_cst (addtype, node->simdclone->args[i].linear_step);
+	    g = gimple_build_assign (iter5, code, iter4, addcst);
+	    gsi = gsi_last_bb (incr_bb);
+	    gsi_insert_before (&gsi, g, GSI_SAME_STMT);
+
+	    g = gimple_build_assign (build_simple_mem_ref (iter1), iter4);
+	    gsi = gsi_after_labels (body_bb);
+	    gsi_insert_before (&gsi, g, GSI_SAME_STMT);
+
+	    imm_use_iterator iter;
+	    use_operand_p use_p;
+	    gimple use_stmt;
+	    FOR_EACH_IMM_USE_STMT (use_stmt, iter, def)
+	      if (use_stmt == load)
+		continue;
+	      else
+		FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
+		  SET_USE (use_p, iter1);
+
+	    if (!TYPE_READONLY (rtype))
+	      {
+		tree v = make_ssa_name (rtype);
+		tree aref = build4 (ARRAY_REF, rtype, array,
+				    size_zero_node, NULL_TREE,
+				    NULL_TREE);
+		gsi = gsi_after_labels (new_exit_bb);
+		g = gimple_build_assign (v, aref);
+		gsi_insert_before (&gsi, g, GSI_SAME_STMT);
+		g = gimple_build_assign (build_simple_mem_ref (def), v);
+		gsi_insert_before (&gsi, g, GSI_SAME_STMT);
+	      }
+	  }
+      }
 
   calculate_dominance_info (CDI_DOMINATORS);
   add_loop (loop, loop->header->loop_father);
--- gcc/c/c-tree.h.jj	2015-06-17 21:01:53.000000000 +0200
+++ gcc/c/c-tree.h	2015-06-30 16:36:04.400102700 +0200
@@ -649,7 +649,7 @@ extern tree c_begin_omp_task (void);
 extern tree c_finish_omp_task (location_t, tree, tree);
 extern void c_finish_omp_cancel (location_t, tree);
 extern void c_finish_omp_cancellation_point (location_t, tree);
-extern tree c_finish_omp_clauses (tree);
+extern tree c_finish_omp_clauses (tree, bool = false);
 extern tree c_build_va_arg (location_t, tree, tree);
 extern tree c_finish_transaction (location_t, tree, int);
 extern bool c_tree_equal (tree, tree);
--- gcc/c/c-parser.c.jj	2015-06-30 14:24:37.319097260 +0200
+++ gcc/c/c-parser.c	2015-06-30 16:37:12.193109783 +0200
@@ -11532,8 +11532,6 @@ c_parser_omp_clause_linear (c_parser *pa
       const char *p = IDENTIFIER_POINTER (tok->value);
       if (strcmp ("val", p) == 0)
 	kind = OMP_CLAUSE_LINEAR_VAL;
-      else if (strcmp ("uval", p) == 0)
-	kind = OMP_CLAUSE_LINEAR_UVAL;
       if (c_parser_peek_2nd_token (parser)->type != CPP_OPEN_PAREN)
 	kind = OMP_CLAUSE_LINEAR_DEFAULT;
       if (kind != OMP_CLAUSE_LINEAR_DEFAULT)
@@ -12411,7 +12409,11 @@ c_parser_omp_all_clauses (c_parser *pars
   c_parser_skip_to_pragma_eol (parser);
 
   if (finish_p)
-    return c_finish_omp_clauses (clauses);
+    {
+      if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM)) != 0)
+	return c_finish_omp_clauses (clauses, true);
+      return c_finish_omp_clauses (clauses);
+    }
 
   return clauses;
 }
--- gcc/c/c-typeck.c.jj	2015-06-30 14:27:47.000000000 +0200
+++ gcc/c/c-typeck.c	2015-06-30 16:35:38.402483469 +0200
@@ -12098,7 +12098,7 @@ c_find_omp_placeholder_r (tree *tp, int
    Remove any elements from the list that are invalid.  */
 
 tree
-c_finish_omp_clauses (tree clauses)
+c_finish_omp_clauses (tree clauses, bool declare_simd)
 {
   bitmap_head generic_head, firstprivate_head, lastprivate_head;
   bitmap_head aligned_head;
@@ -12362,6 +12362,8 @@ c_finish_omp_clauses (tree clauses)
 	  goto check_dup_generic;
 
 	case OMP_CLAUSE_LINEAR:
+	  if (!declare_simd)
+	    need_implicitly_determined = true;
 	  t = OMP_CLAUSE_DECL (c);
 	  if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
 	      && TREE_CODE (TREE_TYPE (t)) != POINTER_TYPE)
--- gcc/cp/cp-tree.h.jj	2015-06-30 14:25:24.000000000 +0200
+++ gcc/cp/cp-tree.h	2015-06-30 16:23:12.616408072 +0200
@@ -5998,7 +5998,7 @@ extern void note_decl_for_pch			(tree);
 extern tree omp_reduction_id			(enum tree_code, tree, tree);
 extern tree cp_remove_omp_priv_cleanup_stmt	(tree *, int *, void *);
 extern void cp_check_omp_declare_reduction	(tree);
-extern tree finish_omp_clauses			(tree, bool);
+extern tree finish_omp_clauses			(tree, bool, bool = false);
 extern tree push_omp_privatization_clauses	(bool);
 extern void pop_omp_privatization_clauses	(tree);
 extern void save_omp_privatization_clauses	(vec<tree> &);
--- gcc/cp/parser.c.jj	2015-06-30 14:25:22.000000000 +0200
+++ gcc/cp/parser.c	2015-06-30 16:28:58.552339799 +0200
@@ -29969,7 +29969,12 @@ cp_parser_omp_all_clauses (cp_parser *pa
   if (!(flag_cilkplus && pragma_tok == NULL))
     cp_parser_skip_to_pragma_eol (parser, pragma_tok);
   if (finish_p)
-    return finish_omp_clauses (clauses, true);
+    {
+      if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM)) != 0)
+	return finish_omp_clauses (clauses, false, true);
+      else
+	return finish_omp_clauses (clauses, true);
+    }
   return clauses;
 }
 
--- gcc/cp/pt.c.jj	2015-06-30 14:25:18.000000000 +0200
+++ gcc/cp/pt.c	2015-06-30 16:29:58.532461311 +0200
@@ -9074,7 +9074,7 @@ apply_late_template_attributes (tree *de
 		  clauses = tsubst_omp_clauses (clauses, true, false, args,
 						complain, in_decl);
 		  c_omp_declare_simd_clauses_to_decls (*decl_p, clauses);
-		  clauses = finish_omp_clauses (clauses, false);
+		  clauses = finish_omp_clauses (clauses, false, true);
 		  tree parms = DECL_ARGUMENTS (*decl_p);
 		  clauses
 		    = c_omp_declare_simd_clauses_to_numbers (parms, clauses);
--- gcc/cp/semantics.c.jj	2015-06-30 14:25:19.621472332 +0200
+++ gcc/cp/semantics.c	2015-06-30 16:25:23.769485575 +0200
@@ -5495,7 +5495,7 @@ finish_omp_reduction_clause (tree c, boo
    Remove any elements from the list that are invalid.  */
 
 tree
-finish_omp_clauses (tree clauses, bool allow_fields)
+finish_omp_clauses (tree clauses, bool allow_fields, bool declare_simd)
 {
   bitmap_head generic_head, firstprivate_head, lastprivate_head;
   bitmap_head aligned_head;
@@ -5563,12 +5563,14 @@ finish_omp_clauses (tree clauses, bool a
 	  if (!type_dependent_expression_p (t))
 	    {
 	      tree type = TREE_TYPE (t);
-	      if (OMP_CLAUSE_LINEAR_KIND (c) == OMP_CLAUSE_LINEAR_REF
+	      if ((OMP_CLAUSE_LINEAR_KIND (c) == OMP_CLAUSE_LINEAR_REF
+		   || OMP_CLAUSE_LINEAR_KIND (c) == OMP_CLAUSE_LINEAR_UVAL)
 		  && TREE_CODE (type) != REFERENCE_TYPE)
 		{
-		  error ("linear clause with %<ref%> modifier applied to "
+		  error ("linear clause with %qs modifier applied to "
 			 "non-reference variable with %qT type",
-			 TREE_TYPE (t));
+			 OMP_CLAUSE_LINEAR_KIND (c) == OMP_CLAUSE_LINEAR_REF
+			 ? "ref" : "uval", TREE_TYPE (t));
 		  remove = true;
 		  break;
 		}
@@ -5611,12 +5613,17 @@ finish_omp_clauses (tree clauses, bool a
 		    type = TREE_TYPE (type);
 		  if (OMP_CLAUSE_LINEAR_KIND (c) == OMP_CLAUSE_LINEAR_REF)
 		    {
-		      type = TREE_TYPE (OMP_CLAUSE_DECL (c));
-		      t = fold_convert_loc (OMP_CLAUSE_LOCATION (c),
-					    sizetype, t);
+		      type = build_pointer_type (type);
+		      tree d = fold_convert (type, OMP_CLAUSE_DECL (c));
+		      t = pointer_int_sum (OMP_CLAUSE_LOCATION (c), PLUS_EXPR,
+					   d, t);
 		      t = fold_build2_loc (OMP_CLAUSE_LOCATION (c),
-					   MULT_EXPR, sizetype, t,
-					   TYPE_SIZE_UNIT (type));
+					   MINUS_EXPR, sizetype, t, d);
+		      if (t == error_mark_node)
+			{
+			  remove = true;
+			  break;
+			}
 		    }
 		  else if (TREE_CODE (type) == POINTER_TYPE)
 		    {
@@ -6357,9 +6364,12 @@ finish_omp_clauses (tree clauses, bool a
 	  need_implicitly_determined = true;
 	  break;
 	case OMP_CLAUSE_REDUCTION:
-	case OMP_CLAUSE_LINEAR:
 	  need_implicitly_determined = true;
 	  break;
+	case OMP_CLAUSE_LINEAR:
+	  if (!declare_simd)
+	    need_implicitly_determined = true;
+	  break;
 	case OMP_CLAUSE_COPYPRIVATE:
 	  need_copy_assignment = true;
 	  break;
--- gcc/testsuite/gcc.dg/gomp/clause-1.c.jj	2015-06-09 20:00:25.000000000 +0200
+++ gcc/testsuite/gcc.dg/gomp/clause-1.c	2015-06-30 17:21:45.253018384 +0200
@@ -34,6 +34,9 @@ foo (int x)
 #pragma omp p for lastprivate (x, x) /* { dg-error "more than once" } */
   for (i = 0; i < 10; i++)
     ;
+#pragma omp p for linear (x, x) /* { dg-error "more than once" } */
+  for (i = 0; i < 10; i++)
+    ;
 #pragma omp single private (x) copyprivate (x) /* { dg-error "more than" } */
     ;
 #pragma omp p shared (bar) /* { dg-error "is not a variable" } */
@@ -80,6 +83,9 @@ foo (int x)
     ;
 #pragma omp p reduction (*:t) /* { dg-error "predetermined 'threadprivate" } */
     ;
+#pragma omp p for linear (t) /* { dg-error "predetermined 'threadprivate" } */
+  for (i = 0; i < 10; i++)
+    ;
 #pragma omp p shared (c) /* { dg-error "predetermined 'shared'" } */
     ;
 #pragma omp p private (c) /* { dg-error "predetermined 'shared'" } */
@@ -91,4 +97,7 @@ foo (int x)
     ;
 #pragma omp p reduction (*:c) /* { dg-error "predetermined 'shared'" } */
     ;
+#pragma omp p for linear (c) /* { dg-error "predetermined 'shared'" } */
+  for (i = 0; i < 10; i++)
+    ;
 }
--- gcc/testsuite/g++.dg/gomp/clause-3.C.jj	2015-06-09 20:01:12.000000000 +0200
+++ gcc/testsuite/g++.dg/gomp/clause-3.C	2015-06-30 17:18:16.537087095 +0200
@@ -34,6 +34,9 @@ foo (int x)
 #pragma omp p for lastprivate (x, x) // { dg-error "more than once" }
   for (i = 0; i < 10; i++)
     ;
+#pragma omp p for linear (x, x) // { dg-error "more than once" }
+  for (i = 0; i < 10; i++)
+    ;
 #pragma omp single private (x) copyprivate (x) // { dg-error "more than once" }
     ;
 #pragma omp p shared (bar) // { dg-error "is not a variable" }
@@ -80,6 +83,9 @@ foo (int x)
     ;
 #pragma omp p reduction (*:t) // { dg-error "predetermined 'threadprivate'" }
     ;
+#pragma omp p for linear (t) // { dg-error "predetermined 'threadprivate'" }
+  for (i = 0; i < 10; i++)
+    ;
 #pragma omp p shared (c) // { dg-error "predetermined 'shared'" }
     ;
 #pragma omp p private (c) // { dg-error "predetermined 'shared'" }
@@ -91,4 +97,7 @@ foo (int x)
     ;
 #pragma omp p reduction (*:c) // { dg-error "predetermined 'shared'" }
     ;
+#pragma omp p for linear (c:2) // { dg-error "predetermined 'shared'" }
+  for (i = 0; i < 10; i++)
+    ;
 }
--- gcc/testsuite/g++.dg/gomp/declare-simd-3.C.jj	2015-06-30 16:43:03.736964530 +0200
+++ gcc/testsuite/g++.dg/gomp/declare-simd-3.C	2015-06-30 16:43:25.035654085 +0200
@@ -0,0 +1,49 @@
+// { dg-do compile }
+
+#pragma omp declare simd uniform(b) linear(c, d) linear(uval(e)) linear(ref(f))
+int f1 (int a, int b, int c, int &d, int &e, int &f)
+{
+  a++;
+  b++;
+  c++;
+  d++;
+  e++;
+  f++;
+  return a + b + c + d + e + f;
+}
+
+#pragma omp declare simd uniform(b) linear(c, d) linear(uval(e)) linear(ref(f))
+int f2 (int a, int b, int c, int &d, int &e, int &f)
+{
+  asm volatile ("" : : "r" (&a));
+  asm volatile ("" : : "r" (&b));
+  asm volatile ("" : : "r" (&c));
+  asm volatile ("" : : "r" (&d));
+  asm volatile ("" : : "r" (&e));
+  asm volatile ("" : : "r" (&f));
+  a++;
+  b++;
+  c++;
+  d++;
+  e++;
+  f++;
+  return a + b + c + d + e + f;
+}
+
+#pragma omp declare simd uniform(b) linear(c, d) linear(uval(e)) linear(ref(f))
+int f3 (const int a, const int b, const int c, const int &d, const int &e, const int &f)
+{
+  return a + b + c + d + e + f;
+}
+
+#pragma omp declare simd uniform(b) linear(c, d) linear(uval(e)) linear(ref(f))
+int f4 (const int a, const int b, const int c, const int &d, const int &e, const int &f)
+{
+  asm volatile ("" : : "r" (&a));
+  asm volatile ("" : : "r" (&b));
+  asm volatile ("" : : "r" (&c));
+  asm volatile ("" : : "r" (&d));
+  asm volatile ("" : : "r" (&e));
+  asm volatile ("" : : "r" (&f));
+  return a + b + c + d + e + f;
+}

	Jakub

Re: [gomp4.1] Handle linear clause modifiers in declare simd

[Ilya Verbin]

On Wed, Jul 01, 2015 at 12:55:38 +0200, Jakub Jelinek wrote:
> 	* cgraph.h (enum cgraph_simd_clone_arg_type): Add
> 	SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP,
> 	SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP,
> 	and SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP.
> 	(struct cgraph_simd_clone_arg): Adjust comment.
> 	* omp-low.c (simd_clone_clauses_extract): Honor
> 	OMP_CLAUSE_LINEAR_KIND.
> 	(simd_clone_mangle): Mangle the various linear kinds
> 	per the new ABI.
> 	(simd_clone_adjust_argument_types): Handle
> 	SIMD_CLONE_ARG_TYPE_LINEAR_*_CONSTANT_STEP.
> 	(simd_clone_init_simd_arrays): Don't do anything
> 	for uval.
> 	(simd_clone_adjust): Handle
> 	SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP like
> 	SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP.
> 	Handle SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP.
> c/
> 	* c-tree.h (c_finish_omp_clauses): Add declare_simd argument.
> 	* c-parser.c (c_parser_omp_clause_linear): Don't handle uval
> 	modifier in C.
> 	(c_parser_omp_all_clauses): If mask includes uniform clause,
> 	pass true to c_finish_omp_clauses' declare_simd.
> 	* c-typeck.c (c_finish_omp_clauses): Add declare_simd argument,
> 	don't set need_implicitly_determined if it is true.
> cp/
> 	* cp-tree.h (finish_omp_clauses): Add declare_simd argument.
> 	* parser.c (cp_parser_omp_all_clauses): If mask includes uniform
> 	clause, pass true to finish_omp_clauses' declare_simd.
> 	* pt.c (apply_late_template_attributes): Pass true to
> 	finish_omp_clauses' declare_simd.
> 	* semantics.c (finish_omp_clauses): Add declare_simd argument,
> 	don't set need_implicitly_determined if it is true.
> testsuite/
> 	* gcc.dg/gomp/clause-1.c (foo): Add some linear clause tests.
> 	* g++.dg/gomp/clause-3.C (foo): Likewise.
> 	* g++.dg/gomp/declare-simd-3.C: New test.

This caused:

gcc/tree-vect-stmts.c: In function ‘bool vectorizable_simd_clone_call(gimple, gimple_stmt_iterator*, gimple_statement_base**, slp_tree)’:
gcc/tree-vect-stmts.c:2810:13: error: enumeration value ‘SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP’ not handled in switch [-Werror=switch]
      switch (n->simdclone->args[i].arg_type)
             ^
gcc/tree-vect-stmts.c:2810:13: error: enumeration value ‘SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP’ not handled in switch [-Werror=switch]
gcc/tree-vect-stmts.c:2810:13: error: enumeration value ‘SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP’ not handled in switch [-Werror=switch]
cc1plus: all warnings being treated as errors
make[4]: *** [tree-vect-stmts.o] Error 1

  -- Ilya

Re: [gomp4.1] Handle linear clause modifiers in declare simd

[Jakub Jelinek]

On Tue, Jul 14, 2015 at 02:41:04PM +0300, Ilya Verbin wrote:
> This caused:
> 
> gcc/tree-vect-stmts.c: In function ‘bool vectorizable_simd_clone_call(gimple, gimple_stmt_iterator*, gimple_statement_base**, slp_tree)’:
> gcc/tree-vect-stmts.c:2810:13: error: enumeration value ‘SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP’ not handled in switch [-Werror=switch]
>       switch (n->simdclone->args[i].arg_type)
>              ^
> gcc/tree-vect-stmts.c:2810:13: error: enumeration value ‘SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP’ not handled in switch [-Werror=switch]
> gcc/tree-vect-stmts.c:2810:13: error: enumeration value ‘SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP’ not handled in switch [-Werror=switch]
> cc1plus: all warnings being treated as errors
> make[4]: *** [tree-vect-stmts.o] Error 1

Oops, missed that warning (and haven't bootstrapped the branch
for a while now).

Fixed thusly, to handle VAL/UVAL better we'll need to find the last
store into the memory and determine if the stored value is linear.
Something deferred for later.

2015-07-14  Jakub Jelinek  <jakub@redhat.com>

	* tree-vect-stmts.c (vectorizable_simd_clone_call): Handle
	SIMD_CLONE_ARG_TYPE_LINEAR_{REF,VAL,UVAL}_CONSTANT_STEP.

--- gcc/tree-vect-stmts.c.jj	2015-07-14 14:30:06.000000000 +0200
+++ gcc/tree-vect-stmts.c	2015-07-14 14:45:08.032376586 +0200
@@ -2825,6 +2825,7 @@ vectorizable_simd_clone_call (gimple stm
 		  i = -1;
 		break;
 	      case SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP:
+	      case SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP:
 		if (arginfo[i].dt == vect_constant_def
 		    || arginfo[i].dt == vect_external_def
 		    || (arginfo[i].linear_step
@@ -2832,6 +2833,8 @@ vectorizable_simd_clone_call (gimple stm
 		  i = -1;
 		break;
 	      case SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP:
+	      case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP:
+	      case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP:
 		/* FORNOW */
 		i = -1;
 		break;


	Jakub

Re: [gomp4.1] Handle linear clause modifiers in declare simd

[Ilya Verbin]

Hi!

On Wed, Jul 01, 2015 at 12:55:38 +0200, Jakub Jelinek wrote:
> I've committed following patch, which per the new ABI additions
> mangles and handles the various new linear clause modifiers in
> declare simd functions.  The vectorizer side is not done yet,
>
> [...]
>
> @@ -14195,12 +14216,25 @@ simd_clone_mangle (struct cgraph_node *n
>      {
>        struct cgraph_simd_clone_arg arg = clone_info->args[n];
>  
> -      if (arg.arg_type == SIMD_CLONE_ARG_TYPE_UNIFORM)
> -	pp_character (&pp, 'u');
> -      else if (arg.arg_type == SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP)
> +      switch (arg.arg_type)
>  	{
> -	  gcc_assert (arg.linear_step != 0);
> +	case SIMD_CLONE_ARG_TYPE_UNIFORM:
> +	  pp_character (&pp, 'u');
> +	  break;
> +	case SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP:
>  	  pp_character (&pp, 'l');
> +	  goto mangle_linear;
> +	case SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP:
> +	  pp_character (&pp, 'R');
> +	  goto mangle_linear;
> +	case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP:
> +	  pp_character (&pp, 'L');
> +	  goto mangle_linear;
> +	case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP:
> +	  pp_character (&pp, 'U');
> +	  goto mangle_linear;
> +	mangle_linear:
> +	  gcc_assert (arg.linear_step != 0);

Could you please point to where the new ABI additions are documented?
I can't find R/L/U parameter types in [1] and [2].

[1] https://sourceware.org/glibc/wiki/libmvec?action=AttachFile&do=view&target=VectorABI.txt
[2] https://groups.google.com/forum/#!topic/x86-64-abi/LmppCfN1rZ4

Thanks,
  -- Ilya

Re: [gomp4.1] Handle linear clause modifiers in declare simd

[Jakub Jelinek]

On Wed, Nov 18, 2015 at 08:30:53PM +0300, Ilya Verbin wrote:
> Could you please point to where the new ABI additions are documented?
> I can't find R/L/U parameter types in [1] and [2].
> 
> [1] https://sourceware.org/glibc/wiki/libmvec?action=AttachFile&do=view&target=VectorABI.txt
> [2] https://groups.google.com/forum/#!topic/x86-64-abi/LmppCfN1rZ4

Xinmin should have those in the Intel ABI pdf, not sure if the latest pdf
is publicly available or not.

	Jakub

RE: [gomp4.1] Handle linear clause modifiers in declare simd

[Tian, Xinmin]

Yes, I will send the updated version to Jakub when I come back from SC15. I am updating it based on discussion with Jakub. 

Thanks,
Xinmin

-----Original Message-----
From: Jakub Jelinek [mailto:jakub@redhat.com] 
Sent: Wednesday, November 18, 2015 9:41 AM
To: Ilya Verbin; Tian, Xinmin
Cc: gcc-patches@gcc.gnu.org; Kirill Yukhin; andrew.n.senkevich@gmail.com
Subject: Re: [gomp4.1] Handle linear clause modifiers in declare simd

On Wed, Nov 18, 2015 at 08:30:53PM +0300, Ilya Verbin wrote:
> Could you please point to where the new ABI additions are documented?
> I can't find R/L/U parameter types in [1] and [2].
> 
> [1] 
> https://sourceware.org/glibc/wiki/libmvec?action=AttachFile&do=view&ta
> rget=VectorABI.txt [2] 
> https://groups.google.com/forum/#!topic/x86-64-abi/LmppCfN1rZ4

Xinmin should have those in the Intel ABI pdf, not sure if the latest pdf is publicly available or not.

	Jakub