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_op1_i32(TCGOpcode opc, TCGv_i32 arg1)
  29 {
  30     *gen_opc_ptr++ = opc;
  31     *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
  32 }
  33
  34 static inline void tcg_gen_op1_i64(TCGOpcode opc, TCGv_i64 arg1)
  35 {
  36     *gen_opc_ptr++ = opc;
  37     *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
  38 }
  39
  40 static inline void tcg_gen_op1i(TCGOpcode opc, TCGArg arg1)
  41 {
  42     *gen_opc_ptr++ = opc;
  43     *gen_opparam_ptr++ = arg1;
  44 }
  45
  46 static inline void tcg_gen_op2_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2)
  47 {
  48     *gen_opc_ptr++ = opc;
  49     *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
  50     *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
  51 }
  52
  53 static inline void tcg_gen_op2_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2)
  54 {
  55     *gen_opc_ptr++ = opc;
  56     *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
  57     *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
  58 }
  59
  60 static inline void tcg_gen_op2i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGArg arg2)
  61 {
  62     *gen_opc_ptr++ = opc;
  63     *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
  64     *gen_opparam_ptr++ = arg2;
  65 }
  66
  67 static inline void tcg_gen_op2i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGArg arg2)
  68 {
  69     *gen_opc_ptr++ = opc;
  70     *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
  71     *gen_opparam_ptr++ = arg2;
  72 }
  73
  74 static inline void tcg_gen_op2ii(TCGOpcode opc, TCGArg arg1, TCGArg arg2)
  75 {
  76     *gen_opc_ptr++ = opc;
  77     *gen_opparam_ptr++ = arg1;
  78     *gen_opparam_ptr++ = arg2;
  79 }
  80
  81 static inline void tcg_gen_op3_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
  82                                    TCGv_i32 arg3)
  83 {
  84     *gen_opc_ptr++ = opc;
  85     *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
  86     *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
  87     *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
  88 }
  89
  90 static inline void tcg_gen_op3_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
  91                                    TCGv_i64 arg3)
  92 {
  93     *gen_opc_ptr++ = opc;
  94     *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
  95     *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
  96     *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
  97 }
  98
  99 static inline void tcg_gen_op3i_i32(TCGOpcode opc, TCGv_i32 arg1,
 100                                     TCGv_i32 arg2, TCGArg arg3)
 101 {
 102     *gen_opc_ptr++ = opc;
 103     *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 104     *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 105     *gen_opparam_ptr++ = arg3;
 106 }
 107
 108 static inline void tcg_gen_op3i_i64(TCGOpcode opc, TCGv_i64 arg1,
 109                                     TCGv_i64 arg2, TCGArg arg3)
 110 {
 111     *gen_opc_ptr++ = opc;
 112     *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 113     *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 114     *gen_opparam_ptr++ = arg3;
 115 }
 116
 117 static inline void tcg_gen_ldst_op_i32(TCGOpcode opc, TCGv_i32 val,
 118                                        TCGv_ptr base, TCGArg offset)
 119 {
 120     *gen_opc_ptr++ = opc;
 121     *gen_opparam_ptr++ = GET_TCGV_I32(val);
 122     *gen_opparam_ptr++ = GET_TCGV_PTR(base);
 123     *gen_opparam_ptr++ = offset;
 124 }
 125
 126 static inline void tcg_gen_ldst_op_i64(TCGOpcode opc, TCGv_i64 val,
 127                                        TCGv_ptr base, TCGArg offset)
 128 {
 129     *gen_opc_ptr++ = opc;
 130     *gen_opparam_ptr++ = GET_TCGV_I64(val);
 131     *gen_opparam_ptr++ = GET_TCGV_PTR(base);
 132     *gen_opparam_ptr++ = offset;
 133 }
 134
 135 static inline void tcg_gen_qemu_ldst_op_i64_i32(TCGOpcode opc, TCGv_i64 val,
 136                                                 TCGv_i32 addr, TCGArg mem_index)
 137 {
 138     *gen_opc_ptr++ = opc;
 139     *gen_opparam_ptr++ = GET_TCGV_I64(val);
 140     *gen_opparam_ptr++ = GET_TCGV_I32(addr);
 141     *gen_opparam_ptr++ = mem_index;
 142 }
 143
 144 static inline void tcg_gen_qemu_ldst_op_i64_i64(TCGOpcode opc, TCGv_i64 val,
 145                                                 TCGv_i64 addr, TCGArg mem_index)
 146 {
 147     *gen_opc_ptr++ = opc;
 148     *gen_opparam_ptr++ = GET_TCGV_I64(val);
 149     *gen_opparam_ptr++ = GET_TCGV_I64(addr);
 150     *gen_opparam_ptr++ = mem_index;
 151 }
 152
 153 static inline void tcg_gen_op4_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 154                                    TCGv_i32 arg3, TCGv_i32 arg4)
 155 {
 156     *gen_opc_ptr++ = opc;
 157     *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 158     *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 159     *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 160     *gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 161 }
 162
 163 static inline void tcg_gen_op4_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 164                                    TCGv_i64 arg3, TCGv_i64 arg4)
 165 {
 166     *gen_opc_ptr++ = opc;
 167     *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 168     *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 169     *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 170     *gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 171 }
 172
 173 static inline void tcg_gen_op4i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 174                                     TCGv_i32 arg3, TCGArg arg4)
 175 {
 176     *gen_opc_ptr++ = opc;
 177     *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 178     *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 179     *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 180     *gen_opparam_ptr++ = arg4;
 181 }
 182
 183 static inline void tcg_gen_op4i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 184                                     TCGv_i64 arg3, TCGArg arg4)
 185 {
 186     *gen_opc_ptr++ = opc;
 187     *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 188     *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 189     *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 190     *gen_opparam_ptr++ = arg4;
 191 }
 192
 193 static inline void tcg_gen_op4ii_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 194                                      TCGArg arg3, TCGArg arg4)
 195 {
 196     *gen_opc_ptr++ = opc;
 197     *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 198     *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 199     *gen_opparam_ptr++ = arg3;
 200     *gen_opparam_ptr++ = arg4;
 201 }
 202
 203 static inline void tcg_gen_op4ii_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 204                                      TCGArg arg3, TCGArg arg4)
 205 {
 206     *gen_opc_ptr++ = opc;
 207     *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 208     *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 209     *gen_opparam_ptr++ = arg3;
 210     *gen_opparam_ptr++ = arg4;
 211 }
 212
 213 static inline void tcg_gen_op5_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 214                                    TCGv_i32 arg3, TCGv_i32 arg4, TCGv_i32 arg5)
 215 {
 216     *gen_opc_ptr++ = opc;
 217     *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 218     *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 219     *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 220     *gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 221     *gen_opparam_ptr++ = GET_TCGV_I32(arg5);
 222 }
 223
 224 static inline void tcg_gen_op5_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 225                                    TCGv_i64 arg3, TCGv_i64 arg4, TCGv_i64 arg5)
 226 {
 227     *gen_opc_ptr++ = opc;
 228     *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 229     *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 230     *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 231     *gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 232     *gen_opparam_ptr++ = GET_TCGV_I64(arg5);
 233 }
 234
 235 static inline void tcg_gen_op5i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 236                                     TCGv_i32 arg3, TCGv_i32 arg4, TCGArg arg5)
 237 {
 238     *gen_opc_ptr++ = opc;
 239     *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 240     *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 241     *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 242     *gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 243     *gen_opparam_ptr++ = arg5;
 244 }
 245
 246 static inline void tcg_gen_op5i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 247                                     TCGv_i64 arg3, TCGv_i64 arg4, TCGArg arg5)
 248 {
 249     *gen_opc_ptr++ = opc;
 250     *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 251     *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 252     *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 253     *gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 254     *gen_opparam_ptr++ = arg5;
 255 }
 256
 257 static inline void tcg_gen_op6_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 258                                    TCGv_i32 arg3, TCGv_i32 arg4, TCGv_i32 arg5,
 259                                    TCGv_i32 arg6)
 260 {
 261     *gen_opc_ptr++ = opc;
 262     *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 263     *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 264     *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 265     *gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 266     *gen_opparam_ptr++ = GET_TCGV_I32(arg5);
 267     *gen_opparam_ptr++ = GET_TCGV_I32(arg6);
 268 }
 269
 270 static inline void tcg_gen_op6_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 271                                    TCGv_i64 arg3, TCGv_i64 arg4, TCGv_i64 arg5,
 272                                    TCGv_i64 arg6)
 273 {
 274     *gen_opc_ptr++ = opc;
 275     *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 276     *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 277     *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 278     *gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 279     *gen_opparam_ptr++ = GET_TCGV_I64(arg5);
 280     *gen_opparam_ptr++ = GET_TCGV_I64(arg6);
 281 }
 282
 283 static inline void tcg_gen_op6i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 284                                     TCGv_i32 arg3, TCGv_i32 arg4,
 285                                     TCGv_i32 arg5, TCGArg arg6)
 286 {
 287     *gen_opc_ptr++ = opc;
 288     *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 289     *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 290     *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 291     *gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 292     *gen_opparam_ptr++ = GET_TCGV_I32(arg5);
 293     *gen_opparam_ptr++ = arg6;
 294 }
 295
 296 static inline void tcg_gen_op6i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 297                                     TCGv_i64 arg3, TCGv_i64 arg4,
 298                                     TCGv_i64 arg5, TCGArg arg6)
 299 {
 300     *gen_opc_ptr++ = opc;
 301     *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 302     *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 303     *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 304     *gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 305     *gen_opparam_ptr++ = GET_TCGV_I64(arg5);
 306     *gen_opparam_ptr++ = arg6;
 307 }
 308
 309 static inline void tcg_gen_op6ii_i32(TCGOpcode opc, TCGv_i32 arg1,
 310                                      TCGv_i32 arg2, TCGv_i32 arg3,
 311                                      TCGv_i32 arg4, TCGArg arg5, TCGArg arg6)
 312 {
 313     *gen_opc_ptr++ = opc;
 314     *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 315     *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 316     *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 317     *gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 318     *gen_opparam_ptr++ = arg5;
 319     *gen_opparam_ptr++ = arg6;
 320 }
 321
 322 static inline void tcg_gen_op6ii_i64(TCGOpcode opc, TCGv_i64 arg1,
 323                                      TCGv_i64 arg2, TCGv_i64 arg3,
 324                                      TCGv_i64 arg4, TCGArg arg5, TCGArg arg6)
 325 {
 326     *gen_opc_ptr++ = opc;
 327     *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 328     *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 329     *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 330     *gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 331     *gen_opparam_ptr++ = arg5;
 332     *gen_opparam_ptr++ = arg6;
 333 }
 334
 335 static inline void gen_set_label(int n)
 336 {
 337     tcg_gen_op1i(INDEX_op_set_label, n);
 338 }
 339
 340 static inline void tcg_gen_br(int label)
 341 {
 342     tcg_gen_op1i(INDEX_op_br, label);
 343 }
 344
 345 static inline void tcg_gen_mov_i32(TCGv_i32 ret, TCGv_i32 arg)
 346 {
 347     if (!TCGV_EQUAL_I32(ret, arg))
 348         tcg_gen_op2_i32(INDEX_op_mov_i32, ret, arg);
 349 }
 350
 351 static inline void tcg_gen_movi_i32(TCGv_i32 ret, int32_t arg)
 352 {
 353     tcg_gen_op2i_i32(INDEX_op_movi_i32, ret, arg);
 354 }
 355
 356 /* helper calls */
 357 static inline void tcg_gen_helperN(void *func, int flags, int sizemask,
 358                                    TCGArg ret, int nargs, TCGArg *args)
 359 {
 360     TCGv_ptr fn;
 361     fn = tcg_const_ptr((tcg_target_long)func);
 362     tcg_gen_callN(&tcg_ctx, fn, flags, sizemask, ret,
 363                   nargs, args);
 364     tcg_temp_free_ptr(fn);
 365 }
 366
 367 /* Note: Both tcg_gen_helper32() and tcg_gen_helper64() are currently
 368    reserved for helpers in tcg-runtime.c. These helpers are all const
 369    and pure, hence the call to tcg_gen_callN() with TCG_CALL_CONST |
 370    TCG_CALL_PURE. This may need to be adjusted if these functions
 371    start to be used with other helpers. */
 372 static inline void tcg_gen_helper32(void *func, TCGv_i32 ret,
 373                                     TCGv_i32 a, TCGv_i32 b)
 374 {
 375     TCGv_ptr fn;
 376     TCGArg args[2];
 377     fn = tcg_const_ptr((tcg_target_long)func);
 378     args[0] = GET_TCGV_I32(a);
 379     args[1] = GET_TCGV_I32(b);
 380     tcg_gen_callN(&tcg_ctx, fn, TCG_CALL_CONST | TCG_CALL_PURE,
 381                   0, GET_TCGV_I32(ret), 2, args);
 382     tcg_temp_free_ptr(fn);
 383 }
 384
 385 static inline void tcg_gen_helper64(void *func, TCGv_i64 ret,
 386                                     TCGv_i64 a, TCGv_i64 b)
 387 {
 388     TCGv_ptr fn;
 389     TCGArg args[2];
 390     fn = tcg_const_ptr((tcg_target_long)func);
 391     args[0] = GET_TCGV_I64(a);
 392     args[1] = GET_TCGV_I64(b);
 393     tcg_gen_callN(&tcg_ctx, fn, TCG_CALL_CONST | TCG_CALL_PURE,
 394                   7, GET_TCGV_I64(ret), 2, args);
 395     tcg_temp_free_ptr(fn);
 396 }
 397
 398 /* 32 bit ops */
 399
 400 static inline void tcg_gen_ld8u_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 401 {
 402     tcg_gen_ldst_op_i32(INDEX_op_ld8u_i32, ret, arg2, offset);
 403 }
 404
 405 static inline void tcg_gen_ld8s_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 406 {
 407     tcg_gen_ldst_op_i32(INDEX_op_ld8s_i32, ret, arg2, offset);
 408 }
 409
 410 static inline void tcg_gen_ld16u_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 411 {
 412     tcg_gen_ldst_op_i32(INDEX_op_ld16u_i32, ret, arg2, offset);
 413 }
 414
 415 static inline void tcg_gen_ld16s_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 416 {
 417     tcg_gen_ldst_op_i32(INDEX_op_ld16s_i32, ret, arg2, offset);
 418 }
 419
 420 static inline void tcg_gen_ld_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 421 {
 422     tcg_gen_ldst_op_i32(INDEX_op_ld_i32, ret, arg2, offset);
 423 }
 424
 425 static inline void tcg_gen_st8_i32(TCGv_i32 arg1, TCGv_ptr arg2, tcg_target_long offset)
 426 {
 427     tcg_gen_ldst_op_i32(INDEX_op_st8_i32, arg1, arg2, offset);
 428 }
 429
 430 static inline void tcg_gen_st16_i32(TCGv_i32 arg1, TCGv_ptr arg2, tcg_target_long offset)
 431 {
 432     tcg_gen_ldst_op_i32(INDEX_op_st16_i32, arg1, arg2, offset);
 433 }
 434
 435 static inline void tcg_gen_st_i32(TCGv_i32 arg1, TCGv_ptr arg2, tcg_target_long offset)
 436 {
 437     tcg_gen_ldst_op_i32(INDEX_op_st_i32, arg1, arg2, offset);
 438 }
 439
 440 static inline void tcg_gen_add_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 441 {
 442     tcg_gen_op3_i32(INDEX_op_add_i32, ret, arg1, arg2);
 443 }
 444
 445 static inline void tcg_gen_addi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 446 {
 447     /* some cases can be optimized here */
 448     if (arg2 == 0) {
 449         tcg_gen_mov_i32(ret, arg1);
 450     } else {
 451         TCGv_i32 t0 = tcg_const_i32(arg2);
 452         tcg_gen_add_i32(ret, arg1, t0);
 453         tcg_temp_free_i32(t0);
 454     }
 455 }
 456
 457 static inline void tcg_gen_sub_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 458 {
 459     tcg_gen_op3_i32(INDEX_op_sub_i32, ret, arg1, arg2);
 460 }
 461
 462 static inline void tcg_gen_subfi_i32(TCGv_i32 ret, int32_t arg1, TCGv_i32 arg2)
 463 {
 464     TCGv_i32 t0 = tcg_const_i32(arg1);
 465     tcg_gen_sub_i32(ret, t0, arg2);
 466     tcg_temp_free_i32(t0);
 467 }
 468
 469 static inline void tcg_gen_subi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 470 {
 471     /* some cases can be optimized here */
 472     if (arg2 == 0) {
 473         tcg_gen_mov_i32(ret, arg1);
 474     } else {
 475         TCGv_i32 t0 = tcg_const_i32(arg2);
 476         tcg_gen_sub_i32(ret, arg1, t0);
 477         tcg_temp_free_i32(t0);
 478     }
 479 }
 480
 481 static inline void tcg_gen_and_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 482 {
 483     if (TCGV_EQUAL_I32(arg1, arg2)) {
 484         tcg_gen_mov_i32(ret, arg1);
 485     } else {
 486         tcg_gen_op3_i32(INDEX_op_and_i32, ret, arg1, arg2);
 487     }
 488 }
 489
 490 static inline void tcg_gen_andi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 491 {
 492     /* some cases can be optimized here */
 493     if (arg2 == 0) {
 494         tcg_gen_movi_i32(ret, 0);
 495     } else if (arg2 == 0xffffffff) {
 496         tcg_gen_mov_i32(ret, arg1);
 497     } else {
 498         TCGv_i32 t0 = tcg_const_i32(arg2);
 499         tcg_gen_and_i32(ret, arg1, t0);
 500         tcg_temp_free_i32(t0);
 501     }
 502 }
 503
 504 static inline void tcg_gen_or_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 505 {
 506     if (TCGV_EQUAL_I32(arg1, arg2)) {
 507         tcg_gen_mov_i32(ret, arg1);
 508     } else {
 509         tcg_gen_op3_i32(INDEX_op_or_i32, ret, arg1, arg2);
 510     }
 511 }
 512
 513 static inline void tcg_gen_ori_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 514 {
 515     /* some cases can be optimized here */
 516     if (arg2 == 0xffffffff) {
 517         tcg_gen_movi_i32(ret, 0xffffffff);
 518     } else if (arg2 == 0) {
 519         tcg_gen_mov_i32(ret, arg1);
 520     } else {
 521         TCGv_i32 t0 = tcg_const_i32(arg2);
 522         tcg_gen_or_i32(ret, arg1, t0);
 523         tcg_temp_free_i32(t0);
 524     }
 525 }
 526
 527 static inline void tcg_gen_xor_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 528 {
 529     if (TCGV_EQUAL_I32(arg1, arg2)) {
 530         tcg_gen_movi_i32(ret, 0);
 531     } else {
 532         tcg_gen_op3_i32(INDEX_op_xor_i32, ret, arg1, arg2);
 533     }
 534 }
 535
 536 static inline void tcg_gen_xori_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 537 {
 538     /* some cases can be optimized here */
 539     if (arg2 == 0) {
 540         tcg_gen_mov_i32(ret, arg1);
 541     } else {
 542         TCGv_i32 t0 = tcg_const_i32(arg2);
 543         tcg_gen_xor_i32(ret, arg1, t0);
 544         tcg_temp_free_i32(t0);
 545     }
 546 }
 547
 548 static inline void tcg_gen_shl_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 549 {
 550     tcg_gen_op3_i32(INDEX_op_shl_i32, ret, arg1, arg2);
 551 }
 552
 553 static inline void tcg_gen_shli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 554 {
 555     if (arg2 == 0) {
 556         tcg_gen_mov_i32(ret, arg1);
 557     } else {
 558         TCGv_i32 t0 = tcg_const_i32(arg2);
 559         tcg_gen_shl_i32(ret, arg1, t0);
 560         tcg_temp_free_i32(t0);
 561     }
 562 }
 563
 564 static inline void tcg_gen_shr_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 565 {
 566     tcg_gen_op3_i32(INDEX_op_shr_i32, ret, arg1, arg2);
 567 }
 568
 569 static inline void tcg_gen_shri_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 570 {
 571     if (arg2 == 0) {
 572         tcg_gen_mov_i32(ret, arg1);
 573     } else {
 574         TCGv_i32 t0 = tcg_const_i32(arg2);
 575         tcg_gen_shr_i32(ret, arg1, t0);
 576         tcg_temp_free_i32(t0);
 577     }
 578 }
 579
 580 static inline void tcg_gen_sar_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 581 {
 582     tcg_gen_op3_i32(INDEX_op_sar_i32, ret, arg1, arg2);
 583 }
 584
 585 static inline void tcg_gen_sari_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 586 {
 587     if (arg2 == 0) {
 588         tcg_gen_mov_i32(ret, arg1);
 589     } else {
 590         TCGv_i32 t0 = tcg_const_i32(arg2);
 591         tcg_gen_sar_i32(ret, arg1, t0);
 592         tcg_temp_free_i32(t0);
 593     }
 594 }
 595
 596 static inline void tcg_gen_brcond_i32(TCGCond cond, TCGv_i32 arg1,
 597                                       TCGv_i32 arg2, int label_index)
 598 {
 599     tcg_gen_op4ii_i32(INDEX_op_brcond_i32, arg1, arg2, cond, label_index);
 600 }
 601
 602 static inline void tcg_gen_brcondi_i32(TCGCond cond, TCGv_i32 arg1,
 603                                        int32_t arg2, int label_index)
 604 {
 605     TCGv_i32 t0 = tcg_const_i32(arg2);
 606     tcg_gen_brcond_i32(cond, arg1, t0, label_index);
 607     tcg_temp_free_i32(t0);
 608 }
 609
 610 static inline void tcg_gen_setcond_i32(TCGCond cond, TCGv_i32 ret,
 611                                        TCGv_i32 arg1, TCGv_i32 arg2)
 612 {
 613     tcg_gen_op4i_i32(INDEX_op_setcond_i32, ret, arg1, arg2, cond);
 614 }
 615
 616 static inline void tcg_gen_setcondi_i32(TCGCond cond, TCGv_i32 ret,
 617                                         TCGv_i32 arg1, int32_t arg2)
 618 {
 619     TCGv_i32 t0 = tcg_const_i32(arg2);
 620     tcg_gen_setcond_i32(cond, ret, arg1, t0);
 621     tcg_temp_free_i32(t0);
 622 }
 623
 624 static inline void tcg_gen_mul_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 625 {
 626     tcg_gen_op3_i32(INDEX_op_mul_i32, ret, arg1, arg2);
 627 }
 628
 629 static inline void tcg_gen_muli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 630 {
 631     TCGv_i32 t0 = tcg_const_i32(arg2);
 632     tcg_gen_mul_i32(ret, arg1, t0);
 633     tcg_temp_free_i32(t0);
 634 }
 635
 636 #ifdef TCG_TARGET_HAS_div_i32
 637 static inline void tcg_gen_div_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 638 {
 639     tcg_gen_op3_i32(INDEX_op_div_i32, ret, arg1, arg2);
 640 }
 641
 642 static inline void tcg_gen_rem_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 643 {
 644     tcg_gen_op3_i32(INDEX_op_rem_i32, ret, arg1, arg2);
 645 }
 646
 647 static inline void tcg_gen_divu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 648 {
 649     tcg_gen_op3_i32(INDEX_op_divu_i32, ret, arg1, arg2);
 650 }
 651
 652 static inline void tcg_gen_remu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 653 {
 654     tcg_gen_op3_i32(INDEX_op_remu_i32, ret, arg1, arg2);
 655 }
 656 #elif defined(TCG_TARGET_HAS_div2_i32)
 657 static inline void tcg_gen_div_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 658 {
 659     TCGv_i32 t0;
 660     t0 = tcg_temp_new_i32();
 661     tcg_gen_sari_i32(t0, arg1, 31);
 662     tcg_gen_op5_i32(INDEX_op_div2_i32, ret, t0, arg1, t0, arg2);
 663     tcg_temp_free_i32(t0);
 664 }
 665
 666 static inline void tcg_gen_rem_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 667 {
 668     TCGv_i32 t0;
 669     t0 = tcg_temp_new_i32();
 670     tcg_gen_sari_i32(t0, arg1, 31);
 671     tcg_gen_op5_i32(INDEX_op_div2_i32, t0, ret, arg1, t0, arg2);
 672     tcg_temp_free_i32(t0);
 673 }
 674
 675 static inline void tcg_gen_divu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 676 {
 677     TCGv_i32 t0;
 678     t0 = tcg_temp_new_i32();
 679     tcg_gen_movi_i32(t0, 0);
 680     tcg_gen_op5_i32(INDEX_op_divu2_i32, ret, t0, arg1, t0, arg2);
 681     tcg_temp_free_i32(t0);
 682 }
 683
 684 static inline void tcg_gen_remu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 685 {
 686     TCGv_i32 t0;
 687     t0 = tcg_temp_new_i32();
 688     tcg_gen_movi_i32(t0, 0);
 689     tcg_gen_op5_i32(INDEX_op_divu2_i32, t0, ret, arg1, t0, arg2);
 690     tcg_temp_free_i32(t0);
 691 }
 692 #else
 693 static inline void tcg_gen_div_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 694 {
 695     tcg_gen_helper32(tcg_helper_div_i32, ret, arg1, arg2);
 696 }
 697
 698 static inline void tcg_gen_rem_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 699 {
 700     tcg_gen_helper32(tcg_helper_rem_i32, ret, arg1, arg2);
 701 }
 702
 703 static inline void tcg_gen_divu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 704 {
 705     tcg_gen_helper32(tcg_helper_divu_i32, ret, arg1, arg2);
 706 }
 707
 708 static inline void tcg_gen_remu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 709 {
 710     tcg_gen_helper32(tcg_helper_remu_i32, ret, arg1, arg2);
 711 }
 712 #endif
 713
 714 #if TCG_TARGET_REG_BITS == 32
 715
 716 static inline void tcg_gen_mov_i64(TCGv_i64 ret, TCGv_i64 arg)
 717 {
 718     if (!TCGV_EQUAL_I64(ret, arg)) {
 719         tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg));
 720         tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg));
 721     }
 722 }
 723
 724 static inline void tcg_gen_movi_i64(TCGv_i64 ret, int64_t arg)
 725 {
 726     tcg_gen_movi_i32(TCGV_LOW(ret), arg);
 727     tcg_gen_movi_i32(TCGV_HIGH(ret), arg >> 32);
 728 }
 729
 730 static inline void tcg_gen_ld8u_i64(TCGv_i64 ret, TCGv_ptr arg2,
 731                                     tcg_target_long offset)
 732 {
 733     tcg_gen_ld8u_i32(TCGV_LOW(ret), arg2, offset);
 734     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 735 }
 736
 737 static inline void tcg_gen_ld8s_i64(TCGv_i64 ret, TCGv_ptr arg2,
 738                                     tcg_target_long offset)
 739 {
 740     tcg_gen_ld8s_i32(TCGV_LOW(ret), arg2, offset);
 741     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), 31);
 742 }
 743
 744 static inline void tcg_gen_ld16u_i64(TCGv_i64 ret, TCGv_ptr arg2,
 745                                      tcg_target_long offset)
 746 {
 747     tcg_gen_ld16u_i32(TCGV_LOW(ret), arg2, offset);
 748     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 749 }
 750
 751 static inline void tcg_gen_ld16s_i64(TCGv_i64 ret, TCGv_ptr arg2,
 752                                      tcg_target_long offset)
 753 {
 754     tcg_gen_ld16s_i32(TCGV_LOW(ret), arg2, offset);
 755     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
 756 }
 757
 758 static inline void tcg_gen_ld32u_i64(TCGv_i64 ret, TCGv_ptr arg2,
 759                                      tcg_target_long offset)
 760 {
 761     tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset);
 762     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 763 }
 764
 765 static inline void tcg_gen_ld32s_i64(TCGv_i64 ret, TCGv_ptr arg2,
 766                                      tcg_target_long offset)
 767 {
 768     tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset);
 769     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
 770 }
 771
 772 static inline void tcg_gen_ld_i64(TCGv_i64 ret, TCGv_ptr arg2,
 773                                   tcg_target_long offset)
 774 {
 775     /* since arg2 and ret have different types, they cannot be the
 776        same temporary */
 777 #ifdef TCG_TARGET_WORDS_BIGENDIAN
 778     tcg_gen_ld_i32(TCGV_HIGH(ret), arg2, offset);
 779     tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset + 4);
 780 #else
 781     tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset);
 782     tcg_gen_ld_i32(TCGV_HIGH(ret), arg2, offset + 4);
 783 #endif
 784 }
 785
 786 static inline void tcg_gen_st8_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 787                                    tcg_target_long offset)
 788 {
 789     tcg_gen_st8_i32(TCGV_LOW(arg1), arg2, offset);
 790 }
 791
 792 static inline void tcg_gen_st16_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 793                                     tcg_target_long offset)
 794 {
 795     tcg_gen_st16_i32(TCGV_LOW(arg1), arg2, offset);
 796 }
 797
 798 static inline void tcg_gen_st32_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 799                                     tcg_target_long offset)
 800 {
 801     tcg_gen_st_i32(TCGV_LOW(arg1), arg2, offset);
 802 }
 803
 804 static inline void tcg_gen_st_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 805                                   tcg_target_long offset)
 806 {
 807 #ifdef TCG_TARGET_WORDS_BIGENDIAN
 808     tcg_gen_st_i32(TCGV_HIGH(arg1), arg2, offset);
 809     tcg_gen_st_i32(TCGV_LOW(arg1), arg2, offset + 4);
 810 #else
 811     tcg_gen_st_i32(TCGV_LOW(arg1), arg2, offset);
 812     tcg_gen_st_i32(TCGV_HIGH(arg1), arg2, offset + 4);
 813 #endif
 814 }
 815
 816 static inline void tcg_gen_add_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 817 {
 818     tcg_gen_op6_i32(INDEX_op_add2_i32, TCGV_LOW(ret), TCGV_HIGH(ret),
 819                     TCGV_LOW(arg1), TCGV_HIGH(arg1), TCGV_LOW(arg2),
 820                     TCGV_HIGH(arg2));
 821 }
 822
 823 static inline void tcg_gen_sub_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 824 {
 825     tcg_gen_op6_i32(INDEX_op_sub2_i32, TCGV_LOW(ret), TCGV_HIGH(ret),
 826                     TCGV_LOW(arg1), TCGV_HIGH(arg1), TCGV_LOW(arg2),
 827                     TCGV_HIGH(arg2));
 828 }
 829
 830 static inline void tcg_gen_and_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 831 {
 832     tcg_gen_and_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 833     tcg_gen_and_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 834 }
 835
 836 static inline void tcg_gen_andi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 837 {
 838     tcg_gen_andi_i32(TCGV_LOW(ret), TCGV_LOW(arg1), arg2);
 839     tcg_gen_andi_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
 840 }
 841
 842 static inline void tcg_gen_or_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 843 {
 844     tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 845     tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 846 }
 847
 848 static inline void tcg_gen_ori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 849 {
 850     tcg_gen_ori_i32(TCGV_LOW(ret), TCGV_LOW(arg1), arg2);
 851     tcg_gen_ori_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
 852 }
 853
 854 static inline void tcg_gen_xor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 855 {
 856     tcg_gen_xor_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 857     tcg_gen_xor_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 858 }
 859
 860 static inline void tcg_gen_xori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 861 {
 862     tcg_gen_xori_i32(TCGV_LOW(ret), TCGV_LOW(arg1), arg2);
 863     tcg_gen_xori_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
 864 }
 865
 866 /* XXX: use generic code when basic block handling is OK or CPU
 867    specific code (x86) */
 868 static inline void tcg_gen_shl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 869 {
 870     tcg_gen_helper64(tcg_helper_shl_i64, ret, arg1, arg2);
 871 }
 872
 873 static inline void tcg_gen_shli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 874 {
 875     tcg_gen_shifti_i64(ret, arg1, arg2, 0, 0);
 876 }
 877
 878 static inline void tcg_gen_shr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 879 {
 880     tcg_gen_helper64(tcg_helper_shr_i64, ret, arg1, arg2);
 881 }
 882
 883 static inline void tcg_gen_shri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 884 {
 885     tcg_gen_shifti_i64(ret, arg1, arg2, 1, 0);
 886 }
 887
 888 static inline void tcg_gen_sar_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 889 {
 890     tcg_gen_helper64(tcg_helper_sar_i64, ret, arg1, arg2);
 891 }
 892
 893 static inline void tcg_gen_sari_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 894 {
 895     tcg_gen_shifti_i64(ret, arg1, arg2, 1, 1);
 896 }
 897
 898 static inline void tcg_gen_brcond_i64(TCGCond cond, TCGv_i64 arg1,
 899                                       TCGv_i64 arg2, int label_index)
 900 {
 901     tcg_gen_op6ii_i32(INDEX_op_brcond2_i32,
 902                       TCGV_LOW(arg1), TCGV_HIGH(arg1), TCGV_LOW(arg2),
 903                       TCGV_HIGH(arg2), cond, label_index);
 904 }
 905
 906 static inline void tcg_gen_setcond_i64(TCGCond cond, TCGv_i64 ret,
 907                                        TCGv_i64 arg1, TCGv_i64 arg2)
 908 {
 909     tcg_gen_op6i_i32(INDEX_op_setcond2_i32, TCGV_LOW(ret),
 910                      TCGV_LOW(arg1), TCGV_HIGH(arg1),
 911                      TCGV_LOW(arg2), TCGV_HIGH(arg2), cond);
 912     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 913 }
 914
 915 static inline void tcg_gen_mul_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 916 {
 917     TCGv_i64 t0;
 918     TCGv_i32 t1;
 919
 920     t0 = tcg_temp_new_i64();
 921     t1 = tcg_temp_new_i32();
 922
 923     tcg_gen_op4_i32(INDEX_op_mulu2_i32, TCGV_LOW(t0), TCGV_HIGH(t0),
 924                     TCGV_LOW(arg1), TCGV_LOW(arg2));
 925
 926     tcg_gen_mul_i32(t1, TCGV_LOW(arg1), TCGV_HIGH(arg2));
 927     tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1);
 928     tcg_gen_mul_i32(t1, TCGV_HIGH(arg1), TCGV_LOW(arg2));
 929     tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1);
 930
 931     tcg_gen_mov_i64(ret, t0);
 932     tcg_temp_free_i64(t0);
 933     tcg_temp_free_i32(t1);
 934 }
 935
 936 static inline void tcg_gen_div_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 937 {
 938     tcg_gen_helper64(tcg_helper_div_i64, ret, arg1, arg2);
 939 }
 940
 941 static inline void tcg_gen_rem_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 942 {
 943     tcg_gen_helper64(tcg_helper_rem_i64, ret, arg1, arg2);
 944 }
 945
 946 static inline void tcg_gen_divu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 947 {
 948     tcg_gen_helper64(tcg_helper_divu_i64, ret, arg1, arg2);
 949 }
 950
 951 static inline void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 952 {
 953     tcg_gen_helper64(tcg_helper_remu_i64, ret, arg1, arg2);
 954 }
 955
 956 #else
 957
 958 static inline void tcg_gen_mov_i64(TCGv_i64 ret, TCGv_i64 arg)
 959 {
 960     if (!TCGV_EQUAL_I64(ret, arg))
 961         tcg_gen_op2_i64(INDEX_op_mov_i64, ret, arg);
 962 }
 963
 964 static inline void tcg_gen_movi_i64(TCGv_i64 ret, int64_t arg)
 965 {
 966     tcg_gen_op2i_i64(INDEX_op_movi_i64, ret, arg);
 967 }
 968
 969 static inline void tcg_gen_ld8u_i64(TCGv_i64 ret, TCGv_i64 arg2,
 970                                     tcg_target_long offset)
 971 {
 972     tcg_gen_ldst_op_i64(INDEX_op_ld8u_i64, ret, arg2, offset);
 973 }
 974
 975 static inline void tcg_gen_ld8s_i64(TCGv_i64 ret, TCGv_i64 arg2,
 976                                     tcg_target_long offset)
 977 {
 978     tcg_gen_ldst_op_i64(INDEX_op_ld8s_i64, ret, arg2, offset);
 979 }
 980
 981 static inline void tcg_gen_ld16u_i64(TCGv_i64 ret, TCGv_i64 arg2,
 982                                      tcg_target_long offset)
 983 {
 984     tcg_gen_ldst_op_i64(INDEX_op_ld16u_i64, ret, arg2, offset);
 985 }
 986
 987 static inline void tcg_gen_ld16s_i64(TCGv_i64 ret, TCGv_i64 arg2,
 988                                      tcg_target_long offset)
 989 {
 990     tcg_gen_ldst_op_i64(INDEX_op_ld16s_i64, ret, arg2, offset);
 991 }
 992
 993 static inline void tcg_gen_ld32u_i64(TCGv_i64 ret, TCGv_i64 arg2,
 994                                      tcg_target_long offset)
 995 {
 996     tcg_gen_ldst_op_i64(INDEX_op_ld32u_i64, ret, arg2, offset);
 997 }
 998
 999 static inline void tcg_gen_ld32s_i64(TCGv_i64 ret, TCGv_i64 arg2,
1000                                      tcg_target_long offset)
1001 {
1002     tcg_gen_ldst_op_i64(INDEX_op_ld32s_i64, ret, arg2, offset);
1003 }
1004
1005 static inline void tcg_gen_ld_i64(TCGv_i64 ret, TCGv_i64 arg2, tcg_target_long offset)
1006 {
1007     tcg_gen_ldst_op_i64(INDEX_op_ld_i64, ret, arg2, offset);
1008 }
1009
1010 static inline void tcg_gen_st8_i64(TCGv_i64 arg1, TCGv_i64 arg2,
1011                                    tcg_target_long offset)
1012 {
1013     tcg_gen_ldst_op_i64(INDEX_op_st8_i64, arg1, arg2, offset);
1014 }
1015
1016 static inline void tcg_gen_st16_i64(TCGv_i64 arg1, TCGv_i64 arg2,
1017                                     tcg_target_long offset)
1018 {
1019     tcg_gen_ldst_op_i64(INDEX_op_st16_i64, arg1, arg2, offset);
1020 }
1021
1022 static inline void tcg_gen_st32_i64(TCGv_i64 arg1, TCGv_i64 arg2,
1023                                     tcg_target_long offset)
1024 {
1025     tcg_gen_ldst_op_i64(INDEX_op_st32_i64, arg1, arg2, offset);
1026 }
1027
1028 static inline void tcg_gen_st_i64(TCGv_i64 arg1, TCGv_i64 arg2, tcg_target_long offset)
1029 {
1030     tcg_gen_ldst_op_i64(INDEX_op_st_i64, arg1, arg2, offset);
1031 }
1032
1033 static inline void tcg_gen_add_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1034 {
1035     tcg_gen_op3_i64(INDEX_op_add_i64, ret, arg1, arg2);
1036 }
1037
1038 static inline void tcg_gen_sub_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1039 {
1040     tcg_gen_op3_i64(INDEX_op_sub_i64, ret, arg1, arg2);
1041 }
1042
1043 static inline void tcg_gen_and_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1044 {
1045     if (TCGV_EQUAL_I64(arg1, arg2)) {
1046         tcg_gen_mov_i64(ret, arg1);
1047     } else {
1048         tcg_gen_op3_i64(INDEX_op_and_i64, ret, arg1, arg2);
1049     }
1050 }
1051
1052 static inline void tcg_gen_andi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1053 {
1054     TCGv_i64 t0 = tcg_const_i64(arg2);
1055     tcg_gen_and_i64(ret, arg1, t0);
1056     tcg_temp_free_i64(t0);
1057 }
1058
1059 static inline void tcg_gen_or_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1060 {
1061     if (TCGV_EQUAL_I64(arg1, arg2)) {
1062         tcg_gen_mov_i64(ret, arg1);
1063     } else {
1064         tcg_gen_op3_i64(INDEX_op_or_i64, ret, arg1, arg2);
1065     }
1066 }
1067
1068 static inline void tcg_gen_ori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1069 {
1070     TCGv_i64 t0 = tcg_const_i64(arg2);
1071     tcg_gen_or_i64(ret, arg1, t0);
1072     tcg_temp_free_i64(t0);
1073 }
1074
1075 static inline void tcg_gen_xor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1076 {
1077     if (TCGV_EQUAL_I64(arg1, arg2)) {
1078         tcg_gen_movi_i64(ret, 0);
1079     } else {
1080         tcg_gen_op3_i64(INDEX_op_xor_i64, ret, arg1, arg2);
1081     }
1082 }
1083
1084 static inline void tcg_gen_xori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1085 {
1086     TCGv_i64 t0 = tcg_const_i64(arg2);
1087     tcg_gen_xor_i64(ret, arg1, t0);
1088     tcg_temp_free_i64(t0);
1089 }
1090
1091 static inline void tcg_gen_shl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1092 {
1093     tcg_gen_op3_i64(INDEX_op_shl_i64, ret, arg1, arg2);
1094 }
1095
1096 static inline void tcg_gen_shli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1097 {
1098     if (arg2 == 0) {
1099         tcg_gen_mov_i64(ret, arg1);
1100     } else {
1101         TCGv_i64 t0 = tcg_const_i64(arg2);
1102         tcg_gen_shl_i64(ret, arg1, t0);
1103         tcg_temp_free_i64(t0);
1104     }
1105 }
1106
1107 static inline void tcg_gen_shr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1108 {
1109     tcg_gen_op3_i64(INDEX_op_shr_i64, ret, arg1, arg2);
1110 }
1111
1112 static inline void tcg_gen_shri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1113 {
1114     if (arg2 == 0) {
1115         tcg_gen_mov_i64(ret, arg1);
1116     } else {
1117         TCGv_i64 t0 = tcg_const_i64(arg2);
1118         tcg_gen_shr_i64(ret, arg1, t0);
1119         tcg_temp_free_i64(t0);
1120     }
1121 }
1122
1123 static inline void tcg_gen_sar_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1124 {
1125     tcg_gen_op3_i64(INDEX_op_sar_i64, ret, arg1, arg2);
1126 }
1127
1128 static inline void tcg_gen_sari_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1129 {
1130     if (arg2 == 0) {
1131         tcg_gen_mov_i64(ret, arg1);
1132     } else {
1133         TCGv_i64 t0 = tcg_const_i64(arg2);
1134         tcg_gen_sar_i64(ret, arg1, t0);
1135         tcg_temp_free_i64(t0);
1136     }
1137 }
1138
1139 static inline void tcg_gen_brcond_i64(TCGCond cond, TCGv_i64 arg1,
1140                                       TCGv_i64 arg2, int label_index)
1141 {
1142     tcg_gen_op4ii_i64(INDEX_op_brcond_i64, arg1, arg2, cond, label_index);
1143 }
1144
1145 static inline void tcg_gen_setcond_i64(TCGCond cond, TCGv_i64 ret,
1146                                        TCGv_i64 arg1, TCGv_i64 arg2)
1147 {
1148     tcg_gen_op4i_i64(INDEX_op_setcond_i64, ret, arg1, arg2, cond);
1149 }
1150
1151 static inline void tcg_gen_mul_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1152 {
1153     tcg_gen_op3_i64(INDEX_op_mul_i64, ret, arg1, arg2);
1154 }
1155
1156 #ifdef TCG_TARGET_HAS_div_i64
1157 static inline void tcg_gen_div_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1158 {
1159     tcg_gen_op3_i64(INDEX_op_div_i64, ret, arg1, arg2);
1160 }
1161
1162 static inline void tcg_gen_rem_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1163 {
1164     tcg_gen_op3_i64(INDEX_op_rem_i64, ret, arg1, arg2);
1165 }
1166
1167 static inline void tcg_gen_divu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1168 {
1169     tcg_gen_op3_i64(INDEX_op_divu_i64, ret, arg1, arg2);
1170 }
1171
1172 static inline void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1173 {
1174     tcg_gen_op3_i64(INDEX_op_remu_i64, ret, arg1, arg2);
1175 }
1176 #elif defined(TCG_TARGET_HAS_div2_i64)
1177 static inline void tcg_gen_div_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1178 {
1179     TCGv_i64 t0;
1180     t0 = tcg_temp_new_i64();
1181     tcg_gen_sari_i64(t0, arg1, 63);
1182     tcg_gen_op5_i64(INDEX_op_div2_i64, ret, t0, arg1, t0, arg2);
1183     tcg_temp_free_i64(t0);
1184 }
1185
1186 static inline void tcg_gen_rem_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1187 {
1188     TCGv_i64 t0;
1189     t0 = tcg_temp_new_i64();
1190     tcg_gen_sari_i64(t0, arg1, 63);
1191     tcg_gen_op5_i64(INDEX_op_div2_i64, t0, ret, arg1, t0, arg2);
1192     tcg_temp_free_i64(t0);
1193 }
1194
1195 static inline void tcg_gen_divu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1196 {
1197     TCGv_i64 t0;
1198     t0 = tcg_temp_new_i64();
1199     tcg_gen_movi_i64(t0, 0);
1200     tcg_gen_op5_i64(INDEX_op_divu2_i64, ret, t0, arg1, t0, arg2);
1201     tcg_temp_free_i64(t0);
1202 }
1203
1204 static inline void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1205 {
1206     TCGv_i64 t0;
1207     t0 = tcg_temp_new_i64();
1208     tcg_gen_movi_i64(t0, 0);
1209     tcg_gen_op5_i64(INDEX_op_divu2_i64, t0, ret, arg1, t0, arg2);
1210     tcg_temp_free_i64(t0);
1211 }
1212 #else
1213 static inline void tcg_gen_div_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1214 {
1215     tcg_gen_helper64(tcg_helper_div_i64, ret, arg1, arg2);
1216 }
1217
1218 static inline void tcg_gen_rem_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1219 {
1220     tcg_gen_helper64(tcg_helper_rem_i64, ret, arg1, arg2);
1221 }
1222
1223 static inline void tcg_gen_divu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1224 {
1225     tcg_gen_helper64(tcg_helper_divu_i64, ret, arg1, arg2);
1226 }
1227
1228 static inline void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1229 {
1230     tcg_gen_helper64(tcg_helper_remu_i64, ret, arg1, arg2);
1231 }
1232 #endif
1233
1234 #endif
1235
1236 static inline void tcg_gen_addi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1237 {
1238     /* some cases can be optimized here */
1239     if (arg2 == 0) {
1240         tcg_gen_mov_i64(ret, arg1);
1241     } else {
1242         TCGv_i64 t0 = tcg_const_i64(arg2);
1243         tcg_gen_add_i64(ret, arg1, t0);
1244         tcg_temp_free_i64(t0);
1245     }
1246 }
1247
1248 static inline void tcg_gen_subfi_i64(TCGv_i64 ret, int64_t arg1, TCGv_i64 arg2)
1249 {
1250     TCGv_i64 t0 = tcg_const_i64(arg1);
1251     tcg_gen_sub_i64(ret, t0, arg2);
1252     tcg_temp_free_i64(t0);
1253 }
1254
1255 static inline void tcg_gen_subi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1256 {
1257     /* some cases can be optimized here */
1258     if (arg2 == 0) {
1259         tcg_gen_mov_i64(ret, arg1);
1260     } else {
1261         TCGv_i64 t0 = tcg_const_i64(arg2);
1262         tcg_gen_sub_i64(ret, arg1, t0);
1263         tcg_temp_free_i64(t0);
1264     }
1265 }
1266 static inline void tcg_gen_brcondi_i64(TCGCond cond, TCGv_i64 arg1,
1267                                        int64_t arg2, int label_index)
1268 {
1269     TCGv_i64 t0 = tcg_const_i64(arg2);
1270     tcg_gen_brcond_i64(cond, arg1, t0, label_index);
1271     tcg_temp_free_i64(t0);
1272 }
1273
1274 static inline void tcg_gen_setcondi_i64(TCGCond cond, TCGv_i64 ret,
1275                                         TCGv_i64 arg1, int64_t arg2)
1276 {
1277     TCGv_i64 t0 = tcg_const_i64(arg2);
1278     tcg_gen_setcond_i64(cond, ret, arg1, t0);
1279     tcg_temp_free_i64(t0);
1280 }
1281
1282 static inline void tcg_gen_muli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1283 {
1284     TCGv_i64 t0 = tcg_const_i64(arg2);
1285     tcg_gen_mul_i64(ret, arg1, t0);
1286     tcg_temp_free_i64(t0);
1287 }
1288
1289
1290 /***************************************/
1291 /* optional operations */
1292
1293 static inline void tcg_gen_ext8s_i32(TCGv_i32 ret, TCGv_i32 arg)
1294 {
1295 #ifdef TCG_TARGET_HAS_ext8s_i32
1296     tcg_gen_op2_i32(INDEX_op_ext8s_i32, ret, arg);
1297 #else
1298     tcg_gen_shli_i32(ret, arg, 24);
1299     tcg_gen_sari_i32(ret, ret, 24);
1300 #endif
1301 }
1302
1303 static inline void tcg_gen_ext16s_i32(TCGv_i32 ret, TCGv_i32 arg)
1304 {
1305 #ifdef TCG_TARGET_HAS_ext16s_i32
1306     tcg_gen_op2_i32(INDEX_op_ext16s_i32, ret, arg);
1307 #else
1308     tcg_gen_shli_i32(ret, arg, 16);
1309     tcg_gen_sari_i32(ret, ret, 16);
1310 #endif
1311 }
1312
1313 static inline void tcg_gen_ext8u_i32(TCGv_i32 ret, TCGv_i32 arg)
1314 {
1315 #ifdef TCG_TARGET_HAS_ext8u_i32
1316     tcg_gen_op2_i32(INDEX_op_ext8u_i32, ret, arg);
1317 #else
1318     tcg_gen_andi_i32(ret, arg, 0xffu);
1319 #endif
1320 }
1321
1322 static inline void tcg_gen_ext16u_i32(TCGv_i32 ret, TCGv_i32 arg)
1323 {
1324 #ifdef TCG_TARGET_HAS_ext16u_i32
1325     tcg_gen_op2_i32(INDEX_op_ext16u_i32, ret, arg);
1326 #else
1327     tcg_gen_andi_i32(ret, arg, 0xffffu);
1328 #endif
1329 }
1330
1331 /* Note: we assume the two high bytes are set to zero */
1332 static inline void tcg_gen_bswap16_i32(TCGv_i32 ret, TCGv_i32 arg)
1333 {
1334 #ifdef TCG_TARGET_HAS_bswap16_i32
1335     tcg_gen_op2_i32(INDEX_op_bswap16_i32, ret, arg);
1336 #else
1337     TCGv_i32 t0 = tcg_temp_new_i32();
1338
1339     tcg_gen_ext8u_i32(t0, arg);
1340     tcg_gen_shli_i32(t0, t0, 8);
1341     tcg_gen_shri_i32(ret, arg, 8);
1342     tcg_gen_or_i32(ret, ret, t0);
1343     tcg_temp_free_i32(t0);
1344 #endif
1345 }
1346
1347 static inline void tcg_gen_bswap32_i32(TCGv_i32 ret, TCGv_i32 arg)
1348 {
1349 #ifdef TCG_TARGET_HAS_bswap32_i32
1350     tcg_gen_op2_i32(INDEX_op_bswap32_i32, ret, arg);
1351 #else
1352     TCGv_i32 t0, t1;
1353     t0 = tcg_temp_new_i32();
1354     t1 = tcg_temp_new_i32();
1355
1356     tcg_gen_shli_i32(t0, arg, 24);
1357
1358     tcg_gen_andi_i32(t1, arg, 0x0000ff00);
1359     tcg_gen_shli_i32(t1, t1, 8);
1360     tcg_gen_or_i32(t0, t0, t1);
1361
1362     tcg_gen_shri_i32(t1, arg, 8);
1363     tcg_gen_andi_i32(t1, t1, 0x0000ff00);
1364     tcg_gen_or_i32(t0, t0, t1);
1365
1366     tcg_gen_shri_i32(t1, arg, 24);
1367     tcg_gen_or_i32(ret, t0, t1);
1368     tcg_temp_free_i32(t0);
1369     tcg_temp_free_i32(t1);
1370 #endif
1371 }
1372
1373 #if TCG_TARGET_REG_BITS == 32
1374 static inline void tcg_gen_ext8s_i64(TCGv_i64 ret, TCGv_i64 arg)
1375 {
1376     tcg_gen_ext8s_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1377     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
1378 }
1379
1380 static inline void tcg_gen_ext16s_i64(TCGv_i64 ret, TCGv_i64 arg)
1381 {
1382     tcg_gen_ext16s_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1383     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
1384 }
1385
1386 static inline void tcg_gen_ext32s_i64(TCGv_i64 ret, TCGv_i64 arg)
1387 {
1388     tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1389     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
1390 }
1391
1392 static inline void tcg_gen_ext8u_i64(TCGv_i64 ret, TCGv_i64 arg)
1393 {
1394     tcg_gen_ext8u_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1395     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1396 }
1397
1398 static inline void tcg_gen_ext16u_i64(TCGv_i64 ret, TCGv_i64 arg)
1399 {
1400     tcg_gen_ext16u_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1401     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1402 }
1403
1404 static inline void tcg_gen_ext32u_i64(TCGv_i64 ret, TCGv_i64 arg)
1405 {
1406     tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1407     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1408 }
1409
1410 static inline void tcg_gen_trunc_i64_i32(TCGv_i32 ret, TCGv_i64 arg)
1411 {
1412     tcg_gen_mov_i32(ret, TCGV_LOW(arg));
1413 }
1414
1415 static inline void tcg_gen_extu_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
1416 {
1417     tcg_gen_mov_i32(TCGV_LOW(ret), arg);
1418     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1419 }
1420
1421 static inline void tcg_gen_ext_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
1422 {
1423     tcg_gen_mov_i32(TCGV_LOW(ret), arg);
1424     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
1425 }
1426
1427 /* Note: we assume the six high bytes are set to zero */
1428 static inline void tcg_gen_bswap16_i64(TCGv_i64 ret, TCGv_i64 arg)
1429 {
1430     tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg));
1431     tcg_gen_bswap16_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1432 }
1433
1434 /* Note: we assume the four high bytes are set to zero */
1435 static inline void tcg_gen_bswap32_i64(TCGv_i64 ret, TCGv_i64 arg)
1436 {
1437     tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg));
1438     tcg_gen_bswap32_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1439 }
1440
1441 static inline void tcg_gen_bswap64_i64(TCGv_i64 ret, TCGv_i64 arg)
1442 {
1443     TCGv_i32 t0, t1;
1444     t0 = tcg_temp_new_i32();
1445     t1 = tcg_temp_new_i32();
1446
1447     tcg_gen_bswap32_i32(t0, TCGV_LOW(arg));
1448     tcg_gen_bswap32_i32(t1, TCGV_HIGH(arg));
1449     tcg_gen_mov_i32(TCGV_LOW(ret), t1);
1450     tcg_gen_mov_i32(TCGV_HIGH(ret), t0);
1451     tcg_temp_free_i32(t0);
1452     tcg_temp_free_i32(t1);
1453 }
1454 #else
1455
1456 static inline void tcg_gen_ext8s_i64(TCGv_i64 ret, TCGv_i64 arg)
1457 {
1458 #ifdef TCG_TARGET_HAS_ext8s_i64
1459     tcg_gen_op2_i64(INDEX_op_ext8s_i64, ret, arg);
1460 #else
1461     tcg_gen_shli_i64(ret, arg, 56);
1462     tcg_gen_sari_i64(ret, ret, 56);
1463 #endif
1464 }
1465
1466 static inline void tcg_gen_ext16s_i64(TCGv_i64 ret, TCGv_i64 arg)
1467 {
1468 #ifdef TCG_TARGET_HAS_ext16s_i64
1469     tcg_gen_op2_i64(INDEX_op_ext16s_i64, ret, arg);
1470 #else
1471     tcg_gen_shli_i64(ret, arg, 48);
1472     tcg_gen_sari_i64(ret, ret, 48);
1473 #endif
1474 }
1475
1476 static inline void tcg_gen_ext32s_i64(TCGv_i64 ret, TCGv_i64 arg)
1477 {
1478 #ifdef TCG_TARGET_HAS_ext32s_i64
1479     tcg_gen_op2_i64(INDEX_op_ext32s_i64, ret, arg);
1480 #else
1481     tcg_gen_shli_i64(ret, arg, 32);
1482     tcg_gen_sari_i64(ret, ret, 32);
1483 #endif
1484 }
1485
1486 static inline void tcg_gen_ext8u_i64(TCGv_i64 ret, TCGv_i64 arg)
1487 {
1488 #ifdef TCG_TARGET_HAS_ext8u_i64
1489     tcg_gen_op2_i64(INDEX_op_ext8u_i64, ret, arg);
1490 #else
1491     tcg_gen_andi_i64(ret, arg, 0xffu);
1492 #endif
1493 }
1494
1495 static inline void tcg_gen_ext16u_i64(TCGv_i64 ret, TCGv_i64 arg)
1496 {
1497 #ifdef TCG_TARGET_HAS_ext16u_i64
1498     tcg_gen_op2_i64(INDEX_op_ext16u_i64, ret, arg);
1499 #else
1500     tcg_gen_andi_i64(ret, arg, 0xffffu);
1501 #endif
1502 }
1503
1504 static inline void tcg_gen_ext32u_i64(TCGv_i64 ret, TCGv_i64 arg)
1505 {
1506 #ifdef TCG_TARGET_HAS_ext32u_i64
1507     tcg_gen_op2_i64(INDEX_op_ext32u_i64, ret, arg);
1508 #else
1509     tcg_gen_andi_i64(ret, arg, 0xffffffffu);
1510 #endif
1511 }
1512
1513 /* Note: we assume the target supports move between 32 and 64 bit
1514    registers.  This will probably break MIPS64 targets.  */
1515 static inline void tcg_gen_trunc_i64_i32(TCGv_i32 ret, TCGv_i64 arg)
1516 {
1517     tcg_gen_mov_i32(ret, MAKE_TCGV_I32(GET_TCGV_I64(arg)));
1518 }
1519
1520 /* Note: we assume the target supports move between 32 and 64 bit
1521    registers */
1522 static inline void tcg_gen_extu_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
1523 {
1524     tcg_gen_ext32u_i64(ret, MAKE_TCGV_I64(GET_TCGV_I32(arg)));
1525 }
1526
1527 /* Note: we assume the target supports move between 32 and 64 bit
1528    registers */
1529 static inline void tcg_gen_ext_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
1530 {
1531     tcg_gen_ext32s_i64(ret, MAKE_TCGV_I64(GET_TCGV_I32(arg)));
1532 }
1533
1534 /* Note: we assume the six high bytes are set to zero */
1535 static inline void tcg_gen_bswap16_i64(TCGv_i64 ret, TCGv_i64 arg)
1536 {
1537 #ifdef TCG_TARGET_HAS_bswap16_i64
1538     tcg_gen_op2_i64(INDEX_op_bswap16_i64, ret, arg);
1539 #else
1540     TCGv_i64 t0 = tcg_temp_new_i64();
1541
1542     tcg_gen_ext8u_i64(t0, arg);
1543     tcg_gen_shli_i64(t0, t0, 8);
1544     tcg_gen_shri_i64(ret, arg, 8);
1545     tcg_gen_or_i64(ret, ret, t0);
1546     tcg_temp_free_i64(t0);
1547 #endif
1548 }
1549
1550 /* Note: we assume the four high bytes are set to zero */
1551 static inline void tcg_gen_bswap32_i64(TCGv_i64 ret, TCGv_i64 arg)
1552 {
1553 #ifdef TCG_TARGET_HAS_bswap32_i64
1554     tcg_gen_op2_i64(INDEX_op_bswap32_i64, ret, arg);
1555 #else
1556     TCGv_i64 t0, t1;
1557     t0 = tcg_temp_new_i64();
1558     t1 = tcg_temp_new_i64();
1559
1560     tcg_gen_shli_i64(t0, arg, 24);
1561     tcg_gen_ext32u_i64(t0, t0);
1562
1563     tcg_gen_andi_i64(t1, arg, 0x0000ff00);
1564     tcg_gen_shli_i64(t1, t1, 8);
1565     tcg_gen_or_i64(t0, t0, t1);
1566
1567     tcg_gen_shri_i64(t1, arg, 8);
1568     tcg_gen_andi_i64(t1, t1, 0x0000ff00);
1569     tcg_gen_or_i64(t0, t0, t1);
1570
1571     tcg_gen_shri_i64(t1, arg, 24);
1572     tcg_gen_or_i64(ret, t0, t1);
1573     tcg_temp_free_i64(t0);
1574     tcg_temp_free_i64(t1);
1575 #endif
1576 }
1577
1578 static inline void tcg_gen_bswap64_i64(TCGv_i64 ret, TCGv_i64 arg)
1579 {
1580 #ifdef TCG_TARGET_HAS_bswap64_i64
1581     tcg_gen_op2_i64(INDEX_op_bswap64_i64, ret, arg);
1582 #else
1583     TCGv_i64 t0 = tcg_temp_new_i64();
1584     TCGv_i64 t1 = tcg_temp_new_i64();
1585
1586     tcg_gen_shli_i64(t0, arg, 56);
1587
1588     tcg_gen_andi_i64(t1, arg, 0x0000ff00);
1589     tcg_gen_shli_i64(t1, t1, 40);
1590     tcg_gen_or_i64(t0, t0, t1);
1591
1592     tcg_gen_andi_i64(t1, arg, 0x00ff0000);
1593     tcg_gen_shli_i64(t1, t1, 24);
1594     tcg_gen_or_i64(t0, t0, t1);
1595
1596     tcg_gen_andi_i64(t1, arg, 0xff000000);
1597     tcg_gen_shli_i64(t1, t1, 8);
1598     tcg_gen_or_i64(t0, t0, t1);
1599
1600     tcg_gen_shri_i64(t1, arg, 8);
1601     tcg_gen_andi_i64(t1, t1, 0xff000000);
1602     tcg_gen_or_i64(t0, t0, t1);
1603
1604     tcg_gen_shri_i64(t1, arg, 24);
1605     tcg_gen_andi_i64(t1, t1, 0x00ff0000);
1606     tcg_gen_or_i64(t0, t0, t1);
1607
1608     tcg_gen_shri_i64(t1, arg, 40);
1609     tcg_gen_andi_i64(t1, t1, 0x0000ff00);
1610     tcg_gen_or_i64(t0, t0, t1);
1611
1612     tcg_gen_shri_i64(t1, arg, 56);
1613     tcg_gen_or_i64(ret, t0, t1);
1614     tcg_temp_free_i64(t0);
1615     tcg_temp_free_i64(t1);
1616 #endif
1617 }
1618
1619 #endif
1620
1621 static inline void tcg_gen_neg_i32(TCGv_i32 ret, TCGv_i32 arg)
1622 {
1623 #ifdef TCG_TARGET_HAS_neg_i32
1624     tcg_gen_op2_i32(INDEX_op_neg_i32, ret, arg);
1625 #else
1626     TCGv_i32 t0 = tcg_const_i32(0);
1627     tcg_gen_sub_i32(ret, t0, arg);
1628     tcg_temp_free_i32(t0);
1629 #endif
1630 }
1631
1632 static inline void tcg_gen_neg_i64(TCGv_i64 ret, TCGv_i64 arg)
1633 {
1634 #ifdef TCG_TARGET_HAS_neg_i64
1635     tcg_gen_op2_i64(INDEX_op_neg_i64, ret, arg);
1636 #else
1637     TCGv_i64 t0 = tcg_const_i64(0);
1638     tcg_gen_sub_i64(ret, t0, arg);
1639     tcg_temp_free_i64(t0);
1640 #endif
1641 }
1642
1643 static inline void tcg_gen_not_i32(TCGv_i32 ret, TCGv_i32 arg)
1644 {
1645 #ifdef TCG_TARGET_HAS_not_i32
1646     tcg_gen_op2_i32(INDEX_op_not_i32, ret, arg);
1647 #else
1648     tcg_gen_xori_i32(ret, arg, -1);
1649 #endif
1650 }
1651
1652 static inline void tcg_gen_not_i64(TCGv_i64 ret, TCGv_i64 arg)
1653 {
1654 #ifdef TCG_TARGET_HAS_not_i64
1655     tcg_gen_op2_i64(INDEX_op_not_i64, ret, arg);
1656 #elif defined(TCG_TARGET_HAS_not_i32) && TCG_TARGET_REG_BITS == 32
1657     tcg_gen_not_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1658     tcg_gen_not_i32(TCGV_HIGH(ret), TCGV_HIGH(arg));
1659 #else
1660     tcg_gen_xori_i64(ret, arg, -1);
1661 #endif
1662 }
1663
1664 static inline void tcg_gen_discard_i32(TCGv_i32 arg)
1665 {
1666     tcg_gen_op1_i32(INDEX_op_discard, arg);
1667 }
1668
1669 #if TCG_TARGET_REG_BITS == 32
1670 static inline void tcg_gen_discard_i64(TCGv_i64 arg)
1671 {
1672     tcg_gen_discard_i32(TCGV_LOW(arg));
1673     tcg_gen_discard_i32(TCGV_HIGH(arg));
1674 }
1675 #else
1676 static inline void tcg_gen_discard_i64(TCGv_i64 arg)
1677 {
1678     tcg_gen_op1_i64(INDEX_op_discard, arg);
1679 }
1680 #endif
1681
1682 static inline void tcg_gen_concat_i32_i64(TCGv_i64 dest, TCGv_i32 low, TCGv_i32 high)
1683 {
1684 #if TCG_TARGET_REG_BITS == 32
1685     tcg_gen_mov_i32(TCGV_LOW(dest), low);
1686     tcg_gen_mov_i32(TCGV_HIGH(dest), high);
1687 #else
1688     TCGv_i64 tmp = tcg_temp_new_i64();
1689     /* This extension is only needed for type correctness.
1690        We may be able to do better given target specific information.  */
1691     tcg_gen_extu_i32_i64(tmp, high);
1692     tcg_gen_shli_i64(tmp, tmp, 32);
1693     tcg_gen_extu_i32_i64(dest, low);
1694     tcg_gen_or_i64(dest, dest, tmp);
1695     tcg_temp_free_i64(tmp);
1696 #endif
1697 }
1698
1699 static inline void tcg_gen_concat32_i64(TCGv_i64 dest, TCGv_i64 low, TCGv_i64 high)
1700 {
1701 #if TCG_TARGET_REG_BITS == 32
1702     tcg_gen_concat_i32_i64(dest, TCGV_LOW(low), TCGV_LOW(high));
1703 #else
1704     TCGv_i64 tmp = tcg_temp_new_i64();
1705     tcg_gen_ext32u_i64(dest, low);
1706     tcg_gen_shli_i64(tmp, high, 32);
1707     tcg_gen_or_i64(dest, dest, tmp);
1708     tcg_temp_free_i64(tmp);
1709 #endif
1710 }
1711
1712 static inline void tcg_gen_andc_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1713 {
1714 #ifdef TCG_TARGET_HAS_andc_i32
1715     tcg_gen_op3_i32(INDEX_op_andc_i32, ret, arg1, arg2);
1716 #else
1717     TCGv_i32 t0;
1718     t0 = tcg_temp_new_i32();
1719     tcg_gen_not_i32(t0, arg2);
1720     tcg_gen_and_i32(ret, arg1, t0);
1721     tcg_temp_free_i32(t0);
1722 #endif
1723 }
1724
1725 static inline void tcg_gen_andc_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1726 {
1727 #ifdef TCG_TARGET_HAS_andc_i64
1728     tcg_gen_op3_i64(INDEX_op_andc_i64, ret, arg1, arg2);
1729 #elif defined(TCG_TARGET_HAS_andc_i32) && TCG_TARGET_REG_BITS == 32
1730     tcg_gen_andc_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
1731     tcg_gen_andc_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
1732 #else
1733     TCGv_i64 t0;
1734     t0 = tcg_temp_new_i64();
1735     tcg_gen_not_i64(t0, arg2);
1736     tcg_gen_and_i64(ret, arg1, t0);
1737     tcg_temp_free_i64(t0);
1738 #endif
1739 }
1740
1741 static inline void tcg_gen_eqv_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1742 {
1743 #ifdef TCG_TARGET_HAS_eqv_i32
1744     tcg_gen_op3_i32(INDEX_op_eqv_i32, ret, arg1, arg2);
1745 #else
1746     tcg_gen_xor_i32(ret, arg1, arg2);
1747     tcg_gen_not_i32(ret, ret);
1748 #endif
1749 }
1750
1751 static inline void tcg_gen_eqv_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1752 {
1753 #ifdef TCG_TARGET_HAS_eqv_i64
1754     tcg_gen_op3_i64(INDEX_op_eqv_i64, ret, arg1, arg2);
1755 #elif defined(TCG_TARGET_HAS_eqv_i32) && TCG_TARGET_REG_BITS == 32
1756     tcg_gen_eqv_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
1757     tcg_gen_eqv_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
1758 #else
1759     tcg_gen_xor_i64(ret, arg1, arg2);
1760     tcg_gen_not_i64(ret, ret);
1761 #endif
1762 }
1763
1764 static inline void tcg_gen_nand_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1765 {
1766 #ifdef TCG_TARGET_HAS_nand_i32
1767     tcg_gen_op3_i32(INDEX_op_nand_i32, ret, arg1, arg2);
1768 #else
1769     tcg_gen_and_i32(ret, arg1, arg2);
1770     tcg_gen_not_i32(ret, ret);
1771 #endif
1772 }
1773
1774 static inline void tcg_gen_nand_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1775 {
1776 #ifdef TCG_TARGET_HAS_nand_i64
1777     tcg_gen_op3_i64(INDEX_op_nand_i64, ret, arg1, arg2);
1778 #elif defined(TCG_TARGET_HAS_nand_i32) && TCG_TARGET_REG_BITS == 32
1779     tcg_gen_nand_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
1780     tcg_gen_nand_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
1781 #else
1782     tcg_gen_and_i64(ret, arg1, arg2);
1783     tcg_gen_not_i64(ret, ret);
1784 #endif
1785 }
1786
1787 static inline void tcg_gen_nor_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1788 {
1789 #ifdef TCG_TARGET_HAS_nor_i32
1790     tcg_gen_op3_i32(INDEX_op_nor_i32, ret, arg1, arg2);
1791 #else
1792     tcg_gen_or_i32(ret, arg1, arg2);
1793     tcg_gen_not_i32(ret, ret);
1794 #endif
1795 }
1796
1797 static inline void tcg_gen_nor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1798 {
1799 #ifdef TCG_TARGET_HAS_nor_i64
1800     tcg_gen_op3_i64(INDEX_op_nor_i64, ret, arg1, arg2);
1801 #elif defined(TCG_TARGET_HAS_nor_i32) && TCG_TARGET_REG_BITS == 32
1802     tcg_gen_nor_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
1803     tcg_gen_nor_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
1804 #else
1805     tcg_gen_or_i64(ret, arg1, arg2);
1806     tcg_gen_not_i64(ret, ret);
1807 #endif
1808 }
1809
1810 static inline void tcg_gen_orc_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1811 {
1812 #ifdef TCG_TARGET_HAS_orc_i32
1813     tcg_gen_op3_i32(INDEX_op_orc_i32, ret, arg1, arg2);
1814 #else
1815     TCGv_i32 t0;
1816     t0 = tcg_temp_new_i32();
1817     tcg_gen_not_i32(t0, arg2);
1818     tcg_gen_or_i32(ret, arg1, t0);
1819     tcg_temp_free_i32(t0);
1820 #endif
1821 }
1822
1823 static inline void tcg_gen_orc_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1824 {
1825 #ifdef TCG_TARGET_HAS_orc_i64
1826     tcg_gen_op3_i64(INDEX_op_orc_i64, ret, arg1, arg2);
1827 #elif defined(TCG_TARGET_HAS_orc_i32) && TCG_TARGET_REG_BITS == 32
1828     tcg_gen_orc_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
1829     tcg_gen_orc_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
1830 #else
1831     TCGv_i64 t0;
1832     t0 = tcg_temp_new_i64();
1833     tcg_gen_not_i64(t0, arg2);
1834     tcg_gen_or_i64(ret, arg1, t0);
1835     tcg_temp_free_i64(t0);
1836 #endif
1837 }
1838
1839 static inline void tcg_gen_rotl_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1840 {
1841 #ifdef TCG_TARGET_HAS_rot_i32
1842     tcg_gen_op3_i32(INDEX_op_rotl_i32, ret, arg1, arg2);
1843 #else
1844     TCGv_i32 t0, t1;
1845
1846     t0 = tcg_temp_new_i32();
1847     t1 = tcg_temp_new_i32();
1848     tcg_gen_shl_i32(t0, arg1, arg2);
1849     tcg_gen_subfi_i32(t1, 32, arg2);
1850     tcg_gen_shr_i32(t1, arg1, t1);
1851     tcg_gen_or_i32(ret, t0, t1);
1852     tcg_temp_free_i32(t0);
1853     tcg_temp_free_i32(t1);
1854 #endif
1855 }
1856
1857 static inline void tcg_gen_rotl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1858 {
1859 #ifdef TCG_TARGET_HAS_rot_i64
1860     tcg_gen_op3_i64(INDEX_op_rotl_i64, ret, arg1, arg2);
1861 #else
1862     TCGv_i64 t0, t1;
1863
1864     t0 = tcg_temp_new_i64();
1865     t1 = tcg_temp_new_i64();
1866     tcg_gen_shl_i64(t0, arg1, arg2);
1867     tcg_gen_subfi_i64(t1, 64, arg2);
1868     tcg_gen_shr_i64(t1, arg1, t1);
1869     tcg_gen_or_i64(ret, t0, t1);
1870     tcg_temp_free_i64(t0);
1871     tcg_temp_free_i64(t1);
1872 #endif
1873 }
1874
1875 static inline void tcg_gen_rotli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
1876 {
1877     /* some cases can be optimized here */
1878     if (arg2 == 0) {
1879         tcg_gen_mov_i32(ret, arg1);
1880     } else {
1881 #ifdef TCG_TARGET_HAS_rot_i32
1882         TCGv_i32 t0 = tcg_const_i32(arg2);
1883         tcg_gen_rotl_i32(ret, arg1, t0);
1884         tcg_temp_free_i32(t0);
1885 #else
1886         TCGv_i32 t0, t1;
1887         t0 = tcg_temp_new_i32();
1888         t1 = tcg_temp_new_i32();
1889         tcg_gen_shli_i32(t0, arg1, arg2);
1890         tcg_gen_shri_i32(t1, arg1, 32 - arg2);
1891         tcg_gen_or_i32(ret, t0, t1);
1892         tcg_temp_free_i32(t0);
1893         tcg_temp_free_i32(t1);
1894 #endif
1895     }
1896 }
1897
1898 static inline void tcg_gen_rotli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1899 {
1900     /* some cases can be optimized here */
1901     if (arg2 == 0) {
1902         tcg_gen_mov_i64(ret, arg1);
1903     } else {
1904 #ifdef TCG_TARGET_HAS_rot_i64
1905         TCGv_i64 t0 = tcg_const_i64(arg2);
1906         tcg_gen_rotl_i64(ret, arg1, t0);
1907         tcg_temp_free_i64(t0);
1908 #else
1909         TCGv_i64 t0, t1;
1910         t0 = tcg_temp_new_i64();
1911         t1 = tcg_temp_new_i64();
1912         tcg_gen_shli_i64(t0, arg1, arg2);
1913         tcg_gen_shri_i64(t1, arg1, 64 - arg2);
1914         tcg_gen_or_i64(ret, t0, t1);
1915         tcg_temp_free_i64(t0);
1916         tcg_temp_free_i64(t1);
1917 #endif
1918     }
1919 }
1920
1921 static inline void tcg_gen_rotr_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1922 {
1923 #ifdef TCG_TARGET_HAS_rot_i32
1924     tcg_gen_op3_i32(INDEX_op_rotr_i32, ret, arg1, arg2);
1925 #else
1926     TCGv_i32 t0, t1;
1927
1928     t0 = tcg_temp_new_i32();
1929     t1 = tcg_temp_new_i32();
1930     tcg_gen_shr_i32(t0, arg1, arg2);
1931     tcg_gen_subfi_i32(t1, 32, arg2);
1932     tcg_gen_shl_i32(t1, arg1, t1);
1933     tcg_gen_or_i32(ret, t0, t1);
1934     tcg_temp_free_i32(t0);
1935     tcg_temp_free_i32(t1);
1936 #endif
1937 }
1938
1939 static inline void tcg_gen_rotr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1940 {
1941 #ifdef TCG_TARGET_HAS_rot_i64
1942     tcg_gen_op3_i64(INDEX_op_rotr_i64, ret, arg1, arg2);
1943 #else
1944     TCGv_i64 t0, t1;
1945
1946     t0 = tcg_temp_new_i64();
1947     t1 = tcg_temp_new_i64();
1948     tcg_gen_shr_i64(t0, arg1, arg2);
1949     tcg_gen_subfi_i64(t1, 64, arg2);
1950     tcg_gen_shl_i64(t1, arg1, t1);
1951     tcg_gen_or_i64(ret, t0, t1);
1952     tcg_temp_free_i64(t0);
1953     tcg_temp_free_i64(t1);
1954 #endif
1955 }
1956
1957 static inline void tcg_gen_rotri_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
1958 {
1959     /* some cases can be optimized here */
1960     if (arg2 == 0) {
1961         tcg_gen_mov_i32(ret, arg1);
1962     } else {
1963         tcg_gen_rotli_i32(ret, arg1, 32 - arg2);
1964     }
1965 }
1966
1967 static inline void tcg_gen_rotri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1968 {
1969     /* some cases can be optimized here */
1970     if (arg2 == 0) {
1971         tcg_gen_mov_i64(ret, arg1);
1972     } else {
1973         tcg_gen_rotli_i64(ret, arg1, 64 - arg2);
1974     }
1975 }
1976
1977 /***************************************/
1978 /* QEMU specific operations. Their type depend on the QEMU CPU
1979    type. */
1980 #ifndef TARGET_LONG_BITS
1981 #error must include QEMU headers
1982 #endif
1983
1984 #if TARGET_LONG_BITS == 32
1985 #define TCGv TCGv_i32
1986 #define tcg_temp_new() tcg_temp_new_i32()
1987 #define tcg_global_reg_new tcg_global_reg_new_i32
1988 #define tcg_global_mem_new tcg_global_mem_new_i32
1989 #define tcg_temp_local_new() tcg_temp_local_new_i32()
1990 #define tcg_temp_free tcg_temp_free_i32
1991 #define tcg_gen_qemu_ldst_op tcg_gen_op3i_i32
1992 #define tcg_gen_qemu_ldst_op_i64 tcg_gen_qemu_ldst_op_i64_i32
1993 #define TCGV_UNUSED(x) TCGV_UNUSED_I32(x)
1994 #define TCGV_EQUAL(a, b) TCGV_EQUAL_I32(a, b)
1995 #else
1996 #define TCGv TCGv_i64
1997 #define tcg_temp_new() tcg_temp_new_i64()
1998 #define tcg_global_reg_new tcg_global_reg_new_i64
1999 #define tcg_global_mem_new tcg_global_mem_new_i64
2000 #define tcg_temp_local_new() tcg_temp_local_new_i64()
2001 #define tcg_temp_free tcg_temp_free_i64
2002 #define tcg_gen_qemu_ldst_op tcg_gen_op3i_i64
2003 #define tcg_gen_qemu_ldst_op_i64 tcg_gen_qemu_ldst_op_i64_i64
2004 #define TCGV_UNUSED(x) TCGV_UNUSED_I64(x)
2005 #define TCGV_EQUAL(a, b) TCGV_EQUAL_I64(a, b)
2006 #endif
2007
2008 /* debug info: write the PC of the corresponding QEMU CPU instruction */
2009 static inline void tcg_gen_debug_insn_start(uint64_t pc)
2010 {
2011     /* XXX: must really use a 32 bit size for TCGArg in all cases */
2012 #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
2013     tcg_gen_op2ii(INDEX_op_debug_insn_start,
2014                   (uint32_t)(pc), (uint32_t)(pc >> 32));
2015 #else
2016     tcg_gen_op1i(INDEX_op_debug_insn_start, pc);
2017 #endif
2018 }
2019
2020 static inline void tcg_gen_exit_tb(tcg_target_long val)
2021 {
2022     tcg_gen_op1i(INDEX_op_exit_tb, val);
2023 }
2024
2025 static inline void tcg_gen_goto_tb(int idx)
2026 {
2027     tcg_gen_op1i(INDEX_op_goto_tb, idx);
2028 }
2029
2030 #if TCG_TARGET_REG_BITS == 32
2031 static inline void tcg_gen_qemu_ld8u(TCGv ret, TCGv addr, int mem_index)
2032 {
2033 #if TARGET_LONG_BITS == 32
2034     tcg_gen_op3i_i32(INDEX_op_qemu_ld8u, ret, addr, mem_index);
2035 #else
2036     tcg_gen_op4i_i32(INDEX_op_qemu_ld8u, TCGV_LOW(ret), TCGV_LOW(addr),
2037                      TCGV_HIGH(addr), mem_index);
2038     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
2039 #endif
2040 }
2041
2042 static inline void tcg_gen_qemu_ld8s(TCGv ret, TCGv addr, int mem_index)
2043 {
2044 #if TARGET_LONG_BITS == 32
2045     tcg_gen_op3i_i32(INDEX_op_qemu_ld8s, ret, addr, mem_index);
2046 #else
2047     tcg_gen_op4i_i32(INDEX_op_qemu_ld8s, TCGV_LOW(ret), TCGV_LOW(addr),
2048                      TCGV_HIGH(addr), mem_index);
2049     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
2050 #endif
2051 }
2052
2053 static inline void tcg_gen_qemu_ld16u(TCGv ret, TCGv addr, int mem_index)
2054 {
2055 #if TARGET_LONG_BITS == 32
2056     tcg_gen_op3i_i32(INDEX_op_qemu_ld16u, ret, addr, mem_index);
2057 #else
2058     tcg_gen_op4i_i32(INDEX_op_qemu_ld16u, TCGV_LOW(ret), TCGV_LOW(addr),
2059                      TCGV_HIGH(addr), mem_index);
2060     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
2061 #endif
2062 }
2063
2064 static inline void tcg_gen_qemu_ld16s(TCGv ret, TCGv addr, int mem_index)
2065 {
2066 #if TARGET_LONG_BITS == 32
2067     tcg_gen_op3i_i32(INDEX_op_qemu_ld16s, ret, addr, mem_index);
2068 #else
2069     tcg_gen_op4i_i32(INDEX_op_qemu_ld16s, TCGV_LOW(ret), TCGV_LOW(addr),
2070                      TCGV_HIGH(addr), mem_index);
2071     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
2072 #endif
2073 }
2074
2075 static inline void tcg_gen_qemu_ld32u(TCGv ret, TCGv addr, int mem_index)
2076 {
2077 #if TARGET_LONG_BITS == 32
2078     tcg_gen_op3i_i32(INDEX_op_qemu_ld32, ret, addr, mem_index);
2079 #else
2080     tcg_gen_op4i_i32(INDEX_op_qemu_ld32, TCGV_LOW(ret), TCGV_LOW(addr),
2081                      TCGV_HIGH(addr), mem_index);
2082     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
2083 #endif
2084 }
2085
2086 static inline void tcg_gen_qemu_ld32s(TCGv ret, TCGv addr, int mem_index)
2087 {
2088 #if TARGET_LONG_BITS == 32
2089     tcg_gen_op3i_i32(INDEX_op_qemu_ld32, ret, addr, mem_index);
2090 #else
2091     tcg_gen_op4i_i32(INDEX_op_qemu_ld32, TCGV_LOW(ret), TCGV_LOW(addr),
2092                      TCGV_HIGH(addr), mem_index);
2093     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
2094 #endif
2095 }
2096
2097 static inline void tcg_gen_qemu_ld64(TCGv_i64 ret, TCGv addr, int mem_index)
2098 {
2099 #if TARGET_LONG_BITS == 32
2100     tcg_gen_op4i_i32(INDEX_op_qemu_ld64, TCGV_LOW(ret), TCGV_HIGH(ret), addr, mem_index);
2101 #else
2102     tcg_gen_op5i_i32(INDEX_op_qemu_ld64, TCGV_LOW(ret), TCGV_HIGH(ret),
2103                      TCGV_LOW(addr), TCGV_HIGH(addr), mem_index);
2104 #endif
2105 }
2106
2107 static inline void tcg_gen_qemu_st8(TCGv arg, TCGv addr, int mem_index)
2108 {
2109 #if TARGET_LONG_BITS == 32
2110     tcg_gen_op3i_i32(INDEX_op_qemu_st8, arg, addr, mem_index);
2111 #else
2112     tcg_gen_op4i_i32(INDEX_op_qemu_st8, TCGV_LOW(arg), TCGV_LOW(addr),
2113                      TCGV_HIGH(addr), mem_index);
2114 #endif
2115 }
2116
2117 static inline void tcg_gen_qemu_st16(TCGv arg, TCGv addr, int mem_index)
2118 {
2119 #if TARGET_LONG_BITS == 32
2120     tcg_gen_op3i_i32(INDEX_op_qemu_st16, arg, addr, mem_index);
2121 #else
2122     tcg_gen_op4i_i32(INDEX_op_qemu_st16, TCGV_LOW(arg), TCGV_LOW(addr),
2123                      TCGV_HIGH(addr), mem_index);
2124 #endif
2125 }
2126
2127 static inline void tcg_gen_qemu_st32(TCGv arg, TCGv addr, int mem_index)
2128 {
2129 #if TARGET_LONG_BITS == 32
2130     tcg_gen_op3i_i32(INDEX_op_qemu_st32, arg, addr, mem_index);
2131 #else
2132     tcg_gen_op4i_i32(INDEX_op_qemu_st32, TCGV_LOW(arg), TCGV_LOW(addr),
2133                      TCGV_HIGH(addr), mem_index);
2134 #endif
2135 }
2136
2137 static inline void tcg_gen_qemu_st64(TCGv_i64 arg, TCGv addr, int mem_index)
2138 {
2139 #if TARGET_LONG_BITS == 32
2140     tcg_gen_op4i_i32(INDEX_op_qemu_st64, TCGV_LOW(arg), TCGV_HIGH(arg), addr,
2141                      mem_index);
2142 #else
2143     tcg_gen_op5i_i32(INDEX_op_qemu_st64, TCGV_LOW(arg), TCGV_HIGH(arg),
2144                      TCGV_LOW(addr), TCGV_HIGH(addr), mem_index);
2145 #endif
2146 }
2147
2148 #define tcg_gen_ld_ptr tcg_gen_ld_i32
2149 #define tcg_gen_discard_ptr tcg_gen_discard_i32
2150
2151 #else /* TCG_TARGET_REG_BITS == 32 */
2152
2153 static inline void tcg_gen_qemu_ld8u(TCGv ret, TCGv addr, int mem_index)
2154 {
2155     tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld8u, ret, addr, mem_index);
2156 }
2157
2158 static inline void tcg_gen_qemu_ld8s(TCGv ret, TCGv addr, int mem_index)
2159 {
2160     tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld8s, ret, addr, mem_index);
2161 }
2162
2163 static inline void tcg_gen_qemu_ld16u(TCGv ret, TCGv addr, int mem_index)
2164 {
2165     tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld16u, ret, addr, mem_index);
2166 }
2167
2168 static inline void tcg_gen_qemu_ld16s(TCGv ret, TCGv addr, int mem_index)
2169 {
2170     tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld16s, ret, addr, mem_index);
2171 }
2172
2173 static inline void tcg_gen_qemu_ld32u(TCGv ret, TCGv addr, int mem_index)
2174 {
2175 #if TARGET_LONG_BITS == 32
2176     tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld32, ret, addr, mem_index);
2177 #else
2178     tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld32u, ret, addr, mem_index);
2179 #endif
2180 }
2181
2182 static inline void tcg_gen_qemu_ld32s(TCGv ret, TCGv addr, int mem_index)
2183 {
2184 #if TARGET_LONG_BITS == 32
2185     tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld32, ret, addr, mem_index);
2186 #else
2187     tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld32s, ret, addr, mem_index);
2188 #endif
2189 }
2190
2191 static inline void tcg_gen_qemu_ld64(TCGv_i64 ret, TCGv addr, int mem_index)
2192 {
2193     tcg_gen_qemu_ldst_op_i64(INDEX_op_qemu_ld64, ret, addr, mem_index);
2194 }
2195
2196 static inline void tcg_gen_qemu_st8(TCGv arg, TCGv addr, int mem_index)
2197 {
2198     tcg_gen_qemu_ldst_op(INDEX_op_qemu_st8, arg, addr, mem_index);
2199 }
2200
2201 static inline void tcg_gen_qemu_st16(TCGv arg, TCGv addr, int mem_index)
2202 {
2203     tcg_gen_qemu_ldst_op(INDEX_op_qemu_st16, arg, addr, mem_index);
2204 }
2205
2206 static inline void tcg_gen_qemu_st32(TCGv arg, TCGv addr, int mem_index)
2207 {
2208     tcg_gen_qemu_ldst_op(INDEX_op_qemu_st32, arg, addr, mem_index);
2209 }
2210
2211 static inline void tcg_gen_qemu_st64(TCGv_i64 arg, TCGv addr, int mem_index)
2212 {
2213     tcg_gen_qemu_ldst_op_i64(INDEX_op_qemu_st64, arg, addr, mem_index);
2214 }
2215
2216 #define tcg_gen_ld_ptr tcg_gen_ld_i64
2217 #define tcg_gen_discard_ptr tcg_gen_discard_i64
2218
2219 #endif /* TCG_TARGET_REG_BITS != 32 */
2220
2221 #if TARGET_LONG_BITS == 64
2222 #define tcg_gen_movi_tl tcg_gen_movi_i64
2223 #define tcg_gen_mov_tl tcg_gen_mov_i64
2224 #define tcg_gen_ld8u_tl tcg_gen_ld8u_i64
2225 #define tcg_gen_ld8s_tl tcg_gen_ld8s_i64
2226 #define tcg_gen_ld16u_tl tcg_gen_ld16u_i64
2227 #define tcg_gen_ld16s_tl tcg_gen_ld16s_i64
2228 #define tcg_gen_ld32u_tl tcg_gen_ld32u_i64
2229 #define tcg_gen_ld32s_tl tcg_gen_ld32s_i64
2230 #define tcg_gen_ld_tl tcg_gen_ld_i64
2231 #define tcg_gen_st8_tl tcg_gen_st8_i64
2232 #define tcg_gen_st16_tl tcg_gen_st16_i64
2233 #define tcg_gen_st32_tl tcg_gen_st32_i64
2234 #define tcg_gen_st_tl tcg_gen_st_i64
2235 #define tcg_gen_add_tl tcg_gen_add_i64
2236 #define tcg_gen_addi_tl tcg_gen_addi_i64
2237 #define tcg_gen_sub_tl tcg_gen_sub_i64
2238 #define tcg_gen_neg_tl tcg_gen_neg_i64
2239 #define tcg_gen_subfi_tl tcg_gen_subfi_i64
2240 #define tcg_gen_subi_tl tcg_gen_subi_i64
2241 #define tcg_gen_and_tl tcg_gen_and_i64
2242 #define tcg_gen_andi_tl tcg_gen_andi_i64
2243 #define tcg_gen_or_tl tcg_gen_or_i64
2244 #define tcg_gen_ori_tl tcg_gen_ori_i64
2245 #define tcg_gen_xor_tl tcg_gen_xor_i64
2246 #define tcg_gen_xori_tl tcg_gen_xori_i64
2247 #define tcg_gen_not_tl tcg_gen_not_i64
2248 #define tcg_gen_shl_tl tcg_gen_shl_i64
2249 #define tcg_gen_shli_tl tcg_gen_shli_i64
2250 #define tcg_gen_shr_tl tcg_gen_shr_i64
2251 #define tcg_gen_shri_tl tcg_gen_shri_i64
2252 #define tcg_gen_sar_tl tcg_gen_sar_i64
2253 #define tcg_gen_sari_tl tcg_gen_sari_i64
2254 #define tcg_gen_brcond_tl tcg_gen_brcond_i64
2255 #define tcg_gen_brcondi_tl tcg_gen_brcondi_i64
2256 #define tcg_gen_setcond_tl tcg_gen_setcond_i64
2257 #define tcg_gen_setcondi_tl tcg_gen_setcondi_i64
2258 #define tcg_gen_mul_tl tcg_gen_mul_i64
2259 #define tcg_gen_muli_tl tcg_gen_muli_i64
2260 #define tcg_gen_div_tl tcg_gen_div_i64
2261 #define tcg_gen_rem_tl tcg_gen_rem_i64
2262 #define tcg_gen_divu_tl tcg_gen_divu_i64
2263 #define tcg_gen_remu_tl tcg_gen_remu_i64
2264 #define tcg_gen_discard_tl tcg_gen_discard_i64
2265 #define tcg_gen_trunc_tl_i32 tcg_gen_trunc_i64_i32
2266 #define tcg_gen_trunc_i64_tl tcg_gen_mov_i64
2267 #define tcg_gen_extu_i32_tl tcg_gen_extu_i32_i64
2268 #define tcg_gen_ext_i32_tl tcg_gen_ext_i32_i64
2269 #define tcg_gen_extu_tl_i64 tcg_gen_mov_i64
2270 #define tcg_gen_ext_tl_i64 tcg_gen_mov_i64
2271 #define tcg_gen_ext8u_tl tcg_gen_ext8u_i64
2272 #define tcg_gen_ext8s_tl tcg_gen_ext8s_i64
2273 #define tcg_gen_ext16u_tl tcg_gen_ext16u_i64
2274 #define tcg_gen_ext16s_tl tcg_gen_ext16s_i64
2275 #define tcg_gen_ext32u_tl tcg_gen_ext32u_i64
2276 #define tcg_gen_ext32s_tl tcg_gen_ext32s_i64
2277 #define tcg_gen_bswap16_tl tcg_gen_bswap16_i64
2278 #define tcg_gen_bswap32_tl tcg_gen_bswap32_i64
2279 #define tcg_gen_bswap64_tl tcg_gen_bswap64_i64
2280 #define tcg_gen_concat_tl_i64 tcg_gen_concat32_i64
2281 #define tcg_gen_andc_tl tcg_gen_andc_i64
2282 #define tcg_gen_eqv_tl tcg_gen_eqv_i64
2283 #define tcg_gen_nand_tl tcg_gen_nand_i64
2284 #define tcg_gen_nor_tl tcg_gen_nor_i64
2285 #define tcg_gen_orc_tl tcg_gen_orc_i64
2286 #define tcg_gen_rotl_tl tcg_gen_rotl_i64
2287 #define tcg_gen_rotli_tl tcg_gen_rotli_i64
2288 #define tcg_gen_rotr_tl tcg_gen_rotr_i64
2289 #define tcg_gen_rotri_tl tcg_gen_rotri_i64
2290 #define tcg_const_tl tcg_const_i64
2291 #define tcg_const_local_tl tcg_const_local_i64
2292 #else
2293 #define tcg_gen_movi_tl tcg_gen_movi_i32
2294 #define tcg_gen_mov_tl tcg_gen_mov_i32
2295 #define tcg_gen_ld8u_tl tcg_gen_ld8u_i32
2296 #define tcg_gen_ld8s_tl tcg_gen_ld8s_i32
2297 #define tcg_gen_ld16u_tl tcg_gen_ld16u_i32
2298 #define tcg_gen_ld16s_tl tcg_gen_ld16s_i32
2299 #define tcg_gen_ld32u_tl tcg_gen_ld_i32
2300 #define tcg_gen_ld32s_tl tcg_gen_ld_i32
2301 #define tcg_gen_ld_tl tcg_gen_ld_i32
2302 #define tcg_gen_st8_tl tcg_gen_st8_i32
2303 #define tcg_gen_st16_tl tcg_gen_st16_i32
2304 #define tcg_gen_st32_tl tcg_gen_st_i32
2305 #define tcg_gen_st_tl tcg_gen_st_i32
2306 #define tcg_gen_add_tl tcg_gen_add_i32
2307 #define tcg_gen_addi_tl tcg_gen_addi_i32
2308 #define tcg_gen_sub_tl tcg_gen_sub_i32
2309 #define tcg_gen_neg_tl tcg_gen_neg_i32
2310 #define tcg_gen_subfi_tl tcg_gen_subfi_i32
2311 #define tcg_gen_subi_tl tcg_gen_subi_i32
2312 #define tcg_gen_and_tl tcg_gen_and_i32
2313 #define tcg_gen_andi_tl tcg_gen_andi_i32
2314 #define tcg_gen_or_tl tcg_gen_or_i32
2315 #define tcg_gen_ori_tl tcg_gen_ori_i32
2316 #define tcg_gen_xor_tl tcg_gen_xor_i32
2317 #define tcg_gen_xori_tl tcg_gen_xori_i32
2318 #define tcg_gen_not_tl tcg_gen_not_i32
2319 #define tcg_gen_shl_tl tcg_gen_shl_i32
2320 #define tcg_gen_shli_tl tcg_gen_shli_i32
2321 #define tcg_gen_shr_tl tcg_gen_shr_i32
2322 #define tcg_gen_shri_tl tcg_gen_shri_i32
2323 #define tcg_gen_sar_tl tcg_gen_sar_i32
2324 #define tcg_gen_sari_tl tcg_gen_sari_i32
2325 #define tcg_gen_brcond_tl tcg_gen_brcond_i32
2326 #define tcg_gen_brcondi_tl tcg_gen_brcondi_i32
2327 #define tcg_gen_setcond_tl tcg_gen_setcond_i32
2328 #define tcg_gen_setcondi_tl tcg_gen_setcondi_i32
2329 #define tcg_gen_mul_tl tcg_gen_mul_i32
2330 #define tcg_gen_muli_tl tcg_gen_muli_i32
2331 #define tcg_gen_div_tl tcg_gen_div_i32
2332 #define tcg_gen_rem_tl tcg_gen_rem_i32
2333 #define tcg_gen_divu_tl tcg_gen_divu_i32
2334 #define tcg_gen_remu_tl tcg_gen_remu_i32
2335 #define tcg_gen_discard_tl tcg_gen_discard_i32
2336 #define tcg_gen_trunc_tl_i32 tcg_gen_mov_i32
2337 #define tcg_gen_trunc_i64_tl tcg_gen_trunc_i64_i32
2338 #define tcg_gen_extu_i32_tl tcg_gen_mov_i32
2339 #define tcg_gen_ext_i32_tl tcg_gen_mov_i32
2340 #define tcg_gen_extu_tl_i64 tcg_gen_extu_i32_i64
2341 #define tcg_gen_ext_tl_i64 tcg_gen_ext_i32_i64
2342 #define tcg_gen_ext8u_tl tcg_gen_ext8u_i32
2343 #define tcg_gen_ext8s_tl tcg_gen_ext8s_i32
2344 #define tcg_gen_ext16u_tl tcg_gen_ext16u_i32
2345 #define tcg_gen_ext16s_tl tcg_gen_ext16s_i32
2346 #define tcg_gen_ext32u_tl tcg_gen_mov_i32
2347 #define tcg_gen_ext32s_tl tcg_gen_mov_i32
2348 #define tcg_gen_bswap16_tl tcg_gen_bswap16_i32
2349 #define tcg_gen_bswap32_tl tcg_gen_bswap32_i32
2350 #define tcg_gen_concat_tl_i64 tcg_gen_concat_i32_i64
2351 #define tcg_gen_andc_tl tcg_gen_andc_i32
2352 #define tcg_gen_eqv_tl tcg_gen_eqv_i32
2353 #define tcg_gen_nand_tl tcg_gen_nand_i32
2354 #define tcg_gen_nor_tl tcg_gen_nor_i32
2355 #define tcg_gen_orc_tl tcg_gen_orc_i32
2356 #define tcg_gen_rotl_tl tcg_gen_rotl_i32
2357 #define tcg_gen_rotli_tl tcg_gen_rotli_i32
2358 #define tcg_gen_rotr_tl tcg_gen_rotr_i32
2359 #define tcg_gen_rotri_tl tcg_gen_rotri_i32
2360 #define tcg_const_tl tcg_const_i32
2361 #define tcg_const_local_tl tcg_const_local_i32
2362 #endif
2363
2364 #if TCG_TARGET_REG_BITS == 32
2365 #define tcg_gen_add_ptr tcg_gen_add_i32
2366 #define tcg_gen_addi_ptr tcg_gen_addi_i32
2367 #define tcg_gen_ext_i32_ptr tcg_gen_mov_i32
2368 #else /* TCG_TARGET_REG_BITS == 32 */
2369 #define tcg_gen_add_ptr tcg_gen_add_i64
2370 #define tcg_gen_addi_ptr tcg_gen_addi_i64
2371 #define tcg_gen_ext_i32_ptr tcg_gen_ext_i32_i64
2372 #endif /* TCG_TARGET_REG_BITS != 32 */