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
  25 #ifndef TCG_H
  26 #define TCG_H
  27
  28 #include "qemu-common.h"
  29 #include "qemu/bitops.h"
  30 #include "tcg-target.h"
  31
  32 /* Default target word size to pointer size.  */
  33 #ifndef TCG_TARGET_REG_BITS
  34 # if UINTPTR_MAX == UINT32_MAX
  35 #  define TCG_TARGET_REG_BITS 32
  36 # elif UINTPTR_MAX == UINT64_MAX
  37 #  define TCG_TARGET_REG_BITS 64
  38 # else
  39 #  error Unknown pointer size for tcg target
  40 # endif
  41 #endif
  42
  43 #if TCG_TARGET_REG_BITS == 32
  44 typedef int32_t tcg_target_long;
  45 typedef uint32_t tcg_target_ulong;
  46 #define TCG_PRIlx PRIx32
  47 #define TCG_PRIld PRId32
  48 #elif TCG_TARGET_REG_BITS == 64
  49 typedef int64_t tcg_target_long;
  50 typedef uint64_t tcg_target_ulong;
  51 #define TCG_PRIlx PRIx64
  52 #define TCG_PRIld PRId64
  53 #else
  54 #error unsupported
  55 #endif
  56
  57 #include "tcg-runtime.h"
  58
  59 #if TCG_TARGET_NB_REGS <= 32
  60 typedef uint32_t TCGRegSet;
  61 #elif TCG_TARGET_NB_REGS <= 64
  62 typedef uint64_t TCGRegSet;
  63 #else
  64 #error unsupported
  65 #endif
  66
  67 #if TCG_TARGET_REG_BITS == 32
  68 /* Turn some undef macros into false macros.  */
  69 #define TCG_TARGET_HAS_trunc_shr_i32    0
  70 #define TCG_TARGET_HAS_div_i64          0
  71 #define TCG_TARGET_HAS_rem_i64          0
  72 #define TCG_TARGET_HAS_div2_i64         0
  73 #define TCG_TARGET_HAS_rot_i64          0
  74 #define TCG_TARGET_HAS_ext8s_i64        0
  75 #define TCG_TARGET_HAS_ext16s_i64       0
  76 #define TCG_TARGET_HAS_ext32s_i64       0
  77 #define TCG_TARGET_HAS_ext8u_i64        0
  78 #define TCG_TARGET_HAS_ext16u_i64       0
  79 #define TCG_TARGET_HAS_ext32u_i64       0
  80 #define TCG_TARGET_HAS_bswap16_i64      0
  81 #define TCG_TARGET_HAS_bswap32_i64      0
  82 #define TCG_TARGET_HAS_bswap64_i64      0
  83 #define TCG_TARGET_HAS_neg_i64          0
  84 #define TCG_TARGET_HAS_not_i64          0
  85 #define TCG_TARGET_HAS_andc_i64         0
  86 #define TCG_TARGET_HAS_orc_i64          0
  87 #define TCG_TARGET_HAS_eqv_i64          0
  88 #define TCG_TARGET_HAS_nand_i64         0
  89 #define TCG_TARGET_HAS_nor_i64          0
  90 #define TCG_TARGET_HAS_deposit_i64      0
  91 #define TCG_TARGET_HAS_movcond_i64      0
  92 #define TCG_TARGET_HAS_add2_i64         0
  93 #define TCG_TARGET_HAS_sub2_i64         0
  94 #define TCG_TARGET_HAS_mulu2_i64        0
  95 #define TCG_TARGET_HAS_muls2_i64        0
  96 #define TCG_TARGET_HAS_muluh_i64        0
  97 #define TCG_TARGET_HAS_mulsh_i64        0
  98 /* Turn some undef macros into true macros.  */
  99 #define TCG_TARGET_HAS_add2_i32         1
 100 #define TCG_TARGET_HAS_sub2_i32         1
 101 #endif
 102
 103 #ifndef TCG_TARGET_deposit_i32_valid
 104 #define TCG_TARGET_deposit_i32_valid(ofs, len) 1
 105 #endif
 106 #ifndef TCG_TARGET_deposit_i64_valid
 107 #define TCG_TARGET_deposit_i64_valid(ofs, len) 1
 108 #endif
 109
 110 /* Only one of DIV or DIV2 should be defined.  */
 111 #if defined(TCG_TARGET_HAS_div_i32)
 112 #define TCG_TARGET_HAS_div2_i32         0
 113 #elif defined(TCG_TARGET_HAS_div2_i32)
 114 #define TCG_TARGET_HAS_div_i32          0
 115 #define TCG_TARGET_HAS_rem_i32          0
 116 #endif
 117 #if defined(TCG_TARGET_HAS_div_i64)
 118 #define TCG_TARGET_HAS_div2_i64         0
 119 #elif defined(TCG_TARGET_HAS_div2_i64)
 120 #define TCG_TARGET_HAS_div_i64          0
 121 #define TCG_TARGET_HAS_rem_i64          0
 122 #endif
 123
 124 /* For 32-bit targets, some sort of unsigned widening multiply is required.  */
 125 #if TCG_TARGET_REG_BITS == 32 \
 126     && !(defined(TCG_TARGET_HAS_mulu2_i32) \
 127          || defined(TCG_TARGET_HAS_muluh_i32))
 128 # error "Missing unsigned widening multiply"
 129 #endif
 130
 131 typedef enum TCGOpcode {
 132 #define DEF(name, oargs, iargs, cargs, flags) INDEX_op_ ## name,
 133 #include "tcg-opc.h"
 134 #undef DEF
 135     NB_OPS,
 136 } TCGOpcode;
 137
 138 #define tcg_regset_clear(d) (d) = 0
 139 #define tcg_regset_set(d, s) (d) = (s)
 140 #define tcg_regset_set32(d, reg, val32) (d) |= (val32) << (reg)
 141 #define tcg_regset_set_reg(d, r) (d) |= 1L << (r)
 142 #define tcg_regset_reset_reg(d, r) (d) &= ~(1L << (r))
 143 #define tcg_regset_test_reg(d, r) (((d) >> (r)) & 1)
 144 #define tcg_regset_or(d, a, b) (d) = (a) | (b)
 145 #define tcg_regset_and(d, a, b) (d) = (a) & (b)
 146 #define tcg_regset_andnot(d, a, b) (d) = (a) & ~(b)
 147 #define tcg_regset_not(d, a) (d) = ~(a)
 148
 149 #ifndef TCG_TARGET_INSN_UNIT_SIZE
 150 #define TCG_TARGET_INSN_UNIT_SIZE 1
 151 #endif
 152 #if TCG_TARGET_INSN_UNIT_SIZE == 1
 153 typedef uint8_t tcg_insn_unit;
 154 #elif TCG_TARGET_INSN_UNIT_SIZE == 2
 155 typedef uint16_t tcg_insn_unit;
 156 #elif TCG_TARGET_INSN_UNIT_SIZE == 4
 157 typedef uint32_t tcg_insn_unit;
 158 #elif TCG_TARGET_INSN_UNIT_SIZE == 8
 159 typedef uint64_t tcg_insn_unit;
 160 #else
 161 /* The port better have done this.  */
 162 #endif
 163
 164
 165 typedef struct TCGRelocation {
 166     struct TCGRelocation *next;
 167     int type;
 168     tcg_insn_unit *ptr;
 169     intptr_t addend;
 170 } TCGRelocation;
 171
 172 typedef struct TCGLabel {
 173     int has_value;
 174     union {
 175         uintptr_t value;
 176         tcg_insn_unit *value_ptr;
 177         TCGRelocation *first_reloc;
 178     } u;
 179 } TCGLabel;
 180
 181 typedef struct TCGPool {
 182     struct TCGPool *next;
 183     int size;
 184     uint8_t data[0] __attribute__ ((aligned));
 185 } TCGPool;
 186
 187 #define TCG_POOL_CHUNK_SIZE 32768
 188
 189 #define TCG_MAX_LABELS 512
 190
 191 #define TCG_MAX_TEMPS 512
 192
 193 /* when the size of the arguments of a called function is smaller than
 194    this value, they are statically allocated in the TB stack frame */
 195 #define TCG_STATIC_CALL_ARGS_SIZE 128
 196
 197 typedef enum TCGType {
 198     TCG_TYPE_I32,
 199     TCG_TYPE_I64,
 200     TCG_TYPE_COUNT, /* number of different types */
 201
 202     /* An alias for the size of the host register.  */
 203 #if TCG_TARGET_REG_BITS == 32
 204     TCG_TYPE_REG = TCG_TYPE_I32,
 205 #else
 206     TCG_TYPE_REG = TCG_TYPE_I64,
 207 #endif
 208
 209     /* An alias for the size of the native pointer.  */
 210 #if UINTPTR_MAX == UINT32_MAX
 211     TCG_TYPE_PTR = TCG_TYPE_I32,
 212 #else
 213     TCG_TYPE_PTR = TCG_TYPE_I64,
 214 #endif
 215
 216     /* An alias for the size of the target "long", aka register.  */
 217 #if TARGET_LONG_BITS == 64
 218     TCG_TYPE_TL = TCG_TYPE_I64,
 219 #else
 220     TCG_TYPE_TL = TCG_TYPE_I32,
 221 #endif
 222 } TCGType;
 223
 224 /* Constants for qemu_ld and qemu_st for the Memory Operation field.  */
 225 typedef enum TCGMemOp {
 226     MO_8     = 0,
 227     MO_16    = 1,
 228     MO_32    = 2,
 229     MO_64    = 3,
 230     MO_SIZE  = 3,   /* Mask for the above.  */
 231
 232     MO_SIGN  = 4,   /* Sign-extended, otherwise zero-extended.  */
 233
 234     MO_BSWAP = 8,   /* Host reverse endian.  */
 235 #ifdef HOST_WORDS_BIGENDIAN
 236     MO_LE    = MO_BSWAP,
 237     MO_BE    = 0,
 238 #else
 239     MO_LE    = 0,
 240     MO_BE    = MO_BSWAP,
 241 #endif
 242 #ifdef TARGET_WORDS_BIGENDIAN
 243     MO_TE    = MO_BE,
 244 #else
 245     MO_TE    = MO_LE,
 246 #endif
 247
 248     /* Combinations of the above, for ease of use.  */
 249     MO_UB    = MO_8,
 250     MO_UW    = MO_16,
 251     MO_UL    = MO_32,
 252     MO_SB    = MO_SIGN | MO_8,
 253     MO_SW    = MO_SIGN | MO_16,
 254     MO_SL    = MO_SIGN | MO_32,
 255     MO_Q     = MO_64,
 256
 257     MO_LEUW  = MO_LE | MO_UW,
 258     MO_LEUL  = MO_LE | MO_UL,
 259     MO_LESW  = MO_LE | MO_SW,
 260     MO_LESL  = MO_LE | MO_SL,
 261     MO_LEQ   = MO_LE | MO_Q,
 262
 263     MO_BEUW  = MO_BE | MO_UW,
 264     MO_BEUL  = MO_BE | MO_UL,
 265     MO_BESW  = MO_BE | MO_SW,
 266     MO_BESL  = MO_BE | MO_SL,
 267     MO_BEQ   = MO_BE | MO_Q,
 268
 269     MO_TEUW  = MO_TE | MO_UW,
 270     MO_TEUL  = MO_TE | MO_UL,
 271     MO_TESW  = MO_TE | MO_SW,
 272     MO_TESL  = MO_TE | MO_SL,
 273     MO_TEQ   = MO_TE | MO_Q,
 274
 275     MO_SSIZE = MO_SIZE | MO_SIGN,
 276 } TCGMemOp;
 277
 278 typedef tcg_target_ulong TCGArg;
 279
 280 /* Define a type and accessor macros for variables.  Using a struct is
 281    nice because it gives some level of type safely.  Ideally the compiler
 282    be able to see through all this.  However in practice this is not true,
 283    especially on targets with braindamaged ABIs (e.g. i386).
 284    We use plain int by default to avoid this runtime overhead.
 285    Users of tcg_gen_* don't need to know about any of this, and should
 286    treat TCGv as an opaque type.
 287    In addition we do typechecking for different types of variables.  TCGv_i32
 288    and TCGv_i64 are 32/64-bit variables respectively.  TCGv and TCGv_ptr
 289    are aliases for target_ulong and host pointer sized values respectively.
 290  */
 291
 292 #ifdef CONFIG_DEBUG_TCG
 293 #define DEBUG_TCGV 1
 294 #endif
 295
 296 #ifdef DEBUG_TCGV
 297
 298 typedef struct
 299 {
 300     int i32;
 301 } TCGv_i32;
 302
 303 typedef struct
 304 {
 305     int i64;
 306 } TCGv_i64;
 307
 308 typedef struct {
 309     int iptr;
 310 } TCGv_ptr;
 311
 312 #define MAKE_TCGV_I32(i) __extension__                  \
 313     ({ TCGv_i32 make_tcgv_tmp = {i}; make_tcgv_tmp;})
 314 #define MAKE_TCGV_I64(i) __extension__                  \
 315     ({ TCGv_i64 make_tcgv_tmp = {i}; make_tcgv_tmp;})
 316 #define MAKE_TCGV_PTR(i) __extension__                  \
 317     ({ TCGv_ptr make_tcgv_tmp = {i}; make_tcgv_tmp; })
 318 #define GET_TCGV_I32(t) ((t).i32)
 319 #define GET_TCGV_I64(t) ((t).i64)
 320 #define GET_TCGV_PTR(t) ((t).iptr)
 321 #if TCG_TARGET_REG_BITS == 32
 322 #define TCGV_LOW(t) MAKE_TCGV_I32(GET_TCGV_I64(t))
 323 #define TCGV_HIGH(t) MAKE_TCGV_I32(GET_TCGV_I64(t) + 1)
 324 #endif
 325
 326 #else /* !DEBUG_TCGV */
 327
 328 typedef int TCGv_i32;
 329 typedef int TCGv_i64;
 330 #if TCG_TARGET_REG_BITS == 32
 331 #define TCGv_ptr TCGv_i32
 332 #else
 333 #define TCGv_ptr TCGv_i64
 334 #endif
 335 #define MAKE_TCGV_I32(x) (x)
 336 #define MAKE_TCGV_I64(x) (x)
 337 #define MAKE_TCGV_PTR(x) (x)
 338 #define GET_TCGV_I32(t) (t)
 339 #define GET_TCGV_I64(t) (t)
 340 #define GET_TCGV_PTR(t) (t)
 341
 342 #if TCG_TARGET_REG_BITS == 32
 343 #define TCGV_LOW(t) (t)
 344 #define TCGV_HIGH(t) ((t) + 1)
 345 #endif
 346
 347 #endif /* DEBUG_TCGV */
 348
 349 #define TCGV_EQUAL_I32(a, b) (GET_TCGV_I32(a) == GET_TCGV_I32(b))
 350 #define TCGV_EQUAL_I64(a, b) (GET_TCGV_I64(a) == GET_TCGV_I64(b))
 351 #define TCGV_EQUAL_PTR(a, b) (GET_TCGV_PTR(a) == GET_TCGV_PTR(b))
 352
 353 /* Dummy definition to avoid compiler warnings.  */
 354 #define TCGV_UNUSED_I32(x) x = MAKE_TCGV_I32(-1)
 355 #define TCGV_UNUSED_I64(x) x = MAKE_TCGV_I64(-1)
 356 #define TCGV_UNUSED_PTR(x) x = MAKE_TCGV_PTR(-1)
 357
 358 #define TCGV_IS_UNUSED_I32(x) (GET_TCGV_I32(x) == -1)
 359 #define TCGV_IS_UNUSED_I64(x) (GET_TCGV_I64(x) == -1)
 360 #define TCGV_IS_UNUSED_PTR(x) (GET_TCGV_PTR(x) == -1)
 361
 362 /* call flags */
 363 /* Helper does not read globals (either directly or through an exception). It
 364    implies TCG_CALL_NO_WRITE_GLOBALS. */
 365 #define TCG_CALL_NO_READ_GLOBALS    0x0010
 366 /* Helper does not write globals */
 367 #define TCG_CALL_NO_WRITE_GLOBALS   0x0020
 368 /* Helper can be safely suppressed if the return value is not used. */
 369 #define TCG_CALL_NO_SIDE_EFFECTS    0x0040
 370
 371 /* convenience version of most used call flags */
 372 #define TCG_CALL_NO_RWG         TCG_CALL_NO_READ_GLOBALS
 373 #define TCG_CALL_NO_WG          TCG_CALL_NO_WRITE_GLOBALS
 374 #define TCG_CALL_NO_SE          TCG_CALL_NO_SIDE_EFFECTS
 375 #define TCG_CALL_NO_RWG_SE      (TCG_CALL_NO_RWG | TCG_CALL_NO_SE)
 376 #define TCG_CALL_NO_WG_SE       (TCG_CALL_NO_WG | TCG_CALL_NO_SE)
 377
 378 /* used to align parameters */
 379 #define TCG_CALL_DUMMY_TCGV     MAKE_TCGV_I32(-1)
 380 #define TCG_CALL_DUMMY_ARG      ((TCGArg)(-1))
 381
 382 /* Conditions.  Note that these are laid out for easy manipulation by
 383    the functions below:
 384      bit 0 is used for inverting;
 385      bit 1 is signed,
 386      bit 2 is unsigned,
 387      bit 3 is used with bit 0 for swapping signed/unsigned.  */
 388 typedef enum {
 389     /* non-signed */
 390     TCG_COND_NEVER  = 0 | 0 | 0 | 0,
 391     TCG_COND_ALWAYS = 0 | 0 | 0 | 1,
 392     TCG_COND_EQ     = 8 | 0 | 0 | 0,
 393     TCG_COND_NE     = 8 | 0 | 0 | 1,
 394     /* signed */
 395     TCG_COND_LT     = 0 | 0 | 2 | 0,
 396     TCG_COND_GE     = 0 | 0 | 2 | 1,
 397     TCG_COND_LE     = 8 | 0 | 2 | 0,
 398     TCG_COND_GT     = 8 | 0 | 2 | 1,
 399     /* unsigned */
 400     TCG_COND_LTU    = 0 | 4 | 0 | 0,
 401     TCG_COND_GEU    = 0 | 4 | 0 | 1,
 402     TCG_COND_LEU    = 8 | 4 | 0 | 0,
 403     TCG_COND_GTU    = 8 | 4 | 0 | 1,
 404 } TCGCond;
 405
 406 /* Invert the sense of the comparison.  */
 407 static inline TCGCond tcg_invert_cond(TCGCond c)
 408 {
 409     return (TCGCond)(c ^ 1);
 410 }
 411
 412 /* Swap the operands in a comparison.  */
 413 static inline TCGCond tcg_swap_cond(TCGCond c)
 414 {
 415     return c & 6 ? (TCGCond)(c ^ 9) : c;
 416 }
 417
 418 /* Create an "unsigned" version of a "signed" comparison.  */
 419 static inline TCGCond tcg_unsigned_cond(TCGCond c)
 420 {
 421     return c & 2 ? (TCGCond)(c ^ 6) : c;
 422 }
 423
 424 /* Must a comparison be considered unsigned?  */
 425 static inline bool is_unsigned_cond(TCGCond c)
 426 {
 427     return (c & 4) != 0;
 428 }
 429
 430 /* Create a "high" version of a double-word comparison.
 431    This removes equality from a LTE or GTE comparison.  */
 432 static inline TCGCond tcg_high_cond(TCGCond c)
 433 {
 434     switch (c) {
 435     case TCG_COND_GE:
 436     case TCG_COND_LE:
 437     case TCG_COND_GEU:
 438     case TCG_COND_LEU:
 439         return (TCGCond)(c ^ 8);
 440     default:
 441         return c;
 442     }
 443 }
 444
 445 #define TEMP_VAL_DEAD  0
 446 #define TEMP_VAL_REG   1
 447 #define TEMP_VAL_MEM   2
 448 #define TEMP_VAL_CONST 3
 449
 450 /* XXX: optimize memory layout */
 451 typedef struct TCGTemp {
 452     TCGType base_type;
 453     TCGType type;
 454     int val_type;
 455     int reg;
 456     tcg_target_long val;
 457     int mem_reg;
 458     intptr_t mem_offset;
 459     unsigned int fixed_reg:1;
 460     unsigned int mem_coherent:1;
 461     unsigned int mem_allocated:1;
 462     unsigned int temp_local:1; /* If true, the temp is saved across
 463                                   basic blocks. Otherwise, it is not
 464                                   preserved across basic blocks. */
 465     unsigned int temp_allocated:1; /* never used for code gen */
 466     const char *name;
 467 } TCGTemp;
 468
 469 typedef struct TCGContext TCGContext;
 470
 471 typedef struct TCGTempSet {
 472     unsigned long l[BITS_TO_LONGS(TCG_MAX_TEMPS)];
 473 } TCGTempSet;
 474
 475 struct TCGContext {
 476     uint8_t *pool_cur, *pool_end;
 477     TCGPool *pool_first, *pool_current, *pool_first_large;
 478     TCGLabel *labels;
 479     int nb_labels;
 480     int nb_globals;
 481     int nb_temps;
 482
 483     /* goto_tb support */
 484     tcg_insn_unit *code_buf;
 485     uintptr_t *tb_next;
 486     uint16_t *tb_next_offset;
 487     uint16_t *tb_jmp_offset; /* != NULL if USE_DIRECT_JUMP */
 488
 489     /* liveness analysis */
 490     uint16_t *op_dead_args; /* for each operation, each bit tells if the
 491                                corresponding argument is dead */
 492     uint8_t *op_sync_args;  /* for each operation, each bit tells if the
 493                                corresponding output argument needs to be
 494                                sync to memory. */
 495
 496     /* tells in which temporary a given register is. It does not take
 497        into account fixed registers */
 498     int reg_to_temp[TCG_TARGET_NB_REGS];
 499     TCGRegSet reserved_regs;
 500     intptr_t current_frame_offset;
 501     intptr_t frame_start;
 502     intptr_t frame_end;
 503     int frame_reg;
 504
 505     tcg_insn_unit *code_ptr;
 506     TCGTemp temps[TCG_MAX_TEMPS]; /* globals first, temps after */
 507     TCGTempSet free_temps[TCG_TYPE_COUNT * 2];
 508
 509     GHashTable *helpers;
 510
 511 #ifdef CONFIG_PROFILER
 512     /* profiling info */
 513     int64_t tb_count1;
 514     int64_t tb_count;
 515     int64_t op_count; /* total insn count */
 516     int op_count_max; /* max insn per TB */
 517     int64_t temp_count;
 518     int temp_count_max;
 519     int64_t del_op_count;
 520     int64_t code_in_len;
 521     int64_t code_out_len;
 522     int64_t interm_time;
 523     int64_t code_time;
 524     int64_t la_time;
 525     int64_t opt_time;
 526     int64_t restore_count;
 527     int64_t restore_time;
 528 #endif
 529
 530 #ifdef CONFIG_DEBUG_TCG
 531     int temps_in_use;
 532     int goto_tb_issue_mask;
 533 #endif
 534
 535     uint16_t gen_opc_buf[OPC_BUF_SIZE];
 536     TCGArg gen_opparam_buf[OPPARAM_BUF_SIZE];
 537
 538     uint16_t *gen_opc_ptr;
 539     TCGArg *gen_opparam_ptr;
 540     target_ulong gen_opc_pc[OPC_BUF_SIZE];
 541     uint16_t gen_opc_icount[OPC_BUF_SIZE];
 542     uint8_t gen_opc_instr_start[OPC_BUF_SIZE];
 543
 544     /* Code generation.  Note that we specifically do not use tcg_insn_unit
 545        here, because there's too much arithmetic throughout that relies
 546        on addition and subtraction working on bytes.  Rely on the GCC
 547        extension that allows arithmetic on void*.  */
 548     int code_gen_max_blocks;
 549     void *code_gen_prologue;
 550     void *code_gen_buffer;
 551     size_t code_gen_buffer_size;
 552     /* threshold to flush the translated code buffer */
 553     size_t code_gen_buffer_max_size;
 554     void *code_gen_ptr;
 555
 556     TBContext tb_ctx;
 557
 558     /* The TCGBackendData structure is private to tcg-target.c.  */
 559     struct TCGBackendData *be;
 560 };
 561
 562 extern TCGContext tcg_ctx;
 563
 564 /* pool based memory allocation */
 565
 566 void *tcg_malloc_internal(TCGContext *s, int size);
 567 void tcg_pool_reset(TCGContext *s);
 568 void tcg_pool_delete(TCGContext *s);
 569
 570 static inline void *tcg_malloc(int size)
 571 {
 572     TCGContext *s = &tcg_ctx;
 573     uint8_t *ptr, *ptr_end;
 574     size = (size + sizeof(long) - 1) & ~(sizeof(long) - 1);
 575     ptr = s->pool_cur;
 576     ptr_end = ptr + size;
 577     if (unlikely(ptr_end > s->pool_end)) {
 578         return tcg_malloc_internal(&tcg_ctx, size);
 579     } else {
 580         s->pool_cur = ptr_end;
 581         return ptr;
 582     }
 583 }
 584
 585 void tcg_context_init(TCGContext *s);
 586 void tcg_prologue_init(TCGContext *s);
 587 void tcg_func_start(TCGContext *s);
 588
 589 int tcg_gen_code(TCGContext *s, tcg_insn_unit *gen_code_buf);
 590 int tcg_gen_code_search_pc(TCGContext *s, tcg_insn_unit *gen_code_buf,
 591                            long offset);
 592
 593 void tcg_set_frame(TCGContext *s, int reg, intptr_t start, intptr_t size);
 594
 595 TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name);
 596 TCGv_i32 tcg_global_mem_new_i32(int reg, intptr_t offset, const char *name);
 597 TCGv_i32 tcg_temp_new_internal_i32(int temp_local);
 598 static inline TCGv_i32 tcg_temp_new_i32(void)
 599 {
 600     return tcg_temp_new_internal_i32(0);
 601 }
 602 static inline TCGv_i32 tcg_temp_local_new_i32(void)
 603 {
 604     return tcg_temp_new_internal_i32(1);
 605 }
 606 void tcg_temp_free_i32(TCGv_i32 arg);
 607 char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg);
 608
 609 TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name);
 610 TCGv_i64 tcg_global_mem_new_i64(int reg, intptr_t offset, const char *name);
 611 TCGv_i64 tcg_temp_new_internal_i64(int temp_local);
 612 static inline TCGv_i64 tcg_temp_new_i64(void)
 613 {
 614     return tcg_temp_new_internal_i64(0);
 615 }
 616 static inline TCGv_i64 tcg_temp_local_new_i64(void)
 617 {
 618     return tcg_temp_new_internal_i64(1);
 619 }
 620 void tcg_temp_free_i64(TCGv_i64 arg);
 621 char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg);
 622
 623 #if defined(CONFIG_DEBUG_TCG)
 624 /* If you call tcg_clear_temp_count() at the start of a section of
 625  * code which is not supposed to leak any TCG temporaries, then
 626  * calling tcg_check_temp_count() at the end of the section will
 627  * return 1 if the section did in fact leak a temporary.
 628  */
 629 void tcg_clear_temp_count(void);
 630 int tcg_check_temp_count(void);
 631 #else
 632 #define tcg_clear_temp_count() do { } while (0)
 633 #define tcg_check_temp_count() 0
 634 #endif
 635
 636 void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf);
 637
 638 #define TCG_CT_ALIAS  0x80
 639 #define TCG_CT_IALIAS 0x40
 640 #define TCG_CT_REG    0x01
 641 #define TCG_CT_CONST  0x02 /* any constant of register size */
 642
 643 typedef struct TCGArgConstraint {
 644     uint16_t ct;
 645     uint8_t alias_index;
 646     union {
 647         TCGRegSet regs;
 648     } u;
 649 } TCGArgConstraint;
 650
 651 #define TCG_MAX_OP_ARGS 16
 652
 653 /* Bits for TCGOpDef->flags, 8 bits available.  */
 654 enum {
 655     /* Instruction defines the end of a basic block.  */
 656     TCG_OPF_BB_END       = 0x01,
 657     /* Instruction clobbers call registers and potentially update globals.  */
 658     TCG_OPF_CALL_CLOBBER = 0x02,
 659     /* Instruction has side effects: it cannot be removed if its outputs
 660        are not used, and might trigger exceptions.  */
 661     TCG_OPF_SIDE_EFFECTS = 0x04,
 662     /* Instruction operands are 64-bits (otherwise 32-bits).  */
 663     TCG_OPF_64BIT        = 0x08,
 664     /* Instruction is optional and not implemented by the host, or insn
 665        is generic and should not be implemened by the host.  */
 666     TCG_OPF_NOT_PRESENT  = 0x10,
 667 };
 668
 669 typedef struct TCGOpDef {
 670     const char *name;
 671     uint8_t nb_oargs, nb_iargs, nb_cargs, nb_args;
 672     uint8_t flags;
 673     TCGArgConstraint *args_ct;
 674     int *sorted_args;
 675 #if defined(CONFIG_DEBUG_TCG)
 676     int used;
 677 #endif
 678 } TCGOpDef;
 679
 680 extern TCGOpDef tcg_op_defs[];
 681 extern const size_t tcg_op_defs_max;
 682
 683 typedef struct TCGTargetOpDef {
 684     TCGOpcode op;
 685     const char *args_ct_str[TCG_MAX_OP_ARGS];
 686 } TCGTargetOpDef;
 687
 688 #define tcg_abort() \
 689 do {\
 690     fprintf(stderr, "%s:%d: tcg fatal error\n", __FILE__, __LINE__);\
 691     abort();\
 692 } while (0)
 693
 694 #ifdef CONFIG_DEBUG_TCG
 695 # define tcg_debug_assert(X) do { assert(X); } while (0)
 696 #elif QEMU_GNUC_PREREQ(4, 5)
 697 # define tcg_debug_assert(X) \
 698     do { if (!(X)) { __builtin_unreachable(); } } while (0)
 699 #else
 700 # define tcg_debug_assert(X) do { (void)(X); } while (0)
 701 #endif
 702
 703 void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs);
 704
 705 #if UINTPTR_MAX == UINT32_MAX
 706 #define TCGV_NAT_TO_PTR(n) MAKE_TCGV_PTR(GET_TCGV_I32(n))
 707 #define TCGV_PTR_TO_NAT(n) MAKE_TCGV_I32(GET_TCGV_PTR(n))
 708
 709 #define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i32((intptr_t)(V)))
 710 #define tcg_global_reg_new_ptr(R, N) \
 711     TCGV_NAT_TO_PTR(tcg_global_reg_new_i32((R), (N)))
 712 #define tcg_global_mem_new_ptr(R, O, N) \
 713     TCGV_NAT_TO_PTR(tcg_global_mem_new_i32((R), (O), (N)))
 714 #define tcg_temp_new_ptr() TCGV_NAT_TO_PTR(tcg_temp_new_i32())
 715 #define tcg_temp_free_ptr(T) tcg_temp_free_i32(TCGV_PTR_TO_NAT(T))
 716 #else
 717 #define TCGV_NAT_TO_PTR(n) MAKE_TCGV_PTR(GET_TCGV_I64(n))
 718 #define TCGV_PTR_TO_NAT(n) MAKE_TCGV_I64(GET_TCGV_PTR(n))
 719
 720 #define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i64((intptr_t)(V)))
 721 #define tcg_global_reg_new_ptr(R, N) \
 722     TCGV_NAT_TO_PTR(tcg_global_reg_new_i64((R), (N)))
 723 #define tcg_global_mem_new_ptr(R, O, N) \
 724     TCGV_NAT_TO_PTR(tcg_global_mem_new_i64((R), (O), (N)))
 725 #define tcg_temp_new_ptr() TCGV_NAT_TO_PTR(tcg_temp_new_i64())
 726 #define tcg_temp_free_ptr(T) tcg_temp_free_i64(TCGV_PTR_TO_NAT(T))
 727 #endif
 728
 729 void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags,
 730                    int sizemask, TCGArg ret, int nargs, TCGArg *args);
 731
 732 void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1,
 733                         int c, int right, int arith);
 734
 735 TCGArg *tcg_optimize(TCGContext *s, uint16_t *tcg_opc_ptr, TCGArg *args,
 736                      TCGOpDef *tcg_op_def);
 737
 738 /* only used for debugging purposes */
 739 void tcg_dump_ops(TCGContext *s);
 740
 741 void dump_ops(const uint16_t *opc_buf, const TCGArg *opparam_buf);
 742 TCGv_i32 tcg_const_i32(int32_t val);
 743 TCGv_i64 tcg_const_i64(int64_t val);
 744 TCGv_i32 tcg_const_local_i32(int32_t val);
 745 TCGv_i64 tcg_const_local_i64(int64_t val);
 746
 747 /**
 748  * tcg_ptr_byte_diff
 749  * @a, @b: addresses to be differenced
 750  *
 751  * There are many places within the TCG backends where we need a byte
 752  * difference between two pointers.  While this can be accomplished
 753  * with local casting, it's easy to get wrong -- especially if one is
 754  * concerned with the signedness of the result.
 755  *
 756  * This version relies on GCC's void pointer arithmetic to get the
 757  * correct result.
 758  */
 759
 760 static inline ptrdiff_t tcg_ptr_byte_diff(void *a, void *b)
 761 {
 762     return a - b;
 763 }
 764
 765 /**
 766  * tcg_pcrel_diff
 767  * @s: the tcg context
 768  * @target: address of the target
 769  *
 770  * Produce a pc-relative difference, from the current code_ptr
 771  * to the destination address.
 772  */
 773
 774 static inline ptrdiff_t tcg_pcrel_diff(TCGContext *s, void *target)
 775 {
 776     return tcg_ptr_byte_diff(target, s->code_ptr);
 777 }
 778
 779 /**
 780  * tcg_current_code_size
 781  * @s: the tcg context
 782  *
 783  * Compute the current code size within the translation block.
 784  * This is used to fill in qemu's data structures for goto_tb.
 785  */
 786
 787 static inline size_t tcg_current_code_size(TCGContext *s)
 788 {
 789     return tcg_ptr_byte_diff(s->code_ptr, s->code_buf);
 790 }
 791
 792 /**
 793  * tcg_qemu_tb_exec:
 794  * @env: CPUArchState * for the CPU
 795  * @tb_ptr: address of generated code for the TB to execute
 796  *
 797  * Start executing code from a given translation block.
 798  * Where translation blocks have been linked, execution
 799  * may proceed from the given TB into successive ones.
 800  * Control eventually returns only when some action is needed
 801  * from the top-level loop: either control must pass to a TB
 802  * which has not yet been directly linked, or an asynchronous
 803  * event such as an interrupt needs handling.
 804  *
 805  * The return value is a pointer to the next TB to execute
 806  * (if known; otherwise zero). This pointer is assumed to be
 807  * 4-aligned, and the bottom two bits are used to return further
 808  * information:
 809  *  0, 1: the link between this TB and the next is via the specified
 810  *        TB index (0 or 1). That is, we left the TB via (the equivalent
 811  *        of) "goto_tb <index>". The main loop uses this to determine
 812  *        how to link the TB just executed to the next.
 813  *  2:    we are using instruction counting code generation, and we
 814  *        did not start executing this TB because the instruction counter
 815  *        would hit zero midway through it. In this case the next-TB pointer
 816  *        returned is the TB we were about to execute, and the caller must
 817  *        arrange to execute the remaining count of instructions.
 818  *  3:    we stopped because the CPU's exit_request flag was set
 819  *        (usually meaning that there is an interrupt that needs to be
 820  *        handled). The next-TB pointer returned is the TB we were
 821  *        about to execute when we noticed the pending exit request.
 822  *
 823  * If the bottom two bits indicate an exit-via-index then the CPU
 824  * state is correctly synchronised and ready for execution of the next
 825  * TB (and in particular the guest PC is the address to execute next).
 826  * Otherwise, we gave up on execution of this TB before it started, and
 827  * the caller must fix up the CPU state by calling cpu_pc_from_tb()
 828  * with the next-TB pointer we return.
 829  *
 830  * Note that TCG targets may use a different definition of tcg_qemu_tb_exec
 831  * to this default (which just calls the prologue.code emitted by
 832  * tcg_target_qemu_prologue()).
 833  */
 834 #define TB_EXIT_MASK 3
 835 #define TB_EXIT_IDX0 0
 836 #define TB_EXIT_IDX1 1
 837 #define TB_EXIT_ICOUNT_EXPIRED 2
 838 #define TB_EXIT_REQUESTED 3
 839
 840 #if !defined(tcg_qemu_tb_exec)
 841 # define tcg_qemu_tb_exec(env, tb_ptr) \
 842     ((uintptr_t (*)(void *, void *))tcg_ctx.code_gen_prologue)(env, tb_ptr)
 843 #endif
 844
 845 void tcg_register_jit(void *buf, size_t buf_size);
 846
 847 /*
 848  * Memory helpers that will be used by TCG generated code.
 849  */
 850 #ifdef CONFIG_SOFTMMU
 851 /* Value zero-extended to tcg register size.  */
 852 tcg_target_ulong helper_ret_ldub_mmu(CPUArchState *env, target_ulong addr,
 853                                      int mmu_idx, uintptr_t retaddr);
 854 tcg_target_ulong helper_le_lduw_mmu(CPUArchState *env, target_ulong addr,
 855                                     int mmu_idx, uintptr_t retaddr);
 856 tcg_target_ulong helper_le_ldul_mmu(CPUArchState *env, target_ulong addr,
 857                                     int mmu_idx, uintptr_t retaddr);
 858 uint64_t helper_le_ldq_mmu(CPUArchState *env, target_ulong addr,
 859                            int mmu_idx, uintptr_t retaddr);
 860 tcg_target_ulong helper_be_lduw_mmu(CPUArchState *env, target_ulong addr,
 861                                     int mmu_idx, uintptr_t retaddr);
 862 tcg_target_ulong helper_be_ldul_mmu(CPUArchState *env, target_ulong addr,
 863                                     int mmu_idx, uintptr_t retaddr);
 864 uint64_t helper_be_ldq_mmu(CPUArchState *env, target_ulong addr,
 865                            int mmu_idx, uintptr_t retaddr);
 866
 867 /* Value sign-extended to tcg register size.  */
 868 tcg_target_ulong helper_ret_ldsb_mmu(CPUArchState *env, target_ulong addr,
 869                                      int mmu_idx, uintptr_t retaddr);
 870 tcg_target_ulong helper_le_ldsw_mmu(CPUArchState *env, target_ulong addr,
 871                                     int mmu_idx, uintptr_t retaddr);
 872 tcg_target_ulong helper_le_ldsl_mmu(CPUArchState *env, target_ulong addr,
 873                                     int mmu_idx, uintptr_t retaddr);
 874 tcg_target_ulong helper_be_ldsw_mmu(CPUArchState *env, target_ulong addr,
 875                                     int mmu_idx, uintptr_t retaddr);
 876 tcg_target_ulong helper_be_ldsl_mmu(CPUArchState *env, target_ulong addr,
 877                                     int mmu_idx, uintptr_t retaddr);
 878
 879 void helper_ret_stb_mmu(CPUArchState *env, target_ulong addr, uint8_t val,
 880                         int mmu_idx, uintptr_t retaddr);
 881 void helper_le_stw_mmu(CPUArchState *env, target_ulong addr, uint16_t val,
 882                        int mmu_idx, uintptr_t retaddr);
 883 void helper_le_stl_mmu(CPUArchState *env, target_ulong addr, uint32_t val,
 884                        int mmu_idx, uintptr_t retaddr);
 885 void helper_le_stq_mmu(CPUArchState *env, target_ulong addr, uint64_t val,
 886                        int mmu_idx, uintptr_t retaddr);
 887 void helper_be_stw_mmu(CPUArchState *env, target_ulong addr, uint16_t val,
 888                        int mmu_idx, uintptr_t retaddr);
 889 void helper_be_stl_mmu(CPUArchState *env, target_ulong addr, uint32_t val,
 890                        int mmu_idx, uintptr_t retaddr);
 891 void helper_be_stq_mmu(CPUArchState *env, target_ulong addr, uint64_t val,
 892                        int mmu_idx, uintptr_t retaddr);
 893
 894 /* Temporary aliases until backends are converted.  */
 895 #ifdef TARGET_WORDS_BIGENDIAN
 896 # define helper_ret_ldsw_mmu  helper_be_ldsw_mmu
 897 # define helper_ret_lduw_mmu  helper_be_lduw_mmu
 898 # define helper_ret_ldsl_mmu  helper_be_ldsl_mmu
 899 # define helper_ret_ldul_mmu  helper_be_ldul_mmu
 900 # define helper_ret_ldq_mmu   helper_be_ldq_mmu
 901 # define helper_ret_stw_mmu   helper_be_stw_mmu
 902 # define helper_ret_stl_mmu   helper_be_stl_mmu
 903 # define helper_ret_stq_mmu   helper_be_stq_mmu
 904 #else
 905 # define helper_ret_ldsw_mmu  helper_le_ldsw_mmu
 906 # define helper_ret_lduw_mmu  helper_le_lduw_mmu
 907 # define helper_ret_ldsl_mmu  helper_le_ldsl_mmu
 908 # define helper_ret_ldul_mmu  helper_le_ldul_mmu
 909 # define helper_ret_ldq_mmu   helper_le_ldq_mmu
 910 # define helper_ret_stw_mmu   helper_le_stw_mmu
 911 # define helper_ret_stl_mmu   helper_le_stl_mmu
 912 # define helper_ret_stq_mmu   helper_le_stq_mmu
 913 #endif
 914
 915 uint8_t helper_ldb_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
 916 uint16_t helper_ldw_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
 917 uint32_t helper_ldl_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
 918 uint64_t helper_ldq_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
 919
 920 void helper_stb_mmu(CPUArchState *env, target_ulong addr,
 921                     uint8_t val, int mmu_idx);
 922 void helper_stw_mmu(CPUArchState *env, target_ulong addr,
 923                     uint16_t val, int mmu_idx);
 924 void helper_stl_mmu(CPUArchState *env, target_ulong addr,
 925                     uint32_t val, int mmu_idx);
 926 void helper_stq_mmu(CPUArchState *env, target_ulong addr,
 927                     uint64_t val, int mmu_idx);
 928 #endif /* CONFIG_SOFTMMU */
 929
 930 #endif /* TCG_H */