notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge pull request #657 from pcercuei/update-lightrec-20220529
[pcsx_rearmed.git] / deps / lightning / lib / jit_sparc.c
CommitLineData
4a71579b
PC		 1/*
2 * Copyright (C) 2013-2019 Free Software Foundation, Inc.
3 *
4 * This file is part of GNU lightning.
5 *
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)
9 * any later version.
10 *
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.
15 *
16 * Authors:
17 * Paulo Cesar Pereira de Andrade
18 */
19
20#define jit_arg_reg_p(i) ((i) >= 0 && (i) < 6)
21#if __WORDSIZE == 32
22# define jit_arg_d_reg_p(i) ((i) >= 0 && (i) < 5)
23# define BIAS(n) (n)
24#else
25# define jit_arg_d_reg_p(i) ((i) >= 0 && (i) < 16)
26# define BIAS(n) ((n) + 2047)
27#endif
28
29/*
30 * Types
31 */
32typedef jit_pointer_t jit_va_list_t;
33
34/*
35 * Prototypes
36 */
37#define patch(instr, node) _patch(_jit, instr, node)
38static void _patch(jit_state_t*,jit_word_t,jit_node_t*);
39
40#define PROTO 1
41# include "jit_sparc-cpu.c"
42# include "jit_sparc-fpu.c"
43#undef PROTO
44
45/*
46 * Initialization
47 */
48jit_register_t _rvs[] = {
49 { 0x00, "%g0" },
50 { 0x01, "%g1" },
51 { rc(gpr) | 0x02, "%g2" },
52 { rc(gpr) | 0x03, "%g3" },
53 { rc(gpr) | 0x04, "%g4" },
54 { 0x05, "%g5" },
55 { 0x06, "%g6" },
56 { 0x07, "%g7" },
57 { rc(arg) | rc(gpr) | 0x08, "%o0" },
58 { rc(arg) | rc(gpr) | 0x09, "%o1" },
59 { rc(arg) | rc(gpr) | 0x0a, "%o2" },
60 { rc(arg) | rc(gpr) | 0x0b, "%o3" },
61 { rc(arg) | rc(gpr) | 0x0c, "%o4" },
62 { rc(arg) | rc(gpr) | 0x0d, "%o5" },
63 { rc(sav) | 0x0e, "%sp" },
64 { 0x0f, "%o7" },
65 { rc(sav) | rc(gpr) | 0x10, "%l0" },
66 { rc(sav) | rc(gpr) | 0x11, "%l1" },
67 { rc(sav) | rc(gpr) | 0x12, "%l2" },
68 { rc(sav) | rc(gpr) | 0x13, "%l3" },
69 { rc(sav) | rc(gpr) | 0x14, "%l4" },
70 { rc(sav) | rc(gpr) | 0x15, "%l5" },
71 { rc(sav) | rc(gpr) | 0x16, "%l6" },
72 { rc(sav) | rc(gpr) | 0x17, "%l7" },
73 { 0x18, "%i0" },
74 { 0x19, "%i1" },
75 { 0x1a, "%i2" },
76 { 0x1b, "%i3" },
77 { 0x1c, "%i4" },
78 { 0x1d, "%i5" },
79 { rc(sav) | 0x1e, "%fp" },
80 { 0x1f, "%i7" },
81# if __WORDSIZE == 32
82 { rc(fpr) | 0x00, "%f0" },
83 { 0x01, "%f1" },
84 { rc(fpr) | 0x02, "%f2" },
85 { 0x03, "%f3" },
86 { rc(fpr) | 0x04, "%f4" },
87 { 0x05, "%f5" },
88 { rc(fpr) | 0x06, "%f6" },
89 { 0x07, "%f7" },
90 { rc(fpr) | 0x08, "%f8" },
91 { 0x09, "%f9" },
92 { rc(fpr) | 0x0a, "%f10" },
93 { 0x0b, "%f11" },
94 { rc(fpr) | 0x0c, "%f12" },
95 { 0x0d, "%f13" },
96 { rc(fpr) | 0x0e, "%f14" },
97 { 0x0f, "%f15" },
98# else
99 { rc(fpr) | rc(dbl) | 0x3e, "%f62" },
100 { rc(fpr) | rc(dbl) | 0x3c, "%f60" },
101 { rc(fpr) | rc(dbl) | 0x3a, "%f58" },
102 { rc(fpr) | rc(dbl) | 0x38, "%f56" },
103 { rc(fpr) | rc(dbl) | 0x36, "%f54" },
104 { rc(fpr) | rc(dbl) | 0x34, "%f52" },
105 { rc(fpr) | rc(dbl) | 0x32, "%f50" },
106 { rc(fpr) | rc(dbl) | 0x30, "%f48" },
107 { rc(fpr) | rc(dbl) | 0x2e, "%f46" },
108 { rc(fpr) | rc(dbl) | 0x2c, "%f44" },
109 { rc(fpr) | rc(dbl) | 0x2a, "%f42" },
110 { rc(fpr) | rc(dbl) | 0x28, "%f40" },
111 { rc(fpr) | rc(dbl) | 0x26, "%f38" },
112 { rc(fpr) | rc(dbl) | 0x24, "%f36" },
113 { rc(fpr) | rc(dbl) | 0x22, "%f34" },
114 { rc(fpr) | rc(dbl) | 0x20, "%f32" },
115 { 0x1f, "%f31" },
116 { rc(arg)|rc(fpr)|rc(sng)|0x1e, "%f30" },
117 { 0x1d, "%f29" },
118 { rc(arg)|rc(fpr)|rc(sng)|0x1c, "%f28" },
119 { 0x1b, "%f27" },
120 { rc(arg)|rc(fpr)|rc(sng)|0x1a, "%f26" },
121 { 0x19, "%f25" },
122 { rc(arg)|rc(fpr)|rc(sng)|0x18, "%f24" },
123 { 0x17, "%f23" },
124 { rc(arg)|rc(fpr)|rc(sng)|0x16, "%f22" },
125 { 0x15, "%f21" },
126 { rc(arg)|rc(fpr)|rc(sng)|0x14, "%f20" },
127 { 0x13, "%f19" },
128 { rc(arg)|rc(fpr)|rc(sng)|0x12, "%f18" },
129 { 0x11, "%f17" },
130 { rc(arg)|rc(fpr)|rc(sng)|0x10, "%f16" },
131 { 0x0f, "%f15" },
132 { rc(arg)|rc(fpr)|rc(sng)|0x0e, "%f14" },
133 { 0x0d, "%f13" },
134 { rc(arg)|rc(fpr)|rc(sng)|0x0c, "%f12" },
135 { 0x0b, "%f11" },
136 { rc(arg)|rc(fpr)|rc(sng)|0x0a, "%f10" },
137 { 0x09, "%f9" },
138 { rc(arg)|rc(fpr)|rc(sng)|0x08, "%f8" },
139 { 0x07, "%f7" },
140 { rc(arg)|rc(fpr)|rc(sng)|0x06, "%f6" },
141 { 0x05, "%f5" },
142 { rc(arg)|rc(fpr)|rc(sng)|0x04, "%f4" },
143 { 0x03, "%f3" },
144 { rc(arg)|rc(fpr)|rc(sng)|0x02, "%f2" },
145 { 0x01, "%f1" },
146 { rc(arg)|rc(fpr)|rc(sng)|0x00, "%f0" },
147# endif
148 { _NOREG, "<none>" },
149};
150
151/*
152 * Implementation
153 */
154void
155jit_get_cpu(void)
156{
157}
158
159void
160_jit_init(jit_state_t *_jit)
161{
162 _jitc->reglen = jit_size(_rvs) - 1;
163# if __WORDSIZE == 64
164 jit_carry = _NOREG;
165# endif
166}
167
168void
169_jit_prolog(jit_state_t *_jit)
170{
171 jit_int32_t offset;
172
173 if (_jitc->function)
174 jit_epilog();
175 assert(jit_regset_cmp_ui(&_jitc->regarg, 0) == 0);
176 jit_regset_set_ui(&_jitc->regsav, 0);
177 offset = _jitc->functions.offset;
178 if (offset >= _jitc->functions.length) {
179 jit_realloc((jit_pointer_t *)&_jitc->functions.ptr,
180 _jitc->functions.length * sizeof(jit_function_t),
181 (_jitc->functions.length + 16) * sizeof(jit_function_t));
182 _jitc->functions.length += 16;
183 }
184 _jitc->function = _jitc->functions.ptr + _jitc->functions.offset++;
185 _jitc->function->self.size = stack_framesize;
186 _jitc->function->self.argi = _jitc->function->self.argf =
187 _jitc->function->self.aoff = _jitc->function->self.alen = 0;
188 /* float conversion */
189# if __WORDSIZE == 32
190 _jitc->function->self.aoff = -8;
191# else
192 /* extra slots in case qmul is called */
193 _jitc->function->self.aoff = -24;
194# endif
195 _jitc->function->self.call = jit_call_default;
196 jit_alloc((jit_pointer_t *)&_jitc->function->regoff,
197 _jitc->reglen * sizeof(jit_int32_t));
198
199 /* _no_link here does not mean the jit_link() call can be removed
200 * by rewriting as:
201 * _jitc->function->prolog = jit_new_node(jit_code_prolog);
202 */
203 _jitc->function->prolog = jit_new_node_no_link(jit_code_prolog);
204 jit_link(_jitc->function->prolog);
205 _jitc->function->prolog->w.w = offset;
206 _jitc->function->epilog = jit_new_node_no_link(jit_code_epilog);
207 /* u: label value
208 * v: offset in blocks vector
209 * w: offset in functions vector
210 */
211 _jitc->function->epilog->w.w = offset;
212
213 jit_regset_new(&_jitc->function->regset);
214}
215
216jit_int32_t
217_jit_allocai(jit_state_t *_jit, jit_int32_t length)
218{
219 assert(_jitc->function);
220 switch (length) {
221 case 0: case 1: break;
222 case 2: _jitc->function->self.aoff &= -2; break;
223 case 3: case 4: _jitc->function->self.aoff &= -4; break;
224 default: _jitc->function->self.aoff &= -8; break;
225 }
226 _jitc->function->self.aoff -= length;
227 if (!_jitc->realize) {
228 jit_inc_synth_ww(allocai, _jitc->function->self.aoff, length);
229 jit_dec_synth();
230 }
231 return (BIAS(_jitc->function->self.aoff));
232}
233
234void
235_jit_allocar(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
236{
237 jit_int32_t reg;
238 assert(_jitc->function);
239 jit_inc_synth_ww(allocar, u, v);
240 if (!_jitc->function->allocar) {
241 _jitc->function->aoffoff = jit_allocai(sizeof(jit_int32_t));
242 _jitc->function->allocar = 1;
243 }
244 reg = jit_get_reg(jit_class_gpr);
245 jit_negr(reg, v);
246 jit_andi(reg, reg, -16);
247 jit_ldxi_i(u, JIT_FP, _jitc->function->aoffoff);
248 jit_addr(u, u, reg);
249 jit_addr(_SP, _SP, reg);
250 jit_stxi_i(_jitc->function->aoffoff, JIT_FP, u);
251 jit_unget_reg(reg);
252 jit_dec_synth();
253}
254
255void
256_jit_ret(jit_state_t *_jit)
257{
258 jit_node_t *instr;
259 assert(_jitc->function);
260 jit_inc_synth(ret);
261 /* jump to epilog */
262 instr = jit_jmpi();
263 jit_patch_at(instr, _jitc->function->epilog);
264 jit_dec_synth();
265}
266
267void
268_jit_retr(jit_state_t *_jit, jit_int32_t u)
269{
270 jit_inc_synth_w(retr, u);
271 if (JIT_RET != u)
272 jit_movr(JIT_RET, u);
273 jit_live(JIT_RET);
274 jit_ret();
275 jit_dec_synth();
276}
277
278void
279_jit_reti(jit_state_t *_jit, jit_word_t u)
280{
281 jit_inc_synth_w(reti, u);
282 jit_movi(JIT_RET, u);
283 jit_ret();
284 jit_dec_synth();
285}
286
287void
288_jit_retr_f(jit_state_t *_jit, jit_int32_t u)
289{
290 jit_inc_synth_w(retr_f, u);
291 if (JIT_FRET != u)
292 jit_movr_f(JIT_FRET, u);
293 else
294 jit_live(JIT_FRET);
295 jit_ret();
296 jit_dec_synth();
297}
298
299void
300_jit_reti_f(jit_state_t *_jit, jit_float32_t u)
301{
302 jit_inc_synth_f(reti_f, u);
303 jit_movi_f(JIT_FRET, u);
304 jit_ret();
305 jit_dec_synth();
306}
307
308void
309_jit_retr_d(jit_state_t *_jit, jit_int32_t u)
310{
311 jit_inc_synth_w(retr_d, u);
312 if (JIT_FRET != u)
313 jit_movr_d(JIT_FRET, u);
314 else
315 jit_live(JIT_FRET);
316 jit_ret();
317 jit_dec_synth();
318}
319
320void
321_jit_reti_d(jit_state_t *_jit, jit_float64_t u)
322{
323 jit_inc_synth_d(reti_d, u);
324 jit_movi_d(JIT_FRET, u);
325 jit_ret();
326 jit_dec_synth();
327}
328
329void
330_jit_epilog(jit_state_t *_jit)
331{
332 assert(_jitc->function);
333 assert(_jitc->function->epilog->next == NULL);
334 jit_link(_jitc->function->epilog);
335 _jitc->function = NULL;
336}
337
338jit_bool_t
339_jit_arg_register_p(jit_state_t *_jit, jit_node_t *u)
340{
341# if __WORDSIZE == 32
342 if (u->code == jit_code_arg || u->code == jit_code_arg_f)
343 return (jit_arg_reg_p(u->u.w));
344 assert(u->code == jit_code_arg_d);
345 return (jit_arg_d_reg_p(u->u.w));
346# else
347 if (u->code == jit_code_arg)
348 return (jit_arg_reg_p(u->u.w));
349 assert(u->code == jit_code_arg_d || u->code == jit_code_arg_f);
350 return (jit_arg_d_reg_p(u->u.w));
351# endif
352}
353
354void
355_jit_ellipsis(jit_state_t *_jit)
356{
357 jit_inc_synth(ellipsis);
358 if (_jitc->prepare) {
359 jit_link_prepare();
360 assert(!(_jitc->function->call.call & jit_call_varargs));
361 _jitc->function->call.call |= jit_call_varargs;
362 }
363 else {
364 jit_link_prolog();
365 assert(!(_jitc->function->self.call & jit_call_varargs));
366 _jitc->function->self.call |= jit_call_varargs;
367
368 _jitc->function->vagp = _jitc->function->self.argi;
369 }
370 jit_dec_synth();
371}
372
373void
374_jit_va_push(jit_state_t *_jit, jit_int32_t u)
375{
376 jit_inc_synth_w(va_push, u);
377 jit_pushargr(u);
378 jit_dec_synth();
379}
380
381jit_node_t *
382_jit_arg(jit_state_t *_jit)
383{
384 jit_node_t *node;
385 jit_int32_t offset;
386 assert(_jitc->function);
387 if (jit_arg_reg_p(_jitc->function->self.argi))
388 offset = _jitc->function->self.argi++;
389 else {
390# if __WORDSIZE == 64
391 if (jit_arg_d_reg_p(_jitc->function->self.argi))
392 ++_jitc->function->self.argi;
393# endif
394 offset = BIAS(_jitc->function->self.size);
395 _jitc->function->self.size += sizeof(jit_word_t);
396 }
397 node = jit_new_node_ww(jit_code_arg, offset,
398 ++_jitc->function->self.argn);
399 jit_link_prolog();
400 return (node);
401}
402
403jit_node_t *
404_jit_arg_f(jit_state_t *_jit)
405{
406 jit_node_t *node;
407 jit_int32_t offset;
408# if __WORDSIZE == 64
409 jit_bool_t inc;
410# endif
411 assert(_jitc->function);
412# if __WORDSIZE == 32
413 if (jit_arg_reg_p(_jitc->function->self.argi))
414 offset = _jitc->function->self.argi++;
415 else {
416 offset = _jitc->function->self.size;
417 _jitc->function->self.size += sizeof(jit_word_t);
418 }
419# else
420 inc = !jit_arg_reg_p(_jitc->function->self.argi);
421 if (jit_arg_d_reg_p(_jitc->function->self.argi))
422 offset = _jitc->function->self.argi++;
423 else
424 offset = BIAS(_jitc->function->self.size);
425 if (inc)
426 _jitc->function->self.size += sizeof(jit_word_t);
427# endif
428 node = jit_new_node_ww(jit_code_arg_f, offset,
429 ++_jitc->function->self.argn);
430 jit_link_prolog();
431 return (node);
432}
433
434jit_node_t *
435_jit_arg_d(jit_state_t *_jit)
436{
437 jit_node_t *node;
438 jit_int32_t offset;
439# if __WORDSIZE == 64
440 jit_bool_t inc;
441# endif
442 assert(_jitc->function);
443# if __WORDSIZE == 32
444 if (jit_arg_d_reg_p(_jitc->function->self.argi)) {
445 offset = _jitc->function->self.argi;
446 _jitc->function->self.argi += 2;
447 }
448 else if (jit_arg_reg_p(_jitc->function->self.argi)) {
449 offset = _jitc->function->self.argi++;
450 _jitc->function->self.size += sizeof(jit_float32_t);
451 }
452 else {
453 offset = _jitc->function->self.size;
454 _jitc->function->self.size += sizeof(jit_float64_t);
455 }
456# else
457 inc = !jit_arg_reg_p(_jitc->function->self.argi);
458 if (jit_arg_d_reg_p(_jitc->function->self.argi))
459 offset = _jitc->function->self.argi++;
460 else
461 offset = BIAS(_jitc->function->self.size);
462 if (inc)
463 _jitc->function->self.size += sizeof(jit_word_t);
464# endif
465 node = jit_new_node_ww(jit_code_arg_d, offset,
466 ++_jitc->function->self.argn);
467 jit_link_prolog();
468 return (node);
469}
470
471void
472_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
473{
474 assert(v->code == jit_code_arg);
475 jit_inc_synth_wp(getarg_c, u, v);
476 if (jit_arg_reg_p(v->u.w))
477 jit_extr_c(u, _I0 + v->u.w);
478 else
479 jit_ldxi_c(u, JIT_FP,
480 v->u.w + (__WORDSIZE >> 3) - sizeof(jit_int8_t));
481 jit_dec_synth();
482}
483
484void
485_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
486{
487 assert(v->code == jit_code_arg);
488 jit_inc_synth_wp(getarg_uc, u, v);
489 if (jit_arg_reg_p(v->u.w))
490 jit_extr_uc(u, _I0 + v->u.w);
491 else
492 jit_ldxi_uc(u, JIT_FP,
493 v->u.w + (__WORDSIZE >> 3) - sizeof(jit_uint8_t));
494 jit_dec_synth();
495}
496
497void
498_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
499{
500 assert(v->code == jit_code_arg);
501 jit_inc_synth_wp(getarg_s, u, v);
502 if (jit_arg_reg_p(v->u.w))
503 jit_extr_s(u, _I0 + v->u.w);
504 else
505 jit_ldxi_s(u, JIT_FP,
506 v->u.w + (__WORDSIZE >> 3) - sizeof(jit_int16_t));
507 jit_dec_synth();
508}
509
510void
511_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
512{
513 assert(v->code == jit_code_arg);
514 jit_inc_synth_wp(getarg_us, u, v);
515 if (jit_arg_reg_p(v->u.w))
516 jit_extr_us(u, _I0 + v->u.w);
517 else
518 jit_ldxi_us(u, JIT_FP,
519 v->u.w + (__WORDSIZE >> 3) - sizeof(jit_uint16_t));
520 jit_dec_synth();
521}
522
523void
524_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
525{
526 assert(v->code == jit_code_arg);
527 jit_inc_synth_wp(getarg_i, u, v);
528 if (jit_arg_reg_p(v->u.w)) {
529# if __WORDSIZE == 64
530 jit_extr_i(u, _I0 + v->u.w);
531# else
532 jit_movr(u, _I0 + v->u.w);
533# endif
534 }
535 else
536 jit_ldxi_i(u, JIT_FP,
537 v->u.w + (__WORDSIZE >> 3) - sizeof(jit_int32_t));
538 jit_dec_synth();
539}
540
541# if __WORDSIZE == 64
542void
543_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
544{
545 assert(v->code == jit_code_arg);
546 jit_inc_synth_wp(getarg_i, u, v);
547 if (jit_arg_reg_p(v->u.w))
548 jit_extr_ui(u, _I0 + v->u.w);
549 else
550 jit_ldxi_ui(u, JIT_FP,
551 v->u.w + (__WORDSIZE >> 3) - sizeof(jit_int32_t));
552 jit_dec_synth();
553}
554
555void
556_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
557{
558 assert(v->code == jit_code_arg);
559 jit_inc_synth_wp(getarg_i, u, v);
560 if (jit_arg_reg_p(v->u.w))
561 jit_movr(u, _I0 + v->u.w);
562 else
563 jit_ldxi_l(u, JIT_FP, v->u.w);
564 jit_dec_synth();
565}
566# endif
567
568void
569_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
570{
571 assert(v->code == jit_code_arg);
572 jit_inc_synth_wp(putargr, u, v);
573 if (jit_arg_reg_p(v->u.w))
574 jit_movr(_I0 + v->u.w, u);
575 else
576 jit_stxi(v->u.w, JIT_FP, u);
577 jit_dec_synth();
578}
579
580void
581_jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
582{
583 jit_int32_t regno;
584 assert(v->code == jit_code_arg);
585 jit_inc_synth_wp(putargi, u, v);
586 if (jit_arg_reg_p(v->u.w))
587 jit_movi(_I0 + v->u.w, u);
588 else {
589 regno = jit_get_reg(jit_class_gpr);
590 jit_movi(regno, u);
591 jit_stxi(v->u.w, JIT_FP, regno);
592 jit_unget_reg(regno);
593 }
594 jit_dec_synth();
595}
596
597void
598_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
599{
600 assert(v->code == jit_code_arg_f);
601 assert(_jitc->function);
602 jit_inc_synth_wp(getarg_f, u, v);
603# if __WORDSIZE == 32
604 if (jit_arg_reg_p(v->u.w)) {
605 jit_stxi_i(-4, JIT_FP, _I0 + v->u.w);
606 jit_ldxi_f(u, JIT_FP, -4);
607 }
608# else
609 if (jit_arg_d_reg_p(v->u.w)) {
610 jit_live(_F0 - (v->u.w << 1)); /* pair of registers is live */
611 jit_movr_f(u, (_F0 - (v->u.w << 1)) - 1);
612 }
613# endif
614 else
615 jit_ldxi_f(u, JIT_FP, v->u.w + (__WORDSIZE >> 3) -
616 sizeof(jit_float32_t));
617 jit_dec_synth();
618}
619
620void
621_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
622{
623 assert(v->code == jit_code_arg_f);
624 jit_inc_synth_wp(putargr_f, u, v);
625# if __WORDSIZE == 32
626 if (jit_arg_reg_p(v->u.w)) {
627 jit_stxi_f(-4, JIT_FP, u);
628 jit_ldxi_i(_I0 + v->u.w, JIT_FP, -4);
629 }
630# else
631 if (jit_arg_d_reg_p(v->u.w)) {
632 jit_live(_F0 - (v->u.w << 1)); /* pair of registers is live */
633 jit_movr_f((_F0 - (v->u.w << 1)) - 1, u);
634 }
635# endif
636 else
637 jit_stxi_f(v->u.w + (__WORDSIZE >> 3) -
638 sizeof(jit_float32_t), JIT_FP, u);
639 jit_dec_synth();
640}
641
642void
643_jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
644{
645 jit_int32_t regno;
646 assert(v->code == jit_code_arg_f);
647 jit_inc_synth_fp(putargi_f, u, v);
648# if __WORDSIZE == 32
649 regno = jit_get_reg(jit_class_fpr);
650 jit_movi_f(regno, u);
651 if (jit_arg_reg_p(v->u.w)) {
652 jit_stxi_f(-4, JIT_FP, regno);
653 jit_ldxi_i(_I0 + v->u.w, JIT_FP, -4);
654 }
655 else
656 jit_stxi_f(v->u.w, JIT_FP, regno);
657 jit_unget_reg(regno);
658# else
659 if (jit_arg_d_reg_p(v->u.w)) {
660 jit_live(_F0 - (v->u.w << 1)); /* pair of registers is live */
661 jit_movi_f((_F0 - (v->u.w << 1)) - 1, u);
662 }
663 else {
664 regno = jit_get_reg(jit_class_fpr | jit_class_sng);
665 jit_movi_f(regno, u);
666 jit_stxi_f(v->u.w + (__WORDSIZE >> 3) -
667 sizeof(jit_float32_t), JIT_FP, regno);
668 jit_unget_reg(regno);
669 }
670# endif
671 jit_dec_synth();
672}
673
674void
675_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
676{
677 assert(v->code == jit_code_arg_d);
678 assert(_jitc->function);
679 jit_inc_synth_wp(getarg_d, u, v);
680 if (jit_arg_d_reg_p(v->u.w)) {
681# if __WORDSIZE == 32
682 jit_stxi(-8, JIT_FP, _I0 + v->u.w);
683 jit_stxi(-4, JIT_FP, _I0 + v->u.w + 1);
684 jit_ldxi_d(u, JIT_FP, -8);
685# else
686 jit_movr_d(u, _F0 - (v->u.w << 1));
687# endif
688 }
689# if __WORDSIZE == 32
690 else if (jit_arg_reg_p(v->u.w)) {
691 jit_stxi(-8, JIT_FP, _I0 + v->u.w);
692 jit_ldxi_f(u, JIT_FP, -8);
693 jit_ldxi_f(u + 1, JIT_FP, stack_framesize);
694 }
695# endif
696 else {
697# if __WORDSIZE == 32
698 jit_ldxi_f(u, JIT_FP, v->u.w);
699 jit_ldxi_f(u + 1, JIT_FP, v->u.w + 4);
700# else
701 jit_ldxi_d(u, JIT_FP, v->u.w);
702# endif
703 }
704 jit_dec_synth();
705}
706
707void
708_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
709{
710 jit_int32_t regno;
711 assert(v->code == jit_code_arg_d);
712 jit_inc_synth_wp(putargr_d, u, v);
713# if __WORDSIZE == 32
714 if (jit_arg_d_reg_p(v->u.w)) {
715 jit_stxi_d(-8, JIT_FP, u);
716 jit_ldxi(_I0 + v->u.w, JIT_FP, -8);
717 jit_ldxi(_I0 + v->u.w + 1, JIT_FP, -4);
718 }
719 else if (jit_arg_reg_p(v->u.w)) {
720 regno = jit_get_reg(jit_class_gpr);
721 jit_stxi_d(-8, JIT_FP, u);
722 jit_ldxi(_I0 + v->u.w, JIT_FP, -8);
723 jit_ldxi(regno, JIT_FP, -4);
724 jit_stxi(stack_framesize, JIT_FP, regno);
725 jit_unget_reg(regno);
726 }
727 else if ((v->u.w & 7) == 0)
728 jit_stxi_d(v->u.w, JIT_FP, u);
729 else {
730 jit_stxi_d(-8, JIT_FP, u);
731 regno = jit_get_reg(jit_class_gpr);
732 jit_ldxi(regno, JIT_FP, -8);
733 jit_stxi(v->u.w, JIT_FP, regno);
734 jit_ldxi(regno, JIT_FP, -4);
735 jit_stxi(v->u.w + 4, JIT_FP, regno);
736 jit_unget_reg(regno);
737 }
738# else
739 if (jit_arg_d_reg_p(v->u.w))
740 jit_movr_d(_F0 - (v->u.w << 1), u);
741 else
742 jit_stxi_d(v->u.w, JIT_FP, u);
743# endif
744 jit_dec_synth();
745}
746
747void
748_jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
749{
750# if __WORDSIZE == 32
751 jit_int32_t gpr;
752# endif
753 jit_int32_t regno;
754 assert(v->code == jit_code_arg_d);
755 jit_inc_synth_dp(putargi_d, u, v);
756# if __WORDSIZE == 32
757 regno = jit_get_reg(jit_class_fpr);
758 jit_movi_d(regno, u);
759 if (jit_arg_d_reg_p(v->u.w)) {
760 jit_stxi_d(-8, JIT_FP, regno);
761 jit_ldxi(_I0 + v->u.w, JIT_FP, -8);
762 jit_ldxi(_I0 + v->u.w + 1, JIT_FP, -4);
763 }
764 else if (jit_arg_reg_p(v->u.w)) {
765 gpr = jit_get_reg(jit_class_gpr);
766 jit_stxi_d(-8, JIT_FP, regno);
767 jit_ldxi(_I0 + v->u.w, JIT_FP, -8);
768 jit_ldxi(gpr, JIT_FP, -4);
769 jit_stxi(stack_framesize, JIT_FP, gpr);
770 jit_unget_reg(gpr);
771 }
772 else if ((v->u.w & 7) == 0)
773 jit_stxi_d(v->u.w, JIT_FP, regno);
774 else {
775 jit_stxi_d(-8, JIT_FP, regno);
776 gpr = jit_get_reg(jit_class_gpr);
777 jit_ldxi(gpr, JIT_FP, -8);
778 jit_stxi(v->u.w, JIT_FP, gpr);
779 jit_ldxi(gpr, JIT_FP, -4);
780 jit_stxi(v->u.w + 4, JIT_FP, gpr);
781 jit_unget_reg(gpr);
782 }
783 jit_unget_reg(regno);
784# else
785 if (jit_arg_d_reg_p(v->u.w))
786 jit_movi_d(_F0 - (v->u.w << 1), u);
787 else {
788 regno = jit_get_reg(jit_class_fpr | jit_class_dbl);
789 jit_movi_d(regno, u);
790 jit_stxi_d(v->u.w, JIT_FP, regno);
791 jit_unget_reg(regno);
792 }
793# endif
794 jit_dec_synth();
795}
796
797void
798_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
799{
800 jit_inc_synth_w(pushargr, u);
801 jit_link_prepare();
802 if (jit_arg_reg_p(_jitc->function->call.argi)) {
803 jit_movr(_O0 + _jitc->function->call.argi, u);
804 ++_jitc->function->call.argi;
805 }
806 else {
807# if __WORDSIZE == 64
808 if (jit_arg_d_reg_p(_jitc->function->call.argi))
809 ++_jitc->function->call.argi;
810# endif
811 jit_stxi(BIAS(_jitc->function->call.size + stack_framesize),
812 JIT_SP, u);
813 _jitc->function->call.size += sizeof(jit_word_t);
814 }
815 jit_dec_synth();
816}
817
818void
819_jit_pushargi(jit_state_t *_jit, jit_word_t u)
820{
821 jit_int32_t regno;
822 jit_inc_synth_w(pushargi, u);
823 jit_link_prepare();
824 if (jit_arg_reg_p(_jitc->function->call.argi)) {
825 jit_movi(_O0 + _jitc->function->call.argi, u);
826 ++_jitc->function->call.argi;
827 }
828 else {
829# if __WORDSIZE == 64
830 if (jit_arg_d_reg_p(_jitc->function->call.argi))
831 ++_jitc->function->call.argi;
832# endif
833 regno = jit_get_reg(jit_class_gpr);
834 jit_movi(regno, u);
835 jit_stxi(BIAS(_jitc->function->call.size + stack_framesize),
836 JIT_SP, regno);
837 jit_unget_reg(regno);
838 _jitc->function->call.size += sizeof(jit_word_t);
839 }
840 jit_dec_synth();
841}
842
843void
844_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
845{
846 jit_inc_synth_w(pushargr_f, u);
847 jit_link_prepare();
848# if __WORDSIZE == 32
849 if (jit_arg_reg_p(_jitc->function->call.argi)) {
850 jit_stxi_f(-8, JIT_FP, u);
851 jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, -8);
852 ++_jitc->function->call.argi;
853 }
854 else {
855 jit_stxi_f(_jitc->function->call.size + stack_framesize,
856 JIT_SP, u);
857 _jitc->function->call.size += sizeof(jit_float32_t);
858 }
859# else
860 if ((_jitc->function->call.call & jit_call_varargs) &&
861 jit_arg_reg_p(_jitc->function->call.argi)) {
862 jit_stxi_f(BIAS(-8), JIT_FP, u);
863 jit_ldxi_i(_O0 + _jitc->function->call.argi, JIT_FP, BIAS(-8));
864 ++_jitc->function->call.argi;
865 }
866 else if (!(_jitc->function->call.call & jit_call_varargs) &&
867 jit_arg_d_reg_p(_jitc->function->call.argi)) {
868 /* pair of registers is live */
869 jit_live(_F0 - (_jitc->function->call.argi << 1));
870 jit_movr_f((_F0 - (_jitc->function->call.argi << 1)) - 1, u);
871 if (!jit_arg_reg_p(_jitc->function->call.argi))
872 _jitc->function->call.size += sizeof(jit_float64_t);
873 ++_jitc->function->call.argi;
874 }
875 else {
876 jit_stxi_f(BIAS(_jitc->function->call.size + stack_framesize + 4),
877 JIT_SP, u);
878 _jitc->function->call.size += sizeof(jit_float64_t);
879 }
880# endif
881 jit_dec_synth();
882}
883
884void
885_jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
886{
887 jit_int32_t regno;
888 jit_inc_synth_f(pushargi_f, u);
889 jit_link_prepare();
890# if __WORDSIZE == 32
891 regno = jit_get_reg(jit_class_fpr);
892 jit_movi_f(regno, u);
893 if (jit_arg_reg_p(_jitc->function->call.argi)) {
894 jit_stxi_f(-8, JIT_FP, regno);
895 jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, -8);
896 _jitc->function->call.argi++;
897 }
898 else {
899 jit_stxi_f(_jitc->function->call.size + stack_framesize,
900 JIT_SP, regno);
901 _jitc->function->call.size += sizeof(jit_float32_t);
902 }
903 jit_unget_reg(regno);
904# else
905 if ((_jitc->function->call.call & jit_call_varargs) &&
906 jit_arg_reg_p(_jitc->function->call.argi)) {
907 regno = jit_get_reg(jit_class_fpr | jit_class_sng);
908 jit_movi_f(regno, u);
909 jit_stxi_f(BIAS(-8), JIT_FP, regno);
910 jit_ldxi_i(_O0 + _jitc->function->call.argi, JIT_FP, BIAS(-8));
911 ++_jitc->function->call.argi;
912 jit_unget_reg(regno);
913 }
914 else if (!(_jitc->function->call.call & jit_call_varargs) &&
915 jit_arg_d_reg_p(_jitc->function->call.argi)) {
916 /* pair of registers is live */
917 jit_live(_F0 - (_jitc->function->call.argi << 1));
918 jit_movi_f((_F0 - (_jitc->function->call.argi << 1)) - 1, u);
919 if (!jit_arg_reg_p(_jitc->function->call.argi))
920 _jitc->function->call.size += sizeof(jit_float64_t);
921 ++_jitc->function->call.argi;
922 }
923 else {
924 regno = jit_get_reg(jit_class_fpr | jit_class_sng);
925 jit_movi_f(regno, u);
926 jit_stxi_f(BIAS(_jitc->function->call.size + stack_framesize + 4),
927 JIT_SP, regno);
928 jit_unget_reg(regno);
929 _jitc->function->call.size += sizeof(jit_float64_t);
930 }
931# endif
932 jit_dec_synth();
933}
934
935void
936_jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
937{
938 jit_inc_synth_w(pushargr_d, u);
939 jit_link_prepare();
940# if __WORDSIZE == 32
941 if (jit_arg_d_reg_p(_jitc->function->call.argi)) {
942 jit_stxi_d(BIAS(-8), JIT_FP, u);
943 jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, BIAS(-8));
944 jit_ldxi(_O0 + _jitc->function->call.argi + 1, JIT_FP, -4);
945 _jitc->function->call.argi += 2;
946 }
947 else if (jit_arg_reg_p(_jitc->function->call.argi)) {
948 jit_stxi_f(-8, JIT_FP, u);
949 jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, -8);
950 ++_jitc->function->call.argi;
951 jit_stxi_f(stack_framesize, JIT_SP, u + 1);
952 _jitc->function->call.size += sizeof(jit_float32_t);
953 }
954 else {
955 jit_stxi_f(_jitc->function->call.size + stack_framesize,
956 JIT_SP, u);
957 jit_stxi_f(_jitc->function->call.size + stack_framesize + 4,
958 JIT_SP, u + 1);
959 _jitc->function->call.size += sizeof(jit_float64_t);
960 }
961# else
962 if ((_jitc->function->call.call & jit_call_varargs) &&
963 jit_arg_reg_p(_jitc->function->call.argi)) {
964 jit_stxi_d(BIAS(-8), JIT_FP, u);
965 jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, BIAS(-8));
966 ++_jitc->function->call.argi;
967 }
968 else if (!(_jitc->function->call.call & jit_call_varargs) &&
969 jit_arg_d_reg_p(_jitc->function->call.argi)) {
970 jit_movr_d(_F0 - (_jitc->function->call.argi << 1), u);
971 if (!jit_arg_reg_p(_jitc->function->call.argi))
972 _jitc->function->call.size += sizeof(jit_float64_t);
973 ++_jitc->function->call.argi;
974 }
975 else {
976 jit_stxi_d(BIAS(_jitc->function->call.size + stack_framesize),
977 JIT_SP, u);
978 _jitc->function->call.size += sizeof(jit_float64_t);
979 }
980# endif
981 jit_dec_synth();
982}
983
984void
985_jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
986{
987 jit_int32_t regno;
988 jit_inc_synth_d(pushargi_d, u);
989 jit_link_prepare();
990# if __WORDSIZE == 32
991 regno = jit_get_reg(jit_class_fpr);
992 jit_movi_d(regno, u);
993 if (jit_arg_d_reg_p(_jitc->function->call.argi)) {
994 jit_stxi_d(BIAS(-8), JIT_FP, regno);
995 jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, BIAS(-8));
996 jit_ldxi(_O0 + _jitc->function->call.argi + 1, JIT_FP, -4);
997 _jitc->function->call.argi += 2;
998 }
999 else if (jit_arg_reg_p(_jitc->function->call.argi)) {
1000 jit_stxi_f(-8, JIT_FP, regno);
1001 jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, -8);
1002 ++_jitc->function->call.argi;
1003 jit_stxi_f(stack_framesize, JIT_SP, u + 1);
1004 _jitc->function->call.size += sizeof(jit_float32_t);
1005 }
1006 else {
1007 jit_stxi_f(_jitc->function->call.size + stack_framesize,
1008 JIT_SP, regno);
1009 jit_stxi_f(_jitc->function->call.size + stack_framesize + 4,
1010 JIT_SP, regno + 1);
1011 _jitc->function->call.size += sizeof(jit_float64_t);
1012 }
1013 jit_unget_reg(regno);
1014# else
1015 if ((_jitc->function->call.call & jit_call_varargs) &&
1016 jit_arg_reg_p(_jitc->function->call.argi)) {
1017 regno = jit_get_reg(jit_class_fpr | jit_class_dbl);
1018 jit_movi_d(regno, u);
1019 jit_stxi_d(BIAS(-8), JIT_FP, regno);
1020 jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, BIAS(-8));
1021 ++_jitc->function->call.argi;
1022 jit_unget_reg(regno);
1023 }
1024 else if (!(_jitc->function->call.call & jit_call_varargs) &&
1025 jit_arg_d_reg_p(_jitc->function->call.argi)) {
1026 jit_movi_d(_F0 - (_jitc->function->call.argi << 1), u);
1027 if (!jit_arg_reg_p(_jitc->function->call.argi))
1028 _jitc->function->call.size += sizeof(jit_float64_t);
1029 ++_jitc->function->call.argi;
1030 }
1031 else {
1032 regno = jit_get_reg(jit_class_fpr | jit_class_dbl);
1033 jit_movi_d(regno, u);
1034 jit_stxi_d(BIAS(_jitc->function->call.size + stack_framesize),
1035 JIT_SP, regno);
1036 jit_unget_reg(regno);
1037 _jitc->function->call.size += sizeof(jit_float64_t);
1038 }
1039# endif
1040 jit_dec_synth();
1041}
1042
1043jit_bool_t
1044_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno)
1045{
1046 jit_int32_t spec;
1047
1048 spec = jit_class(_rvs[regno].spec);
1049 if ((spec & (jit_class_arg|jit_class_gpr)) ==
1050 (jit_class_arg|jit_class_gpr)) {
1051 regno -= _O0;
1052 if (regno >= 0 && regno < node->v.w)
1053 return (1);
1054 }
1055# if __WORDSIZE == 64
1056 if ((spec & (jit_class_arg|jit_class_fpr)) ==
1057 (jit_class_arg|jit_class_fpr)) {
1058 regno = _F0 - (regno >> 1);
1059 if (regno >= 0 && regno < node->v.w)
1060 return (1);
1061 }
1062# endif
1063
1064 return (0);
1065}
1066
1067void
1068_jit_finishr(jit_state_t *_jit, jit_int32_t r0)
1069{
1070 jit_node_t *call;
1071 assert(_jitc->function);
1072 jit_inc_synth_w(finishr, r0);
1073 if (_jitc->function->self.alen < _jitc->function->call.size)
1074 _jitc->function->self.alen = _jitc->function->call.size;
1075 call = jit_callr(r0);
1076 call->v.w = _jitc->function->self.argi;
1077 call->w.w = _jitc->function->self.argf;
1078 _jitc->function->call.argi = _jitc->function->call.argf =
1079 _jitc->function->call.size = 0;
1080 _jitc->prepare = 0;
1081 jit_dec_synth();
1082}
1083
1084jit_node_t *
1085_jit_finishi(jit_state_t *_jit, jit_pointer_t i0)
1086{
1087 jit_node_t *node;
1088 assert(_jitc->function);
1089 jit_inc_synth_w(finishi, (jit_word_t)i0);
1090 if (_jitc->function->self.alen < _jitc->function->call.size)
1091 _jitc->function->self.alen = _jitc->function->call.size;
1092 node = jit_calli(i0);
1093 node->v.w = _jitc->function->call.argi;
1094 node->w.w = _jitc->function->call.argf;
1095 _jitc->function->call.argi = _jitc->function->call.argf =
1096 _jitc->function->call.size = 0;
1097 _jitc->prepare = 0;
1098 jit_dec_synth();
1099 return (node);
1100}
1101
1102void
1103_jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
1104{
1105 jit_inc_synth_w(retval_c, r0);
1106 jit_extr_c(r0, _O0);
1107 jit_dec_synth();
1108}
1109
1110void
1111_jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
1112{
1113 jit_inc_synth_w(retval_uc, r0);
1114 jit_extr_uc(r0, _O0);
1115 jit_dec_synth();
1116}
1117
1118void
1119_jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
1120{
1121 jit_inc_synth_w(retval_s, r0);
1122 jit_extr_s(r0, _O0);
1123 jit_dec_synth();
1124}
1125
1126void
1127_jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
1128{
1129 jit_inc_synth_w(retval_us, r0);
1130 jit_extr_us(r0, _O0);
1131 jit_dec_synth();
1132}
1133
1134void
1135_jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
1136{
1137 jit_inc_synth_w(retval_i, r0);
1138# if __WORDSIZE == 32
1139 if (r0 != _O0)
1140 jit_movr(r0, _O0);
1141# else
1142 jit_extr_i(r0, _O0);
1143# endif
1144 jit_dec_synth();
1145}
1146
1147# if __WORDSIZE == 64
1148void
1149_jit_retval_ui(jit_state_t *_jit, jit_int32_t r0)
1150{
1151 jit_inc_synth_w(retval_i, r0);
1152 if (r0 != _O0)
1153 jit_extr_ui(r0, _O0);
1154 jit_dec_synth();
1155}
1156
1157void
1158_jit_retval_l(jit_state_t *_jit, jit_int32_t r0)
1159{
1160 jit_inc_synth_w(retval_i, r0);
1161 if (r0 != _O0)
1162 jit_movr(r0, _O0);
1163 jit_dec_synth();
1164}
1165# endif
1166
1167void
1168_jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
1169{
1170 jit_inc_synth_w(retval_f, r0);
1171 if (r0 != JIT_FRET)
1172 jit_movr_f(r0, JIT_FRET);
1173 jit_dec_synth();
1174}
1175
1176void
1177_jit_retval_d(jit_state_t *_jit, jit_int32_t r0)
1178{
1179 jit_inc_synth_w(retval_d, r0);
1180 if (r0 != JIT_FRET)
1181 jit_movr_d(r0, JIT_FRET);
1182 jit_dec_synth();
1183}
1184
1185jit_pointer_t
1186_emit_code(jit_state_t *_jit)
1187{
1188 jit_node_t *node;
1189 jit_node_t *temp;
1190 jit_word_t word;
1191 jit_int32_t value;
1192 jit_int32_t offset;
1193 struct {
1194 jit_node_t *node;
1195 jit_word_t word;
1196#if DEVEL_DISASSEMBLER
1197 jit_word_t prevw;
1198#endif
1199 jit_int32_t patch_offset;
1200 } undo;
1201#if DEVEL_DISASSEMBLER
1202 jit_word_t prevw;
1203#endif
1204
1205 _jitc->function = NULL;
1206
1207 jit_reglive_setup();
1208
1209 undo.word = 0;
1210 undo.node = NULL;
1211 undo.patch_offset = 0;
1212
1213#define case_rr(name, type) \
1214 case jit_code_##name##r##type: \
1215 name##r##type(rn(node->u.w), rn(node->v.w)); \
1216 break
1217#define case_rw(name, type) \
1218 case jit_code_##name##i##type: \
1219 name##i##type(rn(node->u.w), node->v.w); \
1220 break
1221#define case_wr(name, type) \
1222 case jit_code_##name##i##type: \
1223 name##i##type(node->u.w, rn(node->v.w)); \
1224 break
1225#define case_rf(name) \
1226 case jit_code_##name##i##type: \
1227 assert(node->flag & jit_flag_data); \
1228 name##_f(rn(node->u.w), \
1229 (jit_float32_t *)node->v.n->u.w); \
1230 break
1231#define case_rd(name) \
1232 case jit_code_##name##i_d: \
1233 assert(node->flag & jit_flag_data); \
1234 name##_d(rn(node->u.w), \
1235 (jit_float64_t *)node->v.n->u.w); \
1236 break
1237#define case_rrr(name, type) \
1238 case jit_code_##name##r##type: \
1239 name##r##type(rn(node->u.w), \
1240 rn(node->v.w), rn(node->w.w)); \
1241 break
1242#define case_rrrr(name, type) \
1243 case jit_code_##name##r##type: \
1244 name##r##type(rn(node->u.q.l), rn(node->u.q.h), \
1245 rn(node->v.w), rn(node->w.w)); \
1246 break
1247#define case_rrw(name, type) \
1248 case jit_code_##name##i##type: \
1249 name##i##type(rn(node->u.w), \
1250 rn(node->v.w), node->w.w); \
1251 break
1252#define case_rrrw(name, type) \
1253 case jit_code_##name##i##type: \
1254 name##i##type(rn(node->u.q.l), rn(node->u.q.h), \
1255 rn(node->v.w), node->w.w); \
1256 break
1257#define case_rrf(name, type, size) \
1258 case jit_code_##name##i##type: \
1259 assert(node->flag & jit_flag_data); \
1260 name##i##type(rn(node->u.w), rn(node->v.w), \
1261 (jit_float##size##_t *)node->w.n->u.w); \
1262 break
1263#define case_wrr(name, type) \
1264 case jit_code_##name##i##type: \
1265 name##i##type(node->u.w, rn(node->v.w), rn(node->w.w)); \
1266 break
1267#define case_brr(name, type) \
1268 case jit_code_##name##r##type: \
1269 temp = node->u.n; \
1270 assert(temp->code == jit_code_label || \
1271 temp->code == jit_code_epilog); \
1272 if (temp->flag & jit_flag_patch) \
1273 name##r##type(temp->u.w, rn(node->v.w), \
1274 rn(node->w.w)); \
1275 else { \
1276 word = name##r##type(_jit->pc.w, \
1277 rn(node->v.w), rn(node->w.w)); \
1278 patch(word, node); \
1279 } \
1280 break
1281#define case_brw(name, type) \
1282 case jit_code_##name##i##type: \
1283 temp = node->u.n; \
1284 assert(temp->code == jit_code_label || \
1285 temp->code == jit_code_epilog); \
1286 if (temp->flag & jit_flag_patch) \
1287 name##i##type(temp->u.w, \
1288 rn(node->v.w), node->w.w); \
1289 else { \
1290 word = name##i##type(_jit->pc.w, \
1291 rn(node->v.w), node->w.w); \
1292 patch(word, node); \
1293 } \
1294 break
1295#define case_brf(name, type, size) \
1296 case jit_code_##name##i##type: \
1297 temp = node->u.n; \
1298 assert(temp->code == jit_code_label || \
1299 temp->code == jit_code_epilog); \
1300 if (temp->flag & jit_flag_patch) \
1301 name##i##type(temp->u.w, rn(node->v.w), \
1302 (jit_float##size##_t *)node->w.n->u.w); \
1303 else { \
1304 word = name##i##type(_jit->pc.w, rn(node->v.w), \
1305 (jit_float##size##_t *)node->w.n->u.w); \
1306 patch(word, node); \
1307 } \
1308 break
1309#if DEVEL_DISASSEMBLER
1310 prevw = _jit->pc.w;
1311#endif
1312 for (node = _jitc->head; node; node = node->next) {
1313 if (_jit->pc.uc >= _jitc->code.end)
1314 return (NULL);
1315
1316#if DEVEL_DISASSEMBLER
1317 node->offset = (jit_uword_t)_jit->pc.w - (jit_uword_t)prevw;
1318 prevw = _jit->pc.w;
1319#endif
1320 value = jit_classify(node->code);
1321 jit_regarg_set(node, value);
1322 switch (node->code) {
1323 case jit_code_align:
1324 assert(!(node->u.w & (node->u.w - 1)) &&
1325 node->u.w <= sizeof(jit_word_t));
1326 if (node->u.w == sizeof(jit_word_t) &&
1327 (word = _jit->pc.w & (sizeof(jit_word_t) - 1)))
1328 nop(sizeof(jit_word_t) - word);
1329 break;
1330 case jit_code_note: case jit_code_name:
1331 node->u.w = _jit->pc.w;
1332 break;
1333 case jit_code_label:
1334 if ((node->link || (node->flag & jit_flag_use)) &&
1335 (word = _jit->pc.w & (sizeof(jit_word_t) - 1)))
1336 nop(sizeof(jit_word_t) - word);
1337 /* remember label is defined */
1338 node->flag |= jit_flag_patch;
1339 node->u.w = _jit->pc.w;
1340 break;
1341 case_rrr(add,);
1342 case_rrw(add,);
1343 case_rrr(addc,);
1344 case_rrw(addc,);
1345 case_rrr(addx,);
1346 case_rrw(addx,);
1347 case_rrr(sub,);
1348 case_rrw(sub,);
1349 case_rrr(subc,);
1350 case_rrw(subc,);
1351 case_rrr(subx,);
1352 case_rrw(subx,);
1353 case_rrw(rsb,);
1354 case_rrr(mul,);
1355 case_rrw(mul,);
1356 case_rrrr(qmul,);
1357 case_rrrw(qmul,);
1358 case_rrrr(qmul, _u);
1359 case_rrrw(qmul, _u);
1360 case_rrr(div,);
1361 case_rrw(div,);
1362 case_rrr(div, _u);
1363 case_rrw(div, _u);
1364 case_rrrr(qdiv,);
1365 case_rrrw(qdiv,);
1366 case_rrrr(qdiv, _u);
1367 case_rrrw(qdiv, _u);
1368 case_rrr(rem,);
1369 case_rrw(rem,);
1370 case_rrr(rem, _u);
1371 case_rrw(rem, _u);
1372 case_rrr(and,);
1373 case_rrw(and,);
1374 case_rrr(or,);
1375 case_rrw(or,);
1376 case_rrr(xor,);
1377 case_rrw(xor,);
1378 case_rrr(lsh,);
1379 case_rrw(lsh,);
1380 case_rrr(rsh,);
1381 case_rrw(rsh,);
1382 case_rrr(rsh, _u);
1383 case_rrw(rsh, _u);
1384 case_rr(trunc, _f_i);
1385 case_rr(trunc, _d_i);
1386#if __WORDSIZE == 64
1387 case_rr(trunc, _f_l);
1388 case_rr(trunc, _d_l);
1389#endif
1390 case_rrr(lt,);
1391 case_rrw(lt,);
1392 case_rrr(lt, _u);
1393 case_rrw(lt, _u);
1394 case_rrr(le,);
1395 case_rrw(le,);
1396 case_rrr(le, _u);
1397 case_rrw(le, _u);
1398 case_rrr(eq,);
1399 case_rrw(eq,);
1400 case_rrr(ge,);
1401 case_rrw(ge,);
1402 case_rrr(ge, _u);
1403 case_rrw(ge, _u);
1404 case_rrr(gt,);
1405 case_rrw(gt,);
1406 case_rrr(gt, _u);
1407 case_rrw(gt, _u);
1408 case_rrr(ne,);
1409 case_rrw(ne,);
1410 case_rr(ld, _c);
1411 case_rw(ld, _c);
1412 case_rr(ld, _uc);
1413 case_rw(ld, _uc);
1414 case_rr(ld, _s);
1415 case_rw(ld, _s);
1416 case_rr(ld, _us);
1417 case_rw(ld, _us);
1418 case_rr(ld, _i);
1419 case_rw(ld, _i);
1420#if __WORDSIZE == 64
1421 case_rr(ld, _ui);
1422 case_rw(ld, _ui);
1423 case_rr(ld, _l);
1424 case_rw(ld, _l);
1425#endif
1426 case_rrr(ldx, _c);
1427 case_rrw(ldx, _c);
1428 case_rrr(ldx, _uc);
1429 case_rrw(ldx, _uc);
1430 case_rrr(ldx, _s);
1431 case_rrw(ldx, _s);
1432 case_rrr(ldx, _us);
1433 case_rrw(ldx, _us);
1434 case_rrr(ldx, _i);
1435 case_rrw(ldx, _i);
1436#if __WORDSIZE == 64
1437 case_rrr(ldx, _ui);
1438 case_rrw(ldx, _ui);
1439 case_rrr(ldx, _l);
1440 case_rrw(ldx, _l);
1441#endif
1442 case_rr(st, _c);
1443 case_wr(st, _c);
1444 case_rr(st, _s);
1445 case_wr(st, _s);
1446 case_rr(st, _i);
1447 case_wr(st, _i);
1448#if __WORDSIZE == 64
1449 case_rr(st, _l);
1450 case_wr(st, _l);
1451#endif
1452 case_rrr(stx, _c);
1453 case_wrr(stx, _c);
1454 case_rrr(stx, _s);
1455 case_wrr(stx, _s);
1456 case_rrr(stx, _i);
1457 case_wrr(stx, _i);
1458#if __WORDSIZE == 64
1459 case_rrr(stx, _l);
1460 case_wrr(stx, _l);
1461#endif
1462 case_rr(hton, _us);
1463 case_rr(hton, _ui);
1464#if __WORDSIZE == 64
1465 case_rr(hton, _ul);
40a44dcb
PC		 1466#endif
1467 case_rr(bswap, _us);
1468 case_rr(bswap, _ui);
1469#if __WORDSIZE == 64
1470 case_rr(bswap, _ul);
4a71579b
PC		 1471#endif
1472 case_rr(ext, _c);
1473 case_rr(ext, _uc);
1474 case_rr(ext, _s);
1475 case_rr(ext, _us);
1476#if __WORDSIZE == 64
1477 case_rr(ext, _i);
1478 case_rr(ext, _ui);
1479#endif
40a44dcb
PC		 1480 case_rrr(movn,);
1481 case_rrr(movz,);
4a71579b
PC		 1482 case_rr(mov,);
1483 case jit_code_movi:
1484 if (node->flag & jit_flag_node) {
1485 temp = node->v.n;
1486 if (temp->code == jit_code_data ||
1487 (temp->code == jit_code_label &&
1488 (temp->flag & jit_flag_patch)))
1489 movi(rn(node->u.w), temp->u.w);
1490 else {
1491 assert(temp->code == jit_code_label ||
1492 temp->code == jit_code_epilog);
1493 word = movi_p(rn(node->u.w), node->v.w);
1494 patch(word, node);
1495 }
1496 }
1497 else
1498 movi(rn(node->u.w), node->v.w);
1499 break;
1500 case_rr(neg,);
1501 case_rr(com,);
1502 case_brr(blt,);
1503 case_brw(blt,);
1504 case_brr(blt, _u);
1505 case_brw(blt, _u);
1506 case_brr(ble,);
1507 case_brw(ble,);
1508 case_brr(ble, _u);
1509 case_brw(ble, _u);
1510 case_brr(beq,);
1511 case_brw(beq,);
1512 case_brr(bge,);
1513 case_brw(bge,);
1514 case_brr(bge, _u);
1515 case_brw(bge, _u);
1516 case_brr(bgt,);
1517 case_brw(bgt,);
1518 case_brr(bgt, _u);
1519 case_brw(bgt, _u);
1520 case_brr(bne,);
1521 case_brw(bne,);
1522 case_brr(boadd,);
1523 case_brw(boadd,);
1524 case_brr(boadd, _u);
1525 case_brw(boadd, _u);
1526 case_brr(bxadd,);
1527 case_brw(bxadd,);
1528 case_brr(bxadd, _u);
1529 case_brw(bxadd, _u);
1530 case_brr(bosub,);
1531 case_brw(bosub,);
1532 case_brr(bosub, _u);
1533 case_brw(bosub, _u);
1534 case_brr(bxsub,);
1535 case_brw(bxsub,);
1536 case_brr(bxsub, _u);
1537 case_brw(bxsub, _u);
1538 case_brr(bms,);
1539 case_brw(bms,);
1540 case_brr(bmc,);
1541 case_brw(bmc,);
1542 case_rrr(add, _f);
1543 case_rrf(add, _f, 32);
1544 case_rrr(sub, _f);
1545 case_rrf(sub, _f, 32);
1546 case_rrf(rsb, _f, 32);
1547 case_rrr(mul, _f);
1548 case_rrf(mul, _f, 32);
1549 case_rrr(div, _f);
1550 case_rrf(div, _f, 32);
1551 case_rr(abs, _f);
1552 case_rr(neg, _f);
1553 case_rr(sqrt, _f);
1554 case_rr(ext, _f);
1555 case_rr(ext, _d_f);
1556 case_rrr(lt, _f);
1557 case_rrf(lt, _f, 32);
1558 case_rrr(le, _f);
1559 case_rrf(le, _f, 32);
1560 case_rrr(eq, _f);
1561 case_rrf(eq, _f, 32);
1562 case_rrr(ge, _f);
1563 case_rrf(ge, _f, 32);
1564 case_rrr(gt, _f);
1565 case_rrf(gt, _f, 32);
1566 case_rrr(ne, _f);
1567 case_rrf(ne, _f, 32);
1568 case_rrr(unlt, _f);
1569 case_rrf(unlt, _f, 32);
1570 case_rrr(unle, _f);
1571 case_rrf(unle, _f, 32);
1572 case_rrr(uneq, _f);
1573 case_rrf(uneq, _f, 32);
1574 case_rrr(unge, _f);
1575 case_rrf(unge, _f, 32);
1576 case_rrr(ungt, _f);
1577 case_rrf(ungt, _f, 32);
1578 case_rrr(ltgt, _f);
1579 case_rrf(ltgt, _f, 32);
1580 case_rrr(ord, _f);
1581 case_rrf(ord, _f, 32);
1582 case_rrr(unord, _f);
1583 case_rrf(unord, _f, 32);
1584 case_rr(ld, _f);
1585 case_rw(ld, _f);
1586 case_rrr(ldx, _f);
1587 case_rrw(ldx, _f);
1588 case_rr(st, _f);
1589 case_wr(st, _f);
1590 case_rrr(stx, _f);
1591 case_wrr(stx, _f);
1592 case_rr(mov, _f);
1593 case jit_code_movi_f:
1594 assert(node->flag & jit_flag_data);
1595 movi_f(rn(node->u.w), (jit_float32_t *)node->v.n->u.w);
1596 break;
1597 case_brr(blt, _f);
1598 case_brf(blt, _f, 32);
1599 case_brr(ble, _f);
1600 case_brf(ble, _f, 32);
1601 case_brr(beq, _f);
1602 case_brf(beq, _f, 32);
1603 case_brr(bge, _f);
1604 case_brf(bge, _f, 32);
1605 case_brr(bgt, _f);
1606 case_brf(bgt, _f, 32);
1607 case_brr(bne, _f);
1608 case_brf(bne, _f, 32);
1609 case_brr(bunlt, _f);
1610 case_brf(bunlt, _f, 32);
1611 case_brr(bunle, _f);
1612 case_brf(bunle, _f, 32);
1613 case_brr(buneq, _f);
1614 case_brf(buneq, _f, 32);
1615 case_brr(bunge, _f);
1616 case_brf(bunge, _f, 32);
1617 case_brr(bungt, _f);
1618 case_brf(bungt, _f, 32);
1619 case_brr(bltgt, _f);
1620 case_brf(bltgt, _f, 32);
1621 case_brr(bord, _f);
1622 case_brf(bord, _f, 32);
1623 case_brr(bunord, _f);
1624 case_brf(bunord, _f, 32);
1625 case_rrr(add, _d);
1626 case_rrf(add, _d, 64);
1627 case_rrr(sub, _d);
1628 case_rrf(sub, _d, 64);
1629 case_rrf(rsb, _d, 64);
1630 case_rrr(mul, _d);
1631 case_rrf(mul, _d, 64);
1632 case_rrr(div, _d);
1633 case_rrf(div, _d, 64);
1634 case_rr(abs, _d);
1635 case_rr(neg, _d);
1636 case_rr(sqrt, _d);
1637 case_rr(ext, _d);
1638 case_rr(ext, _f_d);
1639 case_rrr(lt, _d);
1640 case_rrf(lt, _d, 64);
1641 case_rrr(le, _d);
1642 case_rrf(le, _d, 64);
1643 case_rrr(eq, _d);
1644 case_rrf(eq, _d, 64);
1645 case_rrr(ge, _d);
1646 case_rrf(ge, _d, 64);
1647 case_rrr(gt, _d);
1648 case_rrf(gt, _d, 64);
1649 case_rrr(ne, _d);
1650 case_rrf(ne, _d, 64);
1651 case_rrr(unlt, _d);
1652 case_rrf(unlt, _d, 64);
1653 case_rrr(unle, _d);
1654 case_rrf(unle, _d, 64);
1655 case_rrr(uneq, _d);
1656 case_rrf(uneq, _d, 64);
1657 case_rrr(unge, _d);
1658 case_rrf(unge, _d, 64);
1659 case_rrr(ungt, _d);
1660 case_rrf(ungt, _d, 64);
1661 case_rrr(ltgt, _d);
1662 case_rrf(ltgt, _d, 64);
1663 case_rrr(ord, _d);
1664 case_rrf(ord, _d, 64);
1665 case_rrr(unord, _d);
1666 case_rrf(unord, _d, 64);
1667 case_rr(ld, _d);
1668 case_rw(ld, _d);
1669 case_rrr(ldx, _d);
1670 case_rrw(ldx, _d);
1671 case_rr(st, _d);
1672 case_wr(st, _d);
1673 case_rrr(stx, _d);
1674 case_wrr(stx, _d);
1675 case_rr(mov, _d);
1676 case jit_code_movi_d:
1677 assert(node->flag & jit_flag_data);
1678 movi_d(rn(node->u.w), (jit_float64_t *)node->v.n->u.w);
1679 break;
1680 case_brr(blt, _d);
1681 case_brf(blt, _d, 64);
1682 case_brr(ble, _d);
1683 case_brf(ble, _d, 64);
1684 case_brr(beq, _d);
1685 case_brf(beq, _d, 64);
1686 case_brr(bge, _d);
1687 case_brf(bge, _d, 64);
1688 case_brr(bgt, _d);
1689 case_brf(bgt, _d, 64);
1690 case_brr(bne, _d);
1691 case_brf(bne, _d, 64);
1692 case_brr(bunlt, _d);
1693 case_brf(bunlt, _d, 64);
1694 case_brr(bunle, _d);
1695 case_brf(bunle, _d, 64);
1696 case_brr(buneq, _d);
1697 case_brf(buneq, _d, 64);
1698 case_brr(bunge, _d);
1699 case_brf(bunge, _d, 64);
1700 case_brr(bungt, _d);
1701 case_brf(bungt, _d, 64);
1702 case_brr(bltgt, _d);
1703 case_brf(bltgt, _d, 64);
1704 case_brr(bord, _d);
1705 case_brf(bord, _d, 64);
1706 case_brr(bunord, _d);
1707 case_brf(bunord, _d, 64);
1708 case jit_code_jmpr:
1709 jmpr(rn(node->u.w));
1710 break;
1711 case jit_code_jmpi:
1712 if (node->flag & jit_flag_node) {
1713 temp = node->u.n;
1714 assert(temp->code == jit_code_label ||
1715 temp->code == jit_code_epilog);
1716 if (temp->flag & jit_flag_patch)
1717 jmpi(temp->u.w);
1718 else {
1719 word = jmpi_p(_jit->pc.w);
1720 patch(word, node);
1721 }
1722 }
1723 else
1724 jmpi(node->u.w);
1725 break;
1726 case jit_code_callr:
1727 callr(rn(node->u.w));
1728 break;
1729 case jit_code_calli:
1730 if (node->flag & jit_flag_node) {
1731 temp = node->u.n;
1732 assert(temp->code == jit_code_label ||
1733 temp->code == jit_code_epilog);
1734 word = calli_p(temp->u.w);
1735 if (!(temp->flag & jit_flag_patch))
1736 patch(word, node);
1737 }
1738 else
1739 calli(node->u.w);
1740 break;
1741 case jit_code_prolog:
1742 _jitc->function = _jitc->functions.ptr + node->w.w;
1743 undo.node = node;
1744 undo.word = _jit->pc.w;
1745#if DEVEL_DISASSEMBLER
1746 undo.prevw = prevw;
1747#endif
1748 undo.patch_offset = _jitc->patches.offset;
1749 restart_function:
1750 _jitc->again = 0;
1751 prolog(node);
1752 break;
1753 case jit_code_epilog:
1754 assert(_jitc->function == _jitc->functions.ptr + node->w.w);
1755 if (_jitc->again) {
1756 for (temp = undo.node->next;
1757 temp != node; temp = temp->next) {
1758 if (temp->code == jit_code_label ||
1759 temp->code == jit_code_epilog)
1760 temp->flag &= ~jit_flag_patch;
1761 }
1762 temp->flag &= ~jit_flag_patch;
1763 node = undo.node;
1764 _jit->pc.w = undo.word;
1765#if DEVEL_DISASSEMBLER
1766 prevw = undo.prevw;
1767#endif
1768 _jitc->patches.offset = undo.patch_offset;
1769 goto restart_function;
1770 }
1771 /* remember label is defined */
1772 node->flag |= jit_flag_patch;
1773 node->u.w = _jit->pc.w;
1774 epilog(node);
1775 _jitc->function = NULL;
1776 break;
1777 case jit_code_va_start:
1778 vastart(rn(node->u.w));
1779 break;
1780 case jit_code_va_arg:
1781 vaarg(rn(node->u.w), rn(node->v.w));
1782 break;
1783 case jit_code_va_arg_d:
1784 vaarg_d(rn(node->u.w), rn(node->v.w));
1785 break;
1786 case jit_code_live: case jit_code_ellipsis:
1787 case jit_code_va_push:
1788 case jit_code_allocai: case jit_code_allocar:
1789 case jit_code_arg:
1790 case jit_code_arg_f: case jit_code_arg_d:
1791 case jit_code_va_end:
1792 case jit_code_ret:
1793 case jit_code_retr: case jit_code_reti:
1794 case jit_code_retr_f: case jit_code_reti_f:
1795 case jit_code_retr_d: case jit_code_reti_d:
1796 case jit_code_getarg_c: case jit_code_getarg_uc:
1797 case jit_code_getarg_s: case jit_code_getarg_us:
1798 case jit_code_getarg_i:
1799#if __WORDSIZE == 64
1800 case jit_code_getarg_ui: case jit_code_getarg_l:
1801#endif
1802 case jit_code_getarg_f: case jit_code_getarg_d:
1803 case jit_code_putargr: case jit_code_putargi:
1804 case jit_code_putargr_f: case jit_code_putargi_f:
1805 case jit_code_putargr_d: case jit_code_putargi_d:
1806 case jit_code_pushargr: case jit_code_pushargi:
1807 case jit_code_pushargr_f: case jit_code_pushargi_f:
1808 case jit_code_pushargr_d: case jit_code_pushargi_d:
1809 case jit_code_retval_c: case jit_code_retval_uc:
1810 case jit_code_retval_s: case jit_code_retval_us:
1811 case jit_code_retval_i:
1812#if __WORDSIZE == 64
1813 case jit_code_retval_ui: case jit_code_retval_l:
1814#endif
1815 case jit_code_retval_f: case jit_code_retval_d:
1816 case jit_code_prepare:
1817 case jit_code_finishr: case jit_code_finishi:
1818 break;
1819 default:
1820 abort();
1821 }
1822# if __WORDSIZE == 64
1823 if (jit_carry != _NOREG) {
1824 switch (node->code) {
1825 case jit_code_note:
1826 case jit_code_addcr: case jit_code_addci:
1827 case jit_code_addxr: case jit_code_addxi:
1828 case jit_code_subcr: case jit_code_subci:
1829 case jit_code_subxr: case jit_code_subxi:
1830 break;
1831 default:
1832 jit_unget_reg(jit_carry);
1833 jit_carry = _NOREG;
1834 break;
1835 }
1836 }
1837# endif
1838 jit_regarg_clr(node, value);
1839# if __WORDSIZE == 64
1840 if (jit_regset_cmp_ui(&_jitc->regarg, 0) != 0) {
1841 assert(jit_regset_scan1(&_jitc->regarg, 0) == jit_carry);
1842 assert(jit_regset_scan1(&_jitc->regarg, jit_carry + 1) == ULONG_MAX);
1843 }
1844 assert(_jitc->synth == 0);
1845# else
1846 assert(_jitc->regarg == 0 && _jitc->synth == 0);
1847# endif
1848 jit_reglive(node);
1849 }
1850#undef case_brf
1851#undef case_brw
1852#undef case_brr
1853#undef case_wrr
1854#undef case_rrf
1855#undef case_rrrw
1856#undef case_rrw
1857#undef case_rrrr
1858#undef case_rrr
1859#undef case_rf
1860#undef case_wr
1861#undef case_rw
1862#undef case_rr
1863
1864 for (offset = 0; offset < _jitc->patches.offset; offset++) {
1865 node = _jitc->patches.ptr[offset].node;
1866 word = node->code == jit_code_movi ? node->v.n->u.w : node->u.n->u.w;
1867 patch_at(_jitc->patches.ptr[offset].inst, word);
1868 }
1869
1870 jit_flush(_jit->code.ptr, _jit->pc.uc);
1871
1872 return (_jit->code.ptr);
1873}
1874
1875#define CODE 1
1876# include "jit_sparc-cpu.c"
1877# include "jit_sparc-fpu.c"
1878#undef CODE
1879
1880void
1881jit_flush(void *fptr, void *tptr)
1882{
1883}
1884
1885void
1886_emit_ldxi(jit_state_t *_jit, jit_gpr_t r0, jit_gpr_t r1, jit_word_t i0)
1887{
1888 ldxi(rn(r0), rn(r1), i0);
1889}
1890
1891void
1892_emit_stxi(jit_state_t *_jit, jit_word_t i0, jit_gpr_t r0, jit_gpr_t r1)
1893{
1894 stxi(i0, rn(r0), rn(r1));
1895}
1896
1897void
1898_emit_ldxi_d(jit_state_t *_jit, jit_fpr_t r0, jit_gpr_t r1, jit_word_t i0)
1899{
1900 ldxi_d(rn(r0), rn(r1), i0);
1901}
1902
1903void
1904_emit_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_gpr_t r0, jit_fpr_t r1)
1905{
1906 stxi_d(i0, rn(r0), rn(r1));
1907}
1908
1909static void
1910_patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node)
1911{
1912 jit_int32_t flag;
1913
1914 assert(node->flag & jit_flag_node);
1915 if (node->code == jit_code_movi)
1916 flag = node->v.n->flag;
1917 else
1918 flag = node->u.n->flag;
1919 assert(!(flag & jit_flag_patch));
1920 if (_jitc->patches.offset >= _jitc->patches.length) {
1921 jit_realloc((jit_pointer_t *)&_jitc->patches.ptr,
1922 _jitc->patches.length * sizeof(jit_patch_t),
1923 (_jitc->patches.length + 1024) * sizeof(jit_patch_t));
1924 memset(_jitc->patches.ptr + _jitc->patches.length, 0,
1925 1024 * sizeof(jit_patch_t));
1926 _jitc->patches.length += 1024;
1927 }
1928 _jitc->patches.ptr[_jitc->patches.offset].inst = instr;
1929 _jitc->patches.ptr[_jitc->patches.offset].node = node;
1930 ++_jitc->patches.offset;
1931}
ARM optimized PCSX fork