#define EMIT_CALL_N(name, nargs) \
do { \
POP##nargs; \
- res = emit_call (name, comp.lisp_obj_type, nargs, args); \
+ res = emit_call ((name), comp.lisp_obj_type, (nargs), args); \
PUSH_RVAL (res); \
} while (0)
#define EMIT_CALL_N_REF(name, nargs) \
do { \
DISCARD (nargs); \
- res = emit_call_n_ref (name, nargs, *stack); \
+ res = emit_call_n_ref ((name), (nargs), *stack); \
PUSH_RVAL (res); \
} while (0)
POP2; \
args[2] = gcc_jit_context_new_rvalue_from_int (comp.ctxt, \
comp.int_type, \
- comparison); \
+ (comparison)); \
res = emit_call ("arithcompare", comp.lisp_obj_type, 3, args); \
PUSH_RVAL (res); \
} while (0)
+
+#define SAFE_ALLOCA_BLOCK(ptr, func, name) \
+do { \
+ (ptr) = SAFE_ALLOCA (sizeof (basic_block_t)); \
+ (ptr)->gcc_bb = gcc_jit_function_new_block ((func), (name)); \
+ (ptr)->terminated = false; \
+ (ptr)->top = NULL; \
+ } while (0)
+
+#define DECL_AND_SAFE_ALLOCA_BLOCK(name, func) \
+ basic_block_t *(name); \
+ SAFE_ALLOCA_BLOCK ((name), (func), STR(name))
+
typedef struct {
gcc_jit_block *gcc_bb;
/* When non zero indicates a stack pointer restart. */
void emacs_native_compile (const char *lisp_f_name, const char *c_f_name,
Lisp_Object func, int opt_level, bool dump_asm);
-
static char * ATTRIBUTE_FORMAT_PRINTF (1, 2)
format_string (const char *format, ...)
{
INLINE static void
emit_cond_jump (gcc_jit_rvalue *test,
- gcc_jit_block *then_target, gcc_jit_block *else_target)
+ basic_block_t *then_target, basic_block_t *else_target)
{
gcc_jit_block_end_with_conditional (comp.block->gcc_bb,
NULL,
test,
- then_target,
- else_target);
+ then_target->gcc_bb,
+ else_target->gcc_bb);
comp.block->terminated = true;
}
/* Close current basic block emitting a comparison between two rval. */
static gcc_jit_rvalue *
-emit_comparison_jump (enum gcc_jit_comparison op, /* TODO add basick block as param */
+emit_comparison_jump (enum gcc_jit_comparison op,
gcc_jit_rvalue *a, gcc_jit_rvalue *b,
- gcc_jit_block *then_target, gcc_jit_block *else_target)
+ basic_block_t *then_target, basic_block_t *else_target)
{
gcc_jit_rvalue *test = gcc_jit_context_new_comparison (comp.ctxt,
NULL,
}
static gcc_jit_rvalue *
-emit_make_fixnum (gcc_jit_block *block, gcc_jit_rvalue *obj)
+emit_make_fixnum (gcc_jit_rvalue *obj)
{
emit_comment ("make_fixnum");
comp.lisp_obj_type,
"lisp_obj_fixnum");
- gcc_jit_block_add_assignment (block,
+ gcc_jit_block_add_assignment (comp.block->gcc_bb,
NULL,
emit_lval_XLI (res),
tmp);
}
/* Construct fill and return a lisp object form a raw pointer. */
-/* FIXME do not pass bb */
static gcc_jit_rvalue *
-emit_lisp_obj_from_ptr (basic_block_t *block, void *p)
+emit_lisp_obj_from_ptr (void *p)
{
static unsigned i;
-
- comp.block = block;
emit_comment ("lisp_obj_from_ptr");
gcc_jit_lvalue *lisp_obj =
format_string ("Symbol %s",
(char *) SDATA (SYMBOL_NAME (p))));
- gcc_jit_block_add_assignment (block->gcc_bb,
+ gcc_jit_block_add_assignment (comp.block->gcc_bb,
NULL,
emit_lval_XLP (lisp_obj),
void_ptr);
+
return gcc_jit_lvalue_as_rvalue (lisp_obj);
}
{
emit_comment ("NILP");
- return emit_EQ (x, emit_lisp_obj_from_ptr (comp.block, Qnil));
+ return emit_EQ (x, emit_lisp_obj_from_ptr (Qnil));
}
static gcc_jit_rvalue *
gcc_jit_rvalue *args[] =
{ emit_CONSP (x),
- emit_lisp_obj_from_ptr (comp.block, Qconsp),
+ emit_lisp_obj_from_ptr (Qconsp),
x };
-
gcc_jit_context_new_call (comp.ctxt,
NULL,
comp.check_type,
static void
define_CHECK_TYPE (void)
{
+ USE_SAFE_ALLOCA;
gcc_jit_param *param[] =
{ gcc_jit_context_new_param (comp.ctxt,
NULL,
gcc_jit_rvalue *predicate = gcc_jit_param_as_rvalue (param[1]);
gcc_jit_rvalue *x = gcc_jit_param_as_rvalue (param[2]);
- gcc_jit_block *initial_block =
- gcc_jit_function_new_block (comp.check_type, "initial_block");
- gcc_jit_block *ok_block =
- gcc_jit_function_new_block (comp.check_type, "ok_block");
- gcc_jit_block *not_ok_block =
- gcc_jit_function_new_block (comp.check_type, "not_ok_block");
-
- /* Set current context as needed */
- basic_block_t block = { .gcc_bb = initial_block,
- .terminated = false };
- comp.block = █
+ DECL_AND_SAFE_ALLOCA_BLOCK (init_block, comp.check_type);
+ DECL_AND_SAFE_ALLOCA_BLOCK (ok_block, comp.check_type);
+ DECL_AND_SAFE_ALLOCA_BLOCK (not_ok_block, comp.check_type);
+
+ comp.block = init_block;
comp.func = comp.check_type;
emit_cond_jump (emit_cast (comp.bool_type, ok),
ok_block,
not_ok_block);
- gcc_jit_block_end_with_void_return (ok_block, NULL);
+ gcc_jit_block_end_with_void_return (ok_block->gcc_bb, NULL);
- comp.block->gcc_bb = not_ok_block;
+ comp.block = not_ok_block;
gcc_jit_rvalue *wrong_type_args[] = { predicate, x };
emit_call ("wrong_type_argument",
comp.lisp_obj_type, 2, wrong_type_args));
- gcc_jit_block_end_with_void_return (not_ok_block, NULL);
+ gcc_jit_block_end_with_void_return (not_ok_block->gcc_bb, NULL);
+
+ SAFE_FREE ();
}
static void
define_CAR_CDR (void)
{
+ USE_SAFE_ALLOCA;
+
gcc_jit_param *car_param =
gcc_jit_context_new_param (comp.ctxt,
NULL,
for (int i = 0; i < 2; i++)
{
gcc_jit_rvalue *c = gcc_jit_param_as_rvalue (param);
- gcc_jit_block *initial_block =
- gcc_jit_function_new_block (f, "initial_block");
+ DECL_AND_SAFE_ALLOCA_BLOCK (init_block, f);
+ DECL_AND_SAFE_ALLOCA_BLOCK (is_cons_b, f);
+ DECL_AND_SAFE_ALLOCA_BLOCK (not_a_cons_b, f);
- gcc_jit_block *is_cons_b =
- gcc_jit_function_new_block (f, "is_cons");
-
- gcc_jit_block *not_a_cons_b =
- gcc_jit_function_new_block (f, "not_a_cons");
-
-
- /* Set current context as needed */
- basic_block_t block = { .gcc_bb = initial_block,
- .terminated = false };
- comp.block = █
+ comp.block = init_block;
comp.func = f;
emit_cond_jump (emit_cast (comp.bool_type,
is_cons_b,
not_a_cons_b);
- comp.block->gcc_bb = is_cons_b;
+ comp.block = is_cons_b;
if (f == comp.car)
gcc_jit_block_end_with_return (comp.block->gcc_bb,
NULL,
emit_XCDR (c));
- comp.block->gcc_bb = not_a_cons_b;
+ comp.block = not_a_cons_b;
- gcc_jit_block *is_nil_b =
- gcc_jit_function_new_block (f, "is_nil");
- gcc_jit_block *not_nil_b =
- gcc_jit_function_new_block (f, "not_nil");
+ DECL_AND_SAFE_ALLOCA_BLOCK (is_nil_b, f);
+ DECL_AND_SAFE_ALLOCA_BLOCK (not_nil_b, f);
emit_cond_jump (emit_NILP (c),
is_nil_b,
not_nil_b);
- comp.block->gcc_bb = is_nil_b;
+ comp.block = is_nil_b;
gcc_jit_block_end_with_return (comp.block->gcc_bb,
NULL,
- emit_lisp_obj_from_ptr (comp.block, Qnil));
+ emit_lisp_obj_from_ptr (Qnil));
- comp.block->gcc_bb = not_nil_b;
+ comp.block = not_nil_b;
gcc_jit_rvalue *wrong_type_args[] =
- { emit_lisp_obj_from_ptr (comp.block, Qlistp), c };
+ { emit_lisp_obj_from_ptr (Qlistp), c };
gcc_jit_block_add_eval (comp.block->gcc_bb,
NULL,
comp.lisp_obj_type, 2, wrong_type_args));
gcc_jit_block_end_with_return (comp.block->gcc_bb,
NULL,
- emit_lisp_obj_from_ptr (comp.block, Qnil));
+ emit_lisp_obj_from_ptr (Qnil));
f = comp.cdr;
param = cdr_param;
}
+
+ SAFE_FREE ();
}
static void
define_setcar (void)
{
+ USE_SAFE_ALLOCA;
gcc_jit_param *cell =
gcc_jit_context_new_param (comp.ctxt,
2,
param,
0);
- gcc_jit_block *initial_block =
- gcc_jit_function_new_block (comp.setcar, "initial_block");
- /* Set current context as needed */
- basic_block_t block = { .gcc_bb = initial_block,
- .terminated = false };
- comp.block = █
+
+ DECL_AND_SAFE_ALLOCA_BLOCK (init_block, comp.setcar);
+ comp.block = init_block;
comp.func = comp.setcar;
emit_CHECK_CONS (gcc_jit_param_as_rvalue (cell));
emit_XSETCAR (gcc_jit_param_as_rvalue (cell),
gcc_jit_param_as_rvalue (new_car));
- gcc_jit_block_end_with_return (initial_block,
+ gcc_jit_block_end_with_return (init_block->gcc_bb,
NULL,
gcc_jit_param_as_rvalue (new_car));
-
+ SAFE_FREE ();
}
/* Declare a substitute for PSEUDOVECTORP as always inlined function. */
static void
define_PSEUDOVECTORP (void)
{
+ USE_SAFE_ALLOCA;
+
gcc_jit_param *param[] =
{ gcc_jit_context_new_param (comp.ctxt,
NULL,
param,
0);
- gcc_jit_block *initial_block =
- gcc_jit_function_new_block (comp.pseudovectorp, "initial_block");
-
- gcc_jit_block *ret_false_b =
- gcc_jit_function_new_block (comp.pseudovectorp, "ret_false");
-
- gcc_jit_block *call_pseudovector_typep_b =
- gcc_jit_function_new_block (comp.pseudovectorp, "call_pseudovector");
+ DECL_AND_SAFE_ALLOCA_BLOCK (init_block, comp.pseudovectorp);
+ DECL_AND_SAFE_ALLOCA_BLOCK (ret_false_b, comp.pseudovectorp);
+ DECL_AND_SAFE_ALLOCA_BLOCK (call_pseudovector_typep_b, comp.pseudovectorp);
- /* Set current context as needed */
- basic_block_t block = { .gcc_bb = initial_block,
- .terminated = false };
- comp.block = █
+ comp.block = init_block;
comp.func = comp.pseudovectorp;
emit_cond_jump (
call_pseudovector_typep_b,
ret_false_b);
- comp.block->gcc_bb = ret_false_b;
- gcc_jit_block_end_with_return (ret_false_b,
+ comp.block = ret_false_b;
+ gcc_jit_block_end_with_return (ret_false_b->gcc_bb
+ ,
NULL,
gcc_jit_context_new_rvalue_from_int(
comp.ctxt,
gcc_jit_rvalue *args[2] =
{ gcc_jit_param_as_rvalue (param[0]),
gcc_jit_param_as_rvalue (param[1]) };
- comp.block->gcc_bb = call_pseudovector_typep_b;
+ comp.block = call_pseudovector_typep_b;
/* FIXME use XUNTAG now that's available. */
- gcc_jit_block_end_with_return (call_pseudovector_typep_b,
+ gcc_jit_block_end_with_return (call_pseudovector_typep_b->gcc_bb
+ ,
NULL,
emit_call ("helper_PSEUDOVECTOR_TYPEP_XUNTAG",
comp.bool_type,
2,
args));
+ SAFE_FREE ();
}
static void
define_CHECK_IMPURE (void)
{
+ USE_SAFE_ALLOCA;
+
gcc_jit_param *param[] =
{ gcc_jit_context_new_param (comp.ctxt,
NULL,
2,
param,
0);
- gcc_jit_block *initial_block =
- gcc_jit_function_new_block (comp.check_impure,
- "initial_block");
- gcc_jit_block *err_block =
- gcc_jit_function_new_block (comp.check_impure,
- "err_block");
- gcc_jit_block *ok_block =
- gcc_jit_function_new_block (comp.check_impure,
- "ok_block");
-
- /* Set current context as needed */
- basic_block_t block = { .gcc_bb = initial_block,
- .terminated = false };
- comp.block = █
+
+ DECL_AND_SAFE_ALLOCA_BLOCK (init_block, comp.check_impure);
+ DECL_AND_SAFE_ALLOCA_BLOCK (err_block, comp.check_impure);
+ DECL_AND_SAFE_ALLOCA_BLOCK (ok_block, comp.check_impure);
+
+ comp.block = init_block;
comp.func = comp.check_impure;
- emit_cond_jump (emit_cast (comp.bool_type,
- emit_PURE_P (gcc_jit_param_as_rvalue (param[0]))), /* FIXME */
- err_block,
- ok_block);
- gcc_jit_block_end_with_void_return (ok_block, NULL);
+ emit_cond_jump (
+ emit_cast (comp.bool_type,
+ emit_PURE_P (gcc_jit_param_as_rvalue (param[0]))), /* FIXME */
+ err_block,
+ ok_block);
+ gcc_jit_block_end_with_void_return (ok_block->gcc_bb, NULL);
gcc_jit_rvalue *pure_write_error_arg =
gcc_jit_param_as_rvalue (param[0]);
- comp.block->gcc_bb = err_block;
+ comp.block = err_block;
gcc_jit_block_add_eval (comp.block->gcc_bb,
NULL,
emit_call ("pure_write_error",
comp.void_type, 1,
&pure_write_error_arg));
- gcc_jit_block_end_with_void_return (err_block, NULL);
-}
+ gcc_jit_block_end_with_void_return (err_block->gcc_bb, NULL);
+
+ SAFE_FREE ();}
/* Declare a function to convert boolean into t or nil */
static void
define_bool_to_lisp_obj (void)
{
+ USE_SAFE_ALLOCA;
+
/* x ? Qt : Qnil */
gcc_jit_param *param = gcc_jit_context_new_param (comp.ctxt,
NULL,
1,
¶m,
0);
- gcc_jit_block *initial_block =
- gcc_jit_function_new_block (comp.bool_to_lisp_obj,
- "bool_to_lisp_obj_initial_block");
- gcc_jit_block *ret_t_block =
- gcc_jit_function_new_block (comp.bool_to_lisp_obj,
- "ret_t");
- gcc_jit_block *ret_nil_block =
- gcc_jit_function_new_block (comp.bool_to_lisp_obj,
- "ret_nil");
- /* Set current context as needed */
- basic_block_t block = { .gcc_bb = initial_block,
- .terminated = false };
- comp.block = █
+ DECL_AND_SAFE_ALLOCA_BLOCK (init_block, comp.bool_to_lisp_obj);
+ DECL_AND_SAFE_ALLOCA_BLOCK (ret_t_block, comp.bool_to_lisp_obj);
+ DECL_AND_SAFE_ALLOCA_BLOCK (ret_nil_block, comp.bool_to_lisp_obj);
+ comp.block = init_block;
comp.func = comp.bool_to_lisp_obj;
emit_cond_jump (gcc_jit_param_as_rvalue (param),
ret_t_block,
ret_nil_block);
- block.gcc_bb = ret_t_block;
- gcc_jit_block_end_with_return (ret_t_block,
+
+ comp.block = ret_t_block;
+ gcc_jit_block_end_with_return (ret_t_block->gcc_bb,
NULL,
- emit_lisp_obj_from_ptr (&block, Qt));
- block.gcc_bb = ret_nil_block;
- gcc_jit_block_end_with_return (ret_nil_block,
+ emit_lisp_obj_from_ptr (Qt));
+
+ comp.block = ret_nil_block;
+ gcc_jit_block_end_with_return (ret_nil_block->gcc_bb,
NULL,
- emit_lisp_obj_from_ptr (&block, Qnil));
+ emit_lisp_obj_from_ptr (Qnil));
+
+ SAFE_FREE ();
}
static int
unsigned op;
unsigned pushhandler_n = 0;
+ USE_SAFE_ALLOCA;
+
/* Meta-stack we use to flat the bytecode written for push and pop
Emacs VM.*/
gcc_jit_lvalue **stack_base, **stack, **stack_over;
PUSH_PARAM (gcc_jit_function_get_param (comp.func, i));
gcc_jit_block_end_with_jump (prologue_bb, NULL, bb_map[0].gcc_bb);
- gcc_jit_rvalue *nil = emit_lisp_obj_from_ptr (&bb_map[0], Qnil);
+ comp.block = &bb_map[0];
+ gcc_jit_rvalue *nil = emit_lisp_obj_from_ptr (Qnil);
comp.block = NULL;
op = FETCH;
varref:
{
- args[0] = emit_lisp_obj_from_ptr (comp.block, vectorp[op]);
+ args[0] = emit_lisp_obj_from_ptr (vectorp[op]);
res = emit_call ("Fsymbol_value", comp.lisp_obj_type, 1, args);
PUSH_RVAL (res);
break;
{
POP1;
args[1] = args[0];
- args[0] = emit_lisp_obj_from_ptr (comp.block, vectorp[op]);
+ args[0] = emit_lisp_obj_from_ptr (vectorp[op]);
args[2] = nil;
args[3] = gcc_jit_context_new_rvalue_from_int (comp.ctxt,
comp.int_type,
op -= Bvarbind;
varbind:
{
- args[0] = emit_lisp_obj_from_ptr (comp.block, vectorp[op]);
+ args[0] = emit_lisp_obj_from_ptr (vectorp[op]);
pop (1, &stack, &args[1]);
res = emit_call ("specbind", comp.lisp_obj_type, 2, args);
PUSH_RVAL (res);
#else
res = emit_call ("setjmp", comp.int_type, 1, args);
#endif
- gcc_jit_block *push_h_val_block =
- gcc_jit_function_new_block (comp.func,
- format_string ("push_h_val_%u",
- pushhandler_n));
+ basic_block_t *push_h_val_block;
+ SAFE_ALLOCA_BLOCK (push_h_val_block,
+ comp.func,
+ format_string ("push_h_val_%u",
+ pushhandler_n));
emit_cond_jump (
/* This negation is just to have a bool. */
gcc_jit_context_new_unary_op (comp.ctxt,
GCC_JIT_UNARY_OP_LOGICAL_NEGATE,
comp.bool_type,
res),
- bb_map[pc].gcc_bb,
+ &bb_map[pc],
push_h_val_block);
gcc_jit_lvalue **stack_to_restore = stack;
/* This emit the handler part. */
- basic_block_t bb_orig = *comp.block;
- comp.block->gcc_bb = push_h_val_block;
+ basic_block_t *bb_orig = comp.block;
+ comp.block = push_h_val_block;
/* current_thread->m_handlerlist = c->next; */
gcc_jit_lvalue *m_handlerlist =
gcc_jit_rvalue_dereference_field (comp.current_thread,
NULL,
comp.handler_val_field));
bb_map[handler_pc].top = stack;
- *comp.block = bb_orig;
+ comp.block = bb_orig;
- gcc_jit_block_end_with_jump (push_h_val_block, NULL,
+ gcc_jit_block_end_with_jump (push_h_val_block->gcc_bb, NULL,
bb_map[handler_pc].gcc_bb);
stack = stack_to_restore;
CASE (Bsub1);
{
-
/* (FIXNUMP (TOP) && XFIXNUM (TOP) != MOST_NEGATIVE_FIXNUM
? make_fixnum (XFIXNUM (TOP) - 1)
: Fsub1 (TOP)) */
- gcc_jit_block *sub1_inline_block =
- gcc_jit_function_new_block (comp.func, "inline_sub1");
- gcc_jit_block *sub1_fcall_block =
- gcc_jit_function_new_block (comp.func, "fcall_sub1");
+ DECL_AND_SAFE_ALLOCA_BLOCK (sub1_inline_block, comp.func);
+ DECL_AND_SAFE_ALLOCA_BLOCK (sub1_fcall_block, comp.func);
gcc_jit_rvalue *tos_as_num =
emit_XFIXNUM (gcc_jit_lvalue_as_rvalue (TOS));
tos_as_num,
comp.one);
- gcc_jit_block_add_assignment (sub1_inline_block,
+ basic_block_t *bb_orig = comp.block;
+
+ comp.block = sub1_inline_block;
+ gcc_jit_block_add_assignment (sub1_inline_block->gcc_bb,
NULL,
TOS,
- emit_make_fixnum (sub1_inline_block,
- sub1_inline_res));
- basic_block_t bb_orig = *comp.block;
+ emit_make_fixnum (sub1_inline_res));
- comp.block->gcc_bb = sub1_fcall_block;
+ comp.block = sub1_fcall_block;
POP1;
res = emit_call ("Fsub1", comp.lisp_obj_type, 1, args);
PUSH_RVAL (res);
- *comp.block = bb_orig;
-
- gcc_jit_block_end_with_jump (sub1_inline_block, NULL,
+ gcc_jit_block_end_with_jump (sub1_inline_block->gcc_bb,
+ NULL,
bb_map[pc].gcc_bb);
- gcc_jit_block_end_with_jump (sub1_fcall_block, NULL,
+ gcc_jit_block_end_with_jump (sub1_fcall_block->gcc_bb,
+ NULL,
bb_map[pc].gcc_bb);
+ comp.block = bb_orig;
+ SAFE_FREE ();
}
break;
CASE (Badd1);
{
-
/* (FIXNUMP (TOP) && XFIXNUM (TOP) != MOST_POSITIVE_FIXNUM
? make_fixnum (XFIXNUM (TOP) + 1)
: Fadd (TOP)) */
- gcc_jit_block *add1_inline_block =
- gcc_jit_function_new_block (comp.func, "inline_add1");
- gcc_jit_block *add1_fcall_block =
- gcc_jit_function_new_block (comp.func, "fcall_add1");
+ DECL_AND_SAFE_ALLOCA_BLOCK (add1_inline_block, comp.func);
+ DECL_AND_SAFE_ALLOCA_BLOCK (add1_fcall_block, comp.func);
gcc_jit_rvalue *tos_as_num =
emit_XFIXNUM (gcc_jit_lvalue_as_rvalue (TOS));
tos_as_num,
comp.one);
- gcc_jit_block_add_assignment (add1_inline_block,
+ basic_block_t *bb_orig = comp.block;
+ comp.block = add1_inline_block;
+
+ gcc_jit_block_add_assignment (add1_inline_block->gcc_bb
+ ,
NULL,
TOS,
- emit_make_fixnum (add1_inline_block,
- add1_inline_res));
- basic_block_t bb_orig = *comp.block;
-
- comp.block->gcc_bb = add1_fcall_block;
+ emit_make_fixnum (add1_inline_res));
+ comp.block = add1_fcall_block;
POP1;
res = emit_call ("Fadd1", comp.lisp_obj_type, 1, args);
PUSH_RVAL (res);
- *comp.block = bb_orig;
-
- gcc_jit_block_end_with_jump (add1_inline_block, NULL,
+ gcc_jit_block_end_with_jump (add1_inline_block->gcc_bb,
+ NULL,
bb_map[pc].gcc_bb);
- gcc_jit_block_end_with_jump (add1_fcall_block, NULL,
+ gcc_jit_block_end_with_jump (add1_fcall_block->gcc_bb,
+ NULL,
bb_map[pc].gcc_bb);
+ comp.block = bb_orig;
+ SAFE_FREE ();
}
break;
CASE (Bnegate);
{
-
/* (FIXNUMP (TOP) && XFIXNUM (TOP) != MOST_NEGATIVE_FIXNUM
? make_fixnum (- XFIXNUM (TOP))
: Fminus (1, &TOP)) */
- gcc_jit_block *negate_inline_block =
- gcc_jit_function_new_block (comp.func, "inline_negate");
- gcc_jit_block *negate_fcall_block =
- gcc_jit_function_new_block (comp.func, "fcall_negate");
+ DECL_AND_SAFE_ALLOCA_BLOCK (negate_inline_block, comp.func);
+ DECL_AND_SAFE_ALLOCA_BLOCK (negate_fcall_block, comp.func);
gcc_jit_rvalue *tos_as_num =
emit_XFIXNUM (gcc_jit_lvalue_as_rvalue (TOS));
comp.emacs_int_type,
tos_as_num);
- gcc_jit_block_add_assignment (negate_inline_block,
+ basic_block_t *bb_orig = comp.block;
+
+ comp.block = negate_inline_block;
+ gcc_jit_block_add_assignment (negate_inline_block->gcc_bb,
NULL,
TOS,
- emit_make_fixnum (negate_inline_block,
- negate_inline_res));
- basic_block_t bb_orig = *comp.block;
+ emit_make_fixnum (negate_inline_res));
- comp.block->gcc_bb = negate_fcall_block;
+ comp.block = negate_fcall_block;
EMIT_CALL_N_REF ("Fminus", 1);
- *comp.block = bb_orig;
- gcc_jit_block_end_with_jump (negate_inline_block, NULL,
+ gcc_jit_block_end_with_jump (negate_inline_block->gcc_bb,
+ NULL,
bb_map[pc].gcc_bb);
- gcc_jit_block_end_with_jump (negate_fcall_block, NULL,
+ gcc_jit_block_end_with_jump (negate_fcall_block->gcc_bb,
+ NULL,
bb_map[pc].gcc_bb);
+ comp.block = bb_orig;
+ SAFE_FREE ();
}
break;
CASE (Bplus);
break;
CASE (Binteractive_p); /* Obsolete since 24.1. */
- PUSH_RVAL (emit_lisp_obj_from_ptr (comp.block,
- intern ("interactive-p")));
+ PUSH_RVAL (emit_lisp_obj_from_ptr (intern ("interactive-p")));
res = emit_call ("call0", comp.lisp_obj_type, 1, args);
PUSH_RVAL (res);
break;
op = FETCH2;
POP1;
emit_comparison_jump (GCC_JIT_COMPARISON_EQ, args[0], nil,
- bb_map[op].gcc_bb, bb_map[pc].gcc_bb);
+ &bb_map[op], &bb_map[pc]);
bb_map[op].top = stack;
break;
op = FETCH2;
POP1;
emit_comparison_jump (GCC_JIT_COMPARISON_NE, args[0], nil,
- bb_map[op].gcc_bb, bb_map[pc].gcc_bb);
+ &bb_map[op], &bb_map[pc]);
bb_map[op].top = stack;
break;
emit_comparison_jump (GCC_JIT_COMPARISON_EQ,
gcc_jit_lvalue_as_rvalue (TOS),
nil,
- bb_map[op].gcc_bb, bb_map[pc].gcc_bb);
+ &bb_map[op], &bb_map[pc]);
bb_map[op].top = stack;
DISCARD (1);
break;
emit_comparison_jump (GCC_JIT_COMPARISON_NE,
gcc_jit_lvalue_as_rvalue (TOS),
nil,
- bb_map[op].gcc_bb, bb_map[pc].gcc_bb);
+ &bb_map[op], &bb_map[pc]);
bb_map[op].top = stack;
DISCARD (1);
break;
break;
CASE (Bsave_restriction);
- args[0] = emit_lisp_obj_from_ptr (comp.block,
- save_restriction_restore);
+ args[0] = emit_lisp_obj_from_ptr (save_restriction_restore);
args[1] = emit_call ("save_restriction_save",
comp.lisp_obj_type,
0,
CASE (Bcatch); /* Obsolete since 24.4. */
POP2;
args[2] = args[1];
- args[1] = emit_lisp_obj_from_ptr (comp.block, eval_sub);
+ args[1] = emit_lisp_obj_from_ptr (eval_sub);
emit_call ("internal_catch", comp.void_ptr_type, 3, args);
break;
op += pc;
POP1;
emit_comparison_jump (GCC_JIT_COMPARISON_EQ, args[0], nil,
- bb_map[op].gcc_bb, bb_map[pc].gcc_bb);
+ &bb_map[op], &bb_map[pc]);
bb_map[op].top = stack;
break;
op += pc;
POP1;
emit_comparison_jump (GCC_JIT_COMPARISON_NE, args[0], nil,
- bb_map[op].gcc_bb, bb_map[pc].gcc_bb);
+ &bb_map[op], &bb_map[pc]);
bb_map[op].top = stack;
break;
emit_comparison_jump (GCC_JIT_COMPARISON_EQ,
gcc_jit_lvalue_as_rvalue (TOS),
nil,
- bb_map[op].gcc_bb, bb_map[pc].gcc_bb);
+ &bb_map[op], &bb_map[pc]);
bb_map[op].top = stack;
DISCARD (1);
break;
emit_comparison_jump (GCC_JIT_COMPARISON_NE,
gcc_jit_lvalue_as_rvalue (TOS),
nil,
- bb_map[op].gcc_bb, bb_map[pc].gcc_bb);
+ &bb_map[op], &bb_map[pc]);
bb_map[op].top = stack;
DISCARD (1);
break;
if (pc >= bytestr_length || bytestr_data[pc] != Bswitch)
{
gcc_jit_rvalue *c =
- emit_lisp_obj_from_ptr (comp.block, vectorp[op]);
+ emit_lisp_obj_from_ptr (vectorp[op]);
PUSH_RVAL (c);
break;
}
exit:
xfree (stack_base);
xfree (bb_map);
+ SAFE_FREE ();
return comp_res;
}
projects / emacs.git / commitdiff