deps/lightning/lib/jit_s390-cpu.c

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