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"
67 # include "jit_fallback.c"
73 jit_register_t _rvs[] = {
74 { rc(gpr) | 0x1c, "at" },
75 { rc(gpr) | 0x00, "v0" },
76 { rc(gpr) | 0x01, "t0" },
77 { rc(gpr) | 0x02, "t1" },
78 { rc(gpr) | 0x03, "t2" },
79 { rc(gpr) | 0x04, "t3" },
80 { rc(gpr) | 0x05, "t4" },
81 { rc(gpr) | 0x06, "t5" },
82 { rc(gpr) | 0x07, "t6" },
83 { rc(gpr) | 0x08, "t7" },
84 { rc(gpr) | 0x16, "t8" },
85 { rc(gpr) | 0x17, "t9" },
86 { rc(gpr) | 0x18, "t10" },
87 { rc(gpr) | 0x19, "t11" },
88 { rc(sav) | rc(gpr) | 0x09, "s0" },
89 { rc(sav) | rc(gpr) | 0x0a, "s1" },
90 { rc(sav) | rc(gpr) | 0x0b, "s2" },
91 { rc(sav) | rc(gpr) | 0x0c, "s3" },
92 { rc(sav) | rc(gpr) | 0x0d, "s4" },
93 { rc(sav) | rc(gpr) | 0x0e, "s5" },
95 { rc(arg) | rc(gpr) | 0x15, "a5" },
96 { rc(arg) | rc(gpr) | 0x14, "a4" },
97 { rc(arg) | rc(gpr) | 0x13, "a3" },
98 { rc(arg) | rc(gpr) | 0x12, "a2" },
99 { rc(arg) | rc(gpr) | 0x11, "a1" },
100 { rc(arg) | rc(gpr) | 0x10, "a0" },
106 { rc(fpr) | 0x00, "$f0" },
107 { rc(fpr) | 0x01, "$f1" },
108 { rc(sav) | rc(fpr) | 0x02, "$f2" },
109 { rc(sav) | rc(fpr) | 0x03, "$f3" },
110 { rc(sav) | rc(fpr) | 0x04, "$f4" },
111 { rc(sav) | rc(fpr) | 0x05, "$f5" },
112 { rc(sav) | rc(fpr) | 0x06, "$f6" },
113 { rc(sav) | rc(fpr) | 0x07, "$f7" },
114 { rc(sav) | rc(fpr) | 0x08, "$f8" },
115 { rc(sav) | rc(fpr) | 0x09, "$f9" },
116 { rc(fpr) | 0x0a, "$f10" },
117 { rc(fpr) | 0x0b, "$f11" },
118 { rc(fpr) | 0x0c, "$f12" },
119 { rc(fpr) | 0x0d, "$f13" },
120 { rc(fpr) | 0x0e, "$f14" },
121 { rc(fpr) | 0x0f, "$f15" },
122 { rc(arg) | rc(fpr) | 0x15, "$f21" },
123 { rc(arg) | rc(fpr) | 0x14, "$f20" },
124 { rc(arg) | rc(fpr) | 0x13, "$f19" },
125 { rc(arg) | rc(fpr) | 0x12, "$f18" },
126 { rc(arg) | rc(fpr) | 0x11, "$f17" },
127 { rc(arg) | rc(fpr) | 0x10, "$f16" },
128 { rc(fpr) | 0x16, "$f22" },
129 { rc(fpr) | 0x17, "$f23" },
130 { rc(fpr) | 0x18, "$f24" },
131 { rc(fpr) | 0x19, "$f25" },
132 { rc(fpr) | 0x1a, "$f26" },
133 { rc(fpr) | 0x1b, "$f27" },
134 { rc(fpr) | 0x1c, "$f28" },
135 { rc(fpr) | 0x1d, "$f29" },
136 { rc(fpr) | 0x1e, "$f30" },
138 { _NOREG, "<none>" },
150 _jit_init(jit_state_t *_jit)
152 _jitc->reglen = jit_size(_rvs) - 1;
157 _jit_prolog(jit_state_t *_jit)
163 assert(jit_regset_cmp_ui(&_jitc->regarg, 0) == 0);
164 jit_regset_set_ui(&_jitc->regsav, 0);
165 offset = _jitc->functions.offset;
166 if (offset >= _jitc->functions.length) {
167 jit_realloc((jit_pointer_t *)&_jitc->functions.ptr,
168 _jitc->functions.length * sizeof(jit_function_t),
169 (_jitc->functions.length + 16) * sizeof(jit_function_t));
170 _jitc->functions.length += 16;
172 _jitc->function = _jitc->functions.ptr + _jitc->functions.offset++;
173 _jitc->function->self.size = stack_framesize;
174 _jitc->function->self.argi = _jitc->function->self.alen = 0;
175 /* float conversion */
176 _jitc->function->self.aoff = -8;
177 _jitc->function->self.call = jit_call_default;
178 jit_alloc((jit_pointer_t *)&_jitc->function->regoff,
179 _jitc->reglen * sizeof(jit_int32_t));
181 /* _no_link here does not mean the jit_link() call can be removed
183 * _jitc->function->prolog = jit_new_node(jit_code_prolog);
185 _jitc->function->prolog = jit_new_node_no_link(jit_code_prolog);
186 jit_link(_jitc->function->prolog);
187 _jitc->function->prolog->w.w = offset;
188 _jitc->function->epilog = jit_new_node_no_link(jit_code_epilog);
190 * v: offset in blocks vector
191 * w: offset in functions vector
193 _jitc->function->epilog->w.w = offset;
195 jit_regset_new(&_jitc->function->regset);
199 _jit_allocai(jit_state_t *_jit, jit_int32_t length)
201 assert(_jitc->function != NULL);
203 case 0: case 1: break;
204 case 2: _jitc->function->self.aoff &= -2; break;
205 case 3: case 4: _jitc->function->self.aoff &= -4; break;
206 default: _jitc->function->self.aoff &= -8; break;
208 _jitc->function->self.aoff -= length;
209 if (!_jitc->realize) {
210 jit_inc_synth_ww(allocai, _jitc->function->self.aoff, length);
213 return (_jitc->function->self.aoff);
217 _jit_allocar(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
220 assert(_jitc->function != NULL);
221 jit_inc_synth_ww(allocar, u, v);
222 if (!_jitc->function->allocar) {
223 _jitc->function->aoffoff = jit_allocai(sizeof(jit_int32_t));
224 _jitc->function->allocar = 1;
226 reg = jit_get_reg(jit_class_gpr);
228 jit_andi(reg, reg, -8);
229 jit_ldxi_i(u, JIT_FP, _jitc->function->aoffoff);
231 jit_addr(JIT_SP, JIT_SP, reg);
232 jit_stxi_i(_jitc->function->aoffoff, JIT_FP, u);
238 _jit_ret(jit_state_t *_jit)
241 assert(_jitc->function != NULL);
245 jit_patch_at(instr, _jitc->function->epilog);
250 _jit_retr(jit_state_t *_jit, jit_int32_t u)
252 jit_inc_synth_w(retr, u);
254 jit_movr(JIT_RET, u);
261 _jit_reti(jit_state_t *_jit, jit_word_t u)
263 jit_inc_synth_w(reti, u);
264 jit_movi(JIT_RET, u);
270 _jit_retr_f(jit_state_t *_jit, jit_int32_t u)
272 jit_inc_synth_w(retr_f, u);
274 jit_movr_f(JIT_FRET, u);
282 _jit_reti_f(jit_state_t *_jit, jit_float32_t u)
284 jit_inc_synth_f(reti_f, u);
285 jit_movi_f(JIT_FRET, u);
291 _jit_retr_d(jit_state_t *_jit, jit_int32_t u)
293 jit_inc_synth_w(retr_d, u);
295 jit_movr_d(JIT_FRET, u);
303 _jit_reti_d(jit_state_t *_jit, jit_float64_t u)
305 jit_inc_synth_d(reti_d, u);
306 jit_movi_d(JIT_FRET, u);
312 _jit_epilog(jit_state_t *_jit)
314 assert(_jitc->function != NULL);
315 assert(_jitc->function->epilog->next == NULL);
316 jit_link(_jitc->function->epilog);
317 _jitc->function = NULL;
321 _jit_arg_register_p(jit_state_t *_jit, jit_node_t *u)
323 if (u->code == jit_code_arg)
324 return (jit_arg_reg_p(u->u.w));
325 assert(u->code == jit_code_arg_f || u->code == jit_code_arg_d);
326 return (jit_arg_f_reg_p(u->u.w));
330 _jit_ellipsis(jit_state_t *_jit)
332 jit_inc_synth(ellipsis);
333 if (_jitc->prepare) {
335 assert(!(_jitc->function->call.call & jit_call_varargs));
336 _jitc->function->call.call |= jit_call_varargs;
340 assert(!(_jitc->function->self.call & jit_call_varargs));
341 _jitc->function->self.call |= jit_call_varargs;
343 /* Allocate va_list like object in the stack */
344 _jitc->function->vaoff = jit_allocai(sizeof(jit_va_list_t));
345 _jitc->function->vagp = _jitc->function->self.argi;
351 _jit_va_push(jit_state_t *_jit, jit_int32_t u)
354 jit_inc_synth_w(va_push, u);
355 reg = jit_get_reg(jit_class_gpr);
356 jit_ldxi(reg, u, offsetof(jit_va_list_t, base));
358 jit_ldxi(reg, u, offsetof(jit_va_list_t, offset));
365 _jit_arg(jit_state_t *_jit)
369 assert(_jitc->function != NULL);
370 if (jit_arg_reg_p(_jitc->function->self.argi))
371 offset = _jitc->function->self.argi++;
373 offset = _jitc->function->self.size;
374 _jitc->function->self.size += 8;
376 node = jit_new_node_ww(jit_code_arg, offset,
377 ++_jitc->function->self.argn);
383 _jit_arg_f(jit_state_t *_jit)
387 assert(_jitc->function != NULL);
388 if (jit_arg_f_reg_p(_jitc->function->self.argi))
389 offset = _jitc->function->self.argi++;
391 offset = _jitc->function->self.size;
392 _jitc->function->self.size += 8;
394 node = jit_new_node_ww(jit_code_arg_f, offset,
395 ++_jitc->function->self.argn);
401 _jit_arg_d(jit_state_t *_jit)
405 assert(_jitc->function != NULL);
406 if (jit_arg_f_reg_p(_jitc->function->self.argi))
407 offset = _jitc->function->self.argi++;
409 offset = _jitc->function->self.size;
410 _jitc->function->self.size += 8;
412 node = jit_new_node_ww(jit_code_arg_d, offset,
413 ++_jitc->function->self.argn);
419 _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
421 assert(v->code == jit_code_arg);
422 jit_inc_synth_wp(getarg_c, u, v);
423 if (jit_arg_reg_p(v->u.w))
424 jit_extr_c(u, _A0 - v->u.w);
426 jit_ldxi_c(u, _FP, v->u.w + C_DISP);
431 _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
433 assert(v->code == jit_code_arg);
434 jit_inc_synth_wp(getarg_uc, u, v);
435 if (jit_arg_reg_p(v->u.w))
436 jit_extr_uc(u, _A0 - v->u.w);
438 jit_ldxi_uc(u, _FP, v->u.w + C_DISP);
443 _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
445 assert(v->code == jit_code_arg);
446 jit_inc_synth_wp(getarg_s, u, v);
447 if (jit_arg_reg_p(v->u.w))
448 jit_extr_s(u, _A0 - v->u.w);
450 jit_ldxi_s(u, _FP, v->u.w + S_DISP);
455 _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
457 assert(v->code == jit_code_arg);
458 jit_inc_synth_wp(getarg_us, u, v);
459 if (jit_arg_reg_p(v->u.w))
460 jit_extr_us(u, _A0 - v->u.w);
462 jit_ldxi_us(u, _FP, v->u.w + S_DISP);
467 _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
469 assert(v->code == jit_code_arg);
470 jit_inc_synth_wp(getarg_i, u, v);
471 if (jit_arg_reg_p(v->u.w))
472 jit_extr_i(u, _A0 - v->u.w);
474 jit_ldxi_i(u, _FP, v->u.w + I_DISP);
479 _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
481 assert(v->code == jit_code_arg);
482 jit_inc_synth_wp(getarg_ui, u, v);
483 if (jit_arg_reg_p(v->u.w))
484 jit_extr_ui(u, _A0 - v->u.w);
486 jit_ldxi_ui(u, _FP, v->u.w + I_DISP);
491 _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
493 assert(v->code == jit_code_arg);
494 jit_inc_synth_wp(getarg_l, u, v);
495 if (jit_arg_reg_p(v->u.w))
496 jit_movr(u, _A0 - v->u.w);
498 jit_ldxi_l(u, _FP, v->u.w);
503 _jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
505 assert(v->code == jit_code_arg);
506 jit_inc_synth_wp(putargr, u, v);
507 if (jit_arg_reg_p(v->u.w))
508 jit_movr(_A0 - v->u.w, u);
510 jit_stxi(v->u.w, _FP, u);
515 _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
518 assert(v->code == jit_code_arg);
519 jit_inc_synth_wp(putargi, u, v);
520 if (jit_arg_reg_p(v->u.w))
521 jit_movi(_A0 - v->u.w, u);
523 regno = jit_get_reg(jit_class_gpr);
525 jit_stxi(v->u.w, _FP, regno);
526 jit_unget_reg(regno);
532 _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
534 assert(v->code == jit_code_arg_f);
535 jit_inc_synth_wp(getarg_f, u, v);
536 if (jit_arg_f_reg_p(v->u.w))
537 jit_movr_f(u, _F16 - v->u.w);
539 jit_ldxi_f(u, _FP, v->u.w + F_DISP);
544 _jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
546 assert(v->code == jit_code_arg_f);
547 jit_inc_synth_wp(putargr_f, u, v);
548 if (jit_arg_f_reg_p(v->u.w))
549 jit_movr_f(_F16 - v->u.w, u);
551 jit_stxi_f(v->u.w, _FP, u + F_DISP);
556 _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
559 assert(v->code == jit_code_arg_f);
560 jit_inc_synth_fp(putargi_f, u, v);
561 if (jit_arg_f_reg_p(v->u.w))
562 jit_movi_f(_F16 - v->u.w, u);
564 regno = jit_get_reg(jit_class_fpr);
565 jit_movi_f(regno, u);
566 jit_stxi_f(v->u.w, _FP, regno + F_DISP);
567 jit_unget_reg(regno);
573 _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
575 assert(v->code == jit_code_arg_d);
576 jit_inc_synth_wp(getarg_d, u, v);
577 if (jit_arg_f_reg_p(v->u.w))
578 jit_movr_d(u, _F16 - v->u.w);
580 jit_ldxi_d(u, _FP, v->u.w);
585 _jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
587 assert(v->code == jit_code_arg_d);
588 jit_inc_synth_wp(putargr_d, u, v);
589 if (jit_arg_f_reg_p(v->u.w))
590 jit_movr_d(_F16 - v->u.w, u);
592 jit_stxi_d(v->u.w, _FP, u);
597 _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
600 assert(v->code == jit_code_arg_d);
601 jit_inc_synth_dp(putargi_d, u, v);
602 if (jit_arg_f_reg_p(v->u.w))
603 jit_movi_d(_F16 - v->u.w, u);
605 regno = jit_get_reg(jit_class_fpr);
606 jit_movi_d(regno, u);
607 jit_stxi_d(v->u.w, _FP, regno);
608 jit_unget_reg(regno);
614 _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
616 assert(_jitc->function != NULL);
617 jit_inc_synth_w(pushargr, u);
619 if (jit_arg_reg_p(_jitc->function->call.argi)) {
620 jit_movr(_A0 - _jitc->function->call.argi, u);
621 ++_jitc->function->call.argi;
624 jit_stxi(_jitc->function->call.size, JIT_SP, u);
625 _jitc->function->call.size += 8;
631 _jit_pushargi(jit_state_t *_jit, jit_int64_t u)
634 assert(_jitc->function != NULL);
635 jit_inc_synth_w(pushargi, u);
637 if (jit_arg_reg_p(_jitc->function->call.argi)) {
638 jit_movi(_A0 - _jitc->function->call.argi, u);
639 ++_jitc->function->call.argi;
642 regno = jit_get_reg(jit_class_gpr);
644 jit_stxi(_jitc->function->call.size, JIT_SP, regno);
645 _jitc->function->call.size += 8;
646 jit_unget_reg(regno);
652 _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
654 assert(_jitc->function != NULL);
655 jit_inc_synth_w(pushargr_f, u);
657 if (jit_arg_f_reg_p(_jitc->function->call.argi)) {
658 jit_movr_f(_F16 - _jitc->function->call.argi, u);
659 ++_jitc->function->call.argi;
662 jit_stxi_f(_jitc->function->call.size + F_DISP, JIT_SP, u);
663 _jitc->function->call.size += 8;
669 _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
672 assert(_jitc->function != NULL);
673 jit_inc_synth_f(pushargi_f, u);
675 if (jit_arg_f_reg_p(_jitc->function->call.argi)) {
676 jit_movi_f(_F16 - _jitc->function->call.argi, u);
677 ++_jitc->function->call.argi;
680 regno = jit_get_reg(jit_class_fpr);
681 jit_movi_f(regno, u);
682 jit_stxi_f(_jitc->function->call.size + F_DISP, JIT_SP, regno);
683 _jitc->function->call.size += 8;
684 jit_unget_reg(regno);
690 _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
692 assert(_jitc->function != NULL);
693 jit_inc_synth_w(pushargr_d, u);
695 if (jit_arg_f_reg_p(_jitc->function->call.argi)) {
696 jit_movr_d(_F16 - _jitc->function->call.argi, u);
697 ++_jitc->function->call.argi;
700 jit_stxi_d(_jitc->function->call.size, JIT_SP, u);
701 _jitc->function->call.size += 8;
707 _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
710 assert(_jitc->function != NULL);
711 jit_inc_synth_d(pushargi_d, u);
713 if (jit_arg_f_reg_p(_jitc->function->call.argi)) {
714 jit_movi_d(_F16 - _jitc->function->call.argi, u);
715 ++_jitc->function->call.argi;
718 regno = jit_get_reg(jit_class_fpr);
719 jit_movi_d(regno, u);
720 jit_stxi_d(_jitc->function->call.size, JIT_SP, regno);
721 _jitc->function->call.size += 8;
722 jit_unget_reg(regno);
728 _jit_regarg_p(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno)
732 spec = jit_class(_rvs[regno].spec);
733 if (spec & jit_class_arg) {
734 if (spec & jit_class_gpr) {
736 if (regno >= 0 && regno < node->v.w)
739 else if (spec & jit_class_fpr) {
740 regno = _F16 - regno;
741 if (regno >= 0 && regno < node->w.w)
750 _jit_finishr(jit_state_t *_jit, jit_int32_t r0)
753 assert(_jitc->function != NULL);
754 jit_inc_synth_w(finishr, r0);
755 if (_jitc->function->self.alen < _jitc->function->call.size)
756 _jitc->function->self.alen = _jitc->function->call.size;
757 call = jit_callr(r0);
758 call->v.w = call->w.w = _jitc->function->self.argi;
759 _jitc->function->call.argi = _jitc->function->call.size = 0;
765 _jit_finishi(jit_state_t *_jit, jit_pointer_t i0)
768 assert(_jitc->function != NULL);
769 jit_inc_synth_w(finishi, (jit_word_t)i0);
770 if (_jitc->function->self.alen < _jitc->function->call.size)
771 _jitc->function->self.alen = _jitc->function->call.size;
772 call = jit_calli(i0);
773 call->v.w = call->w.w = _jitc->function->self.argf;
774 _jitc->function->call.argi = _jitc->function->call.size = 0;
781 _jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
783 jit_inc_synth_w(retval_c, r0);
784 jit_extr_c(r0, JIT_RET);
789 _jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
791 jit_inc_synth_w(retval_uc, r0);
792 jit_extr_uc(r0, JIT_RET);
797 _jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
799 jit_inc_synth_w(retval_s, r0);
800 jit_extr_s(r0, JIT_RET);
805 _jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
807 jit_inc_synth_w(retval_us, r0);
808 jit_extr_us(r0, JIT_RET);
813 _jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
815 jit_inc_synth_w(retval_i, r0);
816 jit_extr_i(r0, JIT_RET);
821 _jit_retval_ui(jit_state_t *_jit, jit_int32_t r0)
823 jit_inc_synth_w(retval_ui, r0);
824 jit_extr_ui(r0, JIT_RET);
829 _jit_retval_l(jit_state_t *_jit, jit_int32_t r0)
831 jit_inc_synth_w(retval_l, r0);
833 jit_movr(r0, JIT_RET);
838 _jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
840 jit_inc_synth_w(retval_f, r0);
842 jit_movr_f(r0, JIT_FRET);
847 _jit_retval_d(jit_state_t *_jit, jit_int32_t r0)
849 jit_inc_synth_w(retval_d, r0);
851 jit_movr_d(r0, JIT_FRET);
856 _emit_code(jit_state_t *_jit)
867 #if DEVEL_DISASSEMBLER
870 jit_int32_t const_offset;
871 jit_int32_t patch_offset;
873 #if DEVEL_DISASSEMBLER
877 _jitc->function = NULL;
883 undo.const_offset = undo.patch_offset = 0;
884 #define case_rr(name, type) \
885 case jit_code_##name##r##type: \
886 name##r##type(rn(node->u.w), rn(node->v.w)); \
888 #define case_rw(name, type) \
889 case jit_code_##name##i##type: \
890 name##i##type(rn(node->u.w), node->v.w); \
892 #define case_wr(name, type) \
893 case jit_code_##name##i##type: \
894 name##i##type(node->u.w, rn(node->v.w)); \
896 #define case_rrr(name, type) \
897 case jit_code_##name##r##type: \
898 name##r##type(rn(node->u.w), \
899 rn(node->v.w), rn(node->w.w)); \
901 #define case_rrw(name, type) \
902 case jit_code_##name##i##type: \
903 name##i##type(rn(node->u.w), rn(node->v.w), node->w.w); \
905 #define case_rrf(name, type, size) \
906 case jit_code_##name##i##type: \
907 assert(node->flag & jit_flag_data); \
908 name##i##type(rn(node->u.w), rn(node->v.w), \
909 (jit_float##size##_t *)node->w.n->u.w); \
911 #define case_rrrr(name, type) \
912 case jit_code_##name##r##type: \
913 name##r##type(rn(node->u.q.l), rn(node->u.q.h), \
914 rn(node->v.w), rn(node->w.w)); \
916 #define case_rrrw(name, type) \
917 case jit_code_##name##i##type: \
918 name##i##type(rn(node->u.q.l), rn(node->u.q.h), \
919 rn(node->v.w), node->w.w); \
921 #define case_wrr(name, type) \
922 case jit_code_##name##i##type: \
923 name##i##type(node->u.w, rn(node->v.w), rn(node->w.w)); \
925 #define case_brr(name, type) \
926 case jit_code_##name##r##type: \
928 assert(temp->code == jit_code_label || \
929 temp->code == jit_code_epilog); \
930 if (temp->flag & jit_flag_patch) \
931 name##r##type(temp->u.w, rn(node->v.w), \
934 word = name##r##type(_jit->pc.w, \
935 rn(node->v.w), rn(node->w.w)); \
939 #define case_brw(name, type) \
940 case jit_code_##name##i##type: \
942 assert(temp->code == jit_code_label || \
943 temp->code == jit_code_epilog); \
944 if (temp->flag & jit_flag_patch) \
945 name##i##type(temp->u.w, \
946 rn(node->v.w), node->w.w); \
948 word = name##i##type(_jit->pc.w, \
949 rn(node->v.w), node->w.w); \
953 #define case_brf(name, type, size) \
954 case jit_code_##name##i##type: \
956 assert(temp->code == jit_code_label || \
957 temp->code == jit_code_epilog); \
958 if (temp->flag & jit_flag_patch) \
959 name##i##type(temp->u.w, rn(node->v.w), \
960 (jit_float##size##_t *)node->w.n->u.w); \
962 word = name##i##type(_jit->pc.w, rn(node->v.w), \
963 (jit_float##size##_t *)node->w.n->u.w); \
967 #if DEVEL_DISASSEMBLER
970 for (node = _jitc->head; node; node = node->next) {
971 if (_jit->pc.uc >= _jitc->code.end)
974 #if DEVEL_DISASSEMBLER
975 node->offset = (jit_uword_t)_jit->pc.w - (jit_uword_t)prevw;
978 value = jit_classify(node->code);
979 jit_regarg_set(node, value);
980 switch (node->code) {
982 assert(!(node->u.w & (node->u.w - 1)) &&
983 node->u.w <= sizeof(jit_word_t));
984 if (node->u.w == sizeof(jit_word_t) &&
985 (word = _jit->pc.w & (sizeof(jit_word_t) - 1)))
986 nop(sizeof(jit_word_t) - word);
988 case jit_code_note: case jit_code_name:
989 node->u.w = _jit->pc.w;
992 /* remember label is defined */
993 node->flag |= jit_flag_patch;
994 node->u.w = _jit->pc.w;
1013 case_rrrr(qmul, _u);
1014 case_rrrw(qmul, _u);
1021 case_rrrr(qdiv, _u);
1022 case_rrrw(qdiv, _u);
1039 case_rr(trunc, _f_i);
1040 case_rr(trunc, _d_i);
1041 case_rr(trunc, _f_l);
1042 case_rr(trunc, _d_l);
1090 case_rr(bswap, _us);
1091 case_rr(bswap, _ui);
1092 case_rr(bswap, _ul);
1100 casr(rn(node->u.w), rn(node->v.w),
1101 rn(node->w.q.l), rn(node->w.q.h));
1104 casi(rn(node->u.w), node->v.w,
1105 rn(node->w.q.l), rn(node->w.q.h));
1111 if (node->flag & jit_flag_node) {
1113 if (temp->code == jit_code_data ||
1114 (temp->code == jit_code_label &&
1115 (temp->flag & jit_flag_patch)))
1116 movi(rn(node->u.w), temp->u.w);
1118 assert(temp->code == jit_code_label ||
1119 temp->code == jit_code_epilog);
1120 word = movi_p(rn(node->u.w), node->v.w);
1125 movi(rn(node->u.w), node->v.w);
1171 case_brr(boadd, _u);
1172 case_brw(boadd, _u);
1175 case_brr(bxadd, _u);
1176 case_brw(bxadd, _u);
1179 case_brr(bosub, _u);
1180 case_brw(bosub, _u);
1183 case_brr(bxsub, _u);
1184 case_brw(bxsub, _u);
1190 case_rrf(add, _f, 32);
1192 case_rrf(sub, _f, 32);
1193 case_rrf(rsb, _f, 32);
1195 case_rrf(mul, _f, 32);
1197 case_rrf(div, _f, 32);
1211 case jit_code_movi_f:
1212 assert(node->flag & jit_flag_data);
1213 movi_f(rn(node->u.w), (jit_float32_t *)node->v.n->u.w);
1217 case_rrf(lt, _f, 32);
1219 case_rrf(le, _f, 32);
1221 case_rrf(eq, _f, 32);
1223 case_rrf(ge, _f, 32);
1225 case_rrf(gt, _f, 32);
1227 case_rrf(ne, _f, 32);
1229 case_rrf(unlt, _f, 32);
1231 case_rrf(unle, _f, 32);
1233 case_rrf(uneq, _f, 32);
1235 case_rrf(unge, _f, 32);
1237 case_rrf(ungt, _f, 32);
1239 case_rrf(ltgt, _f, 32);
1241 case_rrf(ord, _f, 32);
1242 case_rrr(unord, _f);
1243 case_rrf(unord, _f, 32);
1245 case_brf(blt, _f, 32);
1247 case_brf(ble, _f, 32);
1249 case_brf(beq, _f, 32);
1251 case_brf(bge, _f, 32);
1253 case_brf(bgt, _f, 32);
1255 case_brf(bne, _f, 32);
1256 case_brr(bunlt, _f);
1257 case_brf(bunlt, _f, 32);
1258 case_brr(bunle, _f);
1259 case_brf(bunle, _f, 32);
1260 case_brr(buneq, _f);
1261 case_brf(buneq, _f, 32);
1262 case_brr(bunge, _f);
1263 case_brf(bunge, _f, 32);
1264 case_brr(bungt, _f);
1265 case_brf(bungt, _f, 32);
1266 case_brr(bltgt, _f);
1267 case_brf(bltgt, _f, 32);
1269 case_brf(bord, _f, 32);
1270 case_brr(bunord, _f);
1271 case_brf(bunord, _f, 32);
1273 case_rrf(add, _d, 64);
1275 case_rrf(sub, _d, 64);
1276 case_rrf(rsb, _d, 64);
1278 case_rrf(mul, _d, 64);
1280 case_rrf(div, _d, 64);
1294 case jit_code_movi_d:
1295 assert(node->flag & jit_flag_data);
1296 movi_d(rn(node->u.w), (jit_float64_t *)node->v.n->u.w);
1300 case_rrf(lt, _d, 64);
1302 case_rrf(le, _d, 64);
1304 case_rrf(eq, _d, 64);
1306 case_rrf(ge, _d, 64);
1308 case_rrf(gt, _d, 64);
1310 case_rrf(ne, _d, 64);
1312 case_rrf(unlt, _d, 64);
1314 case_rrf(unle, _d, 64);
1316 case_rrf(uneq, _d, 64);
1318 case_rrf(unge, _d, 64);
1320 case_rrf(ungt, _d, 64);
1322 case_rrf(ltgt, _d, 64);
1324 case_rrf(ord, _d, 64);
1325 case_rrr(unord, _d);
1326 case_rrf(unord, _d, 64);
1328 case_brf(blt, _d, 64);
1330 case_brf(ble, _d, 64);
1332 case_brf(beq, _d, 64);
1334 case_brf(bge, _d, 64);
1336 case_brf(bgt, _d, 64);
1338 case_brf(bne, _d, 64);
1339 case_brr(bunlt, _d);
1340 case_brf(bunlt, _d, 64);
1341 case_brr(bunle, _d);
1342 case_brf(bunle, _d, 64);
1343 case_brr(buneq, _d);
1344 case_brf(buneq, _d, 64);
1345 case_brr(bunge, _d);
1346 case_brf(bunge, _d, 64);
1347 case_brr(bungt, _d);
1348 case_brf(bungt, _d, 64);
1349 case_brr(bltgt, _d);
1350 case_brf(bltgt, _d, 64);
1352 case_brf(bord, _d, 64);
1353 case_brr(bunord, _d);
1354 case_brf(bunord, _d, 64);
1356 jmpr(rn(node->u.w));
1359 if (node->flag & jit_flag_node) {
1361 assert(temp->code == jit_code_label ||
1362 temp->code == jit_code_epilog);
1363 if (temp->flag & jit_flag_patch)
1366 word = jmpi_p(_jit->pc.w);
1373 case jit_code_callr:
1374 callr(rn(node->u.w));
1376 case jit_code_calli:
1377 if (node->flag & jit_flag_node) {
1379 assert(temp->code == jit_code_label ||
1380 temp->code == jit_code_epilog);
1381 if (!(temp->flag & jit_flag_patch)) {
1382 word = calli_p(temp->u.w);
1391 case jit_code_prolog:
1392 _jitc->function = _jitc->functions.ptr + node->w.w;
1394 undo.word = _jit->pc.w;
1395 #if DEVEL_DISASSEMBLER
1398 undo.patch_offset = _jitc->patches.offset;
1403 case jit_code_epilog:
1404 assert(_jitc->function == _jitc->functions.ptr + node->w.w);
1406 for (temp = undo.node->next;
1407 temp != node; temp = temp->next) {
1408 if (temp->code == jit_code_label ||
1409 temp->code == jit_code_epilog)
1410 temp->flag &= ~jit_flag_patch;
1412 temp->flag &= ~jit_flag_patch;
1414 _jit->pc.w = undo.word;
1415 #if DEVEL_DISASSEMBLER
1418 _jitc->patches.offset = undo.patch_offset;
1419 goto restart_function;
1421 /* remember label is defined */
1422 node->flag |= jit_flag_patch;
1423 node->u.w = _jit->pc.w;
1425 _jitc->function = NULL;
1427 case jit_code_va_start:
1428 vastart(rn(node->u.w));
1430 case jit_code_va_arg:
1431 vaarg(rn(node->u.w), rn(node->v.w));
1433 case jit_code_va_arg_d:
1434 vaarg_d(rn(node->u.w), rn(node->v.w));
1436 case jit_code_live: case jit_code_ellipsis:
1437 case jit_code_va_push:
1438 case jit_code_allocai: case jit_code_allocar:
1440 case jit_code_arg_f: case jit_code_arg_d:
1441 case jit_code_va_end:
1443 case jit_code_retr: case jit_code_reti:
1444 case jit_code_retr_f: case jit_code_reti_f:
1445 case jit_code_retr_d: case jit_code_reti_d:
1446 case jit_code_getarg_c: case jit_code_getarg_uc:
1447 case jit_code_getarg_s: case jit_code_getarg_us:
1448 case jit_code_getarg_i: case jit_code_getarg_ui:
1449 case jit_code_getarg_l:
1450 case jit_code_getarg_f: case jit_code_getarg_d:
1451 case jit_code_putargr: case jit_code_putargi:
1452 case jit_code_putargr_f: case jit_code_putargi_f:
1453 case jit_code_putargr_d: case jit_code_putargi_d:
1454 case jit_code_pushargr: case jit_code_pushargi:
1455 case jit_code_pushargr_f: case jit_code_pushargi_f:
1456 case jit_code_pushargr_d: case jit_code_pushargi_d:
1457 case jit_code_retval_c: case jit_code_retval_uc:
1458 case jit_code_retval_s: case jit_code_retval_us:
1459 case jit_code_retval_i:
1460 case jit_code_retval_ui: case jit_code_retval_l:
1461 case jit_code_retval_f: case jit_code_retval_d:
1462 case jit_code_prepare:
1463 case jit_code_finishr: case jit_code_finishi:
1468 if (jit_carry != _NOREG) {
1469 switch (node->code) {
1471 case jit_code_addcr: case jit_code_addci:
1472 case jit_code_addxr: case jit_code_addxi:
1473 case jit_code_subcr: case jit_code_subci:
1474 case jit_code_subxr: case jit_code_subxi:
1477 jit_unget_reg(jit_carry);
1482 jit_regarg_clr(node, value);
1483 assert(_jitc->regarg == 0 ||
1484 (jit_carry != _NOREG && _jitc->regarg == (1 << jit_carry)));
1485 assert(_jitc->synth == 0);
1486 /* update register live state */
1501 for (offset = 0; offset < _jitc->patches.offset; offset++) {
1502 node = _jitc->patches.ptr[offset].node;
1503 word = node->code == jit_code_movi ? node->v.n->u.w : node->u.n->u.w;
1504 patch_at(_jitc->patches.ptr[offset].inst, word);
1507 jit_flush(_jit->code.ptr, _jit->pc.uc);
1509 return (_jit->code.ptr);
1513 # include "jit_alpha-cpu.c"
1514 # include "jit_alpha-fpu.c"
1515 # include "jit_fallback.c"
1519 jit_flush(void *fptr, void *tptr)
1524 _emit_ldxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1526 ldxi(rn(r0), rn(r1), i0);
1530 _emit_stxi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1532 stxi(i0, rn(r0), rn(r1));
1536 _emit_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1538 ldxi_d(rn(r0), rn(r1), i0);
1542 _emit_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1544 stxi_d(i0, rn(r0), rn(r1));
1548 _patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node)
1552 assert(node->flag & jit_flag_node);
1553 if (node->code == jit_code_movi)
1554 flag = node->v.n->flag;
1556 flag = node->u.n->flag;
1557 assert(!(flag & jit_flag_patch));
1558 if (_jitc->patches.offset >= _jitc->patches.length) {
1559 jit_realloc((jit_pointer_t *)&_jitc->patches.ptr,
1560 _jitc->patches.length * sizeof(jit_patch_t),
1561 (_jitc->patches.length + 1024) * sizeof(jit_patch_t));
1562 _jitc->patches.length += 1024;
1564 _jitc->patches.ptr[_jitc->patches.offset].inst = instr;
1565 _jitc->patches.ptr[_jitc->patches.offset].node = node;
1566 ++_jitc->patches.offset;