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(int 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(int 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(int opc, TCGArg arg1)
  41 {
  42     *gen_opc_ptr++ = opc;
  43     *gen_opparam_ptr++ = arg1;
  44 }
  45
  46 static inline void tcg_gen_op2_i32(int 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(int 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(int 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(int 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(int 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(int 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(int 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(int opc, TCGv_i32 arg1, TCGv_i32 arg2,
 100                                     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(int opc, TCGv_i64 arg1, TCGv_i64 arg2,
 109                                     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(int opc, TCGv_i32 val, TCGv_ptr base,
 118                                        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(int opc, TCGv_i64 val, TCGv_ptr base,
 127                                        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(int opc, TCGv_i64 val, TCGv_i32 addr,
 136                                                 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(int opc, TCGv_i64 val, TCGv_i64 addr,
 145                                                 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(int 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(int 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(int 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(int 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(int 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(int 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(int 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(int 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(int 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(int 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(int 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(int 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_op6ii_i32(int opc, TCGv_i32 arg1, TCGv_i32 arg2,
 284                                      TCGv_i32 arg3, TCGv_i32 arg4, TCGArg arg5,
 285                                      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++ = arg5;
 293     *gen_opparam_ptr++ = arg6;
 294 }
 295
 296 static inline void tcg_gen_op6ii_i64(int opc, TCGv_i64 arg1, TCGv_i64 arg2,
 297                                      TCGv_i64 arg3, TCGv_i64 arg4, TCGArg arg5,
 298                                      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++ = arg5;
 306     *gen_opparam_ptr++ = arg6;
 307 }
 308
 309 static inline void gen_set_label(int n)
 310 {
 311     tcg_gen_op1i(INDEX_op_set_label, n);
 312 }
 313
 314 static inline void tcg_gen_br(int label)
 315 {
 316     tcg_gen_op1i(INDEX_op_br, label);
 317 }
 318
 319 static inline void tcg_gen_mov_i32(TCGv_i32 ret, TCGv_i32 arg)
 320 {
 321     if (GET_TCGV_I32(ret) != GET_TCGV_I32(arg))
 322         tcg_gen_op2_i32(INDEX_op_mov_i32, ret, arg);
 323 }
 324
 325 static inline void tcg_gen_movi_i32(TCGv_i32 ret, int32_t arg)
 326 {
 327     tcg_gen_op2i_i32(INDEX_op_movi_i32, ret, arg);
 328 }
 329
 330 /* helper calls */
 331 static inline void tcg_gen_helperN(void *func, int flags, int sizemask,
 332                                    TCGArg ret, int nargs, TCGArg *args)
 333 {
 334     TCGv_ptr fn;
 335     fn = tcg_const_ptr((tcg_target_long)func);
 336     tcg_gen_callN(&tcg_ctx, fn, flags, sizemask, ret,
 337                   nargs, args);
 338     tcg_temp_free_ptr(fn);
 339 }
 340
 341 /* FIXME: Should this be pure?  */
 342 static inline void tcg_gen_helper64(void *func, TCGv_i64 ret,
 343                                     TCGv_i64 a, TCGv_i64 b)
 344 {
 345     TCGv_ptr fn;
 346     TCGArg args[2];
 347     fn = tcg_const_ptr((tcg_target_long)func);
 348     args[0] = GET_TCGV_I64(a);
 349     args[1] = GET_TCGV_I64(b);
 350     tcg_gen_callN(&tcg_ctx, fn, 0, 7, GET_TCGV_I64(ret), 2, args);
 351     tcg_temp_free_ptr(fn);
 352 }
 353
 354 /* 32 bit ops */
 355
 356 static inline void tcg_gen_ld8u_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 357 {
 358     tcg_gen_ldst_op_i32(INDEX_op_ld8u_i32, ret, arg2, offset);
 359 }
 360
 361 static inline void tcg_gen_ld8s_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 362 {
 363     tcg_gen_ldst_op_i32(INDEX_op_ld8s_i32, ret, arg2, offset);
 364 }
 365
 366 static inline void tcg_gen_ld16u_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 367 {
 368     tcg_gen_ldst_op_i32(INDEX_op_ld16u_i32, ret, arg2, offset);
 369 }
 370
 371 static inline void tcg_gen_ld16s_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 372 {
 373     tcg_gen_ldst_op_i32(INDEX_op_ld16s_i32, ret, arg2, offset);
 374 }
 375
 376 static inline void tcg_gen_ld_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 377 {
 378     tcg_gen_ldst_op_i32(INDEX_op_ld_i32, ret, arg2, offset);
 379 }
 380
 381 static inline void tcg_gen_st8_i32(TCGv_i32 arg1, TCGv_ptr arg2, tcg_target_long offset)
 382 {
 383     tcg_gen_ldst_op_i32(INDEX_op_st8_i32, arg1, arg2, offset);
 384 }
 385
 386 static inline void tcg_gen_st16_i32(TCGv_i32 arg1, TCGv_ptr arg2, tcg_target_long offset)
 387 {
 388     tcg_gen_ldst_op_i32(INDEX_op_st16_i32, arg1, arg2, offset);
 389 }
 390
 391 static inline void tcg_gen_st_i32(TCGv_i32 arg1, TCGv_ptr arg2, tcg_target_long offset)
 392 {
 393     tcg_gen_ldst_op_i32(INDEX_op_st_i32, arg1, arg2, offset);
 394 }
 395
 396 static inline void tcg_gen_add_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 397 {
 398     tcg_gen_op3_i32(INDEX_op_add_i32, ret, arg1, arg2);
 399 }
 400
 401 static inline void tcg_gen_addi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 402 {
 403     /* some cases can be optimized here */
 404     if (arg2 == 0) {
 405         tcg_gen_mov_i32(ret, arg1);
 406     } else {
 407         TCGv_i32 t0 = tcg_const_i32(arg2);
 408         tcg_gen_add_i32(ret, arg1, t0);
 409         tcg_temp_free_i32(t0);
 410     }
 411 }
 412
 413 static inline void tcg_gen_sub_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 414 {
 415     tcg_gen_op3_i32(INDEX_op_sub_i32, ret, arg1, arg2);
 416 }
 417
 418 static inline void tcg_gen_subfi_i32(TCGv_i32 ret, int32_t arg1, TCGv_i32 arg2)
 419 {
 420     TCGv_i32 t0 = tcg_const_i32(arg1);
 421     tcg_gen_sub_i32(ret, t0, arg2);
 422     tcg_temp_free_i32(t0);
 423 }
 424
 425 static inline void tcg_gen_subi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 426 {
 427     /* some cases can be optimized here */
 428     if (arg2 == 0) {
 429         tcg_gen_mov_i32(ret, arg1);
 430     } else {
 431         TCGv_i32 t0 = tcg_const_i32(arg2);
 432         tcg_gen_sub_i32(ret, arg1, t0);
 433         tcg_temp_free_i32(t0);
 434     }
 435 }
 436
 437 static inline void tcg_gen_and_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 438 {
 439     tcg_gen_op3_i32(INDEX_op_and_i32, ret, arg1, arg2);
 440 }
 441
 442 static inline void tcg_gen_andi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 443 {
 444     /* some cases can be optimized here */
 445     if (arg2 == 0) {
 446         tcg_gen_movi_i32(ret, 0);
 447     } else if (arg2 == 0xffffffff) {
 448         tcg_gen_mov_i32(ret, arg1);
 449     } else {
 450         TCGv_i32 t0 = tcg_const_i32(arg2);
 451         tcg_gen_and_i32(ret, arg1, t0);
 452         tcg_temp_free_i32(t0);
 453     }
 454 }
 455
 456 static inline void tcg_gen_or_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 457 {
 458     tcg_gen_op3_i32(INDEX_op_or_i32, ret, arg1, arg2);
 459 }
 460
 461 static inline void tcg_gen_ori_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 462 {
 463     /* some cases can be optimized here */
 464     if (arg2 == 0xffffffff) {
 465         tcg_gen_movi_i32(ret, 0xffffffff);
 466     } else if (arg2 == 0) {
 467         tcg_gen_mov_i32(ret, arg1);
 468     } else {
 469         TCGv_i32 t0 = tcg_const_i32(arg2);
 470         tcg_gen_or_i32(ret, arg1, t0);
 471         tcg_temp_free_i32(t0);
 472     }
 473 }
 474
 475 static inline void tcg_gen_xor_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 476 {
 477     tcg_gen_op3_i32(INDEX_op_xor_i32, ret, arg1, arg2);
 478 }
 479
 480 static inline void tcg_gen_xori_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_xor_i32(ret, arg1, t0);
 488         tcg_temp_free_i32(t0);
 489     }
 490 }
 491
 492 static inline void tcg_gen_shl_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 493 {
 494     tcg_gen_op3_i32(INDEX_op_shl_i32, ret, arg1, arg2);
 495 }
 496
 497 static inline void tcg_gen_shli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 498 {
 499     if (arg2 == 0) {
 500         tcg_gen_mov_i32(ret, arg1);
 501     } else {
 502         TCGv_i32 t0 = tcg_const_i32(arg2);
 503         tcg_gen_shl_i32(ret, arg1, t0);
 504         tcg_temp_free_i32(t0);
 505     }
 506 }
 507
 508 static inline void tcg_gen_shr_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 509 {
 510     tcg_gen_op3_i32(INDEX_op_shr_i32, ret, arg1, arg2);
 511 }
 512
 513 static inline void tcg_gen_shri_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 514 {
 515     if (arg2 == 0) {
 516         tcg_gen_mov_i32(ret, arg1);
 517     } else {
 518         TCGv_i32 t0 = tcg_const_i32(arg2);
 519         tcg_gen_shr_i32(ret, arg1, t0);
 520         tcg_temp_free_i32(t0);
 521     }
 522 }
 523
 524 static inline void tcg_gen_sar_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 525 {
 526     tcg_gen_op3_i32(INDEX_op_sar_i32, ret, arg1, arg2);
 527 }
 528
 529 static inline void tcg_gen_sari_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 530 {
 531     if (arg2 == 0) {
 532         tcg_gen_mov_i32(ret, arg1);
 533     } else {
 534         TCGv_i32 t0 = tcg_const_i32(arg2);
 535         tcg_gen_sar_i32(ret, arg1, t0);
 536         tcg_temp_free_i32(t0);
 537     }
 538 }
 539
 540 static inline void tcg_gen_brcond_i32(int cond, TCGv_i32 arg1, TCGv_i32 arg2,
 541                                       int label_index)
 542 {
 543     tcg_gen_op4ii_i32(INDEX_op_brcond_i32, arg1, arg2, cond, label_index);
 544 }
 545
 546 static inline void tcg_gen_brcondi_i32(int cond, TCGv_i32 arg1, int32_t arg2,
 547                                        int label_index)
 548 {
 549     TCGv_i32 t0 = tcg_const_i32(arg2);
 550     tcg_gen_brcond_i32(cond, arg1, t0, label_index);
 551     tcg_temp_free_i32(t0);
 552 }
 553
 554 static inline void tcg_gen_mul_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 555 {
 556     tcg_gen_op3_i32(INDEX_op_mul_i32, ret, arg1, arg2);
 557 }
 558
 559 static inline void tcg_gen_muli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 560 {
 561     TCGv_i32 t0 = tcg_const_i32(arg2);
 562     tcg_gen_mul_i32(ret, arg1, t0);
 563     tcg_temp_free_i32(t0);
 564 }
 565
 566 #ifdef TCG_TARGET_HAS_div_i32
 567 static inline void tcg_gen_div_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 568 {
 569     tcg_gen_op3_i32(INDEX_op_div_i32, ret, arg1, arg2);
 570 }
 571
 572 static inline void tcg_gen_rem_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 573 {
 574     tcg_gen_op3_i32(INDEX_op_rem_i32, ret, arg1, arg2);
 575 }
 576
 577 static inline void tcg_gen_divu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 578 {
 579     tcg_gen_op3_i32(INDEX_op_divu_i32, ret, arg1, arg2);
 580 }
 581
 582 static inline void tcg_gen_remu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 583 {
 584     tcg_gen_op3_i32(INDEX_op_remu_i32, ret, arg1, arg2);
 585 }
 586 #else
 587 static inline void tcg_gen_div_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 588 {
 589     TCGv_i32 t0;
 590     t0 = tcg_temp_new_i32();
 591     tcg_gen_sari_i32(t0, arg1, 31);
 592     tcg_gen_op5_i32(INDEX_op_div2_i32, ret, t0, arg1, t0, arg2);
 593     tcg_temp_free_i32(t0);
 594 }
 595
 596 static inline void tcg_gen_rem_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 597 {
 598     TCGv_i32 t0;
 599     t0 = tcg_temp_new_i32();
 600     tcg_gen_sari_i32(t0, arg1, 31);
 601     tcg_gen_op5_i32(INDEX_op_div2_i32, t0, ret, arg1, t0, arg2);
 602     tcg_temp_free_i32(t0);
 603 }
 604
 605 static inline void tcg_gen_divu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 606 {
 607     TCGv_i32 t0;
 608     t0 = tcg_temp_new_i32();
 609     tcg_gen_movi_i32(t0, 0);
 610     tcg_gen_op5_i32(INDEX_op_divu2_i32, ret, t0, arg1, t0, arg2);
 611     tcg_temp_free_i32(t0);
 612 }
 613
 614 static inline void tcg_gen_remu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 615 {
 616     TCGv_i32 t0;
 617     t0 = tcg_temp_new_i32();
 618     tcg_gen_movi_i32(t0, 0);
 619     tcg_gen_op5_i32(INDEX_op_divu2_i32, t0, ret, arg1, t0, arg2);
 620     tcg_temp_free_i32(t0);
 621 }
 622 #endif
 623
 624 #if TCG_TARGET_REG_BITS == 32
 625
 626 static inline void tcg_gen_mov_i64(TCGv_i64 ret, TCGv_i64 arg)
 627 {
 628     if (GET_TCGV_I64(ret) != GET_TCGV_I64(arg)) {
 629         tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg));
 630         tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg));
 631     }
 632 }
 633
 634 static inline void tcg_gen_movi_i64(TCGv_i64 ret, int64_t arg)
 635 {
 636     tcg_gen_movi_i32(TCGV_LOW(ret), arg);
 637     tcg_gen_movi_i32(TCGV_HIGH(ret), arg >> 32);
 638 }
 639
 640 static inline void tcg_gen_ld8u_i64(TCGv_i64 ret, TCGv_ptr arg2,
 641                                     tcg_target_long offset)
 642 {
 643     tcg_gen_ld8u_i32(TCGV_LOW(ret), arg2, offset);
 644     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 645 }
 646
 647 static inline void tcg_gen_ld8s_i64(TCGv_i64 ret, TCGv_ptr arg2,
 648                                     tcg_target_long offset)
 649 {
 650     tcg_gen_ld8s_i32(TCGV_LOW(ret), arg2, offset);
 651     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), 31);
 652 }
 653
 654 static inline void tcg_gen_ld16u_i64(TCGv_i64 ret, TCGv_ptr arg2,
 655                                      tcg_target_long offset)
 656 {
 657     tcg_gen_ld16u_i32(TCGV_LOW(ret), arg2, offset);
 658     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 659 }
 660
 661 static inline void tcg_gen_ld16s_i64(TCGv_i64 ret, TCGv_ptr arg2,
 662                                      tcg_target_long offset)
 663 {
 664     tcg_gen_ld16s_i32(TCGV_LOW(ret), arg2, offset);
 665     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
 666 }
 667
 668 static inline void tcg_gen_ld32u_i64(TCGv_i64 ret, TCGv_ptr arg2,
 669                                      tcg_target_long offset)
 670 {
 671     tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset);
 672     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 673 }
 674
 675 static inline void tcg_gen_ld32s_i64(TCGv_i64 ret, TCGv_ptr arg2,
 676                                      tcg_target_long offset)
 677 {
 678     tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset);
 679     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
 680 }
 681
 682 static inline void tcg_gen_ld_i64(TCGv_i64 ret, TCGv_ptr arg2,
 683                                   tcg_target_long offset)
 684 {
 685     /* since arg2 and ret have different types, they cannot be the
 686        same temporary */
 687 #ifdef TCG_TARGET_WORDS_BIGENDIAN
 688     tcg_gen_ld_i32(TCGV_HIGH(ret), arg2, offset);
 689     tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset + 4);
 690 #else
 691     tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset);
 692     tcg_gen_ld_i32(TCGV_HIGH(ret), arg2, offset + 4);
 693 #endif
 694 }
 695
 696 static inline void tcg_gen_st8_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 697                                    tcg_target_long offset)
 698 {
 699     tcg_gen_st8_i32(TCGV_LOW(arg1), arg2, offset);
 700 }
 701
 702 static inline void tcg_gen_st16_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 703                                     tcg_target_long offset)
 704 {
 705     tcg_gen_st16_i32(TCGV_LOW(arg1), arg2, offset);
 706 }
 707
 708 static inline void tcg_gen_st32_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 709                                     tcg_target_long offset)
 710 {
 711     tcg_gen_st_i32(TCGV_LOW(arg1), arg2, offset);
 712 }
 713
 714 static inline void tcg_gen_st_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 715                                   tcg_target_long offset)
 716 {
 717 #ifdef TCG_TARGET_WORDS_BIGENDIAN
 718     tcg_gen_st_i32(TCGV_HIGH(arg1), arg2, offset);
 719     tcg_gen_st_i32(TCGV_LOW(arg1), arg2, offset + 4);
 720 #else
 721     tcg_gen_st_i32(TCGV_LOW(arg1), arg2, offset);
 722     tcg_gen_st_i32(TCGV_HIGH(arg1), arg2, offset + 4);
 723 #endif
 724 }
 725
 726 static inline void tcg_gen_add_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 727 {
 728     tcg_gen_op6_i32(INDEX_op_add2_i32, TCGV_LOW(ret), TCGV_HIGH(ret),
 729                     TCGV_LOW(arg1), TCGV_HIGH(arg1), TCGV_LOW(arg2),
 730                     TCGV_HIGH(arg2));
 731 }
 732
 733 static inline void tcg_gen_sub_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 734 {
 735     tcg_gen_op6_i32(INDEX_op_sub2_i32, TCGV_LOW(ret), TCGV_HIGH(ret),
 736                     TCGV_LOW(arg1), TCGV_HIGH(arg1), TCGV_LOW(arg2),
 737                     TCGV_HIGH(arg2));
 738 }
 739
 740 static inline void tcg_gen_and_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 741 {
 742     tcg_gen_and_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 743     tcg_gen_and_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 744 }
 745
 746 static inline void tcg_gen_andi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 747 {
 748     tcg_gen_andi_i32(TCGV_LOW(ret), TCGV_LOW(arg1), arg2);
 749     tcg_gen_andi_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
 750 }
 751
 752 static inline void tcg_gen_or_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 753 {
 754     tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 755     tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 756 }
 757
 758 static inline void tcg_gen_ori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 759 {
 760     tcg_gen_ori_i32(TCGV_LOW(ret), TCGV_LOW(arg1), arg2);
 761     tcg_gen_ori_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
 762 }
 763
 764 static inline void tcg_gen_xor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 765 {
 766     tcg_gen_xor_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 767     tcg_gen_xor_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 768 }
 769
 770 static inline void tcg_gen_xori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 771 {
 772     tcg_gen_xori_i32(TCGV_LOW(ret), TCGV_LOW(arg1), arg2);
 773     tcg_gen_xori_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
 774 }
 775
 776 /* XXX: use generic code when basic block handling is OK or CPU
 777    specific code (x86) */
 778 static inline void tcg_gen_shl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 779 {
 780     tcg_gen_helper64(tcg_helper_shl_i64, ret, arg1, arg2);
 781 }
 782
 783 static inline void tcg_gen_shli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 784 {
 785     tcg_gen_shifti_i64(ret, arg1, arg2, 0, 0);
 786 }
 787
 788 static inline void tcg_gen_shr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 789 {
 790     tcg_gen_helper64(tcg_helper_shr_i64, ret, arg1, arg2);
 791 }
 792
 793 static inline void tcg_gen_shri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 794 {
 795     tcg_gen_shifti_i64(ret, arg1, arg2, 1, 0);
 796 }
 797
 798 static inline void tcg_gen_sar_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 799 {
 800     tcg_gen_helper64(tcg_helper_sar_i64, ret, arg1, arg2);
 801 }
 802
 803 static inline void tcg_gen_sari_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 804 {
 805     tcg_gen_shifti_i64(ret, arg1, arg2, 1, 1);
 806 }
 807
 808 static inline void tcg_gen_brcond_i64(int cond, TCGv_i64 arg1, TCGv_i64 arg2,
 809                                       int label_index)
 810 {
 811     tcg_gen_op6ii_i32(INDEX_op_brcond2_i32,
 812                       TCGV_LOW(arg1), TCGV_HIGH(arg1), TCGV_LOW(arg2),
 813                       TCGV_HIGH(arg2), cond, label_index);
 814 }
 815
 816 static inline void tcg_gen_mul_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 817 {
 818     TCGv_i64 t0;
 819     TCGv_i32 t1;
 820
 821     t0 = tcg_temp_new_i64();
 822     t1 = tcg_temp_new_i32();
 823
 824     tcg_gen_op4_i32(INDEX_op_mulu2_i32, TCGV_LOW(t0), TCGV_HIGH(t0),
 825                     TCGV_LOW(arg1), TCGV_LOW(arg2));
 826
 827     tcg_gen_mul_i32(t1, TCGV_LOW(arg1), TCGV_HIGH(arg2));
 828     tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1);
 829     tcg_gen_mul_i32(t1, TCGV_HIGH(arg1), TCGV_LOW(arg2));
 830     tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1);
 831
 832     tcg_gen_mov_i64(ret, t0);
 833     tcg_temp_free_i64(t0);
 834     tcg_temp_free_i32(t1);
 835 }
 836
 837 static inline void tcg_gen_div_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 838 {
 839     tcg_gen_helper64(tcg_helper_div_i64, ret, arg1, arg2);
 840 }
 841
 842 static inline void tcg_gen_rem_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 843 {
 844     tcg_gen_helper64(tcg_helper_rem_i64, ret, arg1, arg2);
 845 }
 846
 847 static inline void tcg_gen_divu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 848 {
 849     tcg_gen_helper64(tcg_helper_divu_i64, ret, arg1, arg2);
 850 }
 851
 852 static inline void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 853 {
 854     tcg_gen_helper64(tcg_helper_remu_i64, ret, arg1, arg2);
 855 }
 856
 857 #else
 858
 859 static inline void tcg_gen_mov_i64(TCGv_i64 ret, TCGv_i64 arg)
 860 {
 861     if (GET_TCGV_I64(ret) != GET_TCGV_I64(arg))
 862         tcg_gen_op2_i64(INDEX_op_mov_i64, ret, arg);
 863 }
 864
 865 static inline void tcg_gen_movi_i64(TCGv_i64 ret, int64_t arg)
 866 {
 867     tcg_gen_op2i_i64(INDEX_op_movi_i64, ret, arg);
 868 }
 869
 870 static inline void tcg_gen_ld8u_i64(TCGv_i64 ret, TCGv_i64 arg2,
 871                                     tcg_target_long offset)
 872 {
 873     tcg_gen_ldst_op_i64(INDEX_op_ld8u_i64, ret, arg2, offset);
 874 }
 875
 876 static inline void tcg_gen_ld8s_i64(TCGv_i64 ret, TCGv_i64 arg2,
 877                                     tcg_target_long offset)
 878 {
 879     tcg_gen_ldst_op_i64(INDEX_op_ld8s_i64, ret, arg2, offset);
 880 }
 881
 882 static inline void tcg_gen_ld16u_i64(TCGv_i64 ret, TCGv_i64 arg2,
 883                                      tcg_target_long offset)
 884 {
 885     tcg_gen_ldst_op_i64(INDEX_op_ld16u_i64, ret, arg2, offset);
 886 }
 887
 888 static inline void tcg_gen_ld16s_i64(TCGv_i64 ret, TCGv_i64 arg2,
 889                                      tcg_target_long offset)
 890 {
 891     tcg_gen_ldst_op_i64(INDEX_op_ld16s_i64, ret, arg2, offset);
 892 }
 893
 894 static inline void tcg_gen_ld32u_i64(TCGv_i64 ret, TCGv_i64 arg2,
 895                                      tcg_target_long offset)
 896 {
 897     tcg_gen_ldst_op_i64(INDEX_op_ld32u_i64, ret, arg2, offset);
 898 }
 899
 900 static inline void tcg_gen_ld32s_i64(TCGv_i64 ret, TCGv_i64 arg2,
 901                                      tcg_target_long offset)
 902 {
 903     tcg_gen_ldst_op_i64(INDEX_op_ld32s_i64, ret, arg2, offset);
 904 }
 905
 906 static inline void tcg_gen_ld_i64(TCGv_i64 ret, TCGv_i64 arg2, tcg_target_long offset)
 907 {
 908     tcg_gen_ldst_op_i64(INDEX_op_ld_i64, ret, arg2, offset);
 909 }
 910
 911 static inline void tcg_gen_st8_i64(TCGv_i64 arg1, TCGv_i64 arg2,
 912                                    tcg_target_long offset)
 913 {
 914     tcg_gen_ldst_op_i64(INDEX_op_st8_i64, arg1, arg2, offset);
 915 }
 916
 917 static inline void tcg_gen_st16_i64(TCGv_i64 arg1, TCGv_i64 arg2,
 918                                     tcg_target_long offset)
 919 {
 920     tcg_gen_ldst_op_i64(INDEX_op_st16_i64, arg1, arg2, offset);
 921 }
 922
 923 static inline void tcg_gen_st32_i64(TCGv_i64 arg1, TCGv_i64 arg2,
 924                                     tcg_target_long offset)
 925 {
 926     tcg_gen_ldst_op_i64(INDEX_op_st32_i64, arg1, arg2, offset);
 927 }
 928
 929 static inline void tcg_gen_st_i64(TCGv_i64 arg1, TCGv_i64 arg2, tcg_target_long offset)
 930 {
 931     tcg_gen_ldst_op_i64(INDEX_op_st_i64, arg1, arg2, offset);
 932 }
 933
 934 static inline void tcg_gen_add_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 935 {
 936     tcg_gen_op3_i64(INDEX_op_add_i64, ret, arg1, arg2);
 937 }
 938
 939 static inline void tcg_gen_sub_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 940 {
 941     tcg_gen_op3_i64(INDEX_op_sub_i64, ret, arg1, arg2);
 942 }
 943
 944 static inline void tcg_gen_and_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 945 {
 946     tcg_gen_op3_i64(INDEX_op_and_i64, ret, arg1, arg2);
 947 }
 948
 949 static inline void tcg_gen_andi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 950 {
 951     TCGv_i64 t0 = tcg_const_i64(arg2);
 952     tcg_gen_and_i64(ret, arg1, t0);
 953     tcg_temp_free_i64(t0);
 954 }
 955
 956 static inline void tcg_gen_or_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 957 {
 958     tcg_gen_op3_i64(INDEX_op_or_i64, ret, arg1, arg2);
 959 }
 960
 961 static inline void tcg_gen_ori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 962 {
 963     TCGv_i64 t0 = tcg_const_i64(arg2);
 964     tcg_gen_or_i64(ret, arg1, t0);
 965     tcg_temp_free_i64(t0);
 966 }
 967
 968 static inline void tcg_gen_xor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 969 {
 970     tcg_gen_op3_i64(INDEX_op_xor_i64, ret, arg1, arg2);
 971 }
 972
 973 static inline void tcg_gen_xori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 974 {
 975     TCGv_i64 t0 = tcg_const_i64(arg2);
 976     tcg_gen_xor_i64(ret, arg1, t0);
 977     tcg_temp_free_i64(t0);
 978 }
 979
 980 static inline void tcg_gen_shl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 981 {
 982     tcg_gen_op3_i64(INDEX_op_shl_i64, ret, arg1, arg2);
 983 }
 984
 985 static inline void tcg_gen_shli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 986 {
 987     if (arg2 == 0) {
 988         tcg_gen_mov_i64(ret, arg1);
 989     } else {
 990         TCGv_i64 t0 = tcg_const_i64(arg2);
 991         tcg_gen_shl_i64(ret, arg1, t0);
 992         tcg_temp_free_i64(t0);
 993     }
 994 }
 995
 996 static inline void tcg_gen_shr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 997 {
 998     tcg_gen_op3_i64(INDEX_op_shr_i64, ret, arg1, arg2);
 999 }
1000
1001 static inline void tcg_gen_shri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1002 {
1003     if (arg2 == 0) {
1004         tcg_gen_mov_i64(ret, arg1);
1005     } else {
1006         TCGv_i64 t0 = tcg_const_i64(arg2);
1007         tcg_gen_shr_i64(ret, arg1, t0);
1008         tcg_temp_free_i64(t0);
1009     }
1010 }
1011
1012 static inline void tcg_gen_sar_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1013 {
1014     tcg_gen_op3_i64(INDEX_op_sar_i64, ret, arg1, arg2);
1015 }
1016
1017 static inline void tcg_gen_sari_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1018 {
1019     if (arg2 == 0) {
1020         tcg_gen_mov_i64(ret, arg1);
1021     } else {
1022         TCGv_i64 t0 = tcg_const_i64(arg2);
1023         tcg_gen_sar_i64(ret, arg1, t0);
1024         tcg_temp_free_i64(t0);
1025     }
1026 }
1027
1028 static inline void tcg_gen_brcond_i64(int cond, TCGv_i64 arg1, TCGv_i64 arg2,
1029                                       int label_index)
1030 {
1031     tcg_gen_op4ii_i64(INDEX_op_brcond_i64, arg1, arg2, cond, label_index);
1032 }
1033
1034 static inline void tcg_gen_mul_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1035 {
1036     tcg_gen_op3_i64(INDEX_op_mul_i64, ret, arg1, arg2);
1037 }
1038
1039 #ifdef TCG_TARGET_HAS_div_i64
1040 static inline void tcg_gen_div_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1041 {
1042     tcg_gen_op3_i64(INDEX_op_div_i64, ret, arg1, arg2);
1043 }
1044
1045 static inline void tcg_gen_rem_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1046 {
1047     tcg_gen_op3_i64(INDEX_op_rem_i64, ret, arg1, arg2);
1048 }
1049
1050 static inline void tcg_gen_divu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1051 {
1052     tcg_gen_op3_i64(INDEX_op_divu_i64, ret, arg1, arg2);
1053 }
1054
1055 static inline void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1056 {
1057     tcg_gen_op3_i64(INDEX_op_remu_i64, ret, arg1, arg2);
1058 }
1059 #else
1060 static inline void tcg_gen_div_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1061 {
1062     TCGv_i64 t0;
1063     t0 = tcg_temp_new_i64();
1064     tcg_gen_sari_i64(t0, arg1, 63);
1065     tcg_gen_op5_i64(INDEX_op_div2_i64, ret, t0, arg1, t0, arg2);
1066     tcg_temp_free_i64(t0);
1067 }
1068
1069 static inline void tcg_gen_rem_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1070 {
1071     TCGv_i64 t0;
1072     t0 = tcg_temp_new_i64();
1073     tcg_gen_sari_i64(t0, arg1, 63);
1074     tcg_gen_op5_i64(INDEX_op_div2_i64, t0, ret, arg1, t0, arg2);
1075     tcg_temp_free_i64(t0);
1076 }
1077
1078 static inline void tcg_gen_divu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1079 {
1080     TCGv_i64 t0;
1081     t0 = tcg_temp_new_i64();
1082     tcg_gen_movi_i64(t0, 0);
1083     tcg_gen_op5_i64(INDEX_op_divu2_i64, ret, t0, arg1, t0, arg2);
1084     tcg_temp_free_i64(t0);
1085 }
1086
1087 static inline void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1088 {
1089     TCGv_i64 t0;
1090     t0 = tcg_temp_new_i64();
1091     tcg_gen_movi_i64(t0, 0);
1092     tcg_gen_op5_i64(INDEX_op_divu2_i64, t0, ret, arg1, t0, arg2);
1093     tcg_temp_free_i64(t0);
1094 }
1095 #endif
1096
1097 #endif
1098
1099 static inline void tcg_gen_addi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1100 {
1101     /* some cases can be optimized here */
1102     if (arg2 == 0) {
1103         tcg_gen_mov_i64(ret, arg1);
1104     } else {
1105         TCGv_i64 t0 = tcg_const_i64(arg2);
1106         tcg_gen_add_i64(ret, arg1, t0);
1107         tcg_temp_free_i64(t0);
1108     }
1109 }
1110
1111 static inline void tcg_gen_subfi_i64(TCGv_i64 ret, int64_t arg1, TCGv_i64 arg2)
1112 {
1113     TCGv_i64 t0 = tcg_const_i64(arg1);
1114     tcg_gen_sub_i64(ret, t0, arg2);
1115     tcg_temp_free_i64(t0);
1116 }
1117
1118 static inline void tcg_gen_subi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1119 {
1120     /* some cases can be optimized here */
1121     if (arg2 == 0) {
1122         tcg_gen_mov_i64(ret, arg1);
1123     } else {
1124         TCGv_i64 t0 = tcg_const_i64(arg2);
1125         tcg_gen_sub_i64(ret, arg1, t0);
1126         tcg_temp_free_i64(t0);
1127     }
1128 }
1129 static inline void tcg_gen_brcondi_i64(int cond, TCGv_i64 arg1, int64_t arg2,
1130                                        int label_index)
1131 {
1132     TCGv_i64 t0 = tcg_const_i64(arg2);
1133     tcg_gen_brcond_i64(cond, arg1, t0, label_index);
1134     tcg_temp_free_i64(t0);
1135 }
1136
1137 static inline void tcg_gen_muli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1138 {
1139     TCGv_i64 t0 = tcg_const_i64(arg2);
1140     tcg_gen_mul_i64(ret, arg1, t0);
1141     tcg_temp_free_i64(t0);
1142 }
1143
1144
1145 /***************************************/
1146 /* optional operations */
1147
1148 static inline void tcg_gen_ext8s_i32(TCGv_i32 ret, TCGv_i32 arg)
1149 {
1150 #ifdef TCG_TARGET_HAS_ext8s_i32
1151     tcg_gen_op2_i32(INDEX_op_ext8s_i32, ret, arg);
1152 #else
1153     tcg_gen_shli_i32(ret, arg, 24);
1154     tcg_gen_sari_i32(ret, ret, 24);
1155 #endif
1156 }
1157
1158 static inline void tcg_gen_ext16s_i32(TCGv_i32 ret, TCGv_i32 arg)
1159 {
1160 #ifdef TCG_TARGET_HAS_ext16s_i32
1161     tcg_gen_op2_i32(INDEX_op_ext16s_i32, ret, arg);
1162 #else
1163     tcg_gen_shli_i32(ret, arg, 16);
1164     tcg_gen_sari_i32(ret, ret, 16);
1165 #endif
1166 }
1167
1168 /* These are currently just for convenience.
1169    We assume a target will recognise these automatically .  */
1170 static inline void tcg_gen_ext8u_i32(TCGv_i32 ret, TCGv_i32 arg)
1171 {
1172     tcg_gen_andi_i32(ret, arg, 0xffu);
1173 }
1174
1175 static inline void tcg_gen_ext16u_i32(TCGv_i32 ret, TCGv_i32 arg)
1176 {
1177     tcg_gen_andi_i32(ret, arg, 0xffffu);
1178 }
1179
1180 /* Note: we assume the two high bytes are set to zero */
1181 static inline void tcg_gen_bswap16_i32(TCGv_i32 ret, TCGv_i32 arg)
1182 {
1183 #ifdef TCG_TARGET_HAS_bswap16_i32
1184     tcg_gen_op2_i32(INDEX_op_bswap16_i32, ret, arg);
1185 #else
1186     TCGv_i32 t0, t1;
1187     t0 = tcg_temp_new_i32();
1188     t1 = tcg_temp_new_i32();
1189
1190     tcg_gen_shri_i32(t0, arg, 8);
1191     tcg_gen_andi_i32(t1, arg, 0x000000ff);
1192     tcg_gen_shli_i32(t1, t1, 8);
1193     tcg_gen_or_i32(ret, t0, t1);
1194     tcg_temp_free_i32(t0);
1195     tcg_temp_free_i32(t1);
1196 #endif
1197 }
1198
1199 static inline void tcg_gen_bswap_i32(TCGv_i32 ret, TCGv_i32 arg)
1200 {
1201 #ifdef TCG_TARGET_HAS_bswap_i32
1202     tcg_gen_op2_i32(INDEX_op_bswap_i32, ret, arg);
1203 #else
1204     TCGv_i32 t0, t1;
1205     t0 = tcg_temp_new_i32();
1206     t1 = tcg_temp_new_i32();
1207
1208     tcg_gen_shli_i32(t0, arg, 24);
1209
1210     tcg_gen_andi_i32(t1, arg, 0x0000ff00);
1211     tcg_gen_shli_i32(t1, t1, 8);
1212     tcg_gen_or_i32(t0, t0, t1);
1213
1214     tcg_gen_shri_i32(t1, arg, 8);
1215     tcg_gen_andi_i32(t1, t1, 0x0000ff00);
1216     tcg_gen_or_i32(t0, t0, t1);
1217
1218     tcg_gen_shri_i32(t1, arg, 24);
1219     tcg_gen_or_i32(ret, t0, t1);
1220     tcg_temp_free_i32(t0);
1221     tcg_temp_free_i32(t1);
1222 #endif
1223 }
1224
1225 #if TCG_TARGET_REG_BITS == 32
1226 static inline void tcg_gen_ext8s_i64(TCGv_i64 ret, TCGv_i64 arg)
1227 {
1228     tcg_gen_ext8s_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1229     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
1230 }
1231
1232 static inline void tcg_gen_ext16s_i64(TCGv_i64 ret, TCGv_i64 arg)
1233 {
1234     tcg_gen_ext16s_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1235     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
1236 }
1237
1238 static inline void tcg_gen_ext32s_i64(TCGv_i64 ret, TCGv_i64 arg)
1239 {
1240     tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1241     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
1242 }
1243
1244 static inline void tcg_gen_ext8u_i64(TCGv_i64 ret, TCGv_i64 arg)
1245 {
1246     tcg_gen_ext8u_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1247     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1248 }
1249
1250 static inline void tcg_gen_ext16u_i64(TCGv_i64 ret, TCGv_i64 arg)
1251 {
1252     tcg_gen_ext16u_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1253     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1254 }
1255
1256 static inline void tcg_gen_ext32u_i64(TCGv_i64 ret, TCGv_i64 arg)
1257 {
1258     tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg));
1259     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1260 }
1261
1262 static inline void tcg_gen_trunc_i64_i32(TCGv_i32 ret, TCGv_i64 arg)
1263 {
1264     tcg_gen_mov_i32(ret, TCGV_LOW(arg));
1265 }
1266
1267 static inline void tcg_gen_extu_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
1268 {
1269     tcg_gen_mov_i32(TCGV_LOW(ret), arg);
1270     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1271 }
1272
1273 static inline void tcg_gen_ext_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
1274 {
1275     tcg_gen_mov_i32(TCGV_LOW(ret), arg);
1276     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
1277 }
1278
1279 static inline void tcg_gen_bswap_i64(TCGv_i64 ret, TCGv_i64 arg)
1280 {
1281     TCGv_i32 t0, t1;
1282     t0 = tcg_temp_new_i32();
1283     t1 = tcg_temp_new_i32();
1284
1285     tcg_gen_bswap_i32(t0, TCGV_LOW(arg));
1286     tcg_gen_bswap_i32(t1, TCGV_HIGH(arg));
1287     tcg_gen_mov_i32(TCGV_LOW(ret), t1);
1288     tcg_gen_mov_i32(TCGV_HIGH(ret), t0);
1289     tcg_temp_free_i32(t0);
1290     tcg_temp_free_i32(t1);
1291 }
1292 #else
1293
1294 static inline void tcg_gen_ext8s_i64(TCGv_i64 ret, TCGv_i64 arg)
1295 {
1296 #ifdef TCG_TARGET_HAS_ext8s_i64
1297     tcg_gen_op2_i64(INDEX_op_ext8s_i64, ret, arg);
1298 #else
1299     tcg_gen_shli_i64(ret, arg, 56);
1300     tcg_gen_sari_i64(ret, ret, 56);
1301 #endif
1302 }
1303
1304 static inline void tcg_gen_ext16s_i64(TCGv_i64 ret, TCGv_i64 arg)
1305 {
1306 #ifdef TCG_TARGET_HAS_ext16s_i64
1307     tcg_gen_op2_i64(INDEX_op_ext16s_i64, ret, arg);
1308 #else
1309     tcg_gen_shli_i64(ret, arg, 48);
1310     tcg_gen_sari_i64(ret, ret, 48);
1311 #endif
1312 }
1313
1314 static inline void tcg_gen_ext32s_i64(TCGv_i64 ret, TCGv_i64 arg)
1315 {
1316 #ifdef TCG_TARGET_HAS_ext32s_i64
1317     tcg_gen_op2_i64(INDEX_op_ext32s_i64, ret, arg);
1318 #else
1319     tcg_gen_shli_i64(ret, arg, 32);
1320     tcg_gen_sari_i64(ret, ret, 32);
1321 #endif
1322 }
1323
1324 static inline void tcg_gen_ext8u_i64(TCGv_i64 ret, TCGv_i64 arg)
1325 {
1326     tcg_gen_andi_i64(ret, arg, 0xffu);
1327 }
1328
1329 static inline void tcg_gen_ext16u_i64(TCGv_i64 ret, TCGv_i64 arg)
1330 {
1331     tcg_gen_andi_i64(ret, arg, 0xffffu);
1332 }
1333
1334 static inline void tcg_gen_ext32u_i64(TCGv_i64 ret, TCGv_i64 arg)
1335 {
1336     tcg_gen_andi_i64(ret, arg, 0xffffffffu);
1337 }
1338
1339 /* Note: we assume the target supports move between 32 and 64 bit
1340    registers.  This will probably break MIPS64 targets.  */
1341 static inline void tcg_gen_trunc_i64_i32(TCGv_i32 ret, TCGv_i64 arg)
1342 {
1343     tcg_gen_mov_i32(ret, MAKE_TCGV_I32(GET_TCGV_I64(arg)));
1344 }
1345
1346 /* Note: we assume the target supports move between 32 and 64 bit
1347    registers */
1348 static inline void tcg_gen_extu_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
1349 {
1350     tcg_gen_andi_i64(ret, MAKE_TCGV_I64(GET_TCGV_I32(arg)), 0xffffffffu);
1351 }
1352
1353 /* Note: we assume the target supports move between 32 and 64 bit
1354    registers */
1355 static inline void tcg_gen_ext_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
1356 {
1357     tcg_gen_ext32s_i64(ret, MAKE_TCGV_I64(GET_TCGV_I32(arg)));
1358 }
1359
1360 static inline void tcg_gen_bswap_i64(TCGv_i64 ret, TCGv_i64 arg)
1361 {
1362 #ifdef TCG_TARGET_HAS_bswap_i64
1363     tcg_gen_op2_i64(INDEX_op_bswap_i64, ret, arg);
1364 #else
1365     TCGv_i32 t0, t1;
1366     t0 = tcg_temp_new_i32();
1367     t1 = tcg_temp_new_i32();
1368
1369     tcg_gen_shli_i64(t0, arg, 56);
1370
1371     tcg_gen_andi_i64(t1, arg, 0x0000ff00);
1372     tcg_gen_shli_i64(t1, t1, 40);
1373     tcg_gen_or_i64(t0, t0, t1);
1374
1375     tcg_gen_andi_i64(t1, arg, 0x00ff0000);
1376     tcg_gen_shli_i64(t1, t1, 24);
1377     tcg_gen_or_i64(t0, t0, t1);
1378
1379     tcg_gen_andi_i64(t1, arg, 0xff000000);
1380     tcg_gen_shli_i64(t1, t1, 8);
1381     tcg_gen_or_i64(t0, t0, t1);
1382
1383     tcg_gen_shri_i64(t1, arg, 8);
1384     tcg_gen_andi_i64(t1, t1, 0xff000000);
1385     tcg_gen_or_i64(t0, t0, t1);
1386
1387     tcg_gen_shri_i64(t1, arg, 24);
1388     tcg_gen_andi_i64(t1, t1, 0x00ff0000);
1389     tcg_gen_or_i64(t0, t0, t1);
1390
1391     tcg_gen_shri_i64(t1, arg, 40);
1392     tcg_gen_andi_i64(t1, t1, 0x0000ff00);
1393     tcg_gen_or_i64(t0, t0, t1);
1394
1395     tcg_gen_shri_i64(t1, arg, 56);
1396     tcg_gen_or_i64(ret, t0, t1);
1397     tcg_temp_free_i32(t0);
1398     tcg_temp_free_i32(t1);
1399 #endif
1400 }
1401
1402 #endif
1403
1404 static inline void tcg_gen_neg_i32(TCGv_i32 ret, TCGv_i32 arg)
1405 {
1406 #ifdef TCG_TARGET_HAS_neg_i32
1407     tcg_gen_op2_i32(INDEX_op_neg_i32, ret, arg);
1408 #else
1409     TCGv_i32 t0 = tcg_const_i32(0);
1410     tcg_gen_sub_i32(ret, t0, arg);
1411     tcg_temp_free_i32(t0);
1412 #endif
1413 }
1414
1415 static inline void tcg_gen_neg_i64(TCGv_i64 ret, TCGv_i64 arg)
1416 {
1417 #ifdef TCG_TARGET_HAS_neg_i64
1418     tcg_gen_op2_i64(INDEX_op_neg_i64, ret, arg);
1419 #else
1420     TCGv_i64 t0 = tcg_const_i64(0);
1421     tcg_gen_sub_i64(ret, t0, arg);
1422     tcg_temp_free_i64(t0);
1423 #endif
1424 }
1425
1426 static inline void tcg_gen_not_i32(TCGv_i32 ret, TCGv_i32 arg)
1427 {
1428     tcg_gen_xori_i32(ret, arg, -1);
1429 }
1430
1431 static inline void tcg_gen_not_i64(TCGv_i64 ret, TCGv_i64 arg)
1432 {
1433     tcg_gen_xori_i64(ret, arg, -1);
1434 }
1435
1436 static inline void tcg_gen_discard_i32(TCGv_i32 arg)
1437 {
1438     tcg_gen_op1_i32(INDEX_op_discard, arg);
1439 }
1440
1441 #if TCG_TARGET_REG_BITS == 32
1442 static inline void tcg_gen_discard_i64(TCGv_i64 arg)
1443 {
1444     tcg_gen_discard_i32(TCGV_LOW(arg));
1445     tcg_gen_discard_i32(TCGV_HIGH(arg));
1446 }
1447 #else
1448 static inline void tcg_gen_discard_i64(TCGv_i64 arg)
1449 {
1450     tcg_gen_op1_i64(INDEX_op_discard, arg);
1451 }
1452 #endif
1453
1454 static inline void tcg_gen_concat_i32_i64(TCGv_i64 dest, TCGv_i32 low, TCGv_i32 high)
1455 {
1456 #if TCG_TARGET_REG_BITS == 32
1457     tcg_gen_mov_i32(TCGV_LOW(dest), low);
1458     tcg_gen_mov_i32(TCGV_HIGH(dest), high);
1459 #else
1460     TCGv_i64 tmp = tcg_temp_new_i64();
1461     /* This extension is only needed for type correctness.
1462        We may be able to do better given target specific information.  */
1463     tcg_gen_extu_i32_i64(tmp, high);
1464     tcg_gen_shli_i64(tmp, tmp, 32);
1465     tcg_gen_extu_i32_i64(dest, low);
1466     tcg_gen_or_i64(dest, dest, tmp);
1467     tcg_temp_free_i64(tmp);
1468 #endif
1469 }
1470
1471 static inline void tcg_gen_concat32_i64(TCGv_i64 dest, TCGv_i64 low, TCGv_i64 high)
1472 {
1473 #if TCG_TARGET_REG_BITS == 32
1474     tcg_gen_concat_i32_i64(dest, TCGV_LOW(low), TCGV_LOW(high));
1475 #else
1476     TCGv_i64 tmp = tcg_temp_new_i64();
1477     tcg_gen_ext32u_i64(dest, low);
1478     tcg_gen_shli_i64(tmp, high, 32);
1479     tcg_gen_or_i64(dest, dest, tmp);
1480     tcg_temp_free_i64(tmp);
1481 #endif
1482 }
1483
1484 static inline void tcg_gen_andc_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1485 {
1486     TCGv_i32 t0;
1487     t0 = tcg_temp_new_i32();
1488     tcg_gen_not_i32(t0, arg2);
1489     tcg_gen_and_i32(ret, arg1, t0);
1490     tcg_temp_free_i32(t0);
1491 }
1492
1493 static inline void tcg_gen_andc_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1494 {
1495     TCGv_i64 t0;
1496     t0 = tcg_temp_new_i64();
1497     tcg_gen_not_i64(t0, arg2);
1498     tcg_gen_and_i64(ret, arg1, t0);
1499     tcg_temp_free_i64(t0);
1500 }
1501
1502 static inline void tcg_gen_eqv_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1503 {
1504     TCGv_i32 t0;
1505     t0 = tcg_temp_new_i32();
1506     tcg_gen_xor_i32(t0, arg1, arg2);
1507     tcg_gen_not_i32(ret, t0);
1508     tcg_temp_free_i32(t0);
1509 }
1510
1511 static inline void tcg_gen_eqv_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1512 {
1513     TCGv_i64 t0;
1514     t0 = tcg_temp_new_i64();
1515     tcg_gen_xor_i64(t0, arg1, arg2);
1516     tcg_gen_not_i64(ret, t0);
1517     tcg_temp_free_i64(t0);
1518 }
1519
1520 static inline void tcg_gen_nand_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1521 {
1522     TCGv_i32 t0;
1523     t0 = tcg_temp_new_i32();
1524     tcg_gen_and_i32(t0, arg1, arg2);
1525     tcg_gen_not_i32(ret, t0);
1526     tcg_temp_free_i32(t0);
1527 }
1528
1529 static inline void tcg_gen_nand_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1530 {
1531     TCGv_i64 t0;
1532     t0 = tcg_temp_new_i64();
1533     tcg_gen_and_i64(t0, arg1, arg2);
1534     tcg_gen_not_i64(ret, t0);
1535     tcg_temp_free_i64(t0);
1536 }
1537
1538 static inline void tcg_gen_nor_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1539 {
1540     TCGv_i32 t0;
1541     t0 = tcg_temp_new_i32();
1542     tcg_gen_or_i32(t0, arg1, arg2);
1543     tcg_gen_not_i32(ret, t0);
1544     tcg_temp_free_i32(t0);
1545 }
1546
1547 static inline void tcg_gen_nor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1548 {
1549     TCGv_i64 t0;
1550     t0 = tcg_temp_new_i64();
1551     tcg_gen_or_i64(t0, arg1, arg2);
1552     tcg_gen_not_i64(ret, t0);
1553     tcg_temp_free_i64(t0);
1554 }
1555
1556 static inline void tcg_gen_orc_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1557 {
1558     TCGv_i32 t0;
1559     t0 = tcg_temp_new_i32();
1560     tcg_gen_not_i32(t0, arg2);
1561     tcg_gen_or_i32(ret, arg1, t0);
1562     tcg_temp_free_i32(t0);
1563 }
1564
1565 static inline void tcg_gen_orc_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1566 {
1567     TCGv_i64 t0;
1568     t0 = tcg_temp_new_i64();
1569     tcg_gen_not_i64(t0, arg2);
1570     tcg_gen_or_i64(ret, arg1, t0);
1571     tcg_temp_free_i64(t0);
1572 }
1573
1574 static inline void tcg_gen_rotl_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1575 {
1576     TCGv_i32 t0, t1;
1577
1578     t0 = tcg_temp_new_i32();
1579     t1 = tcg_temp_new_i32();
1580     tcg_gen_shl_i32(t0, arg1, arg2);
1581     tcg_gen_subfi_i32(t1, 32, arg2);
1582     tcg_gen_shr_i32(t1, arg1, t1);
1583     tcg_gen_or_i32(ret, t0, t1);
1584     tcg_temp_free_i32(t0);
1585     tcg_temp_free_i32(t1);
1586 }
1587
1588 static inline void tcg_gen_rotl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1589 {
1590     TCGv_i64 t0, t1;
1591
1592     t0 = tcg_temp_new_i64();
1593     t1 = tcg_temp_new_i64();
1594     tcg_gen_shl_i64(t0, arg1, arg2);
1595     tcg_gen_subfi_i64(t1, 64, arg2);
1596     tcg_gen_shr_i64(t1, arg1, t1);
1597     tcg_gen_or_i64(ret, t0, t1);
1598     tcg_temp_free_i64(t0);
1599     tcg_temp_free_i64(t1);
1600 }
1601
1602 static inline void tcg_gen_rotli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
1603 {
1604     /* some cases can be optimized here */
1605     if (arg2 == 0) {
1606         tcg_gen_mov_i32(ret, arg1);
1607     } else {
1608         TCGv_i32 t0, t1;
1609         t0 = tcg_temp_new_i32();
1610         t1 = tcg_temp_new_i32();
1611         tcg_gen_shli_i32(t0, arg1, arg2);
1612         tcg_gen_shri_i32(t1, arg1, 32 - arg2);
1613         tcg_gen_or_i32(ret, t0, t1);
1614         tcg_temp_free_i32(t0);
1615         tcg_temp_free_i32(t1);
1616     }
1617 }
1618
1619 static inline void tcg_gen_rotli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1620 {
1621     /* some cases can be optimized here */
1622     if (arg2 == 0) {
1623         tcg_gen_mov_i64(ret, arg1);
1624     } else {
1625         TCGv_i64 t0, t1;
1626         t0 = tcg_temp_new_i64();
1627         t1 = tcg_temp_new_i64();
1628         tcg_gen_shli_i64(t0, arg1, arg2);
1629         tcg_gen_shri_i64(t1, arg1, 64 - arg2);
1630         tcg_gen_or_i64(ret, t0, t1);
1631         tcg_temp_free_i64(t0);
1632         tcg_temp_free_i64(t1);
1633     }
1634 }
1635
1636 static inline void tcg_gen_rotr_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
1637 {
1638     TCGv_i32 t0, t1;
1639
1640     t0 = tcg_temp_new_i32();
1641     t1 = tcg_temp_new_i32();
1642     tcg_gen_shr_i32(t0, arg1, arg2);
1643     tcg_gen_subfi_i32(t1, 32, arg2);
1644     tcg_gen_shl_i32(t1, arg1, t1);
1645     tcg_gen_or_i32(ret, t0, t1);
1646     tcg_temp_free_i32(t0);
1647     tcg_temp_free_i32(t1);
1648 }
1649
1650 static inline void tcg_gen_rotr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
1651 {
1652     TCGv_i64 t0, t1;
1653
1654     t0 = tcg_temp_new_i64();
1655     t1 = tcg_temp_new_i64();
1656     tcg_gen_shl_i64(t0, arg1, arg2);
1657     tcg_gen_subfi_i64(t1, 64, arg2);
1658     tcg_gen_shl_i64(t1, arg1, t1);
1659     tcg_gen_or_i64(ret, t0, t1);
1660     tcg_temp_free_i64(t0);
1661     tcg_temp_free_i64(t1);
1662 }
1663
1664 static inline void tcg_gen_rotri_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
1665 {
1666     /* some cases can be optimized here */
1667     if (arg2 == 0) {
1668         tcg_gen_mov_i32(ret, arg1);
1669     } else {
1670         tcg_gen_rotli_i32(ret, arg1, 32 - arg2);
1671     }
1672 }
1673
1674 static inline void tcg_gen_rotri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
1675 {
1676     /* some cases can be optimized here */
1677     if (arg2 == 0) {
1678         tcg_gen_mov_i64(ret, arg1);
1679     } else {
1680         tcg_gen_rotli_i64(ret, arg1, 64 - arg2);
1681     }
1682 }
1683
1684 /***************************************/
1685 /* QEMU specific operations. Their type depend on the QEMU CPU
1686    type. */
1687 #ifndef TARGET_LONG_BITS
1688 #error must include QEMU headers
1689 #endif
1690
1691 #if TARGET_LONG_BITS == 32
1692 #define TCGv TCGv_i32
1693 #define tcg_temp_new() tcg_temp_new_i32()
1694 #define tcg_global_reg_new tcg_global_reg_new_i32
1695 #define tcg_global_mem_new tcg_global_mem_new_i32
1696 #define tcg_temp_local_new() tcg_temp_local_new_i32()
1697 #define tcg_temp_free tcg_temp_free_i32
1698 #define tcg_gen_qemu_ldst_op tcg_gen_op3i_i32
1699 #define tcg_gen_qemu_ldst_op_i64 tcg_gen_qemu_ldst_op_i64_i32
1700 #define TCGV_UNUSED(x) TCGV_UNUSED_I32(x)
1701 #define TCGV_EQUAL(a, b) (GET_TCGV_I32(a) == GET_TCGV_I32(b))
1702 #else
1703 #define TCGv TCGv_i64
1704 #define tcg_temp_new() tcg_temp_new_i64()
1705 #define tcg_global_reg_new tcg_global_reg_new_i64
1706 #define tcg_global_mem_new tcg_global_mem_new_i64
1707 #define tcg_temp_local_new() tcg_temp_local_new_i64()
1708 #define tcg_temp_free tcg_temp_free_i64
1709 #define tcg_gen_qemu_ldst_op tcg_gen_op3i_i64
1710 #define tcg_gen_qemu_ldst_op_i64 tcg_gen_qemu_ldst_op_i64_i64
1711 #define TCGV_UNUSED(x) TCGV_UNUSED_I64(x)
1712 #define TCGV_EQUAL(a, b) (GET_TCGV_I64(a) == GET_TCGV_I64(b))
1713 #endif
1714
1715 /* debug info: write the PC of the corresponding QEMU CPU instruction */
1716 static inline void tcg_gen_debug_insn_start(uint64_t pc)
1717 {
1718     /* XXX: must really use a 32 bit size for TCGArg in all cases */
1719 #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
1720     tcg_gen_op2ii(INDEX_op_debug_insn_start,
1721                   (uint32_t)(pc), (uint32_t)(pc >> 32));
1722 #else
1723     tcg_gen_op1i(INDEX_op_debug_insn_start, pc);
1724 #endif
1725 }
1726
1727 static inline void tcg_gen_exit_tb(tcg_target_long val)
1728 {
1729     tcg_gen_op1i(INDEX_op_exit_tb, val);
1730 }
1731
1732 static inline void tcg_gen_goto_tb(int idx)
1733 {
1734     tcg_gen_op1i(INDEX_op_goto_tb, idx);
1735 }
1736
1737 #if TCG_TARGET_REG_BITS == 32
1738 static inline void tcg_gen_qemu_ld8u(TCGv ret, TCGv addr, int mem_index)
1739 {
1740 #if TARGET_LONG_BITS == 32
1741     tcg_gen_op3i_i32(INDEX_op_qemu_ld8u, ret, addr, mem_index);
1742 #else
1743     tcg_gen_op4i_i32(INDEX_op_qemu_ld8u, TCGV_LOW(ret), TCGV_LOW(addr),
1744                      TCGV_HIGH(addr), mem_index);
1745     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1746 #endif
1747 }
1748
1749 static inline void tcg_gen_qemu_ld8s(TCGv ret, TCGv addr, int mem_index)
1750 {
1751 #if TARGET_LONG_BITS == 32
1752     tcg_gen_op3i_i32(INDEX_op_qemu_ld8s, ret, addr, mem_index);
1753 #else
1754     tcg_gen_op4i_i32(INDEX_op_qemu_ld8s, TCGV_LOW(ret), TCGV_LOW(addr),
1755                      TCGV_HIGH(addr), mem_index);
1756     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
1757 #endif
1758 }
1759
1760 static inline void tcg_gen_qemu_ld16u(TCGv ret, TCGv addr, int mem_index)
1761 {
1762 #if TARGET_LONG_BITS == 32
1763     tcg_gen_op3i_i32(INDEX_op_qemu_ld16u, ret, addr, mem_index);
1764 #else
1765     tcg_gen_op4i_i32(INDEX_op_qemu_ld16u, TCGV_LOW(ret), TCGV_LOW(addr),
1766                      TCGV_HIGH(addr), mem_index);
1767     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1768 #endif
1769 }
1770
1771 static inline void tcg_gen_qemu_ld16s(TCGv ret, TCGv addr, int mem_index)
1772 {
1773 #if TARGET_LONG_BITS == 32
1774     tcg_gen_op3i_i32(INDEX_op_qemu_ld16s, ret, addr, mem_index);
1775 #else
1776     tcg_gen_op4i_i32(INDEX_op_qemu_ld16s, TCGV_LOW(ret), TCGV_LOW(addr),
1777                      TCGV_HIGH(addr), mem_index);
1778     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
1779 #endif
1780 }
1781
1782 static inline void tcg_gen_qemu_ld32u(TCGv ret, TCGv addr, int mem_index)
1783 {
1784 #if TARGET_LONG_BITS == 32
1785     tcg_gen_op3i_i32(INDEX_op_qemu_ld32u, ret, addr, mem_index);
1786 #else
1787     tcg_gen_op4i_i32(INDEX_op_qemu_ld32u, TCGV_LOW(ret), TCGV_LOW(addr),
1788                      TCGV_HIGH(addr), mem_index);
1789     tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
1790 #endif
1791 }
1792
1793 static inline void tcg_gen_qemu_ld32s(TCGv ret, TCGv addr, int mem_index)
1794 {
1795 #if TARGET_LONG_BITS == 32
1796     tcg_gen_op3i_i32(INDEX_op_qemu_ld32u, ret, addr, mem_index);
1797 #else
1798     tcg_gen_op4i_i32(INDEX_op_qemu_ld32u, TCGV_LOW(ret), TCGV_LOW(addr),
1799                      TCGV_HIGH(addr), mem_index);
1800     tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
1801 #endif
1802 }
1803
1804 static inline void tcg_gen_qemu_ld64(TCGv_i64 ret, TCGv addr, int mem_index)
1805 {
1806 #if TARGET_LONG_BITS == 32
1807     tcg_gen_op4i_i32(INDEX_op_qemu_ld64, TCGV_LOW(ret), TCGV_HIGH(ret), addr, mem_index);
1808 #else
1809     tcg_gen_op5i_i32(INDEX_op_qemu_ld64, TCGV_LOW(ret), TCGV_HIGH(ret),
1810                      TCGV_LOW(addr), TCGV_HIGH(addr), mem_index);
1811 #endif
1812 }
1813
1814 static inline void tcg_gen_qemu_st8(TCGv arg, TCGv addr, int mem_index)
1815 {
1816 #if TARGET_LONG_BITS == 32
1817     tcg_gen_op3i_i32(INDEX_op_qemu_st8, arg, addr, mem_index);
1818 #else
1819     tcg_gen_op4i_i32(INDEX_op_qemu_st8, TCGV_LOW(arg), TCGV_LOW(addr),
1820                      TCGV_HIGH(addr), mem_index);
1821 #endif
1822 }
1823
1824 static inline void tcg_gen_qemu_st16(TCGv arg, TCGv addr, int mem_index)
1825 {
1826 #if TARGET_LONG_BITS == 32
1827     tcg_gen_op3i_i32(INDEX_op_qemu_st16, arg, addr, mem_index);
1828 #else
1829     tcg_gen_op4i_i32(INDEX_op_qemu_st16, TCGV_LOW(arg), TCGV_LOW(addr),
1830                      TCGV_HIGH(addr), mem_index);
1831 #endif
1832 }
1833
1834 static inline void tcg_gen_qemu_st32(TCGv arg, TCGv addr, int mem_index)
1835 {
1836 #if TARGET_LONG_BITS == 32
1837     tcg_gen_op3i_i32(INDEX_op_qemu_st32, arg, addr, mem_index);
1838 #else
1839     tcg_gen_op4i_i32(INDEX_op_qemu_st32, TCGV_LOW(arg), TCGV_LOW(addr),
1840                      TCGV_HIGH(addr), mem_index);
1841 #endif
1842 }
1843
1844 static inline void tcg_gen_qemu_st64(TCGv_i64 arg, TCGv addr, int mem_index)
1845 {
1846 #if TARGET_LONG_BITS == 32
1847     tcg_gen_op4i_i32(INDEX_op_qemu_st64, TCGV_LOW(arg), TCGV_HIGH(arg), addr,
1848                      mem_index);
1849 #else
1850     tcg_gen_op5i_i32(INDEX_op_qemu_st64, TCGV_LOW(arg), TCGV_HIGH(arg),
1851                      TCGV_LOW(addr), TCGV_HIGH(addr), mem_index);
1852 #endif
1853 }
1854
1855 #define tcg_gen_ld_ptr tcg_gen_ld_i32
1856 #define tcg_gen_discard_ptr tcg_gen_discard_i32
1857
1858 #else /* TCG_TARGET_REG_BITS == 32 */
1859
1860 static inline void tcg_gen_qemu_ld8u(TCGv ret, TCGv addr, int mem_index)
1861 {
1862     tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld8u, ret, addr, mem_index);
1863 }
1864
1865 static inline void tcg_gen_qemu_ld8s(TCGv ret, TCGv addr, int mem_index)
1866 {
1867     tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld8s, ret, addr, mem_index);
1868 }
1869
1870 static inline void tcg_gen_qemu_ld16u(TCGv ret, TCGv addr, int mem_index)
1871 {
1872     tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld16u, ret, addr, mem_index);
1873 }
1874
1875 static inline void tcg_gen_qemu_ld16s(TCGv ret, TCGv addr, int mem_index)
1876 {
1877     tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld16s, ret, addr, mem_index);
1878 }
1879
1880 static inline void tcg_gen_qemu_ld32u(TCGv ret, TCGv addr, int mem_index)
1881 {
1882     tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld32u, ret, addr, mem_index);
1883 }
1884
1885 static inline void tcg_gen_qemu_ld32s(TCGv ret, TCGv addr, int mem_index)
1886 {
1887     tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld32s, ret, addr, mem_index);
1888 }
1889
1890 static inline void tcg_gen_qemu_ld64(TCGv_i64 ret, TCGv addr, int mem_index)
1891 {
1892     tcg_gen_qemu_ldst_op_i64(INDEX_op_qemu_ld64, ret, addr, mem_index);
1893 }
1894
1895 static inline void tcg_gen_qemu_st8(TCGv arg, TCGv addr, int mem_index)
1896 {
1897     tcg_gen_qemu_ldst_op(INDEX_op_qemu_st8, arg, addr, mem_index);
1898 }
1899
1900 static inline void tcg_gen_qemu_st16(TCGv arg, TCGv addr, int mem_index)
1901 {
1902     tcg_gen_qemu_ldst_op(INDEX_op_qemu_st16, arg, addr, mem_index);
1903 }
1904
1905 static inline void tcg_gen_qemu_st32(TCGv arg, TCGv addr, int mem_index)
1906 {
1907     tcg_gen_qemu_ldst_op(INDEX_op_qemu_st32, arg, addr, mem_index);
1908 }
1909
1910 static inline void tcg_gen_qemu_st64(TCGv_i64 arg, TCGv addr, int mem_index)
1911 {
1912     tcg_gen_qemu_ldst_op_i64(INDEX_op_qemu_st64, arg, addr, mem_index);
1913 }
1914
1915 #define tcg_gen_ld_ptr tcg_gen_ld_i64
1916 #define tcg_gen_discard_ptr tcg_gen_discard_i64
1917
1918 #endif /* TCG_TARGET_REG_BITS != 32 */
1919
1920 #if TARGET_LONG_BITS == 64
1921 #define TCG_TYPE_TL TCG_TYPE_I64
1922 #define tcg_gen_movi_tl tcg_gen_movi_i64
1923 #define tcg_gen_mov_tl tcg_gen_mov_i64
1924 #define tcg_gen_ld8u_tl tcg_gen_ld8u_i64
1925 #define tcg_gen_ld8s_tl tcg_gen_ld8s_i64
1926 #define tcg_gen_ld16u_tl tcg_gen_ld16u_i64
1927 #define tcg_gen_ld16s_tl tcg_gen_ld16s_i64
1928 #define tcg_gen_ld32u_tl tcg_gen_ld32u_i64
1929 #define tcg_gen_ld32s_tl tcg_gen_ld32s_i64
1930 #define tcg_gen_ld_tl tcg_gen_ld_i64
1931 #define tcg_gen_st8_tl tcg_gen_st8_i64
1932 #define tcg_gen_st16_tl tcg_gen_st16_i64
1933 #define tcg_gen_st32_tl tcg_gen_st32_i64
1934 #define tcg_gen_st_tl tcg_gen_st_i64
1935 #define tcg_gen_add_tl tcg_gen_add_i64
1936 #define tcg_gen_addi_tl tcg_gen_addi_i64
1937 #define tcg_gen_sub_tl tcg_gen_sub_i64
1938 #define tcg_gen_neg_tl tcg_gen_neg_i64
1939 #define tcg_gen_subfi_tl tcg_gen_subfi_i64
1940 #define tcg_gen_subi_tl tcg_gen_subi_i64
1941 #define tcg_gen_and_tl tcg_gen_and_i64
1942 #define tcg_gen_andi_tl tcg_gen_andi_i64
1943 #define tcg_gen_or_tl tcg_gen_or_i64
1944 #define tcg_gen_ori_tl tcg_gen_ori_i64
1945 #define tcg_gen_xor_tl tcg_gen_xor_i64
1946 #define tcg_gen_xori_tl tcg_gen_xori_i64
1947 #define tcg_gen_not_tl tcg_gen_not_i64
1948 #define tcg_gen_shl_tl tcg_gen_shl_i64
1949 #define tcg_gen_shli_tl tcg_gen_shli_i64
1950 #define tcg_gen_shr_tl tcg_gen_shr_i64
1951 #define tcg_gen_shri_tl tcg_gen_shri_i64
1952 #define tcg_gen_sar_tl tcg_gen_sar_i64
1953 #define tcg_gen_sari_tl tcg_gen_sari_i64
1954 #define tcg_gen_brcond_tl tcg_gen_brcond_i64
1955 #define tcg_gen_brcondi_tl tcg_gen_brcondi_i64
1956 #define tcg_gen_mul_tl tcg_gen_mul_i64
1957 #define tcg_gen_muli_tl tcg_gen_muli_i64
1958 #define tcg_gen_discard_tl tcg_gen_discard_i64
1959 #define tcg_gen_trunc_tl_i32 tcg_gen_trunc_i64_i32
1960 #define tcg_gen_trunc_i64_tl tcg_gen_mov_i64
1961 #define tcg_gen_extu_i32_tl tcg_gen_extu_i32_i64
1962 #define tcg_gen_ext_i32_tl tcg_gen_ext_i32_i64
1963 #define tcg_gen_extu_tl_i64 tcg_gen_mov_i64
1964 #define tcg_gen_ext_tl_i64 tcg_gen_mov_i64
1965 #define tcg_gen_ext8u_tl tcg_gen_ext8u_i64
1966 #define tcg_gen_ext8s_tl tcg_gen_ext8s_i64
1967 #define tcg_gen_ext16u_tl tcg_gen_ext16u_i64
1968 #define tcg_gen_ext16s_tl tcg_gen_ext16s_i64
1969 #define tcg_gen_ext32u_tl tcg_gen_ext32u_i64
1970 #define tcg_gen_ext32s_tl tcg_gen_ext32s_i64
1971 #define tcg_gen_concat_tl_i64 tcg_gen_concat32_i64
1972 #define tcg_gen_andc_tl tcg_gen_andc_i64
1973 #define tcg_gen_eqv_tl tcg_gen_eqv_i64
1974 #define tcg_gen_nand_tl tcg_gen_nand_i64
1975 #define tcg_gen_nor_tl tcg_gen_nor_i64
1976 #define tcg_gen_orc_tl tcg_gen_orc_i64
1977 #define tcg_gen_rotl_tl tcg_gen_rotl_i64
1978 #define tcg_gen_rotli_tl tcg_gen_rotli_i64
1979 #define tcg_gen_rotr_tl tcg_gen_rotr_i64
1980 #define tcg_gen_rotri_tl tcg_gen_rotri_i64
1981 #define tcg_const_tl tcg_const_i64
1982 #define tcg_const_local_tl tcg_const_local_i64
1983 #else
1984 #define TCG_TYPE_TL TCG_TYPE_I32
1985 #define tcg_gen_movi_tl tcg_gen_movi_i32
1986 #define tcg_gen_mov_tl tcg_gen_mov_i32
1987 #define tcg_gen_ld8u_tl tcg_gen_ld8u_i32
1988 #define tcg_gen_ld8s_tl tcg_gen_ld8s_i32
1989 #define tcg_gen_ld16u_tl tcg_gen_ld16u_i32
1990 #define tcg_gen_ld16s_tl tcg_gen_ld16s_i32
1991 #define tcg_gen_ld32u_tl tcg_gen_ld_i32
1992 #define tcg_gen_ld32s_tl tcg_gen_ld_i32
1993 #define tcg_gen_ld_tl tcg_gen_ld_i32
1994 #define tcg_gen_st8_tl tcg_gen_st8_i32
1995 #define tcg_gen_st16_tl tcg_gen_st16_i32
1996 #define tcg_gen_st32_tl tcg_gen_st_i32
1997 #define tcg_gen_st_tl tcg_gen_st_i32
1998 #define tcg_gen_add_tl tcg_gen_add_i32
1999 #define tcg_gen_addi_tl tcg_gen_addi_i32
2000 #define tcg_gen_sub_tl tcg_gen_sub_i32
2001 #define tcg_gen_neg_tl tcg_gen_neg_i32
2002 #define tcg_gen_subfi_tl tcg_gen_subfi_i32
2003 #define tcg_gen_subi_tl tcg_gen_subi_i32
2004 #define tcg_gen_and_tl tcg_gen_and_i32
2005 #define tcg_gen_andi_tl tcg_gen_andi_i32
2006 #define tcg_gen_or_tl tcg_gen_or_i32
2007 #define tcg_gen_ori_tl tcg_gen_ori_i32
2008 #define tcg_gen_xor_tl tcg_gen_xor_i32
2009 #define tcg_gen_xori_tl tcg_gen_xori_i32
2010 #define tcg_gen_not_tl tcg_gen_not_i32
2011 #define tcg_gen_shl_tl tcg_gen_shl_i32
2012 #define tcg_gen_shli_tl tcg_gen_shli_i32
2013 #define tcg_gen_shr_tl tcg_gen_shr_i32
2014 #define tcg_gen_shri_tl tcg_gen_shri_i32
2015 #define tcg_gen_sar_tl tcg_gen_sar_i32
2016 #define tcg_gen_sari_tl tcg_gen_sari_i32
2017 #define tcg_gen_brcond_tl tcg_gen_brcond_i32
2018 #define tcg_gen_brcondi_tl tcg_gen_brcondi_i32
2019 #define tcg_gen_mul_tl tcg_gen_mul_i32
2020 #define tcg_gen_muli_tl tcg_gen_muli_i32
2021 #define tcg_gen_discard_tl tcg_gen_discard_i32
2022 #define tcg_gen_trunc_tl_i32 tcg_gen_mov_i32
2023 #define tcg_gen_trunc_i64_tl tcg_gen_trunc_i64_i32
2024 #define tcg_gen_extu_i32_tl tcg_gen_mov_i32
2025 #define tcg_gen_ext_i32_tl tcg_gen_mov_i32
2026 #define tcg_gen_extu_tl_i64 tcg_gen_extu_i32_i64
2027 #define tcg_gen_ext_tl_i64 tcg_gen_ext_i32_i64
2028 #define tcg_gen_ext8u_tl tcg_gen_ext8u_i32
2029 #define tcg_gen_ext8s_tl tcg_gen_ext8s_i32
2030 #define tcg_gen_ext16u_tl tcg_gen_ext16u_i32
2031 #define tcg_gen_ext16s_tl tcg_gen_ext16s_i32
2032 #define tcg_gen_ext32u_tl tcg_gen_mov_i32
2033 #define tcg_gen_ext32s_tl tcg_gen_mov_i32
2034 #define tcg_gen_concat_tl_i64 tcg_gen_concat_i32_i64
2035 #define tcg_gen_andc_tl tcg_gen_andc_i32
2036 #define tcg_gen_eqv_tl tcg_gen_eqv_i32
2037 #define tcg_gen_nand_tl tcg_gen_nand_i32
2038 #define tcg_gen_nor_tl tcg_gen_nor_i32
2039 #define tcg_gen_orc_tl tcg_gen_orc_i32
2040 #define tcg_gen_rotl_tl tcg_gen_rotl_i32
2041 #define tcg_gen_rotli_tl tcg_gen_rotli_i32
2042 #define tcg_gen_rotr_tl tcg_gen_rotr_i32
2043 #define tcg_gen_rotri_tl tcg_gen_rotri_i32
2044 #define tcg_const_tl tcg_const_i32
2045 #define tcg_const_local_tl tcg_const_local_i32
2046 #endif
2047
2048 #if TCG_TARGET_REG_BITS == 32
2049 #define tcg_gen_add_ptr tcg_gen_add_i32
2050 #define tcg_gen_addi_ptr tcg_gen_addi_i32
2051 #define tcg_gen_ext_i32_ptr tcg_gen_mov_i32
2052 #else /* TCG_TARGET_REG_BITS == 32 */
2053 #define tcg_gen_add_ptr tcg_gen_add_i64
2054 #define tcg_gen_addi_ptr tcg_gen_addi_i64
2055 #define tcg_gen_ext_i32_ptr tcg_gen_ext_i32_i64
2056 #endif /* TCG_TARGET_REG_BITS != 32 */