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 "tcg-target.h"
  25
  26 #if TCG_TARGET_REG_BITS == 32
  27 typedef int32_t tcg_target_long;
  28 typedef uint32_t tcg_target_ulong;
  29 #define TCG_PRIlx PRIx32
  30 #define TCG_PRIld PRId32
  31 #elif TCG_TARGET_REG_BITS == 64
  32 typedef int64_t tcg_target_long;
  33 typedef uint64_t tcg_target_ulong;
  34 #define TCG_PRIlx PRIx64
  35 #define TCG_PRIld PRId64
  36 #else
  37 #error unsupported
  38 #endif
  39
  40 #if TCG_TARGET_NB_REGS <= 32
  41 typedef uint32_t TCGRegSet;
  42 #elif TCG_TARGET_NB_REGS <= 64
  43 typedef uint64_t TCGRegSet;
  44 #else
  45 #error unsupported
  46 #endif
  47
  48 enum {
  49 #define DEF(s, n, copy_size) INDEX_op_ ## s,
  50 #include "tcg-opc.h"
  51 #undef DEF
  52     NB_OPS,
  53 };
  54
  55 #define tcg_regset_clear(d) (d) = 0
  56 #define tcg_regset_set(d, s) (d) = (s)
  57 #define tcg_regset_set32(d, reg, val32) (d) |= (val32) << (reg)
  58 #define tcg_regset_set_reg(d, r) (d) |= 1 << (r)
  59 #define tcg_regset_reset_reg(d, r) (d) &= ~(1 << (r))
  60 #define tcg_regset_test_reg(d, r) (((d) >> (r)) & 1)
  61 #define tcg_regset_or(d, a, b) (d) = (a) | (b)
  62 #define tcg_regset_and(d, a, b) (d) = (a) & (b)
  63 #define tcg_regset_andnot(d, a, b) (d) = (a) & ~(b)
  64 #define tcg_regset_not(d, a) (d) = ~(a)
  65
  66 typedef struct TCGRelocation {
  67     struct TCGRelocation *next;
  68     int type;
  69     uint8_t *ptr;
  70     tcg_target_long addend;
  71 } TCGRelocation;
  72
  73 typedef struct TCGLabel {
  74     int has_value;
  75     union {
  76         tcg_target_ulong value;
  77         TCGRelocation *first_reloc;
  78     } u;
  79 } TCGLabel;
  80
  81 typedef struct TCGPool {
  82     struct TCGPool *next;
  83     int size;
  84     uint8_t data[0] __attribute__ ((aligned));
  85 } TCGPool;
  86
  87 #define TCG_POOL_CHUNK_SIZE 32768
  88
  89 #define TCG_MAX_LABELS 512
  90
  91 #define TCG_MAX_TEMPS 512
  92
  93 /* when the size of the arguments of a called function is smaller than
  94    this value, they are statically allocated in the TB stack frame */
  95 #define TCG_STATIC_CALL_ARGS_SIZE 128
  96
  97 typedef int TCGType;
  98
  99 #define TCG_TYPE_I32 0
 100 #define TCG_TYPE_I64 1
 101 #define TCG_TYPE_COUNT 2 /* number of different types */
 102
 103 #if TCG_TARGET_REG_BITS == 32
 104 #define TCG_TYPE_PTR TCG_TYPE_I32
 105 #else
 106 #define TCG_TYPE_PTR TCG_TYPE_I64
 107 #endif
 108
 109 typedef tcg_target_ulong TCGArg;
 110
 111 /* Define a type and accessor macros for varables.  Using a struct is
 112    nice because it gives some level of type safely.  Ideally the compiler
 113    be able to see through all this.  However in practice this is not true,
 114    expecially on targets with braindamaged ABIs (e.g. i386).
 115    We use plain int by default to avoid this runtime overhead.
 116    Users of tcg_gen_* don't need to know about any of this, and should
 117    treat TCGv as an opaque type.  */
 118
 119 //#define DEBUG_TCGV 1
 120
 121 #ifdef DEBUG_TCGV
 122
 123 typedef struct
 124 {
 125     int n;
 126 } TCGv;
 127
 128 #define MAKE_TCGV(i) __extension__ \
 129   ({ TCGv make_tcgv_tmp = {i}; make_tcgv_tmp;})
 130 #define GET_TCGV(t) ((t).n)
 131 #if TCG_TARGET_REG_BITS == 32
 132 #define TCGV_HIGH(t) MAKE_TCGV(GET_TCGV(t) + 1)
 133 #endif
 134
 135 #else /* !DEBUG_TCGV */
 136
 137 typedef int TCGv;
 138 #define MAKE_TCGV(x) (x)
 139 #define GET_TCGV(t) (t)
 140 #if TCG_TARGET_REG_BITS == 32
 141 #define TCGV_HIGH(t) ((t) + 1)
 142 #endif
 143
 144 #endif /* DEBUG_TCGV */
 145
 146 /* call flags */
 147 #define TCG_CALL_TYPE_MASK      0x000f
 148 #define TCG_CALL_TYPE_STD       0x0000 /* standard C call */
 149 #define TCG_CALL_TYPE_REGPARM_1 0x0001 /* i386 style regparm call (1 reg) */
 150 #define TCG_CALL_TYPE_REGPARM_2 0x0002 /* i386 style regparm call (2 regs) */
 151 #define TCG_CALL_TYPE_REGPARM   0x0003 /* i386 style regparm call (3 regs) */
 152 /* A pure function only reads its arguments and globals variables and
 153    cannot raise exceptions. Hence a call to a pure function can be
 154    safely suppressed if the return value is not used. */
 155 #define TCG_CALL_PURE           0x0010
 156
 157 /* used to align parameters */
 158 #define TCG_CALL_DUMMY_TCGV     MAKE_TCGV(-1)
 159 #define TCG_CALL_DUMMY_ARG      ((TCGArg)(-1))
 160
 161 typedef enum {
 162     TCG_COND_EQ,
 163     TCG_COND_NE,
 164     TCG_COND_LT,
 165     TCG_COND_GE,
 166     TCG_COND_LE,
 167     TCG_COND_GT,
 168     /* unsigned */
 169     TCG_COND_LTU,
 170     TCG_COND_GEU,
 171     TCG_COND_LEU,
 172     TCG_COND_GTU,
 173 } TCGCond;
 174
 175 #define TEMP_VAL_DEAD  0
 176 #define TEMP_VAL_REG   1
 177 #define TEMP_VAL_MEM   2
 178 #define TEMP_VAL_CONST 3
 179
 180 /* XXX: optimize memory layout */
 181 typedef struct TCGTemp {
 182     TCGType base_type;
 183     TCGType type;
 184     int val_type;
 185     int reg;
 186     tcg_target_long val;
 187     int mem_reg;
 188     tcg_target_long mem_offset;
 189     unsigned int fixed_reg:1;
 190     unsigned int mem_coherent:1;
 191     unsigned int mem_allocated:1;
 192     unsigned int temp_local:1; /* If true, the temp is saved accross
 193                                   basic blocks. Otherwise, it is not
 194                                   preserved accross basic blocks. */
 195     unsigned int temp_allocated:1; /* never used for code gen */
 196     /* index of next free temp of same base type, -1 if end */
 197     int next_free_temp;
 198     const char *name;
 199 } TCGTemp;
 200
 201 typedef struct TCGHelperInfo {
 202     tcg_target_ulong func;
 203     const char *name;
 204 } TCGHelperInfo;
 205
 206 typedef struct TCGContext TCGContext;
 207
 208 struct TCGContext {
 209     uint8_t *pool_cur, *pool_end;
 210     TCGPool *pool_first, *pool_current;
 211     TCGLabel *labels;
 212     int nb_labels;
 213     TCGTemp *temps; /* globals first, temps after */
 214     int nb_globals;
 215     int nb_temps;
 216     /* index of free temps, -1 if none */
 217     int first_free_temp[TCG_TYPE_COUNT * 2];
 218
 219     /* goto_tb support */
 220     uint8_t *code_buf;
 221     unsigned long *tb_next;
 222     uint16_t *tb_next_offset;
 223     uint16_t *tb_jmp_offset; /* != NULL if USE_DIRECT_JUMP */
 224
 225     /* liveness analysis */
 226     uint16_t *op_dead_iargs; /* for each operation, each bit tells if the
 227                                 corresponding input argument is dead */
 228
 229     /* tells in which temporary a given register is. It does not take
 230        into account fixed registers */
 231     int reg_to_temp[TCG_TARGET_NB_REGS];
 232     TCGRegSet reserved_regs;
 233     tcg_target_long current_frame_offset;
 234     tcg_target_long frame_start;
 235     tcg_target_long frame_end;
 236     int frame_reg;
 237
 238     uint8_t *code_ptr;
 239     TCGTemp static_temps[TCG_MAX_TEMPS];
 240
 241     TCGHelperInfo *helpers;
 242     int nb_helpers;
 243     int allocated_helpers;
 244     int helpers_sorted;
 245
 246 #ifdef CONFIG_PROFILER
 247     /* profiling info */
 248     int64_t tb_count1;
 249     int64_t tb_count;
 250     int64_t op_count; /* total insn count */
 251     int op_count_max; /* max insn per TB */
 252     int64_t temp_count;
 253     int temp_count_max;
 254     int64_t old_op_count;
 255     int64_t del_op_count;
 256     int64_t code_in_len;
 257     int64_t code_out_len;
 258     int64_t interm_time;
 259     int64_t code_time;
 260     int64_t la_time;
 261     int64_t restore_count;
 262     int64_t restore_time;
 263 #endif
 264 };
 265
 266 extern TCGContext tcg_ctx;
 267 extern uint16_t *gen_opc_ptr;
 268 extern TCGArg *gen_opparam_ptr;
 269 extern uint16_t gen_opc_buf[];
 270 extern TCGArg gen_opparam_buf[];
 271
 272 /* pool based memory allocation */
 273
 274 void *tcg_malloc_internal(TCGContext *s, int size);
 275 void tcg_pool_reset(TCGContext *s);
 276 void tcg_pool_delete(TCGContext *s);
 277
 278 static inline void *tcg_malloc(int size)
 279 {
 280     TCGContext *s = &tcg_ctx;
 281     uint8_t *ptr, *ptr_end;
 282     size = (size + sizeof(long) - 1) & ~(sizeof(long) - 1);
 283     ptr = s->pool_cur;
 284     ptr_end = ptr + size;
 285     if (unlikely(ptr_end > s->pool_end)) {
 286         return tcg_malloc_internal(&tcg_ctx, size);
 287     } else {
 288         s->pool_cur = ptr_end;
 289         return ptr;
 290     }
 291 }
 292
 293 void tcg_context_init(TCGContext *s);
 294 void tcg_func_start(TCGContext *s);
 295
 296 int dyngen_code(TCGContext *s, uint8_t *gen_code_buf);
 297 int dyngen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset);
 298
 299 void tcg_set_frame(TCGContext *s, int reg,
 300                    tcg_target_long start, tcg_target_long size);
 301 TCGv tcg_global_reg_new(TCGType type, int reg, const char *name);
 302 TCGv tcg_global_reg2_new_hack(TCGType type, int reg1, int reg2,
 303                               const char *name);
 304 TCGv tcg_global_mem_new(TCGType type, int reg, tcg_target_long offset,
 305                         const char *name);
 306 TCGv tcg_temp_new_internal(TCGType type, int temp_local);
 307 static inline TCGv tcg_temp_new(TCGType type)
 308 {
 309     return tcg_temp_new_internal(type, 0);
 310 }
 311 static inline TCGv tcg_temp_local_new(TCGType type)
 312 {
 313     return tcg_temp_new_internal(type, 1);
 314 }
 315 void tcg_temp_free(TCGv arg);
 316 char *tcg_get_arg_str(TCGContext *s, char *buf, int buf_size, TCGv arg);
 317 void tcg_dump_info(FILE *f,
 318                    int (*cpu_fprintf)(FILE *f, const char *fmt, ...));
 319
 320 #define TCG_CT_ALIAS  0x80
 321 #define TCG_CT_IALIAS 0x40
 322 #define TCG_CT_REG    0x01
 323 #define TCG_CT_CONST  0x02 /* any constant of register size */
 324
 325 typedef struct TCGArgConstraint {
 326     uint16_t ct;
 327     uint8_t alias_index;
 328     union {
 329         TCGRegSet regs;
 330     } u;
 331 } TCGArgConstraint;
 332
 333 #define TCG_MAX_OP_ARGS 16
 334
 335 #define TCG_OPF_BB_END     0x01 /* instruction defines the end of a basic
 336                                    block */
 337 #define TCG_OPF_CALL_CLOBBER 0x02 /* instruction clobbers call registers
 338                                    and potentially update globals. */
 339 #define TCG_OPF_SIDE_EFFECTS 0x04 /* instruction has side effects : it
 340                                      cannot be removed if its output
 341                                      are not used */
 342
 343 typedef struct TCGOpDef {
 344     const char *name;
 345     uint8_t nb_oargs, nb_iargs, nb_cargs, nb_args;
 346     uint8_t flags;
 347     uint16_t copy_size;
 348     TCGArgConstraint *args_ct;
 349     int *sorted_args;
 350 } TCGOpDef;
 351
 352 typedef struct TCGTargetOpDef {
 353     int op;
 354     const char *args_ct_str[TCG_MAX_OP_ARGS];
 355 } TCGTargetOpDef;
 356
 357 extern TCGOpDef tcg_op_defs[];
 358
 359 void tcg_target_init(TCGContext *s);
 360 void tcg_target_qemu_prologue(TCGContext *s);
 361
 362 #define tcg_abort() \
 363 do {\
 364     fprintf(stderr, "%s:%d: tcg fatal error\n", __FILE__, __LINE__);\
 365     abort();\
 366 } while (0)
 367
 368 void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs);
 369
 370 void tcg_gen_call(TCGContext *s, TCGv func, unsigned int flags,
 371                   unsigned int nb_rets, const TCGv *rets,
 372                   unsigned int nb_params, const TCGv *args1);
 373 void tcg_gen_shifti_i64(TCGv ret, TCGv arg1,
 374                         int c, int right, int arith);
 375
 376 /* only used for debugging purposes */
 377 void tcg_register_helper(void *func, const char *name);
 378 #define TCG_HELPER(func) tcg_register_helper(func, #func)
 379 const char *tcg_helper_get_name(TCGContext *s, void *func);
 380 void tcg_dump_ops(TCGContext *s, FILE *outfile);
 381
 382 void dump_ops(const uint16_t *opc_buf, const TCGArg *opparam_buf);
 383 TCGv tcg_const_i32(int32_t val);
 384 TCGv tcg_const_i64(int64_t val);
 385
 386 #if TCG_TARGET_REG_BITS == 32
 387 #define tcg_const_ptr tcg_const_i32
 388 #define tcg_add_ptr tcg_add_i32
 389 #define tcg_sub_ptr tcg_sub_i32
 390 #else
 391 #define tcg_const_ptr tcg_const_i64
 392 #define tcg_add_ptr tcg_add_i64
 393 #define tcg_sub_ptr tcg_sub_i64
 394 #endif
 395
 396 void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type,
 397                    int label_index, long addend);
 398 const TCGArg *tcg_gen_code_op(TCGContext *s, int opc, const TCGArg *args1,
 399                               unsigned int dead_iargs);
 400
 401 const TCGArg *dyngen_op(TCGContext *s, int opc, const TCGArg *opparam_ptr);
 402
 403 /* tcg-runtime.c */
 404 int64_t tcg_helper_shl_i64(int64_t arg1, int64_t arg2);
 405 int64_t tcg_helper_shr_i64(int64_t arg1, int64_t arg2);
 406 int64_t tcg_helper_sar_i64(int64_t arg1, int64_t arg2);
 407 int64_t tcg_helper_div_i64(int64_t arg1, int64_t arg2);
 408 int64_t tcg_helper_rem_i64(int64_t arg1, int64_t arg2);
 409 uint64_t tcg_helper_divu_i64(uint64_t arg1, uint64_t arg2);
 410 uint64_t tcg_helper_remu_i64(uint64_t arg1, uint64_t arg2);
 411
 412 extern uint8_t code_gen_prologue[];
 413 #ifdef __powerpc__
 414 #define tcg_qemu_tb_exec(tb_ptr) \
 415     ((long REGPARM __attribute__ ((longcall)) (*)(void *))code_gen_prologue)(tb_ptr)
 416 #else
 417 #define tcg_qemu_tb_exec(tb_ptr) ((long REGPARM (*)(void *))code_gen_prologue)(tb_ptr)
 418 #endif