deps/lightning/lib/jit_sparc.c

   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  */
  32 typedef jit_pointer_t   jit_va_list_t;
  33
  34 /*
  35  * Prototypes
  36  */
  37 #define patch(instr, node)              _patch(_jit, instr, node)
  38 static 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  */
  48 jit_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  */
 154 void
 155 jit_get_cpu(void)
 156 {
 157 }
 158
 159 void
 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
 168 void
 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
 216 jit_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
 234 void
 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
 255 void
 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
 267 void
 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
 278 void
 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
 287 void
 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
 299 void
 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
 308 void
 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
 320 void
 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
 329 void
 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
 338 jit_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
 354 void
 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
 373 void
 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
 381 jit_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
 403 jit_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
 434 jit_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
 471 void
 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
 484 void
 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
 497 void
 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
 510 void
 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
 523 void
 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
 542 void
 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
 555 void
 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
 568 void
 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
 580 void
 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
 597 void
 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
 620 void
 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
 642 void
 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
 674 void
 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
 707 void
 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
 747 void
 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
 797 void
 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
 818 void
 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
 843 void
 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
 884 void
 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
 935 void
 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
 984 void
 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
1043 jit_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
1067 void
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
1084 jit_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
1102 void
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
1110 void
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
1118 void
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
1126 void
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
1134 void
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
1148 void
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
1157 void
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
1167 void
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
1176 void
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
1185 jit_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);
1466 #endif
1467                 case_rr(bswap, _us);
1468                 case_rr(bswap, _ui);
1469 #if __WORDSIZE == 64
1470                 case_rr(bswap, _ul);
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
1480                 case_rrr(movn,);
1481                 case_rrr(movz,);
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
1880 void
1881 jit_flush(void *fptr, void *tptr)
1882 {
1883 }
1884
1885 void
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
1891 void
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
1897 void
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
1903 void
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
1909 static 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 }