deps/lightning/lib/jit_alpha-cpu.c

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