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