[jit] New test case: test-nested-loops.c

[David Malcolm <dmalcolm at redhat dot com>]

Committed to branch dmalcolm/jit:

gcc/testsuite/ChangeLog.jit:
	* jit.dg/test-nested-loops.c: New test case.
	* jit.dg/all-non-failing-tests.h: Add test-nested-loops.c.
	* jit.dg/test-combination.c (create_code): Likewise.
	(verify_code): Likewise.
	* jit.dg/test-threads.c (const): Likewise.
---
 gcc/testsuite/jit.dg/all-non-failing-tests.h |   7 ++
 gcc/testsuite/jit.dg/test-combination.c      |   2 +
 gcc/testsuite/jit.dg/test-nested-loops.c     | 179 +++++++++++++++++++++++++++
 gcc/testsuite/jit.dg/test-threads.c          |   3 +
 4 files changed, 191 insertions(+)
 create mode 100644 gcc/testsuite/jit.dg/test-nested-loops.c

diff --git a/gcc/testsuite/jit.dg/all-non-failing-tests.h b/gcc/testsuite/jit.dg/all-non-failing-tests.h
index 54dacb7..5f7b2ec 100644
--- a/gcc/testsuite/jit.dg/all-non-failing-tests.h
+++ b/gcc/testsuite/jit.dg/all-non-failing-tests.h
@@ -109,6 +109,13 @@
 #undef create_code
 #undef verify_code
 
+/* test-nested-loops.c */
+#define create_code create_code_nested_loop
+#define verify_code verify_code_nested_loop
+#include "test-nested-loops.c"
+#undef create_code
+#undef verify_code
+
 /* test-reading-struct.c */
 #define create_code create_code_reading_struct
 #define verify_code verify_code_reading_struct
diff --git a/gcc/testsuite/jit.dg/test-combination.c b/gcc/testsuite/jit.dg/test-combination.c
index 1b9432b..9d3a535 100644
--- a/gcc/testsuite/jit.dg/test-combination.c
+++ b/gcc/testsuite/jit.dg/test-combination.c
@@ -29,6 +29,7 @@ create_code (gcc_jit_context *ctxt, void * user_data)
   create_code_hello_world (ctxt, user_data);
   create_code_linked_list (ctxt, user_data);
   create_code_quadratic (ctxt, user_data);
+  create_code_nested_loop (ctxt, user_data);
   create_code_reading_struct  (ctxt, user_data);
   create_code_string_literal (ctxt, user_data);
   create_code_sum_of_squares (ctxt, user_data);
@@ -54,6 +55,7 @@ verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
   verify_code_hello_world (ctxt, result);
   verify_code_linked_list (ctxt, result);
   verify_code_quadratic (ctxt, result);
+  verify_code_nested_loop (ctxt, result);
   verify_code_reading_struct (ctxt, result);
   verify_code_string_literal (ctxt, result);
   verify_code_sum_of_squares (ctxt, result);
diff --git a/gcc/testsuite/jit.dg/test-nested-loops.c b/gcc/testsuite/jit.dg/test-nested-loops.c
new file mode 100644
index 0000000..a4cda68
--- /dev/null
+++ b/gcc/testsuite/jit.dg/test-nested-loops.c
@@ -0,0 +1,179 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "libgccjit.h"
+
+#include "harness.h"
+
+void
+create_code (gcc_jit_context *ctxt, void *user_data)
+{
+  /* Let's try to inject the equivalent of:
+
+	double
+	test_nested_loops (int n, double *a, double *b)
+	{
+	  double result = 0.;
+	  for (int i = 0; i < n; i++)
+	    for (int j = 0; j < n; j++)
+	      result += a[i] * b[j];
+	  return result
+	}
+  */
+  gcc_jit_type *val_type =
+    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_DOUBLE);
+  gcc_jit_type *ptr_type = gcc_jit_type_get_pointer (val_type);
+  gcc_jit_type *int_type =
+    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
+
+  gcc_jit_type *return_type = val_type;
+  gcc_jit_param *param_n =
+    gcc_jit_context_new_param (ctxt, NULL, int_type, "n");
+  gcc_jit_param *param_a =
+    gcc_jit_context_new_param (ctxt, NULL, ptr_type, "a");
+  gcc_jit_param *param_b =
+    gcc_jit_context_new_param (ctxt, NULL, ptr_type, "b");
+  gcc_jit_param *params[3] = {param_n, param_a, param_b};
+  gcc_jit_function *func =
+    gcc_jit_context_new_function (ctxt, NULL,
+				  GCC_JIT_FUNCTION_EXPORTED,
+				  return_type,
+				  "test_nested_loops",
+				  3, params, 0);
+
+  /* Create locals. */
+  gcc_jit_lvalue *result =
+    gcc_jit_function_new_local (func, NULL, val_type, "result");
+  gcc_jit_lvalue *i =
+    gcc_jit_function_new_local (func, NULL, int_type, "i");
+  gcc_jit_lvalue *j =
+    gcc_jit_function_new_local (func, NULL, int_type, "j");
+
+  /* Create basic blocks. */
+  gcc_jit_block *b_entry =
+    gcc_jit_function_new_block (func, "b_entry");
+  gcc_jit_block *b_outer_loop_cond =
+    gcc_jit_function_new_block (func, "b_outer_loop_cond");
+  gcc_jit_block *b_outer_loop_head =
+    gcc_jit_function_new_block (func, "b_outer_loop_head");
+  gcc_jit_block *b_outer_loop_tail =
+    gcc_jit_function_new_block (func, "b_outer_loop_tail");
+  gcc_jit_block *b_inner_loop_cond =
+    gcc_jit_function_new_block (func, "b_inner_loop_cond");
+  gcc_jit_block *b_inner_loop_body =
+    gcc_jit_function_new_block (func, "b_inner_loop_body");
+  gcc_jit_block *b_exit =
+    gcc_jit_function_new_block (func, "b_exit");
+
+
+  /* Populate b_entry. */
+
+  /* "result = 0.;" */
+  gcc_jit_block_add_assignment (
+    b_entry, NULL,
+    result,
+    gcc_jit_context_zero (ctxt, val_type));
+  /* "i = 0;" */
+  gcc_jit_block_add_assignment (
+    b_entry, NULL,
+    i,
+    gcc_jit_context_zero (ctxt, int_type));
+  gcc_jit_block_end_with_jump (b_entry, NULL, b_outer_loop_cond);
+
+  /* Populate b_outer_loop_cond. */
+  gcc_jit_block_end_with_conditional (
+    b_outer_loop_cond,
+    NULL,
+    /* (i < n) */
+    gcc_jit_context_new_comparison (
+      ctxt, NULL,
+      GCC_JIT_COMPARISON_LT,
+      gcc_jit_lvalue_as_rvalue (i),
+      gcc_jit_param_as_rvalue (param_n)),
+    b_outer_loop_head,
+    b_exit);
+
+  /* Populate b_outer_loop_head. */
+  /* j = 0; */
+  gcc_jit_block_add_assignment (
+    b_outer_loop_head, NULL,
+    j,
+    gcc_jit_context_zero (ctxt, int_type));
+  gcc_jit_block_end_with_jump (b_outer_loop_head, NULL, b_inner_loop_cond);
+
+  /* Populate b_inner_loop_cond. */
+  gcc_jit_block_end_with_conditional (
+    b_inner_loop_cond,
+    NULL,
+    /* (j < n) */
+    gcc_jit_context_new_comparison (
+      ctxt, NULL,
+      GCC_JIT_COMPARISON_LT,
+      gcc_jit_lvalue_as_rvalue (j),
+      gcc_jit_param_as_rvalue (param_n)),
+    b_inner_loop_body,
+    b_outer_loop_tail);
+
+  /* Populate b_inner_loop_body. */
+  /* "result += a[i] * b[j];" */
+  gcc_jit_block_add_assignment_op (
+    b_inner_loop_body, NULL,
+    result,
+    GCC_JIT_BINARY_OP_PLUS,
+    gcc_jit_context_new_binary_op (
+      ctxt, NULL,
+      GCC_JIT_BINARY_OP_MULT,
+      val_type,
+      gcc_jit_lvalue_as_rvalue (
+        gcc_jit_context_new_array_access(
+          ctxt, NULL,
+          gcc_jit_param_as_rvalue (param_a),
+          gcc_jit_lvalue_as_rvalue (i))),
+      gcc_jit_lvalue_as_rvalue (
+        gcc_jit_context_new_array_access(
+          ctxt, NULL,
+          gcc_jit_param_as_rvalue (param_b),
+          gcc_jit_lvalue_as_rvalue (j)))));
+  /* "j++" */
+  gcc_jit_block_add_assignment_op (
+    b_inner_loop_body, NULL,
+    j,
+    GCC_JIT_BINARY_OP_PLUS,
+    gcc_jit_context_one (ctxt, int_type));
+
+  gcc_jit_block_end_with_jump (b_inner_loop_body, NULL, b_inner_loop_cond);
+
+  /* Populate b_outer_loop_tail. */
+  /* "i++" */
+  gcc_jit_block_add_assignment_op (
+    b_outer_loop_tail, NULL,
+    i,
+    GCC_JIT_BINARY_OP_PLUS,
+    gcc_jit_context_one (ctxt, int_type));
+  gcc_jit_block_end_with_jump (b_outer_loop_tail, NULL, b_outer_loop_cond);
+
+  /* Populate b_exit. */
+  /* "return result;" */
+  gcc_jit_block_end_with_return (
+    b_exit,
+    NULL,
+    gcc_jit_lvalue_as_rvalue (result));
+}
+
+void
+verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
+{
+  typedef double (*test_nested_loops_fn_type) (int n, double *a, double *b);
+  CHECK_NON_NULL (result);
+
+  test_nested_loops_fn_type test_nested_loops =
+    (test_nested_loops_fn_type)gcc_jit_result_get_code (result,
+						     "test_nested_loops");
+  CHECK_NON_NULL (test_nested_loops);
+  double test_a[] = {1., 2., 3., 4., 5., 6., 7., 8., 9., 10.};
+  double test_b[] = {5., 6., 7., 8., 9., 10., 1., 2., 3., 4.};
+  double val = test_nested_loops (10, test_a, test_b);
+  printf("test_nested_loops returned: %f\n", val);
+  CHECK_VALUE (val, 3025.0);
+}
diff --git a/gcc/testsuite/jit.dg/test-threads.c b/gcc/testsuite/jit.dg/test-threads.c
index f31d094..e3dd69f 100644
--- a/gcc/testsuite/jit.dg/test-threads.c
+++ b/gcc/testsuite/jit.dg/test-threads.c
@@ -127,6 +127,9 @@ const struct testcase testcases[] = {
   {"quadratic",
    create_code_quadratic,
    verify_code_quadratic},
+  {"nested_loop",
+   create_code_nested_loop,
+   verify_code_nested_loop},
   {"reading_struct ",
    create_code_reading_struct ,
    verify_code_reading_struct },
-- 
1.8.5.3