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