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         if (sign)
1510             rshi(r1, t2, __WORDSIZE - 1);
1511         else
1512             movi(r1, 0);
1513         patch_at(done, _jit->pc.w);
1514         patch_at(done_over, _jit->pc.w);
1515         jit_unget_reg(s1);
1516     }
1517     else {
1518         /* zero? */
1519         if (sign)
1520             rshi(t0, t2, __WORDSIZE - 1);
1521         else
1522             movi(t0, 0);
1523         movzr(r1, t0, t3);
1524         /* underflow? */
1525         eqi(t1, t3, __WORDSIZE);
1526         movnr(r0, t0, t1);
1527         jit_unget_reg(s1);
1528     }
1529     jit_unget_reg(s0);
1530     if (t2 != r2)
1531         jit_unget_reg(s2);
1532     if (t3 != r3)
1533         jit_unget_reg(s3);
1534 }
1535
1536 static void
1537 _xrshi(jit_state_t *_jit, jit_bool_t sign,
1538        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1539 {
1540     if (i0 == 0) {
1541         movr(r0, r2);
1542         if (sign)
1543             rshi(r1, r2, __WORDSIZE - 1);
1544         else
1545             movi(r1, 0);
1546     }
1547     else if (i0 == __WORDSIZE) {
1548         movr(r1, r2);
1549         if (sign)
1550             rshi(r0, r2, __WORDSIZE - 1);
1551         else
1552             movi(r0, 0);
1553     }
1554     else {
1555         assert((jit_uword_t)i0 <= __WORDSIZE);
1556         lshi(r1, r2, __WORDSIZE - i0);
1557         if (sign)
1558             rshi(r0, r2, i0);
1559         else
1560             rshi_u(r0, r2, i0);
1561     }
1562 }
1563
1564 static void
1565 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1566 {
1567     union {
1568         jit_uword_t     uw;
1569         jit_uint8_t     uc[8];
1570     } u;
1571     jit_int32_t         reg, zapnot;
1572     if (_u8_p(i0))
1573         ANDi(r1, i0, r0);
1574     else {
1575         u.uw = i0;
1576         for (reg = zapnot = 0; reg < 8; ++reg) {
1577 #  if __BYTE_ORDER == __LITTLE_ENDIAN
1578 #    define OFFS(i)             (i)
1579 #  else
1580 #    define OFFS(i)             (7 - (i))
1581 #  endif
1582             if (u.uc[OFFS(reg)] == 0xff)
1583                 zapnot |= 1 << reg;
1584             else if (u.uc[OFFS(reg)] != 0)
1585                 break;
1586 #  undef OFFS
1587         }
1588         if (reg == 8)
1589             ZAPNOTi(r1, zapnot, r0);
1590         else {
1591             reg = jit_get_reg(jit_class_gpr);
1592             movi(rn(reg), i0);
1593             andr(r0, r1, rn(reg));
1594             jit_unget_reg(reg);
1595         }
1596     }
1597 }
1598
1599 static void
1600 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1601 {
1602     jit_int32_t         reg;
1603     if (_u8_p(i0))
1604         ORi(r1, i0, r0);
1605     else {
1606         reg = jit_get_reg(jit_class_gpr);
1607         movi(rn(reg), i0);
1608         orr(r0, r1, rn(reg));
1609         jit_unget_reg(reg);
1610     }
1611 }
1612
1613 static void
1614 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1615 {
1616     jit_int32_t         reg;
1617     if (_u8_p(i0))
1618         XORi(r1, i0, r0);
1619     else {
1620         reg = jit_get_reg(jit_class_gpr);
1621         movi(rn(reg), i0);
1622         xorr(r0, r1, rn(reg));
1623         jit_unget_reg(reg);
1624     }
1625 }
1626
1627 static void
1628 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1629 {
1630     jit_int32_t         reg;
1631     if (_u8_p(i0))
1632         CMPLTi(r1, i0, r0);
1633     else {
1634         reg = jit_get_reg(jit_class_gpr);
1635         movi(rn(reg), i0);
1636         ltr(r0, r1, rn(reg));
1637         jit_unget_reg(reg);
1638     }
1639 }
1640
1641 static void
1642 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1643 {
1644     jit_int32_t         reg;
1645     if (_u8_p(i0))
1646         CMPULTi(r1, i0, r0);
1647     else {
1648         reg = jit_get_reg(jit_class_gpr);
1649         movi(rn(reg), i0);
1650         ltr_u(r0, r1, rn(reg));
1651         jit_unget_reg(reg);
1652     }
1653 }
1654
1655 static void
1656 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1657 {
1658     jit_int32_t         reg;
1659     if (_u8_p(i0))
1660         CMPLEi(r1, i0, r0);
1661     else {
1662         reg = jit_get_reg(jit_class_gpr);
1663         movi(rn(reg), i0);
1664         ler(r0, r1, rn(reg));
1665         jit_unget_reg(reg);
1666     }
1667 }
1668
1669 static void
1670 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1671 {
1672     jit_int32_t         reg;
1673     jit_word_t          ni0;
1674     ni0 = -i0;
1675     if (_u8_p(i0))
1676         CMPULEi(r1, i0, r0);
1677     else {
1678         reg = jit_get_reg(jit_class_gpr);
1679         movi(rn(reg), i0);
1680         ler_u(r0, r1, rn(reg));
1681         jit_unget_reg(reg);
1682     }
1683 }
1684
1685 static void
1686 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1687 {
1688     jit_int32_t         reg;
1689     if (_u8_p(i0))
1690         CMPEQi(r1, i0, r0);
1691     else {
1692         reg = jit_get_reg(jit_class_gpr);
1693         movi(rn(reg), i0);
1694         eqr(r0, r1, rn(reg));
1695         jit_unget_reg(reg);
1696     }
1697 }
1698
1699 static void
1700 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1701 {
1702     jit_int32_t         reg;
1703     reg = jit_get_reg(jit_class_gpr);
1704     movi(rn(reg), i0);
1705     ger(r0, r1, rn(reg));
1706     jit_unget_reg(reg);
1707 }
1708
1709 static void
1710 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1711 {
1712     jit_int32_t         reg;
1713     reg = jit_get_reg(jit_class_gpr);
1714     movi(rn(reg), i0);
1715     ger_u(r0, r1, rn(reg));
1716     jit_unget_reg(reg);
1717 }
1718
1719 static void
1720 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1721 {
1722     jit_int32_t         reg;
1723     reg = jit_get_reg(jit_class_gpr);
1724     movi(rn(reg), i0);
1725     gtr(r0, r1, rn(reg));
1726     jit_unget_reg(reg);
1727 }
1728
1729 static void
1730 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1731 {
1732     jit_int32_t         reg;
1733     reg = jit_get_reg(jit_class_gpr);
1734     movi(rn(reg), i0);
1735     gtr_u(r0, r1, rn(reg));
1736     jit_unget_reg(reg);
1737 }
1738
1739 static void
1740 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1741 {
1742     CMPEQ(r1, r2, r0);
1743     CMPEQi(r0, 0, r0);
1744 }
1745
1746 static void
1747 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1748 {
1749     jit_int32_t         reg;
1750     if (_u8_p(i0)) {
1751         CMPEQi(r1, i0, r0);
1752         CMPEQi(r0, 0, r0);
1753     }
1754     else {
1755         reg = jit_get_reg(jit_class_gpr);
1756         movi(rn(reg), i0);
1757         ner(r0, r1, rn(reg));
1758         jit_unget_reg(reg);
1759     }
1760 }
1761
1762 static jit_word_t
1763 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1764 {
1765     jit_word_t          w;
1766     jit_int32_t         reg;
1767     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1768     ltr(rn(reg), r0, r1);
1769     w = _jit->pc.w;
1770     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1771     jit_unget_reg(reg);
1772     return (w);
1773 }
1774
1775 static jit_word_t
1776 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1777 {
1778     jit_word_t          w;
1779     jit_int32_t         reg;
1780     if (i1 == 0) {
1781         w = _jit->pc.w;
1782         BLT(r0, ((i0 - w) >> 2) - 1);
1783     }
1784     else {
1785         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1786         lti(rn(reg), r0, i1);
1787         w = _jit->pc.w;
1788         BNE(rn(reg), ((i0 - w) >> 2) - 1);
1789         jit_unget_reg(reg);
1790     }
1791     return (w);
1792 }
1793
1794 static jit_word_t
1795 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1796 {
1797     jit_word_t          w;
1798     jit_int32_t         reg;
1799     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1800     ltr_u(rn(reg), r0, r1);
1801     w = _jit->pc.w;
1802     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1803     jit_unget_reg(reg);
1804     return (w);
1805 }
1806
1807 static jit_word_t
1808 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1809 {
1810     jit_word_t          w;
1811     jit_int32_t         reg;
1812     /* FIXME cannot optimize zero because need to return a patcheable address */
1813     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1814     lti_u(rn(reg), r0, i1);
1815     w = _jit->pc.w;
1816     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1817     jit_unget_reg(reg);
1818     return (w);
1819 }
1820
1821 static jit_word_t
1822 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1823 {
1824     jit_word_t          w;
1825     jit_int32_t         reg;
1826     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1827     ler(rn(reg), r0, r1);
1828     w = _jit->pc.w;
1829     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1830     jit_unget_reg(reg);
1831     return (w);
1832 }
1833
1834 static jit_word_t
1835 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1836 {
1837     jit_word_t          w;
1838     jit_int32_t         reg;
1839     if (i1 == 0) {
1840         w = _jit->pc.w;
1841         BLE(r0, ((i0 - w) >> 2) - 1);
1842     }
1843     else {
1844         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1845         lei(rn(reg), r0, i1);
1846         w = _jit->pc.w;
1847         BNE(rn(reg), ((i0 - w) >> 2) - 1);
1848         jit_unget_reg(reg);
1849     }
1850     return (w);
1851 }
1852
1853 static jit_word_t
1854 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1855 {
1856     jit_word_t          w;
1857     jit_int32_t         reg;
1858     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1859     ler_u(rn(reg), r0, r1);
1860     w = _jit->pc.w;
1861     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1862     jit_unget_reg(reg);
1863     return (w);
1864 }
1865
1866 static jit_word_t
1867 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1868 {
1869     jit_word_t          w;
1870     jit_int32_t         reg;
1871     if (i1 == 0) {
1872         w = _jit->pc.w;
1873         BEQ(r0, ((i0 - w) >> 2) - 1);
1874     }
1875     else {
1876         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1877         lei_u(rn(reg), r0, i1);
1878         w = _jit->pc.w;
1879         BNE(rn(reg), ((i0 - w) >> 2) - 1);
1880         jit_unget_reg(reg);
1881      }
1882     return (w);
1883 }
1884
1885 static jit_word_t
1886 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1887 {
1888     jit_word_t          w;
1889     jit_int32_t         reg;
1890     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1891     eqr(rn(reg), r0, r1);
1892     w = _jit->pc.w;
1893     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1894     jit_unget_reg(reg);
1895     return (w);
1896 }
1897
1898 static jit_word_t
1899 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1900 {
1901     jit_word_t          w;
1902     jit_int32_t         reg;
1903     if (i1 == 0) {
1904         w = _jit->pc.w;
1905         BEQ(r0, ((i0 - w) >> 2) - 1);
1906     }
1907     else {
1908         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1909         eqi(rn(reg), r0, i1);
1910         w = _jit->pc.w;
1911         BNE(rn(reg), ((i0 - w) >> 2) - 1);
1912         jit_unget_reg(reg);
1913     }
1914     return (w);
1915 }
1916
1917 static jit_word_t
1918 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1919 {
1920     jit_word_t          w;
1921     jit_int32_t         reg;
1922     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1923     ger(rn(reg), r0, r1);
1924     w = _jit->pc.w;
1925     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1926     jit_unget_reg(reg);
1927     return (w);
1928 }
1929
1930 static jit_word_t
1931 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1932 {
1933     jit_word_t          w;
1934     jit_int32_t         reg;
1935     if (i1 == 0) {
1936         w = _jit->pc.w;
1937         BGE(r0, ((i0 - w) >> 2) - 1);
1938     }
1939     else {
1940         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1941         gei(rn(reg), r0, i1);
1942         w = _jit->pc.w;
1943         BNE(rn(reg), ((i0 - w) >> 2) - 1);
1944         jit_unget_reg(reg);
1945     }
1946     return (w);
1947 }
1948
1949 static jit_word_t
1950 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1951 {
1952     jit_word_t          w;
1953     jit_int32_t         reg;
1954     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1955     ger_u(rn(reg), r0, r1);
1956     w = _jit->pc.w;
1957     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1958     jit_unget_reg(reg);
1959     return (w);
1960 }
1961
1962 static jit_word_t
1963 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1964 {
1965     jit_word_t          w;
1966     jit_int32_t         reg;
1967     /* always true if i1 == 0 */
1968     if (i0 == 0) {
1969         w = _jit->pc.w;
1970         BR(r0, ((i0 - w) >> 2) - 1);
1971     }
1972     else {
1973         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1974         gei_u(rn(reg), r0, i1);
1975         w = _jit->pc.w;
1976         BNE(rn(reg), ((i0 - w) >> 2) - 1);
1977         jit_unget_reg(reg);
1978     }
1979     return (w);
1980 }
1981
1982 static jit_word_t
1983 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1984 {
1985     jit_word_t          w;
1986     jit_int32_t         reg;
1987     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1988     gtr(rn(reg), r0, r1);
1989     w = _jit->pc.w;
1990     BNE(rn(reg), ((i0 - w) >> 2) - 1);
1991     jit_unget_reg(reg);
1992     return (w);
1993 }
1994
1995 static jit_word_t
1996 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1997 {
1998     jit_word_t          w;
1999     jit_int32_t         reg;
2000     if (i1 == 0) {
2001         w = _jit->pc.w;
2002         BGT(r0, ((i0 - w) >> 2) - 1);
2003     }
2004     else {
2005         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2006         gti(rn(reg), r0, i1);
2007         w = _jit->pc.w;
2008         BNE(rn(reg), ((i0 - w) >> 2) - 1);
2009         jit_unget_reg(reg);
2010     }
2011     return (w);
2012 }
2013
2014 static jit_word_t
2015 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2016 {
2017     jit_word_t          w;
2018     jit_int32_t         reg;
2019     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2020     gtr_u(rn(reg), r0, r1);
2021     w = _jit->pc.w;
2022     BNE(rn(reg), ((i0 - w) >> 2) - 1);
2023     jit_unget_reg(reg);
2024     return (w);
2025 }
2026
2027 static jit_word_t
2028 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2029 {
2030     jit_word_t          w;
2031     jit_int32_t         reg;
2032     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2033     gti_u(rn(reg), r0, i1);
2034     w = _jit->pc.w;
2035     BNE(rn(reg), ((i0 - w) >> 2) - 1);
2036     jit_unget_reg(reg);
2037     return (w);
2038 }
2039
2040 static jit_word_t
2041 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2042 {
2043     jit_word_t          w;
2044     jit_int32_t         reg;
2045     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2046     eqr(rn(reg), r0, r1);
2047     w = _jit->pc.w;
2048     BEQ(rn(reg), ((i0 - w) >> 2) - 1);
2049     jit_unget_reg(reg);
2050     return (w);
2051 }
2052
2053 static jit_word_t
2054 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2055 {
2056     jit_word_t          w;
2057     jit_int32_t         reg;
2058     if (i1 == 0) {
2059         w = _jit->pc.w;
2060         BNE(r0, ((i0 - w) >> 2) - 1);
2061     }
2062     else {
2063         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2064         eqi(rn(reg), r0, i1);
2065         w = _jit->pc.w;
2066         BEQ(rn(reg), ((i0 - w) >> 2) - 1);
2067         jit_unget_reg(reg);
2068     }
2069     return (w);
2070 }
2071
2072 static jit_word_t
2073 _baddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
2074        jit_bool_t carry)
2075 {
2076     jit_word_t          w;
2077     jit_int32_t         t0;
2078     jit_int32_t         t1;
2079     jit_int32_t         t2;
2080     jit_int32_t         t3;
2081     /* t0 = r0 + r1;    overflow = r1 < 0 ? r0 < t0 : t0 < r0 */
2082     t0 = jit_get_reg(jit_class_gpr);
2083     t1 = jit_get_reg(jit_class_gpr);
2084     t2 = jit_get_reg(jit_class_gpr);
2085     t3 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2086     addr(rn(t0), r0, r1);               /* t0 = r0 + r1 */
2087     ltr(rn(t1), r1, _R31_REGNO);        /* t1 = r1 < 0 */
2088     ltr(rn(t2), r0, rn(t0));            /* t2 = r0 < t0 */
2089     ltr(rn(t3), rn(t0), r0);            /* t3 = t0 < r0 */
2090     movr(r0, rn(t0));                   /* r0 += r1 */
2091     CMOVNE(rn(t1), rn(t2), rn(t3));     /* if (t1 == 0) t3 = t2; */
2092     jit_unget_reg(t2);
2093     jit_unget_reg(t1);
2094     jit_unget_reg(t0);
2095     w = _jit->pc.w;
2096     if (carry)
2097         BNE(rn(t3), ((i0 - w) >> 2) - 1);
2098     else
2099         BEQ(rn(t3), ((i0 - w) >> 2) - 1);
2100     jit_unget_reg(t3);
2101     return (w);
2102 }
2103
2104 static jit_word_t
2105 _baddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
2106        jit_bool_t carry)
2107 {
2108     jit_word_t          w;
2109     jit_int32_t         reg;
2110     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2111     movi(rn(reg), i1);
2112     w = baddr(i0, r0, rn(reg), carry);
2113     jit_unget_reg(reg);
2114     return (w);
2115 }
2116
2117 static jit_word_t
2118 _baddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
2119          jit_bool_t carry)
2120 {
2121     jit_word_t          w;
2122     jit_int32_t         t0;
2123     jit_int32_t         t1;
2124     t0 = jit_get_reg(jit_class_gpr);
2125     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2126     addr(rn(t0), r0, r1);
2127     ltr_u(rn(t1), rn(t0), r0);
2128     movr(r0, rn(t0));
2129     jit_unget_reg(t0);
2130     w = _jit->pc.w;
2131     if (carry)
2132         BNE(rn(t1), ((i0 - w) >> 2) - 1);
2133     else
2134         BEQ(rn(t1), ((i0 - w) >> 2) - 1);
2135     jit_unget_reg(t1);
2136     return (w);
2137 }
2138
2139 static jit_word_t
2140 _baddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
2141          jit_bool_t carry)
2142 {
2143     jit_word_t          w;
2144     jit_int32_t         t0;
2145     jit_int32_t         t1;
2146     t0 = jit_get_reg(jit_class_gpr);
2147     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2148     addi(rn(t0), r0, i1);
2149     ltr_u(rn(t1), rn(t0), r0);
2150     movr(r0, rn(t0));
2151     jit_unget_reg(t0);
2152     w = _jit->pc.w;
2153     if (carry)
2154         BNE(rn(t1), ((i0 - w) >> 2) - 1);
2155     else
2156         BEQ(rn(t1), ((i0 - w) >> 2) - 1);
2157     jit_unget_reg(t1);
2158     return (w);
2159 }
2160
2161 static jit_word_t
2162 _bsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
2163        jit_bool_t carry)
2164 {
2165     jit_word_t          w;
2166     jit_int32_t         t0;
2167     jit_int32_t         t1;
2168     jit_int32_t         t2;
2169     jit_int32_t         t3;
2170     /* t0 = r0 - r1;    overflow = 0 < r1 ? r0 < t0 : t0 < r0 */
2171     t0 = jit_get_reg(jit_class_gpr);
2172     t1 = jit_get_reg(jit_class_gpr);
2173     t2 = jit_get_reg(jit_class_gpr);
2174     t3 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2175     subr(rn(t0), r0, r1);               /* r0 = r0 - r1 */
2176     ltr(rn(t1), _R31_REGNO, r1);        /* t1 = 0 < r1 */
2177     ltr(rn(t2), r0, rn(t0));            /* t2 = r0 < t0 */
2178     ltr(rn(t3), rn(t0), r0);            /* t3 = t0 < r0 */
2179     movr(r0, rn(t0));                   /* r0 -= r1 */
2180     CMOVNE(rn(t1), rn(t2), rn(t3));     /* if (t1 == 0) t3 = t2; */
2181     jit_unget_reg(t2);
2182     jit_unget_reg(t1);
2183     jit_unget_reg(t0);
2184     w = _jit->pc.w;
2185     if (carry)
2186         BNE(rn(t3), ((i0 - w) >> 2) - 1);
2187     else
2188         BEQ(rn(t3), ((i0 - w) >> 2) - 1);
2189     jit_unget_reg(t3);
2190     return (w);
2191 }
2192
2193 static jit_word_t
2194 _bsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
2195        jit_bool_t carry)
2196 {
2197     jit_word_t          w;
2198     jit_int32_t         reg;
2199     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2200     movi(rn(reg), i1);
2201     w = bsubr(i0, r0, rn(reg), carry);
2202     jit_unget_reg(reg);
2203     return (w);
2204 }
2205
2206 static jit_word_t
2207 _bsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
2208          jit_bool_t carry)
2209 {
2210     jit_word_t          w;
2211     jit_int32_t         t0;
2212     jit_int32_t         t1;
2213     t0 = jit_get_reg(jit_class_gpr);
2214     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2215     subr(rn(t0), r0, r1);
2216     ltr_u(rn(t1), r0, rn(t0));
2217     movr(r0, rn(t0));
2218     jit_unget_reg(t0);
2219     w = _jit->pc.w;
2220     if (carry)
2221         BNE(rn(t1), ((i0 - w) >> 2) - 1);
2222     else
2223         BEQ(rn(t1), ((i0 - w) >> 2) - 1);
2224     jit_unget_reg(t1);
2225     return (w);
2226 }
2227
2228 static jit_word_t
2229 _bsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
2230          jit_bool_t carry)
2231 {
2232     jit_word_t          w;
2233     jit_int32_t         t0;
2234     jit_int32_t         t1;
2235     t0 = jit_get_reg(jit_class_gpr);
2236     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2237     subi(rn(t0), r0, i1);
2238     ltr_u(rn(t1), r0, rn(t0));
2239     movr(r0, rn(t0));
2240     jit_unget_reg(t0);
2241     w = _jit->pc.w;
2242     if (carry)
2243         BNE(rn(t1), ((i0 - w) >> 2) - 1);
2244     else
2245         BEQ(rn(t1), ((i0 - w) >> 2) - 1);
2246     jit_unget_reg(t1);
2247     return (w);
2248 }
2249
2250 static jit_word_t
2251 _bmxr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
2252       jit_bool_t set)
2253 {
2254     jit_word_t          w;
2255     jit_int32_t         t0;
2256     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2257     andr(rn(t0), r0, r1);
2258     w = _jit->pc.w;
2259     if (set)
2260         BNE(rn(t0), ((i0 - w) >> 2) - 1);
2261     else
2262         BEQ(rn(t0), ((i0 - w) >> 2) - 1);
2263     jit_unget_reg(t0);
2264     return (w);
2265 }
2266
2267 static jit_word_t
2268 _bmxi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
2269       jit_bool_t set)
2270 {
2271     jit_word_t          w;
2272     jit_int32_t         t0;
2273     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2274     andi(rn(t0), r0, i1);
2275     w = _jit->pc.w;
2276     if (set)
2277         BNE(rn(t0), ((i0 - w) >> 2) - 1);
2278     else
2279         BEQ(rn(t0), ((i0 - w) >> 2) - 1);
2280     jit_unget_reg(t0);
2281     return (w);
2282 }
2283
2284 static void
2285 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2286 {
2287     ldr_uc(r0, r1);
2288     extr_c(r0, r0);
2289 }
2290
2291 static void
2292 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2293 {
2294     jit_int32_t         reg;
2295     if (_s16_p(i0)) {
2296         LDBU(r0, _R31_REGNO, _u16(i0));
2297         extr_c(r0, r0);
2298     }
2299     else {
2300         reg = jit_get_reg(jit_class_gpr);
2301         movi(rn(reg), i0);
2302         ldr_c(r0, rn(reg));
2303         jit_unget_reg(reg);
2304     }
2305 }
2306
2307 static void
2308 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2309 {
2310     jit_int32_t         reg;
2311     if (_s16_p(i0))
2312         LDBU(r0, _R31_REGNO, _u16(i0));
2313     else  {
2314         reg = jit_get_reg(jit_class_gpr);
2315         movi(rn(reg), i0);
2316         ldr_uc(r0, rn(reg));
2317         jit_unget_reg(reg);
2318     }
2319 }
2320
2321 static void
2322 _ldr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2323 {
2324     ldr_us(r0, r1);
2325     extr_s(r0, r0);
2326 }
2327
2328 static void
2329 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2330 {
2331     jit_int32_t         reg;
2332     if (_s16_p(i0)) {
2333         LDWU(r0, _R31_REGNO, _u16(i0));
2334         extr_s(r0, r0);
2335     }
2336     else {
2337         reg = jit_get_reg(jit_class_gpr);
2338         movi(rn(reg), i0);
2339         ldr_s(r0, rn(reg));
2340         jit_unget_reg(reg);
2341     }
2342 }
2343
2344 static void
2345 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2346 {
2347     jit_int32_t         reg;
2348     if (_s16_p(i0))
2349         LDWU(r0, _R31_REGNO, _u16(i0));
2350     else {
2351         reg = jit_get_reg(jit_class_gpr);
2352         movi(rn(reg), i0);
2353         ldr_us(r0, rn(reg));
2354         jit_unget_reg(reg);
2355     }
2356 }
2357
2358 static void
2359 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2360 {
2361     jit_int32_t         reg;
2362     if (_s16_p(i0))
2363         LDL(r0, _R31_REGNO, _u16(i0));
2364     else {
2365         reg = jit_get_reg(jit_class_gpr);
2366         movi(rn(reg), i0);
2367         ldr_i(r0, rn(reg));
2368         jit_unget_reg(reg);
2369     }
2370 }
2371
2372 static void
2373 _ldr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2374 {
2375     ldr_i(r0, r1);
2376     extr_ui(r0, r0);
2377 }
2378
2379 static void
2380 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2381 {
2382     jit_int32_t         reg;
2383     if (_s16_p(i0)) {
2384         LDL(r0, _R31_REGNO, _u16(i0));
2385         extr_ui(r0, r0);
2386     }
2387     else {
2388         reg = jit_get_reg(jit_class_gpr);
2389         movi(rn(reg), i0);
2390         ldr_ui(r0, rn(reg));
2391         jit_unget_reg(reg);
2392     }
2393 }
2394
2395 static void
2396 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2397 {
2398     jit_int32_t         reg;
2399     if (_s16_p(i0))
2400         LDQ(r0, _R31_REGNO, _u16(i0));
2401     else {
2402         reg = jit_get_reg(jit_class_gpr);
2403         movi(rn(reg), i0);
2404         ldr_l(r0, rn(reg));
2405         jit_unget_reg(reg);
2406     }
2407 }
2408
2409 static void
2410 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2411 {
2412     jit_int32_t         reg;
2413     reg = jit_get_reg(jit_class_gpr);
2414     addr(rn(reg), r1, r2);
2415     ldr_c(r0, rn(reg));
2416     jit_unget_reg(reg);
2417 }
2418
2419 static void
2420 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2421 {
2422     jit_int32_t         reg;
2423     if (_s16_p(i0)) {
2424         LDBU(r0, r1, _u16(i0));
2425         extr_c(r0, r0);
2426     }
2427     else {
2428         reg = jit_get_reg(jit_class_gpr);
2429         addi(rn(reg), r1, i0);
2430         ldr_c(r0, rn(reg));
2431         jit_unget_reg(reg);
2432     }
2433 }
2434
2435 static void
2436 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2437 {
2438     jit_int32_t         reg;
2439     reg = jit_get_reg(jit_class_gpr);
2440     addr(rn(reg), r1, r2);
2441     ldr_uc(r0, rn(reg));
2442     jit_unget_reg(reg);
2443 }
2444
2445 static void
2446 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2447 {
2448     jit_int32_t         reg;
2449     if (_s16_p(i0))
2450         LDBU(r0, r1, _u16(i0));
2451     else {
2452         reg = jit_get_reg(jit_class_gpr);
2453         addi(rn(reg), r1, i0);
2454         ldr_uc(r0, rn(reg));
2455         jit_unget_reg(reg);
2456     }
2457 }
2458
2459 static void
2460 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2461 {
2462     jit_int32_t         reg;
2463     reg = jit_get_reg(jit_class_gpr);
2464     addr(rn(reg), r1, r2);
2465     ldr_s(r0, rn(reg));
2466     jit_unget_reg(reg);
2467 }
2468
2469 static void
2470 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2471 {
2472     jit_int32_t         reg;
2473     if (_s16_p(i0)) {
2474         LDWU(r0, r1, _u16(i0));
2475         extr_s(r0, r0);
2476     }
2477     else {
2478         reg = jit_get_reg(jit_class_gpr);
2479         addi(rn(reg), r1, i0);
2480         ldr_s(r0, rn(reg));
2481         jit_unget_reg(reg);
2482     }
2483 }
2484
2485 static void
2486 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2487 {
2488     jit_int32_t         reg;
2489     reg = jit_get_reg(jit_class_gpr);
2490     addr(rn(reg), r1, r2);
2491     ldr_us(r0, rn(reg));
2492     jit_unget_reg(reg);
2493 }
2494
2495 static void
2496 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2497 {
2498     jit_int32_t         reg;
2499     if (_s16_p(i0))
2500         LDWU(r0, r1, _u16(i0));
2501     else {
2502         reg = jit_get_reg(jit_class_gpr);
2503         addi(rn(reg), r1, i0);
2504         ldr_us(r0, rn(reg));
2505         jit_unget_reg(reg);
2506     }
2507 }
2508
2509 static void
2510 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2511 {
2512     jit_int32_t         reg;
2513     reg = jit_get_reg(jit_class_gpr);
2514     addr(rn(reg), r1, r2);
2515     ldr_i(r0, rn(reg));
2516     jit_unget_reg(reg);
2517 }
2518
2519 static void
2520 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2521 {
2522     jit_int32_t         reg;
2523     if (_s16_p(i0))
2524         LDL(r0, r1, _u16(i0));
2525     else {
2526         reg = jit_get_reg(jit_class_gpr);
2527         addi(rn(reg), r1, i0);
2528         ldr_i(r0, rn(reg));
2529         jit_unget_reg(reg);
2530     }
2531 }
2532
2533 static void
2534 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2535 {
2536     jit_int32_t         reg;
2537     reg = jit_get_reg(jit_class_gpr);
2538     addr(rn(reg), r1, r2);
2539     ldr_ui(r0, rn(reg));
2540     jit_unget_reg(reg);
2541 }
2542
2543 static void
2544 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2545 {
2546     jit_int32_t         reg;
2547     if (_s16_p(i0)) {
2548         LDL(r0, r1, _u16(i0));
2549         extr_ui(r0, r0);
2550     }
2551     else {
2552         reg = jit_get_reg(jit_class_gpr);
2553         addi(rn(reg), r1, i0);
2554         ldr_ui(r0, rn(reg));
2555         jit_unget_reg(reg);
2556     }
2557 }
2558
2559 static void
2560 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2561 {
2562     jit_int32_t         reg;
2563     reg = jit_get_reg(jit_class_gpr);
2564     addr(rn(reg), r1, r2);
2565     ldr_l(r0, rn(reg));
2566     jit_unget_reg(reg);
2567 }
2568
2569 static void
2570 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2571 {
2572     jit_int32_t         reg;
2573     if (_s16_p(i0))
2574         LDQ(r0, r1, _u16(i0));
2575     else {
2576         reg = jit_get_reg(jit_class_gpr);
2577         addi(rn(reg), r1, i0);
2578         ldr_l(r0, rn(reg));
2579         jit_unget_reg(reg);
2580     }
2581 }
2582
2583 static void
2584 _unldr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2585 {
2586     jit_int32_t         t0, r2, t1, r3;
2587     assert(i0 >= 1 && i0 <= sizeof(jit_word_t));
2588     if (i0 == 1)
2589         ldr_c(r0, r1);
2590     else {
2591         t0 = jit_get_reg(jit_class_gpr);        r2 = rn(t0);
2592         t1 = jit_get_reg(jit_class_gpr);
2593         if (r0 == r1) {
2594             r3 = rn(t1);
2595             movr(r3, r1);
2596         }
2597         else
2598             r3 = r1;
2599         LDQ_U(r0, r3, 0);
2600         LDQ_U(r2, r3, 7);
2601         if (r0 == r1) {
2602 #if __BYTE_ORDER == __LITTLE_ENDIAN
2603             LDA(r3, r3, 0);
2604 #else
2605             LDA(r3, r3, 7);
2606 #endif
2607         }
2608         else {
2609             r3 = rn(t1);
2610 #if __BYTE_ORDER == __LITTLE_ENDIAN
2611             LDA(r3, r1, 0);
2612 #else
2613             LDA(r3, r1, 7);
2614 #endif
2615         }
2616         EXTQL(r0, r3, r0);
2617         EXTQH(r2, r3, r2);
2618         OR(r2, r0, r0);
2619         jit_unget_reg(t1);
2620         jit_unget_reg(t0);
2621         switch (i0) {
2622             case 2:
2623                 extr_s(r0, r0);
2624                 break;
2625             case 3:
2626                 lshi(r0, r0, __WORDSIZE - 24);
2627                 rshi(r0, r0, __WORDSIZE - 24);
2628                 break;
2629             case 4:
2630                 extr_i(r0, r0);
2631                 break;
2632             case 5:
2633                 lshi(r0, r0, __WORDSIZE - 40);
2634                 rshi(r0, r0, __WORDSIZE - 40);
2635                 break;
2636             case 6:
2637                 lshi(r0, r0, __WORDSIZE - 48);
2638                 rshi(r0, r0, __WORDSIZE - 48);
2639                 break;
2640             case 7:
2641                 lshi(r0, r0, __WORDSIZE - 56);
2642                 rshi(r0, r0, __WORDSIZE - 56);
2643                 break;
2644             default:
2645                 break;
2646         }
2647     }
2648 }
2649
2650 /* Slightly shorter than fallback, and branchless */
2651 static void
2652 _unldi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
2653 {
2654     jit_int32_t         reg;
2655     reg = jit_get_reg(jit_class_gpr);
2656     movi(rn(reg), i0);
2657     unldr(r0, rn(reg), i1);
2658     jit_unget_reg(reg);
2659 }
2660
2661 static void
2662 _unldr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2663 {
2664     jit_int32_t         t0, r2, t1, r3;
2665     assert(i0 >= 1 && i0 <= sizeof(jit_word_t));
2666     if (i0 == 1)
2667         ldr_uc(r0, r1);
2668     else {
2669         t0 = jit_get_reg(jit_class_gpr);        r2 = rn(t0);
2670         t1 = jit_get_reg(jit_class_gpr);
2671         if (r0 == r1) {
2672             r3 = rn(t1);
2673             movr(r3, r1);
2674         }
2675         else
2676             r3 = r1;
2677         LDQ_U(r0, r3, 0);
2678         LDQ_U(r2, r3, 7);
2679         if (r0 == r1) {
2680 #if __BYTE_ORDER == __LITTLE_ENDIAN
2681             LDA(r3, r3, 0);
2682 #else
2683             LDA(r3, r3, 7);
2684 #endif
2685         }
2686         else {
2687             r3 = rn(t1);
2688 #if __BYTE_ORDER == __LITTLE_ENDIAN
2689             LDA(r3, r1, 0);
2690 #else
2691             LDA(r3, r1, 7);
2692 #endif
2693         }
2694         EXTQL(r0, r3, r0);
2695         EXTQH(r2, r3, r2);
2696         OR(r2, r0, r0);
2697         jit_unget_reg(t1);
2698         jit_unget_reg(t0);
2699         switch (i0) {
2700             case 2:
2701                 extr_us(r0, r0);
2702                 break;
2703             case 3:
2704                 lshi(r0, r0, __WORDSIZE - 24);
2705                 rshi_u(r0, r0, __WORDSIZE - 24);
2706                 break;
2707             case 4:
2708                 extr_ui(r0, r0);
2709                 break;
2710             case 5:
2711                 lshi(r0, r0, __WORDSIZE - 40);
2712                 rshi_u(r0, r0, __WORDSIZE - 40);
2713                 break;
2714             case 6:
2715                 lshi(r0, r0, __WORDSIZE - 48);
2716                 rshi_u(r0, r0, __WORDSIZE - 48);
2717                 break;
2718             case 7:
2719                 lshi(r0, r0, __WORDSIZE - 56);
2720                 rshi_u(r0, r0, __WORDSIZE - 56);
2721                 break;
2722             default:
2723                 break;
2724         }
2725     }
2726 }
2727
2728 static void
2729 _unldi_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
2730 {
2731     jit_int32_t         reg;
2732     reg = jit_get_reg(jit_class_gpr);
2733     movi(rn(reg), i0);
2734     unldr_u(r0, rn(reg), i1);
2735     jit_unget_reg(reg);
2736 }
2737
2738 static void
2739 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2740 {
2741     jit_int32_t         reg;
2742     if (_s16_p(i0))
2743         STB(r0, _R31_REGNO, _u16(i0));
2744     else {
2745         reg = jit_get_reg(jit_class_gpr);
2746         movi(rn(reg), i0);
2747         str_c(rn(reg), r0);
2748         jit_unget_reg(reg);
2749     }
2750 }
2751
2752 static void
2753 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2754 {
2755     jit_int32_t         reg;
2756     if (_s16_p(i0))
2757         STW(r0, _R31_REGNO, _u16(i0));
2758     else {
2759         reg = jit_get_reg(jit_class_gpr);
2760         movi(rn(reg), i0);
2761         str_s(rn(reg), r0);
2762         jit_unget_reg(reg);
2763     }
2764 }
2765
2766 static void
2767 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2768 {
2769     jit_int32_t         reg;
2770     if (_s16_p(i0))
2771         STL(r0, _R31_REGNO, _u16(i0));
2772     else {
2773         reg = jit_get_reg(jit_class_gpr);
2774         movi(rn(reg), i0);
2775         str_i(rn(reg), r0);
2776         jit_unget_reg(reg);
2777     }
2778 }
2779
2780 static void
2781 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2782 {
2783     jit_int32_t         reg;
2784     if (_s16_p(i0))
2785         STQ(r0, _R31_REGNO, _u16(i0));
2786     else {
2787         reg = jit_get_reg(jit_class_gpr);
2788         movi(rn(reg), i0);
2789         str_l(rn(reg), r0);
2790         jit_unget_reg(reg);
2791     }
2792 }
2793
2794 static void
2795 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2796 {
2797     jit_int32_t         reg;
2798     reg = jit_get_reg(jit_class_gpr);
2799     addr(rn(reg), r0, r1);
2800     str_c(rn(reg), r2);
2801     jit_unget_reg(reg);
2802 }
2803
2804 static void
2805 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2806 {
2807     jit_int32_t         reg;
2808     if (_s16_p(i0))
2809         STB(r1, r0, _u16(i0));
2810     else {
2811         reg = jit_get_reg(jit_class_gpr);
2812         addi(rn(reg), r0, i0);
2813         str_c(rn(reg), r1);
2814         jit_unget_reg(reg);
2815     }
2816 }
2817
2818 static void
2819 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2820 {
2821     jit_int32_t         reg;
2822     reg = jit_get_reg(jit_class_gpr);
2823     addr(rn(reg), r0, r1);
2824     str_s(rn(reg), r2);
2825     jit_unget_reg(reg);
2826 }
2827
2828 static void
2829 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2830 {
2831     jit_int32_t         reg;
2832     if (_s16_p(i0))
2833         STW(r1, r0, _u16(i0));
2834     else {
2835         reg = jit_get_reg(jit_class_gpr);
2836         addi(rn(reg), r0, i0);
2837         str_s(rn(reg), r1);
2838         jit_unget_reg(reg);
2839     }
2840 }
2841
2842 static void
2843 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2844 {
2845     jit_int32_t         reg;
2846     reg = jit_get_reg(jit_class_gpr);
2847     addr(rn(reg), r0, r1);
2848     str_i(rn(reg), r2);
2849     jit_unget_reg(reg);
2850 }
2851
2852 static void
2853 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2854 {
2855     jit_int32_t         reg;
2856     if (_s16_p(i0))
2857         STL(r1, r0, _u16(i0));
2858     else {
2859         reg = jit_get_reg(jit_class_gpr);
2860         addi(rn(reg), r0, i0);
2861         str_i(rn(reg), r1);
2862         jit_unget_reg(reg);
2863     }
2864 }
2865
2866 static void
2867 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2868 {
2869     jit_int32_t         reg;
2870     reg = jit_get_reg(jit_class_gpr);
2871     addr(rn(reg), r0, r1);
2872     str_l(rn(reg), r2);
2873     jit_unget_reg(reg);
2874 }
2875
2876 static void
2877 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2878 {
2879     jit_int32_t         reg;
2880     if (_s16_p(i0))
2881         STQ(r1, r0, _u16(i0));
2882     else {
2883         reg = jit_get_reg(jit_class_gpr);
2884         addi(rn(reg), r0, i0);
2885         str_l(rn(reg), r1);
2886         jit_unget_reg(reg);
2887     }
2888 }
2889
2890 static void
2891 _unstr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2892 {
2893     jit_word_t          t0, t1, t2, t3, t4, r2, r3, r4, r5, r6;
2894     assert(i0 > 0 && i0 <= sizeof(jit_word_t));
2895     if (i0 == 1)
2896         str_c(r0, r1);
2897     else if (i0 == 4 || i0 == 8) {
2898         t0 = jit_get_reg(jit_class_gpr);        r2 = rn(t0);
2899         t1 = jit_get_reg(jit_class_gpr);        r3 = rn(t1);
2900         t2 = jit_get_reg(jit_class_gpr);        r4 = rn(t2);
2901         t3 = jit_get_reg(jit_class_gpr);        r5 = rn(t3);
2902         t4 = jit_get_reg(jit_class_gpr);        r6 = rn(t4);
2903 #if __BYTE_ORDER == __LITTLE_ENDIAN
2904         LDA(r4, r0, 0);                 /* r4<2:0> = (X mod 8) = 5 */
2905 #else
2906         LDA(r4, r0, i0 - 1);            /* r4<2:0> = ((X+7) mod 8) = 5 */
2907 #endif
2908         LDQ_U(r2, r0, i0 - 1);          /* Ignores va<2:0>, r2 = yyyH GFED
2909                                                             or (if i0 == 4)
2910                                                             r2 = yyyy yyyD */
2911         LDQ_U(r3, r0, 0);               /* Ignores va<2:0>, r3 = CBAx xxxx */
2912         if (i0 == 8) {
2913             INSQH(r1, r4, r5);          /* r5 = 000H GFED */
2914             INSQL(r1, r4, r6);          /* r6 = CBA0 0000 */
2915             MSKQH(r2, r4, r2);          /* r2 = yyy0 0000 */
2916             MSKQL(r3, r4, r3);          /* r3 = 000x xxxx */
2917         }
2918         else {
2919             INSLH(r1, r4, r5);          /* r5 = 0000 000D */
2920             INSLL(r1, r4, r6);          /* r6 = CBA0 0000 */
2921             MSKLH(r2, r4, r2);          /* r2 = yyy0 0000 */
2922             MSKLL(r3, r4, r3);          /* r3 = 000x xxxx */
2923         }
2924         OR(r2, r5, r2);                 /* r2 = yyyH GFED (or yyyy yyyD) */
2925         OR(r3, r6, r3);                 /* r1 = CBAx xxxx */
2926         STQ_U(r2, r0, i0 - 1);          /* Must store high then low for */
2927         STQ_U(r3, r0, 0);               /* degenerate case of aligned QW */
2928         jit_unget_reg(t4);
2929         jit_unget_reg(t3);
2930         jit_unget_reg(t2);
2931         jit_unget_reg(t1);
2932         jit_unget_reg(t0);
2933     }
2934     else
2935         fallback_unstr(r0, r1, i0);
2936 }
2937
2938 static void
2939 _unsti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2940 {
2941     jit_int32_t         reg;
2942     if (i1 == 4 || i1 == 8) {
2943         reg = jit_get_reg(jit_class_gpr);
2944         movi(rn(reg), i0);
2945         unstr(rn(reg), r0, i1);
2946         jit_unget_reg(reg);
2947     }
2948     else
2949         fallback_unsti(i0, r0, i1);
2950 }
2951
2952 static void
2953 _extr(jit_state_t *_jit,
2954       jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
2955 {
2956     assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
2957     if (i1 == __WORDSIZE)
2958         movr(r0, r1);
2959     else {
2960 #  if __BYTE_ORDER == __BIG_ENDIAN
2961         i0 = __WORDSIZE - (i0 + i1);
2962 #  endif
2963         if (__WORDSIZE - (i0 + i1)) {
2964             lshi(r0, r1, __WORDSIZE - (i0 + i1));
2965             rshi(r0, r0, __WORDSIZE - i1);
2966         }
2967         else
2968             rshi(r0, r1, __WORDSIZE - i1);
2969     }
2970 }
2971
2972 static void
2973 _extr_u(jit_state_t *_jit,
2974         jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
2975 {
2976     assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
2977     if (i1 == __WORDSIZE)
2978         movr(r0, r1);
2979     else {
2980 #  if __BYTE_ORDER == __BIG_ENDIAN
2981         i0 = __WORDSIZE - (i0 + i1);
2982 #  endif
2983         if ((i0 & 7) == 0) {
2984             if (i1 == 8) {
2985                 EXTBLi(r1, i0 >> 3, r0);
2986                 goto done;
2987             }
2988             if (i1 == 16) {
2989                 EXTWLi(r1, i0 >> 3, r0);
2990                 goto done;
2991             }
2992             if (i1 == 32) {
2993                 EXTLLi(r1, i0 >> 3, r0);
2994                 goto done;
2995             }
2996         }
2997         if (i0)
2998             rshi_u(r0, r1, i0);
2999         andi(r0, r0, (1L << i1) - 1);
3000     }
3001 done:;
3002 }
3003
3004 static void
3005 _depr(jit_state_t *_jit,
3006       jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
3007 {
3008     jit_int32_t         t0;
3009     jit_word_t          mask;
3010     assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
3011     if (i1 == __WORDSIZE)
3012         movr(r0, r1);
3013     else {
3014 #  if __BYTE_ORDER == __BIG_ENDIAN
3015         i0 = __WORDSIZE - (i0 + i1);
3016 #  endif
3017         t0 = jit_get_reg(jit_class_gpr);
3018         if ((i0 & 7) == 0) {
3019             if (i1 == 8) {
3020                 MSKBLi(r0, i0 >> 3, rn(t0));
3021                 INSBLi(r1, i0 >> 3, r0);
3022                 goto done;
3023             }
3024             if (i1 == 16) {
3025                 MSKWLi(r0, i0 >> 3, rn(t0));
3026                 INSWLi(r1, i0 >> 3, r0);
3027                 goto done;
3028             }
3029             if (i1 == 32) {
3030                 MSKLLi(r0, i0 >> 3, rn(t0));
3031                 INSLLi(r1, i0 >> 3, r0);
3032                 goto done;
3033             }
3034         }
3035         mask = (1L << i1) - 1;
3036         andi(rn(t0), r1, mask);
3037         if (i0) {
3038             lshi(rn(t0), rn(t0), i0);
3039             mask <<= i0;
3040         }
3041         andi(r0, r0, ~mask);
3042     done:
3043         orr(r0, r0, rn(t0));
3044         jit_unget_reg(t0);
3045     }
3046 }
3047
3048 static void
3049 _extr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3050 {
3051     lshi(r0, r1, 32);
3052     rshi(r0, r0, 32);
3053 }
3054
3055 static void
3056 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3057 {
3058     jit_int32_t         t0;
3059     t0 = jit_get_reg(jit_class_gpr);
3060     EXTBLi(r1, 0, rn(t0));
3061     EXTBLi(r1, 1, r0);
3062     SLLi(rn(t0), 8, rn(t0));
3063     OR(r0, rn(t0), r0);
3064     jit_unget_reg(t0);
3065 }
3066
3067 static void
3068 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3069 {
3070     jit_int32_t         t0;
3071     jit_int32_t         t1;
3072     jit_int32_t         t2;
3073     jit_int32_t         t3;
3074     t0 = jit_get_reg(jit_class_gpr);
3075     t1 = jit_get_reg(jit_class_gpr);
3076     t2 = jit_get_reg(jit_class_gpr);
3077     t3 = jit_get_reg(jit_class_gpr);
3078     EXTBLi(r1, 3, rn(t0));
3079     INSBLi(r1, 3, rn(t1));
3080     SLLi(r1, 8, rn(t2));
3081     ZAPNOTi(rn(t2), 4, rn(t2));
3082     SRLi(r1, 8, rn(t3));
3083     OR(rn(t0), rn(t1), r0);
3084     OR(rn(t2), r0, r0);
3085     ZAPNOTi(rn(t3), 2, rn(t3));
3086     OR(rn(t3), r0, r0);
3087     jit_unget_reg(t3);
3088     jit_unget_reg(t2);
3089     jit_unget_reg(t1);
3090     jit_unget_reg(t0);
3091 }
3092
3093 static void
3094 _bswapr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3095 {
3096     jit_int32_t         t0;
3097     jit_int32_t         t1;
3098     jit_int32_t         t2;
3099     assert(_jitc->function != NULL);
3100     t0 = jit_get_reg(jit_class_fpr);
3101     t1 = jit_get_reg(jit_class_gpr);
3102     t2 = jit_get_reg(jit_class_gpr);
3103     stxi(-8, _FP_REGNO, r1);                    /* r1 = ABCD EFGH */
3104     LDG(rn(t0), _FP_REGNO, _u16(-8));           /* t0 = GHEF CDAB */
3105     STT(rn(t0), _FP_REGNO, _u16(-8));
3106     ldxi(rn(t1), _FP_REGNO, -8);                /* t1 = GHEF CDAB */
3107     lshi(rn(t2), rn(t1), 8);                    /* t2 = HEFC DAB. */
3108     rshi_u(rn(t1), rn(t1), 8);                  /* t1 = .GHE FCDA */
3109     ZAPi(rn(t2), 0x55, rn(t2));                 /* t2 = H.F. D.B. */
3110     ZAPi(rn(t1), 0xaa, rn(t1));                 /* t1 = .G.E .C.A */
3111     orr(r0, rn(t1), rn(t2));                    /* r0 = HGFE DCBA */
3112     jit_unget_reg(t2);
3113     jit_unget_reg(t1);
3114     jit_unget_reg(t0);
3115 }
3116
3117 static jit_word_t
3118 _jmpi(jit_state_t *_jit, jit_word_t i0)
3119 {
3120     jit_word_t          w;
3121     jit_word_t          d;
3122     w = _jit->pc.w;
3123     d = ((i0 - w) >> 2) - 1;
3124     if (_s21_p(d))
3125         BR(_R31_REGNO, d);
3126     else
3127         w = jmpi_p(i0);
3128     return (w);
3129 }
3130
3131 static jit_word_t
3132 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3133 {
3134     jit_word_t          w;
3135     jit_int32_t         reg;
3136     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3137     w = movi_p(rn(reg), i0);
3138     jmpr(rn(reg));
3139     jit_unget_reg(reg);
3140     return (w);
3141 }
3142
3143 static void
3144 _callr(jit_state_t *_jit, jit_int32_t r0)
3145 {
3146     if (r0 != _PV_REGNO)
3147         MOV(r0, _PV_REGNO);
3148     JSR(_RA_REGNO, _PV_REGNO, 0);
3149 }
3150
3151 static void
3152 _calli(jit_state_t *_jit, jit_word_t i0)
3153 {
3154     /* FIXME use a small buffer to load constants - using gp */
3155 #if 0
3156     jit_word_t          w;
3157     jit_word_t          d;
3158     w = _jit->pc.w;
3159     d = ((i0 - w) >> 2) - 1;
3160     if (_s21_p(d))
3161         BSR(_RA_REGNO, d);
3162     else
3163         (void)calli_p(i0);
3164 #else
3165     movi(_PV_REGNO, i0);
3166     callr(_PV_REGNO);
3167 #endif
3168 }
3169
3170 static jit_word_t
3171 _calli_p(jit_state_t *_jit, jit_word_t i0)
3172 {
3173     jit_word_t          w;
3174     w = movi_p(_PV_REGNO, i0);
3175     callr(_PV_REGNO);
3176     return (w);
3177 }
3178
3179 static void
3180 _prolog(jit_state_t *_jit, jit_node_t *node)
3181 {
3182     jit_int32_t         reg;
3183     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3184         jit_int32_t     frame = -_jitc->function->frame;
3185         assert(_jitc->function->self.aoff >= frame);
3186         if (_jitc->function->assume_frame)
3187             return;
3188         _jitc->function->self.aoff = frame;
3189     }
3190     if (_jitc->function->allocar)
3191         _jitc->function->self.aoff &= -8;
3192     _jitc->function->stack = ((_jitc->function->self.alen -
3193                                _jitc->function->self.aoff) + 7) & -8;
3194     /* ldgp gp, 0(pv) */
3195     LDAH(_PV_REGNO, _GP_REGNO, 0);
3196     LDA(_GP_REGNO, _GP_REGNO, 0);
3197     /* callee save registers */
3198     subi(_SP_REGNO, _SP_REGNO, stack_framesize);
3199     stxi(0, _SP_REGNO, _RA_REGNO);
3200     stxi(8, _SP_REGNO, _FP_REGNO);
3201 #  define SPILL(N, O)                                                   \
3202     if (jit_regset_tstbit(&_jitc->function->regset, N))                 \
3203         stxi(O, _SP_REGNO, N##_REGNO)
3204 #  define SPILLD(N, O)                                                  \
3205     if (jit_regset_tstbit(&_jitc->function->regset, N))                 \
3206         stxi_d(O, _SP_REGNO, N##_REGNO)
3207     SPILL(_S0, 16);
3208     SPILL(_S1, 24);
3209     SPILL(_S2, 32);
3210     SPILL(_S3, 40);
3211     SPILL(_S4, 48);
3212     SPILL(_S5, 56);
3213     SPILLD(_F2, 64);
3214     SPILLD(_F3, 72);
3215     SPILLD(_F4, 80);
3216     SPILLD(_F5, 88);
3217     SPILLD(_F6, 96);
3218     SPILLD(_F7, 104);
3219     SPILLD(_F8, 112);
3220     SPILLD(_F9, 120);
3221 #  undef SPILLD
3222 #  undef SPILL
3223     movr(_FP_REGNO, _SP_REGNO);
3224     /* alloca */
3225     if (_jitc->function->stack)
3226         subi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
3227     if (_jitc->function->allocar) {
3228         reg = jit_get_reg(jit_class_gpr);
3229         movi(rn(reg), _jitc->function->self.aoff);
3230         stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(reg));
3231         jit_unget_reg(reg);
3232     }
3233
3234     if (_jitc->function->self.call & jit_call_varargs) {
3235         for (reg = _jitc->function->self.argi; jit_arg_reg_p(reg); ++reg)
3236             stxi(stack_framesize - 48 + reg * 8, _FP_REGNO, rn(_A0 - reg));
3237         for (reg = _jitc->function->self.argi; jit_arg_reg_p(reg); ++reg)
3238             stxi_d(stack_framesize - 96 + reg * 8, _FP_REGNO, rn(_F16 - reg));
3239     }
3240 }
3241
3242 static void
3243 _epilog(jit_state_t *_jit, jit_node_t *node)
3244 {
3245     if (_jitc->function->assume_frame)
3246         return;
3247     movr(_SP_REGNO, _FP_REGNO);
3248     ldxi(_RA_REGNO, _SP_REGNO, 0);
3249     ldxi(_FP_REGNO, _SP_REGNO, 8);
3250 #  define LOAD(N, O)                                                    \
3251     if (jit_regset_tstbit(&_jitc->function->regset, N))                 \
3252         ldxi(N##_REGNO, _SP_REGNO,  O)
3253 #  define LOADD(N, O)                                                   \
3254     if (jit_regset_tstbit(&_jitc->function->regset, N))                 \
3255         ldxi_d(N##_REGNO, _SP_REGNO,  O)
3256     LOAD(_S0, 16);
3257     LOAD(_S1, 24);
3258     LOAD(_S2, 32);
3259     LOAD(_S3, 40);
3260     LOAD(_S4, 48);
3261     LOAD(_S5, 56);
3262     LOADD(_F2, 64);
3263     LOADD(_F3, 72);
3264     LOADD(_F4, 80);
3265     LOADD(_F5, 88);
3266     LOADD(_F6, 96);
3267     LOADD(_F7, 104);
3268     LOADD(_F8, 112);
3269     LOADD(_F9, 120);
3270 #  undef LOADD
3271 #  undef LOAD
3272     addi(_SP_REGNO, _SP_REGNO, stack_framesize);
3273     RET(_R31_REGNO, _RA_REGNO, 1);      /* 1 means procedure return
3274                                          * 0 means no procedure return
3275                                          * other values are reserved */
3276 }
3277
3278 static void
3279 _vastart(jit_state_t *_jit, jit_int32_t r0)
3280 {
3281     jit_int32_t         reg;
3282
3283     /* Return jit_va_list_t in the register argument */
3284     addi(r0, _FP_REGNO, _jitc->function->vaoff);
3285
3286     reg = jit_get_reg(jit_class_gpr);
3287
3288     /* The base field is constant. */
3289     addi(rn(reg), _FP_REGNO, stack_framesize - 48);
3290     stxi(offsetof(jit_va_list_t, base), r0, rn(reg));
3291
3292     /* Initialize the offset field */
3293     if (_jitc->function->vagp < 6)
3294         movi(rn(reg), _jitc->function->vagp * 8);
3295     else
3296         movi(rn(reg), _jitc->function->self.size - (stack_framesize - 48));
3297     stxi(offsetof(jit_va_list_t, offset), r0, rn(reg));
3298
3299     jit_unget_reg(reg);
3300 }
3301
3302 static void
3303 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3304 {
3305     jit_int32_t         rg0, rg1;
3306
3307     assert(_jitc->function->self.call & jit_call_varargs);
3308
3309     rg0 = jit_get_reg(jit_class_gpr);
3310     rg1 = jit_get_reg(jit_class_gpr);
3311
3312     /* Load the base in first temporary. */
3313     ldxi(rn(rg0), r1, offsetof(jit_va_list_t, base));
3314
3315     /* Load the offset in the second temporary. */
3316     ldxi(rn(rg1), r1, offsetof(jit_va_list_t, offset));
3317
3318     /* Load the argument */
3319     ldxr(r0, rn(rg0), rn(rg1));
3320
3321     /* No longer needed. */
3322     jit_unget_reg(rg0);
3323
3324     /* Update offset. */
3325     addi(rn(rg1), rn(rg1), 8);
3326     stxi(offsetof(jit_va_list_t, offset), r1, rn(rg1));
3327     jit_unget_reg(rg1);
3328 }
3329
3330 static void
3331 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3332 {
3333     union {
3334         jit_int32_t     *i;
3335         jit_word_t       w;
3336     } u;
3337     jit_word_t           d;
3338     jit_int16_t         s0, s1, s2, s3;
3339     u.w = instr;
3340     switch (_u6(u.i[0] >> 26)) {
3341         /*   BLT             BLE             BEQ             BGE */
3342         case 0x3a:      case 0x3b:      case 0x39:      case 0x3e:
3343         /*   BGT             BNE             BLBC            BLBS */
3344         case 0x3f:      case 0x3d:      case 0x38:      case 0x3c:
3345         /*   BR              BSR */
3346         case 0x30:      case 0x34:
3347         /*   FBLT            FBLE            FBEQ            FBGE */
3348         case 0x32:      case 0x33:      case 0x31:      case 0x36:
3349         /*   FBGT            FBNE */
3350         case 0x37:      case 0x35:
3351             d = ((label - instr) >> 2) - 1;
3352             assert(_s21_p(d));
3353             u.i[0] &= ~0x1fffff;
3354             u.i[0] |= _u21(d);
3355             break;
3356         /*   LDA */
3357         case 0x08:              /* movi_p */
3358             s0 = label;
3359             s1 = label >> 16;
3360             s2 = label >> 32;
3361             s3 = label >> 48;
3362             if (s0 < 0)
3363                 ++s1;
3364             if (s2 < 0)
3365                 ++s3;
3366             u.i[0] &= ~0xffff;
3367             u.i[0] |= _u16(s0);
3368             /*                          LDA */
3369             assert(_u6(u.i[1] >> 26) == 0x08);
3370             u.i[1] &= ~0xffff;
3371             u.i[1] |= _u16(s2);
3372             /*                          LDAH */
3373             assert(_u6(u.i[2] >> 26) == 0x09);
3374             u.i[2] &= ~0xffff;
3375             u.i[2] |= _u16(s1);
3376             /*                          LDAH */
3377             assert(_u6(u.i[3] >> 26) == 0x09);
3378             u.i[3] &= ~0xffff;
3379             u.i[3] |= _u16(s3);
3380             /*                          SLL */
3381             assert(_u6(u.i[4] >> 26) == 0x12 && _u7(u.i[4] >> 5) == 0x39);
3382             /*                          SRL */
3383             assert(_u6(u.i[5] >> 26) == 0x12 && _u7(u.i[5] >> 5) == 0x34);
3384             /*                          SLL */
3385             assert(_u6(u.i[6] >> 26) == 0x12 && _u7(u.i[6] >> 5) == 0x39);
3386             /*                          BIS */
3387             assert(_u6(u.i[7] >> 26) == 0x11 && _u7(u.i[7] >> 5) == 0x20);
3388             break;
3389         default:
3390             abort();
3391     }
3392 }
3393 #endif