deps/lightning/lib/jit_s390-cpu.c

   1 /*
   2  * Copyright (C) 2013-2019  Free Software Foundation, Inc.
   3  *
   4  * This file is part of GNU lightning.
   5  *
   6  * GNU lightning is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 3, or (at your option)
   9  * any later version.
  10  *
  11  * GNU lightning is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  14  * License for more details.
  15  *
  16  * Authors:
  17  *      Paulo Cesar Pereira de Andrade
  18  */
  19
  20 #if PROTO
  21 #  if __WORDSIZE == 32
  22 #    define ldr(r0,r1)                  ldr_i(r0,r1)
  23 #    define ldxr(r0,r1,r2)              ldxr_i(r0,r1,r2)
  24 #    define ldxi(r0,r1,i0)              ldxi_i(r0,r1,i0)
  25 #    define stxi(i0,r0,r1)              stxi_i(i0,r0,r1)
  26 #  else
  27 #    define ldr(r0,r1)                  ldr_l(r0,r1)
  28 #    define ldxr(r0,r1,r2)              ldxr_l(r0,r1,r2)
  29 #    define ldxi(r0,r1,i0)              ldxi_l(r0,r1,i0)
  30 #    define stxi(i0,r0,r1)              stxi_l(i0,r0,r1)
  31 #  endif
  32 #  define is(i)                         *_jit->pc.us++ = i
  33 #  if __WORDSIZE == 32
  34 #    define stack_framesize             96
  35 #  else
  36 #    define stack_framesize             160
  37 #  endif
  38 #  define _R0_REGNO                     0
  39 #  define _R1_REGNO                     1
  40 #  define _R7_REGNO                     7
  41 #  define _R13_REGNO                    13
  42 #  define _FP_REGNO                     _R13_REGNO
  43 #  define _R14_REGNO                    14
  44 #  define _R15_REGNO                    15
  45 #  define u12_p(i0)                     ((i0) >= 0 && (i0) <= 4095)
  46 #  define s16_p(i0)                     ((i0) >= -32768 && (i0) <= 32767)
  47 #  define x16(i0)                       ((i0) & 0xffff)
  48 #  define s20_p(i0)                     ((i0) >= -524288 && (i0) <= 524287)
  49 #  define x20(i0)                       ((i0) & 0xfffff)
  50 #  if __WORDSIZE == 32
  51 #    define s32_p(i0)                   1
  52 #  else
  53 #    define s32_p(i0)                                                   \
  54     ((i0) >= -2147483648L && (i0) < 2147483647L)
  55 #  endif
  56
  57 /*
  58         Condition Code          Instruction     (Mask) Bit Mask Value
  59         0                       8               8
  60         1                       9               4
  61         2                       10              2
  62         3                       11              1
  63
  64 AGR:
  65         0       Zero
  66         1       < zero
  67         2       > zero
  68         3       Overflow
  69 --
  70 1       ->      overflow                CC_O
  71 14      ->      no overflow             CC_NO
  72
  73 ALGR:
  74         0       Zero, no carry
  75         1       Not zero, no carry
  76         2       Zero, carry
  77         3       Not zero, carry
  78 --
  79 2|1     ->      carry                   CC_NLE
  80 8|4     ->      no carry                CC_LE
  81
  82 SGR:
  83         0       Zero
  84         1       < zero
  85         2       > zero
  86         3       Overflow
  87 --
  88 1       ->      overflow                CC_O
  89 14      ->      no overflow             CC_NO
  90
  91 SLGR:
  92         0       --
  93         1       Not zero, borrow
  94         2       Zero, no borrow
  95         3       Not zero, no borrow
  96 --
  97 4       ->      borrow                  CC_L
  98 11      ->      no borrow               CC_NL
  99   */
 100
 101 #  define CC_NV                         0x0
 102 #  define CC_O                          0x1
 103 #  define CC_H                          0x2
 104 #  define CC_NLE                        0x3
 105 #  define CC_L                          0x4
 106 #  define CC_NHE                        0x5
 107 #  define CC_LH                         0x6
 108 #  define CC_NE                         0x7
 109 #  define CC_E                          0x8
 110 #  define CC_NLH                        0x9
 111 #  define CC_HE                         0xA
 112 #  define CC_NL                         0xB
 113 #  define CC_LE                         0xC
 114 #  define CC_NH                         0xD
 115 #  define CC_NO                         0xE
 116 #  define CC_AL                         0xF
 117 #  define _us                           jit_uint16_t
 118 #  define _ui                           jit_uint32_t
 119 #  define E_(Op)                        _E(_jit,Op)
 120 static void _E(jit_state_t*,_ui);
 121 #  define I_(Op,I)                      _I(_jit,Op,I)
 122 static void _I(jit_state_t*,_ui,_ui);
 123 #  define RR_(Op,R1,R2)                 _RR(_jit,Op,R1,R2)
 124 static void _RR(jit_state_t*,_ui,_ui,_ui);
 125 #  define RRE_(Op,R1,R2)                _RRE(_jit,Op,R1,R2)
 126 static void _RRE(jit_state_t*,_ui,_ui,_ui);
 127 #  define RRF_(Op,R3,M4,R1,R2)          _RRF(_jit,Op,R3,M4,R1,R2)
 128 static void _RRF(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
 129 #  define RX_(Op,R1,X2,B2,D2)           _RX(_jit,Op,R1,X2,B2,D2)
 130 static void _RX(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
 131 #  define RXE_(Op,R1,X2,B2,D2,Op2)      _RXE(_jit,Op,R1,X2,B2,D2,Op2)
 132 static void _RXE(jit_state_t*,_ui,_ui,_ui,_ui,_ui,_ui);
 133 #  define RXF_(Op,R3,X2,B2,D2,R1,Op2)   _RXF(_jit,Op,R3,X2,B2,D2,R1,Op2)
 134 static void _RXF(jit_state_t*,_ui,_ui,_ui,_ui,_ui,_ui,_ui);
 135 #  define RXY_(Op,R1,X2,B2,D2,Op2)      _RXY(_jit,Op,R1,X2,B2,D2,Op2)
 136 static void _RXY(jit_state_t*,_ui,_ui,_ui,_ui,_ui,_ui);
 137 #  define RS_(Op,R1,R3,B2,D2)           _RS(_jit,Op,R1,R3,B2,D2)
 138 static void _RS(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
 139 #  define RSY_(Op,R1,R3,B2,D2,Op2)      RXY_(Op,R1,R3,B2,D2,Op2)
 140 #  define RSL_(Op,L1,B1,D1,Op2)         _RSL(_jit,Op,L1,B1,D1,Op2)
 141 static void _RSL(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
 142 #  define RSI_(Op,R1,R3,I2)             _RSI(_jit,Op,R1,R3,I2)
 143 static void _RSI(jit_state_t*,_ui,_ui,_ui,_ui);
 144 #  define RI_(Op,R1,Op2,I2)             RSI_(Op,R1,Op2,I2)
 145 #  define RIE_(Op,R1,R3,I2,Op2)         _RIE(_jit,Op,R1,R3,I2,Op2)
 146 static void _RIE(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
 147 #  define RIL_(Op,R1,Op2,I2)            _RIL(_jit,Op,R1,Op2,I2)
 148 static void _RIL(jit_state_t*,_ui,_ui,_ui,_ui);
 149 #  define SI_(Op,I2,B1,D1)              _SI(_jit,Op,I2,B1,D1)
 150 static void _SI(jit_state_t*,_ui,_ui,_ui,_ui);
 151 #  define SIY_(Op,I2,B1,D1,Op2)         _SIY(_jit,Op,I2,B1,D1,Op2)
 152 static void _SIY(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
 153 #  define S_(Op,B2,D2)                  _S(_jit,Op,B2,D2)
 154 static void _S(jit_state_t*,_ui,_ui,_ui);
 155 #  define SSL_(Op,L,B1,D1,B2,D2)        SS_(Op,(L)>>4,(L)&0xF,B1,D1,B2,D2)
 156 #  define SS_(Op,LL,LH,B1,D1,B2,D2)     _SS(_jit,Op,LL,LH,B1,D1,B2,D2)
 157 static void _SS(jit_state_t*,_ui,_ui,_ui,_ui,_ui,_ui,_ui);
 158 #  define SSE_(Op,B1,D1,B2,D2)          _SSE(_jit,Op,B1,D1,B2,D2)
 159 static void _SSE(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
 160 #  undef _us
 161 #  undef _ui
 162 #  define nop(c)                        _nop(_jit,c)
 163 static void _nop(jit_state_t*,jit_int32_t);
 164 #  if __WORDSIZE == 32
 165 #    define ADD_(r0,r1)                 AR(r0,r1)
 166 #    define ADDI_(r0,i0)                AHI(r0,i0)
 167 #    define ADDC_(r0,r1)                ALR(r0,r1)
 168 #    define ADDX_(r0,r1)                ALCR(r0,r1)
 169 #    define AND_(r0,r1)                 NR(r0,r1)
 170 #    define CMP_(r0,r1)                 CR(r0,r1)
 171 #    define CMPU_(r0,r1)                CLR(r0,r1)
 172 #    define DIVREM_(r0,r1)              DR(r0,r1)
 173 #    define DIVREMU_(r0,r1)             DLR(r0,r1)
 174 #    define OR_(r0,r1)                  OR(r0,r1)
 175 #    define MUL_(r0,r1)                 MSR(r0,r1)
 176 #    define MULI_(r0,i0)                MHI(r0,i0)
 177 #    define MULU_(r0,r1)                MLR(r0,r1)
 178 #    define SUB_(r0,r1)                 SR(r0,r1)
 179 #    define SUBC_(r0,r1)                SLR(r0,r1)
 180 #    define SUBX_(r0,r1)                SLBR(r0,r1)
 181 #    define TEST_(r0,r1)                LTR(r0,r1)
 182 #    define XOR_(r0,r1)                 XR(r0,r1)
 183 #  else
 184 #    define ADD_(r0,r1)                 AGR(r0,r1)
 185 #    define ADDI_(r0,i0)                AGHI(r0,i0)
 186 #    define ADDC_(r0,r1)                ALGR(r0,r1)
 187 #    define ADDX_(r0,r1)                ALCGR(r0,r1)
 188 #    define AND_(r0,r1)                 NGR(r0,r1)
 189 #    define CMP_(r0,r1)                 CGR(r0,r1)
 190 #    define CMPU_(r0,r1)                CLGR(r0,r1)
 191 #    define DIVREM_(r0,r1)              DSGR(r0,r1)
 192 #    define DIVREMU_(r0,r1)             DLGR(r0,r1)
 193 #    define MUL_(r0,r1)                 MSGR(r0,r1)
 194 #    define MULI_(r0,i0)                MGHI(r0,i0)
 195 #    define MULU_(r0,r1)                MLGR(r0,r1)
 196 #    define OR_(r0,r1)                  OGR(r0,r1)
 197 #    define SUB_(r0,r1)                 SGR(r0,r1)
 198 #    define SUBC_(r0,r1)                SLGR(r0,r1)
 199 #    define SUBX_(r0,r1)                SLBGR(r0,r1)
 200 #    define TEST_(r0,r1)                LTGR(r0,r1)
 201 #    define XOR_(r0,r1)                 XGR(r0,r1)
 202 #  endif
 203 /****************************************************************
 204  * General Instructions                                         *
 205  ****************************************************************/
 206 /* ADD */
 207 #  define AR(R1,R2)                     RR_(0x1A,R1,R2)
 208 #  define AGR(R1,R2)                    RRE_(0xB908,R1,R2)
 209 #  define AGFR(R1,R2)                   RRE_(0xB918,R1,R2)
 210 #  define A(R1,D2,X2,B2)                RX_(0x5A,R1,X2,B2,D2)
 211 #  define AY(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x5A)
 212 #  define AG(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x08)
 213 #  define AGF(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x18)
 214 /* ADD HALFWORD */
 215 #  define AH(R1,D2,X2,B2)               RX_(0x4A,R1,X2,B2,D2)
 216 #  define AHY(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x7A)
 217 /* ADD HALFWORD IMMEDIATE */
 218 #  define AHI(R1,I2)                    RI_(0xA7,R1,0xA,I2)
 219 #  define AGHI(R1,I2)                   RI_(0xA7,R1,0xB,I2)
 220 /* ADD LOGICAL */
 221 #  define ALR(R1,R2)                    RR_(0x1E,R1,R2)
 222 #  define ALGR(R1,R2)                   RRE_(0xB90A,R1,R2)
 223 #  define ALGFR(R1,R2)                  RRE_(0xB91A,R1,R2)
 224 #  define AL(R1,D2,X2,B2)               RX_(0x5E,R1,X2,B2,D2)
 225 #  define ALY(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x5E)
 226 #  define ALG(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x0A)
 227 #  define ALGF(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x1A)
 228 /* ADD LOGICAL WITH CARRY */
 229 #  define ALCR(R1,R2)                   RRE_(0xB998,R1,R2)
 230 #  define ALCGR(R1,R2)                  RRE_(0xB988,R1,R2)
 231 #  define ALC(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x98)
 232 #  define ALCG(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x88)
 233 /* AND */
 234 #  define NR(R1,R2)                     RR_(0x14,R1,R2)
 235 #  define NGR(R1,R2)                    RRE_(0xB980,R1,R2)
 236 #  define N(R1,D2,X2,B2)                RX_(0x54,R1,X2,B2,D2)
 237 #  define NY(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x54)
 238 #  define NG(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x80)
 239 #  define NI(D1,B1,I2)                  SI_(0x94,I2,B1,D1)
 240 #  define NIY(D1,B1,I2)                 SIY_(0xEB,I2,B1,D1,0x54)
 241 #  define NC(D1,L,B1,D2,B2)             SSL_(0xD4,L,B1,D1,B2,D2)
 242 /* AND IMMEDIATE */
 243 #  define NIHH(R1,I2)                   RI_(0xA5,R1,0x4,I2)
 244 #  define NIHL(R1,I2)                   RI_(0xA5,R1,0x5,I2)
 245 #  define NILH(R1,I2)                   RI_(0xA5,R1,0x6,I2)
 246 #  define NILL(R1,I2)                   RI_(0xA5,R1,0x7,I2)
 247 /* BRANCH AND LINK */
 248 #  define BALR(R1,R2)                   RR_(0x05,R1,R2)
 249 #  define BAL(R1,D2,X2,B2)              RX_(0x45,R1,X2,B2,D2)
 250 /* BRANCH AND SAVE */
 251 #  define BASR(R1,R2)                   RR_(0x0D,R1,R2)
 252 #  define BAS(R1,D2,X2,B2)              RX_(0x4D,R1,X2,B2,D2)
 253 /* BRANCH AND SAVE AND SET MODE */
 254 #  define BASSM(R1,R2)                  RR_(0x0C,R1,R2)
 255 /* BRANCH AND SET MODE */
 256 #  define BSM(R1,R2)                    RR_(0x0B,R1,R2)
 257 /* BRANCH ON CONDITION */
 258 #  define BCR(M1,R2)                    RR_(0x07,M1,R2)
 259 #  define BR(R2)                        BCR(CC_AL,R2)
 260 #  define NOPR(R2)                      BCR(CC_NV,R2)
 261 #  define BC(M1,D2,X2,B2)               RX_(0x47,M1,X2,B2,D2)
 262 /* BRANCH ON COUNT */
 263 #  define BCTR(R1,R2)                   RR_(0x06,R1,R2)
 264 #  define BCTGR(R1,R2)                  RRE_(0xB946,R1,R2)
 265 #  define BCT(R1,D2,X2,B2)              RX_(0x46,R1,X2,B2,D2)
 266 #  define BCTG(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x46)
 267 /* BRANCH ON INDEX HIGH */
 268 #  define BXH(R1,R3,D2,B2)              RS_(0x86,R1,R3,B2,D2)
 269 #  define BXHG(R1,R3,B2,D2)             RSY_(0xEB,R1,R3,B2,D2,0x44)
 270 /* BRANCH ON INDEX LOW OR EQUAL */
 271 #  define BXLE(R1,R3,D2,B2)             RS_(0x87,R1,R3,B2,D2)
 272 #  define BXLEG(R1,R3,B2,D2)            RSY_(0xEB,R1,R3,B2,D2,0x45)
 273 /* BRANCH RELATIVE AND SAVE */
 274 #  define BRAS(R1,I2)                   RI_(0xA7,R1,0x5,I2)
 275 /* BRANCH RELATIVE AND SAVE LONG */
 276 #  define BRASL(R1,I2)                  RIL_(0xC0,R1,0x5,I2)
 277 /* BRANCH RELATIVE ON CONDITION */
 278 #  define BRC(M1,I2)                    RI_(0xA7,M1,0x4,I2)
 279 #  define J(I2)                         BRC(CC_AL,I2)
 280 /* BRANCH RELATIVE ON CONDITION LONG */
 281 #  define BRCL(M1,I2)                   RIL_(0xC0,M1,0x4,I2)
 282 #  define BRL(I2)                       BRCL(CC_AL,I2)
 283 /* BRANCH RELATIVE ON COUNT */
 284 #  define BRCT(M1,I2)                   RI_(0xA7,M1,0x6,I2)
 285 #  define BRCTG(M1,I2)                  RI_(0xA7,M1,0x7,I2)
 286 /* BRANCH RELATIVE ON INDEX HIGH */
 287 #  define BRXH(R1,R3,I2)                RSI_(0x84,R1,R3,I2)
 288 #  define BRXHG(R1,R3,I2)               RIE_(0xEC,R1,R3,I2,0x44)
 289 /* BRANCH RELATIVE ON INDEX LOW OR EQUAL */
 290 #  define BRXLE(R1,R3,I2)               RSI_(0x85,R1,R3,I2)
 291 #  define BRXLEG(R1,R3,I2)              RIE_(0xEC,R1,R3,I2,0x45)
 292 /* CHECKSUM */
 293 #  define CKSUM(R1,R2)                  RRE_(0xB241,R1,R2)
 294 /* CIPHER MESAGE (KM) */
 295 #  define KM(R1,R2)                     RRE_(0xB92E,R1,R2)
 296 /* CIPHER MESAGE WITH CHAINING (KMC) */
 297 #  define KMC(R1,R2)                    RRE_(0xB92F,R1,R2)
 298 /* COMPARE */
 299 #  define CR(R1,R2)                     RR_(0x19,R1,R2)
 300 #  define CGR(R1,R2)                    RRE_(0xB920,R1,R2)
 301 #  define CGFR(R1,R2)                   RRE_(0xB930,R1,R2)
 302 #  define C(R1,D2,X2,B2)                RX_(0x59,R1,X2,B2,D2)
 303 #  define CY(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x59)
 304 #  define CG(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x20)
 305 #  define CGF(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x30)
 306 /* COMPARE AND FORM CODEWORD */
 307 #  define CFC(D2,B2)                    S_(0xB21A,B2,D2)
 308 /* COMPARE AND SWAP */
 309 #  define CS(R1,R3,D2,B2)               RS_(0xBA,R1,R3,B2,D2)
 310 #  define CSY(R1,R3,D2,B2)              RSY_(0xEB,R1,R3,B2,D2,0x14)
 311 #  define CSG(R1,R3,D2,B2)              RSY_(0xEB,R1,R3,B2,D2,0x30)
 312 /* COMPARE DOUBLE AND SWAP */
 313 #  define CDS(R1,R3,D2,B2)              RS_(0xBB,R1,R3,B2,D2)
 314 #  define CSDY(R1,R3,D2,B2)             RSY_(0xEB,R1,R3,B2,D2,0x31)
 315 #  define CSDG(R1,R3,D2,B2)             RSY_(0xEB,R1,R3,B2,D2,0x3E)
 316 /* COMPARE HALFWORD */
 317 #  define CH(R1,D2,X2,B2)               RX_(0x49,R1,X2,B2,D2)
 318 #  define CHY(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x79)
 319 /* COMPARE HALFWORD IMMEDIATE */
 320 #  define CHI(R1,I2)                    RI_(0xA7,R1,0xE,I2)
 321 #  define CGHI(R1,I2)                   RI_(0xA7,R1,0xF,I2)
 322 /* COMPARE LOGICAL */
 323 #  define CLR(R1,R2)                    RR_(0x15,R1,R2)
 324 #  define CLGR(R1,R2)                   RRE_(0xB921,R1,R2)
 325 #  define CLGFR(R1,R2)                  RRE_(0xB931,R1,R2)
 326 #  define CL(R1,D2,X2,B2)               RX_(0x55,R1,X2,B2,D2)
 327 #  define CLY(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x55)
 328 #  define CLG(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x21)
 329 #  define CLGF(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x31)
 330 #  define CLI(D1,B1,I2)                 SI_(0x95,I2,B1,D1)
 331 #  define CLIY(D1,B1,I2)                SIY_(0xEB,I2,B1,D1,0x55)
 332 #  define CLC(D1,L,B1,D2,B2)            SSL_(0xD5,L,B1,D1,B2,D2)
 333 /* COMPARE LOGICAL CHARACTERS UNDER MASK */
 334 #  define CLM(R1,M3,D2,B2)              RS_(0xBD,R1,M3,B2,D2)
 335 #  define CLMY(R1,M3,D2,B2)             RSY_(0xEB,R1,M3,B2,D2,0x21)
 336 #  define CLMH(R1,M3,D2,B2)             RSY_(0xEB,R1,M3,B2,D2,0x20)
 337 /* COMPARE LOGICAL LONG */
 338 #  define CLCL(R1,R2)                   RR_(0x0F,R1,R2)
 339 /* COMPARE LOGICAL LONG EXTENDED */
 340 #  define CLCLE(R1,R3,D2,B2)            RS_(0xA9,R1,R3,B2,D2)
 341 /* COMPARE LOGICAL LONG UNICODE */
 342 #  define CLCLU(R1,R3,D2,B2)            RSY_(0xEB,R1,R3,B2,D2,0x8F)
 343 /* COMPARE LOGICAL STRING */
 344 #  define CLST(R1,R2)                   RRE_(0xB25D,R1,R2)
 345 /* COMPARE UNTIL SUBSTRING EQUAL */
 346 #  define CUSE(R1,R2)                   RRE_(0xB257,R1,R2)
 347 /* COMPRESSION CALL */
 348 #  define CMPSC(R1,R2)                  RRE_(0xB263,R1,R2)
 349 /* COMPUTE INTERMEDIATE MESSAGE DIGEST (KIMD) */
 350 #  define KIMD(R1,R2)                   RRE_(0xB93E,R1,R2)
 351 /* COMPUTE LAST MESSAGE DIGEST (KIMD) */
 352 #  define KLMD(R1,R2)                   RRE_(0xB93F,R1,R2)
 353 /* COMPUTE MESSAGE AUTHENTICATION CODE (KMAC) */
 354 #  define KMAC(R1,R2)                   RRE_(0xB91E,R1,R2)
 355 /* CONVERT TO BINARY */
 356 #  define CVB(R1,D2,X2,B2)              RX_(0x4F,R1,X2,B2,D2)
 357 #  define CVBY(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x06)
 358 #  define CVBG(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x0e)
 359 /* CONVERT TO DECIMAL */
 360 #  define CVD(R1,D2,X2,B2)              RX_(0x4E,R1,X2,B2,D2)
 361 #  define CVDY(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x26)
 362 #  define CVDG(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x2E)
 363 /* CONVERT UNICODE TO UTF-8 */
 364 #  define CUUTF(R1,R2)                  RRE_(0xB2A6,R1,R2)
 365 /* CONVERT UTF-8 TO UNICODE */
 366 #  define CUTFU(R1,R2)                  RRE_(0xB2A7,R1,R2)
 367 /* COPY ACCESS */
 368 #  define CPYA(R1,R2)                   RRE_(0xB24D,R1,R2)
 369 /* DIVIDE */
 370 #  define DR(R1,R2)                     RR_(0x1D,R1,R2)
 371 #  define D(R1,D2,X2,B2)                RX_(0x5D,R1,X2,B2,D2)
 372 /* DIVIDE LOGICAL */
 373 #  define DLR(R1,R2)                    RRE_(0xB997,R1,R2)
 374 #  define DLGR(R1,R2)                   RRE_(0xB987,R1,R2)
 375 #  define DL(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x97)
 376 #  define DLG(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x87)
 377 /* DIVIDE SINGLE */
 378 #  define DSGR(R1,R2)                   RRE_(0xB90D,R1,R2)
 379 #  define DSGFR(R1,R2)                  RRE_(0xB91D,R1,R2)
 380 #  define DSG(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x0D)
 381 #  define DSGF(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x1D)
 382 /* EXCLUSIVE OR */
 383 #  define XR(R1,R2)                     RR_(0x17,R1,R2)
 384 #  define XGR(R1,R2)                    RRE_(0xB982,R1,R2)
 385 #  define X(R1,D2,X2,B2)                RX_(0x57,R1,X2,B2,D2)
 386 #  define XY(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x57)
 387 #  define XG(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x82)
 388 #  define XI(D1,B1,I2)                  SI_(0x97,I2,B1,D1)
 389 #  define XIY(D1,B1,I2)                 SIY_(0xEB,I2,B1,D1,0x57)
 390 #  define XC(D1,L,B1,D2,B2)             SSL_(0xD7,L,B1,D1,B2,D2)
 391 /* EXECUTE */
 392 #  define EX(R1,D2,X2,B2)               RX_(0x44,R1,X2,B2,D2)
 393 /* EXTRACT ACCESS */
 394 #  define EAR(R1,R2)                    RRE_(0xB24F,R1,R2)
 395 /* EXTRACT PSW */
 396 #  define EPSW(R1,R2)                   RRE_(0xB98D,R1,R2)
 397 /* INSERT CHARACTER */
 398 #  define IC(R1,D2,X2,B2)               RX_(0x43,R1,X2,B2,D2)
 399 #  define ICY(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x73)
 400 /* INSERT CHARACTERS UNDER MASK */
 401 #  define ICM(R1,M3,D2,B2)              RS_(0xBF,R1,M3,B2,D2)
 402 #  define ICMY(R1,M3,D2,B2)             RSY_(0xEB,R1,M3,B2,D2,0x81)
 403 #  define ICMH(R1,M3,D2,B2)             RSY_(0xEB,R1,M3,B2,D2,0x80)
 404 /* INSERT IMMEDIATE */
 405 #  define IIHH(R1,I2)                   RI_(0xA5,R1,0x0,I2)
 406 #  define IIHL(R1,I2)                   RI_(0xA5,R1,0x1,I2)
 407 #  define IILH(R1,I2)                   RI_(0xA5,R1,0x2,I2)
 408 #  define IILL(R1,I2)                   RI_(0xA5,R1,0x3,I2)
 409 /* INSERT PROGRAM MASK */
 410 #  define IPM(R1)                       RRE_(0xB222,R1,0)
 411 /* LOAD */
 412 #  define LR(R1,R2)                     RR_(0x18,R1,R2)
 413 #  define LGR(R1,R2)                    RRE_(0xB904,R1,R2)
 414 #  define LGFR(R1,R2)                   RRE_(0xB914,R1,R2)
 415 #  define L(R1,D2,X2,B2)                RX_(0x58,R1,X2,B2,D2)
 416 #  define LY(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x58)
 417 #  define LG(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x04)
 418 #  define LGF(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x14)
 419 /* LOAD ACCESS MULTIPLE */
 420 #  define LAM(R1,R3,D2,B2)              RS_(0x9A,R1,R3,B2,D2)
 421 #  define LAMY(R1,R3,D2,B2)             RSY_(0xEB,R1,R3,B2,D2,0x9A)
 422 /* LOAD ADDRESS */
 423 #  define LA(R1,D2,X2,B2)               RX_(0x41,R1,X2,B2,D2)
 424 #  define LAY(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x71)
 425 /* LOAD ADDRESS EXTENDED */
 426 #  define LAE(R1,D2,X2,B2)              RX_(0x51,R1,X2,B2,D2)
 427 /* LOAD ADDRESS RELATIVE LONG */
 428 #  define LARL(R1,I2)                   RIL_(0xC0,R1,0x0,I2)
 429 /* LOAD AND TEST */
 430 #  define LTR(R1,R2)                    RR_(0x12,R1,R2)
 431 #  define LTGR(R1,R2)                   RRE_(0xB902,R1,R2)
 432 #  define LTGFR(R1,R2)                  RRE_(0xB912,R1,R2)
 433 /* LOAD BYTE */
 434 #  define LGBR(R1,R2)                   RRE_(0xB906,R1,R2)      /* disasm */
 435 #  define LB(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x76)
 436 #  define LGB(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x77)
 437 /* LOAD COMPLEMENT */
 438 #  define LCR(R1,R2)                    RR_(0x13,R1,R2)
 439 #  define LCGR(R1,R2)                   RRE_(0xB903,R1,R2)
 440 #  define LCGFR(R1,R2)                  RRE_(0xB913,R1,R2)
 441 /* LOAD HALFWORD */
 442 #  define LH(R1,D2,X2,B2)               RX_(0x48,R1,X2,B2,D2)
 443 #  define LHY(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x78)
 444 #  define LGHR(R1,R2)                   RRE_(0xB907,R1,R2)      /* disasm */
 445 #  define LGH(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x15)
 446 /* LOAD HALFWORD IMMEDIATE */
 447 #  define LHI(R1,I2)                    RI_(0xA7,R1,0x8,I2)
 448 #  define LGHI(R1,I2)                   RI_(0xA7,R1,0x9,I2)
 449 /* LOAD LOGICAL */
 450 #  define LLGFR(R1,R2)                  RRE_(0xB916,R1,R2)
 451 #  define LLGF(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x16)
 452 /* LOAD LOGICAL CHARACTER */
 453 #  define LLGCR(R1,R2)                  RRE_(0xB984,R1,R2)      /* disasm */
 454 #  define LLGC(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x90)
 455 /* LOAD LOGICAL HALFWORD */
 456 #  define LLGHR(R1,R2)                  RRE_(0xB985,R1,R2)      /* disasm */
 457 #  define LLGH(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x91)
 458 /* LOAD LOGICAL IMMEDIATE */
 459 #  define LLIHH(R1,I2)                  RI_(0xA5,R1,0xC,I2)
 460 #  define LLIHL(R1,I2)                  RI_(0xA5,R1,0xD,I2)
 461 #  define LLILH(R1,I2)                  RI_(0xA5,R1,0xE,I2)
 462 #  define LLILL(R1,I2)                  RI_(0xA5,R1,0xF,I2)
 463 /* LOAD LOGICAL THIRTY ONE BITS */
 464 #  define LLGTR(R1,R2)                  RRE_(0xB917,R1,R2)
 465 #  define LLGT(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x17)
 466 /* LOAD MULTIPLE */
 467 #  define LM(R1,R3,D2,B2)               RS_(0x98,R1,R3,B2,D2)
 468 #  define LMY(R1,R3,D2,B2)              RSY_(0xEB,R1,R3,B2,D2,0x98)
 469 #  define LMG(R1,R3,D2,B2)              RSY_(0xEB,R1,R3,B2,D2,0x04)
 470 /* LOAD MULTIPLE DISJOINT */
 471 #  define LMD(R1,R3,D2,B2,D4,B4)        SS_(0xEF,R1,R3,B2,D2,B4,D4)
 472 /* LOAD MULTIPLE HIGH */
 473 #  define LMH(R1,R3,D2,B2)              RSY_(0xEB,R1,R3,B2,D2,0x96)
 474 /* LOAD NEGATIVE */
 475 #  define LNR(R1,R2)                    RR_(0x11,R1,R2)
 476 #  define LNGR(R1,R2)                   RRE_(0xB901,R1,R2)
 477 #  define LNGFR(R1,R2)                  RRE_(0xB911,R1,R2)
 478 /* LOAD PAIR FROM QUADWORD */
 479 #  define LPQ(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x8F)
 480 /* LOAD POSITIVE */
 481 #  define LPR(R1,R2)                    RR_(0x10,R1,R2)
 482 #  define LPGR(R1,R2)                   RRE_(0xB900,R1,R2)
 483 #  define LPGFR(R1,R2)                  RRE_(0xB910,R1,R2)
 484 /* LOAD REVERSED */
 485 #  define LRVR(R1,R2)                   RRE_(0xB91F,R1,R2)
 486 #  define LRVGR(R1,R2)                  RRE_(0xB90F,R1,R2)
 487 #  define LRVH(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x1F)
 488 #  define LRV(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x1E)
 489 #  define LRVG(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x0F)
 490 /* MONITOR CALL */
 491 #  define MC(D1,B1,I2)                  SI_(0xAF,I2,B1,D1)
 492 /* MOVE */
 493 #  define MVI(D1,B1,I2)                 SI_(0x92,I2,B1,D1)
 494 #  define MVIY(D1,B1,I2)                SIY_(0xEB,I2,B1,D1,0x52)
 495 #  define MVC(D1,L,B1,D2,B2)            SSL_(0xD2,L,B1,D1,B2,D2)
 496 /* MOVE INVERSE */
 497 #  define MVCIN(D1,L,B1,D2,B2)          SSL_(0xE8,L,B1,D1,B2,D2)
 498 /* MOVE LONG */
 499 #  define MVCL(R1,R2)                   RR_(0x0E,R1,R2)
 500 /* MOVE LONG EXTENDED */
 501 #  define MVCLE(R1,R3,D2,B2)            RS_(0xA8,R1,R3,B2,D2)
 502 /* MOVE LONG UNICODE */
 503 #  define MVCLU(R1,R3,D2,B2)            RSY_(0xEB,R1,R3,B2,D2,0x8E)
 504 /* MOVE NUMERICS */
 505 #  define MVN(D1,L,B1,D2,B2)            SSL_(0xD1,L,B1,D1,B2,D2)
 506 /* MOVE STRING */
 507 #  define MVST(R1,R2)                   RRE_(0xB255,R1,R2)
 508 /* MOVE WITH OFFSET */
 509 #  define MVO(D1,L1,B1,D2,L2,B2)        SS_(0xF1,L1,L2,B1,D1,B2,D2)
 510 /* MOVE ZONES */
 511 #  define MVZ(D1,L,B1,D2,B2)            SSL_(0xD3,L,B1,D1,B2,D2)
 512 /* MULTIPLY */
 513 #  define MR(R1,R2)                     RR_(0x1C,R1,R2)
 514 #  define M(R1,D2,X2,B2)                RX_(0x5C,R1,X2,B2,D2)
 515 /* MULTIPLY HALFWORD */
 516 #  define MH(R1,D2,X2,B2)               RX_(0x4C,R1,X2,B2,D2)
 517 /* MULTIPLY HALFWORD IMMEDIATE */
 518 #  define MHI(R1,I2)                    RI_(0xA7,R1,0xC,I2)
 519 #  define MGHI(R1,I2)                   RI_(0xA7,R1,0xD,I2)
 520 /* MULTIPLY LOGICAL */
 521 #  define MLR(R1,R2)                    RRE_(0xB996,R1,R2)
 522 #  define MLGR(R1,R2)                   RRE_(0xB986,R1,R2)
 523 #  define ML(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x96)
 524 #  define MLG(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x86)
 525 /* MULTIPLY SINGLE */
 526 #  define MSR(R1,R2)                    RRE_(0xB252,R1,R2)
 527 #  define MSGR(R1,R2)                   RRE_(0xB90C,R1,R2)
 528 #  define MSGFR(R1,R2)                  RRE_(0xB91C,R1,R2)
 529 #  define MS(R1,D2,X2,B2)               RX_(0x71,R1,X2,B2,D2)
 530 #  define MSY(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x51)
 531 #  define MSG(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x0C)
 532 #  define MSGF(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x1C)
 533 /* OR */
 534 #  define OR(R1,R2)                     RR_(0x16,R1,R2)
 535 #  define OGR(R1,R2)                    RRE_(0xB981,R1,R2)
 536 #  define O(R1,D2,X2,B2)                RX_(0x56,R1,X2,B2,D2)
 537 #  define OY(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x56)
 538 #  define OG(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x81)
 539 #  define OI(D1,B1,I2)                  SI_(0x96,I2,B1,D1)
 540 #  define OIY(D1,B1,I2)                 SIY_(0xEB,I2,B1,D1,0x56)
 541 #  define OC(D1,L,B1,D2,B2)             SSL_(0xD6,L,B1,D1,B2,D2)
 542 /* OR IMMEDIATE */
 543 #  define OIHH(R1,I2)                   RI_(0xA5,R1,0x8,I2)
 544 #  define OIHL(R1,I2)                   RI_(0xA5,R1,0x9,I2)
 545 #  define OILH(R1,I2)                   RI_(0xA5,R1,0xA,I2)
 546 #  define OILL(R1,I2)                   RI_(0xA5,R1,0xB,I2)
 547 /* PACK */
 548 #  define PACK(D1,L1,B1,D2,L2,B2)       SS_(0xF2,L1,L2,B1,D1,B2,D2)
 549 /* PACK ASCII */
 550 #  define PKA(D1,B1,D2,L2,B2)           SSL_(0xE9,L2,B1,D1,B2,D2)
 551 /* PACK UNICODE */
 552 #  define PKU(D1,B1,D2,L2,B2)           SSL_(0xE1,L2,B1,D1,B2,D2)
 553 /* PERFORM LOCKED OPERATION */
 554 #  define PLO(R1,D2,B2,R3,D4,B4)        SS_(0xEE,R1,R3,B2,D2,B4,D4)
 555 /* ROTATE LEFT SINGLE LOGICAL */
 556 #  define RLL(R1,R3,D2,B2)              RSY_(0xEB,R1,R3,B2,D2,0x1D)
 557 #  define RLLG(R1,R3,D2,B2)             RSY_(0xEB,R1,R3,B2,D2,0x1C)
 558 /* SEARCH STRING */
 559 #  define SRST(R1,R2)                   RRE_(0xB25E,R1,R2)
 560 /* SET ACCESS */
 561 #  define SAR(R1,R2)                    RRE_(0xB24E,R1,R2)
 562 /* SET ADDRESSING MODE */
 563 #  define SAM24()                       E_(0x10C)
 564 #  define SAM31()                       E_(0x10D)
 565 #  define SAM64()                       E_(0x10E)
 566 /* SET PROGRAM MASK */
 567 #  define SPM(R1)                       RR_(0x04,R1,0)
 568 /* SHIFT LEFT DOUBLE */
 569 #  define SLDA(R1,D2,B2)                RS_(0x8F,R1,0,B2,D2)
 570 /* SHIFT LEFT DOUBLE LOGICAL */
 571 #  define SLDL(R1,D2,B2)                RS_(0x8D,R1,0,B2,D2)
 572 /* SHIFT LEFT SINGLE */
 573 #  define SLA(R1,D2,B2)                 RS_(0x8B,R1,0,B2,D2)
 574 #  define SLAG(R1,R3,D2,B2)             RSY_(0xEB,R1,R3,B2,D2,0x0B)
 575 /* SHIFT LEFT SINGLE LOGICAL */
 576 #  define SLL(R1,D2,B2)                 RS_(0x89,R1,0,B2,D2)
 577 #  define SLLG(R1,R3,D2,B2)             RSY_(0xEB,R1,R3,B2,D2,0x0D)
 578 /* SHIFT RIGHT DOUBLE */
 579 #  define SRDA(R1,D2,B2)                RS_(0x8E,R1,0,B2,D2)
 580 /* SHIFT RIGHT DOUBLE LOGICAL */
 581 #  define SRDL(R1,D2,B2)                RS_(0x8C,R1,0,B2,D2)
 582 /* SHIFT RIGHT SINGLE */
 583 #  define SRA(R1,D2,B2)                 RS_(0x8A,R1,0,B2,D2)
 584 #  define SRAG(R1,R3,D2,B2)             RSY_(0xEB,R1,R3,B2,D2,0x0A)
 585 /* SHIFT RIGHT SINGLE LOGICAL */
 586 #  define SRL(R1,D2,B2)                 RS_(0x88,R1,0,B2,D2)
 587 #  define SRLG(R1,R3,D2,B2)             RSY_(0xEB,R1,R3,B2,D2,0x0C)
 588 /* STORE */
 589 #  define ST(R1,D2,X2,B2)               RX_(0x50,R1,X2,B2,D2)
 590 #  define STY(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x50)
 591 #  define STG(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x24)
 592 /* STORE ACCESS MULTIPLE */
 593 #  define STAM(R1,R3,D2,B2)             RS_(0x9B,R1,R3,B2,D2)
 594 #  define STAMY(R1,R3,D2,B2)            RSY_(0xEB,R1,R3,B2,D2,0x9B)
 595 /* STORE CHARACTER */
 596 #  define STC(R1,D2,X2,B2)              RX_(0x42,R1,X2,B2,D2)
 597 #  define STCY(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x72)
 598 /* STORE CHARACTERS UNDER MASK */
 599 #  define STCM(R1,M3,D2,B2)             RS_(0xBE,R1,M3,B2,D2)
 600 #  define STCMY(R1,M3,D2,B2)            RSY_(0xEB,R1,M3,B2,D2,0x2D)
 601 #  define STCMH(R1,M3,D2,B2)            RSY_(0xEB,R1,M3,B2,D2,0x2C)
 602 /* STORE CLOCK */
 603 #  define STCK(D2,B2)                   S_(0xB205,B2,D2)
 604 /* STORE CLOCK EXTENDED */
 605 #  define STCKE(D2,B2)                  S_(0xB278,B2,D2)
 606 /* STORE HALFWORD */
 607 #  define STH(R1,D2,X2,B2)              RX_(0x40,R1,X2,B2,D2)
 608 #  define STHY(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x70)
 609 /* STORE MULTIPLE */
 610 #  define STM(R1,R3,D2,B2)              RS_(0x90,R1,R3,B2,D2)
 611 #  define STMY(R1,R3,D2,B2)             RSY_(0xEB,R1,R3,B2,D2,0x90)
 612 #  define STMG(R1,R3,D2,B2)             RSY_(0xEB,R1,R3,B2,D2,0x24)
 613 /* STORE MULTIPLE HIGH */
 614 #  define STMH(R1,R3,D2,B2)             RSY_(0xEB,R1,R3,B2,D2,0x26)
 615 /* STORE PAIR TO QUADWORD */
 616 #  define STPQ(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x8E)
 617 /* STORE REVERSED */
 618 #  define STRVH(R1,D2,X2,B2)            RXY_(0xE3,R1,X2,B2,D2,0x3F)
 619 #  define STRV(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x3E)
 620 #  define STRVG(R1,D2,X2,B2)            RXY_(0xE3,R1,X2,B2,D2,0x2F)
 621 /* SUBTRACT */
 622 #  define SR(R1,R2)                     RR_(0x1B,R1,R2)
 623 #  define SGR(R1,R2)                    RRE_(0xB909,R1,R2)
 624 #  define SGFR(R1,R2)                   RRE_(0xB919,R1,R2)
 625 #  define S(R1,D2,X2,B2)                RX_(0x5B,R1,X2,B2,D2)
 626 #  define SY(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x5B)
 627 #  define SG(R1,D2,X2,B2)               RXY_(0xE3,R1,X2,B2,D2,0x09)
 628 #  define SGF(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x19)
 629 /* SUBTRACT HALFWORD */
 630 #  define SH(R1,D2,X2,B2)               RX_(0x4B,R1,X2,B2,D2)
 631 #  define SHY(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x7B)
 632 /* SUBTRACT LOGICAL */
 633 #  define SLR(R1,R2)                    RR_(0x1F,R1,R2)
 634 #  define SLGR(R1,R2)                   RRE_(0xB90B,R1,R2)
 635 #  define SLGFR(R1,R2)                  RRE_(0xB91B,R1,R2)
 636 #  define SL(R1,D2,X2,B2)               RX_(0x5F,R1,X2,B2,D2)
 637 #  define SLY(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x5F)
 638 #  define SLG(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x0B)
 639 #  define SLGF(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x1B)
 640 /* SUBTRACT LOGICAL WITH BORROW */
 641 #  define SLBR(R1,R2)                   RRE_(0xB999,R1,R2)
 642 #  define SLBGR(R1,R2)                  RRE_(0xB989,R1,R2)
 643 #  define SLB(R1,D2,X2,B2)              RXY_(0xE3,R1,X2,B2,D2,0x99)
 644 #  define SLBG(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x89)
 645 /* SUPERVISOR CALL */
 646 #  define SVC(I)                        I_(0xA,I)
 647 /* TEST ADDRESSING MODE */
 648 #  define TAM()                         E_(0x10B)
 649 /* TEST AND SET */
 650 #  define TS(D2,B2)                     RS_(0x93,0,0,B2,D2)
 651 /* TEST UNDER MASK (TEST UNDER MASK HIGH, TEST UNDER MASK LOW) */
 652 #  define TM(D1,B1,I2)                  SI_(0x91,I2,B1,D1)
 653 #  define TMY(D1,B1,I2)                 SIY_(0xEB,I2,B1,D1,0x51)
 654 #  define TMHH(R1,I2)                   RI_(0xA7,R1,0x2,I2)
 655 #  define TMHL(R1,I2)                   RI_(0xA7,R1,0x3,I2)
 656 #  define TMLH(R1,I2)                   RI_(0xA7,R1,0x0,I2)
 657 #  define TMH(R1,I2)                    TMLH(R1,I2)
 658 #  define TMLL(R1,I2)                   RI_(0xA7,R1,0x1,I2)
 659 #  define TML(R1,I2)                    TMLL(R1,I2)
 660 /* TRANSLATE */
 661 #  define TR(D1,L,B1,D2,B2)             SSL_(0xDC,L,B1,D1,B2,D2)
 662 /* TRANSLATE AND TEST */
 663 #  define TRT(D1,L,B1,D2,B2)            SSL_(0xDD,L,B1,D1,B2,D2)
 664 /* TRANSLATE EXTENDED */
 665 #  define TRE(R1,R2)                    RRE_(0xB2A5,R1,R2)
 666 /* TRANSLATE ONE TO ONE */
 667 #  define TROO(R1,R2)                   RRE_(0xB993,R1,R2)
 668 /* TRANSLATE ONE TO TWO */
 669 #  define TROT(R1,R2)                   RRE_(0xB992,R1,R2)
 670 /* TRANSLATE TWO TO ONE */
 671 #  define TRTO(R1,R2)                   RRE_(0xB991,R1,R2)
 672 /* TRANSLATE TWO TO TWO */
 673 #  define TRTT(R1,R2)                   RRE_(0xB990,R1,R2)
 674 /* UNPACK */
 675 #  define UNPK(D1,L1,B1,D2,L2,B2)       SS_(0xF3,L1,L2,B1,D1,B2,D2)
 676 /* UNPACK ASCII */
 677 #  define UNPKA(D1,L1,B1,D2,L2,B2)      SS_(0xEA,L1,L2,B1,D1,B2,D2)
 678 /* UNPACK UNICODE */
 679 #  define UNPKU(D1,L1,B1,D2,L2,B2)      SS_(0xE2,L1,L2,B1,D1,B2,D2)
 680 /* UPDATE TREE */
 681 #  define UPT()                         E_(0x0102)
 682 /****************************************************************
 683  * Decimal Instructions                                         *
 684  ****************************************************************/
 685 /* ADD DECIMAL */
 686 #  define AP(D1,L1,B1,D2,L2,B2)         SS_(0xFA,L1,L2,B1,D1,B2,D2)
 687 /* COMPARE DECIMAL */
 688 #  define CP(D1,L1,B1,D2,L2,B2)         SS_(0xF9,L1,L2,B1,D1,B2,D2)
 689 /* DIVIDE DECIMAL */
 690 #  define DP(D1,L1,B1,D2,L2,B2)         SS_(0xFD,L1,L2,B1,D1,B2,D2)
 691 /* EDIT */
 692 #  define ED(D1,L,B1,D2,B2)             SSL_(0xDE,L,B1,D1,B2,D2)
 693 /* EDIT AND MARK */
 694 #  define EDMK(D1,L,B1,D2,B2)           SSL_(0xDE,L,B1,D1,B2,D2)
 695 /* MULTIPLY DECIMAL */
 696 #  define MP(D1,L1,B1,D2,L2,B2)         SS_(0xFC,L1,L2,B1,D1,B2,D2)
 697 /* SHIFT AND ROUND DECIMAL */
 698 #  define SRP(D1,L1,B1,D2,L2,B2)        SS_(0xF0,L1,L2,B1,D1,B2,D2)
 699 /* SUBTRACE DECIMAL */
 700 #  define SP(D1,L1,B1,D2,L2,B2)         SS_(0xFB,L1,L2,B1,D1,B2,D2)
 701 /* TEST DECIMAL */
 702 #  define TP(D1,L1,B1)                  RSL_(0xEB,L1,B1,D1,0xC0)
 703 /* ZERO AND ADD */
 704 #  define ZAP(D1,L1,B1,D2,L2,B2)        SS_(0xF8,L1,L2,B1,D1,B2,D2)
 705 /****************************************************************
 706  * Control Instructions                                         *
 707  ****************************************************************/
 708 /* BRANCH AND SET AUTHORITY */
 709 #  define BSA(R1,R2)                    RRE_(0xB25A,R1,R2)
 710 /* BRANCH AND STACK */
 711 #  define BAKR(R1,R2)                   RRE_(0xB240,R1,R2)
 712 /* BRANCH IN SUBSPACE GROUP */
 713 #  define BSG(R1,R2)                    RRE_(0xB258,R1,R2)
 714 /* COMPARE AND SWAP AND PURGE */
 715 #  define CSP(R1,R2)                    RRE_(0xB250,R1,R2)
 716 #  define CSPG(R1,R2)                   RRE_(0xB98A,R1,R2)
 717 /* DIAGNOSE */
 718 #  define DIAG()                        SI_(0x83,0,0,0)
 719 /* EXTRACT AND SET EXTENDED AUTHORITY */
 720 #  define ESEA(R1)                      RRE_(0xB99D,R1,0)
 721 /* EXTRACT PRIMARY ASN */
 722 #  define EPAR(R1)                      RRE_(0xB226,R1,0)
 723 /* EXTRACT SECONDARY ASN */
 724 #  define ESAR(R1)                      RRE_(0xB227,R1,0)
 725 /* EXTRACT STACKED REGISTERS */
 726 #  define EREG(R1,R2)                   RRE_(0xB249,R1,R2)
 727 #  define EREGG(R1,R2)                  RRE_(0xB90E,R1,R2)
 728 /* EXTRACT STACKED STATE */
 729 #  define ESTA(R1,R2)                   RRE_(0xB24A,R1,R2)
 730 /* INSERT ADDRESS SPACE CONTROL */
 731 #  define IAC(R1)                       RRE_(0xB224,R1,0)
 732 /* INSERT PSW KEY */
 733 #  define IPK()                         S_(0xB20B,0,0)
 734 /* INSERT STORAGE KEY EXTENDED */
 735 #  define ISKE(R1,R2)                   RRE_(0xB229,R1,R2)
 736 /* INSERT VIRTUAL STORAGE KEY */
 737 #  define IVSK(R1,R2)                   RRE_(0xB223,R1,R2)
 738 /* INVALIDATE DAT TABLE ENTRY */
 739 #  define IDTE(R1,R2,R3)                RRF_(0xB98E,R3,0,R1,R2)
 740 /* INVALIDATE PAGE TABLE ENTRY */
 741 #  define IPTE(R1,R2)                   RRE_(0xB221,R1,R2)
 742 /* LOAD ADDRESS SPACE PARAMETER */
 743 #  define LASP(D1,B1,D2,B2)             SSE_(0xE500,B1,D1,B2,D2)
 744 /* LOAD CONTROL */
 745 #  define LCTL(R1,R3,D2,B2)             RS_(0xB7,R1,R3,B2,D2)
 746 #  define LCTLG(R1,R3,D2,B2)            RSY_(0xEB,R1,R3,B2,D2,0x2F)
 747 /* LOAD PSW */
 748 #  define LPSW(D2,B2)                   SI_(0x82,0,B2,D2)
 749 /* LOAD PSW EXTENDED */
 750 #  define LPSWE(D2,B2)                  S_(0xB2B2,B2,D2)
 751 /* LOAD REAL ADDRESS */
 752 #  define LRA(R1,D2,X2,B2)              RX_(0xB1,R1,X2,B2,D2)
 753 #  define LRAY(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x13)
 754 #  define LRAG(R1,D2,X2,B2)             RXY_(0xE3,R1,X2,B2,D2,0x03)
 755 /* LOAD USING REAL ADDRESS */
 756 #  define LURA(R1,R2)                   RRE_(0xB24B,R1,R2)
 757 #  define LURAG(R1,R2)                  RRE_(0xB905,R1,R2)
 758 /* MODIFY STACKED STATE */
 759 #  define MSTA(R1)                      RRE_(0xB247,R1,0)
 760 /* MOVE PAGE */
 761 #  define MVPG(R1,R2)                   RRE_(0xB254,R1,R2)
 762 /* MOVE TO PRIMARY */
 763 #  define MVCP(D1,R1,B1,D2,B2,R3)       SS_(0xDA,R1,R3,B1,D1,B2,D2)
 764 /* MOVE TO SECONDARY */
 765 #  define MVCS(D1,R1,B1,D2,B2,R3)       SS_(0xDB,R1,R3,B1,D1,B2,D2)
 766 /* MOVE WITH DESTINATION KEY */
 767 #  define MVCDK(D1,B1,D2,B2)            SSE_(0xE50F,B1,D1,B2,D2)
 768 /* MOVE WITH KEY */
 769 #  define MVCK(D1,R1,B1,D2,B2,R3)       SS_(0xD9,R1,R3,B1,D1,B2,D2)
 770 /* MOVE WITH SOURCE KEY */
 771 #  define MVCSK(D1,B1,D2,B2)            SSE_(0xE50E,B1,D1,B2,D2)
 772 /* PAGE IN */
 773 #  define PGIN(R1,R2)                   RRE_(0xB22E,R1,R2)
 774 /* PAGE OUT */
 775 #  define PGOUT(R1,R2)                  RRE_(0xB22F,R1,R2)
 776 /* PROGRAM CALL */
 777 #  define PC(D2,B2)                     S_(0xB218,B2,D2)
 778 /* PROGRAM RETURN */
 779 #  define PR()                          E_(0x0101)
 780 /* PROGRAM TRANSFER */
 781 #  define PT(R1,R2)                     RRE_(0xB228,R1,R2)
 782 /* PURGE ALB */
 783 #  define PALB()                        RRE_(0xB248,0,0)
 784 /* PURGE TLB */
 785 #  define PTLB()                        S_(0xB20D,0,0)
 786 /* RESET REFERENCE BIT EXTENDED */
 787 #  define RRBE(R1,R2)                   RRE_(0xB22A,R1,R2)
 788 /* RESUME PROGRAM */
 789 #  define RP(D2,B2)                     S_(0xB277,B2,D2)
 790 /* SET ADDRESS SPACE CONTROL */
 791 #  define SAC(D2,B2)                    S_(0xB219,B2,D2)
 792 /* SET ADDRESS SPACE CONTROL FAST */
 793 #  define SACF(D2,B2)                   S_(0xB279,B2,D2)
 794 /* SET CLOCK */
 795 #  define SCK(D2,B2)                    S_(0xB204,B2,D2)
 796 /* SET CLOCK COMPARATOR */
 797 #  define SCKC(D2,B2)                   S_(0xB206,B2,D2)
 798 /* SET CLOCK PROGRAMMABLE FIELD */
 799 #  define SCKPF()                       E_(0x0107)
 800 /* SET CPU TIMER */
 801 #  define SPT(D2,B2)                    S_(0xB208,B2,D2)
 802 /* SET PREFIX */
 803 #  define SPX(D2,B2)                    S_(0xB210,B2,D2)
 804 /* SET PSW FROM ADDRESS */
 805 #  define SPKA(D2,B2)                   S_(0xB20A,B2,D2)
 806 /* SET SECONDARY ASN */
 807 #  define SSAR(R1)                      RRE_(0xB225,R1,0)
 808 /* SET STORAGE KEY EXTENDED */
 809 #  define SSKE(R1,R2)                   RRE_(0xB22B,R1,R2)
 810 /* SET SYSTEM MASK */
 811 #  define SSM(D2,B2)                    SI_(0x80,0,B2,D2)
 812 /* SIGNAL PROCESSOR */
 813 #  define SIGP(R1,R3,D2,B2)             RS_(0xAE,R1,R3,B2,D2)
 814 /* STORE CLOCK COMPARATOR */
 815 #  define STCKC(D2,B2)                  S_(0xB207,B2,D2)
 816 /* STORE CONTROL */
 817 #  define STCTL(R1,R3,D2,B2)            RS_(0xB6,R1,R3,B2,D2)
 818 #  define STCTG(R1,R3,D2,B2)            RSY_(0xEB,R1,R3,B2,D2,0x25)
 819 /* STORE CPU ADDRESS */
 820 #  define STAP(D2,B2)                   S_(0xB212,B2,D2)
 821 /* STORE CPU ID */
 822 #  define STIDP(D2,B2)                  S_(0xB202,B2,D2)
 823 /* STORE CPU TIMER */
 824 #  define STPT(D2,B2)                   S_(0xB209,B2,D2)
 825 /* STORE FACILITY LIST */
 826 #  define STFL(D2,B2)                   S_(0xB2B1,B2,D2)
 827 /* STORE PREFIX */
 828 #  define STPX(D2,B2)                   S_(0xB211,B2,D2)
 829 /* STORE REAL ADDRES */
 830 #  define STRAG(D1,B1,D2,B2)            SSE_(0xE502,B1,D1,B2,D2)
 831 /* STORE SYSTEM INFORMATION */
 832 #  define STSI(D2,B2)                   S_(0xB27D,B2,D2)
 833 /* STORE THEN AND SYSTEM MASK */
 834 #  define STNSM(D1,B1,I2)               SI_(0xAC,I2,B1,D1)
 835 /* STORE THEN OR SYSTEM MASK */
 836 #  define STOSM(D1,B1,I2)               SI_(0xAD,I2,B1,D1)
 837 /* STORE USING REAL ADDRESS */
 838 #  define STURA(R1,R2)                  RRE_(0xB246,R1,R2)
 839 #  define STURG(R1,R2)                  RRE_(0xB925,R1,R2)
 840 /* TEST ACCESS */
 841 #  define TAR(R1,R2)                    RRE_(0xB24C,R1,R2)
 842 /* TEST BLOCK */
 843 #  define TB(R1,R2)                     RRE_(0xB22C,R1,R2)
 844 /* TEST PROTECTION */
 845 #  define TPROT(D1,B1,D2,B2)            SSE_(0xE501,B1,D1,B2,D2)
 846 /* TRACE */
 847 #  define TRACE(R1,R3,D2,B2)            RS_(0x99,R1,R3,B2,D2)
 848 #  define TRACG(R1,R3,D2,B2)            RSY_(0xEB,R1,R3,B2,D2,0x0F)
 849 /* TRAP */
 850 #  define TRAP2()                       E_(0x01FF)
 851 #  define TRAP4(D2,B2)                  S_(0xB2FF,B2,D2)
 852 /****************************************************************
 853  * I/O Instructions                                             *
 854  ****************************************************************/
 855 /* CANCEL SUBCHANNEL */
 856 #  define XSCH()                        S_(0xB276,0,0)
 857 /* CLEAR SUBCHANNEL */
 858 #  define CSCH()                        S_(0xB230,0,0)
 859 /* HALT SUBCHANNEL */
 860 #  define HSCH()                        S_(0xB231,0,0)
 861 /* MODIFY SUBCHANNEL */
 862 #  define MSCH(D2,B2)                   S_(0xB232,B2,D2)
 863 /* RESET CHANNEL PATH */
 864 #  define RCHP()                        S_(0xB23B,0,0)
 865 /* RESUME SUBCHANNEL */
 866 #  define RSCH()                        S_(0xB238,0,0)
 867 /* SET ADDRESS LIMIT */
 868 #  define SAL()                         S_(0xB237,0,0)
 869 /* SET CHANNEL MONITOR */
 870 #  define SCHM()                        S_(0xB23C,0,0)
 871 /* START SUBCHANNEL */
 872 #  define SSCH(D2,B2)                   S_(0xB233,B2,D2)
 873 /* STORE CHANNEL PATH STATUS */
 874 #  define STCPS(D2,B2)                  S_(0xB23A,B2,D2)
 875 /* STORE CHANNEL REPORT WORD */
 876 #  define STCRW(D2,B2)                  S_(0xB239,B2,D2)
 877 /* STORE SUBCHANNEL */
 878 #  define STSCH(D2,B2)                  S_(0xB234,B2,D2)
 879 /* TEST PENDING INTERRUPTION */
 880 #  define TPI(D2,B2)                    S_(0xB236,B2,D2)
 881 /* TEST SUBCHANNEL */
 882 #  define TSCH(D2,B2)                   S_(0xB235,B2,D2)
 883 #  define xdivr(r0,r1)                  _xdivr(_jit,r0,r1)
 884 static jit_int32_t _xdivr(jit_state_t*,jit_int32_t,jit_int32_t);
 885 #  define xdivr_u(r0,r1)                _xdivr_u(_jit,r0,r1)
 886 static jit_int32_t _xdivr_u(jit_state_t*,jit_int32_t,jit_int32_t);
 887 #  define xdivi(r0,i0)                  _xdivi(_jit,r0,i0)
 888 static jit_int32_t _xdivi(jit_state_t*,jit_int32_t,jit_word_t);
 889 #  define xdivi_u(r0,i0)                _xdivi_u(_jit,r0,i0)
 890 static jit_int32_t _xdivi_u(jit_state_t*,jit_int32_t,jit_word_t);
 891 #  define crr(cc,r0,r1,r2)              _crr(_jit,cc,r0,r1,r2)
 892 static void _crr(jit_state_t*,
 893                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 894 #  define cri(cc,r0,r1,i0)              _cri(_jit,cc,r0,r1,i0)
 895 static void _cri(jit_state_t*,
 896                  jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 897 #  define crr_u(cc,r0,r1,r2)            _crr_u(_jit,cc,r0,r1,r2)
 898 static void _crr_u(jit_state_t*,
 899                    jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 900 #  define cri_u(cc,r0,r1,i0)            _cri_u(_jit,cc,r0,r1,i0)
 901 static void _cri_u(jit_state_t*,
 902                    jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 903 #  define brr(cc,i0,r0,r1)              _brr(_jit,cc,i0,r0,r1)
 904 static void _brr(jit_state_t*,jit_int32_t,
 905                  jit_word_t,jit_int32_t,jit_int32_t);
 906 #  define brr_p(cc,i0,r0,r1)            _brr_p(_jit,cc,i0,r0,r1)
 907 static jit_word_t _brr_p(jit_state_t*,jit_int32_t,
 908                          jit_word_t,jit_int32_t,jit_int32_t);
 909 #  define bri(cc,i0,r0,i1)              _bri(_jit,cc,i0,r0,i1)
 910 static void _bri(jit_state_t*,jit_int32_t,
 911                  jit_word_t,jit_int32_t,jit_word_t);
 912 #  define bri_p(cc,i0,r0,i1)            _bri_p(_jit,cc,i0,r0,i1)
 913 static jit_word_t _bri_p(jit_state_t*,jit_int32_t,
 914                          jit_word_t,jit_int32_t,jit_word_t);
 915 #  define brr_u(cc,i0,r0,r1)            _brr_u(_jit,cc,i0,r0,r1)
 916 static void _brr_u(jit_state_t*,jit_int32_t,
 917                    jit_word_t,jit_int32_t,jit_int32_t);
 918 #  define brr_u_p(cc,i0,r0,r1)          _brr_u_p(_jit,cc,i0,r0,r1)
 919 static jit_word_t _brr_u_p(jit_state_t*,jit_int32_t,
 920                            jit_word_t,jit_int32_t,jit_int32_t);
 921 #  define bri_u(cc,i0,r0,i1)            _bri_u(_jit,cc,i0,r0,i1)
 922 static void _bri_u(jit_state_t*,jit_int32_t,
 923                    jit_word_t,jit_int32_t,jit_word_t);
 924 #  define bri_u_p(cc,i0,r0,i1)          _bri_u_p(_jit,cc,i0,r0,i1)
 925 static jit_word_t _bri_u_p(jit_state_t*,jit_int32_t,
 926                            jit_word_t,jit_int32_t,jit_word_t);
 927 #  define baddr(c,s,i0,r0,r1)           _baddr(_jit,c,s,i0,r0,r1)
 928 static void _baddr(jit_state_t*,jit_int32_t,jit_bool_t,
 929                    jit_word_t,jit_int32_t,jit_int32_t);
 930 #  define baddr_p(c,s,i0,r0,r1)         _baddr_p(_jit,c,s,i0,r0,r1)
 931 static jit_word_t _baddr_p(jit_state_t*,jit_int32_t,jit_bool_t,
 932                            jit_word_t,jit_int32_t,jit_int32_t);
 933 #  define baddi(c,s,i0,r0,i1)           _baddi(_jit,c,s,i0,r0,i1)
 934 static void _baddi(jit_state_t*,jit_int32_t,jit_bool_t,
 935                    jit_word_t,jit_int32_t,jit_word_t);
 936 #  define baddi_p(c,s,i0,r0,i1)         _baddi_p(_jit,c,s,i0,r0,i1)
 937 static jit_word_t _baddi_p(jit_state_t*,jit_int32_t,jit_bool_t,
 938                            jit_word_t,jit_int32_t,jit_word_t);
 939 #  define bsubr(c,s,i0,r0,r1)           _bsubr(_jit,c,s,i0,r0,r1)
 940 static void _bsubr(jit_state_t*,jit_int32_t,jit_bool_t,
 941                    jit_word_t,jit_int32_t,jit_int32_t);
 942 #  define bsubr_p(c,s,i0,r0,r1)         _bsubr_p(_jit,c,s,i0,r0,r1)
 943 static jit_word_t _bsubr_p(jit_state_t*,jit_int32_t,jit_bool_t,
 944                            jit_word_t,jit_int32_t,jit_int32_t);
 945 #  define bsubi(c,s,i0,r0,i1)           _bsubi(_jit,c,s,i0,r0,i1)
 946 static void _bsubi(jit_state_t*,jit_int32_t,jit_bool_t,
 947                    jit_word_t,jit_int32_t,jit_word_t);
 948 #  define bsubi_p(c,s,i0,r0,i1)         _bsubi_p(_jit,c,s,i0,r0,i1)
 949 static jit_word_t _bsubi_p(jit_state_t*,jit_int32_t,jit_bool_t,
 950                            jit_word_t,jit_int32_t,jit_word_t);
 951 #  define bmxr(cc,i0,r0,r1)             _bmxr(_jit,cc,i0,r0,r1)
 952 static void _bmxr(jit_state_t*,jit_int32_t,
 953                   jit_word_t,jit_int32_t,jit_int32_t);
 954 #  define bmxr_p(cc,i0,r0,r1)           _bmxr_p(_jit,cc,i0,r0,r1)
 955 static jit_word_t _bmxr_p(jit_state_t*,jit_int32_t,
 956                           jit_word_t,jit_int32_t,jit_int32_t);
 957 #  define bmxi(cc,i0,r0,i1)             _bmxi(_jit,cc,i0,r0,i1)
 958 static void _bmxi(jit_state_t*,jit_int32_t,
 959                   jit_word_t,jit_int32_t,jit_word_t);
 960 #  define bmxi_p(cc,i0,r0,i1)           _bmxi_p(_jit,cc,i0,r0,i1)
 961 static jit_word_t _bmxi_p(jit_state_t*,jit_int32_t,
 962                           jit_word_t,jit_int32_t,jit_word_t);
 963 #  define movr(r0,r1)                   _movr(_jit,r0,r1)
 964 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
 965 #  define movi(r0,i0)                   _movi(_jit,r0,i0)
 966 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
 967 #  define movi_p(r0,i0)                 _movi_p(_jit,r0,i0)
 968 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
 969 #  define bswapr_us(r0, r1)             generic_bswapr_us(_jit, r0, r1)
 970 #  define bswapr_ui(r0, r1)             generic_bswapr_ui(_jit, r0, r1)
 971 #  define bswapr_ul(r0, r1)             generic_bswapr_ul(_jit, r0, r1)
 972 #  define movnr(r0,r1,r2)               _movnr(_jit,r0,r1,r2)
 973 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 974 #  define movzr(r0,r1,r2)               _movzr(_jit,r0,r1,r2)
 975 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 976 #  define addr(r0,r1,r2)                _addr(_jit,r0,r1,r2)
 977 static void _addr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 978 #  define addi(r0,r1,i0)                _addi(_jit,r0,r1,i0)
 979 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 980 #  define addcr(r0,r1,r2)               _addcr(_jit,r0,r1,r2)
 981 static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 982 #  define addci(r0,r1,i0)               _addci(_jit,r0,r1,i0)
 983 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 984 #  define addxr(r0,r1,r2)               _addxr(_jit,r0,r1,r2)
 985 static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 986 #  define addxi(r0,r1,i0)               _addxi(_jit,r0,r1,i0)
 987 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 988 #  define subr(r0,r1,r2)                _subr(_jit,r0,r1,r2)
 989 static void _subr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 990 #  define subi(r0,r1,i0)                _subi(_jit,r0,r1,i0)
 991 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 992 #  define subcr(r0,r1,r2)               _subcr(_jit,r0,r1,r2)
 993 static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 994 #  define subci(r0,r1,i0)               _subci(_jit,r0,r1,i0)
 995 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 996 #  define subxr(r0,r1,r2)               _subxr(_jit,r0,r1,r2)
 997 static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 998 #  define subxi(r0,r1,i0)               _subxi(_jit,r0,r1,i0)
 999 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1000 #  define rsbi(r0, r1, i0)              _rsbi(_jit, r0, r1, i0)
1001 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1002 #  define mulr(r0,r1,r2)                _mulr(_jit,r0,r1,r2)
1003 static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1004 #  define muli(r0,r1,i0)                _muli(_jit,r0,r1,i0)
1005 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1006 #  define qmulr(r0,r1,r2,r3)            _qmulr(_jit,r0,r1,r2,r3)
1007 static void _qmulr(jit_state_t*,jit_int32_t,
1008                    jit_int32_t,jit_int32_t,jit_int32_t);
1009 #  define qmuli(r0,r1,r2,i0)            _qmuli(_jit,r0,r1,r2,i0)
1010 static void _qmuli(jit_state_t*,jit_int32_t,
1011                    jit_int32_t,jit_int32_t,jit_word_t);
1012 #  define qmulr_u(r0,r1,r2,r3)          _qmulr_u(_jit,r0,r1,r2,r3)
1013 static void _qmulr_u(jit_state_t*,jit_int32_t,
1014                      jit_int32_t,jit_int32_t,jit_int32_t);
1015 #  define qmuli_u(r0,r1,r2,i0)          _qmuli_u(_jit,r0,r1,r2,i0)
1016 static void _qmuli_u(jit_state_t*,jit_int32_t,
1017                      jit_int32_t,jit_int32_t,jit_word_t);
1018 #  define divr(r0,r1,r2)                _divr(_jit,r0,r1,r2)
1019 static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1020 #  define divi(r0,r1,i0)                _divi(_jit,r0,r1,i0)
1021 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1022 #  define divr_u(r0,r1,r2)              _divr_u(_jit,r0,r1,r2)
1023 static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1024 #  define divi_u(r0,r1,i0)              _divi_u(_jit,r0,r1,i0)
1025 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1026 #  define remr(r0,r1,r2)                _remr(_jit,r0,r1,r2)
1027 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1028 #  define remi(r0,r1,i0)                _remi(_jit,r0,r1,i0)
1029 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1030 #  define remr_u(r0,r1,r2)              _remr_u(_jit,r0,r1,r2)
1031 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1032 #  define remi_u(r0,r1,i0)              _remi_u(_jit,r0,r1,i0)
1033 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1034 #  define qdivr(r0,r1,r2,r3)            _qdivr(_jit,r0,r1,r2,r3)
1035 static void _qdivr(jit_state_t*,jit_int32_t,
1036                    jit_int32_t,jit_int32_t,jit_int32_t);
1037 #  define qdivi(r0,r1,r2,i0)            _qdivi(_jit,r0,r1,r2,i0)
1038 static void _qdivi(jit_state_t*,jit_int32_t,
1039                    jit_int32_t,jit_int32_t,jit_word_t);
1040 #  define qdivr_u(r0,r1,r2,r3)          _qdivr_u(_jit,r0,r1,r2,r3)
1041 static void _qdivr_u(jit_state_t*,jit_int32_t,
1042                      jit_int32_t,jit_int32_t,jit_int32_t);
1043 #  define qdivi_u(r0,r1,r2,i0)          _qdivi_u(_jit,r0,r1,r2,i0)
1044 static void _qdivi_u(jit_state_t*,jit_int32_t,
1045                      jit_int32_t,jit_int32_t,jit_word_t);
1046 #  if __WORDSIZE == 32
1047 #    define lshr(r0,r1,r2)              _lshr(_jit,r0,r1,r2)
1048 static void _lshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1049 #  else
1050 #    define lshr(r0,r1,r2)              SLLG(r0,r1,0,r2)
1051 #  endif
1052 #  define lshi(r0,r1,i0)                _lshi(_jit,r0,r1,i0)
1053 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1054 #  if __WORDSIZE == 32
1055 #    define rshr(r0,r1,r2)              _rshr(_jit,r0,r1,r2)
1056 static void _rshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1057 #  else
1058 #    define rshr(r0,r1,r2)              SRAG(r0,r1,0,r2)
1059 #  endif
1060 #  define rshi(r0,r1,i0)                _rshi(_jit,r0,r1,i0)
1061 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1062 #  if __WORDSIZE == 32
1063 #    define rshr_u(r0,r1,r2)            _rshr_u(_jit,r0,r1,r2)
1064 static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1065 #  else
1066 #    define rshr_u(r0,r1,r2)            SRLG(r0,r1,0,r2)
1067 #  endif
1068 #  define rshi_u(r0,r1,i0)              _rshi_u(_jit,r0,r1,i0)
1069 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1070 #  if __WORDSIZE == 32
1071 #    define negr(r0,r1)                 LCR(r0,r1)
1072 #  else
1073 #    define negr(r0,r1)                 LCGR(r0,r1)
1074 #  endif
1075 #  define comr(r0,r1)                   _comr(_jit,r0,r1)
1076 static void _comr(jit_state_t*,jit_int32_t,jit_int32_t);
1077 #  define andr(r0,r1,r2)                _andr(_jit,r0,r1,r2)
1078 static void _andr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1079 #  define andi(r0,r1,i0)                _andi(_jit,r0,r1,i0)
1080 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1081 #  define orr(r0,r1,r2)                 _orr(_jit,r0,r1,r2)
1082 static void _orr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1083 #  define ori(r0,r1,i0)                 _ori(_jit,r0,r1,i0)
1084 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1085 #  define xorr(r0,r1,r2)                _xorr(_jit,r0,r1,r2)
1086 static void _xorr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1087 #  define xori(r0,r1,i0)                _xori(_jit,r0,r1,i0)
1088 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1089 #  define extr_c(r0,r1)                 LGBR(r0,r1)
1090 #  define extr_uc(r0,r1)                LLGCR(r0,r1)
1091 #  define extr_s(r0,r1)                 LGHR(r0,r1)
1092 #  define extr_us(r0,r1)                LLGHR(r0,r1)
1093 #  if __WORDSIZE == 64
1094 #    define extr_i(r0,r1)               LGFR(r0,r1)
1095 #    define extr_ui(r0,r1)              LLGFR(r0,r1)
1096 #  endif
1097 #  define ldr_c(r0,r1)                  LGB(r0,0,0,r1)
1098 #  define ldi_c(r0,i0)                  _ldi_c(_jit,r0,i0)
1099 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
1100 #  define ldxr_c(r0,r1,r2)              _ldxr_c(_jit,r0,r1,r2)
1101 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1102 #  define ldxi_c(r0,r1,i0)              _ldxi_c(_jit,r0,r1,i0)
1103 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1104 #  define ldr_uc(r0,r1)                 LLGC(r0,0,0,r1)
1105 #  define ldi_uc(r0,i0)                 _ldi_uc(_jit,r0,i0)
1106 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
1107 #  define ldxr_uc(r0,r1,r2)             _ldxr_uc(_jit,r0,r1,r2)
1108 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1109 #  define ldxi_uc(r0,r1,i0)             _ldxi_uc(_jit,r0,r1,i0)
1110 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1111 #  if __WORDSIZE == 32
1112 #    define ldr_s(r0,r1)                LH(r0,0,0,r1)
1113 #  else
1114 #    define ldr_s(r0,r1)                LGH(r0,0,0,r1)
1115 #  endif
1116 #  define ldi_s(r0,i0)                  _ldi_s(_jit,r0,i0)
1117 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
1118 #  define ldxr_s(r0,r1,r2)              _ldxr_s(_jit,r0,r1,r2)
1119 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1120 #  define ldxi_s(r0,r1,i0)              _ldxi_s(_jit,r0,r1,i0)
1121 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1122 #  define ldr_us(r0,r1)                 LLGH(r0,0,0,r1)
1123 #  define ldi_us(r0,i0)                 _ldi_us(_jit,r0,i0)
1124 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
1125 #  define ldxr_us(r0,r1,r2)             _ldxr_us(_jit,r0,r1,r2)
1126 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1127 #  define ldxi_us(r0,r1,i0)             _ldxi_us(_jit,r0,r1,i0)
1128 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1129 #  if __WORDSIZE == 32
1130 #    define ldr_i(r0,r1)                LLGF(r0,0,0,r1)
1131 #  else
1132 #    define ldr_i(r0,r1)                LGF(r0,0,0,r1)
1133 #  endif
1134 #  define ldi_i(r0,i0)                  _ldi_i(_jit,r0,i0)
1135 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
1136 #  define ldxr_i(r0,r1,r2)              _ldxr_i(_jit,r0,r1,r2)
1137 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1138 #  define ldxi_i(r0,r1,i0)              _ldxi_i(_jit,r0,r1,i0)
1139 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1140 #  if __WORDSIZE == 64
1141 #    define ldr_ui(r0,r1)               LLGF(r0,0,0,r1)
1142 #    define ldi_ui(r0,i0)               _ldi_ui(_jit,r0,i0)
1143 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
1144 #    define ldxr_ui(r0,r1,r2)           _ldxr_ui(_jit,r0,r1,r2)
1145 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1146 #    define ldxi_ui(r0,r1,i0)           _ldxi_ui(_jit,r0,r1,i0)
1147 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1148 #    define ldr_l(r0,r1)                LG(r0,0,0,r1)
1149 #    define ldi_l(r0,i0)                _ldi_l(_jit,r0,i0)
1150 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
1151 #    define ldxr_l(r0,r1,r2)            _ldxr_l(_jit,r0,r1,r2)
1152 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1153 #    define ldxi_l(r0,r1,i0)            _ldxi_l(_jit,r0,r1,i0)
1154 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1155 #  endif
1156 #  define str_c(r0,r1)                  STC(r1,0,0,r0)
1157 #  define sti_c(i0,r0)                  _sti_c(_jit,i0,r0)
1158 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
1159 #  define stxr_c(r0,r1,r2)              _stxr_c(_jit,r0,r1,r2)
1160 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1161 #  define stxi_c(i0,r0,r1)              _stxi_c(_jit,i0,r0,r1)
1162 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1163 #  define str_s(r0,r1)                  STH(r1,0,0,r0)
1164 #  define sti_s(i0,r0)                  _sti_s(_jit,i0,r0)
1165 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
1166 #  define stxr_s(r0,r1,r2)              _stxr_s(_jit,r0,r1,r2)
1167 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1168 #  define stxi_s(i0,r0,r1)              _stxi_s(_jit,i0,r0,r1)
1169 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1170 #  define str_i(r0,r1)                  ST(r1,0,0,r0)
1171 #  define sti_i(i0,r0)                  _sti_i(_jit,i0,r0)
1172 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
1173 #  define stxr_i(r0,r1,r2)              _stxr_i(_jit,r0,r1,r2)
1174 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1175 #  define stxi_i(i0,r0,r1)              _stxi_i(_jit,i0,r0,r1)
1176 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1177 #  if __WORDSIZE == 64
1178 #    define str_l(r0,r1)                STG(r1,0,0,r0)
1179 #    define sti_l(i0,r0)                _sti_l(_jit,i0,r0)
1180 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
1181 #  define stxr_l(r0,r1,r2)              _stxr_l(_jit,r0,r1,r2)
1182 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1183 #  define stxi_l(i0,r0,r1)              _stxi_l(_jit,i0,r0,r1)
1184 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1185 #  endif
1186 #  define ltr(r0,r1,r2)                 crr(CC_L,r0,r1,r2)
1187 #  define lti(r0,r1,i0)                 cri(CC_L,r0,r1,i0)
1188 #  define ltr_u(r0,r1,r2)               crr_u(CC_L,r0,r1,r2)
1189 #  define lti_u(r0,r1,i0)               cri_u(CC_L,r0,r1,i0)
1190 #  define ler(r0,r1,r2)                 crr(CC_LE,r0,r1,r2)
1191 #  define lei(r0,r1,i0)                 cri(CC_LE,r0,r1,i0)
1192 #  define ler_u(r0,r1,r2)               crr_u(CC_LE,r0,r1,r2)
1193 #  define lei_u(r0,r1,i0)               cri_u(CC_LE,r0,r1,i0)
1194 #  define eqr(r0,r1,r2)                 crr(CC_E,r0,r1,r2)
1195 #  define eqi(r0,r1,i0)                 cri(CC_E,r0,r1,i0)
1196 #  define ger(r0,r1,r2)                 crr(CC_HE,r0,r1,r2)
1197 #  define gei(r0,r1,i0)                 cri(CC_HE,r0,r1,i0)
1198 #  define ger_u(r0,r1,r2)               crr_u(CC_HE,r0,r1,r2)
1199 #  define gei_u(r0,r1,i0)               cri_u(CC_HE,r0,r1,i0)
1200 #  define gtr(r0,r1,r2)                 crr(CC_H,r0,r1,r2)
1201 #  define gti(r0,r1,i0)                 cri(CC_H,r0,r1,i0)
1202 #  define gtr_u(r0,r1,r2)               crr_u(CC_H,r0,r1,r2)
1203 #  define gti_u(r0,r1,i0)               cri_u(CC_H,r0,r1,i0)
1204 #  define ner(r0,r1,r2)                 crr(CC_NE,r0,r1,r2)
1205 #  define nei(r0,r1,i0)                 cri(CC_NE,r0,r1,i0)
1206 #  define bltr(i0,r0,r1)                brr(CC_L,i0,r0,r1)
1207 #  define bltr_p(i0,r0,r1)              brr_p(CC_L,i0,r0,r1)
1208 #  define blti(i0,r0,i1)                bri(CC_L,i0,r0,i1)
1209 #  define blti_p(i0,r0,i1)              bri_p(CC_L,i0,r0,i1)
1210 #  define bltr_u(i0,r0,r1)              brr_u(CC_L,i0,r0,r1)
1211 #  define bltr_u_p(i0,r0,r1)            brr_u_p(CC_L,i0,r0,r1)
1212 #  define blti_u(i0,r0,i1)              bri_u(CC_L,i0,r0,i1)
1213 #  define blti_u_p(i0,r0,i1)            bri_u_p(CC_L,i0,r0,i1)
1214 #  define bler(i0,r0,r1)                brr(CC_LE,i0,r0,r1)
1215 #  define bler_p(i0,r0,r1)              brr_p(CC_LE,i0,r0,r1)
1216 #  define blei(i0,r0,i1)                bri(CC_LE,i0,r0,i1)
1217 #  define blei_p(i0,r0,i1)              bri_p(CC_LE,i0,r0,i1)
1218 #  define bler_u(i0,r0,r1)              brr_u(CC_LE,i0,r0,r1)
1219 #  define bler_u_p(i0,r0,r1)            brr_u_p(CC_LE,i0,r0,r1)
1220 #  define blei_u(i0,r0,i1)              bri_u(CC_LE,i0,r0,i1)
1221 #  define blei_u_p(i0,r0,i1)            bri_u_p(CC_LE,i0,r0,i1)
1222 #  define beqr(i0,r0,r1)                brr(CC_E,i0,r0,r1)
1223 #  define beqr_p(i0,r0,r1)              brr_p(CC_E,i0,r0,r1)
1224 #  define beqi(i0,r0,i1)                bri(CC_E,i0,r0,i1)
1225 #  define beqi_p(i0,r0,i1)              bri_p(CC_E,i0,r0,i1)
1226 #  define bger(i0,r0,r1)                brr(CC_HE,i0,r0,r1)
1227 #  define bger_p(i0,r0,r1)              brr_p(CC_HE,i0,r0,r1)
1228 #  define bgei(i0,r0,i1)                bri(CC_HE,i0,r0,i1)
1229 #  define bgei_p(i0,r0,i1)              bri_p(CC_HE,i0,r0,i1)
1230 #  define bger_u(i0,r0,r1)              brr_u(CC_HE,i0,r0,r1)
1231 #  define bger_u_p(i0,r0,r1)            brr_u_p(CC_HE,i0,r0,r1)
1232 #  define bgei_u(i0,r0,i1)              bri_u(CC_HE,i0,r0,i1)
1233 #  define bgei_u_p(i0,r0,i1)            bri_u_p(CC_HE,i0,r0,i1)
1234 #  define bgtr(i0,r0,r1)                brr(CC_H,i0,r0,r1)
1235 #  define bgtr_p(i0,r0,r1)              brr_p(CC_H,i0,r0,r1)
1236 #  define bgti(i0,r0,i1)                bri(CC_H,i0,r0,i1)
1237 #  define bgti_p(i0,r0,i1)              bri_p(CC_H,i0,r0,i1)
1238 #  define bgtr_u(i0,r0,r1)              brr_u(CC_H,i0,r0,r1)
1239 #  define bgtr_u_p(i0,r0,r1)            brr_u_p(CC_H,i0,r0,r1)
1240 #  define bgti_u(i0,r0,i1)              bri_u(CC_H,i0,r0,i1)
1241 #  define bgti_u_p(i0,r0,i1)            bri_u_p(CC_H,i0,r0,i1)
1242 #  define bner(i0,r0,r1)                brr(CC_NE,i0,r0,r1)
1243 #  define bner_p(i0,r0,r1)              brr_p(CC_NE,i0,r0,r1)
1244 #  define bnei(i0,r0,i1)                bri(CC_NE,i0,r0,i1)
1245 #  define bnei_p(i0,r0,i1)              bri_p(CC_NE,i0,r0,i1)
1246 #  define boaddr(i0,r0,r1)              baddr(CC_O,1,i0,r0,r1)
1247 #  define boaddr_p(i0,r0,r1)            baddr_p(CC_O,1,i0,r0,r1)
1248 #  define boaddi(i0,r0,i1)              baddi(CC_O,1,i0,r0,i1)
1249 #  define boaddi_p(i0,r0,i1)            baddi_p(CC_O,1,i0,r0,i1)
1250 #  define boaddr_u(i0,r0,r1)            baddr(CC_NLE,0,i0,r0,r1)
1251 #  define boaddr_u_p(i0,r0,r1)          baddr_p(CC_NLE,0,i0,r0,r1)
1252 #  define boaddi_u(i0,r0,i1)            baddi(CC_NLE,0,i0,r0,i1)
1253 #  define boaddi_u_p(i0,r0,i1)          baddi_p(CC_NLE,0,i0,r0,i1)
1254 #  define bxaddr(i0,r0,r1)              baddr(CC_NO,1,i0,r0,r1)
1255 #  define bxaddr_p(i0,r0,r1)            baddr_p(CC_NO,1,i0,r0,r1)
1256 #  define bxaddi(i0,r0,i1)              baddi(CC_NO,1,i0,r0,i1)
1257 #  define bxaddi_p(i0,r0,i1)            baddi_p(CC_NO,1,i0,r0,i1)
1258 #  define bxaddr_u(i0,r0,r1)            baddr(CC_LE,0,i0,r0,r1)
1259 #  define bxaddr_u_p(i0,r0,r1)          baddr_p(CC_LE,0,i0,r0,r1)
1260 #  define bxaddi_u(i0,r0,i1)            baddi(CC_LE,0,i0,r0,i1)
1261 #  define bxaddi_u_p(i0,r0,i1)          baddi_p(CC_LE,0,i0,r0,i1)
1262 #  define bosubr(i0,r0,r1)              bsubr(CC_O,1,i0,r0,r1)
1263 #  define bosubr_p(i0,r0,r1)            bsubr_p(CC_O,1,i0,r0,r1)
1264 #  define bosubi(i0,r0,i1)              bsubi(CC_O,1,i0,r0,i1)
1265 #  define bosubi_p(i0,r0,i1)            bsubi_p(CC_O,1,i0,r0,i1)
1266 #  define bosubr_u(i0,r0,r1)            bsubr(CC_L,0,i0,r0,r1)
1267 #  define bosubr_u_p(i0,r0,r1)          bsubr_p(CC_L,0,i0,r0,r1)
1268 #  define bosubi_u(i0,r0,i1)            bsubi(CC_L,0,i0,r0,i1)
1269 #  define bosubi_u_p(i0,r0,i1)          bsubi_p(CC_L,0,i0,r0,i1)
1270 #  define bxsubr(i0,r0,r1)              bsubr(CC_NO,1,i0,r0,r1)
1271 #  define bxsubr_p(i0,r0,r1)            bsubr_p(CC_NO,1,i0,r0,r1)
1272 #  define bxsubi(i0,r0,i1)              bsubi(CC_NO,1,i0,r0,i1)
1273 #  define bxsubi_p(i0,r0,i1)            bsubi_p(CC_NO,1,i0,r0,i1)
1274 #  define bxsubr_u(i0,r0,r1)            bsubr(CC_NL,0,i0,r0,r1)
1275 #  define bxsubr_u_p(i0,r0,r1)          bsubr_p(CC_NL,0,i0,r0,r1)
1276 #  define bxsubi_u(i0,r0,i1)            bsubi(CC_NL,0,i0,r0,i1)
1277 #  define bxsubi_u_p(i0,r0,i1)          bsubi_p(CC_NL,0,i0,r0,i1)
1278 #  define bmsr(i0,r0,r1)                bmxr(CC_NE,i0,r0,r1)
1279 #  define bmsr_p(i0,r0,r1)              bmxr_p(CC_NE,i0,r0,r1)
1280 #  define bmsi(i0,r0,i1)                bmxi(CC_NE,i0,r0,i1)
1281 #  define bmsi_p(i0,r0,i1)              bmxi_p(CC_NE,i0,r0,i1)
1282 #  define bmcr(i0,r0,r1)                bmxr(CC_E,i0,r0,r1)
1283 #  define bmcr_p(i0,r0,r1)              bmxr_p(CC_E,i0,r0,r1)
1284 #  define bmci(i0,r0,i1)                bmxi(CC_E,i0,r0,i1)
1285 #  define bmci_p(i0,r0,i1)              bmxi_p(CC_E,i0,r0,i1)
1286 #  define jmpr(r0)                      BR(r0)
1287 #  define jmpi(i0)                      _jmpi(_jit,i0)
1288 static void _jmpi(jit_state_t*,jit_word_t);
1289 #  define jmpi_p(i0)                    _jmpi_p(_jit,i0)
1290 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
1291 #  define callr(r0)                     BALR(_R14_REGNO,r0)
1292 #  define calli(i0)                     _calli(_jit,i0)
1293 static void _calli(jit_state_t*,jit_word_t);
1294 #  define calli_p(i0)                   _calli_p(_jit,i0)
1295 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
1296 #  define prolog(i0)                    _prolog(_jit,i0)
1297 static void _prolog(jit_state_t*,jit_node_t*);
1298 #  define epilog(i0)                    _epilog(_jit,i0)
1299 static void _epilog(jit_state_t*,jit_node_t*);
1300 #  define vastart(r0)                   _vastart(_jit, r0)
1301 static void _vastart(jit_state_t*, jit_int32_t);
1302 #  define vaarg(r0, r1)                 _vaarg(_jit, r0, r1)
1303 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
1304 #  define patch_at(instr,label)         _patch_at(_jit,instr,label)
1305 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
1306 #endif
1307
1308 #if CODE
1309 #  define _us                           jit_uint16_t
1310 #  define _ui                           jit_uint32_t
1311 static void
1312 _E(jit_state_t *_jit, _ui Op)
1313 {
1314     union {
1315         struct {
1316             _us op;
1317         } b;
1318         _us     s;
1319     } i0;
1320     i0.b.op = Op;
1321     assert(i0.b.op == Op);
1322     is(i0.s);
1323 }
1324
1325 static void
1326 _I(jit_state_t *_jit, _ui Op, _ui I)
1327 {
1328     union {
1329         struct {
1330             _us op : 8;
1331             _us i  : 8;
1332         } b;
1333         _us     s;
1334     } i0;
1335     i0.b.op = Op;
1336     i0.b.i  = I;
1337     assert(i0.b.op == Op);
1338     assert(i0.b.i  == I);
1339     is(i0.s);
1340 }
1341
1342 static void
1343 _RR(jit_state_t *_jit, _ui Op, _ui R1, _ui R2)
1344 {
1345     union {
1346         struct {
1347             _us op : 8;
1348             _us r1 : 4;
1349             _us r2 : 4;
1350         } b;
1351         _us     s;
1352     } i0;
1353     i0.b.op = Op;
1354     i0.b.r1 = R1;
1355     i0.b.r2 = R2;
1356     assert(i0.b.op == Op);
1357     assert(i0.b.r1 == R1);
1358     assert(i0.b.r2 == R2);
1359     is(i0.s);
1360 }
1361
1362 static void
1363 _RRE(jit_state_t *_jit, _ui Op, _ui R1, _ui R2)
1364 {
1365     union {
1366         struct {
1367             _us op;
1368         } b;
1369         _us     s;
1370     } i0;
1371     union {
1372         struct {
1373             _us _  : 8;
1374             _us r1 : 4;
1375             _us r2 : 4;
1376         } b;
1377         _us     s;
1378     } i1;
1379     i0.b.op = Op;
1380     i1.b._ = 0;
1381     i1.b.r1 = R1;
1382     i1.b.r2 = R2;
1383     assert(i0.b.op == Op);
1384     assert(i1.b.r1 == R1);
1385     assert(i1.b.r2 == R2);
1386     is(i0.s);
1387     is(i1.s);
1388 }
1389
1390 static void
1391 _RRF(jit_state_t *_jit, _ui Op, _ui R3, _ui M4, _ui R1, _ui R2)
1392 {
1393     union {
1394         struct {
1395             _us op;
1396         } b;
1397         _us     s;
1398     } i0;
1399     union {
1400         struct {
1401             _us r3 : 4;
1402             _us m4 : 4;
1403             _us r1 : 4;
1404             _us r2 : 4;
1405         } b;
1406         _us     s;
1407     } i1;
1408     i0.b.op = Op;
1409     i1.b.r3 = R3;
1410     i1.b.m4 = M4;
1411     i1.b.r1 = R1;
1412     i1.b.r2 = R2;
1413     assert(i0.b.op == Op);
1414     assert(i1.b.r3 == R3);
1415     assert(i1.b.m4 == M4);
1416     assert(i1.b.r1 == R1);
1417     assert(i1.b.r2 == R2);
1418     is(i0.s);
1419     is(i1.s);
1420 }
1421
1422 static void
1423 _RX(jit_state_t *_jit, _ui Op, _ui R1, _ui X2, _ui B2, _ui D2)
1424 {
1425     union {
1426         struct {
1427             _us op :  8;
1428             _us r1 :  4;
1429             _us x2 :  4;
1430         } b;
1431         _us     s;
1432     } i0;
1433     union {
1434         struct {
1435             _us b2 :  4;
1436             _us d2 : 12;
1437         } b;
1438         _us     s;
1439     } i1;
1440     i0.b.op = Op;
1441     i0.b.r1 = R1;
1442     i0.b.x2 = X2;
1443     i1.b.b2 = B2;
1444     i1.b.d2 = D2;
1445     assert(i0.b.op == Op);
1446     assert(i0.b.r1 == R1);
1447     assert(i0.b.x2 == X2);
1448     assert(i1.b.b2 == B2);
1449     assert(i1.b.d2 == D2);
1450     is(i0.s);
1451     is(i1.s);
1452 }
1453
1454 static void
1455 _RXE(jit_state_t *_jit, _ui Op, _ui R1, _ui X2, _ui B2, _ui D2, _ui Op2)
1456 {
1457     union {
1458         struct {
1459             _us op :  8;
1460             _us r1 :  4;
1461             _us x2 :  4;
1462         } b;
1463         _us     s;
1464     } i0;
1465     union {
1466         struct {
1467             _us b2 :  4;
1468             _us d2 : 12;
1469         } b;
1470         _ui     s;
1471     } i1;
1472     union {
1473         struct {
1474             _us _  :  8;
1475             _us op :  8;
1476         } b;
1477         _us     s;
1478     } i2;
1479     i2.b._ = 0;
1480     i0.b.op = Op;
1481     i0.b.r1 = R1;
1482     i0.b.x2 = X2;
1483     i1.b.b2 = B2;
1484     i1.b.d2 = D2;
1485     i2.b.op = Op2;
1486     assert(i0.b.op == Op);
1487     assert(i0.b.r1 == R1);
1488     assert(i0.b.x2 == X2);
1489     assert(i1.b.b2 == B2);
1490     assert(i1.b.d2 == D2);
1491     assert(i2.b.op == Op2);
1492     is(i0.s);
1493     is(i1.s);
1494     is(i2.s);
1495 }
1496
1497 static void
1498 _RXF(jit_state_t *_jit, _ui Op, _ui R3, _ui X2, _ui B2, _ui D2, _ui R1, _ui Op2)
1499 {
1500     union {
1501         struct {
1502             _us op :  8;
1503             _us r3 :  4;
1504             _us x2 :  4;
1505         } b;
1506         _us     s;
1507     } i0;
1508     union {
1509         struct {
1510             _us b2 :  4;
1511             _us d2 : 12;
1512         } b;
1513         _us     s;
1514     } i1;
1515     union {
1516         struct {
1517             _us r1 :  4;
1518             _us _  :  4;
1519             _us op :  8;
1520         } b;
1521         _us     s;
1522     } i2;
1523     i2.b._ = 0;
1524     i0.b.op = Op;
1525     i0.b.r3 = R3;
1526     i0.b.x2 = X2;
1527     i1.b.b2 = B2;
1528     i1.b.d2 = D2;
1529     i2.b.r1 = R1;
1530     i2.b.op = Op2;
1531     assert(i0.b.op == Op);
1532     assert(i0.b.r3 == R3);
1533     assert(i0.b.x2 == X2);
1534     assert(i1.b.b2 == B2);
1535     assert(i1.b.d2 == D2);
1536     assert(i2.b.r1 == R1);
1537     assert(i2.b.op == Op2);
1538     is(i0.s);
1539     is(i1.s);
1540     is(i2.s);
1541 }
1542
1543 static void
1544 _RXY(jit_state_t *_jit, _ui Op, _ui R1, _ui X2, _ui B2, _ui D2, _ui Op2)
1545 {
1546     union {
1547         struct {
1548             _us op :  8;
1549             _us r1 :  4;
1550             _us x2 :  4;
1551         } b;
1552         _us     s;
1553     } i0;
1554     union {
1555         struct {
1556             _us b2 :  4;
1557             _us dl : 12;
1558         } b;
1559         _us     s;
1560     } i1;
1561     union {
1562         struct {
1563             _us dh :  8;
1564             _us op :  8;
1565         } b;
1566         _us     s;
1567     } i2;
1568     i0.s = i1.s = i2.s = 0;
1569     i0.b.op = Op;
1570     i0.b.r1 = R1;
1571     i0.b.x2 = X2;
1572     i1.b.b2 = B2;
1573     i1.b.dl = D2 & 0xfff;
1574     i2.b.dh = D2 >> 12;
1575     i2.b.op = Op2;
1576     assert(i0.b.op == Op);
1577     assert(i0.b.r1 == R1);
1578     assert(i0.b.x2 == X2);
1579     assert(i1.b.b2 == B2);
1580     assert(i2.b.dh == D2 >> 12);
1581     assert(i2.b.op == Op2);
1582     is(i0.s);
1583     is(i1.s);
1584     is(i2.s);
1585 }
1586
1587 static void
1588 _RS(jit_state_t *_jit, _ui Op, _ui R1, _ui R3, _ui B2, _ui D2)
1589 {
1590     union {
1591         struct {
1592             _us op :  8;
1593             _us r1 :  4;
1594             _us r3 :  4;
1595         } b;
1596         _us     s;
1597     } i0;
1598     union {
1599         struct {
1600             _us b2 :  4;
1601             _us d2 : 12;
1602         } b;
1603         _us     s;
1604     } i1;
1605     i0.s = i1.s = 0;
1606     i0.b.op = Op;
1607     i0.b.r1 = R1;
1608     i0.b.r3 = R3;
1609     i1.b.b2 = B2;
1610     i1.b.d2 = D2;
1611     assert(i0.b.op == Op);
1612     assert(i0.b.r1 == R1);
1613     assert(i0.b.r3 == R3);
1614     assert(i1.b.b2 == B2);
1615     assert(i1.b.d2 == D2);
1616     is(i0.s);
1617     is(i1.s);
1618 }
1619
1620 static void
1621 _RSL(jit_state_t *_jit, _ui Op, _ui L1, _ui B1, _ui D1, _ui Op2)
1622 {
1623     union {
1624         struct {
1625             _us op :  8;
1626             _us l1 :  4;
1627             _us _  :  4;
1628         } b;
1629         _us     s;
1630     } i0;
1631     union {
1632         struct {
1633             _us b1 :  4;
1634             _us d1 : 12;
1635         } b;
1636         _us     s;
1637     } i1;
1638     union {
1639         struct {
1640             _us _  :  8;
1641             _us op :  8;
1642         } b;
1643         _us     s;
1644     } i2;
1645     i0.b._ = 0;
1646     i2.b._ = 0;
1647     i0.b.op = Op;
1648     i0.b.l1 = L1;
1649     i1.b.b1 = B1;
1650     i1.b.d1 = D1;
1651     i2.b.op = Op2;
1652     assert(i0.b.op == Op);
1653     assert(i0.b.l1 == L1);
1654     assert(i1.b.b1 == B1);
1655     assert(i1.b.d1 == D1);
1656     assert(i2.b.op == Op2);
1657     is(i0.s);
1658     is(i1.s);
1659     is(i2.s);
1660 }
1661
1662 static void
1663 _RSI(jit_state_t *_jit, _ui Op, _ui R1, _ui R3, _ui I2)
1664 {
1665     union {
1666         struct {
1667             _us op :  8;
1668             _us r1 :  4;
1669             _us r3 :  4;
1670         } b;
1671         _us     s;
1672     } i0;
1673     union {
1674         struct {
1675             _us i2;
1676         } b;
1677         _us     s;
1678     } i1;
1679     i0.b.op = Op;
1680     i0.b.r1 = R1;
1681     i0.b.r3 = R3;
1682     i1.b.i2 = I2;
1683     assert(i0.b.op == Op);
1684     assert(i0.b.r1 == R1);
1685     assert(i0.b.r3 == R3);
1686     assert(i1.b.i2 == I2);
1687     is(i0.s);
1688     is(i1.s);
1689 }
1690
1691 static void
1692 _RIE(jit_state_t *_jit, _ui Op, _ui R1, _ui R3, _ui I2, _ui Op2)
1693 {
1694     union {
1695         struct {
1696             _us op :  8;
1697             _us r1 :  4;
1698             _us r3 :  4;
1699         } b;
1700         _us     s;
1701     } i0;
1702     union {
1703         struct {
1704             _us i2;
1705         } b;
1706         _us     s;
1707     } i1;
1708     union {
1709         struct {
1710             _us _  :  8;
1711             _us op :  8;
1712         } b;
1713         _us     s;
1714     } i2;
1715     i2.b._ = 0;
1716     i0.b.op = Op;
1717     i0.b.r1 = R1;
1718     i0.b.r3 = R3;
1719     i1.b.i2 = I2;
1720     i2.b.op = Op2;
1721     assert(i0.b.op == Op);
1722     assert(i0.b.r1 == R1);
1723     assert(i0.b.r3 == R3);
1724     assert(i1.b.i2 == I2);
1725     assert(i2.b.op == Op2);
1726     is(i0.s);
1727     is(i1.s);
1728     is(i2.s);
1729 }
1730
1731 static void
1732 _RIL(jit_state_t *_jit, _ui Op, _ui R1, _ui Op2, _ui I2)
1733 {
1734     union {
1735         struct {
1736             _us o1 :  8;
1737             _us r1 :  4;
1738             _us o2 :  4;
1739         } b;
1740         _us     s;
1741     } i0;
1742     union {
1743         struct {
1744             _ui ih : 16;
1745             _ui il : 16;
1746         } b;
1747         _ui     i;
1748     } i12;
1749     i0.b.o1 = Op;
1750     i0.b.r1 = R1;
1751     i0.b.o2 = Op2;
1752     i12.i   = I2;
1753     assert(i0.b.o1 == Op);
1754     assert(i0.b.r1 == R1);
1755     assert(i0.b.o2 == Op2);
1756     is(i0.s);
1757     is(i12.b.ih);
1758     is(i12.b.il);
1759 }
1760
1761 static void
1762 _SI(jit_state_t *_jit, _ui Op, _ui I2, _ui B1, _ui D1)
1763 {
1764     union {
1765         struct {
1766             _us op :  8;
1767             _us i2 :  8;
1768         } b;
1769         _us     s;
1770     } i0;
1771     union {
1772         struct {
1773             _us b1 :  4;
1774             _us d1 : 12;
1775         } b;
1776         _us     s;
1777     } i1;
1778     i0.b.op = Op;
1779     i0.b.i2 = I2;
1780     i1.b.b1 = B1;
1781     i1.b.d1 = D1;
1782     assert(i0.b.op == Op);
1783     assert(i0.b.i2 == I2);
1784     assert(i1.b.b1 == B1);
1785     assert(i1.b.d1 == D1);
1786     is(i0.s);
1787     is(i1.s);
1788 }
1789
1790 static void
1791 _SIY(jit_state_t *_jit, _ui Op, _ui I2, _ui B1, _ui D1, _ui Op2)
1792 {
1793     union {
1794         struct {
1795             _us op :  8;
1796             _us i2 :  8;
1797         } b;
1798         _us     s;
1799     } i0;
1800     union {
1801         struct {
1802             _us b1 :  4;
1803             _us dl : 12;
1804         } b;
1805         _us     s;
1806     } i1;
1807     union {
1808         struct {
1809             _us dh :  8;
1810             _us op :  8;
1811         } b;
1812         _us     s;
1813     } i2;
1814     i0.b.op = Op;
1815     i0.b.i2 = I2;
1816     i1.b.b1 = B1;
1817     i1.b.dl = D1 & 0xfff;
1818     i2.b.dh = D1 >> 8;
1819     i2.b.op = Op2;
1820     assert(i0.b.op == Op);
1821     assert(i0.b.i2 == I2);
1822     assert(i1.b.b1 == B1);
1823     assert(i2.b.dh == D1 >> 8);
1824     assert(i2.b.op == Op2);
1825     is(i0.s);
1826     is(i1.s);
1827     is(i2.s);
1828 }
1829
1830 static void
1831 _S(jit_state_t *_jit, _ui Op, _ui B2, _ui D2)
1832 {
1833     union {
1834         struct {
1835             _us op;
1836         } b;
1837         _us     s;
1838     } i0;
1839     union {
1840         struct {
1841             _us b2 :  4;
1842             _us d2 : 12;
1843         } b;
1844         _us     s;
1845     } i1;
1846     i0.b.op = Op;
1847     i1.b.b2 = B2;
1848     i1.b.d2 = D2;
1849     assert(i0.b.op == Op);
1850     assert(i1.b.b2 == B2);
1851     assert(i1.b.d2 == D2);
1852     is(i0.s);
1853     is(i1.s);
1854 }
1855
1856 static void
1857 _SS(jit_state_t *_jit, _ui Op, _ui LL, _ui LH, _ui B1, _ui D1, _ui B2, _ui D2)
1858 {
1859     union {
1860         struct {
1861             _us op :  8;
1862             _us ll :  4;
1863             _us lh :  4;
1864         } b;
1865         _us     s;
1866     } i0;
1867     union {
1868         struct {
1869             _us b1 :  4;
1870             _us d1 : 12;
1871         } b;
1872         _us     s;
1873     } i1;
1874     union {
1875         struct {
1876             _us b2 :  4;
1877             _us d2 : 12;
1878         } b;
1879         _us     s;
1880     } i2;
1881     i0.b.op = Op;
1882     i0.b.ll = LL;
1883     i0.b.lh = LH;
1884     i1.b.b1 = B1;
1885     i1.b.d1 = D1;
1886     i2.b.b2 = B2;
1887     i2.b.d2 = D2;
1888     assert(i0.b.op == Op);
1889     assert(i0.b.ll == LL);
1890     assert(i0.b.lh == LH);
1891     assert(i1.b.b1 == B1);
1892     assert(i1.b.d1 == D1);
1893     assert(i2.b.b2 == B2);
1894     assert(i2.b.d2 == D2);
1895     is(i0.s);
1896     is(i1.s);
1897     is(i2.s);
1898 }
1899
1900 static void
1901 _SSE(jit_state_t *_jit, _ui Op, _ui B1, _ui D1, _ui B2, _ui D2)
1902 {
1903     union {
1904         struct {
1905             _us op;
1906         } b;
1907         _us     s;
1908     } i0;
1909     union {
1910         struct {
1911             _us b1 :  4;
1912             _us d1 : 12;
1913         } b;
1914         _us     s;
1915     } i1;
1916     union {
1917         struct {
1918             _us b2 :  4;
1919             _us d2 : 12;
1920         } b;
1921         _us     s;
1922     } i2;
1923     i0.b.op = Op;
1924     i1.b.b1 = B1;
1925     i1.b.d1 = D1;
1926     i2.b.b2 = B2;
1927     i2.b.d2 = D2;
1928     assert(i0.b.op == Op);
1929     assert(i1.b.b1 == B1);
1930     assert(i1.b.d1 == D1);
1931     assert(i2.b.b2 == B2);
1932     assert(i2.b.d2 == D2);
1933     is(i0.s);
1934     is(i1.s);
1935     is(i2.s);
1936 }
1937 #  undef _us
1938 #  undef _ui
1939
1940 static void
1941 _nop(jit_state_t *_jit, jit_int32_t c)
1942 {
1943     assert(c >= 0 && !(c & 1));
1944     while (c) {
1945         NOPR(_R7_REGNO);
1946         c -= 2;
1947     }
1948 }
1949
1950 static jit_int32_t
1951 _xdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1952 {
1953     jit_int32_t         regno;
1954     regno = jit_get_reg_pair();
1955 #if __WORDSIZE == 32
1956     movr(rn(regno), r0);
1957     SRDA(rn(regno), 32, 0);
1958 #else
1959     movr(rn(regno) + 1, r0);
1960 #endif
1961     DIVREM_(rn(regno), r1);
1962     jit_unget_reg_pair(regno);
1963     return (regno);
1964 }
1965
1966 static jit_int32_t
1967 _xdivr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1968 {
1969     jit_int32_t         regno;
1970     regno = jit_get_reg_pair();
1971 #if __WORDSIZE == 32
1972     movr(rn(regno), r0);
1973     SRDL(rn(regno), 32, 0);
1974 #else
1975     movr(rn(regno) + 1, r0);
1976 #endif
1977     movi(rn(regno), 0);
1978     DIVREMU_(rn(regno), r1);
1979     jit_unget_reg_pair(regno);
1980     return (regno);
1981 }
1982
1983 static jit_int32_t
1984 _xdivi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1985 {
1986     jit_int32_t         imm, regno;
1987     regno = jit_get_reg_pair();
1988     imm = jit_get_reg(jit_class_gpr);
1989 #if __WORDSIZE == 32
1990     movr(rn(regno), r0);
1991     SRDA(rn(regno), 32, 0);
1992 #else
1993     movr(rn(regno) + 1, r0);
1994 #endif
1995     movi(rn(imm), i0);
1996     DIVREM_(rn(regno), rn(imm));
1997     jit_unget_reg(imm);
1998     jit_unget_reg_pair(regno);
1999     return (regno);
2000 }
2001
2002 static jit_int32_t
2003 _xdivi_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2004 {
2005     /* cannot overlap because operand is 128-bit */
2006     jit_int32_t         imm, regno;
2007     regno = jit_get_reg_pair();
2008     imm = jit_get_reg(jit_class_gpr);
2009 #if __WORDSIZE == 32
2010     movr(rn(regno), r0);
2011     SRDL(rn(regno), 32, 0);
2012 #else
2013     movr(rn(regno) + 1, r0);
2014 #endif
2015     movi(rn(regno), 0);
2016     movi(rn(imm), i0);
2017     DIVREMU_(rn(regno), rn(imm));
2018     jit_unget_reg(imm);
2019     jit_unget_reg_pair(regno);
2020     return (regno);
2021 }
2022
2023 static void
2024 _crr(jit_state_t *_jit, jit_int32_t cc,
2025      jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2026 {
2027     jit_word_t          w;
2028     jit_int32_t         reg, rg;
2029     if (r0 == r1 || r0 == r2) {
2030         reg = jit_get_reg(jit_class_gpr);
2031         rg = rn(reg);
2032     }
2033     else
2034         rg = r0;
2035     movi(rg, 1);
2036     CMP_(r1, r2);
2037     w = _jit->pc.w;
2038     BRC(cc, 0);
2039     movi(rg, 0);
2040     patch_at(w, _jit->pc.w);
2041     if (r0 == r1 || r0 == r2) {
2042         movr(r0, rg);
2043         jit_unget_reg(reg);
2044     }
2045 }
2046
2047 static void
2048 _cri(jit_state_t *_jit, jit_int32_t cc,
2049      jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2050 {
2051     jit_int32_t         reg;
2052     reg = jit_get_reg(jit_class_gpr);
2053     movi(rn(reg), i0);
2054     crr(cc, r0, r1, rn(reg));
2055     jit_unget_reg(reg);
2056 }
2057
2058 static void
2059 _crr_u(jit_state_t *_jit, jit_int32_t cc,
2060        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2061 {
2062     jit_word_t          w;
2063     jit_int32_t         reg, rg;
2064     if (r0 == r1 || r0 == r2) {
2065         reg = jit_get_reg(jit_class_gpr);
2066         rg = rn(reg);
2067     }
2068     else
2069         rg = r0;
2070     movi(rg, 1);
2071     CMPU_(r1, r2);
2072     w = _jit->pc.w;
2073     BRC(cc, 0);
2074     movi(rg, 0);
2075     patch_at(w, _jit->pc.w);
2076     if (r0 == r1 || r0 == r2) {
2077         movr(r0, rg);
2078         jit_unget_reg(reg);
2079     }
2080 }
2081
2082 static void
2083 _cri_u(jit_state_t *_jit, jit_int32_t cc,
2084        jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2085 {
2086     jit_int32_t         reg;
2087     reg = jit_get_reg(jit_class_gpr);
2088     movi(rn(reg), i0);
2089     crr_u(cc, r0, r1, rn(reg));
2090     jit_unget_reg(reg);
2091 }
2092
2093 static void
2094 _brr(jit_state_t *_jit, jit_int32_t cc,
2095      jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2096 {
2097     jit_word_t          d;
2098     CMP_(r0, r1);
2099     d = (i0 - _jit->pc.w) >> 1;
2100     if (s16_p(d))
2101         BRC(cc, x16(d));
2102     else {
2103         assert(s32_p(d));
2104         BRCL(cc, d);
2105     }
2106 }
2107
2108 static jit_word_t
2109 _brr_p(jit_state_t *_jit, jit_int32_t cc,
2110        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2111 {
2112     jit_word_t          w;
2113     CMP_(r0, r1);
2114     w = _jit->pc.w;
2115     BRCL(cc, 0);
2116     return (w);
2117 }
2118
2119 static void
2120 _bri(jit_state_t *_jit, jit_int32_t cc,
2121      jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2122 {
2123     jit_int32_t         reg;
2124     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2125     movi(rn(reg), i1);
2126     brr(cc, i0, r0, rn(reg));
2127     jit_unget_reg(reg);
2128 }
2129
2130 static jit_word_t
2131 _bri_p(jit_state_t *_jit, jit_int32_t cc,
2132      jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2133 {
2134     jit_word_t          w;
2135     jit_int32_t         reg;
2136     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2137     movi(rn(reg), i1);
2138     w = brr_p(cc, i0, r0, rn(reg));
2139     jit_unget_reg(reg);
2140     return (w);
2141 }
2142
2143 static void
2144 _brr_u(jit_state_t *_jit, jit_int32_t cc,
2145        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2146 {
2147     jit_word_t          d;
2148     CMPU_(r0, r1);
2149     d = (i0 - _jit->pc.w) >> 1;
2150     if (s16_p(d))
2151         BRC(cc, x16(d));
2152     else {
2153         assert(s32_p(d));
2154         BRCL(cc, d);
2155     }
2156 }
2157
2158 static jit_word_t
2159 _brr_u_p(jit_state_t *_jit, jit_int32_t cc,
2160          jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2161 {
2162     jit_word_t          w;
2163     CMPU_(r0, r1);
2164     w = _jit->pc.w;
2165     BRCL(cc, 0);
2166     return (w);
2167 }
2168
2169 static void
2170 _bri_u(jit_state_t *_jit, jit_int32_t cc,
2171        jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2172 {
2173     jit_int32_t         reg;
2174     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2175     movi(rn(reg), i1);
2176     brr_u(cc, i0, r0, rn(reg));
2177     jit_unget_reg(reg);
2178 }
2179
2180 static jit_word_t
2181 _bri_u_p(jit_state_t *_jit, jit_int32_t cc,
2182          jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2183 {
2184     jit_word_t          w;
2185     jit_int32_t         reg;
2186     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2187     movi(rn(reg), i1);
2188     w = brr_u_p(cc, i0, r0, rn(reg));
2189     jit_unget_reg(reg);
2190     return (w);
2191 }
2192
2193 static void
2194 _baddr(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2195        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2196 {
2197     jit_word_t          d;
2198     if (s)              addr(r0, r0, r1);
2199     else                addcr(r0, r0, r1);
2200     d = (i0 - _jit->pc.w) >> 1;
2201     if (s16_p(d))
2202         BRC(c, x16(d));
2203     else {
2204         assert(s32_p(d));
2205         BRCL(c, d);
2206     }
2207 }
2208
2209 static void
2210 _baddi(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2211        jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2212 {
2213     jit_int32_t         reg;
2214     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2215     movi(rn(reg), i1);
2216     baddr(c, s, i0, r0, rn(reg));
2217     jit_unget_reg(reg);
2218 }
2219
2220 static jit_word_t
2221 _baddr_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2222          jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2223 {
2224     jit_word_t          d, w;
2225     if (s)              addr(r0, r0, r1);
2226     else                addcr(r0, r0, r1);
2227     d = (i0 - _jit->pc.w) >> 1;
2228     w = _jit->pc.w;
2229     BRCL(c, d);
2230     return (w);
2231 }
2232
2233 static jit_word_t
2234 _baddi_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2235          jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2236 {
2237     jit_word_t          w;
2238     jit_int32_t         reg;
2239     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2240     movi(rn(reg), i1);
2241     w = baddr_p(c, s, i0, r0, rn(reg));
2242     jit_unget_reg(reg);
2243     return (w);
2244 }
2245
2246 static void
2247 _bsubr(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2248        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2249 {
2250     jit_word_t          d;
2251     if (s)              subr(r0, r0, r1);
2252     else                subcr(r0, r0, r1);
2253     d = (i0 - _jit->pc.w) >> 1;
2254     if (s16_p(d))
2255         BRC(c, x16(d));
2256     else {
2257         assert(s32_p(d));
2258         BRCL(c, d);
2259     }
2260 }
2261
2262 static void
2263 _bsubi(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2264        jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2265 {
2266     jit_int32_t         reg;
2267     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2268     movi(rn(reg), i1);
2269     bsubr(c, s, i0, r0, rn(reg));
2270     jit_unget_reg(reg);
2271 }
2272
2273 static jit_word_t
2274 _bsubr_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2275          jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2276 {
2277     jit_word_t          d, w;
2278     if (s)              subr(r0, r0, r1);
2279     else                subcr(r0, r0, r1);
2280     d = (i0 - _jit->pc.w) >> 1;
2281     w = _jit->pc.w;
2282     BRCL(c, d);
2283     return (w);
2284 }
2285
2286 static jit_word_t
2287 _bsubi_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2288          jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2289 {
2290     jit_word_t          w;
2291     jit_int32_t         reg;
2292     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2293     movi(rn(reg), i1);
2294     w = bsubr_p(c, s, i0, r0, rn(reg));
2295     jit_unget_reg(reg);
2296     return (w);
2297 }
2298
2299 static void
2300 _bmxr(jit_state_t *_jit, jit_int32_t cc,
2301       jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2302 {
2303     jit_word_t          d;
2304     jit_int32_t         reg;
2305     reg = jit_get_reg(jit_class_gpr);
2306     movr(rn(reg), r0);
2307     andr(rn(reg), rn(reg), r1);
2308     TEST_(rn(reg), rn(reg));
2309     jit_unget_reg(reg);
2310     d = (i0 - _jit->pc.w) >> 1;
2311     if (s16_p(d))
2312         BRC(cc, x16(d));
2313     else {
2314         assert(s32_p(d));
2315         BRCL(cc, d);
2316     }
2317 }
2318
2319 static jit_word_t
2320 _bmxr_p(jit_state_t *_jit, jit_int32_t cc,
2321         jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2322 {
2323     jit_word_t          w;
2324     jit_int32_t         reg;
2325     reg = jit_get_reg(jit_class_gpr);
2326     movr(rn(reg), r0);
2327     andr(rn(reg), rn(reg), r1);
2328     TEST_(rn(reg), rn(reg));
2329     jit_unget_reg(reg);
2330     w = _jit->pc.w;
2331     BRCL(cc, 0);
2332     return (w);
2333 }
2334
2335 static void
2336 _bmxi(jit_state_t *_jit, jit_int32_t cc,
2337       jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2338 {
2339     jit_word_t          d;
2340     jit_int32_t         reg;
2341     reg = jit_get_reg(jit_class_gpr);
2342     movi(rn(reg), i1);
2343     andr(rn(reg), rn(reg), r0);
2344     TEST_(rn(reg), rn(reg));
2345     jit_unget_reg(reg);
2346     d = (i0 - _jit->pc.w) >> 1;
2347     if (s16_p(d))
2348         BRC(cc, x16(d));
2349     else {
2350         assert(s32_p(d));
2351         BRCL(cc, d);
2352     }
2353 }
2354
2355 static jit_word_t
2356 _bmxi_p(jit_state_t *_jit, jit_int32_t cc,
2357         jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2358 {
2359     jit_word_t          w;
2360     jit_int32_t         reg;
2361     reg = jit_get_reg(jit_class_gpr);
2362     movi(rn(reg), i1);
2363     andr(rn(reg), rn(reg), r0);
2364     TEST_(rn(reg), rn(reg));
2365     jit_unget_reg(reg);
2366     w = _jit->pc.w;
2367     BRCL(cc, 0);
2368     return (w);
2369 }
2370
2371 static void
2372 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2373 {
2374 #if __WORDSIZE == 32
2375     if (r0 != r1)
2376         LR(r0, r1);
2377 #else
2378     if (r0 != r1)
2379         LGR(r0, r1);
2380 #endif
2381 }
2382
2383 static void
2384 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2385 {
2386     jit_word_t          d;
2387 #if __WORDSIZE == 64
2388     jit_int32_t         bits;
2389 #endif
2390     d = (i0 - _jit->pc.w) >> 1;
2391     if (s16_p(i0)) {
2392 #if __WORDSIZE == 32
2393         LHI(r0, x16(i0));
2394 #else
2395         LGHI(r0, x16(i0));
2396 #endif
2397     }
2398     /* easy way of loading a large amount of 32 bit values and
2399      * usually address of constants */
2400     else if (!(i0 & 1) &&
2401 #if __WORDSIZE == 32
2402              i0 > 0
2403 #else
2404              s32_p(d)
2405 #endif
2406              )
2407         LARL(r0, d);
2408     else {
2409 #if __WORDSIZE == 32
2410         LHI(r0, x16(i0));
2411         IILH(r0, x16((jit_uword_t)i0 >> 16));
2412 #else
2413         bits = 0;
2414         if (i0 &             0xffffL)   bits |= 1;
2415         if (i0 &         0xffff0000L)   bits |= 2;
2416         if (i0 &     0xffff00000000L)   bits |= 4;
2417         if (i0 & 0xffff000000000000L)   bits |= 8;
2418         if (bits != 15)                 LGHI(r0, 0);
2419         if (bits & 1)                   IILL(r0, x16(i0));
2420         if (bits & 2)                   IILH(r0, x16((jit_uword_t)i0 >> 16));
2421         if (bits & 4)                   IIHL(r0, x16((jit_uword_t)i0 >> 32));
2422         if (bits & 8)                   IIHH(r0, x16((jit_uword_t)i0 >> 48));
2423 #endif
2424     }
2425 }
2426
2427 static jit_word_t
2428 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2429 {
2430     jit_word_t          w;
2431     w = _jit->pc.w;
2432 #if __WORDSIZE == 32
2433     LHI(r0, x16(i0));
2434 #else
2435     IILL(r0, x16(i0));
2436 #endif
2437     IILH(r0, x16((jit_uword_t)i0 >> 16));
2438 #if __WORDSIZE == 64
2439     IIHL(r0, x16((jit_uword_t)i0 >> 32));
2440     IIHH(r0, x16((jit_uword_t)i0 >> 48));
2441 #endif
2442     return (w);
2443 }
2444
2445 static void
2446 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2447 {
2448     jit_word_t  w;
2449     w = beqi_p(_jit->pc.w, r2, 0);
2450 #if __WORDSIZE == 32
2451     LR(r0, r1);
2452 #else
2453     LGR(r0, r1);
2454 #endif
2455     patch_at(w, _jit->pc.w);
2456 }
2457
2458 static void
2459 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2460 {
2461     jit_word_t  w;
2462     w = bnei_p(_jit->pc.w, r2, 0);
2463 #if __WORDSIZE == 32
2464     LR(r0, r1);
2465 #else
2466     LGR(r0, r1);
2467 #endif
2468     patch_at(w, _jit->pc.w);
2469 }
2470
2471 static void
2472 _addr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2473 {
2474     if (r0 == r2)
2475         ADD_(r0, r1);
2476     else {
2477         movr(r0, r1);
2478         ADD_(r0, r2);
2479     }
2480 }
2481
2482 static void
2483 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2484 {
2485     jit_int32_t         reg;
2486     if (r0 == r1 && s16_p(i0))
2487         ADDI_(r0, x16(i0));
2488 #if __WORDSIZE == 64
2489     else if (s20_p(i0))
2490         LAY(r0, x20(i0), 0, r1);
2491 #endif
2492     else {
2493         reg = jit_get_reg(jit_class_gpr);
2494         movi(rn(reg), i0);
2495         addr(r0, r1, rn(reg));
2496         jit_unget_reg(reg);
2497     }
2498 }
2499
2500 static void
2501 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2502 {
2503     if (r0 == r2)
2504         ADDC_(r0, r1);
2505     else {
2506         movr(r0, r1);
2507         ADDC_(r0, r2);
2508     }
2509 }
2510
2511 static void
2512 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2513 {
2514     jit_int32_t         reg;
2515     reg = jit_get_reg(jit_class_gpr);
2516     movi(rn(reg), i0);
2517     addcr(r0, r1, rn(reg));
2518     jit_unget_reg(reg);
2519 }
2520
2521 static void
2522 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2523 {
2524     if (r0 == r2)
2525         ADDX_(r0, r1);
2526     else {
2527         movr(r0, r1);
2528         ADDX_(r0, r2);
2529     }
2530 }
2531
2532 static void
2533 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2534 {
2535     jit_int32_t         reg;
2536     reg = jit_get_reg(jit_class_gpr);
2537     movi(rn(reg), i0);
2538     addxr(r0, r1, rn(reg));
2539     jit_unget_reg(reg);
2540 }
2541
2542 static void
2543 _subr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2544 {
2545     jit_int32_t         reg;
2546     if (r0 == r2) {
2547         reg = jit_get_reg(jit_class_gpr);
2548         movr(rn(reg), r2);
2549         movr(r0, r1);
2550         SUB_(r0, rn(reg));
2551         jit_unget_reg(reg);
2552     }
2553     else {
2554         movr(r0, r1);
2555         SUB_(r0, r2);
2556     }
2557 }
2558
2559 static void
2560 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2561 {
2562     jit_int32_t         reg;
2563     if (r0 == r1 && s16_p(-i0))
2564         ADDI_(r0, x16(-i0));
2565 #if __WORDSIZE == 64
2566     else if (s20_p(-i0))
2567         LAY(r0, x20(-i0), 0, r1);
2568 #endif
2569     else {
2570         reg = jit_get_reg(jit_class_gpr);
2571         movi(rn(reg), i0);
2572         subr(r0, r1, rn(reg));
2573         jit_unget_reg(reg);
2574     }
2575 }
2576
2577 static void
2578 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2579 {
2580     jit_int32_t         reg;
2581     if (r0 == r2) {
2582         reg = jit_get_reg(jit_class_gpr);
2583         movr(rn(reg), r2);
2584         movr(r0, r1);
2585         SUBC_(r0, rn(reg));
2586         jit_unget_reg(reg);
2587     }
2588     else {
2589         movr(r0, r1);
2590         SUBC_(r0, r2);
2591     }
2592 }
2593
2594 static void
2595 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2596 {
2597     jit_int32_t         reg;
2598     reg = jit_get_reg(jit_class_gpr);
2599     movi(rn(reg), i0);
2600     subcr(r0, r1, rn(reg));
2601     jit_unget_reg(reg);
2602 }
2603
2604 static void
2605 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2606 {
2607     jit_int32_t         reg;
2608     if (r0 == r2) {
2609         reg = jit_get_reg(jit_class_gpr);
2610         movr(rn(reg), r2);
2611         movr(r0, r1);
2612         SUBX_(r0, rn(reg));
2613         jit_unget_reg(reg);
2614     }
2615     else {
2616         movr(r0, r1);
2617         SUBX_(r0, r2);
2618     }
2619 }
2620
2621 static void
2622 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2623 {
2624     jit_int32_t         reg;
2625     reg = jit_get_reg(jit_class_gpr);
2626     movi(rn(reg), i0);
2627     subxr(r0, r1, rn(reg));
2628     jit_unget_reg(reg);
2629 }
2630
2631 static void
2632 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2633 {
2634     subi(r0, r1, i0);
2635     negr(r0, r0);
2636 }
2637
2638 static void
2639 _mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2640 {
2641     if (r0 == r2)
2642         MUL_(r0, r1);
2643     else {
2644         movr(r0, r1);
2645         MUL_(r0, r2);
2646     }
2647 }
2648
2649 static void
2650 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2651 {
2652     jit_int32_t         reg;
2653     if (s16_p(i0)) {
2654         movr(r0, r1);
2655         MULI_(r0, x16(i0));
2656     }
2657     else {
2658         reg = jit_get_reg(jit_class_gpr);
2659         movi(rn(reg), i0);
2660         mulr(r0, r1, rn(reg));
2661         jit_unget_reg(reg);
2662     }
2663 }
2664
2665 static void
2666 _qmulr(jit_state_t *_jit,
2667        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2668 {
2669     jit_int32_t         reg;
2670     /* The only invalid condition is r0 == r1 */
2671     jit_int32_t         t2, t3, s2, s3;
2672     if (r2 == r0 || r2 == r1) {
2673         s2 = jit_get_reg(jit_class_gpr);
2674         t2 = rn(s2);
2675         movr(t2, r2);
2676     }
2677     else
2678         t2 = r2;
2679     if (r3 == r0 || r3 == r1) {
2680         s3 = jit_get_reg(jit_class_gpr);
2681         t3 = rn(s3);
2682         movr(t3, r3);
2683     }
2684     else
2685         t3 = r3;
2686     qmulr_u(r0, r1, r2, r3);
2687     reg = jit_get_reg(jit_class_gpr);
2688     /**/
2689     rshi(rn(reg), t2, 63);
2690     mulr(rn(reg), rn(reg), t3);
2691     addr(r1, r1, rn(reg));
2692     /**/
2693     rshi(rn(reg), t3, 63);
2694     mulr(rn(reg), rn(reg), t2);
2695     addr(r1, r1, rn(reg));
2696     jit_unget_reg(reg);
2697     if (t2 != r2)
2698         jit_unget_reg(s2);
2699     if (t3 != r3)
2700         jit_unget_reg(s3);
2701 }
2702
2703 static void
2704 _qmuli(jit_state_t *_jit,
2705        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2706 {
2707     jit_int32_t         reg;
2708     reg = jit_get_reg(jit_class_gpr);
2709     movi(rn(reg), i0);
2710     qmulr(r0, r1, r2, rn(reg));
2711     jit_unget_reg(reg);
2712 }
2713
2714 static void
2715 _qmulr_u(jit_state_t *_jit,
2716          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2717 {
2718     jit_int32_t         regno;
2719     regno = jit_get_reg_pair();
2720     movr(rn(regno) + 1, r2);
2721     MULU_(rn(regno), r3);
2722     movr(r0, rn(regno) + 1);
2723     movr(r1, rn(regno));
2724     jit_unget_reg_pair(regno);
2725 }
2726
2727 static void
2728 _qmuli_u(jit_state_t *_jit,
2729          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2730 {
2731     jit_int32_t         regno;
2732     regno = jit_get_reg_pair();
2733     movr(rn(regno) + 1, r2);
2734     movi(rn(regno), i0);
2735     MULU_(rn(regno), rn(regno));
2736     movr(r0, rn(regno) + 1);
2737     movr(r1, rn(regno));
2738     jit_unget_reg_pair(regno);
2739 }
2740
2741 static void
2742 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2743 {
2744     jit_int32_t         regno;
2745     regno = xdivr(r1, r2);
2746     movr(r0, rn(regno) + 1);
2747 }
2748
2749 static void
2750 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2751 {
2752     jit_int32_t         regno;
2753     regno = xdivi(r1, i0);
2754     movr(r0, rn(regno) + 1);
2755 }
2756
2757 static void
2758 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2759 {
2760     jit_int32_t         regno;
2761     regno = xdivr_u(r1, r2);
2762     movr(r0, rn(regno) + 1);
2763 }
2764
2765 static void
2766 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2767 {
2768     jit_int32_t         regno;
2769     regno = xdivi_u(r1, i0);
2770     movr(r0, rn(regno) + 1);
2771 }
2772
2773 static void
2774 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2775 {
2776     jit_int32_t         regno;
2777     regno = xdivr(r1, r2);
2778     movr(r0, rn(regno));
2779 }
2780
2781 static void
2782 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2783 {
2784     jit_int32_t         regno;
2785     regno = xdivi(r1, i0);
2786     movr(r0, rn(regno));
2787 }
2788
2789 static void
2790 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2791 {
2792     jit_int32_t         regno;
2793     regno = xdivr_u(r1, r2);
2794     movr(r0, rn(regno));
2795 }
2796
2797 static void
2798 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2799 {
2800     jit_int32_t         regno;
2801     regno = xdivi_u(r1, i0);
2802     movr(r0, rn(regno));
2803 }
2804
2805 static void
2806 _qdivr(jit_state_t *_jit,
2807        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2808 {
2809     jit_int32_t         regno;
2810     regno = xdivr(r2, r3);
2811     movr(r0, rn(regno) + 1);
2812     movr(r1, rn(regno));
2813 }
2814
2815 static void
2816 _qdivi(jit_state_t *_jit,
2817        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2818 {
2819     jit_int32_t         regno;
2820     regno = xdivi(r2, i0);
2821     movr(r0, rn(regno) + 1);
2822     movr(r1, rn(regno));
2823 }
2824
2825 static void
2826 _qdivr_u(jit_state_t *_jit,
2827          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2828 {
2829     jit_int32_t         regno;
2830     regno = xdivr_u(r2, r3);
2831     movr(r0, rn(regno) + 1);
2832     movr(r1, rn(regno));
2833 }
2834
2835 static void
2836 _qdivi_u(jit_state_t *_jit,
2837          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2838 {
2839     jit_int32_t         regno;
2840     regno = xdivi_u(r2, i0);
2841     movr(r0, rn(regno) + 1);
2842     movr(r1, rn(regno));
2843 }
2844
2845 #  if __WORDSIZE == 32
2846 static void
2847 _lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2848 {
2849     jit_int32_t         reg;
2850     if (r0 == r2) {
2851         reg = jit_get_reg_but_zero(0);
2852         movr(rn(reg), r2);
2853         movr(r0, r1);
2854         SLL(r0, 0, rn(reg));
2855         jit_unget_reg_but_zero(reg);
2856     }
2857     else {
2858         movr(r0, r1);
2859         SLL(r0, 0, r2);
2860     }
2861 }
2862 #endif
2863
2864 static void
2865 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2866 {
2867     jit_int32_t         reg;
2868     reg = jit_get_reg_but_zero(0);
2869     movi(rn(reg), i0);
2870     lshr(r0, r1, rn(reg));
2871     jit_unget_reg_but_zero(reg);
2872 }
2873
2874 #  if __WORDSIZE == 32
2875 static void
2876 _rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2877 {
2878     jit_int32_t         reg;
2879     if (r0 == r2) {
2880         reg = jit_get_reg_but_zero(0);
2881         movr(rn(reg), r2);
2882         movr(r0, r1);
2883         SRA(r0, 0, rn(reg));
2884         jit_unget_reg_but_zero(reg);
2885     }
2886     else {
2887         movr(r0, r1);
2888         SRA(r0, 0, r2);
2889     }
2890 }
2891 #endif
2892
2893 static void
2894 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2895 {
2896     jit_int32_t         reg;
2897     reg = jit_get_reg_but_zero(0);
2898     movi(rn(reg), i0);
2899     rshr(r0, r1, rn(reg));
2900     jit_unget_reg_but_zero(reg);
2901 }
2902
2903 #  if __WORDSIZE == 32
2904 static void
2905 _rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2906 {
2907     jit_int32_t         reg;
2908     if (r0 == r2) {
2909         reg = jit_get_reg_but_zero(0);
2910         movr(rn(reg), r2);
2911         movr(r0, r1);
2912         SRL(r0, 0, rn(reg));
2913         jit_unget_reg_but_zero(reg);
2914     }
2915     else {
2916         movr(r0, r1);
2917         SRL(r0, 0, r2);
2918     }
2919 }
2920 #endif
2921
2922 static void
2923 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2924 {
2925     jit_int32_t         reg;
2926     reg = jit_get_reg_but_zero(0);
2927     movi(rn(reg), i0);
2928     rshr_u(r0, r1, rn(reg));
2929     jit_unget_reg_but_zero(reg);
2930 }
2931
2932 static void
2933 _comr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2934 {
2935     jit_int32_t         reg;
2936     reg = jit_get_reg(jit_class_gpr);
2937     movi(rn(reg), -1);
2938     movr(r0, r1);
2939     XOR_(r0, rn(reg));
2940     jit_unget_reg(reg);
2941 }
2942
2943 static void
2944 _andr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2945 {
2946     if (r0 == r2)
2947         AND_(r0, r1);
2948     else {
2949         movr(r0, r1);
2950         AND_(r0, r2);
2951     }
2952 }
2953
2954 static void
2955 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2956 {
2957     movr(r0, r1);
2958     NILL(r0, x16(i0));
2959     NILH(r0, x16((jit_uword_t)i0 >> 16));
2960 #if __WORDSIZE == 64
2961     NIHL(r0, x16((jit_uword_t)i0 >> 32));
2962     NIHH(r0, x16((jit_uword_t)i0 >> 48));
2963 #endif
2964 }
2965
2966 static void
2967 _orr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2968 {
2969     if (r0 == r2)
2970         OR_(r0, r1);
2971     else {
2972         movr(r0, r1);
2973         OR_(r0, r2);
2974     }
2975 }
2976
2977 static void
2978 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2979 {
2980     movr(r0, r1);
2981     OILL(r0, x16(i0));
2982     OILH(r0, x16((jit_uword_t)i0 >> 16));
2983 #if __WORDSIZE == 64
2984     OIHL(r0, x16((jit_uword_t)i0 >> 32));
2985     OIHH(r0, x16((jit_uword_t)i0 >> 48));
2986 #endif
2987 }
2988
2989 static void
2990 _xorr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2991 {
2992     if (r0 == r2)
2993         XOR_(r0, r1);
2994     else {
2995         movr(r0, r1);
2996         XOR_(r0, r2);
2997     }
2998 }
2999
3000 static void
3001 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3002 {
3003     jit_int32_t         reg;
3004     reg = jit_get_reg(jit_class_gpr);
3005     movi(rn(reg), i0);
3006     xorr(r0, r1, rn(reg));
3007     jit_unget_reg(reg);
3008 }
3009
3010 static void
3011 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3012 {
3013     movi(r0, i0);
3014     ldr_c(r0, r0);
3015 }
3016
3017 static void
3018 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3019 {
3020     if (r0 == r2) {
3021         addr(r0, r0, r1);
3022         ldr_c(r0, r0);
3023     }
3024     else {
3025         movr(r0, r1);
3026         addr(r0, r0, r2);
3027         ldr_c(r0, r0);
3028     }
3029 }
3030
3031 static void
3032 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3033 {
3034     jit_int32_t         reg;
3035     if (s20_p(i0)) {
3036 #if __WORDSIZE == 32
3037         LB(r0, x20(i0), 0, r1);
3038 #else
3039         LGB(r0, x20(i0), 0, r1);
3040 #endif
3041     }
3042     else if (r0 != r1) {
3043         movi(r0, i0);
3044         addr(r0, r0, r1);
3045         ldr_c(r0, r0);
3046     }
3047     else {
3048         reg = jit_get_reg_but_zero(0);
3049         movi(rn(reg), i0);
3050         addr(rn(reg), rn(reg), r1);
3051         ldr_c(r0, rn(reg));
3052         jit_unget_reg_but_zero(reg);
3053     }
3054 }
3055
3056 static void
3057 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3058 {
3059     movi(r0, i0);
3060     ldr_uc(r0, r0);
3061 }
3062
3063 static void
3064 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3065 {
3066     if (r0 == r2) {
3067         addr(r0, r0, r1);
3068         ldr_uc(r0, r0);
3069     }
3070     else {
3071         movr(r0, r1);
3072         addr(r0, r0, r2);
3073         ldr_uc(r0, r0);
3074     }
3075 }
3076
3077 static void
3078 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3079 {
3080     jit_int32_t         reg;
3081     if (s20_p(i0))
3082         LLGC(r0, x20(i0), 0, r1);
3083     else if (r0 != r1) {
3084         movi(r0, i0);
3085         addr(r0, r0, r1);
3086         ldr_uc(r0, r0);
3087     }
3088     else {
3089         reg = jit_get_reg_but_zero(0);
3090         movi(rn(reg), i0);
3091         addr(rn(reg), rn(reg), r1);
3092         ldr_uc(r0, rn(reg));
3093         jit_unget_reg_but_zero(reg);
3094     }
3095 }
3096
3097 static void
3098 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3099 {
3100     movi(r0, i0);
3101     ldr_s(r0, r0);
3102 }
3103
3104 static void
3105 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3106 {
3107     if (r0 == r2) {
3108         addr(r0, r0, r1);
3109         ldr_s(r0, r0);
3110     }
3111     else {
3112         movr(r0, r1);
3113         addr(r0, r0, r2);
3114         ldr_s(r0, r0);
3115     }
3116 }
3117
3118 static void
3119 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3120 {
3121     jit_int32_t         reg;
3122 #if __WORDSIZE == 32
3123     if (u12_p(i0))
3124         LH(r0, i0, 0, r1);
3125     else
3126 #endif
3127     if (s20_p(i0)) {
3128 #if __WORDSIZE == 32
3129         LHY(r0, x20(i0), 0, r1);
3130 #else
3131         LGH(r0, x20(i0), 0, r1);
3132 #endif
3133     }
3134     else if (r0 != r1) {
3135         movi(r0, i0);
3136         addr(r0, r0, r1);
3137         ldr_s(r0, r0);
3138     }
3139     else {
3140         reg = jit_get_reg_but_zero(0);
3141         movi(rn(reg), i0);
3142         addr(rn(reg), rn(reg), r1);
3143         ldr_s(r0, rn(reg));
3144         jit_unget_reg_but_zero(reg);
3145     }
3146 }
3147
3148 static void
3149 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3150 {
3151     movi(r0, i0);
3152     ldr_us(r0, r0);
3153 }
3154
3155 static void
3156 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3157 {
3158     if (r0 == r2) {
3159         addr(r0, r0, r1);
3160         ldr_us(r0, r0);
3161     }
3162     else {
3163         movr(r0, r1);
3164         addr(r0, r0, r2);
3165         ldr_us(r0, r0);
3166     }
3167 }
3168
3169 static void
3170 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3171 {
3172     jit_int32_t         reg;
3173     if (s20_p(i0))
3174         LLGH(r0, x20(i0), 0, r1);
3175     else if (r0 != r1) {
3176         movi(r0, i0);
3177         addr(r0, r0, r1);
3178         ldr_us(r0, r0);
3179     }
3180     else {
3181         reg = jit_get_reg_but_zero(0);
3182         movi(rn(reg), i0);
3183         addr(rn(reg), rn(reg), r1);
3184         ldr_us(r0, rn(reg));
3185         jit_unget_reg_but_zero(reg);
3186     }
3187 }
3188
3189 static void
3190 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3191 {
3192     movi(r0, i0);
3193     ldr_i(r0, r0);
3194 }
3195
3196 static void
3197 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3198 {
3199     if (r0 == r2) {
3200         addr(r0, r0, r1);
3201         ldr_i(r0, r0);
3202     }
3203     else {
3204         movr(r0, r1);
3205         addr(r0, r0, r2);
3206         ldr_i(r0, r0);
3207     }
3208 }
3209
3210 static void
3211 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3212 {
3213     jit_int32_t         reg;
3214     if (s20_p(i0))
3215         LGF(r0, x20(i0), 0, r1);
3216     else if (r0 != r1) {
3217         movi(r0, i0);
3218         addr(r0, r0, r1);
3219         ldr_i(r0, r0);
3220     }
3221     else {
3222         reg = jit_get_reg_but_zero(0);
3223         movi(rn(reg), i0);
3224         addr(rn(reg), rn(reg), r1);
3225         ldr_i(r0, rn(reg));
3226         jit_unget_reg_but_zero(reg);
3227     }
3228 }
3229
3230 #if __WORDSIZE == 64
3231 static void
3232 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3233 {
3234     movi(r0, i0);
3235     ldr_ui(r0, r0);
3236 }
3237
3238 static void
3239 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3240 {
3241     if (r0 == r2) {
3242         addr(r0, r0, r1);
3243         ldr_ui(r0, r0);
3244     }
3245     else {
3246         movr(r0, r1);
3247         addr(r0, r0, r2);
3248         ldr_ui(r0, r0);
3249     }
3250 }
3251
3252 static void
3253 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3254 {
3255     jit_int32_t         reg;
3256     if (s20_p(i0))
3257         LLGF(r0, x20(i0), 0, r1);
3258     else if (r0 != r1) {
3259         movi(r0, i0);
3260         addr(r0, r0, r1);
3261         ldr_ui(r0, r0);
3262     }
3263     else {
3264         reg = jit_get_reg_but_zero(0);
3265         movi(rn(reg), i0);
3266         addr(rn(reg), rn(reg), r1);
3267         ldr_ui(r0, rn(reg));
3268         jit_unget_reg_but_zero(reg);
3269     }
3270 }
3271
3272 static void
3273 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3274 {
3275     movi(r0, i0);
3276     ldr_l(r0, r0);
3277 }
3278
3279 static void
3280 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3281 {
3282     if (r0 == r2) {
3283         addr(r0, r0, r1);
3284         ldr_l(r0, r0);
3285     }
3286     else {
3287         movr(r0, r1);
3288         addr(r0, r0, r2);
3289         ldr_l(r0, r0);
3290     }
3291 }
3292
3293 static void
3294 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3295 {
3296     jit_int32_t         reg;
3297     if (s20_p(i0))
3298         LG(r0, x20(i0), 0, r1);
3299     else if (r0 != r1) {
3300         movi(r0, i0);
3301         addr(r0, r0, r1);
3302         ldr_l(r0, r0);
3303     }
3304     else {
3305         reg = jit_get_reg_but_zero(0);
3306         movi(rn(reg), i0);
3307         addr(rn(reg), rn(reg), r1);
3308         ldr_l(r0, rn(reg));
3309         jit_unget_reg_but_zero(reg);
3310     }
3311 }
3312 #endif
3313
3314 static void
3315 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3316 {
3317     jit_int32_t         reg;
3318     reg = jit_get_reg_but_zero(0);
3319     movi(rn(reg), i0);
3320     str_c(rn(reg), r0);
3321     jit_unget_reg_but_zero(reg);
3322 }
3323
3324 static void
3325 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3326 {
3327     jit_int32_t         reg;
3328     reg = jit_get_reg_but_zero(0);
3329     movr(rn(reg), r0);
3330     addr(rn(reg), rn(reg), r1);
3331     str_c(rn(reg), r2);
3332     jit_unget_reg_but_zero(reg);
3333 }
3334
3335 static void
3336 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3337 {
3338     jit_int32_t         reg;
3339     if (u12_p(i0))
3340         STC(r1, i0, 0, r0);
3341     else if (s20_p(i0))
3342         STCY(r1, x20(i0), 0, r0);
3343     else {
3344         reg = jit_get_reg_but_zero(0);
3345         addi(rn(reg), r0, i0);
3346         str_c(rn(reg), r1);
3347         jit_unget_reg_but_zero(reg);
3348     }
3349 }
3350
3351 static void
3352 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3353 {
3354     jit_int32_t         reg;
3355     reg = jit_get_reg_but_zero(0);
3356     movi(rn(reg), i0);
3357     str_s(rn(reg), r0);
3358     jit_unget_reg_but_zero(reg);
3359 }
3360
3361 static void
3362 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3363 {
3364     jit_int32_t         reg;
3365     reg = jit_get_reg_but_zero(0);
3366     movr(rn(reg), r0);
3367     addr(rn(reg), rn(reg), r1);
3368     str_s(rn(reg), r2);
3369     jit_unget_reg_but_zero(reg);
3370 }
3371
3372 static void
3373 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3374 {
3375     jit_int32_t         reg;
3376     if (u12_p(i0))
3377         STH(r1, i0, 0, r0);
3378     else if (s20_p(i0))
3379         STHY(r1, x20(i0), 0, r0);
3380     else {
3381         reg = jit_get_reg_but_zero(0);
3382         addi(rn(reg), r0, i0);
3383         str_s(rn(reg), r1);
3384         jit_unget_reg_but_zero(reg);
3385     }
3386 }
3387
3388 static void
3389 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3390 {
3391     jit_int32_t         reg;
3392     reg = jit_get_reg_but_zero(0);
3393     movi(rn(reg), i0);
3394     str_i(rn(reg), r0);
3395     jit_unget_reg_but_zero(reg);
3396 }
3397
3398 static void
3399 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3400 {
3401     jit_int32_t         reg;
3402     reg = jit_get_reg_but_zero(0);
3403     movr(rn(reg), r0);
3404     addr(rn(reg), rn(reg), r1);
3405     str_i(rn(reg), r2);
3406     jit_unget_reg_but_zero(reg);
3407 }
3408
3409 static void
3410 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3411 {
3412     jit_int32_t         reg;
3413     if (u12_p(i0))
3414         ST(r1, i0, 0, r0);
3415     else if (s20_p(i0))
3416         STY(r1, x20(i0), 0, r0);
3417     else {
3418         reg = jit_get_reg_but_zero(0);
3419         addi(rn(reg), r0, i0);
3420         str_i(rn(reg), r1);
3421         jit_unget_reg_but_zero(reg);
3422     }
3423 }
3424
3425 #if __WORDSIZE == 64
3426 static void
3427 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3428 {
3429     jit_int32_t         reg;
3430     reg = jit_get_reg_but_zero(0);
3431     movi(rn(reg), i0);
3432     str_l(rn(reg), r0);
3433     jit_unget_reg_but_zero(reg);
3434 }
3435
3436 static void
3437 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3438 {
3439     jit_int32_t         reg;
3440     reg = jit_get_reg_but_zero(0);
3441     movr(rn(reg), r0);
3442     addr(rn(reg), rn(reg), r1);
3443     str_l(rn(reg), r2);
3444     jit_unget_reg_but_zero(reg);
3445 }
3446
3447 static void
3448 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3449 {
3450     jit_int32_t         reg;
3451     if (s20_p(i0))
3452         STG(r1, x20(i0), 0, r0);
3453     else {
3454         reg = jit_get_reg_but_zero(0);
3455         addi(rn(reg), r0, i0);
3456         str_l(rn(reg), r1);
3457         jit_unget_reg_but_zero(reg);
3458     }
3459 }
3460 #endif
3461
3462 static void
3463 _jmpi(jit_state_t *_jit, jit_word_t i0)
3464 {
3465     jit_word_t          d;
3466     jit_int32_t         reg;
3467     d = (i0 - _jit->pc.w) >> 1;
3468     if (s16_p(d))
3469         J(x16(d));
3470     else if (s32_p(d))
3471         BRL(d);
3472     else {
3473         reg = jit_get_reg_but_zero(jit_class_nospill);
3474         movi(rn(reg), i0);
3475         jmpr(rn(reg));
3476         jit_unget_reg_but_zero(reg);
3477     }
3478 }
3479
3480 static jit_word_t
3481 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3482 {
3483     jit_word_t          w;
3484     jit_int32_t         reg;
3485     reg = jit_get_reg_but_zero(jit_class_nospill);
3486     w = movi_p(rn(reg), i0);
3487     jmpr(rn(reg));
3488     jit_unget_reg_but_zero(reg);
3489     return (w);
3490 }
3491
3492 static void
3493 _calli(jit_state_t *_jit, jit_word_t i0)
3494 {
3495     jit_word_t          d;
3496     jit_int32_t         reg;
3497     d = (i0 - _jit->pc.w) >> 1;
3498     if (s32_p(d))
3499         BRASL(_R14_REGNO, d);
3500     else {
3501         reg = jit_get_reg_but_zero(0);
3502         movi(rn(reg), i0);
3503         callr(rn(reg));
3504         jit_unget_reg_but_zero(reg);
3505     }
3506 }
3507
3508 static jit_word_t
3509 _calli_p(jit_state_t *_jit, jit_word_t i0)
3510 {
3511     jit_word_t          w;
3512     jit_int32_t         reg;
3513     reg = jit_get_reg_but_zero(0);
3514     w = movi_p(rn(reg), i0);
3515     callr(rn(reg));
3516     jit_unget_reg_but_zero(reg);
3517     return (w);
3518 }
3519
3520 static jit_int32_t      gprs[] = {
3521     _R2, _R3, _R4, _R5,
3522     _R6, _R7, _R8, _R9, _R10, _R11, _R12, _R13
3523 };
3524
3525 static void
3526 _prolog(jit_state_t *_jit, jit_node_t *i0)
3527 {
3528     jit_int32_t         regno, offset;
3529     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3530         jit_int32_t     frame = -_jitc->function->frame;
3531         assert(_jitc->function->self.aoff >= frame);
3532         if (_jitc->function->assume_frame)
3533             return;
3534         _jitc->function->self.aoff = frame;
3535     }
3536     if (_jitc->function->allocar)
3537         _jitc->function->self.aoff &= -8;
3538     _jitc->function->stack = ((_jitc->function->self.alen -
3539                               /* align stack at 8 bytes */
3540                               _jitc->function->self.aoff) + 7) & -8;
3541     /* *IFF* a non variadic function,
3542      * Lightning does not reserve stack space for spilling arguments
3543      * in registers.
3544      * S390x, as per gcc, has 8 stack slots for spilling arguments,
3545      * (%r6 is callee save) and uses an alloca like approach to save
3546      * callee save fpr registers.
3547      * Since argument registers are not saved in any lightning port,
3548      * use the 8 slots to spill any modified fpr register, and still
3549      * use the same stack frame logic as gcc.
3550      * Save at least %r13 to %r15, as %r13 is used as frame pointer.
3551      * *IFF* a variadic function, a "standard" stack frame, with
3552      * fpr registers saved in an alloca'ed area, is used.
3553      */
3554     if ((_jitc->function->self.call & jit_call_varargs) &&
3555         jit_arg_reg_p(_jitc->function->vagp))
3556         regno = _jitc->function->vagp;
3557     else {
3558         for (regno = 4; regno < jit_size(gprs) - 1; regno++) {
3559             if (jit_regset_tstbit(&_jitc->function->regset, gprs[regno]))
3560                 break;
3561         }
3562     }
3563 #if __WORDSIZE == 32
3564 #  define FP_OFFSET             64
3565     if (_jitc->function->self.call & jit_call_varargs)
3566         offset = regno * 4 + 8;
3567     else
3568         offset = (regno - 4) * 4 + 32;
3569     STM(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3570 #else
3571 #  define FP_OFFSET             128
3572     if (_jitc->function->self.call & jit_call_varargs)
3573         offset = regno * 8 + 16;
3574     else
3575         offset = (regno - 4) * 8 + 48;
3576     STMG(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3577 #endif
3578
3579 #define SPILL(R, O)                                                     \
3580     do {                                                                \
3581         if (jit_regset_tstbit(&_jitc->function->regset, R))             \
3582             stxi_d(O, _R15_REGNO, rn(R));                               \
3583     } while (0)
3584     if (_jitc->function->self.call & jit_call_varargs) {
3585         for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3586             stxi_d(FP_OFFSET + regno * 8, _R15_REGNO, rn(_F0 - regno));
3587         SPILL(_F8, _jitc->function->vaoff + offsetof(jit_va_list_t, f8));
3588         SPILL(_F9, _jitc->function->vaoff + offsetof(jit_va_list_t, f9));
3589         SPILL(_F10, _jitc->function->vaoff + offsetof(jit_va_list_t, f10));
3590         SPILL(_F11, _jitc->function->vaoff + offsetof(jit_va_list_t, f11));
3591         SPILL(_F12, _jitc->function->vaoff + offsetof(jit_va_list_t, f12));
3592         SPILL(_F13, _jitc->function->vaoff + offsetof(jit_va_list_t, f13));
3593         SPILL(_F14, _jitc->function->vaoff + offsetof(jit_va_list_t, f14));
3594     }
3595     else {
3596         /* First 4 in low address */
3597 #if __WORDSIZE == 32
3598         SPILL(_F10, 0);
3599         SPILL(_F11, 8);
3600         SPILL(_F12, 16);
3601         SPILL(_F13, 24);
3602         /* gpr registers here */
3603         SPILL(_F14, 72);
3604         SPILL(_F8, 80);
3605         SPILL(_F9, 88);
3606 #else
3607         SPILL(_F10, 16);
3608         SPILL(_F11, 24);
3609         SPILL(_F12, 32);
3610         SPILL(_F13, 48);
3611         /* Last 3 in high address */
3612         SPILL(_F14, 136);
3613         SPILL(_F8, 144);
3614         SPILL(_F9, 152);
3615 #endif
3616     }
3617 #undef SPILL
3618     movr(_R13_REGNO, _R15_REGNO);
3619     subi(_R15_REGNO, _R15_REGNO, stack_framesize + _jitc->function->stack);
3620     if (_jitc->function->allocar) {
3621         regno = jit_get_reg(jit_class_gpr);
3622         movi(rn(regno), _jitc->function->self.aoff);
3623         stxi_i(_jitc->function->aoffoff, _R13_REGNO, rn(regno));
3624         jit_unget_reg(regno);
3625     }
3626 }
3627
3628 static void
3629 _epilog(jit_state_t *_jit, jit_node_t *i0)
3630 {
3631     jit_int32_t         regno, offset;
3632     if (_jitc->function->assume_frame)
3633         return;
3634     if ((_jitc->function->self.call & jit_call_varargs) &&
3635         jit_arg_reg_p(_jitc->function->vagp))
3636         regno = _jitc->function->vagp;
3637     else {
3638         for (regno = 4; regno < jit_size(gprs) - 1; regno++) {
3639             if (jit_regset_tstbit(&_jitc->function->regset, gprs[regno]))
3640                 break;
3641         }
3642     }
3643 #if __WORDSIZE == 32
3644     if (_jitc->function->self.call & jit_call_varargs)
3645         offset = regno * 4 + 8;
3646     else
3647         offset = (regno - 4) * 4 + 32;
3648 #else
3649     if (_jitc->function->self.call & jit_call_varargs)
3650         offset = regno * 8 + 16;
3651     else
3652         offset = (regno - 4) * 8 + 48;
3653 #endif
3654     movr(_R15_REGNO, _R13_REGNO);
3655
3656 #define LOAD(R, O)                                                      \
3657     do {                                                                \
3658         if (jit_regset_tstbit(&_jitc->function->regset, R))             \
3659             ldxi_d(rn(R), _R15_REGNO, O);                               \
3660     } while (0)
3661     if (_jitc->function->self.call & jit_call_varargs) {
3662         LOAD(_F8, _jitc->function->vaoff + offsetof(jit_va_list_t, f8));
3663         LOAD(_F9, _jitc->function->vaoff + offsetof(jit_va_list_t, f9));
3664         LOAD(_F10, _jitc->function->vaoff + offsetof(jit_va_list_t, f10));
3665         LOAD(_F11, _jitc->function->vaoff + offsetof(jit_va_list_t, f11));
3666         LOAD(_F12, _jitc->function->vaoff + offsetof(jit_va_list_t, f12));
3667         LOAD(_F13, _jitc->function->vaoff + offsetof(jit_va_list_t, f13));
3668         LOAD(_F14, _jitc->function->vaoff + offsetof(jit_va_list_t, f14));
3669     }
3670     else {
3671 #if __WORDSIZE == 32
3672         LOAD(_F10, 0);
3673         LOAD(_F11, 8);
3674         LOAD(_F12, 16);
3675         LOAD(_F13, 24);
3676         LOAD(_F14, 72);
3677         LOAD(_F8, 80);
3678         LOAD(_F9, 88);
3679 #else
3680         LOAD(_F10, 16);
3681         LOAD(_F11, 24);
3682         LOAD(_F12, 32);
3683         LOAD(_F13, 48);
3684         LOAD(_F14, 136);
3685         LOAD(_F8, 144);
3686         LOAD(_F9, 152);
3687 #endif
3688     }
3689 #undef LOAD
3690 #if __WORDSIZE == 32
3691     LM(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3692 #else
3693     LMG(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3694 #endif
3695     BR(_R14_REGNO);
3696 }
3697
3698 static void
3699 _vastart(jit_state_t *_jit, jit_int32_t r0)
3700 {
3701     jit_int32_t         reg;
3702
3703     assert(_jitc->function->self.call & jit_call_varargs);
3704
3705     /* Return jit_va_list_t in the register argument */
3706     addi(r0, _R13_REGNO, _jitc->function->vaoff);
3707     reg = jit_get_reg(jit_class_gpr);
3708
3709     /* Initialize gp offset in the save area. */
3710     movi(rn(reg), _jitc->function->vagp);
3711     stxi(offsetof(jit_va_list_t, gpoff), r0, rn(reg));
3712
3713     /* Initialize fp offset in the save area. */
3714     movi(rn(reg), _jitc->function->vafp);
3715     stxi(offsetof(jit_va_list_t, fpoff), r0, rn(reg));
3716
3717     /* Initialize overflow pointer to the first stack argument. */
3718     addi(rn(reg), _R13_REGNO, _jitc->function->self.size);
3719     stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3720
3721     /* Initialize register save area pointer. */
3722     stxi(offsetof(jit_va_list_t, save), r0, _R13_REGNO);
3723
3724     jit_unget_reg(reg);
3725 }
3726
3727 static void
3728 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3729 {
3730     jit_int32_t         rg0;
3731     jit_int32_t         rg1;
3732     jit_int32_t         rg2;
3733     jit_word_t          ge_code;
3734     jit_word_t          lt_code;
3735
3736     assert(_jitc->function->self.call & jit_call_varargs);
3737
3738     rg0 = jit_get_reg_but_zero(0);
3739     rg1 = jit_get_reg_but_zero(0);
3740
3741     /* Load the gp offset in save area in the first temporary. */
3742     ldxi(rn(rg0), r1, offsetof(jit_va_list_t, gpoff));
3743
3744     /* Jump over if there are no remaining arguments in the save area. */
3745     ge_code = bgei_p(_jit->pc.w, rn(rg0), 5);
3746
3747     /* Load the save area pointer in the second temporary. */
3748     ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3749
3750     /* Scale offset */
3751     rg2 = jit_get_reg_but_zero(0);
3752     lshi(rn(rg2), rn(rg0),
3753 #if __WORDSIZE == 32
3754          2
3755 #else
3756          3
3757 #endif
3758          );
3759     /* Add offset to saved area. */
3760     addi(rn(rg2), rn(rg2), 2 * sizeof(jit_word_t));
3761
3762     /* Load the vararg argument in the first argument. */
3763     ldxr(r0, rn(rg1), rn(rg2));
3764     jit_unget_reg_but_zero(rg2);
3765
3766     /* Update the gp offset. */
3767     addi(rn(rg0), rn(rg0), 1);
3768     stxi(offsetof(jit_va_list_t, gpoff), r1, rn(rg0));
3769
3770     /* Will only need one temporary register below. */
3771     jit_unget_reg_but_zero(rg1);
3772
3773     /* Jump over overflow code. */
3774     lt_code = jmpi_p(_jit->pc.w);
3775
3776     /* Where to land if argument is in overflow area. */
3777     patch_at(ge_code, _jit->pc.w);
3778
3779     /* Load overflow pointer. */
3780     ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3781
3782     /* Load argument. */
3783     ldr(r0, rn(rg0));
3784
3785     /* Update overflow pointer. */
3786     addi(rn(rg0), rn(rg0), sizeof(jit_word_t));
3787     stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3788
3789     /* Where to land if argument is in save area. */
3790     patch_at(lt_code, _jit->pc.w);
3791
3792     jit_unget_reg_but_zero(rg0);
3793 }
3794
3795 static void
3796 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3797 {
3798     jit_word_t                   d;
3799     union {
3800         jit_uint16_t            *s;
3801         jit_word_t               w;
3802     } u;
3803     u.w = instr;
3804     union {
3805         struct {
3806             jit_uint16_t        op :  8;
3807             jit_uint16_t        r1 :  4;
3808             jit_uint16_t        r3 :  4;
3809         } b;
3810         jit_uint16_t            s;
3811     } i0;
3812     union {
3813         struct {
3814             jit_uint16_t        i2;
3815         } b;
3816         jit_uint16_t            s;
3817     } i1;
3818     union {
3819         struct {
3820             jit_uint32_t        ih : 16;
3821             jit_uint32_t        il : 16;
3822         } b;
3823         jit_uint32_t            i;
3824     } i12;
3825     i0.s = u.s[0];
3826     /* movi_p */
3827     if (i0.b.op ==
3828 #if __WORDSIZE == 32
3829         0xA7 && i0.b.r3 == 8
3830 #else
3831         0xA5
3832 #endif
3833         ) {
3834 #if __WORDSIZE == 64
3835         assert(i0.b.r3 == 3);
3836 #endif
3837         i1.b.i2 = (jit_uword_t)label;
3838         u.s[1] = i1.s;
3839         i0.s = u.s[2];
3840         assert(i0.b.op == 0xA5 && i0.b.r3 == 2);
3841         i1.b.i2 = (jit_uword_t)label >> 16;
3842         u.s[3] = i1.s;
3843 #if __WORDSIZE == 64
3844         i0.s = u.s[4];
3845         assert(i0.b.op == 0xA5 && i0.b.r3 == 1);
3846         i1.b.i2 = (jit_uword_t)label >> 32;
3847         u.s[5] = i1.s;
3848         i0.s = u.s[6];
3849         assert(i0.b.op == 0xA5 && i0.b.r3 == 0);
3850         i1.b.i2 = (jit_uword_t)label >> 48;
3851         u.s[7] = i1.s;
3852 #endif
3853     }
3854     /* BRC */
3855     else if (i0.b.op == 0xA7) {
3856         assert(i0.b.r3 == 0x4);
3857         d = (label - instr) >> 1;
3858         assert(s16_p(d));
3859         i1.b.i2 = d;
3860         u.s[1] = i1.s;
3861     }
3862     /* BRCL */
3863     else if (i0.b.op == 0xC0) {
3864         assert(i0.b.r3 == 0x4);
3865         d = (label - instr) >> 1;
3866         assert(s32_p(d));
3867         i12.i = d;
3868         u.s[1] = i12.b.ih;
3869         u.s[2] = i12.b.il;
3870     }
3871     else
3872         abort();
3873 }
3874 #endif