deps/lightning/lib/jit_alpha-cpu.c

   1 /*
   2  * Copyright (C) 2014-2023  Free Software Foundation, Inc.
   3  *
   4  * This file is part of GNU lightning.
   5  *
   6  * GNU lightning is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 3, or (at your option)
   9  * any later version.
  10  *
  11  * GNU lightning is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  14  * License for more details.
  15  *
  16  * Authors:
  17  *      Paulo Cesar Pereira de Andrade
  18  */
  19
  20 #if PROTO
  21 #  define _u2(v)                        ((v) & 0x3)
  22 #  define _s2_p(v)                      ((v) >= -0x2 && (v) <= 0x1)
  23 #  define _u2_p(v)                      ((v) >= 0 && (v) <= 0x3)
  24 #  define _u5(v)                        ((v) & 0x1f)
  25 #  define _s5_p(v)                      ((v) >= -0x10 && (v) <= 0xf)
  26 #  define _u5_p(v)                      ((v) >= 0 && (v) <= 0x1f)
  27 #  define _u6(v)                        ((v) & 0x3f)
  28 #  define _s6_p(v)                      ((v) >= -0x20 && (v) <= 0x1f)
  29 #  define _u6_p(v)                      ((v) >= 0 && (v) <= 0x3f)
  30 #  define _u7(v)                        ((v) & 0x7f)
  31 #  define _s7_p(v)                      ((v) >= -0x40 && (v) <= 0x3f)
  32 #  define _u7_p(v)                      ((v) >= 0 && (v) <= 0x7f)
  33 #  define _u8(v)                        ((v) & 0xff)
  34 #  define _s8_p(v)                      ((v) >= -0x80 && (v) <= 0x7f)
  35 #  define _u8_p(v)                      ((v) >= 0 && (v) <= 0xff)
  36 #  define _u11(v)                       ((v) & 0x7ff)
  37 #  define _s11_p(v)                     ((v) >= -0x400 && (v) <= 0x3ff)
  38 #  define _u11_p(v)                     ((v) >= 0 && (v) <= 0x7ff)
  39 #  define _u14(v)                       ((v) & 0x3fff)
  40 #  define _s14_p(v)                     ((v) >= -0x2000 && (v) <= 0x1fff)
  41 #  define _u14_p(v)                     ((v) >= 0 && (v) <= 0x3fff)
  42 #  define _u16(v)                       ((v) & 0xffff)
  43 #  define _s16_p(v)                     ((v) >= -0x8000 && (v) <= 0x7fff)
  44 #  define _u16_p(v)                     ((v) >= 0 && (v) <= 0xffff)
  45 #  define _u21(v)                       ((v) & 0x1fffff)
  46 #  define _s21_p(v)                     ((v) >= -0x100000 && (v) <= 0xfffff)
  47 #  define _u21_p(v)                     ((v) >= 0 && (v) <= 0x1fffff)
  48 #  define _u26(v)                       ((v) & 0x3ffffff)
  49 #  define _s26_p(v)                     ((v) >= -0x2000000 && (v) <= 0x1ffffff)
  50 #  define _u26_p(v)                     ((v) >= 0 && (v) <= 0x3ffffff)
  51 #  define _u32(v)                       ((v) & 0xffffffff)
  52 #  define _s32_p(v)                     ((v) >= -0x80000000 && (v) <= 0x7fffffff)
  53 #  define _u32_p(v)                     ((v) >= 0 && (v) <= 0xffffffff)
  54 #  define ii(i)                         *_jit->pc.ui++ = i
  55 #  define ldr(r0,r1)                    ldr_l(r0,r1)
  56 #  define ldi(r0,i0)                    ldi_l(r0,i0)
  57 #  define ldxr(r0,r1,r2)                ldxr_l(r0,r1,r2)
  58 #  define ldxi(r0,r1,i0)                ldxi_l(r0,r1,i0)
  59 #  define str(r0,r1)                    str_l(r0,r1)
  60 #  define sti(i0,r0)                    sti_l(i0,r0)
  61 #  define stxr(r0,r1,r2)                stxr_l(r0,r1,r2)
  62 #  define stxi(i0,r0,r1)                stxi_l(i0,r0,r1)
  63 #  define stack_framesize               224
  64 #  define _S0_REGNO                     0x09
  65 #  define _S1_REGNO                     0x0a
  66 #  define _S2_REGNO                     0x0b
  67 #  define _S3_REGNO                     0x0c
  68 #  define _S4_REGNO                     0x0d
  69 #  define _S5_REGNO                     0x0e
  70 #  define _FP_REGNO                     0x0f
  71 #  define _A0_REGNO                     0x10
  72 #  define _A1_REGNO                     0x11
  73 #  define _A2_REGNO                     0x12
  74 #  define _V0_REGNO                     0x00
  75 #  define _T0_REGNO                     0x01
  76 #  define _T1_REGNO                     0x02
  77 #  define _RA_REGNO                     0x1a
  78 #  define _PV_REGNO                     0x1b
  79 #  define _GP_REGNO                     0x1d
  80 #  define _SP_REGNO                     0x1e
  81 #  define _R31_REGNO                    0x1f
  82 #  define Pcd(o,n)                      _Pcd(_jit,o,n)
  83 static void _Pcd(jit_state_t*,int,unsigned int) maybe_unused;
  84 #  define Bra(o,ra,d)                   _Bra(_jit,o,ra,d)
  85 static void _Bra(jit_state_t*,int,int,int);
  86 #  define Mem(o,ra,rb,d)                        _Mem(_jit,o,ra,rb,d)
  87 static void _Mem(jit_state_t*,int,int,int,unsigned int);
  88 #  define Mbr(o,ra,rb,h,d)              _Mbr(_jit,o,ra,rb,h,d)
  89 static void _Mbr(jit_state_t*,int,int,int,int,int);
  90 #  define Opr(o,ra,rb,f,rc)             _Opr(_jit,o,ra,rb,f,rc)
  91 static void _Opr(jit_state_t*,int,int,int,unsigned int,int);
  92 #  define Opi(o,ra,i,f,rc)              _Opi(_jit,o,ra,i,f,rc)
  93 static void _Opi(jit_state_t*,int,int,unsigned int,unsigned int,int);
  94 #  define ADDL(ra,rb,rc)                Opr(0x10,ra,rb,0x00,rc)
  95 #  define ADDLi(ra,im,rc)               Opi(0x10,ra,im,0x00,rc)
  96 #  define ADDL_V(ra,rb,rc)              Opr(0x10,ra,rb,0x40,rc)
  97 #  define ADDL_Vi(ra,im,rc)             Opi(0x10,ra,im,0x40,rc)
  98 #  define ADDQ(ra,rb,rc)                Opr(0x10,ra,rb,0x20,rc)
  99 #  define ADDQi(ra,im,rc)               Opi(0x10,ra,im,0x20,rc)
 100 #  define ADDQ_V(ra,rb,rc)              Opr(0x10,ra,rb,0x60,rc)
 101 #  define ADDQ_Vi(ra,im,rc)             Opi(0x10,ra,im,0x60,rc)
 102 #  define AMASK(rb,rc)                  Opr(0x11,_R31_REGNO,rb,0x61,rc)
 103 #  define AND(ra,rb,rc)                 Opr(0x11,ra,rb,0x00,rc)
 104 #  define ANDi(ra,im,rc)                Opi(0x11,ra,im,0x00,rc)
 105 #  define BEQ(ra,d)                     Bra(0x39,ra,d)
 106 #  define BGE(ra,d)                     Bra(0x3e,ra,d)
 107 #  define BGT(ra,d)                     Bra(0x3f,ra,d)
 108 #  define BIC(ra,rb,rc)                 Opr(0x11,ra,rb,0x08,rc)
 109 #  define ANDNOT(ra,rb,rc)              BIC(ra,rb,rc)
 110 #  define BICi(ra,im,rc)                Opi(0x11,ra,im,0x08,rc)
 111 #  define ANDNOTi(ra,im,rc)             BICi(ra,im,rc)
 112 #  define BIS(ra,rb,rc)                 Opr(0x11,ra,rb,0x20,rc)
 113 #  define BISi(ra,im,rc)                Opi(0x11,ra,im,0x20,rc)
 114 #  define OR(ra,rb,rc)                  BIS(ra,rb,rc)
 115 #  define ORi(ra,im,rc)                 BISi(ra,im,rc)
 116 #  define BLBC(ra,d)                    Bra(0x38,ra,d)
 117 #  define BLBS(ra,d)                    Bra(0x3c,ra,d)
 118 #  define BLE(ra,d)                     Bra(0x3b,ra,d)
 119 #  define BLT(ra,d)                     Bra(0x3a,ra,d)
 120 #  define BNE(ra,d)                     Bra(0x3d,ra,d)
 121 #  define BR(ra,d)                      Bra(0x30,ra,d)
 122 #  define BSR(ra,d)                     Bra(0x34,ra,d)
 123 #  define CALL_PAL(c)                   Pcd(0x00,c)
 124 #  define CMOVEQ(ra,rb,rc)              Opr(0x11,ra,rb,0x24,rc)
 125 #  define CMOVEQi(ra,im,rc)             Opi(0x11,ra,im,0x24,rc)
 126 #  define CMOVGE(ra,rb,rc)              Opr(0x11,ra,rb,0x46,rc)
 127 #  define CMOVGEi(ra,im,rc)             Opi(0x11,ra,im,0x46,rc)
 128 #  define CMOVGT(ra,rb,rc)              Opr(0x11,ra,rb,0x66,rc)
 129 #  define CMOVGTi(ra,im,rc)             Opi(0x11,ra,im,0x66,rc)
 130 #  define CMOVLBC(ra,rb,rc)             Opr(0x11,ra,rb,0x16,rc)
 131 #  define CMOVLBCi(ra,im,rc)            Opi(0x11,ra,im,0x16,rc)
 132 #  define CMOVLBS(ra,rb,rc)             Opr(0x11,ra,rb,0x14,rc)
 133 #  define CMOVLBSi(ra,im,rc)            Opi(0x11,ra,im,0x14,rc)
 134 #  define CMOVLE(ra,rb,rc)              Opr(0x11,ra,rb,0x64,rc)
 135 #  define CMOVLEi(ra,im,rc)             Opi(0x11,ra,im,0x64,rc)
 136 #  define CMOVLT(ra,rb,rc)              Opr(0x11,ra,rb,0x44,rc)
 137 #  define CMOVLTi(ra,im,rc)             Opi(0x11,ra,im,0x44,rc)
 138 #  define CMOVNE(ra,rb,rc)              Opr(0x11,ra,rb,0x26,rc)
 139 #  define CMOVNEi(ra,im,rc)             Opi(0x11,ra,im,0x26,rc)
 140 #  define CMPBGE(ra,rb,rc)              Opr(0x10,ra,rb,0x0f,rc)
 141 #  define CMPBGEi(ra,im,rc)             Opi(0x10,ra,im,0x0f,rc)
 142 #  define CMPEQ(ra,rb,rc)               Opr(0x10,ra,rb,0x2d,rc)
 143 #  define CMPEQi(ra,im,rc)              Opi(0x10,ra,im,0x2d,rc)
 144 #  define CMPLE(ra,rb,rc)               Opr(0x10,ra,rb,0x6d,rc)
 145 #  define CMPLEi(ra,im,rc)              Opi(0x10,ra,im,0x6d,rc)
 146 #  define CMPLT(ra,rb,rc)               Opr(0x10,ra,rb,0x4d,rc)
 147 #  define CMPLTi(ra,im,rc)              Opi(0x10,ra,im,0x4d,rc)
 148 #  define CMPULE(ra,rb,rc)              Opr(0x10,ra,rb,0x3d,rc)
 149 #  define CMPULEi(ra,im,rc)             Opi(0x10,ra,im,0x3d,rc)
 150 #  define CMPULT(ra,rb,rc)              Opr(0x10,ra,rb,0x1d,rc)
 151 #  define CMPULTi(ra,im,rc)             Opi(0x10,ra,im,0x1d,rc)
 152 #  define CTLZ(rb,rc)                   Opr(0x1c,_R31_REGNO,rb,0x32,rc)
 153 #  define CTPOP(rb,rc)                  Opr(0x1c,_R31_REGNO,rb,0x30,rc)
 154 #  define CTTZ(rb,rc)                   Opr(0x1c,_R31_REGNO,rb,0x33,rc)
 155 #  define ECB(rb,d)                     Mem(0x18,_R31_REGNO,rb,0xe800)
 156 #  define EQV(ra,rb,rc)                 Opr(0x11,ra,rb,0x48,rc)
 157 #  define XORNOT(ra,rb,rc)              EQV(ra,rb,rc)
 158 #  define EQVi(ra,im,rc)                Opi(0x11,ra,im,0x48,rc)
 159 #  define XORNOTi(ra,im,rc)             EQVi(ra,im,rc)
 160 #  define EXCB()                        Mem(0x18,0,0,0x0400)
 161 #  define EXTBL(ra,rb,rc)               Opr(0x12,ra,rb,0x06,rc)
 162 #  define EXTBLi(ra,im,rc)              Opi(0x12,ra,im,0x06,rc)
 163 #  define EXTLH(ra,rb,rc)               Opr(0x12,ra,rb,0x6a,rc)
 164 #  define EXTLHi(ra,im,rc)              Opi(0x12,ra,im,0x6a,rc)
 165 #  define EXTLL(ra,rb,rc)               Opr(0x12,ra,rb,0x26,rc)
 166 #  define EXTLLi(ra,im,rc)              Opi(0x12,ra,im,0x26,rc)
 167 #  define EXTQH(ra,rb,rc)               Opr(0x12,ra,rb,0x7a,rc)
 168 #  define EXTQHi(ra,im,rc)              Opi(0x12,ra,im,0x7a,rc)
 169 #  define EXTQL(ra,rb,rc)               Opr(0x12,ra,rb,0x36,rc)
 170 #  define EXTQLi(ra,im,rc)              Opi(0x12,ra,im,0x36,rc)
 171 #  define EXTWH(ra,rb,rc)               Opr(0x12,ra,rb,0x5a,rc)
 172 #  define EXTWHi(ra,im,rc)              Opi(0x12,ra,im,0x5a,rc)
 173 #  define EXTWL(ra,rb,rc)               Opr(0x12,ra,rb,0x16,rc)
 174 #  define EXTWLi(ra,im,rc)              Opi(0x12,ra,im,0x16,rc)
 175 #  define FETCH(rb,d)                   Mem(0x18,_R31_REGNO,rb,0x8000)
 176 #  define FETCH_Mem(rb,d)               Mem(0x18,_R31_REGNO,rb,0xa000)
 177 /* FIXME IMPLVER not disassembled */
 178 #  define IMPLVER(rc)                   Opr(0x11,_R31_REGNO,1,0x6c,rc)
 179 #  define INSBL(ra,rb,rc)               Opr(0x12,ra,rb,0x0b,rc)
 180 #  define INSBLi(ra,im,rc)              Opi(0x12,ra,im,0x0b,rc)
 181 #  define INSLH(ra,rb,rc)               Opr(0x12,ra,rb,0x67,rc)
 182 #  define INSLHi(ra,im,rc)              Opi(0x12,ra,im,0x67,rc)
 183 #  define INSLL(ra,rb,rc)               Opr(0x12,ra,rb,0x2b,rc)
 184 #  define INSLLi(ra,im,rc)              Opi(0x12,ra,im,0x2b,rc)
 185 #  define INSQH(ra,rb,rc)               Opr(0x12,ra,rb,0x77,rc)
 186 #  define INSQHi(ra,im,rc)              Opi(0x12,ra,im,0x77,rc)
 187 #  define INSQL(ra,rb,rc)               Opr(0x12,ra,rb,0x3b,rc)
 188 #  define INSQLi(ra,im,rc)              Opi(0x12,ra,im,0x3b,rc)
 189 #  define INSWH(ra,rb,rc)               Opr(0x12,ra,rb,0x57,rc)
 190 #  define INSWHi(ra,im,rc)              Opi(0x12,ra,im,0x57,rc)
 191 #  define INSWL(ra,rb,rc)               Opr(0x12,ra,rb,0x1b,rc)
 192 #  define INSWLi(ra,im,rc)              Opi(0x12,ra,im,0x1b,rc)
 193 #  define JMP(ra,rb,d)                  Mbr(0x1a,ra,rb,0,d)
 194 #  define JSR(ra,rb,d)                  Mbr(0x1a,ra,rb,1,d)
 195 #  define JSR_COROUTINE(ra,rb,d)        Mbr(0x1a,ra,rb,3,d)
 196 #  define JCR(ra,rb,rd)                 JSR_COROUTINE(ra,rb,d)
 197 #  define LDA(ra,rb,d)                  Mem(0x08,ra,rb,d)
 198 #  define LDAH(ra,rb,d)                 Mem(0x09,ra,rb,d)
 199 #  define LDBU(ra,rb,d)                 Mem(0x0a,ra,rb,d)
 200 #  define LDWU(ra,rb,d)                 Mem(0x0c,ra,rb,d)
 201 #  define LDL(ra,rb,d)                  Mem(0x28,ra,rb,d)
 202 #  define LDL_L(ra,rb,d)                Mem(0x2a,ra,rb,d)
 203 #  define LDQ(ra,rb,d)                  Mem(0x29,ra,rb,d)
 204 #  define LDQ_L(ra,rb,d)                Mem(0x2b,ra,rb,d)
 205 #  define LDQ_U(ra,rb,d)                Mem(0x0b,ra,rb,d)
 206 #  define MAXSB8(ra,rb,rc)              Opr(0x1c,ra,rb,0x3e,rc)
 207 #  define MAXSW4(ra,rb,rc)              Opr(0x1c,ra,rb,0x3f,rc)
 208 #  define MAXSUB8(ra,rb,rc)             Opr(0x1c,ra,rb,0x3c,rc)
 209 #  define MAXSUW4(ra,rb,rc)             Opr(0x1c,ra,rb,0x3d,rc)
 210 #  define MB()                          Mem(0x18,_R31_REGNO,_R31_REGNO,0x4000)
 211 #  define MINSB8(ra,rb,rc)              Opr(0x1c,ra,rb,0x38,rc)
 212 #  define MINSW4(ra,rb,rc)              Opr(0x1c,ra,rb,0x39,rc)
 213 #  define MINSUB8(ra,rb,rc)             Opr(0x1c,ra,rb,0x3a,rc)
 214 #  define MINSUW4(ra,rb,rc)             Opr(0x1c,ra,rb,0x3b,rc)
 215 #  define MSKBL(ra,rb,rc)               Opr(0x12,ra,rb,0x02,rc)
 216 #  define MSKBLi(ra,im,rc)              Opi(0x12,ra,im,0x02,rc)
 217 #  define MSKLH(ra,rb,rc)               Opr(0x12,ra,rb,0x62,rc)
 218 #  define MSKLHi(ra,im,rc)              Opi(0x12,ra,im,0x62,rc)
 219 #  define MSKLL(ra,rb,rc)               Opr(0x12,ra,rb,0x22,rc)
 220 #  define MSKLLi(ra,im,rc)              Opi(0x12,ra,im,0x22,rc)
 221 #  define MSKQH(ra,rb,rc)               Opr(0x12,ra,rb,0x72,rc)
 222 #  define MSKQHi(ra,im,rc)              Opi(0x12,ra,im,0x72,rc)
 223 #  define MSKQL(ra,rb,rc)               Opr(0x12,ra,rb,0x32,rc)
 224 #  define MSKQLi(ra,im,rc)              Opi(0x12,ra,im,0x32,rc)
 225 #  define MSKWH(ra,rb,rc)               Opr(0x12,ra,rb,0x52,rc)
 226 #  define MSKWHi(ra,im,rc)              Opi(0x12,ra,im,0x52,rc)
 227 #  define MSKWL(ra,rb,rc)               Opr(0x12,ra,rb,0x12,rc)
 228 #  define MSKWLi(ra,im,rc)              Opi(0x12,ra,im,0x12,rc)
 229 #  define MULL(ra,rb,rc)                Opr(0x13,ra,rb,0x00,rc)
 230 #  define MULLi(ra,im,rc)               Opi(0x13,ra,im,0x00,rc)
 231 #  define MULL_V(ra,rb,rc)              Opr(0x13,ra,rb,0x40,rc)
 232 #  define MULL_Vi(ra,im,rc)             Opi(0x13,ra,im,0x40,rc)
 233 #  define MULQ(ra,rb,rc)                Opr(0x13,ra,rb,0x20,rc)
 234 #  define MULQi(ra,im,rc)               Opi(0x13,ra,im,0x20,rc)
 235 #  define MULQ_V(ra,rb,rc)              Opr(0x13,ra,rb,0x60,rc)
 236 #  define MULQ_Vi(ra,im,rc)             Opi(0x13,ra,im,0x60,rc)
 237 #  define ORNOT(ra,rb,rc)               Opr(0x11,ra,rb,0x28,rc)
 238 #  define ORNOTi(ra,im,rc)              Opi(0x11,ra,im,0x28,rc)
 239 #  define PERR(ra,rb,rc)                Opr(0x1c,ra,rb,0x31,rc)
 240 #  define PKLB(rb,rc)                   Opr(0x1c,_R31_REGNO,rb,0x37,rc)
 241 #  define PKWB(rb,rc)                   Opr(0x1c,_R31_REGNO,rb,0x36,rc)
 242 /* FIXME PREFETCH* not disassembled */
 243 #  define PREFETCH(rb,d)                Mem(0x28,_R31_REGNO,rb,d)
 244 #  define PREFETCH_EN(rb,d)             Mem(0x29,_R31_REGNO,rb,d)
 245 #  define PREFETCH_M(rb,d)              Mem(0x22,_R31_REGNO,rb,d)
 246 #  define PREFETCH_MEN(rb,d)            Mem(0x23,_R31_REGNO,rb,d)
 247 #  define RC(ra)                        Mem(0x18,ra,_R31_REGNO,0xe000)
 248 #  define RET(ra,rb,d)                  Mbr(0x1a,ra,rb,2,d)
 249 #  define RPCC(ra)                      Mem(0x18,ra,_R31_REGNO,0xc000)
 250 #  define RS(ra)                        Mem(0x18,ra,_R31_REGNO,0xf000)
 251 #  define S4ADDL(ra,rb,rc)              Opr(0x10,ra,rb,0x02,rc)
 252 #  define S4ADDi(ra,im,rc)              Opi(0x10,ra,im,0x02,rc)
 253 #  define S4ADDQ(ra,rb,rc)              Opr(0x10,ra,rb,0x22,rc)
 254 #  define S4ADDQi(ra,im,rc)             Opi(0x10,ra,im,0x22,rc)
 255 #  define S4SUBL(ra,rb,rc)              Opr(0x10,ra,rb,0x0b,rc)
 256 #  define S4SUBLi(ra,im,rc)             Opi(0x10,ra,im,0x0b,rc)
 257 #  define S4SUBQ(ra,rb,rc)              Opr(0x10,ra,rb,0x2b,rc)
 258 #  define S4SUBQi(ra,im,rc)             Opi(0x10,ra,im,0x2b,rc)
 259 #  define S8ADDL(ra,rb,rc)              Opr(0x10,ra,rb,0x12,rc)
 260 #  define S8ADDLi(ra,im,rc)             Opi(0x10,ra,im,0x12,rc)
 261 #  define S8ADDQ(ra,rb,rc)              Opr(0x10,ra,rb,0x32,rc)
 262 #  define S8ADDQi(ra,im,rc)             Opi(0x10,ra,im,0x32,rc)
 263 #  define S8SUBL(ra,rb,rc)              Opr(0x10,ra,rb,0x1b,rc)
 264 #  define S8SUBLi(ra,im,rc)             Opi(0x10,ra,im,0x1b,rc)
 265 #  define S8SUBQ(ra,rb,rc)              Opr(0x10,ra,rb,0x3b,rc)
 266 #  define S8SUBQi(ra,im,rc)             Opi(0x10,ra,im,0x3b,rc)
 267 #  define SEXTB(rb,rc)                  Opr(0x1c,_R31_REGNO,rb,0x00,rc)
 268 /* FIXME not disassembled */
 269 #  define SEXTBi(im,rc)                 Opi(0x1c,_R31_REGNO,im,0x00,rc)
 270 #  define SEXTW(rb,rc)                  Opr(0x1c,_R31_REGNO,rb,0x01,rc)
 271 /* FIXME not disassembled */
 272 #  define SEXTWi(im,rc)                 Opi(0x1c,_R31_REGNO,im,0x01,rc)
 273 #  define SLL(ra,rb,rc)                 Opr(0x12,ra,rb,0x39,rc)
 274 #  define SLLi(ra,im,rc)                Opi(0x12,ra,im,0x39,rc)
 275 #  define SRA(ra,rb,rc)                 Opr(0x12,ra,rb,0x3c,rc)
 276 #  define SRAi(ra,im,rc)                Opi(0x12,ra,im,0x3c,rc)
 277 #  define SRL(ra,rb,rc)                 Opr(0x12,ra,rb,0x34,rc)
 278 #  define SRLi(ra,im,rc)                Opi(0x12,ra,im,0x34,rc)
 279 #  define STB(ra,rb,d)                  Mem(0x0e,ra,rb,d)
 280 #  define STL(ra,rb,d)                  Mem(0x2c,ra,rb,d)
 281 #  define STL_C(ra,rb,d)                Mem(0x2e,ra,rb,d)
 282 #  define STQ(ra,rb,d)                  Mem(0x2d,ra,rb,d)
 283 #  define STQ_C(ra,rb,d)                Mem(0x2f,ra,rb,d)
 284 #  define STQ_U(ra,rb,d)                Mem(0x0f,ra,rb,d)
 285 #  define STW(ra,rb,d)                  Mem(0x0d,ra,rb,d)
 286 #  define SUBL(ra,rb,rc)                Opr(0x10,ra,rb,0x09,rc)
 287 #  define SUBLi(ra,im,rc)               Opi(0x10,ra,im,0x09,rc)
 288 #  define SUBL_V(ra,rb,rc)              Opr(0x10,ra,rb,0x49,rc)
 289 #  define SUBL_Vi(ra,im,rc)             Opi(0x10,ra,im,0x49,rc)
 290 #  define SUBQ(ra,rb,rc)                Opr(0x10,ra,rb,0x29,rc)
 291 #  define SUBQi(ra,im,rc)               Opi(0x10,ra,im,0x29,rc)
 292 #  define SUBQ_V(ra,rb,rc)              Opr(0x10,ra,rb,0x69,rc)
 293 #  define SUBQ_Vi(ra,im,rc)             Opi(0x10,ra,im,0x69,rc)
 294 #  define TRAPB()                       Mem(0x18,_R31_REGNO,_R31_REGNO,0x0000)
 295 #  define UMULH(ra,rb,rc)               Opr(0x13,ra,rb,0x30,rc)
 296 #  define UMULHi(ra,im,rc)              Opi(0x13,ra,im,0x30,rc)
 297 #  define UNPKBL(rb,rc)                 Opr(0x1c,_R31_REGNO,rb,0x35,rc)
 298 #  define UNPKBW(rb,rc)                 Opr(0x1c,_R31_REGNO,rb,0x34,rc)
 299 #  define WH64(ra)                      Mem(0x18,ra,_R31_REGNO,0xf800)
 300 #  define WH64EN(ra)                    Mem(0x18,ra,_R31_REGNO,0xfc00)
 301 #  define WMB()                         Mem(0x18,_R31_REGNO,_R31_REGNO,0x4400)
 302 #  define XOR(ra,rb,rc)                 Opr(0x11,ra,rb,0x40,rc)
 303 #  define XORi(ra,im,rc)                Opi(0x11,ra,im,0x40,rc)
 304 #  define ZAP(ra,rb,rc)                 Opr(0x12,ra,rb,0x30,rc)
 305 #  define ZAPi(ra,im,rc)                Opi(0x12,ra,im,0x30,rc)
 306 #  define ZAPNOT(ra,rb,rc)              Opr(0x12,ra,rb,0x31,rc)
 307 #  define ZAPNOTi(ra,im,rc)             Opi(0x12,ra,im,0x31,rc)
 308 #  define NOP()                         BIS(_R31_REGNO,_R31_REGNO,_R31_REGNO)
 309 #  define MOV(ra,rc)                    BIS(ra,ra,rc)
 310 #  define MOVi(im,rc)                   BISi(_R31_REGNO,im,rc)
 311 #  define NEGL(ra,rc)                   SUBL(_R31_REGNO,ra,rc)
 312 #  define NEGQ(ra,rc)                   SUBQ(_R31_REGNO,ra,rc)
 313 #  define NOT(ra,rc)                    ORNOT(_R31_REGNO,ra,rc)
 314 #  define nop(i0)                       _nop(_jit,i0)
 315 static void _nop(jit_state_t*,jit_int32_t);
 316 #  define movr(r0,r1)                   _movr(_jit,r0,r1)
 317 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
 318 #  define movi(r0,i0)                   _movi(_jit,r0,i0)
 319 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
 320 #  define movi_p(r0,i0)                 _movi_p(_jit,r0,i0)
 321 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
 322 #  define movnr(r0,r1,r2)               CMOVNE(r2, r1, r0)
 323 #  define movzr(r0,r1,r2)               CMOVEQ(r2, r1, r0)
 324 #  define casx(r0, r1, r2, r3, i0)      _casx(_jit, r0, r1, r2, r3, i0)
 325 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
 326                   jit_int32_t,jit_int32_t,jit_word_t);
 327 #define casr(r0, r1, r2, r3)            casx(r0, r1, r2, r3, 0)
 328 #define casi(r0, i0, r1, r2)            casx(r0, _NOREG, r1, r2, i0)
 329 #  define negr(r0,r1)                   NEGQ(r1,r0)
 330 #  define comr(r0,r1)                   NOT(r1,r0)
 331 #  define clor(r0, r1)                  _clor(_jit, r0, r1)
 332 static void _clor(jit_state_t*, jit_int32_t, jit_int32_t);
 333 #  define clzr(r0, r1)                  CTLZ(r1, r0)
 334 #  define ctor(r0, r1)                  _ctor(_jit, r0, r1)
 335 static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t);
 336 #  define ctzr(r0, r1)                  CTTZ(r1, r0)
 337 #  define popcntr(r0, r1)               CTPOP(r1, r0)
 338 #  define addr(r0,r1,r2)                ADDQ(r1,r2,r0)
 339 #  define addi(r0,r1,i0)                _addi(_jit,r0,r1,i0)
 340 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 341 #  define addcr(r0,r1,i0)               _addcr(_jit,r0,r1,i0)
 342 static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 343 #  define addci(r0,r1,i0)               _addci(_jit,r0,r1,i0)
 344 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 345 #  define addxr(r0,r1,i0)               _addxr(_jit,r0,r1,i0)
 346 static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 347 #  define addxi(r0,r1,i0)               _addxi(_jit,r0,r1,i0)
 348 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 349 #  define subr(r0,r1,r2)                SUBQ(r1,r2,r0)
 350 #  define subi(r0,r1,i0)                _subi(_jit,r0,r1,i0)
 351 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 352 #  define subcr(r0,r1,i0)               _subcr(_jit,r0,r1,i0)
 353 static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 354 #  define subci(r0,r1,i0)               _subci(_jit,r0,r1,i0)
 355 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 356 #  define subxr(r0,r1,i0)               _subxr(_jit,r0,r1,i0)
 357 static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 358 #  define subxi(r0,r1,i0)               _subxi(_jit,r0,r1,i0)
 359 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 360 #  define rsbi(r0, r1, i0)              _rsbi(_jit, r0, r1, i0)
 361 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t, jit_word_t);
 362 #  define mulr(r0,r1,r2)                MULQ(r1,r2,r0)
 363 #  define muli(r0,r1,i0)                _muli(_jit,r0,r1,i0)
 364 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 365 #  define hmulr(r0, r1, r2)             qmulr(JIT_NOREG, r0, r1, r2)
 366 #  define hmuli(r0, r1, i0)             qmuli(JIT_NOREG, r0, r1, i0)
 367 #  define hmulr_u(r0, r1, r2)           qmulr_u(JIT_NOREG, r0, r1, r2)
 368 #  define hmuli_u(r0, r1, i0)           qmuli_u(JIT_NOREG, r0, r1, i0)
 369 #  define qmulr(r0,r1,r2,r3)            _qmulr(_jit,r0,r1,r2,r3)
 370 static void _qmulr(jit_state_t*,jit_int32_t,
 371                    jit_int32_t,jit_int32_t,jit_int32_t);
 372 #  define qmuli(r0,r1,r2,i0)            _qmuli(_jit,r0,r1,r2,i0)
 373 static void _qmuli(jit_state_t*,jit_int32_t,
 374                    jit_int32_t,jit_int32_t,jit_word_t);
 375 #  define qmulr_u(r0,r1,r2,r3)          _qmulr_u(_jit,r0,r1,r2,r3)
 376 static void _qmulr_u(jit_state_t*,jit_int32_t,
 377                      jit_int32_t,jit_int32_t,jit_int32_t);
 378 #  define qmuli_u(r0,r1,r2,i0)          _qmuli_u(_jit,r0,r1,r2,i0)
 379 static void _qmuli_u(jit_state_t*,jit_int32_t,
 380                      jit_int32_t,jit_int32_t,jit_word_t);
 381 static jit_word_t __idiv(jit_word_t, jit_word_t);
 382 #  define divr(r0,r1,r2)                _divr(_jit,r0,r1,r2)
 383 static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 384 #  define divi(r0,r1,i0)                _divi(_jit,r0,r1,i0)
 385 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 386 static jit_uword_t __udiv(jit_uword_t, jit_uword_t);
 387 #  define divr_u(r0,r1,r2)              _divr_u(_jit,r0,r1,r2)
 388 static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 389 #  define divi_u(r0,r1,i0)              _divi_u(_jit,r0,r1,i0)
 390 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 391 static jit_word_t __irem(jit_word_t, jit_word_t);
 392 #  define remr(r0,r1,r2)                _remr(_jit,r0,r1,r2)
 393 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 394 #  define remi(r0,r1,i0)                _remi(_jit,r0,r1,i0)
 395 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 396 static jit_uword_t __urem(jit_uword_t, jit_uword_t);
 397 #  define remr_u(r0,r1,r2)              _remr_u(_jit,r0,r1,r2)
 398 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 399 #  define remi_u(r0,r1,i0)              _remi_u(_jit,r0,r1,i0)
 400 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 401 static jit_word_t __idivrem(jit_word_t, jit_word_t, jit_word_t*);
 402 #  define qdivr(r0,r1,r2,r3)            _qdivr(_jit,r0,r1,r2,r3)
 403 static void _qdivr(jit_state_t*,
 404                    jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 405 #  define qdivi(r0,r1,r2,i0)            _qdivi(_jit,r0,r1,r2,i0)
 406 static void _qdivi(jit_state_t*,
 407                    jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 408 static jit_word_t __udivrem(jit_uword_t, jit_uword_t, jit_uword_t*);
 409 #  define qdivr_u(r0,r1,r2,r3)          _qdivr_u(_jit,r0,r1,r2,r3)
 410 static void _qdivr_u(jit_state_t*,
 411                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 412 #  define qdivi_u(r0,r1,r2,i0)          _qdivi_u(_jit,r0,r1,r2,i0)
 413 static void _qdivi_u(jit_state_t*,
 414                      jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 415 #  define lshr(r0,r1,r2)                SLL(r1,r2,r0)
 416 #  define lshi(r0,r1,i0)                _lshi(_jit,r0,r1,i0)
 417 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 418 #  define rshr(r0,r1,r2)                SRA(r1,r2,r0)
 419 #  define rshi(r0,r1,i0)                _rshi(_jit,r0,r1,i0)
 420 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 421 #  define rshr_u(r0,r1,r2)              SRL(r1,r2,r0)
 422 #  define rshi_u(r0,r1,i0)              _rshi_u(_jit,r0,r1,i0)
 423 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 424 #  define qlshr(r0,r1,r2,r3)            xlshr(1,r0,r1,r2,r3)
 425 #  define qlshr_u(r0, r1, r2, r3)       xlshr(0, r0, r1, r2, r3)
 426 #  define xlshr(s,r0,r1,r2,r3)          _xlshr(_jit,s,r0,r1,r2,r3)
 427 static void
 428 _xlshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 429 #  define qlshi(r0, r1, r2, i0)         xlshi(1, r0, r1, r2, i0)
 430 #  define qlshi_u(r0, r1, r2, i0)       xlshi(0, r0, r1, r2, i0)
 431 #  define xlshi(s, r0, r1, r2, i0)      _xlshi(_jit, s, r0, r1, r2, i0)
 432 static void
 433 _xlshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 434 #  define qrshr(r0, r1, r2, r3)         xrshr(1, r0, r1, r2, r3)
 435 #  define qrshr_u(r0, r1, r2, r3)       xrshr(0, r0, r1, r2, r3)
 436 #  define xrshr(s, r0, r1, r2, r3)      _xrshr(_jit, s, r0, r1, r2, r3)
 437 static void
 438 _xrshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 439 #  define qrshi(r0, r1, r2, i0)         xrshi(1, r0, r1, r2, i0)
 440 #  define qrshi_u(r0, r1, r2, i0)       xrshi(0, r0, r1, r2, i0)
 441 #  define xrshi(s, r0, r1, r2, i0)      _xrshi(_jit, s, r0, r1, r2, i0)
 442 static void
 443 _xrshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 444 #  define andr(r0,r1,r2)                AND(r1,r2,r0)
 445 #  define andi(r0,r1,i0)                _andi(_jit,r0,r1,i0)
 446 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 447 #  define orr(r0,r1,r2)                 OR(r1,r2,r0)
 448 #  define ori(r0,r1,i0)                 _ori(_jit,r0,r1,i0)
 449 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 450 #  define xorr(r0,r1,r2)                XOR(r1,r2,r0)
 451 #  define xori(r0,r1,i0)                _xori(_jit,r0,r1,i0)
 452 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 453 #  define ltr(r0,r1,r2)                 CMPLT(r1,r2,r0)
 454 #  define lti(r0,r1,i0)                 _lti(_jit,r0,r1,i0)
 455 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 456 #  define ltr_u(r0,r1,r2)               CMPULT(r1,r2,r0)
 457 #  define lti_u(r0,r1,i0)               _lti_u(_jit,r0,r1,i0)
 458 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 459 #  define ler(r0,r1,r2)                 CMPLE(r1,r2,r0)
 460 #  define lei(r0,r1,i0)                 _lei(_jit,r0,r1,i0)
 461 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 462 #  define ler_u(r0,r1,r2)               CMPULE(r1,r2,r0)
 463 #  define lei_u(r0,r1,i0)               _lei_u(_jit,r0,r1,i0)
 464 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 465 #  define eqr(r0,r1,r2)                 CMPEQ(r1,r2,r0)
 466 #  define eqi(r0,r1,i0)                 _eqi(_jit,r0,r1,i0)
 467 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 468 #  define ger(r0,r1,r2)                 CMPLE(r2,r1,r0)
 469 #  define gei(r0,r1,i0)                 _gei(_jit,r0,r1,i0)
 470 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 471 #  define ger_u(r0,r1,r2)               CMPULE(r2,r1,r0)
 472 #  define gei_u(r0,r1,i0)               _gei_u(_jit,r0,r1,i0)
 473 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 474 #  define gtr(r0,r1,r2)                 CMPLT(r2,r1,r0)
 475 #  define gti(r0,r1,i0)                 _gti(_jit,r0,r1,i0)
 476 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 477 #  define gtr_u(r0,r1,r2)               CMPULT(r2,r1,r0)
 478 #  define gti_u(r0,r1,i0)               _gti_u(_jit,r0,r1,i0)
 479 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 480 #  define ner(r0,r1,r2)                 _ner(_jit,r0,r1,r2)
 481 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 482 #  define nei(r0,r1,i0)                 _nei(_jit,r0,r1,i0)
 483 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 484 #  define bltr(i0,r0,r1)                _bltr(_jit,i0,r0,r1)
 485 static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 486 #  define blti(i0,r0,i1)                _blti(_jit,i0,r0,i1)
 487 static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 488 #  define bltr_u(i0,r0,r1)              _bltr_u(_jit,i0,r0,r1)
 489 static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 490 #  define blti_u(i0,r0,i1)              _blti_u(_jit,i0,r0,i1)
 491 static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 492 #  define bler(i0,r0,r1)                _bler(_jit,i0,r0,r1)
 493 static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 494 #  define blei(i0,r0,i1)                _blei(_jit,i0,r0,i1)
 495 static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 496 #  define bler_u(i0,r0,r1)              _bler_u(_jit,i0,r0,r1)
 497 static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 498 #  define blei_u(i0,r0,i1)              _blei_u(_jit,i0,r0,i1)
 499 static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 500 #  define beqr(i0,r0,r1)                _beqr(_jit,i0,r0,r1)
 501 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 502 #  define beqi(i0,r0,i1)                _beqi(_jit,i0,r0,i1)
 503 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 504 #  define bger(i0,r0,r1)                _bger(_jit,i0,r0,r1)
 505 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 506 #  define bgei(i0,r0,i1)                        _bgei(_jit,i0,r0,i1)
 507 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 508 #  define bger_u(i0,r0,r1)              _bger_u(_jit,i0,r0,r1)
 509 static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 510 #  define bgei_u(i0,r0,i1)              _bgei_u(_jit,i0,r0,i1)
 511 static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 512 #  define bgtr(i0,r0,r1)                _bgtr(_jit,i0,r0,r1)
 513 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 514 #  define bgti(i0,r0,i1)                _bgti(_jit,i0,r0,i1)
 515 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 516 #  define bgtr_u(i0,r0,r1)              _bgtr_u(_jit,i0,r0,r1)
 517 static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 518 #  define bgti_u(i0,r0,i1)              _bgti_u(_jit,i0,r0,i1)
 519 static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 520 #  define bner(i0,r0,r1)                _bner(_jit,i0,r0,r1)
 521 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 522 #  define bnei(i0,r0,i1)                _bnei(_jit,i0,r0,i1)
 523 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 524 #  define baddr(i0,r0,r1,cc)            _baddr(_jit,i0,r0,r1,cc)
 525 static jit_word_t _baddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,
 526                          jit_bool_t);
 527 #  define baddi(i0,r0,i1,cc)            _baddi(_jit,i0,r0,i1,cc)
 528 static jit_word_t _baddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t,
 529                          jit_bool_t);
 530 #  define baddr_u(i0,r0,r1,cc)          _baddr_u(_jit,i0,r0,r1,cc)
 531 static jit_word_t _baddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,
 532                            jit_bool_t);
 533 #  define baddi_u(i0,r0,i1,cc)          _baddi_u(_jit,i0,r0,i1,cc)
 534 static jit_word_t _baddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t,
 535                            jit_bool_t);
 536 #  define boaddr(i0,r0,r1)              baddr(i0,r0,r1,1)
 537 #  define boaddi(i0,r0,i1)              baddi(i0,r0,i1,1)
 538 #  define boaddr_u(i0,r0,r1)            baddr_u(i0,r0,r1,1)
 539 #  define boaddi_u(i0,r0,i1)            baddi_u(i0,r0,i1,1)
 540 #  define bxaddr(i0,r0,r1)              baddr(i0,r0,r1,0)
 541 #  define bxaddi(i0,r0,i1)              baddi(i0,r0,i1,0)
 542 #  define bxaddr_u(i0,r0,r1)            baddr_u(i0,r0,r1,0)
 543 #  define bxaddi_u(i0,r0,i1)            baddi_u(i0,r0,i1,0)
 544 #  define bsubr(i0,r0,r1,cc)            _bsubr(_jit,i0,r0,r1,cc)
 545 static jit_word_t _bsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,
 546                          jit_bool_t);
 547 #  define bsubi(i0,r0,i1,cc)            _bsubi(_jit,i0,r0,i1,cc)
 548 static jit_word_t _bsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t,
 549                          jit_bool_t);
 550 #  define bsubr_u(i0,r0,r1,cc)          _bsubr_u(_jit,i0,r0,r1,cc)
 551 static jit_word_t _bsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,
 552                            jit_bool_t);
 553 #  define bsubi_u(i0,r0,i1,cc)          _bsubi_u(_jit,i0,r0,i1,cc)
 554 static jit_word_t _bsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t,
 555                            jit_bool_t);
 556 #  define bosubr(i0,r0,r1)              bsubr(i0,r0,r1,1)
 557 #  define bosubi(i0,r0,i1)              bsubi(i0,r0,i1,1)
 558 #  define bosubr_u(i0,r0,r1)            bsubr_u(i0,r0,r1,1)
 559 #  define bosubi_u(i0,r0,i1)            bsubi_u(i0,r0,i1,1)
 560 #  define bxsubr(i0,r0,r1)              bsubr(i0,r0,r1,0)
 561 #  define bxsubi(i0,r0,i1)              bsubi(i0,r0,i1,0)
 562 #  define bxsubr_u(i0,r0,r1)            bsubr_u(i0,r0,r1,0)
 563 #  define bxsubi_u(i0,r0,i1)            bsubi_u(i0,r0,i1,0)
 564 #  define bmxr(i0,r0,r1,cc)             _bmxr(_jit,i0,r0,r1,cc)
 565 static jit_word_t _bmxr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,
 566                         jit_bool_t);
 567 #  define bmxi(i0,r0,i1,cc)             _bmxi(_jit,i0,r0,i1,cc)
 568 static jit_word_t _bmxi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t,
 569                         jit_bool_t);
 570 #  define bmsr(i0,r0,r1)                bmxr(i0,r0,r1,1)
 571 #  define bmsi(i0,r0,i1)                bmxi(i0,r0,i1,1)
 572 #  define bmcr(i0,r0,r1)                bmxr(i0,r0,r1,0)
 573 #  define bmci(i0,r0,i1)                bmxi(i0,r0,i1,0)
 574 #  define ldr_c(r0,r1)                  _ldr_c(_jit,r0,r1)
 575 static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
 576 #  define ldi_c(r0,i0)                  _ldi_c(_jit,r0,i0)
 577 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
 578 #  define ldr_uc(r0,r1)                 LDBU(r0,r1,0)
 579 #  define ldi_uc(r0,i0)                 _ldi_uc(_jit,r0,i0)
 580 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
 581 #  define ldr_s(r0,r1)                  _ldr_s(_jit,r0,r1)
 582 static void _ldr_s(jit_state_t*,jit_int32_t,jit_int32_t);
 583 #  define ldi_s(r0,i0)                  _ldi_s(_jit,r0,i0)
 584 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
 585 #  define ldr_us(r0,r1)                 LDWU(r0,r1,0)
 586 #  define ldi_us(r0,i0)                 _ldi_us(_jit,r0,i0)
 587 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
 588 #  define ldr_i(r0,r1)                  LDL(r0,r1,0)
 589 #  define ldi_i(r0,i0)                  _ldi_i(_jit,r0,i0)
 590 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
 591 #  define ldr_ui(r0,r1)                 _ldr_ui(_jit,r0,r1)
 592 static void _ldr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
 593 #  define ldi_ui(r0,i0)                 _ldi_ui(_jit,r0,i0)
 594 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
 595 #  define ldr_l(r0,r1)                  LDQ(r0,r1,0)
 596 #  define ldi_l(r0,i0)                  _ldi_l(_jit,r0,i0)
 597 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
 598 #  define ldxr_c(r0,r1,r2)              _ldxr_c(_jit,r0,r1,r2)
 599 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 600 #  define ldxi_c(r0,r1,i0)              _ldxi_c(_jit,r0,r1,i0)
 601 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 602 #  define ldxr_uc(r0,r1,r2)             _ldxr_uc(_jit,r0,r1,r2)
 603 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 604 #  define ldxi_uc(r0,r1,i0)             _ldxi_uc(_jit,r0,r1,i0)
 605 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 606 #  define ldxr_s(r0,r1,r2)              _ldxr_s(_jit,r0,r1,r2)
 607 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 608 #  define ldxi_s(r0,r1,i0)              _ldxi_s(_jit,r0,r1,i0)
 609 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 610 #  define ldxr_us(r0,r1,r2)             _ldxr_us(_jit,r0,r1,r2)
 611 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 612 #  define ldxi_us(r0,r1,i0)             _ldxi_us(_jit,r0,r1,i0)
 613 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 614 #  define ldxr_i(r0,r1,r2)              _ldxr_i(_jit,r0,r1,r2)
 615 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 616 #  define ldxi_i(r0,r1,i0)              _ldxi_i(_jit,r0,r1,i0)
 617 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 618 #  define ldxr_ui(r0,r1,r2)             _ldxr_ui(_jit,r0,r1,r2)
 619 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 620 #  define ldxi_ui(r0,r1,i0)             _ldxi_ui(_jit,r0,r1,i0)
 621 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 622 #  define ldxr_l(r0,r1,r2)              _ldxr_l(_jit,r0,r1,r2)
 623 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 624 #  define ldxi_l(r0,r1,i0)              _ldxi_l(_jit,r0,r1,i0)
 625 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 626 #  define unldr(r0, r1, i0)             _unldr(_jit, r0, r1, i0)
 627 static void _unldr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 628 #  define unldi(r0, i0, i1)             _unldi(_jit, r0, i0, i1)
 629 static void _unldi(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t);
 630 #  define unldr_u(r0, r1, i0)           _unldr_u(_jit, r0, r1, i0)
 631 static void _unldr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 632 #  define unldi_u(r0, i0, i1)           _unldi_u(_jit, r0, i0, i1)
 633 static void _unldi_u(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t);
 634 #  define str_c(r0,r1)                  STB(r1,r0,0)
 635 #  define sti_c(i0,r0)                  _sti_c(_jit,i0,r0)
 636 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
 637 #  define str_s(r0,r1)                  STW(r1,r0,0)
 638 #  define sti_s(i0,r0)                  _sti_s(_jit,i0,r0)
 639 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
 640 #  define str_i(r0,r1)                  STL(r1,r0,0)
 641 #  define sti_i(i0,r0)                  _sti_i(_jit,i0,r0)
 642 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
 643 #  define str_l(r0,r1)                  STQ(r1,r0,0)
 644 #  define sti_l(i0,r0)                  _sti_l(_jit,i0,r0)
 645 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
 646 #  define stxr_c(r0,r1,r2)              _stxr_c(_jit,r0,r1,r2)
 647 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 648 #  define stxi_c(i0,r0,r1)              _stxi_c(_jit,i0,r0,r1)
 649 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 650 #  define stxr_s(r0,r1,r2)              _stxr_s(_jit,r0,r1,r2)
 651 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 652 #  define stxi_s(i0,r0,r1)              _stxi_s(_jit,i0,r0,r1)
 653 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 654 #  define stxr_i(r0,r1,r2)              _stxr_i(_jit,r0,r1,r2)
 655 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 656 #  define stxi_i(i0,r0,r1)              _stxi_i(_jit,i0,r0,r1)
 657 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 658 #  define stxr_l(r0,r1,r2)              _stxr_l(_jit,r0,r1,r2)
 659 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 660 #  define stxi(i0,r0,r1)                stxi_l(i0,r0,r1)
 661 #  define stxi_l(i0,r0,r1)              _stxi_l(_jit,i0,r0,r1)
 662 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 663 #  define unstr(r0, r1, i0)             _unstr(_jit, r0, r1, i0)
 664 static void _unstr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 665 #  define unsti(i0, r0, i1)             _unsti(_jit, i0, r0, i1)
 666 static void _unsti(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 667 #  define extr(r0,r1,i0,i1)             _extr(_jit,r0,r1,i0,i1)
 668 static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
 669 #  define extr_u(r0,r1,i0,i1)           _extr_u(_jit,r0,r1,i0,i1)
 670 static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
 671 #  define depr(r0,r1,i0,i1)             _depr(_jit,r0,r1,i0,i1)
 672 static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
 673 #  define extr_c(r0,r1)                 SEXTB(r1, r0)
 674 #  define extr_uc(r0,r1)                EXTBLi(r1, 0, r0)
 675 #  define extr_s(r0,r1)                 SEXTW(r1, r0)
 676 #  define extr_us(r0,r1)                EXTWLi(r1, 0, r0)
 677 #  define extr_i(r0,r1)                 _extr_i(_jit,r0,r1)
 678 static void _extr_i(jit_state_t*,jit_int32_t,jit_int32_t);
 679 #  define extr_ui(r0,r1)                EXTLLi(r1, 0, r0)
 680 #  define bswapr_us(r0,r1)              _bswapr_us(_jit,r0,r1)
 681 static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t);
 682 #  define bswapr_ui(r0,r1)              _bswapr_ui(_jit,r0,r1)
 683 static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
 684 #  define bswapr_ul(r0,r1)              _bswapr_ul(_jit,r0,r1)
 685 static void _bswapr_ul(jit_state_t*,jit_int32_t,jit_int32_t);
 686 #  define jmpr(r0)                      JMP(_R31_REGNO,r0,0)
 687 #  define jmpi(i0)                      _jmpi(_jit,i0)
 688 static jit_word_t _jmpi(jit_state_t*, jit_word_t);
 689 #  define jmpi_p(i0)                    _jmpi_p(_jit,i0)
 690 static jit_word_t _jmpi_p(jit_state_t*, jit_word_t);
 691 #define callr(r0)                       _callr(_jit,r0)
 692 static void _callr(jit_state_t*, jit_int32_t);
 693 #  define calli(i0)                     _calli(_jit,i0)
 694 static void _calli(jit_state_t*, jit_word_t);
 695 #  define calli_p(i0)                   _calli_p(_jit,i0)
 696 static jit_word_t _calli_p(jit_state_t*, jit_word_t);
 697 #  define prolog(node)                  _prolog(_jit,node)
 698 static void _prolog(jit_state_t*,jit_node_t*);
 699 #  define epilog(node)                  _epilog(_jit,node)
 700 static void _epilog(jit_state_t*,jit_node_t*);
 701 #  define vastart(r0)                   _vastart(_jit, r0)
 702 static void _vastart(jit_state_t*, jit_int32_t);
 703 #  define vaarg(r0, r1)                 _vaarg(_jit, r0, r1)
 704 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
 705 #  define patch_at(jump,label)          _patch_at(_jit,jump,label)
 706 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
 707 #endif
 708
 709 #if CODE
 710 static void
 711 _Pcd(jit_state_t *_jit, int o, unsigned int n)
 712 {
 713     assert(_u6_p(o));
 714     assert(_u26_p(n));
 715     ii((o<<26)|_u26(n));
 716 }
 717
 718 static void
 719 _Bra(jit_state_t *_jit, int o, int ra, int d)
 720 {
 721     assert(_u6_p(o));
 722     assert(_u5_p(ra));
 723     assert(_s21_p(d));
 724     ii((o<<26)|(ra<<21)|_u21(d));
 725 }
 726
 727 static void
 728 _Mem(jit_state_t *_jit, int o, int ra, int rb, unsigned int d)
 729 {
 730     assert(_u6_p(o));
 731     assert(_u5_p(ra));
 732     assert(_u5_p(rb));
 733     assert(_u16_p(d));
 734     ii((o<<26)|(ra<<21)|(rb<<16)|_u16(d));
 735 }
 736
 737 static void
 738 _Mbr(jit_state_t *_jit, int o, int ra, int rb, int h, int d)
 739 {
 740     assert(_u6_p(o));
 741     assert(_u5_p(ra));
 742     assert(_u5_p(rb));
 743     assert(_u2_p(h));
 744     assert(_s14_p(d));
 745     ii((o<<26)|(ra<<21)|(rb<<16)|(h<<14)|_u14(d));
 746 }
 747
 748 static void
 749 _Opr(jit_state_t *_jit, int o, int ra, int rb, unsigned int f, int rc)
 750 {
 751     assert(_u6_p(o));
 752     assert(_u5_p(ra));
 753     assert(_u5_p(rb));
 754     assert(_u5_p(rc));
 755     assert(_u11_p(f));
 756     ii((o<<26)|(ra<<21)|(rb<<16)|(_u11(f)<<5)|rc);
 757 }
 758
 759 static void
 760 _Opi(jit_state_t *_jit, int o, int ra, unsigned int i, unsigned int f, int rc)
 761 {
 762     assert(_u6_p(o));
 763     assert(_u5_p(ra));
 764     assert(_u8_p(i));
 765     assert(_u5_p(rc));
 766     assert(_u7_p(f));
 767     ii((o<<26)|(ra<<21)|(_u8(i)<<13)|(1<<12)|(_u7(f)<<5)|rc);
 768 }
 769
 770 static void
 771 _nop(jit_state_t *_jit, jit_int32_t i0)
 772 {
 773     for (; i0 > 0; i0 -= 4)
 774         NOP();
 775     assert(i0 == 0);
 776 }
 777
 778 static void
 779 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 780 {
 781     if (r0 != r1)
 782         MOV(r1, r0);
 783 }
 784
 785 static void
 786 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 787 {
 788     jit_int32_t         reg;
 789     jit_int16_t         s0, s1, s2, s3;
 790     s0 = i0;
 791     s1 = i0 >> 16;
 792     s2 = i0 >> 32;
 793     s3 = i0 >> 48;
 794     if (s0 < 0)
 795         ++s1;
 796     if (s2 < 0)
 797         ++s3;
 798     if (_u8_p(i0))
 799         MOVi(_u8(i0), r0);
 800     else if (_s16_p(i0))
 801         LDA(r0, _R31_REGNO, _u16(s0));
 802     else if (_s32_p(i0)) {
 803         LDA(r0, _R31_REGNO, _u16(s0));
 804         LDAH(r0, r0, _u16(s1));
 805     }
 806     else if (_u32_p(i0)) {
 807         LDA(r0, _R31_REGNO, _u16(s0));
 808         if (s1)
 809             LDAH(r0, r0, _u16(s1));
 810         lshi(r0, r0, 32);
 811         rshi_u(r0, r0, 32);
 812     }
 813     else if (_u32(i0) == 0) {
 814         LDA(r0, _R31_REGNO, _u16(s2));
 815         if (s3)
 816             LDAH(r0, r0, _u16(s3));
 817         lshi(r0, r0, 32);
 818     }
 819     else {
 820         reg = jit_get_reg(jit_class_gpr);
 821         LDA(r0, _R31_REGNO, _u16(s0));
 822         LDA(rn(reg), _R31_REGNO, _u16(s2));
 823         if (s1)
 824             LDAH(r0, r0, _u16(s1));
 825         if (s3)
 826             LDAH(rn(reg), rn(reg), _u16(s3));
 827         lshi(r0, r0, 32);
 828         rshi_u(r0, r0, 32);
 829         lshi(rn(reg), rn(reg), 32);
 830         orr(r0, r0, rn(reg));
 831         jit_unget_reg(reg);
 832     }
 833 }
 834
 835 static jit_word_t
 836 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 837 {
 838     jit_word_t          w;
 839     jit_int32_t         reg;
 840     jit_int16_t         s0, s1, s2, s3;
 841     w = _jit->pc.w;
 842     reg = jit_get_reg(jit_class_gpr);
 843     s0 = i0;
 844     s1 = i0 >> 16;
 845     s2 = i0 >> 32;
 846     s3 = i0 >> 48;
 847     if (s0 < 0)
 848         ++s1;
 849     if (s2 < 0)
 850         ++s3;
 851     LDA(r0, _R31_REGNO, _u16(s0));
 852     LDA(rn(reg), _R31_REGNO, _u16(s2));
 853     LDAH(r0, r0, _u16(s1));
 854     LDAH(rn(reg), rn(reg), _u16(s3));
 855     lshi(r0, r0, 32);
 856     rshi_u(r0, r0, 32);
 857     lshi(rn(reg), rn(reg), 32);
 858     orr(r0, r0, rn(reg));
 859     jit_unget_reg(reg);
 860     return (w);
 861 }
 862
 863 static void
 864 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
 865       jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
 866 {
 867     jit_word_t          jump0, jump1, again, done;
 868     jit_int32_t         iscasi, r1_reg;
 869     if ((iscasi = (r1 == _NOREG))) {
 870         r1_reg = jit_get_reg(jit_class_gpr);
 871         r1 = rn(r1_reg);
 872         movi(r1, i0);
 873     }
 874     again = _jit->pc.w;                 /* AGAIN */
 875     LDQ_L(r0, r1, 0);                   /* Load r0 locked */
 876     jump0 = bner(_jit->pc.w, r0, r2);   /* bne FAIL r0 r2 */
 877     movr(r0, r3);                       /* Move to r0 to attempt to store */
 878     STQ_C(r0, r1, 0);                   /* r0 is an in/out argument */
 879     jump1 = _jit->pc.w;
 880     BEQ(r0, 0);                         /* beqi AGAIN r0 0 */
 881     patch_at(jump1, again);
 882     jump1 = _jit->pc.w;
 883     BR(_R31_REGNO, 0);                  /* r0 set to 1 if store succeeded */
 884     patch_at(jump0, _jit->pc.w);        /* FAIL: */
 885     movi(r0, 0);                        /* Already locked */
 886     patch_at(jump1, _jit->pc.w);
 887     if (iscasi)
 888         jit_unget_reg(r1_reg);
 889 }
 890
 891 static void
 892 _clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 893 {
 894     comr(r0, r1);
 895     clzr(r0, r0);
 896 }
 897
 898 static void
 899 _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 900 {
 901     comr(r0, r1);
 902     ctzr(r0, r0);
 903 }
 904
 905 static void
 906 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 907 {
 908     jit_int32_t         reg;
 909     if (_u8_p(i0))
 910         ADDQi(r1, i0, r0);
 911     else if (_s16_p(i0))
 912         LDA(r0, r1, _u16(i0));
 913     else {
 914         reg = jit_get_reg(jit_class_gpr);
 915         movi(rn(reg), i0);
 916         addr(r0, r1, rn(reg));
 917         jit_unget_reg(reg);
 918     }
 919 }
 920
 921 static void
 922 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 923 {
 924     jit_int32_t         reg;
 925     if (jit_carry == _NOREG)
 926         jit_carry = jit_get_reg(jit_class_gpr);
 927     if (r0 == r1) {
 928         reg = jit_get_reg(jit_class_gpr);
 929         addr(rn(reg), r1, r2);
 930         ltr_u(rn(jit_carry), rn(reg), r1);
 931         movr(r0, rn(reg));
 932         jit_unget_reg(reg);
 933     }
 934     else {
 935         addr(r0, r1, r2);
 936         ltr_u(rn(jit_carry), r0, r1);
 937     }
 938 }
 939
 940 static void
 941 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 942 {
 943     jit_int32_t         reg;
 944     if (jit_carry == _NOREG)
 945         jit_carry = jit_get_reg(jit_class_gpr);
 946     if (r0 == r1) {
 947         reg = jit_get_reg(jit_class_gpr);
 948         addi(rn(reg), r1, i0);
 949         ltr_u(rn(jit_carry), rn(reg), r1);
 950         movr(r0, rn(reg));
 951         jit_unget_reg(reg);
 952     }
 953     else {
 954         addi(r0, r1, i0);
 955         ltr_u(rn(jit_carry), r0, r1);
 956     }
 957 }
 958
 959 static void
 960 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 961 {
 962     jit_int32_t         reg;
 963     assert(jit_carry != _NOREG);
 964     reg = jit_get_reg(jit_class_gpr);
 965     movr(rn(reg), rn(jit_carry));
 966     addcr(r0, r1, r2);
 967     addcr(r0, r0, rn(reg));
 968     jit_unget_reg(reg);
 969 }
 970
 971 static void
 972 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 973 {
 974     jit_int32_t         reg;
 975     assert(jit_carry != _NOREG);
 976     reg = jit_get_reg(jit_class_gpr);
 977     movr(rn(reg), rn(jit_carry));
 978     addci(r0, r1, i0);
 979     addcr(r0, r0, rn(reg));
 980     jit_unget_reg(reg);
 981 }
 982
 983 static void
 984 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 985 {
 986     jit_int32_t         reg;
 987     if (_u8_p(i0))
 988         SUBQi(r1, i0, r0);
 989     else if (_s16_p(-i0))
 990         LDA(r0, r1, _u16(-i0));
 991     else {
 992         reg = jit_get_reg(jit_class_gpr);
 993         movi(rn(reg), i0);
 994         subr(r0, r1, rn(reg));
 995         jit_unget_reg(reg);
 996     }
 997 }
 998
 999 static void
1000 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1001 {
1002     jit_int32_t         reg;
1003     if (jit_carry == _NOREG)
1004         jit_carry = jit_get_reg(jit_class_gpr);
1005     if (r0 == r1) {
1006         reg = jit_get_reg(jit_class_gpr);
1007         subr(rn(reg), r1, r2);
1008         ltr_u(rn(jit_carry), r1, rn(reg));
1009         movr(r0, rn(reg));
1010         jit_unget_reg(reg);
1011     }
1012     else {
1013         subr(r0, r1, r2);
1014         ltr_u(rn(jit_carry), r1, r0);
1015     }
1016 }
1017
1018 static void
1019 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1020 {
1021     jit_int32_t         reg;
1022     if (jit_carry == _NOREG)
1023         jit_carry = jit_get_reg(jit_class_gpr);
1024     if (r0 == r1) {
1025         reg = jit_get_reg(jit_class_gpr);
1026         addi(rn(reg), r1, -i0);
1027         ltr_u(rn(jit_carry), r1, rn(reg));
1028         movr(r0, rn(reg));
1029         jit_unget_reg(reg);
1030     }
1031     else {
1032         addi(r0, r1, -i0);
1033         ltr_u(rn(jit_carry), r1, r0);
1034     }
1035 }
1036
1037 static void
1038 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1039 {
1040     jit_int32_t         reg;
1041     assert(jit_carry != _NOREG);
1042     reg = jit_get_reg(jit_class_gpr);
1043     movr(rn(reg), rn(jit_carry));
1044     subcr(r0, r1, r2);
1045     subcr(r0, r0, rn(reg));
1046     jit_unget_reg(reg);
1047 }
1048
1049 static void
1050 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1051 {
1052     jit_int32_t         reg;
1053     assert(jit_carry != _NOREG);
1054     reg = jit_get_reg(jit_class_gpr);
1055     movr(rn(reg), rn(jit_carry));
1056     subci(r0, r1, i0);
1057     subcr(r0, r0, rn(reg));
1058     jit_unget_reg(reg);
1059 }
1060
1061 static void
1062 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1063 {
1064     subi(r0, r1, i0);
1065     negr(r0, r0);
1066 }
1067
1068 static void
1069 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1070 {
1071     jit_int32_t         reg;
1072     if (_u8_p(i0))
1073         MULQi(r1, i0, r0);
1074     else {
1075         reg = jit_get_reg(jit_class_gpr);
1076         movi(rn(reg), i0);
1077         mulr(r0, r1, rn(reg));
1078         jit_unget_reg(reg);
1079     }
1080 }
1081
1082 static void
1083 _qmulr(jit_state_t *_jit, jit_int32_t r0,
1084        jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1085 {
1086     jit_int32_t         reg;
1087     /* The only invalid condition is r0 == r1 */
1088     jit_int32_t         t2, t3, s2, s3;
1089     if ((r0 != JIT_NOREG && r2 == r0) || r2 == r1) {
1090         s2 = jit_get_reg(jit_class_gpr);
1091         t2 = rn(s2);
1092         movr(t2, r2);
1093     }
1094     else
1095         t2 = r2;
1096     if ((r0 != JIT_NOREG && r3 == r0) || r3 == r1) {
1097         s3 = jit_get_reg(jit_class_gpr);
1098         t3 = rn(s3);
1099         movr(t3, r3);
1100     }
1101     else
1102         t3 = r3;
1103     qmulr_u(r0, r1, r2, r3);
1104     reg = jit_get_reg(jit_class_gpr);
1105     /**/
1106     rshi(rn(reg), t2, 63);
1107     mulr(rn(reg), rn(reg), t3);
1108     addr(r1, r1, rn(reg));
1109     /**/
1110     rshi(rn(reg), t3, 63);
1111     mulr(rn(reg), rn(reg), t2);
1112     addr(r1, r1, rn(reg));
1113     jit_unget_reg(reg);
1114     if (t2 != r2)
1115         jit_unget_reg(s2);
1116     if (t3 != r3)
1117         jit_unget_reg(s3);
1118 }
1119
1120 static void
1121 _qmuli(jit_state_t *_jit, jit_int32_t r0,
1122        jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1123 {
1124     jit_int32_t         reg;
1125     reg = jit_get_reg(jit_class_gpr);
1126     movi(rn(reg), i0);
1127     qmulr(r0, r1, r2, rn(reg));
1128     jit_unget_reg(reg);
1129 }
1130
1131 static void
1132 _qmulr_u(jit_state_t *_jit, jit_int32_t r0,
1133          jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1134 {
1135     jit_int32_t         reg;
1136     if (r0 != JIT_NOREG) {
1137         if (r0 == r2 || r0 == r3) {
1138             reg = jit_get_reg(jit_class_gpr);
1139             mulr(rn(reg), r2, r3);
1140         }
1141         else
1142             mulr(r0, r2, r3);
1143     }
1144     UMULH(r2, r3, r1);
1145     if (r0 != JIT_NOREG) {
1146         if (r0 == r2 || r0 == r3) {
1147             movr(r0, rn(reg));
1148             jit_unget_reg(reg);
1149         }
1150     }
1151 }
1152
1153 static void
1154 _qmuli_u(jit_state_t *_jit, jit_int32_t r0,
1155          jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1156 {
1157     jit_int32_t         reg;
1158     if (_u8_p(i0)) {
1159         if (r0 != JIT_NOREG) {
1160             if (r0 == r2) {
1161                 reg = jit_get_reg(jit_class_gpr);
1162                 muli(rn(reg), r2, i0);
1163             }
1164             else
1165                 muli(r0, r2, i0);
1166         }
1167         UMULHi(r2, i0, r1);
1168         if (r0 != JIT_NOREG) {
1169             if (r0 == r2) {
1170                 movr(r0, rn(reg));
1171                 jit_unget_reg(reg);
1172             }
1173         }
1174     }
1175     else {
1176         reg = jit_get_reg(jit_class_gpr);
1177         movi(rn(reg), i0);
1178         qmulr_u(r0, r1, r2, rn(reg));
1179         jit_unget_reg(reg);
1180     }
1181 }
1182
1183 static jit_word_t
1184 __idiv(jit_word_t u, jit_word_t v)
1185 {
1186     return (u / v);
1187 }
1188
1189 static void
1190 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1191 {
1192     movr(_A0_REGNO, r1);
1193     movr(_A1_REGNO, r2);
1194     calli((jit_word_t)__idiv);
1195     movr(r0, _V0_REGNO);
1196 }
1197
1198 static void
1199 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1200 {
1201     movr(_A0_REGNO, r1);
1202     movi(_A1_REGNO, i0);
1203     calli((jit_word_t)__idiv);
1204     movr(r0, _V0_REGNO);
1205 }
1206
1207 static jit_uword_t
1208 __udiv(jit_uword_t u, jit_uword_t v)
1209 {
1210     return (u / v);
1211 }
1212
1213 static void
1214 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1215 {
1216     movr(_A0_REGNO, r1);
1217     movr(_A1_REGNO, r2);
1218     calli((jit_word_t)__udiv);
1219     movr(r0, _V0_REGNO);
1220 }
1221
1222 static void
1223 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1224 {
1225     movr(_A0_REGNO, r1);
1226     movi(_A1_REGNO, i0);
1227     calli((jit_word_t)__udiv);
1228     movr(r0, _V0_REGNO);
1229 }
1230
1231 static jit_word_t
1232 __irem(jit_word_t u, jit_word_t v)
1233 {
1234     return (u % v);
1235 }
1236
1237 static void
1238 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1239 {
1240     movr(_A0_REGNO, r1);
1241     movr(_A1_REGNO, r2);
1242     calli((jit_word_t)__irem);
1243     movr(r0, _V0_REGNO);
1244 }
1245
1246 static void
1247 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1248 {
1249     movr(_A0_REGNO, r1);
1250     movi(_A1_REGNO, i0);
1251     calli((jit_word_t)__irem);
1252     movr(r0, _V0_REGNO);
1253 }
1254
1255 static jit_uword_t
1256 __urem(jit_uword_t u, jit_uword_t v)
1257 {
1258     return (u % v);
1259 }
1260
1261 static void
1262 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1263 {
1264     movr(_A0_REGNO, r1);
1265     movr(_A1_REGNO, r2);
1266     calli((jit_word_t)__urem);
1267     movr(r0, _V0_REGNO);
1268 }
1269
1270 static void
1271 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1272 {
1273     movr(_A0_REGNO, r1);
1274     movi(_A1_REGNO, i0);
1275     calli((jit_word_t)__urem);
1276     movr(r0, _V0_REGNO);
1277 }
1278
1279 static jit_word_t
1280 __idivrem(jit_word_t u, jit_word_t v, jit_word_t *rem)
1281 {
1282     *rem = u % v;
1283     return (u / v);
1284 }
1285
1286 static void
1287 _qdivr(jit_state_t *_jit,
1288        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1289 {
1290     movr(_A0_REGNO, r2);
1291     movr(_A1_REGNO, r3);
1292     subi(_A2_REGNO, _FP_REGNO, 8);
1293     calli((jit_word_t)__idivrem);
1294     movr(r0, _V0_REGNO);
1295     ldxi(r1, _FP_REGNO, -8);
1296 }
1297
1298 static void
1299 _qdivi(jit_state_t *_jit,
1300        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1301 {
1302     movr(_A0_REGNO, r2);
1303     movi(_A1_REGNO, i0);
1304     subi(_A2_REGNO, _FP_REGNO, 8);
1305     calli((jit_word_t)__idivrem);
1306     movr(r0, _V0_REGNO);
1307     ldxi(r1, _FP_REGNO, -8);
1308 }
1309
1310 static jit_word_t
1311 __udivrem(jit_uword_t u, jit_uword_t v, jit_uword_t *rem)
1312 {
1313     *rem = u % v;
1314     return (u / v);
1315 }
1316
1317 static void
1318 _qdivr_u(jit_state_t *_jit,
1319          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1320 {
1321     movr(_A0_REGNO, r2);
1322     movr(_A1_REGNO, r3);
1323     subi(_A2_REGNO, _FP_REGNO, 8);
1324     calli((jit_word_t)__udivrem);
1325     movr(r0, _V0_REGNO);
1326     ldxi(r1, _FP_REGNO, -8);
1327 }
1328
1329 static void
1330 _qdivi_u(jit_state_t *_jit,
1331          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1332 {
1333     movr(_A0_REGNO, r2);
1334     movi(_A1_REGNO, i0);
1335     subi(_A2_REGNO, _FP_REGNO, 8);
1336     calli((jit_word_t)__udivrem);
1337     movr(r0, _V0_REGNO);
1338     ldxi(r1, _FP_REGNO, -8);
1339 }
1340
1341 static void
1342 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1343 {
1344     assert(i0 >= 0 && i0 < 64);
1345     SLLi(r1, i0, r0);
1346 }
1347
1348 static void
1349 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1350 {
1351     assert(i0 >= 0 && i0 < 64);
1352     SRAi(r1, i0, r0);
1353 }
1354
1355 static void
1356 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1357 {
1358     assert(i0 >= 0 && i0 < 64);
1359     SRLi(r1, i0, r0);
1360 }
1361
1362 static void
1363 _xlshr(jit_state_t *_jit, jit_bool_t sign,
1364        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1365 {
1366     jit_bool_t          branch;
1367     jit_word_t          over, zero, done, done_over;
1368     jit_int32_t         t0, s0, t1, s1, t2, s2, t3, s3;
1369     s0 = jit_get_reg(jit_class_gpr);
1370     t0 = rn(s0);
1371     if (r0 == r2 || r1 == r2) {
1372         s2 = jit_get_reg(jit_class_gpr);
1373         t2 = rn(s2);
1374         movr(t2, r2);
1375     }
1376     else
1377         t2 = r2;
1378     if (r0 == r3 || r1 == r3) {
1379         s3 = jit_get_reg(jit_class_gpr);
1380         t3 = rn(s3);
1381         movr(t3, r3);
1382     }
1383     else
1384         t3 = r3;
1385     if ((s1 = jit_get_reg(jit_class_gpr|jit_class_nospill|jit_class_chk))) {
1386         t1 = rn(s1);
1387         branch = 0;
1388     }
1389     else
1390         branch = 1;
1391     rsbi(t0, t3, __WORDSIZE);
1392     lshr(r0, t2, t3);
1393     if (sign)
1394         rshr(r1, t2, t0);
1395     else
1396         rshr_u(r1, t2, t0);
1397     if (branch) {
1398         zero = beqi(_jit->pc.w, t3, 0);
1399         over = beqi(_jit->pc.w, t3, __WORDSIZE);
1400         done = jmpi(_jit->pc.w);
1401         patch_at(over, _jit->pc.w);
1402         /* overflow */
1403         movi(r0, 0);
1404         done_over = jmpi(_jit->pc.w);
1405         /* zero */
1406         patch_at(zero, _jit->pc.w);
1407         if (sign)
1408             rshi(r1, t2, __WORDSIZE - 1);
1409         else
1410             movi(r1, 0);
1411         patch_at(done, _jit->pc.w);
1412         patch_at(done_over, _jit->pc.w);
1413     }
1414     else {
1415         if (sign)
1416             rshi(t0, t2, __WORDSIZE - 1);
1417         else
1418             movi(t0, 0);
1419         /* zero? */
1420         movzr(r1, t0, t3);
1421         /* Branchless but 4 bytes longer than branching fallback */
1422         if (sign)
1423             movi(t0, 0);
1424         /* overflow? */
1425         eqi(t1, t3, __WORDSIZE);
1426         movnr(r0, t0, t1);
1427         jit_unget_reg(s1);
1428     }
1429     jit_unget_reg(s0);
1430     if (t2 != r2)
1431         jit_unget_reg(s2);
1432     if (t3 != r3)
1433         jit_unget_reg(s3);
1434 }
1435
1436 static void
1437 _xlshi(jit_state_t *_jit, jit_bool_t sign,
1438        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1439 {
1440     if (i0 == 0) {
1441         movr(r0, r2);
1442         if (sign)
1443             rshi(r1, r2, __WORDSIZE - 1);
1444         else
1445             movi(r1, 0);
1446     }
1447     else if (i0 == __WORDSIZE) {
1448         movr(r1, r2);
1449         movi(r0, 0);
1450     }
1451     else {
1452         assert((jit_uword_t)i0 <= __WORDSIZE);
1453         if (sign)
1454             rshi(r1, r2, __WORDSIZE - i0);
1455         else
1456             rshi_u(r1, r2, __WORDSIZE - i0);
1457         lshi(r0, r2, i0);
1458     }
1459 }
1460
1461 static void
1462 _xrshr(jit_state_t *_jit, jit_bool_t sign,
1463        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1464 {
1465     jit_bool_t          branch;
1466     jit_word_t          over, zero, done, done_over;
1467     jit_int32_t         t0, s0, t1, s1, t2, s2, t3, s3;
1468     s0 = jit_get_reg(jit_class_gpr);
1469     t0 = rn(s0);
1470     if (r0 == r2 || r1 == r2) {
1471         s2 = jit_get_reg(jit_class_gpr);
1472         t2 = rn(s2);
1473         movr(t2, r2);
1474     }
1475     else
1476         t2 = r2;
1477     if (r0 == r3 || r1 == r3) {
1478         s3 = jit_get_reg(jit_class_gpr);
1479         t3 = rn(s3);
1480         movr(t3, r3);
1481     }
1482     else
1483         t3 = r3;
1484     if ((s1 = jit_get_reg(jit_class_gpr|jit_class_nospill|jit_class_chk))) {
1485         t1 = rn(s1);
1486         branch = 0;
1487     }
1488     else
1489         branch = 1;
1490     rsbi(t0, t3, __WORDSIZE);
1491     if (sign)
1492         rshr(r0, t2, t3);
1493     else
1494         rshr_u(r0, t2, t3);
1495     lshr(r1, t2, t0);
1496     if (branch) {
1497         zero = beqi(_jit->pc.w, t3, 0);
1498         over = beqi(_jit->pc.w, t3, __WORDSIZE);
1499         done = jmpi(_jit->pc.w);
1500         patch_at(over, _jit->pc.w);
1501         /* underflow */
1502         if (sign)
1503             rshi(r0, t2, __WORDSIZE - 1);
1504         else
1505             movi(r0, 0);
1506         done_over = jmpi(_jit->pc.w);
1507         /* zero */
1508         patch_at(zero, _jit->pc.w);
1509         movi(r1, 0);
1510         patch_at(done, _jit->pc.w);
1511         patch_at(done_over, _jit->pc.w);
1512         jit_unget_reg(s1);
1513     }
1514     else {
1515         /* zero? */
1516         movi(t0, 0);
1517         movzr(r1, t0, t3);
1518         /* underflow? */
1519         eqi(t1, t3, __WORDSIZE);
1520         if (sign)
1521             rshi(t0, t2, __WORDSIZE - 1);
1522         movnr(r0, t0, t1);
1523         jit_unget_reg(s1);
1524     }
1525     jit_unget_reg(s0);
1526     if (t2 != r2)
1527         jit_unget_reg(s2);
1528     if (t3 != r3)
1529         jit_unget_reg(s3);
1530 }
1531
1532 static void
1533 _xrshi(jit_state_t *_jit, jit_bool_t sign,
1534        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1535 {
1536     if (i0 == 0) {
1537         movr(r0, r2);
1538         movi(r1, 0);
1539     }
1540     else if (i0 == __WORDSIZE) {
1541         movr(r1, r2);
1542         if (sign)
1543             rshi(r0, r2, __WORDSIZE - 1);
1544         else
1545             movi(r0, 0);
1546     }
1547     else {
1548         assert((jit_uword_t)i0 <= __WORDSIZE);
1549         lshi(r1, r2, __WORDSIZE - i0);
1550         if (sign)
1551             rshi(r0, r2, i0);
1552         else
1553             rshi_u(r0, r2, i0);
1554     }
1555 }
1556
1557 static void
1558 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1559 {
1560     union {
1561         jit_uword_t     uw;
1562         jit_uint8_t     uc[8];
1563     } u;
1564     jit_int32_t         reg, zapnot;
1565     if (_u8_p(i0))
1566         ANDi(r1, i0, r0);
1567     else {
1568         u.uw = i0;
1569         for (reg = zapnot = 0; reg < 8; ++reg) {
1570 #  if __BYTE_ORDER == __LITTLE_ENDIAN
1571 #    define OFFS(i)             (i)
1572 #  else
1573 #    define OFFS(i)             (7 - (i))
1574 #  endif
1575             if (u.uc[OFFS(reg)] == 0xff)
1576                 zapnot |= 1 << reg;
1577             else if (u.uc[OFFS(reg)] != 0)
1578                 break;
1579 #  undef OFFS
1580         }
1581         if (reg == 8)
1582             ZAPNOTi(r1, zapnot, r0);
1583         else {
1584             reg = jit_get_reg(jit_class_gpr);
1585             movi(rn(reg), i0);
1586             andr(r0, r1, rn(reg));
1587             jit_unget_reg(reg);
1588         }
1589     }
1590 }
1591
1592 static void
1593 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1594 {
1595     jit_int32_t         reg;
1596     if (_u8_p(i0))
1597         ORi(r1, i0, r0);
1598     else {
1599         reg = jit_get_reg(jit_class_gpr);
1600         movi(rn(reg), i0);
1601         orr(r0, r1, rn(reg));
1602         jit_unget_reg(reg);
1603     }
1604 }
1605
1606 static void
1607 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1608 {
1609     jit_int32_t         reg;
1610     if (_u8_p(i0))
1611         XORi(r1, i0, r0);
1612     else {
1613         reg = jit_get_reg(jit_class_gpr);
1614         movi(rn(reg), i0);
1615         xorr(r0, r1, rn(reg));
1616         jit_unget_reg(reg);
1617     }
1618 }
1619
1620 static void
1621 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1622 {
1623     jit_int32_t         reg;
1624     if (_u8_p(i0))
1625         CMPLTi(r1, i0, r0);
1626     else {
1627         reg = jit_get_reg(jit_class_gpr);
1628         movi(rn(reg), i0);
1629         ltr(r0, r1, rn(reg));
1630         jit_unget_reg(reg);
1631     }
1632 }
1633
1634 static void
1635 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1636 {
1637     jit_int32_t         reg;
1638     if (_u8_p(i0))
1639         CMPULTi(r1, i0, r0);
1640     else {
1641         reg = jit_get_reg(jit_class_gpr);
1642         movi(rn(reg), i0);
1643         ltr_u(r0, r1, rn(reg));
1644         jit_unget_reg(reg);
1645     }
1646 }
1647
1648 static void
1649 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1650 {
1651     jit_int32_t         reg;
1652     if (_u8_p(i0))
1653         CMPLEi(r1, i0, r0);
1654     else {
1655         reg = jit_get_reg(jit_class_gpr);
1656         movi(rn(reg), i0);
1657         ler(r0, r1, rn(reg));
1658         jit_unget_reg(reg);
1659     }
1660 }
1661
1662 static void
1663 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1664 {
1665     jit_int32_t         reg;
1666     jit_word_t          ni0;
1667     ni0 = -i0;
1668     if (_u8_p(i0))
1669         CMPULEi(r1, i0, r0);
1670     else {
1671         reg = jit_get_reg(jit_class_gpr);
1672         movi(rn(reg), i0);
1673         ler_u(r0, r1, rn(reg));
1674         jit_unget_reg(reg);
1675     }
1676 }
1677
1678 static void
1679 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1680 {
1681     jit_int32_t         reg;
1682     if (_u8_p(i0))
1683         CMPEQi(r1, i0, r0);
1684     else {
1685         reg = jit_get_reg(jit_class_gpr);
1686         movi(rn(reg), i0);
1687         eqr(r0, r1, rn(reg));
1688         jit_unget_reg(reg);
1689     }
1690 }
1691
1692 static void
1693 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1694 {
1695     jit_int32_t         reg;
1696     reg = jit_get_reg(jit_class_gpr);
1697     movi(rn(reg), i0);
1698     ger(r0, r1, rn(reg));
1699     jit_unget_reg(reg);
1700 }
1701
1702 static void
1703 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1704 {
1705     jit_int32_t         reg;
1706     reg = jit_get_reg(jit_class_gpr);
1707     movi(rn(reg), i0);
1708     ger_u(r0, r1, rn(reg));
1709     jit_unget_reg(reg);
1710 }
1711
1712 static void
1713 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1714 {
1715     jit_int32_t         reg;
1716     reg = jit_get_reg(jit_class_gpr);
1717     movi(rn(reg), i0);
1718     gtr(r0, r1, rn(reg));
1719     jit_unget_reg(reg);
1720 }
1721
1722 static void
1723 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1724 {
1725     jit_int32_t         reg;
1726     reg = jit_get_reg(jit_class_gpr);
1727     movi(rn(reg), i0);
1728     gtr_u(r0, r1, rn(reg));
1729     jit_unget_reg(reg);
1730 }
1731
1732 static void
1733 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1734 {
1735     CMPEQ(r1, r2, r0);
1736     CMPEQi(r0, 0, r0);
1737 }
1738
1739 static void
1740 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1741 {
1742     jit_int32_t         reg;
1743     if (_u8_p(i0)) {
1744         CMPEQi(r1, i0, r0);
1745         CMPEQi(r0, 0, r0);
1746     }
1747     else {
1748         reg = jit_get_reg(jit_class_gpr);
1749         movi(rn(reg), i0);
1750         ner(r0, r1, rn(reg));
1751         jit_unget_reg(reg);
1752     }
1753 }
1754
1755 static jit_word_t
1756 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1757 {
1758     jit_word_t          w;
1759     jit_int32_t         reg;
1760     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1761     ltr(rn(reg), r0, r1);
1762     w = _jit->pc.w;
1763     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1764     jit_unget_reg(reg);
1765     return (w);
1766 }
1767
1768 static jit_word_t
1769 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1770 {
1771     jit_word_t          w;
1772     jit_int32_t         reg;
1773     if (i1 == 0) {
1774         w = _jit->pc.w;
1775         BLT(r0, ((i0 - w) >> 2) - 1);
1776     }
1777     else {
1778         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1779         lti(rn(reg), r0, i1);
1780         w = _jit->pc.w;
1781         BNE(rn(reg), ((i0 - w) >> 2) - 1);
1782         jit_unget_reg(reg);
1783     }
1784     return (w);
1785 }
1786
1787 static jit_word_t
1788 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1789 {
1790     jit_word_t          w;
1791     jit_int32_t         reg;
1792     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1793     ltr_u(rn(reg), r0, r1);
1794     w = _jit->pc.w;
1795     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1796     jit_unget_reg(reg);
1797     return (w);
1798 }
1799
1800 static jit_word_t
1801 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1802 {
1803     jit_word_t          w;
1804     jit_int32_t         reg;
1805     /* FIXME cannot optimize zero because need to return a patcheable address */
1806     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1807     lti_u(rn(reg), r0, i1);
1808     w = _jit->pc.w;
1809     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1810     jit_unget_reg(reg);
1811     return (w);
1812 }
1813
1814 static jit_word_t
1815 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1816 {
1817     jit_word_t          w;
1818     jit_int32_t         reg;
1819     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1820     ler(rn(reg), r0, r1);
1821     w = _jit->pc.w;
1822     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1823     jit_unget_reg(reg);
1824     return (w);
1825 }
1826
1827 static jit_word_t
1828 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1829 {
1830     jit_word_t          w;
1831     jit_int32_t         reg;
1832     if (i1 == 0) {
1833         w = _jit->pc.w;
1834         BLE(r0, ((i0 - w) >> 2) - 1);
1835     }
1836     else {
1837         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1838         lei(rn(reg), r0, i1);
1839         w = _jit->pc.w;
1840         BNE(rn(reg), ((i0 - w) >> 2) - 1);
1841         jit_unget_reg(reg);
1842     }
1843     return (w);
1844 }
1845
1846 static jit_word_t
1847 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1848 {
1849     jit_word_t          w;
1850     jit_int32_t         reg;
1851     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1852     ler_u(rn(reg), r0, r1);
1853     w = _jit->pc.w;
1854     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1855     jit_unget_reg(reg);
1856     return (w);
1857 }
1858
1859 static jit_word_t
1860 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1861 {
1862     jit_word_t          w;
1863     jit_int32_t         reg;
1864     if (i1 == 0) {
1865         w = _jit->pc.w;
1866         BEQ(r0, ((i0 - w) >> 2) - 1);
1867     }
1868     else {
1869         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1870         lei_u(rn(reg), r0, i1);
1871         w = _jit->pc.w;
1872         BNE(rn(reg), ((i0 - w) >> 2) - 1);
1873         jit_unget_reg(reg);
1874      }
1875     return (w);
1876 }
1877
1878 static jit_word_t
1879 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1880 {
1881     jit_word_t          w;
1882     jit_int32_t         reg;
1883     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1884     eqr(rn(reg), r0, r1);
1885     w = _jit->pc.w;
1886     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1887     jit_unget_reg(reg);
1888     return (w);
1889 }
1890
1891 static jit_word_t
1892 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1893 {
1894     jit_word_t          w;
1895     jit_int32_t         reg;
1896     if (i1 == 0) {
1897         w = _jit->pc.w;
1898         BEQ(r0, ((i0 - w) >> 2) - 1);
1899     }
1900     else {
1901         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1902         eqi(rn(reg), r0, i1);
1903         w = _jit->pc.w;
1904         BNE(rn(reg), ((i0 - w) >> 2) - 1);
1905         jit_unget_reg(reg);
1906     }
1907     return (w);
1908 }
1909
1910 static jit_word_t
1911 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1912 {
1913     jit_word_t          w;
1914     jit_int32_t         reg;
1915     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1916     ger(rn(reg), r0, r1);
1917     w = _jit->pc.w;
1918     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1919     jit_unget_reg(reg);
1920     return (w);
1921 }
1922
1923 static jit_word_t
1924 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1925 {
1926     jit_word_t          w;
1927     jit_int32_t         reg;
1928     if (i1 == 0) {
1929         w = _jit->pc.w;
1930         BGE(r0, ((i0 - w) >> 2) - 1);
1931     }
1932     else {
1933         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1934         gei(rn(reg), r0, i1);
1935         w = _jit->pc.w;
1936         BNE(rn(reg), ((i0 - w) >> 2) - 1);
1937         jit_unget_reg(reg);
1938     }
1939     return (w);
1940 }
1941
1942 static jit_word_t
1943 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1944 {
1945     jit_word_t          w;
1946     jit_int32_t         reg;
1947     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1948     ger_u(rn(reg), r0, r1);
1949     w = _jit->pc.w;
1950     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1951     jit_unget_reg(reg);
1952     return (w);
1953 }
1954
1955 static jit_word_t
1956 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1957 {
1958     jit_word_t          w;
1959     jit_int32_t         reg;
1960     /* always true if i1 == 0 */
1961     if (i0 == 0) {
1962         w = _jit->pc.w;
1963         BR(r0, ((i0 - w) >> 2) - 1);
1964     }
1965     else {
1966         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1967         gei_u(rn(reg), r0, i1);
1968         w = _jit->pc.w;
1969         BNE(rn(reg), ((i0 - w) >> 2) - 1);
1970         jit_unget_reg(reg);
1971     }
1972     return (w);
1973 }
1974
1975 static jit_word_t
1976 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1977 {
1978     jit_word_t          w;
1979     jit_int32_t         reg;
1980     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1981     gtr(rn(reg), r0, r1);
1982     w = _jit->pc.w;
1983     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1984     jit_unget_reg(reg);
1985     return (w);
1986 }
1987
1988 static jit_word_t
1989 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1990 {
1991     jit_word_t          w;
1992     jit_int32_t         reg;
1993     if (i1 == 0) {
1994         w = _jit->pc.w;
1995         BGT(r0, ((i0 - w) >> 2) - 1);
1996     }
1997     else {
1998         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1999         gti(rn(reg), r0, i1);
2000         w = _jit->pc.w;
2001         BNE(rn(reg), ((i0 - w) >> 2) - 1);
2002         jit_unget_reg(reg);
2003     }
2004     return (w);
2005 }
2006
2007 static jit_word_t
2008 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2009 {
2010     jit_word_t          w;
2011     jit_int32_t         reg;
2012     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2013     gtr_u(rn(reg), r0, r1);
2014     w = _jit->pc.w;
2015     BNE(rn(reg), ((i0 - w) >> 2) - 1);
2016     jit_unget_reg(reg);
2017     return (w);
2018 }
2019
2020 static jit_word_t
2021 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2022 {
2023     jit_word_t          w;
2024     jit_int32_t         reg;
2025     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2026     gti_u(rn(reg), r0, i1);
2027     w = _jit->pc.w;
2028     BNE(rn(reg), ((i0 - w) >> 2) - 1);
2029     jit_unget_reg(reg);
2030     return (w);
2031 }
2032
2033 static jit_word_t
2034 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2035 {
2036     jit_word_t          w;
2037     jit_int32_t         reg;
2038     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2039     eqr(rn(reg), r0, r1);
2040     w = _jit->pc.w;
2041     BEQ(rn(reg), ((i0 - w) >> 2) - 1);
2042     jit_unget_reg(reg);
2043     return (w);
2044 }
2045
2046 static jit_word_t
2047 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2048 {
2049     jit_word_t          w;
2050     jit_int32_t         reg;
2051     if (i1 == 0) {
2052         w = _jit->pc.w;
2053         BNE(r0, ((i0 - w) >> 2) - 1);
2054     }
2055     else {
2056         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2057         eqi(rn(reg), r0, i1);
2058         w = _jit->pc.w;
2059         BEQ(rn(reg), ((i0 - w) >> 2) - 1);
2060         jit_unget_reg(reg);
2061     }
2062     return (w);
2063 }
2064
2065 static jit_word_t
2066 _baddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
2067        jit_bool_t carry)
2068 {
2069     jit_word_t          w;
2070     jit_int32_t         t0;
2071     jit_int32_t         t1;
2072     jit_int32_t         t2;
2073     jit_int32_t         t3;
2074     /* t0 = r0 + r1;    overflow = r1 < 0 ? r0 < t0 : t0 < r0 */
2075     t0 = jit_get_reg(jit_class_gpr);
2076     t1 = jit_get_reg(jit_class_gpr);
2077     t2 = jit_get_reg(jit_class_gpr);
2078     t3 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2079     addr(rn(t0), r0, r1);               /* t0 = r0 + r1 */
2080     ltr(rn(t1), r1, _R31_REGNO);        /* t1 = r1 < 0 */
2081     ltr(rn(t2), r0, rn(t0));            /* t2 = r0 < t0 */
2082     ltr(rn(t3), rn(t0), r0);            /* t3 = t0 < r0 */
2083     movr(r0, rn(t0));                   /* r0 += r1 */
2084     CMOVNE(rn(t1), rn(t2), rn(t3));     /* if (t1 == 0) t3 = t2; */
2085     jit_unget_reg(t2);
2086     jit_unget_reg(t1);
2087     jit_unget_reg(t0);
2088     w = _jit->pc.w;
2089     if (carry)
2090         BNE(rn(t3), ((i0 - w) >> 2) - 1);
2091     else
2092         BEQ(rn(t3), ((i0 - w) >> 2) - 1);
2093     jit_unget_reg(t3);
2094     return (w);
2095 }
2096
2097 static jit_word_t
2098 _baddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
2099        jit_bool_t carry)
2100 {
2101     jit_word_t          w;
2102     jit_int32_t         reg;
2103     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2104     movi(rn(reg), i1);
2105     w = baddr(i0, r0, rn(reg), carry);
2106     jit_unget_reg(reg);
2107     return (w);
2108 }
2109
2110 static jit_word_t
2111 _baddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
2112          jit_bool_t carry)
2113 {
2114     jit_word_t          w;
2115     jit_int32_t         t0;
2116     jit_int32_t         t1;
2117     t0 = jit_get_reg(jit_class_gpr);
2118     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2119     addr(rn(t0), r0, r1);
2120     ltr_u(rn(t1), rn(t0), r0);
2121     movr(r0, rn(t0));
2122     jit_unget_reg(t0);
2123     w = _jit->pc.w;
2124     if (carry)
2125         BNE(rn(t1), ((i0 - w) >> 2) - 1);
2126     else
2127         BEQ(rn(t1), ((i0 - w) >> 2) - 1);
2128     jit_unget_reg(t1);
2129     return (w);
2130 }
2131
2132 static jit_word_t
2133 _baddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
2134          jit_bool_t carry)
2135 {
2136     jit_word_t          w;
2137     jit_int32_t         t0;
2138     jit_int32_t         t1;
2139     t0 = jit_get_reg(jit_class_gpr);
2140     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2141     addi(rn(t0), r0, i1);
2142     ltr_u(rn(t1), rn(t0), r0);
2143     movr(r0, rn(t0));
2144     jit_unget_reg(t0);
2145     w = _jit->pc.w;
2146     if (carry)
2147         BNE(rn(t1), ((i0 - w) >> 2) - 1);
2148     else
2149         BEQ(rn(t1), ((i0 - w) >> 2) - 1);
2150     jit_unget_reg(t1);
2151     return (w);
2152 }
2153
2154 static jit_word_t
2155 _bsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
2156        jit_bool_t carry)
2157 {
2158     jit_word_t          w;
2159     jit_int32_t         t0;
2160     jit_int32_t         t1;
2161     jit_int32_t         t2;
2162     jit_int32_t         t3;
2163     /* t0 = r0 - r1;    overflow = 0 < r1 ? r0 < t0 : t0 < r0 */
2164     t0 = jit_get_reg(jit_class_gpr);
2165     t1 = jit_get_reg(jit_class_gpr);
2166     t2 = jit_get_reg(jit_class_gpr);
2167     t3 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2168     subr(rn(t0), r0, r1);               /* r0 = r0 - r1 */
2169     ltr(rn(t1), _R31_REGNO, r1);        /* t1 = 0 < r1 */
2170     ltr(rn(t2), r0, rn(t0));            /* t2 = r0 < t0 */
2171     ltr(rn(t3), rn(t0), r0);            /* t3 = t0 < r0 */
2172     movr(r0, rn(t0));                   /* r0 -= r1 */
2173     CMOVNE(rn(t1), rn(t2), rn(t3));     /* if (t1 == 0) t3 = t2; */
2174     jit_unget_reg(t2);
2175     jit_unget_reg(t1);
2176     jit_unget_reg(t0);
2177     w = _jit->pc.w;
2178     if (carry)
2179         BNE(rn(t3), ((i0 - w) >> 2) - 1);
2180     else
2181         BEQ(rn(t3), ((i0 - w) >> 2) - 1);
2182     jit_unget_reg(t3);
2183     return (w);
2184 }
2185
2186 static jit_word_t
2187 _bsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
2188        jit_bool_t carry)
2189 {
2190     jit_word_t          w;
2191     jit_int32_t         reg;
2192     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2193     movi(rn(reg), i1);
2194     w = bsubr(i0, r0, rn(reg), carry);
2195     jit_unget_reg(reg);
2196     return (w);
2197 }
2198
2199 static jit_word_t
2200 _bsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
2201          jit_bool_t carry)
2202 {
2203     jit_word_t          w;
2204     jit_int32_t         t0;
2205     jit_int32_t         t1;
2206     t0 = jit_get_reg(jit_class_gpr);
2207     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2208     subr(rn(t0), r0, r1);
2209     ltr_u(rn(t1), r0, rn(t0));
2210     movr(r0, rn(t0));
2211     jit_unget_reg(t0);
2212     w = _jit->pc.w;
2213     if (carry)
2214         BNE(rn(t1), ((i0 - w) >> 2) - 1);
2215     else
2216         BEQ(rn(t1), ((i0 - w) >> 2) - 1);
2217     jit_unget_reg(t1);
2218     return (w);
2219 }
2220
2221 static jit_word_t
2222 _bsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
2223          jit_bool_t carry)
2224 {
2225     jit_word_t          w;
2226     jit_int32_t         t0;
2227     jit_int32_t         t1;
2228     t0 = jit_get_reg(jit_class_gpr);
2229     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2230     subi(rn(t0), r0, i1);
2231     ltr_u(rn(t1), r0, rn(t0));
2232     movr(r0, rn(t0));
2233     jit_unget_reg(t0);
2234     w = _jit->pc.w;
2235     if (carry)
2236         BNE(rn(t1), ((i0 - w) >> 2) - 1);
2237     else
2238         BEQ(rn(t1), ((i0 - w) >> 2) - 1);
2239     jit_unget_reg(t1);
2240     return (w);
2241 }
2242
2243 static jit_word_t
2244 _bmxr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
2245       jit_bool_t set)
2246 {
2247     jit_word_t          w;
2248     jit_int32_t         t0;
2249     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2250     andr(rn(t0), r0, r1);
2251     w = _jit->pc.w;
2252     if (set)
2253         BNE(rn(t0), ((i0 - w) >> 2) - 1);
2254     else
2255         BEQ(rn(t0), ((i0 - w) >> 2) - 1);
2256     jit_unget_reg(t0);
2257     return (w);
2258 }
2259
2260 static jit_word_t
2261 _bmxi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
2262       jit_bool_t set)
2263 {
2264     jit_word_t          w;
2265     jit_int32_t         t0;
2266     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2267     andi(rn(t0), r0, i1);
2268     w = _jit->pc.w;
2269     if (set)
2270         BNE(rn(t0), ((i0 - w) >> 2) - 1);
2271     else
2272         BEQ(rn(t0), ((i0 - w) >> 2) - 1);
2273     jit_unget_reg(t0);
2274     return (w);
2275 }
2276
2277 static void
2278 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2279 {
2280     ldr_uc(r0, r1);
2281     extr_c(r0, r0);
2282 }
2283
2284 static void
2285 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2286 {
2287     jit_int32_t         reg;
2288     if (_s16_p(i0)) {
2289         LDBU(r0, _R31_REGNO, _u16(i0));
2290         extr_c(r0, r0);
2291     }
2292     else {
2293         reg = jit_get_reg(jit_class_gpr);
2294         movi(rn(reg), i0);
2295         ldr_c(r0, rn(reg));
2296         jit_unget_reg(reg);
2297     }
2298 }
2299
2300 static void
2301 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2302 {
2303     jit_int32_t         reg;
2304     if (_s16_p(i0))
2305         LDBU(r0, _R31_REGNO, _u16(i0));
2306     else  {
2307         reg = jit_get_reg(jit_class_gpr);
2308         movi(rn(reg), i0);
2309         ldr_uc(r0, rn(reg));
2310         jit_unget_reg(reg);
2311     }
2312 }
2313
2314 static void
2315 _ldr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2316 {
2317     ldr_us(r0, r1);
2318     extr_s(r0, r0);
2319 }
2320
2321 static void
2322 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2323 {
2324     jit_int32_t         reg;
2325     if (_s16_p(i0)) {
2326         LDWU(r0, _R31_REGNO, _u16(i0));
2327         extr_s(r0, r0);
2328     }
2329     else {
2330         reg = jit_get_reg(jit_class_gpr);
2331         movi(rn(reg), i0);
2332         ldr_s(r0, rn(reg));
2333         jit_unget_reg(reg);
2334     }
2335 }
2336
2337 static void
2338 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2339 {
2340     jit_int32_t         reg;
2341     if (_s16_p(i0))
2342         LDWU(r0, _R31_REGNO, _u16(i0));
2343     else {
2344         reg = jit_get_reg(jit_class_gpr);
2345         movi(rn(reg), i0);
2346         ldr_us(r0, rn(reg));
2347         jit_unget_reg(reg);
2348     }
2349 }
2350
2351 static void
2352 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2353 {
2354     jit_int32_t         reg;
2355     if (_s16_p(i0))
2356         LDL(r0, _R31_REGNO, _u16(i0));
2357     else {
2358         reg = jit_get_reg(jit_class_gpr);
2359         movi(rn(reg), i0);
2360         ldr_i(r0, rn(reg));
2361         jit_unget_reg(reg);
2362     }
2363 }
2364
2365 static void
2366 _ldr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2367 {
2368     ldr_i(r0, r1);
2369     extr_ui(r0, r0);
2370 }
2371
2372 static void
2373 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2374 {
2375     jit_int32_t         reg;
2376     if (_s16_p(i0)) {
2377         LDL(r0, _R31_REGNO, _u16(i0));
2378         extr_ui(r0, r0);
2379     }
2380     else {
2381         reg = jit_get_reg(jit_class_gpr);
2382         movi(rn(reg), i0);
2383         ldr_ui(r0, rn(reg));
2384         jit_unget_reg(reg);
2385     }
2386 }
2387
2388 static void
2389 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2390 {
2391     jit_int32_t         reg;
2392     if (_s16_p(i0))
2393         LDQ(r0, _R31_REGNO, _u16(i0));
2394     else {
2395         reg = jit_get_reg(jit_class_gpr);
2396         movi(rn(reg), i0);
2397         ldr_l(r0, rn(reg));
2398         jit_unget_reg(reg);
2399     }
2400 }
2401
2402 static void
2403 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2404 {
2405     jit_int32_t         reg;
2406     reg = jit_get_reg(jit_class_gpr);
2407     addr(rn(reg), r1, r2);
2408     ldr_c(r0, rn(reg));
2409     jit_unget_reg(reg);
2410 }
2411
2412 static void
2413 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2414 {
2415     jit_int32_t         reg;
2416     if (_s16_p(i0)) {
2417         LDBU(r0, r1, _u16(i0));
2418         extr_c(r0, r0);
2419     }
2420     else {
2421         reg = jit_get_reg(jit_class_gpr);
2422         addi(rn(reg), r1, i0);
2423         ldr_c(r0, rn(reg));
2424         jit_unget_reg(reg);
2425     }
2426 }
2427
2428 static void
2429 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2430 {
2431     jit_int32_t         reg;
2432     reg = jit_get_reg(jit_class_gpr);
2433     addr(rn(reg), r1, r2);
2434     ldr_uc(r0, rn(reg));
2435     jit_unget_reg(reg);
2436 }
2437
2438 static void
2439 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2440 {
2441     jit_int32_t         reg;
2442     if (_s16_p(i0))
2443         LDBU(r0, r1, _u16(i0));
2444     else {
2445         reg = jit_get_reg(jit_class_gpr);
2446         addi(rn(reg), r1, i0);
2447         ldr_uc(r0, rn(reg));
2448         jit_unget_reg(reg);
2449     }
2450 }
2451
2452 static void
2453 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2454 {
2455     jit_int32_t         reg;
2456     reg = jit_get_reg(jit_class_gpr);
2457     addr(rn(reg), r1, r2);
2458     ldr_s(r0, rn(reg));
2459     jit_unget_reg(reg);
2460 }
2461
2462 static void
2463 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2464 {
2465     jit_int32_t         reg;
2466     if (_s16_p(i0)) {
2467         LDWU(r0, r1, _u16(i0));
2468         extr_s(r0, r0);
2469     }
2470     else {
2471         reg = jit_get_reg(jit_class_gpr);
2472         addi(rn(reg), r1, i0);
2473         ldr_s(r0, rn(reg));
2474         jit_unget_reg(reg);
2475     }
2476 }
2477
2478 static void
2479 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2480 {
2481     jit_int32_t         reg;
2482     reg = jit_get_reg(jit_class_gpr);
2483     addr(rn(reg), r1, r2);
2484     ldr_us(r0, rn(reg));
2485     jit_unget_reg(reg);
2486 }
2487
2488 static void
2489 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2490 {
2491     jit_int32_t         reg;
2492     if (_s16_p(i0))
2493         LDWU(r0, r1, _u16(i0));
2494     else {
2495         reg = jit_get_reg(jit_class_gpr);
2496         addi(rn(reg), r1, i0);
2497         ldr_us(r0, rn(reg));
2498         jit_unget_reg(reg);
2499     }
2500 }
2501
2502 static void
2503 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2504 {
2505     jit_int32_t         reg;
2506     reg = jit_get_reg(jit_class_gpr);
2507     addr(rn(reg), r1, r2);
2508     ldr_i(r0, rn(reg));
2509     jit_unget_reg(reg);
2510 }
2511
2512 static void
2513 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2514 {
2515     jit_int32_t         reg;
2516     if (_s16_p(i0))
2517         LDL(r0, r1, _u16(i0));
2518     else {
2519         reg = jit_get_reg(jit_class_gpr);
2520         addi(rn(reg), r1, i0);
2521         ldr_i(r0, rn(reg));
2522         jit_unget_reg(reg);
2523     }
2524 }
2525
2526 static void
2527 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2528 {
2529     jit_int32_t         reg;
2530     reg = jit_get_reg(jit_class_gpr);
2531     addr(rn(reg), r1, r2);
2532     ldr_ui(r0, rn(reg));
2533     jit_unget_reg(reg);
2534 }
2535
2536 static void
2537 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2538 {
2539     jit_int32_t         reg;
2540     if (_s16_p(i0)) {
2541         LDL(r0, r1, _u16(i0));
2542         extr_ui(r0, r0);
2543     }
2544     else {
2545         reg = jit_get_reg(jit_class_gpr);
2546         addi(rn(reg), r1, i0);
2547         ldr_ui(r0, rn(reg));
2548         jit_unget_reg(reg);
2549     }
2550 }
2551
2552 static void
2553 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2554 {
2555     jit_int32_t         reg;
2556     reg = jit_get_reg(jit_class_gpr);
2557     addr(rn(reg), r1, r2);
2558     ldr_l(r0, rn(reg));
2559     jit_unget_reg(reg);
2560 }
2561
2562 static void
2563 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2564 {
2565     jit_int32_t         reg;
2566     if (_s16_p(i0))
2567         LDQ(r0, r1, _u16(i0));
2568     else {
2569         reg = jit_get_reg(jit_class_gpr);
2570         addi(rn(reg), r1, i0);
2571         ldr_l(r0, rn(reg));
2572         jit_unget_reg(reg);
2573     }
2574 }
2575
2576 static void
2577 _unldr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2578 {
2579     jit_int32_t         t0, r2, t1, r3;
2580     assert(i0 >= 1 && i0 <= sizeof(jit_word_t));
2581     if (i0 == 1)
2582         ldr_c(r0, r1);
2583     else {
2584         t0 = jit_get_reg(jit_class_gpr);        r2 = rn(t0);
2585         t1 = jit_get_reg(jit_class_gpr);
2586         if (r0 == r1) {
2587             r3 = rn(t1);
2588             movr(r3, r1);
2589         }
2590         else
2591             r3 = r1;
2592         LDQ_U(r0, r3, 0);
2593         LDQ_U(r2, r3, 7);
2594         if (r0 == r1) {
2595 #if __BYTE_ORDER == __LITTLE_ENDIAN
2596             LDA(r3, r3, 0);
2597 #else
2598             LDA(r3, r3, 7);
2599 #endif
2600         }
2601         else {
2602             r3 = rn(t1);
2603 #if __BYTE_ORDER == __LITTLE_ENDIAN
2604             LDA(r3, r1, 0);
2605 #else
2606             LDA(r3, r1, 7);
2607 #endif
2608         }
2609         EXTQL(r0, r3, r0);
2610         EXTQH(r2, r3, r2);
2611         OR(r2, r0, r0);
2612         jit_unget_reg(t1);
2613         jit_unget_reg(t0);
2614         switch (i0) {
2615             case 2:
2616                 extr_s(r0, r0);
2617                 break;
2618             case 3:
2619                 lshi(r0, r0, __WORDSIZE - 24);
2620                 rshi(r0, r0, __WORDSIZE - 24);
2621                 break;
2622             case 4:
2623                 extr_i(r0, r0);
2624                 break;
2625             case 5:
2626                 lshi(r0, r0, __WORDSIZE - 40);
2627                 rshi(r0, r0, __WORDSIZE - 40);
2628                 break;
2629             case 6:
2630                 lshi(r0, r0, __WORDSIZE - 48);
2631                 rshi(r0, r0, __WORDSIZE - 48);
2632                 break;
2633             case 7:
2634                 lshi(r0, r0, __WORDSIZE - 56);
2635                 rshi(r0, r0, __WORDSIZE - 56);
2636                 break;
2637             default:
2638                 break;
2639         }
2640     }
2641 }
2642
2643 /* Slightly shorter than fallback, and branchless */
2644 static void
2645 _unldi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
2646 {
2647     jit_int32_t         reg;
2648     reg = jit_get_reg(jit_class_gpr);
2649     movi(rn(reg), i0);
2650     unldr(r0, rn(reg), i1);
2651     jit_unget_reg(reg);
2652 }
2653
2654 static void
2655 _unldr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2656 {
2657     jit_int32_t         t0, r2, t1, r3;
2658     assert(i0 >= 1 && i0 <= sizeof(jit_word_t));
2659     if (i0 == 1)
2660         ldr_uc(r0, r1);
2661     else {
2662         t0 = jit_get_reg(jit_class_gpr);        r2 = rn(t0);
2663         t1 = jit_get_reg(jit_class_gpr);
2664         if (r0 == r1) {
2665             r3 = rn(t1);
2666             movr(r3, r1);
2667         }
2668         else
2669             r3 = r1;
2670         LDQ_U(r0, r3, 0);
2671         LDQ_U(r2, r3, 7);
2672         if (r0 == r1) {
2673 #if __BYTE_ORDER == __LITTLE_ENDIAN
2674             LDA(r3, r3, 0);
2675 #else
2676             LDA(r3, r3, 7);
2677 #endif
2678         }
2679         else {
2680             r3 = rn(t1);
2681 #if __BYTE_ORDER == __LITTLE_ENDIAN
2682             LDA(r3, r1, 0);
2683 #else
2684             LDA(r3, r1, 7);
2685 #endif
2686         }
2687         EXTQL(r0, r3, r0);
2688         EXTQH(r2, r3, r2);
2689         OR(r2, r0, r0);
2690         jit_unget_reg(t1);
2691         jit_unget_reg(t0);
2692         switch (i0) {
2693             case 2:
2694                 extr_us(r0, r0);
2695                 break;
2696             case 3:
2697                 lshi(r0, r0, __WORDSIZE - 24);
2698                 rshi_u(r0, r0, __WORDSIZE - 24);
2699                 break;
2700             case 4:
2701                 extr_ui(r0, r0);
2702                 break;
2703             case 5:
2704                 lshi(r0, r0, __WORDSIZE - 40);
2705                 rshi_u(r0, r0, __WORDSIZE - 40);
2706                 break;
2707             case 6:
2708                 lshi(r0, r0, __WORDSIZE - 48);
2709                 rshi_u(r0, r0, __WORDSIZE - 48);
2710                 break;
2711             case 7:
2712                 lshi(r0, r0, __WORDSIZE - 56);
2713                 rshi_u(r0, r0, __WORDSIZE - 56);
2714                 break;
2715             default:
2716                 break;
2717         }
2718     }
2719 }
2720
2721 static void
2722 _unldi_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
2723 {
2724     jit_int32_t         reg;
2725     reg = jit_get_reg(jit_class_gpr);
2726     movi(rn(reg), i0);
2727     unldr_u(r0, rn(reg), i1);
2728     jit_unget_reg(reg);
2729 }
2730
2731 static void
2732 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2733 {
2734     jit_int32_t         reg;
2735     if (_s16_p(i0))
2736         STB(r0, _R31_REGNO, _u16(i0));
2737     else {
2738         reg = jit_get_reg(jit_class_gpr);
2739         movi(rn(reg), i0);
2740         str_c(rn(reg), r0);
2741         jit_unget_reg(reg);
2742     }
2743 }
2744
2745 static void
2746 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2747 {
2748     jit_int32_t         reg;
2749     if (_s16_p(i0))
2750         STW(r0, _R31_REGNO, _u16(i0));
2751     else {
2752         reg = jit_get_reg(jit_class_gpr);
2753         movi(rn(reg), i0);
2754         str_s(rn(reg), r0);
2755         jit_unget_reg(reg);
2756     }
2757 }
2758
2759 static void
2760 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2761 {
2762     jit_int32_t         reg;
2763     if (_s16_p(i0))
2764         STL(r0, _R31_REGNO, _u16(i0));
2765     else {
2766         reg = jit_get_reg(jit_class_gpr);
2767         movi(rn(reg), i0);
2768         str_i(rn(reg), r0);
2769         jit_unget_reg(reg);
2770     }
2771 }
2772
2773 static void
2774 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2775 {
2776     jit_int32_t         reg;
2777     if (_s16_p(i0))
2778         STQ(r0, _R31_REGNO, _u16(i0));
2779     else {
2780         reg = jit_get_reg(jit_class_gpr);
2781         movi(rn(reg), i0);
2782         str_l(rn(reg), r0);
2783         jit_unget_reg(reg);
2784     }
2785 }
2786
2787 static void
2788 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2789 {
2790     jit_int32_t         reg;
2791     reg = jit_get_reg(jit_class_gpr);
2792     addr(rn(reg), r0, r1);
2793     str_c(rn(reg), r2);
2794     jit_unget_reg(reg);
2795 }
2796
2797 static void
2798 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2799 {
2800     jit_int32_t         reg;
2801     if (_s16_p(i0))
2802         STB(r1, r0, _u16(i0));
2803     else {
2804         reg = jit_get_reg(jit_class_gpr);
2805         addi(rn(reg), r0, i0);
2806         str_c(rn(reg), r1);
2807         jit_unget_reg(reg);
2808     }
2809 }
2810
2811 static void
2812 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2813 {
2814     jit_int32_t         reg;
2815     reg = jit_get_reg(jit_class_gpr);
2816     addr(rn(reg), r0, r1);
2817     str_s(rn(reg), r2);
2818     jit_unget_reg(reg);
2819 }
2820
2821 static void
2822 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2823 {
2824     jit_int32_t         reg;
2825     if (_s16_p(i0))
2826         STW(r1, r0, _u16(i0));
2827     else {
2828         reg = jit_get_reg(jit_class_gpr);
2829         addi(rn(reg), r0, i0);
2830         str_s(rn(reg), r1);
2831         jit_unget_reg(reg);
2832     }
2833 }
2834
2835 static void
2836 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2837 {
2838     jit_int32_t         reg;
2839     reg = jit_get_reg(jit_class_gpr);
2840     addr(rn(reg), r0, r1);
2841     str_i(rn(reg), r2);
2842     jit_unget_reg(reg);
2843 }
2844
2845 static void
2846 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2847 {
2848     jit_int32_t         reg;
2849     if (_s16_p(i0))
2850         STL(r1, r0, _u16(i0));
2851     else {
2852         reg = jit_get_reg(jit_class_gpr);
2853         addi(rn(reg), r0, i0);
2854         str_i(rn(reg), r1);
2855         jit_unget_reg(reg);
2856     }
2857 }
2858
2859 static void
2860 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2861 {
2862     jit_int32_t         reg;
2863     reg = jit_get_reg(jit_class_gpr);
2864     addr(rn(reg), r0, r1);
2865     str_l(rn(reg), r2);
2866     jit_unget_reg(reg);
2867 }
2868
2869 static void
2870 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2871 {
2872     jit_int32_t         reg;
2873     if (_s16_p(i0))
2874         STQ(r1, r0, _u16(i0));
2875     else {
2876         reg = jit_get_reg(jit_class_gpr);
2877         addi(rn(reg), r0, i0);
2878         str_l(rn(reg), r1);
2879         jit_unget_reg(reg);
2880     }
2881 }
2882
2883 static void
2884 _unstr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2885 {
2886     jit_word_t          t0, t1, t2, t3, t4, r2, r3, r4, r5, r6;
2887     assert(i0 > 0 && i0 <= sizeof(jit_word_t));
2888     if (i0 == 1)
2889         str_c(r0, r1);
2890     else if (i0 == 4 || i0 == 8) {
2891         t0 = jit_get_reg(jit_class_gpr);        r2 = rn(t0);
2892         t1 = jit_get_reg(jit_class_gpr);        r3 = rn(t1);
2893         t2 = jit_get_reg(jit_class_gpr);        r4 = rn(t2);
2894         t3 = jit_get_reg(jit_class_gpr);        r5 = rn(t3);
2895         t4 = jit_get_reg(jit_class_gpr);        r6 = rn(t4);
2896 #if __BYTE_ORDER == __LITTLE_ENDIAN
2897         LDA(r4, r0, 0);                 /* r4<2:0> = (X mod 8) = 5 */
2898 #else
2899         LDA(r4, r0, i0 - 1);            /* r4<2:0> = ((X+7) mod 8) = 5 */
2900 #endif
2901         LDQ_U(r2, r0, i0 - 1);          /* Ignores va<2:0>, r2 = yyyH GFED
2902                                                             or (if i0 == 4)
2903                                                             r2 = yyyy yyyD */
2904         LDQ_U(r3, r0, 0);               /* Ignores va<2:0>, r3 = CBAx xxxx */
2905         if (i0 == 8) {
2906             INSQH(r1, r4, r5);          /* r5 = 000H GFED */
2907             INSQL(r1, r4, r6);          /* r6 = CBA0 0000 */
2908             MSKQH(r2, r4, r2);          /* r2 = yyy0 0000 */
2909             MSKQL(r3, r4, r3);          /* r3 = 000x xxxx */
2910         }
2911         else {
2912             INSLH(r1, r4, r5);          /* r5 = 0000 000D */
2913             INSLL(r1, r4, r6);          /* r6 = CBA0 0000 */
2914             MSKLH(r2, r4, r2);          /* r2 = yyy0 0000 */
2915             MSKLL(r3, r4, r3);          /* r3 = 000x xxxx */
2916         }
2917         OR(r2, r5, r2);                 /* r2 = yyyH GFED (or yyyy yyyD) */
2918         OR(r3, r6, r3);                 /* r1 = CBAx xxxx */
2919         STQ_U(r2, r0, i0 - 1);          /* Must store high then low for */
2920         STQ_U(r3, r0, 0);               /* degenerate case of aligned QW */
2921         jit_unget_reg(t4);
2922         jit_unget_reg(t3);
2923         jit_unget_reg(t2);
2924         jit_unget_reg(t1);
2925         jit_unget_reg(t0);
2926     }
2927     else
2928         fallback_unstr(r0, r1, i0);
2929 }
2930
2931 static void
2932 _unsti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2933 {
2934     jit_int32_t         reg;
2935     if (i1 == 4 || i1 == 8) {
2936         reg = jit_get_reg(jit_class_gpr);
2937         movi(rn(reg), i0);
2938         unstr(rn(reg), r0, i1);
2939         jit_unget_reg(reg);
2940     }
2941     else
2942         fallback_unsti(i0, r0, i1);
2943 }
2944
2945 static void
2946 _extr(jit_state_t *_jit,
2947       jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
2948 {
2949     assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
2950     if (i1 == __WORDSIZE)
2951         movr(r0, r1);
2952     else {
2953 #  if __BYTE_ORDER == __BIG_ENDIAN
2954         i0 = __WORDSIZE - (i0 + i1);
2955 #  endif
2956         if (__WORDSIZE - (i0 + i1)) {
2957             lshi(r0, r1, __WORDSIZE - (i0 + i1));
2958             rshi(r0, r0, __WORDSIZE - i1);
2959         }
2960         else
2961             rshi(r0, r1, __WORDSIZE - i1);
2962     }
2963 }
2964
2965 static void
2966 _extr_u(jit_state_t *_jit,
2967         jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
2968 {
2969     assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
2970     if (i1 == __WORDSIZE)
2971         movr(r0, r1);
2972     else {
2973 #  if __BYTE_ORDER == __BIG_ENDIAN
2974         i0 = __WORDSIZE - (i0 + i1);
2975 #  endif
2976         if ((i0 & 7) == 0) {
2977             if (i1 == 8) {
2978                 EXTBLi(r1, i0 >> 3, r0);
2979                 goto done;
2980             }
2981             if (i1 == 16) {
2982                 EXTWLi(r1, i0 >> 3, r0);
2983                 goto done;
2984             }
2985             if (i1 == 32) {
2986                 EXTLLi(r1, i0 >> 3, r0);
2987                 goto done;
2988             }
2989         }
2990         if (i0)
2991             rshi_u(r0, r1, i0);
2992         andi(r0, r0, (1L << i1) - 1);
2993     }
2994 done:;
2995 }
2996
2997 static void
2998 _depr(jit_state_t *_jit,
2999       jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
3000 {
3001     jit_int32_t         t0;
3002     jit_word_t          mask;
3003     assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
3004     if (i1 == __WORDSIZE)
3005         movr(r0, r1);
3006     else {
3007 #  if __BYTE_ORDER == __BIG_ENDIAN
3008         i0 = __WORDSIZE - (i0 + i1);
3009 #  endif
3010         t0 = jit_get_reg(jit_class_gpr);
3011         if ((i0 & 7) == 0) {
3012             if (i1 == 8) {
3013                 MSKBLi(r0, i0 >> 3, rn(t0));
3014                 INSBLi(r1, i0 >> 3, r0);
3015                 goto done;
3016             }
3017             if (i1 == 16) {
3018                 MSKWLi(r0, i0 >> 3, rn(t0));
3019                 INSWLi(r1, i0 >> 3, r0);
3020                 goto done;
3021             }
3022             if (i1 == 32) {
3023                 MSKLLi(r0, i0 >> 3, rn(t0));
3024                 INSLLi(r1, i0 >> 3, r0);
3025                 goto done;
3026             }
3027         }
3028         mask = (1L << i1) - 1;
3029         andi(rn(t0), r1, mask);
3030         if (i0) {
3031             lshi(rn(t0), rn(t0), i0);
3032             mask <<= i0;
3033         }
3034         andi(r0, r0, ~mask);
3035     done:
3036         orr(r0, r0, rn(t0));
3037         jit_unget_reg(t0);
3038     }
3039 }
3040
3041 static void
3042 _extr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3043 {
3044     lshi(r0, r1, 32);
3045     rshi(r0, r0, 32);
3046 }
3047
3048 static void
3049 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3050 {
3051     jit_int32_t         t0;
3052     t0 = jit_get_reg(jit_class_gpr);
3053     EXTBLi(r1, 0, rn(t0));
3054     EXTBLi(r1, 1, r0);
3055     SLLi(rn(t0), 8, rn(t0));
3056     OR(r0, rn(t0), r0);
3057     jit_unget_reg(t0);
3058 }
3059
3060 static void
3061 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3062 {
3063     jit_int32_t         t0;
3064     jit_int32_t         t1;
3065     jit_int32_t         t2;
3066     jit_int32_t         t3;
3067     t0 = jit_get_reg(jit_class_gpr);
3068     t1 = jit_get_reg(jit_class_gpr);
3069     t2 = jit_get_reg(jit_class_gpr);
3070     t3 = jit_get_reg(jit_class_gpr);
3071     EXTBLi(r1, 3, rn(t0));
3072     INSBLi(r1, 3, rn(t1));
3073     SLLi(r1, 8, rn(t2));
3074     ZAPNOTi(rn(t2), 4, rn(t2));
3075     SRLi(r1, 8, rn(t3));
3076     OR(rn(t0), rn(t1), r0);
3077     OR(rn(t2), r0, r0);
3078     ZAPNOTi(rn(t3), 2, rn(t3));
3079     OR(rn(t3), r0, r0);
3080     jit_unget_reg(t3);
3081     jit_unget_reg(t2);
3082     jit_unget_reg(t1);
3083     jit_unget_reg(t0);
3084 }
3085
3086 static void
3087 _bswapr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3088 {
3089     jit_int32_t         t0;
3090     jit_int32_t         t1;
3091     jit_int32_t         t2;
3092     assert(_jitc->function != NULL);
3093     t0 = jit_get_reg(jit_class_fpr);
3094     t1 = jit_get_reg(jit_class_gpr);
3095     t2 = jit_get_reg(jit_class_gpr);
3096     stxi(-8, _FP_REGNO, r1);                    /* r1 = ABCD EFGH */
3097     LDG(rn(t0), _FP_REGNO, _u16(-8));           /* t0 = GHEF CDAB */
3098     STT(rn(t0), _FP_REGNO, _u16(-8));
3099     ldxi(rn(t1), _FP_REGNO, -8);                /* t1 = GHEF CDAB */
3100     lshi(rn(t2), rn(t1), 8);                    /* t2 = HEFC DAB. */
3101     rshi_u(rn(t1), rn(t1), 8);                  /* t1 = .GHE FCDA */
3102     ZAPi(rn(t2), 0x55, rn(t2));                 /* t2 = H.F. D.B. */
3103     ZAPi(rn(t1), 0xaa, rn(t1));                 /* t1 = .G.E .C.A */
3104     orr(r0, rn(t1), rn(t2));                    /* r0 = HGFE DCBA */
3105     jit_unget_reg(t2);
3106     jit_unget_reg(t1);
3107     jit_unget_reg(t0);
3108 }
3109
3110 static jit_word_t
3111 _jmpi(jit_state_t *_jit, jit_word_t i0)
3112 {
3113     jit_word_t          w;
3114     jit_word_t          d;
3115     w = _jit->pc.w;
3116     d = ((i0 - w) >> 2) - 1;
3117     if (_s21_p(d))
3118         BR(_R31_REGNO, d);
3119     else
3120         w = jmpi_p(i0);
3121     return (w);
3122 }
3123
3124 static jit_word_t
3125 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3126 {
3127     jit_word_t          w;
3128     jit_int32_t         reg;
3129     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3130     w = movi_p(rn(reg), i0);
3131     jmpr(rn(reg));
3132     jit_unget_reg(reg);
3133     return (w);
3134 }
3135
3136 static void
3137 _callr(jit_state_t *_jit, jit_int32_t r0)
3138 {
3139     if (r0 != _PV_REGNO)
3140         MOV(r0, _PV_REGNO);
3141     JSR(_RA_REGNO, _PV_REGNO, 0);
3142 }
3143
3144 static void
3145 _calli(jit_state_t *_jit, jit_word_t i0)
3146 {
3147     /* FIXME use a small buffer to load constants - using gp */
3148 #if 0
3149     jit_word_t          w;
3150     jit_word_t          d;
3151     w = _jit->pc.w;
3152     d = ((i0 - w) >> 2) - 1;
3153     if (_s21_p(d))
3154         BSR(_RA_REGNO, d);
3155     else
3156         (void)calli_p(i0);
3157 #else
3158     movi(_PV_REGNO, i0);
3159     callr(_PV_REGNO);
3160 #endif
3161 }
3162
3163 static jit_word_t
3164 _calli_p(jit_state_t *_jit, jit_word_t i0)
3165 {
3166     jit_word_t          w;
3167     w = movi_p(_PV_REGNO, i0);
3168     callr(_PV_REGNO);
3169     return (w);
3170 }
3171
3172 static void
3173 _prolog(jit_state_t *_jit, jit_node_t *node)
3174 {
3175     jit_int32_t         reg;
3176     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3177         jit_int32_t     frame = -_jitc->function->frame;
3178         assert(_jitc->function->self.aoff >= frame);
3179         if (_jitc->function->assume_frame)
3180             return;
3181         _jitc->function->self.aoff = frame;
3182     }
3183     if (_jitc->function->allocar)
3184         _jitc->function->self.aoff &= -8;
3185     _jitc->function->stack = ((_jitc->function->self.alen -
3186                                _jitc->function->self.aoff) + 7) & -8;
3187     /* ldgp gp, 0(pv) */
3188     LDAH(_PV_REGNO, _GP_REGNO, 0);
3189     LDA(_GP_REGNO, _GP_REGNO, 0);
3190     /* callee save registers */
3191     subi(_SP_REGNO, _SP_REGNO, stack_framesize);
3192     stxi(0, _SP_REGNO, _RA_REGNO);
3193     stxi(8, _SP_REGNO, _FP_REGNO);
3194 #  define SPILL(N, O)                                                   \
3195     if (jit_regset_tstbit(&_jitc->function->regset, N))                 \
3196         stxi(O, _SP_REGNO, N##_REGNO)
3197 #  define SPILLD(N, O)                                                  \
3198     if (jit_regset_tstbit(&_jitc->function->regset, N))                 \
3199         stxi_d(O, _SP_REGNO, N##_REGNO)
3200     SPILL(_S0, 16);
3201     SPILL(_S1, 24);
3202     SPILL(_S2, 32);
3203     SPILL(_S3, 40);
3204     SPILL(_S4, 48);
3205     SPILL(_S5, 56);
3206     SPILLD(_F2, 64);
3207     SPILLD(_F3, 72);
3208     SPILLD(_F4, 80);
3209     SPILLD(_F5, 88);
3210     SPILLD(_F6, 96);
3211     SPILLD(_F7, 104);
3212     SPILLD(_F8, 112);
3213     SPILLD(_F9, 120);
3214 #  undef SPILLD
3215 #  undef SPILL
3216     movr(_FP_REGNO, _SP_REGNO);
3217     /* alloca */
3218     if (_jitc->function->stack)
3219         subi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
3220     if (_jitc->function->allocar) {
3221         reg = jit_get_reg(jit_class_gpr);
3222         movi(rn(reg), _jitc->function->self.aoff);
3223         stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(reg));
3224         jit_unget_reg(reg);
3225     }
3226
3227     if (_jitc->function->self.call & jit_call_varargs) {
3228         for (reg = _jitc->function->self.argi; jit_arg_reg_p(reg); ++reg)
3229             stxi(stack_framesize - 48 + reg * 8, _FP_REGNO, rn(_A0 - reg));
3230         for (reg = _jitc->function->self.argi; jit_arg_reg_p(reg); ++reg)
3231             stxi_d(stack_framesize - 96 + reg * 8, _FP_REGNO, rn(_F16 - reg));
3232     }
3233 }
3234
3235 static void
3236 _epilog(jit_state_t *_jit, jit_node_t *node)
3237 {
3238     if (_jitc->function->assume_frame)
3239         return;
3240     movr(_SP_REGNO, _FP_REGNO);
3241     ldxi(_RA_REGNO, _SP_REGNO, 0);
3242     ldxi(_FP_REGNO, _SP_REGNO, 8);
3243 #  define LOAD(N, O)                                                    \
3244     if (jit_regset_tstbit(&_jitc->function->regset, N))                 \
3245         ldxi(N##_REGNO, _SP_REGNO,  O)
3246 #  define LOADD(N, O)                                                   \
3247     if (jit_regset_tstbit(&_jitc->function->regset, N))                 \
3248         ldxi_d(N##_REGNO, _SP_REGNO,  O)
3249     LOAD(_S0, 16);
3250     LOAD(_S1, 24);
3251     LOAD(_S2, 32);
3252     LOAD(_S3, 40);
3253     LOAD(_S4, 48);
3254     LOAD(_S5, 56);
3255     LOADD(_F2, 64);
3256     LOADD(_F3, 72);
3257     LOADD(_F4, 80);
3258     LOADD(_F5, 88);
3259     LOADD(_F6, 96);
3260     LOADD(_F7, 104);
3261     LOADD(_F8, 112);
3262     LOADD(_F9, 120);
3263 #  undef LOADD
3264 #  undef LOAD
3265     addi(_SP_REGNO, _SP_REGNO, stack_framesize);
3266     RET(_R31_REGNO, _RA_REGNO, 1);      /* 1 means procedure return
3267                                          * 0 means no procedure return
3268                                          * other values are reserved */
3269 }
3270
3271 static void
3272 _vastart(jit_state_t *_jit, jit_int32_t r0)
3273 {
3274     jit_int32_t         reg;
3275
3276     /* Return jit_va_list_t in the register argument */
3277     addi(r0, _FP_REGNO, _jitc->function->vaoff);
3278
3279     reg = jit_get_reg(jit_class_gpr);
3280
3281     /* The base field is constant. */
3282     addi(rn(reg), _FP_REGNO, stack_framesize - 48);
3283     stxi(offsetof(jit_va_list_t, base), r0, rn(reg));
3284
3285     /* Initialize the offset field */
3286     if (_jitc->function->vagp < 6)
3287         movi(rn(reg), _jitc->function->vagp * 8);
3288     else
3289         movi(rn(reg), _jitc->function->self.size - (stack_framesize - 48));
3290     stxi(offsetof(jit_va_list_t, offset), r0, rn(reg));
3291
3292     jit_unget_reg(reg);
3293 }
3294
3295 static void
3296 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3297 {
3298     jit_int32_t         rg0, rg1;
3299
3300     assert(_jitc->function->self.call & jit_call_varargs);
3301
3302     rg0 = jit_get_reg(jit_class_gpr);
3303     rg1 = jit_get_reg(jit_class_gpr);
3304
3305     /* Load the base in first temporary. */
3306     ldxi(rn(rg0), r1, offsetof(jit_va_list_t, base));
3307
3308     /* Load the offset in the second temporary. */
3309     ldxi(rn(rg1), r1, offsetof(jit_va_list_t, offset));
3310
3311     /* Load the argument */
3312     ldxr(r0, rn(rg0), rn(rg1));
3313
3314     /* No longer needed. */
3315     jit_unget_reg(rg0);
3316
3317     /* Update offset. */
3318     addi(rn(rg1), rn(rg1), 8);
3319     stxi(offsetof(jit_va_list_t, offset), r1, rn(rg1));
3320     jit_unget_reg(rg1);
3321 }
3322
3323 static void
3324 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3325 {
3326     union {
3327         jit_int32_t     *i;
3328         jit_word_t       w;
3329     } u;
3330     jit_word_t           d;
3331     jit_int16_t         s0, s1, s2, s3;
3332     u.w = instr;
3333     switch (_u6(u.i[0] >> 26)) {
3334         /*   BLT             BLE             BEQ             BGE */
3335         case 0x3a:      case 0x3b:      case 0x39:      case 0x3e:
3336         /*   BGT             BNE             BLBC            BLBS */
3337         case 0x3f:      case 0x3d:      case 0x38:      case 0x3c:
3338         /*   BR              BSR */
3339         case 0x30:      case 0x34:
3340         /*   FBLT            FBLE            FBEQ            FBGE */
3341         case 0x32:      case 0x33:      case 0x31:      case 0x36:
3342         /*   FBGT            FBNE */
3343         case 0x37:      case 0x35:
3344             d = ((label - instr) >> 2) - 1;
3345             assert(_s21_p(d));
3346             u.i[0] &= ~0x1fffff;
3347             u.i[0] |= _u21(d);
3348             break;
3349         /*   LDA */
3350         case 0x08:              /* movi_p */
3351             s0 = label;
3352             s1 = label >> 16;
3353             s2 = label >> 32;
3354             s3 = label >> 48;
3355             if (s0 < 0)
3356                 ++s1;
3357             if (s2 < 0)
3358                 ++s3;
3359             u.i[0] &= ~0xffff;
3360             u.i[0] |= _u16(s0);
3361             /*                          LDA */
3362             assert(_u6(u.i[1] >> 26) == 0x08);
3363             u.i[1] &= ~0xffff;
3364             u.i[1] |= _u16(s2);
3365             /*                          LDAH */
3366             assert(_u6(u.i[2] >> 26) == 0x09);
3367             u.i[2] &= ~0xffff;
3368             u.i[2] |= _u16(s1);
3369             /*                          LDAH */
3370             assert(_u6(u.i[3] >> 26) == 0x09);
3371             u.i[3] &= ~0xffff;
3372             u.i[3] |= _u16(s3);
3373             /*                          SLL */
3374             assert(_u6(u.i[4] >> 26) == 0x12 && _u7(u.i[4] >> 5) == 0x39);
3375             /*                          SRL */
3376             assert(_u6(u.i[5] >> 26) == 0x12 && _u7(u.i[5] >> 5) == 0x34);
3377             /*                          SLL */
3378             assert(_u6(u.i[6] >> 26) == 0x12 && _u7(u.i[6] >> 5) == 0x39);
3379             /*                          BIS */
3380             assert(_u6(u.i[7] >> 26) == 0x11 && _u7(u.i[7] >> 5) == 0x20);
3381             break;
3382         default:
3383             abort();
3384     }
3385 }
3386 #endif