deps/lightning/lib/jit_s390-fpu.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 #  define RND_CUR                       0
  22 #  define RND_BIAS_NEAR                 1
  23 #  define RND_NEAR                      4
  24 #  define RND_ZERO                      5
  25 #  define RND_POS_INF                   6
  26 #  define RND_NEG_INF                   7
  27 /****************************************************************
  28  * Floating Point Instructions                                  *
  29  ****************************************************************/
  30 /* CONVERT BFP TO HFP */
  31 #  define THDER(R1,R2)                  RRE_(0xB358,R1,R2)
  32 #  define THDR(R1,R2)                   RRE_(0xB359,R1,R2)
  33 /* CONVERT HFP TO BFP */
  34 #  define TBEDR(R1,R2)                  RRE_(0xB350,R1,R2)
  35 #  define TBDR(R1,R2)                   RRE_(0xB351,R1,R2)
  36 /* LOAD */
  37 #  define LER(R1,R2)                    RR_(0x38,R1,R2)
  38 #  define LDR(R1,R2)                    RR_(0x28,R1,R2)
  39 #  define LXR(R1,R2)                    RRE_(0xB365,R1,R2)
  40 #  define LE(R1,D2,X2,B2)               RX_(0x78,R1,X2,B2,D2)
  41 #  define LD(R1,D2,X2,B2)               RX_(0x68,R1,X2,B2,D2)
  42 #  define LEY(R1,D2,X2,B2)              RXY_(0xED,R1,X2,B2,D2,0x64)
  43 #  define LDY(R1,D2,X2,B2)              RXY_(0xED,R1,X2,B2,D2,0x65)
  44 /* LOAD ZERO */
  45 #  define LZER(R1)                      RRE_(0xB374,R1,0)
  46 #  define LZDR(R1)                      RRE_(0xB375,R1,0)
  47 #  define LZXR(R1)                      RRE_(0xB376,R1,0)
  48 /* STORE */
  49 #  define STE(R1,D2,X2,B2)              RX_(0x70,R1,X2,B2,D2)
  50 #  define STD(R1,D2,X2,B2)              RX_(0x60,R1,X2,B2,D2)
  51 #  define STEY(R1,D2,X2,B2)             RXY_(0xED,R1,X2,B2,D2,0x66)
  52 #  define STDY(R1,D2,X2,B2)             RXY_(0xED,R1,X2,B2,D2,0x67)
  53 /****************************************************************
  54  * Hexadecimal Floating Point Instructions                      *
  55  ****************************************************************/
  56 /* ADD NORMALIZED */
  57 #  define AER(R1,R2)                    RR_(0x3A,R1,R2)
  58 #  define ADR(R1,R2)                    RR_(0x2A,R1,R2)
  59 #  define AXR(R1,R2)                    RR_(0x36,R1,R2)
  60 #  define AE(R1,D2,X2,B2)               RX_(0x7A,R1,X2,B2,D2)
  61 #  define AD(R1,D2,X2,B2)               RX_(0x6A,R1,X2,B2,D2)
  62 /* ADD UNNORMALIZED */
  63 #  define AUR(R1,R2)                    RR_(0x3E,R1,R2)
  64 #  define AWR(R1,R2)                    RR_(0x2E,R1,R2)
  65 #  define AU(R1,D2,X2,B2)               RX_(0x7E,R1,X2,B2,D2)
  66 #  define AW(R1,D2,X2,B2)               RX_(0x6E,R1,X2,B2,D2)
  67 /* COMPARE */
  68 #  define CER(R1,R2)                    RR_(0x39,R1,R2)
  69 #  define CDR(R1,R2)                    RR_(0x29,R1,R2)
  70 #  define CXR(R1,R2)                    RRE_(0xB369,R1,R2)
  71 #  define CE(R1,D2,X2,B2)               RX_(0x79,R1,X2,B2,D2)
  72 #  define CD(R1,D2,X2,B2)               RX_(0x69,R1,X2,B2,D2)
  73 /* CONVERT FROM FIXED */
  74 #  define CEFR(R1,R2)                   RRE_(0xB3B4,R1,R2)
  75 #  define CDFR(R1,R2)                   RRE_(0xB3B5,R1,R2)
  76 #  define CXFR(R1,R2)                   RRE_(0xB3B6,R1,R2)
  77 #  define CEGR(R1,R2)                   RRE_(0xB3C4,R1,R2)
  78 #  define CDGR(R1,R2)                   RRE_(0xB3C5,R1,R2)
  79 #  define CXGR(R1,R2)                   RRE_(0xB3C6,R1,R2)
  80 /* CONVERT TO FIXED */
  81 #  define CFER(R1,R2)                   RRE_(0xB3B8,R1,R2)
  82 #  define CFDR(R1,R2)                   RRE_(0xB3B9,R1,R2)
  83 #  define CFXR(R1,R2)                   RRE_(0xB3BA,R1,R2)
  84 #  define CGER(R1,R2)                   RRE_(0xB3C8,R1,R2)
  85 #  define CGDR(R1,R2)                   RRE_(0xB3C9,R1,R2)
  86 #  define CGXR(R1,R2)                   RRE_(0xB3CA,R1,R2)
  87 /* DIVIDE */
  88 #  define DER(R1,R2)                    RR_(0x3D,R1,R2)
  89 #  define DDR(R1,R2)                    RR_(0x2D,R1,R2)
  90 #  define DXR(R1,R2)                    RRE_(0xB22D,R1,R2)
  91 #  define DE(R1,D2,X2,B2)               RX_(0x7D,R1,X2,B2,D2)
  92 #  define DD(R1,D2,X2,B2)               RX_(0x6D,R1,X2,B2,D2)
  93 /* HALVE */
  94 #  define HER(R1,R2)                    RR_(0x34,R1,R2)
  95 #  define HDR(R1,R2)                    RR_(0x24,R1,R2)
  96 /* LOAD AND TEST */
  97 #  define LTER(R1,R2)                   RR_(0x32,R1,R2)
  98 #  define LTDR(R1,R2)                   RR_(0x22,R1,R2)
  99 #  define LTXR(R1,R2)                   RRE_(0xB362,R1,R2)
 100 /* LOAD COMPLEMENT */
 101 #  define LCER(R1,R2)                   RR_(0x33,R1,R2)
 102 #  define LCDR(R1,R2)                   RR_(0x23,R1,R2)
 103 #  define LCXR(R1,R2)                   RRE_(0xB363,R1,R2)
 104 /* LOAD FP INTEGER */
 105 #  define FIER(R1,R2)                   RRE_(0xB377,R1,R2)
 106 #  define FIDR(R1,R2)                   RRE_(0xB37F,R1,R2)
 107 #  define FIXR(R1,R2)                   RRE_(0xB367,R1,R2)
 108 /* LOAD LENGHTENED */
 109 #  define LDER(R1,R2)                   RRE_(0xB324,R1,R2)
 110 #  define LXDR(R1,R2)                   RRE_(0xB325,R1,R2)
 111 #  define LXER(R1,R2)                   RRE_(0xB326,R1,R2)
 112 #  define LDE(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x24)
 113 #  define LXD(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x25)
 114 #  define LXE(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x26)
 115 /* LOAD NEGATIVE */
 116 #  define LNER(R1,R2)                   RR_(0x31,R1,R2)
 117 #  define LNDR(R1,R2)                   RR_(0x21,R1,R2)
 118 #  define LNXR(R1,R2)                   RRE_(0xB361,R1,R2)
 119 /* LOAD POSITIVE */
 120 #  define LPER(R1,R2)                   RR_(0x30,R1,R2)
 121 #  define LPDR(R1,R2)                   RR_(0x20,R1,R2)
 122 #  define LPXR(R1,R2)                   RRE_(0xB360,R1,R2)
 123 /* LOAD ROUNDED */
 124 #  define LEDR(R1,R2)                   RR_(0x35,R1,R2)
 125 #  define LDXR(R1,R2)                   RR_(0x25,R1,R2)
 126 #  define LRER(R1,R2)                   LEDR(R1,R2)
 127 #  define LRDR(R1,R2)                   LDXR(R1,R2)
 128 #  define LRXR(R1,R2)                   RRE_(0xB366,R1,R2)
 129 /* MULTIPLY */
 130 #  define MEER(R1,R2)                   RRE_(0xB337,R1,R2)
 131 #  define MDR(R1,R2)                    RR_(0x2C,R1,R2)
 132 #  define MXR(R1,R2)                    RR_(0x26,R1,R2)
 133 #  define MDER(R1,R2)                   RR_(0x3C,R1,R2)
 134 #  define MXDR(R1,R2)                   RR_(0x27,R1,R2)
 135 #  define MER(R1,R2)                    MDER(R1,R2)
 136 #  define MEE(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x37)
 137 #  define MD(R1,D2,X2,B2)               RX_(0x6C,R1,X2,B2,D2)
 138 #  define MDE(R1,D2,X2,B2)              RX_(0x7C,R1,X2,B2,D2)
 139 #  define MXD(R1,D2,X2,B2)              RX_(0x67,R1,X2,B2,D2)
 140 #  define ME(R1,D2,X2,B2)               MDE(R1,D2,X2,B2)
 141 /* MULTIPLY AND ADD */
 142 #  define MAER(R1,R3,R2)                RRF_(0xB32E,R1,0,R3,R2)
 143 #  define MADR(R1,R3,R2)                RRF_(0xB33E,R1,0,R3,R2)
 144 #  define MAE(R1,R3,D2,X2,B2)           RXF_(0xED,R3,X2,B2,D2,R1,0x2E)
 145 #  define MAD(R1,R3,D2,X2,B2)           RXF_(0xED,R3,X2,B2,D2,R1,0x3E)
 146 /* MULTIPLY AND SUBTRACT */
 147 #  define MSER(R1,R3,R2)                RRF_(0xB32F,R1,0,R3,R2)
 148 #  define MSDR(R1,R3,R2)                RRF_(0xB33F,R1,0,R3,R2)
 149 #  define MSE(R1,R3,D2,X2,B2)           RXF_(0xED,R3,X2,B2,D2,R1,0x2F)
 150 #  define MSD(R1,R3,D2,X2,B2)           RXF_(0xED,R3,X2,B2,D2,R1,0x3F)
 151 /* SQUARE ROOT */
 152 #  define SQER(R1,R2)                   RRE_(0xB245,R1,R2)
 153 #  define SQDR(R1,R2)                   RRE_(0xB244,R1,R2)
 154 #  define SQXR(R1,R2)                   RRE_(0xB336,R1,R2)
 155 #  define SQE(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x34)
 156 #  define SQD(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x35)
 157 /* SUBTRACT NORMALIZED */
 158 #  define SER(R1,R2)                    RR_(0x3B,R1,R2)
 159 #  define SDR(R1,R2)                    RR_(0x2B,R1,R2)
 160 #  define SXR(R1,R2)                    RR_(0x37,R1,R2)
 161 #  define SE(R1,D2,X2,B2)               RX_(0x7B,R1,X2,B2,D2)
 162 #  define SD(R1,D2,X2,B2)               RX_(0x6B,R1,X2,B2,D2)
 163 /* SUBTRACT UNNORMALIZED */
 164 #  define SUR(R1,R2)                    RR_(0x3F,R1,R2)
 165 #  define SWR(R1,R2)                    RR_(0x2F,R1,R2)
 166 #  define SU(R1,D2,X2,B2)               RX_(0x7F,R1,X2,B2,D2)
 167 #  define SW(R1,D2,X2,B2)               RX_(0x6F,R1,X2,B2,D2)
 168 /****************************************************************
 169  * Binary Floating Point Instructions                           *
 170  ****************************************************************/
 171 /* ADD */
 172 #  define AEBR(R1,R2)                   RRE_(0xB30A,R1,R2)
 173 #  define ADBR(R1,R2)                   RRE_(0xB31A,R1,R2)
 174 #  define AXBR(R1,R2)                   RRE_(0xB34A,R1,R2)
 175 #  define AEB(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x0A)
 176 #  define ADB(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x1A)
 177 /* COMPARE */
 178 #  define CEBR(R1,R2)                   RRE_(0xB309,R1,R2)
 179 #  define CDBR(R1,R2)                   RRE_(0xB319,R1,R2)
 180 #  define CXBR(R1,R2)                   RRE_(0xB349,R1,R2)
 181 #  define CEB(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x09)
 182 #  define CDB(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x19)
 183 /* COMPARE AND SIGNAL */
 184 #  define KEBR(R1,R2)                   RRE_(0xB308,R1,R2)
 185 #  define KDBR(R1,R2)                   RRE_(0xB318,R1,R2)
 186 #  define KXBR(R1,R2)                   RRE_(0xB348,R1,R2)
 187 #  define KEB(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x08)
 188 #  define KDB(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x18)
 189 /* CONVERT FROM FIXED */
 190 #  define CEFBR(R1,R2)                  RRE_(0xB394,R1,R2)
 191 #  define CDFBR(R1,R2)                  RRE_(0xB395,R1,R2)
 192 #  define CXFBR(R1,R2)                  RRE_(0xB396,R1,R2)
 193 #  define CEGBR(R1,R2)                  RRE_(0xB3A4,R1,R2)
 194 #  define CDGBR(R1,R2)                  RRE_(0xB3A5,R1,R2)
 195 #  define CXGBR(R1,R2)                  RRE_(0xB3A6,R1,R2)
 196 /* CONVERT TO FIXED */
 197 #  define CFEBR(R1,M3,R2)               RRF_(0xB398,M3,0,R1,R2)
 198 #  define CFDBR(R1,M3,R2)               RRF_(0xB399,M3,0,R1,R2)
 199 #  define CFXBR(R1,M3,R2)               RRF_(0xB39A,M3,0,R1,R2)
 200 #  define CGEBR(R1,M3,R2)               RRF_(0xB3A8,M3,0,R1,R2)
 201 #  define CGDBR(R1,M3,R2)               RRF_(0xB3A9,M3,0,R1,R2)
 202 #  define CGXBR(R1,M3,R2)               RRF_(0xB3AA,M3,0,R1,R2)
 203 /* DIVIDE */
 204 #  define DEBR(R1,R2)                   RRE_(0xB30D,R1,R2)
 205 #  define DDBR(R1,R2)                   RRE_(0xB31D,R1,R2)
 206 #  define DXBR(R1,R2)                   RRE_(0xB34D,R1,R2)
 207 #  define DEB(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x0D)
 208 #  define DDB(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x1D)
 209 /* DIVIDE TO INTEGER */
 210 #  define DIEBR(R1,R3,R2,M4)            RRF_(0xB353,R3,M4,R1,R2)
 211 #  define DIDBR(R1,R3,R2,M4)            RRF_(0xB35B,R3,M4,R1,R2)
 212 /* EXTRACT FPC */
 213 #  define EFPC(R1)                      RRE_(0xB38C,R1,0)
 214 /* LOAD AND TEST */
 215 #  define LTEBR(R1,R2)                  RRE_(0xB302,R1,R2)
 216 #  define LTDBR(R1,R2)                  RRE_(0xB312,R1,R2)
 217 #  define LTXBR(R1,R2)                  RRE_(0xB342,R1,R2)
 218 /* LOAD COMPLEMENT */
 219 #  define LCEBR(R1,R2)                  RRE_(0xB303,R1,R2)
 220 #  define LCDBR(R1,R2)                  RRE_(0xB313,R1,R2)
 221 #  define LCXBR(R1,R2)                  RRE_(0xB343,R1,R2)
 222 /* LOAD FP INTEGER */
 223 #  define FIEBR(R1,M3,R2)               RRF_(0xB357,M3,0,R1,R2)
 224 #  define FIDBR(R1,M3,R2)               RRF_(0xB35F,M3,0,R1,R2)
 225 #  define FIXBR(R1,M3,R2)               RRF_(0xB347,M3,0,R1,R2)
 226 /* LOAD FPC */
 227 #  define LFPC(D2,B2)                   S_(0xB29D,B2,D2)
 228 /* LOAD LENGTHENED */
 229 #  define LDEBR(R1,R2)                  RRE_(0xB304,R1,R2)
 230 #  define LXDBR(R1,R2)                  RRE_(0xB305,R1,R2)
 231 #  define LXEBR(R1,R2)                  RRE_(0xB306,R1,R2)
 232 #  define LDEB(R1,D2,X2,B2)             RXE_(0xED,R1,X2,B2,D2,0x04)
 233 #  define LXDB(R1,D2,X2,B2)             RXE_(0xED,R1,X2,B2,D2,0x05)
 234 #  define LXEB(R1,D2,X2,B2)             RXE_(0xED,R1,X2,B2,D2,0x06)
 235 /* LOAD NEGATIVE */
 236 #  define LNEBR(R1,R2)                  RRE_(0xB301,R1,R2)
 237 #  define LNDBR(R1,R2)                  RRE_(0xB311,R1,R2)
 238 #  define LNXBR(R1,R2)                  RRE_(0xB341,R1,R2)
 239 /* LOAD POSITIVE */
 240 #  define LPEBR(R1,R2)                  RRE_(0xB300,R1,R2)
 241 #  define LPDBR(R1,R2)                  RRE_(0xB310,R1,R2)
 242 #  define LPXBR(R1,R2)                  RRE_(0xB340,R1,R2)
 243 /* LOAD ROUNDED */
 244 #  define LEDBR(R1,R2)                  RRE_(0xB344,R1,R2)
 245 #  define LDXBR(R1,R2)                  RRE_(0xB345,R1,R2)
 246 #  define LEXBR(R1,R2)                  RRE_(0xB346,R1,R2)
 247 /* MULTIPLY */
 248 #  define MEEBR(R1,R2)                  RRE_(0xB317,R1,R2)
 249 #  define MDBR(R1,R2)                   RRE_(0xB31C,R1,R2)
 250 #  define MXBR(R1,R2)                   RRE_(0xB34C,R1,R2)
 251 #  define MDEBR(R1,R2)                  RRE_(0xB30C,R1,R2)
 252 #  define MXDBR(R1,R2)                  RRE_(0xB307,R1,R2)
 253 #  define MEEB(R1,D2,X2,B2)             RXE_(0xED,R1,X2,B2,D2,0x17)
 254 #  define MDB(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x1C)
 255 #  define MDEB(R1,D2,X2,B2)             RXE_(0xED,R1,X2,B2,D2,0x0C)
 256 #  define MXDB(R1,D2,X2,B2)             RXE_(0xED,R1,X2,B2,D2,0x07)
 257 /* MULTIPLY AND ADD */
 258 #  define MAEBR(R1,R3,R2)               RRF_(0xB30E,R1,0,R3,R2)
 259 #  define MADBR(R1,R3,R2)               RRF_(0xB31E,R1,0,R3,R2)
 260 #  define MAEB(R1,R3,D2,X2,B2)          RXF_(0xED,R3,X2,B2,D2,R1,0x0E)
 261 #  define MADB(R1,R3,D2,X2,B2)          RXF_(0xED,R3,X2,B2,D2,R1,0x1E)
 262 /* MULTIPLY AND SUBTRACT */
 263 #  define MSEBR(R1,R3,R2)               RRF_(0xB30F,R1,0,R3,R2)
 264 #  define MSDBR(R1,R3,R2)               RRF_(0xB31F,R1,0,R3,R2)
 265 #  define MSEB(R1,R3,D2,X2,B2)          RXF_(0xED,R3,X2,B2,D2,R1,0x0F)
 266 #  define MSDB(R1,R3,D2,X2,B2)          RXF_(0xED,R3,X2,B2,D2,R1,0x1F)
 267 /* SET FPC */
 268 #  define SFPC(R1)                      RRE_(0xB384,R1,0)
 269 /* SET ROUNDING MODE */
 270 #  define SRNM(D2,B2)                   S_(0xB299,B2,D2)
 271 /* SQUARE ROOT */
 272 #  define SQEBR(R1,R2)                  RRE_(0xB314,R1,R2)
 273 #  define SQDBR(R1,R2)                  RRE_(0xB315,R1,R2)
 274 #  define SQXBR(R1,R2)                  RRE_(0xB316,R1,R2)
 275 /* STORE FPC */
 276 #  define STFPC(D2,B2)                  S_(0xB29C,B2,D2)
 277 /* SUBTRACT */
 278 #  define SEBR(R1,R2)                   RRE_(0xB30B,R1,R2)
 279 #  define SDBR(R1,R2)                   RRE_(0xB31B,R1,R2)
 280 #  define SXBR(R1,R2)                   RRE_(0xB34B,R1,R2)
 281 #  define SEB(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x0B)
 282 #  define SDB(R1,D2,X2,B2)              RXE_(0xED,R1,X2,B2,D2,0x1B)
 283 /* TEST DATA CLASS */
 284 #  define TCEB(R1,D2,X2,B2)             RXE_(0xED,R1,X2,B2,D2,0x10)
 285 #  define TCDB(R1,D2,X2,B2)             RXE_(0xED,R1,X2,B2,D2,0x11)
 286 #  define TCXB(R1,D2,X2,B2)             RXE_(0xED,R1,X2,B2,D2,0x12)
 287 #  define fp(code,r0,r1,i0)             _fp(_jit,jit_code_##code##i_f,r0,r1,i0)
 288 static void _fp(jit_state_t*,jit_code_t,
 289                 jit_int32_t,jit_int32_t,jit_float32_t*);
 290 #  define dp(code,r0,r1,i0)             _dp(_jit,jit_code_##code##i_d,r0,r1,i0)
 291 static void _dp(jit_state_t*,jit_code_t,
 292                 jit_int32_t,jit_int32_t,jit_float64_t*);
 293 #  define fr(cc,r0,r1,r2)               _fr(_jit,cc,r0,r1,r2)
 294 static void _fr(jit_state_t*,jit_int32_t,
 295                 jit_int32_t,jit_int32_t,jit_int32_t);
 296 #  define dr(cc,r0,r1,r2)               _dr(_jit,cc,r0,r1,r2)
 297 static void _dr(jit_state_t*,jit_int32_t,
 298                 jit_int32_t,jit_int32_t,jit_int32_t);
 299 #  define fi(cc,r0,r1,i0)               _fi(_jit,cc,r0,r1,i0)
 300 static void _fi(jit_state_t*,jit_int32_t,
 301                 jit_int32_t,jit_int32_t,jit_float32_t*);
 302 #  define di(cc,r0,r1,i0)               _di(_jit,cc,r0,r1,i0)
 303 static void _di(jit_state_t*,jit_int32_t,
 304                 jit_int32_t,jit_int32_t,jit_float64_t*);
 305 #  define bfr(cc,i0,r0,r1)              _bfr(_jit,cc,i0,r0,r1)
 306 static void _bfr(jit_state_t*,jit_int32_t,
 307                  jit_word_t,jit_int32_t,jit_int32_t);
 308 #  define bdr(cc,i0,r0,r1)              _bdr(_jit,cc,i0,r0,r1)
 309 static void _bdr(jit_state_t*,jit_int32_t,
 310                  jit_word_t,jit_int32_t,jit_int32_t);
 311 #  define bfr_p(cc,i0,r0,r1)            _bfr_p(_jit,cc,i0,r0,r1)
 312 static jit_word_t _bfr_p(jit_state_t*,jit_int32_t,
 313                          jit_word_t,jit_int32_t,jit_int32_t);
 314 #  define bdr_p(cc,i0,r0,r1)            _bdr_p(_jit,cc,i0,r0,r1)
 315 static jit_word_t _bdr_p(jit_state_t*,jit_int32_t,
 316                          jit_word_t,jit_int32_t,jit_int32_t);
 317 #  define bfi(cc,i0,r0,i1)              _bfi(_jit,cc,i0,r0,i1)
 318 static void _bfi(jit_state_t*,jit_int32_t,
 319                  jit_word_t,jit_int32_t,jit_float32_t*);
 320 #  define bdi(cc,i0,r0,i1)              _bdi(_jit,cc,i0,r0,i1)
 321 static void _bdi(jit_state_t*,jit_int32_t,
 322                  jit_word_t,jit_int32_t,jit_float64_t*);
 323 #  define bfi_p(cc,i0,r0,i1)            _bfi_p(_jit,cc,i0,r0,i1)
 324 static jit_word_t _bfi_p(jit_state_t*,jit_int32_t,
 325                          jit_word_t,jit_int32_t,jit_float32_t*);
 326 #  define bdi_p(cc,i0,r0,i1)            _bdi_p(_jit,cc,i0,r0,i1)
 327 static jit_word_t _bdi_p(jit_state_t*,jit_int32_t,
 328                          jit_word_t,jit_int32_t,jit_float64_t*);
 329 #  define buneqr(db,i0,r0,r1)           _buneqr(_jit,db,i0,r0,r1)
 330 static jit_word_t _buneqr(jit_state_t*,jit_int32_t,
 331                           jit_word_t,jit_int32_t,jit_int32_t);
 332 #  define buneqi(db,i0,r0,i1)           _buneqi(_jit,db,i0,r0,(jit_word_t)i1)
 333 static jit_word_t _buneqi(jit_state_t*,jit_int32_t,
 334                           jit_word_t,jit_int32_t,jit_word_t);
 335 #  define bltgtr(db,i0,r0,r1)           _bltgtr(_jit,db,i0,r0,r1)
 336 static jit_word_t _bltgtr(jit_state_t*,jit_int32_t,
 337                           jit_word_t,jit_int32_t,jit_int32_t);
 338 #  define bltgti(db,i0,r0,i1)           _bltgti(_jit,db,i0,r0,(jit_word_t)i1)
 339 static jit_word_t _bltgti(jit_state_t*,jit_int32_t,
 340                           jit_word_t,jit_int32_t,jit_word_t);
 341 #  define movr_f(r0,r1)                 _movr_f(_jit,r0,r1)
 342 static void _movr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 343 #  define movi_f(r0,i0)                 _movi_f(_jit,r0,i0)
 344 static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*);
 345 #define movi_w_f(r0, i0)                _movi_w_f(_jit, r0, i0)
 346 static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t);
 347 #  define movr_d(r0,r1)                 _movr_d(_jit,r0,r1)
 348 static void _movr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 349 #  define movi_d(r0,i0)                 _movi_d(_jit,r0,i0)
 350 static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*);
 351 #  define absr_f(r0,r1)                 LPEBR(r0,r1)
 352 #  define absr_d(r0,r1)                 LPDBR(r0,r1)
 353 #  define negr_f(r0,r1)                 LCEBR(r0,r1)
 354 #  define negr_d(r0,r1)                 LCDBR(r0,r1)
 355 #  define sqrtr_f(r0,r1)                SQEBR(r0,r1)
 356 #  define fmar_f(r0,r1,r2,r3)           _fmar_f(_jit,r0,r1,r2,r3)
 357 static void _fmar_f(jit_state_t*,
 358                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 359 #  define fmsr_f(r0,r1,r2,r3)           _fmsr_f(_jit,r0,r1,r2,r3)
 360 static void _fmsr_f(jit_state_t*,
 361                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 362 #  define fnmar_f(r0,r1,r2,r3)          _fnmar_f(_jit,r0,r1,r2,r3)
 363 static void _fnmar_f(jit_state_t*,
 364                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 365 #  define fnmsr_f(r0,r1,r2,r3)          _fnmsr_f(_jit,r0,r1,r2,r3)
 366 static void _fnmsr_f(jit_state_t*,
 367                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 368 #  define sqrtr_d(r0,r1)                SQDBR(r0,r1)
 369 #  define fmar_d(r0,r1,r2,r3)           _fmar_d(_jit,r0,r1,r2,r3)
 370 static void _fmar_d(jit_state_t*,
 371                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 372 #  define fmsr_d(r0,r1,r2,r3)           _fmsr_d(_jit,r0,r1,r2,r3)
 373 static void _fmsr_d(jit_state_t*,
 374                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 375 #  define fnmar_d(r0,r1,r2,r3)          _fnmar_d(_jit,r0,r1,r2,r3)
 376 static void _fnmar_d(jit_state_t*,
 377                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 378 #  define fnmsr_d(r0,r1,r2,r3)          _fnmsr_d(_jit,r0,r1,r2,r3)
 379 static void _fnmsr_d(jit_state_t*,
 380                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 381 #  define truncr_f_i(r0,r1)             CFEBR(r0,RND_ZERO,r1)
 382 #  define truncr_d_i(r0,r1)             CFDBR(r0,RND_ZERO,r1)
 383 #  if __WORDSIZE == 64
 384 #    define truncr_f_l(r0,r1)           CGEBR(r0,RND_ZERO,r1)
 385 #    define truncr_d_l(r0,r1)           CGDBR(r0,RND_ZERO,r1)
 386 #  endif
 387 #  if __WORDSIZE == 32
 388 #    define extr_f(r0,r1)               CEFBR(r0,r1)
 389 #    define extr_d(r0,r1)               CDFBR(r0,r1)
 390 #    define movi_ww_d(r0, i0, i1)       _movi_ww_d(_jit, r0, i0, i1)
 391 static void _movi_ww_d(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t);
 392 #  else
 393 #    define extr_f(r0,r1)               CEGBR(r0,r1)
 394 #    define extr_d(r0,r1)               CDGBR(r0,r1)
 395 #    define movi_w_d(r0, i0)            _movi_w_d(_jit, r0, i0)
 396 static void _movi_w_d(jit_state_t*, jit_int32_t, jit_word_t);
 397 #  endif
 398 #  define extr_d_f(r0,r1)               LEDBR(r0,r1)
 399 #  define extr_f_d(r0,r1)               LDEBR(r0,r1)
 400 #  define addr_f(r0,r1,r2)              _addr_f(_jit,r0,r1,r2)
 401 static void _addr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 402 #  define addi_f(r0,r1,i0)              fp(add,r0,r1,i0)
 403 #  define addr_d(r0,r1,r2)              _addr_d(_jit,r0,r1,r2)
 404 static void _addr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 405 #  define addi_d(r0,r1,i0)              dp(add,r0,r1,i0)
 406 #  define subr_f(r0,r1,r2)              _subr_f(_jit,r0,r1,r2)
 407 static void _subr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 408 #  define subi_f(r0,r1,i0)              fp(sub,r0,r1,i0)
 409 #  define subr_d(r0,r1,r2)              _subr_d(_jit,r0,r1,r2)
 410 static void _subr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 411 #  define subi_d(r0,r1,i0)              dp(sub,r0,r1,i0)
 412 #  define rsbr_f(r0,r1,r2)              subr_f(r0,r2,r1)
 413 #  define rsbi_f(r0,r1,i0)              fp(rsb,r0,r1,i0)
 414 #  define rsbr_d(r0,r1,r2)              subr_d(r0,r2,r1)
 415 #  define rsbi_d(r0,r1,i0)              dp(rsb,r0,r1,i0)
 416 #  define mulr_f(r0,r1,r2)              _mulr_f(_jit,r0,r1,r2)
 417 static void _mulr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 418 #  define muli_f(r0,r1,i0)              fp(mul,r0,r1,i0)
 419 #  define mulr_d(r0,r1,r2)              _mulr_d(_jit,r0,r1,r2)
 420 static void _mulr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 421 #  define muli_d(r0,r1,i0)              dp(mul,r0,r1,i0)
 422 #  define divr_f(r0,r1,r2)              _divr_f(_jit,r0,r1,r2)
 423 static void _divr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 424 #  define divi_f(r0,r1,i0)              fp(div,r0,r1,i0)
 425 #  define divr_d(r0,r1,r2)              _divr_d(_jit,r0,r1,r2)
 426 static void _divr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 427 #  define divi_d(r0,r1,i0)              dp(div,r0,r1,i0)
 428 #  define ldr_f(r0,r1)                  LE(r0,0,0,r1)
 429 #  define ldr_d(r0,r1)                  LD(r0,0,0,r1)
 430 #  define ldi_f(r0,i0)                  _ldi_f(_jit,r0,i0)
 431 static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
 432 #  define ldi_d(r0,i0)                  _ldi_d(_jit,r0,i0)
 433 static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
 434 #  define ldxr_f(r0,r1,r2)              _ldxr_f(_jit,r0,r1,r2)
 435 static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 436 #  define ldxr_d(r0,r1,r2)              _ldxr_d(_jit,r0,r1,r2)
 437 static void _ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 438 #  define ldxi_f(r0,r1,i0)              _ldxi_f(_jit,r0,r1,i0)
 439 static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 440 #  define ldxi_d(r0,r1,i0)              _ldxi_d(_jit,r0,r1,i0)
 441 static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 442 #  define str_f(r0,r1)                  STE(r1,0,0,r0)
 443 #  define str_d(r0,r1)                  STD(r1,0,0,r0)
 444 #  define sti_f(i0,r0)                  _sti_f(_jit,i0,r0)
 445 static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
 446 #  define sti_d(i0,r0)                  _sti_d(_jit,i0,r0)
 447 static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
 448 #  define stxr_f(r0,r1,r2)              _stxr_f(_jit,r0,r1,r2)
 449 static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 450 #  define stxr_d(r0,r1,r2)              _stxr_d(_jit,r0,r1,r2)
 451 static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 452 #  define stxi_f(i0,r0,r1)              _stxi_f(_jit,i0,r0,r1)
 453 static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 454 #  define stxi_d(i0,r0,r1)              _stxi_d(_jit,i0,r0,r1)
 455 static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 456 #  define ltr_f(r0,r1,r2)               fr(CC_L,r0,r1,r2)
 457 #  define ltr_d(r0,r1,r2)               dr(CC_L,r0,r1,r2)
 458 #  define lti_f(r0,r1,i0)               fi(CC_L,r0,r1,i0)
 459 #  define lti_d(r0,r1,i0)               di(CC_L,r0,r1,i0)
 460 #  define ler_f(r0,r1,r2)               fr(CC_LE,r0,r1,r2)
 461 #  define ler_d(r0,r1,r2)               dr(CC_LE,r0,r1,r2)
 462 #  define lei_f(r0,r1,i0)               fi(CC_LE,r0,r1,i0)
 463 #  define lei_d(r0,r1,i0)               di(CC_LE,r0,r1,i0)
 464 #  define eqr_f(r0,r1,r2)               fr(CC_E,r0,r1,r2)
 465 #  define eqr_d(r0,r1,r2)               dr(CC_E,r0,r1,r2)
 466 #  define eqi_f(r0,r1,i0)               fi(CC_E,r0,r1,i0)
 467 #  define eqi_d(r0,r1,i0)               di(CC_E,r0,r1,i0)
 468 #  define ger_f(r0,r1,r2)               fr(CC_HE,r0,r1,r2)
 469 #  define ger_d(r0,r1,r2)               dr(CC_HE,r0,r1,r2)
 470 #  define gei_f(r0,r1,i0)               fi(CC_HE,r0,r1,i0)
 471 #  define gei_d(r0,r1,i0)               di(CC_HE,r0,r1,i0)
 472 #  define gtr_f(r0,r1,r2)               fr(CC_H,r0,r1,r2)
 473 #  define gtr_d(r0,r1,r2)               dr(CC_H,r0,r1,r2)
 474 #  define gti_f(r0,r1,i0)               fi(CC_H,r0,r1,i0)
 475 #  define gti_d(r0,r1,i0)               di(CC_H,r0,r1,i0)
 476 #  define ner_f(r0,r1,r2)               fr(CC_NE,r0,r1,r2)
 477 #  define ner_d(r0,r1,r2)               dr(CC_NE,r0,r1,r2)
 478 #  define nei_f(r0,r1,i0)               fi(CC_NE,r0,r1,i0)
 479 #  define nei_d(r0,r1,i0)               di(CC_NE,r0,r1,i0)
 480 #  define unltr_f(r0,r1,r2)             fr(CC_NHE,r0,r1,r2)
 481 #  define unltr_d(r0,r1,r2)             dr(CC_NHE,r0,r1,r2)
 482 #  define unlti_f(r0,r1,i0)             fi(CC_NHE,r0,r1,i0)
 483 #  define unlti_d(r0,r1,i0)             di(CC_NHE,r0,r1,i0)
 484 #  define unler_f(r0,r1,r2)             fr(CC_NH,r0,r1,r2)
 485 #  define unler_d(r0,r1,r2)             dr(CC_NH,r0,r1,r2)
 486 #  define unlei_f(r0,r1,i0)             fi(CC_NH,r0,r1,i0)
 487 #  define unlei_d(r0,r1,i0)             di(CC_NH,r0,r1,i0)
 488 #  define uneqr_f(r0,r1,r2)             _uneqr_f(_jit,r0,r1,r2)
 489 static void _uneqr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 490 #  define uneqr_d(r0,r1,r2)             _uneqr_d(_jit,r0,r1,r2)
 491 static void _uneqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 492 #  define uneqi_f(r0,r1,i0)             fp(uneq,r0,r1,i0)
 493 #  define uneqi_d(r0,r1,i0)             dp(uneq,r0,r1,i0)
 494 #  define unger_f(r0,r1,r2)             fr(CC_NL,r0,r1,r2)
 495 #  define unger_d(r0,r1,r2)             dr(CC_NL,r0,r1,r2)
 496 #  define ungei_f(r0,r1,i0)             fi(CC_NL,r0,r1,i0)
 497 #  define ungei_d(r0,r1,i0)             di(CC_NL,r0,r1,i0)
 498 #  define ungtr_f(r0,r1,r2)             fr(CC_NLE,r0,r1,r2)
 499 #  define ungtr_d(r0,r1,r2)             dr(CC_NLE,r0,r1,r2)
 500 #  define ungti_f(r0,r1,i0)             fi(CC_NLE,r0,r1,i0)
 501 #  define ungti_d(r0,r1,i0)             di(CC_NLE,r0,r1,i0)
 502 #  define ltgtr_f(r0,r1,r2)             _ltgtr_f(_jit,r0,r1,r2)
 503 static void _ltgtr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 504 #  define ltgtr_d(r0,r1,r2)             _ltgtr_d(_jit,r0,r1,r2)
 505 static void _ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 506 #  define ltgti_f(r0,r1,i0)             fp(ltgt,r0,r1,i0)
 507 #  define ltgti_d(r0,r1,i0)             dp(ltgt,r0,r1,i0)
 508 #  define ordr_f(r0,r1,r2)              fr(CC_NO,r0,r1,r2)
 509 #  define ordr_d(r0,r1,r2)              dr(CC_NO,r0,r1,r2)
 510 #  define ordi_f(r0,r1,i0)              fi(CC_NO,r0,r1,i0)
 511 #  define ordi_d(r0,r1,i0)              di(CC_NO,r0,r1,i0)
 512 #  define unordr_f(r0,r1,r2)            fr(CC_O,r0,r1,r2)
 513 #  define unordr_d(r0,r1,r2)            dr(CC_O,r0,r1,r2)
 514 #  define unordi_f(r0,r1,i0)            fi(CC_O,r0,r1,i0)
 515 #  define unordi_d(r0,r1,i0)            di(CC_O,r0,r1,i0)
 516 #  define bltr_f(i0,r0,r1)              bfr(CC_L,i0,r0,r1)
 517 #  define bltr_d(i0,r0,r1)              bdr(CC_L,i0,r0,r1)
 518 #  define blti_f(i0,r0,i1)              bfi(CC_L,i0,r0,i1)
 519 #  define blti_d(i0,r0,i1)              bdi(CC_L,i0,r0,i1)
 520 #  define bltr_f_p(i0,r0,r1)            bfr_p(CC_L,i0,r0,r1)
 521 #  define bltr_d_p(i0,r0,r1)            bdr_p(CC_L,i0,r0,r1)
 522 #  define blti_f_p(i0,r0,i1)            bfi_p(CC_L,i0,r0,i1)
 523 #  define blti_d_p(i0,r0,i1)            bdi_p(CC_L,i0,r0,i1)
 524 #  define bler_f(i0,r0,r1)              bfr(CC_LE,i0,r0,r1)
 525 #  define bler_d(i0,r0,r1)              bdr(CC_LE,i0,r0,r1)
 526 #  define blei_f(i0,r0,i1)              bfi(CC_LE,i0,r0,i1)
 527 #  define blei_d(i0,r0,i1)              bdi(CC_LE,i0,r0,i1)
 528 #  define bler_f_p(i0,r0,r1)            bfr_p(CC_LE,i0,r0,r1)
 529 #  define bler_d_p(i0,r0,r1)            bdr_p(CC_LE,i0,r0,r1)
 530 #  define blei_f_p(i0,r0,i1)            bfi_p(CC_LE,i0,r0,i1)
 531 #  define blei_d_p(i0,r0,i1)            bdi_p(CC_LE,i0,r0,i1)
 532 #  define beqr_f(i0,r0,r1)              bfr(CC_E,i0,r0,r1)
 533 #  define beqr_d(i0,r0,r1)              bdr(CC_E,i0,r0,r1)
 534 #  define beqi_f(i0,r0,i1)              bfi(CC_E,i0,r0,i1)
 535 #  define beqi_d(i0,r0,i1)              bdi(CC_E,i0,r0,i1)
 536 #  define beqr_f_p(i0,r0,r1)            bfr_p(CC_E,i0,r0,r1)
 537 #  define beqr_d_p(i0,r0,r1)            bdr_p(CC_E,i0,r0,r1)
 538 #  define beqi_f_p(i0,r0,i1)            bfi_p(CC_E,i0,r0,i1)
 539 #  define beqi_d_p(i0,r0,i1)            bdi_p(CC_E,i0,r0,i1)
 540 #  define bger_f(i0,r0,r1)              bfr(CC_HE,i0,r0,r1)
 541 #  define bger_d(i0,r0,r1)              bdr(CC_HE,i0,r0,r1)
 542 #  define bgei_f(i0,r0,i1)              bfi(CC_HE,i0,r0,i1)
 543 #  define bgei_d(i0,r0,i1)              bdi(CC_HE,i0,r0,i1)
 544 #  define bger_f_p(i0,r0,r1)            bfr_p(CC_HE,i0,r0,r1)
 545 #  define bger_d_p(i0,r0,r1)            bdr_p(CC_HE,i0,r0,r1)
 546 #  define bgei_f_p(i0,r0,i1)            bfi_p(CC_HE,i0,r0,i1)
 547 #  define bgei_d_p(i0,r0,i1)            bdi_p(CC_HE,i0,r0,i1)
 548 #  define bgtr_f(i0,r0,r1)              bfr(CC_H,i0,r0,r1)
 549 #  define bgtr_d(i0,r0,r1)              bdr(CC_H,i0,r0,r1)
 550 #  define bgti_f(i0,r0,i1)              bfi(CC_H,i0,r0,i1)
 551 #  define bgti_d(i0,r0,i1)              bdi(CC_H,i0,r0,i1)
 552 #  define bgtr_f_p(i0,r0,r1)            bfr_p(CC_H,i0,r0,r1)
 553 #  define bgtr_d_p(i0,r0,r1)            bdr_p(CC_H,i0,r0,r1)
 554 #  define bgti_f_p(i0,r0,i1)            bfi_p(CC_H,i0,r0,i1)
 555 #  define bgti_d_p(i0,r0,i1)            bdi_p(CC_H,i0,r0,i1)
 556 #  define bner_f(i0,r0,r1)              bfr(CC_NE,i0,r0,r1)
 557 #  define bner_d(i0,r0,r1)              bdr(CC_NE,i0,r0,r1)
 558 #  define bnei_f(i0,r0,i1)              bfi(CC_NE,i0,r0,i1)
 559 #  define bnei_d(i0,r0,i1)              bdi(CC_NE,i0,r0,i1)
 560 #  define bner_f_p(i0,r0,r1)            bfr_p(CC_NE,i0,r0,r1)
 561 #  define bner_d_p(i0,r0,r1)            bdr_p(CC_NE,i0,r0,r1)
 562 #  define bnei_f_p(i0,r0,i1)            bfi_p(CC_NE,i0,r0,i1)
 563 #  define bnei_d_p(i0,r0,i1)            bdi_p(CC_NE,i0,r0,i1)
 564 #  define bunltr_f(i0,r0,r1)            bfr(CC_NHE,i0,r0,r1)
 565 #  define bunltr_d(i0,r0,r1)            bdr(CC_NHE,i0,r0,r1)
 566 #  define bunlti_f(i0,r0,i1)            bfi(CC_NHE,i0,r0,i1)
 567 #  define bunlti_d(i0,r0,i1)            bdi(CC_NHE,i0,r0,i1)
 568 #  define bunltr_f_p(i0,r0,r1)          bfr_p(CC_NHE,i0,r0,r1)
 569 #  define bunltr_d_p(i0,r0,r1)          bdr_p(CC_NHE,i0,r0,r1)
 570 #  define bunlti_f_p(i0,r0,i1)          bfi_p(CC_NHE,i0,r0,i1)
 571 #  define bunlti_d_p(i0,r0,i1)          bdi_p(CC_NHE,i0,r0,i1)
 572 #  define bunler_f(i0,r0,r1)            bfr(CC_NH,i0,r0,r1)
 573 #  define bunler_d(i0,r0,r1)            bdr(CC_NH,i0,r0,r1)
 574 #  define bunlei_f(i0,r0,i1)            bfi(CC_NH,i0,r0,i1)
 575 #  define bunlei_d(i0,r0,i1)            bdi(CC_NH,i0,r0,i1)
 576 #  define bunler_f_p(i0,r0,r1)          bfr_p(CC_NH,i0,r0,r1)
 577 #  define bunler_d_p(i0,r0,r1)          bdr_p(CC_NH,i0,r0,r1)
 578 #  define bunlei_f_p(i0,r0,i1)          bfi_p(CC_NH,i0,r0,i1)
 579 #  define bunlei_d_p(i0,r0,i1)          bdi_p(CC_NH,i0,r0,i1)
 580 #  define buneqr_f(i0,r0,r1)            buneqr(0,i0,r0,r1)
 581 #  define buneqr_d(i0,r0,r1)            buneqr(1,i0,r0,r1)
 582 #  define buneqi_f(i0,r0,i1)            buneqi(0,i0,r0,i1)
 583 #  define buneqi_d(i0,r0,i1)            buneqi(1,i0,r0,i1)
 584 #  define buneqr_f_p(i0,r0,r1)          buneqr(0,i0,r0,r1)
 585 #  define buneqr_d_p(i0,r0,r1)          buneqr(1,i0,r0,r1)
 586 #  define buneqi_f_p(i0,r0,i1)          buneqi(0,i0,r0,i1)
 587 #  define buneqi_d_p(i0,r0,i1)          buneqi(1,i0,r0,i1)
 588 #  define bunger_f(i0,r0,r1)            bfr(CC_NL,i0,r0,r1)
 589 #  define bunger_d(i0,r0,r1)            bdr(CC_NL,i0,r0,r1)
 590 #  define bungei_f(i0,r0,i1)            bfi(CC_NL,i0,r0,i1)
 591 #  define bungei_d(i0,r0,i1)            bdi(CC_NL,i0,r0,i1)
 592 #  define bunger_f_p(i0,r0,r1)          bfr_p(CC_NL,i0,r0,r1)
 593 #  define bunger_d_p(i0,r0,r1)          bdr_p(CC_NL,i0,r0,r1)
 594 #  define bungei_f_p(i0,r0,i1)          bfi_p(CC_NL,i0,r0,i1)
 595 #  define bungei_d_p(i0,r0,i1)          bdi_p(CC_NL,i0,r0,i1)
 596 #  define bungtr_f(i0,r0,r1)            bfr(CC_NLE,i0,r0,r1)
 597 #  define bungtr_d(i0,r0,r1)            bdr(CC_NLE,i0,r0,r1)
 598 #  define bungti_f(i0,r0,i1)            bfi(CC_NLE,i0,r0,i1)
 599 #  define bungti_d(i0,r0,i1)            bdi(CC_NLE,i0,r0,i1)
 600 #  define bungtr_f_p(i0,r0,r1)          bfr_p(CC_NLE,i0,r0,r1)
 601 #  define bungtr_d_p(i0,r0,r1)          bdr_p(CC_NLE,i0,r0,r1)
 602 #  define bungti_f_p(i0,r0,i1)          bfi_p(CC_NLE,i0,r0,i1)
 603 #  define bungti_d_p(i0,r0,i1)          bdi_p(CC_NLE,i0,r0,i1)
 604 #  define bltgtr_f(i0,r0,r1)            bltgtr(0,i0,r0,r1)
 605 #  define bltgtr_d(i0,r0,r1)            bltgtr(1,i0,r0,r1)
 606 #  define bltgti_f(i0,r0,i1)            bltgti(0,i0,r0,i1)
 607 #  define bltgti_d(i0,r0,i1)            bltgti(1,i0,r0,i1)
 608 #  define bltgtr_f_p(i0,r0,r1)          bltgtr(0,i0,r0,r1)
 609 #  define bltgtr_d_p(i0,r0,r1)          bltgtr(1,i0,r0,r1)
 610 #  define bltgti_f_p(i0,r0,i1)          bltgti(0,i0,r0,i1)
 611 #  define bltgti_d_p(i0,r0,i1)          bltgti(1,i0,r0,i1)
 612 #  define bordr_f(i0,r0,r1)             bfr(CC_NO,i0,r0,r1)
 613 #  define bordr_d(i0,r0,r1)             bdr(CC_NO,i0,r0,r1)
 614 #  define bordi_f(i0,r0,i1)             bfi(CC_NO,i0,r0,i1)
 615 #  define bordi_d(i0,r0,i1)             bdi(CC_NO,i0,r0,i1)
 616 #  define bordr_f_p(i0,r0,r1)           bfr_p(CC_NO,i0,r0,r1)
 617 #  define bordr_d_p(i0,r0,r1)           bdr_p(CC_NO,i0,r0,r1)
 618 #  define bordi_f_p(i0,r0,i1)           bfi_p(CC_NO,i0,r0,i1)
 619 #  define bordi_d_p(i0,r0,i1)           bdi_p(CC_NO,i0,r0,i1)
 620 #  define bunordr_f(i0,r0,r1)           bfr(CC_O,i0,r0,r1)
 621 #  define bunordr_d(i0,r0,r1)           bdr(CC_O,i0,r0,r1)
 622 #  define bunordi_f(i0,r0,i1)           bfi(CC_O,i0,r0,i1)
 623 #  define bunordi_d(i0,r0,i1)           bdi(CC_O,i0,r0,i1)
 624 #  define bunordr_f_p(i0,r0,r1)         bfr_p(CC_O,i0,r0,r1)
 625 #  define bunordr_d_p(i0,r0,r1)         bdr_p(CC_O,i0,r0,r1)
 626 #  define bunordi_f_p(i0,r0,i1)         bfi_p(CC_O,i0,r0,i1)
 627 #  define bunordi_d_p(i0,r0,i1)         bdi_p(CC_O,i0,r0,i1)
 628 #  define vaarg_d(r0, r1)               _vaarg_d(_jit, r0, r1)
 629 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
 630 #endif
 631
 632 #if CODE
 633 static void
 634 _fp(jit_state_t *_jit, jit_code_t code,
 635     jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
 636 {
 637     jit_int32_t         reg;
 638     reg = jit_get_reg(jit_class_fpr);
 639     movi_f(rn(reg), i0);
 640     switch (code) {
 641         case jit_code_addi_f:   addr_f(r0, r1, rn(reg));        break;
 642         case jit_code_subi_f:   subr_f(r0, r1, rn(reg));        break;
 643         case jit_code_rsbi_f:   rsbr_f(r0, r1, rn(reg));        break;
 644         case jit_code_muli_f:   mulr_f(r0, r1, rn(reg));        break;
 645         case jit_code_divi_f:   divr_f(r0, r1, rn(reg));        break;
 646         case jit_code_uneqi_f:  uneqr_f(r0, r1, rn(reg));       break;
 647         case jit_code_ltgti_f:  ltgtr_f(r0, r1, rn(reg));       break;
 648         default:                abort();
 649     }
 650     jit_unget_reg(reg);
 651 }
 652
 653 static void
 654 _dp(jit_state_t *_jit, jit_code_t code,
 655     jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
 656 {
 657     jit_int32_t         reg;
 658     reg = jit_get_reg(jit_class_fpr);
 659     movi_d(rn(reg), i0);
 660     switch (code) {
 661         case jit_code_addi_d:   addr_d(r0, r1, rn(reg));        break;
 662         case jit_code_subi_d:   subr_d(r0, r1, rn(reg));        break;
 663         case jit_code_rsbi_d:   rsbr_d(r0, r1, rn(reg));        break;
 664         case jit_code_muli_d:   mulr_d(r0, r1, rn(reg));        break;
 665         case jit_code_divi_d:   divr_d(r0, r1, rn(reg));        break;
 666         case jit_code_uneqi_d:  uneqr_d(r0, r1, rn(reg));       break;
 667         case jit_code_ltgti_d:  ltgtr_d(r0, r1, rn(reg));       break;
 668         default:                abort();
 669     }
 670     jit_unget_reg(reg);
 671 }
 672
 673 static void
 674 _fr(jit_state_t *_jit, jit_int32_t cc,
 675      jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 676 {
 677     jit_word_t          w;
 678     LGHI(r0, 1);
 679     CEBR(r1, r2);
 680     w = _jit->pc.w;
 681     BRC(cc, 0);
 682     LGHI(r0, 0);
 683     patch_at(w, _jit->pc.w);
 684 }
 685
 686 static void
 687 _dr(jit_state_t *_jit, jit_int32_t cc,
 688      jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 689 {
 690     jit_word_t          w;
 691     LGHI(r0, 1);
 692     CDBR(r1, r2);
 693     w = _jit->pc.w;
 694     BRC(cc, 0);
 695     LGHI(r0, 0);
 696     patch_at(w, _jit->pc.w);
 697 }
 698
 699 static void
 700 _fi(jit_state_t *_jit, jit_int32_t cc,
 701      jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
 702 {
 703     jit_int32_t         reg;
 704     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
 705     movi_f(rn(reg), i0);
 706     fr(cc, r0, r1, rn(reg));
 707     jit_unget_reg(reg);
 708 }
 709
 710 static void
 711 _di(jit_state_t *_jit, jit_int32_t cc,
 712      jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
 713 {
 714     jit_int32_t         reg;
 715     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
 716     movi_d(rn(reg), i0);
 717     dr(cc, r0, r1, rn(reg));
 718     jit_unget_reg(reg);
 719 }
 720
 721
 722 static void
 723 _bfr(jit_state_t *_jit, jit_int32_t cc,
 724      jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 725 {
 726     jit_word_t          d;
 727     CEBR(r0, r1);
 728     d = (i0 - _jit->pc.w) >> 1;
 729     if (s16_p(d))
 730         BRC(cc, x16(d));
 731     else {
 732         assert(s32_p(d));
 733         BRCL(cc, d);
 734     }
 735 }
 736
 737 static void
 738 _bdr(jit_state_t *_jit, jit_int32_t cc,
 739      jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 740 {
 741     jit_word_t          d;
 742     CDBR(r0, r1);
 743     d = (i0 - _jit->pc.w) >> 1;
 744     if (s16_p(d))
 745         BRC(cc, x16(d));
 746     else {
 747         assert(s32_p(d));
 748         BRCL(cc, d);
 749     }
 750 }
 751
 752 static jit_word_t
 753 _bfr_p(jit_state_t *_jit, jit_int32_t cc,
 754        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 755 {
 756     jit_word_t          w;
 757     CEBR(r0, r1);
 758     w = _jit->pc.w;
 759     BRCL(cc, 0);
 760     return (w);
 761 }
 762
 763 static jit_word_t
 764 _bdr_p(jit_state_t *_jit, jit_int32_t cc,
 765        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 766 {
 767     jit_word_t          w;
 768     CDBR(r0, r1);
 769     w = _jit->pc.w;
 770     BRCL(cc, 0);
 771     return (w);
 772 }
 773
 774 static void
 775 _bfi(jit_state_t *_jit, jit_int32_t cc,
 776      jit_word_t i0, jit_int32_t r0, jit_float32_t *i1)
 777 {
 778     jit_int32_t         reg;
 779     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
 780     movi_f(rn(reg), i1);
 781     bfr(cc, i0, r0, rn(reg));
 782     jit_unget_reg(reg);
 783 }
 784
 785 static void
 786 _bdi(jit_state_t *_jit, jit_int32_t cc,
 787      jit_word_t i0, jit_int32_t r0, jit_float64_t *i1)
 788 {
 789     jit_int32_t         reg;
 790     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
 791     movi_d(rn(reg), i1);
 792     bdr(cc, i0, r0, rn(reg));
 793     jit_unget_reg(reg);
 794 }
 795
 796 static jit_word_t
 797 _bfi_p(jit_state_t *_jit, jit_int32_t cc,
 798      jit_word_t i0, jit_int32_t r0, jit_float32_t *i1)
 799 {
 800     jit_word_t          w;
 801     jit_int32_t         reg;
 802     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
 803     movi_f(rn(reg), i1);
 804     w = bfr_p(cc, i0, r0, rn(reg));
 805     jit_unget_reg(reg);
 806     return (w);
 807 }
 808
 809 static jit_word_t
 810 _bdi_p(jit_state_t *_jit, jit_int32_t cc,
 811      jit_word_t i0, jit_int32_t r0, jit_float64_t *i1)
 812 {
 813     jit_word_t          w;
 814     jit_int32_t         reg;
 815     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
 816     movi_d(rn(reg), i1);
 817     w = bdr_p(cc, i0, r0, rn(reg));
 818     jit_unget_reg(reg);
 819     return (w);
 820 }
 821
 822 static jit_word_t
 823 _buneqr(jit_state_t *_jit, jit_int32_t db,
 824         jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 825 {
 826     jit_word_t          unord, ne, w;
 827     if (db)     CDBR(r0, r1);
 828     else        CEBR(r0, r1);
 829     unord = _jit->pc.w;
 830     BRC(CC_O, 0);                       /* unord satisfies condition */
 831     ne = _jit->pc.w;
 832     BRC(CC_NE, 0);                      /* ne does not satisfy condition */
 833     patch_at(unord, _jit->pc.w);
 834     w = _jit->pc.w;
 835     BRCL(CC_AL, (i0 - _jit->pc.w) >> 1);
 836     patch_at(ne, _jit->pc.w);
 837     return (w);
 838 }
 839
 840 static jit_word_t
 841 _buneqi(jit_state_t *_jit, jit_int32_t db,
 842         jit_word_t i0, jit_int32_t r0, jit_word_t i1)
 843 {
 844     jit_word_t          w;
 845     jit_int32_t         reg;
 846     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
 847     if (db)
 848         movi_d(rn(reg), (jit_float64_t *)i1);
 849     else
 850         movi_f(rn(reg), (jit_float32_t *)i1);
 851     w = buneqr(db, i0, r0, rn(reg));
 852     jit_unget_reg(reg);
 853     return (w);
 854 }
 855
 856 static jit_word_t
 857 _bltgtr(jit_state_t *_jit, jit_int32_t db,
 858         jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 859 {
 860     jit_word_t          unord, eq, w;
 861     if (db)     CDBR(r0, r1);
 862     else        CEBR(r0, r1);
 863     unord = _jit->pc.w;
 864     BRC(CC_O, 0);                       /* unord does not satisfy condition */
 865     eq = _jit->pc.w;
 866     BRC(CC_E, 0);                       /* eq does not satisfy condition */
 867     w = _jit->pc.w;
 868     BRCL(CC_AL, (i0 - _jit->pc.w) >> 1);
 869     patch_at(unord, _jit->pc.w);
 870     patch_at(eq, _jit->pc.w);
 871     return (w);
 872 }
 873
 874 static jit_word_t
 875 _bltgti(jit_state_t *_jit, jit_int32_t db,
 876         jit_word_t i0, jit_int32_t r0, jit_word_t i1)
 877 {
 878     jit_word_t          w;
 879     jit_int32_t         reg;
 880     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
 881     if (db)
 882         movi_d(rn(reg), (jit_float64_t *)i1);
 883     else
 884         movi_f(rn(reg), (jit_float32_t *)i1);
 885     w = bltgtr(db, i0, r0, rn(reg));
 886     jit_unget_reg(reg);
 887     return (w);
 888 }
 889
 890 static void
 891 _movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 892 {
 893     if (r0 != r1)
 894         LER(r0, r1);
 895 }
 896
 897 static void
 898 _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
 899 {
 900     union {
 901         jit_int32_t      i;
 902         jit_float32_t    f;
 903     } data;
 904     jit_int32_t          reg;
 905
 906     if (*(jit_int32_t *)i0 == 0)
 907         LZER(r0);
 908     else if (_jitc->no_data) {
 909         data.f = *i0;
 910         reg = jit_get_reg_but_zero(0);
 911         movi(rn(reg), data.i & 0xffffffff);
 912         stxi_i(-4, _FP_REGNO, rn(reg));
 913         jit_unget_reg_but_zero(reg);
 914         ldxi_f(r0, _FP_REGNO, -4);
 915     }
 916     else
 917         ldi_f(r0, (jit_word_t)i0);
 918 }
 919
 920 static void
 921 _movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 922 {
 923     jit_int32_t         reg;
 924     reg = jit_get_reg(jit_class_gpr);
 925     movi(rn(reg), i0);
 926     movr_w_f(r0, rn(reg));
 927     jit_unget_reg(reg);
 928 }
 929
 930 static void
 931 _movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 932 {
 933     if (r0 != r1)
 934         LDR(r0, r1);
 935 }
 936
 937 static void
 938 _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
 939 {
 940     union {
 941 #if __WORDSIZE == 32
 942         jit_int32_t      i[2];
 943 #else
 944         jit_int64_t      l;
 945 #endif
 946         jit_float64_t    d;
 947     } data;
 948     jit_int32_t          reg;
 949
 950     if (*(jit_int64_t *)i0 == 0)
 951         LZDR(r0);
 952     else if (_jitc->no_data) {
 953         data.d = *i0;
 954         reg = jit_get_reg_but_zero(0);
 955 #if __WORDSIZE == 32
 956         movi(rn(reg), data.i[0]);
 957         stxi_i(-8, _FP_REGNO, rn(reg));
 958         movi(rn(reg), data.i[1]);
 959         stxi_i(-4, _FP_REGNO, rn(reg));
 960 #else
 961         movi(rn(reg), data.l);
 962         stxi_l(-8, _FP_REGNO, rn(reg));
 963 #endif
 964         jit_unget_reg_but_zero(reg);
 965         ldxi_d(r0, _FP_REGNO, -8);
 966     }
 967     else
 968         ldi_d(r0, (jit_word_t)i0);
 969 }
 970
 971 #if __WORDSIZE == 32
 972 static void
 973 _movi_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
 974 {
 975     jit_int32_t         t0, t1;
 976     t0 = jit_get_reg(jit_class_gpr);
 977     t1 = jit_get_reg(jit_class_gpr);
 978     movi(rn(t0), i0);
 979     movi(rn(t1), i1);
 980     movr_ww_d(r0, rn(t0), rn(t1));
 981     jit_unget_reg(t1);
 982     jit_unget_reg(t0);
 983 }
 984 #else
 985 static void
 986 _movi_w_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 987 {
 988     jit_int32_t         reg;
 989     reg = jit_get_reg(jit_class_gpr);
 990     movi(rn(reg), i0);
 991     movr_w_d(r0, rn(reg));
 992     jit_unget_reg(reg);
 993 }
 994 #endif
 995
 996 static void
 997 _fmar_f(jit_state_t* _jit,
 998         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 999 {
1000     jit_int32_t         t0;
1001     if (r0 == r3)
1002         MAEBR(r0, r2, r1);
1003     else {
1004         t0 = jit_get_reg(jit_class_fpr);
1005         movr_f(rn(t0), r3);
1006         MAEBR(rn(t0), r2, r1);
1007         movr_f(r0, rn(t0));
1008         jit_unget_reg(t0);
1009     }
1010 }
1011
1012 static void
1013 _fmsr_f(jit_state_t* _jit,
1014         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1015 {
1016     jit_int32_t         t0;
1017     if (r0 == r3)
1018         MSEBR(r0, r2, r1);
1019     else {
1020         t0 = jit_get_reg(jit_class_fpr);
1021         movr_f(rn(t0), r3);
1022         MSEBR(rn(t0), r2, r1);
1023         movr_f(r0, rn(t0));
1024         jit_unget_reg(t0);
1025     }
1026 }
1027
1028 static void
1029 _fnmar_f(jit_state_t* _jit,
1030         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1031 {
1032     jit_int32_t         t0;
1033     if (r0 == r3) {
1034         MAEBR(r0, r2, r1);
1035         negr_f(r0, r0);
1036     }
1037     else {
1038         t0 = jit_get_reg(jit_class_fpr);
1039         movr_f(rn(t0), r3);
1040         MAEBR(rn(t0), r2, r1);
1041         negr_f(r0, rn(t0));
1042         jit_unget_reg(t0);
1043     }
1044 }
1045
1046 static void
1047 _fnmsr_f(jit_state_t* _jit,
1048         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1049 {
1050     jit_int32_t         t0;
1051     if (r0 == r3) {
1052         MSEBR(r0, r2, r1);
1053         negr_f(r0, r0);
1054     }
1055     else {
1056         t0 = jit_get_reg(jit_class_fpr);
1057         movr_f(rn(t0), r3);
1058         MSEBR(rn(t0), r2, r1);
1059         negr_f(r0, rn(t0));
1060         jit_unget_reg(t0);
1061     }
1062 }
1063
1064 static void
1065 _fmar_d(jit_state_t* _jit,
1066         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1067 {
1068     jit_int32_t         t0;
1069     if (r0 == r3)
1070         MADBR(r0, r2, r1);
1071     else {
1072         t0 = jit_get_reg(jit_class_fpr);
1073         movr_d(rn(t0), r3);
1074         MADBR(rn(t0), r2, r1);
1075         movr_d(r0, rn(t0));
1076         jit_unget_reg(t0);
1077     }
1078 }
1079
1080 static void
1081 _fmsr_d(jit_state_t* _jit,
1082         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1083 {
1084     jit_int32_t         t0;
1085     if (r0 == r3)
1086         MSDBR(r0, r2, r1);
1087     else {
1088         t0 = jit_get_reg(jit_class_fpr);
1089         movr_d(rn(t0), r3);
1090         MSDBR(rn(t0), r2, r1);
1091         movr_d(r0, rn(t0));
1092         jit_unget_reg(t0);
1093     }
1094 }
1095
1096 static void
1097 _fnmar_d(jit_state_t* _jit,
1098         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1099 {
1100     jit_int32_t         t0;
1101     if (r0 == r3) {
1102         MADBR(r0, r2, r1);
1103         negr_d(r0, r0);
1104     }
1105     else {
1106         t0 = jit_get_reg(jit_class_fpr);
1107         movr_f(rn(t0), r3);
1108         MADBR(rn(t0), r2, r1);
1109         negr_d(r0, rn(t0));
1110         jit_unget_reg(t0);
1111     }
1112 }
1113
1114 static void
1115 _fnmsr_d(jit_state_t* _jit,
1116         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1117 {
1118     jit_int32_t         t0;
1119     if (r0 == r3) {
1120         MSDBR(r0, r2, r1);
1121         negr_d(r0, r0);
1122     }
1123     else {
1124         t0 = jit_get_reg(jit_class_fpr);
1125         movr_d(rn(t0), r3);
1126         MSDBR(rn(t0), r2, r1);
1127         negr_d(r0, rn(t0));
1128         jit_unget_reg(t0);
1129     }
1130 }
1131
1132 static void
1133 _addr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1134 {
1135     if (r0 == r2)
1136         AEBR(r0, r1);
1137     else {
1138         movr_f(r0, r1);
1139         AEBR(r0, r2);
1140     }
1141 }
1142
1143 static void
1144 _addr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1145 {
1146     if (r0 == r2)
1147         ADBR(r0, r1);
1148     else {
1149         movr_d(r0, r1);
1150         ADBR(r0, r2);
1151     }
1152 }
1153
1154 static void
1155 _subr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1156 {
1157     jit_int32_t         reg;
1158     if (r0 == r2) {
1159         reg = jit_get_reg(jit_class_fpr);
1160         movr_f(rn(reg), r2);
1161         movr_f(r0, r1);
1162         SEBR(r0, rn(reg));
1163         jit_unget_reg(reg);
1164     }
1165     else {
1166         movr_f(r0, r1);
1167         SEBR(r0, r2);
1168     }
1169 }
1170
1171 static void
1172 _subr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1173 {
1174     jit_int32_t         reg;
1175     if (r0 == r2) {
1176         reg = jit_get_reg(jit_class_fpr);
1177         movr_d(rn(reg), r2);
1178         movr_d(r0, r1);
1179         SDBR(r0, rn(reg));
1180         jit_unget_reg(reg);
1181     }
1182     else {
1183         movr_d(r0, r1);
1184         SDBR(r0, r2);
1185     }
1186 }
1187
1188 static void
1189 _mulr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1190 {
1191     if (r0 == r2)
1192         MEEBR(r0, r1);
1193     else {
1194         movr_f(r0, r1);
1195         MEEBR(r0, r2);
1196     }
1197 }
1198
1199 static void
1200 _mulr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1201 {
1202     if (r0 == r2)
1203         MDBR(r0, r1);
1204     else {
1205         movr_d(r0, r1);
1206         MDBR(r0, r2);
1207     }
1208 }
1209
1210 static void
1211 _divr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1212 {
1213     jit_int32_t         reg;
1214     if (r0 == r2) {
1215         reg = jit_get_reg(jit_class_fpr);
1216         movr_f(rn(reg), r2);
1217         movr_f(r0, r1);
1218         DEBR(r0, rn(reg));
1219         jit_unget_reg(reg);
1220     }
1221     else {
1222         movr_f(r0, r1);
1223         DEBR(r0, r2);
1224     }
1225 }
1226
1227 static void
1228 _divr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1229 {
1230     jit_int32_t         reg;
1231     if (r0 == r2) {
1232         reg = jit_get_reg(jit_class_fpr);
1233         movr_d(rn(reg), r2);
1234         movr_d(r0, r1);
1235         DDBR(r0, rn(reg));
1236         jit_unget_reg(reg);
1237     }
1238     else {
1239         movr_d(r0, r1);
1240         DDBR(r0, r2);
1241     }
1242 }
1243
1244 static void
1245 _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1246 {
1247     jit_int32_t         reg;
1248     reg = jit_get_reg_but_zero(0);
1249     movi(rn(reg), i0);
1250     ldr_f(r0, rn(reg));
1251     jit_unget_reg_but_zero(reg);
1252 }
1253
1254 static void
1255 _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1256 {
1257     jit_int32_t         reg;
1258     reg = jit_get_reg_but_zero(0);
1259     movi(rn(reg), i0);
1260     ldr_d(r0, rn(reg));
1261     jit_unget_reg_but_zero(reg);
1262 }
1263
1264 static void
1265 _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1266 {
1267     jit_int32_t         reg;
1268     reg = jit_get_reg_but_zero(0);
1269     movr(rn(reg), r1);
1270     addr(rn(reg), rn(reg), r2);
1271     ldr_f(r0, rn(reg));
1272     jit_unget_reg_but_zero(reg);
1273 }
1274
1275 static void
1276 _ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1277 {
1278     jit_int32_t         reg;
1279     reg = jit_get_reg_but_zero(0);
1280     movr(rn(reg), r1);
1281     addr(rn(reg), rn(reg), r2);
1282     ldr_d(r0, rn(reg));
1283     jit_unget_reg_but_zero(reg);
1284 }
1285
1286 static void
1287 _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1288 {
1289     jit_int32_t         reg;
1290     if (u12_p(i0))
1291         LE(r0, i0, 0, r1);
1292     else if (s20_p(i0))
1293         LEY(r0, x20(i0), 0, r1);
1294     else {
1295         reg = jit_get_reg_but_zero(0);
1296         movi(rn(reg), i0);
1297         addr(rn(reg), rn(reg), r1);
1298         ldr_f(r0, rn(reg));
1299         jit_unget_reg_but_zero(reg);
1300     }
1301 }
1302
1303 static void
1304 _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1305 {
1306     jit_int32_t         reg;
1307     if (u12_p(i0))
1308         LD(r0, i0, 0, r1);
1309     else if (s20_p(i0))
1310         LDY(r0, x20(i0), 0, r1);
1311     else {
1312         reg = jit_get_reg_but_zero(0);
1313         movi(rn(reg), i0);
1314         addr(rn(reg), rn(reg), r1);
1315         ldr_d(r0, rn(reg));
1316         jit_unget_reg_but_zero(reg);
1317     }
1318 }
1319
1320 static void
1321 _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1322 {
1323     jit_int32_t         reg;
1324     reg = jit_get_reg_but_zero(0);
1325     movi(rn(reg), i0);
1326     str_f(rn(reg), r0);
1327     jit_unget_reg_but_zero(reg);
1328 }
1329
1330 static void
1331 _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1332 {
1333     jit_int32_t         reg;
1334     reg = jit_get_reg_but_zero(0);
1335     movi(rn(reg), i0);
1336     str_d(rn(reg), r0);
1337     jit_unget_reg_but_zero(reg);
1338 }
1339
1340 static void
1341 _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1342 {
1343     jit_int32_t         reg;
1344     reg = jit_get_reg_but_zero(0);
1345     movr(rn(reg), r0);
1346     addr(rn(reg), rn(reg), r1);
1347     str_f(rn(reg), r2);
1348     jit_unget_reg_but_zero(reg);
1349 }
1350
1351 static void
1352 _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1353 {
1354     jit_int32_t         reg;
1355     reg = jit_get_reg_but_zero(0);
1356     movr(rn(reg), r0);
1357     addr(rn(reg), rn(reg), r1);
1358     str_d(rn(reg), r2);
1359     jit_unget_reg_but_zero(reg);
1360 }
1361
1362 static void
1363 _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1364 {
1365     jit_int32_t         reg;
1366     if (u12_p(i0))
1367         STE(r1, i0, 0, r0);
1368     else if (s20_p(i0))
1369         STEY(r1, x20(i0), 0, r0);
1370     else {
1371         reg = jit_get_reg_but_zero(0);
1372         movi(rn(reg), i0);
1373         addr(rn(reg), rn(reg), r0);
1374         str_f(rn(reg), r1);
1375         jit_unget_reg_but_zero(reg);
1376     }
1377 }
1378
1379 static void
1380 _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1381 {
1382     jit_int32_t         reg;
1383     if (u12_p(i0))
1384         STD(r1, i0, 0, r0);
1385     else if (s20_p(i0))
1386         STDY(r1, x20(i0), 0, r0);
1387     else {
1388         reg = jit_get_reg_but_zero(0);
1389         movi(rn(reg), i0);
1390         addr(rn(reg), rn(reg), r0);
1391         str_d(rn(reg), r1);
1392         jit_unget_reg_but_zero(reg);
1393     }
1394 }
1395
1396 static void
1397 _uneqr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1398 {
1399     jit_word_t          unord, eq;
1400     movi(r0, 1);                        /* set to one */
1401     CEBR(r1, r2);
1402     unord = _jit->pc.w;                 /* keep set to one if unord */
1403     BRC(CC_O, 0);
1404     eq = _jit->pc.w;
1405     BRC(CC_E, 0);                       /* keep set to one if eq */
1406     movi(r0, 0);                        /* set to zero */
1407     patch_at(unord, _jit->pc.w);
1408     patch_at(eq, _jit->pc.w);
1409 }
1410
1411 static void
1412 _uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1413 {
1414     jit_word_t          unord, eq;
1415     movi(r0, 1);                        /* set to one */
1416     CDBR(r1, r2);
1417     unord = _jit->pc.w;                 /* keep set to one if unord */
1418     BRC(CC_O, 0);
1419     eq = _jit->pc.w;
1420     BRC(CC_E, 0);                       /* keep set to one if eq */
1421     movi(r0, 0);                        /* set to zero */
1422     patch_at(unord, _jit->pc.w);
1423     patch_at(eq, _jit->pc.w);
1424 }
1425
1426 static void
1427 _ltgtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1428 {
1429     jit_word_t          unord, eq;
1430     movi(r0, 0);                        /* set to zero */
1431     CEBR(r1, r2);
1432     unord = _jit->pc.w;                 /* keep set to zero if unord */
1433     BRC(CC_O, 0);
1434     eq = _jit->pc.w;
1435     BRC(CC_E, 0);                       /* keep set to zero if eq */
1436     movi(r0, 1);                        /* set to one */
1437     patch_at(unord, _jit->pc.w);
1438     patch_at(eq, _jit->pc.w);
1439 }
1440
1441 static void
1442 _ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1443 {
1444     jit_word_t          unord, eq;
1445     movi(r0, 0);                        /* set to zero */
1446     CDBR(r1, r2);
1447     unord = _jit->pc.w;                 /* keep set to zero if unord */
1448     BRC(CC_O, 0);
1449     eq = _jit->pc.w;
1450     BRC(CC_E, 0);                       /* keep set to zero if eq */
1451     movi(r0, 1);                        /* set to one */
1452     patch_at(unord, _jit->pc.w);
1453     patch_at(eq, _jit->pc.w);
1454 }
1455
1456 static void
1457 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1458 {
1459     jit_int32_t         rg0;
1460     jit_int32_t         rg1;
1461     jit_int32_t         rg2;
1462     jit_word_t          ge_code;
1463     jit_word_t          lt_code;
1464
1465     assert(_jitc->function->self.call & jit_call_varargs);
1466
1467     rg0 = jit_get_reg_but_zero(jit_class_gpr);
1468     rg1 = jit_get_reg_but_zero(jit_class_gpr);
1469
1470     /* Load the fp offset in save area in the first temporary. */
1471     ldxi(rn(rg0), r1, offsetof(jit_va_list_t, fpoff));
1472
1473     /* Jump over if there are no remaining arguments in the save area. */
1474     ge_code = bgei_p(_jit->pc.w, rn(rg0), NUM_FLOAT_REG_ARGS);
1475
1476     /* Load the save area pointer in the second temporary. */
1477     ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
1478
1479     /* Scale offset. */
1480     rg2 = jit_get_reg_but_zero(0);
1481     lshi(rn(rg2), rn(rg0), 3);
1482     /* Add offset to saved area */
1483     addi(rn(rg2), rn(rg2), 16 * sizeof(jit_word_t));
1484
1485     /* Load the vararg argument in the first argument. */
1486     ldxr_d(r0, rn(rg1), rn(rg2));
1487     jit_unget_reg_but_zero(rg2);
1488
1489     /* Update the fp offset. */
1490     addi(rn(rg0), rn(rg0), 1);
1491     stxi(offsetof(jit_va_list_t, fpoff), r1, rn(rg0));
1492
1493     /* Will only need one temporary register below. */
1494     jit_unget_reg_but_zero(rg1);
1495
1496     /* Jump over overflow code. */
1497     lt_code = jmpi_p(_jit->pc.w);
1498
1499     /* Where to land if argument is in overflow area. */
1500     patch_at(ge_code, _jit->pc.w);
1501
1502     /* Load overflow pointer. */
1503     ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
1504
1505     /* Load argument. */
1506     ldr_d(r0, rn(rg0));
1507
1508     /* Update overflow pointer. */
1509     addi(rn(rg0), rn(rg0), sizeof(jit_float64_t));
1510     stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
1511
1512     /* Where to land if argument is in save area. */
1513     patch_at(lt_code, _jit->pc.w);
1514
1515     jit_unget_reg_but_zero(rg0);
1516 }
1517 #endif