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 casx(r0, r1, r2, r3, i0)      _casx(_jit, r0, r1, r2, r3, i0)
 977 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
 978                   jit_int32_t,jit_int32_t,jit_word_t);
 979 #define casr(r0, r1, r2, r3)            casx(r0, r1, r2, r3, 0)
 980 #define casi(r0, i0, r1, r2)            casx(r0, _NOREG, r1, r2, i0)
 981 #  define addr(r0,r1,r2)                _addr(_jit,r0,r1,r2)
 982 static void _addr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 983 #  define addi(r0,r1,i0)                _addi(_jit,r0,r1,i0)
 984 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 985 #  define addcr(r0,r1,r2)               _addcr(_jit,r0,r1,r2)
 986 static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 987 #  define addci(r0,r1,i0)               _addci(_jit,r0,r1,i0)
 988 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 989 #  define addxr(r0,r1,r2)               _addxr(_jit,r0,r1,r2)
 990 static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 991 #  define addxi(r0,r1,i0)               _addxi(_jit,r0,r1,i0)
 992 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 993 #  define subr(r0,r1,r2)                _subr(_jit,r0,r1,r2)
 994 static void _subr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 995 #  define subi(r0,r1,i0)                _subi(_jit,r0,r1,i0)
 996 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 997 #  define subcr(r0,r1,r2)               _subcr(_jit,r0,r1,r2)
 998 static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 999 #  define subci(r0,r1,i0)               _subci(_jit,r0,r1,i0)
1000 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1001 #  define subxr(r0,r1,r2)               _subxr(_jit,r0,r1,r2)
1002 static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1003 #  define subxi(r0,r1,i0)               _subxi(_jit,r0,r1,i0)
1004 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1005 #  define rsbi(r0, r1, i0)              _rsbi(_jit, r0, r1, i0)
1006 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1007 #  define mulr(r0,r1,r2)                _mulr(_jit,r0,r1,r2)
1008 static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1009 #  define muli(r0,r1,i0)                _muli(_jit,r0,r1,i0)
1010 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1011 #  define qmulr(r0,r1,r2,r3)            _qmulr(_jit,r0,r1,r2,r3)
1012 static void _qmulr(jit_state_t*,jit_int32_t,
1013                    jit_int32_t,jit_int32_t,jit_int32_t);
1014 #  define qmuli(r0,r1,r2,i0)            _qmuli(_jit,r0,r1,r2,i0)
1015 static void _qmuli(jit_state_t*,jit_int32_t,
1016                    jit_int32_t,jit_int32_t,jit_word_t);
1017 #  define qmulr_u(r0,r1,r2,r3)          _qmulr_u(_jit,r0,r1,r2,r3)
1018 static void _qmulr_u(jit_state_t*,jit_int32_t,
1019                      jit_int32_t,jit_int32_t,jit_int32_t);
1020 #  define qmuli_u(r0,r1,r2,i0)          _qmuli_u(_jit,r0,r1,r2,i0)
1021 static void _qmuli_u(jit_state_t*,jit_int32_t,
1022                      jit_int32_t,jit_int32_t,jit_word_t);
1023 #  define divr(r0,r1,r2)                _divr(_jit,r0,r1,r2)
1024 static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1025 #  define divi(r0,r1,i0)                _divi(_jit,r0,r1,i0)
1026 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1027 #  define divr_u(r0,r1,r2)              _divr_u(_jit,r0,r1,r2)
1028 static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1029 #  define divi_u(r0,r1,i0)              _divi_u(_jit,r0,r1,i0)
1030 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1031 #  define remr(r0,r1,r2)                _remr(_jit,r0,r1,r2)
1032 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1033 #  define remi(r0,r1,i0)                _remi(_jit,r0,r1,i0)
1034 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1035 #  define remr_u(r0,r1,r2)              _remr_u(_jit,r0,r1,r2)
1036 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1037 #  define remi_u(r0,r1,i0)              _remi_u(_jit,r0,r1,i0)
1038 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1039 #  define qdivr(r0,r1,r2,r3)            _qdivr(_jit,r0,r1,r2,r3)
1040 static void _qdivr(jit_state_t*,jit_int32_t,
1041                    jit_int32_t,jit_int32_t,jit_int32_t);
1042 #  define qdivi(r0,r1,r2,i0)            _qdivi(_jit,r0,r1,r2,i0)
1043 static void _qdivi(jit_state_t*,jit_int32_t,
1044                    jit_int32_t,jit_int32_t,jit_word_t);
1045 #  define qdivr_u(r0,r1,r2,r3)          _qdivr_u(_jit,r0,r1,r2,r3)
1046 static void _qdivr_u(jit_state_t*,jit_int32_t,
1047                      jit_int32_t,jit_int32_t,jit_int32_t);
1048 #  define qdivi_u(r0,r1,r2,i0)          _qdivi_u(_jit,r0,r1,r2,i0)
1049 static void _qdivi_u(jit_state_t*,jit_int32_t,
1050                      jit_int32_t,jit_int32_t,jit_word_t);
1051 #  if __WORDSIZE == 32
1052 #    define lshr(r0,r1,r2)              _lshr(_jit,r0,r1,r2)
1053 static void _lshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1054 #  else
1055 #    define lshr(r0,r1,r2)              SLLG(r0,r1,0,r2)
1056 #  endif
1057 #  define lshi(r0,r1,i0)                _lshi(_jit,r0,r1,i0)
1058 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1059 #  if __WORDSIZE == 32
1060 #    define rshr(r0,r1,r2)              _rshr(_jit,r0,r1,r2)
1061 static void _rshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1062 #  else
1063 #    define rshr(r0,r1,r2)              SRAG(r0,r1,0,r2)
1064 #  endif
1065 #  define rshi(r0,r1,i0)                _rshi(_jit,r0,r1,i0)
1066 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1067 #  if __WORDSIZE == 32
1068 #    define rshr_u(r0,r1,r2)            _rshr_u(_jit,r0,r1,r2)
1069 static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1070 #  else
1071 #    define rshr_u(r0,r1,r2)            SRLG(r0,r1,0,r2)
1072 #  endif
1073 #  define rshi_u(r0,r1,i0)              _rshi_u(_jit,r0,r1,i0)
1074 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1075 #  if __WORDSIZE == 32
1076 #    define negr(r0,r1)                 LCR(r0,r1)
1077 #  else
1078 #    define negr(r0,r1)                 LCGR(r0,r1)
1079 #  endif
1080 #  define comr(r0,r1)                   _comr(_jit,r0,r1)
1081 static void _comr(jit_state_t*,jit_int32_t,jit_int32_t);
1082 #  define andr(r0,r1,r2)                _andr(_jit,r0,r1,r2)
1083 static void _andr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1084 #  define andi(r0,r1,i0)                _andi(_jit,r0,r1,i0)
1085 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1086 #  define orr(r0,r1,r2)                 _orr(_jit,r0,r1,r2)
1087 static void _orr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1088 #  define ori(r0,r1,i0)                 _ori(_jit,r0,r1,i0)
1089 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1090 #  define xorr(r0,r1,r2)                _xorr(_jit,r0,r1,r2)
1091 static void _xorr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1092 #  define xori(r0,r1,i0)                _xori(_jit,r0,r1,i0)
1093 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1094 #  define extr_c(r0,r1)                 LGBR(r0,r1)
1095 #  define extr_uc(r0,r1)                LLGCR(r0,r1)
1096 #  define extr_s(r0,r1)                 LGHR(r0,r1)
1097 #  define extr_us(r0,r1)                LLGHR(r0,r1)
1098 #  if __WORDSIZE == 64
1099 #    define extr_i(r0,r1)               LGFR(r0,r1)
1100 #    define extr_ui(r0,r1)              LLGFR(r0,r1)
1101 #  endif
1102 #  define ldr_c(r0,r1)                  LGB(r0,0,0,r1)
1103 #  define ldi_c(r0,i0)                  _ldi_c(_jit,r0,i0)
1104 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
1105 #  define ldxr_c(r0,r1,r2)              _ldxr_c(_jit,r0,r1,r2)
1106 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1107 #  define ldxi_c(r0,r1,i0)              _ldxi_c(_jit,r0,r1,i0)
1108 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1109 #  define ldr_uc(r0,r1)                 LLGC(r0,0,0,r1)
1110 #  define ldi_uc(r0,i0)                 _ldi_uc(_jit,r0,i0)
1111 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
1112 #  define ldxr_uc(r0,r1,r2)             _ldxr_uc(_jit,r0,r1,r2)
1113 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1114 #  define ldxi_uc(r0,r1,i0)             _ldxi_uc(_jit,r0,r1,i0)
1115 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1116 #  if __WORDSIZE == 32
1117 #    define ldr_s(r0,r1)                LH(r0,0,0,r1)
1118 #  else
1119 #    define ldr_s(r0,r1)                LGH(r0,0,0,r1)
1120 #  endif
1121 #  define ldi_s(r0,i0)                  _ldi_s(_jit,r0,i0)
1122 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
1123 #  define ldxr_s(r0,r1,r2)              _ldxr_s(_jit,r0,r1,r2)
1124 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1125 #  define ldxi_s(r0,r1,i0)              _ldxi_s(_jit,r0,r1,i0)
1126 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1127 #  define ldr_us(r0,r1)                 LLGH(r0,0,0,r1)
1128 #  define ldi_us(r0,i0)                 _ldi_us(_jit,r0,i0)
1129 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
1130 #  define ldxr_us(r0,r1,r2)             _ldxr_us(_jit,r0,r1,r2)
1131 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1132 #  define ldxi_us(r0,r1,i0)             _ldxi_us(_jit,r0,r1,i0)
1133 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1134 #  if __WORDSIZE == 32
1135 #    define ldr_i(r0,r1)                LLGF(r0,0,0,r1)
1136 #  else
1137 #    define ldr_i(r0,r1)                LGF(r0,0,0,r1)
1138 #  endif
1139 #  define ldi_i(r0,i0)                  _ldi_i(_jit,r0,i0)
1140 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
1141 #  define ldxr_i(r0,r1,r2)              _ldxr_i(_jit,r0,r1,r2)
1142 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1143 #  define ldxi_i(r0,r1,i0)              _ldxi_i(_jit,r0,r1,i0)
1144 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1145 #  if __WORDSIZE == 64
1146 #    define ldr_ui(r0,r1)               LLGF(r0,0,0,r1)
1147 #    define ldi_ui(r0,i0)               _ldi_ui(_jit,r0,i0)
1148 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
1149 #    define ldxr_ui(r0,r1,r2)           _ldxr_ui(_jit,r0,r1,r2)
1150 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1151 #    define ldxi_ui(r0,r1,i0)           _ldxi_ui(_jit,r0,r1,i0)
1152 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1153 #    define ldr_l(r0,r1)                LG(r0,0,0,r1)
1154 #    define ldi_l(r0,i0)                _ldi_l(_jit,r0,i0)
1155 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
1156 #    define ldxr_l(r0,r1,r2)            _ldxr_l(_jit,r0,r1,r2)
1157 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1158 #    define ldxi_l(r0,r1,i0)            _ldxi_l(_jit,r0,r1,i0)
1159 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1160 #  endif
1161 #  define str_c(r0,r1)                  STC(r1,0,0,r0)
1162 #  define sti_c(i0,r0)                  _sti_c(_jit,i0,r0)
1163 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
1164 #  define stxr_c(r0,r1,r2)              _stxr_c(_jit,r0,r1,r2)
1165 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1166 #  define stxi_c(i0,r0,r1)              _stxi_c(_jit,i0,r0,r1)
1167 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1168 #  define str_s(r0,r1)                  STH(r1,0,0,r0)
1169 #  define sti_s(i0,r0)                  _sti_s(_jit,i0,r0)
1170 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
1171 #  define stxr_s(r0,r1,r2)              _stxr_s(_jit,r0,r1,r2)
1172 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1173 #  define stxi_s(i0,r0,r1)              _stxi_s(_jit,i0,r0,r1)
1174 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1175 #  define str_i(r0,r1)                  ST(r1,0,0,r0)
1176 #  define sti_i(i0,r0)                  _sti_i(_jit,i0,r0)
1177 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
1178 #  define stxr_i(r0,r1,r2)              _stxr_i(_jit,r0,r1,r2)
1179 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1180 #  define stxi_i(i0,r0,r1)              _stxi_i(_jit,i0,r0,r1)
1181 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1182 #  if __WORDSIZE == 64
1183 #    define str_l(r0,r1)                STG(r1,0,0,r0)
1184 #    define sti_l(i0,r0)                _sti_l(_jit,i0,r0)
1185 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
1186 #  define stxr_l(r0,r1,r2)              _stxr_l(_jit,r0,r1,r2)
1187 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1188 #  define stxi_l(i0,r0,r1)              _stxi_l(_jit,i0,r0,r1)
1189 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1190 #  endif
1191 #  define ltr(r0,r1,r2)                 crr(CC_L,r0,r1,r2)
1192 #  define lti(r0,r1,i0)                 cri(CC_L,r0,r1,i0)
1193 #  define ltr_u(r0,r1,r2)               crr_u(CC_L,r0,r1,r2)
1194 #  define lti_u(r0,r1,i0)               cri_u(CC_L,r0,r1,i0)
1195 #  define ler(r0,r1,r2)                 crr(CC_LE,r0,r1,r2)
1196 #  define lei(r0,r1,i0)                 cri(CC_LE,r0,r1,i0)
1197 #  define ler_u(r0,r1,r2)               crr_u(CC_LE,r0,r1,r2)
1198 #  define lei_u(r0,r1,i0)               cri_u(CC_LE,r0,r1,i0)
1199 #  define eqr(r0,r1,r2)                 crr(CC_E,r0,r1,r2)
1200 #  define eqi(r0,r1,i0)                 cri(CC_E,r0,r1,i0)
1201 #  define ger(r0,r1,r2)                 crr(CC_HE,r0,r1,r2)
1202 #  define gei(r0,r1,i0)                 cri(CC_HE,r0,r1,i0)
1203 #  define ger_u(r0,r1,r2)               crr_u(CC_HE,r0,r1,r2)
1204 #  define gei_u(r0,r1,i0)               cri_u(CC_HE,r0,r1,i0)
1205 #  define gtr(r0,r1,r2)                 crr(CC_H,r0,r1,r2)
1206 #  define gti(r0,r1,i0)                 cri(CC_H,r0,r1,i0)
1207 #  define gtr_u(r0,r1,r2)               crr_u(CC_H,r0,r1,r2)
1208 #  define gti_u(r0,r1,i0)               cri_u(CC_H,r0,r1,i0)
1209 #  define ner(r0,r1,r2)                 crr(CC_NE,r0,r1,r2)
1210 #  define nei(r0,r1,i0)                 cri(CC_NE,r0,r1,i0)
1211 #  define bltr(i0,r0,r1)                brr(CC_L,i0,r0,r1)
1212 #  define bltr_p(i0,r0,r1)              brr_p(CC_L,i0,r0,r1)
1213 #  define blti(i0,r0,i1)                bri(CC_L,i0,r0,i1)
1214 #  define blti_p(i0,r0,i1)              bri_p(CC_L,i0,r0,i1)
1215 #  define bltr_u(i0,r0,r1)              brr_u(CC_L,i0,r0,r1)
1216 #  define bltr_u_p(i0,r0,r1)            brr_u_p(CC_L,i0,r0,r1)
1217 #  define blti_u(i0,r0,i1)              bri_u(CC_L,i0,r0,i1)
1218 #  define blti_u_p(i0,r0,i1)            bri_u_p(CC_L,i0,r0,i1)
1219 #  define bler(i0,r0,r1)                brr(CC_LE,i0,r0,r1)
1220 #  define bler_p(i0,r0,r1)              brr_p(CC_LE,i0,r0,r1)
1221 #  define blei(i0,r0,i1)                bri(CC_LE,i0,r0,i1)
1222 #  define blei_p(i0,r0,i1)              bri_p(CC_LE,i0,r0,i1)
1223 #  define bler_u(i0,r0,r1)              brr_u(CC_LE,i0,r0,r1)
1224 #  define bler_u_p(i0,r0,r1)            brr_u_p(CC_LE,i0,r0,r1)
1225 #  define blei_u(i0,r0,i1)              bri_u(CC_LE,i0,r0,i1)
1226 #  define blei_u_p(i0,r0,i1)            bri_u_p(CC_LE,i0,r0,i1)
1227 #  define beqr(i0,r0,r1)                brr(CC_E,i0,r0,r1)
1228 #  define beqr_p(i0,r0,r1)              brr_p(CC_E,i0,r0,r1)
1229 #  define beqi(i0,r0,i1)                bri(CC_E,i0,r0,i1)
1230 #  define beqi_p(i0,r0,i1)              bri_p(CC_E,i0,r0,i1)
1231 #  define bger(i0,r0,r1)                brr(CC_HE,i0,r0,r1)
1232 #  define bger_p(i0,r0,r1)              brr_p(CC_HE,i0,r0,r1)
1233 #  define bgei(i0,r0,i1)                bri(CC_HE,i0,r0,i1)
1234 #  define bgei_p(i0,r0,i1)              bri_p(CC_HE,i0,r0,i1)
1235 #  define bger_u(i0,r0,r1)              brr_u(CC_HE,i0,r0,r1)
1236 #  define bger_u_p(i0,r0,r1)            brr_u_p(CC_HE,i0,r0,r1)
1237 #  define bgei_u(i0,r0,i1)              bri_u(CC_HE,i0,r0,i1)
1238 #  define bgei_u_p(i0,r0,i1)            bri_u_p(CC_HE,i0,r0,i1)
1239 #  define bgtr(i0,r0,r1)                brr(CC_H,i0,r0,r1)
1240 #  define bgtr_p(i0,r0,r1)              brr_p(CC_H,i0,r0,r1)
1241 #  define bgti(i0,r0,i1)                bri(CC_H,i0,r0,i1)
1242 #  define bgti_p(i0,r0,i1)              bri_p(CC_H,i0,r0,i1)
1243 #  define bgtr_u(i0,r0,r1)              brr_u(CC_H,i0,r0,r1)
1244 #  define bgtr_u_p(i0,r0,r1)            brr_u_p(CC_H,i0,r0,r1)
1245 #  define bgti_u(i0,r0,i1)              bri_u(CC_H,i0,r0,i1)
1246 #  define bgti_u_p(i0,r0,i1)            bri_u_p(CC_H,i0,r0,i1)
1247 #  define bner(i0,r0,r1)                brr(CC_NE,i0,r0,r1)
1248 #  define bner_p(i0,r0,r1)              brr_p(CC_NE,i0,r0,r1)
1249 #  define bnei(i0,r0,i1)                bri(CC_NE,i0,r0,i1)
1250 #  define bnei_p(i0,r0,i1)              bri_p(CC_NE,i0,r0,i1)
1251 #  define boaddr(i0,r0,r1)              baddr(CC_O,1,i0,r0,r1)
1252 #  define boaddr_p(i0,r0,r1)            baddr_p(CC_O,1,i0,r0,r1)
1253 #  define boaddi(i0,r0,i1)              baddi(CC_O,1,i0,r0,i1)
1254 #  define boaddi_p(i0,r0,i1)            baddi_p(CC_O,1,i0,r0,i1)
1255 #  define boaddr_u(i0,r0,r1)            baddr(CC_NLE,0,i0,r0,r1)
1256 #  define boaddr_u_p(i0,r0,r1)          baddr_p(CC_NLE,0,i0,r0,r1)
1257 #  define boaddi_u(i0,r0,i1)            baddi(CC_NLE,0,i0,r0,i1)
1258 #  define boaddi_u_p(i0,r0,i1)          baddi_p(CC_NLE,0,i0,r0,i1)
1259 #  define bxaddr(i0,r0,r1)              baddr(CC_NO,1,i0,r0,r1)
1260 #  define bxaddr_p(i0,r0,r1)            baddr_p(CC_NO,1,i0,r0,r1)
1261 #  define bxaddi(i0,r0,i1)              baddi(CC_NO,1,i0,r0,i1)
1262 #  define bxaddi_p(i0,r0,i1)            baddi_p(CC_NO,1,i0,r0,i1)
1263 #  define bxaddr_u(i0,r0,r1)            baddr(CC_LE,0,i0,r0,r1)
1264 #  define bxaddr_u_p(i0,r0,r1)          baddr_p(CC_LE,0,i0,r0,r1)
1265 #  define bxaddi_u(i0,r0,i1)            baddi(CC_LE,0,i0,r0,i1)
1266 #  define bxaddi_u_p(i0,r0,i1)          baddi_p(CC_LE,0,i0,r0,i1)
1267 #  define bosubr(i0,r0,r1)              bsubr(CC_O,1,i0,r0,r1)
1268 #  define bosubr_p(i0,r0,r1)            bsubr_p(CC_O,1,i0,r0,r1)
1269 #  define bosubi(i0,r0,i1)              bsubi(CC_O,1,i0,r0,i1)
1270 #  define bosubi_p(i0,r0,i1)            bsubi_p(CC_O,1,i0,r0,i1)
1271 #  define bosubr_u(i0,r0,r1)            bsubr(CC_L,0,i0,r0,r1)
1272 #  define bosubr_u_p(i0,r0,r1)          bsubr_p(CC_L,0,i0,r0,r1)
1273 #  define bosubi_u(i0,r0,i1)            bsubi(CC_L,0,i0,r0,i1)
1274 #  define bosubi_u_p(i0,r0,i1)          bsubi_p(CC_L,0,i0,r0,i1)
1275 #  define bxsubr(i0,r0,r1)              bsubr(CC_NO,1,i0,r0,r1)
1276 #  define bxsubr_p(i0,r0,r1)            bsubr_p(CC_NO,1,i0,r0,r1)
1277 #  define bxsubi(i0,r0,i1)              bsubi(CC_NO,1,i0,r0,i1)
1278 #  define bxsubi_p(i0,r0,i1)            bsubi_p(CC_NO,1,i0,r0,i1)
1279 #  define bxsubr_u(i0,r0,r1)            bsubr(CC_NL,0,i0,r0,r1)
1280 #  define bxsubr_u_p(i0,r0,r1)          bsubr_p(CC_NL,0,i0,r0,r1)
1281 #  define bxsubi_u(i0,r0,i1)            bsubi(CC_NL,0,i0,r0,i1)
1282 #  define bxsubi_u_p(i0,r0,i1)          bsubi_p(CC_NL,0,i0,r0,i1)
1283 #  define bmsr(i0,r0,r1)                bmxr(CC_NE,i0,r0,r1)
1284 #  define bmsr_p(i0,r0,r1)              bmxr_p(CC_NE,i0,r0,r1)
1285 #  define bmsi(i0,r0,i1)                bmxi(CC_NE,i0,r0,i1)
1286 #  define bmsi_p(i0,r0,i1)              bmxi_p(CC_NE,i0,r0,i1)
1287 #  define bmcr(i0,r0,r1)                bmxr(CC_E,i0,r0,r1)
1288 #  define bmcr_p(i0,r0,r1)              bmxr_p(CC_E,i0,r0,r1)
1289 #  define bmci(i0,r0,i1)                bmxi(CC_E,i0,r0,i1)
1290 #  define bmci_p(i0,r0,i1)              bmxi_p(CC_E,i0,r0,i1)
1291 #  define jmpr(r0)                      BR(r0)
1292 #  define jmpi(i0)                      _jmpi(_jit,i0)
1293 static void _jmpi(jit_state_t*,jit_word_t);
1294 #  define jmpi_p(i0)                    _jmpi_p(_jit,i0)
1295 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
1296 #  define callr(r0)                     BALR(_R14_REGNO,r0)
1297 #  define calli(i0)                     _calli(_jit,i0)
1298 static void _calli(jit_state_t*,jit_word_t);
1299 #  define calli_p(i0)                   _calli_p(_jit,i0)
1300 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
1301 #  define prolog(i0)                    _prolog(_jit,i0)
1302 static void _prolog(jit_state_t*,jit_node_t*);
1303 #  define epilog(i0)                    _epilog(_jit,i0)
1304 static void _epilog(jit_state_t*,jit_node_t*);
1305 #  define vastart(r0)                   _vastart(_jit, r0)
1306 static void _vastart(jit_state_t*, jit_int32_t);
1307 #  define vaarg(r0, r1)                 _vaarg(_jit, r0, r1)
1308 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
1309 #  define patch_at(instr,label)         _patch_at(_jit,instr,label)
1310 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
1311 #endif
1312
1313 #if CODE
1314 #  define _us                           jit_uint16_t
1315 #  define _ui                           jit_uint32_t
1316 static void
1317 _E(jit_state_t *_jit, _ui Op)
1318 {
1319     union {
1320         struct {
1321             _us op;
1322         } b;
1323         _us     s;
1324     } i0;
1325     i0.b.op = Op;
1326     assert(i0.b.op == Op);
1327     is(i0.s);
1328 }
1329
1330 static void
1331 _I(jit_state_t *_jit, _ui Op, _ui I)
1332 {
1333     union {
1334         struct {
1335             _us op : 8;
1336             _us i  : 8;
1337         } b;
1338         _us     s;
1339     } i0;
1340     i0.b.op = Op;
1341     i0.b.i  = I;
1342     assert(i0.b.op == Op);
1343     assert(i0.b.i  == I);
1344     is(i0.s);
1345 }
1346
1347 static void
1348 _RR(jit_state_t *_jit, _ui Op, _ui R1, _ui R2)
1349 {
1350     union {
1351         struct {
1352             _us op : 8;
1353             _us r1 : 4;
1354             _us r2 : 4;
1355         } b;
1356         _us     s;
1357     } i0;
1358     i0.b.op = Op;
1359     i0.b.r1 = R1;
1360     i0.b.r2 = R2;
1361     assert(i0.b.op == Op);
1362     assert(i0.b.r1 == R1);
1363     assert(i0.b.r2 == R2);
1364     is(i0.s);
1365 }
1366
1367 static void
1368 _RRE(jit_state_t *_jit, _ui Op, _ui R1, _ui R2)
1369 {
1370     union {
1371         struct {
1372             _us op;
1373         } b;
1374         _us     s;
1375     } i0;
1376     union {
1377         struct {
1378             _us _  : 8;
1379             _us r1 : 4;
1380             _us r2 : 4;
1381         } b;
1382         _us     s;
1383     } i1;
1384     i0.b.op = Op;
1385     i1.b._ = 0;
1386     i1.b.r1 = R1;
1387     i1.b.r2 = R2;
1388     assert(i0.b.op == Op);
1389     assert(i1.b.r1 == R1);
1390     assert(i1.b.r2 == R2);
1391     is(i0.s);
1392     is(i1.s);
1393 }
1394
1395 static void
1396 _RRF(jit_state_t *_jit, _ui Op, _ui R3, _ui M4, _ui R1, _ui R2)
1397 {
1398     union {
1399         struct {
1400             _us op;
1401         } b;
1402         _us     s;
1403     } i0;
1404     union {
1405         struct {
1406             _us r3 : 4;
1407             _us m4 : 4;
1408             _us r1 : 4;
1409             _us r2 : 4;
1410         } b;
1411         _us     s;
1412     } i1;
1413     i0.b.op = Op;
1414     i1.b.r3 = R3;
1415     i1.b.m4 = M4;
1416     i1.b.r1 = R1;
1417     i1.b.r2 = R2;
1418     assert(i0.b.op == Op);
1419     assert(i1.b.r3 == R3);
1420     assert(i1.b.m4 == M4);
1421     assert(i1.b.r1 == R1);
1422     assert(i1.b.r2 == R2);
1423     is(i0.s);
1424     is(i1.s);
1425 }
1426
1427 static void
1428 _RX(jit_state_t *_jit, _ui Op, _ui R1, _ui X2, _ui B2, _ui D2)
1429 {
1430     union {
1431         struct {
1432             _us op :  8;
1433             _us r1 :  4;
1434             _us x2 :  4;
1435         } b;
1436         _us     s;
1437     } i0;
1438     union {
1439         struct {
1440             _us b2 :  4;
1441             _us d2 : 12;
1442         } b;
1443         _us     s;
1444     } i1;
1445     i0.b.op = Op;
1446     i0.b.r1 = R1;
1447     i0.b.x2 = X2;
1448     i1.b.b2 = B2;
1449     i1.b.d2 = D2;
1450     assert(i0.b.op == Op);
1451     assert(i0.b.r1 == R1);
1452     assert(i0.b.x2 == X2);
1453     assert(i1.b.b2 == B2);
1454     assert(i1.b.d2 == D2);
1455     is(i0.s);
1456     is(i1.s);
1457 }
1458
1459 static void
1460 _RXE(jit_state_t *_jit, _ui Op, _ui R1, _ui X2, _ui B2, _ui D2, _ui Op2)
1461 {
1462     union {
1463         struct {
1464             _us op :  8;
1465             _us r1 :  4;
1466             _us x2 :  4;
1467         } b;
1468         _us     s;
1469     } i0;
1470     union {
1471         struct {
1472             _us b2 :  4;
1473             _us d2 : 12;
1474         } b;
1475         _ui     s;
1476     } i1;
1477     union {
1478         struct {
1479             _us _  :  8;
1480             _us op :  8;
1481         } b;
1482         _us     s;
1483     } i2;
1484     i2.b._ = 0;
1485     i0.b.op = Op;
1486     i0.b.r1 = R1;
1487     i0.b.x2 = X2;
1488     i1.b.b2 = B2;
1489     i1.b.d2 = D2;
1490     i2.b.op = Op2;
1491     assert(i0.b.op == Op);
1492     assert(i0.b.r1 == R1);
1493     assert(i0.b.x2 == X2);
1494     assert(i1.b.b2 == B2);
1495     assert(i1.b.d2 == D2);
1496     assert(i2.b.op == Op2);
1497     is(i0.s);
1498     is(i1.s);
1499     is(i2.s);
1500 }
1501
1502 static void
1503 _RXF(jit_state_t *_jit, _ui Op, _ui R3, _ui X2, _ui B2, _ui D2, _ui R1, _ui Op2)
1504 {
1505     union {
1506         struct {
1507             _us op :  8;
1508             _us r3 :  4;
1509             _us x2 :  4;
1510         } b;
1511         _us     s;
1512     } i0;
1513     union {
1514         struct {
1515             _us b2 :  4;
1516             _us d2 : 12;
1517         } b;
1518         _us     s;
1519     } i1;
1520     union {
1521         struct {
1522             _us r1 :  4;
1523             _us _  :  4;
1524             _us op :  8;
1525         } b;
1526         _us     s;
1527     } i2;
1528     i2.b._ = 0;
1529     i0.b.op = Op;
1530     i0.b.r3 = R3;
1531     i0.b.x2 = X2;
1532     i1.b.b2 = B2;
1533     i1.b.d2 = D2;
1534     i2.b.r1 = R1;
1535     i2.b.op = Op2;
1536     assert(i0.b.op == Op);
1537     assert(i0.b.r3 == R3);
1538     assert(i0.b.x2 == X2);
1539     assert(i1.b.b2 == B2);
1540     assert(i1.b.d2 == D2);
1541     assert(i2.b.r1 == R1);
1542     assert(i2.b.op == Op2);
1543     is(i0.s);
1544     is(i1.s);
1545     is(i2.s);
1546 }
1547
1548 static void
1549 _RXY(jit_state_t *_jit, _ui Op, _ui R1, _ui X2, _ui B2, _ui D2, _ui Op2)
1550 {
1551     union {
1552         struct {
1553             _us op :  8;
1554             _us r1 :  4;
1555             _us x2 :  4;
1556         } b;
1557         _us     s;
1558     } i0;
1559     union {
1560         struct {
1561             _us b2 :  4;
1562             _us dl : 12;
1563         } b;
1564         _us     s;
1565     } i1;
1566     union {
1567         struct {
1568             _us dh :  8;
1569             _us op :  8;
1570         } b;
1571         _us     s;
1572     } i2;
1573     i0.s = i1.s = i2.s = 0;
1574     i0.b.op = Op;
1575     i0.b.r1 = R1;
1576     i0.b.x2 = X2;
1577     i1.b.b2 = B2;
1578     i1.b.dl = D2 & 0xfff;
1579     i2.b.dh = D2 >> 12;
1580     i2.b.op = Op2;
1581     assert(i0.b.op == Op);
1582     assert(i0.b.r1 == R1);
1583     assert(i0.b.x2 == X2);
1584     assert(i1.b.b2 == B2);
1585     assert(i2.b.dh == D2 >> 12);
1586     assert(i2.b.op == Op2);
1587     is(i0.s);
1588     is(i1.s);
1589     is(i2.s);
1590 }
1591
1592 static void
1593 _RS(jit_state_t *_jit, _ui Op, _ui R1, _ui R3, _ui B2, _ui D2)
1594 {
1595     union {
1596         struct {
1597             _us op :  8;
1598             _us r1 :  4;
1599             _us r3 :  4;
1600         } b;
1601         _us     s;
1602     } i0;
1603     union {
1604         struct {
1605             _us b2 :  4;
1606             _us d2 : 12;
1607         } b;
1608         _us     s;
1609     } i1;
1610     i0.s = i1.s = 0;
1611     i0.b.op = Op;
1612     i0.b.r1 = R1;
1613     i0.b.r3 = R3;
1614     i1.b.b2 = B2;
1615     i1.b.d2 = D2;
1616     assert(i0.b.op == Op);
1617     assert(i0.b.r1 == R1);
1618     assert(i0.b.r3 == R3);
1619     assert(i1.b.b2 == B2);
1620     assert(i1.b.d2 == D2);
1621     is(i0.s);
1622     is(i1.s);
1623 }
1624
1625 static void
1626 _RSL(jit_state_t *_jit, _ui Op, _ui L1, _ui B1, _ui D1, _ui Op2)
1627 {
1628     union {
1629         struct {
1630             _us op :  8;
1631             _us l1 :  4;
1632             _us _  :  4;
1633         } b;
1634         _us     s;
1635     } i0;
1636     union {
1637         struct {
1638             _us b1 :  4;
1639             _us d1 : 12;
1640         } b;
1641         _us     s;
1642     } i1;
1643     union {
1644         struct {
1645             _us _  :  8;
1646             _us op :  8;
1647         } b;
1648         _us     s;
1649     } i2;
1650     i0.b._ = 0;
1651     i2.b._ = 0;
1652     i0.b.op = Op;
1653     i0.b.l1 = L1;
1654     i1.b.b1 = B1;
1655     i1.b.d1 = D1;
1656     i2.b.op = Op2;
1657     assert(i0.b.op == Op);
1658     assert(i0.b.l1 == L1);
1659     assert(i1.b.b1 == B1);
1660     assert(i1.b.d1 == D1);
1661     assert(i2.b.op == Op2);
1662     is(i0.s);
1663     is(i1.s);
1664     is(i2.s);
1665 }
1666
1667 static void
1668 _RSI(jit_state_t *_jit, _ui Op, _ui R1, _ui R3, _ui I2)
1669 {
1670     union {
1671         struct {
1672             _us op :  8;
1673             _us r1 :  4;
1674             _us r3 :  4;
1675         } b;
1676         _us     s;
1677     } i0;
1678     union {
1679         struct {
1680             _us i2;
1681         } b;
1682         _us     s;
1683     } i1;
1684     i0.b.op = Op;
1685     i0.b.r1 = R1;
1686     i0.b.r3 = R3;
1687     i1.b.i2 = I2;
1688     assert(i0.b.op == Op);
1689     assert(i0.b.r1 == R1);
1690     assert(i0.b.r3 == R3);
1691     assert(i1.b.i2 == I2);
1692     is(i0.s);
1693     is(i1.s);
1694 }
1695
1696 static void
1697 _RIE(jit_state_t *_jit, _ui Op, _ui R1, _ui R3, _ui I2, _ui Op2)
1698 {
1699     union {
1700         struct {
1701             _us op :  8;
1702             _us r1 :  4;
1703             _us r3 :  4;
1704         } b;
1705         _us     s;
1706     } i0;
1707     union {
1708         struct {
1709             _us i2;
1710         } b;
1711         _us     s;
1712     } i1;
1713     union {
1714         struct {
1715             _us _  :  8;
1716             _us op :  8;
1717         } b;
1718         _us     s;
1719     } i2;
1720     i2.b._ = 0;
1721     i0.b.op = Op;
1722     i0.b.r1 = R1;
1723     i0.b.r3 = R3;
1724     i1.b.i2 = I2;
1725     i2.b.op = Op2;
1726     assert(i0.b.op == Op);
1727     assert(i0.b.r1 == R1);
1728     assert(i0.b.r3 == R3);
1729     assert(i1.b.i2 == I2);
1730     assert(i2.b.op == Op2);
1731     is(i0.s);
1732     is(i1.s);
1733     is(i2.s);
1734 }
1735
1736 static void
1737 _RIL(jit_state_t *_jit, _ui Op, _ui R1, _ui Op2, _ui I2)
1738 {
1739     union {
1740         struct {
1741             _us o1 :  8;
1742             _us r1 :  4;
1743             _us o2 :  4;
1744         } b;
1745         _us     s;
1746     } i0;
1747     union {
1748         struct {
1749             _ui ih : 16;
1750             _ui il : 16;
1751         } b;
1752         _ui     i;
1753     } i12;
1754     i0.b.o1 = Op;
1755     i0.b.r1 = R1;
1756     i0.b.o2 = Op2;
1757     i12.i   = I2;
1758     assert(i0.b.o1 == Op);
1759     assert(i0.b.r1 == R1);
1760     assert(i0.b.o2 == Op2);
1761     is(i0.s);
1762     is(i12.b.ih);
1763     is(i12.b.il);
1764 }
1765
1766 static void
1767 _SI(jit_state_t *_jit, _ui Op, _ui I2, _ui B1, _ui D1)
1768 {
1769     union {
1770         struct {
1771             _us op :  8;
1772             _us i2 :  8;
1773         } b;
1774         _us     s;
1775     } i0;
1776     union {
1777         struct {
1778             _us b1 :  4;
1779             _us d1 : 12;
1780         } b;
1781         _us     s;
1782     } i1;
1783     i0.b.op = Op;
1784     i0.b.i2 = I2;
1785     i1.b.b1 = B1;
1786     i1.b.d1 = D1;
1787     assert(i0.b.op == Op);
1788     assert(i0.b.i2 == I2);
1789     assert(i1.b.b1 == B1);
1790     assert(i1.b.d1 == D1);
1791     is(i0.s);
1792     is(i1.s);
1793 }
1794
1795 static void
1796 _SIY(jit_state_t *_jit, _ui Op, _ui I2, _ui B1, _ui D1, _ui Op2)
1797 {
1798     union {
1799         struct {
1800             _us op :  8;
1801             _us i2 :  8;
1802         } b;
1803         _us     s;
1804     } i0;
1805     union {
1806         struct {
1807             _us b1 :  4;
1808             _us dl : 12;
1809         } b;
1810         _us     s;
1811     } i1;
1812     union {
1813         struct {
1814             _us dh :  8;
1815             _us op :  8;
1816         } b;
1817         _us     s;
1818     } i2;
1819     i0.b.op = Op;
1820     i0.b.i2 = I2;
1821     i1.b.b1 = B1;
1822     i1.b.dl = D1 & 0xfff;
1823     i2.b.dh = D1 >> 8;
1824     i2.b.op = Op2;
1825     assert(i0.b.op == Op);
1826     assert(i0.b.i2 == I2);
1827     assert(i1.b.b1 == B1);
1828     assert(i2.b.dh == D1 >> 8);
1829     assert(i2.b.op == Op2);
1830     is(i0.s);
1831     is(i1.s);
1832     is(i2.s);
1833 }
1834
1835 static void
1836 _S(jit_state_t *_jit, _ui Op, _ui B2, _ui D2)
1837 {
1838     union {
1839         struct {
1840             _us op;
1841         } b;
1842         _us     s;
1843     } i0;
1844     union {
1845         struct {
1846             _us b2 :  4;
1847             _us d2 : 12;
1848         } b;
1849         _us     s;
1850     } i1;
1851     i0.b.op = Op;
1852     i1.b.b2 = B2;
1853     i1.b.d2 = D2;
1854     assert(i0.b.op == Op);
1855     assert(i1.b.b2 == B2);
1856     assert(i1.b.d2 == D2);
1857     is(i0.s);
1858     is(i1.s);
1859 }
1860
1861 static void
1862 _SS(jit_state_t *_jit, _ui Op, _ui LL, _ui LH, _ui B1, _ui D1, _ui B2, _ui D2)
1863 {
1864     union {
1865         struct {
1866             _us op :  8;
1867             _us ll :  4;
1868             _us lh :  4;
1869         } b;
1870         _us     s;
1871     } i0;
1872     union {
1873         struct {
1874             _us b1 :  4;
1875             _us d1 : 12;
1876         } b;
1877         _us     s;
1878     } i1;
1879     union {
1880         struct {
1881             _us b2 :  4;
1882             _us d2 : 12;
1883         } b;
1884         _us     s;
1885     } i2;
1886     i0.b.op = Op;
1887     i0.b.ll = LL;
1888     i0.b.lh = LH;
1889     i1.b.b1 = B1;
1890     i1.b.d1 = D1;
1891     i2.b.b2 = B2;
1892     i2.b.d2 = D2;
1893     assert(i0.b.op == Op);
1894     assert(i0.b.ll == LL);
1895     assert(i0.b.lh == LH);
1896     assert(i1.b.b1 == B1);
1897     assert(i1.b.d1 == D1);
1898     assert(i2.b.b2 == B2);
1899     assert(i2.b.d2 == D2);
1900     is(i0.s);
1901     is(i1.s);
1902     is(i2.s);
1903 }
1904
1905 static void
1906 _SSE(jit_state_t *_jit, _ui Op, _ui B1, _ui D1, _ui B2, _ui D2)
1907 {
1908     union {
1909         struct {
1910             _us op;
1911         } b;
1912         _us     s;
1913     } i0;
1914     union {
1915         struct {
1916             _us b1 :  4;
1917             _us d1 : 12;
1918         } b;
1919         _us     s;
1920     } i1;
1921     union {
1922         struct {
1923             _us b2 :  4;
1924             _us d2 : 12;
1925         } b;
1926         _us     s;
1927     } i2;
1928     i0.b.op = Op;
1929     i1.b.b1 = B1;
1930     i1.b.d1 = D1;
1931     i2.b.b2 = B2;
1932     i2.b.d2 = D2;
1933     assert(i0.b.op == Op);
1934     assert(i1.b.b1 == B1);
1935     assert(i1.b.d1 == D1);
1936     assert(i2.b.b2 == B2);
1937     assert(i2.b.d2 == D2);
1938     is(i0.s);
1939     is(i1.s);
1940     is(i2.s);
1941 }
1942 #  undef _us
1943 #  undef _ui
1944
1945 static void
1946 _nop(jit_state_t *_jit, jit_int32_t c)
1947 {
1948     assert(c >= 0 && !(c & 1));
1949     while (c) {
1950         NOPR(_R7_REGNO);
1951         c -= 2;
1952     }
1953 }
1954
1955 static jit_int32_t
1956 _xdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1957 {
1958     jit_int32_t         regno;
1959     regno = jit_get_reg_pair();
1960 #if __WORDSIZE == 32
1961     movr(rn(regno), r0);
1962     SRDA(rn(regno), 32, 0);
1963 #else
1964     movr(rn(regno) + 1, r0);
1965 #endif
1966     DIVREM_(rn(regno), r1);
1967     jit_unget_reg_pair(regno);
1968     return (regno);
1969 }
1970
1971 static jit_int32_t
1972 _xdivr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1973 {
1974     jit_int32_t         regno;
1975     regno = jit_get_reg_pair();
1976 #if __WORDSIZE == 32
1977     movr(rn(regno), r0);
1978     SRDL(rn(regno), 32, 0);
1979 #else
1980     movr(rn(regno) + 1, r0);
1981 #endif
1982     movi(rn(regno), 0);
1983     DIVREMU_(rn(regno), r1);
1984     jit_unget_reg_pair(regno);
1985     return (regno);
1986 }
1987
1988 static jit_int32_t
1989 _xdivi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1990 {
1991     jit_int32_t         imm, regno;
1992     regno = jit_get_reg_pair();
1993     imm = jit_get_reg(jit_class_gpr);
1994 #if __WORDSIZE == 32
1995     movr(rn(regno), r0);
1996     SRDA(rn(regno), 32, 0);
1997 #else
1998     movr(rn(regno) + 1, r0);
1999 #endif
2000     movi(rn(imm), i0);
2001     DIVREM_(rn(regno), rn(imm));
2002     jit_unget_reg(imm);
2003     jit_unget_reg_pair(regno);
2004     return (regno);
2005 }
2006
2007 static jit_int32_t
2008 _xdivi_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2009 {
2010     /* cannot overlap because operand is 128-bit */
2011     jit_int32_t         imm, regno;
2012     regno = jit_get_reg_pair();
2013     imm = jit_get_reg(jit_class_gpr);
2014 #if __WORDSIZE == 32
2015     movr(rn(regno), r0);
2016     SRDL(rn(regno), 32, 0);
2017 #else
2018     movr(rn(regno) + 1, r0);
2019 #endif
2020     movi(rn(regno), 0);
2021     movi(rn(imm), i0);
2022     DIVREMU_(rn(regno), rn(imm));
2023     jit_unget_reg(imm);
2024     jit_unget_reg_pair(regno);
2025     return (regno);
2026 }
2027
2028 static void
2029 _crr(jit_state_t *_jit, jit_int32_t cc,
2030      jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2031 {
2032     jit_word_t          w;
2033     jit_int32_t         reg, rg;
2034     if (r0 == r1 || r0 == r2) {
2035         reg = jit_get_reg(jit_class_gpr);
2036         rg = rn(reg);
2037     }
2038     else
2039         rg = r0;
2040     movi(rg, 1);
2041     CMP_(r1, r2);
2042     w = _jit->pc.w;
2043     BRC(cc, 0);
2044     movi(rg, 0);
2045     patch_at(w, _jit->pc.w);
2046     if (r0 == r1 || r0 == r2) {
2047         movr(r0, rg);
2048         jit_unget_reg(reg);
2049     }
2050 }
2051
2052 static void
2053 _cri(jit_state_t *_jit, jit_int32_t cc,
2054      jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2055 {
2056     jit_int32_t         reg;
2057     reg = jit_get_reg(jit_class_gpr);
2058     movi(rn(reg), i0);
2059     crr(cc, r0, r1, rn(reg));
2060     jit_unget_reg(reg);
2061 }
2062
2063 static void
2064 _crr_u(jit_state_t *_jit, jit_int32_t cc,
2065        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2066 {
2067     jit_word_t          w;
2068     jit_int32_t         reg, rg;
2069     if (r0 == r1 || r0 == r2) {
2070         reg = jit_get_reg(jit_class_gpr);
2071         rg = rn(reg);
2072     }
2073     else
2074         rg = r0;
2075     movi(rg, 1);
2076     CMPU_(r1, r2);
2077     w = _jit->pc.w;
2078     BRC(cc, 0);
2079     movi(rg, 0);
2080     patch_at(w, _jit->pc.w);
2081     if (r0 == r1 || r0 == r2) {
2082         movr(r0, rg);
2083         jit_unget_reg(reg);
2084     }
2085 }
2086
2087 static void
2088 _cri_u(jit_state_t *_jit, jit_int32_t cc,
2089        jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2090 {
2091     jit_int32_t         reg;
2092     reg = jit_get_reg(jit_class_gpr);
2093     movi(rn(reg), i0);
2094     crr_u(cc, r0, r1, rn(reg));
2095     jit_unget_reg(reg);
2096 }
2097
2098 static void
2099 _brr(jit_state_t *_jit, jit_int32_t cc,
2100      jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2101 {
2102     jit_word_t          d;
2103     CMP_(r0, r1);
2104     d = (i0 - _jit->pc.w) >> 1;
2105     if (s16_p(d))
2106         BRC(cc, x16(d));
2107     else {
2108         assert(s32_p(d));
2109         BRCL(cc, d);
2110     }
2111 }
2112
2113 static jit_word_t
2114 _brr_p(jit_state_t *_jit, jit_int32_t cc,
2115        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2116 {
2117     jit_word_t          w;
2118     CMP_(r0, r1);
2119     w = _jit->pc.w;
2120     BRCL(cc, 0);
2121     return (w);
2122 }
2123
2124 static void
2125 _bri(jit_state_t *_jit, jit_int32_t cc,
2126      jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2127 {
2128     jit_int32_t         reg;
2129     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2130     movi(rn(reg), i1);
2131     brr(cc, i0, r0, rn(reg));
2132     jit_unget_reg(reg);
2133 }
2134
2135 static jit_word_t
2136 _bri_p(jit_state_t *_jit, jit_int32_t cc,
2137      jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2138 {
2139     jit_word_t          w;
2140     jit_int32_t         reg;
2141     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2142     movi(rn(reg), i1);
2143     w = brr_p(cc, i0, r0, rn(reg));
2144     jit_unget_reg(reg);
2145     return (w);
2146 }
2147
2148 static void
2149 _brr_u(jit_state_t *_jit, jit_int32_t cc,
2150        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2151 {
2152     jit_word_t          d;
2153     CMPU_(r0, r1);
2154     d = (i0 - _jit->pc.w) >> 1;
2155     if (s16_p(d))
2156         BRC(cc, x16(d));
2157     else {
2158         assert(s32_p(d));
2159         BRCL(cc, d);
2160     }
2161 }
2162
2163 static jit_word_t
2164 _brr_u_p(jit_state_t *_jit, jit_int32_t cc,
2165          jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2166 {
2167     jit_word_t          w;
2168     CMPU_(r0, r1);
2169     w = _jit->pc.w;
2170     BRCL(cc, 0);
2171     return (w);
2172 }
2173
2174 static void
2175 _bri_u(jit_state_t *_jit, jit_int32_t cc,
2176        jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2177 {
2178     jit_int32_t         reg;
2179     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2180     movi(rn(reg), i1);
2181     brr_u(cc, i0, r0, rn(reg));
2182     jit_unget_reg(reg);
2183 }
2184
2185 static jit_word_t
2186 _bri_u_p(jit_state_t *_jit, jit_int32_t cc,
2187          jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2188 {
2189     jit_word_t          w;
2190     jit_int32_t         reg;
2191     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2192     movi(rn(reg), i1);
2193     w = brr_u_p(cc, i0, r0, rn(reg));
2194     jit_unget_reg(reg);
2195     return (w);
2196 }
2197
2198 static void
2199 _baddr(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2200        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2201 {
2202     jit_word_t          d;
2203     if (s)              addr(r0, r0, r1);
2204     else                addcr(r0, r0, r1);
2205     d = (i0 - _jit->pc.w) >> 1;
2206     if (s16_p(d))
2207         BRC(c, x16(d));
2208     else {
2209         assert(s32_p(d));
2210         BRCL(c, d);
2211     }
2212 }
2213
2214 static void
2215 _baddi(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2216        jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2217 {
2218     jit_int32_t         reg;
2219     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2220     movi(rn(reg), i1);
2221     baddr(c, s, i0, r0, rn(reg));
2222     jit_unget_reg(reg);
2223 }
2224
2225 static jit_word_t
2226 _baddr_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2227          jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2228 {
2229     jit_word_t          d, w;
2230     if (s)              addr(r0, r0, r1);
2231     else                addcr(r0, r0, r1);
2232     d = (i0 - _jit->pc.w) >> 1;
2233     w = _jit->pc.w;
2234     BRCL(c, d);
2235     return (w);
2236 }
2237
2238 static jit_word_t
2239 _baddi_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2240          jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2241 {
2242     jit_word_t          w;
2243     jit_int32_t         reg;
2244     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2245     movi(rn(reg), i1);
2246     w = baddr_p(c, s, i0, r0, rn(reg));
2247     jit_unget_reg(reg);
2248     return (w);
2249 }
2250
2251 static void
2252 _bsubr(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2253        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2254 {
2255     jit_word_t          d;
2256     if (s)              subr(r0, r0, r1);
2257     else                subcr(r0, r0, r1);
2258     d = (i0 - _jit->pc.w) >> 1;
2259     if (s16_p(d))
2260         BRC(c, x16(d));
2261     else {
2262         assert(s32_p(d));
2263         BRCL(c, d);
2264     }
2265 }
2266
2267 static void
2268 _bsubi(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2269        jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2270 {
2271     jit_int32_t         reg;
2272     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2273     movi(rn(reg), i1);
2274     bsubr(c, s, i0, r0, rn(reg));
2275     jit_unget_reg(reg);
2276 }
2277
2278 static jit_word_t
2279 _bsubr_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2280          jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2281 {
2282     jit_word_t          d, w;
2283     if (s)              subr(r0, r0, r1);
2284     else                subcr(r0, r0, r1);
2285     d = (i0 - _jit->pc.w) >> 1;
2286     w = _jit->pc.w;
2287     BRCL(c, d);
2288     return (w);
2289 }
2290
2291 static jit_word_t
2292 _bsubi_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2293          jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2294 {
2295     jit_word_t          w;
2296     jit_int32_t         reg;
2297     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2298     movi(rn(reg), i1);
2299     w = bsubr_p(c, s, i0, r0, rn(reg));
2300     jit_unget_reg(reg);
2301     return (w);
2302 }
2303
2304 static void
2305 _bmxr(jit_state_t *_jit, jit_int32_t cc,
2306       jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2307 {
2308     jit_word_t          d;
2309     jit_int32_t         reg;
2310     reg = jit_get_reg(jit_class_gpr);
2311     movr(rn(reg), r0);
2312     andr(rn(reg), rn(reg), r1);
2313     TEST_(rn(reg), rn(reg));
2314     jit_unget_reg(reg);
2315     d = (i0 - _jit->pc.w) >> 1;
2316     if (s16_p(d))
2317         BRC(cc, x16(d));
2318     else {
2319         assert(s32_p(d));
2320         BRCL(cc, d);
2321     }
2322 }
2323
2324 static jit_word_t
2325 _bmxr_p(jit_state_t *_jit, jit_int32_t cc,
2326         jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2327 {
2328     jit_word_t          w;
2329     jit_int32_t         reg;
2330     reg = jit_get_reg(jit_class_gpr);
2331     movr(rn(reg), r0);
2332     andr(rn(reg), rn(reg), r1);
2333     TEST_(rn(reg), rn(reg));
2334     jit_unget_reg(reg);
2335     w = _jit->pc.w;
2336     BRCL(cc, 0);
2337     return (w);
2338 }
2339
2340 static void
2341 _bmxi(jit_state_t *_jit, jit_int32_t cc,
2342       jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2343 {
2344     jit_word_t          d;
2345     jit_int32_t         reg;
2346     reg = jit_get_reg(jit_class_gpr);
2347     movi(rn(reg), i1);
2348     andr(rn(reg), rn(reg), r0);
2349     TEST_(rn(reg), rn(reg));
2350     jit_unget_reg(reg);
2351     d = (i0 - _jit->pc.w) >> 1;
2352     if (s16_p(d))
2353         BRC(cc, x16(d));
2354     else {
2355         assert(s32_p(d));
2356         BRCL(cc, d);
2357     }
2358 }
2359
2360 static jit_word_t
2361 _bmxi_p(jit_state_t *_jit, jit_int32_t cc,
2362         jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2363 {
2364     jit_word_t          w;
2365     jit_int32_t         reg;
2366     reg = jit_get_reg(jit_class_gpr);
2367     movi(rn(reg), i1);
2368     andr(rn(reg), rn(reg), r0);
2369     TEST_(rn(reg), rn(reg));
2370     jit_unget_reg(reg);
2371     w = _jit->pc.w;
2372     BRCL(cc, 0);
2373     return (w);
2374 }
2375
2376 static void
2377 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2378 {
2379 #if __WORDSIZE == 32
2380     if (r0 != r1)
2381         LR(r0, r1);
2382 #else
2383     if (r0 != r1)
2384         LGR(r0, r1);
2385 #endif
2386 }
2387
2388 static void
2389 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2390 {
2391     jit_word_t          d;
2392 #if __WORDSIZE == 64
2393     jit_int32_t         bits;
2394 #endif
2395     d = (i0 - _jit->pc.w) >> 1;
2396     if (s16_p(i0)) {
2397 #if __WORDSIZE == 32
2398         LHI(r0, x16(i0));
2399 #else
2400         LGHI(r0, x16(i0));
2401 #endif
2402     }
2403     /* easy way of loading a large amount of 32 bit values and
2404      * usually address of constants */
2405     else if (!(i0 & 1) &&
2406 #if __WORDSIZE == 32
2407              i0 > 0
2408 #else
2409              s32_p(d)
2410 #endif
2411              )
2412         LARL(r0, d);
2413     else {
2414 #if __WORDSIZE == 32
2415         LHI(r0, x16(i0));
2416         IILH(r0, x16((jit_uword_t)i0 >> 16));
2417 #else
2418         bits = 0;
2419         if (i0 &             0xffffL)   bits |= 1;
2420         if (i0 &         0xffff0000L)   bits |= 2;
2421         if (i0 &     0xffff00000000L)   bits |= 4;
2422         if (i0 & 0xffff000000000000L)   bits |= 8;
2423         if (bits != 15)                 LGHI(r0, 0);
2424         if (bits & 1)                   IILL(r0, x16(i0));
2425         if (bits & 2)                   IILH(r0, x16((jit_uword_t)i0 >> 16));
2426         if (bits & 4)                   IIHL(r0, x16((jit_uword_t)i0 >> 32));
2427         if (bits & 8)                   IIHH(r0, x16((jit_uword_t)i0 >> 48));
2428 #endif
2429     }
2430 }
2431
2432 static jit_word_t
2433 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2434 {
2435     jit_word_t          w;
2436     w = _jit->pc.w;
2437 #if __WORDSIZE == 32
2438     LHI(r0, x16(i0));
2439 #else
2440     IILL(r0, x16(i0));
2441 #endif
2442     IILH(r0, x16((jit_uword_t)i0 >> 16));
2443 #if __WORDSIZE == 64
2444     IIHL(r0, x16((jit_uword_t)i0 >> 32));
2445     IIHH(r0, x16((jit_uword_t)i0 >> 48));
2446 #endif
2447     return (w);
2448 }
2449
2450 static void
2451 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2452 {
2453     jit_word_t  w;
2454     w = beqi_p(_jit->pc.w, r2, 0);
2455 #if __WORDSIZE == 32
2456     LR(r0, r1);
2457 #else
2458     LGR(r0, r1);
2459 #endif
2460     patch_at(w, _jit->pc.w);
2461 }
2462
2463 static void
2464 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2465 {
2466     jit_word_t  w;
2467     w = bnei_p(_jit->pc.w, r2, 0);
2468 #if __WORDSIZE == 32
2469     LR(r0, r1);
2470 #else
2471     LGR(r0, r1);
2472 #endif
2473     patch_at(w, _jit->pc.w);
2474 }
2475
2476 static void
2477 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
2478       jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
2479 {
2480     fallback_casx(r0, r1, r2, r3, i0);
2481 }
2482
2483 static void
2484 _addr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2485 {
2486     if (r0 == r2)
2487         ADD_(r0, r1);
2488     else {
2489         movr(r0, r1);
2490         ADD_(r0, r2);
2491     }
2492 }
2493
2494 static void
2495 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2496 {
2497     jit_int32_t         reg;
2498     if (r0 == r1 && s16_p(i0))
2499         ADDI_(r0, x16(i0));
2500 #if __WORDSIZE == 64
2501     else if (s20_p(i0))
2502         LAY(r0, x20(i0), 0, r1);
2503 #endif
2504     else {
2505         reg = jit_get_reg(jit_class_gpr);
2506         movi(rn(reg), i0);
2507         addr(r0, r1, rn(reg));
2508         jit_unget_reg(reg);
2509     }
2510 }
2511
2512 static void
2513 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2514 {
2515     if (r0 == r2)
2516         ADDC_(r0, r1);
2517     else {
2518         movr(r0, r1);
2519         ADDC_(r0, r2);
2520     }
2521 }
2522
2523 static void
2524 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2525 {
2526     jit_int32_t         reg;
2527     reg = jit_get_reg(jit_class_gpr);
2528     movi(rn(reg), i0);
2529     addcr(r0, r1, rn(reg));
2530     jit_unget_reg(reg);
2531 }
2532
2533 static void
2534 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2535 {
2536     if (r0 == r2)
2537         ADDX_(r0, r1);
2538     else {
2539         movr(r0, r1);
2540         ADDX_(r0, r2);
2541     }
2542 }
2543
2544 static void
2545 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2546 {
2547     jit_int32_t         reg;
2548     reg = jit_get_reg(jit_class_gpr);
2549     movi(rn(reg), i0);
2550     addxr(r0, r1, rn(reg));
2551     jit_unget_reg(reg);
2552 }
2553
2554 static void
2555 _subr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2556 {
2557     jit_int32_t         reg;
2558     if (r0 == r2) {
2559         reg = jit_get_reg(jit_class_gpr);
2560         movr(rn(reg), r2);
2561         movr(r0, r1);
2562         SUB_(r0, rn(reg));
2563         jit_unget_reg(reg);
2564     }
2565     else {
2566         movr(r0, r1);
2567         SUB_(r0, r2);
2568     }
2569 }
2570
2571 static void
2572 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2573 {
2574     jit_int32_t         reg;
2575     if (r0 == r1 && s16_p(-i0))
2576         ADDI_(r0, x16(-i0));
2577 #if __WORDSIZE == 64
2578     else if (s20_p(-i0))
2579         LAY(r0, x20(-i0), 0, r1);
2580 #endif
2581     else {
2582         reg = jit_get_reg(jit_class_gpr);
2583         movi(rn(reg), i0);
2584         subr(r0, r1, rn(reg));
2585         jit_unget_reg(reg);
2586     }
2587 }
2588
2589 static void
2590 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2591 {
2592     jit_int32_t         reg;
2593     if (r0 == r2) {
2594         reg = jit_get_reg(jit_class_gpr);
2595         movr(rn(reg), r2);
2596         movr(r0, r1);
2597         SUBC_(r0, rn(reg));
2598         jit_unget_reg(reg);
2599     }
2600     else {
2601         movr(r0, r1);
2602         SUBC_(r0, r2);
2603     }
2604 }
2605
2606 static void
2607 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2608 {
2609     jit_int32_t         reg;
2610     reg = jit_get_reg(jit_class_gpr);
2611     movi(rn(reg), i0);
2612     subcr(r0, r1, rn(reg));
2613     jit_unget_reg(reg);
2614 }
2615
2616 static void
2617 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2618 {
2619     jit_int32_t         reg;
2620     if (r0 == r2) {
2621         reg = jit_get_reg(jit_class_gpr);
2622         movr(rn(reg), r2);
2623         movr(r0, r1);
2624         SUBX_(r0, rn(reg));
2625         jit_unget_reg(reg);
2626     }
2627     else {
2628         movr(r0, r1);
2629         SUBX_(r0, r2);
2630     }
2631 }
2632
2633 static void
2634 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2635 {
2636     jit_int32_t         reg;
2637     reg = jit_get_reg(jit_class_gpr);
2638     movi(rn(reg), i0);
2639     subxr(r0, r1, rn(reg));
2640     jit_unget_reg(reg);
2641 }
2642
2643 static void
2644 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2645 {
2646     subi(r0, r1, i0);
2647     negr(r0, r0);
2648 }
2649
2650 static void
2651 _mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2652 {
2653     if (r0 == r2)
2654         MUL_(r0, r1);
2655     else {
2656         movr(r0, r1);
2657         MUL_(r0, r2);
2658     }
2659 }
2660
2661 static void
2662 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2663 {
2664     jit_int32_t         reg;
2665     if (s16_p(i0)) {
2666         movr(r0, r1);
2667         MULI_(r0, x16(i0));
2668     }
2669     else {
2670         reg = jit_get_reg(jit_class_gpr);
2671         movi(rn(reg), i0);
2672         mulr(r0, r1, rn(reg));
2673         jit_unget_reg(reg);
2674     }
2675 }
2676
2677 static void
2678 _qmulr(jit_state_t *_jit,
2679        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2680 {
2681     jit_int32_t         reg;
2682     /* The only invalid condition is r0 == r1 */
2683     jit_int32_t         t2, t3, s2, s3;
2684     if (r2 == r0 || r2 == r1) {
2685         s2 = jit_get_reg(jit_class_gpr);
2686         t2 = rn(s2);
2687         movr(t2, r2);
2688     }
2689     else
2690         t2 = r2;
2691     if (r3 == r0 || r3 == r1) {
2692         s3 = jit_get_reg(jit_class_gpr);
2693         t3 = rn(s3);
2694         movr(t3, r3);
2695     }
2696     else
2697         t3 = r3;
2698     qmulr_u(r0, r1, r2, r3);
2699     reg = jit_get_reg(jit_class_gpr);
2700     /**/
2701     rshi(rn(reg), t2, 63);
2702     mulr(rn(reg), rn(reg), t3);
2703     addr(r1, r1, rn(reg));
2704     /**/
2705     rshi(rn(reg), t3, 63);
2706     mulr(rn(reg), rn(reg), t2);
2707     addr(r1, r1, rn(reg));
2708     jit_unget_reg(reg);
2709     if (t2 != r2)
2710         jit_unget_reg(s2);
2711     if (t3 != r3)
2712         jit_unget_reg(s3);
2713 }
2714
2715 static void
2716 _qmuli(jit_state_t *_jit,
2717        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2718 {
2719     jit_int32_t         reg;
2720     reg = jit_get_reg(jit_class_gpr);
2721     movi(rn(reg), i0);
2722     qmulr(r0, r1, r2, rn(reg));
2723     jit_unget_reg(reg);
2724 }
2725
2726 static void
2727 _qmulr_u(jit_state_t *_jit,
2728          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2729 {
2730     jit_int32_t         regno;
2731     regno = jit_get_reg_pair();
2732     movr(rn(regno) + 1, r2);
2733     MULU_(rn(regno), r3);
2734     movr(r0, rn(regno) + 1);
2735     movr(r1, rn(regno));
2736     jit_unget_reg_pair(regno);
2737 }
2738
2739 static void
2740 _qmuli_u(jit_state_t *_jit,
2741          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2742 {
2743     jit_int32_t         regno;
2744     regno = jit_get_reg_pair();
2745     movr(rn(regno) + 1, r2);
2746     movi(rn(regno), i0);
2747     MULU_(rn(regno), rn(regno));
2748     movr(r0, rn(regno) + 1);
2749     movr(r1, rn(regno));
2750     jit_unget_reg_pair(regno);
2751 }
2752
2753 static void
2754 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2755 {
2756     jit_int32_t         regno;
2757     regno = xdivr(r1, r2);
2758     movr(r0, rn(regno) + 1);
2759 }
2760
2761 static void
2762 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2763 {
2764     jit_int32_t         regno;
2765     regno = xdivi(r1, i0);
2766     movr(r0, rn(regno) + 1);
2767 }
2768
2769 static void
2770 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2771 {
2772     jit_int32_t         regno;
2773     regno = xdivr_u(r1, r2);
2774     movr(r0, rn(regno) + 1);
2775 }
2776
2777 static void
2778 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2779 {
2780     jit_int32_t         regno;
2781     regno = xdivi_u(r1, i0);
2782     movr(r0, rn(regno) + 1);
2783 }
2784
2785 static void
2786 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2787 {
2788     jit_int32_t         regno;
2789     regno = xdivr(r1, r2);
2790     movr(r0, rn(regno));
2791 }
2792
2793 static void
2794 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2795 {
2796     jit_int32_t         regno;
2797     regno = xdivi(r1, i0);
2798     movr(r0, rn(regno));
2799 }
2800
2801 static void
2802 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2803 {
2804     jit_int32_t         regno;
2805     regno = xdivr_u(r1, r2);
2806     movr(r0, rn(regno));
2807 }
2808
2809 static void
2810 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2811 {
2812     jit_int32_t         regno;
2813     regno = xdivi_u(r1, i0);
2814     movr(r0, rn(regno));
2815 }
2816
2817 static void
2818 _qdivr(jit_state_t *_jit,
2819        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2820 {
2821     jit_int32_t         regno;
2822     regno = xdivr(r2, r3);
2823     movr(r0, rn(regno) + 1);
2824     movr(r1, rn(regno));
2825 }
2826
2827 static void
2828 _qdivi(jit_state_t *_jit,
2829        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2830 {
2831     jit_int32_t         regno;
2832     regno = xdivi(r2, i0);
2833     movr(r0, rn(regno) + 1);
2834     movr(r1, rn(regno));
2835 }
2836
2837 static void
2838 _qdivr_u(jit_state_t *_jit,
2839          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2840 {
2841     jit_int32_t         regno;
2842     regno = xdivr_u(r2, r3);
2843     movr(r0, rn(regno) + 1);
2844     movr(r1, rn(regno));
2845 }
2846
2847 static void
2848 _qdivi_u(jit_state_t *_jit,
2849          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2850 {
2851     jit_int32_t         regno;
2852     regno = xdivi_u(r2, i0);
2853     movr(r0, rn(regno) + 1);
2854     movr(r1, rn(regno));
2855 }
2856
2857 #  if __WORDSIZE == 32
2858 static void
2859 _lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2860 {
2861     jit_int32_t         reg;
2862     if (r0 == r2) {
2863         reg = jit_get_reg_but_zero(0);
2864         movr(rn(reg), r2);
2865         movr(r0, r1);
2866         SLL(r0, 0, rn(reg));
2867         jit_unget_reg_but_zero(reg);
2868     }
2869     else {
2870         movr(r0, r1);
2871         SLL(r0, 0, r2);
2872     }
2873 }
2874 #endif
2875
2876 static void
2877 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2878 {
2879     jit_int32_t         reg;
2880     reg = jit_get_reg_but_zero(0);
2881     movi(rn(reg), i0);
2882     lshr(r0, r1, rn(reg));
2883     jit_unget_reg_but_zero(reg);
2884 }
2885
2886 #  if __WORDSIZE == 32
2887 static void
2888 _rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2889 {
2890     jit_int32_t         reg;
2891     if (r0 == r2) {
2892         reg = jit_get_reg_but_zero(0);
2893         movr(rn(reg), r2);
2894         movr(r0, r1);
2895         SRA(r0, 0, rn(reg));
2896         jit_unget_reg_but_zero(reg);
2897     }
2898     else {
2899         movr(r0, r1);
2900         SRA(r0, 0, r2);
2901     }
2902 }
2903 #endif
2904
2905 static void
2906 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2907 {
2908     jit_int32_t         reg;
2909     reg = jit_get_reg_but_zero(0);
2910     movi(rn(reg), i0);
2911     rshr(r0, r1, rn(reg));
2912     jit_unget_reg_but_zero(reg);
2913 }
2914
2915 #  if __WORDSIZE == 32
2916 static void
2917 _rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2918 {
2919     jit_int32_t         reg;
2920     if (r0 == r2) {
2921         reg = jit_get_reg_but_zero(0);
2922         movr(rn(reg), r2);
2923         movr(r0, r1);
2924         SRL(r0, 0, rn(reg));
2925         jit_unget_reg_but_zero(reg);
2926     }
2927     else {
2928         movr(r0, r1);
2929         SRL(r0, 0, r2);
2930     }
2931 }
2932 #endif
2933
2934 static void
2935 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2936 {
2937     jit_int32_t         reg;
2938     reg = jit_get_reg_but_zero(0);
2939     movi(rn(reg), i0);
2940     rshr_u(r0, r1, rn(reg));
2941     jit_unget_reg_but_zero(reg);
2942 }
2943
2944 static void
2945 _comr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2946 {
2947     jit_int32_t         reg;
2948     reg = jit_get_reg(jit_class_gpr);
2949     movi(rn(reg), -1);
2950     movr(r0, r1);
2951     XOR_(r0, rn(reg));
2952     jit_unget_reg(reg);
2953 }
2954
2955 static void
2956 _andr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2957 {
2958     if (r0 == r2)
2959         AND_(r0, r1);
2960     else {
2961         movr(r0, r1);
2962         AND_(r0, r2);
2963     }
2964 }
2965
2966 static void
2967 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2968 {
2969     movr(r0, r1);
2970     NILL(r0, x16(i0));
2971     NILH(r0, x16((jit_uword_t)i0 >> 16));
2972 #if __WORDSIZE == 64
2973     NIHL(r0, x16((jit_uword_t)i0 >> 32));
2974     NIHH(r0, x16((jit_uword_t)i0 >> 48));
2975 #endif
2976 }
2977
2978 static void
2979 _orr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2980 {
2981     if (r0 == r2)
2982         OR_(r0, r1);
2983     else {
2984         movr(r0, r1);
2985         OR_(r0, r2);
2986     }
2987 }
2988
2989 static void
2990 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2991 {
2992     movr(r0, r1);
2993     OILL(r0, x16(i0));
2994     OILH(r0, x16((jit_uword_t)i0 >> 16));
2995 #if __WORDSIZE == 64
2996     OIHL(r0, x16((jit_uword_t)i0 >> 32));
2997     OIHH(r0, x16((jit_uword_t)i0 >> 48));
2998 #endif
2999 }
3000
3001 static void
3002 _xorr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3003 {
3004     if (r0 == r2)
3005         XOR_(r0, r1);
3006     else {
3007         movr(r0, r1);
3008         XOR_(r0, r2);
3009     }
3010 }
3011
3012 static void
3013 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3014 {
3015     jit_int32_t         reg;
3016     reg = jit_get_reg(jit_class_gpr);
3017     movi(rn(reg), i0);
3018     xorr(r0, r1, rn(reg));
3019     jit_unget_reg(reg);
3020 }
3021
3022 static void
3023 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3024 {
3025     movi(r0, i0);
3026     ldr_c(r0, r0);
3027 }
3028
3029 static void
3030 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3031 {
3032     if (r0 == r2) {
3033         addr(r0, r0, r1);
3034         ldr_c(r0, r0);
3035     }
3036     else {
3037         movr(r0, r1);
3038         addr(r0, r0, r2);
3039         ldr_c(r0, r0);
3040     }
3041 }
3042
3043 static void
3044 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3045 {
3046     jit_int32_t         reg;
3047     if (s20_p(i0)) {
3048 #if __WORDSIZE == 32
3049         LB(r0, x20(i0), 0, r1);
3050 #else
3051         LGB(r0, x20(i0), 0, r1);
3052 #endif
3053     }
3054     else if (r0 != r1) {
3055         movi(r0, i0);
3056         addr(r0, r0, r1);
3057         ldr_c(r0, r0);
3058     }
3059     else {
3060         reg = jit_get_reg_but_zero(0);
3061         movi(rn(reg), i0);
3062         addr(rn(reg), rn(reg), r1);
3063         ldr_c(r0, rn(reg));
3064         jit_unget_reg_but_zero(reg);
3065     }
3066 }
3067
3068 static void
3069 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3070 {
3071     movi(r0, i0);
3072     ldr_uc(r0, r0);
3073 }
3074
3075 static void
3076 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3077 {
3078     if (r0 == r2) {
3079         addr(r0, r0, r1);
3080         ldr_uc(r0, r0);
3081     }
3082     else {
3083         movr(r0, r1);
3084         addr(r0, r0, r2);
3085         ldr_uc(r0, r0);
3086     }
3087 }
3088
3089 static void
3090 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3091 {
3092     jit_int32_t         reg;
3093     if (s20_p(i0))
3094         LLGC(r0, x20(i0), 0, r1);
3095     else if (r0 != r1) {
3096         movi(r0, i0);
3097         addr(r0, r0, r1);
3098         ldr_uc(r0, r0);
3099     }
3100     else {
3101         reg = jit_get_reg_but_zero(0);
3102         movi(rn(reg), i0);
3103         addr(rn(reg), rn(reg), r1);
3104         ldr_uc(r0, rn(reg));
3105         jit_unget_reg_but_zero(reg);
3106     }
3107 }
3108
3109 static void
3110 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3111 {
3112     movi(r0, i0);
3113     ldr_s(r0, r0);
3114 }
3115
3116 static void
3117 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3118 {
3119     if (r0 == r2) {
3120         addr(r0, r0, r1);
3121         ldr_s(r0, r0);
3122     }
3123     else {
3124         movr(r0, r1);
3125         addr(r0, r0, r2);
3126         ldr_s(r0, r0);
3127     }
3128 }
3129
3130 static void
3131 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3132 {
3133     jit_int32_t         reg;
3134 #if __WORDSIZE == 32
3135     if (u12_p(i0))
3136         LH(r0, i0, 0, r1);
3137     else
3138 #endif
3139     if (s20_p(i0)) {
3140 #if __WORDSIZE == 32
3141         LHY(r0, x20(i0), 0, r1);
3142 #else
3143         LGH(r0, x20(i0), 0, r1);
3144 #endif
3145     }
3146     else if (r0 != r1) {
3147         movi(r0, i0);
3148         addr(r0, r0, r1);
3149         ldr_s(r0, r0);
3150     }
3151     else {
3152         reg = jit_get_reg_but_zero(0);
3153         movi(rn(reg), i0);
3154         addr(rn(reg), rn(reg), r1);
3155         ldr_s(r0, rn(reg));
3156         jit_unget_reg_but_zero(reg);
3157     }
3158 }
3159
3160 static void
3161 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3162 {
3163     movi(r0, i0);
3164     ldr_us(r0, r0);
3165 }
3166
3167 static void
3168 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3169 {
3170     if (r0 == r2) {
3171         addr(r0, r0, r1);
3172         ldr_us(r0, r0);
3173     }
3174     else {
3175         movr(r0, r1);
3176         addr(r0, r0, r2);
3177         ldr_us(r0, r0);
3178     }
3179 }
3180
3181 static void
3182 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3183 {
3184     jit_int32_t         reg;
3185     if (s20_p(i0))
3186         LLGH(r0, x20(i0), 0, r1);
3187     else if (r0 != r1) {
3188         movi(r0, i0);
3189         addr(r0, r0, r1);
3190         ldr_us(r0, r0);
3191     }
3192     else {
3193         reg = jit_get_reg_but_zero(0);
3194         movi(rn(reg), i0);
3195         addr(rn(reg), rn(reg), r1);
3196         ldr_us(r0, rn(reg));
3197         jit_unget_reg_but_zero(reg);
3198     }
3199 }
3200
3201 static void
3202 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3203 {
3204     movi(r0, i0);
3205     ldr_i(r0, r0);
3206 }
3207
3208 static void
3209 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3210 {
3211     if (r0 == r2) {
3212         addr(r0, r0, r1);
3213         ldr_i(r0, r0);
3214     }
3215     else {
3216         movr(r0, r1);
3217         addr(r0, r0, r2);
3218         ldr_i(r0, r0);
3219     }
3220 }
3221
3222 static void
3223 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3224 {
3225     jit_int32_t         reg;
3226     if (s20_p(i0))
3227         LGF(r0, x20(i0), 0, r1);
3228     else if (r0 != r1) {
3229         movi(r0, i0);
3230         addr(r0, r0, r1);
3231         ldr_i(r0, r0);
3232     }
3233     else {
3234         reg = jit_get_reg_but_zero(0);
3235         movi(rn(reg), i0);
3236         addr(rn(reg), rn(reg), r1);
3237         ldr_i(r0, rn(reg));
3238         jit_unget_reg_but_zero(reg);
3239     }
3240 }
3241
3242 #if __WORDSIZE == 64
3243 static void
3244 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3245 {
3246     movi(r0, i0);
3247     ldr_ui(r0, r0);
3248 }
3249
3250 static void
3251 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3252 {
3253     if (r0 == r2) {
3254         addr(r0, r0, r1);
3255         ldr_ui(r0, r0);
3256     }
3257     else {
3258         movr(r0, r1);
3259         addr(r0, r0, r2);
3260         ldr_ui(r0, r0);
3261     }
3262 }
3263
3264 static void
3265 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3266 {
3267     jit_int32_t         reg;
3268     if (s20_p(i0))
3269         LLGF(r0, x20(i0), 0, r1);
3270     else if (r0 != r1) {
3271         movi(r0, i0);
3272         addr(r0, r0, r1);
3273         ldr_ui(r0, r0);
3274     }
3275     else {
3276         reg = jit_get_reg_but_zero(0);
3277         movi(rn(reg), i0);
3278         addr(rn(reg), rn(reg), r1);
3279         ldr_ui(r0, rn(reg));
3280         jit_unget_reg_but_zero(reg);
3281     }
3282 }
3283
3284 static void
3285 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3286 {
3287     movi(r0, i0);
3288     ldr_l(r0, r0);
3289 }
3290
3291 static void
3292 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3293 {
3294     if (r0 == r2) {
3295         addr(r0, r0, r1);
3296         ldr_l(r0, r0);
3297     }
3298     else {
3299         movr(r0, r1);
3300         addr(r0, r0, r2);
3301         ldr_l(r0, r0);
3302     }
3303 }
3304
3305 static void
3306 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3307 {
3308     jit_int32_t         reg;
3309     if (s20_p(i0))
3310         LG(r0, x20(i0), 0, r1);
3311     else if (r0 != r1) {
3312         movi(r0, i0);
3313         addr(r0, r0, r1);
3314         ldr_l(r0, r0);
3315     }
3316     else {
3317         reg = jit_get_reg_but_zero(0);
3318         movi(rn(reg), i0);
3319         addr(rn(reg), rn(reg), r1);
3320         ldr_l(r0, rn(reg));
3321         jit_unget_reg_but_zero(reg);
3322     }
3323 }
3324 #endif
3325
3326 static void
3327 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3328 {
3329     jit_int32_t         reg;
3330     reg = jit_get_reg_but_zero(0);
3331     movi(rn(reg), i0);
3332     str_c(rn(reg), r0);
3333     jit_unget_reg_but_zero(reg);
3334 }
3335
3336 static void
3337 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3338 {
3339     jit_int32_t         reg;
3340     reg = jit_get_reg_but_zero(0);
3341     movr(rn(reg), r0);
3342     addr(rn(reg), rn(reg), r1);
3343     str_c(rn(reg), r2);
3344     jit_unget_reg_but_zero(reg);
3345 }
3346
3347 static void
3348 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3349 {
3350     jit_int32_t         reg;
3351     if (u12_p(i0))
3352         STC(r1, i0, 0, r0);
3353     else if (s20_p(i0))
3354         STCY(r1, x20(i0), 0, r0);
3355     else {
3356         reg = jit_get_reg_but_zero(0);
3357         addi(rn(reg), r0, i0);
3358         str_c(rn(reg), r1);
3359         jit_unget_reg_but_zero(reg);
3360     }
3361 }
3362
3363 static void
3364 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3365 {
3366     jit_int32_t         reg;
3367     reg = jit_get_reg_but_zero(0);
3368     movi(rn(reg), i0);
3369     str_s(rn(reg), r0);
3370     jit_unget_reg_but_zero(reg);
3371 }
3372
3373 static void
3374 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3375 {
3376     jit_int32_t         reg;
3377     reg = jit_get_reg_but_zero(0);
3378     movr(rn(reg), r0);
3379     addr(rn(reg), rn(reg), r1);
3380     str_s(rn(reg), r2);
3381     jit_unget_reg_but_zero(reg);
3382 }
3383
3384 static void
3385 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3386 {
3387     jit_int32_t         reg;
3388     if (u12_p(i0))
3389         STH(r1, i0, 0, r0);
3390     else if (s20_p(i0))
3391         STHY(r1, x20(i0), 0, r0);
3392     else {
3393         reg = jit_get_reg_but_zero(0);
3394         addi(rn(reg), r0, i0);
3395         str_s(rn(reg), r1);
3396         jit_unget_reg_but_zero(reg);
3397     }
3398 }
3399
3400 static void
3401 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3402 {
3403     jit_int32_t         reg;
3404     reg = jit_get_reg_but_zero(0);
3405     movi(rn(reg), i0);
3406     str_i(rn(reg), r0);
3407     jit_unget_reg_but_zero(reg);
3408 }
3409
3410 static void
3411 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3412 {
3413     jit_int32_t         reg;
3414     reg = jit_get_reg_but_zero(0);
3415     movr(rn(reg), r0);
3416     addr(rn(reg), rn(reg), r1);
3417     str_i(rn(reg), r2);
3418     jit_unget_reg_but_zero(reg);
3419 }
3420
3421 static void
3422 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3423 {
3424     jit_int32_t         reg;
3425     if (u12_p(i0))
3426         ST(r1, i0, 0, r0);
3427     else if (s20_p(i0))
3428         STY(r1, x20(i0), 0, r0);
3429     else {
3430         reg = jit_get_reg_but_zero(0);
3431         addi(rn(reg), r0, i0);
3432         str_i(rn(reg), r1);
3433         jit_unget_reg_but_zero(reg);
3434     }
3435 }
3436
3437 #if __WORDSIZE == 64
3438 static void
3439 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3440 {
3441     jit_int32_t         reg;
3442     reg = jit_get_reg_but_zero(0);
3443     movi(rn(reg), i0);
3444     str_l(rn(reg), r0);
3445     jit_unget_reg_but_zero(reg);
3446 }
3447
3448 static void
3449 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3450 {
3451     jit_int32_t         reg;
3452     reg = jit_get_reg_but_zero(0);
3453     movr(rn(reg), r0);
3454     addr(rn(reg), rn(reg), r1);
3455     str_l(rn(reg), r2);
3456     jit_unget_reg_but_zero(reg);
3457 }
3458
3459 static void
3460 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3461 {
3462     jit_int32_t         reg;
3463     if (s20_p(i0))
3464         STG(r1, x20(i0), 0, r0);
3465     else {
3466         reg = jit_get_reg_but_zero(0);
3467         addi(rn(reg), r0, i0);
3468         str_l(rn(reg), r1);
3469         jit_unget_reg_but_zero(reg);
3470     }
3471 }
3472 #endif
3473
3474 static void
3475 _jmpi(jit_state_t *_jit, jit_word_t i0)
3476 {
3477     jit_word_t          d;
3478     jit_int32_t         reg;
3479     d = (i0 - _jit->pc.w) >> 1;
3480     if (s16_p(d))
3481         J(x16(d));
3482     else if (s32_p(d))
3483         BRL(d);
3484     else {
3485         reg = jit_get_reg_but_zero(jit_class_nospill);
3486         movi(rn(reg), i0);
3487         jmpr(rn(reg));
3488         jit_unget_reg_but_zero(reg);
3489     }
3490 }
3491
3492 static jit_word_t
3493 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3494 {
3495     jit_word_t          w;
3496     jit_int32_t         reg;
3497     reg = jit_get_reg_but_zero(jit_class_nospill);
3498     w = movi_p(rn(reg), i0);
3499     jmpr(rn(reg));
3500     jit_unget_reg_but_zero(reg);
3501     return (w);
3502 }
3503
3504 static void
3505 _calli(jit_state_t *_jit, jit_word_t i0)
3506 {
3507     jit_word_t          d;
3508     jit_int32_t         reg;
3509     d = (i0 - _jit->pc.w) >> 1;
3510     if (s32_p(d))
3511         BRASL(_R14_REGNO, d);
3512     else {
3513         reg = jit_get_reg_but_zero(0);
3514         movi(rn(reg), i0);
3515         callr(rn(reg));
3516         jit_unget_reg_but_zero(reg);
3517     }
3518 }
3519
3520 static jit_word_t
3521 _calli_p(jit_state_t *_jit, jit_word_t i0)
3522 {
3523     jit_word_t          w;
3524     jit_int32_t         reg;
3525     reg = jit_get_reg_but_zero(0);
3526     w = movi_p(rn(reg), i0);
3527     callr(rn(reg));
3528     jit_unget_reg_but_zero(reg);
3529     return (w);
3530 }
3531
3532 static jit_int32_t      gprs[] = {
3533     _R2, _R3, _R4, _R5,
3534     _R6, _R7, _R8, _R9, _R10, _R11, _R12, _R13
3535 };
3536
3537 static void
3538 _prolog(jit_state_t *_jit, jit_node_t *i0)
3539 {
3540     jit_int32_t         regno, offset;
3541     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3542         jit_int32_t     frame = -_jitc->function->frame;
3543         assert(_jitc->function->self.aoff >= frame);
3544         if (_jitc->function->assume_frame)
3545             return;
3546         _jitc->function->self.aoff = frame;
3547     }
3548     if (_jitc->function->allocar)
3549         _jitc->function->self.aoff &= -8;
3550     _jitc->function->stack = ((_jitc->function->self.alen -
3551                               /* align stack at 8 bytes */
3552                               _jitc->function->self.aoff) + 7) & -8;
3553     /* *IFF* a non variadic function,
3554      * Lightning does not reserve stack space for spilling arguments
3555      * in registers.
3556      * S390x, as per gcc, has 8 stack slots for spilling arguments,
3557      * (%r6 is callee save) and uses an alloca like approach to save
3558      * callee save fpr registers.
3559      * Since argument registers are not saved in any lightning port,
3560      * use the 8 slots to spill any modified fpr register, and still
3561      * use the same stack frame logic as gcc.
3562      * Save at least %r13 to %r15, as %r13 is used as frame pointer.
3563      * *IFF* a variadic function, a "standard" stack frame, with
3564      * fpr registers saved in an alloca'ed area, is used.
3565      */
3566     if ((_jitc->function->self.call & jit_call_varargs) &&
3567         jit_arg_reg_p(_jitc->function->vagp))
3568         regno = _jitc->function->vagp;
3569     else {
3570         for (regno = 4; regno < jit_size(gprs) - 1; regno++) {
3571             if (jit_regset_tstbit(&_jitc->function->regset, gprs[regno]))
3572                 break;
3573         }
3574     }
3575 #if __WORDSIZE == 32
3576 #  define FP_OFFSET             64
3577     if (_jitc->function->self.call & jit_call_varargs)
3578         offset = regno * 4 + 8;
3579     else
3580         offset = (regno - 4) * 4 + 32;
3581     STM(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3582 #else
3583 #  define FP_OFFSET             128
3584     if (_jitc->function->self.call & jit_call_varargs)
3585         offset = regno * 8 + 16;
3586     else
3587         offset = (regno - 4) * 8 + 48;
3588     STMG(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3589 #endif
3590
3591 #define SPILL(R, O)                                                     \
3592     do {                                                                \
3593         if (jit_regset_tstbit(&_jitc->function->regset, R))             \
3594             stxi_d(O, _R15_REGNO, rn(R));                               \
3595     } while (0)
3596     if (_jitc->function->self.call & jit_call_varargs) {
3597         for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3598             stxi_d(FP_OFFSET + regno * 8, _R15_REGNO, rn(_F0 - regno));
3599         SPILL(_F8, _jitc->function->vaoff + offsetof(jit_va_list_t, f8));
3600         SPILL(_F9, _jitc->function->vaoff + offsetof(jit_va_list_t, f9));
3601         SPILL(_F10, _jitc->function->vaoff + offsetof(jit_va_list_t, f10));
3602         SPILL(_F11, _jitc->function->vaoff + offsetof(jit_va_list_t, f11));
3603         SPILL(_F12, _jitc->function->vaoff + offsetof(jit_va_list_t, f12));
3604         SPILL(_F13, _jitc->function->vaoff + offsetof(jit_va_list_t, f13));
3605         SPILL(_F14, _jitc->function->vaoff + offsetof(jit_va_list_t, f14));
3606     }
3607     else {
3608         /* First 4 in low address */
3609 #if __WORDSIZE == 32
3610         SPILL(_F10, 0);
3611         SPILL(_F11, 8);
3612         SPILL(_F12, 16);
3613         SPILL(_F13, 24);
3614         /* gpr registers here */
3615         SPILL(_F14, 72);
3616         SPILL(_F8, 80);
3617         SPILL(_F9, 88);
3618 #else
3619         SPILL(_F10, 16);
3620         SPILL(_F11, 24);
3621         SPILL(_F12, 32);
3622         SPILL(_F13, 48);
3623         /* Last 3 in high address */
3624         SPILL(_F14, 136);
3625         SPILL(_F8, 144);
3626         SPILL(_F9, 152);
3627 #endif
3628     }
3629 #undef SPILL
3630     movr(_R13_REGNO, _R15_REGNO);
3631     subi(_R15_REGNO, _R15_REGNO, stack_framesize + _jitc->function->stack);
3632     if (_jitc->function->allocar) {
3633         regno = jit_get_reg(jit_class_gpr);
3634         movi(rn(regno), _jitc->function->self.aoff);
3635         stxi_i(_jitc->function->aoffoff, _R13_REGNO, rn(regno));
3636         jit_unget_reg(regno);
3637     }
3638 }
3639
3640 static void
3641 _epilog(jit_state_t *_jit, jit_node_t *i0)
3642 {
3643     jit_int32_t         regno, offset;
3644     if (_jitc->function->assume_frame)
3645         return;
3646     if ((_jitc->function->self.call & jit_call_varargs) &&
3647         jit_arg_reg_p(_jitc->function->vagp))
3648         regno = _jitc->function->vagp;
3649     else {
3650         for (regno = 4; regno < jit_size(gprs) - 1; regno++) {
3651             if (jit_regset_tstbit(&_jitc->function->regset, gprs[regno]))
3652                 break;
3653         }
3654     }
3655 #if __WORDSIZE == 32
3656     if (_jitc->function->self.call & jit_call_varargs)
3657         offset = regno * 4 + 8;
3658     else
3659         offset = (regno - 4) * 4 + 32;
3660 #else
3661     if (_jitc->function->self.call & jit_call_varargs)
3662         offset = regno * 8 + 16;
3663     else
3664         offset = (regno - 4) * 8 + 48;
3665 #endif
3666     movr(_R15_REGNO, _R13_REGNO);
3667
3668 #define LOAD(R, O)                                                      \
3669     do {                                                                \
3670         if (jit_regset_tstbit(&_jitc->function->regset, R))             \
3671             ldxi_d(rn(R), _R15_REGNO, O);                               \
3672     } while (0)
3673     if (_jitc->function->self.call & jit_call_varargs) {
3674         LOAD(_F8, _jitc->function->vaoff + offsetof(jit_va_list_t, f8));
3675         LOAD(_F9, _jitc->function->vaoff + offsetof(jit_va_list_t, f9));
3676         LOAD(_F10, _jitc->function->vaoff + offsetof(jit_va_list_t, f10));
3677         LOAD(_F11, _jitc->function->vaoff + offsetof(jit_va_list_t, f11));
3678         LOAD(_F12, _jitc->function->vaoff + offsetof(jit_va_list_t, f12));
3679         LOAD(_F13, _jitc->function->vaoff + offsetof(jit_va_list_t, f13));
3680         LOAD(_F14, _jitc->function->vaoff + offsetof(jit_va_list_t, f14));
3681     }
3682     else {
3683 #if __WORDSIZE == 32
3684         LOAD(_F10, 0);
3685         LOAD(_F11, 8);
3686         LOAD(_F12, 16);
3687         LOAD(_F13, 24);
3688         LOAD(_F14, 72);
3689         LOAD(_F8, 80);
3690         LOAD(_F9, 88);
3691 #else
3692         LOAD(_F10, 16);
3693         LOAD(_F11, 24);
3694         LOAD(_F12, 32);
3695         LOAD(_F13, 48);
3696         LOAD(_F14, 136);
3697         LOAD(_F8, 144);
3698         LOAD(_F9, 152);
3699 #endif
3700     }
3701 #undef LOAD
3702 #if __WORDSIZE == 32
3703     LM(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3704 #else
3705     LMG(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3706 #endif
3707     BR(_R14_REGNO);
3708 }
3709
3710 static void
3711 _vastart(jit_state_t *_jit, jit_int32_t r0)
3712 {
3713     jit_int32_t         reg;
3714
3715     assert(_jitc->function->self.call & jit_call_varargs);
3716
3717     /* Return jit_va_list_t in the register argument */
3718     addi(r0, _R13_REGNO, _jitc->function->vaoff);
3719     reg = jit_get_reg(jit_class_gpr);
3720
3721     /* Initialize gp offset in the save area. */
3722     movi(rn(reg), _jitc->function->vagp);
3723     stxi(offsetof(jit_va_list_t, gpoff), r0, rn(reg));
3724
3725     /* Initialize fp offset in the save area. */
3726     movi(rn(reg), _jitc->function->vafp);
3727     stxi(offsetof(jit_va_list_t, fpoff), r0, rn(reg));
3728
3729     /* Initialize overflow pointer to the first stack argument. */
3730     addi(rn(reg), _R13_REGNO, _jitc->function->self.size);
3731     stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3732
3733     /* Initialize register save area pointer. */
3734     stxi(offsetof(jit_va_list_t, save), r0, _R13_REGNO);
3735
3736     jit_unget_reg(reg);
3737 }
3738
3739 static void
3740 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3741 {
3742     jit_int32_t         rg0;
3743     jit_int32_t         rg1;
3744     jit_int32_t         rg2;
3745     jit_word_t          ge_code;
3746     jit_word_t          lt_code;
3747
3748     assert(_jitc->function->self.call & jit_call_varargs);
3749
3750     rg0 = jit_get_reg_but_zero(0);
3751     rg1 = jit_get_reg_but_zero(0);
3752
3753     /* Load the gp offset in save area in the first temporary. */
3754     ldxi(rn(rg0), r1, offsetof(jit_va_list_t, gpoff));
3755
3756     /* Jump over if there are no remaining arguments in the save area. */
3757     ge_code = bgei_p(_jit->pc.w, rn(rg0), 5);
3758
3759     /* Load the save area pointer in the second temporary. */
3760     ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3761
3762     /* Scale offset */
3763     rg2 = jit_get_reg_but_zero(0);
3764     lshi(rn(rg2), rn(rg0),
3765 #if __WORDSIZE == 32
3766          2
3767 #else
3768          3
3769 #endif
3770          );
3771     /* Add offset to saved area. */
3772     addi(rn(rg2), rn(rg2), 2 * sizeof(jit_word_t));
3773
3774     /* Load the vararg argument in the first argument. */
3775     ldxr(r0, rn(rg1), rn(rg2));
3776     jit_unget_reg_but_zero(rg2);
3777
3778     /* Update the gp offset. */
3779     addi(rn(rg0), rn(rg0), 1);
3780     stxi(offsetof(jit_va_list_t, gpoff), r1, rn(rg0));
3781
3782     /* Will only need one temporary register below. */
3783     jit_unget_reg_but_zero(rg1);
3784
3785     /* Jump over overflow code. */
3786     lt_code = jmpi_p(_jit->pc.w);
3787
3788     /* Where to land if argument is in overflow area. */
3789     patch_at(ge_code, _jit->pc.w);
3790
3791     /* Load overflow pointer. */
3792     ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3793
3794     /* Load argument. */
3795     ldr(r0, rn(rg0));
3796
3797     /* Update overflow pointer. */
3798     addi(rn(rg0), rn(rg0), sizeof(jit_word_t));
3799     stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3800
3801     /* Where to land if argument is in save area. */
3802     patch_at(lt_code, _jit->pc.w);
3803
3804     jit_unget_reg_but_zero(rg0);
3805 }
3806
3807 static void
3808 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3809 {
3810     jit_word_t                   d;
3811     union {
3812         jit_uint16_t            *s;
3813         jit_word_t               w;
3814     } u;
3815     u.w = instr;
3816     union {
3817         struct {
3818             jit_uint16_t        op :  8;
3819             jit_uint16_t        r1 :  4;
3820             jit_uint16_t        r3 :  4;
3821         } b;
3822         jit_uint16_t            s;
3823     } i0;
3824     union {
3825         struct {
3826             jit_uint16_t        i2;
3827         } b;
3828         jit_uint16_t            s;
3829     } i1;
3830     union {
3831         struct {
3832             jit_uint32_t        ih : 16;
3833             jit_uint32_t        il : 16;
3834         } b;
3835         jit_uint32_t            i;
3836     } i12;
3837     i0.s = u.s[0];
3838     /* movi_p */
3839     if (i0.b.op ==
3840 #if __WORDSIZE == 32
3841         0xA7 && i0.b.r3 == 8
3842 #else
3843         0xA5
3844 #endif
3845         ) {
3846 #if __WORDSIZE == 64
3847         assert(i0.b.r3 == 3);
3848 #endif
3849         i1.b.i2 = (jit_uword_t)label;
3850         u.s[1] = i1.s;
3851         i0.s = u.s[2];
3852         assert(i0.b.op == 0xA5 && i0.b.r3 == 2);
3853         i1.b.i2 = (jit_uword_t)label >> 16;
3854         u.s[3] = i1.s;
3855 #if __WORDSIZE == 64
3856         i0.s = u.s[4];
3857         assert(i0.b.op == 0xA5 && i0.b.r3 == 1);
3858         i1.b.i2 = (jit_uword_t)label >> 32;
3859         u.s[5] = i1.s;
3860         i0.s = u.s[6];
3861         assert(i0.b.op == 0xA5 && i0.b.r3 == 0);
3862         i1.b.i2 = (jit_uword_t)label >> 48;
3863         u.s[7] = i1.s;
3864 #endif
3865     }
3866     /* BRC */
3867     else if (i0.b.op == 0xA7) {
3868         assert(i0.b.r3 == 0x4);
3869         d = (label - instr) >> 1;
3870         assert(s16_p(d));
3871         i1.b.i2 = d;
3872         u.s[1] = i1.s;
3873     }
3874     /* BRCL */
3875     else if (i0.b.op == 0xC0) {
3876         assert(i0.b.r3 == 0x4);
3877         d = (label - instr) >> 1;
3878         assert(s32_p(d));
3879         i12.i = d;
3880         u.s[1] = i12.b.ih;
3881         u.s[2] = i12.b.il;
3882     }
3883     else
3884         abort();
3885 }
3886 #endif