minwin-gcc-5-2/gcc/testsuite/jit.dg/test-quadratic.c

#include <stdlib.h>
#include <stdio.h>

#include "libgccjit.h"

#include "harness.h"

struct quadratic
{
  double a;
  double b;
  double c;
  double discriminant;
};

/* Let's try to inject the equivalent of:

     extern double sqrt (double);

     static void
     calc_discriminant (struct quadratic *q)
     {
       // (b^2 - 4ac)
       q->discriminant = (q->b * q->b) - (4 * q->a * q->c);
     }

     int
     test_quadratic (double a, double b, double c, double *r1, double *r2)
     {
       struct quadratic q;
       q.a = a;
       q.b = b;
       q.c = c;
       calc_discriminant (&q);
       if (q.discriminant > 0)
	 {
	    double s = sqrt (q.discriminant);
	    *r1 = (-b + s) / (2 * a);
	    *r2 = (-b - s) / (2 * a);
	    return 2;
	 }
       else if (q.discriminant == 0)
	 {
	    *r1 = -b / (2 * a);
	    return 1;
	 }
	 else return 0;
     }
*/

struct quadratic_test
{
  gcc_jit_context *ctxt;

  /* "double" and "(double *)".  */
  gcc_jit_type *numeric_type;
  gcc_jit_type *numeric_type_ptr;

  /* The value (double)0.  */
  gcc_jit_rvalue *zero;

  gcc_jit_type *int_type;
  gcc_jit_type *void_type;

  /* "struct quadratic" */
  gcc_jit_type *quadratic;
  gcc_jit_field *a;
  gcc_jit_field *b;
  gcc_jit_field *c;
  gcc_jit_field *discriminant;

  /* "(struct quadratic *)" */
  gcc_jit_type *quadratic_ptr;

  gcc_jit_function *calc_discriminant;

  gcc_jit_function *sqrt;

};

static void
make_types (struct quadratic_test *testcase)
{
  testcase->numeric_type =
    gcc_jit_context_get_type (testcase->ctxt, GCC_JIT_TYPE_DOUBLE);
  testcase->numeric_type_ptr =
    gcc_jit_type_get_pointer (testcase->numeric_type);
  testcase->zero =
    gcc_jit_context_zero (testcase->ctxt, testcase->numeric_type);

  testcase->int_type =
    gcc_jit_context_get_type (testcase->ctxt, GCC_JIT_TYPE_INT);

  testcase->void_type =
    gcc_jit_context_get_type (testcase->ctxt, GCC_JIT_TYPE_VOID);

  testcase->a =
    gcc_jit_context_new_field (testcase->ctxt,
			       NULL,
			       testcase->numeric_type,
			       "a");
  testcase->b =
    gcc_jit_context_new_field (testcase->ctxt,
			       NULL,
			       testcase->numeric_type,
			       "b");
  testcase->c =
    gcc_jit_context_new_field (testcase->ctxt,
			       NULL,
			       testcase->numeric_type,
			       "c");
  testcase->discriminant =
    gcc_jit_context_new_field (testcase->ctxt,
			       NULL,
			       testcase->numeric_type,
			       "discriminant");
  gcc_jit_field *fields[] = {testcase->a,
			     testcase->b,
			     testcase->c,
			     testcase->discriminant};
  testcase->quadratic =
    gcc_jit_struct_as_type (
      gcc_jit_context_new_struct_type (testcase->ctxt, NULL,
				       "quadratic", 4, fields));
  testcase->quadratic_ptr = gcc_jit_type_get_pointer (testcase->quadratic);
}

static void
make_sqrt (struct quadratic_test *testcase)
{
  gcc_jit_param *param_x =
    gcc_jit_context_new_param (testcase->ctxt, NULL,
			       testcase->numeric_type, "x");
  testcase->sqrt =
    gcc_jit_context_new_function (testcase->ctxt, NULL,
				  GCC_JIT_FUNCTION_IMPORTED,
				  testcase->numeric_type,
				  "sqrt",
				  1, &param_x,
				  0);
}

static void
make_calc_discriminant (struct quadratic_test *testcase)
{
  /* Build "calc_discriminant".  */
  gcc_jit_param *param_q =
    gcc_jit_context_new_param (testcase->ctxt, NULL,
			       testcase->quadratic_ptr, "q");
  testcase->calc_discriminant =
    gcc_jit_context_new_function (testcase->ctxt, NULL,
				  GCC_JIT_FUNCTION_INTERNAL,
				  testcase->void_type,
				  "calc_discriminant",
				  1, &param_q,
				  0);
  gcc_jit_block *blk =
    gcc_jit_function_new_block (testcase->calc_discriminant, NULL);
  gcc_jit_block_add_comment (
    blk, NULL,
    "(b^2 - 4ac)");

  gcc_jit_rvalue *q_a =
    gcc_jit_lvalue_as_rvalue (
	gcc_jit_rvalue_dereference_field (
	  gcc_jit_param_as_rvalue (param_q),
	  NULL, testcase->a));
  gcc_jit_rvalue *q_b =
    gcc_jit_lvalue_as_rvalue (
	gcc_jit_rvalue_dereference_field (
	  gcc_jit_param_as_rvalue (param_q),
	  NULL, testcase->b));
  gcc_jit_rvalue *q_c =
    gcc_jit_lvalue_as_rvalue (
	gcc_jit_rvalue_dereference_field (
	  gcc_jit_param_as_rvalue (param_q),
	  NULL, testcase->c));

  /* (q->b * q->b) - (4 * q->a * q->c) */
  gcc_jit_rvalue *rhs =
    gcc_jit_context_new_binary_op (
      testcase->ctxt, NULL,
      GCC_JIT_BINARY_OP_MINUS,
      testcase->numeric_type,

      /* (q->b * q->b) */
      gcc_jit_context_new_binary_op (
	testcase->ctxt, NULL,
	GCC_JIT_BINARY_OP_MULT,
	testcase->numeric_type,
	q_b, q_b),

      /* (4 * (q->a * q->c)) */
      gcc_jit_context_new_binary_op (
	testcase->ctxt, NULL,
	GCC_JIT_BINARY_OP_MULT,
	testcase->numeric_type,
	/* 4.0 */
	gcc_jit_context_new_rvalue_from_int (
	  testcase->ctxt,
	  testcase->numeric_type,
	  4),
	/* (q->a * q->c) */
	gcc_jit_context_new_binary_op (
	  testcase->ctxt, NULL,
	  GCC_JIT_BINARY_OP_MULT,
	  testcase->numeric_type,
	  q_a, q_c)));

  CHECK_STRING_VALUE (
     gcc_jit_object_get_debug_string (gcc_jit_rvalue_as_object (rhs)),
     "q->b * q->b - (double)4 * q->a * q->c");

  gcc_jit_block_add_assignment (
    blk, NULL,

    /* q->discriminant =...  */
    gcc_jit_rvalue_dereference_field (
      gcc_jit_param_as_rvalue (param_q),
      NULL,
      testcase->discriminant),
    rhs);

  gcc_jit_block_end_with_void_return (blk, NULL);
}

static void
make_test_quadratic (struct quadratic_test *testcase)
{
  gcc_jit_param *a =
    gcc_jit_context_new_param (testcase->ctxt, NULL,
			       testcase->numeric_type, "a");
  gcc_jit_param *b =
    gcc_jit_context_new_param (testcase->ctxt, NULL,
			       testcase->numeric_type, "b");
  gcc_jit_param *c =
    gcc_jit_context_new_param (testcase->ctxt, NULL,
			       testcase->numeric_type, "c");
  gcc_jit_param *r1 =
    gcc_jit_context_new_param (testcase->ctxt, NULL,
			       testcase->numeric_type_ptr, "r1");
  gcc_jit_param *r2 =
    gcc_jit_context_new_param (testcase->ctxt, NULL,
			       testcase->numeric_type_ptr, "r2");
  gcc_jit_param *params[] = {a, b, c, r1, r2};
  gcc_jit_function *test_quadratic =
    gcc_jit_context_new_function (testcase->ctxt, NULL,
				  GCC_JIT_FUNCTION_EXPORTED,
				  testcase->int_type,
				  "test_quadratic",
				  5, params,
				  0);
  /* struct quadratic q; */
  gcc_jit_lvalue *q =
    gcc_jit_function_new_local (
      test_quadratic, NULL,
      testcase->quadratic,
      "q");

  gcc_jit_block *initial =
    gcc_jit_function_new_block (test_quadratic,
				"initial");
  gcc_jit_block *on_positive_discriminant
    = gcc_jit_function_new_block (test_quadratic,
				  "positive_discriminant");

  gcc_jit_block *on_nonpositive_discriminant
    = gcc_jit_function_new_block (test_quadratic,
				  "nonpositive_discriminant");

  gcc_jit_block *on_zero_discriminant
    = gcc_jit_function_new_block (test_quadratic,
				  "zero_discriminant");

  gcc_jit_block *on_negative_discriminant
    = gcc_jit_function_new_block (test_quadratic,
				  "negative_discriminant");

  /* Initial block.  */
  /* q.a = a; */
  gcc_jit_block_add_assignment (
    initial, NULL,
    gcc_jit_lvalue_access_field (q, NULL, testcase->a),
    gcc_jit_param_as_rvalue (a));
  /* q.b = b; */
  gcc_jit_block_add_assignment (
    initial, NULL,
    gcc_jit_lvalue_access_field (q, NULL, testcase->b),
    gcc_jit_param_as_rvalue (b));
  /* q.c = c; */
  gcc_jit_block_add_assignment (
    initial, NULL,
    gcc_jit_lvalue_access_field (q, NULL, testcase->c),
    gcc_jit_param_as_rvalue (c));
  /* calc_discriminant (&q); */
  gcc_jit_rvalue *address_of_q = gcc_jit_lvalue_get_address (q, NULL);
  gcc_jit_block_add_eval (
    initial, NULL,
    gcc_jit_context_new_call (
      testcase->ctxt, NULL,
      testcase->calc_discriminant,
      1, &address_of_q));

  gcc_jit_block_add_comment (
    initial, NULL,
    "if (q.discriminant > 0)");
  gcc_jit_block_end_with_conditional (
    initial, NULL,
    gcc_jit_context_new_comparison (
      testcase->ctxt, NULL,
      GCC_JIT_COMPARISON_GT,
      gcc_jit_rvalue_access_field (
	gcc_jit_lvalue_as_rvalue (q),
	NULL,
	testcase->discriminant),
      testcase->zero),
    on_positive_discriminant,
    on_nonpositive_discriminant);

  /* Block: "on_positive_discriminant" */
  /* double s = sqrt (q.discriminant); */
  gcc_jit_lvalue *s = gcc_jit_function_new_local (
    test_quadratic, NULL,
    testcase->numeric_type,
    "s");
  gcc_jit_rvalue *discriminant_of_q =
    gcc_jit_rvalue_access_field (gcc_jit_lvalue_as_rvalue (q),
				 NULL,
				 testcase->discriminant);
  gcc_jit_block_add_assignment (
    on_positive_discriminant, NULL,
    s,
    gcc_jit_context_new_call (
      testcase->ctxt, NULL,
      testcase->sqrt,
      1, &discriminant_of_q));

  gcc_jit_rvalue *minus_b =
    gcc_jit_context_new_unary_op (
      testcase->ctxt, NULL,
      GCC_JIT_UNARY_OP_MINUS,
      testcase->numeric_type,
      gcc_jit_param_as_rvalue (b));
  gcc_jit_rvalue *two_a =
    gcc_jit_context_new_binary_op (
      testcase->ctxt, NULL,
      GCC_JIT_BINARY_OP_MULT,
      testcase->numeric_type,
      gcc_jit_context_new_rvalue_from_int (
	testcase->ctxt,
	testcase->numeric_type,
	2),
      gcc_jit_param_as_rvalue (a));

  gcc_jit_block_add_comment (
    on_positive_discriminant, NULL,
    "*r1 = (-b + s) / (2 * a);");
  gcc_jit_block_add_assignment (
    on_positive_discriminant, NULL,

    /* "*r1 = ..." */
    gcc_jit_rvalue_dereference (
      gcc_jit_param_as_rvalue (r1), NULL),

    /* (-b + s) / (2 * a) */
    gcc_jit_context_new_binary_op (
      testcase->ctxt, NULL,
      GCC_JIT_BINARY_OP_DIVIDE,
      testcase->numeric_type,
      gcc_jit_context_new_binary_op (
	testcase->ctxt, NULL,
	GCC_JIT_BINARY_OP_PLUS,
	testcase->numeric_type,
	minus_b,
	gcc_jit_lvalue_as_rvalue (s)),
      two_a));

  gcc_jit_block_add_comment (
    on_positive_discriminant, NULL,
    "*r2 = (-b - s) / (2 * a)");
  gcc_jit_block_add_assignment (
    on_positive_discriminant, NULL,

    /* "*r2 = ..." */
    gcc_jit_rvalue_dereference (
      gcc_jit_param_as_rvalue (r2), NULL),

    /* (-b - s) / (2 * a) */
    gcc_jit_context_new_binary_op (
      testcase->ctxt, NULL,
      GCC_JIT_BINARY_OP_DIVIDE,
      testcase->numeric_type,
      gcc_jit_context_new_binary_op (
	testcase->ctxt, NULL,
	GCC_JIT_BINARY_OP_MINUS,
	testcase->numeric_type,
	minus_b,
	gcc_jit_lvalue_as_rvalue (s)),
      two_a));

  /* "return 2;" */
  gcc_jit_block_end_with_return (
    on_positive_discriminant, NULL,
    gcc_jit_context_new_rvalue_from_int (
      testcase->ctxt,
      testcase->int_type,
      2));

  /* Block: "on_nonpositive_discriminant" */
  gcc_jit_block_add_comment (
    on_nonpositive_discriminant, NULL,
    "else if (q.discriminant == 0)");
  gcc_jit_block_end_with_conditional (
    on_nonpositive_discriminant, NULL,
    gcc_jit_context_new_comparison (
      testcase->ctxt, NULL,
      GCC_JIT_COMPARISON_EQ,
      gcc_jit_rvalue_access_field (
	gcc_jit_lvalue_as_rvalue (q),
	NULL,
	testcase->discriminant),
      testcase->zero),
    on_zero_discriminant,
    on_negative_discriminant);

  /* Block: "on_zero_discriminant" */
  gcc_jit_block_add_comment (
    on_zero_discriminant, NULL,
    "*r1 = -b / (2 * a);");
  gcc_jit_block_add_assignment (
    on_zero_discriminant, NULL,

    /* "*r1 = ..." */
    gcc_jit_rvalue_dereference (
      gcc_jit_param_as_rvalue (r1), NULL),

    /* -b / (2 * a) */
    gcc_jit_context_new_binary_op (
      testcase->ctxt, NULL,
      GCC_JIT_BINARY_OP_DIVIDE,
      testcase->numeric_type,
      minus_b,
      two_a));
  gcc_jit_block_end_with_return (
    /* "return 1;" */
    on_zero_discriminant, NULL,
      gcc_jit_context_one (testcase->ctxt, testcase->int_type));

  /* Block: "on_negative_discriminant" */
  gcc_jit_block_end_with_return (
    /* "else return 0;" */
    on_negative_discriminant, NULL,
    gcc_jit_context_zero (testcase->ctxt, testcase->int_type));
}

void
create_code (gcc_jit_context *ctxt, void *user_data)
{
  struct quadratic_test testcase;
  memset (&testcase, 0, sizeof (testcase));
  testcase.ctxt = ctxt;
  make_types (&testcase);
  make_sqrt (&testcase);
  make_calc_discriminant (&testcase);
  make_test_quadratic (&testcase);
}

void
verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
{
  typedef int (*fn_type) (double a, double b, double c,
			  double *r1, double *r2);

  CHECK_NON_NULL (result);

  fn_type test_quadratic =
    (fn_type)gcc_jit_result_get_code (result, "test_quadratic");
  CHECK_NON_NULL (test_quadratic);

  /* Verify that the code correctly solves quadratic equations.  */
  double r1, r2;

  /* This one has two solutions: */
  CHECK_VALUE (test_quadratic (1, 3, -4, &r1, &r2), 2);
  CHECK_VALUE (r1, 1);
  CHECK_VALUE (r2, -4);

  /* This one has one solution: */
  CHECK_VALUE (test_quadratic (4, 4, 1, &r1, &r2), 1);
  CHECK_VALUE (r1, -0.5);

  /* This one has no real solutions: */
  CHECK_VALUE (test_quadratic (4, 1, 1, &r1, &r2), 0);
}