handle missing isl_ast_expr

From ISL's documentation, isl_ast_op_zdiv_r is equal to zero iff the remainder
on integer division is zero.  Code generate a modulo operation for that.

	* graphite-isl-ast-to-gimple.c (binary_op_to_tree): Handle isl_ast_op_zdiv_r.
        (gcc_expression_from_isl_expr_op): Same.

	* gcc.dg/graphite/id-28.c: New.

Co-Authored-By: Sebastian Pop <s.pop@samsung.com>

From-SVN: r231212

gcc/ChangeLog

 2015-12-02  Aditya Kumar  <aditya.k7@samsung.com>
 	    Sebastian Pop  <s.pop@samsung.com>
 
+	* graphite-isl-ast-to-gimple.c (binary_op_to_tree): Handle isl_ast_op_zdiv_r.
+        (gcc_expression_from_isl_expr_op): Same.
+
+2015-12-02  Aditya Kumar  <aditya.k7@samsung.com>
+	    Sebastian Pop  <s.pop@samsung.com>
+
 	* graphite-isl-ast-to-gimple.c (copy_bb_and_scalar_dependences): Check
 	that insertion point is still in the region.
 

gcc/graphite-isl-ast-to-gimple.c

@@ -588,6 +588,7 @@ binary_op_to_tree (tree type, __isl_take isl_ast_expr *expr, ivs_params &ip)
 	}
       return fold_build2 (TRUNC_DIV_EXPR, type, tree_lhs_expr, tree_rhs_expr);
 
+    case isl_ast_op_zdiv_r:
     case isl_ast_op_pdiv_r:
       /* As ISL operates on arbitrary precision numbers, we may end up with
 	 division by 2^64 that is folded to 0.  */
@@ -758,6 +759,7 @@ gcc_expression_from_isl_expr_op (tree type, __isl_take isl_ast_expr *expr,
     case isl_ast_op_pdiv_q:
     case isl_ast_op_pdiv_r:
     case isl_ast_op_fdiv_q:
+    case isl_ast_op_zdiv_r:
     case isl_ast_op_and:
     case isl_ast_op_or:
     case isl_ast_op_eq:

gcc/testsuite/ChangeLog

 2015-12-02  Aditya Kumar  <aditya.k7@samsung.com>
 	    Sebastian Pop  <s.pop@samsung.com>
 
+	* gcc.dg/graphite/id-28.c: New.
+
+2015-12-02  Aditya Kumar  <aditya.k7@samsung.com>
+	    Sebastian Pop  <s.pop@samsung.com>
+
 	* gfortran.dg/graphite/id-26.f03: New.
 
 2015-12-02  Jason Merrill  <jason@redhat.com>

gcc/testsuite/gcc.dg/graphite/id-28.c

+/* { dg-options "-fcilkplus -floop-nest-optimize -O3" } */
+
+#if HAVE_IO
+#include <stdio.h>
+#endif
+#include <math.h>
+#define NUMBER 5
+
+int func1 (int *a1, int *a2)
+{
+  return __sec_reduce_add (a1[0:NUMBER] * a2[0:NUMBER:1]);
+}
+
+int func2 (int *a1, int *a2)
+{
+  return (__sec_reduce_add (a1[0:NUMBER] * a2[0:NUMBER]) +
+	  __sec_reduce_mul (a1[0:NUMBER] + a2[0:NUMBER]));
+}
+
+int func3 (int *a1, int *a2)
+{
+  return (int) sqrt ((double)(__sec_reduce_add (a1[0:NUMBER] * a2[0:NUMBER]) +
+			      a2[0] + a2[1] + a2[3]));
+}
+
+int func4 (int *a1, int *a2)
+{
+  return a1[NUMBER-1] * (__sec_reduce_add (a1[0:NUMBER] * a2[0:NUMBER]) + a2[0] + a2[1] + a2[3])/a1[NUMBER-2];
+}
+int main(void)
+{
+  int array[NUMBER], array2[NUMBER];
+  int return_value = 0;
+  int ii = 0;
+  int argc = 1;
+  __asm volatile ("" : "+r" (argc));
+  for (ii = 0; ii < NUMBER; ii++)
+    {
+      array[ii] = argc; /* This should calculate to 1.  */
+      array2[ii]  = argc * argc + argc;  /* This should calculate to 2.  */
+    }
+
+  return_value = func1 (array, array2);
+#if HAVE_IO
+  printf("Return_value = %d\n", return_value);
+#endif
+  if (return_value != (2+2+2+2+2))
+    return 1;
+
+  return_value = func2 (array2, array);
+#if HAVE_IO
+  printf("Return_value = %d\n", return_value);
+#endif
+  if (return_value != (3*3*3*3*3) + (2+2+2+2+2))
+    return 2;
+
+  return_value = func3 (array, array2);
+#if HAVE_IO
+  printf("Return_value = %d\n", return_value);
+#endif
+  if (return_value != 4)
+    return 3;
+
+  return_value = func4 (array, array2);
+#if HAVE_IO
+  printf("Return_value = %d\n", return_value);
+#endif
+  if (return_value != 16)
+    return 4;
+
+  return 0;
+}