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