deps/lightning/lib/jit_s390-cpu.c

   1 /*
   2  * Copyright (C) 2013-2022  Free Software Foundation, Inc.
   3  *
   4  * This file is part of GNU lightning.
   5  *
   6  * GNU lightning is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 3, or (at your option)
   9  * any later version.
  10  *
  11  * GNU lightning is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  14  * License for more details.
  15  *
  16  * Authors:
  17  *      Paulo Cesar Pereira de Andrade
  18  */
  19
  20 #if PROTO
  21 #  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     jit_int32_t         iscasi, r1_reg;
2481     if ((iscasi = (r1 == _NOREG))) {
2482         r1_reg = jit_get_reg_but_zero(0);
2483         r1 = rn(r1_reg);
2484         movi(r1, i0);
2485     }
2486     /* Do not clobber r2 */
2487     movr(r0, r2);
2488     /*  The CS and CSG instructions below effectively do atomically:
2489      * if (*r1 == r0)
2490      *     *r1 = r3;
2491      * else
2492      *     r0 = *r1
2493      * So, we do not need to check cpu flags to know if it did work,
2494      * just compare if values are different.
2495      * Obviously it is somewhat of undefined behavior if old_value (r2)
2496      * and new_value (r3) have the same value, but should still work
2497      * as expected as a noop.
2498      */
2499 #  if __WORDSIZE == 32
2500     CS(r0, r3, 0, r1);
2501 #  else
2502     CSG(r0, r3, 0, r1);
2503 #  endif
2504     eqr(r0, r0, r2);
2505     if (iscasi)
2506         jit_unget_reg(r1_reg);
2507 }
2508
2509 static void
2510 _addr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2511 {
2512     if (r0 == r2)
2513         ADD_(r0, r1);
2514     else {
2515         movr(r0, r1);
2516         ADD_(r0, r2);
2517     }
2518 }
2519
2520 static void
2521 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2522 {
2523     jit_int32_t         reg;
2524     if (r0 == r1 && s16_p(i0))
2525         ADDI_(r0, x16(i0));
2526 #if __WORDSIZE == 64
2527     else if (s20_p(i0))
2528         LAY(r0, x20(i0), 0, r1);
2529 #endif
2530     else {
2531         reg = jit_get_reg(jit_class_gpr);
2532         movi(rn(reg), i0);
2533         addr(r0, r1, rn(reg));
2534         jit_unget_reg(reg);
2535     }
2536 }
2537
2538 static void
2539 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2540 {
2541     if (r0 == r2)
2542         ADDC_(r0, r1);
2543     else {
2544         movr(r0, r1);
2545         ADDC_(r0, r2);
2546     }
2547 }
2548
2549 static void
2550 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2551 {
2552     jit_int32_t         reg;
2553     reg = jit_get_reg(jit_class_gpr);
2554     movi(rn(reg), i0);
2555     addcr(r0, r1, rn(reg));
2556     jit_unget_reg(reg);
2557 }
2558
2559 static void
2560 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2561 {
2562     if (r0 == r2)
2563         ADDX_(r0, r1);
2564     else {
2565         movr(r0, r1);
2566         ADDX_(r0, r2);
2567     }
2568 }
2569
2570 static void
2571 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2572 {
2573     jit_int32_t         reg;
2574     reg = jit_get_reg(jit_class_gpr);
2575     movi(rn(reg), i0);
2576     addxr(r0, r1, rn(reg));
2577     jit_unget_reg(reg);
2578 }
2579
2580 static void
2581 _subr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2582 {
2583     jit_int32_t         reg;
2584     if (r0 == r2) {
2585         reg = jit_get_reg(jit_class_gpr);
2586         movr(rn(reg), r2);
2587         movr(r0, r1);
2588         SUB_(r0, rn(reg));
2589         jit_unget_reg(reg);
2590     }
2591     else {
2592         movr(r0, r1);
2593         SUB_(r0, r2);
2594     }
2595 }
2596
2597 static void
2598 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2599 {
2600     jit_int32_t         reg;
2601     if (r0 == r1 && s16_p(-i0))
2602         ADDI_(r0, x16(-i0));
2603 #if __WORDSIZE == 64
2604     else if (s20_p(-i0))
2605         LAY(r0, x20(-i0), 0, r1);
2606 #endif
2607     else {
2608         reg = jit_get_reg(jit_class_gpr);
2609         movi(rn(reg), i0);
2610         subr(r0, r1, rn(reg));
2611         jit_unget_reg(reg);
2612     }
2613 }
2614
2615 static void
2616 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2617 {
2618     jit_int32_t         reg;
2619     if (r0 == r2) {
2620         reg = jit_get_reg(jit_class_gpr);
2621         movr(rn(reg), r2);
2622         movr(r0, r1);
2623         SUBC_(r0, rn(reg));
2624         jit_unget_reg(reg);
2625     }
2626     else {
2627         movr(r0, r1);
2628         SUBC_(r0, r2);
2629     }
2630 }
2631
2632 static void
2633 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2634 {
2635     jit_int32_t         reg;
2636     reg = jit_get_reg(jit_class_gpr);
2637     movi(rn(reg), i0);
2638     subcr(r0, r1, rn(reg));
2639     jit_unget_reg(reg);
2640 }
2641
2642 static void
2643 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2644 {
2645     jit_int32_t         reg;
2646     if (r0 == r2) {
2647         reg = jit_get_reg(jit_class_gpr);
2648         movr(rn(reg), r2);
2649         movr(r0, r1);
2650         SUBX_(r0, rn(reg));
2651         jit_unget_reg(reg);
2652     }
2653     else {
2654         movr(r0, r1);
2655         SUBX_(r0, r2);
2656     }
2657 }
2658
2659 static void
2660 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2661 {
2662     jit_int32_t         reg;
2663     reg = jit_get_reg(jit_class_gpr);
2664     movi(rn(reg), i0);
2665     subxr(r0, r1, rn(reg));
2666     jit_unget_reg(reg);
2667 }
2668
2669 static void
2670 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2671 {
2672     subi(r0, r1, i0);
2673     negr(r0, r0);
2674 }
2675
2676 static void
2677 _mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2678 {
2679     if (r0 == r2)
2680         MUL_(r0, r1);
2681     else {
2682         movr(r0, r1);
2683         MUL_(r0, r2);
2684     }
2685 }
2686
2687 static void
2688 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2689 {
2690     jit_int32_t         reg;
2691     if (s16_p(i0)) {
2692         movr(r0, r1);
2693         MULI_(r0, x16(i0));
2694     }
2695     else {
2696         reg = jit_get_reg(jit_class_gpr);
2697         movi(rn(reg), i0);
2698         mulr(r0, r1, rn(reg));
2699         jit_unget_reg(reg);
2700     }
2701 }
2702
2703 static void
2704 _qmulr(jit_state_t *_jit,
2705        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2706 {
2707     jit_int32_t         reg;
2708     /* The only invalid condition is r0 == r1 */
2709     jit_int32_t         t2, t3, s2, s3;
2710     if (r2 == r0 || r2 == r1) {
2711         s2 = jit_get_reg(jit_class_gpr);
2712         t2 = rn(s2);
2713         movr(t2, r2);
2714     }
2715     else
2716         t2 = r2;
2717     if (r3 == r0 || r3 == r1) {
2718         s3 = jit_get_reg(jit_class_gpr);
2719         t3 = rn(s3);
2720         movr(t3, r3);
2721     }
2722     else
2723         t3 = r3;
2724     qmulr_u(r0, r1, r2, r3);
2725     reg = jit_get_reg(jit_class_gpr);
2726     /**/
2727     rshi(rn(reg), t2, 63);
2728     mulr(rn(reg), rn(reg), t3);
2729     addr(r1, r1, rn(reg));
2730     /**/
2731     rshi(rn(reg), t3, 63);
2732     mulr(rn(reg), rn(reg), t2);
2733     addr(r1, r1, rn(reg));
2734     jit_unget_reg(reg);
2735     if (t2 != r2)
2736         jit_unget_reg(s2);
2737     if (t3 != r3)
2738         jit_unget_reg(s3);
2739 }
2740
2741 static void
2742 _qmuli(jit_state_t *_jit,
2743        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2744 {
2745     jit_int32_t         reg;
2746     reg = jit_get_reg(jit_class_gpr);
2747     movi(rn(reg), i0);
2748     qmulr(r0, r1, r2, rn(reg));
2749     jit_unget_reg(reg);
2750 }
2751
2752 static void
2753 _qmulr_u(jit_state_t *_jit,
2754          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2755 {
2756     jit_int32_t         regno;
2757     regno = jit_get_reg_pair();
2758     movr(rn(regno) + 1, r2);
2759     MULU_(rn(regno), r3);
2760     movr(r0, rn(regno) + 1);
2761     movr(r1, rn(regno));
2762     jit_unget_reg_pair(regno);
2763 }
2764
2765 static void
2766 _qmuli_u(jit_state_t *_jit,
2767          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2768 {
2769     jit_int32_t         regno;
2770     regno = jit_get_reg_pair();
2771     movr(rn(regno) + 1, r2);
2772     movi(rn(regno), i0);
2773     MULU_(rn(regno), rn(regno));
2774     movr(r0, rn(regno) + 1);
2775     movr(r1, rn(regno));
2776     jit_unget_reg_pair(regno);
2777 }
2778
2779 static void
2780 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2781 {
2782     jit_int32_t         regno;
2783     regno = xdivr(r1, r2);
2784     movr(r0, rn(regno) + 1);
2785 }
2786
2787 static void
2788 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2789 {
2790     jit_int32_t         regno;
2791     regno = xdivi(r1, i0);
2792     movr(r0, rn(regno) + 1);
2793 }
2794
2795 static void
2796 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2797 {
2798     jit_int32_t         regno;
2799     regno = xdivr_u(r1, r2);
2800     movr(r0, rn(regno) + 1);
2801 }
2802
2803 static void
2804 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2805 {
2806     jit_int32_t         regno;
2807     regno = xdivi_u(r1, i0);
2808     movr(r0, rn(regno) + 1);
2809 }
2810
2811 static void
2812 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2813 {
2814     jit_int32_t         regno;
2815     regno = xdivr(r1, r2);
2816     movr(r0, rn(regno));
2817 }
2818
2819 static void
2820 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2821 {
2822     jit_int32_t         regno;
2823     regno = xdivi(r1, i0);
2824     movr(r0, rn(regno));
2825 }
2826
2827 static void
2828 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2829 {
2830     jit_int32_t         regno;
2831     regno = xdivr_u(r1, r2);
2832     movr(r0, rn(regno));
2833 }
2834
2835 static void
2836 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2837 {
2838     jit_int32_t         regno;
2839     regno = xdivi_u(r1, i0);
2840     movr(r0, rn(regno));
2841 }
2842
2843 static void
2844 _qdivr(jit_state_t *_jit,
2845        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2846 {
2847     jit_int32_t         regno;
2848     regno = xdivr(r2, r3);
2849     movr(r0, rn(regno) + 1);
2850     movr(r1, rn(regno));
2851 }
2852
2853 static void
2854 _qdivi(jit_state_t *_jit,
2855        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2856 {
2857     jit_int32_t         regno;
2858     regno = xdivi(r2, i0);
2859     movr(r0, rn(regno) + 1);
2860     movr(r1, rn(regno));
2861 }
2862
2863 static void
2864 _qdivr_u(jit_state_t *_jit,
2865          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2866 {
2867     jit_int32_t         regno;
2868     regno = xdivr_u(r2, r3);
2869     movr(r0, rn(regno) + 1);
2870     movr(r1, rn(regno));
2871 }
2872
2873 static void
2874 _qdivi_u(jit_state_t *_jit,
2875          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2876 {
2877     jit_int32_t         regno;
2878     regno = xdivi_u(r2, i0);
2879     movr(r0, rn(regno) + 1);
2880     movr(r1, rn(regno));
2881 }
2882
2883 #  if __WORDSIZE == 32
2884 static void
2885 _lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2886 {
2887     jit_int32_t         reg;
2888     if (r0 == r2) {
2889         reg = jit_get_reg_but_zero(0);
2890         movr(rn(reg), r2);
2891         movr(r0, r1);
2892         SLL(r0, 0, rn(reg));
2893         jit_unget_reg_but_zero(reg);
2894     }
2895     else {
2896         movr(r0, r1);
2897         SLL(r0, 0, r2);
2898     }
2899 }
2900 #endif
2901
2902 static void
2903 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2904 {
2905     jit_int32_t         reg;
2906     reg = jit_get_reg_but_zero(0);
2907     movi(rn(reg), i0);
2908     lshr(r0, r1, rn(reg));
2909     jit_unget_reg_but_zero(reg);
2910 }
2911
2912 #  if __WORDSIZE == 32
2913 static void
2914 _rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2915 {
2916     jit_int32_t         reg;
2917     if (r0 == r2) {
2918         reg = jit_get_reg_but_zero(0);
2919         movr(rn(reg), r2);
2920         movr(r0, r1);
2921         SRA(r0, 0, rn(reg));
2922         jit_unget_reg_but_zero(reg);
2923     }
2924     else {
2925         movr(r0, r1);
2926         SRA(r0, 0, r2);
2927     }
2928 }
2929 #endif
2930
2931 static void
2932 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2933 {
2934     jit_int32_t         reg;
2935     reg = jit_get_reg_but_zero(0);
2936     movi(rn(reg), i0);
2937     rshr(r0, r1, rn(reg));
2938     jit_unget_reg_but_zero(reg);
2939 }
2940
2941 #  if __WORDSIZE == 32
2942 static void
2943 _rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2944 {
2945     jit_int32_t         reg;
2946     if (r0 == r2) {
2947         reg = jit_get_reg_but_zero(0);
2948         movr(rn(reg), r2);
2949         movr(r0, r1);
2950         SRL(r0, 0, rn(reg));
2951         jit_unget_reg_but_zero(reg);
2952     }
2953     else {
2954         movr(r0, r1);
2955         SRL(r0, 0, r2);
2956     }
2957 }
2958 #endif
2959
2960 static void
2961 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2962 {
2963     jit_int32_t         reg;
2964     reg = jit_get_reg_but_zero(0);
2965     movi(rn(reg), i0);
2966     rshr_u(r0, r1, rn(reg));
2967     jit_unget_reg_but_zero(reg);
2968 }
2969
2970 static void
2971 _comr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2972 {
2973     jit_int32_t         reg;
2974     reg = jit_get_reg(jit_class_gpr);
2975     movi(rn(reg), -1);
2976     movr(r0, r1);
2977     XOR_(r0, rn(reg));
2978     jit_unget_reg(reg);
2979 }
2980
2981 static void
2982 _andr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2983 {
2984     if (r0 == r2)
2985         AND_(r0, r1);
2986     else {
2987         movr(r0, r1);
2988         AND_(r0, r2);
2989     }
2990 }
2991
2992 static void
2993 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2994 {
2995     movr(r0, r1);
2996     NILL(r0, x16(i0));
2997     NILH(r0, x16((jit_uword_t)i0 >> 16));
2998 #if __WORDSIZE == 64
2999     NIHL(r0, x16((jit_uword_t)i0 >> 32));
3000     NIHH(r0, x16((jit_uword_t)i0 >> 48));
3001 #endif
3002 }
3003
3004 static void
3005 _orr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3006 {
3007     if (r0 == r2)
3008         OR_(r0, r1);
3009     else {
3010         movr(r0, r1);
3011         OR_(r0, r2);
3012     }
3013 }
3014
3015 static void
3016 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3017 {
3018     movr(r0, r1);
3019     OILL(r0, x16(i0));
3020     OILH(r0, x16((jit_uword_t)i0 >> 16));
3021 #if __WORDSIZE == 64
3022     OIHL(r0, x16((jit_uword_t)i0 >> 32));
3023     OIHH(r0, x16((jit_uword_t)i0 >> 48));
3024 #endif
3025 }
3026
3027 static void
3028 _xorr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3029 {
3030     if (r0 == r2)
3031         XOR_(r0, r1);
3032     else {
3033         movr(r0, r1);
3034         XOR_(r0, r2);
3035     }
3036 }
3037
3038 static void
3039 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3040 {
3041     jit_int32_t         reg;
3042     reg = jit_get_reg(jit_class_gpr);
3043     movi(rn(reg), i0);
3044     xorr(r0, r1, rn(reg));
3045     jit_unget_reg(reg);
3046 }
3047
3048 static void
3049 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3050 {
3051     movi(r0, i0);
3052     ldr_c(r0, r0);
3053 }
3054
3055 static void
3056 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3057 {
3058     if (r0 == r2) {
3059         addr(r0, r0, r1);
3060         ldr_c(r0, r0);
3061     }
3062     else {
3063         movr(r0, r1);
3064         addr(r0, r0, r2);
3065         ldr_c(r0, r0);
3066     }
3067 }
3068
3069 static void
3070 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3071 {
3072     jit_int32_t         reg;
3073     if (s20_p(i0)) {
3074 #if __WORDSIZE == 32
3075         LB(r0, x20(i0), 0, r1);
3076 #else
3077         LGB(r0, x20(i0), 0, r1);
3078 #endif
3079     }
3080     else if (r0 != r1) {
3081         movi(r0, i0);
3082         addr(r0, r0, r1);
3083         ldr_c(r0, r0);
3084     }
3085     else {
3086         reg = jit_get_reg_but_zero(0);
3087         movi(rn(reg), i0);
3088         addr(rn(reg), rn(reg), r1);
3089         ldr_c(r0, rn(reg));
3090         jit_unget_reg_but_zero(reg);
3091     }
3092 }
3093
3094 static void
3095 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3096 {
3097     movi(r0, i0);
3098     ldr_uc(r0, r0);
3099 }
3100
3101 static void
3102 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3103 {
3104     if (r0 == r2) {
3105         addr(r0, r0, r1);
3106         ldr_uc(r0, r0);
3107     }
3108     else {
3109         movr(r0, r1);
3110         addr(r0, r0, r2);
3111         ldr_uc(r0, r0);
3112     }
3113 }
3114
3115 static void
3116 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3117 {
3118     jit_int32_t         reg;
3119     if (s20_p(i0))
3120         LLGC(r0, x20(i0), 0, r1);
3121     else if (r0 != r1) {
3122         movi(r0, i0);
3123         addr(r0, r0, r1);
3124         ldr_uc(r0, r0);
3125     }
3126     else {
3127         reg = jit_get_reg_but_zero(0);
3128         movi(rn(reg), i0);
3129         addr(rn(reg), rn(reg), r1);
3130         ldr_uc(r0, rn(reg));
3131         jit_unget_reg_but_zero(reg);
3132     }
3133 }
3134
3135 static void
3136 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3137 {
3138     movi(r0, i0);
3139     ldr_s(r0, r0);
3140 }
3141
3142 static void
3143 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3144 {
3145     if (r0 == r2) {
3146         addr(r0, r0, r1);
3147         ldr_s(r0, r0);
3148     }
3149     else {
3150         movr(r0, r1);
3151         addr(r0, r0, r2);
3152         ldr_s(r0, r0);
3153     }
3154 }
3155
3156 static void
3157 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3158 {
3159     jit_int32_t         reg;
3160 #if __WORDSIZE == 32
3161     if (u12_p(i0))
3162         LH(r0, i0, 0, r1);
3163     else
3164 #endif
3165     if (s20_p(i0)) {
3166 #if __WORDSIZE == 32
3167         LHY(r0, x20(i0), 0, r1);
3168 #else
3169         LGH(r0, x20(i0), 0, r1);
3170 #endif
3171     }
3172     else if (r0 != r1) {
3173         movi(r0, i0);
3174         addr(r0, r0, r1);
3175         ldr_s(r0, r0);
3176     }
3177     else {
3178         reg = jit_get_reg_but_zero(0);
3179         movi(rn(reg), i0);
3180         addr(rn(reg), rn(reg), r1);
3181         ldr_s(r0, rn(reg));
3182         jit_unget_reg_but_zero(reg);
3183     }
3184 }
3185
3186 static void
3187 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3188 {
3189     movi(r0, i0);
3190     ldr_us(r0, r0);
3191 }
3192
3193 static void
3194 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3195 {
3196     if (r0 == r2) {
3197         addr(r0, r0, r1);
3198         ldr_us(r0, r0);
3199     }
3200     else {
3201         movr(r0, r1);
3202         addr(r0, r0, r2);
3203         ldr_us(r0, r0);
3204     }
3205 }
3206
3207 static void
3208 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3209 {
3210     jit_int32_t         reg;
3211     if (s20_p(i0))
3212         LLGH(r0, x20(i0), 0, r1);
3213     else if (r0 != r1) {
3214         movi(r0, i0);
3215         addr(r0, r0, r1);
3216         ldr_us(r0, r0);
3217     }
3218     else {
3219         reg = jit_get_reg_but_zero(0);
3220         movi(rn(reg), i0);
3221         addr(rn(reg), rn(reg), r1);
3222         ldr_us(r0, rn(reg));
3223         jit_unget_reg_but_zero(reg);
3224     }
3225 }
3226
3227 static void
3228 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3229 {
3230     movi(r0, i0);
3231     ldr_i(r0, r0);
3232 }
3233
3234 static void
3235 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3236 {
3237     if (r0 == r2) {
3238         addr(r0, r0, r1);
3239         ldr_i(r0, r0);
3240     }
3241     else {
3242         movr(r0, r1);
3243         addr(r0, r0, r2);
3244         ldr_i(r0, r0);
3245     }
3246 }
3247
3248 static void
3249 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3250 {
3251     jit_int32_t         reg;
3252     if (s20_p(i0))
3253         LGF(r0, x20(i0), 0, r1);
3254     else if (r0 != r1) {
3255         movi(r0, i0);
3256         addr(r0, r0, r1);
3257         ldr_i(r0, r0);
3258     }
3259     else {
3260         reg = jit_get_reg_but_zero(0);
3261         movi(rn(reg), i0);
3262         addr(rn(reg), rn(reg), r1);
3263         ldr_i(r0, rn(reg));
3264         jit_unget_reg_but_zero(reg);
3265     }
3266 }
3267
3268 #if __WORDSIZE == 64
3269 static void
3270 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3271 {
3272     movi(r0, i0);
3273     ldr_ui(r0, r0);
3274 }
3275
3276 static void
3277 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3278 {
3279     if (r0 == r2) {
3280         addr(r0, r0, r1);
3281         ldr_ui(r0, r0);
3282     }
3283     else {
3284         movr(r0, r1);
3285         addr(r0, r0, r2);
3286         ldr_ui(r0, r0);
3287     }
3288 }
3289
3290 static void
3291 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3292 {
3293     jit_int32_t         reg;
3294     if (s20_p(i0))
3295         LLGF(r0, x20(i0), 0, r1);
3296     else if (r0 != r1) {
3297         movi(r0, i0);
3298         addr(r0, r0, r1);
3299         ldr_ui(r0, r0);
3300     }
3301     else {
3302         reg = jit_get_reg_but_zero(0);
3303         movi(rn(reg), i0);
3304         addr(rn(reg), rn(reg), r1);
3305         ldr_ui(r0, rn(reg));
3306         jit_unget_reg_but_zero(reg);
3307     }
3308 }
3309
3310 static void
3311 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3312 {
3313     movi(r0, i0);
3314     ldr_l(r0, r0);
3315 }
3316
3317 static void
3318 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3319 {
3320     if (r0 == r2) {
3321         addr(r0, r0, r1);
3322         ldr_l(r0, r0);
3323     }
3324     else {
3325         movr(r0, r1);
3326         addr(r0, r0, r2);
3327         ldr_l(r0, r0);
3328     }
3329 }
3330
3331 static void
3332 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3333 {
3334     jit_int32_t         reg;
3335     if (s20_p(i0))
3336         LG(r0, x20(i0), 0, r1);
3337     else if (r0 != r1) {
3338         movi(r0, i0);
3339         addr(r0, r0, r1);
3340         ldr_l(r0, r0);
3341     }
3342     else {
3343         reg = jit_get_reg_but_zero(0);
3344         movi(rn(reg), i0);
3345         addr(rn(reg), rn(reg), r1);
3346         ldr_l(r0, rn(reg));
3347         jit_unget_reg_but_zero(reg);
3348     }
3349 }
3350 #endif
3351
3352 static void
3353 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3354 {
3355     jit_int32_t         reg;
3356     reg = jit_get_reg_but_zero(0);
3357     movi(rn(reg), i0);
3358     str_c(rn(reg), r0);
3359     jit_unget_reg_but_zero(reg);
3360 }
3361
3362 static void
3363 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3364 {
3365     jit_int32_t         reg;
3366     reg = jit_get_reg_but_zero(0);
3367     movr(rn(reg), r0);
3368     addr(rn(reg), rn(reg), r1);
3369     str_c(rn(reg), r2);
3370     jit_unget_reg_but_zero(reg);
3371 }
3372
3373 static void
3374 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3375 {
3376     jit_int32_t         reg;
3377     if (u12_p(i0))
3378         STC(r1, i0, 0, r0);
3379     else if (s20_p(i0))
3380         STCY(r1, x20(i0), 0, r0);
3381     else {
3382         reg = jit_get_reg_but_zero(0);
3383         addi(rn(reg), r0, i0);
3384         str_c(rn(reg), r1);
3385         jit_unget_reg_but_zero(reg);
3386     }
3387 }
3388
3389 static void
3390 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3391 {
3392     jit_int32_t         reg;
3393     reg = jit_get_reg_but_zero(0);
3394     movi(rn(reg), i0);
3395     str_s(rn(reg), r0);
3396     jit_unget_reg_but_zero(reg);
3397 }
3398
3399 static void
3400 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3401 {
3402     jit_int32_t         reg;
3403     reg = jit_get_reg_but_zero(0);
3404     movr(rn(reg), r0);
3405     addr(rn(reg), rn(reg), r1);
3406     str_s(rn(reg), r2);
3407     jit_unget_reg_but_zero(reg);
3408 }
3409
3410 static void
3411 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3412 {
3413     jit_int32_t         reg;
3414     if (u12_p(i0))
3415         STH(r1, i0, 0, r0);
3416     else if (s20_p(i0))
3417         STHY(r1, x20(i0), 0, r0);
3418     else {
3419         reg = jit_get_reg_but_zero(0);
3420         addi(rn(reg), r0, i0);
3421         str_s(rn(reg), r1);
3422         jit_unget_reg_but_zero(reg);
3423     }
3424 }
3425
3426 static void
3427 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3428 {
3429     jit_int32_t         reg;
3430     reg = jit_get_reg_but_zero(0);
3431     movi(rn(reg), i0);
3432     str_i(rn(reg), r0);
3433     jit_unget_reg_but_zero(reg);
3434 }
3435
3436 static void
3437 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3438 {
3439     jit_int32_t         reg;
3440     reg = jit_get_reg_but_zero(0);
3441     movr(rn(reg), r0);
3442     addr(rn(reg), rn(reg), r1);
3443     str_i(rn(reg), r2);
3444     jit_unget_reg_but_zero(reg);
3445 }
3446
3447 static void
3448 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3449 {
3450     jit_int32_t         reg;
3451     if (u12_p(i0))
3452         ST(r1, i0, 0, r0);
3453     else if (s20_p(i0))
3454         STY(r1, x20(i0), 0, r0);
3455     else {
3456         reg = jit_get_reg_but_zero(0);
3457         addi(rn(reg), r0, i0);
3458         str_i(rn(reg), r1);
3459         jit_unget_reg_but_zero(reg);
3460     }
3461 }
3462
3463 #if __WORDSIZE == 64
3464 static void
3465 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3466 {
3467     jit_int32_t         reg;
3468     reg = jit_get_reg_but_zero(0);
3469     movi(rn(reg), i0);
3470     str_l(rn(reg), r0);
3471     jit_unget_reg_but_zero(reg);
3472 }
3473
3474 static void
3475 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3476 {
3477     jit_int32_t         reg;
3478     reg = jit_get_reg_but_zero(0);
3479     movr(rn(reg), r0);
3480     addr(rn(reg), rn(reg), r1);
3481     str_l(rn(reg), r2);
3482     jit_unget_reg_but_zero(reg);
3483 }
3484
3485 static void
3486 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3487 {
3488     jit_int32_t         reg;
3489     if (s20_p(i0))
3490         STG(r1, x20(i0), 0, r0);
3491     else {
3492         reg = jit_get_reg_but_zero(0);
3493         addi(rn(reg), r0, i0);
3494         str_l(rn(reg), r1);
3495         jit_unget_reg_but_zero(reg);
3496     }
3497 }
3498 #endif
3499
3500 static void
3501 _jmpi(jit_state_t *_jit, jit_word_t i0)
3502 {
3503     jit_word_t          d;
3504     jit_int32_t         reg;
3505     d = (i0 - _jit->pc.w) >> 1;
3506     if (s16_p(d))
3507         J(x16(d));
3508     else if (s32_p(d))
3509         BRL(d);
3510     else {
3511         reg = jit_get_reg_but_zero(jit_class_nospill);
3512         movi(rn(reg), i0);
3513         jmpr(rn(reg));
3514         jit_unget_reg_but_zero(reg);
3515     }
3516 }
3517
3518 static jit_word_t
3519 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3520 {
3521     jit_word_t          w;
3522     jit_int32_t         reg;
3523     reg = jit_get_reg_but_zero(jit_class_nospill);
3524     w = movi_p(rn(reg), i0);
3525     jmpr(rn(reg));
3526     jit_unget_reg_but_zero(reg);
3527     return (w);
3528 }
3529
3530 static void
3531 _calli(jit_state_t *_jit, jit_word_t i0)
3532 {
3533     jit_word_t          d;
3534     jit_int32_t         reg;
3535     d = (i0 - _jit->pc.w) >> 1;
3536     if (s32_p(d))
3537         BRASL(_R14_REGNO, d);
3538     else {
3539         reg = jit_get_reg_but_zero(0);
3540         movi(rn(reg), i0);
3541         callr(rn(reg));
3542         jit_unget_reg_but_zero(reg);
3543     }
3544 }
3545
3546 static jit_word_t
3547 _calli_p(jit_state_t *_jit, jit_word_t i0)
3548 {
3549     jit_word_t          w;
3550     jit_int32_t         reg;
3551     reg = jit_get_reg_but_zero(0);
3552     w = movi_p(rn(reg), i0);
3553     callr(rn(reg));
3554     jit_unget_reg_but_zero(reg);
3555     return (w);
3556 }
3557
3558 static jit_int32_t      gprs[] = {
3559     _R2, _R3, _R4, _R5,
3560     _R6, _R7, _R8, _R9, _R10, _R11, _R12, _R13
3561 };
3562
3563 static void
3564 _prolog(jit_state_t *_jit, jit_node_t *i0)
3565 {
3566     jit_int32_t         regno, offset;
3567     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3568         jit_int32_t     frame = -_jitc->function->frame;
3569         assert(_jitc->function->self.aoff >= frame);
3570         if (_jitc->function->assume_frame)
3571             return;
3572         _jitc->function->self.aoff = frame;
3573     }
3574     if (_jitc->function->allocar)
3575         _jitc->function->self.aoff &= -8;
3576     _jitc->function->stack = ((_jitc->function->self.alen -
3577                               /* align stack at 8 bytes */
3578                               _jitc->function->self.aoff) + 7) & -8;
3579     /* *IFF* a non variadic function,
3580      * Lightning does not reserve stack space for spilling arguments
3581      * in registers.
3582      * S390x, as per gcc, has 8 stack slots for spilling arguments,
3583      * (%r6 is callee save) and uses an alloca like approach to save
3584      * callee save fpr registers.
3585      * Since argument registers are not saved in any lightning port,
3586      * use the 8 slots to spill any modified fpr register, and still
3587      * use the same stack frame logic as gcc.
3588      * Save at least %r13 to %r15, as %r13 is used as frame pointer.
3589      * *IFF* a variadic function, a "standard" stack frame, with
3590      * fpr registers saved in an alloca'ed area, is used.
3591      */
3592     if ((_jitc->function->self.call & jit_call_varargs) &&
3593         jit_arg_reg_p(_jitc->function->vagp))
3594         regno = _jitc->function->vagp;
3595     else {
3596         for (regno = 4; regno < jit_size(gprs) - 1; regno++) {
3597             if (jit_regset_tstbit(&_jitc->function->regset, gprs[regno]))
3598                 break;
3599         }
3600     }
3601 #if __WORDSIZE == 32
3602 #  define FP_OFFSET             64
3603     if (_jitc->function->self.call & jit_call_varargs)
3604         offset = regno * 4 + 8;
3605     else
3606         offset = (regno - 4) * 4 + 32;
3607     STM(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3608 #else
3609 #  define FP_OFFSET             128
3610     if (_jitc->function->self.call & jit_call_varargs)
3611         offset = regno * 8 + 16;
3612     else
3613         offset = (regno - 4) * 8 + 48;
3614     STMG(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3615 #endif
3616
3617 #define SPILL(R, O)                                                     \
3618     do {                                                                \
3619         if (jit_regset_tstbit(&_jitc->function->regset, R))             \
3620             stxi_d(O, _R15_REGNO, rn(R));                               \
3621     } while (0)
3622     if (_jitc->function->self.call & jit_call_varargs) {
3623         for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3624             stxi_d(FP_OFFSET + regno * 8, _R15_REGNO, rn(_F0 - regno));
3625         SPILL(_F8, _jitc->function->vaoff + offsetof(jit_va_list_t, f8));
3626         SPILL(_F9, _jitc->function->vaoff + offsetof(jit_va_list_t, f9));
3627         SPILL(_F10, _jitc->function->vaoff + offsetof(jit_va_list_t, f10));
3628         SPILL(_F11, _jitc->function->vaoff + offsetof(jit_va_list_t, f11));
3629         SPILL(_F12, _jitc->function->vaoff + offsetof(jit_va_list_t, f12));
3630         SPILL(_F13, _jitc->function->vaoff + offsetof(jit_va_list_t, f13));
3631         SPILL(_F14, _jitc->function->vaoff + offsetof(jit_va_list_t, f14));
3632     }
3633     else {
3634         /* First 4 in low address */
3635 #if __WORDSIZE == 32
3636         SPILL(_F10, 0);
3637         SPILL(_F11, 8);
3638         SPILL(_F12, 16);
3639         SPILL(_F13, 24);
3640         /* gpr registers here */
3641         SPILL(_F14, 72);
3642         SPILL(_F8, 80);
3643         SPILL(_F9, 88);
3644 #else
3645         SPILL(_F10, 16);
3646         SPILL(_F11, 24);
3647         SPILL(_F12, 32);
3648         SPILL(_F13, 48);
3649         /* Last 3 in high address */
3650         SPILL(_F14, 136);
3651         SPILL(_F8, 144);
3652         SPILL(_F9, 152);
3653 #endif
3654     }
3655 #undef SPILL
3656     movr(_R13_REGNO, _R15_REGNO);
3657     subi(_R15_REGNO, _R15_REGNO, stack_framesize + _jitc->function->stack);
3658     if (_jitc->function->allocar) {
3659         regno = jit_get_reg(jit_class_gpr);
3660         movi(rn(regno), _jitc->function->self.aoff);
3661         stxi_i(_jitc->function->aoffoff, _R13_REGNO, rn(regno));
3662         jit_unget_reg(regno);
3663     }
3664 }
3665
3666 static void
3667 _epilog(jit_state_t *_jit, jit_node_t *i0)
3668 {
3669     jit_int32_t         regno, offset;
3670     if (_jitc->function->assume_frame)
3671         return;
3672     if ((_jitc->function->self.call & jit_call_varargs) &&
3673         jit_arg_reg_p(_jitc->function->vagp))
3674         regno = _jitc->function->vagp;
3675     else {
3676         for (regno = 4; regno < jit_size(gprs) - 1; regno++) {
3677             if (jit_regset_tstbit(&_jitc->function->regset, gprs[regno]))
3678                 break;
3679         }
3680     }
3681 #if __WORDSIZE == 32
3682     if (_jitc->function->self.call & jit_call_varargs)
3683         offset = regno * 4 + 8;
3684     else
3685         offset = (regno - 4) * 4 + 32;
3686 #else
3687     if (_jitc->function->self.call & jit_call_varargs)
3688         offset = regno * 8 + 16;
3689     else
3690         offset = (regno - 4) * 8 + 48;
3691 #endif
3692     movr(_R15_REGNO, _R13_REGNO);
3693
3694 #define LOAD(R, O)                                                      \
3695     do {                                                                \
3696         if (jit_regset_tstbit(&_jitc->function->regset, R))             \
3697             ldxi_d(rn(R), _R15_REGNO, O);                               \
3698     } while (0)
3699     if (_jitc->function->self.call & jit_call_varargs) {
3700         LOAD(_F8, _jitc->function->vaoff + offsetof(jit_va_list_t, f8));
3701         LOAD(_F9, _jitc->function->vaoff + offsetof(jit_va_list_t, f9));
3702         LOAD(_F10, _jitc->function->vaoff + offsetof(jit_va_list_t, f10));
3703         LOAD(_F11, _jitc->function->vaoff + offsetof(jit_va_list_t, f11));
3704         LOAD(_F12, _jitc->function->vaoff + offsetof(jit_va_list_t, f12));
3705         LOAD(_F13, _jitc->function->vaoff + offsetof(jit_va_list_t, f13));
3706         LOAD(_F14, _jitc->function->vaoff + offsetof(jit_va_list_t, f14));
3707     }
3708     else {
3709 #if __WORDSIZE == 32
3710         LOAD(_F10, 0);
3711         LOAD(_F11, 8);
3712         LOAD(_F12, 16);
3713         LOAD(_F13, 24);
3714         LOAD(_F14, 72);
3715         LOAD(_F8, 80);
3716         LOAD(_F9, 88);
3717 #else
3718         LOAD(_F10, 16);
3719         LOAD(_F11, 24);
3720         LOAD(_F12, 32);
3721         LOAD(_F13, 48);
3722         LOAD(_F14, 136);
3723         LOAD(_F8, 144);
3724         LOAD(_F9, 152);
3725 #endif
3726     }
3727 #undef LOAD
3728 #if __WORDSIZE == 32
3729     LM(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3730 #else
3731     LMG(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3732 #endif
3733     BR(_R14_REGNO);
3734 }
3735
3736 static void
3737 _vastart(jit_state_t *_jit, jit_int32_t r0)
3738 {
3739     jit_int32_t         reg;
3740
3741     assert(_jitc->function->self.call & jit_call_varargs);
3742
3743     /* Return jit_va_list_t in the register argument */
3744     addi(r0, _R13_REGNO, _jitc->function->vaoff);
3745     reg = jit_get_reg(jit_class_gpr);
3746
3747     /* Initialize gp offset in the save area. */
3748     movi(rn(reg), _jitc->function->vagp);
3749     stxi(offsetof(jit_va_list_t, gpoff), r0, rn(reg));
3750
3751     /* Initialize fp offset in the save area. */
3752     movi(rn(reg), _jitc->function->vafp);
3753     stxi(offsetof(jit_va_list_t, fpoff), r0, rn(reg));
3754
3755     /* Initialize overflow pointer to the first stack argument. */
3756     addi(rn(reg), _R13_REGNO, _jitc->function->self.size);
3757     stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3758
3759     /* Initialize register save area pointer. */
3760     stxi(offsetof(jit_va_list_t, save), r0, _R13_REGNO);
3761
3762     jit_unget_reg(reg);
3763 }
3764
3765 static void
3766 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3767 {
3768     jit_int32_t         rg0;
3769     jit_int32_t         rg1;
3770     jit_int32_t         rg2;
3771     jit_word_t          ge_code;
3772     jit_word_t          lt_code;
3773
3774     assert(_jitc->function->self.call & jit_call_varargs);
3775
3776     rg0 = jit_get_reg_but_zero(0);
3777     rg1 = jit_get_reg_but_zero(0);
3778
3779     /* Load the gp offset in save area in the first temporary. */
3780     ldxi(rn(rg0), r1, offsetof(jit_va_list_t, gpoff));
3781
3782     /* Jump over if there are no remaining arguments in the save area. */
3783     ge_code = bgei_p(_jit->pc.w, rn(rg0), 5);
3784
3785     /* Load the save area pointer in the second temporary. */
3786     ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3787
3788     /* Scale offset */
3789     rg2 = jit_get_reg_but_zero(0);
3790     lshi(rn(rg2), rn(rg0),
3791 #if __WORDSIZE == 32
3792          2
3793 #else
3794          3
3795 #endif
3796          );
3797     /* Add offset to saved area. */
3798     addi(rn(rg2), rn(rg2), 2 * sizeof(jit_word_t));
3799
3800     /* Load the vararg argument in the first argument. */
3801     ldxr(r0, rn(rg1), rn(rg2));
3802     jit_unget_reg_but_zero(rg2);
3803
3804     /* Update the gp offset. */
3805     addi(rn(rg0), rn(rg0), 1);
3806     stxi(offsetof(jit_va_list_t, gpoff), r1, rn(rg0));
3807
3808     /* Will only need one temporary register below. */
3809     jit_unget_reg_but_zero(rg1);
3810
3811     /* Jump over overflow code. */
3812     lt_code = jmpi_p(_jit->pc.w);
3813
3814     /* Where to land if argument is in overflow area. */
3815     patch_at(ge_code, _jit->pc.w);
3816
3817     /* Load overflow pointer. */
3818     ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3819
3820     /* Load argument. */
3821     ldr(r0, rn(rg0));
3822
3823     /* Update overflow pointer. */
3824     addi(rn(rg0), rn(rg0), sizeof(jit_word_t));
3825     stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3826
3827     /* Where to land if argument is in save area. */
3828     patch_at(lt_code, _jit->pc.w);
3829
3830     jit_unget_reg_but_zero(rg0);
3831 }
3832
3833 static void
3834 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3835 {
3836     jit_word_t                   d;
3837     union {
3838         jit_uint16_t            *s;
3839         jit_word_t               w;
3840     } u;
3841     u.w = instr;
3842     union {
3843         struct {
3844             jit_uint16_t        op :  8;
3845             jit_uint16_t        r1 :  4;
3846             jit_uint16_t        r3 :  4;
3847         } b;
3848         jit_uint16_t            s;
3849     } i0;
3850     union {
3851         struct {
3852             jit_uint16_t        i2;
3853         } b;
3854         jit_uint16_t            s;
3855     } i1;
3856     union {
3857         struct {
3858             jit_uint32_t        ih : 16;
3859             jit_uint32_t        il : 16;
3860         } b;
3861         jit_uint32_t            i;
3862     } i12;
3863     i0.s = u.s[0];
3864     /* movi_p */
3865     if (i0.b.op ==
3866 #if __WORDSIZE == 32
3867         0xA7 && i0.b.r3 == 8
3868 #else
3869         0xA5
3870 #endif
3871         ) {
3872 #if __WORDSIZE == 64
3873         assert(i0.b.r3 == 3);
3874 #endif
3875         i1.b.i2 = (jit_uword_t)label;
3876         u.s[1] = i1.s;
3877         i0.s = u.s[2];
3878         assert(i0.b.op == 0xA5 && i0.b.r3 == 2);
3879         i1.b.i2 = (jit_uword_t)label >> 16;
3880         u.s[3] = i1.s;
3881 #if __WORDSIZE == 64
3882         i0.s = u.s[4];
3883         assert(i0.b.op == 0xA5 && i0.b.r3 == 1);
3884         i1.b.i2 = (jit_uword_t)label >> 32;
3885         u.s[5] = i1.s;
3886         i0.s = u.s[6];
3887         assert(i0.b.op == 0xA5 && i0.b.r3 == 0);
3888         i1.b.i2 = (jit_uword_t)label >> 48;
3889         u.s[7] = i1.s;
3890 #endif
3891     }
3892     /* BRC */
3893     else if (i0.b.op == 0xA7) {
3894         assert(i0.b.r3 == 0x4);
3895         d = (label - instr) >> 1;
3896         assert(s16_p(d));
3897         i1.b.i2 = d;
3898         u.s[1] = i1.s;
3899     }
3900     /* BRCL */
3901     else if (i0.b.op == 0xC0) {
3902         assert(i0.b.r3 == 0x4);
3903         d = (label - instr) >> 1;
3904         assert(s32_p(d));
3905         i12.i = d;
3906         u.s[1] = i12.b.ih;
3907         u.s[2] = i12.b.il;
3908     }
3909     else
3910         abort();
3911 }
3912 #endif