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 "cpu.h"
  30 #include "exec/tb-context.h"
  31 #include "qemu/bitops.h"
  32 #include "tcg-target.h"
  33
  34 /* XXX: make safe guess about sizes */
  35 #define MAX_OP_PER_INSTR 266
  36
  37 #if HOST_LONG_BITS == 32
  38 #define MAX_OPC_PARAM_PER_ARG 2
  39 #else
  40 #define MAX_OPC_PARAM_PER_ARG 1
  41 #endif
  42 #define MAX_OPC_PARAM_IARGS 5
  43 #define MAX_OPC_PARAM_OARGS 1
  44 #define MAX_OPC_PARAM_ARGS (MAX_OPC_PARAM_IARGS + MAX_OPC_PARAM_OARGS)
  45
  46 /* A Call op needs up to 4 + 2N parameters on 32-bit archs,
  47  * and up to 4 + N parameters on 64-bit archs
  48  * (N = number of input arguments + output arguments).  */
  49 #define MAX_OPC_PARAM (4 + (MAX_OPC_PARAM_PER_ARG * MAX_OPC_PARAM_ARGS))
  50 #define OPC_BUF_SIZE 640
  51 #define OPC_MAX_SIZE (OPC_BUF_SIZE - MAX_OP_PER_INSTR)
  52
  53 #define OPPARAM_BUF_SIZE (OPC_BUF_SIZE * MAX_OPC_PARAM)
  54
  55 #define CPU_TEMP_BUF_NLONGS 128
  56
  57 /* Default target word size to pointer size.  */
  58 #ifndef TCG_TARGET_REG_BITS
  59 # if UINTPTR_MAX == UINT32_MAX
  60 #  define TCG_TARGET_REG_BITS 32
  61 # elif UINTPTR_MAX == UINT64_MAX
  62 #  define TCG_TARGET_REG_BITS 64
  63 # else
  64 #  error Unknown pointer size for tcg target
  65 # endif
  66 #endif
  67
  68 #if TCG_TARGET_REG_BITS == 32
  69 typedef int32_t tcg_target_long;
  70 typedef uint32_t tcg_target_ulong;
  71 #define TCG_PRIlx PRIx32
  72 #define TCG_PRIld PRId32
  73 #elif TCG_TARGET_REG_BITS == 64
  74 typedef int64_t tcg_target_long;
  75 typedef uint64_t tcg_target_ulong;
  76 #define TCG_PRIlx PRIx64
  77 #define TCG_PRIld PRId64
  78 #else
  79 #error unsupported
  80 #endif
  81
  82 #if TCG_TARGET_NB_REGS <= 32
  83 typedef uint32_t TCGRegSet;
  84 #elif TCG_TARGET_NB_REGS <= 64
  85 typedef uint64_t TCGRegSet;
  86 #else
  87 #error unsupported
  88 #endif
  89
  90 #if TCG_TARGET_REG_BITS == 32
  91 /* Turn some undef macros into false macros.  */
  92 #define TCG_TARGET_HAS_extrl_i64_i32    0
  93 #define TCG_TARGET_HAS_extrh_i64_i32    0
  94 #define TCG_TARGET_HAS_div_i64          0
  95 #define TCG_TARGET_HAS_rem_i64          0
  96 #define TCG_TARGET_HAS_div2_i64         0
  97 #define TCG_TARGET_HAS_rot_i64          0
  98 #define TCG_TARGET_HAS_ext8s_i64        0
  99 #define TCG_TARGET_HAS_ext16s_i64       0
 100 #define TCG_TARGET_HAS_ext32s_i64       0
 101 #define TCG_TARGET_HAS_ext8u_i64        0
 102 #define TCG_TARGET_HAS_ext16u_i64       0
 103 #define TCG_TARGET_HAS_ext32u_i64       0
 104 #define TCG_TARGET_HAS_bswap16_i64      0
 105 #define TCG_TARGET_HAS_bswap32_i64      0
 106 #define TCG_TARGET_HAS_bswap64_i64      0
 107 #define TCG_TARGET_HAS_neg_i64          0
 108 #define TCG_TARGET_HAS_not_i64          0
 109 #define TCG_TARGET_HAS_andc_i64         0
 110 #define TCG_TARGET_HAS_orc_i64          0
 111 #define TCG_TARGET_HAS_eqv_i64          0
 112 #define TCG_TARGET_HAS_nand_i64         0
 113 #define TCG_TARGET_HAS_nor_i64          0
 114 #define TCG_TARGET_HAS_clz_i64          0
 115 #define TCG_TARGET_HAS_ctz_i64          0
 116 #define TCG_TARGET_HAS_deposit_i64      0
 117 #define TCG_TARGET_HAS_extract_i64      0
 118 #define TCG_TARGET_HAS_sextract_i64     0
 119 #define TCG_TARGET_HAS_movcond_i64      0
 120 #define TCG_TARGET_HAS_add2_i64         0
 121 #define TCG_TARGET_HAS_sub2_i64         0
 122 #define TCG_TARGET_HAS_mulu2_i64        0
 123 #define TCG_TARGET_HAS_muls2_i64        0
 124 #define TCG_TARGET_HAS_muluh_i64        0
 125 #define TCG_TARGET_HAS_mulsh_i64        0
 126 /* Turn some undef macros into true macros.  */
 127 #define TCG_TARGET_HAS_add2_i32         1
 128 #define TCG_TARGET_HAS_sub2_i32         1
 129 #endif
 130
 131 #ifndef TCG_TARGET_deposit_i32_valid
 132 #define TCG_TARGET_deposit_i32_valid(ofs, len) 1
 133 #endif
 134 #ifndef TCG_TARGET_deposit_i64_valid
 135 #define TCG_TARGET_deposit_i64_valid(ofs, len) 1
 136 #endif
 137 #ifndef TCG_TARGET_extract_i32_valid
 138 #define TCG_TARGET_extract_i32_valid(ofs, len) 1
 139 #endif
 140 #ifndef TCG_TARGET_extract_i64_valid
 141 #define TCG_TARGET_extract_i64_valid(ofs, len) 1
 142 #endif
 143
 144 /* Only one of DIV or DIV2 should be defined.  */
 145 #if defined(TCG_TARGET_HAS_div_i32)
 146 #define TCG_TARGET_HAS_div2_i32         0
 147 #elif defined(TCG_TARGET_HAS_div2_i32)
 148 #define TCG_TARGET_HAS_div_i32          0
 149 #define TCG_TARGET_HAS_rem_i32          0
 150 #endif
 151 #if defined(TCG_TARGET_HAS_div_i64)
 152 #define TCG_TARGET_HAS_div2_i64         0
 153 #elif defined(TCG_TARGET_HAS_div2_i64)
 154 #define TCG_TARGET_HAS_div_i64          0
 155 #define TCG_TARGET_HAS_rem_i64          0
 156 #endif
 157
 158 /* For 32-bit targets, some sort of unsigned widening multiply is required.  */
 159 #if TCG_TARGET_REG_BITS == 32 \
 160     && !(defined(TCG_TARGET_HAS_mulu2_i32) \
 161          || defined(TCG_TARGET_HAS_muluh_i32))
 162 # error "Missing unsigned widening multiply"
 163 #endif
 164
 165 #ifndef TARGET_INSN_START_EXTRA_WORDS
 166 # define TARGET_INSN_START_WORDS 1
 167 #else
 168 # define TARGET_INSN_START_WORDS (1 + TARGET_INSN_START_EXTRA_WORDS)
 169 #endif
 170
 171 typedef enum TCGOpcode {
 172 #define DEF(name, oargs, iargs, cargs, flags) INDEX_op_ ## name,
 173 #include "tcg-opc.h"
 174 #undef DEF
 175     NB_OPS,
 176 } TCGOpcode;
 177
 178 #define tcg_regset_clear(d) (d) = 0
 179 #define tcg_regset_set(d, s) (d) = (s)
 180 #define tcg_regset_set32(d, reg, val32) (d) |= (val32) << (reg)
 181 #define tcg_regset_set_reg(d, r) (d) |= 1L << (r)
 182 #define tcg_regset_reset_reg(d, r) (d) &= ~(1L << (r))
 183 #define tcg_regset_test_reg(d, r) (((d) >> (r)) & 1)
 184 #define tcg_regset_or(d, a, b) (d) = (a) | (b)
 185 #define tcg_regset_and(d, a, b) (d) = (a) & (b)
 186 #define tcg_regset_andnot(d, a, b) (d) = (a) & ~(b)
 187 #define tcg_regset_not(d, a) (d) = ~(a)
 188
 189 #ifndef TCG_TARGET_INSN_UNIT_SIZE
 190 # error "Missing TCG_TARGET_INSN_UNIT_SIZE"
 191 #elif TCG_TARGET_INSN_UNIT_SIZE == 1
 192 typedef uint8_t tcg_insn_unit;
 193 #elif TCG_TARGET_INSN_UNIT_SIZE == 2
 194 typedef uint16_t tcg_insn_unit;
 195 #elif TCG_TARGET_INSN_UNIT_SIZE == 4
 196 typedef uint32_t tcg_insn_unit;
 197 #elif TCG_TARGET_INSN_UNIT_SIZE == 8
 198 typedef uint64_t tcg_insn_unit;
 199 #else
 200 /* The port better have done this.  */
 201 #endif
 202
 203
 204 #if defined CONFIG_DEBUG_TCG || defined QEMU_STATIC_ANALYSIS
 205 # define tcg_debug_assert(X) do { assert(X); } while (0)
 206 #elif QEMU_GNUC_PREREQ(4, 5)
 207 # define tcg_debug_assert(X) \
 208     do { if (!(X)) { __builtin_unreachable(); } } while (0)
 209 #else
 210 # define tcg_debug_assert(X) do { (void)(X); } while (0)
 211 #endif
 212
 213 typedef struct TCGRelocation {
 214     struct TCGRelocation *next;
 215     int type;
 216     tcg_insn_unit *ptr;
 217     intptr_t addend;
 218 } TCGRelocation;
 219
 220 typedef struct TCGLabel {
 221     unsigned has_value : 1;
 222     unsigned id : 31;
 223     union {
 224         uintptr_t value;
 225         tcg_insn_unit *value_ptr;
 226         TCGRelocation *first_reloc;
 227     } u;
 228 } TCGLabel;
 229
 230 typedef struct TCGPool {
 231     struct TCGPool *next;
 232     int size;
 233     uint8_t data[0] __attribute__ ((aligned));
 234 } TCGPool;
 235
 236 #define TCG_POOL_CHUNK_SIZE 32768
 237
 238 #define TCG_MAX_TEMPS 512
 239 #define TCG_MAX_INSNS 512
 240
 241 /* when the size of the arguments of a called function is smaller than
 242    this value, they are statically allocated in the TB stack frame */
 243 #define TCG_STATIC_CALL_ARGS_SIZE 128
 244
 245 typedef enum TCGType {
 246     TCG_TYPE_I32,
 247     TCG_TYPE_I64,
 248     TCG_TYPE_COUNT, /* number of different types */
 249
 250     /* An alias for the size of the host register.  */
 251 #if TCG_TARGET_REG_BITS == 32
 252     TCG_TYPE_REG = TCG_TYPE_I32,
 253 #else
 254     TCG_TYPE_REG = TCG_TYPE_I64,
 255 #endif
 256
 257     /* An alias for the size of the native pointer.  */
 258 #if UINTPTR_MAX == UINT32_MAX
 259     TCG_TYPE_PTR = TCG_TYPE_I32,
 260 #else
 261     TCG_TYPE_PTR = TCG_TYPE_I64,
 262 #endif
 263
 264     /* An alias for the size of the target "long", aka register.  */
 265 #if TARGET_LONG_BITS == 64
 266     TCG_TYPE_TL = TCG_TYPE_I64,
 267 #else
 268     TCG_TYPE_TL = TCG_TYPE_I32,
 269 #endif
 270 } TCGType;
 271
 272 /* Constants for qemu_ld and qemu_st for the Memory Operation field.  */
 273 typedef enum TCGMemOp {
 274     MO_8     = 0,
 275     MO_16    = 1,
 276     MO_32    = 2,
 277     MO_64    = 3,
 278     MO_SIZE  = 3,   /* Mask for the above.  */
 279
 280     MO_SIGN  = 4,   /* Sign-extended, otherwise zero-extended.  */
 281
 282     MO_BSWAP = 8,   /* Host reverse endian.  */
 283 #ifdef HOST_WORDS_BIGENDIAN
 284     MO_LE    = MO_BSWAP,
 285     MO_BE    = 0,
 286 #else
 287     MO_LE    = 0,
 288     MO_BE    = MO_BSWAP,
 289 #endif
 290 #ifdef TARGET_WORDS_BIGENDIAN
 291     MO_TE    = MO_BE,
 292 #else
 293     MO_TE    = MO_LE,
 294 #endif
 295
 296     /* MO_UNALN accesses are never checked for alignment.
 297      * MO_ALIGN accesses will result in a call to the CPU's
 298      * do_unaligned_access hook if the guest address is not aligned.
 299      * The default depends on whether the target CPU defines ALIGNED_ONLY.
 300      *
 301      * Some architectures (e.g. ARMv8) need the address which is aligned
 302      * to a size more than the size of the memory access.
 303      * Some architectures (e.g. SPARCv9) need an address which is aligned,
 304      * but less strictly than the natural alignment.
 305      *
 306      * MO_ALIGN supposes the alignment size is the size of a memory access.
 307      *
 308      * There are three options:
 309      * - unaligned access permitted (MO_UNALN).
 310      * - an alignment to the size of an access (MO_ALIGN);
 311      * - an alignment to a specified size, which may be more or less than
 312      *   the access size (MO_ALIGN_x where 'x' is a size in bytes);
 313      */
 314     MO_ASHIFT = 4,
 315     MO_AMASK = 7 << MO_ASHIFT,
 316 #ifdef ALIGNED_ONLY
 317     MO_ALIGN = 0,
 318     MO_UNALN = MO_AMASK,
 319 #else
 320     MO_ALIGN = MO_AMASK,
 321     MO_UNALN = 0,
 322 #endif
 323     MO_ALIGN_2  = 1 << MO_ASHIFT,
 324     MO_ALIGN_4  = 2 << MO_ASHIFT,
 325     MO_ALIGN_8  = 3 << MO_ASHIFT,
 326     MO_ALIGN_16 = 4 << MO_ASHIFT,
 327     MO_ALIGN_32 = 5 << MO_ASHIFT,
 328     MO_ALIGN_64 = 6 << MO_ASHIFT,
 329
 330     /* Combinations of the above, for ease of use.  */
 331     MO_UB    = MO_8,
 332     MO_UW    = MO_16,
 333     MO_UL    = MO_32,
 334     MO_SB    = MO_SIGN | MO_8,
 335     MO_SW    = MO_SIGN | MO_16,
 336     MO_SL    = MO_SIGN | MO_32,
 337     MO_Q     = MO_64,
 338
 339     MO_LEUW  = MO_LE | MO_UW,
 340     MO_LEUL  = MO_LE | MO_UL,
 341     MO_LESW  = MO_LE | MO_SW,
 342     MO_LESL  = MO_LE | MO_SL,
 343     MO_LEQ   = MO_LE | MO_Q,
 344
 345     MO_BEUW  = MO_BE | MO_UW,
 346     MO_BEUL  = MO_BE | MO_UL,
 347     MO_BESW  = MO_BE | MO_SW,
 348     MO_BESL  = MO_BE | MO_SL,
 349     MO_BEQ   = MO_BE | MO_Q,
 350
 351     MO_TEUW  = MO_TE | MO_UW,
 352     MO_TEUL  = MO_TE | MO_UL,
 353     MO_TESW  = MO_TE | MO_SW,
 354     MO_TESL  = MO_TE | MO_SL,
 355     MO_TEQ   = MO_TE | MO_Q,
 356
 357     MO_SSIZE = MO_SIZE | MO_SIGN,
 358 } TCGMemOp;
 359
 360 /**
 361  * get_alignment_bits
 362  * @memop: TCGMemOp value
 363  *
 364  * Extract the alignment size from the memop.
 365  */
 366 static inline unsigned get_alignment_bits(TCGMemOp memop)
 367 {
 368     unsigned a = memop & MO_AMASK;
 369
 370     if (a == MO_UNALN) {
 371         /* No alignment required.  */
 372         a = 0;
 373     } else if (a == MO_ALIGN) {
 374         /* A natural alignment requirement.  */
 375         a = memop & MO_SIZE;
 376     } else {
 377         /* A specific alignment requirement.  */
 378         a = a >> MO_ASHIFT;
 379     }
 380 #if defined(CONFIG_SOFTMMU)
 381     /* The requested alignment cannot overlap the TLB flags.  */
 382     tcg_debug_assert((TLB_FLAGS_MASK & ((1 << a) - 1)) == 0);
 383 #endif
 384     return a;
 385 }
 386
 387 typedef tcg_target_ulong TCGArg;
 388
 389 /* Define type and accessor macros for TCG variables.
 390
 391    TCG variables are the inputs and outputs of TCG ops, as described
 392    in tcg/README. Target CPU front-end code uses these types to deal
 393    with TCG variables as it emits TCG code via the tcg_gen_* functions.
 394    They come in several flavours:
 395     * TCGv_i32 : 32 bit integer type
 396     * TCGv_i64 : 64 bit integer type
 397     * TCGv_ptr : a host pointer type
 398     * TCGv : an integer type the same size as target_ulong
 399              (an alias for either TCGv_i32 or TCGv_i64)
 400    The compiler's type checking will complain if you mix them
 401    up and pass the wrong sized TCGv to a function.
 402
 403    Users of tcg_gen_* don't need to know about any of the internal
 404    details of these, and should treat them as opaque types.
 405    You won't be able to look inside them in a debugger either.
 406
 407    Internal implementation details follow:
 408
 409    Note that there is no definition of the structs TCGv_i32_d etc anywhere.
 410    This is deliberate, because the values we store in variables of type
 411    TCGv_i32 are not really pointers-to-structures. They're just small
 412    integers, but keeping them in pointer types like this means that the
 413    compiler will complain if you accidentally pass a TCGv_i32 to a
 414    function which takes a TCGv_i64, and so on. Only the internals of
 415    TCG need to care about the actual contents of the types, and they always
 416    box and unbox via the MAKE_TCGV_* and GET_TCGV_* functions.
 417    Converting to and from intptr_t rather than int reduces the number
 418    of sign-extension instructions that get implied on 64-bit hosts.  */
 419
 420 typedef struct TCGv_i32_d *TCGv_i32;
 421 typedef struct TCGv_i64_d *TCGv_i64;
 422 typedef struct TCGv_ptr_d *TCGv_ptr;
 423 typedef TCGv_ptr TCGv_env;
 424 #if TARGET_LONG_BITS == 32
 425 #define TCGv TCGv_i32
 426 #elif TARGET_LONG_BITS == 64
 427 #define TCGv TCGv_i64
 428 #else
 429 #error Unhandled TARGET_LONG_BITS value
 430 #endif
 431
 432 static inline TCGv_i32 QEMU_ARTIFICIAL MAKE_TCGV_I32(intptr_t i)
 433 {
 434     return (TCGv_i32)i;
 435 }
 436
 437 static inline TCGv_i64 QEMU_ARTIFICIAL MAKE_TCGV_I64(intptr_t i)
 438 {
 439     return (TCGv_i64)i;
 440 }
 441
 442 static inline TCGv_ptr QEMU_ARTIFICIAL MAKE_TCGV_PTR(intptr_t i)
 443 {
 444     return (TCGv_ptr)i;
 445 }
 446
 447 static inline intptr_t QEMU_ARTIFICIAL GET_TCGV_I32(TCGv_i32 t)
 448 {
 449     return (intptr_t)t;
 450 }
 451
 452 static inline intptr_t QEMU_ARTIFICIAL GET_TCGV_I64(TCGv_i64 t)
 453 {
 454     return (intptr_t)t;
 455 }
 456
 457 static inline intptr_t QEMU_ARTIFICIAL GET_TCGV_PTR(TCGv_ptr t)
 458 {
 459     return (intptr_t)t;
 460 }
 461
 462 #if TCG_TARGET_REG_BITS == 32
 463 #define TCGV_LOW(t) MAKE_TCGV_I32(GET_TCGV_I64(t))
 464 #define TCGV_HIGH(t) MAKE_TCGV_I32(GET_TCGV_I64(t) + 1)
 465 #endif
 466
 467 #define TCGV_EQUAL_I32(a, b) (GET_TCGV_I32(a) == GET_TCGV_I32(b))
 468 #define TCGV_EQUAL_I64(a, b) (GET_TCGV_I64(a) == GET_TCGV_I64(b))
 469 #define TCGV_EQUAL_PTR(a, b) (GET_TCGV_PTR(a) == GET_TCGV_PTR(b))
 470
 471 /* Dummy definition to avoid compiler warnings.  */
 472 #define TCGV_UNUSED_I32(x) x = MAKE_TCGV_I32(-1)
 473 #define TCGV_UNUSED_I64(x) x = MAKE_TCGV_I64(-1)
 474 #define TCGV_UNUSED_PTR(x) x = MAKE_TCGV_PTR(-1)
 475
 476 #define TCGV_IS_UNUSED_I32(x) (GET_TCGV_I32(x) == -1)
 477 #define TCGV_IS_UNUSED_I64(x) (GET_TCGV_I64(x) == -1)
 478 #define TCGV_IS_UNUSED_PTR(x) (GET_TCGV_PTR(x) == -1)
 479
 480 /* call flags */
 481 /* Helper does not read globals (either directly or through an exception). It
 482    implies TCG_CALL_NO_WRITE_GLOBALS. */
 483 #define TCG_CALL_NO_READ_GLOBALS    0x0010
 484 /* Helper does not write globals */
 485 #define TCG_CALL_NO_WRITE_GLOBALS   0x0020
 486 /* Helper can be safely suppressed if the return value is not used. */
 487 #define TCG_CALL_NO_SIDE_EFFECTS    0x0040
 488
 489 /* convenience version of most used call flags */
 490 #define TCG_CALL_NO_RWG         TCG_CALL_NO_READ_GLOBALS
 491 #define TCG_CALL_NO_WG          TCG_CALL_NO_WRITE_GLOBALS
 492 #define TCG_CALL_NO_SE          TCG_CALL_NO_SIDE_EFFECTS
 493 #define TCG_CALL_NO_RWG_SE      (TCG_CALL_NO_RWG | TCG_CALL_NO_SE)
 494 #define TCG_CALL_NO_WG_SE       (TCG_CALL_NO_WG | TCG_CALL_NO_SE)
 495
 496 /* used to align parameters */
 497 #define TCG_CALL_DUMMY_TCGV     MAKE_TCGV_I32(-1)
 498 #define TCG_CALL_DUMMY_ARG      ((TCGArg)(-1))
 499
 500 typedef enum {
 501     /* Used to indicate the type of accesses on which ordering
 502        is to be ensured.  Modeled after SPARC barriers.  */
 503     TCG_MO_LD_LD  = 0x01,
 504     TCG_MO_ST_LD  = 0x02,
 505     TCG_MO_LD_ST  = 0x04,
 506     TCG_MO_ST_ST  = 0x08,
 507     TCG_MO_ALL    = 0x0F,  /* OR of the above */
 508
 509     /* Used to indicate the kind of ordering which is to be ensured by the
 510        instruction.  These types are derived from x86/aarch64 instructions.
 511        It should be noted that these are different from C11 semantics.  */
 512     TCG_BAR_LDAQ  = 0x10,  /* Following ops will not come forward */
 513     TCG_BAR_STRL  = 0x20,  /* Previous ops will not be delayed */
 514     TCG_BAR_SC    = 0x30,  /* No ops cross barrier; OR of the above */
 515 } TCGBar;
 516
 517 /* Conditions.  Note that these are laid out for easy manipulation by
 518    the functions below:
 519      bit 0 is used for inverting;
 520      bit 1 is signed,
 521      bit 2 is unsigned,
 522      bit 3 is used with bit 0 for swapping signed/unsigned.  */
 523 typedef enum {
 524     /* non-signed */
 525     TCG_COND_NEVER  = 0 | 0 | 0 | 0,
 526     TCG_COND_ALWAYS = 0 | 0 | 0 | 1,
 527     TCG_COND_EQ     = 8 | 0 | 0 | 0,
 528     TCG_COND_NE     = 8 | 0 | 0 | 1,
 529     /* signed */
 530     TCG_COND_LT     = 0 | 0 | 2 | 0,
 531     TCG_COND_GE     = 0 | 0 | 2 | 1,
 532     TCG_COND_LE     = 8 | 0 | 2 | 0,
 533     TCG_COND_GT     = 8 | 0 | 2 | 1,
 534     /* unsigned */
 535     TCG_COND_LTU    = 0 | 4 | 0 | 0,
 536     TCG_COND_GEU    = 0 | 4 | 0 | 1,
 537     TCG_COND_LEU    = 8 | 4 | 0 | 0,
 538     TCG_COND_GTU    = 8 | 4 | 0 | 1,
 539 } TCGCond;
 540
 541 /* Invert the sense of the comparison.  */
 542 static inline TCGCond tcg_invert_cond(TCGCond c)
 543 {
 544     return (TCGCond)(c ^ 1);
 545 }
 546
 547 /* Swap the operands in a comparison.  */
 548 static inline TCGCond tcg_swap_cond(TCGCond c)
 549 {
 550     return c & 6 ? (TCGCond)(c ^ 9) : c;
 551 }
 552
 553 /* Create an "unsigned" version of a "signed" comparison.  */
 554 static inline TCGCond tcg_unsigned_cond(TCGCond c)
 555 {
 556     return c & 2 ? (TCGCond)(c ^ 6) : c;
 557 }
 558
 559 /* Must a comparison be considered unsigned?  */
 560 static inline bool is_unsigned_cond(TCGCond c)
 561 {
 562     return (c & 4) != 0;
 563 }
 564
 565 /* Create a "high" version of a double-word comparison.
 566    This removes equality from a LTE or GTE comparison.  */
 567 static inline TCGCond tcg_high_cond(TCGCond c)
 568 {
 569     switch (c) {
 570     case TCG_COND_GE:
 571     case TCG_COND_LE:
 572     case TCG_COND_GEU:
 573     case TCG_COND_LEU:
 574         return (TCGCond)(c ^ 8);
 575     default:
 576         return c;
 577     }
 578 }
 579
 580 typedef enum TCGTempVal {
 581     TEMP_VAL_DEAD,
 582     TEMP_VAL_REG,
 583     TEMP_VAL_MEM,
 584     TEMP_VAL_CONST,
 585 } TCGTempVal;
 586
 587 typedef struct TCGTemp {
 588     TCGReg reg:8;
 589     TCGTempVal val_type:8;
 590     TCGType base_type:8;
 591     TCGType type:8;
 592     unsigned int fixed_reg:1;
 593     unsigned int indirect_reg:1;
 594     unsigned int indirect_base:1;
 595     unsigned int mem_coherent:1;
 596     unsigned int mem_allocated:1;
 597     unsigned int temp_local:1; /* If true, the temp is saved across
 598                                   basic blocks. Otherwise, it is not
 599                                   preserved across basic blocks. */
 600     unsigned int temp_allocated:1; /* never used for code gen */
 601
 602     tcg_target_long val;
 603     struct TCGTemp *mem_base;
 604     intptr_t mem_offset;
 605     const char *name;
 606 } TCGTemp;
 607
 608 typedef struct TCGContext TCGContext;
 609
 610 typedef struct TCGTempSet {
 611     unsigned long l[BITS_TO_LONGS(TCG_MAX_TEMPS)];
 612 } TCGTempSet;
 613
 614 /* While we limit helpers to 6 arguments, for 32-bit hosts, with padding,
 615    this imples a max of 6*2 (64-bit in) + 2 (64-bit out) = 14 operands.
 616    There are never more than 2 outputs, which means that we can store all
 617    dead + sync data within 16 bits.  */
 618 #define DEAD_ARG  4
 619 #define SYNC_ARG  1
 620 typedef uint16_t TCGLifeData;
 621
 622 /* The layout here is designed to avoid crossing of a 32-bit boundary.
 623    If we do so, gcc adds padding, expanding the size to 12.  */
 624 typedef struct TCGOp {
 625     TCGOpcode opc   : 8;        /*  8 */
 626
 627     /* Index of the prev/next op, or 0 for the end of the list.  */
 628     unsigned prev   : 10;       /* 18 */
 629     unsigned next   : 10;       /* 28 */
 630
 631     /* The number of out and in parameter for a call.  */
 632     unsigned calli  : 4;        /* 32 */
 633     unsigned callo  : 2;        /* 34 */
 634
 635     /* Index of the arguments for this op, or 0 for zero-operand ops.  */
 636     unsigned args   : 14;       /* 48 */
 637
 638     /* Lifetime data of the operands.  */
 639     unsigned life   : 16;       /* 64 */
 640 } TCGOp;
 641
 642 /* Make sure operands fit in the bitfields above.  */
 643 QEMU_BUILD_BUG_ON(NB_OPS > (1 << 8));
 644 QEMU_BUILD_BUG_ON(OPC_BUF_SIZE > (1 << 10));
 645 QEMU_BUILD_BUG_ON(OPPARAM_BUF_SIZE > (1 << 14));
 646
 647 /* Make sure that we don't overflow 64 bits without noticing.  */
 648 QEMU_BUILD_BUG_ON(sizeof(TCGOp) > 8);
 649
 650 struct TCGContext {
 651     uint8_t *pool_cur, *pool_end;
 652     TCGPool *pool_first, *pool_current, *pool_first_large;
 653     int nb_labels;
 654     int nb_globals;
 655     int nb_temps;
 656     int nb_indirects;
 657
 658     /* goto_tb support */
 659     tcg_insn_unit *code_buf;
 660     uint16_t *tb_jmp_reset_offset; /* tb->jmp_reset_offset */
 661     uint16_t *tb_jmp_insn_offset; /* tb->jmp_insn_offset if USE_DIRECT_JUMP */
 662     uintptr_t *tb_jmp_target_addr; /* tb->jmp_target_addr if !USE_DIRECT_JUMP */
 663
 664     TCGRegSet reserved_regs;
 665     intptr_t current_frame_offset;
 666     intptr_t frame_start;
 667     intptr_t frame_end;
 668     TCGTemp *frame_temp;
 669
 670     tcg_insn_unit *code_ptr;
 671
 672     GHashTable *helpers;
 673
 674 #ifdef CONFIG_PROFILER
 675     /* profiling info */
 676     int64_t tb_count1;
 677     int64_t tb_count;
 678     int64_t op_count; /* total insn count */
 679     int op_count_max; /* max insn per TB */
 680     int64_t temp_count;
 681     int temp_count_max;
 682     int64_t del_op_count;
 683     int64_t code_in_len;
 684     int64_t code_out_len;
 685     int64_t search_out_len;
 686     int64_t interm_time;
 687     int64_t code_time;
 688     int64_t la_time;
 689     int64_t opt_time;
 690     int64_t restore_count;
 691     int64_t restore_time;
 692 #endif
 693
 694 #ifdef CONFIG_DEBUG_TCG
 695     int temps_in_use;
 696     int goto_tb_issue_mask;
 697 #endif
 698
 699     int gen_next_op_idx;
 700     int gen_next_parm_idx;
 701
 702     /* Code generation.  Note that we specifically do not use tcg_insn_unit
 703        here, because there's too much arithmetic throughout that relies
 704        on addition and subtraction working on bytes.  Rely on the GCC
 705        extension that allows arithmetic on void*.  */
 706     int code_gen_max_blocks;
 707     void *code_gen_prologue;
 708     void *code_gen_buffer;
 709     size_t code_gen_buffer_size;
 710     void *code_gen_ptr;
 711
 712     /* Threshold to flush the translated code buffer.  */
 713     void *code_gen_highwater;
 714
 715     TBContext tb_ctx;
 716
 717     /* Track which vCPU triggers events */
 718     CPUState *cpu;                      /* *_trans */
 719     TCGv_env tcg_env;                   /* *_exec  */
 720
 721     /* The TCGBackendData structure is private to tcg-target.inc.c.  */
 722     struct TCGBackendData *be;
 723
 724     TCGTempSet free_temps[TCG_TYPE_COUNT * 2];
 725     TCGTemp temps[TCG_MAX_TEMPS]; /* globals first, temps after */
 726
 727     /* Tells which temporary holds a given register.
 728        It does not take into account fixed registers */
 729     TCGTemp *reg_to_temp[TCG_TARGET_NB_REGS];
 730
 731     TCGOp gen_op_buf[OPC_BUF_SIZE];
 732     TCGArg gen_opparam_buf[OPPARAM_BUF_SIZE];
 733
 734     uint16_t gen_insn_end_off[TCG_MAX_INSNS];
 735     target_ulong gen_insn_data[TCG_MAX_INSNS][TARGET_INSN_START_WORDS];
 736 };
 737
 738 extern TCGContext tcg_ctx;
 739 extern bool parallel_cpus;
 740
 741 static inline void tcg_set_insn_param(int op_idx, int arg, TCGArg v)
 742 {
 743     int op_argi = tcg_ctx.gen_op_buf[op_idx].args;
 744     tcg_ctx.gen_opparam_buf[op_argi + arg] = v;
 745 }
 746
 747 /* The number of opcodes emitted so far.  */
 748 static inline int tcg_op_buf_count(void)
 749 {
 750     return tcg_ctx.gen_next_op_idx;
 751 }
 752
 753 /* Test for whether to terminate the TB for using too many opcodes.  */
 754 static inline bool tcg_op_buf_full(void)
 755 {
 756     return tcg_op_buf_count() >= OPC_MAX_SIZE;
 757 }
 758
 759 /* pool based memory allocation */
 760
 761 /* tb_lock must be held for tcg_malloc_internal. */
 762 void *tcg_malloc_internal(TCGContext *s, int size);
 763 void tcg_pool_reset(TCGContext *s);
 764
 765 void tb_lock(void);
 766 void tb_unlock(void);
 767 void tb_lock_reset(void);
 768
 769 /* Called with tb_lock held.  */
 770 static inline void *tcg_malloc(int size)
 771 {
 772     TCGContext *s = &tcg_ctx;
 773     uint8_t *ptr, *ptr_end;
 774     size = (size + sizeof(long) - 1) & ~(sizeof(long) - 1);
 775     ptr = s->pool_cur;
 776     ptr_end = ptr + size;
 777     if (unlikely(ptr_end > s->pool_end)) {
 778         return tcg_malloc_internal(&tcg_ctx, size);
 779     } else {
 780         s->pool_cur = ptr_end;
 781         return ptr;
 782     }
 783 }
 784
 785 void tcg_context_init(TCGContext *s);
 786 void tcg_prologue_init(TCGContext *s);
 787 void tcg_func_start(TCGContext *s);
 788
 789 int tcg_gen_code(TCGContext *s, TranslationBlock *tb);
 790
 791 void tcg_set_frame(TCGContext *s, TCGReg reg, intptr_t start, intptr_t size);
 792
 793 int tcg_global_mem_new_internal(TCGType, TCGv_ptr, intptr_t, const char *);
 794
 795 TCGv_i32 tcg_global_reg_new_i32(TCGReg reg, const char *name);
 796 TCGv_i64 tcg_global_reg_new_i64(TCGReg reg, const char *name);
 797
 798 TCGv_i32 tcg_temp_new_internal_i32(int temp_local);
 799 TCGv_i64 tcg_temp_new_internal_i64(int temp_local);
 800
 801 void tcg_temp_free_i32(TCGv_i32 arg);
 802 void tcg_temp_free_i64(TCGv_i64 arg);
 803
 804 static inline TCGv_i32 tcg_global_mem_new_i32(TCGv_ptr reg, intptr_t offset,
 805                                               const char *name)
 806 {
 807     int idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name);
 808     return MAKE_TCGV_I32(idx);
 809 }
 810
 811 static inline TCGv_i32 tcg_temp_new_i32(void)
 812 {
 813     return tcg_temp_new_internal_i32(0);
 814 }
 815
 816 static inline TCGv_i32 tcg_temp_local_new_i32(void)
 817 {
 818     return tcg_temp_new_internal_i32(1);
 819 }
 820
 821 static inline TCGv_i64 tcg_global_mem_new_i64(TCGv_ptr reg, intptr_t offset,
 822                                               const char *name)
 823 {
 824     int idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name);
 825     return MAKE_TCGV_I64(idx);
 826 }
 827
 828 static inline TCGv_i64 tcg_temp_new_i64(void)
 829 {
 830     return tcg_temp_new_internal_i64(0);
 831 }
 832
 833 static inline TCGv_i64 tcg_temp_local_new_i64(void)
 834 {
 835     return tcg_temp_new_internal_i64(1);
 836 }
 837
 838 #if defined(CONFIG_DEBUG_TCG)
 839 /* If you call tcg_clear_temp_count() at the start of a section of
 840  * code which is not supposed to leak any TCG temporaries, then
 841  * calling tcg_check_temp_count() at the end of the section will
 842  * return 1 if the section did in fact leak a temporary.
 843  */
 844 void tcg_clear_temp_count(void);
 845 int tcg_check_temp_count(void);
 846 #else
 847 #define tcg_clear_temp_count() do { } while (0)
 848 #define tcg_check_temp_count() 0
 849 #endif
 850
 851 void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf);
 852 void tcg_dump_op_count(FILE *f, fprintf_function cpu_fprintf);
 853
 854 #define TCG_CT_ALIAS  0x80
 855 #define TCG_CT_IALIAS 0x40
 856 #define TCG_CT_NEWREG 0x20 /* output requires a new register */
 857 #define TCG_CT_REG    0x01
 858 #define TCG_CT_CONST  0x02 /* any constant of register size */
 859
 860 typedef struct TCGArgConstraint {
 861     uint16_t ct;
 862     uint8_t alias_index;
 863     union {
 864         TCGRegSet regs;
 865     } u;
 866 } TCGArgConstraint;
 867
 868 #define TCG_MAX_OP_ARGS 16
 869
 870 /* Bits for TCGOpDef->flags, 8 bits available.  */
 871 enum {
 872     /* Instruction defines the end of a basic block.  */
 873     TCG_OPF_BB_END       = 0x01,
 874     /* Instruction clobbers call registers and potentially update globals.  */
 875     TCG_OPF_CALL_CLOBBER = 0x02,
 876     /* Instruction has side effects: it cannot be removed if its outputs
 877        are not used, and might trigger exceptions.  */
 878     TCG_OPF_SIDE_EFFECTS = 0x04,
 879     /* Instruction operands are 64-bits (otherwise 32-bits).  */
 880     TCG_OPF_64BIT        = 0x08,
 881     /* Instruction is optional and not implemented by the host, or insn
 882        is generic and should not be implemened by the host.  */
 883     TCG_OPF_NOT_PRESENT  = 0x10,
 884 };
 885
 886 typedef struct TCGOpDef {
 887     const char *name;
 888     uint8_t nb_oargs, nb_iargs, nb_cargs, nb_args;
 889     uint8_t flags;
 890     TCGArgConstraint *args_ct;
 891     int *sorted_args;
 892 #if defined(CONFIG_DEBUG_TCG)
 893     int used;
 894 #endif
 895 } TCGOpDef;
 896
 897 extern TCGOpDef tcg_op_defs[];
 898 extern const size_t tcg_op_defs_max;
 899
 900 typedef struct TCGTargetOpDef {
 901     TCGOpcode op;
 902     const char *args_ct_str[TCG_MAX_OP_ARGS];
 903 } TCGTargetOpDef;
 904
 905 #define tcg_abort() \
 906 do {\
 907     fprintf(stderr, "%s:%d: tcg fatal error\n", __FILE__, __LINE__);\
 908     abort();\
 909 } while (0)
 910
 911 #if UINTPTR_MAX == UINT32_MAX
 912 #define TCGV_NAT_TO_PTR(n) MAKE_TCGV_PTR(GET_TCGV_I32(n))
 913 #define TCGV_PTR_TO_NAT(n) MAKE_TCGV_I32(GET_TCGV_PTR(n))
 914
 915 #define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i32((intptr_t)(V)))
 916 #define tcg_global_reg_new_ptr(R, N) \
 917     TCGV_NAT_TO_PTR(tcg_global_reg_new_i32((R), (N)))
 918 #define tcg_global_mem_new_ptr(R, O, N) \
 919     TCGV_NAT_TO_PTR(tcg_global_mem_new_i32((R), (O), (N)))
 920 #define tcg_temp_new_ptr() TCGV_NAT_TO_PTR(tcg_temp_new_i32())
 921 #define tcg_temp_free_ptr(T) tcg_temp_free_i32(TCGV_PTR_TO_NAT(T))
 922 #else
 923 #define TCGV_NAT_TO_PTR(n) MAKE_TCGV_PTR(GET_TCGV_I64(n))
 924 #define TCGV_PTR_TO_NAT(n) MAKE_TCGV_I64(GET_TCGV_PTR(n))
 925
 926 #define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i64((intptr_t)(V)))
 927 #define tcg_global_reg_new_ptr(R, N) \
 928     TCGV_NAT_TO_PTR(tcg_global_reg_new_i64((R), (N)))
 929 #define tcg_global_mem_new_ptr(R, O, N) \
 930     TCGV_NAT_TO_PTR(tcg_global_mem_new_i64((R), (O), (N)))
 931 #define tcg_temp_new_ptr() TCGV_NAT_TO_PTR(tcg_temp_new_i64())
 932 #define tcg_temp_free_ptr(T) tcg_temp_free_i64(TCGV_PTR_TO_NAT(T))
 933 #endif
 934
 935 void tcg_gen_callN(TCGContext *s, void *func,
 936                    TCGArg ret, int nargs, TCGArg *args);
 937
 938 void tcg_op_remove(TCGContext *s, TCGOp *op);
 939 TCGOp *tcg_op_insert_before(TCGContext *s, TCGOp *op, TCGOpcode opc, int narg);
 940 TCGOp *tcg_op_insert_after(TCGContext *s, TCGOp *op, TCGOpcode opc, int narg);
 941
 942 void tcg_optimize(TCGContext *s);
 943
 944 /* only used for debugging purposes */
 945 void tcg_dump_ops(TCGContext *s);
 946
 947 TCGv_i32 tcg_const_i32(int32_t val);
 948 TCGv_i64 tcg_const_i64(int64_t val);
 949 TCGv_i32 tcg_const_local_i32(int32_t val);
 950 TCGv_i64 tcg_const_local_i64(int64_t val);
 951
 952 TCGLabel *gen_new_label(void);
 953
 954 /**
 955  * label_arg
 956  * @l: label
 957  *
 958  * Encode a label for storage in the TCG opcode stream.
 959  */
 960
 961 static inline TCGArg label_arg(TCGLabel *l)
 962 {
 963     return (uintptr_t)l;
 964 }
 965
 966 /**
 967  * arg_label
 968  * @i: value
 969  *
 970  * The opposite of label_arg.  Retrieve a label from the
 971  * encoding of the TCG opcode stream.
 972  */
 973
 974 static inline TCGLabel *arg_label(TCGArg i)
 975 {
 976     return (TCGLabel *)(uintptr_t)i;
 977 }
 978
 979 /**
 980  * tcg_ptr_byte_diff
 981  * @a, @b: addresses to be differenced
 982  *
 983  * There are many places within the TCG backends where we need a byte
 984  * difference between two pointers.  While this can be accomplished
 985  * with local casting, it's easy to get wrong -- especially if one is
 986  * concerned with the signedness of the result.
 987  *
 988  * This version relies on GCC's void pointer arithmetic to get the
 989  * correct result.
 990  */
 991
 992 static inline ptrdiff_t tcg_ptr_byte_diff(void *a, void *b)
 993 {
 994     return a - b;
 995 }
 996
 997 /**
 998  * tcg_pcrel_diff
 999  * @s: the tcg context
1000  * @target: address of the target
1001  *
1002  * Produce a pc-relative difference, from the current code_ptr
1003  * to the destination address.
1004  */
1005
1006 static inline ptrdiff_t tcg_pcrel_diff(TCGContext *s, void *target)
1007 {
1008     return tcg_ptr_byte_diff(target, s->code_ptr);
1009 }
1010
1011 /**
1012  * tcg_current_code_size
1013  * @s: the tcg context
1014  *
1015  * Compute the current code size within the translation block.
1016  * This is used to fill in qemu's data structures for goto_tb.
1017  */
1018
1019 static inline size_t tcg_current_code_size(TCGContext *s)
1020 {
1021     return tcg_ptr_byte_diff(s->code_ptr, s->code_buf);
1022 }
1023
1024 /* Combine the TCGMemOp and mmu_idx parameters into a single value.  */
1025 typedef uint32_t TCGMemOpIdx;
1026
1027 /**
1028  * make_memop_idx
1029  * @op: memory operation
1030  * @idx: mmu index
1031  *
1032  * Encode these values into a single parameter.
1033  */
1034 static inline TCGMemOpIdx make_memop_idx(TCGMemOp op, unsigned idx)
1035 {
1036     tcg_debug_assert(idx <= 15);
1037     return (op << 4) | idx;
1038 }
1039
1040 /**
1041  * get_memop
1042  * @oi: combined op/idx parameter
1043  *
1044  * Extract the memory operation from the combined value.
1045  */
1046 static inline TCGMemOp get_memop(TCGMemOpIdx oi)
1047 {
1048     return oi >> 4;
1049 }
1050
1051 /**
1052  * get_mmuidx
1053  * @oi: combined op/idx parameter
1054  *
1055  * Extract the mmu index from the combined value.
1056  */
1057 static inline unsigned get_mmuidx(TCGMemOpIdx oi)
1058 {
1059     return oi & 15;
1060 }
1061
1062 /**
1063  * tcg_qemu_tb_exec:
1064  * @env: pointer to CPUArchState for the CPU
1065  * @tb_ptr: address of generated code for the TB to execute
1066  *
1067  * Start executing code from a given translation block.
1068  * Where translation blocks have been linked, execution
1069  * may proceed from the given TB into successive ones.
1070  * Control eventually returns only when some action is needed
1071  * from the top-level loop: either control must pass to a TB
1072  * which has not yet been directly linked, or an asynchronous
1073  * event such as an interrupt needs handling.
1074  *
1075  * Return: The return value is the value passed to the corresponding
1076  * tcg_gen_exit_tb() at translation time of the last TB attempted to execute.
1077  * The value is either zero or a 4-byte aligned pointer to that TB combined
1078  * with additional information in its two least significant bits. The
1079  * additional information is encoded as follows:
1080  *  0, 1: the link between this TB and the next is via the specified
1081  *        TB index (0 or 1). That is, we left the TB via (the equivalent
1082  *        of) "goto_tb <index>". The main loop uses this to determine
1083  *        how to link the TB just executed to the next.
1084  *  2:    we are using instruction counting code generation, and we
1085  *        did not start executing this TB because the instruction counter
1086  *        would hit zero midway through it. In this case the pointer
1087  *        returned is the TB we were about to execute, and the caller must
1088  *        arrange to execute the remaining count of instructions.
1089  *  3:    we stopped because the CPU's exit_request flag was set
1090  *        (usually meaning that there is an interrupt that needs to be
1091  *        handled). The pointer returned is the TB we were about to execute
1092  *        when we noticed the pending exit request.
1093  *
1094  * If the bottom two bits indicate an exit-via-index then the CPU
1095  * state is correctly synchronised and ready for execution of the next
1096  * TB (and in particular the guest PC is the address to execute next).
1097  * Otherwise, we gave up on execution of this TB before it started, and
1098  * the caller must fix up the CPU state by calling the CPU's
1099  * synchronize_from_tb() method with the TB pointer we return (falling
1100  * back to calling the CPU's set_pc method with tb->pb if no
1101  * synchronize_from_tb() method exists).
1102  *
1103  * Note that TCG targets may use a different definition of tcg_qemu_tb_exec
1104  * to this default (which just calls the prologue.code emitted by
1105  * tcg_target_qemu_prologue()).
1106  */
1107 #define TB_EXIT_MASK 3
1108 #define TB_EXIT_IDX0 0
1109 #define TB_EXIT_IDX1 1
1110 #define TB_EXIT_ICOUNT_EXPIRED 2
1111 #define TB_EXIT_REQUESTED 3
1112
1113 #ifdef HAVE_TCG_QEMU_TB_EXEC
1114 uintptr_t tcg_qemu_tb_exec(CPUArchState *env, uint8_t *tb_ptr);
1115 #else
1116 # define tcg_qemu_tb_exec(env, tb_ptr) \
1117     ((uintptr_t (*)(void *, void *))tcg_ctx.code_gen_prologue)(env, tb_ptr)
1118 #endif
1119
1120 void tcg_register_jit(void *buf, size_t buf_size);
1121
1122 /*
1123  * Memory helpers that will be used by TCG generated code.
1124  */
1125 #ifdef CONFIG_SOFTMMU
1126 /* Value zero-extended to tcg register size.  */
1127 tcg_target_ulong helper_ret_ldub_mmu(CPUArchState *env, target_ulong addr,
1128                                      TCGMemOpIdx oi, uintptr_t retaddr);
1129 tcg_target_ulong helper_le_lduw_mmu(CPUArchState *env, target_ulong addr,
1130                                     TCGMemOpIdx oi, uintptr_t retaddr);
1131 tcg_target_ulong helper_le_ldul_mmu(CPUArchState *env, target_ulong addr,
1132                                     TCGMemOpIdx oi, uintptr_t retaddr);
1133 uint64_t helper_le_ldq_mmu(CPUArchState *env, target_ulong addr,
1134                            TCGMemOpIdx oi, uintptr_t retaddr);
1135 tcg_target_ulong helper_be_lduw_mmu(CPUArchState *env, target_ulong addr,
1136                                     TCGMemOpIdx oi, uintptr_t retaddr);
1137 tcg_target_ulong helper_be_ldul_mmu(CPUArchState *env, target_ulong addr,
1138                                     TCGMemOpIdx oi, uintptr_t retaddr);
1139 uint64_t helper_be_ldq_mmu(CPUArchState *env, target_ulong addr,
1140                            TCGMemOpIdx oi, uintptr_t retaddr);
1141
1142 /* Value sign-extended to tcg register size.  */
1143 tcg_target_ulong helper_ret_ldsb_mmu(CPUArchState *env, target_ulong addr,
1144                                      TCGMemOpIdx oi, uintptr_t retaddr);
1145 tcg_target_ulong helper_le_ldsw_mmu(CPUArchState *env, target_ulong addr,
1146                                     TCGMemOpIdx oi, uintptr_t retaddr);
1147 tcg_target_ulong helper_le_ldsl_mmu(CPUArchState *env, target_ulong addr,
1148                                     TCGMemOpIdx oi, uintptr_t retaddr);
1149 tcg_target_ulong helper_be_ldsw_mmu(CPUArchState *env, target_ulong addr,
1150                                     TCGMemOpIdx oi, uintptr_t retaddr);
1151 tcg_target_ulong helper_be_ldsl_mmu(CPUArchState *env, target_ulong addr,
1152                                     TCGMemOpIdx oi, uintptr_t retaddr);
1153
1154 void helper_ret_stb_mmu(CPUArchState *env, target_ulong addr, uint8_t val,
1155                         TCGMemOpIdx oi, uintptr_t retaddr);
1156 void helper_le_stw_mmu(CPUArchState *env, target_ulong addr, uint16_t val,
1157                        TCGMemOpIdx oi, uintptr_t retaddr);
1158 void helper_le_stl_mmu(CPUArchState *env, target_ulong addr, uint32_t val,
1159                        TCGMemOpIdx oi, uintptr_t retaddr);
1160 void helper_le_stq_mmu(CPUArchState *env, target_ulong addr, uint64_t val,
1161                        TCGMemOpIdx oi, uintptr_t retaddr);
1162 void helper_be_stw_mmu(CPUArchState *env, target_ulong addr, uint16_t val,
1163                        TCGMemOpIdx oi, uintptr_t retaddr);
1164 void helper_be_stl_mmu(CPUArchState *env, target_ulong addr, uint32_t val,
1165                        TCGMemOpIdx oi, uintptr_t retaddr);
1166 void helper_be_stq_mmu(CPUArchState *env, target_ulong addr, uint64_t val,
1167                        TCGMemOpIdx oi, uintptr_t retaddr);
1168
1169 uint8_t helper_ret_ldb_cmmu(CPUArchState *env, target_ulong addr,
1170                             TCGMemOpIdx oi, uintptr_t retaddr);
1171 uint16_t helper_le_ldw_cmmu(CPUArchState *env, target_ulong addr,
1172                             TCGMemOpIdx oi, uintptr_t retaddr);
1173 uint32_t helper_le_ldl_cmmu(CPUArchState *env, target_ulong addr,
1174                             TCGMemOpIdx oi, uintptr_t retaddr);
1175 uint64_t helper_le_ldq_cmmu(CPUArchState *env, target_ulong addr,
1176                             TCGMemOpIdx oi, uintptr_t retaddr);
1177 uint16_t helper_be_ldw_cmmu(CPUArchState *env, target_ulong addr,
1178                             TCGMemOpIdx oi, uintptr_t retaddr);
1179 uint32_t helper_be_ldl_cmmu(CPUArchState *env, target_ulong addr,
1180                             TCGMemOpIdx oi, uintptr_t retaddr);
1181 uint64_t helper_be_ldq_cmmu(CPUArchState *env, target_ulong addr,
1182                             TCGMemOpIdx oi, uintptr_t retaddr);
1183
1184 /* Temporary aliases until backends are converted.  */
1185 #ifdef TARGET_WORDS_BIGENDIAN
1186 # define helper_ret_ldsw_mmu  helper_be_ldsw_mmu
1187 # define helper_ret_lduw_mmu  helper_be_lduw_mmu
1188 # define helper_ret_ldsl_mmu  helper_be_ldsl_mmu
1189 # define helper_ret_ldul_mmu  helper_be_ldul_mmu
1190 # define helper_ret_ldl_mmu   helper_be_ldul_mmu
1191 # define helper_ret_ldq_mmu   helper_be_ldq_mmu
1192 # define helper_ret_stw_mmu   helper_be_stw_mmu
1193 # define helper_ret_stl_mmu   helper_be_stl_mmu
1194 # define helper_ret_stq_mmu   helper_be_stq_mmu
1195 # define helper_ret_ldw_cmmu  helper_be_ldw_cmmu
1196 # define helper_ret_ldl_cmmu  helper_be_ldl_cmmu
1197 # define helper_ret_ldq_cmmu  helper_be_ldq_cmmu
1198 #else
1199 # define helper_ret_ldsw_mmu  helper_le_ldsw_mmu
1200 # define helper_ret_lduw_mmu  helper_le_lduw_mmu
1201 # define helper_ret_ldsl_mmu  helper_le_ldsl_mmu
1202 # define helper_ret_ldul_mmu  helper_le_ldul_mmu
1203 # define helper_ret_ldl_mmu   helper_le_ldul_mmu
1204 # define helper_ret_ldq_mmu   helper_le_ldq_mmu
1205 # define helper_ret_stw_mmu   helper_le_stw_mmu
1206 # define helper_ret_stl_mmu   helper_le_stl_mmu
1207 # define helper_ret_stq_mmu   helper_le_stq_mmu
1208 # define helper_ret_ldw_cmmu  helper_le_ldw_cmmu
1209 # define helper_ret_ldl_cmmu  helper_le_ldl_cmmu
1210 # define helper_ret_ldq_cmmu  helper_le_ldq_cmmu
1211 #endif
1212
1213 uint32_t helper_atomic_cmpxchgb_mmu(CPUArchState *env, target_ulong addr,
1214                                     uint32_t cmpv, uint32_t newv,
1215                                     TCGMemOpIdx oi, uintptr_t retaddr);
1216 uint32_t helper_atomic_cmpxchgw_le_mmu(CPUArchState *env, target_ulong addr,
1217                                        uint32_t cmpv, uint32_t newv,
1218                                        TCGMemOpIdx oi, uintptr_t retaddr);
1219 uint32_t helper_atomic_cmpxchgl_le_mmu(CPUArchState *env, target_ulong addr,
1220                                        uint32_t cmpv, uint32_t newv,
1221                                        TCGMemOpIdx oi, uintptr_t retaddr);
1222 uint64_t helper_atomic_cmpxchgq_le_mmu(CPUArchState *env, target_ulong addr,
1223                                        uint64_t cmpv, uint64_t newv,
1224                                        TCGMemOpIdx oi, uintptr_t retaddr);
1225 uint32_t helper_atomic_cmpxchgw_be_mmu(CPUArchState *env, target_ulong addr,
1226                                        uint32_t cmpv, uint32_t newv,
1227                                        TCGMemOpIdx oi, uintptr_t retaddr);
1228 uint32_t helper_atomic_cmpxchgl_be_mmu(CPUArchState *env, target_ulong addr,
1229                                        uint32_t cmpv, uint32_t newv,
1230                                        TCGMemOpIdx oi, uintptr_t retaddr);
1231 uint64_t helper_atomic_cmpxchgq_be_mmu(CPUArchState *env, target_ulong addr,
1232                                        uint64_t cmpv, uint64_t newv,
1233                                        TCGMemOpIdx oi, uintptr_t retaddr);
1234
1235 #define GEN_ATOMIC_HELPER(NAME, TYPE, SUFFIX)         \
1236 TYPE helper_atomic_ ## NAME ## SUFFIX ## _mmu         \
1237     (CPUArchState *env, target_ulong addr, TYPE val,  \
1238      TCGMemOpIdx oi, uintptr_t retaddr);
1239
1240 #ifdef CONFIG_ATOMIC64
1241 #define GEN_ATOMIC_HELPER_ALL(NAME)          \
1242     GEN_ATOMIC_HELPER(NAME, uint32_t, b)     \
1243     GEN_ATOMIC_HELPER(NAME, uint32_t, w_le)  \
1244     GEN_ATOMIC_HELPER(NAME, uint32_t, w_be)  \
1245     GEN_ATOMIC_HELPER(NAME, uint32_t, l_le)  \
1246     GEN_ATOMIC_HELPER(NAME, uint32_t, l_be)  \
1247     GEN_ATOMIC_HELPER(NAME, uint64_t, q_le)  \
1248     GEN_ATOMIC_HELPER(NAME, uint64_t, q_be)
1249 #else
1250 #define GEN_ATOMIC_HELPER_ALL(NAME)          \
1251     GEN_ATOMIC_HELPER(NAME, uint32_t, b)     \
1252     GEN_ATOMIC_HELPER(NAME, uint32_t, w_le)  \
1253     GEN_ATOMIC_HELPER(NAME, uint32_t, w_be)  \
1254     GEN_ATOMIC_HELPER(NAME, uint32_t, l_le)  \
1255     GEN_ATOMIC_HELPER(NAME, uint32_t, l_be)
1256 #endif
1257
1258 GEN_ATOMIC_HELPER_ALL(fetch_add)
1259 GEN_ATOMIC_HELPER_ALL(fetch_sub)
1260 GEN_ATOMIC_HELPER_ALL(fetch_and)
1261 GEN_ATOMIC_HELPER_ALL(fetch_or)
1262 GEN_ATOMIC_HELPER_ALL(fetch_xor)
1263
1264 GEN_ATOMIC_HELPER_ALL(add_fetch)
1265 GEN_ATOMIC_HELPER_ALL(sub_fetch)
1266 GEN_ATOMIC_HELPER_ALL(and_fetch)
1267 GEN_ATOMIC_HELPER_ALL(or_fetch)
1268 GEN_ATOMIC_HELPER_ALL(xor_fetch)
1269
1270 GEN_ATOMIC_HELPER_ALL(xchg)
1271
1272 #undef GEN_ATOMIC_HELPER_ALL
1273 #undef GEN_ATOMIC_HELPER
1274 #endif /* CONFIG_SOFTMMU */
1275
1276 #ifdef CONFIG_ATOMIC128
1277 #include "qemu/int128.h"
1278
1279 /* These aren't really a "proper" helpers because TCG cannot manage Int128.
1280    However, use the same format as the others, for use by the backends. */
1281 Int128 helper_atomic_cmpxchgo_le_mmu(CPUArchState *env, target_ulong addr,
1282                                      Int128 cmpv, Int128 newv,
1283                                      TCGMemOpIdx oi, uintptr_t retaddr);
1284 Int128 helper_atomic_cmpxchgo_be_mmu(CPUArchState *env, target_ulong addr,
1285                                      Int128 cmpv, Int128 newv,
1286                                      TCGMemOpIdx oi, uintptr_t retaddr);
1287
1288 Int128 helper_atomic_ldo_le_mmu(CPUArchState *env, target_ulong addr,
1289                                 TCGMemOpIdx oi, uintptr_t retaddr);
1290 Int128 helper_atomic_ldo_be_mmu(CPUArchState *env, target_ulong addr,
1291                                 TCGMemOpIdx oi, uintptr_t retaddr);
1292 void helper_atomic_sto_le_mmu(CPUArchState *env, target_ulong addr, Int128 val,
1293                               TCGMemOpIdx oi, uintptr_t retaddr);
1294 void helper_atomic_sto_be_mmu(CPUArchState *env, target_ulong addr, Int128 val,
1295                               TCGMemOpIdx oi, uintptr_t retaddr);
1296
1297 #endif /* CONFIG_ATOMIC128 */
1298
1299 #endif /* TCG_H */