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 /* define it to use liveness analysis (better code) */ 26 #define USE_LIVENESS_ANALYSIS 27 28 #include "config.h" 29 30 #if !defined(CONFIG_DEBUG_TCG) && !defined(NDEBUG) 31 /* define it to suppress various consistency checks (faster) */ 32 #define NDEBUG 33 #endif 34 35 #include <stdarg.h> 36 #include <stdlib.h> 37 #include <stdio.h> 38 #include <string.h> 39 #include <inttypes.h> 40 #ifdef _WIN32 41 #include <malloc.h> 42 #endif 43 #ifdef _AIX 44 #include <alloca.h> 45 #endif 46 47 #include "qemu-common.h" 48 #include "cache-utils.h" 49 #include "host-utils.h" 50 #include "qemu-timer.h" 51 52 /* Note: the long term plan is to reduce the dependancies on the QEMU 53 CPU definitions. Currently they are used for qemu_ld/st 54 instructions */ 55 #define NO_CPU_IO_DEFS 56 #include "cpu.h" 57 #include "exec-all.h" 58 59 #include "tcg-op.h" 60 #include "elf.h" 61 62 #if defined(CONFIG_USE_GUEST_BASE) && !defined(TCG_TARGET_HAS_GUEST_BASE) 63 #error GUEST_BASE not supported on this host. 64 #endif 65 66 static void tcg_target_init(TCGContext *s); 67 static void tcg_target_qemu_prologue(TCGContext *s); 68 static void patch_reloc(uint8_t *code_ptr, int type, 69 tcg_target_long value, tcg_target_long addend); 70 71 static TCGOpDef tcg_op_defs[] = { 72 #define DEF(s, oargs, iargs, cargs, flags) { #s, oargs, iargs, cargs, iargs + oargs + cargs, flags }, 73 #include "tcg-opc.h" 74 #undef DEF 75 }; 76 77 static TCGRegSet tcg_target_available_regs[2]; 78 static TCGRegSet tcg_target_call_clobber_regs; 79 80 /* XXX: move that inside the context */ 81 uint16_t *gen_opc_ptr; 82 TCGArg *gen_opparam_ptr; 83 84 static inline void tcg_out8(TCGContext *s, uint8_t v) 85 { 86 *s->code_ptr++ = v; 87 } 88 89 static inline void tcg_out16(TCGContext *s, uint16_t v) 90 { 91 *(uint16_t *)s->code_ptr = v; 92 s->code_ptr += 2; 93 } 94 95 static inline void tcg_out32(TCGContext *s, uint32_t v) 96 { 97 *(uint32_t *)s->code_ptr = v; 98 s->code_ptr += 4; 99 } 100 101 /* label relocation processing */ 102 103 static void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type, 104 int label_index, long addend) 105 { 106 TCGLabel *l; 107 TCGRelocation *r; 108 109 l = &s->labels[label_index]; 110 if (l->has_value) { 111 /* FIXME: This may break relocations on RISC targets that 112 modify instruction fields in place. The caller may not have 113 written the initial value. */ 114 patch_reloc(code_ptr, type, l->u.value, addend); 115 } else { 116 /* add a new relocation entry */ 117 r = tcg_malloc(sizeof(TCGRelocation)); 118 r->type = type; 119 r->ptr = code_ptr; 120 r->addend = addend; 121 r->next = l->u.first_reloc; 122 l->u.first_reloc = r; 123 } 124 } 125 126 static void tcg_out_label(TCGContext *s, int label_index, 127 tcg_target_long value) 128 { 129 TCGLabel *l; 130 TCGRelocation *r; 131 132 l = &s->labels[label_index]; 133 if (l->has_value) 134 tcg_abort(); 135 r = l->u.first_reloc; 136 while (r != NULL) { 137 patch_reloc(r->ptr, r->type, value, r->addend); 138 r = r->next; 139 } 140 l->has_value = 1; 141 l->u.value = value; 142 } 143 144 int gen_new_label(void) 145 { 146 TCGContext *s = &tcg_ctx; 147 int idx; 148 TCGLabel *l; 149 150 if (s->nb_labels >= TCG_MAX_LABELS) 151 tcg_abort(); 152 idx = s->nb_labels++; 153 l = &s->labels[idx]; 154 l->has_value = 0; 155 l->u.first_reloc = NULL; 156 return idx; 157 } 158 159 #include "tcg-target.c" 160 161 /* pool based memory allocation */ 162 void *tcg_malloc_internal(TCGContext *s, int size) 163 { 164 TCGPool *p; 165 int pool_size; 166 167 if (size > TCG_POOL_CHUNK_SIZE) { 168 /* big malloc: insert a new pool (XXX: could optimize) */ 169 p = qemu_malloc(sizeof(TCGPool) + size); 170 p->size = size; 171 if (s->pool_current) 172 s->pool_current->next = p; 173 else 174 s->pool_first = p; 175 p->next = s->pool_current; 176 } else { 177 p = s->pool_current; 178 if (!p) { 179 p = s->pool_first; 180 if (!p) 181 goto new_pool; 182 } else { 183 if (!p->next) { 184 new_pool: 185 pool_size = TCG_POOL_CHUNK_SIZE; 186 p = qemu_malloc(sizeof(TCGPool) + pool_size); 187 p->size = pool_size; 188 p->next = NULL; 189 if (s->pool_current) 190 s->pool_current->next = p; 191 else 192 s->pool_first = p; 193 } else { 194 p = p->next; 195 } 196 } 197 } 198 s->pool_current = p; 199 s->pool_cur = p->data + size; 200 s->pool_end = p->data + p->size; 201 return p->data; 202 } 203 204 void tcg_pool_reset(TCGContext *s) 205 { 206 s->pool_cur = s->pool_end = NULL; 207 s->pool_current = NULL; 208 } 209 210 void tcg_context_init(TCGContext *s) 211 { 212 int op, total_args, n; 213 TCGOpDef *def; 214 TCGArgConstraint *args_ct; 215 int *sorted_args; 216 217 memset(s, 0, sizeof(*s)); 218 s->temps = s->static_temps; 219 s->nb_globals = 0; 220 221 /* Count total number of arguments and allocate the corresponding 222 space */ 223 total_args = 0; 224 for(op = 0; op < NB_OPS; op++) { 225 def = &tcg_op_defs[op]; 226 n = def->nb_iargs + def->nb_oargs; 227 total_args += n; 228 } 229 230 args_ct = qemu_malloc(sizeof(TCGArgConstraint) * total_args); 231 sorted_args = qemu_malloc(sizeof(int) * total_args); 232 233 for(op = 0; op < NB_OPS; op++) { 234 def = &tcg_op_defs[op]; 235 def->args_ct = args_ct; 236 def->sorted_args = sorted_args; 237 n = def->nb_iargs + def->nb_oargs; 238 sorted_args += n; 239 args_ct += n; 240 } 241 242 tcg_target_init(s); 243 } 244 245 void tcg_prologue_init(TCGContext *s) 246 { 247 /* init global prologue and epilogue */ 248 s->code_buf = code_gen_prologue; 249 s->code_ptr = s->code_buf; 250 tcg_target_qemu_prologue(s); 251 flush_icache_range((unsigned long)s->code_buf, 252 (unsigned long)s->code_ptr); 253 } 254 255 void tcg_set_frame(TCGContext *s, int reg, 256 tcg_target_long start, tcg_target_long size) 257 { 258 s->frame_start = start; 259 s->frame_end = start + size; 260 s->frame_reg = reg; 261 } 262 263 void tcg_func_start(TCGContext *s) 264 { 265 int i; 266 tcg_pool_reset(s); 267 s->nb_temps = s->nb_globals; 268 for(i = 0; i < (TCG_TYPE_COUNT * 2); i++) 269 s->first_free_temp[i] = -1; 270 s->labels = tcg_malloc(sizeof(TCGLabel) * TCG_MAX_LABELS); 271 s->nb_labels = 0; 272 s->current_frame_offset = s->frame_start; 273 274 gen_opc_ptr = gen_opc_buf; 275 gen_opparam_ptr = gen_opparam_buf; 276 } 277 278 static inline void tcg_temp_alloc(TCGContext *s, int n) 279 { 280 if (n > TCG_MAX_TEMPS) 281 tcg_abort(); 282 } 283 284 static inline int tcg_global_reg_new_internal(TCGType type, int reg, 285 const char *name) 286 { 287 TCGContext *s = &tcg_ctx; 288 TCGTemp *ts; 289 int idx; 290 291 #if TCG_TARGET_REG_BITS == 32 292 if (type != TCG_TYPE_I32) 293 tcg_abort(); 294 #endif 295 if (tcg_regset_test_reg(s->reserved_regs, reg)) 296 tcg_abort(); 297 idx = s->nb_globals; 298 tcg_temp_alloc(s, s->nb_globals + 1); 299 ts = &s->temps[s->nb_globals]; 300 ts->base_type = type; 301 ts->type = type; 302 ts->fixed_reg = 1; 303 ts->reg = reg; 304 ts->name = name; 305 s->nb_globals++; 306 tcg_regset_set_reg(s->reserved_regs, reg); 307 return idx; 308 } 309 310 TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name) 311 { 312 int idx; 313 314 idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name); 315 return MAKE_TCGV_I32(idx); 316 } 317 318 TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name) 319 { 320 int idx; 321 322 idx = tcg_global_reg_new_internal(TCG_TYPE_I64, reg, name); 323 return MAKE_TCGV_I64(idx); 324 } 325 326 static inline int tcg_global_mem_new_internal(TCGType type, int reg, 327 tcg_target_long offset, 328 const char *name) 329 { 330 TCGContext *s = &tcg_ctx; 331 TCGTemp *ts; 332 int idx; 333 334 idx = s->nb_globals; 335 #if TCG_TARGET_REG_BITS == 32 336 if (type == TCG_TYPE_I64) { 337 char buf[64]; 338 tcg_temp_alloc(s, s->nb_globals + 2); 339 ts = &s->temps[s->nb_globals]; 340 ts->base_type = type; 341 ts->type = TCG_TYPE_I32; 342 ts->fixed_reg = 0; 343 ts->mem_allocated = 1; 344 ts->mem_reg = reg; 345 #ifdef TCG_TARGET_WORDS_BIGENDIAN 346 ts->mem_offset = offset + 4; 347 #else 348 ts->mem_offset = offset; 349 #endif 350 pstrcpy(buf, sizeof(buf), name); 351 pstrcat(buf, sizeof(buf), "_0"); 352 ts->name = strdup(buf); 353 ts++; 354 355 ts->base_type = type; 356 ts->type = TCG_TYPE_I32; 357 ts->fixed_reg = 0; 358 ts->mem_allocated = 1; 359 ts->mem_reg = reg; 360 #ifdef TCG_TARGET_WORDS_BIGENDIAN 361 ts->mem_offset = offset; 362 #else 363 ts->mem_offset = offset + 4; 364 #endif 365 pstrcpy(buf, sizeof(buf), name); 366 pstrcat(buf, sizeof(buf), "_1"); 367 ts->name = strdup(buf); 368 369 s->nb_globals += 2; 370 } else 371 #endif 372 { 373 tcg_temp_alloc(s, s->nb_globals + 1); 374 ts = &s->temps[s->nb_globals]; 375 ts->base_type = type; 376 ts->type = type; 377 ts->fixed_reg = 0; 378 ts->mem_allocated = 1; 379 ts->mem_reg = reg; 380 ts->mem_offset = offset; 381 ts->name = name; 382 s->nb_globals++; 383 } 384 return idx; 385 } 386 387 TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset, 388 const char *name) 389 { 390 int idx; 391 392 idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name); 393 return MAKE_TCGV_I32(idx); 394 } 395 396 TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset, 397 const char *name) 398 { 399 int idx; 400 401 idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name); 402 return MAKE_TCGV_I64(idx); 403 } 404 405 static inline int tcg_temp_new_internal(TCGType type, int temp_local) 406 { 407 TCGContext *s = &tcg_ctx; 408 TCGTemp *ts; 409 int idx, k; 410 411 k = type; 412 if (temp_local) 413 k += TCG_TYPE_COUNT; 414 idx = s->first_free_temp[k]; 415 if (idx != -1) { 416 /* There is already an available temp with the 417 right type */ 418 ts = &s->temps[idx]; 419 s->first_free_temp[k] = ts->next_free_temp; 420 ts->temp_allocated = 1; 421 assert(ts->temp_local == temp_local); 422 } else { 423 idx = s->nb_temps; 424 #if TCG_TARGET_REG_BITS == 32 425 if (type == TCG_TYPE_I64) { 426 tcg_temp_alloc(s, s->nb_temps + 2); 427 ts = &s->temps[s->nb_temps]; 428 ts->base_type = type; 429 ts->type = TCG_TYPE_I32; 430 ts->temp_allocated = 1; 431 ts->temp_local = temp_local; 432 ts->name = NULL; 433 ts++; 434 ts->base_type = TCG_TYPE_I32; 435 ts->type = TCG_TYPE_I32; 436 ts->temp_allocated = 1; 437 ts->temp_local = temp_local; 438 ts->name = NULL; 439 s->nb_temps += 2; 440 } else 441 #endif 442 { 443 tcg_temp_alloc(s, s->nb_temps + 1); 444 ts = &s->temps[s->nb_temps]; 445 ts->base_type = type; 446 ts->type = type; 447 ts->temp_allocated = 1; 448 ts->temp_local = temp_local; 449 ts->name = NULL; 450 s->nb_temps++; 451 } 452 } 453 454 #if defined(CONFIG_DEBUG_TCG) 455 s->temps_in_use++; 456 #endif 457 return idx; 458 } 459 460 TCGv_i32 tcg_temp_new_internal_i32(int temp_local) 461 { 462 int idx; 463 464 idx = tcg_temp_new_internal(TCG_TYPE_I32, temp_local); 465 return MAKE_TCGV_I32(idx); 466 } 467 468 TCGv_i64 tcg_temp_new_internal_i64(int temp_local) 469 { 470 int idx; 471 472 idx = tcg_temp_new_internal(TCG_TYPE_I64, temp_local); 473 return MAKE_TCGV_I64(idx); 474 } 475 476 static inline void tcg_temp_free_internal(int idx) 477 { 478 TCGContext *s = &tcg_ctx; 479 TCGTemp *ts; 480 int k; 481 482 #if defined(CONFIG_DEBUG_TCG) 483 s->temps_in_use--; 484 if (s->temps_in_use < 0) { 485 fprintf(stderr, "More temporaries freed than allocated!\n"); 486 } 487 #endif 488 489 assert(idx >= s->nb_globals && idx < s->nb_temps); 490 ts = &s->temps[idx]; 491 assert(ts->temp_allocated != 0); 492 ts->temp_allocated = 0; 493 k = ts->base_type; 494 if (ts->temp_local) 495 k += TCG_TYPE_COUNT; 496 ts->next_free_temp = s->first_free_temp[k]; 497 s->first_free_temp[k] = idx; 498 } 499 500 void tcg_temp_free_i32(TCGv_i32 arg) 501 { 502 tcg_temp_free_internal(GET_TCGV_I32(arg)); 503 } 504 505 void tcg_temp_free_i64(TCGv_i64 arg) 506 { 507 tcg_temp_free_internal(GET_TCGV_I64(arg)); 508 } 509 510 TCGv_i32 tcg_const_i32(int32_t val) 511 { 512 TCGv_i32 t0; 513 t0 = tcg_temp_new_i32(); 514 tcg_gen_movi_i32(t0, val); 515 return t0; 516 } 517 518 TCGv_i64 tcg_const_i64(int64_t val) 519 { 520 TCGv_i64 t0; 521 t0 = tcg_temp_new_i64(); 522 tcg_gen_movi_i64(t0, val); 523 return t0; 524 } 525 526 TCGv_i32 tcg_const_local_i32(int32_t val) 527 { 528 TCGv_i32 t0; 529 t0 = tcg_temp_local_new_i32(); 530 tcg_gen_movi_i32(t0, val); 531 return t0; 532 } 533 534 TCGv_i64 tcg_const_local_i64(int64_t val) 535 { 536 TCGv_i64 t0; 537 t0 = tcg_temp_local_new_i64(); 538 tcg_gen_movi_i64(t0, val); 539 return t0; 540 } 541 542 #if defined(CONFIG_DEBUG_TCG) 543 void tcg_clear_temp_count(void) 544 { 545 TCGContext *s = &tcg_ctx; 546 s->temps_in_use = 0; 547 } 548 549 int tcg_check_temp_count(void) 550 { 551 TCGContext *s = &tcg_ctx; 552 if (s->temps_in_use) { 553 /* Clear the count so that we don't give another 554 * warning immediately next time around. 555 */ 556 s->temps_in_use = 0; 557 return 1; 558 } 559 return 0; 560 } 561 #endif 562 563 void tcg_register_helper(void *func, const char *name) 564 { 565 TCGContext *s = &tcg_ctx; 566 int n; 567 if ((s->nb_helpers + 1) > s->allocated_helpers) { 568 n = s->allocated_helpers; 569 if (n == 0) { 570 n = 4; 571 } else { 572 n *= 2; 573 } 574 s->helpers = realloc(s->helpers, n * sizeof(TCGHelperInfo)); 575 s->allocated_helpers = n; 576 } 577 s->helpers[s->nb_helpers].func = (tcg_target_ulong)func; 578 s->helpers[s->nb_helpers].name = name; 579 s->nb_helpers++; 580 } 581 582 /* Note: we convert the 64 bit args to 32 bit and do some alignment 583 and endian swap. Maybe it would be better to do the alignment 584 and endian swap in tcg_reg_alloc_call(). */ 585 void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags, 586 int sizemask, TCGArg ret, int nargs, TCGArg *args) 587 { 588 #ifdef TCG_TARGET_I386 589 int call_type; 590 #endif 591 int i; 592 int real_args; 593 int nb_rets; 594 TCGArg *nparam; 595 596 #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 597 for (i = 0; i < nargs; ++i) { 598 int is_64bit = sizemask & (1 << (i+1)*2); 599 int is_signed = sizemask & (2 << (i+1)*2); 600 if (!is_64bit) { 601 TCGv_i64 temp = tcg_temp_new_i64(); 602 TCGv_i64 orig = MAKE_TCGV_I64(args[i]); 603 if (is_signed) { 604 tcg_gen_ext32s_i64(temp, orig); 605 } else { 606 tcg_gen_ext32u_i64(temp, orig); 607 } 608 args[i] = GET_TCGV_I64(temp); 609 } 610 } 611 #endif /* TCG_TARGET_EXTEND_ARGS */ 612 613 *gen_opc_ptr++ = INDEX_op_call; 614 nparam = gen_opparam_ptr++; 615 #ifdef TCG_TARGET_I386 616 call_type = (flags & TCG_CALL_TYPE_MASK); 617 #endif 618 if (ret != TCG_CALL_DUMMY_ARG) { 619 #if TCG_TARGET_REG_BITS < 64 620 if (sizemask & 1) { 621 #ifdef TCG_TARGET_WORDS_BIGENDIAN 622 *gen_opparam_ptr++ = ret + 1; 623 *gen_opparam_ptr++ = ret; 624 #else 625 *gen_opparam_ptr++ = ret; 626 *gen_opparam_ptr++ = ret + 1; 627 #endif 628 nb_rets = 2; 629 } else 630 #endif 631 { 632 *gen_opparam_ptr++ = ret; 633 nb_rets = 1; 634 } 635 } else { 636 nb_rets = 0; 637 } 638 real_args = 0; 639 for (i = 0; i < nargs; i++) { 640 #if TCG_TARGET_REG_BITS < 64 641 int is_64bit = sizemask & (1 << (i+1)*2); 642 if (is_64bit) { 643 #ifdef TCG_TARGET_I386 644 /* REGPARM case: if the third parameter is 64 bit, it is 645 allocated on the stack */ 646 if (i == 2 && call_type == TCG_CALL_TYPE_REGPARM) { 647 call_type = TCG_CALL_TYPE_REGPARM_2; 648 flags = (flags & ~TCG_CALL_TYPE_MASK) | call_type; 649 } 650 #endif 651 #ifdef TCG_TARGET_CALL_ALIGN_ARGS 652 /* some targets want aligned 64 bit args */ 653 if (real_args & 1) { 654 *gen_opparam_ptr++ = TCG_CALL_DUMMY_ARG; 655 real_args++; 656 } 657 #endif 658 /* If stack grows up, then we will be placing successive 659 arguments at lower addresses, which means we need to 660 reverse the order compared to how we would normally 661 treat either big or little-endian. For those arguments 662 that will wind up in registers, this still works for 663 HPPA (the only current STACK_GROWSUP target) since the 664 argument registers are *also* allocated in decreasing 665 order. If another such target is added, this logic may 666 have to get more complicated to differentiate between 667 stack arguments and register arguments. */ 668 #if defined(TCG_TARGET_WORDS_BIGENDIAN) != defined(TCG_TARGET_STACK_GROWSUP) 669 *gen_opparam_ptr++ = args[i] + 1; 670 *gen_opparam_ptr++ = args[i]; 671 #else 672 *gen_opparam_ptr++ = args[i]; 673 *gen_opparam_ptr++ = args[i] + 1; 674 #endif 675 real_args += 2; 676 continue; 677 } 678 #endif /* TCG_TARGET_REG_BITS < 64 */ 679 680 *gen_opparam_ptr++ = args[i]; 681 real_args++; 682 } 683 *gen_opparam_ptr++ = GET_TCGV_PTR(func); 684 685 *gen_opparam_ptr++ = flags; 686 687 *nparam = (nb_rets << 16) | (real_args + 1); 688 689 /* total parameters, needed to go backward in the instruction stream */ 690 *gen_opparam_ptr++ = 1 + nb_rets + real_args + 3; 691 692 #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 693 for (i = 0; i < nargs; ++i) { 694 int is_64bit = sizemask & (1 << (i+1)*2); 695 if (!is_64bit) { 696 TCGv_i64 temp = MAKE_TCGV_I64(args[i]); 697 tcg_temp_free_i64(temp); 698 } 699 } 700 #endif /* TCG_TARGET_EXTEND_ARGS */ 701 } 702 703 #if TCG_TARGET_REG_BITS == 32 704 void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, 705 int c, int right, int arith) 706 { 707 if (c == 0) { 708 tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1)); 709 tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1)); 710 } else if (c >= 32) { 711 c -= 32; 712 if (right) { 713 if (arith) { 714 tcg_gen_sari_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 715 tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 31); 716 } else { 717 tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 718 tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 719 } 720 } else { 721 tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_LOW(arg1), c); 722 tcg_gen_movi_i32(TCGV_LOW(ret), 0); 723 } 724 } else { 725 TCGv_i32 t0, t1; 726 727 t0 = tcg_temp_new_i32(); 728 t1 = tcg_temp_new_i32(); 729 if (right) { 730 tcg_gen_shli_i32(t0, TCGV_HIGH(arg1), 32 - c); 731 if (arith) 732 tcg_gen_sari_i32(t1, TCGV_HIGH(arg1), c); 733 else 734 tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c); 735 tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_LOW(arg1), c); 736 tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t0); 737 tcg_gen_mov_i32(TCGV_HIGH(ret), t1); 738 } else { 739 tcg_gen_shri_i32(t0, TCGV_LOW(arg1), 32 - c); 740 /* Note: ret can be the same as arg1, so we use t1 */ 741 tcg_gen_shli_i32(t1, TCGV_LOW(arg1), c); 742 tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c); 743 tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0); 744 tcg_gen_mov_i32(TCGV_LOW(ret), t1); 745 } 746 tcg_temp_free_i32(t0); 747 tcg_temp_free_i32(t1); 748 } 749 } 750 #endif 751 752 753 static void tcg_reg_alloc_start(TCGContext *s) 754 { 755 int i; 756 TCGTemp *ts; 757 for(i = 0; i < s->nb_globals; i++) { 758 ts = &s->temps[i]; 759 if (ts->fixed_reg) { 760 ts->val_type = TEMP_VAL_REG; 761 } else { 762 ts->val_type = TEMP_VAL_MEM; 763 } 764 } 765 for(i = s->nb_globals; i < s->nb_temps; i++) { 766 ts = &s->temps[i]; 767 ts->val_type = TEMP_VAL_DEAD; 768 ts->mem_allocated = 0; 769 ts->fixed_reg = 0; 770 } 771 for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 772 s->reg_to_temp[i] = -1; 773 } 774 } 775 776 static char *tcg_get_arg_str_idx(TCGContext *s, char *buf, int buf_size, 777 int idx) 778 { 779 TCGTemp *ts; 780 781 ts = &s->temps[idx]; 782 if (idx < s->nb_globals) { 783 pstrcpy(buf, buf_size, ts->name); 784 } else { 785 if (ts->temp_local) 786 snprintf(buf, buf_size, "loc%d", idx - s->nb_globals); 787 else 788 snprintf(buf, buf_size, "tmp%d", idx - s->nb_globals); 789 } 790 return buf; 791 } 792 793 char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg) 794 { 795 return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I32(arg)); 796 } 797 798 char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg) 799 { 800 return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I64(arg)); 801 } 802 803 static int helper_cmp(const void *p1, const void *p2) 804 { 805 const TCGHelperInfo *th1 = p1; 806 const TCGHelperInfo *th2 = p2; 807 if (th1->func < th2->func) 808 return -1; 809 else if (th1->func == th2->func) 810 return 0; 811 else 812 return 1; 813 } 814 815 /* find helper definition (Note: A hash table would be better) */ 816 static TCGHelperInfo *tcg_find_helper(TCGContext *s, tcg_target_ulong val) 817 { 818 int m, m_min, m_max; 819 TCGHelperInfo *th; 820 tcg_target_ulong v; 821 822 if (unlikely(!s->helpers_sorted)) { 823 qsort(s->helpers, s->nb_helpers, sizeof(TCGHelperInfo), 824 helper_cmp); 825 s->helpers_sorted = 1; 826 } 827 828 /* binary search */ 829 m_min = 0; 830 m_max = s->nb_helpers - 1; 831 while (m_min <= m_max) { 832 m = (m_min + m_max) >> 1; 833 th = &s->helpers[m]; 834 v = th->func; 835 if (v == val) 836 return th; 837 else if (val < v) { 838 m_max = m - 1; 839 } else { 840 m_min = m + 1; 841 } 842 } 843 return NULL; 844 } 845 846 static const char * const cond_name[] = 847 { 848 [TCG_COND_EQ] = "eq", 849 [TCG_COND_NE] = "ne", 850 [TCG_COND_LT] = "lt", 851 [TCG_COND_GE] = "ge", 852 [TCG_COND_LE] = "le", 853 [TCG_COND_GT] = "gt", 854 [TCG_COND_LTU] = "ltu", 855 [TCG_COND_GEU] = "geu", 856 [TCG_COND_LEU] = "leu", 857 [TCG_COND_GTU] = "gtu" 858 }; 859 860 void tcg_dump_ops(TCGContext *s, FILE *outfile) 861 { 862 const uint16_t *opc_ptr; 863 const TCGArg *args; 864 TCGArg arg; 865 TCGOpcode c; 866 int i, k, nb_oargs, nb_iargs, nb_cargs, first_insn; 867 const TCGOpDef *def; 868 char buf[128]; 869 870 first_insn = 1; 871 opc_ptr = gen_opc_buf; 872 args = gen_opparam_buf; 873 while (opc_ptr < gen_opc_ptr) { 874 c = *opc_ptr++; 875 def = &tcg_op_defs[c]; 876 if (c == INDEX_op_debug_insn_start) { 877 uint64_t pc; 878 #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS 879 pc = ((uint64_t)args[1] << 32) | args[0]; 880 #else 881 pc = args[0]; 882 #endif 883 if (!first_insn) 884 fprintf(outfile, "\n"); 885 fprintf(outfile, " ---- 0x%" PRIx64, pc); 886 first_insn = 0; 887 nb_oargs = def->nb_oargs; 888 nb_iargs = def->nb_iargs; 889 nb_cargs = def->nb_cargs; 890 } else if (c == INDEX_op_call) { 891 TCGArg arg; 892 893 /* variable number of arguments */ 894 arg = *args++; 895 nb_oargs = arg >> 16; 896 nb_iargs = arg & 0xffff; 897 nb_cargs = def->nb_cargs; 898 899 fprintf(outfile, " %s ", def->name); 900 901 /* function name */ 902 fprintf(outfile, "%s", 903 tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + nb_iargs - 1])); 904 /* flags */ 905 fprintf(outfile, ",$0x%" TCG_PRIlx, 906 args[nb_oargs + nb_iargs]); 907 /* nb out args */ 908 fprintf(outfile, ",$%d", nb_oargs); 909 for(i = 0; i < nb_oargs; i++) { 910 fprintf(outfile, ","); 911 fprintf(outfile, "%s", 912 tcg_get_arg_str_idx(s, buf, sizeof(buf), args[i])); 913 } 914 for(i = 0; i < (nb_iargs - 1); i++) { 915 fprintf(outfile, ","); 916 if (args[nb_oargs + i] == TCG_CALL_DUMMY_ARG) { 917 fprintf(outfile, "<dummy>"); 918 } else { 919 fprintf(outfile, "%s", 920 tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + i])); 921 } 922 } 923 } else if (c == INDEX_op_movi_i32 924 #if TCG_TARGET_REG_BITS == 64 925 || c == INDEX_op_movi_i64 926 #endif 927 ) { 928 tcg_target_ulong val; 929 TCGHelperInfo *th; 930 931 nb_oargs = def->nb_oargs; 932 nb_iargs = def->nb_iargs; 933 nb_cargs = def->nb_cargs; 934 fprintf(outfile, " %s %s,$", def->name, 935 tcg_get_arg_str_idx(s, buf, sizeof(buf), args[0])); 936 val = args[1]; 937 th = tcg_find_helper(s, val); 938 if (th) { 939 fprintf(outfile, "%s", th->name); 940 } else { 941 if (c == INDEX_op_movi_i32) 942 fprintf(outfile, "0x%x", (uint32_t)val); 943 else 944 fprintf(outfile, "0x%" PRIx64 , (uint64_t)val); 945 } 946 } else { 947 fprintf(outfile, " %s ", def->name); 948 if (c == INDEX_op_nopn) { 949 /* variable number of arguments */ 950 nb_cargs = *args; 951 nb_oargs = 0; 952 nb_iargs = 0; 953 } else { 954 nb_oargs = def->nb_oargs; 955 nb_iargs = def->nb_iargs; 956 nb_cargs = def->nb_cargs; 957 } 958 959 k = 0; 960 for(i = 0; i < nb_oargs; i++) { 961 if (k != 0) 962 fprintf(outfile, ","); 963 fprintf(outfile, "%s", 964 tcg_get_arg_str_idx(s, buf, sizeof(buf), args[k++])); 965 } 966 for(i = 0; i < nb_iargs; i++) { 967 if (k != 0) 968 fprintf(outfile, ","); 969 fprintf(outfile, "%s", 970 tcg_get_arg_str_idx(s, buf, sizeof(buf), args[k++])); 971 } 972 switch (c) { 973 case INDEX_op_brcond_i32: 974 #if TCG_TARGET_REG_BITS == 32 975 case INDEX_op_brcond2_i32: 976 #elif TCG_TARGET_REG_BITS == 64 977 case INDEX_op_brcond_i64: 978 #endif 979 case INDEX_op_setcond_i32: 980 #if TCG_TARGET_REG_BITS == 32 981 case INDEX_op_setcond2_i32: 982 #elif TCG_TARGET_REG_BITS == 64 983 case INDEX_op_setcond_i64: 984 #endif 985 if (args[k] < ARRAY_SIZE(cond_name) && cond_name[args[k]]) 986 fprintf(outfile, ",%s", cond_name[args[k++]]); 987 else 988 fprintf(outfile, ",$0x%" TCG_PRIlx, args[k++]); 989 i = 1; 990 break; 991 default: 992 i = 0; 993 break; 994 } 995 for(; i < nb_cargs; i++) { 996 if (k != 0) 997 fprintf(outfile, ","); 998 arg = args[k++]; 999 fprintf(outfile, "$0x%" TCG_PRIlx, arg); 1000 } 1001 } 1002 fprintf(outfile, "\n"); 1003 args += nb_iargs + nb_oargs + nb_cargs; 1004 } 1005 } 1006 1007 /* we give more priority to constraints with less registers */ 1008 static int get_constraint_priority(const TCGOpDef *def, int k) 1009 { 1010 const TCGArgConstraint *arg_ct; 1011 1012 int i, n; 1013 arg_ct = &def->args_ct[k]; 1014 if (arg_ct->ct & TCG_CT_ALIAS) { 1015 /* an alias is equivalent to a single register */ 1016 n = 1; 1017 } else { 1018 if (!(arg_ct->ct & TCG_CT_REG)) 1019 return 0; 1020 n = 0; 1021 for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1022 if (tcg_regset_test_reg(arg_ct->u.regs, i)) 1023 n++; 1024 } 1025 } 1026 return TCG_TARGET_NB_REGS - n + 1; 1027 } 1028 1029 /* sort from highest priority to lowest */ 1030 static void sort_constraints(TCGOpDef *def, int start, int n) 1031 { 1032 int i, j, p1, p2, tmp; 1033 1034 for(i = 0; i < n; i++) 1035 def->sorted_args[start + i] = start + i; 1036 if (n <= 1) 1037 return; 1038 for(i = 0; i < n - 1; i++) { 1039 for(j = i + 1; j < n; j++) { 1040 p1 = get_constraint_priority(def, def->sorted_args[start + i]); 1041 p2 = get_constraint_priority(def, def->sorted_args[start + j]); 1042 if (p1 < p2) { 1043 tmp = def->sorted_args[start + i]; 1044 def->sorted_args[start + i] = def->sorted_args[start + j]; 1045 def->sorted_args[start + j] = tmp; 1046 } 1047 } 1048 } 1049 } 1050 1051 void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs) 1052 { 1053 TCGOpcode op; 1054 TCGOpDef *def; 1055 const char *ct_str; 1056 int i, nb_args; 1057 1058 for(;;) { 1059 if (tdefs->op == (TCGOpcode)-1) 1060 break; 1061 op = tdefs->op; 1062 assert((unsigned)op < NB_OPS); 1063 def = &tcg_op_defs[op]; 1064 #if defined(CONFIG_DEBUG_TCG) 1065 /* Duplicate entry in op definitions? */ 1066 assert(!def->used); 1067 def->used = 1; 1068 #endif 1069 nb_args = def->nb_iargs + def->nb_oargs; 1070 for(i = 0; i < nb_args; i++) { 1071 ct_str = tdefs->args_ct_str[i]; 1072 /* Incomplete TCGTargetOpDef entry? */ 1073 assert(ct_str != NULL); 1074 tcg_regset_clear(def->args_ct[i].u.regs); 1075 def->args_ct[i].ct = 0; 1076 if (ct_str[0] >= '0' && ct_str[0] <= '9') { 1077 int oarg; 1078 oarg = ct_str[0] - '0'; 1079 assert(oarg < def->nb_oargs); 1080 assert(def->args_ct[oarg].ct & TCG_CT_REG); 1081 /* TCG_CT_ALIAS is for the output arguments. The input 1082 argument is tagged with TCG_CT_IALIAS. */ 1083 def->args_ct[i] = def->args_ct[oarg]; 1084 def->args_ct[oarg].ct = TCG_CT_ALIAS; 1085 def->args_ct[oarg].alias_index = i; 1086 def->args_ct[i].ct |= TCG_CT_IALIAS; 1087 def->args_ct[i].alias_index = oarg; 1088 } else { 1089 for(;;) { 1090 if (*ct_str == '\0') 1091 break; 1092 switch(*ct_str) { 1093 case 'i': 1094 def->args_ct[i].ct |= TCG_CT_CONST; 1095 ct_str++; 1096 break; 1097 default: 1098 if (target_parse_constraint(&def->args_ct[i], &ct_str) < 0) { 1099 fprintf(stderr, "Invalid constraint '%s' for arg %d of operation '%s'\n", 1100 ct_str, i, def->name); 1101 exit(1); 1102 } 1103 } 1104 } 1105 } 1106 } 1107 1108 /* TCGTargetOpDef entry with too much information? */ 1109 assert(i == TCG_MAX_OP_ARGS || tdefs->args_ct_str[i] == NULL); 1110 1111 /* sort the constraints (XXX: this is just an heuristic) */ 1112 sort_constraints(def, 0, def->nb_oargs); 1113 sort_constraints(def, def->nb_oargs, def->nb_iargs); 1114 1115 #if 0 1116 { 1117 int i; 1118 1119 printf("%s: sorted=", def->name); 1120 for(i = 0; i < def->nb_oargs + def->nb_iargs; i++) 1121 printf(" %d", def->sorted_args[i]); 1122 printf("\n"); 1123 } 1124 #endif 1125 tdefs++; 1126 } 1127 1128 #if defined(CONFIG_DEBUG_TCG) 1129 i = 0; 1130 for (op = 0; op < ARRAY_SIZE(tcg_op_defs); op++) { 1131 if (op < INDEX_op_call || op == INDEX_op_debug_insn_start) { 1132 /* Wrong entry in op definitions? */ 1133 if (tcg_op_defs[op].used) { 1134 fprintf(stderr, "Invalid op definition for %s\n", 1135 tcg_op_defs[op].name); 1136 i = 1; 1137 } 1138 } else { 1139 /* Missing entry in op definitions? */ 1140 if (!tcg_op_defs[op].used) { 1141 fprintf(stderr, "Missing op definition for %s\n", 1142 tcg_op_defs[op].name); 1143 i = 1; 1144 } 1145 } 1146 } 1147 if (i == 1) { 1148 tcg_abort(); 1149 } 1150 #endif 1151 } 1152 1153 #ifdef USE_LIVENESS_ANALYSIS 1154 1155 /* set a nop for an operation using 'nb_args' */ 1156 static inline void tcg_set_nop(TCGContext *s, uint16_t *opc_ptr, 1157 TCGArg *args, int nb_args) 1158 { 1159 if (nb_args == 0) { 1160 *opc_ptr = INDEX_op_nop; 1161 } else { 1162 *opc_ptr = INDEX_op_nopn; 1163 args[0] = nb_args; 1164 args[nb_args - 1] = nb_args; 1165 } 1166 } 1167 1168 /* liveness analysis: end of function: globals are live, temps are 1169 dead. */ 1170 /* XXX: at this stage, not used as there would be little gains because 1171 most TBs end with a conditional jump. */ 1172 static inline void tcg_la_func_end(TCGContext *s, uint8_t *dead_temps) 1173 { 1174 memset(dead_temps, 0, s->nb_globals); 1175 memset(dead_temps + s->nb_globals, 1, s->nb_temps - s->nb_globals); 1176 } 1177 1178 /* liveness analysis: end of basic block: globals are live, temps are 1179 dead, local temps are live. */ 1180 static inline void tcg_la_bb_end(TCGContext *s, uint8_t *dead_temps) 1181 { 1182 int i; 1183 TCGTemp *ts; 1184 1185 memset(dead_temps, 0, s->nb_globals); 1186 ts = &s->temps[s->nb_globals]; 1187 for(i = s->nb_globals; i < s->nb_temps; i++) { 1188 if (ts->temp_local) 1189 dead_temps[i] = 0; 1190 else 1191 dead_temps[i] = 1; 1192 ts++; 1193 } 1194 } 1195 1196 /* Liveness analysis : update the opc_dead_iargs array to tell if a 1197 given input arguments is dead. Instructions updating dead 1198 temporaries are removed. */ 1199 static void tcg_liveness_analysis(TCGContext *s) 1200 { 1201 int i, op_index, nb_args, nb_iargs, nb_oargs, arg, nb_ops; 1202 TCGOpcode op; 1203 TCGArg *args; 1204 const TCGOpDef *def; 1205 uint8_t *dead_temps; 1206 unsigned int dead_iargs; 1207 1208 gen_opc_ptr++; /* skip end */ 1209 1210 nb_ops = gen_opc_ptr - gen_opc_buf; 1211 1212 s->op_dead_iargs = tcg_malloc(nb_ops * sizeof(uint16_t)); 1213 1214 dead_temps = tcg_malloc(s->nb_temps); 1215 memset(dead_temps, 1, s->nb_temps); 1216 1217 args = gen_opparam_ptr; 1218 op_index = nb_ops - 1; 1219 while (op_index >= 0) { 1220 op = gen_opc_buf[op_index]; 1221 def = &tcg_op_defs[op]; 1222 switch(op) { 1223 case INDEX_op_call: 1224 { 1225 int call_flags; 1226 1227 nb_args = args[-1]; 1228 args -= nb_args; 1229 nb_iargs = args[0] & 0xffff; 1230 nb_oargs = args[0] >> 16; 1231 args++; 1232 call_flags = args[nb_oargs + nb_iargs]; 1233 1234 /* pure functions can be removed if their result is not 1235 used */ 1236 if (call_flags & TCG_CALL_PURE) { 1237 for(i = 0; i < nb_oargs; i++) { 1238 arg = args[i]; 1239 if (!dead_temps[arg]) 1240 goto do_not_remove_call; 1241 } 1242 tcg_set_nop(s, gen_opc_buf + op_index, 1243 args - 1, nb_args); 1244 } else { 1245 do_not_remove_call: 1246 1247 /* output args are dead */ 1248 for(i = 0; i < nb_oargs; i++) { 1249 arg = args[i]; 1250 dead_temps[arg] = 1; 1251 } 1252 1253 if (!(call_flags & TCG_CALL_CONST)) { 1254 /* globals are live (they may be used by the call) */ 1255 memset(dead_temps, 0, s->nb_globals); 1256 } 1257 1258 /* input args are live */ 1259 dead_iargs = 0; 1260 for(i = 0; i < nb_iargs; i++) { 1261 arg = args[i + nb_oargs]; 1262 if (arg != TCG_CALL_DUMMY_ARG) { 1263 if (dead_temps[arg]) { 1264 dead_iargs |= (1 << i); 1265 } 1266 dead_temps[arg] = 0; 1267 } 1268 } 1269 s->op_dead_iargs[op_index] = dead_iargs; 1270 } 1271 args--; 1272 } 1273 break; 1274 case INDEX_op_set_label: 1275 args--; 1276 /* mark end of basic block */ 1277 tcg_la_bb_end(s, dead_temps); 1278 break; 1279 case INDEX_op_debug_insn_start: 1280 args -= def->nb_args; 1281 break; 1282 case INDEX_op_nopn: 1283 nb_args = args[-1]; 1284 args -= nb_args; 1285 break; 1286 case INDEX_op_discard: 1287 args--; 1288 /* mark the temporary as dead */ 1289 dead_temps[args[0]] = 1; 1290 break; 1291 case INDEX_op_end: 1292 break; 1293 /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */ 1294 default: 1295 args -= def->nb_args; 1296 nb_iargs = def->nb_iargs; 1297 nb_oargs = def->nb_oargs; 1298 1299 /* Test if the operation can be removed because all 1300 its outputs are dead. We assume that nb_oargs == 0 1301 implies side effects */ 1302 if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) { 1303 for(i = 0; i < nb_oargs; i++) { 1304 arg = args[i]; 1305 if (!dead_temps[arg]) 1306 goto do_not_remove; 1307 } 1308 tcg_set_nop(s, gen_opc_buf + op_index, args, def->nb_args); 1309 #ifdef CONFIG_PROFILER 1310 s->del_op_count++; 1311 #endif 1312 } else { 1313 do_not_remove: 1314 1315 /* output args are dead */ 1316 for(i = 0; i < nb_oargs; i++) { 1317 arg = args[i]; 1318 dead_temps[arg] = 1; 1319 } 1320 1321 /* if end of basic block, update */ 1322 if (def->flags & TCG_OPF_BB_END) { 1323 tcg_la_bb_end(s, dead_temps); 1324 } else if (def->flags & TCG_OPF_CALL_CLOBBER) { 1325 /* globals are live */ 1326 memset(dead_temps, 0, s->nb_globals); 1327 } 1328 1329 /* input args are live */ 1330 dead_iargs = 0; 1331 for(i = 0; i < nb_iargs; i++) { 1332 arg = args[i + nb_oargs]; 1333 if (dead_temps[arg]) { 1334 dead_iargs |= (1 << i); 1335 } 1336 dead_temps[arg] = 0; 1337 } 1338 s->op_dead_iargs[op_index] = dead_iargs; 1339 } 1340 break; 1341 } 1342 op_index--; 1343 } 1344 1345 if (args != gen_opparam_buf) 1346 tcg_abort(); 1347 } 1348 #else 1349 /* dummy liveness analysis */ 1350 static void tcg_liveness_analysis(TCGContext *s) 1351 { 1352 int nb_ops; 1353 nb_ops = gen_opc_ptr - gen_opc_buf; 1354 1355 s->op_dead_iargs = tcg_malloc(nb_ops * sizeof(uint16_t)); 1356 memset(s->op_dead_iargs, 0, nb_ops * sizeof(uint16_t)); 1357 } 1358 #endif 1359 1360 #ifndef NDEBUG 1361 static void dump_regs(TCGContext *s) 1362 { 1363 TCGTemp *ts; 1364 int i; 1365 char buf[64]; 1366 1367 for(i = 0; i < s->nb_temps; i++) { 1368 ts = &s->temps[i]; 1369 printf(" %10s: ", tcg_get_arg_str_idx(s, buf, sizeof(buf), i)); 1370 switch(ts->val_type) { 1371 case TEMP_VAL_REG: 1372 printf("%s", tcg_target_reg_names[ts->reg]); 1373 break; 1374 case TEMP_VAL_MEM: 1375 printf("%d(%s)", (int)ts->mem_offset, tcg_target_reg_names[ts->mem_reg]); 1376 break; 1377 case TEMP_VAL_CONST: 1378 printf("$0x%" TCG_PRIlx, ts->val); 1379 break; 1380 case TEMP_VAL_DEAD: 1381 printf("D"); 1382 break; 1383 default: 1384 printf("???"); 1385 break; 1386 } 1387 printf("\n"); 1388 } 1389 1390 for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1391 if (s->reg_to_temp[i] >= 0) { 1392 printf("%s: %s\n", 1393 tcg_target_reg_names[i], 1394 tcg_get_arg_str_idx(s, buf, sizeof(buf), s->reg_to_temp[i])); 1395 } 1396 } 1397 } 1398 1399 static void check_regs(TCGContext *s) 1400 { 1401 int reg, k; 1402 TCGTemp *ts; 1403 char buf[64]; 1404 1405 for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1406 k = s->reg_to_temp[reg]; 1407 if (k >= 0) { 1408 ts = &s->temps[k]; 1409 if (ts->val_type != TEMP_VAL_REG || 1410 ts->reg != reg) { 1411 printf("Inconsistency for register %s:\n", 1412 tcg_target_reg_names[reg]); 1413 goto fail; 1414 } 1415 } 1416 } 1417 for(k = 0; k < s->nb_temps; k++) { 1418 ts = &s->temps[k]; 1419 if (ts->val_type == TEMP_VAL_REG && 1420 !ts->fixed_reg && 1421 s->reg_to_temp[ts->reg] != k) { 1422 printf("Inconsistency for temp %s:\n", 1423 tcg_get_arg_str_idx(s, buf, sizeof(buf), k)); 1424 fail: 1425 printf("reg state:\n"); 1426 dump_regs(s); 1427 tcg_abort(); 1428 } 1429 } 1430 } 1431 #endif 1432 1433 static void temp_allocate_frame(TCGContext *s, int temp) 1434 { 1435 TCGTemp *ts; 1436 ts = &s->temps[temp]; 1437 s->current_frame_offset = (s->current_frame_offset + sizeof(tcg_target_long) - 1) & ~(sizeof(tcg_target_long) - 1); 1438 if (s->current_frame_offset + sizeof(tcg_target_long) > s->frame_end) 1439 tcg_abort(); 1440 ts->mem_offset = s->current_frame_offset; 1441 ts->mem_reg = s->frame_reg; 1442 ts->mem_allocated = 1; 1443 s->current_frame_offset += sizeof(tcg_target_long); 1444 } 1445 1446 /* free register 'reg' by spilling the corresponding temporary if necessary */ 1447 static void tcg_reg_free(TCGContext *s, int reg) 1448 { 1449 TCGTemp *ts; 1450 int temp; 1451 1452 temp = s->reg_to_temp[reg]; 1453 if (temp != -1) { 1454 ts = &s->temps[temp]; 1455 assert(ts->val_type == TEMP_VAL_REG); 1456 if (!ts->mem_coherent) { 1457 if (!ts->mem_allocated) 1458 temp_allocate_frame(s, temp); 1459 tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1460 } 1461 ts->val_type = TEMP_VAL_MEM; 1462 s->reg_to_temp[reg] = -1; 1463 } 1464 } 1465 1466 /* Allocate a register belonging to reg1 & ~reg2 */ 1467 static int tcg_reg_alloc(TCGContext *s, TCGRegSet reg1, TCGRegSet reg2) 1468 { 1469 int i, reg; 1470 TCGRegSet reg_ct; 1471 1472 tcg_regset_andnot(reg_ct, reg1, reg2); 1473 1474 /* first try free registers */ 1475 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1476 reg = tcg_target_reg_alloc_order[i]; 1477 if (tcg_regset_test_reg(reg_ct, reg) && s->reg_to_temp[reg] == -1) 1478 return reg; 1479 } 1480 1481 /* XXX: do better spill choice */ 1482 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1483 reg = tcg_target_reg_alloc_order[i]; 1484 if (tcg_regset_test_reg(reg_ct, reg)) { 1485 tcg_reg_free(s, reg); 1486 return reg; 1487 } 1488 } 1489 1490 tcg_abort(); 1491 } 1492 1493 /* save a temporary to memory. 'allocated_regs' is used in case a 1494 temporary registers needs to be allocated to store a constant. */ 1495 static void temp_save(TCGContext *s, int temp, TCGRegSet allocated_regs) 1496 { 1497 TCGTemp *ts; 1498 int reg; 1499 1500 ts = &s->temps[temp]; 1501 if (!ts->fixed_reg) { 1502 switch(ts->val_type) { 1503 case TEMP_VAL_REG: 1504 tcg_reg_free(s, ts->reg); 1505 break; 1506 case TEMP_VAL_DEAD: 1507 ts->val_type = TEMP_VAL_MEM; 1508 break; 1509 case TEMP_VAL_CONST: 1510 reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 1511 allocated_regs); 1512 if (!ts->mem_allocated) 1513 temp_allocate_frame(s, temp); 1514 tcg_out_movi(s, ts->type, reg, ts->val); 1515 tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1516 ts->val_type = TEMP_VAL_MEM; 1517 break; 1518 case TEMP_VAL_MEM: 1519 break; 1520 default: 1521 tcg_abort(); 1522 } 1523 } 1524 } 1525 1526 /* save globals to their cannonical location and assume they can be 1527 modified be the following code. 'allocated_regs' is used in case a 1528 temporary registers needs to be allocated to store a constant. */ 1529 static void save_globals(TCGContext *s, TCGRegSet allocated_regs) 1530 { 1531 int i; 1532 1533 for(i = 0; i < s->nb_globals; i++) { 1534 temp_save(s, i, allocated_regs); 1535 } 1536 } 1537 1538 /* at the end of a basic block, we assume all temporaries are dead and 1539 all globals are stored at their canonical location. */ 1540 static void tcg_reg_alloc_bb_end(TCGContext *s, TCGRegSet allocated_regs) 1541 { 1542 TCGTemp *ts; 1543 int i; 1544 1545 for(i = s->nb_globals; i < s->nb_temps; i++) { 1546 ts = &s->temps[i]; 1547 if (ts->temp_local) { 1548 temp_save(s, i, allocated_regs); 1549 } else { 1550 if (ts->val_type == TEMP_VAL_REG) { 1551 s->reg_to_temp[ts->reg] = -1; 1552 } 1553 ts->val_type = TEMP_VAL_DEAD; 1554 } 1555 } 1556 1557 save_globals(s, allocated_regs); 1558 } 1559 1560 #define IS_DEAD_IARG(n) ((dead_iargs >> (n)) & 1) 1561 1562 static void tcg_reg_alloc_movi(TCGContext *s, const TCGArg *args) 1563 { 1564 TCGTemp *ots; 1565 tcg_target_ulong val; 1566 1567 ots = &s->temps[args[0]]; 1568 val = args[1]; 1569 1570 if (ots->fixed_reg) { 1571 /* for fixed registers, we do not do any constant 1572 propagation */ 1573 tcg_out_movi(s, ots->type, ots->reg, val); 1574 } else { 1575 /* The movi is not explicitly generated here */ 1576 if (ots->val_type == TEMP_VAL_REG) 1577 s->reg_to_temp[ots->reg] = -1; 1578 ots->val_type = TEMP_VAL_CONST; 1579 ots->val = val; 1580 } 1581 } 1582 1583 static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def, 1584 const TCGArg *args, 1585 unsigned int dead_iargs) 1586 { 1587 TCGTemp *ts, *ots; 1588 int reg; 1589 const TCGArgConstraint *arg_ct; 1590 1591 ots = &s->temps[args[0]]; 1592 ts = &s->temps[args[1]]; 1593 arg_ct = &def->args_ct[0]; 1594 1595 /* XXX: always mark arg dead if IS_DEAD_IARG(0) */ 1596 if (ts->val_type == TEMP_VAL_REG) { 1597 if (IS_DEAD_IARG(0) && !ts->fixed_reg && !ots->fixed_reg) { 1598 /* the mov can be suppressed */ 1599 if (ots->val_type == TEMP_VAL_REG) 1600 s->reg_to_temp[ots->reg] = -1; 1601 reg = ts->reg; 1602 s->reg_to_temp[reg] = -1; 1603 ts->val_type = TEMP_VAL_DEAD; 1604 } else { 1605 if (ots->val_type == TEMP_VAL_REG) { 1606 reg = ots->reg; 1607 } else { 1608 reg = tcg_reg_alloc(s, arg_ct->u.regs, s->reserved_regs); 1609 } 1610 if (ts->reg != reg) { 1611 tcg_out_mov(s, ots->type, reg, ts->reg); 1612 } 1613 } 1614 } else if (ts->val_type == TEMP_VAL_MEM) { 1615 if (ots->val_type == TEMP_VAL_REG) { 1616 reg = ots->reg; 1617 } else { 1618 reg = tcg_reg_alloc(s, arg_ct->u.regs, s->reserved_regs); 1619 } 1620 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1621 } else if (ts->val_type == TEMP_VAL_CONST) { 1622 if (ots->fixed_reg) { 1623 reg = ots->reg; 1624 tcg_out_movi(s, ots->type, reg, ts->val); 1625 } else { 1626 /* propagate constant */ 1627 if (ots->val_type == TEMP_VAL_REG) 1628 s->reg_to_temp[ots->reg] = -1; 1629 ots->val_type = TEMP_VAL_CONST; 1630 ots->val = ts->val; 1631 return; 1632 } 1633 } else { 1634 tcg_abort(); 1635 } 1636 s->reg_to_temp[reg] = args[0]; 1637 ots->reg = reg; 1638 ots->val_type = TEMP_VAL_REG; 1639 ots->mem_coherent = 0; 1640 } 1641 1642 static void tcg_reg_alloc_op(TCGContext *s, 1643 const TCGOpDef *def, TCGOpcode opc, 1644 const TCGArg *args, 1645 unsigned int dead_iargs) 1646 { 1647 TCGRegSet allocated_regs; 1648 int i, k, nb_iargs, nb_oargs, reg; 1649 TCGArg arg; 1650 const TCGArgConstraint *arg_ct; 1651 TCGTemp *ts; 1652 TCGArg new_args[TCG_MAX_OP_ARGS]; 1653 int const_args[TCG_MAX_OP_ARGS]; 1654 1655 nb_oargs = def->nb_oargs; 1656 nb_iargs = def->nb_iargs; 1657 1658 /* copy constants */ 1659 memcpy(new_args + nb_oargs + nb_iargs, 1660 args + nb_oargs + nb_iargs, 1661 sizeof(TCGArg) * def->nb_cargs); 1662 1663 /* satisfy input constraints */ 1664 tcg_regset_set(allocated_regs, s->reserved_regs); 1665 for(k = 0; k < nb_iargs; k++) { 1666 i = def->sorted_args[nb_oargs + k]; 1667 arg = args[i]; 1668 arg_ct = &def->args_ct[i]; 1669 ts = &s->temps[arg]; 1670 if (ts->val_type == TEMP_VAL_MEM) { 1671 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1672 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1673 ts->val_type = TEMP_VAL_REG; 1674 ts->reg = reg; 1675 ts->mem_coherent = 1; 1676 s->reg_to_temp[reg] = arg; 1677 } else if (ts->val_type == TEMP_VAL_CONST) { 1678 if (tcg_target_const_match(ts->val, arg_ct)) { 1679 /* constant is OK for instruction */ 1680 const_args[i] = 1; 1681 new_args[i] = ts->val; 1682 goto iarg_end; 1683 } else { 1684 /* need to move to a register */ 1685 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1686 tcg_out_movi(s, ts->type, reg, ts->val); 1687 ts->val_type = TEMP_VAL_REG; 1688 ts->reg = reg; 1689 ts->mem_coherent = 0; 1690 s->reg_to_temp[reg] = arg; 1691 } 1692 } 1693 assert(ts->val_type == TEMP_VAL_REG); 1694 if (arg_ct->ct & TCG_CT_IALIAS) { 1695 if (ts->fixed_reg) { 1696 /* if fixed register, we must allocate a new register 1697 if the alias is not the same register */ 1698 if (arg != args[arg_ct->alias_index]) 1699 goto allocate_in_reg; 1700 } else { 1701 /* if the input is aliased to an output and if it is 1702 not dead after the instruction, we must allocate 1703 a new register and move it */ 1704 if (!IS_DEAD_IARG(i - nb_oargs)) 1705 goto allocate_in_reg; 1706 } 1707 } 1708 reg = ts->reg; 1709 if (tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1710 /* nothing to do : the constraint is satisfied */ 1711 } else { 1712 allocate_in_reg: 1713 /* allocate a new register matching the constraint 1714 and move the temporary register into it */ 1715 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1716 tcg_out_mov(s, ts->type, reg, ts->reg); 1717 } 1718 new_args[i] = reg; 1719 const_args[i] = 0; 1720 tcg_regset_set_reg(allocated_regs, reg); 1721 iarg_end: ; 1722 } 1723 1724 if (def->flags & TCG_OPF_BB_END) { 1725 tcg_reg_alloc_bb_end(s, allocated_regs); 1726 } else { 1727 /* mark dead temporaries and free the associated registers */ 1728 for(i = 0; i < nb_iargs; i++) { 1729 arg = args[nb_oargs + i]; 1730 if (IS_DEAD_IARG(i)) { 1731 ts = &s->temps[arg]; 1732 if (!ts->fixed_reg) { 1733 if (ts->val_type == TEMP_VAL_REG) 1734 s->reg_to_temp[ts->reg] = -1; 1735 ts->val_type = TEMP_VAL_DEAD; 1736 } 1737 } 1738 } 1739 1740 if (def->flags & TCG_OPF_CALL_CLOBBER) { 1741 /* XXX: permit generic clobber register list ? */ 1742 for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1743 if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 1744 tcg_reg_free(s, reg); 1745 } 1746 } 1747 /* XXX: for load/store we could do that only for the slow path 1748 (i.e. when a memory callback is called) */ 1749 1750 /* store globals and free associated registers (we assume the insn 1751 can modify any global. */ 1752 save_globals(s, allocated_regs); 1753 } 1754 1755 /* satisfy the output constraints */ 1756 tcg_regset_set(allocated_regs, s->reserved_regs); 1757 for(k = 0; k < nb_oargs; k++) { 1758 i = def->sorted_args[k]; 1759 arg = args[i]; 1760 arg_ct = &def->args_ct[i]; 1761 ts = &s->temps[arg]; 1762 if (arg_ct->ct & TCG_CT_ALIAS) { 1763 reg = new_args[arg_ct->alias_index]; 1764 } else { 1765 /* if fixed register, we try to use it */ 1766 reg = ts->reg; 1767 if (ts->fixed_reg && 1768 tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1769 goto oarg_end; 1770 } 1771 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1772 } 1773 tcg_regset_set_reg(allocated_regs, reg); 1774 /* if a fixed register is used, then a move will be done afterwards */ 1775 if (!ts->fixed_reg) { 1776 if (ts->val_type == TEMP_VAL_REG) 1777 s->reg_to_temp[ts->reg] = -1; 1778 ts->val_type = TEMP_VAL_REG; 1779 ts->reg = reg; 1780 /* temp value is modified, so the value kept in memory is 1781 potentially not the same */ 1782 ts->mem_coherent = 0; 1783 s->reg_to_temp[reg] = arg; 1784 } 1785 oarg_end: 1786 new_args[i] = reg; 1787 } 1788 } 1789 1790 /* emit instruction */ 1791 tcg_out_op(s, opc, new_args, const_args); 1792 1793 /* move the outputs in the correct register if needed */ 1794 for(i = 0; i < nb_oargs; i++) { 1795 ts = &s->temps[args[i]]; 1796 reg = new_args[i]; 1797 if (ts->fixed_reg && ts->reg != reg) { 1798 tcg_out_mov(s, ts->type, ts->reg, reg); 1799 } 1800 } 1801 } 1802 1803 #ifdef TCG_TARGET_STACK_GROWSUP 1804 #define STACK_DIR(x) (-(x)) 1805 #else 1806 #define STACK_DIR(x) (x) 1807 #endif 1808 1809 static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def, 1810 TCGOpcode opc, const TCGArg *args, 1811 unsigned int dead_iargs) 1812 { 1813 int nb_iargs, nb_oargs, flags, nb_regs, i, reg, nb_params; 1814 TCGArg arg, func_arg; 1815 TCGTemp *ts; 1816 tcg_target_long stack_offset, call_stack_size, func_addr; 1817 int const_func_arg, allocate_args; 1818 TCGRegSet allocated_regs; 1819 const TCGArgConstraint *arg_ct; 1820 1821 arg = *args++; 1822 1823 nb_oargs = arg >> 16; 1824 nb_iargs = arg & 0xffff; 1825 nb_params = nb_iargs - 1; 1826 1827 flags = args[nb_oargs + nb_iargs]; 1828 1829 nb_regs = tcg_target_get_call_iarg_regs_count(flags); 1830 if (nb_regs > nb_params) 1831 nb_regs = nb_params; 1832 1833 /* assign stack slots first */ 1834 /* XXX: preallocate call stack */ 1835 call_stack_size = (nb_params - nb_regs) * sizeof(tcg_target_long); 1836 call_stack_size = (call_stack_size + TCG_TARGET_STACK_ALIGN - 1) & 1837 ~(TCG_TARGET_STACK_ALIGN - 1); 1838 allocate_args = (call_stack_size > TCG_STATIC_CALL_ARGS_SIZE); 1839 if (allocate_args) { 1840 tcg_out_addi(s, TCG_REG_CALL_STACK, -STACK_DIR(call_stack_size)); 1841 } 1842 1843 stack_offset = TCG_TARGET_CALL_STACK_OFFSET; 1844 for(i = nb_regs; i < nb_params; i++) { 1845 arg = args[nb_oargs + i]; 1846 #ifdef TCG_TARGET_STACK_GROWSUP 1847 stack_offset -= sizeof(tcg_target_long); 1848 #endif 1849 if (arg != TCG_CALL_DUMMY_ARG) { 1850 ts = &s->temps[arg]; 1851 if (ts->val_type == TEMP_VAL_REG) { 1852 tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset); 1853 } else if (ts->val_type == TEMP_VAL_MEM) { 1854 reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 1855 s->reserved_regs); 1856 /* XXX: not correct if reading values from the stack */ 1857 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1858 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 1859 } else if (ts->val_type == TEMP_VAL_CONST) { 1860 reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 1861 s->reserved_regs); 1862 /* XXX: sign extend may be needed on some targets */ 1863 tcg_out_movi(s, ts->type, reg, ts->val); 1864 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 1865 } else { 1866 tcg_abort(); 1867 } 1868 } 1869 #ifndef TCG_TARGET_STACK_GROWSUP 1870 stack_offset += sizeof(tcg_target_long); 1871 #endif 1872 } 1873 1874 /* assign input registers */ 1875 tcg_regset_set(allocated_regs, s->reserved_regs); 1876 for(i = 0; i < nb_regs; i++) { 1877 arg = args[nb_oargs + i]; 1878 if (arg != TCG_CALL_DUMMY_ARG) { 1879 ts = &s->temps[arg]; 1880 reg = tcg_target_call_iarg_regs[i]; 1881 tcg_reg_free(s, reg); 1882 if (ts->val_type == TEMP_VAL_REG) { 1883 if (ts->reg != reg) { 1884 tcg_out_mov(s, ts->type, reg, ts->reg); 1885 } 1886 } else if (ts->val_type == TEMP_VAL_MEM) { 1887 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1888 } else if (ts->val_type == TEMP_VAL_CONST) { 1889 /* XXX: sign extend ? */ 1890 tcg_out_movi(s, ts->type, reg, ts->val); 1891 } else { 1892 tcg_abort(); 1893 } 1894 tcg_regset_set_reg(allocated_regs, reg); 1895 } 1896 } 1897 1898 /* assign function address */ 1899 func_arg = args[nb_oargs + nb_iargs - 1]; 1900 arg_ct = &def->args_ct[0]; 1901 ts = &s->temps[func_arg]; 1902 func_addr = ts->val; 1903 const_func_arg = 0; 1904 if (ts->val_type == TEMP_VAL_MEM) { 1905 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1906 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1907 func_arg = reg; 1908 tcg_regset_set_reg(allocated_regs, reg); 1909 } else if (ts->val_type == TEMP_VAL_REG) { 1910 reg = ts->reg; 1911 if (!tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1912 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1913 tcg_out_mov(s, ts->type, reg, ts->reg); 1914 } 1915 func_arg = reg; 1916 tcg_regset_set_reg(allocated_regs, reg); 1917 } else if (ts->val_type == TEMP_VAL_CONST) { 1918 if (tcg_target_const_match(func_addr, arg_ct)) { 1919 const_func_arg = 1; 1920 func_arg = func_addr; 1921 } else { 1922 reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1923 tcg_out_movi(s, ts->type, reg, func_addr); 1924 func_arg = reg; 1925 tcg_regset_set_reg(allocated_regs, reg); 1926 } 1927 } else { 1928 tcg_abort(); 1929 } 1930 1931 1932 /* mark dead temporaries and free the associated registers */ 1933 for(i = 0; i < nb_iargs; i++) { 1934 arg = args[nb_oargs + i]; 1935 if (IS_DEAD_IARG(i)) { 1936 ts = &s->temps[arg]; 1937 if (!ts->fixed_reg) { 1938 if (ts->val_type == TEMP_VAL_REG) 1939 s->reg_to_temp[ts->reg] = -1; 1940 ts->val_type = TEMP_VAL_DEAD; 1941 } 1942 } 1943 } 1944 1945 /* clobber call registers */ 1946 for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1947 if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 1948 tcg_reg_free(s, reg); 1949 } 1950 } 1951 1952 /* store globals and free associated registers (we assume the call 1953 can modify any global. */ 1954 if (!(flags & TCG_CALL_CONST)) { 1955 save_globals(s, allocated_regs); 1956 } 1957 1958 tcg_out_op(s, opc, &func_arg, &const_func_arg); 1959 1960 if (allocate_args) { 1961 tcg_out_addi(s, TCG_REG_CALL_STACK, STACK_DIR(call_stack_size)); 1962 } 1963 1964 /* assign output registers and emit moves if needed */ 1965 for(i = 0; i < nb_oargs; i++) { 1966 arg = args[i]; 1967 ts = &s->temps[arg]; 1968 reg = tcg_target_call_oarg_regs[i]; 1969 assert(s->reg_to_temp[reg] == -1); 1970 if (ts->fixed_reg) { 1971 if (ts->reg != reg) { 1972 tcg_out_mov(s, ts->type, ts->reg, reg); 1973 } 1974 } else { 1975 if (ts->val_type == TEMP_VAL_REG) 1976 s->reg_to_temp[ts->reg] = -1; 1977 ts->val_type = TEMP_VAL_REG; 1978 ts->reg = reg; 1979 ts->mem_coherent = 0; 1980 s->reg_to_temp[reg] = arg; 1981 } 1982 } 1983 1984 return nb_iargs + nb_oargs + def->nb_cargs + 1; 1985 } 1986 1987 #ifdef CONFIG_PROFILER 1988 1989 static int64_t tcg_table_op_count[NB_OPS]; 1990 1991 static void dump_op_count(void) 1992 { 1993 int i; 1994 FILE *f; 1995 f = fopen("/tmp/op.log", "w"); 1996 for(i = INDEX_op_end; i < NB_OPS; i++) { 1997 fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, tcg_table_op_count[i]); 1998 } 1999 fclose(f); 2000 } 2001 #endif 2002 2003 2004 static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf, 2005 long search_pc) 2006 { 2007 TCGOpcode opc; 2008 int op_index; 2009 const TCGOpDef *def; 2010 unsigned int dead_iargs; 2011 const TCGArg *args; 2012 2013 #ifdef DEBUG_DISAS 2014 if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) { 2015 qemu_log("OP:\n"); 2016 tcg_dump_ops(s, logfile); 2017 qemu_log("\n"); 2018 } 2019 #endif 2020 2021 #ifdef CONFIG_PROFILER 2022 s->la_time -= profile_getclock(); 2023 #endif 2024 tcg_liveness_analysis(s); 2025 #ifdef CONFIG_PROFILER 2026 s->la_time += profile_getclock(); 2027 #endif 2028 2029 #ifdef DEBUG_DISAS 2030 if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT))) { 2031 qemu_log("OP after liveness analysis:\n"); 2032 tcg_dump_ops(s, logfile); 2033 qemu_log("\n"); 2034 } 2035 #endif 2036 2037 tcg_reg_alloc_start(s); 2038 2039 s->code_buf = gen_code_buf; 2040 s->code_ptr = gen_code_buf; 2041 2042 args = gen_opparam_buf; 2043 op_index = 0; 2044 2045 for(;;) { 2046 opc = gen_opc_buf[op_index]; 2047 #ifdef CONFIG_PROFILER 2048 tcg_table_op_count[opc]++; 2049 #endif 2050 def = &tcg_op_defs[opc]; 2051 #if 0 2052 printf("%s: %d %d %d\n", def->name, 2053 def->nb_oargs, def->nb_iargs, def->nb_cargs); 2054 // dump_regs(s); 2055 #endif 2056 switch(opc) { 2057 case INDEX_op_mov_i32: 2058 #if TCG_TARGET_REG_BITS == 64 2059 case INDEX_op_mov_i64: 2060 #endif 2061 dead_iargs = s->op_dead_iargs[op_index]; 2062 tcg_reg_alloc_mov(s, def, args, dead_iargs); 2063 break; 2064 case INDEX_op_movi_i32: 2065 #if TCG_TARGET_REG_BITS == 64 2066 case INDEX_op_movi_i64: 2067 #endif 2068 tcg_reg_alloc_movi(s, args); 2069 break; 2070 case INDEX_op_debug_insn_start: 2071 /* debug instruction */ 2072 break; 2073 case INDEX_op_nop: 2074 case INDEX_op_nop1: 2075 case INDEX_op_nop2: 2076 case INDEX_op_nop3: 2077 break; 2078 case INDEX_op_nopn: 2079 args += args[0]; 2080 goto next; 2081 case INDEX_op_discard: 2082 { 2083 TCGTemp *ts; 2084 ts = &s->temps[args[0]]; 2085 /* mark the temporary as dead */ 2086 if (!ts->fixed_reg) { 2087 if (ts->val_type == TEMP_VAL_REG) 2088 s->reg_to_temp[ts->reg] = -1; 2089 ts->val_type = TEMP_VAL_DEAD; 2090 } 2091 } 2092 break; 2093 case INDEX_op_set_label: 2094 tcg_reg_alloc_bb_end(s, s->reserved_regs); 2095 tcg_out_label(s, args[0], (long)s->code_ptr); 2096 break; 2097 case INDEX_op_call: 2098 dead_iargs = s->op_dead_iargs[op_index]; 2099 args += tcg_reg_alloc_call(s, def, opc, args, dead_iargs); 2100 goto next; 2101 case INDEX_op_end: 2102 goto the_end; 2103 default: 2104 /* Note: in order to speed up the code, it would be much 2105 faster to have specialized register allocator functions for 2106 some common argument patterns */ 2107 dead_iargs = s->op_dead_iargs[op_index]; 2108 tcg_reg_alloc_op(s, def, opc, args, dead_iargs); 2109 break; 2110 } 2111 args += def->nb_args; 2112 next: 2113 if (search_pc >= 0 && search_pc < s->code_ptr - gen_code_buf) { 2114 return op_index; 2115 } 2116 op_index++; 2117 #ifndef NDEBUG 2118 check_regs(s); 2119 #endif 2120 } 2121 the_end: 2122 return -1; 2123 } 2124 2125 int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf) 2126 { 2127 #ifdef CONFIG_PROFILER 2128 { 2129 int n; 2130 n = (gen_opc_ptr - gen_opc_buf); 2131 s->op_count += n; 2132 if (n > s->op_count_max) 2133 s->op_count_max = n; 2134 2135 s->temp_count += s->nb_temps; 2136 if (s->nb_temps > s->temp_count_max) 2137 s->temp_count_max = s->nb_temps; 2138 } 2139 #endif 2140 2141 tcg_gen_code_common(s, gen_code_buf, -1); 2142 2143 /* flush instruction cache */ 2144 flush_icache_range((unsigned long)gen_code_buf, 2145 (unsigned long)s->code_ptr); 2146 return s->code_ptr - gen_code_buf; 2147 } 2148 2149 /* Return the index of the micro operation such as the pc after is < 2150 offset bytes from the start of the TB. The contents of gen_code_buf must 2151 not be changed, though writing the same values is ok. 2152 Return -1 if not found. */ 2153 int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset) 2154 { 2155 return tcg_gen_code_common(s, gen_code_buf, offset); 2156 } 2157 2158 #ifdef CONFIG_PROFILER 2159 void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2160 { 2161 TCGContext *s = &tcg_ctx; 2162 int64_t tot; 2163 2164 tot = s->interm_time + s->code_time; 2165 cpu_fprintf(f, "JIT cycles %" PRId64 " (%0.3f s at 2.4 GHz)\n", 2166 tot, tot / 2.4e9); 2167 cpu_fprintf(f, "translated TBs %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n", 2168 s->tb_count, 2169 s->tb_count1 - s->tb_count, 2170 s->tb_count1 ? (double)(s->tb_count1 - s->tb_count) / s->tb_count1 * 100.0 : 0); 2171 cpu_fprintf(f, "avg ops/TB %0.1f max=%d\n", 2172 s->tb_count ? (double)s->op_count / s->tb_count : 0, s->op_count_max); 2173 cpu_fprintf(f, "deleted ops/TB %0.2f\n", 2174 s->tb_count ? 2175 (double)s->del_op_count / s->tb_count : 0); 2176 cpu_fprintf(f, "avg temps/TB %0.2f max=%d\n", 2177 s->tb_count ? 2178 (double)s->temp_count / s->tb_count : 0, 2179 s->temp_count_max); 2180 2181 cpu_fprintf(f, "cycles/op %0.1f\n", 2182 s->op_count ? (double)tot / s->op_count : 0); 2183 cpu_fprintf(f, "cycles/in byte %0.1f\n", 2184 s->code_in_len ? (double)tot / s->code_in_len : 0); 2185 cpu_fprintf(f, "cycles/out byte %0.1f\n", 2186 s->code_out_len ? (double)tot / s->code_out_len : 0); 2187 if (tot == 0) 2188 tot = 1; 2189 cpu_fprintf(f, " gen_interm time %0.1f%%\n", 2190 (double)s->interm_time / tot * 100.0); 2191 cpu_fprintf(f, " gen_code time %0.1f%%\n", 2192 (double)s->code_time / tot * 100.0); 2193 cpu_fprintf(f, "liveness/code time %0.1f%%\n", 2194 (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0); 2195 cpu_fprintf(f, "cpu_restore count %" PRId64 "\n", 2196 s->restore_count); 2197 cpu_fprintf(f, " avg cycles %0.1f\n", 2198 s->restore_count ? (double)s->restore_time / s->restore_count : 0); 2199 2200 dump_op_count(); 2201 } 2202 #else 2203 void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2204 { 2205 cpu_fprintf(f, "[TCG profiler not compiled]\n"); 2206 } 2207 #endif 2208