static void
add_push (compilation_state *state,
gcc_jit_block *block,
gcc_jit_rvalue *rvalue,
gcc_jit_location *loc)
{
/* stack[stack_depth] = RVALUE */
gcc_jit_block_add_assignment (
block,
loc,
/* stack[stack_depth] */
gcc_jit_context_new_array_access (
state->ctxt,
loc,
gcc_jit_lvalue_as_rvalue (state->stack),
gcc_jit_lvalue_as_rvalue (state->stack_depth)),
rvalue);
/* "stack_depth++;". */
gcc_jit_block_add_assignment_op (
block,
loc,
state->stack_depth,
GCC_JIT_BINARY_OP_PLUS,
state->const_one);
}
static void
add_pop (compilation_state *state,
gcc_jit_block *block,
gcc_jit_lvalue *lvalue,
gcc_jit_location *loc)
{
/* "--stack_depth;". */
gcc_jit_block_add_assignment_op (
block,
loc,
state->stack_depth,
GCC_JIT_BINARY_OP_MINUS,
state->const_one);
/* "LVALUE = stack[stack_depth];". */
gcc_jit_block_add_assignment (
block,
loc,
lvalue,
/* stack[stack_depth] */
gcc_jit_lvalue_as_rvalue (
gcc_jit_context_new_array_access (
state->ctxt,
loc,
gcc_jit_lvalue_as_rvalue (state->stack),
gcc_jit_lvalue_as_rvalue (state->stack_depth))));
}
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, ¶m,
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);
}
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));
}
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, ¶m_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)));
}
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;
}
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));
}
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));
}
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);
}
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;
}
void
create_code (gcc_jit_context *ctxt, void *user_data)
{
/* Let's try to inject the equivalent of:
double
test_nested_loops (int n, double *a, double *b)
{
double result = 0.;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
result += a[i] * b[j];
return result
}
*/
gcc_jit_type *val_type =
gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_DOUBLE);
gcc_jit_type *ptr_type = gcc_jit_type_get_pointer (val_type);
gcc_jit_type *int_type =
gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
gcc_jit_type *return_type = val_type;
gcc_jit_param *param_n =
gcc_jit_context_new_param (ctxt, NULL, int_type, "n");
gcc_jit_param *param_a =
gcc_jit_context_new_param (ctxt, NULL, ptr_type, "a");
gcc_jit_param *param_b =
gcc_jit_context_new_param (ctxt, NULL, ptr_type, "b");
gcc_jit_param *params[3] = {param_n, param_a, param_b};
gcc_jit_function *func =
gcc_jit_context_new_function (ctxt, NULL,
GCC_JIT_FUNCTION_EXPORTED,
return_type,
"test_nested_loops",
3, params, 0);
/* Create locals. */
gcc_jit_lvalue *result =
gcc_jit_function_new_local (func, NULL, val_type, "result");
gcc_jit_lvalue *i =
gcc_jit_function_new_local (func, NULL, int_type, "i");
gcc_jit_lvalue *j =
gcc_jit_function_new_local (func, NULL, int_type, "j");
/* Create basic blocks. */
gcc_jit_block *b_entry =
gcc_jit_function_new_block (func, "b_entry");
gcc_jit_block *b_outer_loop_cond =
gcc_jit_function_new_block (func, "b_outer_loop_cond");
gcc_jit_block *b_outer_loop_head =
gcc_jit_function_new_block (func, "b_outer_loop_head");
gcc_jit_block *b_outer_loop_tail =
gcc_jit_function_new_block (func, "b_outer_loop_tail");
gcc_jit_block *b_inner_loop_cond =
gcc_jit_function_new_block (func, "b_inner_loop_cond");
gcc_jit_block *b_inner_loop_body =
gcc_jit_function_new_block (func, "b_inner_loop_body");
gcc_jit_block *b_exit =
gcc_jit_function_new_block (func, "b_exit");
/* Populate b_entry. */
/* "result = 0.;" */
gcc_jit_block_add_assignment (
b_entry, NULL,
result,
gcc_jit_context_zero (ctxt, val_type));
/* "i = 0;" */
gcc_jit_block_add_assignment (
b_entry, NULL,
i,
gcc_jit_context_zero (ctxt, int_type));
gcc_jit_block_end_with_jump (b_entry, NULL, b_outer_loop_cond);
/* Populate b_outer_loop_cond. */
gcc_jit_block_end_with_conditional (
b_outer_loop_cond,
NULL,
/* (i < n) */
gcc_jit_context_new_comparison (
ctxt, NULL,
GCC_JIT_COMPARISON_LT,
gcc_jit_lvalue_as_rvalue (i),
gcc_jit_param_as_rvalue (param_n)),
b_outer_loop_head,
b_exit);
/* Populate b_outer_loop_head. */
/* j = 0; */
gcc_jit_block_add_assignment (
b_outer_loop_head, NULL,
j,
gcc_jit_context_zero (ctxt, int_type));
gcc_jit_block_end_with_jump (b_outer_loop_head, NULL, b_inner_loop_cond);
/* Populate b_inner_loop_cond. */
gcc_jit_block_end_with_conditional (
b_inner_loop_cond,
NULL,
/* (j < n) */
gcc_jit_context_new_comparison (
ctxt, NULL,
GCC_JIT_COMPARISON_LT,
gcc_jit_lvalue_as_rvalue (j),
gcc_jit_param_as_rvalue (param_n)),
b_inner_loop_body,
b_outer_loop_tail);
/* Populate b_inner_loop_body. */
/* "result += a[i] * b[j];" */
gcc_jit_block_add_assignment_op (
b_inner_loop_body, NULL,
result,
GCC_JIT_BINARY_OP_PLUS,
gcc_jit_context_new_binary_op (
ctxt, NULL,
GCC_JIT_BINARY_OP_MULT,
val_type,
gcc_jit_lvalue_as_rvalue (
gcc_jit_context_new_array_access(
ctxt, NULL,
gcc_jit_param_as_rvalue (param_a),
gcc_jit_lvalue_as_rvalue (i))),
gcc_jit_lvalue_as_rvalue (
gcc_jit_context_new_array_access(
ctxt, NULL,
gcc_jit_param_as_rvalue (param_b),
gcc_jit_lvalue_as_rvalue (j)))));
/* "j++" */
gcc_jit_block_add_assignment_op (
b_inner_loop_body, NULL,
j,
GCC_JIT_BINARY_OP_PLUS,
gcc_jit_context_one (ctxt, int_type));
gcc_jit_block_end_with_jump (b_inner_loop_body, NULL, b_inner_loop_cond);
/* Populate b_outer_loop_tail. */
/* "i++" */
gcc_jit_block_add_assignment_op (
b_outer_loop_tail, NULL,
i,
GCC_JIT_BINARY_OP_PLUS,
gcc_jit_context_one (ctxt, int_type));
gcc_jit_block_end_with_jump (b_outer_loop_tail, NULL, b_outer_loop_cond);
/* Populate b_exit. */
/* "return result;" */
gcc_jit_block_end_with_return (
b_exit,
NULL,
gcc_jit_lvalue_as_rvalue (result));
}
void
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 */
}
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);
}
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));
}
/* 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
}
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, ¶m_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));
}
static void
make_calc_discriminant (struct top_level *top_level,
struct middle_level *middle_level)
{
/* Build "calc_discriminant". */
gcc_jit_param *param_q =
gcc_jit_context_new_param (middle_level->ctxt, NULL,
top_level->quadratic_ptr, "q");
middle_level->calc_discriminant =
gcc_jit_context_new_function (middle_level->ctxt, NULL,
GCC_JIT_FUNCTION_EXPORTED,
top_level->void_type,
"calc_discriminant",
1, ¶m_q,
0);
gcc_jit_block *blk =
gcc_jit_function_new_block (middle_level->calc_discriminant, NULL);
gcc_jit_block_add_comment (
blk, NULL,
"(b^2 - 4ac)");
gcc_jit_rvalue *q_a =
gcc_jit_lvalue_as_rvalue (
gcc_jit_rvalue_dereference_field (
gcc_jit_param_as_rvalue (param_q),
NULL, top_level->a));
gcc_jit_rvalue *q_b =
gcc_jit_lvalue_as_rvalue (
gcc_jit_rvalue_dereference_field (
gcc_jit_param_as_rvalue (param_q),
NULL, top_level->b));
gcc_jit_rvalue *q_c =
gcc_jit_lvalue_as_rvalue (
gcc_jit_rvalue_dereference_field (
gcc_jit_param_as_rvalue (param_q),
NULL, top_level->c));
gcc_jit_block_add_assignment (
blk, NULL,
/* q->discriminant =... */
gcc_jit_rvalue_dereference_field (
gcc_jit_param_as_rvalue (param_q),
NULL,
top_level->discriminant),
/* (q->b * q->b) - (4 * q->a * q->c) */
gcc_jit_context_new_binary_op (
middle_level->ctxt, NULL,
GCC_JIT_BINARY_OP_MINUS,
top_level->numeric_type,
/* (q->b * q->b) */
gcc_jit_context_new_binary_op (
middle_level->ctxt, NULL,
GCC_JIT_BINARY_OP_MULT,
top_level->numeric_type,
q_b, q_b),
/* (4 * (q->a * q->c)) */
gcc_jit_context_new_binary_op (
middle_level->ctxt, NULL,
GCC_JIT_BINARY_OP_MULT,
top_level->numeric_type,
/* 4.0 */
gcc_jit_context_new_rvalue_from_int (
middle_level->ctxt,
top_level->numeric_type,
4),
/* (q->a * q->c) */
gcc_jit_context_new_binary_op (
middle_level->ctxt, NULL,
GCC_JIT_BINARY_OP_MULT,
top_level->numeric_type,
q_a, q_c)))); /* end of gcc_jit_function_add_assignment call. */
gcc_jit_block_end_with_void_return (blk, NULL);
}
