deps/lightning/lib/jit_sparc-cpu.c

   1 /*
   2  * Copyright (C) 2013-2023  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 #if PROTO
  21 #  define _G2_REGNO                             0x02
  22 #  define _G3_REGNO                             0x03
  23 #  define _G4_REGNO                             0x04
  24 #  define _O0_REGNO                             0x08
  25 #  define _O1_REGNO                             0x09
  26 #  define _SP_REGNO                             0x0e
  27 #  define _FP_REGNO                             0x1e
  28 #  define _O7_REGNO                             0x0f
  29 #  define _L0_REGNO                             0x10
  30 #  define _L1_REGNO                             0x11
  31 #  define _L2_REGNO                             0x12
  32 #  define _L3_REGNO                             0x13
  33 #  define _L4_REGNO                             0x14
  34 #  define _L5_REGNO                             0x15
  35 #  define _L6_REGNO                             0x16
  36 #  define _L7_REGNO                             0x17
  37 #  define _I7_REGNO                             0x1f
  38 /*
  39  *                                      - previous stack frame
  40  * fp   ----
  41  * fp-  local variables (in lightning, 8 bytes space for float conversion)
  42  * fp-  alloca
  43  * sp+  stack arguments
  44  * sp+  6 words to save register arguments
  45  * sp+  1 word for hidden address of aggregate return value (32 bits only)
  46  * sp+  16 words for in and local registers
  47  * sp   ----
  48  *      decreasing memory address       - next stack frame (not yet allocated)
  49  */
  50 #  define stack_framesize                       ((16 + (__WORDSIZE == 32) + 6) * sizeof(jit_word_t))
  51 typedef union {
  52     struct {                            jit_uint32_t b: 2;      } op;
  53     struct {    jit_uint32_t _: 2;      jit_uint32_t b: 1;      } a;
  54     struct {    jit_uint32_t _: 2;      jit_uint32_t b: 5;      } rd;
  55     struct {    jit_uint32_t _: 2;      jit_uint32_t b: 30;     } disp30;
  56     struct {    jit_uint32_t _: 3;      jit_uint32_t b: 4;      } cond;
  57     struct {    jit_uint32_t _: 7;      jit_uint32_t b: 3;      } op2;
  58     struct {    jit_uint32_t _: 7;      jit_uint32_t b: 6;      } op3;
  59     struct {    jit_uint32_t _: 10;     jit_uint32_t b: 1;      } cc1;
  60     struct {    jit_uint32_t _: 10;     jit_uint32_t b: 22;     } imm22;
  61     struct {    jit_uint32_t _: 10;     jit_uint32_t b: 22;     } disp22;
  62     struct {    jit_uint32_t _: 11;     jit_uint32_t b: 1;      } cc0;
  63     struct {    jit_uint32_t _: 12;     jit_uint32_t b: 1;      } p;
  64     struct {    jit_uint32_t _: 13;     jit_uint32_t b: 19;     } disp19;
  65     struct {    jit_uint32_t _: 13;     jit_uint32_t b: 5;      } rs1;
  66     struct {    jit_uint32_t _: 18;     jit_uint32_t b: 1;      } i;
  67     struct {    jit_uint32_t _: 18;     jit_uint32_t b: 9;      } opf;
  68     struct {    jit_uint32_t _: 19;     jit_uint32_t b: 1;      } x;
  69     struct {    jit_uint32_t _: 19;     jit_uint32_t b: 8;      } asi;
  70     struct {    jit_uint32_t _: 19;     jit_uint32_t b: 6;      } res;
  71     struct {    jit_uint32_t _: 19;     jit_uint32_t b: 13;     } simm13;
  72     struct {    jit_uint32_t _: 20;     jit_uint32_t b: 7;      } asix;
  73     struct {    jit_uint32_t _: 20;     jit_uint32_t b: 6;      } asis;
  74     struct {    jit_uint32_t _: 26;     jit_uint32_t b: 6;      } shim;
  75     struct {    jit_uint32_t _: 25;     jit_uint32_t b: 7;      } imm7;
  76     struct {    jit_uint32_t _: 27;     jit_uint32_t b: 5;      } rs2;
  77     jit_int32_t                                                   v;
  78 } jit_instr_t;
  79 #  define ii(i)                         *_jit->pc.ui++ = i
  80 #  define s7_p(imm)                     ((imm) <= 63 && (imm) >= -64)
  81 #  define s13_p(imm)                    ((imm) <= 4095 && (imm) >= -4096)
  82 #  define s19_p(imm)                    ((imm) <= 262143 && (imm) >= -262144)
  83 #  define s22_p(imm)                    ((imm) <= 2097151 && (imm) >= -20971512)
  84 #  define s30_p(imm)                    ((imm) <= 536870911 && (imm) >= -536870912)
  85 #  define f1(op, disp30)                _f1(_jit, op, disp30)
  86 static void _f1(jit_state_t*,jit_int32_t,jit_int32_t);
  87 #  define f2r(op, rd, op2, imm22)       _f2r(_jit, op, rd, op2, imm22)
  88 static void _f2r(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  89 #  define f2b(op, a, cond, op2, disp22) _f2b(_jit, op, a, cond, op2, disp22)
  90 static void
  91 _f2b(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  92 #  if __WORDSIZE == 64
  93 #    define f2bp(op,a,cond,op2,cc1,cc0,p,disp19)                                \
  94         _f2bp(_jit,op,a,cond,op2,cc1,cc0,p,disp19)
  95 static void
  96 _f2bp(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
  97       jit_int32_t,jit_int32_t,jit_int32_t);
  98 #  endif
  99 #  define f3r(op, rd, op3, rs1, rs2)    _f3r(_jit, op, rd, op3, rs1, rs2)
 100 static void _f3r(jit_state_t*,
 101                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 102 #  if __WORDSIZE == 64
 103 #  define f3ri(op, rd, op3, rs1, rs2)   _f3ri(_jit, op, rd, op3, rs1, rs2)
 104 static void _f3ri(jit_state_t*,
 105                   jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 106 #  define f3rx(op, rd, op3, rs1, rs2)   _f3rx(_jit, op, rd, op3, rs1, rs2)
 107 static void _f3rx(jit_state_t*,
 108                   jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 109 #  endif
 110 #  define f3i(op, rd, op3, rs1, simm13) _f3i(_jit, op, rd, op3, rs1, simm13)
 111 static void _f3i(jit_state_t*,
 112                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 113 #  define f3s(op, rd, op3, rs1, simm13) _f3s(_jit, op, rd, op3, rs1, simm13)
 114 static void _f3s(jit_state_t*,
 115                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 116 #  define f3t(cond, rs1, i, ri)         _f3t(_jit, cond, rs1, i, ri)
 117 static void _f3t(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
 118     maybe_unused;
 119 #  define f3a(op,rd,op3,rs1,asi,rs2)    _f3a(_jit, op, rd, op3, rs1, asi, rs2)
 120 static void _f3a(jit_state_t*,jit_int32_t,
 121                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
 122     maybe_unused;
 123 #  define f2c1(op,rd,op3,rs1,opf,rs2)   _f2c1(_jit,op,rd,op3,rs1,opf,rs2)
 124 static void
 125 _f2c1(jit_state_t*,jit_int32_t, jit_int32_t,
 126       jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
 127     maybe_unused;
 128 #  define LDSB(rs1, rs2, rd)            f3r(3, rd, 9, rs1, rs2)
 129 #  define LDSBI(rs1, imm, rd)           f3i(3, rd, 9, rs1, imm)
 130 #  define LDSH(rs1, rs2, rd)            f3r(3, rd, 10, rs1, rs2)
 131 #  define LDSHI(rs1, imm, rd)           f3i(3, rd, 10, rs1, imm)
 132 #  define LDUB(rs1, rs2, rd)            f3r(3, rd, 1, rs1, rs2)
 133 #  define LDUBI(rs1, imm, rd)           f3i(3, rd, 1, rs1, imm)
 134 #  define LDUH(rs1, rs2, rd)            f3r(3, rd, 2, rs1, rs2)
 135 #  define LDUHI(rs1, imm, rd)           f3i(3, rd, 2, rs1, imm)
 136 #  if __WORDSIZE == 32
 137 #    define LD(rs1, rs2, rd)            f3r(3, rd, 0, rs1, rs2)
 138 #    define LDI(rs1, imm, rd)           f3i(3, rd, 0, rs1, imm)
 139 #    define LDD(rs1, rs2, rd)           f3r(3, rd, 3, rs1, rs2)
 140 #    define LDDI(rs1, imm, rd)          f3i(3, rd, 3, rs1, imm)
 141 #  else
 142 #    define LDSW(rs1, rs2, rd)          f3r(3, rd, 8, rs1, rs2)
 143 #    define LDSWI(rs1, imm, rd)         f3i(3, rd, 8, rs1, imm)
 144 #    define LDUW(rs1, rs2, rd)          f3r(3, rd, 0, rs1, rs2)
 145 #    define LDUWI(rs1, imm, rd)         f3i(3, rd, 0, rs1, imm)
 146 #    define LDX(rs1, rs2, rd)           f3r(3, rd, 11, rs1, rs2)
 147 #    define LDXI(rs1, imm, rd)          f3i(3, rd, 11, rs1, imm)
 148 #  endif
 149 #  define LDSBA(rs1, rs2, asi, rd)      f3a(3, rd, 25, rs1, asi, rs2)
 150 #  define LDSHA(rs1, rs2, asi, rd)      f3a(3, rd, 26, rs1, asi, rs2)
 151 #  define LDUBA(rs1, rs2, asi, rd)      f3a(3, rd, 17, rs1, asi, rs2)
 152 #  define LDUHA(rs1, rs2, asi, rd)      f3a(3, rd, 18, rs1, asi, rs2)
 153 #  if __WORDSIZE == 32
 154 #    define LDA(rs1, rs2, asi, rd)      f3a(3, rd, 16, rs1, asi, rs2)
 155 #    define LDDA(rs1, rs2, asi, rd)     f3a(3, rd, 19, rs1, asi, rs2)
 156 #  else
 157 #    define LDSWA(rs1, rs2, asi, rd)    f3a(3, rd, 24, rs1, asi, rs2)
 158 #    define LDUWA(rs1, rs2, asi, rd)    f3a(3, rd, 16, rs1, asi, rs2)
 159 #    define LDXA(rs1, rs2, asi, rd)     f3a(3, rd, 27, rs1, asi, rs2)
 160 #  endif
 161 #  define LDC(rs1, rs2, rd)             f3r(3, rd, 48, rs1, rs2)
 162 #  define LDCI(rs1, imm, rd)            f3i(3, rd, 48, rs1, imm)
 163 #  define LDDC(rs1, rs2, rd)            f3r(3, rd, 51, rs1, rs2)
 164 #  define LDDCI(rs1, imm, rd)           f3i(3, rd, 51, rs1, imm)
 165 #  define LDCSR(rs1, rs2, rd)           f3r(3, rd, 49, rs1, rs2)
 166 #  define LDCSRI(rs1, imm, rd)          f3i(3, rd, 49, rs1, imm)
 167 #  define STB(rd, rs1, rs2)             f3r(3, rd, 5, rs1, rs2)
 168 #  define STBI(rd, rs1, imm)            f3i(3, rd, 5, rs1, imm)
 169 #  define STH(rd, rs1, rs2)             f3r(3, rd, 6, rs1, rs2)
 170 #  define STHI(rd, rs1, imm)            f3i(3, rd, 6, rs1, imm)
 171 #  if __WORDSIZE == 32
 172 #    define ST(rd, rs1, rs2)            f3r(3, rd, 4, rs1, rs2)
 173 #    define STI(rd, rs1, imm)           f3i(3, rd, 4, rs1, imm)
 174 #    define STD(rrd, s1, rs2)           f3r(3, rd, 7, rs1, rs2)
 175 #    define STDI(rd, rs1, imm)          f3i(3, rd, 7, rs1, imm)
 176 #  else
 177 #    define STW(rd, rs1, rs2)           f3r(3, rd, 4, rs1, rs2)
 178 #    define STWI(rd, rs1, imm)          f3i(3, rd, 4, rs1, imm)
 179 #    define STX(rd, rs1, rs2)           f3r(3, rd, 14, rs1, rs2)
 180 #    define STXI(rd, rs1, imm)          f3i(3, rd, 14, rs1, imm)
 181 #  endif
 182 #  define STBA(rd, rs1, rs2)            f3a(3, rd, 21, rs1, asi, rs2)
 183 #  define STHA(rd, rs1, rs2)            f3a(3, rd, 22, rs1, asi, rs2)
 184 #  if __WORDSIZE == 32
 185 #    define STA(rd, rs1, rs2)           f3a(3, rd, 20, rs1, asi, rs2)
 186 #    define STDA(rd, rs1, rs2)          f3a(3, rd, 23, rs1, asi, rs2)
 187 #  else
 188 #    define STWA(rd, rs1, rs2)          f3a(3, rd, 20, rs1, asi, rs2)
 189 #    define STXA(rd, rs1, rs2)          f3a(3, rd, 30, rs1, asi, rs2)
 190 #  endif
 191 #  define STC(rd, rs1, rs2)             f3r(3, rd, 52, rs1, rs2)
 192 #  define STCI(rd, rs1, imm)            f3i(3, rd, 52, rs1, imm)
 193 #  define STDC(rd, rs1, rs2)            f3r(3, rd, 55, rs1, rs2)
 194 #  define STDCI(rd, rs1, imm)           f3i(3, rd, 55, rs1, imm)
 195 #  define STCSR(rd, rs1, rs2)           f3r(3, rd, 53, rs1, rs2)
 196 #  define STCSRI(rd, rs1, imm)          f3i(3, rd, 53, rs1, imm)
 197 #  define STDCQ(rd, rs1, rs2)           f3r(3, rd, 54, rs1, rs2)
 198 #  define STDCQI(rd, rs1, imm)          f3i(3, rd, 54, rs1, imm)
 199 #  define LDSTUB(rs1, rs2, rd)          f3r(3, rd, 13, rs1, rs2)
 200 #  define LDSTUBI(rs1, imm, rd)         f3r(3, rd, 13, rs1, imm)
 201 #  define LDSTUBA(rs1, rs2, asi, rd)    f3a(3, rd, 21, rs1, asi, rs2)
 202 #  define SWAP(rs1, rs2, rd)            f3r(3, rd, 15, rs1, rs2)
 203 #  define SWAPI(rs1, imm, rd)           f3r(3, rd, 15, rs1, imm)
 204 #  define SWAPA(rs1, rs2, asi, rd)      f3a(3, rd, 23, rs1, asi, rs2)
 205 /* Sparc v9 deprecates SWAP* in favor of CAS*A */
 206 #  define CASA(rs1, rs2, rd)            f3a(3, rd, 60, rs1, 128, rs2)
 207 #  if __WORDSIZE == 64
 208 #    define CASXA(rs1, rs2, rd)         f3a(3, rd, 62, rs1, 128, rs2)
 209 #  endif
 210 #  define NOP()                         SETHI(0, 0)
 211 #  define HI(im)                        ((im) >> 10)
 212 #  define LO(im)                        ((im) & 0x3ff)
 213 #  define SETHI(im, rd)                 f2r(0, rd, 4, im)
 214 #  define AND(rs1, rs2, rd)             f3r(2, rd, 1, rs1, rs2)
 215 #  define ANDI(rs1, imm, rd)            f3i(2, rd, 1, rs1, imm)
 216 #  define ANDcc(rs1, rs2, rd)           f3r(2, rd, 17, rs1, rs2)
 217 #  define ANDIcc(rs1, imm, rd)          f3i(2, rd, 17, rs1, imm)
 218 #  define BTST(rs1, rs2)                ANDcc(rs1, rs2, 0)
 219 #  define BTSTI(rs1, imm)               ANDIcc(rs1, imm, 0)
 220 #  define ANDN(rs1, rs2, rd)            f3r(2, rd, 5, rs1, rs2)
 221 #  define ANDNI(rs1, imm, rd)           f3i(2, rd, 5, rs1, imm)
 222 #  define ANDNcc(rs1, rs2, rd)          f3r(2, rd, 21, rs1, rs2)
 223 #  define ANDNIcc(rs1, imm, rd)         f3i(2, rd, 21, rs1, imm)
 224 #  define OR(rs1, rs2, rd)              f3r(2, rd, 2, rs1, rs2)
 225 #  define ORI(rs1, imm, rd)             f3i(2, rd, 2, rs1, imm)
 226 #  define ORcc(rs1, rs2, rd)            f3r(2, rd, 18, rs1, rs2)
 227 #  define ORIcc(rs1, imm, rd)           f3i(2, rd, 18, rs1, imm)
 228 #  define ORN(rs1, rs2, rd)             f3r(2, rd, 6, rs1, rs2)
 229 #  define ORNI(rs1, imm, rd)            f3i(2, rd, 6, rs1, imm)
 230 #  define ORNcc(rs1, rs2, rd)           f3r(2, rd, 22, rs1, rs2)
 231 #  define ORNIcc(rs1, imm, rd)          f3i(2, rd, 22, rs1, imm)
 232 #  define XOR(rs1, rs2, rd)             f3r(2, rd, 3, rs1, rs2)
 233 #  define XORI(rs1, imm, rd)            f3i(2, rd, 3, rs1, imm)
 234 #  define XORcc(rs1, rs2, rd)           f3r(2, rd, 19, rs1, rs2)
 235 #  define XORIcc(rs1, imm, rd)          f3i(2, rd, 19, rs1, imm)
 236 #  define XNOR(rs1, rs2, rd)            f3r(2, rd, 7, rs1, rs2)
 237 #  define XNORI(rs1, imm, rd)           f3i(2, rd, 7, rs1, imm)
 238 #  define XNORcc(rs1, rs2, rd)          f3r(2, rd, 23, rs1, rs2)
 239 #  define XNORIcc(rs1, imm, rd)         f3i(2, rd, 23, rs1, imm)
 240 #  define SLL(rs1, rs2, rd)             f3r(2, rd, 37, rs1, rs2)
 241 #  define SLLI(rs1, imm, rd)            f3i(2, rd, 37, rs1, imm)
 242 #  define SRL(rs1, rs2, rd)             f3r(2, rd, 38, rs1, rs2)
 243 #  define SRLI(rs1, imm, rd)            f3i(2, rd, 38, rs1, imm)
 244 #  define SRA(rs1, rs2, rd)             f3r(2, rd, 39, rs1, rs2)
 245 #  define SRAI(rs1, imm, rd)            f3i(2, rd, 39, rs1, imm)
 246 #  if __WORDSIZE == 64
 247 #    define SLLX(rs1, rs2, rd)          f3rx(2, rd, 37, rs1, rs2)
 248 #    define SLLXI(rs1, imm, rd)         f3s(2, rd, 37, rs1, imm)
 249 #    define SRLX(rs1, rs2, rd)          f3rx(2, rd, 38, rs1, rs2)
 250 #    define SRLXI(rs1, imm, rd)         f3s(2, rd, 38, rs1, imm)
 251 #    define SRAX(rs1, rs2, rd)          f3rx(2, rd, 39, rs1, rs2)
 252 #    define SRAXI(rs1, imm, rd)         f3s(2, rd, 39, rs1, imm)
 253 #  endif
 254 #  define ADD(rs1, rs2, rd)             f3r(2, rd, 0, rs1, rs2)
 255 #  define ADDI(rs1, imm, rd)            f3i(2, rd, 0, rs1, imm)
 256 #  define ADDcc(rs1, rs2, rd)           f3r(2, rd, 16, rs1, rs2)
 257 #  define ADDIcc(rs1, imm, rd)          f3i(2, rd, 16, rs1, imm)
 258 #  define ADDX(rs1, rs2, rd)            f3r(2, rd, 8, rs1, rs2)
 259 #  define ADDXI(rs1, imm, rd)           f3i(2, rd, 8, rs1, imm)
 260 #  define ADDXcc(rs1, rs2, rd)          f3r(2, rd, 24, rs1, rs2)
 261 #  define ADDXIcc(rs1, imm, rd)         f3i(2, rd, 24, rs1, imm)
 262 #  define TADDcc(rs1, rs2, rd)          f3r(2, rd, 32, rs1, rs2)
 263 #  define TADDIcc(rs1, imm, rd)         f3i(2, rd, 32, rs1, imm)
 264 #  define TADDccTV(rs1, rs2, rd)        f3r(2, rd, 34, rs1, rs2)
 265 #  define TADDIccTV(rs1, imm, rd)       f3i(2, rd, 34, rs1, imm)
 266 #  define SUB(rs1, rs2, rd)             f3r(2, rd, 4, rs1, rs2)
 267 #  define NEG(rs1, rd)                  SUB(0, rs1, rd)
 268 #  define SUBI(rs1, imm, rd)            f3i(2, rd, 4, rs1, imm)
 269 #  define SUBcc(rs1, rs2, rd)           f3r(2, rd, 20, rs1, rs2)
 270 #  define SUBIcc(rs1, imm, rd)          f3i(2, rd, 20, rs1, imm)
 271 #  define CMP(rs1, rs2)                 SUBcc(rs1, rs2, 0)
 272 #  define CMPI(rs1, imm)                SUBIcc(rs1, imm, 0)
 273 #  define SUBX(rs1, rs2, rd)            f3r(2, rd, 12, rs1, rs2)
 274 #  define SUBXI(rs1, imm, rd)           f3i(2, rd, 12, rs1, imm)
 275 #  define SUBXcc(rs1, rs2, rd)          f3r(2, rd, 28, rs1, rs2)
 276 #  define SUBXIcc(rs1, imm, rd)         f3i(2, rd, 28, rs1, imm)
 277 #  define TSUBcc(rs1, rs2, rd)          f3r(2, rd, 33, rs1, rs2)
 278 #  define TDADDIcc(rs1, imm, rd)        f3i(2, rd, 33, rs1, imm)
 279 #  define TSUBccTV(rs1, rs2, rd)        f3r(2, rd, 35, rs1, rs2)
 280 #  define TSUBIccTV(rs1, imm, rd)       f3i(2, rd, 35, rs1, imm)
 281 #  define MULScc(rs1, rs2, rd)          f3r(2, rd, 36, rs1, rs2)
 282 #  define MULSIcc(rs1, imm, rd)         f3i(2, rd, 36, rs1, imm)
 283 #  define UMUL(rs1, rs2, rd)            f3r(2, rd, 10, rs1, rs2)
 284 #  define UMULI(rs1, imm, rd)           f3i(2, rd, 10, rs1, imm)
 285 #  define SMUL(rs1, rs2, rd)            f3r(2, rd, 11, rs1, rs2)
 286 #  define SMULI(rs1, imm, rd)           f3i(2, rd, 11, rs1, imm)
 287 #  define UMULcc(rs1, rs2, rd)          f3r(2, rd, 26, rs1, rs2)
 288 #  define UMULIcc(rs1, imm, rd)         f3i(2, rd, 26, rs1, imm)
 289 #  define SMULcc(rs1, rs2, rd)          f3r(2, rd, 27, rs1, rs2)
 290 #  define SMULIcc(rs1, imm, rd)         f3i(2, rd, 27, rs1, imm)
 291 #  define UDIV(rs1, rs2, rd)            f3r(2, rd, 14, rs1, rs2)
 292 #  define UDIVI(rs1, imm, rd)           f3i(2, rd, 14, rs1, imm)
 293 #  define SDIV(rs1, rs2, rd)            f3r(2, rd, 15, rs1, rs2)
 294 #  define SDIVI(rs1, imm, rd)           f3i(2, rd, 15, rs1, imm)
 295 #  define UDIVcc(rs1, rs2, rd)          f3r(2, rd, 30, rs1, rs2)
 296 #  define UDIVIcc(rs1, imm, rd)         f3i(2, rd, 30, rs1, imm)
 297 #  define SDIVcc(rs1, rs2, rd)          f3r(2, rd, 31, rs1, rs2)
 298 #  define SDIVIcc(rs1, imm, rd)         f3i(2, rd, 31, rs1, imm)
 299 #  if __WORDSIZE == 64
 300 #    define MULX(rs1, rs2, rd)          f3r(2, rd, 9, rs1, rs2)
 301 #    define MULXI(rs1, imm, rd)         f3i(2, rd, 9, rs1, imm)
 302 #    define SDIVX(rs1, rs2, rd)         f3r(2, rd, 45, rs1, rs2)
 303 #    define SDIVXI(rs1, imm, rd)        f3i(2, rd, 45, rs1, imm)
 304 #    define UDIVX(rs1, rs2, rd)         f3r(2, rd, 13, rs1, rs2)
 305 #    define UDIVXI(rs1, imm, rd)        f3i(2, rd, 13, rs1, imm)
 306 #  endif
 307 #  define SAVE(rs1, rs2, rd)            f3r(2, rd, 60, rs1, rs2)
 308 #  define SAVEI(rs1, imm, rd)           f3i(2, rd, 60, rs1, imm)
 309 #  define RESTORE(rs1, rs2, rd)         f3r(2, rd, 61, rs1, rs2)
 310 #  define RESTOREI(rs1, imm, rd)        f3i(2, rd, 61, rs1, imm)
 311 #  define SPARC_BA                      8       /* always */
 312 #  define SPARC_BN                      0       /* never */
 313 #  define SPARC_BNE                     9       /* not equal - not Z */
 314 #  define SPARC_BNZ                     SPARC_BNE
 315 #  define SPARC_BE                      1       /* equal - Z */
 316 #  define SPARC_BZ                      SPARC_BE
 317 #  define SPARC_BG                      10      /* greater - not (Z or (N xor V)) */
 318 #  define SPARC_BLE                     2       /* less or equal - Z or (N xor V) */
 319 #  define SPARC_BGE                     11      /* greater or equal - not (N xor V) */
 320 #  define SPARC_BL                      3       /* less - N xor V */
 321 #  define SPARC_BGU                     12      /* greater unsigned - not (C or Z) */
 322 #  define SPARC_BLEU                    4       /* less or equal unsigned - C or Z */
 323 #  define SPARC_BCC                     13      /* carry clear - not C */
 324 #  define SPARC_BGEU                    SPARC_BCC
 325 #  define SPARC_BCS                     5       /* carry set - C */
 326 #  define SPARC_BLU                     SPARC_BCS
 327 #  define SPARC_BPOS                    14      /* positive - not N */
 328 #  define SPARC_BNEG                    6       /* negative - N */
 329 #  define SPARC_BVC                     15      /* overflow clear - not V */
 330 #  define SPARC_BVS                     7       /* overflow set - V */
 331 /* Preferred BPcc integer branch opcodes */
 332 #  if __WORDSIZE == 64
 333 #    define SPARC_BPA                   8       /* always - 1 */
 334 #    define SPARC_BPN                   0       /* never - 0 */
 335 #    define SPARC_BPNE                  9       /* not equal - not Z */
 336 #    define SPARC_BPE                   1       /* equal - Z */
 337 #    define SPARC_BPG                   10      /* greater - not (Z or (N xor V)) */
 338 #    define SPARC_BPLE                  2       /* less or equal - Z or (N xor V) */
 339 #    define SPARC_BPGE                  11      /* greater or equal - not (N xor V) */
 340 #    define SPARC_BPL                   3       /* less - N xor V */
 341 #    define SPARC_BPGU                  12      /* greater unsigned - not (C or V) */
 342 #    define SPARC_BPLEU                 4       /* less or equal unsigned  - C or Z */
 343 #    define SPARC_BPCC                  13      /* carry clear (greater than or equal, unsigned) - not C */
 344 #    define SPARC_BPCS                  5       /* carry set (less than, unsigned) - C */
 345 #    define SPARC_BPPOS                 14      /* positive - not N */
 346 #    define SPARC_BPNEG                 6       /* negative - N */
 347 #    define SPARC_BPVC                  15      /* overflow clear - not V */
 348 #    define SPARC_BPVS                  7       /* overflow set - V */
 349 #  endif
 350 #  define B(cc, imm)                    f2b(0, 0, cc, 2, imm)
 351 #  define Ba(cc, imm)                   f2b(0, 1, cc, 2, imm)
 352 #  define BA(imm)                       B(SPARC_BA, imm)
 353 #  define BAa(imm)                      Ba(SPARC_BA, imm)
 354 #  define BN(imm)                       B(SPARC_BN, imm)
 355 #  define BNa(imm)                      Ba(SPARC_BN, imm)
 356 #  define BNE(imm)                      B(SPARC_BNE, imm)
 357 #  define BNEa(imm)                     Ba(SPARC_BNE, imm)
 358 #  define BNZ(imm)                      BNE(imm)
 359 #  define BNZa(imm)                     BNEa(imm)
 360 #  define BE(imm)                       B(SPARC_BE, imm)
 361 #  define BEa(imm)                      Ba(SPARC_BE, imm)
 362 #  define BZ(imm)                       BE(imm)
 363 #  define BZa(imm)                      BEa(imm)
 364 #  define BG(imm)                       B(SPARC_BG, imm)
 365 #  define BGa(imm)                      Ba(SPARC_BG, imm)
 366 #  define BLE(imm)                      B(SPARC_BLE, imm)
 367 #  define BLEa(imm)                     Ba(SPARC_BLE, imm)
 368 #  define BGE(imm)                      B(SPARC_BGE, imm)
 369 #  define BGEa(imm)                     Ba(SPARC_BGE, imm)
 370 #  define BL(imm)                       B(SPARC_BL, imm)
 371 #  define BLa(imm)                      Ba(SPARC_BL, imm)
 372 #  define BGU(imm)                      B(SPARC_BGU, imm)
 373 #  define BGUa(imm)                     Ba(SPARC_BGU, imm)
 374 #  define BLEU(imm)                     B(SPARC_BLEU, imm)
 375 #  define BLEUa(imm)                    Ba(SPARC_BLEU, imm)
 376 #  define BCC(imm)                      B(SPARC_BCC, imm)
 377 #  define BCCa(imm)                     Ba(SPARC_BCC, imm)
 378 #  define BGEU(imm)                     BCC(imm)
 379 #  define BGEUa(imm)                    BCCa(imm)
 380 #  define BCS(imm)                      B(SPARC_BCS, imm)
 381 #  define BCSa(imm)                     Ba(SPARC_BCS, imm)
 382 #  define BLU(imm)                      BCS(imm)
 383 #  define BLUa(imm)                     BCSa(imm)
 384 #  define BPOS(imm)                     B(SPARC_BPOS, imm)
 385 #  define BPOSa(imm)                    Ba(SPARC_BPOS, imm)
 386 #  define BNEG(imm)                     B(SPARC_BNEG, imm)
 387 #  define BNEGa(imm)                    Ba(SPARC_BNEG, imm)
 388 #  define BVC(imm)                      B(SPARC_BVC, imm)
 389 #  define BVCa(imm)                     Ba(SPARC_BVC, imm)
 390 #  define BVS(imm)                      B(SPARC_BVS, imm)
 391 #  define BVSa(imm)                     Ba(SPARC_BVS, imm)
 392 #  if __WORDSIZE == 64
 393 #    define BPccap(cc,a,cc1, cc2,p,imm) f2bp(0, a, cc, 1, cc1, cc0, p, imm)
 394 #    define BPap(cc, imm)               f2bp(0, 1, cc, 1, 1, 0, p, imm)
 395 #    define BPa(cc, imm)                f2bp(0, 1, cc, 1, 1, 0, 1, imm)
 396 #    define BP(cc, imm)                 f2bp(0, 0, cc, 1, 1, 0, 1, imm)
 397 #    define BPA(imm)                    BP(SPARC_BPA, imm)
 398 #    define BPN(imm)                    BP(SPARC_BPN, imm)
 399 #    define BNPE(imm)                   BP(SPARC_BPNE, imm)
 400 #    define BPE(imm)                    BP(SPARC_BPE, imm)
 401 #    define BPG(imm)                    BP(SPARC_BPG, imm)
 402 #    define BPLE(imm)                   BP(SPARC_BPLE, imm)
 403 #    define BPGE(imm)                   BP(SPARC_BPGE, imm)
 404 #    define BPL(imm)                    BP(SPARC_BPL, imm)
 405 #    define BPGU(imm)                   BP(SPARC_BPGU, imm)
 406 #    define BPLEU(imm)                  BP(SPARC_BPLEU, imm)
 407 #    define BPCC(imm)                   BP(SPARC_BPCC, imm)
 408 #    define BPCS(imm)                   BP(SPARC_BPCS, imm)
 409 #    define BPPOS(imm)                  BP(SPARC_BPPOS, imm)
 410 #    define BPNEG(imm)                  BP(SPARC_BPNEG, imm)
 411 #    define BPVC(imm)                   BP(SPARC_BPVC, imm)
 412 #    define BPVS(imm)                   BP(SPARC_BPVS, imm)
 413 #  endif
 414 #  define SPARC_CBA                     8       /* always */
 415 #  define SPARC_CBN                     0       /* never */
 416 #  define SPARC_CB3                     7       /* 3 */
 417 #  define SPARC_CB2                     6       /* 2 */
 418 #  define SPARC_CB23                    5       /* 2 or 3 */
 419 #  define SPARC_CB1                     4       /* 1 */
 420 #  define SPARC_CB13                    3       /* 1 or 3 */
 421 #  define SPARC_CB12                    2       /* 1 or 2 */
 422 #  define SPARC_CB123                   1       /* 1 or 2 or 3 */
 423 #  define SPARC_CB0                     9       /* 0 */
 424 #  define SPARC_CB03                    10      /* 0 or 3 */
 425 #  define SPARC_CB02                    11      /* 0 or 2 */
 426 #  define SPARC_CB023                   12      /* 0 or 2 or 3 */
 427 #  define SPARC_CB01                    13      /* 0 or 1 */
 428 #  define SPARC_CB013                   14      /* 0 or 1 or 3 */
 429 #  define SPARC_CB012                   15      /* 0 or 1 or 2 */
 430 #  define CB(cc, imm)                   f2b(0, 0, cc, 7, imm)
 431 #  define CBa(cc, imm)                  f2b(0, 1, cc, 7, imm)
 432 #  define CBA(imm)                      CB(SPARC_CBA, imm)
 433 #  define CBAa(imm)                     CBa(SPARC_CBA, imm)
 434 #  define CBN(imm)                      CB(SPARC_CBN, imm)
 435 #  define CBNa(imm)                     CBa(SPARC_CBN, imm)
 436 #  define CB3(imm)                      CB(SPARC_CB3, imm)
 437 #  define CB3a(imm)                     CBa(SPARC_CB3, imm)
 438 #  define CB2(imm)                      CB(SPARC_CB2, imm)
 439 #  define CB2a(imm)                     CBa(SPARC_CB2, imm)
 440 #  define CB23(imm)                     CB(SPARC_CB23, imm)
 441 #  define CB23a(imm)                    CBa(SPARC_CB23, imm)
 442 #  define CB1(imm)                      CB(SPARC_CB1, imm)
 443 #  define CB1a(imm)                     CBa(SPARC_CB1, imm)
 444 #  define CB13(imm)                     CB(SPARC_CB13, imm)
 445 #  define CB13a(imm)                    CBa(SPARC_CB13, imm)
 446 #  define CB12(imm)                     CB(SPARC_CB12, imm)
 447 #  define CB12a(imm)                    CBa(SPARC_CB12, imm)
 448 #  define CB123(imm)                    CB(SPARC_CB123, imm)
 449 #  define CB123a(imm)                   CBa(SPARC_CB123, imm)
 450 #  define CB0(imm)                      CB(SPARC_CB0, imm)
 451 #  define CB0a(imm)                     CBa(SPARC_CB0, imm)
 452 #  define CB03(imm)                     CB(SPARC_CB03, imm)
 453 #  define CB03a(imm)                    CBa(SPARC_CB03, imm)
 454 #  define CB02(imm)                     CB(SPARC_CB02, imm)
 455 #  define CB02a(imm)                    CBa(SPARC_CB02, imm)
 456 #  define CB023(imm)                    CB(SPARC_CB103, imm)
 457 #  define CB023a(imm)                   CBa(SPARC_CB023, imm)
 458 #  define CB01(imm)                     CB(SPARC_CB01, imm)
 459 #  define CB01a(imm)                    CBa(SPARC_CB01, imm)
 460 #  define CB013(imm)                    CB(SPARC_CB013, imm)
 461 #  define CB013a(imm)                   CBa(SPARC_CB013, imm)
 462 #  define CB012(imm)                    CB(SPARC_CB012, imm)
 463 #  define CB012a(imm)                   CBa(SPARC_CB012, imm)
 464 #  define CALLI(imm)                    f1(1, imm)
 465 #  define CALL(r0)                      JMPL(_O7_REGNO, r0, 0)
 466 #  define RETL()                        JMPLI(0, _O7_REGNO, 8)
 467 #  define RET()                         JMPLI(0, _I7_REGNO, 8)
 468 #  define JMPL(rd, rs1, rs2)            f3r(2, rd, 56, rs1, rs2)
 469 #  define JMPLI(rd, rs1, imm)           f3i(2, rd, 56, rs1, imm)
 470 #  define RETT(rs1, rs2)                f3r(2, 0, 57, rs1, rs2)
 471 #  define RETTI(rs1, imm)               f3i(2, 0, 57, rs1, imm)
 472 #  define SPARC_TA                      8       /* always */
 473 #  define SPARC_TN                      0       /* never */
 474 #  define SPARC_TNE                     9       /* not equal - not Z */
 475 #  define SPARC_TNZ                     SPARC_BNE
 476 #  define SPARC_TE                      1       /* equal - Z */
 477 #  define SPARC_TZ                      SPARC_BE
 478 #  define SPARC_TG                      10      /* greater - not (Z or (N xor V)) */
 479 #  define SPARC_TLE                     2       /* less or equal - Z or (N xor V) */
 480 #  define SPARC_TGE                     11      /* greater or equal - not (N xor V) */
 481 #  define SPARC_TL                      3       /* less - N xor V */
 482 #  define SPARC_TGU                     12      /* greater unsigned - not (C or Z) */
 483 #  define SPARC_TLEU                    4       /* less or equal unsigned - C or Z */
 484 #  define SPARC_TCC                     13      /* carry clear - not C */
 485 #  define SPARC_TGEU                    SPARC_BCC
 486 #  define SPARC_TCS                     5       /* carry set - C */
 487 #  define SPARC_TLU                     SPARC_BCS
 488 #  define SPARC_TPOS                    14      /* positive - not N */
 489 #  define SPARC_TNEG                    6       /* negative - N */
 490 #  define SPARC_TVC                     15      /* overflow clear - not V */
 491 #  define SPARC_TVS                     7       /* overflow set - V */
 492 #  define T(cc, rs1, rs2)               f3t(cc, rs1, 0, rs2)
 493 #  define TI(cc, rs1, imm)              f3t(cc, rs1, 1, imm)
 494 #  define TA(rs1, rs2)                  T(SPARC_TA, rs1, rs2)
 495 #  define TAI(rs1, imm)                 TI(SPARC_TA, rs1, imm)
 496 #  define TN(rs1, rs2)                  T(SPARC_TN, rs1, rs2)
 497 #  define TNI(rs1, imm)                 TI(SPARC_TN, rs1, imm)
 498 #  define TNE(rs1, rs2)                 T(SPARC_TNE, rs1, rs2)
 499 #  define TNEI(rs1, imm)                TI(SPARC_TNE, rs1, imm)
 500 #  define TNZ(rs1, rs2)                 TNE(rs1, rs2)
 501 #  define TNZI(rs1, imm)                TNEI(rs1, imm)
 502 #  define TE(rs1, rs2)                  T(SPARC_TE, rs1, rs2)
 503 #  define TEI(rs1, imm)                 TI(SPARC_TE, rs1, imm)
 504 #  define TZ(rs1, rs2)                  TE(rs1, rs2)
 505 #  define TZI(rs1, imm)                 TEI(rs1, imm)
 506 #  define TG(rs1, rs2)                  T(SPARC_TG, rs1, rs2)
 507 #  define TGI(rs1, imm)                 TI(SPARC_TG, rs1, imm)
 508 #  define TLE(rs1, rs2)                 T(SPARC_TLE, rs1, rs2)
 509 #  define TLEI(rs1, imm)                TI(SPARC_TLE, rs1, imm)
 510 #  define TGE(rs1, rs2)                 T(SPARC_TGE, rs1, rs2)
 511 #  define TGEI(rs1, imm)                TI(SPARC_TGE, rs1, imm)
 512 #  define TL(rs1, rs2)                  T(SPARC_TL, rs1, rs2)
 513 #  define TLI(rs1, imm)                 TI(SPARC_TL, rs1, imm)
 514 #  define TGU(rs1, rs2)                 T(SPARC_TGU, rs1, rs2)
 515 #  define TGUI(rs1, imm)                TI(SPARC_TGU, rs1, imm)
 516 #  define TLEU(rs1, rs2)                T(SPARC_TLEU, rs1, rs2)
 517 #  define TLEUI(rs1, imm)               TI(SPARC_TLEU, rs1, imm)
 518 #  define TCC(rs1, rs2)                 T(SPARC_TCC, rs1, rs2)
 519 #  define TCCI(rs1, imm)                TI(SPARC_TCC, rs1, imm)
 520 #  define TGEU(rs1, rs2)                TCC(rs1, rs2)
 521 #  define TGEUI(rs1, imm)               TCCI(rs1, imm)
 522 #  define TCS(rs1, rs2)                 T(SPARC_TCC, rs1, rs2)
 523 #  define TCSI(rs1, imm)                TI(SPARC_TCC, rs1, imm)
 524 #  define TLU(rs1, rs2)                 TCS(rs1, rs2)
 525 #  define TLUI(rs1, imm)                TCSI(rs1, imm)
 526 #  define TPOS(rs1, rs2)                T(SPARC_TPOS, rs1, rs2)
 527 #  define TPOSI(rs1, imm)               TI(SPARC_TPOS, rs1, imm)
 528 #  define TNEG(rs1, rs2)                T(SPARC_TNEG, rs1, rs2)
 529 #  define TNEGI(rs1, imm)               TI(SPARC_TNEG, rs1, imm)
 530 #  define TVC(rs1, rs2)                 T(SPARC_TVC, rs1, rs2)
 531 #  define TVCI(rs1, imm)                TI(SPARC_TVC, rs1, imm)
 532 #  define TVS(rs1, rs2)                 T(SPARC_TVS, rs1, rs2)
 533 #  define TVSI(rs1, imm)                TI(SPARC_TVS, rs1, imm)
 534 #  define RDY(rd)                       f3r(2, rd, 40, 0, 0)
 535 #  define RDASR(rs1, rd)                f3r(2, rd, 40, rs1, 0)
 536 #  define RDPSR(rd)                     f3r(2, rd, 41, 0, 0)
 537 #  define RDWIM(rd)                     f3r(2, rd, 42, 0, 0)
 538 #  define RDTBR(rd)                     f3r(2, rd, 43, 0, 0)
 539 #  define WRY(rs1, rs2)                 f3r(2, 0, 48, rs1, rs2)
 540 #  define WRYI(rs1, imm)                f3i(2, 0, 48, rs1, imm)
 541 #  define WRASR(rs1, rs2, rd)           f3r(2, rd, 48, rs1, rs2)
 542 #  define WRASRI(rs1, imm, rd)          f3i(2, rd, 48, rs1, imm)
 543 #  define WRPSR(rs1, rs2, rd)           f3r(2, rd, 49, rs1, rs2)
 544 #  define WRPSRI(rs1, imm, rd)          f3i(2, rd, 49, rs1, imm)
 545 #  define WRWIM(rs1, rs2, rd)           f3r(2, rd, 50, rs1, rs2)
 546 #  define WRWIMI(rs1, imm, rd)          f3i(2, rd, 50, rs1, imm)
 547 #  define WRTBR(rs1, rs2, rd)           f3r(2, rd, 51, rs1, rs2)
 548 #  define WRTBRI(rs1, imm, rd)          f3i(2, rd, 51, rs1, imm)
 549 #  define STBAR()                       f3i(2, 0, 40, 15, 0)
 550 #  define UNIMP(imm)                    f2r(0, 0, 0, imm)
 551 #  define FLUSH(rs1, rs2)               f3r(2, 0, 59, rs1, rs2)
 552 #  define FLUSHI(rs1, im)               f3i(2, 0, 59, rs1, imm)
 553 #  define LZCNT(rs2, rd)                f2c1(2, rd, 54, 0, 23, rs2)
 554 #  define nop(i0)                       _nop(_jit, i0)
 555 static void _nop(jit_state_t*, jit_int32_t);
 556 #  define movr(r0, r1)                  _movr(_jit, r0, r1)
 557 static void _movr(jit_state_t*, jit_int32_t, jit_int32_t);
 558 #  define movi(r0, i0)                  _movi(_jit, r0, i0)
 559 static void _movi(jit_state_t*, jit_int32_t, jit_word_t);
 560 #  define movi_p(r0, i0)                _movi_p(_jit, r0, i0)
 561 static jit_word_t _movi_p(jit_state_t*, jit_int32_t, jit_word_t);
 562 #  define bswapr_us(r0, r1)             generic_bswapr_us(_jit, r0, r1)
 563 #  define bswapr_ui(r0, r1)             generic_bswapr_ui(_jit, r0, r1)
 564 #  define bswapr_ul(r0, r1)             generic_bswapr_ul(_jit, r0, r1)
 565 #  define movnr(r0,r1,r2)               _movnr(_jit,r0,r1,r2)
 566 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 567 #  define movzr(r0,r1,r2)               _movzr(_jit,r0,r1,r2)
 568 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 569 #  define casx(r0, r1, r2, r3, i0)      _casx(_jit, r0, r1, r2, r3, i0)
 570 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
 571                   jit_int32_t,jit_int32_t,jit_word_t);
 572 #define casr(r0, r1, r2, r3)            casx(r0, r1, r2, r3, 0)
 573 #define casi(r0, i0, r1, r2)            casx(r0, _NOREG, r1, r2, i0)
 574 #  define comr(r0, r1)                  XNOR(r1, 0, r0)
 575 #  define negr(r0, r1)                  NEG(r1, r0)
 576 #  define bitswap(r0, r1)               _bitswap(_jit, r0, r1)
 577 static void _bitswap(jit_state_t*, jit_int32_t, jit_int32_t);
 578 #  define clor(r0, r1)                  _clor(_jit, r0, r1)
 579 static void _clor(jit_state_t*, jit_int32_t, jit_int32_t);
 580 #  define clzr(r0, r1)                  _clzr(_jit, r0, r1)
 581 static void _clzr(jit_state_t*, jit_int32_t, jit_int32_t);
 582 #  define ctor(r0, r1)                  _ctor(_jit, r0, r1)
 583 static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t);
 584 #  define ctzr(r0, r1)                  _ctzr(_jit, r0, r1)
 585 static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t);
 586 #  define addr(r0, r1, r2)              ADD(r1, r2, r0)
 587 #  define addi(r0, r1, i0)              _addi(_jit, r0, r1, i0)
 588 static void _addi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 589 #  if __WORDSIZE == 32
 590 #    define addcr(r0, r1, r2)           ADDcc(r1, r2, r0)
 591 #  else
 592 #    define addcr(r0, r1, r2)           _addcr(_jit, r0, r1, r2)
 593 static void _addcr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 594 #  endif
 595 #  define addci(r0, r1, i0)             _addci(_jit, r0, r1, i0)
 596 static void _addci(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 597 #  if __WORDSIZE == 32
 598 #    define addxr(r0, r1, r2)           ADDXcc(r1, r2, r0)
 599 #  else
 600 #    define addxr(r0, r1, r2)           _addxr(_jit, r0, r1, r2)
 601 static void _addxr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 602 #  endif
 603 #  define addxi(r0, r1, i0)             _addxi(_jit, r0, r1, i0)
 604 static void _addxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 605 #  define subr(r0, r1, r2)              SUB(r1, r2, r0)
 606 #  define subi(r0, r1, i0)              _subi(_jit, r0, r1, i0)
 607 static void _subi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 608 #  if __WORDSIZE == 32
 609 #    define subcr(r0, r1, r2)           SUBcc(r1, r2, r0)
 610 #  else
 611 #    define subcr(r0, r1, r2)           _subcr(_jit, r0, r1, r2)
 612 static void _subcr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 613 #  endif
 614 #  define subci(r0, r1, i0)             _subci(_jit, r0, r1, i0)
 615 static void _subci(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 616 #  if __WORDSIZE == 32
 617 #    define subxr(r0, r1, r2)           SUBXcc(r1, r2, r0)
 618 #  else
 619 #    define subxr(r0, r1, r2)           _subxr(_jit, r0, r1, r2)
 620 static void _subxr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 621 #  endif
 622 #  define subxi(r0, r1, i0)             _subxi(_jit, r0, r1, i0)
 623 static void _subxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 624 #  define rsbi(r0, r1, i0)              _rsbi(_jit, r0, r1, i0)
 625 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 626 #  if __WORDSIZE == 32
 627 #    define mulr(r0, r1, r2)            UMUL(r1, r2, r0)
 628 #  else
 629 #    define mulr(r0, r1, r2)            MULX(r1, r2, r0)
 630 #  endif
 631 #  define muli(r0, r1, i0)              _muli(_jit, r0, r1, i0)
 632 static void _muli(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 633 #  if __WORDSIZE == 32
 634 #    define qmulr(r0,r1,r2,r3)          iqmulr(r0,r1,r2,r3,1)
 635 #    define qmulr_u(r0,r1,r2,r3)        iqmulr(r0,r1,r2,r3,0)
 636 #    define iqmulr(r0,r1,r2,r3,cc)      _iqmulr(_jit,r0,r1,r2,r3,cc)
 637 static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
 638                     jit_int32_t,jit_int32_t,jit_bool_t);
 639 #  define qmuli(r0,r1,r2,i0)            iqmuli(r0,r1,r2,i0,1)
 640 #  define qmuli_u(r0,r1,r2,i0)          iqmuli(r0,r1,r2,i0,0)
 641 #  define iqmuli(r0,r1,r2,i0,cc)        _iqmuli(_jit,r0,r1,r2,i0,cc)
 642 static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
 643                     jit_int32_t,jit_word_t,jit_bool_t);
 644 #  else
 645 #    define qmulr(r0,r1,r2,r3)          _qmulr(_jit,r0,r1,r2,r3)
 646 static void _qmulr(jit_state_t*,jit_int32_t,jit_int32_t,
 647                    jit_int32_t,jit_int32_t);
 648 #  define qmuli(r0,r1,r2,i0)            _qmuli(_jit,r0,r1,r2,i0)
 649 static void _qmuli(jit_state_t*,jit_int32_t,jit_int32_t,
 650                    jit_int32_t,jit_word_t);
 651 #    define qmulr_u(r0,r1,r2,r3)        _qmulr_u(_jit,r0,r1,r2,r3)
 652 static void _qmulr_u(jit_state_t*,jit_int32_t,jit_int32_t,
 653                      jit_int32_t,jit_int32_t);
 654 #  define qmuli_u(r0,r1,r2,i0)          _qmuli_u(_jit,r0,r1,r2,i0)
 655 static void _qmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,
 656                      jit_int32_t,jit_word_t);
 657 #  endif
 658 #  define divr(r0, r1, r2)              _divr(_jit, r0, r1, r2)
 659 static void _divr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 660 #  define divi(r0, r1, i0)              _divi(_jit, r0, r1, i0)
 661 static void _divi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 662 #  define divr_u(r0, r1, r2)            _divr_u(_jit, r0, r1, r2)
 663 static void _divr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 664 #  define divi_u(r0, r1, i0)            _divi_u(_jit, r0, r1, i0)
 665 static void _divi_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 666 #  define qdivr(r0,r1,r2,r3)            iqdivr(r0,r1,r2,r3,1)
 667 #  define qdivr_u(r0,r1,r2,r3)          iqdivr(r0,r1,r2,r3,0)
 668 #  define iqdivr(r0,r1,r2,r3,cc)        _iqdivr(_jit,r0,r1,r2,r3,cc)
 669 static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
 670                     jit_int32_t,jit_int32_t,jit_bool_t);
 671 #  define qdivi(r0,r1,r2,i0)            iqdivi(r0,r1,r2,i0,1)
 672 #  define qdivi_u(r0,r1,r2,i0)          iqdivi(r0,r1,r2,i0,0)
 673 #  define iqdivi(r0,r1,r2,i0,cc)        _iqdivi(_jit,r0,r1,r2,i0,cc)
 674 static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
 675                     jit_int32_t,jit_word_t,jit_bool_t);
 676 #  define remr(r0, r1, r2)              _remr(_jit, r0, r1, r2)
 677 static void _remr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 678 #  define remi(r0, r1, i0)              _remi(_jit, r0, r1, i0)
 679 static void _remi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 680 #  define remr_u(r0, r1, r2)            _remr_u(_jit, r0, r1, r2)
 681 static void _remr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 682 #  define remi_u(r0, r1, i0)            _remi_u(_jit, r0, r1, i0)
 683 static void _remi_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 684 #  define andr(r0, r1, r2)              AND(r1, r2, r0)
 685 #  define andi(r0, r1, i0)              _andi(_jit, r0, r1, i0)
 686 static void _andi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 687 #  define orr(r0, r1, r2)               OR(r1, r2, r0)
 688 #  define ori(r0, r1, i0)               _ori(_jit, r0, r1, i0)
 689 static void _ori(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 690 #  define xorr(r0, r1, r2)              XOR(r1, r2, r0)
 691 #  define xori(r0, r1, i0)              _xori(_jit, r0, r1, i0)
 692 static void _xori(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 693 #  if __WORDSIZE == 32
 694 #    define lshr(r0, r1, r2)            SLL(r1, r2, r0)
 695 #    define lshi(r0, r1, i0)            SLLI(r1, i0, r0)
 696 #    define rshr(r0, r1, r2)            SRA(r1, r2, r0)
 697 #    define rshi(r0, r1, i0)            SRAI(r1, i0, r0)
 698 #    define rshr_u(r0, r1, r2)          SRL(r1, r2, r0)
 699 #    define rshi_u(r0, r1, i0)          SRLI(r1, i0, r0)
 700 #  else
 701 #    define lshr(r0, r1, r2)            SLLX(r1, r2, r0)
 702 #    define lshi(r0, r1, i0)            SLLXI(r1, i0, r0)
 703 #    define rshr(r0, r1, r2)            SRAX(r1, r2, r0)
 704 #    define rshi(r0, r1, i0)            SRAXI(r1, i0, r0)
 705 #    define rshr_u(r0, r1, r2)          SRLX(r1, r2, r0)
 706 #    define rshi_u(r0, r1, i0)          SRLXI(r1, i0, r0)
 707 #  endif
 708 #  define extr_c(r0,r1)                 _extr_c(_jit,r0,r1)
 709 static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
 710 #  define extr_uc(r0,r1)                andi(r0, r1, 0xff)
 711 #  define extr_s(r0,r1)                 _extr_s(_jit,r0,r1)
 712 static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
 713 #  define extr_us(r0,r1)                _extr_us(_jit,r0,r1)
 714 static void _extr_us(jit_state_t*,jit_int32_t,jit_int32_t);
 715 #  if __WORDSIZE == 64
 716 #    define extr_i(r0,r1)               _extr_i(_jit,r0,r1)
 717 static void _extr_i(jit_state_t*,jit_int32_t,jit_int32_t);
 718 #    define extr_ui(r0,r1)              _extr_ui(_jit,r0,r1)
 719 static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
 720 #  endif
 721 #  define cr(cc, r0, r1, r2)            _cr(_jit, cc, r0, r1, r2)
 722 static void _cr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 723 #  define cw(cc, r0, r1, i0)            _cw(_jit, cc, r0, r1, i0)
 724 static void _cw(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 725 #  if __WORDSIZE == 32
 726 #    define ltr(r0, r1, r2)             cr(SPARC_BL, r0, r1, r2)
 727 #    define lti(r0, r1, i0)             cw(SPARC_BL, r0, r1, i0)
 728 #    define ltr_u(r0, r1, r2)           cr(SPARC_BLU, r0, r1, r2)
 729 #    define lti_u(r0, r1, i0)           cw(SPARC_BLU, r0, r1, i0)
 730 #    define ler(r0, r1, r2)             cr(SPARC_BLE, r0, r1, r2)
 731 #    define lei(r0, r1, i0)             cw(SPARC_BLE, r0, r1, i0)
 732 #    define ler_u(r0, r1, r2)           cr(SPARC_BLEU, r0, r1, r2)
 733 #    define lei_u(r0, r1, i0)           cw(SPARC_BLEU, r0, r1, i0)
 734 #    define eqr(r0, r1, r2)             cr(SPARC_BE, r0, r1, r2)
 735 #    define eqi(r0, r1, i0)             cw(SPARC_BE, r0, r1, i0)
 736 #    define ger(r0, r1, r2)             cr(SPARC_BGE, r0, r1, r2)
 737 #    define gei(r0, r1, i0)             cw(SPARC_BGE, r0, r1, i0)
 738 #    define ger_u(r0, r1, r2)           cr(SPARC_BGEU, r0, r1, r2)
 739 #    define gei_u(r0, r1, i0)           cw(SPARC_BGEU, r0, r1, i0)
 740 #    define gtr(r0, r1, r2)             cr(SPARC_BG, r0, r1, r2)
 741 #    define gti(r0, r1, i0)             cw(SPARC_BG, r0, r1, i0)
 742 #    define gtr_u(r0, r1, r2)           cr(SPARC_BGU, r0, r1, r2)
 743 #    define gti_u(r0, r1, i0)           cw(SPARC_BGU, r0, r1, i0)
 744 #    define ner(r0, r1, r2)             cr(SPARC_BNE, r0, r1, r2)
 745 #    define nei(r0, r1, i0)             cw(SPARC_BNE, r0, r1, i0)
 746 #  else
 747 #  define ltr(r0, r1, r2)               cr(SPARC_BPL, r0, r1, r2)
 748 #  define lti(r0, r1, i0)               cw(SPARC_BPL, r0, r1, i0)
 749 #  define ltr_u(r0, r1, r2)             cr(SPARC_BPCS, r0, r1, r2)
 750 #  define lti_u(r0, r1, i0)             cw(SPARC_BPCS, r0, r1, i0)
 751 #  define ler(r0, r1, r2)               cr(SPARC_BPLE, r0, r1, r2)
 752 #  define lei(r0, r1, i0)               cw(SPARC_BPLE, r0, r1, i0)
 753 #  define ler_u(r0, r1, r2)             cr(SPARC_BPLEU, r0, r1, r2)
 754 #  define lei_u(r0, r1, i0)             cw(SPARC_BPLEU, r0, r1, i0)
 755 #  define eqr(r0, r1, r2)               cr(SPARC_BPE, r0, r1, r2)
 756 #  define eqi(r0, r1, i0)               cw(SPARC_BPE, r0, r1, i0)
 757 #  define ger(r0, r1, r2)               cr(SPARC_BPGE, r0, r1, r2)
 758 #  define gei(r0, r1, i0)               cw(SPARC_BPGE, r0, r1, i0)
 759 #  define ger_u(r0, r1, r2)             cr(SPARC_BPCC, r0, r1, r2)
 760 #  define gei_u(r0, r1, i0)             cw(SPARC_BPCC, r0, r1, i0)
 761 #  define gtr(r0, r1, r2)               cr(SPARC_BPG, r0, r1, r2)
 762 #  define gti(r0, r1, i0)               cw(SPARC_BPG, r0, r1, i0)
 763 #  define gtr_u(r0, r1, r2)             cr(SPARC_BPGU, r0, r1, r2)
 764 #  define gti_u(r0, r1, i0)             cw(SPARC_BPGU, r0, r1, i0)
 765 #  define ner(r0, r1, r2)               cr(SPARC_BPNE, r0, r1, r2)
 766 #  define nei(r0, r1, i0)               cw(SPARC_BPNE, r0, r1, i0)
 767 #  endif
 768 #  define ldr_c(r0, r1)                 LDSB(r1, 0, r0)
 769 #  define ldi_c(r0, i0)                 _ldi_c(_jit, r0, i0)
 770 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
 771 #  define ldr_uc(r0, r1)                LDUB(r1, 0, r0)
 772 #  define ldi_uc(r0, i0)                _ldi_uc(_jit, r0, i0)
 773 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
 774 #  define ldr_s(r0, r1)                 LDSH(r1, 0, r0)
 775 #  define ldi_s(r0, i0)                 _ldi_s(_jit, r0, i0)
 776 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
 777 #  define ldr_us(r0, r1)                LDUH(r1, 0, r0)
 778 #  define ldi_us(r0, i0)                _ldi_us(_jit, r0, i0)
 779 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
 780 #  if __WORDSIZE == 32
 781 #    define ldr_i(r0, r1)               LD(r1, 0, r0)
 782 #    define ldr(u, v)                   ldr_i(u, v)
 783 #    define ldi(u, v)                   ldi_i(u, v)
 784 #  else
 785 #    define ldr_i(r0, r1)               LDSW(r1, 0, r0)
 786 #    define ldr_ui(r0, r1)              LDUW(r1, 0, r0)
 787 #    define ldr_l(r0, r1)               LDX(r1, 0, r0)
 788 #    define ldr(u, v)                   ldr_l(u, v)
 789 #    define ldi(u, v)                   ldi_l(u, v)
 790 #  endif
 791 #  define ldi_i(r0, i0)                 _ldi_i(_jit, r0, i0)
 792 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
 793 #  if __WORDSIZE == 64
 794 #    define ldi_ui(r0, i0)              _ldi_ui(_jit, r0, i0)
 795 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
 796 #    define ldi_l(r0, i0)               _ldi_l(_jit, r0, i0)
 797 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
 798 #  endif
 799 #  define ldxr_c(r0, r1, r2)            LDSB(r1, r2, r0)
 800 #  define ldxi_c(r0, r1, i0)            _ldxi_c(_jit, r0, r1, i0)
 801 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 802 #  define ldxr_uc(r0, r1, r2)           LDUB(r1, r2, r0)
 803 #  define ldxi_uc(r0, r1, i0)           _ldxi_uc(_jit, r0, r1, i0)
 804 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 805 #  define ldxr_s(r0, r1, r2)            LDSH(r1, r2, r0)
 806 #  define ldxi_s(r0, r1, i0)            _ldxi_s(_jit, r0, r1, i0)
 807 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 808 #  define ldxr_us(r0, r1, r2)           LDUH(r1, r2, r0)
 809 #  define ldxi_us(r0, r1, i0)           _ldxi_us(_jit, r0, r1, i0)
 810 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 811 #  if __WORDSIZE == 32
 812 #    define ldxr(u, v, w)               ldxr_i(u, v, w)
 813 #    define ldxr_i(r0, r1, r2)          LD(r1, r2, r0)
 814 #    define ldxi(u, v, w)               ldxi_i(u, v, w)
 815 #  else
 816 #    define ldxr(u, v, w)               ldxr_l(u, v, w)
 817 #    define ldxr_i(r0, r1, r2)          LDSW(r1, r2, r0)
 818 #    define ldxr_ui(r0, r1, r2)         LDUW(r1, r2, r0)
 819 #    define ldxr_l(r0, r1, r2)          LDX(r1, r2, r0)
 820 #    define ldxi(u, v, w)               ldxi_l(u, v, w)
 821 #  endif
 822 #  define ldxi_i(r0, r1, i0)            _ldxi_i(_jit, r0, r1, i0)
 823 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 824 #  if __WORDSIZE == 64
 825 #    define ldxi_ui(r0, r1, i0)         _ldxi_ui(_jit, r0, r1, i0)
 826 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 827 #    define ldxi_l(r0, r1, i0)          _ldxi_l(_jit, r0, r1, i0)
 828 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 829 #  endif
 830 #  define str_c(r0, r1)                 STB(r1, r0, 0)
 831 #  define sti_c(i0, r0)                 _sti_c(_jit, i0, r0)
 832 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
 833 #  define str_s(r0, r1)                 STH(r1, r0, 0)
 834 #  define sti_s(i0, r0)                 _sti_s(_jit, i0, r0)
 835 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
 836 #  if __WORDSIZE == 32
 837 #    define str(u, v)                   str_i(u, v)
 838 #    define str_i(r0, r1)               STI(r1, r0, 0)
 839 #    define sti(u, v)                   sti_i(u, v)
 840 #  else
 841 #    define str(u, v)                   str_l(u, v)
 842 #    define str_i(r0, r1)               STW(r1, r0, 0)
 843 #    define str_l(r0, r1)               STX(r1, r0, 0)
 844 #    define sti(u, v)                   sti_l(u, v)
 845 #  endif
 846 #  define sti_i(i0, r0)                 _sti_i(_jit, i0, r0)
 847 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
 848 #  if __WORDSIZE == 64
 849 #    define sti_l(i0, r0)               _sti_l(_jit, i0, r0)
 850 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
 851 #  endif
 852 #  define stxr_c(r0, r1, r2)            STB(r2, r1, r0)
 853 #  define stxi_c(i0, r0, r1)            _stxi_c(_jit, i0, r0, r1)
 854 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 855 #  define stxr_s(r0, r1, r2)            STH(r2, r1, r0)
 856 #  define stxi_s(i0, r0, r1)            _stxi_s(_jit, i0, r0, r1)
 857 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 858 #  if __WORDSIZE == 32
 859 #    define stxr(u, v, w)               stxr_i(u, v, w)
 860 #    define stxr_i(r0, r1, r2)          ST(r2, r1, r0)
 861 #    define stxi(u, v, w)               stxi_i(u, v, w)
 862 #  else
 863 #    define stxr(u, v, w)               stxr_l(u, v, w)
 864 #    define stxr_i(r0, r1, r2)          STW(r2, r1, r0)
 865 #    define stxi(u, v, w)               stxi_l(u, v, w)
 866 #    define stxr_l(r0, r1, r2)          STX(r2, r1, r0)
 867 #  endif
 868 #  define stxi_i(i0, r0, r1)            _stxi_i(_jit, i0, r0, r1)
 869 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 870 #  if __WORDSIZE == 64
 871 #    define stxi_l(i0, r0, r1)          _stxi_l(_jit, i0, r0, r1)
 872 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 873 #  endif
 874 #  define br(cc, i0, r0, r1)            _br(_jit, cc, i0, r0, r1)
 875 static jit_word_t
 876 _br(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
 877 #  define bw(cc, i0, r0, i1)            _bw(_jit, cc, i0, r0, i1)
 878 static jit_word_t
 879 _bw(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
 880 #  if __WORDSIZE == 32
 881 #    define bltr(i0, r0, r1)            br(SPARC_BL, i0, r0, r1)
 882 #    define blti(i0, r0, i1)            bw(SPARC_BL, i0, r0, i1)
 883 #    define bltr_u(i0, r0, r1)          br(SPARC_BLU, i0, r0, r1)
 884 #    define blti_u(i0, r0, i1)          bw(SPARC_BLU, i0, r0, i1)
 885 #    define bler(i0, r0, r1)            br(SPARC_BLE, i0, r0, r1)
 886 #    define blei(i0, r0, i1)            bw(SPARC_BLE, i0, r0, i1)
 887 #    define bler_u(i0, r0, r1)          br(SPARC_BLEU, i0, r0, r1)
 888 #    define blei_u(i0, r0, i1)          bw(SPARC_BLEU, i0, r0, i1)
 889 #    define beqr(i0, r0, r1)            br(SPARC_BE, i0, r0, r1)
 890 #    define beqi(i0, r0, i1)            bw(SPARC_BE, i0, r0, i1)
 891 #    define bger(i0, r0, r1)            br(SPARC_BGE, i0, r0, r1)
 892 #    define bgei(i0, r0, i1)            bw(SPARC_BGE, i0, r0, i1)
 893 #    define bger_u(i0, r0, r1)          br(SPARC_BGEU, i0, r0, r1)
 894 #    define bgei_u(i0, r0, i1)          bw(SPARC_BGEU, i0, r0, i1)
 895 #    define bgtr(i0, r0, r1)            br(SPARC_BG, i0, r0, r1)
 896 #    define bgti(i0, r0, i1)            bw(SPARC_BG, i0, r0, i1)
 897 #    define bgtr_u(i0, r0, r1)          br(SPARC_BGU, i0, r0, r1)
 898 #    define bgti_u(i0, r0, i1)          bw(SPARC_BGU, i0, r0, i1)
 899 #    define bner(i0, r0, r1)            br(SPARC_BNE, i0, r0, r1)
 900 #    define bnei(i0, r0, i1)            bw(SPARC_BNE, i0, r0, i1)
 901 #  else
 902 #    define bltr(i0, r0, r1)            br(SPARC_BPL, i0, r0, r1)
 903 #    define blti(i0, r0, i1)            bw(SPARC_BPL, i0, r0, i1)
 904 #    define bltr_u(i0, r0, r1)          br(SPARC_BPCS, i0, r0, r1)
 905 #    define blti_u(i0, r0, i1)          bw(SPARC_BPCS, i0, r0, i1)
 906 #    define bler(i0, r0, r1)            br(SPARC_BPLE, i0, r0, r1)
 907 #    define blei(i0, r0, i1)            bw(SPARC_BPLE, i0, r0, i1)
 908 #    define bler_u(i0, r0, r1)          br(SPARC_BPLEU, i0, r0, r1)
 909 #    define blei_u(i0, r0, i1)          bw(SPARC_BPLEU, i0, r0, i1)
 910 #    define beqr(i0, r0, r1)            br(SPARC_BPE, i0, r0, r1)
 911 #    define beqi(i0, r0, i1)            bw(SPARC_BPE, i0, r0, i1)
 912 #    define bger(i0, r0, r1)            br(SPARC_BPGE, i0, r0, r1)
 913 #    define bgei(i0, r0, i1)            bw(SPARC_BPGE, i0, r0, i1)
 914 #    define bger_u(i0, r0, r1)          br(SPARC_BPCC, i0, r0, r1)
 915 #    define bgei_u(i0, r0, i1)          bw(SPARC_BPCC, i0, r0, i1)
 916 #    define bgtr(i0, r0, r1)            br(SPARC_BPG, i0, r0, r1)
 917 #    define bgti(i0, r0, i1)            bw(SPARC_BPG, i0, r0, i1)
 918 #    define bgtr_u(i0, r0, r1)          br(SPARC_BPGU, i0, r0, r1)
 919 #    define bgti_u(i0, r0, i1)          bw(SPARC_BPGU, i0, r0, i1)
 920 #    define bner(i0, r0, r1)            br(SPARC_BPNE, i0, r0, r1)
 921 #    define bnei(i0, r0, i1)            bw(SPARC_BPNE, i0, r0, i1)
 922 #  endif
 923 #  define b_asr(jif,add,sgn,i0,r0,r1)   _b_asr(_jit,jif,add,sgn,i0,r0,r1)
 924 static jit_word_t
 925 _b_asr(jit_state_t*,jit_bool_t,jit_bool_t,jit_bool_t,
 926        jit_word_t,jit_int32_t,jit_int32_t);
 927 #  define b_asw(jif,add,sgn,i0,r0,i1)   _b_asw(_jit,jif,add,sgn,i0,r0,i1)
 928 static jit_word_t
 929 _b_asw(jit_state_t*,jit_bool_t,jit_bool_t,jit_bool_t,
 930        jit_word_t,jit_int32_t,jit_word_t);
 931 #  define boaddr(i0, r0, r1)            b_asr(1, 1, 1, i0, r0, r1)
 932 #  define boaddi(i0, r0, i1)            b_asw(1, 1, 1, i0, r0, i1)
 933 #  define boaddr_u(i0, r0, r1)          b_asr(1, 1, 0, i0, r0, r1)
 934 #  define boaddi_u(i0, r0, i1)          b_asw(1, 1, 0, i0, r0, i1)
 935 #  define bxaddr(i0, r0, r1)            b_asr(0, 1, 1, i0, r0, r1)
 936 #  define bxaddi(i0, r0, i1)            b_asw(0, 1, 1, i0, r0, i1)
 937 #  define bxaddr_u(i0, r0, r1)          b_asr(0, 1, 0, i0, r0, r1)
 938 #  define bxaddi_u(i0, r0, i1)          b_asw(0, 1, 0, i0, r0, i1)
 939 #  define bosubr(i0, r0, r1)            b_asr(1, 0, 1, i0, r0, r1)
 940 #  define bosubi(i0, r0, i1)            b_asw(1, 0, 1, i0, r0, i1)
 941 #  define bosubr_u(i0, r0, r1)          b_asr(1, 0, 0, i0, r0, r1)
 942 #  define bosubi_u(i0, r0, i1)          b_asw(1, 0, 0, i0, r0, i1)
 943 #  define bxsubr(i0, r0, r1)            b_asr(0, 0, 1, i0, r0, r1)
 944 #  define bxsubi(i0, r0, i1)            b_asw(0, 0, 1, i0, r0, i1)
 945 #  define bxsubr_u(i0, r0, r1)          b_asr(0, 0, 0, i0, r0, r1)
 946 #  define bxsubi_u(i0, r0, i1)          b_asw(0, 0, 0, i0, r0, i1)
 947 #  define bm_r(set, i0, r0, r1)         _bm_r(_jit,set,i0,r0,r1)
 948 static jit_word_t
 949 _bm_r(jit_state_t*,jit_bool_t,jit_word_t,jit_int32_t,jit_int32_t);
 950 #  define bm_w(set,i0,r0,i1)            _bm_w(_jit,set,i0,r0,i1)
 951 static jit_word_t
 952 _bm_w(jit_state_t*,jit_bool_t,jit_word_t,jit_int32_t,jit_word_t);
 953 #  define bmsr(i0, r0, r1)              bm_r(1, i0, r0, r1)
 954 #  define bmsi(i0, r0, i1)              bm_w(1, i0, r0, i1)
 955 #  define bmcr(i0, r0, r1)              bm_r(0, i0, r0, r1)
 956 #  define bmci(i0, r0, i1)              bm_w(0, i0, r0, i1)
 957 #  define jmpr(r0)                      _jmpr(_jit, r0)
 958 static void _jmpr(jit_state_t*,jit_int32_t);
 959 #  define jmpi(i0)                      _jmpi(_jit, i0)
 960 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
 961 #  define jmpi_p(i0)                    _jmpi_p(_jit, i0)
 962 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
 963 #  define callr(r0)                     _callr(_jit, r0)
 964 static void _callr(jit_state_t*,jit_int32_t);
 965 #  define calli(i0)                     _calli(_jit, i0)
 966 static jit_word_t _calli(jit_state_t*,jit_word_t);
 967 #  define calli_p(i0)                   _calli_p(_jit, i0)
 968 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
 969 #  define prolog(node)                  _prolog(_jit, node)
 970 static void _prolog(jit_state_t*,jit_node_t*);
 971 #  define epilog(node)                  _epilog(_jit, node)
 972 static void _epilog(jit_state_t*,jit_node_t*);
 973 #define vastart(r0)                     _vastart(_jit, r0)
 974 static void _vastart(jit_state_t*, jit_int32_t);
 975 #define vaarg(r0, r1)                   _vaarg(_jit, r0, r1)
 976 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
 977 #define patch_at(jump, label)           _patch_at(_jit, jump, label)
 978 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
 979 #endif
 980
 981 #if CODE
 982 static void
 983 _f2r(jit_state_t *_jit,
 984      jit_int32_t op, jit_int32_t rd, jit_int32_t op2, jit_int32_t imm22)
 985 {
 986     jit_instr_t         v;
 987     assert(!(op  & 0xfffffffc));
 988     assert(!(rd  & 0xffffffe0));
 989     assert(!(op2 & 0xfffffff8));
 990     assert(s22_p(imm22));
 991     v.op.b    = op;
 992     v.rd.b    = rd;
 993     v.op2.b   = op2;
 994     v.imm22.b = imm22;
 995     ii(v.v);
 996 }
 997
 998 static void
 999 _f2b(jit_state_t *_jit,
1000      jit_int32_t op, jit_int32_t a, jit_int32_t cond, jit_int32_t op2,
1001      jit_int32_t disp22)
1002 {
1003     jit_instr_t         v;
1004     assert(!(op   & 0xfffffffc));
1005     assert(!(a    & 0xfffffffe));
1006     assert(!(cond & 0xfffffff0));
1007     assert(!(op2  & 0xfffffff8));
1008     assert(s22_p(disp22));
1009     v.op.b     = op;
1010     v.a.b      = a;
1011     v.cond.b   = cond;
1012     v.op2.b    = op2;
1013     v.disp22.b = disp22;
1014     ii(v.v);
1015 }
1016
1017 #  if __WORDSIZE == 64
1018 static void
1019 _f2bp(jit_state_t *_jit,
1020       jit_int32_t op, jit_int32_t a, jit_int32_t cond, jit_int32_t op2,
1021       jit_int32_t cc1, jit_int32_t cc0, jit_int32_t p, jit_int32_t disp19)
1022 {
1023     jit_instr_t         v;
1024     assert(!(op   & 0xfffffffc));
1025     assert(!(a    & 0xfffffffe));
1026     assert(!(cond & 0xfffffff0));
1027     assert(!(op2  & 0xfffffff8));
1028     assert(s19_p(disp19));
1029     v.op.b     = op;
1030     v.a.b      = a;
1031     v.cond.b   = cond;
1032     v.op2.b    = op2;
1033     v.cc1.b    = cc1;
1034     v.cc0.b    = cc0;
1035     v.p.b      = p;
1036     v.disp19.b = disp19;
1037     ii(v.v);
1038 }
1039 #  endif
1040
1041 static void
1042 _f3r(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1043      jit_int32_t op3, jit_int32_t rs1, jit_int32_t rs2)
1044 {
1045     jit_instr_t         v;
1046     assert(!(op  & 0xfffffffc));
1047     assert(!(rd  & 0xffffffe0));
1048     assert(!(op3 & 0xffffffc0));
1049     assert(!(rs1 & 0xffffffe0));
1050     assert(!(rs2 & 0xffffffe0));
1051     v.op.b  = op;
1052     v.rd.b  = rd;
1053     v.op3.b = op3;
1054     v.rs1.b = rs1;
1055     v.i.b   = 0;
1056     v.asi.b = 0;
1057     v.rs2.b = rs2;
1058     ii(v.v);
1059 }
1060
1061 #  if __WORDSIZE == 64
1062 static void
1063 _f3ri(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1064       jit_int32_t op3, jit_int32_t rs1, jit_int32_t rs2)
1065 {
1066     jit_instr_t         v;
1067     assert(!(op  & 0xfffffffc));
1068     assert(!(rd  & 0xffffffe0));
1069     assert(!(op3 & 0xffffffc0));
1070     assert(!(rs1 & 0xffffffe0));
1071     assert(!(rs2 & 0xffffffe0));
1072     v.op.b  = op;
1073     v.rd.b  = rd;
1074     v.op3.b = op3;
1075     v.rs1.b = rs1;
1076     v.i.b   = 1;
1077     v.asi.b = 0;
1078     v.rs2.b = rs2;
1079     ii(v.v);
1080 }
1081
1082 static void
1083 _f3rx(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1084       jit_int32_t op3, jit_int32_t rs1, jit_int32_t rs2)
1085 {
1086     jit_instr_t         v;
1087     assert(!(op  & 0xfffffffc));
1088     assert(!(rd  & 0xffffffe0));
1089     assert(!(op3 & 0xffffffc0));
1090     assert(!(rs1 & 0xffffffe0));
1091     assert(!(rs2 & 0xffffffe0));
1092     v.op.b   = op;
1093     v.rd.b   = rd;
1094     v.op3.b  = op3;
1095     v.rs1.b  = rs1;
1096     v.i.b    = 0;
1097     v.x.b    = 1;
1098     v.asix.b = 0;
1099     v.rs2.b  = rs2;
1100     ii(v.v);
1101 }
1102
1103 static void
1104 _f3s(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1105       jit_int32_t op3, jit_int32_t rs1, jit_int32_t shim)
1106 {
1107     jit_instr_t         v;
1108     assert(!(op   & 0xfffffffc));
1109     assert(!(rd   & 0xffffffe0));
1110     assert(!(op3  & 0xffffffc0));
1111     assert(!(rs1  & 0xffffffe0));
1112     assert(!(shim & 0xffffffc0));
1113     v.op.b   = op;
1114     v.rd.b   = rd;
1115     v.op3.b  = op3;
1116     v.rs1.b  = rs1;
1117     v.i.b    = 1;
1118     v.x.b    = 1;
1119     v.asis.b = 0;
1120     v.shim.b = shim;
1121     ii(v.v);
1122 }
1123 #  endif
1124
1125 static void
1126 _f3i(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1127      jit_int32_t op3, jit_int32_t rs1, jit_int32_t simm13)
1128 {
1129     jit_instr_t         v;
1130     assert(!(op  & 0xfffffffc));
1131     assert(!(rd  & 0xffffffe0));
1132     assert(!(op3 & 0xffffffc0));
1133     assert(!(rs1 & 0xffffffe0));
1134     assert(s13_p(simm13));
1135     v.op.b     = op;
1136     v.rd.b     = rd;
1137     v.op3.b    = op3;
1138     v.rs1.b    = rs1;
1139     v.i.b      = 1;
1140     v.simm13.b = simm13;
1141     ii(v.v);
1142 }
1143
1144 static void
1145 _f3t(jit_state_t *_jit, jit_int32_t cond,
1146      jit_int32_t rs1, jit_int32_t i, jit_int32_t rs2_imm7)
1147 {
1148     jit_instr_t         v;
1149     assert(!(cond & 0xfffffff0));
1150     assert(!(i    & 0xfffffffe));
1151     assert(!(rs1 & 0xffffffe0));
1152     v.op.b     = 2;
1153     v.rd.b     = cond;
1154     v.op3.b    = 58;
1155     v.i.b      = i;
1156     if (i) {
1157         assert(s7_p(rs2_imm7));
1158         v.res.b  = 0;
1159         v.imm7.b = rs2_imm7;
1160     }
1161     else {
1162         assert(!(rs2_imm7 & 0xffffffe0));
1163         v.asi.b = 0;
1164         v.rs2.b = rs2_imm7;
1165     }
1166     ii(v.v);
1167 }
1168
1169 static void
1170 _f3a(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1171      jit_int32_t op3, jit_int32_t rs1, jit_int32_t asi, jit_int32_t rs2)
1172 {
1173     jit_instr_t         v;
1174     assert(!(op  & 0xfffffffc));
1175     assert(!(rd  & 0xffffffe0));
1176     assert(!(op3 & 0xffffffc0));
1177     assert(!(rs1 & 0xffffffe0));
1178     assert(!(asi & 0xffffff00));
1179     assert(!(rs2 & 0xffffffe0));
1180     v.op.b    = op;
1181     v.rd.b    = rd;
1182     v.op3.b   = op3;
1183     v.rs1.b   = rs1;
1184     v.i.b     = 0;
1185     v.asi.b   = asi;
1186     v.rs2.b   = rs2;
1187     ii(v.v);
1188 }
1189
1190 static void
1191 _f1(jit_state_t *_jit, jit_int32_t op, jit_int32_t disp30)
1192 {
1193     jit_instr_t         v;
1194     assert(!(op  & 0xfffffffc));
1195     assert(s30_p(disp30));
1196     v.op.b     = op;
1197     v.disp30.b = disp30;
1198     ii(v.v);
1199 }
1200
1201 static void
1202 _f2c1(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1203       jit_int32_t op3, jit_int32_t rs1, jit_int32_t opf, jit_int32_t rs2)
1204 {
1205     jit_instr_t         v;
1206     assert(!(op  & 0xfffffffc));
1207     assert(!(rd  & 0xffffffe0));
1208     assert(!(res & 0xffffffc0));
1209     assert(!(rs1 & 0xffffffe0));
1210     assert(!(opf & 0xfffffe00));
1211     assert(!(rs2 & 0xfffffe00));
1212     v.op.b = op;
1213     v.rd.b = rd;
1214     v.op3.b = op3;
1215     v.rs1.b = rs1;
1216     v.opf.b = opf;
1217     v.rs2.b = rs2;
1218     ii(v.v);
1219 }
1220
1221 static void
1222 _nop(jit_state_t *_jit, jit_int32_t i0)
1223 {
1224     for (; i0 > 0; i0 -= 4)
1225         NOP();
1226     assert(i0 == 0);
1227 }
1228
1229 static void
1230 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1231 {
1232     if (r0 != r1)
1233         ORI(r1, 0, r0);
1234 }
1235
1236 static void
1237 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1238 {
1239     if (s13_p(i0))
1240         ORI(0, i0, r0);
1241     else {
1242 #  if __WORDSIZE == 64
1243         if (i0 & 0xffffffff00000000) {
1244             jit_int32_t reg = jit_get_reg(jit_class_gpr);
1245             movi(rn(reg), (i0 >> 32) & 0xffffffff);
1246             movi(r0, i0 & 0xffffffff);
1247             lshi(rn(reg), rn(reg), 32);
1248             OR(rn(reg), r0, r0);
1249             jit_unget_reg(reg);
1250         }
1251         else {
1252 #  endif
1253             SETHI(HI((int)i0), r0);
1254             if (LO(i0))
1255                 ORI(r0, LO(i0), r0);
1256 #  if __WORDSIZE == 64
1257         }
1258 #  endif
1259     }
1260 }
1261
1262 static jit_word_t
1263 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1264 {
1265     jit_word_t          w;
1266 #  if __WORDSIZE == 64
1267     jit_int32_t         reg;
1268 #  endif
1269     w = _jit->pc.w;
1270 #  if __WORDSIZE == 64
1271     reg = jit_get_reg(jit_class_gpr);
1272     SETHI(HI((int)i0), r0);
1273     ORI(r0, LO(i0), r0);
1274     i0 = (int)(i0 >> 32);
1275     SETHI(HI(i0), rn(reg));
1276     ORI(rn(reg), LO(i0), rn(reg));
1277     SLLXI(rn(reg), 32, rn(reg));
1278     OR(rn(reg), r0, r0);
1279     jit_unget_reg(reg);
1280 #  else
1281     SETHI(HI(i0), r0);
1282     ORI(r0, LO(i0), r0);
1283 #  endif
1284     return (w);
1285 }
1286
1287 static void
1288 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1289 {
1290     jit_word_t  w;
1291     w = beqi(_jit->pc.w, r2, 0);
1292     ORI(r1, 0, r0);
1293     patch_at(w, _jit->pc.w);
1294 }
1295
1296 static void
1297 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1298 {
1299     jit_word_t  w;
1300     w = bnei(_jit->pc.w, r2, 0);
1301     ORI(r1, 0, r0);
1302     patch_at(w, _jit->pc.w);
1303 }
1304
1305 static void
1306 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1307       jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1308 {
1309     jit_int32_t         iscasi, r1_reg;
1310     if ((iscasi = (r1 == _NOREG))) {
1311         r1_reg = jit_get_reg(jit_class_gpr);
1312         r1 = rn(r1_reg);
1313         movi(r1, i0);
1314     }
1315     /* Do not clobber r2 */
1316     movr(r0, r3);
1317     /* The CASXA instruction compares the value in register r[rs2] with
1318      * the doubleword in memory pointed to by the doubleword address in
1319      *  r[rs1]. If the values are equal, the value in r[rd] is swapped
1320      * with the doubleword pointed to by the doubleword address in r[rs1].
1321      *  If the values are not equal, the contents of the doubleword pointed
1322      *  to by r[rs1] replaces the value in r[rd], but the memory location
1323      * remains unchanged.
1324      */
1325 #  if __WORDSIZE == 32
1326     CASA(r1, r2, r0);
1327 #  else
1328     CASXA(r1, r2, r0);
1329 #  endif
1330     eqr(r0, r0, r2);
1331     if (iscasi)
1332         jit_unget_reg(r1_reg);
1333 }
1334
1335 static void
1336 _bitswap(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1337 {
1338     jit_int32_t         t0, t1, t2, t3, t4;
1339     movr(r0, r1);
1340     t0 = jit_get_reg(jit_class_gpr);
1341     t1 = jit_get_reg(jit_class_gpr);
1342     t2 = jit_get_reg(jit_class_gpr);
1343     movi(rn(t0), __WORDSIZE == 32 ? 0x55555555L : 0x5555555555555555L);
1344     rshi_u(rn(t1), r0, 1);              /* t1 = v >> 1 */
1345     andr(rn(t1), rn(t1), rn(t0));       /* t1 &= t0 */
1346     andr(rn(t2), r0, rn(t0));           /* t2 = v & t0*/
1347     lshi(rn(t2), rn(t2), 1);            /* t2 <<= 1 */
1348     orr(r0, rn(t1), rn(t2));            /* v = t1 | t2 */
1349     movi(rn(t0), __WORDSIZE == 32 ? 0x33333333L : 0x3333333333333333L);
1350     rshi_u(rn(t1), r0, 2);              /* t1 = v >> 2 */
1351     andr(rn(t1), rn(t1), rn(t0));       /* t1 &= t0 */
1352     andr(rn(t2), r0, rn(t0));           /* t2 = v & t0*/
1353     lshi(rn(t2), rn(t2), 2);            /* t2 <<= 2 */
1354     orr(r0, rn(t1), rn(t2));            /* v = t1 | t2 */
1355     movi(rn(t0), __WORDSIZE == 32 ? 0x0f0f0f0fL : 0x0f0f0f0f0f0f0f0fL);
1356     rshi_u(rn(t1), r0, 4);              /* t1 = v >> 4 */
1357     andr(rn(t1), rn(t1), rn(t0));       /* t1 &= t0 */
1358     andr(rn(t2), r0, rn(t0));           /* t2 = v & t0*/
1359     lshi(rn(t2), rn(t2), 4);            /* t2 <<= 4 */
1360     orr(r0, rn(t1), rn(t2));            /* v = t1 | t2 */
1361     movi(rn(t0), __WORDSIZE == 32 ?  0x00ff00ffL : 0x00ff00ff00ff00ffL);
1362     rshi_u(rn(t1), r0, 8);              /* t1 = v >> 8 */
1363     andr(rn(t1), rn(t1), rn(t0));       /* t1 &= t0 */
1364     andr(rn(t2), r0, rn(t0));           /* t2 = v & t0*/
1365     lshi(rn(t2), rn(t2), 8);            /* t2 <<= 8 */
1366     orr(r0, rn(t1), rn(t2));            /* v = t1 | t2 */
1367 #  if __WORDSIZE == 32
1368     rshi_u(rn(t1), r0, 16);             /* t1 = v >> 16 */
1369     lshi(rn(t2), r0, 16);               /* t2 = v << 16 */
1370     orr(r0, rn(t1), rn(t2));            /* v = t1 | t2 */
1371 #  else
1372     movi(rn(t0), 0x0000ffff0000ffffL);
1373     rshi_u(rn(t1), r0, 16);             /* t1 = v >> 16 */
1374     andr(rn(t1), rn(t1), rn(t0));       /* t1 &= t0 */
1375     andr(rn(t2), r0, rn(t0));           /* t2 = v & t0*/
1376     lshi(rn(t2), rn(t2), 16);           /* t2 <<= 16 */
1377     orr(r0, rn(t1), rn(t2));            /* v = t1 | t2 */
1378     rshi_u(rn(t1), r0, 32);             /* t1 = v >> 32 */
1379     lshi(rn(t2), r0, 32);               /* t2 = v << 32 */
1380     orr(r0, rn(t1), rn(t2));            /* v = t1 | t2 */
1381 #  endif
1382     jit_unget_reg(t2);
1383     jit_unget_reg(t1);
1384     jit_unget_reg(t0);
1385 }
1386
1387 static void
1388 _clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1389 {
1390     if (jit_cpu.lzcnt) {
1391         comr(r0, r1);
1392         clzr(r0, r0);
1393     }
1394     else
1395         fallback_clo(r0, r1);
1396 }
1397
1398 static void
1399 _clzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1400 {
1401     if (jit_cpu.lzcnt) {
1402 #if __WORDSIZE == 32
1403         jit_word_t              w;
1404         SLLXI(r1, 32, r0);
1405         LZCNT(r0, r0);
1406 #if __WORDSIZE == 32
1407         w = blei(_jit->pc.w, r0, 31);
1408         rshi(r0, r0, 1);        /* r0 is 64 */
1409         patch_at(w, _jit->pc.w);
1410 #endif
1411 #else
1412         LZCNT(r1, r0);
1413     }
1414     else
1415         fallback_clz(r0, r1);
1416 }
1417
1418 static void
1419 _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1420 {
1421     if (jit_cpu.lzcnt) {
1422         bitswap(r0, r1);
1423         clor(r0, r0);
1424     }
1425     else
1426         fallback_cto(r0, r1);
1427 }
1428
1429 static void
1430 _ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1431 {
1432     if (jit_cpu.lzcnt) {
1433         bitswap(r0, r1);
1434         clzr(r0, r0);
1435     }
1436     else
1437         fallback_ctz(r0, r1);
1438 }
1439
1440 static void
1441 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1442 {
1443     jit_int32_t         reg;
1444     if (s13_p(i0))
1445         ADDI(r1, i0, r0);
1446     else {
1447         reg = jit_get_reg(jit_class_gpr);
1448         movi(rn(reg), i0);
1449         addr(r0, r1, rn(reg));
1450         jit_unget_reg(reg);
1451     }
1452 }
1453
1454 #  if __WORDSIZE == 64
1455 static void
1456 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1457 {
1458     jit_int32_t         reg;
1459     if (jit_carry == _NOREG)
1460         jit_carry = jit_get_reg(jit_class_gpr);
1461     if (r0 == r1) {
1462         reg = jit_get_reg(jit_class_gpr);
1463         addr(rn(reg), r1, r2);
1464         ltr_u(rn(jit_carry), rn(reg), r1);
1465         movr(r0, rn(reg));
1466         jit_unget_reg(reg);
1467     }
1468     else {
1469         addr(r0, r1, r2);
1470         ltr_u(rn(jit_carry), r0, r1);
1471     }
1472 }
1473 #  endif
1474
1475 static void
1476 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1477 {
1478 #  if __WORDSIZE == 32
1479     jit_int32_t         reg;
1480     if (s13_p(i0))
1481         ADDIcc(r1, i0, r0);
1482     else {
1483         reg = jit_get_reg(jit_class_gpr);
1484         movi(rn(reg), i0);
1485         addcr(r0, r1, rn(reg));
1486         jit_unget_reg(reg);
1487     }
1488 #  else
1489     jit_int32_t         reg;
1490     if (jit_carry == _NOREG)
1491         jit_carry = jit_get_reg(jit_class_gpr);
1492     if (r0 == r1) {
1493         reg = jit_get_reg(jit_class_gpr);
1494         addi(rn(reg), r1, i0);
1495         ltr_u(rn(jit_carry), rn(reg), r1);
1496         movr(r0, rn(reg));
1497         jit_unget_reg(reg);
1498     }
1499     else {
1500         addi(r0, r1, i0);
1501         ltr_u(rn(jit_carry), r0, r1);
1502     }
1503 #  endif
1504 }
1505
1506 #  if __WORDSIZE == 64
1507 static void
1508 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1509 {
1510     jit_int32_t         reg;
1511     assert(jit_carry != _NOREG);
1512     reg = jit_get_reg(jit_class_gpr);
1513     movr(rn(reg), rn(jit_carry));
1514     addcr(r0, r1, r2);
1515     addcr(r0, r0, rn(reg));
1516     jit_unget_reg(reg);
1517 }
1518 #  endif
1519
1520 static void
1521 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1522 {
1523 #  if __WORDSIZE == 32
1524     jit_int32_t         reg;
1525     if (s13_p(i0))
1526         ADDXIcc(r1, i0, r0);
1527     else {
1528         reg = jit_get_reg(jit_class_gpr);
1529         movi(rn(reg), i0);
1530         addxr(r0, r1, rn(reg));
1531         jit_unget_reg(reg);
1532     }
1533 #  else
1534     jit_int32_t         reg;
1535     assert(jit_carry != _NOREG);
1536     reg = jit_get_reg(jit_class_gpr);
1537     movr(rn(reg), rn(jit_carry));
1538     addci(r0, r1, i0);
1539     addcr(r0, r0, rn(reg));
1540     jit_unget_reg(reg);
1541 #  endif
1542 }
1543
1544 static void
1545 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1546 {
1547     jit_int32_t         reg;
1548     if (s13_p(i0))
1549         SUBI(r1, i0, r0);
1550     else {
1551         reg = jit_get_reg(jit_class_gpr);
1552         movi(rn(reg), i0);
1553         subr(r0, r1, rn(reg));
1554         jit_unget_reg(reg);
1555     }
1556 }
1557
1558 #  if __WORDSIZE == 64
1559 static void
1560 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1561 {
1562     jit_int32_t         reg;
1563     if (jit_carry == _NOREG)
1564         jit_carry = jit_get_reg(jit_class_gpr);
1565     if (r0 == r1) {
1566         reg = jit_get_reg(jit_class_gpr);
1567         subr(rn(reg), r1, r2);
1568         ltr_u(rn(jit_carry), r1, rn(reg));
1569         movr(r0, rn(reg));
1570         jit_unget_reg(reg);
1571     }
1572     else {
1573         subr(r0, r1, r2);
1574         ltr_u(rn(jit_carry), r1, r0);
1575     }
1576 }
1577 #  endif
1578
1579 static void
1580 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1581 {
1582 #  if __WORDSIZE == 32
1583     jit_int32_t         reg;
1584     if (s13_p(i0))
1585         SUBIcc(r1, i0, r0);
1586     else {
1587         reg = jit_get_reg(jit_class_gpr);
1588         movi(rn(reg), i0);
1589         subcr(r0, r1, rn(reg));
1590         jit_unget_reg(reg);
1591     }
1592 #  else
1593     jit_int32_t         reg;
1594     if (jit_carry == _NOREG)
1595         jit_carry = jit_get_reg(jit_class_gpr);
1596     if (r0 == r1) {
1597         reg = jit_get_reg(jit_class_gpr);
1598         addi(rn(reg), r1, -i0);
1599         ltr_u(rn(jit_carry), r1, rn(reg));
1600         movr(r0, rn(reg));
1601         jit_unget_reg(reg);
1602     }
1603     else {
1604         addi(r0, r1, -i0);
1605         ltr_u(rn(jit_carry), r1, r0);
1606     }
1607 #  endif
1608 }
1609
1610 #  if __WORDSIZE == 64
1611 static void
1612 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1613 {
1614     jit_int32_t         reg;
1615     assert(jit_carry != _NOREG);
1616     reg = jit_get_reg(jit_class_gpr);
1617     movr(rn(reg), rn(jit_carry));
1618     subcr(r0, r1, r2);
1619     subcr(r0, r0, rn(reg));
1620     jit_unget_reg(reg);
1621 }
1622 #endif
1623
1624 static void
1625 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1626 {
1627 #  if __WORDSIZE == 32
1628     jit_int32_t         reg;
1629     if (s13_p(i0))
1630         SUBXIcc(r1, i0, r0);
1631     else {
1632         reg = jit_get_reg(jit_class_gpr);
1633         movi(rn(reg), i0);
1634         subxr(r0, r1, rn(reg));
1635         jit_unget_reg(reg);
1636     }
1637 #  else
1638     jit_int32_t         reg;
1639     assert(jit_carry != _NOREG);
1640     reg = jit_get_reg(jit_class_gpr);
1641     movr(rn(reg), rn(jit_carry));
1642     subci(r0, r1, i0);
1643     subcr(r0, r0, rn(reg));
1644     jit_unget_reg(reg);
1645 #  endif
1646 }
1647
1648 static void
1649 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1650 {
1651     subi(r0, r1, i0);
1652     negr(r0, r0);
1653 }
1654
1655 static void
1656 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1657 {
1658     jit_int32_t         reg;
1659     if (s13_p(i0)) {
1660 #  if __WORDSIZE == 32
1661         UMULI(r1, i0, r0);
1662 #  else
1663         MULXI(r1, i0, r0);
1664 #  endif
1665     }
1666     else {
1667         reg = jit_get_reg(jit_class_gpr);
1668         movi(rn(reg), i0);
1669         mulr(r0, r1, rn(reg));
1670         jit_unget_reg(reg);
1671     }
1672 }
1673
1674 #  if __WORDSIZE == 32
1675 static void
1676 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1677         jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1678 {
1679     if (sign)
1680         SMUL(r2, r3, r0);
1681     else
1682         UMUL(r2, r3, r0);
1683     RDY(r1);
1684 }
1685
1686 static void
1687 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1688         jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1689 {
1690     jit_int32_t         reg;
1691     if (s13_p(i0)) {
1692         if (sign)
1693             SMULI(r2, i0, r0);
1694         else
1695             UMULI(r2, i0, r0);
1696         RDY(r1);
1697     }
1698     else {
1699         reg = jit_get_reg(jit_class_gpr);
1700         movi(rn(reg), i0);
1701         iqmulr(r0, r1, r2, rn(reg), sign);
1702         jit_unget_reg(reg);
1703     }
1704 }
1705
1706 #  else
1707 static __int128_t __llmul(jit_word_t a, jit_word_t b)
1708 {
1709     return (__int128_t)a * (__int128_t)b;
1710 }
1711
1712 #  define QMUL_PROLOG()                                         \
1713     do {                                                        \
1714         (void)jit_get_reg(_O0|jit_class_gpr|jit_class_named);   \
1715         (void)jit_get_reg(_O1|jit_class_gpr|jit_class_named);   \
1716         if (r0 != _G2_REGNO && r1 != _G2_REGNO)                 \
1717             stxi(BIAS(-8), _FP_REGNO, _G2_REGNO);               \
1718         if (r0 != _G3_REGNO && r1 != _G3_REGNO)                 \
1719             stxi(BIAS(-16), _FP_REGNO, _G3_REGNO);              \
1720         if (r0 != _G4_REGNO && r1 != _G4_REGNO)                 \
1721             stxi(BIAS(-24), _FP_REGNO, _G4_REGNO);              \
1722     } while (0)
1723
1724 #  define QMUL_EPILOG()                                         \
1725     do {                                                        \
1726         if (r0 != _G2_REGNO && r1 != _G2_REGNO)                 \
1727             ldxi(_G2_REGNO, _FP_REGNO, BIAS(-8));               \
1728         if (r0 != _G3_REGNO && r1 != _G3_REGNO)                 \
1729             ldxi(_G3_REGNO, _FP_REGNO, BIAS(-16));              \
1730         if (r0 != _G4_REGNO && r1 != _G4_REGNO)                 \
1731             ldxi(_G4_REGNO, _FP_REGNO, BIAS(-24));              \
1732         (void)jit_unget_reg(_O0);                               \
1733         (void)jit_unget_reg(_O1);                               \
1734     } while (0)
1735
1736 static void
1737 _qmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1738        jit_int32_t r2, jit_int32_t r3)
1739 {
1740     QMUL_PROLOG();
1741     movr(_O0_REGNO, r3);
1742     movr(_O1_REGNO, r2);
1743     calli((jit_word_t)__llmul);
1744     movr(r0, _O1_REGNO);
1745     movr(r1, _O0_REGNO);
1746     QMUL_EPILOG();
1747 }
1748
1749 static void
1750 _qmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1751        jit_int32_t r2, jit_word_t i0)
1752 {
1753     QMUL_PROLOG();
1754     movi(_O0_REGNO, i0);
1755     movr(_O1_REGNO, r2);
1756     calli((jit_word_t)__llmul);
1757     movr(r0, _O1_REGNO);
1758     movr(r1, _O0_REGNO);
1759     QMUL_EPILOG();
1760 }
1761
1762 static __uint128_t __ullmul(jit_uword_t a, jit_uword_t b)
1763 {
1764     return (__uint128_t)a * (__uint128_t)b;
1765 }
1766
1767 static void
1768 _qmulr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1769          jit_int32_t r2, jit_int32_t r3)
1770 {
1771     QMUL_PROLOG();
1772     movr(_O0_REGNO, r3);
1773     movr(_O1_REGNO, r2);
1774     calli((jit_word_t)__ullmul);
1775     movr(r0, _O1_REGNO);
1776     movr(r1, _O0_REGNO);
1777     QMUL_EPILOG();
1778 }
1779
1780 static void
1781 _qmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1782          jit_int32_t r2, jit_word_t i0)
1783 {
1784     QMUL_PROLOG();
1785     movi(_O0_REGNO, i0);
1786     movr(_O1_REGNO, r2);
1787     calli((jit_word_t)__ullmul);
1788     movr(r0, _O1_REGNO);
1789     movr(r1, _O0_REGNO);
1790     QMUL_EPILOG();
1791 }
1792 #  endif
1793
1794 static void
1795 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1796 {
1797 #  if __WORDSIZE == 32
1798     jit_int32_t         reg;
1799     reg = jit_get_reg(jit_class_gpr);
1800     rshi(rn(reg), r1, 31);
1801     WRY(rn(reg), 0);
1802     SDIV(r1, r2, r0);
1803     jit_unget_reg(reg);
1804 #  else
1805     SDIVX(r1, r2, r0);
1806 #  endif
1807 }
1808
1809 static void
1810 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1811 {
1812     jit_int32_t         reg;
1813 #  if __WORDSIZE == 32
1814     reg = jit_get_reg(jit_class_gpr);
1815 #  endif
1816     if (s13_p(i0)) {
1817 #  if __WORDSIZE == 32
1818         rshi(rn(reg), r1, 31);
1819         WRY(rn(reg), 0);
1820         SDIVI(r1, i0, r0);
1821 #  else
1822         SDIVXI(r1, i0, r0);
1823 #  endif
1824     }
1825     else {
1826 #  if __WORDSIZE == 64
1827         reg = jit_get_reg(jit_class_gpr);
1828 #  endif
1829         movi(rn(reg), i0);
1830         divr(r0, r1, rn(reg));
1831 #  if __WORDSIZE == 64
1832         jit_unget_reg(reg);
1833 #  endif
1834     }
1835 #  if __WORDSIZE == 32
1836     jit_unget_reg(reg);
1837 #  endif
1838 }
1839
1840 static void
1841 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1842 {
1843 #  if __WORDSIZE == 32
1844     WRYI(0, 0);
1845     UDIV(r1, r2, r0);
1846 #  else
1847     UDIVX(r1, r2, r0);
1848 #  endif
1849 }
1850
1851 static void
1852 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1853 {
1854     jit_int32_t         reg;
1855     if (s13_p(i0)) {
1856 #  if __WORDSIZE == 32
1857         WRYI(0, 0);
1858         UDIVI(r1, i0, r0);
1859 #  else
1860         UDIVXI(r1, i0, r0);
1861 #  endif
1862     }
1863     else {
1864         reg = jit_get_reg(jit_class_gpr);
1865         movi(rn(reg), i0);
1866         divr_u(r0, r1, rn(reg));
1867         jit_unget_reg(reg);
1868     }
1869 }
1870
1871 static void
1872 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1873         jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1874 {
1875     jit_int32_t         sv0, rg0;
1876     jit_int32_t         sv1, rg1;
1877
1878     if (r0 == r2 || r0 == r3) {
1879         sv0 = jit_get_reg(jit_class_gpr);
1880         rg0 = rn(sv0);
1881     }
1882     else
1883         rg0 = r0;
1884     if (r1 == r2 || r1 == r3) {
1885         sv1 = jit_get_reg(jit_class_gpr);
1886         rg1 = rn(sv1);
1887     }
1888     else
1889         rg1 = r1;
1890
1891     if (sign)
1892         divr(rg0, r2, r3);
1893     else
1894         divr_u(rg0, r2, r3);
1895     mulr(rg1, r3, rg0);
1896     subr(rg1, r2, rg1);
1897     if (rg0 != r0) {
1898         movr(r0, rg0);
1899         jit_unget_reg(sv0);
1900     }
1901     if (rg1 != r1) {
1902         movr(r1, rg1);
1903         jit_unget_reg(sv1);
1904     }
1905 }
1906
1907 static void
1908 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1909         jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1910 {
1911     jit_int32_t         reg;
1912     reg = jit_get_reg(jit_class_gpr);
1913     movi(rn(reg), i0);
1914     iqdivr(r0, r1, r2, rn(reg), sign);
1915     jit_unget_reg(reg);
1916 }
1917
1918 static void
1919 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1920 {
1921     jit_int32_t         reg;
1922     if (r0 == r1 || r0 == r2) {
1923         reg = jit_get_reg(jit_class_gpr);
1924         divr(rn(reg), r1, r2);
1925         mulr(rn(reg), r2, rn(reg));
1926         subr(r0, r1, rn(reg));
1927         jit_unget_reg(reg);
1928     }
1929     else {
1930         divr(r0, r1, r2);
1931         mulr(r0, r2, r0);
1932         subr(r0, r1, r0);
1933     }
1934 }
1935
1936 static void
1937 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1938 {
1939     jit_int32_t         reg;
1940     reg = jit_get_reg(jit_class_gpr);
1941     movi(rn(reg), i0);
1942     remr(r0, r1, rn(reg));
1943     jit_unget_reg(reg);
1944 }
1945
1946 static void
1947 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1948 {
1949     jit_int32_t         reg;
1950     if (r0 == r1 || r0 == r2) {
1951         reg = jit_get_reg(jit_class_gpr);
1952         divr_u(rn(reg), r1, r2);
1953         mulr(rn(reg), r2, rn(reg));
1954         subr(r0, r1, rn(reg));
1955         jit_unget_reg(reg);
1956     }
1957     else {
1958         divr_u(r0, r1, r2);
1959         mulr(r0, r2, r0);
1960         subr(r0, r1, r0);
1961     }
1962 }
1963
1964 static void
1965 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1966 {
1967     jit_int32_t         reg;
1968     reg = jit_get_reg(jit_class_gpr);
1969     movi(rn(reg), i0);
1970     remr_u(r0, r1, rn(reg));
1971     jit_unget_reg(reg);
1972 }
1973
1974 static void
1975 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1976 {
1977     jit_int32_t         reg;
1978     if (s13_p(i0))
1979         ANDI(r1, i0, r0);
1980     else {
1981         reg = jit_get_reg(jit_class_gpr);
1982         movi(rn(reg), i0);
1983         andr(r0, r1, rn(reg));
1984         jit_unget_reg(reg);
1985     }
1986 }
1987
1988 static void
1989 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1990 {
1991     jit_int32_t         reg;
1992     if (s13_p(i0))
1993         ORI(r1, i0, r0);
1994     else {
1995         reg = jit_get_reg(jit_class_gpr);
1996         movi(rn(reg), i0);
1997         orr(r0, r1, rn(reg));
1998         jit_unget_reg(reg);
1999     }
2000 }
2001
2002 static void
2003 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2004 {
2005     jit_int32_t         reg;
2006     if (s13_p(i0))
2007         XORI(r1, i0, r0);
2008     else {
2009         reg = jit_get_reg(jit_class_gpr);
2010         movi(rn(reg), i0);
2011         xorr(r0, r1, rn(reg));
2012         jit_unget_reg(reg);
2013     }
2014 }
2015
2016 static void
2017 _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2018 {
2019     lshi(r0, r1, __WORDSIZE - 8);
2020     rshi(r0, r0, __WORDSIZE - 8);
2021 }
2022
2023 static void
2024 _extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2025 {
2026     lshi(r0, r1, __WORDSIZE - 16);
2027     rshi(r0, r0, __WORDSIZE - 16);
2028 }
2029
2030 static void
2031 _extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2032 {
2033     lshi(r0, r1, __WORDSIZE - 16);
2034     rshi_u(r0, r0, __WORDSIZE - 16);
2035 }
2036
2037 #if __WORDSIZE == 64
2038 static void
2039 _extr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2040 {
2041     lshi(r0, r1, __WORDSIZE - 32);
2042     rshi(r0, r0, __WORDSIZE - 32);
2043 }
2044
2045 static void
2046 _extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2047 {
2048     lshi(r0, r1, __WORDSIZE - 32);
2049     rshi_u(r0, r0, __WORDSIZE - 32);
2050 }
2051 #endif
2052
2053 static void
2054 _cr(jit_state_t *_jit, jit_int32_t cc,
2055     jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2056 {
2057     CMP(r1, r2);
2058 #  if __WORDSIZE == 32
2059     Ba(cc, 3);
2060 #  else
2061     BPa(cc, 3);
2062 #  endif
2063     movi(r0, 1);
2064     movi(r0, 0);
2065 }
2066
2067 static void
2068 _cw(jit_state_t *_jit, jit_int32_t cc,
2069     jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2070 {
2071     jit_int32_t         reg;
2072     if (s13_p(i0)) {
2073         CMPI(r1, i0);
2074 #  if __WORDSIZE == 32
2075         Ba(cc, 3);
2076 #  else
2077         BPa(cc, 3);
2078 #  endif
2079         movi(r0, 1);
2080         movi(r0, 0);
2081     }
2082     else {
2083         reg = jit_get_reg(jit_class_gpr);
2084         movi(rn(reg), i0);
2085         cr(cc, r0, r1, rn(reg));
2086         jit_unget_reg(reg);
2087     }
2088 }
2089
2090 static void
2091 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2092 {
2093     jit_int32_t         reg;
2094     if (s13_p(i0))
2095         LDSBI(0, i0, r0);
2096     else {
2097         reg = jit_get_reg(jit_class_gpr);
2098         movi(rn(reg), i0);
2099         ldr_c(r0, rn(reg));
2100         jit_unget_reg(reg);
2101     }
2102 }
2103
2104 static void
2105 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2106 {
2107     jit_int32_t         reg;
2108     if (s13_p(i0))
2109         LDUBI(0, i0, r0);
2110     else {
2111         reg = jit_get_reg(jit_class_gpr);
2112         movi(rn(reg), i0);
2113         ldr_uc(r0, rn(reg));
2114         jit_unget_reg(reg);
2115     }
2116 }
2117
2118 static void
2119 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2120 {
2121     jit_int32_t         reg;
2122     if (s13_p(i0))
2123         LDSHI(0, i0, r0);
2124     else {
2125         reg = jit_get_reg(jit_class_gpr);
2126         movi(rn(reg), i0);
2127         ldr_s(r0, rn(reg));
2128         jit_unget_reg(reg);
2129     }
2130 }
2131
2132 static void
2133 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2134 {
2135     jit_int32_t         reg;
2136     if (s13_p(i0))
2137         LDUHI(0, i0, r0);
2138     else {
2139         reg = jit_get_reg(jit_class_gpr);
2140         movi(rn(reg), i0);
2141         ldr_us(r0, rn(reg));
2142         jit_unget_reg(reg);
2143     }
2144 }
2145
2146 static void
2147 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2148 {
2149     jit_int32_t         reg;
2150     if (s13_p(i0)) {
2151 #  if __WORDSIZE == 32
2152         LDI(0, i0, r0);
2153 #  else
2154         LDSWI(0, i0, r0);
2155 #  endif
2156     }
2157     else {
2158         reg = jit_get_reg(jit_class_gpr);
2159         movi(rn(reg), i0);
2160         ldr_i(r0, rn(reg));
2161         jit_unget_reg(reg);
2162     }
2163 }
2164
2165 #  if __WORDSIZE == 64
2166 static void
2167 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2168 {
2169     jit_int32_t         reg;
2170     if (s13_p(i0))
2171         LDUWI(0, i0, r0);
2172     else {
2173         reg = jit_get_reg(jit_class_gpr);
2174         movi(rn(reg), i0);
2175         ldr_ui(r0, rn(reg));
2176         jit_unget_reg(reg);
2177     }
2178 }
2179
2180 static void
2181 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2182 {
2183     jit_int32_t         reg;
2184     if (s13_p(i0))
2185         LDXI(0, i0, r0);
2186     else {
2187         reg = jit_get_reg(jit_class_gpr);
2188         movi(rn(reg), i0);
2189         ldr_l(r0, rn(reg));
2190         jit_unget_reg(reg);
2191     }
2192 }
2193 #  endif
2194
2195 static void
2196 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2197 {
2198     jit_int32_t         reg;
2199     if (s13_p(i0))
2200         LDSBI(r1, i0, r0);
2201     else {
2202         reg = jit_get_reg(jit_class_gpr);
2203         movi(rn(reg), i0);
2204         ldxr_c(r0, r1, rn(reg));
2205         jit_unget_reg(reg);
2206     }
2207 }
2208
2209 static void
2210 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2211 {
2212     jit_int32_t         reg;
2213     if (s13_p(i0))
2214         LDUBI(r1, i0, r0);
2215     else {
2216         reg = jit_get_reg(jit_class_gpr);
2217         movi(rn(reg), i0);
2218         ldxr_uc(r0, r1, rn(reg));
2219         jit_unget_reg(reg);
2220     }
2221 }
2222
2223 static void
2224 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2225 {
2226     jit_int32_t         reg;
2227     if (s13_p(i0))
2228         LDSHI(r1, i0, r0);
2229     else {
2230         reg = jit_get_reg(jit_class_gpr);
2231         movi(rn(reg), i0);
2232         ldxr_s(r0, r1, rn(reg));
2233         jit_unget_reg(reg);
2234     }
2235 }
2236
2237 static void
2238 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2239 {
2240     jit_int32_t         reg;
2241     if (s13_p(i0))
2242         LDUHI(r1, i0, r0);
2243     else {
2244         reg = jit_get_reg(jit_class_gpr);
2245         movi(rn(reg), i0);
2246         ldxr_us(r0, r1, rn(reg));
2247         jit_unget_reg(reg);
2248     }
2249 }
2250
2251 static void
2252 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2253 {
2254     jit_int32_t         reg;
2255     if (s13_p(i0)) {
2256 #  if __WORDSIZE == 32
2257         LDI(r1, i0, r0);
2258 #  else
2259         LDSWI(r1, i0, r0);
2260 #  endif
2261     }
2262     else {
2263         reg = jit_get_reg(jit_class_gpr);
2264         movi(rn(reg), i0);
2265         ldxr_i(r0, r1, rn(reg));
2266         jit_unget_reg(reg);
2267     }
2268 }
2269
2270 #  if __WORDSIZE == 64
2271 static void
2272 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2273 {
2274     jit_int32_t         reg;
2275     if (s13_p(i0))
2276         LDUWI(r1, i0, r0);
2277     else {
2278         reg = jit_get_reg(jit_class_gpr);
2279         movi(rn(reg), i0);
2280         ldxr_ui(r0, r1, rn(reg));
2281         jit_unget_reg(reg);
2282     }
2283 }
2284
2285 static void
2286 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2287 {
2288     jit_int32_t         reg;
2289     if (s13_p(i0))
2290         LDXI(r1, i0, r0);
2291     else {
2292         reg = jit_get_reg(jit_class_gpr);
2293         movi(rn(reg), i0);
2294         ldxr_l(r0, r1, rn(reg));
2295         jit_unget_reg(reg);
2296     }
2297 }
2298 #  endif
2299
2300 static void
2301 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2302 {
2303     jit_int32_t         reg;
2304     if (s13_p(i0))
2305         STBI(r0, 0, i0);
2306     else {
2307         reg = jit_get_reg(jit_class_gpr);
2308         movi(rn(reg), i0);
2309         str_c(rn(reg), r0);
2310         jit_unget_reg(reg);
2311     }
2312 }
2313
2314 static void
2315 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2316 {
2317     jit_int32_t         reg;
2318     if (s13_p(i0))
2319         STHI(r0, 0, i0);
2320     else {
2321         reg = jit_get_reg(jit_class_gpr);
2322         movi(rn(reg), i0);
2323         str_s(rn(reg), r0);
2324         jit_unget_reg(reg);
2325     }
2326 }
2327
2328 static void
2329 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2330 {
2331     jit_int32_t         reg;
2332     if (s13_p(i0)) {
2333 #  if __WORDSIZE == 32
2334         STI(r0, 0, i0);
2335 #  else
2336         STWI(r0, 0, i0);
2337 #  endif
2338     }
2339     else {
2340         reg = jit_get_reg(jit_class_gpr);
2341         movi(rn(reg), i0);
2342         str_i(rn(reg), r0);
2343         jit_unget_reg(reg);
2344     }
2345 }
2346
2347 #  if __WORDSIZE == 64
2348 static void
2349 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2350 {
2351     jit_int32_t         reg;
2352     if (s13_p(i0))
2353         STXI(r0, 0, i0);
2354     else {
2355         reg = jit_get_reg(jit_class_gpr);
2356         movi(rn(reg), i0);
2357         str_l(rn(reg), r0);
2358         jit_unget_reg(reg);
2359     }
2360 }
2361 #  endif
2362
2363 static void
2364 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2365 {
2366     jit_int32_t         reg;
2367     if (s13_p(i0))
2368         STBI(r1, r0, i0);
2369     else {
2370         reg = jit_get_reg(jit_class_gpr);
2371         movi(rn(reg), i0);
2372         stxr_c(r0, rn(reg), r1);
2373         jit_unget_reg(reg);
2374     }
2375 }
2376
2377 static void
2378 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2379 {
2380     jit_int32_t         reg;
2381     if (s13_p(i0))
2382         STHI(r1, r0, i0);
2383     else {
2384         reg = jit_get_reg(jit_class_gpr);
2385         movi(rn(reg), i0);
2386         stxr_s(r0, rn(reg), r1);
2387         jit_unget_reg(reg);
2388     }
2389 }
2390
2391 static void
2392 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2393 {
2394     jit_int32_t         reg;
2395     if (s13_p(i0)) {
2396 #  if __WORDSIZE == 32
2397         STI(r1, r0, i0);
2398 #  else
2399         STWI(r1, r0, i0);
2400 #  endif
2401     }
2402     else {
2403         reg = jit_get_reg(jit_class_gpr);
2404         movi(rn(reg), i0);
2405         stxr_i(r0, rn(reg), r1);
2406         jit_unget_reg(reg);
2407     }
2408 }
2409
2410 #  if __WORDSIZE == 64
2411 static void
2412 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2413 {
2414     jit_int32_t         reg;
2415     if (s13_p(i0))
2416         STXI(r1, r0, i0);
2417     else {
2418         reg = jit_get_reg(jit_class_gpr);
2419         movi(rn(reg), i0);
2420         stxr_l(r0, rn(reg), r1);
2421         jit_unget_reg(reg);
2422     }
2423 }
2424 #  endif
2425
2426 static jit_word_t
2427 _br(jit_state_t *_jit, jit_int32_t cc,
2428     jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2429 {
2430     jit_word_t          w;
2431     CMP(r0, r1);
2432     w = _jit->pc.w;
2433 #  if __WORDSIZE == 32
2434     B(cc, (i0 - w) >> 2);
2435 #  else
2436     BP(cc, (i0 - w) >> 2);
2437 #  endif
2438     NOP();
2439     return (w);
2440 }
2441
2442 static jit_word_t
2443 _bw(jit_state_t *_jit, jit_int32_t cc,
2444     jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2445 {
2446     jit_word_t          w;
2447     jit_int32_t         reg;
2448     if (s13_p(i1)) {
2449         CMPI(r0, i1);
2450         w = _jit->pc.w;
2451 #  if __WORDSIZE == 32
2452         B(cc, (i0 - w) >> 2);
2453 #  else
2454         BP(cc, (i0 - w) >> 2);
2455 #  endif
2456         NOP();
2457     }
2458     else {
2459         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2460         movi(rn(reg), i1);
2461         w = br(cc, i0, r0, rn(reg));
2462         jit_unget_reg(reg);
2463     }
2464     return (w);
2465 }
2466
2467 static jit_word_t
2468 _b_asr(jit_state_t *_jit, jit_bool_t jif, jit_bool_t add, jit_bool_t sgn,
2469        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2470 {
2471     jit_word_t          w;
2472     if (add)
2473         ADDcc(r0, r1, r0);
2474     else
2475         SUBcc(r0, r1, r0);
2476     w = _jit->pc.w;
2477 #  if __WORDSIZE == 32
2478     B(sgn ?
2479       (jif ? SPARC_BVS : SPARC_BVC) :
2480       (jif ? SPARC_BCS : SPARC_BCC),
2481       (i0 - w) >> 2);
2482 #  else
2483     BP(sgn ?
2484        (jif ? SPARC_BPVS : SPARC_BPVC) :
2485        (jif ? SPARC_BPCS : SPARC_BPCC),
2486        (i0 - w) >> 2);
2487 #  endif
2488     NOP();
2489     return (w);
2490 }
2491
2492 static jit_word_t
2493 _b_asw(jit_state_t *_jit, jit_bool_t jif, jit_bool_t add, jit_bool_t sgn,
2494        jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2495 {
2496     jit_word_t          w;
2497     jit_int32_t         reg;
2498     if (s13_p(i1)) {
2499         if (add)
2500             ADDIcc(r0, i1, r0);
2501         else
2502             SUBIcc(r0, i1, r0);
2503         w = _jit->pc.w;
2504 #  if __WORDSIZE == 32
2505         B(sgn ?
2506           (jif ? SPARC_BVS : SPARC_BVC) :
2507           (jif ? SPARC_BCS : SPARC_BCC),
2508           (i0 - w) >> 2);
2509 #  else
2510         BP(sgn ?
2511            (jif ? SPARC_BPVS : SPARC_BPVC) :
2512            (jif ? SPARC_BPCS : SPARC_BPCC),
2513            (i0 - w) >> 2);
2514 #  endif
2515         NOP();
2516     }
2517     else {
2518         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2519         movi(rn(reg), i1);
2520         w = b_asr(jif, add, sgn, i0, r0, rn(reg));
2521         jit_unget_reg(reg);
2522     }
2523     return (w);
2524 }
2525
2526 static jit_word_t
2527 _bm_r(jit_state_t *_jit, jit_bool_t set,
2528       jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2529 {
2530     jit_word_t          w;
2531     BTST(r0, r1);
2532     w = _jit->pc.w;
2533 #  if __WORDSIZE == 32
2534     B(set ? SPARC_BNZ : SPARC_BZ, (i0 - w) >> 2);
2535 #  else
2536     BP(set ? SPARC_BPNE : SPARC_BPE, (i0 - w) >> 2);
2537 #  endif
2538     NOP();
2539     return (w);
2540 }
2541
2542 static jit_word_t
2543 _bm_w(jit_state_t *_jit, jit_bool_t set,
2544       jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2545 {
2546     jit_word_t          w;
2547     jit_int32_t         reg;
2548     if (s13_p(i1)) {
2549         BTSTI(r0, i1);
2550         w = _jit->pc.w;
2551 #  if __WORDSIZE == 32
2552         B(set ? SPARC_BNZ : SPARC_BZ, (i0 - w) >> 2);
2553 #  else
2554         BP(set ? SPARC_BPNE : SPARC_BPE, (i0 - w) >> 2);
2555 #  endif
2556         NOP();
2557     }
2558     else {
2559         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2560         movi(rn(reg), i1);
2561         w = bm_r(set, i0, r0, rn(reg));
2562         jit_unget_reg(reg);
2563     }
2564     return (w);
2565 }
2566
2567 static void
2568 _jmpr(jit_state_t *_jit, jit_int32_t r0)
2569 {
2570     JMPL(0, r0, 0);
2571     NOP();
2572 }
2573
2574 static jit_word_t
2575 _jmpi(jit_state_t *_jit, jit_word_t i0)
2576 {
2577     jit_int32_t         reg;
2578     jit_word_t          d, w;
2579     w = _jit->pc.w;
2580     d = (i0 - w) >> 2;
2581     if (s22_p(d)) {
2582         BA(d);
2583         NOP();
2584     }
2585     else {
2586         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2587         movi(rn(reg), i0);
2588         jmpr(rn(reg));
2589         jit_unget_reg(reg);
2590     }
2591     return (w);
2592 }
2593
2594 static jit_word_t
2595 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
2596 {
2597     jit_word_t          w;
2598     jit_int32_t         reg;
2599     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2600     w = movi_p(rn(reg), i0);
2601     jmpr(rn(reg));
2602     jit_unget_reg(reg);
2603     return (w);
2604 }
2605
2606 static void
2607 _callr(jit_state_t *_jit, jit_int32_t r0)
2608 {
2609     CALL(r0);
2610     NOP();
2611 }
2612
2613 static jit_word_t
2614 _calli(jit_state_t *_jit, jit_word_t i0)
2615 {
2616     jit_word_t          d, w;
2617     w = _jit->pc.w;
2618     d = (i0 - w) >> 2;
2619     if (s30_p(d)) {
2620         CALLI(d);
2621         NOP();
2622     }
2623     else
2624         w = calli_p(i0);
2625     return (w);
2626 }
2627
2628 static jit_word_t
2629 _calli_p(jit_state_t *_jit, jit_word_t i0)
2630 {
2631     jit_word_t          w;
2632     jit_int32_t         reg;
2633     reg = jit_get_reg(jit_class_gpr);
2634     w = movi_p(rn(reg), i0);
2635     callr(rn(reg));
2636     jit_unget_reg(reg);
2637     return (w);
2638 }
2639
2640 #define OFF(n)          BIAS(((n) * sizeof(jit_word_t)))
2641 static void
2642 _prolog(jit_state_t *_jit, jit_node_t *node)
2643 {
2644     jit_int32_t         reg;
2645     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2646         jit_int32_t     frame = -_jitc->function->frame;
2647         assert(_jitc->function->self.aoff >= frame);
2648         if (_jitc->function->assume_frame)
2649             return;
2650         _jitc->function->self.aoff = frame;
2651     }
2652     if (_jitc->function->allocar)
2653         _jitc->function->self.aoff &= -16;
2654     /* align at 16 bytes boundary */
2655     _jitc->function->stack = ((stack_framesize +
2656                               _jitc->function->self.alen -
2657                               _jitc->function->self.aoff) + 15) & -16;
2658     SAVEI(_SP_REGNO, -_jitc->function->stack, _SP_REGNO);
2659
2660     /* (most) other backends do not save incoming arguments, so,
2661      * only save locals here */
2662     if (jit_regset_tstbit(&_jitc->function->regset, _L0))
2663         stxi(OFF(0), _SP_REGNO, _L0_REGNO);
2664     if (jit_regset_tstbit(&_jitc->function->regset, _L1))
2665         stxi(OFF(1), _SP_REGNO, _L1_REGNO);
2666     if (jit_regset_tstbit(&_jitc->function->regset, _L2))
2667         stxi(OFF(2), _SP_REGNO, _L2_REGNO);
2668     if (jit_regset_tstbit(&_jitc->function->regset, _L3))
2669         stxi(OFF(3), _SP_REGNO, _L3_REGNO);
2670     if (jit_regset_tstbit(&_jitc->function->regset, _L4))
2671         stxi(OFF(4), _SP_REGNO, _L4_REGNO);
2672     if (jit_regset_tstbit(&_jitc->function->regset, _L5))
2673         stxi(OFF(5), _SP_REGNO, _L5_REGNO);
2674     if (jit_regset_tstbit(&_jitc->function->regset, _L6))
2675         stxi(OFF(6), _SP_REGNO, _L6_REGNO);
2676     if (jit_regset_tstbit(&_jitc->function->regset, _L7))
2677         stxi(OFF(7), _SP_REGNO, _L7_REGNO);
2678
2679     if (_jitc->function->allocar) {
2680         reg = jit_get_reg(jit_class_gpr);
2681         movi(rn(reg), BIAS(_jitc->function->self.aoff));
2682         /* Already "biased" by allocai */
2683         stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(reg));
2684         jit_unget_reg(reg);
2685     }
2686
2687     if (_jitc->function->self.call & jit_call_varargs) {
2688         for (reg = _jitc->function->vagp; jit_arg_reg_p(reg); ++reg)
2689             stxi(BIAS((16 + (__WORDSIZE == 32)) * sizeof(jit_word_t) +
2690                       reg * sizeof(jit_word_t)), _FP_REGNO, rn(_I0 + reg));
2691     }
2692 }
2693
2694 static void
2695 _epilog(jit_state_t *_jit, jit_node_t *node)
2696 {
2697     if (_jitc->function->assume_frame)
2698         return;
2699     if (_jitc->function->allocar)
2700         subi(_SP_REGNO, _FP_REGNO, _jitc->function->stack);
2701     if (jit_regset_tstbit(&_jitc->function->regset, _L0))
2702         ldxi(_L0_REGNO, _SP_REGNO, _jitc->function->stack + OFF(0));
2703     if (jit_regset_tstbit(&_jitc->function->regset, _L1))
2704         ldxi(_L1_REGNO, _SP_REGNO, _jitc->function->stack + OFF(1));
2705     if (jit_regset_tstbit(&_jitc->function->regset, _L2))
2706         ldxi(_L2_REGNO, _SP_REGNO, _jitc->function->stack + OFF(2));
2707     if (jit_regset_tstbit(&_jitc->function->regset, _L3))
2708         ldxi(_L3_REGNO, _SP_REGNO, _jitc->function->stack + OFF(3));
2709     if (jit_regset_tstbit(&_jitc->function->regset, _L4))
2710         ldxi(_L4_REGNO, _SP_REGNO, _jitc->function->stack + OFF(4));
2711     if (jit_regset_tstbit(&_jitc->function->regset, _L5))
2712         ldxi(_L5_REGNO, _SP_REGNO, _jitc->function->stack + OFF(5));
2713     if (jit_regset_tstbit(&_jitc->function->regset, _L6))
2714         ldxi(_L6_REGNO, _SP_REGNO, _jitc->function->stack + OFF(6));
2715     if (jit_regset_tstbit(&_jitc->function->regset, _L7))
2716         ldxi(_L7_REGNO, _SP_REGNO, _jitc->function->stack + OFF(7));
2717     RESTOREI(0, 0, 0);
2718     RETL();
2719     NOP();
2720 }
2721
2722 static void
2723 _vastart(jit_state_t *_jit, jit_int32_t r0)
2724 {
2725     /* Initialize stack pointer to the first stack argument. */
2726     if (jit_arg_reg_p(_jitc->function->vagp))
2727         addi(r0, _FP_REGNO, BIAS((16 + (__WORDSIZE == 32) +
2728                                   _jitc->function->vagp) *
2729                                  sizeof(jit_word_t)));
2730     else
2731         addi(r0, _FP_REGNO, BIAS(_jitc->function->self.size));
2732 }
2733
2734 static void
2735 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2736 {
2737     assert(_jitc->function->self.call & jit_call_varargs);
2738
2739     /* Load argument. */
2740     ldr(r0, r1);
2741
2742     /* Update vararg stack pointer. */
2743     addi(r1, r1, sizeof(jit_word_t));
2744 }
2745
2746 static void
2747 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
2748 {
2749     jit_instr_t          i;
2750     union {
2751         jit_int32_t     *i;
2752         jit_word_t       w;
2753     } u;
2754
2755     u.w = instr;
2756     i.v = u.i[0];
2757
2758     if (i.op.b == 0) {                          /* conditional branch */
2759         if (i.op2.b == 2 || i.op2.b == 6) {     /* int or float condition */
2760             i.disp22.b = (label - instr) >> 2;
2761             u.i[0] = i.v;
2762         }
2763 #  if __WORDSIZE == 64
2764         else if (i.op2.b == 1) {
2765             i.disp19.b = (label - instr) >> 2;
2766             u.i[0] = i.v;
2767         }
2768 #  endif
2769         else if (i.op2.b == 4) {        /* movi_p */
2770             /* SETHI */
2771             i.imm22.b = HI((int)label);
2772             u.i[0] = i.v;
2773             i.v = u.i[1];
2774             if (i.op.b == 2 && i.op3.b == 2) {
2775                 /* ORI */
2776                 i.simm13.b = LO(label);
2777                 u.i[1] = i.v;
2778 #  if __WORDSIZE == 64
2779                 i.v = u.i[2];
2780                 assert(i.op2.b == 4);
2781                 label = (label >> 32) & 0xffffffff;
2782                 i.imm22.b = HI((int)label);
2783                 u.i[2] = i.v;
2784                 i.v = u.i[3];
2785                 assert(i.op.b == 2 && i.op3.b == 2);
2786                 /* ORI */
2787                 i.simm13.b = LO(label);
2788                 u.i[3] = i.v;
2789 #  endif
2790             }
2791             else
2792                 abort();
2793         }
2794         else
2795             abort();
2796     }
2797     else if (i.op.b == 1) {
2798         assert(s30_p((label - instr) >> 2));
2799         i.disp30.b = (label - instr) >> 2;
2800         u.i[0] = i.v;
2801     }
2802     else
2803         abort();
2804 }
2805 #endif