2 * Copyright (C) 2014-2019 Free Software Foundation, Inc.
4 * This file is part of GNU lightning.
6 * GNU lightning is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU Lesser General Public License as published
8 * by the Free Software Foundation; either version 3, or (at your option)
11 * GNU lightning is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
14 * License for more details.
17 * Paulo Cesar Pereira de Andrade
20 #define jit_arg_reg_p(i) ((i) >= 0 && (i) < 6)
21 #define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 6)
22 #if __BYTE_ORDER == __LITTLE_ENDIAN
28 # define C_DISP 8 - sizeof(jit_int8_t)
29 # define S_DISP 8 - sizeof(jit_int16_t)
30 # define I_DISP 8 - sizeof(jit_int32_t)
31 # define F_DISP 8 - sizeof(jit_float32_t)
38 * What I could understand from gcc/config/alpha/alpha.c:alpha_build_builtin_va_list()
39 * and other helpers, as well as objdump of simple test programs; could not
40 * get gdb working on the test system I had access...
42 * base-48 to base is where up to 6 float registers are saved.
43 * base to base+48 is where up to 6 integer registers are saved.
44 * base+48... is where varargs arguments are stored.
50 * load(reg, base, offset);
53 typedef struct jit_va_list {
61 #define patch(instr, node) _patch(_jit, instr, node)
62 static void _patch(jit_state_t*,jit_word_t,jit_node_t*);
65 # include "jit_alpha-cpu.c"
66 # include "jit_alpha-fpu.c"
72 jit_register_t _rvs[] = {
73 { rc(gpr) | 0x1c, "at" },
74 { rc(gpr) | 0x00, "v0" },
75 { rc(gpr) | 0x01, "t0" },
76 { rc(gpr) | 0x02, "t1" },
77 { rc(gpr) | 0x03, "t2" },
78 { rc(gpr) | 0x04, "t3" },
79 { rc(gpr) | 0x05, "t4" },
80 { rc(gpr) | 0x06, "t5" },
81 { rc(gpr) | 0x07, "t6" },
82 { rc(gpr) | 0x08, "t7" },
83 { rc(gpr) | 0x16, "t8" },
84 { rc(gpr) | 0x17, "t9" },
85 { rc(gpr) | 0x18, "t10" },
86 { rc(gpr) | 0x19, "t11" },
87 { rc(sav) | rc(gpr) | 0x09, "s0" },
88 { rc(sav) | rc(gpr) | 0x0a, "s1" },
89 { rc(sav) | rc(gpr) | 0x0b, "s2" },
90 { rc(sav) | rc(gpr) | 0x0c, "s3" },
91 { rc(sav) | rc(gpr) | 0x0d, "s4" },
92 { rc(sav) | rc(gpr) | 0x0e, "s5" },
94 { rc(arg) | rc(gpr) | 0x15, "a5" },
95 { rc(arg) | rc(gpr) | 0x14, "a4" },
96 { rc(arg) | rc(gpr) | 0x13, "a3" },
97 { rc(arg) | rc(gpr) | 0x12, "a2" },
98 { rc(arg) | rc(gpr) | 0x11, "a1" },
99 { rc(arg) | rc(gpr) | 0x10, "a0" },
105 { rc(fpr) | 0x00, "$f0" },
106 { rc(fpr) | 0x01, "$f1" },
107 { rc(sav) | rc(fpr) | 0x02, "$f2" },
108 { rc(sav) | rc(fpr) | 0x03, "$f3" },
109 { rc(sav) | rc(fpr) | 0x04, "$f4" },
110 { rc(sav) | rc(fpr) | 0x05, "$f5" },
111 { rc(sav) | rc(fpr) | 0x06, "$f6" },
112 { rc(sav) | rc(fpr) | 0x07, "$f7" },
113 { rc(sav) | rc(fpr) | 0x08, "$f8" },
114 { rc(sav) | rc(fpr) | 0x09, "$f9" },
115 { rc(fpr) | 0x0a, "$f10" },
116 { rc(fpr) | 0x0b, "$f11" },
117 { rc(fpr) | 0x0c, "$f12" },
118 { rc(fpr) | 0x0d, "$f13" },
119 { rc(fpr) | 0x0e, "$f14" },
120 { rc(fpr) | 0x0f, "$f15" },
121 { rc(arg) | rc(fpr) | 0x15, "$f21" },
122 { rc(arg) | rc(fpr) | 0x14, "$f20" },
123 { rc(arg) | rc(fpr) | 0x13, "$f19" },
124 { rc(arg) | rc(fpr) | 0x12, "$f18" },
125 { rc(arg) | rc(fpr) | 0x11, "$f17" },
126 { rc(arg) | rc(fpr) | 0x10, "$f16" },
127 { rc(fpr) | 0x16, "$f22" },
128 { rc(fpr) | 0x17, "$f23" },
129 { rc(fpr) | 0x18, "$f24" },
130 { rc(fpr) | 0x19, "$f25" },
131 { rc(fpr) | 0x1a, "$f26" },
132 { rc(fpr) | 0x1b, "$f27" },
133 { rc(fpr) | 0x1c, "$f28" },
134 { rc(fpr) | 0x1d, "$f29" },
135 { rc(fpr) | 0x1e, "$f30" },
137 { _NOREG, "<none>" },
149 _jit_init(jit_state_t *_jit)
151 _jitc->reglen = jit_size(_rvs) - 1;
156 _jit_prolog(jit_state_t *_jit)
162 assert(jit_regset_cmp_ui(&_jitc->regarg, 0) == 0);
163 jit_regset_set_ui(&_jitc->regsav, 0);
164 offset = _jitc->functions.offset;
165 if (offset >= _jitc->functions.length) {
166 jit_realloc((jit_pointer_t *)&_jitc->functions.ptr,
167 _jitc->functions.length * sizeof(jit_function_t),
168 (_jitc->functions.length + 16) * sizeof(jit_function_t));
169 _jitc->functions.length += 16;
171 _jitc->function = _jitc->functions.ptr + _jitc->functions.offset++;
172 _jitc->function->self.size = stack_framesize;
173 _jitc->function->self.argi = _jitc->function->self.alen = 0;
174 /* float conversion */
175 _jitc->function->self.aoff = -8;
176 _jitc->function->self.call = jit_call_default;
177 jit_alloc((jit_pointer_t *)&_jitc->function->regoff,
178 _jitc->reglen * sizeof(jit_int32_t));
180 /* _no_link here does not mean the jit_link() call can be removed
182 * _jitc->function->prolog = jit_new_node(jit_code_prolog);
184 _jitc->function->prolog = jit_new_node_no_link(jit_code_prolog);
185 jit_link(_jitc->function->prolog);
186 _jitc->function->prolog->w.w = offset;
187 _jitc->function->epilog = jit_new_node_no_link(jit_code_epilog);
189 * v: offset in blocks vector
190 * w: offset in functions vector
192 _jitc->function->epilog->w.w = offset;
194 jit_regset_new(&_jitc->function->regset);
198 _jit_allocai(jit_state_t *_jit, jit_int32_t length)
200 assert(_jitc->function != NULL);
202 case 0: case 1: break;
203 case 2: _jitc->function->self.aoff &= -2; break;
204 case 3: case 4: _jitc->function->self.aoff &= -4; break;
205 default: _jitc->function->self.aoff &= -8; break;
207 _jitc->function->self.aoff -= length;
208 if (!_jitc->realize) {
209 jit_inc_synth_ww(allocai, _jitc->function->self.aoff, length);
212 return (_jitc->function->self.aoff);
216 _jit_allocar(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
219 assert(_jitc->function != NULL);
220 jit_inc_synth_ww(allocar, u, v);
221 if (!_jitc->function->allocar) {
222 _jitc->function->aoffoff = jit_allocai(sizeof(jit_int32_t));
223 _jitc->function->allocar = 1;
225 reg = jit_get_reg(jit_class_gpr);
227 jit_andi(reg, reg, -8);
228 jit_ldxi_i(u, JIT_FP, _jitc->function->aoffoff);
230 jit_addr(JIT_SP, JIT_SP, reg);
231 jit_stxi_i(_jitc->function->aoffoff, JIT_FP, u);
237 _jit_ret(jit_state_t *_jit)
240 assert(_jitc->function != NULL);
244 jit_patch_at(instr, _jitc->function->epilog);
249 _jit_retr(jit_state_t *_jit, jit_int32_t u)
251 jit_inc_synth_w(retr, u);
253 jit_movr(JIT_RET, u);
260 _jit_reti(jit_state_t *_jit, jit_word_t u)
262 jit_inc_synth_w(reti, u);
263 jit_movi(JIT_RET, u);
269 _jit_retr_f(jit_state_t *_jit, jit_int32_t u)
271 jit_inc_synth_w(retr_f, u);
273 jit_movr_f(JIT_FRET, u);
281 _jit_reti_f(jit_state_t *_jit, jit_float32_t u)
283 jit_inc_synth_f(reti_f, u);
284 jit_movi_f(JIT_FRET, u);
290 _jit_retr_d(jit_state_t *_jit, jit_int32_t u)
292 jit_inc_synth_w(retr_d, u);
294 jit_movr_d(JIT_FRET, u);
302 _jit_reti_d(jit_state_t *_jit, jit_float64_t u)
304 jit_inc_synth_d(reti_d, u);
305 jit_movi_d(JIT_FRET, u);
311 _jit_epilog(jit_state_t *_jit)
313 assert(_jitc->function != NULL);
314 assert(_jitc->function->epilog->next == NULL);
315 jit_link(_jitc->function->epilog);
316 _jitc->function = NULL;
320 _jit_arg_register_p(jit_state_t *_jit, jit_node_t *u)
322 if (u->code == jit_code_arg)
323 return (jit_arg_reg_p(u->u.w));
324 assert(u->code == jit_code_arg_f || u->code == jit_code_arg_d);
325 return (jit_arg_f_reg_p(u->u.w));
329 _jit_ellipsis(jit_state_t *_jit)
331 jit_inc_synth(ellipsis);
332 if (_jitc->prepare) {
334 assert(!(_jitc->function->call.call & jit_call_varargs));
335 _jitc->function->call.call |= jit_call_varargs;
339 assert(!(_jitc->function->self.call & jit_call_varargs));
340 _jitc->function->self.call |= jit_call_varargs;
342 /* Allocate va_list like object in the stack */
343 _jitc->function->vaoff = jit_allocai(sizeof(jit_va_list_t));
344 _jitc->function->vagp = _jitc->function->self.argi;
350 _jit_va_push(jit_state_t *_jit, jit_int32_t u)
353 jit_inc_synth_w(va_push, u);
354 reg = jit_get_reg(jit_class_gpr);
355 jit_ldxi(reg, u, offsetof(jit_va_list_t, base));
357 jit_ldxi(reg, u, offsetof(jit_va_list_t, offset));
364 _jit_arg(jit_state_t *_jit)
368 assert(_jitc->function != NULL);
369 if (jit_arg_reg_p(_jitc->function->self.argi))
370 offset = _jitc->function->self.argi++;
372 offset = _jitc->function->self.size;
373 _jitc->function->self.size += 8;
375 node = jit_new_node_ww(jit_code_arg, offset,
376 ++_jitc->function->self.argn);
382 _jit_arg_f(jit_state_t *_jit)
386 assert(_jitc->function != NULL);
387 if (jit_arg_f_reg_p(_jitc->function->self.argi))
388 offset = _jitc->function->self.argi++;
390 offset = _jitc->function->self.size;
391 _jitc->function->self.size += 8;
393 node = jit_new_node_ww(jit_code_arg_f, offset,
394 ++_jitc->function->self.argn);
400 _jit_arg_d(jit_state_t *_jit)
404 assert(_jitc->function != NULL);
405 if (jit_arg_f_reg_p(_jitc->function->self.argi))
406 offset = _jitc->function->self.argi++;
408 offset = _jitc->function->self.size;
409 _jitc->function->self.size += 8;
411 node = jit_new_node_ww(jit_code_arg_d, offset,
412 ++_jitc->function->self.argn);
418 _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
420 assert(v->code == jit_code_arg);
421 jit_inc_synth_wp(getarg_c, u, v);
422 if (jit_arg_reg_p(v->u.w))
423 jit_extr_c(u, _A0 - v->u.w);
425 jit_ldxi_c(u, _FP, v->u.w + C_DISP);
430 _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
432 assert(v->code == jit_code_arg);
433 jit_inc_synth_wp(getarg_uc, u, v);
434 if (jit_arg_reg_p(v->u.w))
435 jit_extr_uc(u, _A0 - v->u.w);
437 jit_ldxi_uc(u, _FP, v->u.w + C_DISP);
442 _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
444 assert(v->code == jit_code_arg);
445 jit_inc_synth_wp(getarg_s, u, v);
446 if (jit_arg_reg_p(v->u.w))
447 jit_extr_s(u, _A0 - v->u.w);
449 jit_ldxi_s(u, _FP, v->u.w + S_DISP);
454 _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
456 assert(v->code == jit_code_arg);
457 jit_inc_synth_wp(getarg_us, u, v);
458 if (jit_arg_reg_p(v->u.w))
459 jit_extr_us(u, _A0 - v->u.w);
461 jit_ldxi_us(u, _FP, v->u.w + S_DISP);
466 _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
468 assert(v->code == jit_code_arg);
469 jit_inc_synth_wp(getarg_i, u, v);
470 if (jit_arg_reg_p(v->u.w))
471 jit_extr_i(u, _A0 - v->u.w);
473 jit_ldxi_i(u, _FP, v->u.w + I_DISP);
478 _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
480 assert(v->code == jit_code_arg);
481 jit_inc_synth_wp(getarg_ui, u, v);
482 if (jit_arg_reg_p(v->u.w))
483 jit_extr_ui(u, _A0 - v->u.w);
485 jit_ldxi_ui(u, _FP, v->u.w + I_DISP);
490 _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
492 assert(v->code == jit_code_arg);
493 jit_inc_synth_wp(getarg_l, u, v);
494 if (jit_arg_reg_p(v->u.w))
495 jit_movr(u, _A0 - v->u.w);
497 jit_ldxi_l(u, _FP, v->u.w);
502 _jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
504 assert(v->code == jit_code_arg);
505 jit_inc_synth_wp(putargr, u, v);
506 if (jit_arg_reg_p(v->u.w))
507 jit_movr(_A0 - v->u.w, u);
509 jit_stxi(v->u.w, _FP, u);
514 _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
517 assert(v->code == jit_code_arg);
518 jit_inc_synth_wp(putargi, u, v);
519 if (jit_arg_reg_p(v->u.w))
520 jit_movi(_A0 - v->u.w, u);
522 regno = jit_get_reg(jit_class_gpr);
524 jit_stxi(v->u.w, _FP, regno);
525 jit_unget_reg(regno);
531 _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
533 assert(v->code == jit_code_arg_f);
534 jit_inc_synth_wp(getarg_f, u, v);
535 if (jit_arg_f_reg_p(v->u.w))
536 jit_movr_f(u, _F16 - v->u.w);
538 jit_ldxi_f(u, _FP, v->u.w + F_DISP);
543 _jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
545 assert(v->code == jit_code_arg_f);
546 jit_inc_synth_wp(putargr_f, u, v);
547 if (jit_arg_f_reg_p(v->u.w))
548 jit_movr_f(_F16 - v->u.w, u);
550 jit_stxi_f(v->u.w, _FP, u + F_DISP);
555 _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
558 assert(v->code == jit_code_arg_f);
559 jit_inc_synth_fp(putargi_f, u, v);
560 if (jit_arg_f_reg_p(v->u.w))
561 jit_movi_f(_F16 - v->u.w, u);
563 regno = jit_get_reg(jit_class_fpr);
564 jit_movi_f(regno, u);
565 jit_stxi_f(v->u.w, _FP, regno + F_DISP);
566 jit_unget_reg(regno);
572 _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
574 assert(v->code == jit_code_arg_d);
575 jit_inc_synth_wp(getarg_d, u, v);
576 if (jit_arg_f_reg_p(v->u.w))
577 jit_movr_d(u, _F16 - v->u.w);
579 jit_ldxi_d(u, _FP, v->u.w);
584 _jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
586 assert(v->code == jit_code_arg_d);
587 jit_inc_synth_wp(putargr_d, u, v);
588 if (jit_arg_f_reg_p(v->u.w))
589 jit_movr_d(_F16 - v->u.w, u);
591 jit_stxi_d(v->u.w, _FP, u);
596 _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
599 assert(v->code == jit_code_arg_d);
600 jit_inc_synth_dp(putargi_d, u, v);
601 if (jit_arg_f_reg_p(v->u.w))
602 jit_movi_d(_F16 - v->u.w, u);
604 regno = jit_get_reg(jit_class_fpr);
605 jit_movi_d(regno, u);
606 jit_stxi_d(v->u.w, _FP, regno);
607 jit_unget_reg(regno);
613 _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
615 assert(_jitc->function != NULL);
616 jit_inc_synth_w(pushargr, u);
618 if (jit_arg_reg_p(_jitc->function->call.argi)) {
619 jit_movr(_A0 - _jitc->function->call.argi, u);
620 ++_jitc->function->call.argi;
623 jit_stxi(_jitc->function->call.size, JIT_SP, u);
624 _jitc->function->call.size += 8;
630 _jit_pushargi(jit_state_t *_jit, jit_int64_t u)
633 assert(_jitc->function != NULL);
634 jit_inc_synth_w(pushargi, u);
636 if (jit_arg_reg_p(_jitc->function->call.argi)) {
637 jit_movi(_A0 - _jitc->function->call.argi, u);
638 ++_jitc->function->call.argi;
641 regno = jit_get_reg(jit_class_gpr);
643 jit_stxi(_jitc->function->call.size, JIT_SP, regno);
644 _jitc->function->call.size += 8;
645 jit_unget_reg(regno);
651 _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
653 assert(_jitc->function != NULL);
654 jit_inc_synth_w(pushargr_f, u);
656 if (jit_arg_f_reg_p(_jitc->function->call.argi)) {
657 jit_movr_f(_F16 - _jitc->function->call.argi, u);
658 ++_jitc->function->call.argi;
661 jit_stxi_f(_jitc->function->call.size + F_DISP, JIT_SP, u);
662 _jitc->function->call.size += 8;
668 _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
671 assert(_jitc->function != NULL);
672 jit_inc_synth_f(pushargi_f, u);
674 if (jit_arg_f_reg_p(_jitc->function->call.argi)) {
675 jit_movi_f(_F16 - _jitc->function->call.argi, u);
676 ++_jitc->function->call.argi;
679 regno = jit_get_reg(jit_class_fpr);
680 jit_movi_f(regno, u);
681 jit_stxi_f(_jitc->function->call.size + F_DISP, JIT_SP, regno);
682 _jitc->function->call.size += 8;
683 jit_unget_reg(regno);
689 _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
691 assert(_jitc->function != NULL);
692 jit_inc_synth_w(pushargr_d, u);
694 if (jit_arg_f_reg_p(_jitc->function->call.argi)) {
695 jit_movr_d(_F16 - _jitc->function->call.argi, u);
696 ++_jitc->function->call.argi;
699 jit_stxi_d(_jitc->function->call.size, JIT_SP, u);
700 _jitc->function->call.size += 8;
706 _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
709 assert(_jitc->function != NULL);
710 jit_inc_synth_d(pushargi_d, u);
712 if (jit_arg_f_reg_p(_jitc->function->call.argi)) {
713 jit_movi_d(_F16 - _jitc->function->call.argi, u);
714 ++_jitc->function->call.argi;
717 regno = jit_get_reg(jit_class_fpr);
718 jit_movi_d(regno, u);
719 jit_stxi_d(_jitc->function->call.size, JIT_SP, regno);
720 _jitc->function->call.size += 8;
721 jit_unget_reg(regno);
727 _jit_regarg_p(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno)
731 spec = jit_class(_rvs[regno].spec);
732 if (spec & jit_class_arg) {
733 if (spec & jit_class_gpr) {
735 if (regno >= 0 && regno < node->v.w)
738 else if (spec & jit_class_fpr) {
739 regno = _F16 - regno;
740 if (regno >= 0 && regno < node->w.w)
749 _jit_finishr(jit_state_t *_jit, jit_int32_t r0)
752 assert(_jitc->function != NULL);
753 jit_inc_synth_w(finishr, r0);
754 if (_jitc->function->self.alen < _jitc->function->call.size)
755 _jitc->function->self.alen = _jitc->function->call.size;
756 call = jit_callr(r0);
757 call->v.w = call->w.w = _jitc->function->self.argi;
758 _jitc->function->call.argi = _jitc->function->call.size = 0;
764 _jit_finishi(jit_state_t *_jit, jit_pointer_t i0)
767 assert(_jitc->function != NULL);
768 jit_inc_synth_w(finishi, (jit_word_t)i0);
769 if (_jitc->function->self.alen < _jitc->function->call.size)
770 _jitc->function->self.alen = _jitc->function->call.size;
771 call = jit_calli(i0);
772 call->v.w = call->w.w = _jitc->function->self.argf;
773 _jitc->function->call.argi = _jitc->function->call.size = 0;
780 _jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
782 jit_inc_synth_w(retval_c, r0);
783 jit_extr_c(r0, JIT_RET);
788 _jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
790 jit_inc_synth_w(retval_uc, r0);
791 jit_extr_uc(r0, JIT_RET);
796 _jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
798 jit_inc_synth_w(retval_s, r0);
799 jit_extr_s(r0, JIT_RET);
804 _jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
806 jit_inc_synth_w(retval_us, r0);
807 jit_extr_us(r0, JIT_RET);
812 _jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
814 jit_inc_synth_w(retval_i, r0);
815 jit_extr_i(r0, JIT_RET);
820 _jit_retval_ui(jit_state_t *_jit, jit_int32_t r0)
822 jit_inc_synth_w(retval_ui, r0);
823 jit_extr_ui(r0, JIT_RET);
828 _jit_retval_l(jit_state_t *_jit, jit_int32_t r0)
830 jit_inc_synth_w(retval_l, r0);
832 jit_movr(r0, JIT_RET);
837 _jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
839 jit_inc_synth_w(retval_f, r0);
841 jit_movr_f(r0, JIT_FRET);
846 _jit_retval_d(jit_state_t *_jit, jit_int32_t r0)
848 jit_inc_synth_w(retval_d, r0);
850 jit_movr_d(r0, JIT_FRET);
855 _emit_code(jit_state_t *_jit)
866 #if DEVEL_DISASSEMBLER
869 jit_int32_t const_offset;
870 jit_int32_t patch_offset;
872 #if DEVEL_DISASSEMBLER
876 _jitc->function = NULL;
882 undo.const_offset = undo.patch_offset = 0;
883 #define case_rr(name, type) \
884 case jit_code_##name##r##type: \
885 name##r##type(rn(node->u.w), rn(node->v.w)); \
887 #define case_rw(name, type) \
888 case jit_code_##name##i##type: \
889 name##i##type(rn(node->u.w), node->v.w); \
891 #define case_wr(name, type) \
892 case jit_code_##name##i##type: \
893 name##i##type(node->u.w, rn(node->v.w)); \
895 #define case_rrr(name, type) \
896 case jit_code_##name##r##type: \
897 name##r##type(rn(node->u.w), \
898 rn(node->v.w), rn(node->w.w)); \
900 #define case_rrw(name, type) \
901 case jit_code_##name##i##type: \
902 name##i##type(rn(node->u.w), rn(node->v.w), node->w.w); \
904 #define case_rrf(name, type, size) \
905 case jit_code_##name##i##type: \
906 assert(node->flag & jit_flag_data); \
907 name##i##type(rn(node->u.w), rn(node->v.w), \
908 (jit_float##size##_t *)node->w.n->u.w); \
910 #define case_rrrr(name, type) \
911 case jit_code_##name##r##type: \
912 name##r##type(rn(node->u.q.l), rn(node->u.q.h), \
913 rn(node->v.w), rn(node->w.w)); \
915 #define case_rrrw(name, type) \
916 case jit_code_##name##i##type: \
917 name##i##type(rn(node->u.q.l), rn(node->u.q.h), \
918 rn(node->v.w), node->w.w); \
920 #define case_wrr(name, type) \
921 case jit_code_##name##i##type: \
922 name##i##type(node->u.w, rn(node->v.w), rn(node->w.w)); \
924 #define case_brr(name, type) \
925 case jit_code_##name##r##type: \
927 assert(temp->code == jit_code_label || \
928 temp->code == jit_code_epilog); \
929 if (temp->flag & jit_flag_patch) \
930 name##r##type(temp->u.w, rn(node->v.w), \
933 word = name##r##type(_jit->pc.w, \
934 rn(node->v.w), rn(node->w.w)); \
938 #define case_brw(name, type) \
939 case jit_code_##name##i##type: \
941 assert(temp->code == jit_code_label || \
942 temp->code == jit_code_epilog); \
943 if (temp->flag & jit_flag_patch) \
944 name##i##type(temp->u.w, \
945 rn(node->v.w), node->w.w); \
947 word = name##i##type(_jit->pc.w, \
948 rn(node->v.w), node->w.w); \
952 #define case_brf(name, type, size) \
953 case jit_code_##name##i##type: \
955 assert(temp->code == jit_code_label || \
956 temp->code == jit_code_epilog); \
957 if (temp->flag & jit_flag_patch) \
958 name##i##type(temp->u.w, rn(node->v.w), \
959 (jit_float##size##_t *)node->w.n->u.w); \
961 word = name##i##type(_jit->pc.w, rn(node->v.w), \
962 (jit_float##size##_t *)node->w.n->u.w); \
966 #if DEVEL_DISASSEMBLER
969 for (node = _jitc->head; node; node = node->next) {
970 if (_jit->pc.uc >= _jitc->code.end)
973 #if DEVEL_DISASSEMBLER
974 node->offset = (jit_uword_t)_jit->pc.w - (jit_uword_t)prevw;
977 value = jit_classify(node->code);
978 jit_regarg_set(node, value);
979 switch (node->code) {
981 assert(!(node->u.w & (node->u.w - 1)) &&
982 node->u.w <= sizeof(jit_word_t));
983 if (node->u.w == sizeof(jit_word_t) &&
984 (word = _jit->pc.w & (sizeof(jit_word_t) - 1)))
985 nop(sizeof(jit_word_t) - word);
987 case jit_code_note: case jit_code_name:
988 node->u.w = _jit->pc.w;
991 /* remember label is defined */
992 node->flag |= jit_flag_patch;
993 node->u.w = _jit->pc.w;
1012 case_rrrr(qmul, _u);
1013 case_rrrw(qmul, _u);
1020 case_rrrr(qdiv, _u);
1021 case_rrrw(qdiv, _u);
1038 case_rr(trunc, _f_i);
1039 case_rr(trunc, _d_i);
1040 case_rr(trunc, _f_l);
1041 case_rr(trunc, _d_l);
1097 if (node->flag & jit_flag_node) {
1099 if (temp->code == jit_code_data ||
1100 (temp->code == jit_code_label &&
1101 (temp->flag & jit_flag_patch)))
1102 movi(rn(node->u.w), temp->u.w);
1104 assert(temp->code == jit_code_label ||
1105 temp->code == jit_code_epilog);
1106 word = movi_p(rn(node->u.w), node->v.w);
1111 movi(rn(node->u.w), node->v.w);
1157 case_brr(boadd, _u);
1158 case_brw(boadd, _u);
1161 case_brr(bxadd, _u);
1162 case_brw(bxadd, _u);
1165 case_brr(bosub, _u);
1166 case_brw(bosub, _u);
1169 case_brr(bxsub, _u);
1170 case_brw(bxsub, _u);
1176 case_rrf(add, _f, 32);
1178 case_rrf(sub, _f, 32);
1179 case_rrf(rsb, _f, 32);
1181 case_rrf(mul, _f, 32);
1183 case_rrf(div, _f, 32);
1197 case jit_code_movi_f:
1198 assert(node->flag & jit_flag_data);
1199 movi_f(rn(node->u.w), (jit_float32_t *)node->v.n->u.w);
1203 case_rrf(lt, _f, 32);
1205 case_rrf(le, _f, 32);
1207 case_rrf(eq, _f, 32);
1209 case_rrf(ge, _f, 32);
1211 case_rrf(gt, _f, 32);
1213 case_rrf(ne, _f, 32);
1215 case_rrf(unlt, _f, 32);
1217 case_rrf(unle, _f, 32);
1219 case_rrf(uneq, _f, 32);
1221 case_rrf(unge, _f, 32);
1223 case_rrf(ungt, _f, 32);
1225 case_rrf(ltgt, _f, 32);
1227 case_rrf(ord, _f, 32);
1228 case_rrr(unord, _f);
1229 case_rrf(unord, _f, 32);
1231 case_brf(blt, _f, 32);
1233 case_brf(ble, _f, 32);
1235 case_brf(beq, _f, 32);
1237 case_brf(bge, _f, 32);
1239 case_brf(bgt, _f, 32);
1241 case_brf(bne, _f, 32);
1242 case_brr(bunlt, _f);
1243 case_brf(bunlt, _f, 32);
1244 case_brr(bunle, _f);
1245 case_brf(bunle, _f, 32);
1246 case_brr(buneq, _f);
1247 case_brf(buneq, _f, 32);
1248 case_brr(bunge, _f);
1249 case_brf(bunge, _f, 32);
1250 case_brr(bungt, _f);
1251 case_brf(bungt, _f, 32);
1252 case_brr(bltgt, _f);
1253 case_brf(bltgt, _f, 32);
1255 case_brf(bord, _f, 32);
1256 case_brr(bunord, _f);
1257 case_brf(bunord, _f, 32);
1259 case_rrf(add, _d, 64);
1261 case_rrf(sub, _d, 64);
1262 case_rrf(rsb, _d, 64);
1264 case_rrf(mul, _d, 64);
1266 case_rrf(div, _d, 64);
1280 case jit_code_movi_d:
1281 assert(node->flag & jit_flag_data);
1282 movi_d(rn(node->u.w), (jit_float64_t *)node->v.n->u.w);
1286 case_rrf(lt, _d, 64);
1288 case_rrf(le, _d, 64);
1290 case_rrf(eq, _d, 64);
1292 case_rrf(ge, _d, 64);
1294 case_rrf(gt, _d, 64);
1296 case_rrf(ne, _d, 64);
1298 case_rrf(unlt, _d, 64);
1300 case_rrf(unle, _d, 64);
1302 case_rrf(uneq, _d, 64);
1304 case_rrf(unge, _d, 64);
1306 case_rrf(ungt, _d, 64);
1308 case_rrf(ltgt, _d, 64);
1310 case_rrf(ord, _d, 64);
1311 case_rrr(unord, _d);
1312 case_rrf(unord, _d, 64);
1314 case_brf(blt, _d, 64);
1316 case_brf(ble, _d, 64);
1318 case_brf(beq, _d, 64);
1320 case_brf(bge, _d, 64);
1322 case_brf(bgt, _d, 64);
1324 case_brf(bne, _d, 64);
1325 case_brr(bunlt, _d);
1326 case_brf(bunlt, _d, 64);
1327 case_brr(bunle, _d);
1328 case_brf(bunle, _d, 64);
1329 case_brr(buneq, _d);
1330 case_brf(buneq, _d, 64);
1331 case_brr(bunge, _d);
1332 case_brf(bunge, _d, 64);
1333 case_brr(bungt, _d);
1334 case_brf(bungt, _d, 64);
1335 case_brr(bltgt, _d);
1336 case_brf(bltgt, _d, 64);
1338 case_brf(bord, _d, 64);
1339 case_brr(bunord, _d);
1340 case_brf(bunord, _d, 64);
1342 jmpr(rn(node->u.w));
1345 if (node->flag & jit_flag_node) {
1347 assert(temp->code == jit_code_label ||
1348 temp->code == jit_code_epilog);
1349 if (temp->flag & jit_flag_patch)
1352 word = jmpi_p(_jit->pc.w);
1359 case jit_code_callr:
1360 callr(rn(node->u.w));
1362 case jit_code_calli:
1363 if (node->flag & jit_flag_node) {
1365 assert(temp->code == jit_code_label ||
1366 temp->code == jit_code_epilog);
1367 if (!(temp->flag & jit_flag_patch)) {
1368 word = calli_p(temp->u.w);
1377 case jit_code_prolog:
1378 _jitc->function = _jitc->functions.ptr + node->w.w;
1380 undo.word = _jit->pc.w;
1381 #if DEVEL_DISASSEMBLER
1384 undo.patch_offset = _jitc->patches.offset;
1389 case jit_code_epilog:
1390 assert(_jitc->function == _jitc->functions.ptr + node->w.w);
1392 for (temp = undo.node->next;
1393 temp != node; temp = temp->next) {
1394 if (temp->code == jit_code_label ||
1395 temp->code == jit_code_epilog)
1396 temp->flag &= ~jit_flag_patch;
1398 temp->flag &= ~jit_flag_patch;
1400 _jit->pc.w = undo.word;
1401 #if DEVEL_DISASSEMBLER
1404 _jitc->patches.offset = undo.patch_offset;
1405 goto restart_function;
1407 /* remember label is defined */
1408 node->flag |= jit_flag_patch;
1409 node->u.w = _jit->pc.w;
1411 _jitc->function = NULL;
1413 case jit_code_va_start:
1414 vastart(rn(node->u.w));
1416 case jit_code_va_arg:
1417 vaarg(rn(node->u.w), rn(node->v.w));
1419 case jit_code_va_arg_d:
1420 vaarg_d(rn(node->u.w), rn(node->v.w));
1422 case jit_code_live: case jit_code_ellipsis:
1423 case jit_code_va_push:
1424 case jit_code_allocai: case jit_code_allocar:
1426 case jit_code_arg_f: case jit_code_arg_d:
1427 case jit_code_va_end:
1429 case jit_code_retr: case jit_code_reti:
1430 case jit_code_retr_f: case jit_code_reti_f:
1431 case jit_code_retr_d: case jit_code_reti_d:
1432 case jit_code_getarg_c: case jit_code_getarg_uc:
1433 case jit_code_getarg_s: case jit_code_getarg_us:
1434 case jit_code_getarg_i: case jit_code_getarg_ui:
1435 case jit_code_getarg_l:
1436 case jit_code_getarg_f: case jit_code_getarg_d:
1437 case jit_code_putargr: case jit_code_putargi:
1438 case jit_code_putargr_f: case jit_code_putargi_f:
1439 case jit_code_putargr_d: case jit_code_putargi_d:
1440 case jit_code_pushargr: case jit_code_pushargi:
1441 case jit_code_pushargr_f: case jit_code_pushargi_f:
1442 case jit_code_pushargr_d: case jit_code_pushargi_d:
1443 case jit_code_retval_c: case jit_code_retval_uc:
1444 case jit_code_retval_s: case jit_code_retval_us:
1445 case jit_code_retval_i:
1446 case jit_code_retval_ui: case jit_code_retval_l:
1447 case jit_code_retval_f: case jit_code_retval_d:
1448 case jit_code_prepare:
1449 case jit_code_finishr: case jit_code_finishi:
1454 if (jit_carry != _NOREG) {
1455 switch (node->code) {
1457 case jit_code_addcr: case jit_code_addci:
1458 case jit_code_addxr: case jit_code_addxi:
1459 case jit_code_subcr: case jit_code_subci:
1460 case jit_code_subxr: case jit_code_subxi:
1463 jit_unget_reg(jit_carry);
1468 jit_regarg_clr(node, value);
1469 assert(_jitc->regarg == 0 ||
1470 (jit_carry != _NOREG && _jitc->regarg == (1 << jit_carry)));
1471 assert(_jitc->synth == 0);
1472 /* update register live state */
1487 for (offset = 0; offset < _jitc->patches.offset; offset++) {
1488 node = _jitc->patches.ptr[offset].node;
1489 word = node->code == jit_code_movi ? node->v.n->u.w : node->u.n->u.w;
1490 patch_at(_jitc->patches.ptr[offset].inst, word);
1493 jit_flush(_jit->code.ptr, _jit->pc.uc);
1495 return (_jit->code.ptr);
1499 # include "jit_alpha-cpu.c"
1500 # include "jit_alpha-fpu.c"
1504 jit_flush(void *fptr, void *tptr)
1509 _emit_ldxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1511 ldxi(rn(r0), rn(r1), i0);
1515 _emit_stxi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1517 stxi(i0, rn(r0), rn(r1));
1521 _emit_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1523 ldxi_d(rn(r0), rn(r1), i0);
1527 _emit_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1529 stxi_d(i0, rn(r0), rn(r1));
1533 _patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node)
1537 assert(node->flag & jit_flag_node);
1538 if (node->code == jit_code_movi)
1539 flag = node->v.n->flag;
1541 flag = node->u.n->flag;
1542 assert(!(flag & jit_flag_patch));
1543 if (_jitc->patches.offset >= _jitc->patches.length) {
1544 jit_realloc((jit_pointer_t *)&_jitc->patches.ptr,
1545 _jitc->patches.length * sizeof(jit_patch_t),
1546 (_jitc->patches.length + 1024) * sizeof(jit_patch_t));
1547 _jitc->patches.length += 1024;
1549 _jitc->patches.ptr[_jitc->patches.offset].inst = instr;
1550 _jitc->patches.ptr[_jitc->patches.offset].node = node;
1551 ++_jitc->patches.offset;