Example #1
0
static void
create_use_of_void_return (gcc_jit_context *ctxt)
{
  /* Let's try to inject the equivalent of:
       void
       test_of_void_return (int *out)
       {
         *out = 1;
	 return;
       }
  */
  gcc_jit_type *void_t =
    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID);
  gcc_jit_type *int_t =
    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
  gcc_jit_type *int_ptr_t =
    gcc_jit_type_get_pointer (int_t);

  /* Build the test_fn.  */
  gcc_jit_param *param_out =
    gcc_jit_context_new_param (ctxt, NULL, int_ptr_t, "out");
  gcc_jit_function *test_fn =
    gcc_jit_context_new_function (ctxt, NULL,
                                  GCC_JIT_FUNCTION_EXPORTED,
                                  void_t,
                                  "test_of_void_return",
                                  1, &param_out,
                                  0);
  gcc_jit_block *initial =
    gcc_jit_function_new_block (test_fn, "initial");

  gcc_jit_block_add_assignment (
    initial, NULL,
    /* "*out = ..." */
    gcc_jit_rvalue_dereference (gcc_jit_param_as_rvalue (param_out),
				NULL),
    gcc_jit_context_one (ctxt, int_t));
  gcc_jit_block_end_with_void_return (initial, NULL);
}
void
create_code (gcc_jit_context *ctxt, void *user_data)
{
  /* Let's try to inject the equivalent of:
       void
       int test_bogus_dereference_read (int i)
       {
	 return *i;
       }
     i.e. where i is *not* a pointer.
  */
  gcc_jit_type *void_type =
    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID);
  gcc_jit_type *int_type =
    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);

  /* 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,
                                  void_type,
                                  "test_bogus_dereference_read",
                                  1, &param_i,
                                  0);
  gcc_jit_block *block = gcc_jit_function_new_block (test_fn, NULL);
  /* Erroneous: "return *i;" */
  gcc_jit_block_end_with_return (
    block,
    NULL,
    gcc_jit_lvalue_as_rvalue (
      gcc_jit_rvalue_dereference (
        gcc_jit_param_as_rvalue (param_i),
	NULL)));
}
Example #3
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));
}
Example #4
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);
}
Example #5
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;
}
Example #6
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 */
}
Example #7
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));
}