gcc: Allow the COUNT argument of the `register' pragma to be a variable name.

* gcc-plugin/src/starpu.c (handle_pragma_register): Allow the COUNT
  argument to be a variable name.

* gcc-plugin/tests/register-errors.c (main): Add test with X_SIZE.

* gcc-plugin/tests/register.c (main): Add test with Y_SIZE.

gcc-plugin/src/starpu.c

@@ -365,10 +365,24 @@ handle_pragma_register (struct cpp_reader *reader)
       if (count == NULL_TREE)
 	error_at (loc, "cannot determine size of array %qE", var_name);
     }
-  else if (type == CPP_NUMBER)
+  else
     {
-      /* TOKEN is a number, consume it.  */
-      tree count_arg = token;
+      /* TOKEN may be a number or a integer variable.  */
+
+      tree count_arg;
+
+      if (TREE_CODE (token) == IDENTIFIER_NODE)
+	{
+	  count_arg = lookup_name (token);
+	  if (count_arg == NULL_TREE)
+	    error_at (loc, "unbound variable %qE", token);
+	  else if (!INTEGRAL_TYPE_P (TREE_TYPE (count_arg)))
+	    error_at (loc, "integer expected");
+	}
+      else if (TREE_CODE (token) != INTEGER_CST)
+	error_at (loc, "integer expected");
+      else
+	count_arg = token;
 
       if (count != NULL_TREE)
 	{
@@ -377,10 +391,21 @@ handle_pragma_register (struct cpp_reader *reader)
 		  "element count can be omitted for bounded array %qE",
 		  var_name);
 
-	  if (!tree_int_cst_equal (count, count_arg))
-	    error_at (loc,
-		      "specified element count differs from actual size of array %qE",
-		      var_name);
+	  if (count_arg != NULL_TREE)
+	    {
+	      if (TREE_CODE (count_arg) == INTEGER_CST)
+		{
+		  if (!tree_int_cst_equal (count, count_arg))
+		    error_at (loc, "specified element count differs "
+			      "from actual size of array %qE", var_name);
+		}
+	      else
+		/* Using a variable to determine the array size whereas the
+		   array size is actually known statically.  This looks like
+		   unreasonable code, so error out.  */
+		error_at (loc, "determining array size at run-time "
+			  "although array size is known at compile-time");
+	    }
 	}
       else
 	count = count_arg;
@@ -388,11 +413,6 @@ handle_pragma_register (struct cpp_reader *reader)
       if (pragma_lex (&token) != CPP_EOF)
 	error_at (loc, "junk after %<starpu register%> pragma");
     }
-  else
-    {
-      error_at (loc, "integer expected");
-      return;
-    }
 
   /* If VAR is an array, take its address.  */
   tree pointer =

gcc-plugin/tests/register-errors.c

@@ -30,6 +30,9 @@ main (int argc, char *argv[])
   static int x[123] __attribute__ ((unused));
 #pragma starpu register x 234 /* (note "can be omitted") *//* (error "differs from actual size") */
 
+  size_t x_size __attribute__ ((unused)) = sizeof x / sizeof x[0];
+#pragma starpu register x x_size /* (note "can be omitted") *//* (error "known at compile-time") */
+
 #pragma starpu register does_not_exit 123 /* (error "unbound variable") */
 
 #pragma starpu register argv /* (error "cannot determine size") */

gcc-plugin/tests/register.c

@@ -38,6 +38,7 @@ main (int argc, char *argv[])
   double *y;
   static char z[345];
   short w[] = { 1, 2, 3 };
+  size_t y_size = 234;
 
   y = malloc (234 * sizeof *y);
 
@@ -51,6 +52,11 @@ main (int argc, char *argv[])
   expected_register_arguments.element_size = sizeof *y;
 #pragma starpu register y 234
 
+  expected_register_arguments.pointer = y;
+  expected_register_arguments.elements = y_size;
+  expected_register_arguments.element_size = sizeof *y;
+#pragma starpu register y y_size
+
   expected_register_arguments.pointer = z;
   expected_register_arguments.elements = 345;
   expected_register_arguments.element_size = sizeof z[0];
@@ -77,7 +83,7 @@ main (int argc, char *argv[])
 
   foo ();
 
-  assert (data_register_calls == 7);
+  assert (data_register_calls == 8);
 
   free (y);