deps/lightning/lib/jit_alpha-cpu.c

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