1 /* 2 * Tiny Code Generator for QEMU 3 * 4 * Copyright (c) 2008 Fabrice Bellard 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 #include "qemu-common.h" 25 #include "tcg-target.h" 26 #include "tcg-runtime.h" 27 28 #if TCG_TARGET_REG_BITS == 32 29 typedef int32_t tcg_target_long; 30 typedef uint32_t tcg_target_ulong; 31 #define TCG_PRIlx PRIx32 32 #define TCG_PRIld PRId32 33 #elif TCG_TARGET_REG_BITS == 64 34 typedef int64_t tcg_target_long; 35 typedef uint64_t tcg_target_ulong; 36 #define TCG_PRIlx PRIx64 37 #define TCG_PRIld PRId64 38 #else 39 #error unsupported 40 #endif 41 42 #if TCG_TARGET_NB_REGS <= 32 43 typedef uint32_t TCGRegSet; 44 #elif TCG_TARGET_NB_REGS <= 64 45 typedef uint64_t TCGRegSet; 46 #else 47 #error unsupported 48 #endif 49 50 enum { 51 #define DEF(s, n, copy_size) INDEX_op_ ## s, 52 #include "tcg-opc.h" 53 #undef DEF 54 NB_OPS, 55 }; 56 57 #define tcg_regset_clear(d) (d) = 0 58 #define tcg_regset_set(d, s) (d) = (s) 59 #define tcg_regset_set32(d, reg, val32) (d) |= (val32) << (reg) 60 #define tcg_regset_set_reg(d, r) (d) |= 1L << (r) 61 #define tcg_regset_reset_reg(d, r) (d) &= ~(1L << (r)) 62 #define tcg_regset_test_reg(d, r) (((d) >> (r)) & 1) 63 #define tcg_regset_or(d, a, b) (d) = (a) | (b) 64 #define tcg_regset_and(d, a, b) (d) = (a) & (b) 65 #define tcg_regset_andnot(d, a, b) (d) = (a) & ~(b) 66 #define tcg_regset_not(d, a) (d) = ~(a) 67 68 typedef struct TCGRelocation { 69 struct TCGRelocation *next; 70 int type; 71 uint8_t *ptr; 72 tcg_target_long addend; 73 } TCGRelocation; 74 75 typedef struct TCGLabel { 76 int has_value; 77 union { 78 tcg_target_ulong value; 79 TCGRelocation *first_reloc; 80 } u; 81 } TCGLabel; 82 83 typedef struct TCGPool { 84 struct TCGPool *next; 85 int size; 86 uint8_t data[0] __attribute__ ((aligned)); 87 } TCGPool; 88 89 #define TCG_POOL_CHUNK_SIZE 32768 90 91 #define TCG_MAX_LABELS 512 92 93 #define TCG_MAX_TEMPS 512 94 95 /* when the size of the arguments of a called function is smaller than 96 this value, they are statically allocated in the TB stack frame */ 97 #define TCG_STATIC_CALL_ARGS_SIZE 128 98 99 typedef int TCGType; 100 101 #define TCG_TYPE_I32 0 102 #define TCG_TYPE_I64 1 103 #define TCG_TYPE_COUNT 2 /* number of different types */ 104 105 #if TCG_TARGET_REG_BITS == 32 106 #define TCG_TYPE_PTR TCG_TYPE_I32 107 #else 108 #define TCG_TYPE_PTR TCG_TYPE_I64 109 #endif 110 111 typedef tcg_target_ulong TCGArg; 112 113 /* Define a type and accessor macros for varables. Using a struct is 114 nice because it gives some level of type safely. Ideally the compiler 115 be able to see through all this. However in practice this is not true, 116 expecially on targets with braindamaged ABIs (e.g. i386). 117 We use plain int by default to avoid this runtime overhead. 118 Users of tcg_gen_* don't need to know about any of this, and should 119 treat TCGv as an opaque type. 120 In additon we do typechecking for different types of variables. TCGv_i32 121 and TCGv_i64 are 32/64-bit variables respectively. TCGv and TCGv_ptr 122 are aliases for target_ulong and host pointer sized values respectively. 123 */ 124 125 #ifdef CONFIG_DEBUG_TCG 126 #define DEBUG_TCGV 1 127 #endif 128 129 #ifdef DEBUG_TCGV 130 131 typedef struct 132 { 133 int i32; 134 } TCGv_i32; 135 136 typedef struct 137 { 138 int i64; 139 } TCGv_i64; 140 141 #define MAKE_TCGV_I32(i) __extension__ \ 142 ({ TCGv_i32 make_tcgv_tmp = {i}; make_tcgv_tmp;}) 143 #define MAKE_TCGV_I64(i) __extension__ \ 144 ({ TCGv_i64 make_tcgv_tmp = {i}; make_tcgv_tmp;}) 145 #define GET_TCGV_I32(t) ((t).i32) 146 #define GET_TCGV_I64(t) ((t).i64) 147 #if TCG_TARGET_REG_BITS == 32 148 #define TCGV_LOW(t) MAKE_TCGV_I32(GET_TCGV_I64(t)) 149 #define TCGV_HIGH(t) MAKE_TCGV_I32(GET_TCGV_I64(t) + 1) 150 #endif 151 152 #else /* !DEBUG_TCGV */ 153 154 typedef int TCGv_i32; 155 typedef int TCGv_i64; 156 #define MAKE_TCGV_I32(x) (x) 157 #define MAKE_TCGV_I64(x) (x) 158 #define GET_TCGV_I32(t) (t) 159 #define GET_TCGV_I64(t) (t) 160 161 #if TCG_TARGET_REG_BITS == 32 162 #define TCGV_LOW(t) (t) 163 #define TCGV_HIGH(t) ((t) + 1) 164 #endif 165 166 #endif /* DEBUG_TCGV */ 167 168 #define TCGV_EQUAL_I32(a, b) (GET_TCGV_I32(a) == GET_TCGV_I32(b)) 169 #define TCGV_EQUAL_I64(a, b) (GET_TCGV_I64(a) == GET_TCGV_I64(b)) 170 171 /* Dummy definition to avoid compiler warnings. */ 172 #define TCGV_UNUSED_I32(x) x = MAKE_TCGV_I32(-1) 173 #define TCGV_UNUSED_I64(x) x = MAKE_TCGV_I64(-1) 174 175 /* call flags */ 176 #define TCG_CALL_TYPE_MASK 0x000f 177 #define TCG_CALL_TYPE_STD 0x0000 /* standard C call */ 178 #define TCG_CALL_TYPE_REGPARM_1 0x0001 /* i386 style regparm call (1 reg) */ 179 #define TCG_CALL_TYPE_REGPARM_2 0x0002 /* i386 style regparm call (2 regs) */ 180 #define TCG_CALL_TYPE_REGPARM 0x0003 /* i386 style regparm call (3 regs) */ 181 /* A pure function only reads its arguments and TCG global variables 182 and cannot raise exceptions. Hence a call to a pure function can be 183 safely suppressed if the return value is not used. */ 184 #define TCG_CALL_PURE 0x0010 185 /* A const function only reads its arguments and does not use TCG 186 global variables. Hence a call to such a function does not 187 save TCG global variables back to their canonical location. */ 188 #define TCG_CALL_CONST 0x0020 189 190 /* used to align parameters */ 191 #define TCG_CALL_DUMMY_TCGV MAKE_TCGV_I32(-1) 192 #define TCG_CALL_DUMMY_ARG ((TCGArg)(-1)) 193 194 typedef enum { 195 TCG_COND_EQ, 196 TCG_COND_NE, 197 TCG_COND_LT, 198 TCG_COND_GE, 199 TCG_COND_LE, 200 TCG_COND_GT, 201 /* unsigned */ 202 TCG_COND_LTU, 203 TCG_COND_GEU, 204 TCG_COND_LEU, 205 TCG_COND_GTU, 206 } TCGCond; 207 208 /* Invert the sense of the comparison. */ 209 static inline TCGCond tcg_invert_cond(TCGCond c) 210 { 211 return (TCGCond)(c ^ 1); 212 } 213 214 /* Swap the operands in a comparison. */ 215 static inline TCGCond tcg_swap_cond(TCGCond c) 216 { 217 int mask = (c < TCG_COND_LT ? 0 : c < TCG_COND_LTU ? 7 : 15); 218 return (TCGCond)(c ^ mask); 219 } 220 221 static inline TCGCond tcg_unsigned_cond(TCGCond c) 222 { 223 return (c >= TCG_COND_LT && c <= TCG_COND_GT ? c + 4 : c); 224 } 225 226 #define TEMP_VAL_DEAD 0 227 #define TEMP_VAL_REG 1 228 #define TEMP_VAL_MEM 2 229 #define TEMP_VAL_CONST 3 230 231 /* XXX: optimize memory layout */ 232 typedef struct TCGTemp { 233 TCGType base_type; 234 TCGType type; 235 int val_type; 236 int reg; 237 tcg_target_long val; 238 int mem_reg; 239 tcg_target_long mem_offset; 240 unsigned int fixed_reg:1; 241 unsigned int mem_coherent:1; 242 unsigned int mem_allocated:1; 243 unsigned int temp_local:1; /* If true, the temp is saved accross 244 basic blocks. Otherwise, it is not 245 preserved accross basic blocks. */ 246 unsigned int temp_allocated:1; /* never used for code gen */ 247 /* index of next free temp of same base type, -1 if end */ 248 int next_free_temp; 249 const char *name; 250 } TCGTemp; 251 252 typedef struct TCGHelperInfo { 253 tcg_target_ulong func; 254 const char *name; 255 } TCGHelperInfo; 256 257 typedef struct TCGContext TCGContext; 258 259 struct TCGContext { 260 uint8_t *pool_cur, *pool_end; 261 TCGPool *pool_first, *pool_current; 262 TCGLabel *labels; 263 int nb_labels; 264 TCGTemp *temps; /* globals first, temps after */ 265 int nb_globals; 266 int nb_temps; 267 /* index of free temps, -1 if none */ 268 int first_free_temp[TCG_TYPE_COUNT * 2]; 269 270 /* goto_tb support */ 271 uint8_t *code_buf; 272 unsigned long *tb_next; 273 uint16_t *tb_next_offset; 274 uint16_t *tb_jmp_offset; /* != NULL if USE_DIRECT_JUMP */ 275 276 /* liveness analysis */ 277 uint16_t *op_dead_iargs; /* for each operation, each bit tells if the 278 corresponding input argument is dead */ 279 280 /* tells in which temporary a given register is. It does not take 281 into account fixed registers */ 282 int reg_to_temp[TCG_TARGET_NB_REGS]; 283 TCGRegSet reserved_regs; 284 tcg_target_long current_frame_offset; 285 tcg_target_long frame_start; 286 tcg_target_long frame_end; 287 int frame_reg; 288 289 uint8_t *code_ptr; 290 TCGTemp static_temps[TCG_MAX_TEMPS]; 291 292 TCGHelperInfo *helpers; 293 int nb_helpers; 294 int allocated_helpers; 295 int helpers_sorted; 296 297 #ifdef CONFIG_PROFILER 298 /* profiling info */ 299 int64_t tb_count1; 300 int64_t tb_count; 301 int64_t op_count; /* total insn count */ 302 int op_count_max; /* max insn per TB */ 303 int64_t temp_count; 304 int temp_count_max; 305 int64_t del_op_count; 306 int64_t code_in_len; 307 int64_t code_out_len; 308 int64_t interm_time; 309 int64_t code_time; 310 int64_t la_time; 311 int64_t restore_count; 312 int64_t restore_time; 313 #endif 314 }; 315 316 extern TCGContext tcg_ctx; 317 extern uint16_t *gen_opc_ptr; 318 extern TCGArg *gen_opparam_ptr; 319 extern uint16_t gen_opc_buf[]; 320 extern TCGArg gen_opparam_buf[]; 321 322 /* pool based memory allocation */ 323 324 void *tcg_malloc_internal(TCGContext *s, int size); 325 void tcg_pool_reset(TCGContext *s); 326 void tcg_pool_delete(TCGContext *s); 327 328 static inline void *tcg_malloc(int size) 329 { 330 TCGContext *s = &tcg_ctx; 331 uint8_t *ptr, *ptr_end; 332 size = (size + sizeof(long) - 1) & ~(sizeof(long) - 1); 333 ptr = s->pool_cur; 334 ptr_end = ptr + size; 335 if (unlikely(ptr_end > s->pool_end)) { 336 return tcg_malloc_internal(&tcg_ctx, size); 337 } else { 338 s->pool_cur = ptr_end; 339 return ptr; 340 } 341 } 342 343 void tcg_context_init(TCGContext *s); 344 void tcg_func_start(TCGContext *s); 345 346 int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf); 347 int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset); 348 349 void tcg_set_frame(TCGContext *s, int reg, 350 tcg_target_long start, tcg_target_long size); 351 352 TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name); 353 TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset, 354 const char *name); 355 TCGv_i32 tcg_temp_new_internal_i32(int temp_local); 356 static inline TCGv_i32 tcg_temp_new_i32(void) 357 { 358 return tcg_temp_new_internal_i32(0); 359 } 360 static inline TCGv_i32 tcg_temp_local_new_i32(void) 361 { 362 return tcg_temp_new_internal_i32(1); 363 } 364 void tcg_temp_free_i32(TCGv_i32 arg); 365 char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg); 366 367 TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name); 368 TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset, 369 const char *name); 370 TCGv_i64 tcg_temp_new_internal_i64(int temp_local); 371 static inline TCGv_i64 tcg_temp_new_i64(void) 372 { 373 return tcg_temp_new_internal_i64(0); 374 } 375 static inline TCGv_i64 tcg_temp_local_new_i64(void) 376 { 377 return tcg_temp_new_internal_i64(1); 378 } 379 void tcg_temp_free_i64(TCGv_i64 arg); 380 char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg); 381 382 void tcg_dump_info(FILE *f, 383 int (*cpu_fprintf)(FILE *f, const char *fmt, ...)); 384 385 #define TCG_CT_ALIAS 0x80 386 #define TCG_CT_IALIAS 0x40 387 #define TCG_CT_REG 0x01 388 #define TCG_CT_CONST 0x02 /* any constant of register size */ 389 390 typedef struct TCGArgConstraint { 391 uint16_t ct; 392 uint8_t alias_index; 393 union { 394 TCGRegSet regs; 395 } u; 396 } TCGArgConstraint; 397 398 #define TCG_MAX_OP_ARGS 16 399 400 #define TCG_OPF_BB_END 0x01 /* instruction defines the end of a basic 401 block */ 402 #define TCG_OPF_CALL_CLOBBER 0x02 /* instruction clobbers call registers 403 and potentially update globals. */ 404 #define TCG_OPF_SIDE_EFFECTS 0x04 /* instruction has side effects : it 405 cannot be removed if its output 406 are not used */ 407 408 typedef struct TCGOpDef { 409 const char *name; 410 uint8_t nb_oargs, nb_iargs, nb_cargs, nb_args; 411 uint8_t flags; 412 uint16_t copy_size; 413 TCGArgConstraint *args_ct; 414 int *sorted_args; 415 #if defined(CONFIG_DEBUG_TCG) 416 int used; 417 #endif 418 } TCGOpDef; 419 420 typedef struct TCGTargetOpDef { 421 int op; 422 const char *args_ct_str[TCG_MAX_OP_ARGS]; 423 } TCGTargetOpDef; 424 425 void tcg_target_init(TCGContext *s); 426 void tcg_target_qemu_prologue(TCGContext *s); 427 428 #define tcg_abort() \ 429 do {\ 430 fprintf(stderr, "%s:%d: tcg fatal error\n", __FILE__, __LINE__);\ 431 abort();\ 432 } while (0) 433 434 void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs); 435 436 #if TCG_TARGET_REG_BITS == 32 437 #define tcg_const_ptr tcg_const_i32 438 #define tcg_add_ptr tcg_add_i32 439 #define tcg_sub_ptr tcg_sub_i32 440 #define TCGv_ptr TCGv_i32 441 #define GET_TCGV_PTR GET_TCGV_I32 442 #define tcg_global_reg_new_ptr tcg_global_reg_new_i32 443 #define tcg_global_mem_new_ptr tcg_global_mem_new_i32 444 #define tcg_temp_new_ptr tcg_temp_new_i32 445 #define tcg_temp_free_ptr tcg_temp_free_i32 446 #else 447 #define tcg_const_ptr tcg_const_i64 448 #define tcg_add_ptr tcg_add_i64 449 #define tcg_sub_ptr tcg_sub_i64 450 #define TCGv_ptr TCGv_i64 451 #define GET_TCGV_PTR GET_TCGV_I64 452 #define tcg_global_reg_new_ptr tcg_global_reg_new_i64 453 #define tcg_global_mem_new_ptr tcg_global_mem_new_i64 454 #define tcg_temp_new_ptr tcg_temp_new_i64 455 #define tcg_temp_free_ptr tcg_temp_free_i64 456 #endif 457 458 void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags, 459 int sizemask, TCGArg ret, int nargs, TCGArg *args); 460 461 void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, 462 int c, int right, int arith); 463 464 /* only used for debugging purposes */ 465 void tcg_register_helper(void *func, const char *name); 466 const char *tcg_helper_get_name(TCGContext *s, void *func); 467 void tcg_dump_ops(TCGContext *s, FILE *outfile); 468 469 void dump_ops(const uint16_t *opc_buf, const TCGArg *opparam_buf); 470 TCGv_i32 tcg_const_i32(int32_t val); 471 TCGv_i64 tcg_const_i64(int64_t val); 472 TCGv_i32 tcg_const_local_i32(int32_t val); 473 TCGv_i64 tcg_const_local_i64(int64_t val); 474 475 void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type, 476 int label_index, long addend); 477 478 extern uint8_t code_gen_prologue[]; 479 #if defined(_ARCH_PPC) && !defined(_ARCH_PPC64) 480 #define tcg_qemu_tb_exec(tb_ptr) \ 481 ((long REGPARM __attribute__ ((longcall)) (*)(void *))code_gen_prologue)(tb_ptr) 482 #else 483 #define tcg_qemu_tb_exec(tb_ptr) ((long REGPARM (*)(void *))code_gen_prologue)(tb_ptr) 484 #endif 485
