tcg/tcg.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 "qemu-common.h"
  25
  26 #include "tcg-target.h"
  27
  28 /* Default target word size to pointer size.  */
  29 #ifndef TCG_TARGET_REG_BITS
  30 # if UINTPTR_MAX == UINT32_MAX
  31 #  define TCG_TARGET_REG_BITS 32
  32 # elif UINTPTR_MAX == UINT64_MAX
  33 #  define TCG_TARGET_REG_BITS 64
  34 # else
  35 #  error Unknown pointer size for tcg target
  36 # endif
  37 #endif
  38
  39 #if TCG_TARGET_REG_BITS == 32
  40 typedef int32_t tcg_target_long;
  41 typedef uint32_t tcg_target_ulong;
  42 #define TCG_PRIlx PRIx32
  43 #define TCG_PRIld PRId32
  44 #elif TCG_TARGET_REG_BITS == 64
  45 typedef int64_t tcg_target_long;
  46 typedef uint64_t tcg_target_ulong;
  47 #define TCG_PRIlx PRIx64
  48 #define TCG_PRIld PRId64
  49 #else
  50 #error unsupported
  51 #endif
  52
  53 #include "tcg-runtime.h"
  54
  55 #if TCG_TARGET_NB_REGS <= 32
  56 typedef uint32_t TCGRegSet;
  57 #elif TCG_TARGET_NB_REGS <= 64
  58 typedef uint64_t TCGRegSet;
  59 #else
  60 #error unsupported
  61 #endif
  62
  63 #if TCG_TARGET_REG_BITS == 32
  64 /* Turn some undef macros into false macros.  */
  65 #define TCG_TARGET_HAS_div_i64          0
  66 #define TCG_TARGET_HAS_rem_i64          0
  67 #define TCG_TARGET_HAS_div2_i64         0
  68 #define TCG_TARGET_HAS_rot_i64          0
  69 #define TCG_TARGET_HAS_ext8s_i64        0
  70 #define TCG_TARGET_HAS_ext16s_i64       0
  71 #define TCG_TARGET_HAS_ext32s_i64       0
  72 #define TCG_TARGET_HAS_ext8u_i64        0
  73 #define TCG_TARGET_HAS_ext16u_i64       0
  74 #define TCG_TARGET_HAS_ext32u_i64       0
  75 #define TCG_TARGET_HAS_bswap16_i64      0
  76 #define TCG_TARGET_HAS_bswap32_i64      0
  77 #define TCG_TARGET_HAS_bswap64_i64      0
  78 #define TCG_TARGET_HAS_neg_i64          0
  79 #define TCG_TARGET_HAS_not_i64          0
  80 #define TCG_TARGET_HAS_andc_i64         0
  81 #define TCG_TARGET_HAS_orc_i64          0
  82 #define TCG_TARGET_HAS_eqv_i64          0
  83 #define TCG_TARGET_HAS_nand_i64         0
  84 #define TCG_TARGET_HAS_nor_i64          0
  85 #define TCG_TARGET_HAS_deposit_i64      0
  86 #define TCG_TARGET_HAS_movcond_i64      0
  87 #define TCG_TARGET_HAS_add2_i64         0
  88 #define TCG_TARGET_HAS_sub2_i64         0
  89 #define TCG_TARGET_HAS_mulu2_i64        0
  90 #define TCG_TARGET_HAS_muls2_i64        0
  91 #define TCG_TARGET_HAS_muluh_i64        0
  92 #define TCG_TARGET_HAS_mulsh_i64        0
  93 /* Turn some undef macros into true macros.  */
  94 #define TCG_TARGET_HAS_add2_i32         1
  95 #define TCG_TARGET_HAS_sub2_i32         1
  96 #define TCG_TARGET_HAS_mulu2_i32        1
  97 #endif
  98
  99 #ifndef TCG_TARGET_deposit_i32_valid
 100 #define TCG_TARGET_deposit_i32_valid(ofs, len) 1
 101 #endif
 102 #ifndef TCG_TARGET_deposit_i64_valid
 103 #define TCG_TARGET_deposit_i64_valid(ofs, len) 1
 104 #endif
 105
 106 /* Only one of DIV or DIV2 should be defined.  */
 107 #if defined(TCG_TARGET_HAS_div_i32)
 108 #define TCG_TARGET_HAS_div2_i32         0
 109 #elif defined(TCG_TARGET_HAS_div2_i32)
 110 #define TCG_TARGET_HAS_div_i32          0
 111 #define TCG_TARGET_HAS_rem_i32          0
 112 #endif
 113 #if defined(TCG_TARGET_HAS_div_i64)
 114 #define TCG_TARGET_HAS_div2_i64         0
 115 #elif defined(TCG_TARGET_HAS_div2_i64)
 116 #define TCG_TARGET_HAS_div_i64          0
 117 #define TCG_TARGET_HAS_rem_i64          0
 118 #endif
 119
 120 typedef enum TCGOpcode {
 121 #define DEF(name, oargs, iargs, cargs, flags) INDEX_op_ ## name,
 122 #include "tcg-opc.h"
 123 #undef DEF
 124     NB_OPS,
 125 } TCGOpcode;
 126
 127 #define tcg_regset_clear(d) (d) = 0
 128 #define tcg_regset_set(d, s) (d) = (s)
 129 #define tcg_regset_set32(d, reg, val32) (d) |= (val32) << (reg)
 130 #define tcg_regset_set_reg(d, r) (d) |= 1L << (r)
 131 #define tcg_regset_reset_reg(d, r) (d) &= ~(1L << (r))
 132 #define tcg_regset_test_reg(d, r) (((d) >> (r)) & 1)
 133 #define tcg_regset_or(d, a, b) (d) = (a) | (b)
 134 #define tcg_regset_and(d, a, b) (d) = (a) & (b)
 135 #define tcg_regset_andnot(d, a, b) (d) = (a) & ~(b)
 136 #define tcg_regset_not(d, a) (d) = ~(a)
 137
 138 typedef struct TCGRelocation {
 139     struct TCGRelocation *next;
 140     int type;
 141     uint8_t *ptr;
 142     tcg_target_long addend;
 143 } TCGRelocation;
 144
 145 typedef struct TCGLabel {
 146     int has_value;
 147     union {
 148         tcg_target_ulong value;
 149         TCGRelocation *first_reloc;
 150     } u;
 151 } TCGLabel;
 152
 153 typedef struct TCGPool {
 154     struct TCGPool *next;
 155     int size;
 156     uint8_t data[0] __attribute__ ((aligned));
 157 } TCGPool;
 158
 159 #define TCG_POOL_CHUNK_SIZE 32768
 160
 161 #define TCG_MAX_LABELS 512
 162
 163 #define TCG_MAX_TEMPS 512
 164
 165 /* when the size of the arguments of a called function is smaller than
 166    this value, they are statically allocated in the TB stack frame */
 167 #define TCG_STATIC_CALL_ARGS_SIZE 128
 168
 169 typedef enum TCGType {
 170     TCG_TYPE_I32,
 171     TCG_TYPE_I64,
 172     TCG_TYPE_COUNT, /* number of different types */
 173
 174     /* An alias for the size of the host register.  */
 175 #if TCG_TARGET_REG_BITS == 32
 176     TCG_TYPE_REG = TCG_TYPE_I32,
 177 #else
 178     TCG_TYPE_REG = TCG_TYPE_I64,
 179 #endif
 180
 181     /* An alias for the size of the native pointer.  */
 182 #if UINTPTR_MAX == UINT32_MAX
 183     TCG_TYPE_PTR = TCG_TYPE_I32,
 184 #else
 185     TCG_TYPE_PTR = TCG_TYPE_I64,
 186 #endif
 187
 188     /* An alias for the size of the target "long", aka register.  */
 189 #if TARGET_LONG_BITS == 64
 190     TCG_TYPE_TL = TCG_TYPE_I64,
 191 #else
 192     TCG_TYPE_TL = TCG_TYPE_I32,
 193 #endif
 194 } TCGType;
 195
 196 typedef tcg_target_ulong TCGArg;
 197
 198 /* Define a type and accessor macros for variables.  Using a struct is
 199    nice because it gives some level of type safely.  Ideally the compiler
 200    be able to see through all this.  However in practice this is not true,
 201    especially on targets with braindamaged ABIs (e.g. i386).
 202    We use plain int by default to avoid this runtime overhead.
 203    Users of tcg_gen_* don't need to know about any of this, and should
 204    treat TCGv as an opaque type.
 205    In addition we do typechecking for different types of variables.  TCGv_i32
 206    and TCGv_i64 are 32/64-bit variables respectively.  TCGv and TCGv_ptr
 207    are aliases for target_ulong and host pointer sized values respectively.
 208  */
 209
 210 #if defined(CONFIG_QEMU_LDST_OPTIMIZATION) && defined(CONFIG_SOFTMMU)
 211 /* Macros/structures for qemu_ld/st IR code optimization:
 212    TCG_MAX_HELPER_LABELS is defined as same as OPC_BUF_SIZE in exec-all.h. */
 213 #define TCG_MAX_QEMU_LDST       640
 214
 215 typedef struct TCGLabelQemuLdst {
 216     int is_ld:1;            /* qemu_ld: 1, qemu_st: 0 */
 217     int opc:4;
 218     int addrlo_reg;         /* reg index for low word of guest virtual addr */
 219     int addrhi_reg;         /* reg index for high word of guest virtual addr */
 220     int datalo_reg;         /* reg index for low word to be loaded or stored */
 221     int datahi_reg;         /* reg index for high word to be loaded or stored */
 222     int mem_index;          /* soft MMU memory index */
 223     uint8_t *raddr;         /* gen code addr of the next IR of qemu_ld/st IR */
 224     uint8_t *label_ptr[2];  /* label pointers to be updated */
 225 } TCGLabelQemuLdst;
 226 #endif
 227
 228 #ifdef CONFIG_DEBUG_TCG
 229 #define DEBUG_TCGV 1
 230 #endif
 231
 232 #ifdef DEBUG_TCGV
 233
 234 typedef struct
 235 {
 236     int i32;
 237 } TCGv_i32;
 238
 239 typedef struct
 240 {
 241     int i64;
 242 } TCGv_i64;
 243
 244 typedef struct {
 245     int iptr;
 246 } TCGv_ptr;
 247
 248 #define MAKE_TCGV_I32(i) __extension__                  \
 249     ({ TCGv_i32 make_tcgv_tmp = {i}; make_tcgv_tmp;})
 250 #define MAKE_TCGV_I64(i) __extension__                  \
 251     ({ TCGv_i64 make_tcgv_tmp = {i}; make_tcgv_tmp;})
 252 #define MAKE_TCGV_PTR(i) __extension__                  \
 253     ({ TCGv_ptr make_tcgv_tmp = {i}; make_tcgv_tmp; })
 254 #define GET_TCGV_I32(t) ((t).i32)
 255 #define GET_TCGV_I64(t) ((t).i64)
 256 #define GET_TCGV_PTR(t) ((t).iptr)
 257 #if TCG_TARGET_REG_BITS == 32
 258 #define TCGV_LOW(t) MAKE_TCGV_I32(GET_TCGV_I64(t))
 259 #define TCGV_HIGH(t) MAKE_TCGV_I32(GET_TCGV_I64(t) + 1)
 260 #endif
 261
 262 #else /* !DEBUG_TCGV */
 263
 264 typedef int TCGv_i32;
 265 typedef int TCGv_i64;
 266 #if TCG_TARGET_REG_BITS == 32
 267 #define TCGv_ptr TCGv_i32
 268 #else
 269 #define TCGv_ptr TCGv_i64
 270 #endif
 271 #define MAKE_TCGV_I32(x) (x)
 272 #define MAKE_TCGV_I64(x) (x)
 273 #define MAKE_TCGV_PTR(x) (x)
 274 #define GET_TCGV_I32(t) (t)
 275 #define GET_TCGV_I64(t) (t)
 276 #define GET_TCGV_PTR(t) (t)
 277
 278 #if TCG_TARGET_REG_BITS == 32
 279 #define TCGV_LOW(t) (t)
 280 #define TCGV_HIGH(t) ((t) + 1)
 281 #endif
 282
 283 #endif /* DEBUG_TCGV */
 284
 285 #define TCGV_EQUAL_I32(a, b) (GET_TCGV_I32(a) == GET_TCGV_I32(b))
 286 #define TCGV_EQUAL_I64(a, b) (GET_TCGV_I64(a) == GET_TCGV_I64(b))
 287
 288 /* Dummy definition to avoid compiler warnings.  */
 289 #define TCGV_UNUSED_I32(x) x = MAKE_TCGV_I32(-1)
 290 #define TCGV_UNUSED_I64(x) x = MAKE_TCGV_I64(-1)
 291
 292 #define TCGV_IS_UNUSED_I32(x) (GET_TCGV_I32(x) == -1)
 293 #define TCGV_IS_UNUSED_I64(x) (GET_TCGV_I64(x) == -1)
 294
 295 /* call flags */
 296 /* Helper does not read globals (either directly or through an exception). It
 297    implies TCG_CALL_NO_WRITE_GLOBALS. */
 298 #define TCG_CALL_NO_READ_GLOBALS    0x0010
 299 /* Helper does not write globals */
 300 #define TCG_CALL_NO_WRITE_GLOBALS   0x0020
 301 /* Helper can be safely suppressed if the return value is not used. */
 302 #define TCG_CALL_NO_SIDE_EFFECTS    0x0040
 303
 304 /* convenience version of most used call flags */
 305 #define TCG_CALL_NO_RWG         TCG_CALL_NO_READ_GLOBALS
 306 #define TCG_CALL_NO_WG          TCG_CALL_NO_WRITE_GLOBALS
 307 #define TCG_CALL_NO_SE          TCG_CALL_NO_SIDE_EFFECTS
 308 #define TCG_CALL_NO_RWG_SE      (TCG_CALL_NO_RWG | TCG_CALL_NO_SE)
 309 #define TCG_CALL_NO_WG_SE       (TCG_CALL_NO_WG | TCG_CALL_NO_SE)
 310
 311 /* used to align parameters */
 312 #define TCG_CALL_DUMMY_TCGV     MAKE_TCGV_I32(-1)
 313 #define TCG_CALL_DUMMY_ARG      ((TCGArg)(-1))
 314
 315 /* Conditions.  Note that these are laid out for easy manipulation by
 316    the functions below:
 317      bit 0 is used for inverting;
 318      bit 1 is signed,
 319      bit 2 is unsigned,
 320      bit 3 is used with bit 0 for swapping signed/unsigned.  */
 321 typedef enum {
 322     /* non-signed */
 323     TCG_COND_NEVER  = 0 | 0 | 0 | 0,
 324     TCG_COND_ALWAYS = 0 | 0 | 0 | 1,
 325     TCG_COND_EQ     = 8 | 0 | 0 | 0,
 326     TCG_COND_NE     = 8 | 0 | 0 | 1,
 327     /* signed */
 328     TCG_COND_LT     = 0 | 0 | 2 | 0,
 329     TCG_COND_GE     = 0 | 0 | 2 | 1,
 330     TCG_COND_LE     = 8 | 0 | 2 | 0,
 331     TCG_COND_GT     = 8 | 0 | 2 | 1,
 332     /* unsigned */
 333     TCG_COND_LTU    = 0 | 4 | 0 | 0,
 334     TCG_COND_GEU    = 0 | 4 | 0 | 1,
 335     TCG_COND_LEU    = 8 | 4 | 0 | 0,
 336     TCG_COND_GTU    = 8 | 4 | 0 | 1,
 337 } TCGCond;
 338
 339 /* Invert the sense of the comparison.  */
 340 static inline TCGCond tcg_invert_cond(TCGCond c)
 341 {
 342     return (TCGCond)(c ^ 1);
 343 }
 344
 345 /* Swap the operands in a comparison.  */
 346 static inline TCGCond tcg_swap_cond(TCGCond c)
 347 {
 348     return c & 6 ? (TCGCond)(c ^ 9) : c;
 349 }
 350
 351 /* Create an "unsigned" version of a "signed" comparison.  */
 352 static inline TCGCond tcg_unsigned_cond(TCGCond c)
 353 {
 354     return c & 2 ? (TCGCond)(c ^ 6) : c;
 355 }
 356
 357 /* Must a comparison be considered unsigned?  */
 358 static inline bool is_unsigned_cond(TCGCond c)
 359 {
 360     return (c & 4) != 0;
 361 }
 362
 363 /* Create a "high" version of a double-word comparison.
 364    This removes equality from a LTE or GTE comparison.  */
 365 static inline TCGCond tcg_high_cond(TCGCond c)
 366 {
 367     switch (c) {
 368     case TCG_COND_GE:
 369     case TCG_COND_LE:
 370     case TCG_COND_GEU:
 371     case TCG_COND_LEU:
 372         return (TCGCond)(c ^ 8);
 373     default:
 374         return c;
 375     }
 376 }
 377
 378 #define TEMP_VAL_DEAD  0
 379 #define TEMP_VAL_REG   1
 380 #define TEMP_VAL_MEM   2
 381 #define TEMP_VAL_CONST 3
 382
 383 /* XXX: optimize memory layout */
 384 typedef struct TCGTemp {
 385     TCGType base_type;
 386     TCGType type;
 387     int val_type;
 388     int reg;
 389     tcg_target_long val;
 390     int mem_reg;
 391     tcg_target_long mem_offset;
 392     unsigned int fixed_reg:1;
 393     unsigned int mem_coherent:1;
 394     unsigned int mem_allocated:1;
 395     unsigned int temp_local:1; /* If true, the temp is saved across
 396                                   basic blocks. Otherwise, it is not
 397                                   preserved across basic blocks. */
 398     unsigned int temp_allocated:1; /* never used for code gen */
 399     /* index of next free temp of same base type, -1 if end */
 400     int next_free_temp;
 401     const char *name;
 402 } TCGTemp;
 403
 404 typedef struct TCGHelperInfo {
 405     tcg_target_ulong func;
 406     const char *name;
 407 } TCGHelperInfo;
 408
 409 typedef struct TCGContext TCGContext;
 410
 411 struct TCGContext {
 412     uint8_t *pool_cur, *pool_end;
 413     TCGPool *pool_first, *pool_current, *pool_first_large;
 414     TCGLabel *labels;
 415     int nb_labels;
 416     int nb_globals;
 417     int nb_temps;
 418     /* index of free temps, -1 if none */
 419     int first_free_temp[TCG_TYPE_COUNT * 2];
 420
 421     /* goto_tb support */
 422     uint8_t *code_buf;
 423     uintptr_t *tb_next;
 424     uint16_t *tb_next_offset;
 425     uint16_t *tb_jmp_offset; /* != NULL if USE_DIRECT_JUMP */
 426
 427     /* liveness analysis */
 428     uint16_t *op_dead_args; /* for each operation, each bit tells if the
 429                                corresponding argument is dead */
 430     uint8_t *op_sync_args;  /* for each operation, each bit tells if the
 431                                corresponding output argument needs to be
 432                                sync to memory. */
 433
 434     /* tells in which temporary a given register is. It does not take
 435        into account fixed registers */
 436     int reg_to_temp[TCG_TARGET_NB_REGS];
 437     TCGRegSet reserved_regs;
 438     tcg_target_long current_frame_offset;
 439     tcg_target_long frame_start;
 440     tcg_target_long frame_end;
 441     int frame_reg;
 442
 443     uint8_t *code_ptr;
 444     TCGTemp temps[TCG_MAX_TEMPS]; /* globals first, temps after */
 445
 446     TCGHelperInfo *helpers;
 447     int nb_helpers;
 448     int allocated_helpers;
 449     int helpers_sorted;
 450
 451 #ifdef CONFIG_PROFILER
 452     /* profiling info */
 453     int64_t tb_count1;
 454     int64_t tb_count;
 455     int64_t op_count; /* total insn count */
 456     int op_count_max; /* max insn per TB */
 457     int64_t temp_count;
 458     int temp_count_max;
 459     int64_t del_op_count;
 460     int64_t code_in_len;
 461     int64_t code_out_len;
 462     int64_t interm_time;
 463     int64_t code_time;
 464     int64_t la_time;
 465     int64_t opt_time;
 466     int64_t restore_count;
 467     int64_t restore_time;
 468 #endif
 469
 470 #ifdef CONFIG_DEBUG_TCG
 471     int temps_in_use;
 472     int goto_tb_issue_mask;
 473 #endif
 474
 475     uint16_t gen_opc_buf[OPC_BUF_SIZE];
 476     TCGArg gen_opparam_buf[OPPARAM_BUF_SIZE];
 477
 478     uint16_t *gen_opc_ptr;
 479     TCGArg *gen_opparam_ptr;
 480     target_ulong gen_opc_pc[OPC_BUF_SIZE];
 481     uint16_t gen_opc_icount[OPC_BUF_SIZE];
 482     uint8_t gen_opc_instr_start[OPC_BUF_SIZE];
 483
 484     /* Code generation */
 485     int code_gen_max_blocks;
 486     uint8_t *code_gen_prologue;
 487     uint8_t *code_gen_buffer;
 488     size_t code_gen_buffer_size;
 489     /* threshold to flush the translated code buffer */
 490     size_t code_gen_buffer_max_size;
 491     uint8_t *code_gen_ptr;
 492
 493     TBContext tb_ctx;
 494
 495 #if defined(CONFIG_QEMU_LDST_OPTIMIZATION) && defined(CONFIG_SOFTMMU)
 496     /* labels info for qemu_ld/st IRs
 497        The labels help to generate TLB miss case codes at the end of TB */
 498     TCGLabelQemuLdst *qemu_ldst_labels;
 499     int nb_qemu_ldst_labels;
 500 #endif
 501 };
 502
 503 extern TCGContext tcg_ctx;
 504
 505 /* pool based memory allocation */
 506
 507 void *tcg_malloc_internal(TCGContext *s, int size);
 508 void tcg_pool_reset(TCGContext *s);
 509 void tcg_pool_delete(TCGContext *s);
 510
 511 static inline void *tcg_malloc(int size)
 512 {
 513     TCGContext *s = &tcg_ctx;
 514     uint8_t *ptr, *ptr_end;
 515     size = (size + sizeof(long) - 1) & ~(sizeof(long) - 1);
 516     ptr = s->pool_cur;
 517     ptr_end = ptr + size;
 518     if (unlikely(ptr_end > s->pool_end)) {
 519         return tcg_malloc_internal(&tcg_ctx, size);
 520     } else {
 521         s->pool_cur = ptr_end;
 522         return ptr;
 523     }
 524 }
 525
 526 void tcg_context_init(TCGContext *s);
 527 void tcg_prologue_init(TCGContext *s);
 528 void tcg_func_start(TCGContext *s);
 529
 530 int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf);
 531 int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset);
 532
 533 void tcg_set_frame(TCGContext *s, int reg,
 534                    tcg_target_long start, tcg_target_long size);
 535
 536 TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name);
 537 TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset,
 538                                 const char *name);
 539 TCGv_i32 tcg_temp_new_internal_i32(int temp_local);
 540 static inline TCGv_i32 tcg_temp_new_i32(void)
 541 {
 542     return tcg_temp_new_internal_i32(0);
 543 }
 544 static inline TCGv_i32 tcg_temp_local_new_i32(void)
 545 {
 546     return tcg_temp_new_internal_i32(1);
 547 }
 548 void tcg_temp_free_i32(TCGv_i32 arg);
 549 char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg);
 550
 551 TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name);
 552 TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset,
 553                                 const char *name);
 554 TCGv_i64 tcg_temp_new_internal_i64(int temp_local);
 555 static inline TCGv_i64 tcg_temp_new_i64(void)
 556 {
 557     return tcg_temp_new_internal_i64(0);
 558 }
 559 static inline TCGv_i64 tcg_temp_local_new_i64(void)
 560 {
 561     return tcg_temp_new_internal_i64(1);
 562 }
 563 void tcg_temp_free_i64(TCGv_i64 arg);
 564 char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg);
 565
 566 #if defined(CONFIG_DEBUG_TCG)
 567 /* If you call tcg_clear_temp_count() at the start of a section of
 568  * code which is not supposed to leak any TCG temporaries, then
 569  * calling tcg_check_temp_count() at the end of the section will
 570  * return 1 if the section did in fact leak a temporary.
 571  */
 572 void tcg_clear_temp_count(void);
 573 int tcg_check_temp_count(void);
 574 #else
 575 #define tcg_clear_temp_count() do { } while (0)
 576 #define tcg_check_temp_count() 0
 577 #endif
 578
 579 void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf);
 580
 581 #define TCG_CT_ALIAS  0x80
 582 #define TCG_CT_IALIAS 0x40
 583 #define TCG_CT_REG    0x01
 584 #define TCG_CT_CONST  0x02 /* any constant of register size */
 585
 586 typedef struct TCGArgConstraint {
 587     uint16_t ct;
 588     uint8_t alias_index;
 589     union {
 590         TCGRegSet regs;
 591     } u;
 592 } TCGArgConstraint;
 593
 594 #define TCG_MAX_OP_ARGS 16
 595
 596 /* Bits for TCGOpDef->flags, 8 bits available.  */
 597 enum {
 598     /* Instruction defines the end of a basic block.  */
 599     TCG_OPF_BB_END       = 0x01,
 600     /* Instruction clobbers call registers and potentially update globals.  */
 601     TCG_OPF_CALL_CLOBBER = 0x02,
 602     /* Instruction has side effects: it cannot be removed if its outputs
 603        are not used, and might trigger exceptions.  */
 604     TCG_OPF_SIDE_EFFECTS = 0x04,
 605     /* Instruction operands are 64-bits (otherwise 32-bits).  */
 606     TCG_OPF_64BIT        = 0x08,
 607     /* Instruction is optional and not implemented by the host, or insn
 608        is generic and should not be implemened by the host.  */
 609     TCG_OPF_NOT_PRESENT  = 0x10,
 610 };
 611
 612 typedef struct TCGOpDef {
 613     const char *name;
 614     uint8_t nb_oargs, nb_iargs, nb_cargs, nb_args;
 615     uint8_t flags;
 616     TCGArgConstraint *args_ct;
 617     int *sorted_args;
 618 #if defined(CONFIG_DEBUG_TCG)
 619     int used;
 620 #endif
 621 } TCGOpDef;
 622
 623 extern TCGOpDef tcg_op_defs[];
 624 extern const size_t tcg_op_defs_max;
 625
 626 typedef struct TCGTargetOpDef {
 627     TCGOpcode op;
 628     const char *args_ct_str[TCG_MAX_OP_ARGS];
 629 } TCGTargetOpDef;
 630
 631 #define tcg_abort() \
 632 do {\
 633     fprintf(stderr, "%s:%d: tcg fatal error\n", __FILE__, __LINE__);\
 634     abort();\
 635 } while (0)
 636
 637 #ifdef CONFIG_DEBUG_TCG
 638 # define tcg_debug_assert(X) do { assert(X); } while (0)
 639 #elif QEMU_GNUC_PREREQ(4, 5)
 640 # define tcg_debug_assert(X) \
 641     do { if (!(X)) { __builtin_unreachable(); } } while (0)
 642 #else
 643 # define tcg_debug_assert(X) do { (void)(X); } while (0)
 644 #endif
 645
 646 void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs);
 647
 648 #if UINTPTR_MAX == UINT32_MAX
 649 #define TCGV_NAT_TO_PTR(n) MAKE_TCGV_PTR(GET_TCGV_I32(n))
 650 #define TCGV_PTR_TO_NAT(n) MAKE_TCGV_I32(GET_TCGV_PTR(n))
 651
 652 #define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i32((intptr_t)(V)))
 653 #define tcg_global_reg_new_ptr(R, N) \
 654     TCGV_NAT_TO_PTR(tcg_global_reg_new_i32((R), (N)))
 655 #define tcg_global_mem_new_ptr(R, O, N) \
 656     TCGV_NAT_TO_PTR(tcg_global_mem_new_i32((R), (O), (N)))
 657 #define tcg_temp_new_ptr() TCGV_NAT_TO_PTR(tcg_temp_new_i32())
 658 #define tcg_temp_free_ptr(T) tcg_temp_free_i32(TCGV_PTR_TO_NAT(T))
 659 #else
 660 #define TCGV_NAT_TO_PTR(n) MAKE_TCGV_PTR(GET_TCGV_I64(n))
 661 #define TCGV_PTR_TO_NAT(n) MAKE_TCGV_I64(GET_TCGV_PTR(n))
 662
 663 #define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i64((intptr_t)(V)))
 664 #define tcg_global_reg_new_ptr(R, N) \
 665     TCGV_NAT_TO_PTR(tcg_global_reg_new_i64((R), (N)))
 666 #define tcg_global_mem_new_ptr(R, O, N) \
 667     TCGV_NAT_TO_PTR(tcg_global_mem_new_i64((R), (O), (N)))
 668 #define tcg_temp_new_ptr() TCGV_NAT_TO_PTR(tcg_temp_new_i64())
 669 #define tcg_temp_free_ptr(T) tcg_temp_free_i64(TCGV_PTR_TO_NAT(T))
 670 #endif
 671
 672 void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags,
 673                    int sizemask, TCGArg ret, int nargs, TCGArg *args);
 674
 675 void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1,
 676                         int c, int right, int arith);
 677
 678 TCGArg *tcg_optimize(TCGContext *s, uint16_t *tcg_opc_ptr, TCGArg *args,
 679                      TCGOpDef *tcg_op_def);
 680
 681 /* only used for debugging purposes */
 682 void tcg_register_helper(void *func, const char *name);
 683 const char *tcg_helper_get_name(TCGContext *s, void *func);
 684 void tcg_dump_ops(TCGContext *s);
 685
 686 void dump_ops(const uint16_t *opc_buf, const TCGArg *opparam_buf);
 687 TCGv_i32 tcg_const_i32(int32_t val);
 688 TCGv_i64 tcg_const_i64(int64_t val);
 689 TCGv_i32 tcg_const_local_i32(int32_t val);
 690 TCGv_i64 tcg_const_local_i64(int64_t val);
 691
 692 /**
 693  * tcg_qemu_tb_exec:
 694  * @env: CPUArchState * for the CPU
 695  * @tb_ptr: address of generated code for the TB to execute
 696  *
 697  * Start executing code from a given translation block.
 698  * Where translation blocks have been linked, execution
 699  * may proceed from the given TB into successive ones.
 700  * Control eventually returns only when some action is needed
 701  * from the top-level loop: either control must pass to a TB
 702  * which has not yet been directly linked, or an asynchronous
 703  * event such as an interrupt needs handling.
 704  *
 705  * The return value is a pointer to the next TB to execute
 706  * (if known; otherwise zero). This pointer is assumed to be
 707  * 4-aligned, and the bottom two bits are used to return further
 708  * information:
 709  *  0, 1: the link between this TB and the next is via the specified
 710  *        TB index (0 or 1). That is, we left the TB via (the equivalent
 711  *        of) "goto_tb <index>". The main loop uses this to determine
 712  *        how to link the TB just executed to the next.
 713  *  2:    we are using instruction counting code generation, and we
 714  *        did not start executing this TB because the instruction counter
 715  *        would hit zero midway through it. In this case the next-TB pointer
 716  *        returned is the TB we were about to execute, and the caller must
 717  *        arrange to execute the remaining count of instructions.
 718  *  3:    we stopped because the CPU's exit_request flag was set
 719  *        (usually meaning that there is an interrupt that needs to be
 720  *        handled). The next-TB pointer returned is the TB we were
 721  *        about to execute when we noticed the pending exit request.
 722  *
 723  * If the bottom two bits indicate an exit-via-index then the CPU
 724  * state is correctly synchronised and ready for execution of the next
 725  * TB (and in particular the guest PC is the address to execute next).
 726  * Otherwise, we gave up on execution of this TB before it started, and
 727  * the caller must fix up the CPU state by calling cpu_pc_from_tb()
 728  * with the next-TB pointer we return.
 729  *
 730  * Note that TCG targets may use a different definition of tcg_qemu_tb_exec
 731  * to this default (which just calls the prologue.code emitted by
 732  * tcg_target_qemu_prologue()).
 733  */
 734 #define TB_EXIT_MASK 3
 735 #define TB_EXIT_IDX0 0
 736 #define TB_EXIT_IDX1 1
 737 #define TB_EXIT_ICOUNT_EXPIRED 2
 738 #define TB_EXIT_REQUESTED 3
 739
 740 #if !defined(tcg_qemu_tb_exec)
 741 # define tcg_qemu_tb_exec(env, tb_ptr) \
 742     ((uintptr_t (*)(void *, void *))tcg_ctx.code_gen_prologue)(env, tb_ptr)
 743 #endif
 744
 745 void tcg_register_jit(void *buf, size_t buf_size);
 746
 747 #if defined(CONFIG_QEMU_LDST_OPTIMIZATION) && defined(CONFIG_SOFTMMU)
 748 /* Generate TB finalization at the end of block */
 749 void tcg_out_tb_finalize(TCGContext *s);
 750 #endif