>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.
---
gcc/graphite-isl-ast-to-gimple.c | 2 +
gcc/testsuite/gcc.dg/graphite/id-28.c | 72 +++++++++++++++++++++++++++++++++++
2 files changed, 74 insertions(+)
create mode 100644 gcc/testsuite/gcc.dg/graphite/id-28.c
diff --git a/gcc/graphite-isl-ast-to-gimple.c b/gcc/graphite-isl-ast-to-gimple.c
index 497b200..06a2062 100644
--- a/gcc/graphite-isl-ast-to-gimple.c
+++ b/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:
diff --git a/gcc/testsuite/gcc.dg/graphite/id-28.c
b/gcc/testsuite/gcc.dg/graphite/id-28.c
new file mode 100644
index 0000000..e3f2368
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/id-28.c
@@ -0,0 +1,72 @@
+/* { 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;
+}
--
1.9.1
