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, ¶m_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) { /* 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)); }
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; }
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)); }
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)); }