void
create_code (gcc_jit_context *ctxt, void *user_data)
{
    /* Let's try to inject the equivalent of:

         struct foo;

         extern void called_function (struct foo *ptr);

         void
         test_fn ()
         {
           struct foo f;
     called_function (f);
       }

       and verify that we get a type error (foo * vs foo).
    */
    gcc_jit_type *void_type =
        gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID);
    gcc_jit_struct *struct_foo =
        gcc_jit_context_new_struct_type (ctxt, NULL, "foo", 0, NULL);
    gcc_jit_type *foo_ptr =
        gcc_jit_type_get_pointer (gcc_jit_struct_as_type (struct_foo));
    gcc_jit_param *param =
        gcc_jit_context_new_param (ctxt, NULL, foo_ptr, "ptr");

    gcc_jit_function *called_function =
        gcc_jit_context_new_function (ctxt, NULL,
                                      GCC_JIT_FUNCTION_IMPORTED,
                                      void_type,
                                      "called_function",
                                      1, &param,
                                      0);

    gcc_jit_function *test_fn =
        gcc_jit_context_new_function (ctxt, NULL,
                                      GCC_JIT_FUNCTION_EXPORTED,
                                      void_type,
                                      "test_fn",
                                      0, NULL,
                                      0);
    gcc_jit_lvalue *f =
        gcc_jit_function_new_local (
            test_fn, NULL, gcc_jit_struct_as_type (struct_foo), "f");

    gcc_jit_block *block = gcc_jit_function_new_block (test_fn, NULL);

    gcc_jit_rvalue *arg = gcc_jit_lvalue_as_rvalue (f);

    gcc_jit_block_add_eval (
        block, NULL,
        gcc_jit_context_new_call (
            ctxt, NULL,
            called_function,
            1, &arg));
    gcc_jit_block_end_with_void_return (block, NULL);
}
示例#2
0
void
create_code (gcc_jit_context *ctxt, void *user_data)
{
  /* Where "ETC" is a very long suffix, let's try to inject the
     equivalent of:

       struct struct_ETC;

       int
       test_fn_ETC ()
       {
	  int local_ETC;
	  local_ETC = 42;
	  return local_ETC;
       }

     to verify that the API copes with such long names.  */

  populate_names ();

  gcc_jit_type *int_type =
    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);

  /* We don't yet use this struct.  */
  (void)gcc_jit_context_new_opaque_struct (ctxt, NULL,
					   long_names.struct_name);

  gcc_jit_function *test_fn =
    gcc_jit_context_new_function (ctxt, NULL,
				  GCC_JIT_FUNCTION_EXPORTED,
				  int_type,
				  long_names.fn_name,
				  0, NULL,
				  0);
  gcc_jit_lvalue *local =
    gcc_jit_function_new_local (test_fn,
				NULL,
				int_type,
				long_names.local_name);

  gcc_jit_block *block =
    gcc_jit_function_new_block (test_fn, long_names.block_name);

  gcc_jit_block_add_assignment (
    block,
    NULL,
    local,
    gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 42));

  gcc_jit_block_end_with_return (
    block, NULL,
    gcc_jit_lvalue_as_rvalue (local));
}
示例#3
0
void
create_code (gcc_jit_context *ctxt, void *user_data)
{
  /* Let's try to inject the equivalent of:
     float
     test_union (int i)
     {
        union int_or_float u;
	u.as_int = i;
	return u.as_float;
     }
  */
  gcc_jit_type *int_type =
    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
  gcc_jit_type *float_type =
    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_FLOAT);
  gcc_jit_field *as_int =
    gcc_jit_context_new_field (ctxt,
                               NULL,
                               int_type,
                               "as_int");
  gcc_jit_field *as_float =
    gcc_jit_context_new_field (ctxt,
                               NULL,
                               float_type,
                               "as_float");
  gcc_jit_field *fields[] = {as_int, as_float};
  gcc_jit_type *union_type =
    gcc_jit_context_new_union_type (ctxt, NULL,
				    "int_or_float", 2, fields);

  /* Build the test function.  */
  gcc_jit_param *param_i =
    gcc_jit_context_new_param (ctxt, NULL, int_type, "i");
  gcc_jit_function *test_fn =
    gcc_jit_context_new_function (ctxt, NULL,
                                  GCC_JIT_FUNCTION_EXPORTED,
                                  float_type,
                                  "test_union",
                                  1, &param_i,
                                  0);

  gcc_jit_lvalue *u =
    gcc_jit_function_new_local (test_fn, NULL,
				union_type, "u");

  gcc_jit_block *block = gcc_jit_function_new_block (test_fn, NULL);

  /* u.as_int = i; */
  gcc_jit_block_add_assignment (
    block,
    NULL,
    /* "u.as_int = ..." */
    gcc_jit_lvalue_access_field (u,
				 NULL,
				 as_int),
    gcc_jit_param_as_rvalue (param_i));

  /* return u.as_float; */
  gcc_jit_block_end_with_return (
    block, NULL,
    gcc_jit_rvalue_access_field (gcc_jit_lvalue_as_rvalue (u),
				 NULL,
				 as_float));
}
示例#4
0
void
create_code (gcc_jit_context *ctxt)
{
  /*
    Simple sum-of-squares, to test conditionals and looping

    int loop_test (int n)
    {
      int i;
      int sum = 0;
      for (i = 0; i < n ; i ++)
      {
	sum += i * i;
      }
      return sum;
   */
  gcc_jit_type *the_type =
    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
  gcc_jit_type *return_type = the_type;

  gcc_jit_param *n =
    gcc_jit_context_new_param (ctxt, NULL, the_type, "n");
  gcc_jit_param *params[1] = {n};
  gcc_jit_function *func =
    gcc_jit_context_new_function (ctxt, NULL,
				  GCC_JIT_FUNCTION_EXPORTED,
				  return_type,
				  "loop_test",
				  1, params, 0);

  /* Build locals:  */
  gcc_jit_lvalue *i =
    gcc_jit_function_new_local (func, NULL, the_type, "i");
  gcc_jit_lvalue *sum =
    gcc_jit_function_new_local (func, NULL, the_type, "sum");

  gcc_jit_block *b_initial =
    gcc_jit_function_new_block (func, "initial");
  gcc_jit_block *b_loop_cond =
    gcc_jit_function_new_block (func, "loop_cond");
  gcc_jit_block *b_loop_body =
    gcc_jit_function_new_block (func, "loop_body");
  gcc_jit_block *b_after_loop =
    gcc_jit_function_new_block (func, "after_loop");

  /* sum = 0; */
  gcc_jit_block_add_assignment (
    b_initial, NULL,
    sum,
    gcc_jit_context_zero (ctxt, the_type));

  /* i = 0; */
  gcc_jit_block_add_assignment (
    b_initial, NULL,
    i,
    gcc_jit_context_zero (ctxt, the_type));

  gcc_jit_block_end_with_jump (b_initial, NULL, b_loop_cond);

  /* if (i >= n) */
  gcc_jit_block_end_with_conditional (
    b_loop_cond, NULL,
    gcc_jit_context_new_comparison (
       ctxt, NULL,
       GCC_JIT_COMPARISON_GE,
       gcc_jit_lvalue_as_rvalue (i),
       gcc_jit_param_as_rvalue (n)),
    b_after_loop,
    b_loop_body);

  /* sum += i * i */
  gcc_jit_block_add_assignment_op (
    b_loop_body, NULL,
    sum,
    GCC_JIT_BINARY_OP_PLUS,
    gcc_jit_context_new_binary_op (
      ctxt, NULL,
      GCC_JIT_BINARY_OP_MULT, the_type,
      gcc_jit_lvalue_as_rvalue (i),
      gcc_jit_lvalue_as_rvalue (i)));

  /* i++ */
  gcc_jit_block_add_assignment_op (
    b_loop_body, NULL,
    i,
    GCC_JIT_BINARY_OP_PLUS,
    gcc_jit_context_one (ctxt, the_type));

  gcc_jit_block_end_with_jump (b_loop_body, NULL, b_loop_cond);

  /* return sum */
  gcc_jit_block_end_with_return (
    b_after_loop,
    NULL,
    gcc_jit_lvalue_as_rvalue (sum));
}
示例#5
0
文件: toyvm.c 项目: KangDroid/gcc
static toyvm_compiled_function *
toyvm_function_compile (toyvm_function *fn)
{
  compilation_state state;
  int pc;
  char *funcname;

  memset (&state, 0, sizeof (state));

  funcname = get_function_name (fn->fn_filename);

  state.ctxt = gcc_jit_context_acquire ();

  gcc_jit_context_set_bool_option (state.ctxt,
				   GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE,
				   0);
  gcc_jit_context_set_bool_option (state.ctxt,
				   GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE,
				   0);
  gcc_jit_context_set_int_option (state.ctxt,
				  GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL,
				  3);
  gcc_jit_context_set_bool_option (state.ctxt,
				   GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES,
				   0);
  gcc_jit_context_set_bool_option (state.ctxt,
				   GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING,
				   0);
  gcc_jit_context_set_bool_option (state.ctxt,
				   GCC_JIT_BOOL_OPTION_DEBUGINFO,
				   1);

  /* Create types.  */
  state.int_type =
    gcc_jit_context_get_type (state.ctxt, GCC_JIT_TYPE_INT);
  state.bool_type =
    gcc_jit_context_get_type (state.ctxt, GCC_JIT_TYPE_BOOL);
  state.stack_type =
    gcc_jit_context_new_array_type (state.ctxt, NULL,
				    state.int_type, MAX_STACK_DEPTH);

  /* The constant value 1.  */
  state.const_one = gcc_jit_context_one (state.ctxt, state.int_type);

  /* Create locations.  */
  for (pc = 0; pc < fn->fn_num_ops; pc++)
    {
      toyvm_op *op = &fn->fn_ops[pc];

      state.op_locs[pc] = gcc_jit_context_new_location (state.ctxt,
							fn->fn_filename,
							op->op_linenum,
							0); /* column */
    }

  /* Creating the function.  */
  state.param_arg =
    gcc_jit_context_new_param (state.ctxt, state.op_locs[0],
			       state.int_type, "arg");
  state.fn =
    gcc_jit_context_new_function (state.ctxt,
				  state.op_locs[0],
				  GCC_JIT_FUNCTION_EXPORTED,
				  state.int_type,
				  funcname,
				  1, &state.param_arg, 0);

  /* Create stack lvalues.  */
  state.stack =
    gcc_jit_function_new_local (state.fn, NULL,
				state.stack_type, "stack");
  state.stack_depth =
    gcc_jit_function_new_local (state.fn, NULL,
				state.int_type, "stack_depth");
  state.x =
    gcc_jit_function_new_local (state.fn, NULL,
				state.int_type, "x");
  state.y =
    gcc_jit_function_new_local (state.fn, NULL,
				state.int_type, "y");

  /* 1st pass: create blocks, one per opcode. */

  /* We need an entry block to do one-time initialization, so create that
     first.  */
  state.initial_block = gcc_jit_function_new_block (state.fn, "initial");

  /* Create a block per operation.  */
  for (pc = 0; pc < fn->fn_num_ops; pc++)
    {
      char buf[16];
      sprintf (buf, "instr%i", pc);
      state.op_blocks[pc] = gcc_jit_function_new_block (state.fn, buf);
    }

  /* Populate the initial block.  */

  /* "stack_depth = 0;".  */
  gcc_jit_block_add_assignment (
    state.initial_block,
    state.op_locs[0],
    state.stack_depth,
    gcc_jit_context_zero (state.ctxt, state.int_type));

  /* "PUSH (arg);".  */
  add_push (&state,
	    state.initial_block,
	    gcc_jit_param_as_rvalue (state.param_arg),
	    state.op_locs[0]);

  /* ...and jump to insn 0.  */
  gcc_jit_block_end_with_jump (state.initial_block,
			       state.op_locs[0],
			       state.op_blocks[0]);

  /* 2nd pass: fill in instructions.  */
  for (pc = 0; pc < fn->fn_num_ops; pc++)
    {
      gcc_jit_location *loc = state.op_locs[pc];

      gcc_jit_block *block = state.op_blocks[pc];
      gcc_jit_block *next_block = (pc < fn->fn_num_ops
				   ? state.op_blocks[pc + 1]
				   : NULL);

      toyvm_op *op;
      op = &fn->fn_ops[pc];

      /* Helper macros.  */

#define X_EQUALS_POP()\
      add_pop (&state, block, state.x, loc)
#define Y_EQUALS_POP()\
      add_pop (&state, block, state.y, loc)
#define PUSH_RVALUE(RVALUE)\
      add_push (&state, block, (RVALUE), loc)
#define PUSH_X()\
      PUSH_RVALUE (gcc_jit_lvalue_as_rvalue (state.x))
#define PUSH_Y() \
      PUSH_RVALUE (gcc_jit_lvalue_as_rvalue (state.y))

      gcc_jit_block_add_comment (block, loc, opcode_names[op->op_opcode]);

      /* Handle the individual opcodes.  */

      switch (op->op_opcode)
	{
	case DUP:
	  X_EQUALS_POP ();
	  PUSH_X ();
	  PUSH_X ();
	  break;

	case ROT:
	  Y_EQUALS_POP ();
	  X_EQUALS_POP ();
	  PUSH_Y ();
	  PUSH_X ();
	  break;

	case BINARY_ADD:
	  Y_EQUALS_POP ();
	  X_EQUALS_POP ();
	  PUSH_RVALUE (
	   gcc_jit_context_new_binary_op (
	     state.ctxt,
	     loc,
	     GCC_JIT_BINARY_OP_PLUS,
	     state.int_type,
	     gcc_jit_lvalue_as_rvalue (state.x),
	     gcc_jit_lvalue_as_rvalue (state.y)));
	  break;

	case BINARY_SUBTRACT:
	  Y_EQUALS_POP ();
	  X_EQUALS_POP ();
	  PUSH_RVALUE (
	   gcc_jit_context_new_binary_op (
	     state.ctxt,
	     loc,
	     GCC_JIT_BINARY_OP_MINUS,
	     state.int_type,
	     gcc_jit_lvalue_as_rvalue (state.x),
	     gcc_jit_lvalue_as_rvalue (state.y)));
	  break;

	case BINARY_MULT:
	  Y_EQUALS_POP ();
	  X_EQUALS_POP ();
	  PUSH_RVALUE (
	   gcc_jit_context_new_binary_op (
	     state.ctxt,
	     loc,
	     GCC_JIT_BINARY_OP_MULT,
	     state.int_type,
	     gcc_jit_lvalue_as_rvalue (state.x),
	     gcc_jit_lvalue_as_rvalue (state.y)));
	  break;

	case BINARY_COMPARE_LT:
	  Y_EQUALS_POP ();
	  X_EQUALS_POP ();
	  PUSH_RVALUE (
	     /* cast of bool to int */
	     gcc_jit_context_new_cast (
	       state.ctxt,
	       loc,
	       /* (x < y) as a bool */
	       gcc_jit_context_new_comparison (
		 state.ctxt,
		 loc,
		 GCC_JIT_COMPARISON_LT,
		 gcc_jit_lvalue_as_rvalue (state.x),
		 gcc_jit_lvalue_as_rvalue (state.y)),
	       state.int_type));
	  break;

	case RECURSE:
	  {
	    X_EQUALS_POP ();
	    gcc_jit_rvalue *arg = gcc_jit_lvalue_as_rvalue (state.x);
	    PUSH_RVALUE (
	      gcc_jit_context_new_call (
		state.ctxt,
		loc,
		state.fn,
		1, &arg));
	    break;
	  }

	case RETURN:
	  X_EQUALS_POP ();
	  gcc_jit_block_end_with_return (
	    block,
	    loc,
	    gcc_jit_lvalue_as_rvalue (state.x));
	  break;

	  /* Ops taking an operand.  */
	case PUSH_CONST:
	  PUSH_RVALUE (
	    gcc_jit_context_new_rvalue_from_int (
	      state.ctxt,
	      state.int_type,
	      op->op_operand));
	  break;

	case JUMP_ABS_IF_TRUE:
	  X_EQUALS_POP ();
	  gcc_jit_block_end_with_conditional (
	    block,
	    loc,
	    /* "(bool)x".  */
	    gcc_jit_context_new_cast (
	      state.ctxt,
	      loc,
	      gcc_jit_lvalue_as_rvalue (state.x),
	      state.bool_type),
	    state.op_blocks[op->op_operand], /* on_true */
	    next_block); /* on_false */
	  break;

	default:
	  assert(0);
	} /* end of switch on opcode */

      /* Go to the next block.  */
      if (op->op_opcode != JUMP_ABS_IF_TRUE
	  && op->op_opcode != RETURN)
	gcc_jit_block_end_with_jump (
	  block,
	  loc,
	  next_block);

    } /* end of loop on PC locations.  */

  /* We've now finished populating the context.  Compile it.  */
  gcc_jit_result *jit_result = gcc_jit_context_compile (state.ctxt);
  gcc_jit_context_release (state.ctxt);

  toyvm_compiled_function *toyvm_result =
    (toyvm_compiled_function *)calloc (1, sizeof (toyvm_compiled_function));
  if (!toyvm_result)
    {
      fprintf (stderr, "out of memory allocating toyvm_compiled_function\n");
      gcc_jit_result_release (jit_result);
      return NULL;
    }

  toyvm_result->cf_jit_result = jit_result;
  toyvm_result->cf_code =
    (toyvm_compiled_code)gcc_jit_result_get_code (jit_result,
						  funcname);

  free (funcname);

  return toyvm_result;
}
示例#6
0
static void
create_overflow_fn (gcc_jit_context *ctxt,
		    gcc_jit_type *type,
		    const char *funcname,
		    const char *builtin_name)
{
  /* Create the equivalent of this C:

       int
       test_overflow_T_OP (T x, T y, int *ovf)
       {
	 T result;
	 result = x OP y;
	 *ovf = ...; // did overflow happen?
	 return result;
       }

  */
  gcc_jit_type *t_bool =
    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_BOOL);
  gcc_jit_type *t_bool_star =
    gcc_jit_type_get_pointer (t_bool);

  gcc_jit_param *x =
    gcc_jit_context_new_param (
      ctxt,
      NULL,
      type, "x");
  gcc_jit_param *y =
    gcc_jit_context_new_param (
      ctxt,
      NULL,
      type, "y");
  gcc_jit_param *ovf =
    gcc_jit_context_new_param (
      ctxt,
      NULL,
      t_bool_star, "ovf");
  gcc_jit_param *params[3] = {x, y, ovf};

  gcc_jit_function *func =
    gcc_jit_context_new_function (ctxt,
				  NULL,
				  GCC_JIT_FUNCTION_EXPORTED,
				  type,
				  funcname,
				  3, params, 0);

  gcc_jit_lvalue *result =
    gcc_jit_function_new_local (func, NULL, type, "result");

  gcc_jit_block *b_initial =
    gcc_jit_function_new_block (func, "initial");

  /* The builtins are listed in builtins.def as being variadic, but
     the have these signatures:
       bool __builtin_add_overflow (type1 a, type2 b, type3 *res);
       bool __builtin_sub_overflow (type1 a, type2 b, type3 *res);
       bool __builtin_mul_overflow (type1 a, type2 b, type3 *res);  */

  gcc_jit_function *builtin_fn =
    gcc_jit_context_get_builtin_function (ctxt, builtin_name);

  /* Construct a call of the form:
       (returns bool) __builtin_add_overflow (x, y, &result).  */
  gcc_jit_rvalue *args[3] = {gcc_jit_param_as_rvalue (x),
			     gcc_jit_param_as_rvalue (y),
			     gcc_jit_lvalue_get_address (result, NULL)};
  gcc_jit_rvalue *call =
    gcc_jit_context_new_call (ctxt,
			      NULL,
			      builtin_fn,
			      3, args);

  /* "*ovf = BUILTIN_CALL ();" */
  gcc_jit_block_add_assignment (
    b_initial, NULL,
    gcc_jit_rvalue_dereference (gcc_jit_param_as_rvalue (ovf),
				NULL),
    call);

  /* "return result;" */
  gcc_jit_block_end_with_return (
    b_initial, NULL,
    gcc_jit_lvalue_as_rvalue (result));
}
示例#7
0
/* Build various compound expressions, and verify that they have sane debug
   strings.  */
void
create_code (gcc_jit_context *ctxt, void *user_data)
{
  /* Make a singly-linked list type:
      struct node
      {
       struct node *next;
       int value;
      };
  */
  gcc_jit_type *t_int =
    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
  gcc_jit_struct *t_node =
    gcc_jit_context_new_opaque_struct (ctxt, NULL, "node");
  gcc_jit_type *t_node_ptr =
    gcc_jit_type_get_pointer (gcc_jit_struct_as_type (t_node));
  gcc_jit_field *f_next =
    gcc_jit_context_new_field (ctxt, NULL, t_node_ptr, "next");
  gcc_jit_field *f_value =
    gcc_jit_context_new_field (ctxt, NULL, t_int, "value");
  gcc_jit_field *fields[] = {f_next, f_value};
  gcc_jit_struct_set_fields (t_node, NULL, 2, fields);

  /* Create a dummy function so that we have locals/params to build
     expressions with.  */
  gcc_jit_type *t_void =
    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID);
  gcc_jit_function *fn =
    gcc_jit_context_new_function (ctxt, NULL,
				  GCC_JIT_FUNCTION_EXPORTED,
				  t_void,
				  "test_debug_strings",
				  0, NULL, 0);
  gcc_jit_rvalue *ptr =
    gcc_jit_lvalue_as_rvalue (
      gcc_jit_function_new_local (fn,
				  NULL,
				  t_node_ptr,
				  "ptr"));
  gcc_jit_rvalue *a =
    gcc_jit_lvalue_as_rvalue (
      gcc_jit_function_new_local (fn, NULL, t_int, "a"));
  gcc_jit_rvalue *b =
    gcc_jit_lvalue_as_rvalue (
      gcc_jit_function_new_local (fn, NULL, t_int, "b"));
  gcc_jit_rvalue *c =
    gcc_jit_lvalue_as_rvalue (
      gcc_jit_function_new_local (fn, NULL, t_int, "c"));
  gcc_jit_rvalue *d =
    gcc_jit_lvalue_as_rvalue (
      gcc_jit_function_new_local (fn, NULL, t_int, "d"));

#define CHECK_RVALUE_DEBUG_STRING(RVALUE, EXPECTED) \
  CHECK_STRING_VALUE ( \
    gcc_jit_object_get_debug_string (gcc_jit_rvalue_as_object (RVALUE)), \
    (EXPECTED))

#define CHECK_LVALUE_DEBUG_STRING(LVALUE, EXPECTED) \
  CHECK_STRING_VALUE ( \
    gcc_jit_object_get_debug_string (gcc_jit_lvalue_as_object (LVALUE)), \
    (EXPECTED))

  /* Verify various simple compound expressions.  */
  {
    CHECK_RVALUE_DEBUG_STRING (ptr, "ptr");

    gcc_jit_lvalue *deref =
      gcc_jit_rvalue_dereference_field (ptr,
					NULL,
					f_value);
    CHECK_LVALUE_DEBUG_STRING (deref, "ptr->value");

    gcc_jit_rvalue *deref_as_rvalue = gcc_jit_lvalue_as_rvalue (deref);

#define BINOP(OP, A, B) \
    gcc_jit_context_new_binary_op (ctxt, NULL, \
				   GCC_JIT_BINARY_OP_##OP, t_int, (A), (B))
#define COMPARISON(OP, A, B) \
    gcc_jit_context_new_comparison (ctxt, NULL, \
				    GCC_JIT_COMPARISON_##OP,(A), (B))

    CHECK_RVALUE_DEBUG_STRING (
      BINOP (PLUS, deref_as_rvalue, deref_as_rvalue),
      "ptr->value + ptr->value");
    CHECK_RVALUE_DEBUG_STRING (
      BINOP (MULT, deref_as_rvalue, deref_as_rvalue),
      "ptr->value * ptr->value");

   /* Multiplication has higher precedence in C than addition, so this
       dump shouldn't contain parentheses.  */
    CHECK_RVALUE_DEBUG_STRING (
      BINOP (PLUS,
	     BINOP (MULT, a, b),
	     BINOP (MULT, c, d)),
      "a * b + c * d");

    /* ...but this one should.  */
    CHECK_RVALUE_DEBUG_STRING (
      BINOP (MULT,
	     BINOP (PLUS, a, b),
	     BINOP (PLUS, c, d)),
      "(a + b) * (c + d)");

    /* Equal precedences don't need parentheses.  */
    CHECK_RVALUE_DEBUG_STRING (
      BINOP (MULT,
	     BINOP (MULT, a, b),
	     BINOP (MULT, c, d)),
      "a * b * c * d");

    /* Comparisons and logical ops.  */
    CHECK_RVALUE_DEBUG_STRING (
      COMPARISON (LT, a, b),
      "a < b");

    CHECK_RVALUE_DEBUG_STRING (
      BINOP (LOGICAL_AND,
	     COMPARISON (LT, a, b),
	     COMPARISON (GT, c, d)),
      "a < b && c > d");

    CHECK_RVALUE_DEBUG_STRING (
      BINOP (LOGICAL_AND,
	     BINOP (LOGICAL_OR,
		    COMPARISON (LT, a, b),
		    COMPARISON (LT, a, c)),
	     BINOP (LOGICAL_OR,
		    COMPARISON (GT, d, b),
		    COMPARISON (GT, d, c))),
      "(a < b || a < c) && (d > b || d > c)");

    CHECK_RVALUE_DEBUG_STRING (
      BINOP (LOGICAL_OR,
	     BINOP (LOGICAL_AND,
		    COMPARISON (LT, a, b),
		    COMPARISON (LT, a, c)),
	     BINOP (LOGICAL_AND,
		    COMPARISON (GT, d, b),
		    COMPARISON (GT, d, c))),
      "a < b && a < c || d > b && d > c");

#undef BINOP
#undef COMPARISON
  }

  /* PR jit/66539 "Missing parentheses in jit dumps".
     Construct the equivalent of
       ((cast)ptr->next)->next
     and verify that the appropriate parentheses appear in the debug
     string.   */
  {
    /* "ptr->next". */
    gcc_jit_lvalue *inner_deref =
      gcc_jit_rvalue_dereference_field (ptr,
					NULL,
					f_next);
    /* "((node *)ptr->next)"; the cast is redundant, purely
       to exercise dumping.  */
    gcc_jit_rvalue *test_cast =
      gcc_jit_context_new_cast (ctxt, NULL,
				gcc_jit_lvalue_as_rvalue (inner_deref),
				t_node_ptr);
    /* "((node *)ptr->next)->next".  */
    gcc_jit_lvalue *outer_deref =
      gcc_jit_rvalue_dereference_field (test_cast, /* gcc_jit_rvalue *ptr */
					NULL, /* gcc_jit_location *loc */
					f_next); /* gcc_jit_field *field */
    CHECK_LVALUE_DEBUG_STRING (outer_deref,
			       "((struct node *)ptr->next)->next");
  }

#undef CHECK_LVALUE_DEBUG_STRING
}
示例#8
0
void generate_code_regexp(gcc_jit_context *ctx, const char* regexp)
{
  const char* matchhere_regexp = regexp;
  if (regexp[0] == '^')
  {
    matchhere_regexp++;
  }
  gcc_jit_function* matchhere = generate_code_matchhere(ctx, matchhere_regexp, "matchhere");

  // match function
  gcc_jit_type *int_type = gcc_jit_context_get_type(ctx, GCC_JIT_TYPE_INT);
  gcc_jit_type *char_type = gcc_jit_context_get_type(ctx, GCC_JIT_TYPE_CHAR);
  gcc_jit_type *const_char_ptr_type = gcc_jit_context_get_type(ctx, GCC_JIT_TYPE_CONST_CHAR_PTR);

  gcc_jit_param *param_text = gcc_jit_context_new_param(ctx, /* loc */ NULL, const_char_ptr_type, "text");
  gcc_jit_param *param_regex = gcc_jit_context_new_param(ctx, /* loc */ NULL, const_char_ptr_type, "_regex");
  gcc_jit_rvalue *rval_text = gcc_jit_param_as_rvalue(param_text);

  gcc_jit_param* params[] = { param_regex, param_text };
  gcc_jit_function *match = gcc_jit_context_new_function(ctx, /* loc */ NULL,
      GCC_JIT_FUNCTION_EXPORTED, int_type, "match",
      2, params, /* is_variadic */ 0);

  gcc_jit_rvalue* args[] = { rval_text };
  gcc_jit_rvalue* call_to_matchhere = gcc_jit_context_new_call(ctx, /* loc */ NULL,
      matchhere,
      1, args);
  if (regexp[0] == '^')
  {
    gcc_jit_block* block = gcc_jit_function_new_block(match, new_block_name());

    gcc_jit_block_end_with_return(
        block, /* loc */ NULL,
        gcc_jit_context_new_comparison(ctx, /* loc */ NULL,
          GCC_JIT_COMPARISON_NE, 
          call_to_matchhere,
          gcc_jit_context_zero(ctx, int_type)));
  }
  else
  {
    gcc_jit_block* loop_body = gcc_jit_function_new_block(match, new_block_name());
    gcc_jit_block* return_one = gcc_jit_function_new_block(match, new_block_name());
    gcc_jit_block* condition_check = gcc_jit_function_new_block(match, new_block_name());
    gcc_jit_block* return_zero = gcc_jit_function_new_block(match, new_block_name());

    gcc_jit_block_end_with_conditional(
        loop_body, /* loc */ NULL,
        gcc_jit_context_new_comparison(ctx, /* loc */ NULL,
          GCC_JIT_COMPARISON_NE, 
          call_to_matchhere,
          gcc_jit_context_zero(ctx, int_type)),
        return_one,
        condition_check);

    gcc_jit_block_end_with_return(
        return_one, /* loc */ NULL,
        gcc_jit_context_one(ctx, int_type));

    gcc_jit_lvalue* tmp = gcc_jit_function_new_local(match, /* loc */ NULL, char_type, new_local_name());
    gcc_jit_block_add_assignment(
        condition_check, /* loc */ NULL,
        tmp,
        gcc_jit_lvalue_as_rvalue(
          gcc_jit_rvalue_dereference(rval_text, /* loc */ NULL)));
    gcc_jit_block_add_assignment(
        condition_check, /* loc */ NULL,
        gcc_jit_param_as_lvalue(param_text),
        gcc_jit_context_new_cast(
          ctx, /* loc */ NULL,
          gcc_jit_lvalue_get_address(
            gcc_jit_context_new_array_access(
              ctx, /* loc */ NULL,
              rval_text,
              gcc_jit_context_one(ctx, int_type)),
            /* loc */ NULL),
          const_char_ptr_type));
    gcc_jit_block_end_with_conditional(
        condition_check, /* loc */ NULL,
        gcc_jit_context_new_comparison(ctx, /* loc */ NULL,
          GCC_JIT_COMPARISON_NE, 
          gcc_jit_lvalue_as_rvalue(tmp),
          gcc_jit_context_zero(ctx, char_type)),
        loop_body,
        return_zero);

    gcc_jit_block_end_with_return(
        return_zero, /* loc */ NULL,
        gcc_jit_context_zero(ctx, int_type));
  }
  // gcc_jit_function_dump_to_dot(match, "match.dot");

  // gcc_jit_context_dump_to_file(ctx, "generated-regex.dump", /* update-locations */ 1);
  // gcc_jit_context_set_bool_option(ctx, GCC_JIT_BOOL_OPTION_DEBUGINFO, 1);
}
示例#9
0
static gcc_jit_function *generate_code_matchhere(gcc_jit_context *ctx, const char* regexp, const char* function_name)
{
  gcc_jit_type *int_type = gcc_jit_context_get_type(ctx, GCC_JIT_TYPE_INT);
  gcc_jit_type *char_type = gcc_jit_context_get_type(ctx, GCC_JIT_TYPE_CHAR);
  gcc_jit_type *const_char_ptr_type = gcc_jit_context_get_type(ctx, GCC_JIT_TYPE_CONST_CHAR_PTR);

  gcc_jit_param *param_text = gcc_jit_context_new_param(ctx, /* loc */ NULL, const_char_ptr_type, "text");
  gcc_jit_rvalue *rval_text = gcc_jit_param_as_rvalue(param_text);

  // matchhere
  gcc_jit_param* params[] = { param_text };
  gcc_jit_function *matchhere = gcc_jit_context_new_function(ctx, /* loc */ NULL,
      GCC_JIT_FUNCTION_INTERNAL, int_type, function_name,
      1, params, /* is_variadic */ 0);
  gcc_jit_block* current_block = gcc_jit_function_new_block(matchhere, new_block_name());

  gcc_jit_rvalue* text_plus_one = 
    gcc_jit_context_new_cast(
        ctx, /* loc */ NULL,
        gcc_jit_lvalue_get_address(
          gcc_jit_context_new_array_access(
            ctx, /* loc */ NULL,
            rval_text,
            gcc_jit_context_one(ctx, int_type)),
          /* loc */ NULL),
        const_char_ptr_type);

  gcc_jit_block* return_zero = NULL;

  gcc_jit_block* return_one = gcc_jit_function_new_block(matchhere, new_block_name());
  gcc_jit_block_end_with_return(
      return_one, /* loc */ NULL,
      gcc_jit_context_one(ctx, int_type));

  // Now go creating
  for (;;)
  {
    if (regexp[0] == '\0')
    {
      gcc_jit_block_end_with_jump(
          current_block, /* loc */ NULL,
          return_one);
      break; // We are done
    }
    else if (regexp[1] == '*')
    {
      // Generate code for the remaining regular expression
      gcc_jit_function *remaining_regexp_match = generate_code_matchhere(ctx, regexp + 2, new_function_name());

      gcc_jit_block* loop_body = gcc_jit_function_new_block(matchhere, new_block_name());
      gcc_jit_block* loop_check = gcc_jit_function_new_block(matchhere, new_block_name());

      gcc_jit_block_end_with_jump(current_block, /* loc */ NULL, loop_body);

      gcc_jit_rvalue* args[] = { rval_text };
      gcc_jit_rvalue* match_remainder = 
        gcc_jit_context_new_comparison(
            ctx, /* loc */ NULL,
            GCC_JIT_COMPARISON_NE,
            gcc_jit_context_new_call(ctx, /* loc */ NULL,
              remaining_regexp_match, 1, args),
            gcc_jit_context_zero(ctx, int_type));

      gcc_jit_block_end_with_conditional(loop_body, /* loc */ NULL,
          match_remainder,
          return_one,
          loop_check);

      gcc_jit_lvalue* tmp = gcc_jit_function_new_local(matchhere, /* loc */ NULL, char_type, new_local_name());
      gcc_jit_block_add_assignment(
          loop_check, /* loc */ NULL,
          tmp,
          gcc_jit_lvalue_as_rvalue(
            gcc_jit_rvalue_dereference(rval_text, /* loc */ NULL)));

      gcc_jit_rvalue* check_expr;
      if (regexp[0] == '.')
      {
        check_expr =
          gcc_jit_context_new_comparison(ctx, /* loc */ NULL,
              GCC_JIT_COMPARISON_NE,
              gcc_jit_lvalue_as_rvalue(tmp),
              gcc_jit_context_zero(ctx, char_type));
      }
      else
      {
        check_expr =
          gcc_jit_context_new_comparison(ctx, /* loc */ NULL,
              GCC_JIT_COMPARISON_EQ,
              gcc_jit_lvalue_as_rvalue(tmp),
              gcc_jit_context_new_rvalue_from_int(ctx, char_type, regexp[0]));
      }

      generate_return_zero(ctx, matchhere, &return_zero);

      gcc_jit_block_add_assignment(loop_check, /* loc */ NULL,
          gcc_jit_param_as_lvalue(param_text),
          text_plus_one);
      gcc_jit_block_end_with_conditional(loop_check, /* loc */ NULL,
          check_expr,
          loop_body,
          return_zero);

      break; // We are done
    }
    else if (regexp[0] == '$' && regexp[1] == '\0')
    {
      gcc_jit_block_end_with_return(
          current_block, /* loc */ NULL,
          gcc_jit_context_new_comparison(ctx, /* loc */ NULL,
            GCC_JIT_COMPARISON_EQ, 
            gcc_jit_lvalue_as_rvalue(
              gcc_jit_rvalue_dereference(rval_text, /* loc */ NULL)
              ),
            gcc_jit_context_zero(ctx, char_type)));

      regexp++;
    }
    else if (regexp[0] == '.')
    {
      generate_return_zero(ctx, matchhere, &return_zero);

      gcc_jit_block* next_block = gcc_jit_function_new_block(matchhere, new_block_name());

      // if (*text == '\0')
      //    return 0;
      gcc_jit_block_end_with_conditional(
          current_block, /* loc */ NULL,
          gcc_jit_context_new_comparison(ctx, /* loc */ NULL,
            GCC_JIT_COMPARISON_EQ, 
            gcc_jit_lvalue_as_rvalue(
              gcc_jit_rvalue_dereference(rval_text, /* loc */ NULL)
              ),
            gcc_jit_context_zero(ctx, char_type)),
          return_zero,
          next_block);

      // text = &text[1]; // pointer arithmetic
      gcc_jit_block_add_assignment(next_block, /* loc */ NULL,
          gcc_jit_param_as_lvalue(param_text),
          text_plus_one);

      // Chain the code
      current_block = next_block;

      // Done with the current letter
      regexp++;
    }
    else
    {
      generate_return_zero(ctx, matchhere, &return_zero);

      gcc_jit_block* next_block = gcc_jit_function_new_block(matchhere, new_block_name());

      // if (*text != regexp[0])
      //    return 0;
      gcc_jit_block_end_with_conditional(
          current_block, /* loc */ NULL,
          gcc_jit_context_new_comparison(ctx, /* loc */ NULL,
            GCC_JIT_COMPARISON_NE, 
            gcc_jit_lvalue_as_rvalue(
              gcc_jit_rvalue_dereference(rval_text, /* loc */ NULL)
              ),
            gcc_jit_context_new_rvalue_from_int(ctx, char_type, regexp[0])),
          return_zero,
          next_block);

      // text = &text[1]; // pointer arithmetic
      gcc_jit_block_add_assignment(next_block, /* loc */ NULL,
          gcc_jit_param_as_lvalue(param_text),
          text_plus_one);

      // Chain the code
      current_block = next_block;

      // Done with the current letter
      regexp++;
    }
  }

  // char c[64];
  // snprintf(c, 63, "%s.dot", function_name);
  // c[63] = '\0';

  // gcc_jit_function_dump_to_dot(matchhere, c);

  return matchhere;
}
示例#10
0
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));
}
示例#11
0
void
create_code (gcc_jit_context *ctxt, void * user_data)
{
  gcc_jit_type *type_void = gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID);
  gcc_jit_type *type_int = gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
  gcc_jit_type *type_unsigned_char = gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_UNSIGNED_CHAR);
  gcc_jit_type *type_void_ptr =
    gcc_jit_type_get_pointer (type_void);
  gcc_jit_type *type_void_ptr_ptr =
    gcc_jit_type_get_pointer (type_void_ptr);
  gcc_jit_type *type_unsigned_char__ =
    gcc_jit_type_get_pointer (type_unsigned_char);
  gcc_jit_field *field_x =
    gcc_jit_context_new_field (ctxt,
                               NULL, /* gcc_jit_location *loc */
                               type_int, /* gcc_jit_type *type, */
                               "x"); /* const char *name */
  gcc_jit_field *field_y =
    gcc_jit_context_new_field (ctxt,
                               NULL, /* gcc_jit_location *loc */
                               type_int, /* gcc_jit_type *type, */
                               "y"); /* const char *name */
  gcc_jit_struct *struct_struct_ip_coord =
    gcc_jit_context_new_opaque_struct (ctxt,
                                       NULL, /* gcc_jit_location *loc */
                                       "ip_coord"); /* const char *name */
  gcc_jit_field *fields_fields_0x18dc9d0[2] = {
    field_x,
    field_y,
  };
  gcc_jit_struct_set_fields (struct_struct_ip_coord, /* gcc_jit_struct *struct_type */
                             NULL, /* gcc_jit_location *loc */
                             2, /* int num_fields */
                             fields_fields_0x18dc9d0); /* gcc_jit_field **fields */
  gcc_jit_field *field_size =
    gcc_jit_context_new_field (ctxt,
                               NULL, /* gcc_jit_location *loc */
                               gcc_jit_struct_as_type (struct_struct_ip_coord), /* gcc_jit_type *type, */
                               "size"); /* const char *name */
  gcc_jit_field *field_imrow =
    gcc_jit_context_new_field (ctxt,
                               NULL, /* gcc_jit_location *loc */
                               type_void_ptr_ptr, /* gcc_jit_type *type, */
                               "imrow"); /* const char *name */
  gcc_jit_struct *struct_struct_ip_image =
    gcc_jit_context_new_opaque_struct (ctxt,
                                       NULL, /* gcc_jit_location *loc */
                                       "ip_image"); /* const char *name */
  gcc_jit_field *fields_fields_0x18dd310[] = {
    field_size,
    field_imrow
  };
  gcc_jit_struct_set_fields (struct_struct_ip_image, /* gcc_jit_struct *struct_type */
                             NULL, /* gcc_jit_location *loc */
                             2, /* int num_fields */
                             fields_fields_0x18dd310); /* gcc_jit_field **fields */
  gcc_jit_type *type_struct_ip_image__ =
    gcc_jit_type_get_pointer (gcc_jit_struct_as_type (struct_struct_ip_image));
  gcc_jit_param *param_dest =
    gcc_jit_context_new_param (ctxt,
                               NULL, /* gcc_jit_location *loc */
                               type_struct_ip_image__, /*gcc_jit_type *type */
                               "dest"); /* const char *name */
  gcc_jit_param *param_src =
    gcc_jit_context_new_param (ctxt,
                               NULL, /* gcc_jit_location *loc */
                               type_struct_ip_image__, /*gcc_jit_type *type */
                               "src"); /* const char *name */
  gcc_jit_param *params_for_func_ip_jit_im_add_clip_UBYTE[2] = {
    param_dest,
    param_src,
  };
  gcc_jit_function *func_ip_jit_im_add_clip_UBYTE =
    gcc_jit_context_new_function (ctxt, /* gcc_jit_context *ctxt */
                                  NULL, /* gcc_jit_location *loc */
                                  GCC_JIT_FUNCTION_EXPORTED, /* enum gcc_jit_function_kind kind */
                                  type_void, /* gcc_jit_type *return_type */
                                  "ip_jit_im_add_clip_UBYTE", /* const char *name */
                                  2, /* int num_params */
                                  params_for_func_ip_jit_im_add_clip_UBYTE, /* gcc_jit_param **params */
                                  0); /* int is_variadic */
  gcc_jit_lvalue *local_rowlen =
    gcc_jit_function_new_local (func_ip_jit_im_add_clip_UBYTE, /* gcc_jit_function *func */
                                NULL, /* gcc_jit_location *loc */
                                type_int, /* gcc_jit_type *type */
                                "rowlen"); /* const char *name */
  gcc_jit_lvalue *local_numrows =
    gcc_jit_function_new_local (func_ip_jit_im_add_clip_UBYTE, /* gcc_jit_function *func */
                                NULL, /* gcc_jit_location *loc */
                                type_int, /* gcc_jit_type *type */
                                "numrows"); /* const char *name */
  gcc_jit_lvalue *local_j =
    gcc_jit_function_new_local (func_ip_jit_im_add_clip_UBYTE, /* gcc_jit_function *func */
                                NULL, /* gcc_jit_location *loc */
                                type_int, /* gcc_jit_type *type */
                                "j"); /* const char *name */
  gcc_jit_lvalue *local_dptr =
    gcc_jit_function_new_local (func_ip_jit_im_add_clip_UBYTE, /* gcc_jit_function *func */
                                NULL, /* gcc_jit_location *loc */
                                type_unsigned_char__, /* gcc_jit_type *type */
                                "dptr"); /* const char *name */
  gcc_jit_lvalue *local_sptr =
    gcc_jit_function_new_local (func_ip_jit_im_add_clip_UBYTE, /* gcc_jit_function *func */
                                NULL, /* gcc_jit_location *loc */
                                type_unsigned_char__, /* gcc_jit_type *type */
                                "sptr"); /* const char *name */
  gcc_jit_lvalue *local_i =
    gcc_jit_function_new_local (func_ip_jit_im_add_clip_UBYTE, /* gcc_jit_function *func */
                                NULL, /* gcc_jit_location *loc */
                                type_int, /* gcc_jit_type *type */
                                "i"); /* const char *name */
  gcc_jit_block *block_F1 =
    gcc_jit_function_new_block (func_ip_jit_im_add_clip_UBYTE, "F1");
  gcc_jit_block *block_C1 =
    gcc_jit_function_new_block (func_ip_jit_im_add_clip_UBYTE, "C1");
  gcc_jit_block *block_L1 =
    gcc_jit_function_new_block (func_ip_jit_im_add_clip_UBYTE, "L1");
  gcc_jit_block *block_C2 =
    gcc_jit_function_new_block (func_ip_jit_im_add_clip_UBYTE, "C2");
  gcc_jit_block *block_L2 =
    gcc_jit_function_new_block (func_ip_jit_im_add_clip_UBYTE, "L2");
  gcc_jit_block *block_A2 =
    gcc_jit_function_new_block (func_ip_jit_im_add_clip_UBYTE, "A2");
  gcc_jit_block *block_A1 =
    gcc_jit_function_new_block (func_ip_jit_im_add_clip_UBYTE, "A1");
  gcc_jit_lvalue *lvalue_dest__size=
    gcc_jit_rvalue_dereference_field (gcc_jit_param_as_rvalue (param_dest), /* gcc_jit_rvalue *ptr */
                                      NULL, /* gcc_jit_location *loc */
                                      field_size); /* gcc_jit_field *field */
  gcc_jit_rvalue *rvalue_dest__size_x = 
    gcc_jit_rvalue_access_field (gcc_jit_lvalue_as_rvalue (lvalue_dest__size), /*gcc_jit_rvalue *struct_or_union */
                                 NULL, /*gcc_jit_location *loc */
                                 field_x);
  gcc_jit_block_add_assignment (block_F1, /*gcc_jit_block *block */
                                NULL, /* gcc_jit_location *loc */
                                local_rowlen, /* gcc_jit_lvalue *lvalue */
                                rvalue_dest__size_x); /* gcc_jit_rvalue *rvalue */
  gcc_jit_rvalue *rvalue_dest__size_y = 
    gcc_jit_rvalue_access_field (gcc_jit_lvalue_as_rvalue (lvalue_dest__size), /*gcc_jit_rvalue *struct_or_union */
                                 NULL, /*gcc_jit_location *loc */
                                 field_y);
  gcc_jit_block_add_assignment (block_F1, /*gcc_jit_block *block */
                                NULL, /* gcc_jit_location *loc */
                                local_numrows, /* gcc_jit_lvalue *lvalue */
                                rvalue_dest__size_y); /* gcc_jit_rvalue *rvalue */
  gcc_jit_rvalue *rvalue__int_0 =
    gcc_jit_context_new_rvalue_from_int (ctxt, /* gcc_jit_context *ctxt */
                                         type_int, /* gcc_jit_type *numeric_type */
                                         0); /* int value */
  gcc_jit_block_add_assignment (block_F1, /*gcc_jit_block *block */
                                NULL, /* gcc_jit_location *loc */
                                local_j, /* gcc_jit_lvalue *lvalue */
                                rvalue__int_0); /* gcc_jit_rvalue *rvalue */
  gcc_jit_block_end_with_jump (block_F1, /*gcc_jit_block *block */
                               NULL, /* gcc_jit_location *loc */
                               block_C1); /* gcc_jit_block *target */
  gcc_jit_rvalue *rvalue_j___numrows =
    gcc_jit_context_new_comparison (ctxt,
                                    NULL, /* gcc_jit_location *loc */
                                    GCC_JIT_COMPARISON_LT, /* enum gcc_jit_comparison op */
                                    gcc_jit_lvalue_as_rvalue (local_j), /* gcc_jit_rvalue *a */
                                    gcc_jit_lvalue_as_rvalue (local_numrows)); /* gcc_jit_rvalue *b */
  gcc_jit_block_end_with_conditional (block_C1, /*gcc_jit_block *block */
                                      NULL, /* gcc_jit_location *loc */
                                      rvalue_j___numrows, /* gcc_jit_rvalue *boolval */
                                      block_L1, /* gcc_jit_block *on_true */
                                      block_A1); /* gcc_jit_block *on_false */
  gcc_jit_lvalue *lvalue_dest__imrow=
    gcc_jit_rvalue_dereference_field (gcc_jit_param_as_rvalue (param_dest), /* gcc_jit_rvalue *ptr */
                                      NULL, /* gcc_jit_location *loc */
                                      field_imrow); /* gcc_jit_field *field */
  gcc_jit_lvalue *lvalue_dest__imrow_j_ = 
    gcc_jit_context_new_array_access (ctxt, /* gcc_jit_context *ctxt */
                                      NULL, /*gcc_jit_location *loc */
                                      gcc_jit_lvalue_as_rvalue (lvalue_dest__imrow), /* gcc_jit_rvalue *ptr */
                                      gcc_jit_lvalue_as_rvalue (local_j)); /* gcc_jit_rvalue *index */
  gcc_jit_rvalue *rvalue__unsigned_char___dest__imrow_j_ =
    gcc_jit_context_new_cast (ctxt,
                              NULL, /* gcc_jit_location *loc */
                              gcc_jit_lvalue_as_rvalue (lvalue_dest__imrow_j_), /* gcc_jit_rvalue *rvalue */
                              type_unsigned_char__); /* gcc_jit_type *type */
  gcc_jit_block_add_assignment (block_L1, /*gcc_jit_block *block */
                                NULL, /* gcc_jit_location *loc */
                                local_dptr, /* gcc_jit_lvalue *lvalue */
                                rvalue__unsigned_char___dest__imrow_j_); /* gcc_jit_rvalue *rvalue */
  gcc_jit_lvalue *lvalue_src__imrow=
    gcc_jit_rvalue_dereference_field (gcc_jit_param_as_rvalue (param_src), /* gcc_jit_rvalue *ptr */
                                      NULL, /* gcc_jit_location *loc */
                                      field_imrow); /* gcc_jit_field *field */
  gcc_jit_lvalue *lvalue_src__imrow_j_ = 
    gcc_jit_context_new_array_access (ctxt, /* gcc_jit_context *ctxt */
                                      NULL, /*gcc_jit_location *loc */
                                      gcc_jit_lvalue_as_rvalue (lvalue_src__imrow), /* gcc_jit_rvalue *ptr */
                                      gcc_jit_lvalue_as_rvalue (local_j)); /* gcc_jit_rvalue *index */
  gcc_jit_rvalue *rvalue__unsigned_char___src__imrow_j_ =
    gcc_jit_context_new_cast (ctxt,
                              NULL, /* gcc_jit_location *loc */
                              gcc_jit_lvalue_as_rvalue (lvalue_src__imrow_j_), /* gcc_jit_rvalue *rvalue */
                              type_unsigned_char__); /* gcc_jit_type *type */
  gcc_jit_block_add_assignment (block_L1, /*gcc_jit_block *block */
                                NULL, /* gcc_jit_location *loc */
                                local_sptr, /* gcc_jit_lvalue *lvalue */
                                rvalue__unsigned_char___src__imrow_j_); /* gcc_jit_rvalue *rvalue */
  gcc_jit_rvalue *rvalue__int_0_0x18dd890 =
    gcc_jit_context_new_rvalue_from_int (ctxt, /* gcc_jit_context *ctxt */
                                         type_int, /* gcc_jit_type *numeric_type */
                                         0); /* int value */
  gcc_jit_block_add_assignment (block_L1, /*gcc_jit_block *block */
                                NULL, /* gcc_jit_location *loc */
                                local_i, /* gcc_jit_lvalue *lvalue */
                                rvalue__int_0_0x18dd890); /* gcc_jit_rvalue *rvalue */
  gcc_jit_block_end_with_jump (block_L1, /*gcc_jit_block *block */
                               NULL, /* gcc_jit_location *loc */
                               block_C2); /* gcc_jit_block *target */
  gcc_jit_rvalue *rvalue_i___rowlen =
    gcc_jit_context_new_comparison (ctxt,
                                    NULL, /* gcc_jit_location *loc */
                                    GCC_JIT_COMPARISON_LT, /* enum gcc_jit_comparison op */
                                    gcc_jit_lvalue_as_rvalue (local_i), /* gcc_jit_rvalue *a */
                                    gcc_jit_lvalue_as_rvalue (local_rowlen)); /* gcc_jit_rvalue *b */
  gcc_jit_block_end_with_conditional (block_C2, /*gcc_jit_block *block */
                                      NULL, /* gcc_jit_location *loc */
                                      rvalue_i___rowlen, /* gcc_jit_rvalue *boolval */
                                      block_L2, /* gcc_jit_block *on_true */
                                      block_A2); /* gcc_jit_block *on_false */
  gcc_jit_lvalue *dereference__dptr =
    gcc_jit_rvalue_dereference (gcc_jit_lvalue_as_rvalue (local_dptr), /* gcc_jit_rvalue *rvalue */
                                NULL); /* gcc_jit_location *loc */
  gcc_jit_lvalue *dereference__sptr =
    gcc_jit_rvalue_dereference (gcc_jit_lvalue_as_rvalue (local_sptr), /* gcc_jit_rvalue *rvalue */
                                NULL); /* gcc_jit_location *loc */
  gcc_jit_block *block_p_C1_true =
    gcc_jit_function_new_block (func_ip_jit_im_add_clip_UBYTE, "p_C1_true");
  gcc_jit_block *block_p_C1_end =
    gcc_jit_function_new_block (func_ip_jit_im_add_clip_UBYTE, "p_C1_end");
  gcc_jit_lvalue *local_ival =
    gcc_jit_function_new_local (func_ip_jit_im_add_clip_UBYTE, /* gcc_jit_function *func */
                                NULL, /* gcc_jit_location *loc */
                                type_int, /* gcc_jit_type *type */
                                "ival"); /* const char *name */
  gcc_jit_rvalue *rvalue__int__dptr =
    gcc_jit_context_new_cast (ctxt,
                              NULL, /* gcc_jit_location *loc */
                              gcc_jit_lvalue_as_rvalue (dereference__dptr), /* gcc_jit_rvalue *rvalue */
                              type_int); /* gcc_jit_type *type */
  gcc_jit_rvalue *rvalue__int__sptr =
    gcc_jit_context_new_cast (ctxt,
                              NULL, /* gcc_jit_location *loc */
                              gcc_jit_lvalue_as_rvalue (dereference__sptr), /* gcc_jit_rvalue *rvalue */
                              type_int); /* gcc_jit_type *type */
  gcc_jit_rvalue *rvalue__int__dptr____int__sptr =
    gcc_jit_context_new_binary_op (ctxt,
                                   NULL, /* gcc_jit_location *loc */
                                   GCC_JIT_BINARY_OP_PLUS, /* enum gcc_jit_binary_op op */
                                   type_int, /* gcc_jit_type *result_type */
                                   rvalue__int__dptr, /* gcc_jit_rvalue *a */
                                   rvalue__int__sptr); /* gcc_jit_rvalue *b */
  gcc_jit_block_add_assignment (block_L2, /*gcc_jit_block *block */
                                NULL, /* gcc_jit_location *loc */
                                local_ival, /* gcc_jit_lvalue *lvalue */
                                rvalue__int__dptr____int__sptr); /* gcc_jit_rvalue *rvalue */
  gcc_jit_rvalue *rvalue__int_255 =
    gcc_jit_context_new_rvalue_from_int (ctxt, /* gcc_jit_context *ctxt */
                                         type_int, /* gcc_jit_type *numeric_type */
                                         255); /* int value */
  gcc_jit_rvalue *rvalue_ival____int_255 =
    gcc_jit_context_new_comparison (ctxt,
                                    NULL, /* gcc_jit_location *loc */
                                    GCC_JIT_COMPARISON_GT, /* enum gcc_jit_comparison op */
                                    gcc_jit_lvalue_as_rvalue (local_ival), /* gcc_jit_rvalue *a */
                                    rvalue__int_255); /* gcc_jit_rvalue *b */
  gcc_jit_block_end_with_conditional (block_L2, /*gcc_jit_block *block */
                                      NULL, /* gcc_jit_location *loc */
                                      rvalue_ival____int_255, /* gcc_jit_rvalue *boolval */
                                      block_p_C1_true, /* gcc_jit_block *on_true */
                                      block_p_C1_end); /* gcc_jit_block *on_false */
  gcc_jit_block_add_assignment (block_p_C1_true, /*gcc_jit_block *block */
                                NULL, /* gcc_jit_location *loc */
                                local_ival, /* gcc_jit_lvalue *lvalue */
                                rvalue__int_255); /* gcc_jit_rvalue *rvalue */
  gcc_jit_block_end_with_jump (block_p_C1_true, /*gcc_jit_block *block */
                               NULL, /* gcc_jit_location *loc */
                               block_p_C1_end); /* gcc_jit_block *target */
  gcc_jit_rvalue *rvalue__unsigned_char_ival =
    gcc_jit_context_new_cast (ctxt,
                              NULL, /* gcc_jit_location *loc */
                              gcc_jit_lvalue_as_rvalue (local_ival), /* gcc_jit_rvalue *rvalue */
                              type_unsigned_char); /* gcc_jit_type *type */
  gcc_jit_lvalue *dereference__dptr_0x18df2e0 =
    gcc_jit_rvalue_dereference (gcc_jit_lvalue_as_rvalue (local_dptr), /* gcc_jit_rvalue *rvalue */
                                NULL); /* gcc_jit_location *loc */
  gcc_jit_block_add_assignment (block_p_C1_end, /*gcc_jit_block *block */
                                NULL, /* gcc_jit_location *loc */
                                dereference__dptr_0x18df2e0, /* gcc_jit_lvalue *lvalue */
                                rvalue__unsigned_char_ival); /* gcc_jit_rvalue *rvalue */
  gcc_jit_rvalue *rvalue__int_1 =
    gcc_jit_context_new_rvalue_from_int (ctxt, /* gcc_jit_context *ctxt */
                                         type_int, /* gcc_jit_type *numeric_type */
                                         1); /* int value */
  gcc_jit_lvalue *lvalue_dptr__int_1_ = 
    gcc_jit_context_new_array_access (ctxt, /* gcc_jit_context *ctxt */
                                      NULL, /*gcc_jit_location *loc */
                                      gcc_jit_lvalue_as_rvalue (local_dptr), /* gcc_jit_rvalue *ptr */
                                      rvalue__int_1); /* gcc_jit_rvalue *index */
  gcc_jit_rvalue *address_of__dptr__int_1_ =
    gcc_jit_lvalue_get_address (lvalue_dptr__int_1_, /* gcc_jit_lvalue *lvalue */
                                NULL); /* gcc_jit_location *loc */
  gcc_jit_block_add_assignment (block_p_C1_end, /*gcc_jit_block *block */
                                NULL, /* gcc_jit_location *loc */
                                local_dptr, /* gcc_jit_lvalue *lvalue */
                                address_of__dptr__int_1_); /* gcc_jit_rvalue *rvalue */
  gcc_jit_rvalue *rvalue__int_1_0x18df500 =
    gcc_jit_context_new_rvalue_from_int (ctxt, /* gcc_jit_context *ctxt */
                                         type_int, /* gcc_jit_type *numeric_type */
                                         1); /* int value */
  gcc_jit_lvalue *lvalue_sptr__int_1_ = 
    gcc_jit_context_new_array_access (ctxt, /* gcc_jit_context *ctxt */
                                      NULL, /*gcc_jit_location *loc */
                                      gcc_jit_lvalue_as_rvalue (local_sptr), /* gcc_jit_rvalue *ptr */
                                      rvalue__int_1_0x18df500); /* gcc_jit_rvalue *index */
  gcc_jit_rvalue *address_of__sptr__int_1_ =
    gcc_jit_lvalue_get_address (lvalue_sptr__int_1_, /* gcc_jit_lvalue *lvalue */
                                NULL); /* gcc_jit_location *loc */
  gcc_jit_block_add_assignment (block_p_C1_end, /*gcc_jit_block *block */
                                NULL, /* gcc_jit_location *loc */
                                local_sptr, /* gcc_jit_lvalue *lvalue */
                                address_of__sptr__int_1_); /* gcc_jit_rvalue *rvalue */
  gcc_jit_rvalue *rvalue__int_1_0x18df650 =
    gcc_jit_context_new_rvalue_from_int (ctxt, /* gcc_jit_context *ctxt */
                                         type_int, /* gcc_jit_type *numeric_type */
                                         1); /* int value */
  gcc_jit_rvalue *rvalue_i____int_1 =
    gcc_jit_context_new_binary_op (ctxt,
                                   NULL, /* gcc_jit_location *loc */
                                   GCC_JIT_BINARY_OP_PLUS, /* enum gcc_jit_binary_op op */
                                   type_int, /* gcc_jit_type *result_type */
                                   gcc_jit_lvalue_as_rvalue (local_i), /* gcc_jit_rvalue *a */
                                   rvalue__int_1_0x18df650); /* gcc_jit_rvalue *b */
  gcc_jit_block_add_assignment (block_p_C1_end, /*gcc_jit_block *block */
                                NULL, /* gcc_jit_location *loc */
                                local_i, /* gcc_jit_lvalue *lvalue */
                                rvalue_i____int_1); /* gcc_jit_rvalue *rvalue */
  gcc_jit_block_end_with_jump (block_p_C1_end, /*gcc_jit_block *block */
                               NULL, /* gcc_jit_location *loc */
                               block_C2); /* gcc_jit_block *target */
  gcc_jit_rvalue *rvalue__int_1_0x18df7e0 =
    gcc_jit_context_new_rvalue_from_int (ctxt, /* gcc_jit_context *ctxt */
                                         type_int, /* gcc_jit_type *numeric_type */
                                         1); /* int value */
  gcc_jit_rvalue *rvalue_j____int_1 =
    gcc_jit_context_new_binary_op (ctxt,
                                   NULL, /* gcc_jit_location *loc */
                                   GCC_JIT_BINARY_OP_PLUS, /* enum gcc_jit_binary_op op */
                                   type_int, /* gcc_jit_type *result_type */
                                   gcc_jit_lvalue_as_rvalue (local_j), /* gcc_jit_rvalue *a */
                                   rvalue__int_1_0x18df7e0); /* gcc_jit_rvalue *b */
  gcc_jit_block_add_assignment (block_A2, /*gcc_jit_block *block */
                                NULL, /* gcc_jit_location *loc */
                                local_j, /* gcc_jit_lvalue *lvalue */
                                rvalue_j____int_1); /* gcc_jit_rvalue *rvalue */
  gcc_jit_block_end_with_jump (block_A2, /*gcc_jit_block *block */
                               NULL, /* gcc_jit_location *loc */
                               block_C1); /* gcc_jit_block *target */
  gcc_jit_block_end_with_void_return (block_A1, /*gcc_jit_block *block */
                                      NULL); /* gcc_jit_location *loc */
}
示例#12
0
void ravi_emit_iFORPREP(ravi_function_def_t *def, int A, int pc, int step_one) {
  ravi_branch_def_t *forloop_target = def->jmp_targets[pc];
  assert(forloop_target);

  forloop_target->ilimit = gcc_jit_function_new_local(
      def->jit_function, NULL, def->ravi->types->lua_IntegerT,
      unique_name(def, "ilimit", 0));
  if (!step_one) {
    forloop_target->istep = gcc_jit_function_new_local(
        def->jit_function, NULL, def->ravi->types->lua_IntegerT,
        unique_name(def, "istep", 0));
  }
  forloop_target->iidx = gcc_jit_function_new_local(
      def->jit_function, NULL, def->ravi->types->lua_IntegerT,
      unique_name(def, "iidx", 0));

  //    lua_Integer initv = ivalue(init);
  //    setivalue(init, initv - ivalue(pstep));

  // Load pointer to base
  ravi_emit_load_base(def);

  //  TValue *init = ra;
  //  TValue *pstep = ra + 2;
  gcc_jit_lvalue *init = ravi_emit_get_register(def, A);
  gcc_jit_lvalue *plimit = ravi_emit_get_register(def, A + 1);
  gcc_jit_lvalue *pstep = NULL;
  if (!step_one)
    pstep = ravi_emit_get_register(def, A + 2);
  // Get ivalue(pstep)

  gcc_jit_lvalue *limit_ivalue = ravi_emit_load_reg_i(def, plimit);
  gcc_jit_lvalue *init_ivalue = ravi_emit_load_reg_i(def, init);

  if (!step_one) {
    //    setivalue(init, initv - ivalue(pstep));
    gcc_jit_lvalue *step_ivalue = ravi_emit_load_reg_i(def, pstep);
    gcc_jit_rvalue *idx = gcc_jit_context_new_binary_op(
        def->function_context, NULL, GCC_JIT_BINARY_OP_MINUS,
        def->ravi->types->lua_IntegerT, gcc_jit_lvalue_as_rvalue(init_ivalue),
        gcc_jit_lvalue_as_rvalue(step_ivalue));
    // Save idx
    gcc_jit_block_add_assignment(def->current_block, NULL, forloop_target->iidx,
                                 idx);

    // Save step
    gcc_jit_block_add_assignment(def->current_block, NULL,
                                 forloop_target->istep,
                                 gcc_jit_lvalue_as_rvalue(step_ivalue));
  } else {
    //    setivalue(init, initv - ivalue(pstep));
    gcc_jit_rvalue *idx = gcc_jit_context_new_binary_op(
        def->function_context, NULL, GCC_JIT_BINARY_OP_MINUS,
        def->ravi->types->lua_IntegerT, gcc_jit_lvalue_as_rvalue(init_ivalue),
        gcc_jit_context_new_rvalue_from_int(def->function_context,
                                            def->ravi->types->lua_IntegerT, 1));

    // Save idx
    gcc_jit_block_add_assignment(def->current_block, NULL, forloop_target->iidx,
                                 idx);
  }

  // Save limit
  gcc_jit_block_add_assignment(def->current_block, NULL, forloop_target->ilimit,
                               gcc_jit_lvalue_as_rvalue(limit_ivalue));

  // We are done so jump to forloop
  lua_assert(def->jmp_targets[pc]->jmp);
  ravi_emit_branch(def, def->jmp_targets[pc]->jmp);
}
示例#13
0
static void
make_test_quadratic (struct top_level *top_level,
		     struct middle_level *middle_level,
		     struct bottom_level *bottom_level)
{
  gcc_jit_param *a =
    gcc_jit_context_new_param (bottom_level->ctxt, NULL,
			       top_level->numeric_type, "a");
  gcc_jit_param *b =
    gcc_jit_context_new_param (bottom_level->ctxt, NULL,
			       top_level->numeric_type, "b");
  gcc_jit_param *c =
    gcc_jit_context_new_param (bottom_level->ctxt, NULL,
			       top_level->numeric_type, "c");
  gcc_jit_param *r1 =
    gcc_jit_context_new_param (bottom_level->ctxt, NULL,
			       top_level->numeric_type_ptr, "r1");
  gcc_jit_param *r2 =
    gcc_jit_context_new_param (bottom_level->ctxt, NULL,
			       top_level->numeric_type_ptr, "r2");
  gcc_jit_param *params[] = {a, b, c, r1, r2};
  gcc_jit_function *test_quadratic =
    gcc_jit_context_new_function (bottom_level->ctxt, NULL,
				  GCC_JIT_FUNCTION_EXPORTED,
				  top_level->int_type,
				  "test_quadratic",
				  5, params,
				  0);

  /* struct quadratic q; */
  gcc_jit_lvalue *q =
    gcc_jit_function_new_local (
      test_quadratic, NULL,
      top_level->struct_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, top_level->a),
    gcc_jit_param_as_rvalue (a));
  /* q.b = b; */
  gcc_jit_block_add_assignment (
    initial, NULL,
    gcc_jit_lvalue_access_field (q, NULL, top_level->b),
    gcc_jit_param_as_rvalue (b));
  /* q.c = c; */
  gcc_jit_block_add_assignment (
    initial, NULL,
    gcc_jit_lvalue_access_field (q, NULL, top_level->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 (
      bottom_level->ctxt, NULL,
      middle_level->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 (
      bottom_level->ctxt, NULL,
      GCC_JIT_COMPARISON_GT,
      gcc_jit_rvalue_access_field (
	gcc_jit_lvalue_as_rvalue (q),
	NULL,
	top_level->discriminant),
      top_level->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,
    top_level->numeric_type,
    "s");
  gcc_jit_rvalue *discriminant_of_q =
    gcc_jit_rvalue_access_field (gcc_jit_lvalue_as_rvalue (q),
				 NULL,
				 top_level->discriminant);
  gcc_jit_block_add_assignment (
    on_positive_discriminant, NULL,
    s,
    gcc_jit_context_new_call (
      bottom_level->ctxt, NULL,
      top_level->sqrt,
      1, &discriminant_of_q));

  gcc_jit_rvalue *minus_b =
    gcc_jit_context_new_unary_op (
      bottom_level->ctxt, NULL,
      GCC_JIT_UNARY_OP_MINUS,
      top_level->numeric_type,
      gcc_jit_param_as_rvalue (b));
  gcc_jit_rvalue *two_a =
    gcc_jit_context_new_binary_op (
      bottom_level->ctxt, NULL,
      GCC_JIT_BINARY_OP_MULT,
      top_level->numeric_type,
      gcc_jit_context_new_rvalue_from_int (
	bottom_level->ctxt,
	top_level->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 (
      bottom_level->ctxt, NULL,
      GCC_JIT_BINARY_OP_DIVIDE,
      top_level->numeric_type,
      gcc_jit_context_new_binary_op (
	bottom_level->ctxt, NULL,
	GCC_JIT_BINARY_OP_PLUS,
	top_level->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 (
      bottom_level->ctxt, NULL,
      GCC_JIT_BINARY_OP_DIVIDE,
      top_level->numeric_type,
      gcc_jit_context_new_binary_op (
	bottom_level->ctxt, NULL,
	GCC_JIT_BINARY_OP_MINUS,
	top_level->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 (
      bottom_level->ctxt,
      top_level->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 (
      bottom_level->ctxt, NULL,
      GCC_JIT_COMPARISON_EQ,
      gcc_jit_rvalue_access_field (
	gcc_jit_lvalue_as_rvalue (q),
	NULL,
	top_level->discriminant),
      top_level->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 (
      bottom_level->ctxt, NULL,
      GCC_JIT_BINARY_OP_DIVIDE,
      top_level->numeric_type,
      minus_b,
      two_a));

  /* "return 1;" */
  gcc_jit_block_end_with_return (
    on_zero_discriminant, NULL,
      gcc_jit_context_one (bottom_level->ctxt, top_level->int_type));

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