tcg/tcg-op.h

   1 /*
   2  * Tiny Code Generator for QEMU
   3  *
   4  * Copyright (c) 2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "tcg.h"
  25
  26 int gen_new_label(void);
  27
  28 static inline void tcg_gen_op0(TCGOpcode opc)
  29 {
  30     *tcg_ctx.gen_opc_ptr++ = opc;
  31 }
  32
  33 static inline void tcg_gen_op1_i32(TCGOpcode opc, TCGv_i32 arg1)
  34 {
  35     *tcg_ctx.gen_opc_ptr++ = opc;
  36     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg1);
  37 }
  38
  39 static inline void tcg_gen_op1_i64(TCGOpcode opc, TCGv_i64 arg1)
  40 {
  41     *tcg_ctx.gen_opc_ptr++ = opc;
  42     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg1);
  43 }
  44
  45 static inline void tcg_gen_op1i(TCGOpcode opc, TCGArg arg1)
  46 {
  47     *tcg_ctx.gen_opc_ptr++ = opc;
  48     *tcg_ctx.gen_opparam_ptr++ = arg1;
  49 }
  50
  51 static inline void tcg_gen_op2_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2)
  52 {
  53     *tcg_ctx.gen_opc_ptr++ = opc;
  54     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg1);
  55     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg2);
  56 }
  57
  58 static inline void tcg_gen_op2_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2)
  59 {
  60     *tcg_ctx.gen_opc_ptr++ = opc;
  61     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg1);
  62     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg2);
  63 }
  64
  65 static inline void tcg_gen_op2i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGArg arg2)
  66 {
  67     *tcg_ctx.gen_opc_ptr++ = opc;
  68     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg1);
  69     *tcg_ctx.gen_opparam_ptr++ = arg2;
  70 }
  71
  72 static inline void tcg_gen_op2i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGArg arg2)
  73 {
  74     *tcg_ctx.gen_opc_ptr++ = opc;
  75     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg1);
  76     *tcg_ctx.gen_opparam_ptr++ = arg2;
  77 }
  78
  79 static inline void tcg_gen_op2ii(TCGOpcode opc, TCGArg arg1, TCGArg arg2)
  80 {
  81     *tcg_ctx.gen_opc_ptr++ = opc;
  82     *tcg_ctx.gen_opparam_ptr++ = arg1;
  83     *tcg_ctx.gen_opparam_ptr++ = arg2;
  84 }
  85
  86 static inline void tcg_gen_op3_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
  87                                    TCGv_i32 arg3)
  88 {
  89     *tcg_ctx.gen_opc_ptr++ = opc;
  90     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg1);
  91     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg2);
  92     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg3);
  93 }
  94
  95 static inline void tcg_gen_op3_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
  96                                    TCGv_i64 arg3)
  97 {
  98     *tcg_ctx.gen_opc_ptr++ = opc;
  99     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 100     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 101     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 102 }
 103
 104 static inline void tcg_gen_op3i_i32(TCGOpcode opc, TCGv_i32 arg1,
 105                                     TCGv_i32 arg2, TCGArg arg3)
 106 {
 107     *tcg_ctx.gen_opc_ptr++ = opc;
 108     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 109     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 110     *tcg_ctx.gen_opparam_ptr++ = arg3;
 111 }
 112
 113 static inline void tcg_gen_op3i_i64(TCGOpcode opc, TCGv_i64 arg1,
 114                                     TCGv_i64 arg2, TCGArg arg3)
 115 {
 116     *tcg_ctx.gen_opc_ptr++ = opc;
 117     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 118     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 119     *tcg_ctx.gen_opparam_ptr++ = arg3;
 120 }
 121
 122 static inline void tcg_gen_ldst_op_i32(TCGOpcode opc, TCGv_i32 val,
 123                                        TCGv_ptr base, TCGArg offset)
 124 {
 125     *tcg_ctx.gen_opc_ptr++ = opc;
 126     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(val);
 127     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_PTR(base);
 128     *tcg_ctx.gen_opparam_ptr++ = offset;
 129 }
 130
 131 static inline void tcg_gen_ldst_op_i64(TCGOpcode opc, TCGv_i64 val,
 132                                        TCGv_ptr base, TCGArg offset)
 133 {
 134     *tcg_ctx.gen_opc_ptr++ = opc;
 135     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(val);
 136     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_PTR(base);
 137     *tcg_ctx.gen_opparam_ptr++ = offset;
 138 }
 139
 140 static inline void tcg_gen_op4_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 141                                    TCGv_i32 arg3, TCGv_i32 arg4)
 142 {
 143     *tcg_ctx.gen_opc_ptr++ = opc;
 144     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 145     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 146     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 147     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 148 }
 149
 150 static inline void tcg_gen_op4_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 151                                    TCGv_i64 arg3, TCGv_i64 arg4)
 152 {
 153     *tcg_ctx.gen_opc_ptr++ = opc;
 154     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 155     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 156     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 157     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 158 }
 159
 160 static inline void tcg_gen_op4i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 161                                     TCGv_i32 arg3, TCGArg arg4)
 162 {
 163     *tcg_ctx.gen_opc_ptr++ = opc;
 164     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 165     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 166     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 167     *tcg_ctx.gen_opparam_ptr++ = arg4;
 168 }
 169
 170 static inline void tcg_gen_op4i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 171                                     TCGv_i64 arg3, TCGArg arg4)
 172 {
 173     *tcg_ctx.gen_opc_ptr++ = opc;
 174     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 175     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 176     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 177     *tcg_ctx.gen_opparam_ptr++ = arg4;
 178 }
 179
 180 static inline void tcg_gen_op4ii_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 181                                      TCGArg arg3, TCGArg arg4)
 182 {
 183     *tcg_ctx.gen_opc_ptr++ = opc;
 184     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 185     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 186     *tcg_ctx.gen_opparam_ptr++ = arg3;
 187     *tcg_ctx.gen_opparam_ptr++ = arg4;
 188 }
 189
 190 static inline void tcg_gen_op4ii_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 191                                      TCGArg arg3, TCGArg arg4)
 192 {
 193     *tcg_ctx.gen_opc_ptr++ = opc;
 194     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 195     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 196     *tcg_ctx.gen_opparam_ptr++ = arg3;
 197     *tcg_ctx.gen_opparam_ptr++ = arg4;
 198 }
 199
 200 static inline void tcg_gen_op5_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 201                                    TCGv_i32 arg3, TCGv_i32 arg4, TCGv_i32 arg5)
 202 {
 203     *tcg_ctx.gen_opc_ptr++ = opc;
 204     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 205     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 206     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 207     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 208     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg5);
 209 }
 210
 211 static inline void tcg_gen_op5_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 212                                    TCGv_i64 arg3, TCGv_i64 arg4, TCGv_i64 arg5)
 213 {
 214     *tcg_ctx.gen_opc_ptr++ = opc;
 215     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 216     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 217     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 218     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 219     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg5);
 220 }
 221
 222 static inline void tcg_gen_op5i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 223                                     TCGv_i32 arg3, TCGv_i32 arg4, TCGArg arg5)
 224 {
 225     *tcg_ctx.gen_opc_ptr++ = opc;
 226     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 227     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 228     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 229     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 230     *tcg_ctx.gen_opparam_ptr++ = arg5;
 231 }
 232
 233 static inline void tcg_gen_op5i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 234                                     TCGv_i64 arg3, TCGv_i64 arg4, TCGArg arg5)
 235 {
 236     *tcg_ctx.gen_opc_ptr++ = opc;
 237     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 238     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 239     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 240     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 241     *tcg_ctx.gen_opparam_ptr++ = arg5;
 242 }
 243
 244 static inline void tcg_gen_op5ii_i32(TCGOpcode opc, TCGv_i32 arg1,
 245                                      TCGv_i32 arg2, TCGv_i32 arg3,
 246                                      TCGArg arg4, TCGArg arg5)
 247 {
 248     *tcg_ctx.gen_opc_ptr++ = opc;
 249     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 250     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 251     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 252     *tcg_ctx.gen_opparam_ptr++ = arg4;
 253     *tcg_ctx.gen_opparam_ptr++ = arg5;
 254 }
 255
 256 static inline void tcg_gen_op5ii_i64(TCGOpcode opc, TCGv_i64 arg1,
 257                                      TCGv_i64 arg2, TCGv_i64 arg3,
 258                                      TCGArg arg4, TCGArg arg5)
 259 {
 260     *tcg_ctx.gen_opc_ptr++ = opc;
 261     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 262     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 263     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 264     *tcg_ctx.gen_opparam_ptr++ = arg4;
 265     *tcg_ctx.gen_opparam_ptr++ = arg5;
 266 }
 267
 268 static inline void tcg_gen_op6_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 269                                    TCGv_i32 arg3, TCGv_i32 arg4, TCGv_i32 arg5,
 270                                    TCGv_i32 arg6)
 271 {
 272     *tcg_ctx.gen_opc_ptr++ = opc;
 273     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 274     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 275     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 276     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 277     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg5);
 278     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg6);
 279 }
 280
 281 static inline void tcg_gen_op6_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 282                                    TCGv_i64 arg3, TCGv_i64 arg4, TCGv_i64 arg5,
 283                                    TCGv_i64 arg6)
 284 {
 285     *tcg_ctx.gen_opc_ptr++ = opc;
 286     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 287     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 288     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 289     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 290     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg5);
 291     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg6);
 292 }
 293
 294 static inline void tcg_gen_op6i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 295                                     TCGv_i32 arg3, TCGv_i32 arg4,
 296                                     TCGv_i32 arg5, TCGArg arg6)
 297 {
 298     *tcg_ctx.gen_opc_ptr++ = opc;
 299     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 300     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 301     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 302     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 303     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg5);
 304     *tcg_ctx.gen_opparam_ptr++ = arg6;
 305 }
 306
 307 static inline void tcg_gen_op6i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 308                                     TCGv_i64 arg3, TCGv_i64 arg4,
 309                                     TCGv_i64 arg5, TCGArg arg6)
 310 {
 311     *tcg_ctx.gen_opc_ptr++ = opc;
 312     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 313     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 314     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 315     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 316     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg5);
 317     *tcg_ctx.gen_opparam_ptr++ = arg6;
 318 }
 319
 320 static inline void tcg_gen_op6ii_i32(TCGOpcode opc, TCGv_i32 arg1,
 321                                      TCGv_i32 arg2, TCGv_i32 arg3,
 322                                      TCGv_i32 arg4, TCGArg arg5, TCGArg arg6)
 323 {
 324     *tcg_ctx.gen_opc_ptr++ = opc;
 325     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 326     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 327     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 328     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 329     *tcg_ctx.gen_opparam_ptr++ = arg5;
 330     *tcg_ctx.gen_opparam_ptr++ = arg6;
 331 }
 332
 333 static inline void tcg_gen_op6ii_i64(TCGOpcode opc, TCGv_i64 arg1,
 334                                      TCGv_i64 arg2, TCGv_i64 arg3,
 335                                      TCGv_i64 arg4, TCGArg arg5, TCGArg arg6)
 336 {
 337     *tcg_ctx.gen_opc_ptr++ = opc;
 338     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 339     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 340     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 341     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 342     *tcg_ctx.gen_opparam_ptr++ = arg5;
 343     *tcg_ctx.gen_opparam_ptr++ = arg6;
 344 }
 345
 346 static inline void tcg_add_param_i32(TCGv_i32 val)
 347 {
 348     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(val);
 349 }
 350
 351 static inline void tcg_add_param_i64(TCGv_i64 val)
 352 {
 353 #if TCG_TARGET_REG_BITS == 32
 354     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(TCGV_LOW(val));
 355     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I32(TCGV_HIGH(val));
 356 #else
 357     *tcg_ctx.gen_opparam_ptr++ = GET_TCGV_I64(val);
 358 #endif
 359 }
 360
 361 static inline void gen_set_label(int n)
 362 {
 363     tcg_gen_op1i(INDEX_op_set_label, n);
 364 }
 365
 366 static inline void tcg_gen_br(int label)
 367 {
 368     tcg_gen_op1i(INDEX_op_br, label);
 369 }
 370
 371 static inline void tcg_gen_mov_i32(TCGv_i32 ret, TCGv_i32 arg)
 372 {
 373     if (!TCGV_EQUAL_I32(ret, arg))
 374         tcg_gen_op2_i32(INDEX_op_mov_i32, ret, arg);
 375 }
 376
 377 static inline void tcg_gen_movi_i32(TCGv_i32 ret, int32_t arg)
 378 {
 379     tcg_gen_op2i_i32(INDEX_op_movi_i32, ret, arg);
 380 }
 381
 382 /* A version of dh_sizemask from def-helper.h that doesn't rely on
 383    preprocessor magic.  */
 384 static inline int tcg_gen_sizemask(int n, int is_64bit, int is_signed)
 385 {
 386     return (is_64bit << n*2) | (is_signed << (n*2 + 1));
 387 }
 388
 389 /* helper calls */
 390 static inline void tcg_gen_helperN(void *func, int flags, int sizemask,
 391                                    TCGArg ret, int nargs, TCGArg *args)
 392 {
 393     TCGv_ptr fn;
 394     fn = tcg_const_ptr(func);
 395     tcg_gen_callN(&tcg_ctx, fn, flags, sizemask, ret,
 396                   nargs, args);
 397     tcg_temp_free_ptr(fn);
 398 }
 399
 400 /* Note: Both tcg_gen_helper32() and tcg_gen_helper64() are currently
 401    reserved for helpers in tcg-runtime.c. These helpers all do not read
 402    globals and do not have side effects, hence the call to tcg_gen_callN()
 403    with TCG_CALL_NO_READ_GLOBALS | TCG_CALL_NO_SIDE_EFFECTS. This may need
 404    to be adjusted if these functions start to be used with other helpers. */
 405 static inline void tcg_gen_helper32(void *func, int sizemask, TCGv_i32 ret,
 406                                     TCGv_i32 a, TCGv_i32 b)
 407 {
 408     TCGv_ptr fn;
 409     TCGArg args[2];
 410     fn = tcg_const_ptr(func);
 411     args[0] = GET_TCGV_I32(a);
 412     args[1] = GET_TCGV_I32(b);
 413     tcg_gen_callN(&tcg_ctx, fn,
 414                   TCG_CALL_NO_READ_GLOBALS | TCG_CALL_NO_SIDE_EFFECTS,
 415                   sizemask, GET_TCGV_I32(ret), 2, args);
 416     tcg_temp_free_ptr(fn);
 417 }
 418
 419 static inline void tcg_gen_helper64(void *func, int sizemask, TCGv_i64 ret,
 420                                     TCGv_i64 a, TCGv_i64 b)
 421 {
 422     TCGv_ptr fn;
 423     TCGArg args[2];
 424     fn = tcg_const_ptr(func);
 425     args[0] = GET_TCGV_I64(a);
 426     args[1] = GET_TCGV_I64(b);
 427     tcg_gen_callN(&tcg_ctx, fn,
 428                   TCG_CALL_NO_READ_GLOBALS | TCG_CALL_NO_SIDE_EFFECTS,
 429                   sizemask, GET_TCGV_I64(ret), 2, args);
 430     tcg_temp_free_ptr(fn);
 431 }
 432
 433 /* 32 bit ops */
 434
 435 static inline void tcg_gen_ld8u_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 436 {
 437     tcg_gen_ldst_op_i32(INDEX_op_ld8u_i32, ret, arg2, offset);
 438 }
 439
 440 static inline void tcg_gen_ld8s_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 441 {
 442     tcg_gen_ldst_op_i32(INDEX_op_ld8s_i32, ret, arg2, offset);
 443 }
 444
 445 static inline void tcg_gen_ld16u_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 446 {
 447     tcg_gen_ldst_op_i32(INDEX_op_ld16u_i32, ret, arg2, offset);
 448 }
 449
 450 static inline void tcg_gen_ld16s_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 451 {
 452     tcg_gen_ldst_op_i32(INDEX_op_ld16s_i32, ret, arg2, offset);
 453 }
 454
 455 static inline void tcg_gen_ld_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 456 {
 457     tcg_gen_ldst_op_i32(INDEX_op_ld_i32, ret, arg2, offset);
 458 }
 459
 460 static inline void tcg_gen_st8_i32(TCGv_i32 arg1, TCGv_ptr arg2, tcg_target_long offset)
 461 {
 462     tcg_gen_ldst_op_i32(INDEX_op_st8_i32, arg1, arg2, offset);
 463 }
 464
 465 static inline void tcg_gen_st16_i32(TCGv_i32 arg1, TCGv_ptr arg2, tcg_target_long offset)
 466 {
 467     tcg_gen_ldst_op_i32(INDEX_op_st16_i32, arg1, arg2, offset);
 468 }
 469
 470 static inline void tcg_gen_st_i32(TCGv_i32 arg1, TCGv_ptr arg2, tcg_target_long offset)
 471 {
 472     tcg_gen_ldst_op_i32(INDEX_op_st_i32, arg1, arg2, offset);
 473 }
 474
 475 static inline void tcg_gen_add_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 476 {
 477     tcg_gen_op3_i32(INDEX_op_add_i32, ret, arg1, arg2);
 478 }
 479
 480 static inline void tcg_gen_addi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 481 {
 482     /* some cases can be optimized here */
 483     if (arg2 == 0) {
 484         tcg_gen_mov_i32(ret, arg1);
 485     } else {
 486         TCGv_i32 t0 = tcg_const_i32(arg2);
 487         tcg_gen_add_i32(ret, arg1, t0);
 488         tcg_temp_free_i32(t0);
 489     }
 490 }
 491
 492 static inline void tcg_gen_sub_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 493 {
 494     tcg_gen_op3_i32(INDEX_op_sub_i32, ret, arg1, arg2);
 495 }
 496
 497 static inline void tcg_gen_subfi_i32(TCGv_i32 ret, int32_t arg1, TCGv_i32 arg2)
 498 {
 499     TCGv_i32 t0 = tcg_const_i32(arg1);
 500     tcg_gen_sub_i32(ret, t0, arg2);
 501     tcg_temp_free_i32(t0);
 502 }
 503
 504 static inline void tcg_gen_subi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 505 {
 506     /* some cases can be optimized here */
 507     if (arg2 == 0) {
 508         tcg_gen_mov_i32(ret, arg1);
 509     } else {
 510         TCGv_i32 t0 = tcg_const_i32(arg2);
 511         tcg_gen_sub_i32(ret, arg1, t0);
 512         tcg_temp_free_i32(t0);
 513     }
 514 }
 515
 516 static inline void tcg_gen_and_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 517 {
 518     if (TCGV_EQUAL_I32(arg1, arg2)) {
 519         tcg_gen_mov_i32(ret, arg1);
 520     } else {
 521         tcg_gen_op3_i32(INDEX_op_and_i32, ret, arg1, arg2);
 522     }
 523 }
 524
 525 static inline void tcg_gen_andi_i32(TCGv_i32 ret, TCGv_i32 arg1, uint32_t arg2)
 526 {
 527     TCGv_i32 t0;
 528     /* Some cases can be optimized here.  */
 529     switch (arg2) {
 530     case 0:
 531         tcg_gen_movi_i32(ret, 0);
 532         return;
 533     case 0xffffffffu:
 534         tcg_gen_mov_i32(ret, arg1);
 535         return;
 536     case 0xffu:
 537         /* Don't recurse with tcg_gen_ext8u_i32.  */
 538         if (TCG_TARGET_HAS_ext8u_i32) {
 539             tcg_gen_op2_i32(INDEX_op_ext8u_i32, ret, arg1);
 540             return;
 541         }
 542         break;
 543     case 0xffffu:
 544         if (TCG_TARGET_HAS_ext16u_i32) {
 545             tcg_gen_op2_i32(INDEX_op_ext16u_i32, ret, arg1);
 546             return;
 547         }
 548         break;
 549     }
 550     t0 = tcg_const_i32(arg2);
 551     tcg_gen_and_i32(ret, arg1, t0);
 552     tcg_temp_free_i32(t0);
 553 }
 554
 555 static inline void tcg_gen_or_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 556 {
 557     if (TCGV_EQUAL_I32(arg1, arg2)) {
 558         tcg_gen_mov_i32(ret, arg1);
 559     } else {
 560         tcg_gen_op3_i32(INDEX_op_or_i32, ret, arg1, arg2);
 561     }
 562 }
 563
 564 static inline void tcg_gen_ori_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 565 {
 566     /* Some cases can be optimized here.  */
 567     if (arg2 == -1) {
 568         tcg_gen_movi_i32(ret, -1);
 569     } else if (arg2 == 0) {
 570         tcg_gen_mov_i32(ret, arg1);
 571     } else {
 572         TCGv_i32 t0 = tcg_const_i32(arg2);
 573         tcg_gen_or_i32(ret, arg1, t0);
 574         tcg_temp_free_i32(t0);
 575     }
 576 }
 577
 578 static inline void tcg_gen_xor_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 579 {
 580     if (TCGV_EQUAL_I32(arg1, arg2)) {
 581         tcg_gen_movi_i32(ret, 0);
 582     } else {
 583         tcg_gen_op3_i32(INDEX_op_xor_i32, ret, arg1, arg2);
 584     }
 585 }
 586
 587 static inline void tcg_gen_xori_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 588 {
 589     /* Some cases can be optimized here.  */
 590     if (arg2 == 0) {
 591         tcg_gen_mov_i32(ret, arg1);
 592     } else if (arg2 == -1 && TCG_TARGET_HAS_not_i32) {
 593         /* Don't recurse with tcg_gen_not_i32.  */
 594         tcg_gen_op2_i32(INDEX_op_not_i32, ret, arg1);
 595     } else {
 596         TCGv_i32 t0 = tcg_const_i32(arg2);
 597         tcg_gen_xor_i32(ret, arg1, t0);
 598         tcg_temp_free_i32(t0);
 599     }
 600 }
 601
 602 static inline void tcg_gen_shl_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 603 {
 604     tcg_gen_op3_i32(INDEX_op_shl_i32, ret, arg1, arg2);
 605 }
 606
 607 static inline void tcg_gen_shli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 608 {
 609     if (arg2 == 0) {
 610         tcg_gen_mov_i32(ret, arg1);
 611     } else {
 612         TCGv_i32 t0 = tcg_const_i32(arg2);
 613         tcg_gen_shl_i32(ret, arg1, t0);
 614         tcg_temp_free_i32(t0);
 615     }
 616 }
 617
 618 static inline void tcg_gen_shr_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 619 {
 620     tcg_gen_op3_i32(INDEX_op_shr_i32, ret, arg1, arg2);
 621 }
 622
 623 static inline void tcg_gen_shri_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 624 {
 625     if (arg2 == 0) {
 626         tcg_gen_mov_i32(ret, arg1);
 627     } else {
 628         TCGv_i32 t0 = tcg_const_i32(arg2);
 629         tcg_gen_shr_i32(ret, arg1, t0);
 630         tcg_temp_free_i32(t0);
 631     }
 632 }
 633
 634 static inline void tcg_gen_sar_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 635 {
 636     tcg_gen_op3_i32(INDEX_op_sar_i32, ret, arg1, arg2);
 637 }
 638
 639 static inline void tcg_gen_sari_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 640 {
 641     if (arg2 == 0) {
 642         tcg_gen_mov_i32(ret, arg1);
 643     } else {
 644         TCGv_i32 t0 = tcg_const_i32(arg2);
 645         tcg_gen_sar_i32(ret, arg1, t0);
 646         tcg_temp_free_i32(t0);
 647     }
 648 }
 649
 650 static inline void tcg_gen_brcond_i32(TCGCond cond, TCGv_i32 arg1,
 651                                       TCGv_i32 arg2, int label_index)
 652 {
 653     if (cond == TCG_COND_ALWAYS) {
 654         tcg_gen_br(label_index);
 655     } else if (cond != TCG_COND_NEVER) {
 656         tcg_gen_op4ii_i32(INDEX_op_brcond_i32, arg1, arg2, cond, label_index);
 657     }
 658 }
 659
 660 static inline void tcg_gen_brcondi_i32(TCGCond cond, TCGv_i32 arg1,
 661                                        int32_t arg2, int label_index)
 662 {
 663     if (cond == TCG_COND_ALWAYS) {
 664         tcg_gen_br(label_index);
 665     } else if (cond != TCG_COND_NEVER) {
 666         TCGv_i32 t0 = tcg_const_i32(arg2);
 667         tcg_gen_brcond_i32(cond, arg1, t0, label_index);
 668         tcg_temp_free_i32(t0);
 669     }
 670 }
 671
 672 static inline void tcg_gen_setcond_i32(TCGCond cond, TCGv_i32 ret,
 673                                        TCGv_i32 arg1, TCGv_i32 arg2)
 674 {
 675     if (cond == TCG_COND_ALWAYS) {
 676         tcg_gen_movi_i32(ret, 1);
 677     } else if (cond == TCG_COND_NEVER) {
 678         tcg_gen_movi_i32(ret, 0);
 679     } else {
 680         tcg_gen_op4i_i32(INDEX_op_setcond_i32, ret, arg1, arg2, cond);
 681     }
 682 }
 683
 684 static inline void tcg_gen_setcondi_i32(TCGCond cond, TCGv_i32 ret,
 685                                         TCGv_i32 arg1, int32_t arg2)
 686 {
 687     if (cond == TCG_COND_ALWAYS) {
 688         tcg_gen_movi_i32(ret, 1);
 689     } else if (cond == TCG_COND_NEVER) {
 690         tcg_gen_movi_i32(ret, 0);
 691     } else {
 692         TCGv_i32 t0 = tcg_const_i32(arg2);
 693         tcg_gen_setcond_i32(cond, ret, arg1, t0);
 694         tcg_temp_free_i32(t0);
 695     }
 696 }
 697
 698 static inline void tcg_gen_mul_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 699 {
 700     tcg_gen_op3_i32(INDEX_op_mul_i32, ret, arg1, arg2);
 701 }
 702
 703 static inline void tcg_gen_muli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 704 {
 705     TCGv_i32 t0 = tcg_const_i32(arg2);
 706     tcg_gen_mul_i32(ret, arg1, t0);
 707     tcg_temp_free_i32(t0);
 708 }
 709
 710 static inline void tcg_gen_div_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 711 {
 712     if (TCG_TARGET_HAS_div_i32) {
 713         tcg_gen_op3_i32(INDEX_op_div_i32, ret, arg1, arg2);
 714     } else if (TCG_TARGET_HAS_div2_i32) {
 715         TCGv_i32 t0 = tcg_temp_new_i32();
 716         tcg_gen_sari_i32(t0, arg1, 31);
 717         tcg_gen_op5_i32(INDEX_op_div2_i32, ret, t0, arg1, t0, arg2);
 718         tcg_temp_free_i32(t0);
 719     } else {
 720         int sizemask = 0;
 721         /* Return value and both arguments are 32-bit and signed.  */
 722         sizemask |= tcg_gen_sizemask(0, 0, 1);
 723         sizemask |= tcg_gen_sizemask(1, 0, 1);
 724         sizemask |= tcg_gen_sizemask(2, 0, 1);
 725         tcg_gen_helper32(tcg_helper_div_i32, sizemask, ret, arg1, arg2);
 726     }
 727 }
 728
 729 static inline void tcg_gen_rem_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 730 {
 731     if (TCG_TARGET_HAS_rem_i32) {
 732         tcg_gen_op3_i32(INDEX_op_rem_i32, ret, arg1, arg2);
 733     } else if (TCG_TARGET_HAS_div_i32) {
 734         TCGv_i32 t0 = tcg_temp_new_i32();
 735         tcg_gen_op3_i32(INDEX_op_div_i32, t0, arg1, arg2);
 736         tcg_gen_mul_i32(t0, t0, arg2);
 737         tcg_gen_sub_i32(ret, arg1, t0);
 738         tcg_temp_free_i32(t0);
 739     } else if (TCG_TARGET_HAS_div2_i32) {
 740         TCGv_i32 t0 = tcg_temp_new_i32();
 741         tcg_gen_sari_i32(t0, arg1, 31);
 742         tcg_gen_op5_i32(INDEX_op_div2_i32, t0, ret, arg1, t0, arg2);
 743         tcg_temp_free_i32(t0);
 744     } else {
 745         int sizemask = 0;
 746         /* Return value and both arguments are 32-bit and signed.  */
 747         sizemask |= tcg_gen_sizemask(0, 0, 1);
 748         sizemask |= tcg_gen_sizemask(1, 0, 1);
 749         sizemask |= tcg_gen_sizemask(2, 0, 1);
 750         tcg_gen_helper32(tcg_helper_rem_i32, sizemask, ret, arg1, arg2);
 751     }
 752 }
 753
 754 static inline void tcg_gen_divu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 755 {
 756     if (TCG_TARGET_HAS_div_i32) {
 757         tcg_gen_op3_i32(INDEX_op_divu_i32, ret, arg1, arg2);
 758     } else if (TCG_TARGET_HAS_div2_i32) {
 759         TCGv_i32 t0 = tcg_temp_new_i32();
 760         tcg_gen_movi_i32(t0, 0);
 761         tcg_gen_op5_i32(INDEX_op_divu2_i32, ret, t0, arg1, t0, arg2);
 762         tcg_temp_free_i32(t0);
 763     } else {
 764         int sizemask = 0;
 765         /* Return value and both arguments are 32-bit and unsigned.  */
 766         sizemask |= tcg_gen_sizemask(0, 0, 0);
 767         sizemask |= tcg_gen_sizemask(1, 0, 0);
 768         sizemask |= tcg_gen_sizemask(2, 0, 0);
 769         tcg_gen_helper32(tcg_helper_divu_i32, sizemask, ret, arg1, arg2);
 770     }
 771 }
 772
 773 static inline void tcg_gen_remu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 774 {
 775     if (TCG_TARGET_HAS_rem_i32) {
 776         tcg_gen_op3_i32(INDEX_op_remu_i32, ret, arg1, arg2);
 777     } else if (TCG_TARGET_HAS_div_i32) {
 778         TCGv_i32 t0 = tcg_temp_new_i32();
 779         tcg_gen_op3_i32(INDEX_op_divu_i32, t0, arg1, arg2);
 780         tcg_gen_mul_i32(t0, t0, arg2);
 781         tcg_gen_sub_i32(ret, arg1, t0);
 782         tcg_temp_free_i32(t0);
 783     } else if (TCG_TARGET_HAS_div2_i32) {
 784         TCGv_i32 t0 = tcg_temp_new_i32();
 785         tcg_gen_movi_i32(t0, 0);
 786         tcg_gen_op5_i32(INDEX_op_divu2_i32, t0, ret, arg1, t0, arg2);
 787         tcg_temp_free_i32(t0);
 788     } else {
 789         int sizemask = 0;
 790         /* Return value and both arguments are 32-bit and unsigned.  */
 791         sizemask |= tcg_gen_sizemask(0, 0, 0);
 792         sizemask |= tcg_gen_sizemask(1, 0, 0);
 793         sizemask |= tcg_gen_sizemask(2, 0, 0);
 794         tcg_gen_helper32(tcg_helper_remu_i32, sizemask, ret, arg1, arg2);
 795     }
 796 }
 797
 798 #if TCG_TARGET_REG_BITS == 32
 799
 800 static inline void tcg_gen_mov_i64(TCGv_i64 ret, TCGv_i64 arg)
 801 {
 802     if (!TCGV_EQUAL_I64(ret, arg)) {
 803         tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg));
 804         tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg));
 805     }
 806 }
 807
 808 static inline void tcg_gen_movi_i64(TCGv_i64 ret, int64_t arg)
 809 {
 810     tcg_gen_movi_i32(TCGV_LOW(ret), arg);
 811     tcg_gen_movi_i32(TCGV_HIGH(ret), arg >> 32);
 812 }
 813
 814 static inline void tcg_gen_ld8u_i64(TCGv_i64 ret, TCGv_ptr arg2,
 815                                     tcg_target_long offset)
 816 {
 817     tcg_gen_ld8u_i32(TCGV_LOW(ret), arg2, offset);
 818     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 819 }
 820
 821 static inline void tcg_gen_ld8s_i64(TCGv_i64 ret, TCGv_ptr arg2,
 822                                     tcg_target_long offset)
 823 {
 824     tcg_gen_ld8s_i32(TCGV_LOW(ret), arg2, offset);
 825     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), 31);
 826 }
 827
 828 static inline void tcg_gen_ld16u_i64(TCGv_i64 ret, TCGv_ptr arg2,
 829                                      tcg_target_long offset)
 830 {
 831     tcg_gen_ld16u_i32(TCGV_LOW(ret), arg2, offset);
 832     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 833 }
 834
 835 static inline void tcg_gen_ld16s_i64(TCGv_i64 ret, TCGv_ptr arg2,
 836                                      tcg_target_long offset)
 837 {
 838     tcg_gen_ld16s_i32(TCGV_LOW(ret), arg2, offset);
 839     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
 840 }
 841
 842 static inline void tcg_gen_ld32u_i64(TCGv_i64 ret, TCGv_ptr arg2,
 843                                      tcg_target_long offset)
 844 {
 845     tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset);
 846     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 847 }
 848
 849 static inline void tcg_gen_ld32s_i64(TCGv_i64 ret, TCGv_ptr arg2,
 850                                      tcg_target_long offset)
 851 {
 852     tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset);
 853     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
 854 }
 855
 856 static inline void tcg_gen_ld_i64(TCGv_i64 ret, TCGv_ptr arg2,
 857                                   tcg_target_long offset)
 858 {
 859     /* since arg2 and ret have different types, they cannot be the
 860        same temporary */
 861 #ifdef HOST_WORDS_BIGENDIAN
 862     tcg_gen_ld_i32(TCGV_HIGH(ret), arg2, offset);
 863     tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset + 4);
 864 #else
 865     tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset);
 866     tcg_gen_ld_i32(TCGV_HIGH(ret), arg2, offset + 4);
 867 #endif
 868 }
 869
 870 static inline void tcg_gen_st8_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 871                                    tcg_target_long offset)
 872 {
 873     tcg_gen_st8_i32(TCGV_LOW(arg1), arg2, offset);
 874 }
 875
 876 static inline void tcg_gen_st16_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 877                                     tcg_target_long offset)
 878 {
 879     tcg_gen_st16_i32(TCGV_LOW(arg1), arg2, offset);
 880 }
 881
 882 static inline void tcg_gen_st32_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 883                                     tcg_target_long offset)
 884 {
 885     tcg_gen_st_i32(TCGV_LOW(arg1), arg2, offset);
 886 }
 887
 888 static inline void tcg_gen_st_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 889                                   tcg_target_long offset)
 890 {
 891 #ifdef HOST_WORDS_BIGENDIAN
 892     tcg_gen_st_i32(TCGV_HIGH(arg1), arg2, offset);
 893     tcg_gen_st_i32(TCGV_LOW(arg1), arg2, offset + 4);
 894 #else
 895     tcg_gen_st_i32(TCGV_LOW(arg1), arg2, offset);
 896     tcg_gen_st_i32(TCGV_HIGH(arg1), arg2, offset + 4);
 897 #endif
 898 }
 899
 900 static inline void tcg_gen_add_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 901 {
 902     tcg_gen_op6_i32(INDEX_op_add2_i32, TCGV_LOW(ret), TCGV_HIGH(ret),
 903                     TCGV_LOW(arg1), TCGV_HIGH(arg1), TCGV_LOW(arg2),
 904                     TCGV_HIGH(arg2));
 905     /* Allow the optimizer room to replace add2 with two moves.  */
 906     tcg_gen_op0(INDEX_op_nop);
 907 }
 908
 909 static inline void tcg_gen_sub_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 910 {
 911     tcg_gen_op6_i32(INDEX_op_sub2_i32, TCGV_LOW(ret), TCGV_HIGH(ret),
 912                     TCGV_LOW(arg1), TCGV_HIGH(arg1), TCGV_LOW(arg2),
 913                     TCGV_HIGH(arg2));
 914     /* Allow the optimizer room to replace sub2 with two moves.  */
 915     tcg_gen_op0(INDEX_op_nop);
 916 }
 917
 918 static inline void tcg_gen_and_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 919 {
 920     tcg_gen_and_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 921     tcg_gen_and_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 922 }
 923
 924 static inline void tcg_gen_andi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 925 {
 926     tcg_gen_andi_i32(TCGV_LOW(ret), TCGV_LOW(arg1), arg2);
 927     tcg_gen_andi_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
 928 }
 929
 930 static inline void tcg_gen_or_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 931 {
 932     tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 933     tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 934 }
 935
 936 static inline void tcg_gen_ori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 937 {
 938     tcg_gen_ori_i32(TCGV_LOW(ret), TCGV_LOW(arg1), arg2);
 939     tcg_gen_ori_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
 940 }
 941
 942 static inline void tcg_gen_xor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 943 {
 944     tcg_gen_xor_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 945     tcg_gen_xor_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 946 }
 947
 948 static inline void tcg_gen_xori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 949 {
 950     tcg_gen_xori_i32(TCGV_LOW(ret), TCGV_LOW(arg1), arg2);
 951     tcg_gen_xori_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
 952 }
 953
 954 /* XXX: use generic code when basic block handling is OK or CPU
 955    specific code (x86) */
 956 static inline void tcg_gen_shl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 957 {
 958     int sizemask = 0;
 959     /* Return value and both arguments are 64-bit and signed.  */
 960     sizemask |= tcg_gen_sizemask(0, 1, 1);
 961     sizemask |= tcg_gen_sizemask(1, 1, 1);
 962     sizemask |= tcg_gen_sizemask(2, 1, 1);
 963
 964     tcg_gen_helper64(tcg_helper_shl_i64, sizemask, ret, arg1, arg2);
 965 }
 966
 967 static inline void tcg_gen_shli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 968 {
 969     tcg_gen_shifti_i64(ret, arg1, arg2, 0, 0);
 970 }
 971
 972 static inline void tcg_gen_shr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 973 {
 974     int sizemask = 0;
 975     /* Return value and both arguments are 64-bit and signed.  */
 976     sizemask |= tcg_gen_sizemask(0, 1, 1);
 977     sizemask |= tcg_gen_sizemask(1, 1, 1);
 978     sizemask |= tcg_gen_sizemask(2, 1, 1);
 979
 980     tcg_gen_helper64(tcg_helper_shr_i64, sizemask, ret, arg1, arg2);
 981 }
 982
 983 static inline void tcg_gen_shri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 984 {
 985     tcg_gen_shifti_i64(ret, arg1, arg2, 1, 0);
 986 }
 987
 988 static inline void tcg_gen_sar_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 989 {
 990     int sizemask = 0;
 991     /* Return value and both arguments are 64-bit and signed.  */
 992     sizemask |= tcg_gen_sizemask(0, 1, 1);
 993     sizemask |= tcg_gen_sizemask(1, 1, 1);
 994     sizemask |= tcg_gen_sizemask(2, 1, 1);
 995
 996     tcg_gen_helper64(tcg_helper_sar_i64, sizemask, ret, arg1, arg2);
 997 }
 998
 999 static inline void tcg_gen_sari_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1000 {
1001     tcg_gen_shifti_i64(ret, arg1, arg2, 1, 1);
1002 }
1003
1004 static inline void tcg_gen_brcond_i64(TCGCond cond, TCGv_i64 arg1,
1005                                       TCGv_i64 arg2, int label_index)
1006 {
1007     if (cond == TCG_COND_ALWAYS) {
1008         tcg_gen_br(label_index);
1009     } else if (cond != TCG_COND_NEVER) {
1010         tcg_gen_op6ii_i32(INDEX_op_brcond2_i32,
1011                           TCGV_LOW(arg1), TCGV_HIGH(arg1), TCGV_LOW(arg2),
1012                           TCGV_HIGH(arg2), cond, label_index);
1013     }
1014 }
1015
1016 static inline void tcg_gen_setcond_i64(TCGCond cond, TCGv_i64 ret,
1017                                        TCGv_i64 arg1, TCGv_i64 arg2)
1018 {
1019     if (cond == TCG_COND_ALWAYS) {
1020         tcg_gen_movi_i32(TCGV_LOW(ret), 1);
1021     } else if (cond == TCG_COND_NEVER) {
1022         tcg_gen_movi_i32(TCGV_LOW(ret), 0);
1023     } else {
1024         tcg_gen_op6i_i32(INDEX_op_setcond2_i32, TCGV_LOW(ret),
1025                          TCGV_LOW(arg1), TCGV_HIGH(arg1),
1026                          TCGV_LOW(arg2), TCGV_HIGH(arg2), cond);
1027     }
1028     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1029 }
1030
1031 static inline void tcg_gen_mul_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1032 {
1033     TCGv_i64 t0;
1034     TCGv_i32 t1;
1035
1036     t0 = tcg_temp_new_i64();
1037     t1 = tcg_temp_new_i32();
1038
1039     if (TCG_TARGET_HAS_mulu2_i32) {
1040         tcg_gen_op4_i32(INDEX_op_mulu2_i32, TCGV_LOW(t0), TCGV_HIGH(t0),
1041                         TCGV_LOW(arg1), TCGV_LOW(arg2));
1042         /* Allow the optimizer room to replace mulu2 with two moves.  */
1043         tcg_gen_op0(INDEX_op_nop);
1044     } else {
1045         tcg_debug_assert(TCG_TARGET_HAS_muluh_i32);
1046         tcg_gen_op3_i32(INDEX_op_mul_i32, TCGV_LOW(t0),
1047                         TCGV_LOW(arg1), TCGV_LOW(arg2));
1048         tcg_gen_op3_i32(INDEX_op_muluh_i32, TCGV_HIGH(t0),
1049                         TCGV_LOW(arg1), TCGV_LOW(arg2));
1050     }
1051
1052     tcg_gen_mul_i32(t1, TCGV_LOW(arg1), TCGV_HIGH(arg2));
1053     tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1);
1054     tcg_gen_mul_i32(t1, TCGV_HIGH(arg1), TCGV_LOW(arg2));
1055     tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1);
1056
1057     tcg_gen_mov_i64(ret, t0);
1058     tcg_temp_free_i64(t0);
1059     tcg_temp_free_i32(t1);
1060 }
1061
1062 static inline void tcg_gen_div_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1063 {
1064     int sizemask = 0;
1065     /* Return value and both arguments are 64-bit and signed.  */
1066     sizemask |= tcg_gen_sizemask(0, 1, 1);
1067     sizemask |= tcg_gen_sizemask(1, 1, 1);
1068     sizemask |= tcg_gen_sizemask(2, 1, 1);
1069
1070     tcg_gen_helper64(tcg_helper_div_i64, sizemask, ret, arg1, arg2);
1071 }
1072
1073 static inline void tcg_gen_rem_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1074 {
1075     int sizemask = 0;
1076     /* Return value and both arguments are 64-bit and signed.  */
1077     sizemask |= tcg_gen_sizemask(0, 1, 1);
1078     sizemask |= tcg_gen_sizemask(1, 1, 1);
1079     sizemask |= tcg_gen_sizemask(2, 1, 1);
1080
1081     tcg_gen_helper64(tcg_helper_rem_i64, sizemask, ret, arg1, arg2);
1082 }
1083
1084 static inline void tcg_gen_divu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1085 {
1086     int sizemask = 0;
1087     /* Return value and both arguments are 64-bit and unsigned.  */
1088     sizemask |= tcg_gen_sizemask(0, 1, 0);
1089     sizemask |= tcg_gen_sizemask(1, 1, 0);
1090     sizemask |= tcg_gen_sizemask(2, 1, 0);
1091
1092     tcg_gen_helper64(tcg_helper_divu_i64, sizemask, ret, arg1, arg2);
1093 }
1094
1095 static inline void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1096 {
1097     int sizemask = 0;
1098     /* Return value and both arguments are 64-bit and unsigned.  */
1099     sizemask |= tcg_gen_sizemask(0, 1, 0);
1100     sizemask |= tcg_gen_sizemask(1, 1, 0);
1101     sizemask |= tcg_gen_sizemask(2, 1, 0);
1102
1103     tcg_gen_helper64(tcg_helper_remu_i64, sizemask, ret, arg1, arg2);
1104 }
1105
1106 #else
1107
1108 static inline void tcg_gen_mov_i64(TCGv_i64 ret, TCGv_i64 arg)
1109 {
1110     if (!TCGV_EQUAL_I64(ret, arg))
1111         tcg_gen_op2_i64(INDEX_op_mov_i64, ret, arg);
1112 }
1113
1114 static inline void tcg_gen_movi_i64(TCGv_i64 ret, int64_t arg)
1115 {
1116     tcg_gen_op2i_i64(INDEX_op_movi_i64, ret, arg);
1117 }
1118
1119 static inline void tcg_gen_ld8u_i64(TCGv_i64 ret, TCGv_ptr arg2,
1120                                     tcg_target_long offset)
1121 {
1122     tcg_gen_ldst_op_i64(INDEX_op_ld8u_i64, ret, arg2, offset);
1123 }
1124
1125 static inline void tcg_gen_ld8s_i64(TCGv_i64 ret, TCGv_ptr arg2,
1126                                     tcg_target_long offset)
1127 {
1128     tcg_gen_ldst_op_i64(INDEX_op_ld8s_i64, ret, arg2, offset);
1129 }
1130
1131 static inline void tcg_gen_ld16u_i64(TCGv_i64 ret, TCGv_ptr arg2,
1132                                      tcg_target_long offset)
1133 {
1134     tcg_gen_ldst_op_i64(INDEX_op_ld16u_i64, ret, arg2, offset);
1135 }
1136
1137 static inline void tcg_gen_ld16s_i64(TCGv_i64 ret, TCGv_ptr arg2,
1138                                      tcg_target_long offset)
1139 {
1140     tcg_gen_ldst_op_i64(INDEX_op_ld16s_i64, ret, arg2, offset);
1141 }
1142
1143 static inline void tcg_gen_ld32u_i64(TCGv_i64 ret, TCGv_ptr arg2,
1144                                      tcg_target_long offset)
1145 {
1146     tcg_gen_ldst_op_i64(INDEX_op_ld32u_i64, ret, arg2, offset);
1147 }
1148
1149 static inline void tcg_gen_ld32s_i64(TCGv_i64 ret, TCGv_ptr arg2,
1150                                      tcg_target_long offset)
1151 {
1152     tcg_gen_ldst_op_i64(INDEX_op_ld32s_i64, ret, arg2, offset);
1153 }
1154
1155 static inline void tcg_gen_ld_i64(TCGv_i64 ret, TCGv_ptr arg2, tcg_target_long offset)
1156 {
1157     tcg_gen_ldst_op_i64(INDEX_op_ld_i64, ret, arg2, offset);
1158 }
1159
1160 static inline void tcg_gen_st8_i64(TCGv_i64 arg1, TCGv_ptr arg2,
1161                                    tcg_target_long offset)
1162 {
1163     tcg_gen_ldst_op_i64(INDEX_op_st8_i64, arg1, arg2, offset);
1164 }
1165
1166 static inline void tcg_gen_st16_i64(TCGv_i64 arg1, TCGv_ptr arg2,
1167                                     tcg_target_long offset)
1168 {
1169     tcg_gen_ldst_op_i64(INDEX_op_st16_i64, arg1, arg2, offset);
1170 }
1171
1172 static inline void tcg_gen_st32_i64(TCGv_i64 arg1, TCGv_ptr arg2,
1173                                     tcg_target_long offset)
1174 {
1175     tcg_gen_ldst_op_i64(INDEX_op_st32_i64, arg1, arg2, offset);
1176 }
1177
1178 static inline void tcg_gen_st_i64(TCGv_i64 arg1, TCGv_ptr arg2, tcg_target_long offset)
1179 {
1180     tcg_gen_ldst_op_i64(INDEX_op_st_i64, arg1, arg2, offset);
1181 }
1182
1183 static inline void tcg_gen_add_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1184 {
1185     tcg_gen_op3_i64(INDEX_op_add_i64, ret, arg1, arg2);
1186 }
1187
1188 static inline void tcg_gen_sub_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1189 {
1190     tcg_gen_op3_i64(INDEX_op_sub_i64, ret, arg1, arg2);
1191 }
1192
1193 static inline void tcg_gen_and_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1194 {
1195     if (TCGV_EQUAL_I64(arg1, arg2)) {
1196         tcg_gen_mov_i64(ret, arg1);
1197     } else {
1198         tcg_gen_op3_i64(INDEX_op_and_i64, ret, arg1, arg2);
1199     }
1200 }
1201
1202 static inline void tcg_gen_andi_i64(TCGv_i64 ret, TCGv_i64 arg1, uint64_t arg2)
1203 {
1204     TCGv_i64 t0;
1205     /* Some cases can be optimized here.  */
1206     switch (arg2) {
1207     case 0:
1208         tcg_gen_movi_i64(ret, 0);
1209         return;
1210     case 0xffffffffffffffffull:
1211         tcg_gen_mov_i64(ret, arg1);
1212         return;
1213     case 0xffull:
1214         /* Don't recurse with tcg_gen_ext8u_i32.  */
1215         if (TCG_TARGET_HAS_ext8u_i64) {
1216             tcg_gen_op2_i64(INDEX_op_ext8u_i64, ret, arg1);
1217             return;
1218         }
1219         break;
1220     case 0xffffu:
1221         if (TCG_TARGET_HAS_ext16u_i64) {
1222             tcg_gen_op2_i64(INDEX_op_ext16u_i64, ret, arg1);
1223             return;
1224         }
1225         break;
1226     case 0xffffffffull:
1227         if (TCG_TARGET_HAS_ext32u_i64) {
1228             tcg_gen_op2_i64(INDEX_op_ext32u_i64, ret, arg1);
1229             return;
1230         }
1231         break;
1232     }
1233     t0 = tcg_const_i64(arg2);
1234     tcg_gen_and_i64(ret, arg1, t0);
1235     tcg_temp_free_i64(t0);
1236 }
1237
1238 static inline void tcg_gen_or_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1239 {
1240     if (TCGV_EQUAL_I64(arg1, arg2)) {
1241         tcg_gen_mov_i64(ret, arg1);
1242     } else {
1243         tcg_gen_op3_i64(INDEX_op_or_i64, ret, arg1, arg2);
1244     }
1245 }
1246
1247 static inline void tcg_gen_ori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1248 {
1249     /* Some cases can be optimized here.  */
1250     if (arg2 == -1) {
1251         tcg_gen_movi_i64(ret, -1);
1252     } else if (arg2 == 0) {
1253         tcg_gen_mov_i64(ret, arg1);
1254     } else {
1255         TCGv_i64 t0 = tcg_const_i64(arg2);
1256         tcg_gen_or_i64(ret, arg1, t0);
1257         tcg_temp_free_i64(t0);
1258     }
1259 }
1260
1261 static inline void tcg_gen_xor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1262 {
1263     if (TCGV_EQUAL_I64(arg1, arg2)) {
1264         tcg_gen_movi_i64(ret, 0);
1265     } else {
1266         tcg_gen_op3_i64(INDEX_op_xor_i64, ret, arg1, arg2);
1267     }
1268 }
1269
1270 static inline void tcg_gen_xori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1271 {
1272     /* Some cases can be optimized here.  */
1273     if (arg2 == 0) {
1274         tcg_gen_mov_i64(ret, arg1);
1275     } else if (arg2 == -1 && TCG_TARGET_HAS_not_i64) {
1276         /* Don't recurse with tcg_gen_not_i64.  */
1277         tcg_gen_op2_i64(INDEX_op_not_i64, ret, arg1);
1278     } else {
1279         TCGv_i64 t0 = tcg_const_i64(arg2);
1280         tcg_gen_xor_i64(ret, arg1, t0);
1281         tcg_temp_free_i64(t0);
1282     }
1283 }
1284
1285 static inline void tcg_gen_shl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1286 {
1287     tcg_gen_op3_i64(INDEX_op_shl_i64, ret, arg1, arg2);
1288 }
1289
1290 static inline void tcg_gen_shli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1291 {
1292     if (arg2 == 0) {
1293         tcg_gen_mov_i64(ret, arg1);
1294     } else {
1295         TCGv_i64 t0 = tcg_const_i64(arg2);
1296         tcg_gen_shl_i64(ret, arg1, t0);
1297         tcg_temp_free_i64(t0);
1298     }
1299 }
1300
1301 static inline void tcg_gen_shr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1302 {
1303     tcg_gen_op3_i64(INDEX_op_shr_i64, ret, arg1, arg2);
1304 }
1305
1306 static inline void tcg_gen_shri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1307 {
1308     if (arg2 == 0) {
1309         tcg_gen_mov_i64(ret, arg1);
1310     } else {
1311         TCGv_i64 t0 = tcg_const_i64(arg2);
1312         tcg_gen_shr_i64(ret, arg1, t0);
1313         tcg_temp_free_i64(t0);
1314     }
1315 }
1316
1317 static inline void tcg_gen_sar_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1318 {
1319     tcg_gen_op3_i64(INDEX_op_sar_i64, ret, arg1, arg2);
1320 }
1321
1322 static inline void tcg_gen_sari_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1323 {
1324     if (arg2 == 0) {
1325         tcg_gen_mov_i64(ret, arg1);
1326     } else {
1327         TCGv_i64 t0 = tcg_const_i64(arg2);
1328         tcg_gen_sar_i64(ret, arg1, t0);
1329         tcg_temp_free_i64(t0);
1330     }
1331 }
1332
1333 static inline void tcg_gen_brcond_i64(TCGCond cond, TCGv_i64 arg1,
1334                                       TCGv_i64 arg2, int label_index)
1335 {
1336     if (cond == TCG_COND_ALWAYS) {
1337         tcg_gen_br(label_index);
1338     } else if (cond != TCG_COND_NEVER) {
1339         tcg_gen_op4ii_i64(INDEX_op_brcond_i64, arg1, arg2, cond, label_index);
1340     }
1341 }
1342
1343 static inline void tcg_gen_setcond_i64(TCGCond cond, TCGv_i64 ret,
1344                                        TCGv_i64 arg1, TCGv_i64 arg2)
1345 {
1346     if (cond == TCG_COND_ALWAYS) {
1347         tcg_gen_movi_i64(ret, 1);
1348     } else if (cond == TCG_COND_NEVER) {
1349         tcg_gen_movi_i64(ret, 0);
1350     } else {
1351         tcg_gen_op4i_i64(INDEX_op_setcond_i64, ret, arg1, arg2, cond);
1352     }
1353 }
1354
1355 static inline void tcg_gen_mul_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1356 {
1357     tcg_gen_op3_i64(INDEX_op_mul_i64, ret, arg1, arg2);
1358 }
1359
1360 static inline void tcg_gen_div_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1361 {
1362     if (TCG_TARGET_HAS_div_i64) {
1363         tcg_gen_op3_i64(INDEX_op_div_i64, ret, arg1, arg2);
1364     } else if (TCG_TARGET_HAS_div2_i64) {
1365         TCGv_i64 t0 = tcg_temp_new_i64();
1366         tcg_gen_sari_i64(t0, arg1, 63);
1367         tcg_gen_op5_i64(INDEX_op_div2_i64, ret, t0, arg1, t0, arg2);
1368         tcg_temp_free_i64(t0);
1369     } else {
1370         int sizemask = 0;
1371         /* Return value and both arguments are 64-bit and signed.  */
1372         sizemask |= tcg_gen_sizemask(0, 1, 1);
1373         sizemask |= tcg_gen_sizemask(1, 1, 1);
1374         sizemask |= tcg_gen_sizemask(2, 1, 1);
1375         tcg_gen_helper64(tcg_helper_div_i64, sizemask, ret, arg1, arg2);
1376     }
1377 }
1378
1379 static inline void tcg_gen_rem_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1380 {
1381     if (TCG_TARGET_HAS_rem_i64) {
1382         tcg_gen_op3_i64(INDEX_op_rem_i64, ret, arg1, arg2);
1383     } else if (TCG_TARGET_HAS_div_i64) {
1384         TCGv_i64 t0 = tcg_temp_new_i64();
1385         tcg_gen_op3_i64(INDEX_op_div_i64, t0, arg1, arg2);
1386         tcg_gen_mul_i64(t0, t0, arg2);
1387         tcg_gen_sub_i64(ret, arg1, t0);
1388         tcg_temp_free_i64(t0);
1389     } else if (TCG_TARGET_HAS_div2_i64) {
1390         TCGv_i64 t0 = tcg_temp_new_i64();
1391         tcg_gen_sari_i64(t0, arg1, 63);
1392         tcg_gen_op5_i64(INDEX_op_div2_i64, t0, ret, arg1, t0, arg2);
1393         tcg_temp_free_i64(t0);
1394     } else {
1395         int sizemask = 0;
1396         /* Return value and both arguments are 64-bit and signed.  */
1397         sizemask |= tcg_gen_sizemask(0, 1, 1);
1398         sizemask |= tcg_gen_sizemask(1, 1, 1);
1399         sizemask |= tcg_gen_sizemask(2, 1, 1);
1400         tcg_gen_helper64(tcg_helper_rem_i64, sizemask, ret, arg1, arg2);
1401     }
1402 }
1403
1404 static inline void tcg_gen_divu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1405 {
1406     if (TCG_TARGET_HAS_div_i64) {
1407         tcg_gen_op3_i64(INDEX_op_divu_i64, ret, arg1, arg2);
1408     } else if (TCG_TARGET_HAS_div2_i64) {
1409         TCGv_i64 t0 = tcg_temp_new_i64();
1410         tcg_gen_movi_i64(t0, 0);
1411         tcg_gen_op5_i64(INDEX_op_divu2_i64, ret, t0, arg1, t0, arg2);
1412         tcg_temp_free_i64(t0);
1413     } else {
1414         int sizemask = 0;
1415         /* Return value and both arguments are 64-bit and unsigned.  */
1416         sizemask |= tcg_gen_sizemask(0, 1, 0);
1417         sizemask |= tcg_gen_sizemask(1, 1, 0);
1418         sizemask |= tcg_gen_sizemask(2, 1, 0);
1419         tcg_gen_helper64(tcg_helper_divu_i64, sizemask, ret, arg1, arg2);
1420     }
1421 }
1422
1423 static inline void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1424 {
1425     if (TCG_TARGET_HAS_rem_i64) {
1426         tcg_gen_op3_i64(INDEX_op_remu_i64, ret, arg1, arg2);
1427     } else if (TCG_TARGET_HAS_div_i64) {
1428         TCGv_i64 t0 = tcg_temp_new_i64();
1429         tcg_gen_op3_i64(INDEX_op_divu_i64, t0, arg1, arg2);
1430         tcg_gen_mul_i64(t0, t0, arg2);
1431         tcg_gen_sub_i64(ret, arg1, t0);
1432         tcg_temp_free_i64(t0);
1433     } else if (TCG_TARGET_HAS_div2_i64) {
1434         TCGv_i64 t0 = tcg_temp_new_i64();
1435         tcg_gen_movi_i64(t0, 0);
1436         tcg_gen_op5_i64(INDEX_op_divu2_i64, t0, ret, arg1, t0, arg2);
1437         tcg_temp_free_i64(t0);
1438     } else {
1439         int sizemask = 0;
1440         /* Return value and both arguments are 64-bit and unsigned.  */
1441         sizemask |= tcg_gen_sizemask(0, 1, 0);
1442         sizemask |= tcg_gen_sizemask(1, 1, 0);
1443         sizemask |= tcg_gen_sizemask(2, 1, 0);
1444         tcg_gen_helper64(tcg_helper_remu_i64, sizemask, ret, arg1, arg2);
1445     }
1446 }
1447 #endif /* TCG_TARGET_REG_BITS == 32 */
1448
1449 static inline void tcg_gen_addi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1450 {
1451     /* some cases can be optimized here */
1452     if (arg2 == 0) {
1453         tcg_gen_mov_i64(ret, arg1);
1454     } else {
1455         TCGv_i64 t0 = tcg_const_i64(arg2);
1456         tcg_gen_add_i64(ret, arg1, t0);
1457         tcg_temp_free_i64(t0);
1458     }
1459 }
1460
1461 static inline void tcg_gen_subfi_i64(TCGv_i64 ret, int64_t arg1, TCGv_i64 arg2)
1462 {
1463     TCGv_i64 t0 = tcg_const_i64(arg1);
1464     tcg_gen_sub_i64(ret, t0, arg2);
1465     tcg_temp_free_i64(t0);
1466 }
1467
1468 static inline void tcg_gen_subi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1469 {
1470     /* some cases can be optimized here */
1471     if (arg2 == 0) {
1472         tcg_gen_mov_i64(ret, arg1);
1473     } else {
1474         TCGv_i64 t0 = tcg_const_i64(arg2);
1475         tcg_gen_sub_i64(ret, arg1, t0);
1476         tcg_temp_free_i64(t0);
1477     }
1478 }
1479 static inline void tcg_gen_brcondi_i64(TCGCond cond, TCGv_i64 arg1,
1480                                        int64_t arg2, int label_index)
1481 {
1482     if (cond == TCG_COND_ALWAYS) {
1483         tcg_gen_br(label_index);
1484     } else if (cond != TCG_COND_NEVER) {
1485         TCGv_i64 t0 = tcg_const_i64(arg2);
1486         tcg_gen_brcond_i64(cond, arg1, t0, label_index);
1487         tcg_temp_free_i64(t0);
1488     }
1489 }
1490
1491 static inline void tcg_gen_setcondi_i64(TCGCond cond, TCGv_i64 ret,
1492                                         TCGv_i64 arg1, int64_t arg2)
1493 {
1494     TCGv_i64 t0 = tcg_const_i64(arg2);
1495     tcg_gen_setcond_i64(cond, ret, arg1, t0);
1496     tcg_temp_free_i64(t0);
1497 }
1498
1499 static inline void tcg_gen_muli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1500 {
1501     TCGv_i64 t0 = tcg_const_i64(arg2);
1502     tcg_gen_mul_i64(ret, arg1, t0);
1503     tcg_temp_free_i64(t0);
1504 }
1505
1506
1507 /***************************************/
1508 /* optional operations */
1509
1510 static inline void tcg_gen_ext8s_i32(TCGv_i32 ret, TCGv_i32 arg)
1511 {
1512     if (TCG_TARGET_HAS_ext8s_i32) {
1513         tcg_gen_op2_i32(INDEX_op_ext8s_i32, ret, arg);
1514     } else {
1515         tcg_gen_shli_i32(ret, arg, 24);
1516         tcg_gen_sari_i32(ret, ret, 24);
1517     }
1518 }
1519
1520 static inline void tcg_gen_ext16s_i32(TCGv_i32 ret, TCGv_i32 arg)
1521 {
1522     if (TCG_TARGET_HAS_ext16s_i32) {
1523         tcg_gen_op2_i32(INDEX_op_ext16s_i32, ret, arg);
1524     } else {
1525         tcg_gen_shli_i32(ret, arg, 16);
1526         tcg_gen_sari_i32(ret, ret, 16);
1527     }
1528 }
1529
1530 static inline void tcg_gen_ext8u_i32(TCGv_i32 ret, TCGv_i32 arg)
1531 {
1532     if (TCG_TARGET_HAS_ext8u_i32) {
1533         tcg_gen_op2_i32(INDEX_op_ext8u_i32, ret, arg);
1534     } else {
1535         tcg_gen_andi_i32(ret, arg, 0xffu);
1536     }
1537 }
1538
1539 static inline void tcg_gen_ext16u_i32(TCGv_i32 ret, TCGv_i32 arg)
1540 {
1541     if (TCG_TARGET_HAS_ext16u_i32) {
1542         tcg_gen_op2_i32(INDEX_op_ext16u_i32, ret, arg);
1543     } else {
1544         tcg_gen_andi_i32(ret, arg, 0xffffu);
1545     }
1546 }
1547
1548 /* Note: we assume the two high bytes are set to zero */
1549 static inline void tcg_gen_bswap16_i32(TCGv_i32 ret, TCGv_i32 arg)
1550 {
1551     if (TCG_TARGET_HAS_bswap16_i32) {
1552         tcg_gen_op2_i32(INDEX_op_bswap16_i32, ret, arg);
1553     } else {
1554         TCGv_i32 t0 = tcg_temp_new_i32();
1555
1556         tcg_gen_ext8u_i32(t0, arg);
1557         tcg_gen_shli_i32(t0, t0, 8);
1558         tcg_gen_shri_i32(ret, arg, 8);
1559         tcg_gen_or_i32(ret, ret, t0);
1560         tcg_temp_free_i32(t0);
1561     }
1562 }
1563
1564 static inline void tcg_gen_bswap32_i32(TCGv_i32 ret, TCGv_i32 arg)
1565 {
1566     if (TCG_TARGET_HAS_bswap32_i32) {
1567         tcg_gen_op2_i32(INDEX_op_bswap32_i32, ret, arg);
1568     } else {
1569         TCGv_i32 t0, t1;
1570         t0 = tcg_temp_new_i32();
1571         t1 = tcg_temp_new_i32();
1572
1573         tcg_gen_shli_i32(t0, arg, 24);
1574
1575         tcg_gen_andi_i32(t1, arg, 0x0000ff00);
1576         tcg_gen_shli_i32(t1, t1, 8);
1577         tcg_gen_or_i32(t0, t0, t1);
1578
1579         tcg_gen_shri_i32(t1, arg, 8);
1580         tcg_gen_andi_i32(t1, t1, 0x0000ff00);
1581         tcg_gen_or_i32(t0, t0, t1);
1582
1583         tcg_gen_shri_i32(t1, arg, 24);
1584         tcg_gen_or_i32(ret, t0, t1);
1585         tcg_temp_free_i32(t0);
1586         tcg_temp_free_i32(t1);
1587     }
1588 }
1589
1590 #if TCG_TARGET_REG_BITS == 32
1591 static inline void tcg_gen_ext8s_i64(TCGv_i64 ret, TCGv_i64 arg)
1592 {
1593     tcg_gen_ext8s_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1594     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
1595 }
1596
1597 static inline void tcg_gen_ext16s_i64(TCGv_i64 ret, TCGv_i64 arg)
1598 {
1599     tcg_gen_ext16s_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1600     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
1601 }
1602
1603 static inline void tcg_gen_ext32s_i64(TCGv_i64 ret, TCGv_i64 arg)
1604 {
1605     tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1606     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
1607 }
1608
1609 static inline void tcg_gen_ext8u_i64(TCGv_i64 ret, TCGv_i64 arg)
1610 {
1611     tcg_gen_ext8u_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1612     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1613 }
1614
1615 static inline void tcg_gen_ext16u_i64(TCGv_i64 ret, TCGv_i64 arg)
1616 {
1617     tcg_gen_ext16u_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1618     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1619 }
1620
1621 static inline void tcg_gen_ext32u_i64(TCGv_i64 ret, TCGv_i64 arg)
1622 {
1623     tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1624     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1625 }
1626
1627 static inline void tcg_gen_trunc_shr_i64_i32(TCGv_i32 ret, TCGv_i64 arg,
1628                                              unsigned int count)
1629 {
1630     tcg_debug_assert(count < 64);
1631     if (count >= 32) {
1632         tcg_gen_shri_i32(ret, TCGV_HIGH(arg), count - 32);
1633     } else if (count == 0) {
1634         tcg_gen_mov_i32(ret, TCGV_LOW(arg));
1635     } else {
1636         TCGv_i64 t = tcg_temp_new_i64();
1637         tcg_gen_shri_i64(t, arg, count);
1638         tcg_gen_mov_i32(ret, TCGV_LOW(t));
1639         tcg_temp_free_i64(t);
1640     }
1641 }
1642
1643 static inline void tcg_gen_extu_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
1644 {
1645     tcg_gen_mov_i32(TCGV_LOW(ret), arg);
1646     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1647 }
1648
1649 static inline void tcg_gen_ext_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
1650 {
1651     tcg_gen_mov_i32(TCGV_LOW(ret), arg);
1652     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
1653 }
1654
1655 /* Note: we assume the six high bytes are set to zero */
1656 static inline void tcg_gen_bswap16_i64(TCGv_i64 ret, TCGv_i64 arg)
1657 {
1658     tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg));
1659     tcg_gen_bswap16_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1660 }
1661
1662 /* Note: we assume the four high bytes are set to zero */
1663 static inline void tcg_gen_bswap32_i64(TCGv_i64 ret, TCGv_i64 arg)
1664 {
1665     tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg));
1666     tcg_gen_bswap32_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1667 }
1668
1669 static inline void tcg_gen_bswap64_i64(TCGv_i64 ret, TCGv_i64 arg)
1670 {
1671     TCGv_i32 t0, t1;
1672     t0 = tcg_temp_new_i32();
1673     t1 = tcg_temp_new_i32();
1674
1675     tcg_gen_bswap32_i32(t0, TCGV_LOW(arg));
1676     tcg_gen_bswap32_i32(t1, TCGV_HIGH(arg));
1677     tcg_gen_mov_i32(TCGV_LOW(ret), t1);
1678     tcg_gen_mov_i32(TCGV_HIGH(ret), t0);
1679     tcg_temp_free_i32(t0);
1680     tcg_temp_free_i32(t1);
1681 }
1682 #else
1683
1684 static inline void tcg_gen_ext8s_i64(TCGv_i64 ret, TCGv_i64 arg)
1685 {
1686     if (TCG_TARGET_HAS_ext8s_i64) {
1687         tcg_gen_op2_i64(INDEX_op_ext8s_i64, ret, arg);
1688     } else {
1689         tcg_gen_shli_i64(ret, arg, 56);
1690         tcg_gen_sari_i64(ret, ret, 56);
1691     }
1692 }
1693
1694 static inline void tcg_gen_ext16s_i64(TCGv_i64 ret, TCGv_i64 arg)
1695 {
1696     if (TCG_TARGET_HAS_ext16s_i64) {
1697         tcg_gen_op2_i64(INDEX_op_ext16s_i64, ret, arg);
1698     } else {
1699         tcg_gen_shli_i64(ret, arg, 48);
1700         tcg_gen_sari_i64(ret, ret, 48);
1701     }
1702 }
1703
1704 static inline void tcg_gen_ext32s_i64(TCGv_i64 ret, TCGv_i64 arg)
1705 {
1706     if (TCG_TARGET_HAS_ext32s_i64) {
1707         tcg_gen_op2_i64(INDEX_op_ext32s_i64, ret, arg);
1708     } else {
1709         tcg_gen_shli_i64(ret, arg, 32);
1710         tcg_gen_sari_i64(ret, ret, 32);
1711     }
1712 }
1713
1714 static inline void tcg_gen_ext8u_i64(TCGv_i64 ret, TCGv_i64 arg)
1715 {
1716     if (TCG_TARGET_HAS_ext8u_i64) {
1717         tcg_gen_op2_i64(INDEX_op_ext8u_i64, ret, arg);
1718     } else {
1719         tcg_gen_andi_i64(ret, arg, 0xffu);
1720     }
1721 }
1722
1723 static inline void tcg_gen_ext16u_i64(TCGv_i64 ret, TCGv_i64 arg)
1724 {
1725     if (TCG_TARGET_HAS_ext16u_i64) {
1726         tcg_gen_op2_i64(INDEX_op_ext16u_i64, ret, arg);
1727     } else {
1728         tcg_gen_andi_i64(ret, arg, 0xffffu);
1729     }
1730 }
1731
1732 static inline void tcg_gen_ext32u_i64(TCGv_i64 ret, TCGv_i64 arg)
1733 {
1734     if (TCG_TARGET_HAS_ext32u_i64) {
1735         tcg_gen_op2_i64(INDEX_op_ext32u_i64, ret, arg);
1736     } else {
1737         tcg_gen_andi_i64(ret, arg, 0xffffffffu);
1738     }
1739 }
1740
1741 static inline void tcg_gen_trunc_shr_i64_i32(TCGv_i32 ret, TCGv_i64 arg,
1742                                              unsigned int count)
1743 {
1744     tcg_debug_assert(count < 64);
1745     if (TCG_TARGET_HAS_trunc_shr_i32) {
1746         tcg_gen_op3i_i32(INDEX_op_trunc_shr_i32, ret,
1747                          MAKE_TCGV_I32(GET_TCGV_I64(arg)), count);
1748     } else if (count == 0) {
1749         tcg_gen_mov_i32(ret, MAKE_TCGV_I32(GET_TCGV_I64(arg)));
1750     } else {
1751         TCGv_i64 t = tcg_temp_new_i64();
1752         tcg_gen_shri_i64(t, arg, count);
1753         tcg_gen_mov_i32(ret, MAKE_TCGV_I32(GET_TCGV_I64(t)));
1754         tcg_temp_free_i64(t);
1755     }
1756 }
1757
1758 /* Note: we assume the target supports move between 32 and 64 bit
1759    registers */
1760 static inline void tcg_gen_extu_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
1761 {
1762     tcg_gen_ext32u_i64(ret, MAKE_TCGV_I64(GET_TCGV_I32(arg)));
1763 }
1764
1765 /* Note: we assume the target supports move between 32 and 64 bit
1766    registers */
1767 static inline void tcg_gen_ext_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
1768 {
1769     tcg_gen_ext32s_i64(ret, MAKE_TCGV_I64(GET_TCGV_I32(arg)));
1770 }
1771
1772 /* Note: we assume the six high bytes are set to zero */
1773 static inline void tcg_gen_bswap16_i64(TCGv_i64 ret, TCGv_i64 arg)
1774 {
1775     if (TCG_TARGET_HAS_bswap16_i64) {
1776         tcg_gen_op2_i64(INDEX_op_bswap16_i64, ret, arg);
1777     } else {
1778         TCGv_i64 t0 = tcg_temp_new_i64();
1779
1780         tcg_gen_ext8u_i64(t0, arg);
1781         tcg_gen_shli_i64(t0, t0, 8);
1782         tcg_gen_shri_i64(ret, arg, 8);
1783         tcg_gen_or_i64(ret, ret, t0);
1784         tcg_temp_free_i64(t0);
1785     }
1786 }
1787
1788 /* Note: we assume the four high bytes are set to zero */
1789 static inline void tcg_gen_bswap32_i64(TCGv_i64 ret, TCGv_i64 arg)
1790 {
1791     if (TCG_TARGET_HAS_bswap32_i64) {
1792         tcg_gen_op2_i64(INDEX_op_bswap32_i64, ret, arg);
1793     } else {
1794         TCGv_i64 t0, t1;
1795         t0 = tcg_temp_new_i64();
1796         t1 = tcg_temp_new_i64();
1797
1798         tcg_gen_shli_i64(t0, arg, 24);
1799         tcg_gen_ext32u_i64(t0, t0);
1800
1801         tcg_gen_andi_i64(t1, arg, 0x0000ff00);
1802         tcg_gen_shli_i64(t1, t1, 8);
1803         tcg_gen_or_i64(t0, t0, t1);
1804
1805         tcg_gen_shri_i64(t1, arg, 8);
1806         tcg_gen_andi_i64(t1, t1, 0x0000ff00);
1807         tcg_gen_or_i64(t0, t0, t1);
1808
1809         tcg_gen_shri_i64(t1, arg, 24);
1810         tcg_gen_or_i64(ret, t0, t1);
1811         tcg_temp_free_i64(t0);
1812         tcg_temp_free_i64(t1);
1813     }
1814 }
1815
1816 static inline void tcg_gen_bswap64_i64(TCGv_i64 ret, TCGv_i64 arg)
1817 {
1818     if (TCG_TARGET_HAS_bswap64_i64) {
1819         tcg_gen_op2_i64(INDEX_op_bswap64_i64, ret, arg);
1820     } else {
1821         TCGv_i64 t0 = tcg_temp_new_i64();
1822         TCGv_i64 t1 = tcg_temp_new_i64();
1823
1824         tcg_gen_shli_i64(t0, arg, 56);
1825
1826         tcg_gen_andi_i64(t1, arg, 0x0000ff00);
1827         tcg_gen_shli_i64(t1, t1, 40);
1828         tcg_gen_or_i64(t0, t0, t1);
1829
1830         tcg_gen_andi_i64(t1, arg, 0x00ff0000);
1831         tcg_gen_shli_i64(t1, t1, 24);
1832         tcg_gen_or_i64(t0, t0, t1);
1833
1834         tcg_gen_andi_i64(t1, arg, 0xff000000);
1835         tcg_gen_shli_i64(t1, t1, 8);
1836         tcg_gen_or_i64(t0, t0, t1);
1837
1838         tcg_gen_shri_i64(t1, arg, 8);
1839         tcg_gen_andi_i64(t1, t1, 0xff000000);
1840         tcg_gen_or_i64(t0, t0, t1);
1841
1842         tcg_gen_shri_i64(t1, arg, 24);
1843         tcg_gen_andi_i64(t1, t1, 0x00ff0000);
1844         tcg_gen_or_i64(t0, t0, t1);
1845
1846         tcg_gen_shri_i64(t1, arg, 40);
1847         tcg_gen_andi_i64(t1, t1, 0x0000ff00);
1848         tcg_gen_or_i64(t0, t0, t1);
1849
1850         tcg_gen_shri_i64(t1, arg, 56);
1851         tcg_gen_or_i64(ret, t0, t1);
1852         tcg_temp_free_i64(t0);
1853         tcg_temp_free_i64(t1);
1854     }
1855 }
1856
1857 #endif
1858
1859 static inline void tcg_gen_neg_i32(TCGv_i32 ret, TCGv_i32 arg)
1860 {
1861     if (TCG_TARGET_HAS_neg_i32) {
1862         tcg_gen_op2_i32(INDEX_op_neg_i32, ret, arg);
1863     } else {
1864         TCGv_i32 t0 = tcg_const_i32(0);
1865         tcg_gen_sub_i32(ret, t0, arg);
1866         tcg_temp_free_i32(t0);
1867     }
1868 }
1869
1870 static inline void tcg_gen_neg_i64(TCGv_i64 ret, TCGv_i64 arg)
1871 {
1872     if (TCG_TARGET_HAS_neg_i64) {
1873         tcg_gen_op2_i64(INDEX_op_neg_i64, ret, arg);
1874     } else {
1875         TCGv_i64 t0 = tcg_const_i64(0);
1876         tcg_gen_sub_i64(ret, t0, arg);
1877         tcg_temp_free_i64(t0);
1878     }
1879 }
1880
1881 static inline void tcg_gen_not_i32(TCGv_i32 ret, TCGv_i32 arg)
1882 {
1883     if (TCG_TARGET_HAS_not_i32) {
1884         tcg_gen_op2_i32(INDEX_op_not_i32, ret, arg);
1885     } else {
1886         tcg_gen_xori_i32(ret, arg, -1);
1887     }
1888 }
1889
1890 static inline void tcg_gen_not_i64(TCGv_i64 ret, TCGv_i64 arg)
1891 {
1892 #if TCG_TARGET_REG_BITS == 64
1893     if (TCG_TARGET_HAS_not_i64) {
1894         tcg_gen_op2_i64(INDEX_op_not_i64, ret, arg);
1895     } else {
1896         tcg_gen_xori_i64(ret, arg, -1);
1897     }
1898 #else
1899     tcg_gen_not_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1900     tcg_gen_not_i32(TCGV_HIGH(ret), TCGV_HIGH(arg));
1901 #endif
1902 }
1903
1904 static inline void tcg_gen_discard_i32(TCGv_i32 arg)
1905 {
1906     tcg_gen_op1_i32(INDEX_op_discard, arg);
1907 }
1908
1909 static inline void tcg_gen_discard_i64(TCGv_i64 arg)
1910 {
1911 #if TCG_TARGET_REG_BITS == 32
1912     tcg_gen_discard_i32(TCGV_LOW(arg));
1913     tcg_gen_discard_i32(TCGV_HIGH(arg));
1914 #else
1915     tcg_gen_op1_i64(INDEX_op_discard, arg);
1916 #endif
1917 }
1918
1919 static inline void tcg_gen_andc_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1920 {
1921     if (TCG_TARGET_HAS_andc_i32) {
1922         tcg_gen_op3_i32(INDEX_op_andc_i32, ret, arg1, arg2);
1923     } else {
1924         TCGv_i32 t0 = tcg_temp_new_i32();
1925         tcg_gen_not_i32(t0, arg2);
1926         tcg_gen_and_i32(ret, arg1, t0);
1927         tcg_temp_free_i32(t0);
1928     }
1929 }
1930
1931 static inline void tcg_gen_andc_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1932 {
1933 #if TCG_TARGET_REG_BITS == 64
1934     if (TCG_TARGET_HAS_andc_i64) {
1935         tcg_gen_op3_i64(INDEX_op_andc_i64, ret, arg1, arg2);
1936     } else {
1937         TCGv_i64 t0 = tcg_temp_new_i64();
1938         tcg_gen_not_i64(t0, arg2);
1939         tcg_gen_and_i64(ret, arg1, t0);
1940         tcg_temp_free_i64(t0);
1941     }
1942 #else
1943     tcg_gen_andc_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
1944     tcg_gen_andc_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
1945 #endif
1946 }
1947
1948 static inline void tcg_gen_eqv_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1949 {
1950     if (TCG_TARGET_HAS_eqv_i32) {
1951         tcg_gen_op3_i32(INDEX_op_eqv_i32, ret, arg1, arg2);
1952     } else {
1953         tcg_gen_xor_i32(ret, arg1, arg2);
1954         tcg_gen_not_i32(ret, ret);
1955     }
1956 }
1957
1958 static inline void tcg_gen_eqv_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1959 {
1960 #if TCG_TARGET_REG_BITS == 64
1961     if (TCG_TARGET_HAS_eqv_i64) {
1962         tcg_gen_op3_i64(INDEX_op_eqv_i64, ret, arg1, arg2);
1963     } else {
1964         tcg_gen_xor_i64(ret, arg1, arg2);
1965         tcg_gen_not_i64(ret, ret);
1966     }
1967 #else
1968     tcg_gen_eqv_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
1969     tcg_gen_eqv_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
1970 #endif
1971 }
1972
1973 static inline void tcg_gen_nand_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1974 {
1975     if (TCG_TARGET_HAS_nand_i32) {
1976         tcg_gen_op3_i32(INDEX_op_nand_i32, ret, arg1, arg2);
1977     } else {
1978         tcg_gen_and_i32(ret, arg1, arg2);
1979         tcg_gen_not_i32(ret, ret);
1980     }
1981 }
1982
1983 static inline void tcg_gen_nand_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1984 {
1985 #if TCG_TARGET_REG_BITS == 64
1986     if (TCG_TARGET_HAS_nand_i64) {
1987         tcg_gen_op3_i64(INDEX_op_nand_i64, ret, arg1, arg2);
1988     } else {
1989         tcg_gen_and_i64(ret, arg1, arg2);
1990         tcg_gen_not_i64(ret, ret);
1991     }
1992 #else
1993     tcg_gen_nand_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
1994     tcg_gen_nand_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
1995 #endif
1996 }
1997
1998 static inline void tcg_gen_nor_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1999 {
2000     if (TCG_TARGET_HAS_nor_i32) {
2001         tcg_gen_op3_i32(INDEX_op_nor_i32, ret, arg1, arg2);
2002     } else {
2003         tcg_gen_or_i32(ret, arg1, arg2);
2004         tcg_gen_not_i32(ret, ret);
2005     }
2006 }
2007
2008 static inline void tcg_gen_nor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
2009 {
2010 #if TCG_TARGET_REG_BITS == 64
2011     if (TCG_TARGET_HAS_nor_i64) {
2012         tcg_gen_op3_i64(INDEX_op_nor_i64, ret, arg1, arg2);
2013     } else {
2014         tcg_gen_or_i64(ret, arg1, arg2);
2015         tcg_gen_not_i64(ret, ret);
2016     }
2017 #else
2018     tcg_gen_nor_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
2019     tcg_gen_nor_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
2020 #endif
2021 }
2022
2023 static inline void tcg_gen_orc_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
2024 {
2025     if (TCG_TARGET_HAS_orc_i32) {
2026         tcg_gen_op3_i32(INDEX_op_orc_i32, ret, arg1, arg2);
2027     } else {
2028         TCGv_i32 t0 = tcg_temp_new_i32();
2029         tcg_gen_not_i32(t0, arg2);
2030         tcg_gen_or_i32(ret, arg1, t0);
2031         tcg_temp_free_i32(t0);
2032     }
2033 }
2034
2035 static inline void tcg_gen_orc_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
2036 {
2037 #if TCG_TARGET_REG_BITS == 64
2038     if (TCG_TARGET_HAS_orc_i64) {
2039         tcg_gen_op3_i64(INDEX_op_orc_i64, ret, arg1, arg2);
2040     } else {
2041         TCGv_i64 t0 = tcg_temp_new_i64();
2042         tcg_gen_not_i64(t0, arg2);
2043         tcg_gen_or_i64(ret, arg1, t0);
2044         tcg_temp_free_i64(t0);
2045     }
2046 #else
2047     tcg_gen_orc_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
2048     tcg_gen_orc_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
2049 #endif
2050 }
2051
2052 static inline void tcg_gen_rotl_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
2053 {
2054     if (TCG_TARGET_HAS_rot_i32) {
2055         tcg_gen_op3_i32(INDEX_op_rotl_i32, ret, arg1, arg2);
2056     } else {
2057         TCGv_i32 t0, t1;
2058
2059         t0 = tcg_temp_new_i32();
2060         t1 = tcg_temp_new_i32();
2061         tcg_gen_shl_i32(t0, arg1, arg2);
2062         tcg_gen_subfi_i32(t1, 32, arg2);
2063         tcg_gen_shr_i32(t1, arg1, t1);
2064         tcg_gen_or_i32(ret, t0, t1);
2065         tcg_temp_free_i32(t0);
2066         tcg_temp_free_i32(t1);
2067     }
2068 }
2069
2070 static inline void tcg_gen_rotl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
2071 {
2072     if (TCG_TARGET_HAS_rot_i64) {
2073         tcg_gen_op3_i64(INDEX_op_rotl_i64, ret, arg1, arg2);
2074     } else {
2075         TCGv_i64 t0, t1;
2076         t0 = tcg_temp_new_i64();
2077         t1 = tcg_temp_new_i64();
2078         tcg_gen_shl_i64(t0, arg1, arg2);
2079         tcg_gen_subfi_i64(t1, 64, arg2);
2080         tcg_gen_shr_i64(t1, arg1, t1);
2081         tcg_gen_or_i64(ret, t0, t1);
2082         tcg_temp_free_i64(t0);
2083         tcg_temp_free_i64(t1);
2084     }
2085 }
2086
2087 static inline void tcg_gen_rotli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
2088 {
2089     /* some cases can be optimized here */
2090     if (arg2 == 0) {
2091         tcg_gen_mov_i32(ret, arg1);
2092     } else if (TCG_TARGET_HAS_rot_i32) {
2093         TCGv_i32 t0 = tcg_const_i32(arg2);
2094         tcg_gen_rotl_i32(ret, arg1, t0);
2095         tcg_temp_free_i32(t0);
2096     } else {
2097         TCGv_i32 t0, t1;
2098         t0 = tcg_temp_new_i32();
2099         t1 = tcg_temp_new_i32();
2100         tcg_gen_shli_i32(t0, arg1, arg2);
2101         tcg_gen_shri_i32(t1, arg1, 32 - arg2);
2102         tcg_gen_or_i32(ret, t0, t1);
2103         tcg_temp_free_i32(t0);
2104         tcg_temp_free_i32(t1);
2105     }
2106 }
2107
2108 static inline void tcg_gen_rotli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
2109 {
2110     /* some cases can be optimized here */
2111     if (arg2 == 0) {
2112         tcg_gen_mov_i64(ret, arg1);
2113     } else if (TCG_TARGET_HAS_rot_i64) {
2114         TCGv_i64 t0 = tcg_const_i64(arg2);
2115         tcg_gen_rotl_i64(ret, arg1, t0);
2116         tcg_temp_free_i64(t0);
2117     } else {
2118         TCGv_i64 t0, t1;
2119         t0 = tcg_temp_new_i64();
2120         t1 = tcg_temp_new_i64();
2121         tcg_gen_shli_i64(t0, arg1, arg2);
2122         tcg_gen_shri_i64(t1, arg1, 64 - arg2);
2123         tcg_gen_or_i64(ret, t0, t1);
2124         tcg_temp_free_i64(t0);
2125         tcg_temp_free_i64(t1);
2126     }
2127 }
2128
2129 static inline void tcg_gen_rotr_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
2130 {
2131     if (TCG_TARGET_HAS_rot_i32) {
2132         tcg_gen_op3_i32(INDEX_op_rotr_i32, ret, arg1, arg2);
2133     } else {
2134         TCGv_i32 t0, t1;
2135
2136         t0 = tcg_temp_new_i32();
2137         t1 = tcg_temp_new_i32();
2138         tcg_gen_shr_i32(t0, arg1, arg2);
2139         tcg_gen_subfi_i32(t1, 32, arg2);
2140         tcg_gen_shl_i32(t1, arg1, t1);
2141         tcg_gen_or_i32(ret, t0, t1);
2142         tcg_temp_free_i32(t0);
2143         tcg_temp_free_i32(t1);
2144     }
2145 }
2146
2147 static inline void tcg_gen_rotr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
2148 {
2149     if (TCG_TARGET_HAS_rot_i64) {
2150         tcg_gen_op3_i64(INDEX_op_rotr_i64, ret, arg1, arg2);
2151     } else {
2152         TCGv_i64 t0, t1;
2153         t0 = tcg_temp_new_i64();
2154         t1 = tcg_temp_new_i64();
2155         tcg_gen_shr_i64(t0, arg1, arg2);
2156         tcg_gen_subfi_i64(t1, 64, arg2);
2157         tcg_gen_shl_i64(t1, arg1, t1);
2158         tcg_gen_or_i64(ret, t0, t1);
2159         tcg_temp_free_i64(t0);
2160         tcg_temp_free_i64(t1);
2161     }
2162 }
2163
2164 static inline void tcg_gen_rotri_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
2165 {
2166     /* some cases can be optimized here */
2167     if (arg2 == 0) {
2168         tcg_gen_mov_i32(ret, arg1);
2169     } else {
2170         tcg_gen_rotli_i32(ret, arg1, 32 - arg2);
2171     }
2172 }
2173
2174 static inline void tcg_gen_rotri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
2175 {
2176     /* some cases can be optimized here */
2177     if (arg2 == 0) {
2178         tcg_gen_mov_i64(ret, arg1);
2179     } else {
2180         tcg_gen_rotli_i64(ret, arg1, 64 - arg2);
2181     }
2182 }
2183
2184 static inline void tcg_gen_deposit_i32(TCGv_i32 ret, TCGv_i32 arg1,
2185                                        TCGv_i32 arg2, unsigned int ofs,
2186                                        unsigned int len)
2187 {
2188     uint32_t mask;
2189     TCGv_i32 t1;
2190
2191     tcg_debug_assert(ofs < 32);
2192     tcg_debug_assert(len <= 32);
2193     tcg_debug_assert(ofs + len <= 32);
2194
2195     if (ofs == 0 && len == 32) {
2196         tcg_gen_mov_i32(ret, arg2);
2197         return;
2198     }
2199     if (TCG_TARGET_HAS_deposit_i32 && TCG_TARGET_deposit_i32_valid(ofs, len)) {
2200         tcg_gen_op5ii_i32(INDEX_op_deposit_i32, ret, arg1, arg2, ofs, len);
2201         return;
2202     }
2203
2204     mask = (1u << len) - 1;
2205     t1 = tcg_temp_new_i32();
2206
2207     if (ofs + len < 32) {
2208         tcg_gen_andi_i32(t1, arg2, mask);
2209         tcg_gen_shli_i32(t1, t1, ofs);
2210     } else {
2211         tcg_gen_shli_i32(t1, arg2, ofs);
2212     }
2213     tcg_gen_andi_i32(ret, arg1, ~(mask << ofs));
2214     tcg_gen_or_i32(ret, ret, t1);
2215
2216     tcg_temp_free_i32(t1);
2217 }
2218
2219 static inline void tcg_gen_deposit_i64(TCGv_i64 ret, TCGv_i64 arg1,
2220                                        TCGv_i64 arg2, unsigned int ofs,
2221                                        unsigned int len)
2222 {
2223     uint64_t mask;
2224     TCGv_i64 t1;
2225
2226     tcg_debug_assert(ofs < 64);
2227     tcg_debug_assert(len <= 64);
2228     tcg_debug_assert(ofs + len <= 64);
2229
2230     if (ofs == 0 && len == 64) {
2231         tcg_gen_mov_i64(ret, arg2);
2232         return;
2233     }
2234     if (TCG_TARGET_HAS_deposit_i64 && TCG_TARGET_deposit_i64_valid(ofs, len)) {
2235         tcg_gen_op5ii_i64(INDEX_op_deposit_i64, ret, arg1, arg2, ofs, len);
2236         return;
2237     }
2238
2239 #if TCG_TARGET_REG_BITS == 32
2240     if (ofs >= 32) {
2241         tcg_gen_deposit_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1),
2242                             TCGV_LOW(arg2), ofs - 32, len);
2243         tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1));
2244         return;
2245     }
2246     if (ofs + len <= 32) {
2247         tcg_gen_deposit_i32(TCGV_LOW(ret), TCGV_LOW(arg1),
2248                             TCGV_LOW(arg2), ofs, len);
2249         tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1));
2250         return;
2251     }
2252 #endif
2253
2254     mask = (1ull << len) - 1;
2255     t1 = tcg_temp_new_i64();
2256
2257     if (ofs + len < 64) {
2258         tcg_gen_andi_i64(t1, arg2, mask);
2259         tcg_gen_shli_i64(t1, t1, ofs);
2260     } else {
2261         tcg_gen_shli_i64(t1, arg2, ofs);
2262     }
2263     tcg_gen_andi_i64(ret, arg1, ~(mask << ofs));
2264     tcg_gen_or_i64(ret, ret, t1);
2265
2266     tcg_temp_free_i64(t1);
2267 }
2268
2269 static inline void tcg_gen_concat_i32_i64(TCGv_i64 dest, TCGv_i32 low,
2270                                           TCGv_i32 high)
2271 {
2272 #if TCG_TARGET_REG_BITS == 32
2273     tcg_gen_mov_i32(TCGV_LOW(dest), low);
2274     tcg_gen_mov_i32(TCGV_HIGH(dest), high);
2275 #else
2276     TCGv_i64 tmp = tcg_temp_new_i64();
2277     /* These extensions are only needed for type correctness.
2278        We may be able to do better given target specific information.  */
2279     tcg_gen_extu_i32_i64(tmp, high);
2280     tcg_gen_extu_i32_i64(dest, low);
2281     /* If deposit is available, use it.  Otherwise use the extra
2282        knowledge that we have of the zero-extensions above.  */
2283     if (TCG_TARGET_HAS_deposit_i64 && TCG_TARGET_deposit_i64_valid(32, 32)) {
2284         tcg_gen_deposit_i64(dest, dest, tmp, 32, 32);
2285     } else {
2286         tcg_gen_shli_i64(tmp, tmp, 32);
2287         tcg_gen_or_i64(dest, dest, tmp);
2288     }
2289     tcg_temp_free_i64(tmp);
2290 #endif
2291 }
2292
2293 static inline void tcg_gen_concat32_i64(TCGv_i64 dest, TCGv_i64 low,
2294                                         TCGv_i64 high)
2295 {
2296     tcg_gen_deposit_i64(dest, low, high, 32, 32);
2297 }
2298
2299 static inline void tcg_gen_trunc_i64_i32(TCGv_i32 ret, TCGv_i64 arg)
2300 {
2301     tcg_gen_trunc_shr_i64_i32(ret, arg, 0);
2302 }
2303
2304 static inline void tcg_gen_extr_i64_i32(TCGv_i32 lo, TCGv_i32 hi, TCGv_i64 arg)
2305 {
2306     tcg_gen_trunc_shr_i64_i32(lo, arg, 0);
2307     tcg_gen_trunc_shr_i64_i32(hi, arg, 32);
2308 }
2309
2310 static inline void tcg_gen_extr32_i64(TCGv_i64 lo, TCGv_i64 hi, TCGv_i64 arg)
2311 {
2312     tcg_gen_ext32u_i64(lo, arg);
2313     tcg_gen_shri_i64(hi, arg, 32);
2314 }
2315
2316 static inline void tcg_gen_movcond_i32(TCGCond cond, TCGv_i32 ret,
2317                                        TCGv_i32 c1, TCGv_i32 c2,
2318                                        TCGv_i32 v1, TCGv_i32 v2)
2319 {
2320     if (TCG_TARGET_HAS_movcond_i32) {
2321         tcg_gen_op6i_i32(INDEX_op_movcond_i32, ret, c1, c2, v1, v2, cond);
2322     } else {
2323         TCGv_i32 t0 = tcg_temp_new_i32();
2324         TCGv_i32 t1 = tcg_temp_new_i32();
2325         tcg_gen_setcond_i32(cond, t0, c1, c2);
2326         tcg_gen_neg_i32(t0, t0);
2327         tcg_gen_and_i32(t1, v1, t0);
2328         tcg_gen_andc_i32(ret, v2, t0);
2329         tcg_gen_or_i32(ret, ret, t1);
2330         tcg_temp_free_i32(t0);
2331         tcg_temp_free_i32(t1);
2332     }
2333 }
2334
2335 static inline void tcg_gen_movcond_i64(TCGCond cond, TCGv_i64 ret,
2336                                        TCGv_i64 c1, TCGv_i64 c2,
2337                                        TCGv_i64 v1, TCGv_i64 v2)
2338 {
2339 #if TCG_TARGET_REG_BITS == 32
2340     TCGv_i32 t0 = tcg_temp_new_i32();
2341     TCGv_i32 t1 = tcg_temp_new_i32();
2342     tcg_gen_op6i_i32(INDEX_op_setcond2_i32, t0,
2343                      TCGV_LOW(c1), TCGV_HIGH(c1),
2344                      TCGV_LOW(c2), TCGV_HIGH(c2), cond);
2345
2346     if (TCG_TARGET_HAS_movcond_i32) {
2347         tcg_gen_movi_i32(t1, 0);
2348         tcg_gen_movcond_i32(TCG_COND_NE, TCGV_LOW(ret), t0, t1,
2349                             TCGV_LOW(v1), TCGV_LOW(v2));
2350         tcg_gen_movcond_i32(TCG_COND_NE, TCGV_HIGH(ret), t0, t1,
2351                             TCGV_HIGH(v1), TCGV_HIGH(v2));
2352     } else {
2353         tcg_gen_neg_i32(t0, t0);
2354
2355         tcg_gen_and_i32(t1, TCGV_LOW(v1), t0);
2356         tcg_gen_andc_i32(TCGV_LOW(ret), TCGV_LOW(v2), t0);
2357         tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t1);
2358
2359         tcg_gen_and_i32(t1, TCGV_HIGH(v1), t0);
2360         tcg_gen_andc_i32(TCGV_HIGH(ret), TCGV_HIGH(v2), t0);
2361         tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t1);
2362     }
2363     tcg_temp_free_i32(t0);
2364     tcg_temp_free_i32(t1);
2365 #else
2366     if (TCG_TARGET_HAS_movcond_i64) {
2367         tcg_gen_op6i_i64(INDEX_op_movcond_i64, ret, c1, c2, v1, v2, cond);
2368     } else {
2369         TCGv_i64 t0 = tcg_temp_new_i64();
2370         TCGv_i64 t1 = tcg_temp_new_i64();
2371         tcg_gen_setcond_i64(cond, t0, c1, c2);
2372         tcg_gen_neg_i64(t0, t0);
2373         tcg_gen_and_i64(t1, v1, t0);
2374         tcg_gen_andc_i64(ret, v2, t0);
2375         tcg_gen_or_i64(ret, ret, t1);
2376         tcg_temp_free_i64(t0);
2377         tcg_temp_free_i64(t1);
2378     }
2379 #endif
2380 }
2381
2382 static inline void tcg_gen_add2_i32(TCGv_i32 rl, TCGv_i32 rh, TCGv_i32 al,
2383                                     TCGv_i32 ah, TCGv_i32 bl, TCGv_i32 bh)
2384 {
2385     if (TCG_TARGET_HAS_add2_i32) {
2386         tcg_gen_op6_i32(INDEX_op_add2_i32, rl, rh, al, ah, bl, bh);
2387         /* Allow the optimizer room to replace add2 with two moves.  */
2388         tcg_gen_op0(INDEX_op_nop);
2389     } else {
2390         TCGv_i64 t0 = tcg_temp_new_i64();
2391         TCGv_i64 t1 = tcg_temp_new_i64();
2392         tcg_gen_concat_i32_i64(t0, al, ah);
2393         tcg_gen_concat_i32_i64(t1, bl, bh);
2394         tcg_gen_add_i64(t0, t0, t1);
2395         tcg_gen_extr_i64_i32(rl, rh, t0);
2396         tcg_temp_free_i64(t0);
2397         tcg_temp_free_i64(t1);
2398     }
2399 }
2400
2401 static inline void tcg_gen_sub2_i32(TCGv_i32 rl, TCGv_i32 rh, TCGv_i32 al,
2402                                     TCGv_i32 ah, TCGv_i32 bl, TCGv_i32 bh)
2403 {
2404     if (TCG_TARGET_HAS_sub2_i32) {
2405         tcg_gen_op6_i32(INDEX_op_sub2_i32, rl, rh, al, ah, bl, bh);
2406         /* Allow the optimizer room to replace sub2 with two moves.  */
2407         tcg_gen_op0(INDEX_op_nop);
2408     } else {
2409         TCGv_i64 t0 = tcg_temp_new_i64();
2410         TCGv_i64 t1 = tcg_temp_new_i64();
2411         tcg_gen_concat_i32_i64(t0, al, ah);
2412         tcg_gen_concat_i32_i64(t1, bl, bh);
2413         tcg_gen_sub_i64(t0, t0, t1);
2414         tcg_gen_extr_i64_i32(rl, rh, t0);
2415         tcg_temp_free_i64(t0);
2416         tcg_temp_free_i64(t1);
2417     }
2418 }
2419
2420 static inline void tcg_gen_mulu2_i32(TCGv_i32 rl, TCGv_i32 rh,
2421                                      TCGv_i32 arg1, TCGv_i32 arg2)
2422 {
2423     if (TCG_TARGET_HAS_mulu2_i32) {
2424         tcg_gen_op4_i32(INDEX_op_mulu2_i32, rl, rh, arg1, arg2);
2425         /* Allow the optimizer room to replace mulu2 with two moves.  */
2426         tcg_gen_op0(INDEX_op_nop);
2427     } else if (TCG_TARGET_HAS_muluh_i32) {
2428         TCGv_i32 t = tcg_temp_new_i32();
2429         tcg_gen_op3_i32(INDEX_op_mul_i32, t, arg1, arg2);
2430         tcg_gen_op3_i32(INDEX_op_muluh_i32, rh, arg1, arg2);
2431         tcg_gen_mov_i32(rl, t);
2432         tcg_temp_free_i32(t);
2433     } else {
2434         TCGv_i64 t0 = tcg_temp_new_i64();
2435         TCGv_i64 t1 = tcg_temp_new_i64();
2436         tcg_gen_extu_i32_i64(t0, arg1);
2437         tcg_gen_extu_i32_i64(t1, arg2);
2438         tcg_gen_mul_i64(t0, t0, t1);
2439         tcg_gen_extr_i64_i32(rl, rh, t0);
2440         tcg_temp_free_i64(t0);
2441         tcg_temp_free_i64(t1);
2442     }
2443 }
2444
2445 static inline void tcg_gen_muls2_i32(TCGv_i32 rl, TCGv_i32 rh,
2446                                      TCGv_i32 arg1, TCGv_i32 arg2)
2447 {
2448     if (TCG_TARGET_HAS_muls2_i32) {
2449         tcg_gen_op4_i32(INDEX_op_muls2_i32, rl, rh, arg1, arg2);
2450         /* Allow the optimizer room to replace muls2 with two moves.  */
2451         tcg_gen_op0(INDEX_op_nop);
2452     } else if (TCG_TARGET_HAS_mulsh_i32) {
2453         TCGv_i32 t = tcg_temp_new_i32();
2454         tcg_gen_op3_i32(INDEX_op_mul_i32, t, arg1, arg2);
2455         tcg_gen_op3_i32(INDEX_op_mulsh_i32, rh, arg1, arg2);
2456         tcg_gen_mov_i32(rl, t);
2457         tcg_temp_free_i32(t);
2458     } else if (TCG_TARGET_REG_BITS == 32) {
2459         TCGv_i32 t0 = tcg_temp_new_i32();
2460         TCGv_i32 t1 = tcg_temp_new_i32();
2461         TCGv_i32 t2 = tcg_temp_new_i32();
2462         TCGv_i32 t3 = tcg_temp_new_i32();
2463         tcg_gen_mulu2_i32(t0, t1, arg1, arg2);
2464         /* Adjust for negative inputs.  */
2465         tcg_gen_sari_i32(t2, arg1, 31);
2466         tcg_gen_sari_i32(t3, arg2, 31);
2467         tcg_gen_and_i32(t2, t2, arg2);
2468         tcg_gen_and_i32(t3, t3, arg1);
2469         tcg_gen_sub_i32(rh, t1, t2);
2470         tcg_gen_sub_i32(rh, rh, t3);
2471         tcg_gen_mov_i32(rl, t0);
2472         tcg_temp_free_i32(t0);
2473         tcg_temp_free_i32(t1);
2474         tcg_temp_free_i32(t2);
2475         tcg_temp_free_i32(t3);
2476     } else {
2477         TCGv_i64 t0 = tcg_temp_new_i64();
2478         TCGv_i64 t1 = tcg_temp_new_i64();
2479         tcg_gen_ext_i32_i64(t0, arg1);
2480         tcg_gen_ext_i32_i64(t1, arg2);
2481         tcg_gen_mul_i64(t0, t0, t1);
2482         tcg_gen_extr_i64_i32(rl, rh, t0);
2483         tcg_temp_free_i64(t0);
2484         tcg_temp_free_i64(t1);
2485     }
2486 }
2487
2488 static inline void tcg_gen_add2_i64(TCGv_i64 rl, TCGv_i64 rh, TCGv_i64 al,
2489                                     TCGv_i64 ah, TCGv_i64 bl, TCGv_i64 bh)
2490 {
2491     if (TCG_TARGET_HAS_add2_i64) {
2492         tcg_gen_op6_i64(INDEX_op_add2_i64, rl, rh, al, ah, bl, bh);
2493         /* Allow the optimizer room to replace add2 with two moves.  */
2494         tcg_gen_op0(INDEX_op_nop);
2495     } else {
2496         TCGv_i64 t0 = tcg_temp_new_i64();
2497         TCGv_i64 t1 = tcg_temp_new_i64();
2498         tcg_gen_add_i64(t0, al, bl);
2499         tcg_gen_setcond_i64(TCG_COND_LTU, t1, t0, al);
2500         tcg_gen_add_i64(rh, ah, bh);
2501         tcg_gen_add_i64(rh, rh, t1);
2502         tcg_gen_mov_i64(rl, t0);
2503         tcg_temp_free_i64(t0);
2504         tcg_temp_free_i64(t1);
2505     }
2506 }
2507
2508 static inline void tcg_gen_sub2_i64(TCGv_i64 rl, TCGv_i64 rh, TCGv_i64 al,
2509                                     TCGv_i64 ah, TCGv_i64 bl, TCGv_i64 bh)
2510 {
2511     if (TCG_TARGET_HAS_sub2_i64) {
2512         tcg_gen_op6_i64(INDEX_op_sub2_i64, rl, rh, al, ah, bl, bh);
2513         /* Allow the optimizer room to replace sub2 with two moves.  */
2514         tcg_gen_op0(INDEX_op_nop);
2515     } else {
2516         TCGv_i64 t0 = tcg_temp_new_i64();
2517         TCGv_i64 t1 = tcg_temp_new_i64();
2518         tcg_gen_sub_i64(t0, al, bl);
2519         tcg_gen_setcond_i64(TCG_COND_LTU, t1, al, bl);
2520         tcg_gen_sub_i64(rh, ah, bh);
2521         tcg_gen_sub_i64(rh, rh, t1);
2522         tcg_gen_mov_i64(rl, t0);
2523         tcg_temp_free_i64(t0);
2524         tcg_temp_free_i64(t1);
2525     }
2526 }
2527
2528 static inline void tcg_gen_mulu2_i64(TCGv_i64 rl, TCGv_i64 rh,
2529                                      TCGv_i64 arg1, TCGv_i64 arg2)
2530 {
2531     if (TCG_TARGET_HAS_mulu2_i64) {
2532         tcg_gen_op4_i64(INDEX_op_mulu2_i64, rl, rh, arg1, arg2);
2533         /* Allow the optimizer room to replace mulu2 with two moves.  */
2534         tcg_gen_op0(INDEX_op_nop);
2535     } else if (TCG_TARGET_HAS_muluh_i64) {
2536         TCGv_i64 t = tcg_temp_new_i64();
2537         tcg_gen_op3_i64(INDEX_op_mul_i64, t, arg1, arg2);
2538         tcg_gen_op3_i64(INDEX_op_muluh_i64, rh, arg1, arg2);
2539         tcg_gen_mov_i64(rl, t);
2540         tcg_temp_free_i64(t);
2541     } else {
2542         TCGv_i64 t0 = tcg_temp_new_i64();
2543         int sizemask = 0;
2544         /* Return value and both arguments are 64-bit and unsigned.  */
2545         sizemask |= tcg_gen_sizemask(0, 1, 0);
2546         sizemask |= tcg_gen_sizemask(1, 1, 0);
2547         sizemask |= tcg_gen_sizemask(2, 1, 0);
2548         tcg_gen_mul_i64(t0, arg1, arg2);
2549         tcg_gen_helper64(tcg_helper_muluh_i64, sizemask, rh, arg1, arg2);
2550         tcg_gen_mov_i64(rl, t0);
2551         tcg_temp_free_i64(t0);
2552     }
2553 }
2554
2555 static inline void tcg_gen_muls2_i64(TCGv_i64 rl, TCGv_i64 rh,
2556                                      TCGv_i64 arg1, TCGv_i64 arg2)
2557 {
2558     if (TCG_TARGET_HAS_muls2_i64) {
2559         tcg_gen_op4_i64(INDEX_op_muls2_i64, rl, rh, arg1, arg2);
2560         /* Allow the optimizer room to replace muls2 with two moves.  */
2561         tcg_gen_op0(INDEX_op_nop);
2562     } else if (TCG_TARGET_HAS_mulsh_i64) {
2563         TCGv_i64 t = tcg_temp_new_i64();
2564         tcg_gen_op3_i64(INDEX_op_mul_i64, t, arg1, arg2);
2565         tcg_gen_op3_i64(INDEX_op_mulsh_i64, rh, arg1, arg2);
2566         tcg_gen_mov_i64(rl, t);
2567         tcg_temp_free_i64(t);
2568     } else if (TCG_TARGET_HAS_mulu2_i64 || TCG_TARGET_HAS_muluh_i64) {
2569         TCGv_i64 t0 = tcg_temp_new_i64();
2570         TCGv_i64 t1 = tcg_temp_new_i64();
2571         TCGv_i64 t2 = tcg_temp_new_i64();
2572         TCGv_i64 t3 = tcg_temp_new_i64();
2573         tcg_gen_mulu2_i64(t0, t1, arg1, arg2);
2574         /* Adjust for negative inputs.  */
2575         tcg_gen_sari_i64(t2, arg1, 63);
2576         tcg_gen_sari_i64(t3, arg2, 63);
2577         tcg_gen_and_i64(t2, t2, arg2);
2578         tcg_gen_and_i64(t3, t3, arg1);
2579         tcg_gen_sub_i64(rh, t1, t2);
2580         tcg_gen_sub_i64(rh, rh, t3);
2581         tcg_gen_mov_i64(rl, t0);
2582         tcg_temp_free_i64(t0);
2583         tcg_temp_free_i64(t1);
2584         tcg_temp_free_i64(t2);
2585         tcg_temp_free_i64(t3);
2586     } else {
2587         TCGv_i64 t0 = tcg_temp_new_i64();
2588         int sizemask = 0;
2589         /* Return value and both arguments are 64-bit and signed.  */
2590         sizemask |= tcg_gen_sizemask(0, 1, 1);
2591         sizemask |= tcg_gen_sizemask(1, 1, 1);
2592         sizemask |= tcg_gen_sizemask(2, 1, 1);
2593         tcg_gen_mul_i64(t0, arg1, arg2);
2594         tcg_gen_helper64(tcg_helper_mulsh_i64, sizemask, rh, arg1, arg2);
2595         tcg_gen_mov_i64(rl, t0);
2596         tcg_temp_free_i64(t0);
2597     }
2598 }
2599
2600 /***************************************/
2601 /* QEMU specific operations. Their type depend on the QEMU CPU
2602    type. */
2603 #ifndef TARGET_LONG_BITS
2604 #error must include QEMU headers
2605 #endif
2606
2607 #if TARGET_LONG_BITS == 32
2608 #define TCGv TCGv_i32
2609 #define tcg_temp_new() tcg_temp_new_i32()
2610 #define tcg_global_reg_new tcg_global_reg_new_i32
2611 #define tcg_global_mem_new tcg_global_mem_new_i32
2612 #define tcg_temp_local_new() tcg_temp_local_new_i32()
2613 #define tcg_temp_free tcg_temp_free_i32
2614 #define TCGV_UNUSED(x) TCGV_UNUSED_I32(x)
2615 #define TCGV_IS_UNUSED(x) TCGV_IS_UNUSED_I32(x)
2616 #define TCGV_EQUAL(a, b) TCGV_EQUAL_I32(a, b)
2617 #define tcg_add_param_tl tcg_add_param_i32
2618 #define tcg_gen_qemu_ld_tl tcg_gen_qemu_ld_i32
2619 #define tcg_gen_qemu_st_tl tcg_gen_qemu_st_i32
2620 #else
2621 #define TCGv TCGv_i64
2622 #define tcg_temp_new() tcg_temp_new_i64()
2623 #define tcg_global_reg_new tcg_global_reg_new_i64
2624 #define tcg_global_mem_new tcg_global_mem_new_i64
2625 #define tcg_temp_local_new() tcg_temp_local_new_i64()
2626 #define tcg_temp_free tcg_temp_free_i64
2627 #define TCGV_UNUSED(x) TCGV_UNUSED_I64(x)
2628 #define TCGV_IS_UNUSED(x) TCGV_IS_UNUSED_I64(x)
2629 #define TCGV_EQUAL(a, b) TCGV_EQUAL_I64(a, b)
2630 #define tcg_add_param_tl tcg_add_param_i64
2631 #define tcg_gen_qemu_ld_tl tcg_gen_qemu_ld_i64
2632 #define tcg_gen_qemu_st_tl tcg_gen_qemu_st_i64
2633 #endif
2634
2635 /* debug info: write the PC of the corresponding QEMU CPU instruction */
2636 static inline void tcg_gen_debug_insn_start(uint64_t pc)
2637 {
2638     /* XXX: must really use a 32 bit size for TCGArg in all cases */
2639 #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
2640     tcg_gen_op2ii(INDEX_op_debug_insn_start,
2641                   (uint32_t)(pc), (uint32_t)(pc >> 32));
2642 #else
2643     tcg_gen_op1i(INDEX_op_debug_insn_start, pc);
2644 #endif
2645 }
2646
2647 static inline void tcg_gen_exit_tb(uintptr_t val)
2648 {
2649     tcg_gen_op1i(INDEX_op_exit_tb, val);
2650 }
2651
2652 static inline void tcg_gen_goto_tb(unsigned idx)
2653 {
2654     /* We only support two chained exits.  */
2655     tcg_debug_assert(idx <= 1);
2656 #ifdef CONFIG_DEBUG_TCG
2657     /* Verify that we havn't seen this numbered exit before.  */
2658     tcg_debug_assert((tcg_ctx.goto_tb_issue_mask & (1 << idx)) == 0);
2659     tcg_ctx.goto_tb_issue_mask |= 1 << idx;
2660 #endif
2661     tcg_gen_op1i(INDEX_op_goto_tb, idx);
2662 }
2663
2664
2665 void tcg_gen_qemu_ld_i32(TCGv_i32, TCGv, TCGArg, TCGMemOp);
2666 void tcg_gen_qemu_st_i32(TCGv_i32, TCGv, TCGArg, TCGMemOp);
2667 void tcg_gen_qemu_ld_i64(TCGv_i64, TCGv, TCGArg, TCGMemOp);
2668 void tcg_gen_qemu_st_i64(TCGv_i64, TCGv, TCGArg, TCGMemOp);
2669
2670 static inline void tcg_gen_qemu_ld8u(TCGv ret, TCGv addr, int mem_index)
2671 {
2672     tcg_gen_qemu_ld_tl(ret, addr, mem_index, MO_UB);
2673 }
2674
2675 static inline void tcg_gen_qemu_ld8s(TCGv ret, TCGv addr, int mem_index)
2676 {
2677     tcg_gen_qemu_ld_tl(ret, addr, mem_index, MO_SB);
2678 }
2679
2680 static inline void tcg_gen_qemu_ld16u(TCGv ret, TCGv addr, int mem_index)
2681 {
2682     tcg_gen_qemu_ld_tl(ret, addr, mem_index, MO_TEUW);
2683 }
2684
2685 static inline void tcg_gen_qemu_ld16s(TCGv ret, TCGv addr, int mem_index)
2686 {
2687     tcg_gen_qemu_ld_tl(ret, addr, mem_index, MO_TESW);
2688 }
2689
2690 static inline void tcg_gen_qemu_ld32u(TCGv ret, TCGv addr, int mem_index)
2691 {
2692     tcg_gen_qemu_ld_tl(ret, addr, mem_index, MO_TEUL);
2693 }
2694
2695 static inline void tcg_gen_qemu_ld32s(TCGv ret, TCGv addr, int mem_index)
2696 {
2697     tcg_gen_qemu_ld_tl(ret, addr, mem_index, MO_TESL);
2698 }
2699
2700 static inline void tcg_gen_qemu_ld64(TCGv_i64 ret, TCGv addr, int mem_index)
2701 {
2702     tcg_gen_qemu_ld_i64(ret, addr, mem_index, MO_TEQ);
2703 }
2704
2705 static inline void tcg_gen_qemu_st8(TCGv arg, TCGv addr, int mem_index)
2706 {
2707     tcg_gen_qemu_st_tl(arg, addr, mem_index, MO_UB);
2708 }
2709
2710 static inline void tcg_gen_qemu_st16(TCGv arg, TCGv addr, int mem_index)
2711 {
2712     tcg_gen_qemu_st_tl(arg, addr, mem_index, MO_TEUW);
2713 }
2714
2715 static inline void tcg_gen_qemu_st32(TCGv arg, TCGv addr, int mem_index)
2716 {
2717     tcg_gen_qemu_st_tl(arg, addr, mem_index, MO_TEUL);
2718 }
2719
2720 static inline void tcg_gen_qemu_st64(TCGv_i64 arg, TCGv addr, int mem_index)
2721 {
2722     tcg_gen_qemu_st_i64(arg, addr, mem_index, MO_TEQ);
2723 }
2724
2725 #if TARGET_LONG_BITS == 64
2726 #define tcg_gen_movi_tl tcg_gen_movi_i64
2727 #define tcg_gen_mov_tl tcg_gen_mov_i64
2728 #define tcg_gen_ld8u_tl tcg_gen_ld8u_i64
2729 #define tcg_gen_ld8s_tl tcg_gen_ld8s_i64
2730 #define tcg_gen_ld16u_tl tcg_gen_ld16u_i64
2731 #define tcg_gen_ld16s_tl tcg_gen_ld16s_i64
2732 #define tcg_gen_ld32u_tl tcg_gen_ld32u_i64
2733 #define tcg_gen_ld32s_tl tcg_gen_ld32s_i64
2734 #define tcg_gen_ld_tl tcg_gen_ld_i64
2735 #define tcg_gen_st8_tl tcg_gen_st8_i64
2736 #define tcg_gen_st16_tl tcg_gen_st16_i64
2737 #define tcg_gen_st32_tl tcg_gen_st32_i64
2738 #define tcg_gen_st_tl tcg_gen_st_i64
2739 #define tcg_gen_add_tl tcg_gen_add_i64
2740 #define tcg_gen_addi_tl tcg_gen_addi_i64
2741 #define tcg_gen_sub_tl tcg_gen_sub_i64
2742 #define tcg_gen_neg_tl tcg_gen_neg_i64
2743 #define tcg_gen_subfi_tl tcg_gen_subfi_i64
2744 #define tcg_gen_subi_tl tcg_gen_subi_i64
2745 #define tcg_gen_and_tl tcg_gen_and_i64
2746 #define tcg_gen_andi_tl tcg_gen_andi_i64
2747 #define tcg_gen_or_tl tcg_gen_or_i64
2748 #define tcg_gen_ori_tl tcg_gen_ori_i64
2749 #define tcg_gen_xor_tl tcg_gen_xor_i64
2750 #define tcg_gen_xori_tl tcg_gen_xori_i64
2751 #define tcg_gen_not_tl tcg_gen_not_i64
2752 #define tcg_gen_shl_tl tcg_gen_shl_i64
2753 #define tcg_gen_shli_tl tcg_gen_shli_i64
2754 #define tcg_gen_shr_tl tcg_gen_shr_i64
2755 #define tcg_gen_shri_tl tcg_gen_shri_i64
2756 #define tcg_gen_sar_tl tcg_gen_sar_i64
2757 #define tcg_gen_sari_tl tcg_gen_sari_i64
2758 #define tcg_gen_brcond_tl tcg_gen_brcond_i64
2759 #define tcg_gen_brcondi_tl tcg_gen_brcondi_i64
2760 #define tcg_gen_setcond_tl tcg_gen_setcond_i64
2761 #define tcg_gen_setcondi_tl tcg_gen_setcondi_i64
2762 #define tcg_gen_mul_tl tcg_gen_mul_i64
2763 #define tcg_gen_muli_tl tcg_gen_muli_i64
2764 #define tcg_gen_div_tl tcg_gen_div_i64
2765 #define tcg_gen_rem_tl tcg_gen_rem_i64
2766 #define tcg_gen_divu_tl tcg_gen_divu_i64
2767 #define tcg_gen_remu_tl tcg_gen_remu_i64
2768 #define tcg_gen_discard_tl tcg_gen_discard_i64
2769 #define tcg_gen_trunc_tl_i32 tcg_gen_trunc_i64_i32
2770 #define tcg_gen_trunc_i64_tl tcg_gen_mov_i64
2771 #define tcg_gen_extu_i32_tl tcg_gen_extu_i32_i64
2772 #define tcg_gen_ext_i32_tl tcg_gen_ext_i32_i64
2773 #define tcg_gen_extu_tl_i64 tcg_gen_mov_i64
2774 #define tcg_gen_ext_tl_i64 tcg_gen_mov_i64
2775 #define tcg_gen_ext8u_tl tcg_gen_ext8u_i64
2776 #define tcg_gen_ext8s_tl tcg_gen_ext8s_i64
2777 #define tcg_gen_ext16u_tl tcg_gen_ext16u_i64
2778 #define tcg_gen_ext16s_tl tcg_gen_ext16s_i64
2779 #define tcg_gen_ext32u_tl tcg_gen_ext32u_i64
2780 #define tcg_gen_ext32s_tl tcg_gen_ext32s_i64
2781 #define tcg_gen_bswap16_tl tcg_gen_bswap16_i64
2782 #define tcg_gen_bswap32_tl tcg_gen_bswap32_i64
2783 #define tcg_gen_bswap64_tl tcg_gen_bswap64_i64
2784 #define tcg_gen_concat_tl_i64 tcg_gen_concat32_i64
2785 #define tcg_gen_extr_i64_tl tcg_gen_extr32_i64
2786 #define tcg_gen_andc_tl tcg_gen_andc_i64
2787 #define tcg_gen_eqv_tl tcg_gen_eqv_i64
2788 #define tcg_gen_nand_tl tcg_gen_nand_i64
2789 #define tcg_gen_nor_tl tcg_gen_nor_i64
2790 #define tcg_gen_orc_tl tcg_gen_orc_i64
2791 #define tcg_gen_rotl_tl tcg_gen_rotl_i64
2792 #define tcg_gen_rotli_tl tcg_gen_rotli_i64
2793 #define tcg_gen_rotr_tl tcg_gen_rotr_i64
2794 #define tcg_gen_rotri_tl tcg_gen_rotri_i64
2795 #define tcg_gen_deposit_tl tcg_gen_deposit_i64
2796 #define tcg_const_tl tcg_const_i64
2797 #define tcg_const_local_tl tcg_const_local_i64
2798 #define tcg_gen_movcond_tl tcg_gen_movcond_i64
2799 #define tcg_gen_add2_tl tcg_gen_add2_i64
2800 #define tcg_gen_sub2_tl tcg_gen_sub2_i64
2801 #define tcg_gen_mulu2_tl tcg_gen_mulu2_i64
2802 #define tcg_gen_muls2_tl tcg_gen_muls2_i64
2803 #else
2804 #define tcg_gen_movi_tl tcg_gen_movi_i32
2805 #define tcg_gen_mov_tl tcg_gen_mov_i32
2806 #define tcg_gen_ld8u_tl tcg_gen_ld8u_i32
2807 #define tcg_gen_ld8s_tl tcg_gen_ld8s_i32
2808 #define tcg_gen_ld16u_tl tcg_gen_ld16u_i32
2809 #define tcg_gen_ld16s_tl tcg_gen_ld16s_i32
2810 #define tcg_gen_ld32u_tl tcg_gen_ld_i32
2811 #define tcg_gen_ld32s_tl tcg_gen_ld_i32
2812 #define tcg_gen_ld_tl tcg_gen_ld_i32
2813 #define tcg_gen_st8_tl tcg_gen_st8_i32
2814 #define tcg_gen_st16_tl tcg_gen_st16_i32
2815 #define tcg_gen_st32_tl tcg_gen_st_i32
2816 #define tcg_gen_st_tl tcg_gen_st_i32
2817 #define tcg_gen_add_tl tcg_gen_add_i32
2818 #define tcg_gen_addi_tl tcg_gen_addi_i32
2819 #define tcg_gen_sub_tl tcg_gen_sub_i32
2820 #define tcg_gen_neg_tl tcg_gen_neg_i32
2821 #define tcg_gen_subfi_tl tcg_gen_subfi_i32
2822 #define tcg_gen_subi_tl tcg_gen_subi_i32
2823 #define tcg_gen_and_tl tcg_gen_and_i32
2824 #define tcg_gen_andi_tl tcg_gen_andi_i32
2825 #define tcg_gen_or_tl tcg_gen_or_i32
2826 #define tcg_gen_ori_tl tcg_gen_ori_i32
2827 #define tcg_gen_xor_tl tcg_gen_xor_i32
2828 #define tcg_gen_xori_tl tcg_gen_xori_i32
2829 #define tcg_gen_not_tl tcg_gen_not_i32
2830 #define tcg_gen_shl_tl tcg_gen_shl_i32
2831 #define tcg_gen_shli_tl tcg_gen_shli_i32
2832 #define tcg_gen_shr_tl tcg_gen_shr_i32
2833 #define tcg_gen_shri_tl tcg_gen_shri_i32
2834 #define tcg_gen_sar_tl tcg_gen_sar_i32
2835 #define tcg_gen_sari_tl tcg_gen_sari_i32
2836 #define tcg_gen_brcond_tl tcg_gen_brcond_i32
2837 #define tcg_gen_brcondi_tl tcg_gen_brcondi_i32
2838 #define tcg_gen_setcond_tl tcg_gen_setcond_i32
2839 #define tcg_gen_setcondi_tl tcg_gen_setcondi_i32
2840 #define tcg_gen_mul_tl tcg_gen_mul_i32
2841 #define tcg_gen_muli_tl tcg_gen_muli_i32
2842 #define tcg_gen_div_tl tcg_gen_div_i32
2843 #define tcg_gen_rem_tl tcg_gen_rem_i32
2844 #define tcg_gen_divu_tl tcg_gen_divu_i32
2845 #define tcg_gen_remu_tl tcg_gen_remu_i32
2846 #define tcg_gen_discard_tl tcg_gen_discard_i32
2847 #define tcg_gen_trunc_tl_i32 tcg_gen_mov_i32
2848 #define tcg_gen_trunc_i64_tl tcg_gen_trunc_i64_i32
2849 #define tcg_gen_extu_i32_tl tcg_gen_mov_i32
2850 #define tcg_gen_ext_i32_tl tcg_gen_mov_i32
2851 #define tcg_gen_extu_tl_i64 tcg_gen_extu_i32_i64
2852 #define tcg_gen_ext_tl_i64 tcg_gen_ext_i32_i64
2853 #define tcg_gen_ext8u_tl tcg_gen_ext8u_i32
2854 #define tcg_gen_ext8s_tl tcg_gen_ext8s_i32
2855 #define tcg_gen_ext16u_tl tcg_gen_ext16u_i32
2856 #define tcg_gen_ext16s_tl tcg_gen_ext16s_i32
2857 #define tcg_gen_ext32u_tl tcg_gen_mov_i32
2858 #define tcg_gen_ext32s_tl tcg_gen_mov_i32
2859 #define tcg_gen_bswap16_tl tcg_gen_bswap16_i32
2860 #define tcg_gen_bswap32_tl tcg_gen_bswap32_i32
2861 #define tcg_gen_concat_tl_i64 tcg_gen_concat_i32_i64
2862 #define tcg_gen_extr_tl_i64 tcg_gen_extr_i32_i64
2863 #define tcg_gen_andc_tl tcg_gen_andc_i32
2864 #define tcg_gen_eqv_tl tcg_gen_eqv_i32
2865 #define tcg_gen_nand_tl tcg_gen_nand_i32
2866 #define tcg_gen_nor_tl tcg_gen_nor_i32
2867 #define tcg_gen_orc_tl tcg_gen_orc_i32
2868 #define tcg_gen_rotl_tl tcg_gen_rotl_i32
2869 #define tcg_gen_rotli_tl tcg_gen_rotli_i32
2870 #define tcg_gen_rotr_tl tcg_gen_rotr_i32
2871 #define tcg_gen_rotri_tl tcg_gen_rotri_i32
2872 #define tcg_gen_deposit_tl tcg_gen_deposit_i32
2873 #define tcg_const_tl tcg_const_i32
2874 #define tcg_const_local_tl tcg_const_local_i32
2875 #define tcg_gen_movcond_tl tcg_gen_movcond_i32
2876 #define tcg_gen_add2_tl tcg_gen_add2_i32
2877 #define tcg_gen_sub2_tl tcg_gen_sub2_i32
2878 #define tcg_gen_mulu2_tl tcg_gen_mulu2_i32
2879 #define tcg_gen_muls2_tl tcg_gen_muls2_i32
2880 #endif
2881
2882 #if UINTPTR_MAX == UINT32_MAX
2883 # define tcg_gen_ld_ptr(R, A, O) \
2884     tcg_gen_ld_i32(TCGV_PTR_TO_NAT(R), (A), (O))
2885 # define tcg_gen_discard_ptr(A) \
2886     tcg_gen_discard_i32(TCGV_PTR_TO_NAT(A))
2887 # define tcg_gen_add_ptr(R, A, B) \
2888     tcg_gen_add_i32(TCGV_PTR_TO_NAT(R), TCGV_PTR_TO_NAT(A), TCGV_PTR_TO_NAT(B))
2889 # define tcg_gen_addi_ptr(R, A, B) \
2890     tcg_gen_addi_i32(TCGV_PTR_TO_NAT(R), TCGV_PTR_TO_NAT(A), (B))
2891 # define tcg_gen_ext_i32_ptr(R, A) \
2892     tcg_gen_mov_i32(TCGV_PTR_TO_NAT(R), (A))
2893 #else
2894 # define tcg_gen_ld_ptr(R, A, O) \
2895     tcg_gen_ld_i64(TCGV_PTR_TO_NAT(R), (A), (O))
2896 # define tcg_gen_discard_ptr(A) \
2897     tcg_gen_discard_i64(TCGV_PTR_TO_NAT(A))
2898 # define tcg_gen_add_ptr(R, A, B) \
2899     tcg_gen_add_i64(TCGV_PTR_TO_NAT(R), TCGV_PTR_TO_NAT(A), TCGV_PTR_TO_NAT(B))
2900 # define tcg_gen_addi_ptr(R, A, B) \
2901     tcg_gen_addi_i64(TCGV_PTR_TO_NAT(R), TCGV_PTR_TO_NAT(A), (B))
2902 # define tcg_gen_ext_i32_ptr(R, A) \
2903     tcg_gen_ext_i32_i64(TCGV_PTR_TO_NAT(R), (A))
2904 #endif /* UINTPTR_MAX == UINT32_MAX */