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