deps/lightning/lib/jit_sparc-cpu.c

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