deps/lightning/lib/jit_aarch64-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 typedef union {
  22 /* aarch64-opc.c */
  23 #  define ui                    jit_uint32_t
  24 #  if __BYTE_ORDER == __LITTLE_ENDIAN
  25     /* cond2: condition in truly conditional-executed inst.  */
  26     struct {            ui b:  4; } cond2;
  27     /* nzcv: flag bit specifier, encoded in the "nzcv" field.  */
  28     struct {            ui b:  4; } nzcv;
  29     /* defgh: d:e:f:g:h bits in AdvSIMD modified immediate.  */
  30     struct { ui _:  5;  ui b:  5; } defgh;
  31     /* abc: a:b:c bits in AdvSIMD modified immediate.  */
  32     struct { ui _: 16;  ui b:  3; } abc;
  33     /* imm19: e.g. in CBZ.  */
  34     struct { ui _:  5;  ui b: 19; } imm19;
  35     /* immhi: e.g. in ADRP.  */
  36     struct { ui _:  5;  ui b: 19; } immhi;
  37     /* immlo: e.g. in ADRP.  */
  38     struct { ui _: 29;  ui b:  2; } immlo;
  39     /* size: in most AdvSIMD and floating-point instructions.  */
  40     struct { ui _: 22;  ui b:  2; } size;
  41     /* vldst_size: size field in the AdvSIMD load/store inst.  */
  42     struct { ui _: 10;  ui b:  2; } vldst_size;
  43     /* op: in AdvSIMD modified immediate instructions.  */
  44     struct { ui _: 29;  ui b:  1; } op;
  45     /* Q: in most AdvSIMD instructions.  */
  46     struct { ui _: 30;  ui b:  1; } Q;
  47     /* Rt: in load/store instructions.  */
  48     struct {            ui b:  5; } Rt;
  49     /* Rd: in many integer instructions.  */
  50     struct {            ui b:  5; } Rd;
  51     /* Rn: in many integer instructions.  */
  52     struct { ui _:  5;  ui b:  5; } Rn;
  53     /* Rt2: in load/store pair instructions.  */
  54     struct { ui _: 10;  ui b:  5; } Rt2;
  55     /* Ra: in fp instructions.  */
  56     struct { ui _: 10;  ui b:  5; } Ra;
  57     /* op2: in the system instructions.  */
  58     struct { ui _:  5;  ui b:  3; } op2;
  59     /* CRm: in the system instructions.  */
  60     struct { ui _:  8;  ui b:  4; } CRm;
  61     /* CRn: in the system instructions.  */
  62     struct { ui _: 12;  ui b:  4; } CRn;
  63     /* op1: in the system instructions.  */
  64     struct { ui _: 16;  ui b:  3; } op1;
  65     /* op0: in the system instructions.  */
  66     struct { ui _: 19;  ui b:  2; } op0;
  67     /* imm3: in add/sub extended reg instructions.  */
  68     struct { ui _: 10;  ui b:  3; } imm3;
  69     /* cond: condition flags as a source operand.  */
  70     struct { ui _: 12;  ui b:  4; } cond;
  71     /* opcode: in advsimd load/store instructions.  */
  72     struct { ui _: 12;  ui b:  4; } opcode;
  73     /* cmode: in advsimd modified immediate instructions.  */
  74     struct { ui _: 12;  ui b:  4; } cmode;
  75     /* asisdlso_opcode: opcode in advsimd ld/st single element.  */
  76     struct { ui _: 13;  ui b:  3; } asisdlso_opcode;
  77     /* len: in advsimd tbl/tbx instructions.  */
  78     struct { ui _: 13;  ui b:  2; } len;
  79     /* Rm: in ld/st reg offset and some integer inst.  */
  80     struct { ui _: 16;  ui b:  5; } Rm;
  81     /* Rs: in load/store exclusive instructions.  */
  82     struct { ui _: 16;  ui b:  5; } Rs;
  83     /* option: in ld/st reg offset + add/sub extended reg inst.  */
  84     struct { ui _: 13;  ui b:  3; } option;
  85     /* S: in load/store reg offset instructions.  */
  86     struct { ui _: 12;  ui b:  1; } S;
  87     /* hw: in move wide constant instructions.  */
  88     struct { ui _: 21;  ui b:  2; } hw;
  89     /* opc: in load/store reg offset instructions.  */
  90     struct { ui _: 22;  ui b:  2; } opc;
  91     /* opc1: in load/store reg offset instructions.  */
  92     struct { ui _: 23;  ui b:  1; } opc1;
  93     /* shift: in add/sub reg/imm shifted instructions.  */
  94     struct { ui _: 22;  ui b:  2; } shift;
  95     /* type: floating point type field in fp data inst.  */
  96     struct { ui _: 22;  ui b:  2; } type;
  97     /* ldst_size: size field in ld/st reg offset inst.  */
  98     struct { ui _: 30;  ui b:  2; } ldst_size;
  99     /* imm6: in add/sub reg shifted instructions.  */
 100     struct { ui _: 10;  ui b:  6; } imm6;
 101     /* imm4: in advsimd ext and advsimd ins instructions.  */
 102     struct { ui _: 11;  ui b:  4; } imm4;
 103     /* imm5: in conditional compare (immediate) instructions.  */
 104     struct { ui _: 16;  ui b:  5; } imm5;
 105     /* imm7: in load/store pair pre/post index instructions.  */
 106     struct { ui _: 15;  ui b:  7; } imm7;
 107     /* imm8: in floating-point scalar move immediate inst.  */
 108     struct { ui _: 13;  ui b:  8; } imm8;
 109     /* imm9: in load/store pre/post index instructions.  */
 110     struct { ui _: 12;  ui b:  9; } imm9;
 111     /* imm12: in ld/st unsigned imm or add/sub shifted inst.  */
 112     struct { ui _: 10;  ui b: 12; } imm12;
 113     /* imm14: in test bit and branch instructions.  */
 114     struct { ui _:  5;  ui b: 14; } imm14;
 115     /* imm16: in exception instructions.  */
 116     struct { ui _:  5;  ui b: 16; } imm16;
 117     /* imm26: in unconditional branch instructions.  */
 118     struct {            ui b: 26; } imm26;
 119     /* imms: in bitfield and logical immediate instructions.  */
 120     struct { ui _: 10;  ui b:  6; } imms;
 121     /* immr: in bitfield and logical immediate instructions.  */
 122     struct { ui _: 16;  ui b:  6; } immr;
 123     /* immb: in advsimd shift by immediate instructions.  */
 124     struct { ui _: 16;  ui b:  3; } immb;
 125     /* immh: in advsimd shift by immediate instructions.  */
 126     struct { ui _: 19;  ui b:  4; } immh;
 127     /* N: in logical (immediate) instructions.  */
 128     struct { ui _: 22;  ui b:  1; } N;
 129     /* index: in ld/st inst deciding the pre/post-index.  */
 130     struct { ui _: 11;  ui b:  1; } index;
 131     /* index2: in ld/st pair inst deciding the pre/post-index.  */
 132     struct { ui _: 24;  ui b:  1; } index2;
 133     /* sf: in integer data processing instructions.  */
 134     struct { ui _: 31;  ui b:  1; } sf;
 135     /* H: in advsimd scalar x indexed element instructions.  */
 136     struct { ui _: 11;  ui b:  1; } H;
 137     /* L: in advsimd scalar x indexed element instructions.  */
 138     struct { ui _: 21;  ui b:  1; } L;
 139     /* M: in advsimd scalar x indexed element instructions.  */
 140     struct { ui _: 20;  ui b:  1; } M;
 141     /* b5: in the test bit and branch instructions.  */
 142     struct { ui _: 31;  ui b:  1; } b5;
 143     /* b40: in the test bit and branch instructions.  */
 144     struct { ui _: 19;  ui b:  5; } b40;
 145     /* scale: in the fixed-point scalar to fp converting inst.  */
 146     struct { ui _: 10;  ui b:  6; } scale;
 147 #  else
 148     struct { ui _: 28;  ui b:  4; } cond2;
 149     struct { ui _: 28;  ui b:  4; } nzcv;
 150     struct { ui _: 22;  ui b:  5; } defgh;
 151     struct { ui _: 13;  ui b:  3; } abc;
 152     struct { ui _:  8;  ui b: 19; } imm19;
 153     struct { ui _:  8;  ui b: 19; } immhi;
 154     struct { ui _:  1;  ui b: 29; } immlo;
 155     struct { ui _:  8;  ui b:  2; } size;
 156     struct { ui _: 20;  ui b:  2; } vldst_size;
 157     struct { ui _:  2;  ui b:  1; } op;
 158     struct { ui _:  1;  ui b:  1; } Q;
 159     struct { ui _: 27;  ui b:  1; } Rt;
 160     struct { ui _: 27;  ui b:  1; } Rd;
 161     struct { ui _: 22;  ui b:  5; } Rn;
 162     struct { ui _: 17;  ui b:  5; } Rt2;
 163     struct { ui _: 17;  ui b:  5; } Ra;
 164     struct { ui _: 24;  ui b:  3; } op2;
 165     struct { ui _: 20;  ui b:  4; } CRm;
 166     struct { ui _: 16;  ui b:  4; } CRn;
 167     struct { ui _: 13;  ui b:  3; } op1;
 168     struct { ui _: 11;  ui b:  2; } op0;
 169     struct { ui _: 19;  ui b:  3; } imm3;
 170     struct { ui _: 16;  ui b:  4; } cond;
 171     struct { ui _: 16;  ui b:  4; } opcode;
 172     struct { ui _: 16;  ui b:  4; } cmode;
 173     struct { ui _: 16;  ui b:  3; } asisdlso_opcode;
 174     struct { ui _: 17;  ui b:  2; } len;
 175     struct { ui _: 11;  ui b:  5; } Rm;
 176     struct { ui _: 11;  ui b:  5; } Rs;
 177     struct { ui _: 16;  ui b:  3; } option;
 178     struct { ui _: 19;  ui b:  1; } S;
 179     struct { ui _:  9;  ui b:  2; } hw;
 180     struct { ui _:  8;  ui b:  2; } opc;
 181     struct { ui _:  8;  ui b:  1; } opc1;
 182     struct { ui _:  8;  ui b:  2; } shift;
 183     struct { ui _:  8;  ui b:  2; } type;
 184     struct {            ui b:  2; } ldst_size;
 185     struct { ui _: 16;  ui b:  6; } imm6;
 186     struct { ui _: 17;  ui b:  4; } imm4;
 187     struct { ui _: 11;  ui b:  5; } imm5;
 188     struct { ui _: 10;  ui b:  7; } imm7;
 189     struct { ui _: 11;  ui b:  8; } imm8;
 190     struct { ui _: 11;  ui b:  9; } imm9;
 191     struct { ui _: 10;  ui b: 12; } imm12;
 192     struct { ui _: 13;  ui b: 14; } imm14;
 193     struct { ui _: 11;  ui b: 16; } imm16;
 194     struct { ui _:  6;  ui b: 26; } imm26;
 195     struct { ui _: 16;  ui b:  6; } imms;
 196     struct { ui _: 10;  ui b:  6; } immr;
 197     struct { ui _: 13;  ui b:  3; } immb;
 198     struct { ui _:  9;  ui b:  4; } immh;
 199     struct { ui _:  9;  ui b:  1; } N;
 200     struct { ui _: 20;  ui b:  1; } index;
 201     struct { ui _:  7;  ui b:  1; } index2;
 202     struct {            ui b:  1; } sf;
 203     struct { ui _: 20;  ui b:  1; } H;
 204     struct { ui _: 10;  ui b:  1; } L;
 205     struct { ui _: 11;  ui b:  1; } M;
 206     struct {            ui b:  1; } b5;
 207     struct { ui _:  8;  ui b:  5; } b40;
 208     struct { ui _: 16;  ui b:  6; } scale;
 209 #  endif
 210     jit_int32_t         w;
 211 #  undef ui
 212 } instr_t;
 213 #  define s26_p(d)                      ((d) >= -33554432 && (d) <= 33554431)
 214 #  define ii(i)                         *_jit->pc.ui++ = i
 215 #  define ldr(r0,r1)                    ldr_l(r0,r1)
 216 #  define ldi(r0,i0)                    ldi_l(r0,i0)
 217 #  define ldxr(r0,r1,r2)                ldxr_l(r0,r1,r2)
 218 #  define ldxi(r0,r1,i0)                ldxi_l(r0,r1,i0)
 219 #  define str(r0,r1)                    str_l(r0,r1)
 220 #  define sti(i0,r0)                    sti_l(i0,r0)
 221 #  define stxr(r0,r1,r2)                stxr_l(r0,r1,r2)
 222 #  define stxi(i0,r0,r1)                stxi_l(i0,r0,r1)
 223 #  define FP_REGNO                      0x1d
 224 #  define LR_REGNO                      0x1e
 225 #  define SP_REGNO                      0x1f
 226 #  define XZR_REGNO                     0x1f
 227 #  define WZR_REGNO                     XZR_REGNO
 228 #  define LSL_12                        0x00400000
 229 #  define MOVI_LSL_16                   0x00200000
 230 #  define MOVI_LSL_32                   0x00400000
 231 #  define MOVI_LSL_48                   0x00600000
 232 #  define XS                            0x80000000      /* Wn -> Xn */
 233 #  define DS                            0x00400000      /* Sn -> Dn */
 234 #  define CC_NE                         0x0
 235 #  define CC_EQ                         0x1
 236 #  define CC_CC                         0x2
 237 #  define CC_LO                         CC_CC
 238 #  define CC_CS                         0x3
 239 #  define CC_HS                         CC_CS
 240 #  define CC_PL                         0x4
 241 #  define CC_MI                         0x5
 242 #  define CC_VC                         0x6
 243 #  define CC_VS                         0x7
 244 #  define CC_LS                         0x8
 245 #  define CC_HI                         0x9
 246 #  define CC_LT                         0xa
 247 #  define CC_GE                         0xb
 248 #  define CC_LE                         0xc
 249 #  define CC_GT                         0xd
 250 #  define CC_NV                         0xe
 251 #  define CC_AL                         0xf
 252 /* Branches need inverted condition */
 253 #  define BCC_EQ                        0x0
 254 #  define BCC_NE                        0x1
 255 #  define BCC_CS                        0x2
 256 #  define BCC_HS                        BCC_CS
 257 #  define BCC_CC                        0x3
 258 #  define BCC_LO                        BCC_CC
 259 #  define BCC_MI                        0x4
 260 #  define BCC_PL                        0x5
 261 #  define BCC_VS                        0x6
 262 #  define BCC_VC                        0x7
 263 #  define BCC_HI                        0x8
 264 #  define BCC_LS                        0x9
 265 #  define BCC_GE                        0xa
 266 #  define BCC_LT                        0xb
 267 #  define BCC_GT                        0xc
 268 #  define BCC_LE                        0xd
 269 #  define BCC_AL                        0xe
 270 #  define BCC_NV                        0xf
 271 /* adapted and cut down to only tested and required by lightning,
 272  * from data in binutils/aarch64-tbl.h */
 273 #  define A64_ADCS                      0x3a000000
 274 #  define A64_SBCS                      0x7a000000
 275 #  define A64_ADDI                      0x11000000
 276 #  define A64_ADDSI                     0xb1000000
 277 #  define A64_SUBI                      0x51000000
 278 #  define A64_SUBSI                     0x71000000
 279 #  define A64_ADD                       0x0b000000
 280 #  define A64_ADDS                      0x2b000000
 281 #  define A64_SUB                       0x4b000000
 282 #  define A64_NEG                       0x4b0003e0
 283 #  define A64_SUBS                      0x6b000000
 284 #  define A64_CMP                       0x6b00001f
 285 #  define A64_BFM                       0x33400000
 286 #  define A64_SBFM                      0x93400000
 287 #  define A64_SBFX                      0x13400000
 288 #  define A64_UBFM                      0x53400000
 289 #  define A64_UBFX                      0x53400000
 290 #  define A64_B                         0x14000000
 291 #  define A64_BL                        0x94000000
 292 #  define A64_BR                        0xd61f0000
 293 #  define A64_BLR                       0xd63f0000
 294 #  define A64_RET                       0xd65f0000
 295 #  define A64_CBZ                       0x34000000
 296 #  define A64_CBNZ                      0x35000000
 297 #  define A64_B_C                       0x54000000
 298 #  define A64_CSINC                     0x1a800400
 299 #  define A64_CSSEL                     0x1a800000
 300 #  define A64_REV                       0xdac00c00
 301 #  define A64_UDIV                      0x1ac00800
 302 #  define A64_SDIV                      0x1ac00c00
 303 #  define A64_LSL                       0x1ac02000
 304 #  define A64_LSR                       0x1ac02400
 305 #  define A64_ASR                       0x1ac02800
 306 #  define A64_RORV                      0x1ac02c00
 307 #  define A64_EXTR                      0x13800000
 308 #  define A64_MUL                       0x1b007c00
 309 #  define A64_SMULL                     0x9b207c00
 310 #  define A64_SMULH                     0x9b407c00
 311 #  define A64_UMULL                     0x9ba07c00
 312 #  define A64_UMULH                     0x9bc07c00
 313 #  define A64_STRBI                     0x39000000
 314 #  define A64_LDRBI                     0x39400000
 315 #  define A64_LDRSBI                    0x39800000
 316 #  define A64_STRI                      0xf9000000
 317 #  define A64_LDRI                      0xf9400000
 318 #  define A64_STRHI                     0x79000000
 319 #  define A64_LDRHI                     0x79400000
 320 #  define A64_LDRSHI                    0x79800000
 321 #  define A64_STRWI                     0xb9000000
 322 #  define A64_LDRWI                     0xb9400000
 323 #  define A64_LDRSWI                    0xb9800000
 324 #  define A64_STRB                      0x38206800
 325 #  define A64_LDRB                      0x38606800
 326 #  define A64_LDRSB                     0x38e06800
 327 #  define A64_STR                       0xf8206800
 328 #  define A64_LDR                       0xf8606800
 329 #  define A64_LDAXR                     0xc85ffc00
 330 #  define A64_STLXR                     0xc800fc00
 331 #  define A64_STRH                      0x78206800
 332 #  define A64_LDRH                      0x78606800
 333 #  define A64_LDRSH                     0x78a06800
 334 #  define A64_STRW                      0xb8206800
 335 #  define A64_LDRW                      0xb8606800
 336 #  define A64_LDRSW                     0xb8a06800
 337 #  define A64_STURB                     0x38000000
 338 #  define A64_LDURB                     0x38400000
 339 #  define A64_LDURSB                    0x38800000
 340 #  define A64_STUR                      0xf8000000
 341 #  define A64_LDUR                      0xf8400000
 342 #  define A64_STURH                     0x78000000
 343 #  define A64_LDURH                     0x78400000
 344 #  define A64_LDURSH                    0x78800000
 345 #  define A64_STURW                     0xb8000000
 346 #  define A64_LDURW                     0xb8400000
 347 #  define A64_LDURSW                    0xb8800000
 348 #  define A64_STP                       0x29000000
 349 #  define A64_LDP                       0x29400000
 350 #  define A64_STP_POS                   0x29800000
 351 #  define A64_LDP_PRE                   0x28c00000
 352 #  define A64_ANDI                      0x12400000
 353 #  define A64_ORRI                      0x32400000
 354 #  define A64_EORI                      0x52400000
 355 #  define A64_ANDSI                     0x72000000
 356 #  define A64_AND                       0x0a000000
 357 #  define A64_ORR                       0x2a000000
 358 #  define A64_MOV                       0x2a0003e0      /* AKA orr Rd,xzr,Rm */
 359 #  define A64_MVN                       0x2a2003e0
 360 #  define A64_CLS                       0x5ac01400
 361 #  define A64_CLZ                       0x5ac01000
 362 #  define A64_RBIT                      0x5ac00000
 363 #  define A64_UXTW                      0x2a0003e0      /* AKA MOV */
 364 #  define A64_EOR                       0x4a000000
 365 #  define A64_ANDS                      0x6a000000
 366 #  define A64_MOVN                      0x12800000
 367 #  define A64_MOVZ                      0x52800000
 368 #  define A64_MOVK                      0x72800000
 369 #  define BFM(Rd,Rn,ImmR,ImmS)          oxxrs(A64_BFM|XS,Rd,Rn,ImmR,ImmS)
 370 #  define SBFM(Rd,Rn,ImmR,ImmS)         oxxrs(A64_SBFM|XS,Rd,Rn,ImmR,ImmS)
 371 #  define UBFM(Rd,Rn,ImmR,ImmS)         oxxrs(A64_UBFM|XS,Rd,Rn,ImmR,ImmS)
 372 #  define SBFX(Rd,Rn,ImmR,ImmS)         oxxrs(A64_SBFX|XS,Rd,Rn,ImmR,ImmS)
 373 #  define UBFX(Rd,Rn,ImmR,ImmS)         oxxrs(A64_UBFX|XS,Rd,Rn,ImmR,ImmS)
 374 #  define CMP(Rn,Rm)                    oxx_(A64_CMP|XS,Rn,Rm)
 375 #  define CMPI(Rn,Imm12)                oxxi(A64_SUBSI|XS,XZR_REGNO,Rn,Imm12)
 376 #  define CMPI_12(Rn,Imm12)             oxxi(A64_SUBSI|XS|LSL_12,XZR_REGNO,Rn,Imm12)
 377 #  define CMNI(Rn,Imm12)                oxxi(A64_ADDSI|XS,XZR_REGNO,Rn,Imm12)
 378 #  define CMNI_12(Rn,Imm12)             oxxi(A64_ADDSI|XS|LSL_12,XZR_REGNO,Rn,Imm12)
 379 #  define CSINC(Rd,Rn,Rm,Cc)            oxxxc(A64_CSINC|XS,Rd,Rn,Rm,Cc)
 380 #  define TST(Rn,Rm)                    oxxx(A64_ANDS|XS,XZR_REGNO,Rn,Rm)
 381 /* actually should use oxxrs but logical_immediate returns proper encoding */
 382 #  define TSTI(Rn,Imm12)                oxxi(A64_ANDSI,XZR_REGNO,Rn,Imm12)
 383 #  define MOV(Rd,Rm)                    ox_x(A64_MOV|XS,Rd,Rm)
 384 #  define MVN(Rd,Rm)                    ox_x(A64_MVN|XS,Rd,Rm)
 385 #  define NEG(Rd,Rm)                    ox_x(A64_NEG|XS,Rd,Rm)
 386 #  define CLS(Rd,Rm)                    o_xx(A64_CLS|XS,Rd,Rm)
 387 #  define CLZ(Rd,Rm)                    o_xx(A64_CLZ|XS,Rd,Rm)
 388 #  define RBIT(Rd,Rm)                   o_xx(A64_RBIT|XS,Rd,Rm)
 389 #  define MOVN(Rd,Imm16)                ox_h(A64_MOVN|XS,Rd,Imm16)
 390 #  define MOVN_16(Rd,Imm16)             ox_h(A64_MOVN|XS|MOVI_LSL_16,Rd,Imm16)
 391 #  define MOVN_32(Rd,Imm16)             ox_h(A64_MOVN|XS|MOVI_LSL_32,Rd,Imm16)
 392 #  define MOVN_48(Rd,Imm16)             ox_h(A64_MOVN|XS|MOVI_LSL_48,Rd,Imm16)
 393 #  define MOVZ(Rd,Imm16)                ox_h(A64_MOVZ|XS,Rd,Imm16)
 394 #  define MOVZ_16(Rd,Imm16)             ox_h(A64_MOVZ|XS|MOVI_LSL_16,Rd,Imm16)
 395 #  define MOVZ_32(Rd,Imm16)             ox_h(A64_MOVZ|XS|MOVI_LSL_32,Rd,Imm16)
 396 #  define MOVZ_48(Rd,Imm16)             ox_h(A64_MOVZ|XS|MOVI_LSL_48,Rd,Imm16)
 397 #  define MOVK(Rd,Imm16)                ox_h(A64_MOVK|XS,Rd,Imm16)
 398 #  define MOVK_16(Rd,Imm16)             ox_h(A64_MOVK|XS|MOVI_LSL_16,Rd,Imm16)
 399 #  define MOVK_32(Rd,Imm16)             ox_h(A64_MOVK|XS|MOVI_LSL_32,Rd,Imm16)
 400 #  define MOVK_48(Rd,Imm16)             ox_h(A64_MOVK|XS|MOVI_LSL_48,Rd,Imm16)
 401 #  define ADD(Rd,Rn,Rm)                 oxxx(A64_ADD|XS,Rd,Rn,Rm)
 402 #  define ADDI(Rd,Rn,Imm12)             oxxi(A64_ADDI|XS,Rd,Rn,Imm12)
 403 #  define ADDI_12(Rd,Rn,Imm12)          oxxi(A64_ADDI|XS|LSL_12,Rd,Rn,Imm12)
 404 #  define MOV_XSP(Rd,Rn)                ADDI(Rd,Rn,0)
 405 #  define ADDS(Rd,Rn,Rm)                oxxx(A64_ADDS|XS,Rd,Rn,Rm)
 406 #  define ADDSI(Rd,Rn,Imm12)            oxxi(A64_ADDSI|XS,Rd,Rn,Imm12)
 407 #  define ADDSI_12(Rd,Rn,Imm12)         oxxi(A64_ADDSI|XS|LSL_12,Rd,Rn,Imm12)
 408 #  define ADCS(Rd,Rn,Rm)                oxxx(A64_ADCS|XS,Rd,Rn,Rm)
 409 #  define SUB(Rd,Rn,Rm)                 oxxx(A64_SUB|XS,Rd,Rn,Rm)
 410 #  define SUBI(Rd,Rn,Imm12)             oxxi(A64_SUBI|XS,Rd,Rn,Imm12)
 411 #  define SUBI_12(Rd,Rn,Imm12)          oxxi(A64_SUBI|XS|LSL_12,Rd,Rn,Imm12)
 412 #  define SUBS(Rd,Rn,Rm)                oxxx(A64_SUBS|XS,Rd,Rn,Rm)
 413 #  define SUBSI(Rd,Rn,Imm12)            oxxi(A64_SUBSI|XS,Rd,Rn,Imm12)
 414 #  define SUBSI_12(Rd,Rn,Imm12)         oxxi(A64_SUBSI|XS|LSL_12,Rd,Rn,Imm12)
 415 #  define SBCS(Rd,Rn,Rm)                oxxx(A64_SBCS|XS,Rd,Rn,Rm)
 416 #  define MUL(Rd,Rn,Rm)                 oxxx(A64_MUL|XS,Rd,Rn,Rm)
 417 #  define SMULL(Rd,Rn,Rm)               oxxx(A64_SMULL,Rd,Rn,Rm)
 418 #  define SMULH(Rd,Rn,Rm)               oxxx(A64_SMULH,Rd,Rn,Rm)
 419 #  define UMULL(Rd,Rn,Rm)               oxxx(A64_UMULL,Rd,Rn,Rm)
 420 #  define UMULH(Rd,Rn,Rm)               oxxx(A64_UMULH,Rd,Rn,Rm)
 421 #  define SDIV(Rd,Rn,Rm)                oxxx(A64_SDIV|XS,Rd,Rn,Rm)
 422 #  define UDIV(Rd,Rn,Rm)                oxxx(A64_UDIV|XS,Rd,Rn,Rm)
 423 #  define LSL(Rd,Rn,Rm)                 oxxx(A64_LSL|XS,Rd,Rn,Rm)
 424 #  define LSLI(r0,r1,i0)                UBFM(r0,r1,(64-i0)&63,63-i0)
 425 #  define ASR(Rd,Rn,Rm)                 oxxx(A64_ASR|XS,Rd,Rn,Rm)
 426 #  define ASRI(r0,r1,i0)                SBFM(r0,r1,i0,63)
 427 #  define LSR(Rd,Rn,Rm)                 oxxx(A64_LSR|XS,Rd,Rn,Rm)
 428 #  define LSRI(r0,r1,i0)                UBFM(r0,r1,i0,63)
 429 #  define RORV(Rd,Rn,Rm)                oxxx(A64_RORV|XS,Rd,Rn,Rm)
 430 #  define EXTR(Rd,Rn,Rm,Im)             oxxx6(A64_EXTR|XS|DS,Rm,Im,Rn,Rd)
 431 #  define ROR(Rd,Rn,Rm,Im)              EXTR(Rd,Rn,Rm,Im)
 432 #  define AND(Rd,Rn,Rm)                 oxxx(A64_AND|XS,Rd,Rn,Rm)
 433 /* actually should use oxxrs but logical_immediate returns proper encoding */
 434 #  define ANDI(Rd,Rn,Imm12)             oxxi(A64_ANDI|XS,Rd,Rn,Imm12)
 435 #  define ORR(Rd,Rn,Rm)                 oxxx(A64_ORR|XS,Rd,Rn,Rm)
 436 /* actually should use oxxrs but logical_immediate returns proper encoding */
 437 #  define ORRI(Rd,Rn,Imm12)             oxxi(A64_ORRI|XS,Rd,Rn,Imm12)
 438 #  define EOR(Rd,Rn,Rm)                 oxxx(A64_EOR|XS,Rd,Rn,Rm)
 439 /* actually should use oxxrs but logical_immediate returns proper encoding */
 440 #  define EORI(Rd,Rn,Imm12)             oxxi(A64_EORI|XS,Rd,Rn,Imm12)
 441 #  define SXTB(Rd,Rn)                   SBFM(Rd,Rn,0,7)
 442 #  define SXTH(Rd,Rn)                   SBFM(Rd,Rn,0,15)
 443 #  define SXTW(Rd,Rn)                   SBFM(Rd,Rn,0,31)
 444 #  define UXTB(Rd,Rn)                   oxxrs(A64_UBFX & ~DS,Rd,Rn,0,7)
 445 #  define UXTH(Rd,Rn)                   oxxrs(A64_UBFX & ~DS,Rd,Rn,0,15)
 446 #  define UXTW(Rd,Rm)                   ox_x(A64_UXTW,Rd,Rm)
 447 #  define REV(Rd,Rn)                    o_xx(A64_REV,Rd,Rn)
 448 #  define LDRSB(Rt,Rn,Rm)               oxxx(A64_LDRSB,Rt,Rn,Rm)
 449 #  define LDRSBI(Rt,Rn,Imm12)           oxxi(A64_LDRSBI,Rt,Rn,Imm12)
 450 #  define LDURSB(Rt,Rn,Imm9)            oxx9(A64_LDURSB,Rt,Rn,Imm9)
 451 #  define LDRB(Rt,Rn,Rm)                oxxx(A64_LDRB,Rt,Rn,Rm)
 452 #  define LDRBI(Rt,Rn,Imm12)            oxxi(A64_LDRBI,Rt,Rn,Imm12)
 453 #  define LDURB(Rt,Rn,Imm9)             oxx9(A64_LDURB,Rt,Rn,Imm9)
 454 #  define LDRSH(Rt,Rn,Rm)               oxxx(A64_LDRSH,Rt,Rn,Rm)
 455 #  define LDRSHI(Rt,Rn,Imm12)           oxxi(A64_LDRSHI,Rt,Rn,Imm12)
 456 #  define LDURSH(Rt,Rn,Imm9)            oxx9(A64_LDURSH,Rt,Rn,Imm9)
 457 #  define LDRH(Rt,Rn,Rm)                oxxx(A64_LDRH,Rt,Rn,Rm)
 458 #  define LDRHI(Rt,Rn,Imm12)            oxxi(A64_LDRHI,Rt,Rn,Imm12)
 459 #  define LDURH(Rt,Rn,Imm9)             oxx9(A64_LDURH,Rt,Rn,Imm9)
 460 #  define LDRSW(Rt,Rn,Rm)               oxxx(A64_LDRSW,Rt,Rn,Rm)
 461 #  define LDRSWI(Rt,Rn,Imm12)           oxxi(A64_LDRSWI,Rt,Rn,Imm12)
 462 #  define LDURSW(Rt,Rn,Imm9)            oxx9(A64_LDURSW,Rt,Rn,Imm9)
 463 #  define LDRW(Rt,Rn,Rm)                oxxx(A64_LDRW,Rt,Rn,Rm)
 464 #  define LDRWI(Rt,Rn,Imm12)            oxxi(A64_LDRWI,Rt,Rn,Imm12)
 465 #  define LDURW(Rt,Rn,Imm9)             oxx9(A64_LDURW,Rt,Rn,Imm9)
 466 #  define LDR(Rt,Rn,Rm)                 oxxx(A64_LDR,Rt,Rn,Rm)
 467 #  define LDRI(Rt,Rn,Imm12)             oxxi(A64_LDRI,Rt,Rn,Imm12)
 468 #  define LDUR(Rt,Rn,Imm9)              oxx9(A64_LDUR,Rt,Rn,Imm9)
 469 #  define LDAXR(Rt,Rn)                  o_xx(A64_LDAXR,Rt,Rn)
 470 #  define STLXR(Rs,Rt,Rn)               oxxx(A64_STLXR,Rs,Rn,Rt)
 471 #  define STRB(Rt,Rn,Rm)                oxxx(A64_STRB,Rt,Rn,Rm)
 472 #  define STRBI(Rt,Rn,Imm12)            oxxi(A64_STRBI,Rt,Rn,Imm12)
 473 #  define STURB(Rt,Rn,Imm9)             oxx9(A64_STURB,Rt,Rn,Imm9)
 474 #  define STRH(Rt,Rn,Rm)                oxxx(A64_STRH,Rt,Rn,Rm)
 475 #  define STRHI(Rt,Rn,Imm12)            oxxi(A64_STRHI,Rt,Rn,Imm12)
 476 #  define STURH(Rt,Rn,Imm9)             oxx9(A64_STURH,Rt,Rn,Imm9)
 477 #  define STRW(Rt,Rn,Rm)                oxxx(A64_STRW,Rt,Rn,Rm)
 478 #  define STRWI(Rt,Rn,Imm12)            oxxi(A64_STRWI,Rt,Rn,Imm12)
 479 #  define STURW(Rt,Rn,Imm9)             oxx9(A64_STURW,Rt,Rn,Imm9)
 480 #  define STR(Rt,Rn,Rm)                 oxxx(A64_STR,Rt,Rn,Rm)
 481 #  define STRI(Rt,Rn,Imm12)             oxxi(A64_STRI,Rt,Rn,Imm12)
 482 #  define STUR(Rt,Rn,Imm9)              oxx9(A64_STUR,Rt,Rn,Imm9)
 483 #  define LDPI(Rt,Rt2,Rn,Simm7)         oxxx7(A64_LDP|XS,Rt,Rt2,Rn,Simm7)
 484 #  define STPI(Rt,Rt2,Rn,Simm7)         oxxx7(A64_STP|XS,Rt,Rt2,Rn,Simm7)
 485 #  define LDPI_PRE(Rt,Rt2,Rn,Simm7)     oxxx7(A64_LDP_PRE|XS,Rt,Rt2,Rn,Simm7)
 486 #  define STPI_POS(Rt,Rt2,Rn,Simm7)     oxxx7(A64_STP_POS|XS,Rt,Rt2,Rn,Simm7)
 487 #  define CSET(Rd,Cc)                   CSINC(Rd,XZR_REGNO,XZR_REGNO,Cc)
 488 #  define CSEL(Rd,Rn,Rm,Cc)             oxxxc(A64_CSSEL|XS,Rd,Rn,Rm,Cc)
 489 #  define B(Simm26)                     o26(A64_B,Simm26)
 490 #  define BL(Simm26)                    o26(A64_BL,Simm26)
 491 #  define BR(Rn)                        o_x_(A64_BR,Rn)
 492 #  define BLR(Rn)                       o_x_(A64_BLR,Rn)
 493 #  define RET()                         o_x_(A64_RET,LR_REGNO)
 494 #  define B_C(Cc,Simm19)                oc19(A64_B_C,Cc,Simm19)
 495 #  define CBZ(Rd,Simm19)                ox19(A64_CBZ|XS,Rd,Simm19)
 496 #  define CBNZ(Rd,Simm19)               ox19(A64_CBNZ|XS,Rd,Simm19)
 497 #  define NOP()                         ii(0xd503201f)
 498 static jit_int32_t logical_immediate(jit_word_t);
 499 #  define oxxx(Op,Rd,Rn,Rm)             _oxxx(_jit,Op,Rd,Rn,Rm)
 500 static void _oxxx(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 501 #  define oxxi(Op,Rd,Rn,Imm12)          _oxxi(_jit,Op,Rd,Rn,Imm12)
 502 static void _oxxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 503 #  define oxx9(Op,Rd,Rn,Imm9)           _oxx9(_jit,Op,Rd,Rn,Imm9)
 504 static void _oxx9(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 505 #  define ox19(Op,Rd,Simm19)            _ox19(_jit,Op,Rd,Simm19)
 506 static void _ox19(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 507 #  define oc19(Op,Cc,Simm19)            _oc19(_jit,Op,Cc,Simm19)
 508 static void _oc19(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 509 #  define o26(Op,Simm26)                _o26(_jit,Op,Simm26)
 510 static void _oc26(jit_state_t*,jit_int32_t,jit_int32_t);
 511 #  define ox_x(Op,Rd,Rn)                _ox_x(_jit,Op,Rd,Rn)
 512 static void _ox_x(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 513 #  define o_xx(Op,Rd,Rn)                _o_xx(_jit,Op,Rd,Rn)
 514 static void _o_xx(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 515 #  define oxx_(Op,Rn,Rm)                _oxx_(_jit,Op,Rn,Rm)
 516 static void _oxx_(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 517 #  define o_x_(Op,Rn)                   _o_x_(_jit,Op,Rn)
 518 static void _o_x_(jit_state_t*,jit_int32_t,jit_int32_t);
 519 #  define ox_h(Op,Rd,Imm16)             _ox_h(_jit,Op,Rd,Imm16)
 520 static void _ox_h(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 521 #  define oxxrs(Op,Rd,Rn,R,S)           _oxxrs(_jit,Op,Rd,Rn,R,S)
 522 static void _oxxrs(jit_state_t*,jit_int32_t,jit_int32_t,
 523                    jit_int32_t,jit_int32_t,jit_int32_t);
 524 #  define oxxxc(Op,Rd,Rn,Rm,Cc)         _oxxxc(_jit,Op,Rd,Rn,Rm,Cc)
 525 static void _oxxxc(jit_state_t*,jit_int32_t,jit_int32_t,
 526                    jit_int32_t,jit_int32_t,jit_int32_t);
 527 #  define oxxx7(Op,Rt,Rt2,Rn,Simm7)     _oxxx7(_jit,Op,Rt,Rt2,Rn,Simm7)
 528 static void _oxxx7(jit_state_t*,jit_int32_t,
 529                    jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 530 #  define oxxx6(Op,Rm,Imm6,Rn,Rd)       _oxxx6(_jit,Op,Rm,Imm6,Rn,Rd)
 531 static void _oxxx6(jit_state_t*,jit_int32_t,
 532                    jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 533 #  define nop(i0)                       _nop(_jit,i0)
 534 static void _nop(jit_state_t*,jit_int32_t);
 535 #  define addr(r0,r1,r2)                ADD(r0,r1,r2)
 536 #  define addi(r0,r1,i0)                _addi(_jit,r0,r1,i0)
 537 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 538 #  define addcr(r0,r1,r2)               ADDS(r0,r1,r2)
 539 #  define addci(r0,r1,i0)               _addci(_jit,r0,r1,i0)
 540 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 541 #  define addxr(r0,r1,r2)               ADCS(r0,r1,r2)
 542 #  define addxi(r0,r1,i0)               _addxi(_jit,r0,r1,i0)
 543 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 544 #  define subr(r0,r1,r2)                SUB(r0,r1,r2)
 545 #  define subi(r0,r1,i0)                _subi(_jit,r0,r1,i0)
 546 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 547 #  define subcr(r0,r1,r2)               SUBS(r0,r1,r2)
 548 #  define subci(r0,r1,i0)               _subci(_jit,r0,r1,i0)
 549 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 550 #  define subxr(r0,r1,r2)               SBCS(r0,r1,r2)
 551 #  define subxi(r0,r1,i0)               _subxi(_jit,r0,r1,i0)
 552 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 553 #  define rsbi(r0, r1, i0)              _rsbi(_jit, r0, r1, i0)
 554 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 555 #  define mulr(r0,r1,r2)                MUL(r0,r1,r2)
 556 #  define muli(r0,r1,i0)                _muli(_jit,r0,r1,i0)
 557 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 558 #  define hmulr(r0,r1,r2)               SMULH(r0,r1,r2)
 559 #  define hmuli(r0,r1,i0)               _hmuli(_jit,r0,r1,i0)
 560 static void _hmuli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 561 #  define hmulr_u(r0,r1,r2)             UMULH(r0,r1,r2)
 562 #  define hmuli_u(r0,r1,i0)             _hmuli_u(_jit,r0,r1,i0)
 563 static void _hmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 564 #  define qmulr(r0,r1,r2,r3)            _qmulr(_jit,r0,r1,r2,r3)
 565 static void _qmulr(jit_state_t*,jit_int32_t,
 566                    jit_int32_t,jit_int32_t,jit_int32_t);
 567 #  define qmuli(r0,r1,r2,i0)            _qmuli(_jit,r0,r1,r2,i0)
 568 static void _qmuli(jit_state_t*,jit_int32_t,
 569                    jit_int32_t,jit_int32_t,jit_word_t);
 570 #  define qmulr_u(r0,r1,r2,r3)          _qmulr_u(_jit,r0,r1,r2,r3)
 571 static void _qmulr_u(jit_state_t*,jit_int32_t,
 572                      jit_int32_t,jit_int32_t,jit_int32_t);
 573 #  define qmuli_u(r0,r1,r2,i0)          _qmuli_u(_jit,r0,r1,r2,i0)
 574 static void _qmuli_u(jit_state_t*,jit_int32_t,
 575                      jit_int32_t,jit_int32_t,jit_word_t);
 576 #  define divr(r0,r1,r2)                SDIV(r0,r1,r2)
 577 #  define divi(r0,r1,i0)                _divi(_jit,r0,r1,i0)
 578 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 579 #  define divr_u(r0,r1,r2)              UDIV(r0,r1,r2)
 580 #  define divi_u(r0,r1,i0)              _divi_u(_jit,r0,r1,i0)
 581 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 582 #  define qdivr(r0,r1,r2,r3)            _iqdivr(_jit,1,r0,r1,r2,r3)
 583 #  define qdivr_u(r0,r1,r2,r3)          _iqdivr(_jit,0,r0,r1,r2,r3)
 584 static void _iqdivr(jit_state_t*,jit_bool_t,
 585                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 586 #  define qdivi(r0,r1,r2,i0)            _qdivi(_jit,r0,r1,r2,i0)
 587 static void _qdivi(jit_state_t*,jit_int32_t,
 588                    jit_int32_t,jit_int32_t,jit_word_t);
 589 #  define qdivi_u(r0,r1,r2,i0)          _qdivi_u(_jit,r0,r1,r2,i0)
 590 static void _qdivi_u(jit_state_t*,jit_int32_t,
 591                      jit_int32_t,jit_int32_t,jit_word_t);
 592 #  define remr(r0,r1,r2)                _remr(_jit,r0,r1,r2)
 593 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 594 #  define remi(r0,r1,i0)                _remi(_jit,r0,r1,i0)
 595 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 596 #  define remr_u(r0,r1,r2)              _remr_u(_jit,r0,r1,r2)
 597 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 598 #  define remi_u(r0,r1,i0)              _remi_u(_jit,r0,r1,i0)
 599 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 600 #  define lshr(r0,r1,r2)                LSL(r0,r1,r2)
 601 #  define lshi(r0,r1,i0)                _lshi(_jit,r0,r1,i0)
 602 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 603 #  define rshr(r0,r1,r2)                ASR(r0,r1,r2)
 604 #  define rshi(r0,r1,i0)                _rshi(_jit,r0,r1,i0)
 605 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 606 #  define rshr_u(r0,r1,r2)              LSR(r0,r1,r2)
 607 #  define rshi_u(r0,r1,i0)              _rshi_u(_jit,r0,r1,i0)
 608 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 609 #  define qlshr(r0,r1,r2,r3)            xlshr(1,r0,r1,r2,r3)
 610 #  define qlshr_u(r0, r1, r2, r3)       xlshr(0, r0, r1, r2, r3)
 611 #  define xlshr(s,r0,r1,r2,r3)          _xlshr(_jit,s,r0,r1,r2,r3)
 612 static void
 613 _xlshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 614 #  define qlshi(r0, r1, r2, i0)         xlshi(1, r0, r1, r2, i0)
 615 #  define qlshi_u(r0, r1, r2, i0)       xlshi(0, r0, r1, r2, i0)
 616 #  define xlshi(s, r0, r1, r2, i0)      _xlshi(_jit, s, r0, r1, r2, i0)
 617 static void
 618 _xlshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 619 #  define qrshr(r0, r1, r2, r3)         xrshr(1, r0, r1, r2, r3)
 620 #  define qrshr_u(r0, r1, r2, r3)       xrshr(0, r0, r1, r2, r3)
 621 #  define xrshr(s, r0, r1, r2, r3)      _xrshr(_jit, s, r0, r1, r2, r3)
 622 static void
 623 _xrshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 624 #  define qrshi(r0, r1, r2, i0)         xrshi(1, r0, r1, r2, i0)
 625 #  define qrshi_u(r0, r1, r2, i0)       xrshi(0, r0, r1, r2, i0)
 626 #  define xrshi(s, r0, r1, r2, i0)      _xrshi(_jit, s, r0, r1, r2, i0)
 627 static void
 628 _xrshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 629 #  define lrotr(r0,r1,r2)               _lrotr(_jit,r0,r1,r2)
 630 static void _lrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 631 #  define lroti(r0,r1,i0)               rroti(r0,r1,64-i0)
 632 #  define rrotr(r0,r1,r2)               RORV(r0,r1,r2)
 633 #  define rroti(r0,r1,i0)               ROR(r0,r1,r1,i0)
 634 #  define movnr(r0,r1,r2)               _movnr(_jit,r0,r1,r2)
 635 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 636 #  define movzr(r0,r1,r2)               _movzr(_jit,r0,r1,r2)
 637 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 638 #  define negr(r0,r1)                   NEG(r0,r1)
 639 #  define comr(r0,r1)                   MVN(r0,r1)
 640 #  define clor(r0, r1)                  _clor(_jit, r0, r1)
 641 static void _clor(jit_state_t*, jit_int32_t, jit_int32_t);
 642 #  define clzr(r0, r1)                  CLZ(r0,r1)
 643 static void _clzr(jit_state_t*, jit_int32_t, jit_int32_t);
 644 #  define ctor(r0, r1)                  _ctor(_jit, r0, r1)
 645 static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t);
 646 #  define ctzr(r0, r1)                  _ctzr(_jit, r0, r1)
 647 static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t);
 648 #  define rbitr(r0, r1)                 RBIT(r0, r1)
 649 #  define andr(r0,r1,r2)                AND(r0,r1,r2)
 650 #  define andi(r0,r1,i0)                _andi(_jit,r0,r1,i0)
 651 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 652 #  define orr(r0,r1,r2)                 ORR(r0,r1,r2)
 653 #  define ori(r0,r1,i0)                 _ori(_jit,r0,r1,i0)
 654 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 655 #  define xorr(r0,r1,r2)                EOR(r0,r1,r2)
 656 #  define xori(r0,r1,i0)                _xori(_jit,r0,r1,i0)
 657 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 658 #  define ldr_c(r0,r1)                  LDRSBI(r0,r1,0)
 659 #  define ldi_c(r0,i0)                  _ldi_c(_jit,r0,i0)
 660 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
 661 #  define ldr_uc(r0,r1)                 _ldr_uc(_jit,r0,r1)
 662 static void _ldr_uc(jit_state_t*,jit_int32_t,jit_int32_t);
 663 #  define ldi_uc(r0,i0)                 _ldi_uc(_jit,r0,i0)
 664 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
 665 #  define ldr_s(r0,r1)                  LDRSHI(r0,r1,0)
 666 #  define ldi_s(r0,i0)                  _ldi_s(_jit,r0,i0)
 667 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
 668 #  define ldr_us(r0,r1)                 _ldr_us(_jit,r0,r1)
 669 static void _ldr_us(jit_state_t*,jit_int32_t,jit_int32_t);
 670 #  define ldi_us(r0,i0)                 _ldi_us(_jit,r0,i0)
 671 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
 672 #  define ldr_i(r0,r1)                  LDRSWI(r0,r1,0)
 673 #  define ldi_i(r0,i0)                  _ldi_i(_jit,r0,i0)
 674 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
 675 #  define ldr_ui(r0,r1)                 _ldr_ui(_jit,r0,r1)
 676 static void _ldr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
 677 #  define ldi_ui(r0,i0)                 _ldi_ui(_jit,r0,i0)
 678 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
 679 #  define ldr_l(r0,r1)                  LDRI(r0,r1,0)
 680 static void _ldr_l(jit_state_t*,jit_int32_t,jit_int32_t);
 681 #  define ldi_l(r0,i0)                  _ldi_l(_jit,r0,i0)
 682 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
 683 #  define ldxr_c(r0,r1,r2)              _ldxr_c(_jit,r0,r1,r2)
 684 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 685 #  define ldxi_c(r0,r1,i0)              _ldxi_c(_jit,r0,r1,i0)
 686 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 687 #  define ldxr_uc(r0,r1,r2)             _ldxr_uc(_jit,r0,r1,r2)
 688 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 689 #  define ldxi_uc(r0,r1,i0)             _ldxi_uc(_jit,r0,r1,i0)
 690 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 691 #  define ldxr_s(r0,r1,r2)              LDRSH(r0,r1,r2)
 692 #  define ldxi_s(r0,r1,i0)              _ldxi_s(_jit,r0,r1,i0)
 693 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 694 #  define ldxr_us(r0,r1,r2)             _ldxr_us(_jit,r0,r1,r2)
 695 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 696 #  define ldxi_us(r0,r1,i0)             _ldxi_us(_jit,r0,r1,i0)
 697 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 698 #  define ldxr_i(r0,r1,r2)              LDRSW(r0,r1,r2)
 699 #  define ldxi_i(r0,r1,i0)              _ldxi_i(_jit,r0,r1,i0)
 700 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 701 #  define ldxr_ui(r0,r1,r2)             _ldxr_ui(_jit,r0,r1,r2)
 702 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 703 #  define ldxi_ui(r0,r1,i0)             _ldxi_ui(_jit,r0,r1,i0)
 704 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 705 #  define ldxr_l(r0,r1,r2)              LDR(r0,r1,r2)
 706 #  define ldxi_l(r0,r1,i0)              _ldxi_l(_jit,r0,r1,i0)
 707 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 708 #  define unldr(r0, r1, i0)             generic_unldr(r0, r1, i0)
 709 #  define unldi(r0, i0, i1)             generic_unldi(r0, i0, i1)
 710 #  define unldr_u(r0, r1, i0)           generic_unldr_u(r0, r1, i0)
 711 #  define unldi_u(r0, i0, i1)           generic_unldi_u(r0, i0, i1)
 712 #  define str_c(r0,r1)                  STRBI(r1,r0,0)
 713 #  define sti_c(i0,r0)                  _sti_c(_jit,i0,r0)
 714 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
 715 #  define str_s(r0,r1)                  STRHI(r1,r0,0)
 716 #  define sti_s(i0,r0)                  _sti_s(_jit,i0,r0)
 717 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
 718 #  define str_i(r0,r1)                  STRWI(r1,r0,0)
 719 #  define sti_i(i0,r0)                  _sti_i(_jit,i0,r0)
 720 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
 721 #  define str_l(r0,r1)                  STRI(r1,r0,0)
 722 #  define sti_l(i0,r0)                  _sti_l(_jit,i0,r0)
 723 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
 724 #  define stxr_c(r0,r1,r2)              STRB(r2,r1,r0)
 725 #  define stxi_c(i0,r0,r1)              _stxi_c(_jit,i0,r0,r1)
 726 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 727 #  define stxr_s(r0,r1,r2)              STRH(r2,r1,r0)
 728 #  define stxi_s(i0,r0,r1)              _stxi_s(_jit,i0,r0,r1)
 729 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 730 #  define stxr_i(r0,r1,r2)              STRW(r2,r1,r0)
 731 #  define stxi_i(i0,r0,r1)              _stxi_i(_jit,i0,r0,r1)
 732 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 733 #  define stxr_l(r0,r1,r2)              STR(r2,r1,r0)
 734 #  define stxi_l(i0,r0,r1)              _stxi_l(_jit,i0,r0,r1)
 735 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 736 #  define unstr(r0, r1, i0)             generic_unstr(r0, r1, i0)
 737 #  define unsti(i0, r0, i1)             generic_unsti(i0, r0, i1)
 738 #  define bswapr_us(r0,r1)              _bswapr_us(_jit,r0,r1)
 739 static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t);
 740 #  define bswapr_ui(r0,r1)              _bswapr_ui(_jit,r0,r1)
 741 static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
 742 #  define bswapr_ul(r0,r1)              REV(r0,r1)
 743 #define extr(r0,r1,i0,i1)               _extr(_jit,r0,r1,i0,i1)
 744 static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
 745 #define extr_u(r0,r1,i0,i1)             _extr_u(_jit,r0,r1,i0,i1)
 746 static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
 747 #define depr(r0,r1,i0,i1)               _depr(_jit,r0,r1,i0,i1)
 748 static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
 749 #  define extr_c(r0,r1)                 SXTB(r0,r1)
 750 #  define extr_uc(r0,r1)                UXTB(r0,r1)
 751 #  define extr_s(r0,r1)                 SXTH(r0,r1)
 752 #  define extr_us(r0,r1)                UXTH(r0,r1)
 753 #  define extr_i(r0,r1)                 SXTW(r0,r1)
 754 #  define extr_ui(r0,r1)                UXTW(r0,r1)
 755 #  define casx(r0, r1, r2, r3, i0)      _casx(_jit, r0, r1, r2, r3, i0)
 756 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
 757                   jit_int32_t,jit_int32_t,jit_word_t);
 758 #define casr(r0, r1, r2, r3)            casx(r0, r1, r2, r3, 0)
 759 #define casi(r0, i0, r1, r2)            casx(r0, _NOREG, r1, r2, i0)
 760 #  define movr(r0,r1)                   _movr(_jit,r0,r1)
 761 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
 762 #  define movi(r0,i0)                   _movi(_jit,r0,i0)
 763 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
 764 #  define movi_p(r0,i0)                 _movi_p(_jit,r0,i0)
 765 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
 766 #  define ccr(cc,r0,r1,r2)              _ccr(_jit,cc,r0,r1,r2)
 767 static void _ccr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 768 #  define cci(cc,r0,r1,i0)              _cci(_jit,cc,r0,r1,i0)
 769 static void _cci(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 770 #  define ltr(r0,r1,r2)                 ccr(CC_LT,r0,r1,r2)
 771 #  define lti(r0,r1,i0)                 cci(CC_LT,r0,r1,i0)
 772 #  define ltr_u(r0,r1,r2)               ccr(CC_CC,r0,r1,r2)
 773 #  define lti_u(r0,r1,i0)               cci(CC_CC,r0,r1,i0)
 774 #  define ler(r0,r1,r2)                 ccr(CC_LE,r0,r1,r2)
 775 #  define lei(r0,r1,i0)                 cci(CC_LE,r0,r1,i0)
 776 #  define ler_u(r0,r1,r2)               ccr(CC_LS,r0,r1,r2)
 777 #  define lei_u(r0,r1,i0)               cci(CC_LS,r0,r1,i0)
 778 #  define eqr(r0,r1,r2)                 ccr(CC_EQ,r0,r1,r2)
 779 #  define eqi(r0,r1,i0)                 cci(CC_EQ,r0,r1,i0)
 780 #  define ger(r0,r1,r2)                 ccr(CC_GE,r0,r1,r2)
 781 #  define gei(r0,r1,i0)                 cci(CC_GE,r0,r1,i0)
 782 #  define ger_u(r0,r1,r2)               ccr(CC_CS,r0,r1,r2)
 783 #  define gei_u(r0,r1,i0)               cci(CC_CS,r0,r1,i0)
 784 #  define gtr(r0,r1,r2)                 ccr(CC_GT,r0,r1,r2)
 785 #  define gti(r0,r1,i0)                 cci(CC_GT,r0,r1,i0)
 786 #  define gtr_u(r0,r1,r2)               ccr(CC_HI,r0,r1,r2)
 787 #  define gti_u(r0,r1,i0)               cci(CC_HI,r0,r1,i0)
 788 #  define ner(r0,r1,r2)                 ccr(CC_NE,r0,r1,r2)
 789 #  define nei(r0,r1,i0)                 cci(CC_NE,r0,r1,i0)
 790 #  define bccr(cc,i0,r0,r1)             _bccr(_jit,cc,i0,r0,r1)
 791 static jit_word_t
 792 _bccr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
 793 #  define bcci(cc,i0,r0,i1)             _bcci(_jit,cc,i0,r0,i1)
 794 static jit_word_t
 795 _bcci(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
 796 #  define bltr(i0,r0,r1)                bccr(BCC_LT,i0,r0,r1)
 797 #  define blti(i0,r0,i1)                bcci(BCC_LT,i0,r0,i1)
 798 #  define bltr_u(i0,r0,r1)              bccr(BCC_CC,i0,r0,r1)
 799 #  define blti_u(i0,r0,i1)              bcci(BCC_CC,i0,r0,i1)
 800 #  define bler(i0,r0,r1)                bccr(BCC_LE,i0,r0,r1)
 801 #  define blei(i0,r0,i1)                bcci(BCC_LE,i0,r0,i1)
 802 #  define bler_u(i0,r0,r1)              bccr(BCC_LS,i0,r0,r1)
 803 #  define blei_u(i0,r0,i1)              bcci(BCC_LS,i0,r0,i1)
 804 #  define beqr(i0,r0,r1)                bccr(BCC_EQ,i0,r0,r1)
 805 #  define beqi(i0,r0,i1)                _beqi(_jit,i0,r0,i1)
 806 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 807 #  define bger(i0,r0,r1)                bccr(BCC_GE,i0,r0,r1)
 808 #  define bgei(i0,r0,i1)                bcci(BCC_GE,i0,r0,i1)
 809 #  define bger_u(i0,r0,r1)              bccr(BCC_CS,i0,r0,r1)
 810 #  define bgei_u(i0,r0,i1)              bcci(BCC_CS,i0,r0,i1)
 811 #  define bgtr(i0,r0,r1)                bccr(BCC_GT,i0,r0,r1)
 812 #  define bgti(i0,r0,i1)                bcci(BCC_GT,i0,r0,i1)
 813 #  define bgtr_u(i0,r0,r1)              bccr(BCC_HI,i0,r0,r1)
 814 #  define bgti_u(i0,r0,i1)              bcci(BCC_HI,i0,r0,i1)
 815 #  define bner(i0,r0,r1)                bccr(BCC_NE,i0,r0,r1)
 816 #  define bnei(i0,r0,i1)                _bnei(_jit,i0,r0,i1)
 817 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 818 #  define baddr(cc,i0,r0,r1)            _baddr(_jit,cc,i0,r0,r1)
 819 static jit_word_t
 820 _baddr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
 821 #  define baddi(cc,i0,r0,i1)            _baddi(_jit,cc,i0,r0,i1)
 822 static jit_word_t
 823 _baddi(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
 824 #  define boaddr(i0,r0,r1)              baddr(BCC_VS,i0,r0,r1)
 825 #  define boaddi(i0,r0,i1)              baddi(BCC_VS,i0,r0,i1)
 826 #  define boaddr_u(i0,r0,r1)            baddr(BCC_HS,i0,r0,r1)
 827 #  define boaddi_u(i0,r0,i1)            baddi(BCC_HS,i0,r0,i1)
 828 #  define bxaddr(i0,r0,r1)              baddr(BCC_VC,i0,r0,r1)
 829 #  define bxaddi(i0,r0,i1)              baddi(BCC_VC,i0,r0,i1)
 830 #  define bxaddr_u(i0,r0,r1)            baddr(BCC_LO,i0,r0,r1)
 831 #  define bxaddi_u(i0,r0,i1)            baddi(BCC_LO,i0,r0,i1)
 832 #  define bsubr(cc,i0,r0,r1)            _bsubr(_jit,cc,i0,r0,r1)
 833 static jit_word_t
 834 _bsubr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
 835 #  define bsubi(cc,i0,r0,i1)            _bsubi(_jit,cc,i0,r0,i1)
 836 static jit_word_t
 837 _bsubi(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
 838 #  define bosubr(i0,r0,r1)              bsubr(BCC_VS,i0,r0,r1)
 839 #  define bosubi(i0,r0,i1)              bsubi(BCC_VS,i0,r0,i1)
 840 #  define bosubr_u(i0,r0,r1)            bsubr(BCC_LO,i0,r0,r1)
 841 #  define bosubi_u(i0,r0,i1)            bsubi(BCC_LO,i0,r0,i1)
 842 #  define bxsubr(i0,r0,r1)              bsubr(BCC_VC,i0,r0,r1)
 843 #  define bxsubi(i0,r0,i1)              bsubi(BCC_VC,i0,r0,i1)
 844 #  define bxsubr_u(i0,r0,r1)            bsubr(BCC_HS,i0,r0,r1)
 845 #  define bxsubi_u(i0,r0,i1)            bsubi(BCC_HS,i0,r0,i1)
 846 #  define bmxr(cc,i0,r0,r1)             _bmxr(_jit,cc,i0,r0,r1)
 847 static jit_word_t
 848 _bmxr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
 849 #  define bmxi(cc,i0,r0,r1)             _bmxi(_jit,cc,i0,r0,r1)
 850 static jit_word_t
 851 _bmxi(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
 852 #  define bmsr(i0,r0,r1)                bmxr(BCC_NE,i0,r0,r1)
 853 #  define bmsi(i0,r0,i1)                bmxi(BCC_NE,i0,r0,i1)
 854 #  define bmcr(i0,r0,r1)                bmxr(BCC_EQ,i0,r0,r1)
 855 #  define bmci(i0,r0,i1)                bmxi(BCC_EQ,i0,r0,i1)
 856 #  define jmpr(r0)                      BR(r0)
 857 #  define jmpi(i0)                      _jmpi(_jit,i0)
 858 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
 859 #  define jmpi_p(i0)                    _jmpi_p(_jit,i0)
 860 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
 861 #  define callr(r0)                     BLR(r0)
 862 #  define calli(i0)                     _calli(_jit,i0)
 863 static jit_word_t _calli(jit_state_t*,jit_word_t);
 864 #  define calli_p(i0)                   _calli_p(_jit,i0)
 865 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
 866 #  define prolog(i0)                    _prolog(_jit,i0)
 867 static void _prolog(jit_state_t*,jit_node_t*);
 868 #  define epilog(i0)                    _epilog(_jit,i0)
 869 static void _epilog(jit_state_t*,jit_node_t*);
 870 #  define vastart(r0)                   _vastart(_jit, r0)
 871 static void _vastart(jit_state_t*, jit_int32_t);
 872 #  define vaarg(r0, r1)                 _vaarg(_jit, r0, r1)
 873 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
 874 #  define patch_at(jump,label)          _patch_at(_jit,jump,label)
 875 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
 876 #endif
 877
 878 #if CODE
 879 /* https://dougallj.wordpress.com/2021/10/30/bit-twiddling-optimising-aarch64-logical-immediate-encoding-and-decoding/ */
 880 #include "aarch64-logical-immediates.c"
 881 static jit_int32_t
 882 logical_immediate(jit_word_t imm)
 883 {
 884     jit_int32_t         result = encodeLogicalImmediate64(imm);
 885     if (result != ENCODE_FAILED) {
 886         assert(isValidLogicalImmediate64(result));
 887         return (result & 0xfff);
 888     }
 889     return (-1);
 890 }
 891
 892 static void
 893 _oxxx(jit_state_t *_jit, jit_int32_t Op,
 894       jit_int32_t Rd, jit_int32_t Rn, jit_int32_t Rm)
 895 {
 896     instr_t     i;
 897     assert(!(Rd &       ~0x1f));
 898     assert(!(Rn &       ~0x1f));
 899     assert(!(Rm &       ~0x1f));
 900     assert(!(Op & ~0xffe0fc00));
 901     i.w = Op;
 902     i.Rd.b = Rd;
 903     i.Rn.b = Rn;
 904     i.Rm.b = Rm;
 905     ii(i.w);
 906 }
 907
 908 static void
 909 _oxxi(jit_state_t *_jit, jit_int32_t Op,
 910       jit_int32_t Rd, jit_int32_t Rn, jit_int32_t Imm12)
 911 {
 912     instr_t     i;
 913     assert(!(Rd    &       ~0x1f));
 914     assert(!(Rn    &       ~0x1f));
 915     assert(!(Imm12 &      ~0xfff));
 916     assert(!(Op    & ~0xffe00000));
 917     i.w = Op;
 918     i.Rd.b = Rd;
 919     i.Rn.b = Rn;
 920     i.imm12.b = Imm12;
 921     ii(i.w);
 922 }
 923
 924 static void
 925 _oxx9(jit_state_t *_jit, jit_int32_t Op,
 926       jit_int32_t Rd, jit_int32_t Rn, jit_int32_t Imm9)
 927 {
 928     instr_t     i;
 929     assert(!(Rd   &       ~0x1f));
 930     assert(!(Rn   &       ~0x1f));
 931     assert(!(Imm9 &      ~0x1ff));
 932     assert(!(Op   & ~0xffe00000));
 933     i.w = Op;
 934     i.Rd.b = Rd;
 935     i.Rn.b = Rn;
 936     i.imm9.b = Imm9;
 937     ii(i.w);
 938 }
 939
 940 static void
 941 _ox19(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rd, jit_int32_t Simm19)
 942 {
 943     instr_t     i;
 944     assert(!(Rd &         ~0x1f));
 945     assert(Simm19 >= -262148 && Simm19 <= 262143);
 946     assert(!(Op   & ~0xff000000));
 947     i.w = Op;
 948     i.Rd.b = Rd;
 949     i.imm19.b = Simm19;
 950     ii(i.w);
 951 }
 952
 953 static void
 954 _oc19(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Cc, jit_int32_t Simm19)
 955 {
 956     instr_t     i;
 957     assert(!(Cc &          ~0xf));
 958     assert(Simm19 >= -262148 && Simm19 <= 262143);
 959     assert(!(Op   & ~0xff000000));
 960     i.w = Op;
 961     i.cond2.b = Cc;
 962     i.imm19.b = Simm19;
 963     ii(i.w);
 964 }
 965
 966 static void
 967 _o26(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Simm26)
 968 {
 969     instr_t     i;
 970     assert(s26_p(Simm26));
 971     assert(!(Op   & ~0xfc000000));
 972     i.w = Op;
 973     i.imm26.b = Simm26;
 974     ii(i.w);
 975 }
 976
 977 static void
 978 _ox_x(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rd, jit_int32_t Rm)
 979 {
 980     instr_t     i;
 981     assert(!(Rd &       ~0x1f));
 982     assert(!(Rm &       ~0x1f));
 983     assert(!(Op & ~0xffe0ffe0));
 984     i.w = Op;
 985     i.Rd.b = Rd;
 986     i.Rm.b = Rm;
 987     ii(i.w);
 988 }
 989
 990 static void
 991 _o_xx(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rd, jit_int32_t Rn)
 992 {
 993     instr_t     i;
 994     assert(!(Rd &       ~0x1f));
 995     assert(!(Rn &       ~0x1f));
 996     assert(!(Op & ~0xfffffc00));
 997     i.w = Op;
 998     i.Rd.b = Rd;
 999     i.Rn.b = Rn;
1000     ii(i.w);
1001 }
1002
1003 static void
1004 _oxx_(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rn, jit_int32_t Rm)
1005 {
1006     instr_t     i;
1007     assert(!(Rn &       ~0x1f));
1008     assert(!(Rm &       ~0x1f));
1009     assert(!(Op & ~0xffc0fc1f));
1010     i.w = Op;
1011     i.Rn.b = Rn;
1012     i.Rm.b = Rm;
1013     ii(i.w);
1014 }
1015
1016 static void
1017 _o_x_(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rn)
1018 {
1019     instr_t     i;
1020     assert(!(Rn & ~0x1f));
1021     assert(!(Op & 0x3e0));
1022     i.w = Op;
1023     i.Rn.b = Rn;
1024     ii(i.w);
1025 }
1026
1027 static void
1028 _ox_h(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rd, jit_int32_t Imm16)
1029 {
1030     instr_t     i;
1031     assert(!(Rd    &       ~0x1f));
1032     assert(!(Imm16 &     ~0xffff));
1033     assert(!(Op    & ~0xffe00000));
1034     i.w = Op;
1035     i.Rd.b = Rd;
1036     i.imm16.b = Imm16;
1037     ii(i.w);
1038 }
1039
1040 static void
1041 _oxxrs(jit_state_t *_jit, jit_int32_t Op,
1042        jit_int32_t Rd, jit_int32_t Rn, jit_int32_t R, jit_int32_t S)
1043 {
1044     instr_t     i;
1045     assert(!(Rd &       ~0x1f));
1046     assert(!(Rn &       ~0x1f));
1047     assert(!(R  &       ~0x3f));
1048     assert(!(S  &       ~0x3f));
1049     assert(!(Op & ~0xffc00000));
1050     i.w = Op;
1051     i.Rd.b = Rd;
1052     i.Rn.b = Rn;
1053     i.immr.b = R;
1054     i.imms.b = S;
1055     ii(i.w);
1056 }
1057
1058 static void
1059 _oxxxc(jit_state_t *_jit, jit_int32_t Op,
1060        jit_int32_t Rd, jit_int32_t Rn, jit_int32_t Rm, jit_int32_t Cc)
1061 {
1062     instr_t     i;
1063     assert(!(Rd &       ~0x1f));
1064     assert(!(Rn &       ~0x1f));
1065     assert(!(Rm &       ~0x1f));
1066     assert(!(Cc  &       ~0xf));
1067     assert(!(Op & ~0xffc00c00));
1068     i.w = Op;
1069     i.Rd.b = Rd;
1070     i.Rn.b = Rn;
1071     i.Rm.b = Rm;
1072     i.cond.b = Cc;
1073     ii(i.w);
1074 }
1075
1076 static void
1077 _oxxx7(jit_state_t *_jit, jit_int32_t Op,
1078        jit_int32_t Rt, jit_int32_t Rt2, jit_int32_t Rn, jit_int32_t Simm7)
1079 {
1080     instr_t     i;
1081     assert(!(Rt  &       ~0x1f));
1082     assert(!(Rt2 &       ~0x1f));
1083     assert(!(Rn  &       ~0x1f));
1084     assert(Simm7 >= -128 && Simm7 <= 127);
1085     assert(!(Op & ~0xffc003e0));
1086     i.w = Op;
1087     i.Rt.b = Rt;
1088     i.Rt2.b = Rt2;
1089     i.Rn.b = Rn;
1090     i.imm7.b = Simm7;
1091     ii(i.w);
1092 }
1093
1094 static void
1095 _oxxx6(jit_state_t *_jit, jit_int32_t Op,
1096        jit_int32_t Rm, jit_int32_t Imm6, jit_int32_t Rn, jit_int32_t Rd)
1097 {
1098     instr_t     i;
1099     assert(!(Rm  &      ~0x1f));
1100     assert(!(Rn &       ~0x1f));
1101     assert(!(Rd  &      ~0x1f));
1102     assert(Imm6 >= 0 && Imm6 <= 63);
1103     assert(!(Op & ~0xffe0fc00));
1104     i.w = Op;
1105     i.Rm.b = Rm;
1106     i.imm6.b = Imm6;
1107     i.Rn.b = Rn;
1108     i.Rd.b = Rd;
1109     ii(i.w);
1110 }
1111
1112 static void
1113 _nop(jit_state_t *_jit, jit_int32_t i0)
1114 {
1115     for (; i0 > 0; i0 -= 4)
1116         NOP();
1117     assert(i0 == 0);
1118 }
1119
1120 static void
1121 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1122 {
1123     jit_int32_t         reg;
1124     jit_word_t          is =  i0 >> 12;
1125     jit_word_t          in = -i0;
1126     jit_word_t          iS =  in >> 12;
1127     if (      i0 >= 0 && i0 <= 0xfff)
1128         ADDI   (r0, r1, i0);
1129     else if ((is << 12) == i0 && is >= 0 && is <= 0xfff)
1130         ADDI_12(r0, r1, is);
1131     else if ( in >= 0 && in <= 0xfff)
1132         SUBI   (r0, r1, in);
1133     else if ((iS << 12) == is && iS >= 0 && iS <= 0xfff)
1134         SUBI_12(r0, r1, iS);
1135     else {
1136         reg = jit_get_reg(jit_class_gpr);
1137         movi(rn(reg), i0);
1138         addr(r0, r1, rn(reg));
1139         jit_unget_reg(reg);
1140     }
1141 }
1142
1143 static void
1144 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1145 {
1146     jit_int32_t         reg;
1147     jit_word_t          is =  i0 >> 12;
1148     jit_word_t          in = -i0;
1149     jit_word_t          iS =  in >> 12;
1150     if (      i0 >= 0 && i0 <= 0xfff)
1151         ADDSI   (r0, r1, i0);
1152     else if ((is << 12) == i0 && is >= 0 && is <= 0xfff)
1153         ADDSI_12(r0, r1, is);
1154     else if ( in >= 0 && in <= 0xfff)
1155         SUBSI   (r0, r1, in);
1156     else if ((iS << 12) == is && iS >= 0 && iS <= 0xfff)
1157         SUBSI_12(r0, r1, iS);
1158     else {
1159         reg = jit_get_reg(jit_class_gpr);
1160         movi(rn(reg), i0);
1161         addcr(r0, r1, rn(reg));
1162         jit_unget_reg(reg);
1163     }
1164 }
1165
1166 static void
1167 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1168 {
1169     jit_int32_t         reg;
1170     reg = jit_get_reg(jit_class_gpr);
1171     movi(rn(reg), i0);
1172     addxr(r0, r1, rn(reg));
1173     jit_unget_reg(reg);
1174 }
1175
1176 static void
1177 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1178 {
1179     jit_int32_t         reg;
1180     jit_word_t          is = i0 >> 12;
1181     if (      i0 >= 0 && i0 <= 0xfff)
1182         SUBI   (r0, r1, i0);
1183     else if ((is << 12) == i0 && is >= 0 && is <= 0xfff)
1184         SUBI_12(r0, r1, is);
1185     else {
1186         reg = jit_get_reg(jit_class_gpr);
1187         movi(rn(reg), i0);
1188         subr(r0, r1, rn(reg));
1189         jit_unget_reg(reg);
1190     }
1191 }
1192
1193 static void
1194 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1195 {
1196     jit_int32_t         reg;
1197     jit_word_t          is = i0 >> 12;
1198     if (      i0 >= 0 && i0 <= 0xfff)
1199         SUBSI   (r0, r1, i0);
1200     else if ((is << 12) == i0 && is >= 0 && is <= 0xfff)
1201         SUBSI_12(r0, r1, is);
1202     else {
1203         reg = jit_get_reg(jit_class_gpr);
1204         movi(rn(reg), i0);
1205         subcr(r0, r1, rn(reg));
1206         jit_unget_reg(reg);
1207     }
1208 }
1209
1210 static void
1211 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1212 {
1213     jit_int32_t         reg;
1214     reg = jit_get_reg(jit_class_gpr);
1215     movi(rn(reg), i0);
1216     subxr(r0, r1, rn(reg));
1217     jit_unget_reg(reg);
1218 }
1219
1220 static void
1221 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1222 {
1223     subi(r0, r1, i0);
1224     negr(r0, r0);
1225 }
1226
1227 static void
1228 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1229 {
1230     jit_int32_t         reg;
1231     reg = jit_get_reg(jit_class_gpr);
1232     movi(rn(reg), i0);
1233     mulr(r0, r1, rn(reg));
1234     jit_unget_reg(reg);
1235 }
1236
1237 static void
1238 _hmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1239 {
1240     jit_int32_t         reg;
1241     reg = jit_get_reg(jit_class_gpr);
1242     movi(rn(reg), i0);
1243     hmulr(r0, r1, rn(reg));
1244     jit_unget_reg(reg);
1245 }
1246
1247 static void
1248 _hmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1249 {
1250     jit_int32_t         reg;
1251     reg = jit_get_reg(jit_class_gpr);
1252     movi(rn(reg), i0);
1253     hmulr_u(r0, r1, rn(reg));
1254     jit_unget_reg(reg);
1255 }
1256
1257 static void
1258 _qmulr(jit_state_t *_jit, jit_int32_t r0,
1259        jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1260 {
1261     jit_int32_t         reg;
1262     if (r0 == r2 || r0 == r3) {
1263         reg = jit_get_reg(jit_class_gpr);
1264         mulr(rn(reg), r2, r3);
1265     }
1266     else
1267         mulr(r0, r2, r3);
1268     SMULH(r1, r2, r3);
1269     if (r0 == r2 || r0 == r3) {
1270         movr(r0, rn(reg));
1271         jit_unget_reg(reg);
1272     }
1273 }
1274
1275 static void
1276 _qmuli(jit_state_t *_jit, jit_int32_t r0,
1277        jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1278 {
1279     jit_int32_t         reg;
1280     reg = jit_get_reg(jit_class_gpr);
1281     movi(rn(reg), i0);
1282     qmulr(r0, r1, r2, rn(reg));
1283     jit_unget_reg(reg);
1284 }
1285
1286 static void
1287 _qmulr_u(jit_state_t *_jit, jit_int32_t r0,
1288          jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1289 {
1290     jit_int32_t         reg;
1291     if (r0 == r2 || r0 == r3) {
1292         reg = jit_get_reg(jit_class_gpr);
1293         mulr(rn(reg), r2, r3);
1294     }
1295     else
1296         mulr(r0, r2, r3);
1297     UMULH(r1, r2, r3);
1298     if (r0 == r2 || r0 == r3) {
1299         movr(r0, rn(reg));
1300         jit_unget_reg(reg);
1301     }
1302 }
1303
1304 static void
1305 _qmuli_u(jit_state_t *_jit, jit_int32_t r0,
1306          jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1307 {
1308     jit_int32_t         reg;
1309     reg = jit_get_reg(jit_class_gpr);
1310     movi(rn(reg), i0);
1311     qmulr_u(r0, r1, r2, rn(reg));
1312     jit_unget_reg(reg);
1313 }
1314
1315 static void
1316 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1317 {
1318     jit_int32_t         reg;
1319     reg = jit_get_reg(jit_class_gpr);
1320     movi(rn(reg), i0);
1321     divr(r0, r1, rn(reg));
1322     jit_unget_reg(reg);
1323 }
1324
1325 static void
1326 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1327 {
1328     jit_int32_t         reg;
1329     reg = jit_get_reg(jit_class_gpr);
1330     movi(rn(reg), i0);
1331     divr_u(r0, r1, rn(reg));
1332     jit_unget_reg(reg);
1333 }
1334
1335 static void
1336 _iqdivr(jit_state_t *_jit, jit_bool_t sign,
1337         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1338 {
1339     jit_int32_t         sv0, rg0;
1340     jit_int32_t         sv1, rg1;
1341     if (r0 == r2 || r0 == r3) {
1342         sv0 = jit_get_reg(jit_class_gpr);
1343         rg0 = rn(sv0);
1344     }
1345     else
1346         rg0 = r0;
1347     if (r1 == r2 || r1 == r3) {
1348         sv1 = jit_get_reg(jit_class_gpr);
1349         rg1 = rn(sv1);
1350     }
1351     else
1352         rg1 = r1;
1353     if (sign)
1354         divr(rg0, r2, r3);
1355     else
1356         divr_u(rg0, r2, r3);
1357     mulr(rg1, r3, rg0);
1358     subr(rg1, r2, rg1);
1359     if (rg0 != r0) {
1360         movr(r0, rg0);
1361         jit_unget_reg(sv0);
1362     }
1363     if (rg1 != r1) {
1364         movr(r1, rg1);
1365         jit_unget_reg(sv1);
1366     }
1367 }
1368
1369 static void
1370 _qdivi(jit_state_t *_jit, jit_int32_t r0,
1371        jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1372 {
1373     jit_int32_t         reg;
1374     reg = jit_get_reg(jit_class_gpr);
1375     movi(rn(reg), i0);
1376     qdivr(r0, r1, r2, rn(reg));
1377     jit_unget_reg(reg);
1378 }
1379
1380 static void
1381 _qdivi_u(jit_state_t *_jit, jit_int32_t r0,
1382          jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1383 {
1384     jit_int32_t         reg;
1385     reg = jit_get_reg(jit_class_gpr);
1386     movi(rn(reg), i0);
1387     qdivr_u(r0, r1, r2, rn(reg));
1388     jit_unget_reg(reg);
1389 }
1390
1391 static void
1392 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1393 {
1394     jit_int32_t         reg;
1395     if (r0 == r1 || r0 == r2) {
1396         reg = jit_get_reg(jit_class_gpr);
1397         divr(rn(reg), r1, r2);
1398         mulr(rn(reg), r2, rn(reg));
1399         subr(r0, r1, rn(reg));
1400         jit_unget_reg(reg);
1401     }
1402     else {
1403         divr(r0, r1, r2);
1404         mulr(r0, r2, r0);
1405         subr(r0, r1, r0);
1406     }
1407 }
1408
1409 static void
1410 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1411 {
1412     jit_int32_t         reg;
1413     reg = jit_get_reg(jit_class_gpr);
1414     movi(rn(reg), i0);
1415     remr(r0, r1, rn(reg));
1416     jit_unget_reg(reg);
1417 }
1418
1419 static void
1420 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1421 {
1422     jit_int32_t         reg;
1423     if (r0 == r1 || r0 == r2) {
1424         reg = jit_get_reg(jit_class_gpr);
1425         divr_u(rn(reg), r1, r2);
1426         mulr(rn(reg), r2, rn(reg));
1427         subr(r0, r1, rn(reg));
1428         jit_unget_reg(reg);
1429     }
1430     else {
1431         divr_u(r0, r1, r2);
1432         mulr(r0, r2, r0);
1433         subr(r0, r1, r0);
1434     }
1435 }
1436
1437 static void
1438 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1439 {
1440     jit_int32_t         reg;
1441     reg = jit_get_reg(jit_class_gpr);
1442     movi(rn(reg), i0);
1443     remr_u(r0, r1, rn(reg));
1444     jit_unget_reg(reg);
1445 }
1446
1447 static void
1448 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1449 {
1450     if (i0 == 0)
1451         movr(r0, r1);
1452     else {
1453         assert(i0 > 0 && i0 < 64);
1454         LSLI(r0, r1, i0);
1455     }
1456 }
1457
1458 static void
1459 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1460 {
1461     if (i0 == 0)
1462         movr(r0, r1);
1463     else {
1464         assert(i0 > 0 && i0 < 64);
1465         ASRI(r0, r1, i0);
1466     }
1467 }
1468
1469 static void
1470 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1471 {
1472     if (i0 == 0)
1473         movr(r0, r1);
1474     else {
1475         assert(i0 > 0 && i0 < 64);
1476         LSRI(r0, r1, i0);
1477     }
1478 }
1479
1480 static void
1481 _xlshr(jit_state_t *_jit, jit_bool_t sign,
1482        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1483 {
1484     jit_bool_t          branch;
1485     jit_word_t          over, zero, done, done_over;
1486     jit_int32_t         t0, s0, t1, s1, t2, s2, t3, s3;
1487     s0 = jit_get_reg(jit_class_gpr);
1488     t0 = rn(s0);
1489     if (r0 == r2 || r1 == r2) {
1490         s2 = jit_get_reg(jit_class_gpr);
1491         t2 = rn(s2);
1492         movr(t2, r2);
1493     }
1494     else
1495         t2 = r2;
1496     if (r0 == r3 || r1 == r3) {
1497         s3 = jit_get_reg(jit_class_gpr);
1498         t3 = rn(s3);
1499         movr(t3, r3);
1500     }
1501     else
1502         t3 = r3;
1503     if ((s1 = jit_get_reg(jit_class_gpr|jit_class_nospill|jit_class_chk))) {
1504         t1 = rn(s1);
1505         branch = 0;
1506     }
1507     else
1508         branch = 1;
1509     rsbi(t0, t3, __WORDSIZE);
1510     lshr(r0, t2, t3);
1511     if (sign)
1512         rshr(r1, t2, t0);
1513     else
1514         rshr_u(r1, t2, t0);
1515     if (branch) {
1516         zero = beqi(_jit->pc.w, t3, 0);
1517         over = beqi(_jit->pc.w, t3, __WORDSIZE);
1518         done = jmpi(_jit->pc.w);
1519         patch_at(over, _jit->pc.w);
1520         /* overflow */
1521         movi(r0, 0);
1522         done_over = jmpi(_jit->pc.w);
1523         /* zero */
1524         patch_at(zero, _jit->pc.w);
1525         if (sign)
1526             rshi(r1, t2, __WORDSIZE - 1);
1527         else
1528             movi(r1, 0);
1529         patch_at(done, _jit->pc.w);
1530         patch_at(done_over, _jit->pc.w);
1531     }
1532     else {
1533         if (sign)
1534             rshi(t0, t2, __WORDSIZE - 1);
1535         else
1536             movi(t0, 0);
1537         /* zero? */
1538         movzr(r1, t0, t3);
1539         /* Branchless but 4 bytes longer than branching fallback */
1540         if (sign)
1541             movi(t0, 0);
1542         /* overflow? */
1543         eqi(t1, t3, __WORDSIZE);
1544         movnr(r0, t0, t1);
1545         jit_unget_reg(s1);
1546     }
1547     jit_unget_reg(s0);
1548     if (t2 != r2)
1549         jit_unget_reg(s2);
1550     if (t3 != r3)
1551         jit_unget_reg(s3);
1552 }
1553
1554 static void
1555 _xlshi(jit_state_t *_jit, jit_bool_t sign,
1556        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1557 {
1558     if (i0 == 0) {
1559         movr(r0, r2);
1560         if (sign)
1561             rshi(r1, r2, __WORDSIZE - 1);
1562         else
1563             movi(r1, 0);
1564     }
1565     else if (i0 == __WORDSIZE) {
1566         movr(r1, r2);
1567         movi(r0, 0);
1568     }
1569     else {
1570         assert((jit_uword_t)i0 <= __WORDSIZE);
1571         if (sign)
1572             rshi(r1, r2, __WORDSIZE - i0);
1573         else
1574             rshi_u(r1, r2, __WORDSIZE - i0);
1575         lshi(r0, r2, i0);
1576     }
1577 }
1578
1579 static void
1580 _xrshr(jit_state_t *_jit, jit_bool_t sign,
1581        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1582 {
1583     jit_int32_t         t0, s0, t2, s2, t3, s3;
1584     s0 = jit_get_reg(jit_class_gpr);
1585     t0 = rn(s0);
1586     if (r0 == r2 || r1 == r2) {
1587         s2 = jit_get_reg(jit_class_gpr);
1588         t2 = rn(s2);
1589         movr(t2, r2);
1590     }
1591     else
1592         t2 = r2;
1593     if (r0 == r3 || r1 == r3) {
1594         s3 = jit_get_reg(jit_class_gpr);
1595         t3 = rn(s3);
1596         movr(t3, r3);
1597     }
1598     else
1599         t3 = r3;
1600
1601     if (sign) {
1602         /* underflow? */
1603         eqi(t0, t3, __WORDSIZE);
1604         subr(t0, t3, t0);
1605         rshr(r0, t2, t0);
1606     }
1607     else {
1608         /* underflow? */
1609         nei(t0, t3, __WORDSIZE);
1610         rshr_u(r0, t2, t3);
1611         movzr(r0, t0, t0);
1612     }
1613
1614     rsbi(t0, t3, __WORDSIZE);
1615     lshr(r1, t2, t0);
1616
1617     /* zero? */
1618     movzr(r1, t3, t3);
1619
1620     jit_unget_reg(s0);
1621     if (t2 != r2)
1622         jit_unget_reg(s2);
1623     if (t3 != r3)
1624         jit_unget_reg(s3);
1625 }
1626
1627 static void
1628 _xrshi(jit_state_t *_jit, jit_bool_t sign,
1629        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1630 {
1631     if (i0 == 0) {
1632         movr(r0, r2);
1633         movi(r1, 0);
1634     }
1635     else if (i0 == __WORDSIZE) {
1636         movr(r1, r2);
1637         if (sign)
1638             rshi(r0, r2, __WORDSIZE - 1);
1639         else
1640             movi(r0, 0);
1641     }
1642     else {
1643         assert((jit_uword_t)i0 <= __WORDSIZE);
1644         lshi(r1, r2, __WORDSIZE - i0);
1645         if (sign)
1646             rshi(r0, r2, i0);
1647         else
1648             rshi_u(r0, r2, i0);
1649     }
1650 }
1651
1652 static void
1653 _lrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1654 {
1655     jit_int32_t         reg;
1656     if (r0 != r1 && r0 != r2) {
1657         rsbi(r0, r2, 64);
1658         rrotr(r0, r1, r0);
1659     }
1660     else {
1661         reg = jit_get_reg(jit_class_gpr);
1662         rsbi(rn(reg), r2, 64);
1663         rrotr(r0, r1, rn(reg));
1664         jit_unget_reg(reg);
1665     }
1666 }
1667
1668 static void
1669 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1670 {
1671         CMPI(r2, 0);
1672         CSEL(r0, r0, r1, CC_NE);
1673 }
1674
1675 static void
1676 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1677 {
1678         CMPI(r2, 0);
1679         CSEL(r0, r0, r1, CC_EQ);
1680 }
1681
1682 static void
1683 _extr(jit_state_t *_jit,
1684       jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
1685 {
1686     assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
1687     if ( i1 == __WORDSIZE)
1688         movr(r0, r1);
1689     else {
1690 #  if __BYTE_ORDER == __BIG_ENDIAN
1691         i0 = __WORDSIZE - (i0 + i1);
1692 #  endif
1693         SBFX(r0, r1, i0, (i0 + i1) - 1);
1694     }
1695 }
1696
1697 static void
1698 _extr_u(jit_state_t *_jit,
1699         jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
1700 {
1701     assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
1702     if (i1 == __WORDSIZE)
1703         movr(r0, r1);
1704     else {
1705 #  if __BYTE_ORDER == __BIG_ENDIAN
1706         i0 = __WORDSIZE - (i0 + i1);
1707 #  endif
1708         UBFX(r0, r1, i0, (i0 + i1) - 1);
1709     }
1710 }
1711
1712 static void
1713 _depr(jit_state_t *_jit,
1714       jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
1715 {
1716     jit_int32_t         t0;
1717     jit_word_t          mask;
1718     assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
1719     if (i1 == __WORDSIZE)
1720         movr(r0, r1);
1721     else {
1722 #  if __BYTE_ORDER == __BIG_ENDIAN
1723         i0 = __WORDSIZE - (i0 + i1);
1724 #  endif
1725         BFM(r0, r1, -i0 & 63, i1 - 1);
1726     }
1727 }
1728
1729 static void
1730 _clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1731 {
1732     comr(r0, r1);
1733     clzr(r0, r0);
1734 }
1735
1736 static void
1737 _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1738 {
1739     RBIT(r0, r1);
1740     clor(r0, r0);
1741 }
1742
1743 static void
1744 _ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1745 {
1746     RBIT(r0, r1);
1747     clzr(r0, r0);
1748 }
1749
1750 static void
1751 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1752 {
1753     jit_int32_t         reg;
1754     jit_int32_t         imm;
1755     if (i0 == 0)
1756         movi(r0, 0);
1757     else if (i0 == -1)
1758         movr(r0, r1);
1759     else {
1760         imm = logical_immediate(i0);
1761         if (imm != -1)
1762             ANDI(r0, r1, imm);
1763         else {
1764             reg = jit_get_reg(jit_class_gpr);
1765             movi(rn(reg), i0);
1766             andr(r0, r1, rn(reg));
1767             jit_unget_reg(reg);
1768         }
1769     }
1770 }
1771
1772 static void
1773 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1774 {
1775     jit_int32_t         reg;
1776     jit_int32_t         imm;
1777     if (i0 == 0)
1778         movr(r0, r1);
1779     else if (i0 == -1)
1780         movi(r0, -1);
1781     else {
1782         imm = logical_immediate(i0);
1783         if (imm != -1)
1784             ORRI(r0, r1, imm);
1785         else {
1786             reg = jit_get_reg(jit_class_gpr);
1787             movi(rn(reg), i0);
1788             orr(r0, r1, rn(reg));
1789             jit_unget_reg(reg);
1790         }
1791     }
1792 }
1793
1794 static void
1795 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1796 {
1797     jit_int32_t         reg;
1798     jit_int32_t         imm;
1799     if (i0 == 0)
1800         movr(r0, r1);
1801     else if (i0 == -1)
1802         comr(r0, r1);
1803     else {
1804         imm = logical_immediate(i0);
1805         if (imm != -1)
1806             EORI(r0, r1, imm);
1807         else {
1808             reg = jit_get_reg(jit_class_gpr);
1809             movi(rn(reg), i0);
1810             xorr(r0, r1, rn(reg));
1811             jit_unget_reg(reg);
1812         }
1813     }
1814 }
1815
1816 static void
1817 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1818 {
1819     bswapr_ul(r0, r1);
1820     rshi_u(r0, r0, 48);
1821 }
1822
1823 static void
1824 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1825 {
1826     bswapr_ul(r0, r1);
1827     rshi_u(r0, r0, 32);
1828 }
1829
1830 static void
1831 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1832 {
1833     jit_int32_t         reg;
1834     reg = jit_get_reg(jit_class_gpr);
1835     movi(rn(reg), i0);
1836     ldr_c(r0, rn(reg));
1837     jit_unget_reg(reg);
1838 }
1839
1840 static void
1841 _ldr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1842 {
1843     LDRBI(r0, r1, 0);
1844 #if 0
1845     extr_uc(r0, r0);
1846 #endif
1847 }
1848
1849 static void
1850 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1851 {
1852     jit_int32_t         reg;
1853     reg = jit_get_reg(jit_class_gpr);
1854     movi(rn(reg), i0);
1855     ldr_uc(r0, rn(reg));
1856     jit_unget_reg(reg);
1857 }
1858
1859 static void
1860 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1861 {
1862     jit_int32_t         reg;
1863     reg = jit_get_reg(jit_class_gpr);
1864     movi(rn(reg), i0);
1865     ldr_s(r0, rn(reg));
1866     jit_unget_reg(reg);
1867 }
1868
1869 static void
1870 _ldr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1871 {
1872     LDRHI(r0, r1, 0);
1873 #if 0
1874     extr_us(r0, r0);
1875 #endif
1876 }
1877
1878 static void
1879 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1880 {
1881     jit_int32_t         reg;
1882     reg = jit_get_reg(jit_class_gpr);
1883     movi(rn(reg), i0);
1884     ldr_us(r0, rn(reg));
1885     jit_unget_reg(reg);
1886 }
1887
1888 static void
1889 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1890 {
1891     jit_int32_t         reg;
1892     reg = jit_get_reg(jit_class_gpr);
1893     movi(rn(reg), i0);
1894     ldr_i(r0, rn(reg));
1895     jit_unget_reg(reg);
1896 }
1897
1898 static void
1899 _ldr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1900 {
1901     LDRWI(r0, r1, 0);
1902 #if 0
1903     extr_ui(r0, r0);
1904 #endif
1905 }
1906
1907 static void
1908 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1909 {
1910     jit_int32_t         reg;
1911     reg = jit_get_reg(jit_class_gpr);
1912     movi(rn(reg), i0);
1913     ldr_ui(r0, rn(reg));
1914     jit_unget_reg(reg);
1915 }
1916
1917 static void
1918 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1919 {
1920     jit_int32_t         reg;
1921     reg = jit_get_reg(jit_class_gpr);
1922     movi(rn(reg), i0);
1923     ldr_l(r0, rn(reg));
1924     jit_unget_reg(reg);
1925 }
1926
1927 static void
1928 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1929 {
1930     LDRSB(r0, r1, r2);
1931     extr_c(r0, r0);
1932 }
1933
1934 static void
1935 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1936 {
1937     jit_int32_t         reg;
1938     if (i0 >= 0 && i0 <= 4095)
1939         LDRSBI(r0, r1, i0);
1940     else if (i0 > -256 && i0 < 0)
1941         LDURSB(r0, r1, i0 & 0x1ff);
1942     else {
1943         reg = jit_get_reg(jit_class_gpr);
1944         movi(rn(reg), i0);
1945         LDRSB(r0, r1, rn(reg));
1946         jit_unget_reg(reg);
1947     }
1948     extr_c(r0, r0);
1949 }
1950
1951 static void
1952 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1953 {
1954     LDRB(r0, r1, r2);
1955 #if 0
1956     extr_uc(r0, r0);
1957 #endif
1958 }
1959
1960 static void
1961 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1962 {
1963     jit_int32_t         reg;
1964     if (i0 >= 0 && i0 <= 4095)
1965         LDRBI(r0, r1, i0);
1966     else if (i0 > -256 && i0 < 0)
1967         LDURB(r0, r1, i0 & 0x1ff);
1968     else {
1969         reg = jit_get_reg(jit_class_gpr);
1970         addi(rn(reg), r1, i0);
1971         ldr_uc(r0, rn(reg));
1972         jit_unget_reg(reg);
1973     }
1974 #if 0
1975     extr_uc(r0, r0);
1976 #endif
1977 }
1978
1979 static void
1980 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1981 {
1982     jit_int32_t         reg;
1983     if (i0 >= 0 && i0 <= 8191 && !(i0 & 1))
1984         LDRSHI(r0, r1, i0 >> 1);
1985     else if (i0 > -256 && i0 < 0)
1986         LDURSH(r0, r1, i0 & 0x1ff);
1987     else {
1988         reg = jit_get_reg(jit_class_gpr);
1989         movi(rn(reg), i0);
1990         LDRSH(r0, r1, rn(reg));
1991         jit_unget_reg(reg);
1992     }
1993 }
1994
1995 static void
1996 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1997 {
1998     LDRH(r0, r1, r2);
1999 #if 0
2000     extr_us(r0, r0);
2001 #endif
2002 }
2003
2004 static void
2005 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2006 {
2007     jit_int32_t         reg;
2008     if (i0 >= 0 && i0 <= 8191 && !(i0 & 1))
2009         LDRHI(r0, r1, i0 >> 1);
2010     else if (i0 > -256 && i0 < 0)
2011         LDURH(r0, r1, i0 & 0x1ff);
2012     else {
2013         reg = jit_get_reg(jit_class_gpr);
2014         movi(rn(reg), i0);
2015         LDRH(r0, r1, rn(reg));
2016         jit_unget_reg(reg);
2017     }
2018 #if 0
2019     extr_us(r0, r0);
2020 #endif
2021 }
2022
2023 static void
2024 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2025 {
2026     jit_int32_t         reg;
2027     if (i0 >= 0 && i0 <= 16383 && !(i0 & 3))
2028         LDRSWI(r0, r1, i0 >> 2);
2029     else if (i0 > -256 && i0 < 0)
2030         LDURSW(r0, r1, i0 & 0x1ff);
2031     else {
2032         reg = jit_get_reg(jit_class_gpr);
2033         addi(rn(reg), r1, i0);
2034         ldr_i(r0, rn(reg));
2035         jit_unget_reg(reg);
2036     }
2037 }
2038
2039 static void
2040 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2041 {
2042     LDRW(r0, r1, r2);
2043 #if 0
2044     extr_ui(r0, r0);
2045 #endif
2046 }
2047
2048 static void
2049 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2050 {
2051     jit_int32_t         reg;
2052     if (i0 >= 0 && i0 <= 16383 && !(i0 & 3))
2053         LDRWI(r0, r1, i0 >> 2);
2054     else if (i0 > -256 && i0 < 0)
2055         LDURW(r0, r1, i0 & 0x1ff);
2056     else {
2057         reg = jit_get_reg(jit_class_gpr);
2058         movi(rn(reg), i0);
2059         LDRW(r0, r1, rn(reg));
2060         jit_unget_reg(reg);
2061     }
2062 #if 0
2063     extr_ui(r0, r0);
2064 #endif
2065 }
2066
2067 static void
2068 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2069 {
2070     jit_int32_t         reg;
2071     if (i0 >= 0 && i0 <= 32767 && !(i0 & 7))
2072         LDRI(r0, r1, i0 >> 3);
2073     else if (i0 > -256 && i0 < 0)
2074         LDUR(r0, r1, i0 & 0x1ff);
2075     else {
2076         reg = jit_get_reg(jit_class_gpr);
2077         addi(rn(reg), r1, i0);
2078         ldr_l(r0, rn(reg));
2079         jit_unget_reg(reg);
2080     }
2081 }
2082
2083 static void
2084 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2085 {
2086     jit_int32_t         reg;
2087     reg = jit_get_reg(jit_class_gpr);
2088     movi(rn(reg), i0);
2089     str_c(rn(reg), r0);
2090     jit_unget_reg(reg);
2091 }
2092
2093 static void
2094 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2095 {
2096     jit_int32_t         reg;
2097     reg = jit_get_reg(jit_class_gpr);
2098     movi(rn(reg), i0);
2099     str_s(rn(reg), r0);
2100     jit_unget_reg(reg);
2101 }
2102
2103 static void
2104 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2105 {
2106     jit_int32_t         reg;
2107     reg = jit_get_reg(jit_class_gpr);
2108     movi(rn(reg), i0);
2109     str_i(rn(reg), r0);
2110     jit_unget_reg(reg);
2111 }
2112
2113 static void
2114 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2115 {
2116     jit_int32_t         reg;
2117     reg = jit_get_reg(jit_class_gpr);
2118     movi(rn(reg), i0);
2119     str_l(rn(reg), r0);
2120     jit_unget_reg(reg);
2121 }
2122
2123 static void
2124 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2125 {
2126     jit_int32_t         reg;
2127     if (i0 >= 0 && i0 <= 4095)
2128         STRBI(r1, r0, i0);
2129     else if (i0 > -256 && i0 < 0)
2130         STURB(r1, r0, i0 & 0x1ff);
2131     else {
2132         reg = jit_get_reg(jit_class_gpr);
2133         addi(rn(reg), r0, i0);
2134         str_c(rn(reg), r1);
2135         jit_unget_reg(reg);
2136     }
2137 }
2138
2139 static void
2140 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2141 {
2142     jit_int32_t         reg;
2143     if (i0 >= 0 && i0 <= 8191 && !(i0 & 1))
2144         STRHI(r1, r0, i0 >> 1);
2145     else if (i0 > -256 && i0 < 0)
2146         STURH(r1, r0, i0 & 0x1ff);
2147     else {
2148         reg = jit_get_reg(jit_class_gpr);
2149         addi(rn(reg), r0, i0);
2150         str_s(rn(reg), r1);
2151         jit_unget_reg(reg);
2152     }
2153 }
2154
2155 static void
2156 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2157 {
2158     jit_int32_t         reg;
2159     if (i0 >= 0 && i0 <= 16383 && !(i0 & 3))
2160         STRWI(r1, r0, i0 >> 2);
2161     else if (i0 > -256 && i0 < 0)
2162         STURW(r1, r0, i0 & 0x1ff);
2163     else {
2164         reg = jit_get_reg(jit_class_gpr);
2165         addi(rn(reg), r0, i0);
2166         str_i(rn(reg), r1);
2167         jit_unget_reg(reg);
2168     }
2169 }
2170
2171 static void
2172 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2173 {
2174     jit_int32_t         reg;
2175     if (i0 >= 0 && i0 <= 32767 && !(i0 & 7))
2176         STRI(r1, r0, i0 >> 3);
2177     else if (i0 > -256 && i0 < 0)
2178         STUR(r1, r0, i0 & 0x1ff);
2179     else {
2180         reg = jit_get_reg(jit_class_gpr);
2181         addi(rn(reg), r0, i0);
2182         str_l(rn(reg), r1);
2183         jit_unget_reg(reg);
2184     }
2185 }
2186
2187 static void
2188 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
2189       jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
2190 {
2191     jit_int32_t         r1_reg, iscasi;
2192     jit_word_t          retry, done, jump0, jump1;
2193     if ((iscasi = (r1 == _NOREG))) {
2194         r1_reg = jit_get_reg(jit_class_gpr);
2195         r1 = rn(r1_reg);
2196         movi(r1, i0);
2197     }
2198     /* retry: */
2199     retry = _jit->pc.w;
2200     LDAXR(r0, r1);
2201     eqr(r0, r0, r2);
2202     jump0 = beqi(_jit->pc.w, r0, 0);    /* beqi done r0 0 */
2203     STLXR(r3, r0, r1);
2204     jump1 = bnei(_jit->pc.w, r0, 0);    /* bnei retry r0 0 */
2205     /* done: */
2206     CSET(r0, CC_EQ);
2207     done = _jit->pc.w;
2208     patch_at(jump0, done);
2209     patch_at(jump1, retry);
2210     if (iscasi)
2211         jit_unget_reg(r1_reg);
2212 }
2213
2214 static void
2215 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2216 {
2217     if (r0 != r1)
2218         MOV(r0, r1);
2219 }
2220
2221 static void
2222 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2223 {
2224     jit_word_t          n0, ibit, nbit;
2225     n0 = ~i0;
2226     ibit = nbit = 0;
2227     if (i0 & 0x000000000000ffffL)       ibit |= 1;
2228     if (i0 & 0x00000000ffff0000L)       ibit |= 2;
2229     if (i0 & 0x0000ffff00000000L)       ibit |= 4;
2230     if (i0 & 0xffff000000000000L)       ibit |= 8;
2231     if (n0 & 0x000000000000ffffL)       nbit |= 1;
2232     if (n0 & 0x00000000ffff0000L)       nbit |= 2;
2233     if (n0 & 0x0000ffff00000000L)       nbit |= 4;
2234     if (n0 & 0xffff000000000000L)       nbit |= 8;
2235     switch (ibit) {
2236         case 0:
2237             MOVZ   (r0,  0);
2238             break;
2239         case 1:
2240             MOVZ   (r0,  i0        & 0xffff);
2241             break;
2242         case 2:
2243             MOVZ_16(r0, (i0 >> 16) & 0xffff);
2244             break;
2245         case 3:
2246             MOVZ   (r0,  i0        & 0xffff);
2247             MOVK_16(r0, (i0 >> 16) & 0xffff);
2248             break;
2249         case 4:
2250             MOVZ_32(r0, (i0 >> 32) & 0xffff);
2251             break;
2252         case 5:
2253             MOVZ   (r0,  i0        & 0xffff);
2254             MOVK_32(r0, (i0 >> 32) & 0xffff);
2255             break;
2256         case 6:
2257             MOVZ_16(r0, (i0 >> 16) & 0xffff);
2258             MOVK_32(r0, (i0 >> 32) & 0xffff);
2259             break;
2260         case 7:
2261             if (nbit == 8)
2262                 MOVN_48(r0, (n0 >> 48) & 0xffff);
2263             else {
2264                 MOVZ   (r0,  i0        & 0xffff);
2265                 MOVK_16(r0, (i0 >> 16) & 0xffff);
2266                 MOVK_32(r0, (i0 >> 32) & 0xffff);
2267             }
2268             break;
2269         case 8:
2270             MOVZ_48(r0, (i0 >> 48) & 0xffff);
2271             break;
2272         case 9:
2273             MOVZ   (r0,  i0        & 0xffff);
2274             MOVK_48(r0, (i0 >> 48) & 0xffff);
2275             break;
2276         case 10:
2277             MOVZ_16(r0, (i0 >> 16) & 0xffff);
2278             MOVK_48(r0, (i0 >> 48) & 0xffff);
2279             break;
2280         case 11:
2281             if (nbit == 4)
2282                 MOVN_32(r0, (n0 >> 32) & 0xffff);
2283             else {
2284                 MOVZ   (r0,  i0        & 0xffff);
2285                 MOVK_16(r0, (i0 >> 16) & 0xffff);
2286                 MOVK_48(r0, (i0 >> 48) & 0xffff);
2287             }
2288             break;
2289         case 12:
2290             MOVZ_32(r0, (i0 >> 32) & 0xffff);
2291             MOVK_48(r0, (i0 >> 48) & 0xffff);
2292             break;
2293         case 13:
2294             if (nbit == 2)
2295                 MOVN_16(r0, (n0 >> 16) & 0xffff);
2296             else {
2297                 MOVZ   (r0,  i0        & 0xffff);
2298                 MOVK_32(r0, (i0 >> 32) & 0xffff);
2299                 MOVK_48(r0, (i0 >> 48) & 0xffff);
2300             }
2301             break;
2302         case 14:
2303             if (nbit == 1)
2304                 MOVN   (r0, (n0)       & 0xffff);
2305             else {
2306                 MOVZ_16(r0, (i0 >> 16) & 0xffff);
2307                 MOVK_32(r0, (i0 >> 32) & 0xffff);
2308                 MOVK_48(r0, (i0 >> 48) & 0xffff);
2309             }
2310             break;
2311         case 15:
2312             if (nbit == 0)
2313                 MOVN   (r0,  0);
2314             else if (nbit == 1)
2315                 MOVN   (r0,  n0        & 0xffff);
2316             else if (nbit == 8)
2317                 MOVN_48(r0, (n0 >> 48) & 0xffff);
2318             else {
2319                 MOVZ   (r0,  i0        & 0xffff);
2320                 MOVK_16(r0, (i0 >> 16) & 0xffff);
2321                 MOVK_32(r0, (i0 >> 32) & 0xffff);
2322                 MOVK_48(r0, (i0 >> 48) & 0xffff);
2323             }
2324             break;
2325         default:
2326             abort();
2327     }
2328 }
2329
2330 static jit_word_t
2331 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2332 {
2333     jit_word_t          w;
2334     w = _jit->pc.w;
2335     MOVZ   (r0,  i0        & 0xffff);
2336     MOVK_16(r0, (i0 >> 16) & 0xffff);
2337     MOVK_32(r0, (i0 >> 32) & 0xffff);
2338     MOVK_48(r0, (i0 >> 48) & 0xffff);
2339     return (w);
2340 }
2341
2342 static void
2343 _ccr(jit_state_t *_jit, jit_int32_t cc,
2344      jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2345 {
2346     CMP(r1, r2);
2347     CSET(r0, cc);
2348 }
2349
2350 static void
2351 _cci(jit_state_t *_jit, jit_int32_t cc,
2352      jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2353 {
2354     jit_int32_t         reg;
2355     jit_word_t          is =  i0 >> 12;
2356     jit_word_t          in = -i0;
2357     jit_word_t          iS =  in >> 12;
2358     if (      i0 >= 0 && i0 <= 0xfff)
2359         CMPI   (r1, i0);
2360     else if ((is << 12) == i0 && is >= 0 && is <= 0xfff)
2361         CMPI_12(r1, is);
2362     else if ( in >= 0 && in <= 0xfff)
2363         CMNI   (r1, in);
2364     else if ((iS << 12) == is && iS >= 0 && iS <= 0xfff)
2365         CMNI_12(r1, iS);
2366     else {
2367         reg = jit_get_reg(jit_class_gpr);
2368         movi(rn(reg), i0);
2369         CMP(r1, rn(reg));
2370         jit_unget_reg(reg);
2371     }
2372     CSET(r0, cc);
2373 }
2374
2375 static jit_word_t
2376 _bccr(jit_state_t *_jit, jit_int32_t cc,
2377       jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2378 {
2379     jit_word_t          w, d;
2380     CMP(r0, r1);
2381     w = _jit->pc.w;
2382     d = (i0 - w) >> 2;
2383     B_C(cc, d);
2384     return (w);
2385 }
2386
2387 static jit_word_t
2388 _bcci(jit_state_t *_jit, jit_int32_t cc,
2389       jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2390 {
2391     jit_int32_t         reg;
2392     jit_word_t          w, d;
2393     jit_word_t          is =  i1 >> 12;
2394     jit_word_t          in = -i1;
2395     jit_word_t          iS =  in >> 12;
2396     if (      i1 >= 0 && i1 <= 0xfff)
2397         CMPI   (r0, i1);
2398     else if ((is << 12) == i1 && is >= 0 && is <= 0xfff)
2399         CMPI_12(r0, is);
2400     else if ( in >= 0 && in <= 0xfff)
2401         CMNI   (r0, in);
2402     else if ((iS << 12) == is && iS >= 0 && iS <= 0xfff)
2403         CMNI_12(r0, iS);
2404     else {
2405         reg = jit_get_reg(jit_class_gpr);
2406         movi(rn(reg), i1);
2407         CMP(r0, rn(reg));
2408         jit_unget_reg(reg);
2409     }
2410     w = _jit->pc.w;
2411     d = (i0 - w) >> 2;
2412     B_C(cc, d);
2413     return (w);
2414 }
2415
2416 static jit_word_t
2417 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2418 {
2419     jit_word_t          w;
2420     if (i1 == 0) {
2421         w = _jit->pc.w;
2422         CBZ(r0, (i0 - w) >> 2);
2423     }
2424     else
2425         w = bcci(BCC_EQ, i0, r0, i1);
2426     return (w);
2427 }
2428
2429 static jit_word_t
2430 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2431 {
2432     jit_word_t          w;
2433     if (i1 == 0) {
2434         w = _jit->pc.w;
2435         CBNZ(r0, (i0 - w) >> 2);
2436     }
2437     else
2438         w = bcci(BCC_NE, i0, r0, i1);
2439     return (w);
2440 }
2441
2442 static jit_word_t
2443 _baddr(jit_state_t *_jit, jit_int32_t cc,
2444        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2445 {
2446     jit_word_t          w;
2447     addcr(r0, r0, r1);
2448     w = _jit->pc.w;
2449     B_C(cc, (i0 - w) >> 2);
2450     return (w);
2451 }
2452
2453 static jit_word_t
2454 _baddi(jit_state_t *_jit, jit_int32_t cc,
2455        jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2456 {
2457     jit_word_t          w;
2458     addci(r0, r0, i1);
2459     w = _jit->pc.w;
2460     B_C(cc, (i0 - w) >> 2);
2461     return (w);
2462 }
2463
2464 static jit_word_t
2465 _bsubr(jit_state_t *_jit, jit_int32_t cc,
2466        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2467 {
2468     jit_word_t          w;
2469     subcr(r0, r0, r1);
2470     w = _jit->pc.w;
2471     B_C(cc, (i0 - w) >> 2);
2472     return (w);
2473 }
2474
2475 static jit_word_t
2476 _bsubi(jit_state_t *_jit, jit_int32_t cc,
2477        jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2478 {
2479     jit_word_t          w;
2480     subci(r0, r0, i1);
2481     w = _jit->pc.w;
2482     B_C(cc, (i0 - w) >> 2);
2483     return (w);
2484 }
2485
2486 static jit_word_t
2487 _bmxr(jit_state_t *_jit, jit_int32_t cc,
2488       jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2489 {
2490     jit_word_t          w;
2491     TST(r0, r1);
2492     w = _jit->pc.w;
2493     B_C(cc, (i0 - w) >> 2);
2494     return (w);
2495 }
2496
2497 static jit_word_t
2498 _bmxi(jit_state_t *_jit, jit_int32_t cc,
2499       jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2500 {
2501     jit_word_t          w;
2502     jit_int32_t         reg;
2503     jit_int32_t         imm;
2504     imm = logical_immediate(i1);
2505     if (imm != -1)
2506         TSTI(r0, imm);
2507     else {
2508         reg = jit_get_reg(jit_class_gpr);
2509         movi(rn(reg), i1);
2510         TST(r0, rn(reg));
2511         jit_unget_reg(reg);
2512     }
2513     w = _jit->pc.w;
2514     B_C(cc, (i0 - w) >> 2);
2515     return (w);
2516 }
2517
2518 static jit_word_t
2519 _jmpi(jit_state_t *_jit, jit_word_t i0)
2520 {
2521     jit_int32_t         reg;
2522     jit_word_t          d, w;
2523     w = _jit->pc.w;
2524     d = (i0 - w) >> 2;
2525     if (s26_p(d))
2526         B(d);
2527     else {
2528         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2529         movi(rn(reg), i0);
2530         jmpr(rn(reg));
2531         jit_unget_reg(reg);
2532     }
2533     return (w);
2534 }
2535
2536 static jit_word_t
2537 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
2538 {
2539     jit_word_t          w;
2540     jit_int32_t         reg;
2541     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2542     w = movi_p(rn(reg), i0);
2543     jmpr(rn(reg));
2544     jit_unget_reg(reg);
2545     return (w);
2546 }
2547
2548 static jit_word_t
2549 _calli(jit_state_t *_jit, jit_word_t i0)
2550 {
2551     jit_int32_t         reg;
2552     jit_word_t          d, w;
2553     w = _jit->pc.w;
2554     d = (i0 - w) >> 2;
2555     if (s26_p(d))
2556         BL(d);
2557     else {
2558         reg = jit_get_reg(jit_class_gpr);
2559         movi(rn(reg), i0);
2560         callr(rn(reg));
2561         jit_unget_reg(reg);
2562     }
2563     return (w);
2564 }
2565
2566 static jit_word_t
2567 _calli_p(jit_state_t *_jit, jit_word_t i0)
2568 {
2569     jit_word_t          w;
2570     jit_int32_t         reg;
2571     reg = jit_get_reg(jit_class_gpr);
2572     w = movi_p(rn(reg), i0);
2573     callr(rn(reg));
2574     jit_unget_reg(reg);
2575     return (w);
2576 }
2577
2578 static void
2579 _prolog(jit_state_t *_jit, jit_node_t *node)
2580 {
2581     jit_int32_t         reg, rreg, offs;
2582     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2583         jit_int32_t     frame = -_jitc->function->frame;
2584         jit_check_frame();
2585         assert(_jitc->function->self.aoff >= frame);
2586         if (_jitc->function->assume_frame)
2587             return;
2588         _jitc->function->self.aoff = frame;
2589     }
2590     if (_jitc->function->allocar)
2591         _jitc->function->self.aoff &= -16;
2592     _jitc->function->stack = ((_jitc->function->self.alen -
2593                               /* align stack at 16 bytes */
2594                               _jitc->function->self.aoff) + 15) & -16;
2595
2596     if (!_jitc->function->need_frame) {
2597         /* check if any callee save register needs to be saved */
2598         for (reg = 0; reg < _jitc->reglen; ++reg)
2599             if (jit_regset_tstbit(&_jitc->function->regset, reg) &&
2600                 (_rvs[reg].spec & jit_class_sav)) {
2601                 jit_check_frame();
2602                 break;
2603             }
2604     }
2605
2606     if (_jitc->function->need_frame) {
2607         STPI_POS(FP_REGNO, LR_REGNO, SP_REGNO, -(jit_framesize() >> 3));
2608         MOV_XSP(FP_REGNO, SP_REGNO);
2609     }
2610     /* callee save registers */
2611     for (reg = 0, offs = 2; reg < jit_size(iregs);) {
2612         if (jit_regset_tstbit(&_jitc->function->regset, iregs[reg])) {
2613             for (rreg = reg + 1; rreg < jit_size(iregs); rreg++) {
2614                 if (jit_regset_tstbit(&_jitc->function->regset, iregs[rreg]))
2615                     break;
2616             }
2617             if (rreg < jit_size(iregs)) {
2618                 STPI(rn(iregs[reg]), rn(iregs[rreg]), SP_REGNO, offs);
2619                 offs += 2;
2620                 reg = rreg + 1;
2621             }
2622             else {
2623                 STRI(rn(iregs[reg]), SP_REGNO, offs);
2624                 ++offs;
2625                 /* No pair found */
2626                 break;
2627             }
2628         }
2629         else
2630             ++reg;
2631     }
2632     for (reg = 0, offs <<= 3; reg < jit_size(fregs); reg++) {
2633         if (jit_regset_tstbit(&_jitc->function->regset, fregs[reg])) {
2634             stxi_d(offs, SP_REGNO, rn(fregs[reg]));
2635             offs += sizeof(jit_float64_t);
2636         }
2637     }
2638
2639   if (_jitc->function->stack)
2640         subi(SP_REGNO, SP_REGNO, _jitc->function->stack);
2641     if (_jitc->function->allocar) {
2642         reg = jit_get_reg(jit_class_gpr);
2643         movi(rn(reg), _jitc->function->self.aoff);
2644         stxi_i(_jitc->function->aoffoff, FP_REGNO, rn(reg));
2645         jit_unget_reg(reg);
2646     }
2647
2648 #if !__APPLE__
2649     if (_jitc->function->self.call & jit_call_varargs) {
2650         /* Save gp registers in the save area, if any is a vararg */
2651         for (reg = 8 - _jitc->function->vagp / -8;
2652              jit_arg_reg_p(reg); ++reg)
2653             stxi(_jitc->function->vaoff + offsetof(jit_va_list_t, x0) +
2654                  reg * 8, FP_REGNO, rn(JIT_RA0 - reg));
2655
2656         for (reg = 8 - _jitc->function->vafp / -16;
2657              jit_arg_f_reg_p(reg); ++reg)
2658             /* Save fp registers in the save area, if any is a vararg */
2659             /* Note that the full 16 byte register is not saved, because
2660              * lightning only handles float and double, and, while
2661              * attempting to provide a va_list compatible pointer as
2662              * jit_va_start return, does not guarantee it (on all ports). */
2663             stxi_d(_jitc->function->vaoff + offsetof(jit_va_list_t, q0) +
2664                    reg * 16 + offsetof(jit_qreg_t, l), FP_REGNO, rn(_V0 - reg));
2665     }
2666 #endif
2667 }
2668
2669 static void
2670 _epilog(jit_state_t *_jit, jit_node_t *node)
2671 {
2672     jit_int32_t         reg, rreg, offs;
2673     if (_jitc->function->assume_frame)
2674         return;
2675     if (_jitc->function->stack)
2676         MOV_XSP(SP_REGNO, FP_REGNO);
2677     /* callee save registers */
2678     for (reg = 0, offs = 2; reg < jit_size(iregs);) {
2679         if (jit_regset_tstbit(&_jitc->function->regset, iregs[reg])) {
2680             for (rreg = reg + 1; rreg < jit_size(iregs); rreg++) {
2681                 if (jit_regset_tstbit(&_jitc->function->regset, iregs[rreg]))
2682                     break;
2683             }
2684             if (rreg < jit_size(iregs)) {
2685                 LDPI(rn(iregs[reg]), rn(iregs[rreg]), SP_REGNO, offs);
2686                 offs += 2;
2687                 reg = rreg + 1;
2688             }
2689             else {
2690                 LDRI(rn(iregs[reg]), SP_REGNO, offs);
2691                 ++offs;
2692                 /* No pair found */
2693                 break;
2694             }
2695         }
2696         else
2697             ++reg;
2698     }
2699     for (reg = 0, offs <<= 3; reg < jit_size(fregs); reg++) {
2700         if (jit_regset_tstbit(&_jitc->function->regset, fregs[reg])) {
2701             ldxi_d(rn(fregs[reg]), SP_REGNO, offs);
2702             offs += sizeof(jit_float64_t);
2703         }
2704     }
2705
2706     if (_jitc->function->need_frame)
2707         LDPI_PRE(FP_REGNO, LR_REGNO, SP_REGNO, jit_framesize() >> 3);
2708     RET();
2709 }
2710
2711 static void
2712 _vastart(jit_state_t *_jit, jit_int32_t r0)
2713 {
2714 #if !__APPLE__
2715     jit_int32_t         reg;
2716
2717     assert(_jitc->function->self.call & jit_call_varargs);
2718
2719     /* Return jit_va_list_t in the register argument */
2720     addi(r0, FP_REGNO, _jitc->function->vaoff);
2721
2722     reg = jit_get_reg(jit_class_gpr);
2723
2724     /* Initialize stack pointer to the first stack argument. */
2725     addi(rn(reg), FP_REGNO, jit_selfsize());
2726     stxi(offsetof(jit_va_list_t, stack), r0, rn(reg));
2727
2728     /* Initialize gp top pointer to the first stack argument. */
2729     addi(rn(reg), r0, va_gp_top_offset);
2730     stxi(offsetof(jit_va_list_t, gptop), r0, rn(reg));
2731
2732     /* Initialize fp top pointer to the first stack argument. */
2733     addi(rn(reg), r0, va_fp_top_offset);
2734     stxi(offsetof(jit_va_list_t, fptop), r0, rn(reg));
2735
2736     /* Initialize gp offset in the save area. */
2737     movi(rn(reg), _jitc->function->vagp);
2738     stxi_i(offsetof(jit_va_list_t, gpoff), r0, rn(reg));
2739
2740     /* Initialize fp offset in the save area. */
2741     movi(rn(reg), _jitc->function->vafp);
2742     stxi_i(offsetof(jit_va_list_t, fpoff), r0, rn(reg));
2743
2744     jit_unget_reg(reg);
2745 #else
2746     assert(_jitc->function->self.call & jit_call_varargs);
2747     addi(r0, FP_REGNO, jit_selfsize());
2748 #endif
2749 }
2750
2751 static void
2752 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2753 {
2754 #if !__APPLE__
2755     jit_word_t          ge_code;
2756     jit_word_t          lt_code;
2757     jit_int32_t         rg0, rg1;
2758
2759     assert(_jitc->function->self.call & jit_call_varargs);
2760
2761     rg0 = jit_get_reg(jit_class_gpr);
2762     rg1 = jit_get_reg(jit_class_gpr);
2763
2764     /* Load the gp offset in save area in the first temporary. */
2765     ldxi_i(rn(rg0), r1, offsetof(jit_va_list_t, gpoff));
2766
2767     /* Jump over if there are no remaining arguments in the save area. */
2768     ge_code = bgei(_jit->pc.w, rn(rg0), 0);
2769
2770     /* Load the gp save pointer in the second temporary. */
2771     ldxi(rn(rg1), r1, offsetof(jit_va_list_t, gptop));
2772
2773     /* Load the vararg argument in the first argument. */
2774     ldxr(r0, rn(rg1), rn(rg0));
2775
2776     /* Update the gp offset. */
2777     addi(rn(rg0), rn(rg0), 8);
2778     stxi_i(offsetof(jit_va_list_t, gpoff), r1, rn(rg0));
2779
2780     /* Will only need one temporary register below. */
2781     jit_unget_reg(rg1);
2782
2783     /* Jump over overflow code. */
2784     lt_code = jmpi(_jit->pc.w);
2785
2786     /* Where to land if argument is in overflow area. */
2787     patch_at(ge_code, _jit->pc.w);
2788
2789     /* Load stack pointer. */
2790     ldxi(rn(rg0), r1, offsetof(jit_va_list_t, stack));
2791
2792     /* Load argument. */
2793     ldr(r0, rn(rg0));
2794
2795     /* Update stack pointer. */
2796     addi(rn(rg0), rn(rg0), 8);
2797     stxi(offsetof(jit_va_list_t, stack), r1, rn(rg0));
2798
2799     /* Where to land if argument is in gp save area. */
2800     patch_at(lt_code, _jit->pc.w);
2801
2802     jit_unget_reg(rg0);
2803 #else
2804     assert(_jitc->function->self.call & jit_call_varargs);
2805     ldr(r0, r1);
2806     addi(r1, r1, sizeof(jit_word_t));
2807 #endif
2808 }
2809
2810 static void
2811 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
2812 {
2813     instr_t              i;
2814     jit_word_t           d;
2815     jit_int32_t          fc, ff, ffc;
2816     union {
2817         jit_int32_t     *i;
2818         jit_word_t       w;
2819     } u;
2820     u.w = instr;
2821     i.w = u.i[0];
2822     fc  = i.w & 0xfc000000;
2823     ff  = i.w & 0xff000000;
2824     ffc = i.w & 0xffc00000;
2825     if (fc == A64_B || fc == A64_BL) {
2826         d = (label - instr) >> 2;
2827         assert(s26_p(d));
2828         i.imm26.b = d;
2829         u.i[0] = i.w;
2830     }
2831     else if (ff == A64_B_C || ff == (A64_CBZ|XS) || ff == (A64_CBNZ|XS)) {
2832         d = (label - instr) >> 2;
2833         assert(d >= -262148 && d <= 262143);
2834         i.imm19.b = d;
2835         u.i[0] = i.w;
2836     }
2837     else if (ffc == (A64_MOVZ|XS)) {
2838         i.imm16.b = label;
2839         u.i[0] = i.w;
2840         i.w = u.i[1];
2841         assert((i.w & 0xffe00000) == (A64_MOVK|XS|MOVI_LSL_16));
2842         i.imm16.b = label >> 16;
2843         u.i[1] = i.w;
2844         i.w = u.i[2];
2845         assert((i.w & 0xffe00000) == (A64_MOVK|XS|MOVI_LSL_32));
2846         i.imm16.b = label >> 32;
2847         u.i[2] = i.w;
2848         i.w = u.i[3];
2849         assert((i.w & 0xffe00000) == (A64_MOVK|XS|MOVI_LSL_48));
2850         i.imm16.b = label >> 48;
2851         u.i[3] = i.w;
2852     }
2853     else
2854         abort();
2855 }
2856 #endif