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_TCG_OPTIMIZATIONS 27 28 #include "qemu/osdep.h" 29 30 /* Define to jump the ELF file used to communicate with GDB. */ 31 #undef DEBUG_JIT 32 33 #include "qemu/error-report.h" 34 #include "qemu/cutils.h" 35 #include "qemu/host-utils.h" 36 #include "qemu/qemu-print.h" 37 #include "qemu/timer.h" 38 #include "qemu/cacheflush.h" 39 40 /* Note: the long term plan is to reduce the dependencies on the QEMU 41 CPU definitions. Currently they are used for qemu_ld/st 42 instructions */ 43 #define NO_CPU_IO_DEFS 44 45 #include "exec/exec-all.h" 46 #include "tcg/tcg-op.h" 47 48 #if UINTPTR_MAX == UINT32_MAX 49 # define ELF_CLASS ELFCLASS32 50 #else 51 # define ELF_CLASS ELFCLASS64 52 #endif 53 #ifdef HOST_WORDS_BIGENDIAN 54 # define ELF_DATA ELFDATA2MSB 55 #else 56 # define ELF_DATA ELFDATA2LSB 57 #endif 58 59 #include "elf.h" 60 #include "exec/log.h" 61 #include "tcg-internal.h" 62 63 #ifdef CONFIG_TCG_INTERPRETER 64 #include <ffi.h> 65 #endif 66 67 /* Forward declarations for functions declared in tcg-target.c.inc and 68 used here. */ 69 static void tcg_target_init(TCGContext *s); 70 static void tcg_target_qemu_prologue(TCGContext *s); 71 static bool patch_reloc(tcg_insn_unit *code_ptr, int type, 72 intptr_t value, intptr_t addend); 73 74 /* The CIE and FDE header definitions will be common to all hosts. */ 75 typedef struct { 76 uint32_t len __attribute__((aligned((sizeof(void *))))); 77 uint32_t id; 78 uint8_t version; 79 char augmentation[1]; 80 uint8_t code_align; 81 uint8_t data_align; 82 uint8_t return_column; 83 } DebugFrameCIE; 84 85 typedef struct QEMU_PACKED { 86 uint32_t len __attribute__((aligned((sizeof(void *))))); 87 uint32_t cie_offset; 88 uintptr_t func_start; 89 uintptr_t func_len; 90 } DebugFrameFDEHeader; 91 92 typedef struct QEMU_PACKED { 93 DebugFrameCIE cie; 94 DebugFrameFDEHeader fde; 95 } DebugFrameHeader; 96 97 static void tcg_register_jit_int(const void *buf, size_t size, 98 const void *debug_frame, 99 size_t debug_frame_size) 100 __attribute__((unused)); 101 102 /* Forward declarations for functions declared and used in tcg-target.c.inc. */ 103 static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1, 104 intptr_t arg2); 105 static bool tcg_out_mov(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg); 106 static void tcg_out_movi(TCGContext *s, TCGType type, 107 TCGReg ret, tcg_target_long arg); 108 static void tcg_out_op(TCGContext *s, TCGOpcode opc, 109 const TCGArg args[TCG_MAX_OP_ARGS], 110 const int const_args[TCG_MAX_OP_ARGS]); 111 #if TCG_TARGET_MAYBE_vec 112 static bool tcg_out_dup_vec(TCGContext *s, TCGType type, unsigned vece, 113 TCGReg dst, TCGReg src); 114 static bool tcg_out_dupm_vec(TCGContext *s, TCGType type, unsigned vece, 115 TCGReg dst, TCGReg base, intptr_t offset); 116 static void tcg_out_dupi_vec(TCGContext *s, TCGType type, unsigned vece, 117 TCGReg dst, int64_t arg); 118 static void tcg_out_vec_op(TCGContext *s, TCGOpcode opc, 119 unsigned vecl, unsigned vece, 120 const TCGArg args[TCG_MAX_OP_ARGS], 121 const int const_args[TCG_MAX_OP_ARGS]); 122 #else 123 static inline bool tcg_out_dup_vec(TCGContext *s, TCGType type, unsigned vece, 124 TCGReg dst, TCGReg src) 125 { 126 g_assert_not_reached(); 127 } 128 static inline bool tcg_out_dupm_vec(TCGContext *s, TCGType type, unsigned vece, 129 TCGReg dst, TCGReg base, intptr_t offset) 130 { 131 g_assert_not_reached(); 132 } 133 static inline void tcg_out_dupi_vec(TCGContext *s, TCGType type, unsigned vece, 134 TCGReg dst, int64_t arg) 135 { 136 g_assert_not_reached(); 137 } 138 static inline void tcg_out_vec_op(TCGContext *s, TCGOpcode opc, 139 unsigned vecl, unsigned vece, 140 const TCGArg args[TCG_MAX_OP_ARGS], 141 const int const_args[TCG_MAX_OP_ARGS]) 142 { 143 g_assert_not_reached(); 144 } 145 #endif 146 static void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1, 147 intptr_t arg2); 148 static bool tcg_out_sti(TCGContext *s, TCGType type, TCGArg val, 149 TCGReg base, intptr_t ofs); 150 #ifdef CONFIG_TCG_INTERPRETER 151 static void tcg_out_call(TCGContext *s, const tcg_insn_unit *target, 152 ffi_cif *cif); 153 #else 154 static void tcg_out_call(TCGContext *s, const tcg_insn_unit *target); 155 #endif 156 static bool tcg_target_const_match(int64_t val, TCGType type, int ct); 157 #ifdef TCG_TARGET_NEED_LDST_LABELS 158 static int tcg_out_ldst_finalize(TCGContext *s); 159 #endif 160 161 TCGContext tcg_init_ctx; 162 __thread TCGContext *tcg_ctx; 163 164 TCGContext **tcg_ctxs; 165 unsigned int tcg_cur_ctxs; 166 unsigned int tcg_max_ctxs; 167 TCGv_env cpu_env = 0; 168 const void *tcg_code_gen_epilogue; 169 uintptr_t tcg_splitwx_diff; 170 171 #ifndef CONFIG_TCG_INTERPRETER 172 tcg_prologue_fn *tcg_qemu_tb_exec; 173 #endif 174 175 static TCGRegSet tcg_target_available_regs[TCG_TYPE_COUNT]; 176 static TCGRegSet tcg_target_call_clobber_regs; 177 178 #if TCG_TARGET_INSN_UNIT_SIZE == 1 179 static __attribute__((unused)) inline void tcg_out8(TCGContext *s, uint8_t v) 180 { 181 *s->code_ptr++ = v; 182 } 183 184 static __attribute__((unused)) inline void tcg_patch8(tcg_insn_unit *p, 185 uint8_t v) 186 { 187 *p = v; 188 } 189 #endif 190 191 #if TCG_TARGET_INSN_UNIT_SIZE <= 2 192 static __attribute__((unused)) inline void tcg_out16(TCGContext *s, uint16_t v) 193 { 194 if (TCG_TARGET_INSN_UNIT_SIZE == 2) { 195 *s->code_ptr++ = v; 196 } else { 197 tcg_insn_unit *p = s->code_ptr; 198 memcpy(p, &v, sizeof(v)); 199 s->code_ptr = p + (2 / TCG_TARGET_INSN_UNIT_SIZE); 200 } 201 } 202 203 static __attribute__((unused)) inline void tcg_patch16(tcg_insn_unit *p, 204 uint16_t v) 205 { 206 if (TCG_TARGET_INSN_UNIT_SIZE == 2) { 207 *p = v; 208 } else { 209 memcpy(p, &v, sizeof(v)); 210 } 211 } 212 #endif 213 214 #if TCG_TARGET_INSN_UNIT_SIZE <= 4 215 static __attribute__((unused)) inline void tcg_out32(TCGContext *s, uint32_t v) 216 { 217 if (TCG_TARGET_INSN_UNIT_SIZE == 4) { 218 *s->code_ptr++ = v; 219 } else { 220 tcg_insn_unit *p = s->code_ptr; 221 memcpy(p, &v, sizeof(v)); 222 s->code_ptr = p + (4 / TCG_TARGET_INSN_UNIT_SIZE); 223 } 224 } 225 226 static __attribute__((unused)) inline void tcg_patch32(tcg_insn_unit *p, 227 uint32_t v) 228 { 229 if (TCG_TARGET_INSN_UNIT_SIZE == 4) { 230 *p = v; 231 } else { 232 memcpy(p, &v, sizeof(v)); 233 } 234 } 235 #endif 236 237 #if TCG_TARGET_INSN_UNIT_SIZE <= 8 238 static __attribute__((unused)) inline void tcg_out64(TCGContext *s, uint64_t v) 239 { 240 if (TCG_TARGET_INSN_UNIT_SIZE == 8) { 241 *s->code_ptr++ = v; 242 } else { 243 tcg_insn_unit *p = s->code_ptr; 244 memcpy(p, &v, sizeof(v)); 245 s->code_ptr = p + (8 / TCG_TARGET_INSN_UNIT_SIZE); 246 } 247 } 248 249 static __attribute__((unused)) inline void tcg_patch64(tcg_insn_unit *p, 250 uint64_t v) 251 { 252 if (TCG_TARGET_INSN_UNIT_SIZE == 8) { 253 *p = v; 254 } else { 255 memcpy(p, &v, sizeof(v)); 256 } 257 } 258 #endif 259 260 /* label relocation processing */ 261 262 static void tcg_out_reloc(TCGContext *s, tcg_insn_unit *code_ptr, int type, 263 TCGLabel *l, intptr_t addend) 264 { 265 TCGRelocation *r = tcg_malloc(sizeof(TCGRelocation)); 266 267 r->type = type; 268 r->ptr = code_ptr; 269 r->addend = addend; 270 QSIMPLEQ_INSERT_TAIL(&l->relocs, r, next); 271 } 272 273 static void tcg_out_label(TCGContext *s, TCGLabel *l) 274 { 275 tcg_debug_assert(!l->has_value); 276 l->has_value = 1; 277 l->u.value_ptr = tcg_splitwx_to_rx(s->code_ptr); 278 } 279 280 TCGLabel *gen_new_label(void) 281 { 282 TCGContext *s = tcg_ctx; 283 TCGLabel *l = tcg_malloc(sizeof(TCGLabel)); 284 285 memset(l, 0, sizeof(TCGLabel)); 286 l->id = s->nb_labels++; 287 QSIMPLEQ_INIT(&l->relocs); 288 289 QSIMPLEQ_INSERT_TAIL(&s->labels, l, next); 290 291 return l; 292 } 293 294 static bool tcg_resolve_relocs(TCGContext *s) 295 { 296 TCGLabel *l; 297 298 QSIMPLEQ_FOREACH(l, &s->labels, next) { 299 TCGRelocation *r; 300 uintptr_t value = l->u.value; 301 302 QSIMPLEQ_FOREACH(r, &l->relocs, next) { 303 if (!patch_reloc(r->ptr, r->type, value, r->addend)) { 304 return false; 305 } 306 } 307 } 308 return true; 309 } 310 311 static void set_jmp_reset_offset(TCGContext *s, int which) 312 { 313 /* 314 * We will check for overflow at the end of the opcode loop in 315 * tcg_gen_code, where we bound tcg_current_code_size to UINT16_MAX. 316 */ 317 s->tb_jmp_reset_offset[which] = tcg_current_code_size(s); 318 } 319 320 /* Signal overflow, starting over with fewer guest insns. */ 321 static void QEMU_NORETURN tcg_raise_tb_overflow(TCGContext *s) 322 { 323 siglongjmp(s->jmp_trans, -2); 324 } 325 326 #define C_PFX1(P, A) P##A 327 #define C_PFX2(P, A, B) P##A##_##B 328 #define C_PFX3(P, A, B, C) P##A##_##B##_##C 329 #define C_PFX4(P, A, B, C, D) P##A##_##B##_##C##_##D 330 #define C_PFX5(P, A, B, C, D, E) P##A##_##B##_##C##_##D##_##E 331 #define C_PFX6(P, A, B, C, D, E, F) P##A##_##B##_##C##_##D##_##E##_##F 332 333 /* Define an enumeration for the various combinations. */ 334 335 #define C_O0_I1(I1) C_PFX1(c_o0_i1_, I1), 336 #define C_O0_I2(I1, I2) C_PFX2(c_o0_i2_, I1, I2), 337 #define C_O0_I3(I1, I2, I3) C_PFX3(c_o0_i3_, I1, I2, I3), 338 #define C_O0_I4(I1, I2, I3, I4) C_PFX4(c_o0_i4_, I1, I2, I3, I4), 339 340 #define C_O1_I1(O1, I1) C_PFX2(c_o1_i1_, O1, I1), 341 #define C_O1_I2(O1, I1, I2) C_PFX3(c_o1_i2_, O1, I1, I2), 342 #define C_O1_I3(O1, I1, I2, I3) C_PFX4(c_o1_i3_, O1, I1, I2, I3), 343 #define C_O1_I4(O1, I1, I2, I3, I4) C_PFX5(c_o1_i4_, O1, I1, I2, I3, I4), 344 345 #define C_N1_I2(O1, I1, I2) C_PFX3(c_n1_i2_, O1, I1, I2), 346 347 #define C_O2_I1(O1, O2, I1) C_PFX3(c_o2_i1_, O1, O2, I1), 348 #define C_O2_I2(O1, O2, I1, I2) C_PFX4(c_o2_i2_, O1, O2, I1, I2), 349 #define C_O2_I3(O1, O2, I1, I2, I3) C_PFX5(c_o2_i3_, O1, O2, I1, I2, I3), 350 #define C_O2_I4(O1, O2, I1, I2, I3, I4) C_PFX6(c_o2_i4_, O1, O2, I1, I2, I3, I4), 351 352 typedef enum { 353 #include "tcg-target-con-set.h" 354 } TCGConstraintSetIndex; 355 356 static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode); 357 358 #undef C_O0_I1 359 #undef C_O0_I2 360 #undef C_O0_I3 361 #undef C_O0_I4 362 #undef C_O1_I1 363 #undef C_O1_I2 364 #undef C_O1_I3 365 #undef C_O1_I4 366 #undef C_N1_I2 367 #undef C_O2_I1 368 #undef C_O2_I2 369 #undef C_O2_I3 370 #undef C_O2_I4 371 372 /* Put all of the constraint sets into an array, indexed by the enum. */ 373 374 #define C_O0_I1(I1) { .args_ct_str = { #I1 } }, 375 #define C_O0_I2(I1, I2) { .args_ct_str = { #I1, #I2 } }, 376 #define C_O0_I3(I1, I2, I3) { .args_ct_str = { #I1, #I2, #I3 } }, 377 #define C_O0_I4(I1, I2, I3, I4) { .args_ct_str = { #I1, #I2, #I3, #I4 } }, 378 379 #define C_O1_I1(O1, I1) { .args_ct_str = { #O1, #I1 } }, 380 #define C_O1_I2(O1, I1, I2) { .args_ct_str = { #O1, #I1, #I2 } }, 381 #define C_O1_I3(O1, I1, I2, I3) { .args_ct_str = { #O1, #I1, #I2, #I3 } }, 382 #define C_O1_I4(O1, I1, I2, I3, I4) { .args_ct_str = { #O1, #I1, #I2, #I3, #I4 } }, 383 384 #define C_N1_I2(O1, I1, I2) { .args_ct_str = { "&" #O1, #I1, #I2 } }, 385 386 #define C_O2_I1(O1, O2, I1) { .args_ct_str = { #O1, #O2, #I1 } }, 387 #define C_O2_I2(O1, O2, I1, I2) { .args_ct_str = { #O1, #O2, #I1, #I2 } }, 388 #define C_O2_I3(O1, O2, I1, I2, I3) { .args_ct_str = { #O1, #O2, #I1, #I2, #I3 } }, 389 #define C_O2_I4(O1, O2, I1, I2, I3, I4) { .args_ct_str = { #O1, #O2, #I1, #I2, #I3, #I4 } }, 390 391 static const TCGTargetOpDef constraint_sets[] = { 392 #include "tcg-target-con-set.h" 393 }; 394 395 396 #undef C_O0_I1 397 #undef C_O0_I2 398 #undef C_O0_I3 399 #undef C_O0_I4 400 #undef C_O1_I1 401 #undef C_O1_I2 402 #undef C_O1_I3 403 #undef C_O1_I4 404 #undef C_N1_I2 405 #undef C_O2_I1 406 #undef C_O2_I2 407 #undef C_O2_I3 408 #undef C_O2_I4 409 410 /* Expand the enumerator to be returned from tcg_target_op_def(). */ 411 412 #define C_O0_I1(I1) C_PFX1(c_o0_i1_, I1) 413 #define C_O0_I2(I1, I2) C_PFX2(c_o0_i2_, I1, I2) 414 #define C_O0_I3(I1, I2, I3) C_PFX3(c_o0_i3_, I1, I2, I3) 415 #define C_O0_I4(I1, I2, I3, I4) C_PFX4(c_o0_i4_, I1, I2, I3, I4) 416 417 #define C_O1_I1(O1, I1) C_PFX2(c_o1_i1_, O1, I1) 418 #define C_O1_I2(O1, I1, I2) C_PFX3(c_o1_i2_, O1, I1, I2) 419 #define C_O1_I3(O1, I1, I2, I3) C_PFX4(c_o1_i3_, O1, I1, I2, I3) 420 #define C_O1_I4(O1, I1, I2, I3, I4) C_PFX5(c_o1_i4_, O1, I1, I2, I3, I4) 421 422 #define C_N1_I2(O1, I1, I2) C_PFX3(c_n1_i2_, O1, I1, I2) 423 424 #define C_O2_I1(O1, O2, I1) C_PFX3(c_o2_i1_, O1, O2, I1) 425 #define C_O2_I2(O1, O2, I1, I2) C_PFX4(c_o2_i2_, O1, O2, I1, I2) 426 #define C_O2_I3(O1, O2, I1, I2, I3) C_PFX5(c_o2_i3_, O1, O2, I1, I2, I3) 427 #define C_O2_I4(O1, O2, I1, I2, I3, I4) C_PFX6(c_o2_i4_, O1, O2, I1, I2, I3, I4) 428 429 #include "tcg-target.c.inc" 430 431 static void alloc_tcg_plugin_context(TCGContext *s) 432 { 433 #ifdef CONFIG_PLUGIN 434 s->plugin_tb = g_new0(struct qemu_plugin_tb, 1); 435 s->plugin_tb->insns = 436 g_ptr_array_new_with_free_func(qemu_plugin_insn_cleanup_fn); 437 #endif 438 } 439 440 /* 441 * All TCG threads except the parent (i.e. the one that called tcg_context_init 442 * and registered the target's TCG globals) must register with this function 443 * before initiating translation. 444 * 445 * In user-mode we just point tcg_ctx to tcg_init_ctx. See the documentation 446 * of tcg_region_init() for the reasoning behind this. 447 * 448 * In softmmu each caller registers its context in tcg_ctxs[]. Note that in 449 * softmmu tcg_ctxs[] does not track tcg_ctx_init, since the initial context 450 * is not used anymore for translation once this function is called. 451 * 452 * Not tracking tcg_init_ctx in tcg_ctxs[] in softmmu keeps code that iterates 453 * over the array (e.g. tcg_code_size() the same for both softmmu and user-mode. 454 */ 455 #ifdef CONFIG_USER_ONLY 456 void tcg_register_thread(void) 457 { 458 tcg_ctx = &tcg_init_ctx; 459 } 460 #else 461 void tcg_register_thread(void) 462 { 463 TCGContext *s = g_malloc(sizeof(*s)); 464 unsigned int i, n; 465 466 *s = tcg_init_ctx; 467 468 /* Relink mem_base. */ 469 for (i = 0, n = tcg_init_ctx.nb_globals; i < n; ++i) { 470 if (tcg_init_ctx.temps[i].mem_base) { 471 ptrdiff_t b = tcg_init_ctx.temps[i].mem_base - tcg_init_ctx.temps; 472 tcg_debug_assert(b >= 0 && b < n); 473 s->temps[i].mem_base = &s->temps[b]; 474 } 475 } 476 477 /* Claim an entry in tcg_ctxs */ 478 n = qatomic_fetch_inc(&tcg_cur_ctxs); 479 g_assert(n < tcg_max_ctxs); 480 qatomic_set(&tcg_ctxs[n], s); 481 482 if (n > 0) { 483 alloc_tcg_plugin_context(s); 484 tcg_region_initial_alloc(s); 485 } 486 487 tcg_ctx = s; 488 } 489 #endif /* !CONFIG_USER_ONLY */ 490 491 /* pool based memory allocation */ 492 void *tcg_malloc_internal(TCGContext *s, int size) 493 { 494 TCGPool *p; 495 int pool_size; 496 497 if (size > TCG_POOL_CHUNK_SIZE) { 498 /* big malloc: insert a new pool (XXX: could optimize) */ 499 p = g_malloc(sizeof(TCGPool) + size); 500 p->size = size; 501 p->next = s->pool_first_large; 502 s->pool_first_large = p; 503 return p->data; 504 } else { 505 p = s->pool_current; 506 if (!p) { 507 p = s->pool_first; 508 if (!p) 509 goto new_pool; 510 } else { 511 if (!p->next) { 512 new_pool: 513 pool_size = TCG_POOL_CHUNK_SIZE; 514 p = g_malloc(sizeof(TCGPool) + pool_size); 515 p->size = pool_size; 516 p->next = NULL; 517 if (s->pool_current) 518 s->pool_current->next = p; 519 else 520 s->pool_first = p; 521 } else { 522 p = p->next; 523 } 524 } 525 } 526 s->pool_current = p; 527 s->pool_cur = p->data + size; 528 s->pool_end = p->data + p->size; 529 return p->data; 530 } 531 532 void tcg_pool_reset(TCGContext *s) 533 { 534 TCGPool *p, *t; 535 for (p = s->pool_first_large; p; p = t) { 536 t = p->next; 537 g_free(p); 538 } 539 s->pool_first_large = NULL; 540 s->pool_cur = s->pool_end = NULL; 541 s->pool_current = NULL; 542 } 543 544 #include "exec/helper-proto.h" 545 546 static const TCGHelperInfo all_helpers[] = { 547 #include "exec/helper-tcg.h" 548 }; 549 static GHashTable *helper_table; 550 551 #ifdef CONFIG_TCG_INTERPRETER 552 static GHashTable *ffi_table; 553 554 static ffi_type * const typecode_to_ffi[8] = { 555 [dh_typecode_void] = &ffi_type_void, 556 [dh_typecode_i32] = &ffi_type_uint32, 557 [dh_typecode_s32] = &ffi_type_sint32, 558 [dh_typecode_i64] = &ffi_type_uint64, 559 [dh_typecode_s64] = &ffi_type_sint64, 560 [dh_typecode_ptr] = &ffi_type_pointer, 561 }; 562 #endif 563 564 static int indirect_reg_alloc_order[ARRAY_SIZE(tcg_target_reg_alloc_order)]; 565 static void process_op_defs(TCGContext *s); 566 static TCGTemp *tcg_global_reg_new_internal(TCGContext *s, TCGType type, 567 TCGReg reg, const char *name); 568 569 static void tcg_context_init(unsigned max_cpus) 570 { 571 TCGContext *s = &tcg_init_ctx; 572 int op, total_args, n, i; 573 TCGOpDef *def; 574 TCGArgConstraint *args_ct; 575 TCGTemp *ts; 576 577 memset(s, 0, sizeof(*s)); 578 s->nb_globals = 0; 579 580 /* Count total number of arguments and allocate the corresponding 581 space */ 582 total_args = 0; 583 for(op = 0; op < NB_OPS; op++) { 584 def = &tcg_op_defs[op]; 585 n = def->nb_iargs + def->nb_oargs; 586 total_args += n; 587 } 588 589 args_ct = g_new0(TCGArgConstraint, total_args); 590 591 for(op = 0; op < NB_OPS; op++) { 592 def = &tcg_op_defs[op]; 593 def->args_ct = args_ct; 594 n = def->nb_iargs + def->nb_oargs; 595 args_ct += n; 596 } 597 598 /* Register helpers. */ 599 /* Use g_direct_hash/equal for direct pointer comparisons on func. */ 600 helper_table = g_hash_table_new(NULL, NULL); 601 602 for (i = 0; i < ARRAY_SIZE(all_helpers); ++i) { 603 g_hash_table_insert(helper_table, (gpointer)all_helpers[i].func, 604 (gpointer)&all_helpers[i]); 605 } 606 607 #ifdef CONFIG_TCG_INTERPRETER 608 /* g_direct_hash/equal for direct comparisons on uint32_t. */ 609 ffi_table = g_hash_table_new(NULL, NULL); 610 for (i = 0; i < ARRAY_SIZE(all_helpers); ++i) { 611 struct { 612 ffi_cif cif; 613 ffi_type *args[]; 614 } *ca; 615 uint32_t typemask = all_helpers[i].typemask; 616 gpointer hash = (gpointer)(uintptr_t)typemask; 617 ffi_status status; 618 int nargs; 619 620 if (g_hash_table_lookup(ffi_table, hash)) { 621 continue; 622 } 623 624 /* Ignoring the return type, find the last non-zero field. */ 625 nargs = 32 - clz32(typemask >> 3); 626 nargs = DIV_ROUND_UP(nargs, 3); 627 628 ca = g_malloc0(sizeof(*ca) + nargs * sizeof(ffi_type *)); 629 ca->cif.rtype = typecode_to_ffi[typemask & 7]; 630 ca->cif.nargs = nargs; 631 632 if (nargs != 0) { 633 ca->cif.arg_types = ca->args; 634 for (i = 0; i < nargs; ++i) { 635 int typecode = extract32(typemask, (i + 1) * 3, 3); 636 ca->args[i] = typecode_to_ffi[typecode]; 637 } 638 } 639 640 status = ffi_prep_cif(&ca->cif, FFI_DEFAULT_ABI, nargs, 641 ca->cif.rtype, ca->cif.arg_types); 642 assert(status == FFI_OK); 643 644 g_hash_table_insert(ffi_table, hash, (gpointer)&ca->cif); 645 } 646 #endif 647 648 tcg_target_init(s); 649 process_op_defs(s); 650 651 /* Reverse the order of the saved registers, assuming they're all at 652 the start of tcg_target_reg_alloc_order. */ 653 for (n = 0; n < ARRAY_SIZE(tcg_target_reg_alloc_order); ++n) { 654 int r = tcg_target_reg_alloc_order[n]; 655 if (tcg_regset_test_reg(tcg_target_call_clobber_regs, r)) { 656 break; 657 } 658 } 659 for (i = 0; i < n; ++i) { 660 indirect_reg_alloc_order[i] = tcg_target_reg_alloc_order[n - 1 - i]; 661 } 662 for (; i < ARRAY_SIZE(tcg_target_reg_alloc_order); ++i) { 663 indirect_reg_alloc_order[i] = tcg_target_reg_alloc_order[i]; 664 } 665 666 alloc_tcg_plugin_context(s); 667 668 tcg_ctx = s; 669 /* 670 * In user-mode we simply share the init context among threads, since we 671 * use a single region. See the documentation tcg_region_init() for the 672 * reasoning behind this. 673 * In softmmu we will have at most max_cpus TCG threads. 674 */ 675 #ifdef CONFIG_USER_ONLY 676 tcg_ctxs = &tcg_ctx; 677 tcg_cur_ctxs = 1; 678 tcg_max_ctxs = 1; 679 #else 680 tcg_max_ctxs = max_cpus; 681 tcg_ctxs = g_new0(TCGContext *, max_cpus); 682 #endif 683 684 tcg_debug_assert(!tcg_regset_test_reg(s->reserved_regs, TCG_AREG0)); 685 ts = tcg_global_reg_new_internal(s, TCG_TYPE_PTR, TCG_AREG0, "env"); 686 cpu_env = temp_tcgv_ptr(ts); 687 } 688 689 void tcg_init(size_t tb_size, int splitwx, unsigned max_cpus) 690 { 691 tcg_context_init(max_cpus); 692 tcg_region_init(tb_size, splitwx, max_cpus); 693 } 694 695 /* 696 * Allocate TBs right before their corresponding translated code, making 697 * sure that TBs and code are on different cache lines. 698 */ 699 TranslationBlock *tcg_tb_alloc(TCGContext *s) 700 { 701 uintptr_t align = qemu_icache_linesize; 702 TranslationBlock *tb; 703 void *next; 704 705 retry: 706 tb = (void *)ROUND_UP((uintptr_t)s->code_gen_ptr, align); 707 next = (void *)ROUND_UP((uintptr_t)(tb + 1), align); 708 709 if (unlikely(next > s->code_gen_highwater)) { 710 if (tcg_region_alloc(s)) { 711 return NULL; 712 } 713 goto retry; 714 } 715 qatomic_set(&s->code_gen_ptr, next); 716 s->data_gen_ptr = NULL; 717 return tb; 718 } 719 720 void tcg_prologue_init(TCGContext *s) 721 { 722 size_t prologue_size; 723 724 s->code_ptr = s->code_gen_ptr; 725 s->code_buf = s->code_gen_ptr; 726 s->data_gen_ptr = NULL; 727 728 #ifndef CONFIG_TCG_INTERPRETER 729 tcg_qemu_tb_exec = (tcg_prologue_fn *)tcg_splitwx_to_rx(s->code_ptr); 730 #endif 731 732 #ifdef TCG_TARGET_NEED_POOL_LABELS 733 s->pool_labels = NULL; 734 #endif 735 736 qemu_thread_jit_write(); 737 /* Generate the prologue. */ 738 tcg_target_qemu_prologue(s); 739 740 #ifdef TCG_TARGET_NEED_POOL_LABELS 741 /* Allow the prologue to put e.g. guest_base into a pool entry. */ 742 { 743 int result = tcg_out_pool_finalize(s); 744 tcg_debug_assert(result == 0); 745 } 746 #endif 747 748 prologue_size = tcg_current_code_size(s); 749 750 #ifndef CONFIG_TCG_INTERPRETER 751 flush_idcache_range((uintptr_t)tcg_splitwx_to_rx(s->code_buf), 752 (uintptr_t)s->code_buf, prologue_size); 753 #endif 754 755 #ifdef DEBUG_DISAS 756 if (qemu_loglevel_mask(CPU_LOG_TB_OUT_ASM)) { 757 FILE *logfile = qemu_log_lock(); 758 qemu_log("PROLOGUE: [size=%zu]\n", prologue_size); 759 if (s->data_gen_ptr) { 760 size_t code_size = s->data_gen_ptr - s->code_gen_ptr; 761 size_t data_size = prologue_size - code_size; 762 size_t i; 763 764 log_disas(s->code_gen_ptr, code_size); 765 766 for (i = 0; i < data_size; i += sizeof(tcg_target_ulong)) { 767 if (sizeof(tcg_target_ulong) == 8) { 768 qemu_log("0x%08" PRIxPTR ": .quad 0x%016" PRIx64 "\n", 769 (uintptr_t)s->data_gen_ptr + i, 770 *(uint64_t *)(s->data_gen_ptr + i)); 771 } else { 772 qemu_log("0x%08" PRIxPTR ": .long 0x%08x\n", 773 (uintptr_t)s->data_gen_ptr + i, 774 *(uint32_t *)(s->data_gen_ptr + i)); 775 } 776 } 777 } else { 778 log_disas(s->code_gen_ptr, prologue_size); 779 } 780 qemu_log("\n"); 781 qemu_log_flush(); 782 qemu_log_unlock(logfile); 783 } 784 #endif 785 786 #ifndef CONFIG_TCG_INTERPRETER 787 /* 788 * Assert that goto_ptr is implemented completely, setting an epilogue. 789 * For tci, we use NULL as the signal to return from the interpreter, 790 * so skip this check. 791 */ 792 tcg_debug_assert(tcg_code_gen_epilogue != NULL); 793 #endif 794 795 tcg_region_prologue_set(s); 796 } 797 798 void tcg_func_start(TCGContext *s) 799 { 800 tcg_pool_reset(s); 801 s->nb_temps = s->nb_globals; 802 803 /* No temps have been previously allocated for size or locality. */ 804 memset(s->free_temps, 0, sizeof(s->free_temps)); 805 806 /* No constant temps have been previously allocated. */ 807 for (int i = 0; i < TCG_TYPE_COUNT; ++i) { 808 if (s->const_table[i]) { 809 g_hash_table_remove_all(s->const_table[i]); 810 } 811 } 812 813 s->nb_ops = 0; 814 s->nb_labels = 0; 815 s->current_frame_offset = s->frame_start; 816 817 #ifdef CONFIG_DEBUG_TCG 818 s->goto_tb_issue_mask = 0; 819 #endif 820 821 QTAILQ_INIT(&s->ops); 822 QTAILQ_INIT(&s->free_ops); 823 QSIMPLEQ_INIT(&s->labels); 824 } 825 826 static TCGTemp *tcg_temp_alloc(TCGContext *s) 827 { 828 int n = s->nb_temps++; 829 830 if (n >= TCG_MAX_TEMPS) { 831 tcg_raise_tb_overflow(s); 832 } 833 return memset(&s->temps[n], 0, sizeof(TCGTemp)); 834 } 835 836 static TCGTemp *tcg_global_alloc(TCGContext *s) 837 { 838 TCGTemp *ts; 839 840 tcg_debug_assert(s->nb_globals == s->nb_temps); 841 tcg_debug_assert(s->nb_globals < TCG_MAX_TEMPS); 842 s->nb_globals++; 843 ts = tcg_temp_alloc(s); 844 ts->kind = TEMP_GLOBAL; 845 846 return ts; 847 } 848 849 static TCGTemp *tcg_global_reg_new_internal(TCGContext *s, TCGType type, 850 TCGReg reg, const char *name) 851 { 852 TCGTemp *ts; 853 854 if (TCG_TARGET_REG_BITS == 32 && type != TCG_TYPE_I32) { 855 tcg_abort(); 856 } 857 858 ts = tcg_global_alloc(s); 859 ts->base_type = type; 860 ts->type = type; 861 ts->kind = TEMP_FIXED; 862 ts->reg = reg; 863 ts->name = name; 864 tcg_regset_set_reg(s->reserved_regs, reg); 865 866 return ts; 867 } 868 869 void tcg_set_frame(TCGContext *s, TCGReg reg, intptr_t start, intptr_t size) 870 { 871 s->frame_start = start; 872 s->frame_end = start + size; 873 s->frame_temp 874 = tcg_global_reg_new_internal(s, TCG_TYPE_PTR, reg, "_frame"); 875 } 876 877 TCGTemp *tcg_global_mem_new_internal(TCGType type, TCGv_ptr base, 878 intptr_t offset, const char *name) 879 { 880 TCGContext *s = tcg_ctx; 881 TCGTemp *base_ts = tcgv_ptr_temp(base); 882 TCGTemp *ts = tcg_global_alloc(s); 883 int indirect_reg = 0, bigendian = 0; 884 #ifdef HOST_WORDS_BIGENDIAN 885 bigendian = 1; 886 #endif 887 888 switch (base_ts->kind) { 889 case TEMP_FIXED: 890 break; 891 case TEMP_GLOBAL: 892 /* We do not support double-indirect registers. */ 893 tcg_debug_assert(!base_ts->indirect_reg); 894 base_ts->indirect_base = 1; 895 s->nb_indirects += (TCG_TARGET_REG_BITS == 32 && type == TCG_TYPE_I64 896 ? 2 : 1); 897 indirect_reg = 1; 898 break; 899 default: 900 g_assert_not_reached(); 901 } 902 903 if (TCG_TARGET_REG_BITS == 32 && type == TCG_TYPE_I64) { 904 TCGTemp *ts2 = tcg_global_alloc(s); 905 char buf[64]; 906 907 ts->base_type = TCG_TYPE_I64; 908 ts->type = TCG_TYPE_I32; 909 ts->indirect_reg = indirect_reg; 910 ts->mem_allocated = 1; 911 ts->mem_base = base_ts; 912 ts->mem_offset = offset + bigendian * 4; 913 pstrcpy(buf, sizeof(buf), name); 914 pstrcat(buf, sizeof(buf), "_0"); 915 ts->name = strdup(buf); 916 917 tcg_debug_assert(ts2 == ts + 1); 918 ts2->base_type = TCG_TYPE_I64; 919 ts2->type = TCG_TYPE_I32; 920 ts2->indirect_reg = indirect_reg; 921 ts2->mem_allocated = 1; 922 ts2->mem_base = base_ts; 923 ts2->mem_offset = offset + (1 - bigendian) * 4; 924 pstrcpy(buf, sizeof(buf), name); 925 pstrcat(buf, sizeof(buf), "_1"); 926 ts2->name = strdup(buf); 927 } else { 928 ts->base_type = type; 929 ts->type = type; 930 ts->indirect_reg = indirect_reg; 931 ts->mem_allocated = 1; 932 ts->mem_base = base_ts; 933 ts->mem_offset = offset; 934 ts->name = name; 935 } 936 return ts; 937 } 938 939 TCGTemp *tcg_temp_new_internal(TCGType type, bool temp_local) 940 { 941 TCGContext *s = tcg_ctx; 942 TCGTempKind kind = temp_local ? TEMP_LOCAL : TEMP_NORMAL; 943 TCGTemp *ts; 944 int idx, k; 945 946 k = type + (temp_local ? TCG_TYPE_COUNT : 0); 947 idx = find_first_bit(s->free_temps[k].l, TCG_MAX_TEMPS); 948 if (idx < TCG_MAX_TEMPS) { 949 /* There is already an available temp with the right type. */ 950 clear_bit(idx, s->free_temps[k].l); 951 952 ts = &s->temps[idx]; 953 ts->temp_allocated = 1; 954 tcg_debug_assert(ts->base_type == type); 955 tcg_debug_assert(ts->kind == kind); 956 } else { 957 ts = tcg_temp_alloc(s); 958 if (TCG_TARGET_REG_BITS == 32 && type == TCG_TYPE_I64) { 959 TCGTemp *ts2 = tcg_temp_alloc(s); 960 961 ts->base_type = type; 962 ts->type = TCG_TYPE_I32; 963 ts->temp_allocated = 1; 964 ts->kind = kind; 965 966 tcg_debug_assert(ts2 == ts + 1); 967 ts2->base_type = TCG_TYPE_I64; 968 ts2->type = TCG_TYPE_I32; 969 ts2->temp_allocated = 1; 970 ts2->kind = kind; 971 } else { 972 ts->base_type = type; 973 ts->type = type; 974 ts->temp_allocated = 1; 975 ts->kind = kind; 976 } 977 } 978 979 #if defined(CONFIG_DEBUG_TCG) 980 s->temps_in_use++; 981 #endif 982 return ts; 983 } 984 985 TCGv_vec tcg_temp_new_vec(TCGType type) 986 { 987 TCGTemp *t; 988 989 #ifdef CONFIG_DEBUG_TCG 990 switch (type) { 991 case TCG_TYPE_V64: 992 assert(TCG_TARGET_HAS_v64); 993 break; 994 case TCG_TYPE_V128: 995 assert(TCG_TARGET_HAS_v128); 996 break; 997 case TCG_TYPE_V256: 998 assert(TCG_TARGET_HAS_v256); 999 break; 1000 default: 1001 g_assert_not_reached(); 1002 } 1003 #endif 1004 1005 t = tcg_temp_new_internal(type, 0); 1006 return temp_tcgv_vec(t); 1007 } 1008 1009 /* Create a new temp of the same type as an existing temp. */ 1010 TCGv_vec tcg_temp_new_vec_matching(TCGv_vec match) 1011 { 1012 TCGTemp *t = tcgv_vec_temp(match); 1013 1014 tcg_debug_assert(t->temp_allocated != 0); 1015 1016 t = tcg_temp_new_internal(t->base_type, 0); 1017 return temp_tcgv_vec(t); 1018 } 1019 1020 void tcg_temp_free_internal(TCGTemp *ts) 1021 { 1022 TCGContext *s = tcg_ctx; 1023 int k, idx; 1024 1025 /* In order to simplify users of tcg_constant_*, silently ignore free. */ 1026 if (ts->kind == TEMP_CONST) { 1027 return; 1028 } 1029 1030 #if defined(CONFIG_DEBUG_TCG) 1031 s->temps_in_use--; 1032 if (s->temps_in_use < 0) { 1033 fprintf(stderr, "More temporaries freed than allocated!\n"); 1034 } 1035 #endif 1036 1037 tcg_debug_assert(ts->kind < TEMP_GLOBAL); 1038 tcg_debug_assert(ts->temp_allocated != 0); 1039 ts->temp_allocated = 0; 1040 1041 idx = temp_idx(ts); 1042 k = ts->base_type + (ts->kind == TEMP_NORMAL ? 0 : TCG_TYPE_COUNT); 1043 set_bit(idx, s->free_temps[k].l); 1044 } 1045 1046 TCGTemp *tcg_constant_internal(TCGType type, int64_t val) 1047 { 1048 TCGContext *s = tcg_ctx; 1049 GHashTable *h = s->const_table[type]; 1050 TCGTemp *ts; 1051 1052 if (h == NULL) { 1053 h = g_hash_table_new(g_int64_hash, g_int64_equal); 1054 s->const_table[type] = h; 1055 } 1056 1057 ts = g_hash_table_lookup(h, &val); 1058 if (ts == NULL) { 1059 ts = tcg_temp_alloc(s); 1060 1061 if (TCG_TARGET_REG_BITS == 32 && type == TCG_TYPE_I64) { 1062 TCGTemp *ts2 = tcg_temp_alloc(s); 1063 1064 ts->base_type = TCG_TYPE_I64; 1065 ts->type = TCG_TYPE_I32; 1066 ts->kind = TEMP_CONST; 1067 ts->temp_allocated = 1; 1068 /* 1069 * Retain the full value of the 64-bit constant in the low 1070 * part, so that the hash table works. Actual uses will 1071 * truncate the value to the low part. 1072 */ 1073 ts->val = val; 1074 1075 tcg_debug_assert(ts2 == ts + 1); 1076 ts2->base_type = TCG_TYPE_I64; 1077 ts2->type = TCG_TYPE_I32; 1078 ts2->kind = TEMP_CONST; 1079 ts2->temp_allocated = 1; 1080 ts2->val = val >> 32; 1081 } else { 1082 ts->base_type = type; 1083 ts->type = type; 1084 ts->kind = TEMP_CONST; 1085 ts->temp_allocated = 1; 1086 ts->val = val; 1087 } 1088 g_hash_table_insert(h, &ts->val, ts); 1089 } 1090 1091 return ts; 1092 } 1093 1094 TCGv_vec tcg_constant_vec(TCGType type, unsigned vece, int64_t val) 1095 { 1096 val = dup_const(vece, val); 1097 return temp_tcgv_vec(tcg_constant_internal(type, val)); 1098 } 1099 1100 TCGv_vec tcg_constant_vec_matching(TCGv_vec match, unsigned vece, int64_t val) 1101 { 1102 TCGTemp *t = tcgv_vec_temp(match); 1103 1104 tcg_debug_assert(t->temp_allocated != 0); 1105 return tcg_constant_vec(t->base_type, vece, val); 1106 } 1107 1108 TCGv_i32 tcg_const_i32(int32_t val) 1109 { 1110 TCGv_i32 t0; 1111 t0 = tcg_temp_new_i32(); 1112 tcg_gen_movi_i32(t0, val); 1113 return t0; 1114 } 1115 1116 TCGv_i64 tcg_const_i64(int64_t val) 1117 { 1118 TCGv_i64 t0; 1119 t0 = tcg_temp_new_i64(); 1120 tcg_gen_movi_i64(t0, val); 1121 return t0; 1122 } 1123 1124 TCGv_i32 tcg_const_local_i32(int32_t val) 1125 { 1126 TCGv_i32 t0; 1127 t0 = tcg_temp_local_new_i32(); 1128 tcg_gen_movi_i32(t0, val); 1129 return t0; 1130 } 1131 1132 TCGv_i64 tcg_const_local_i64(int64_t val) 1133 { 1134 TCGv_i64 t0; 1135 t0 = tcg_temp_local_new_i64(); 1136 tcg_gen_movi_i64(t0, val); 1137 return t0; 1138 } 1139 1140 #if defined(CONFIG_DEBUG_TCG) 1141 void tcg_clear_temp_count(void) 1142 { 1143 TCGContext *s = tcg_ctx; 1144 s->temps_in_use = 0; 1145 } 1146 1147 int tcg_check_temp_count(void) 1148 { 1149 TCGContext *s = tcg_ctx; 1150 if (s->temps_in_use) { 1151 /* Clear the count so that we don't give another 1152 * warning immediately next time around. 1153 */ 1154 s->temps_in_use = 0; 1155 return 1; 1156 } 1157 return 0; 1158 } 1159 #endif 1160 1161 /* Return true if OP may appear in the opcode stream. 1162 Test the runtime variable that controls each opcode. */ 1163 bool tcg_op_supported(TCGOpcode op) 1164 { 1165 const bool have_vec 1166 = TCG_TARGET_HAS_v64 | TCG_TARGET_HAS_v128 | TCG_TARGET_HAS_v256; 1167 1168 switch (op) { 1169 case INDEX_op_discard: 1170 case INDEX_op_set_label: 1171 case INDEX_op_call: 1172 case INDEX_op_br: 1173 case INDEX_op_mb: 1174 case INDEX_op_insn_start: 1175 case INDEX_op_exit_tb: 1176 case INDEX_op_goto_tb: 1177 case INDEX_op_goto_ptr: 1178 case INDEX_op_qemu_ld_i32: 1179 case INDEX_op_qemu_st_i32: 1180 case INDEX_op_qemu_ld_i64: 1181 case INDEX_op_qemu_st_i64: 1182 return true; 1183 1184 case INDEX_op_qemu_st8_i32: 1185 return TCG_TARGET_HAS_qemu_st8_i32; 1186 1187 case INDEX_op_mov_i32: 1188 case INDEX_op_setcond_i32: 1189 case INDEX_op_brcond_i32: 1190 case INDEX_op_ld8u_i32: 1191 case INDEX_op_ld8s_i32: 1192 case INDEX_op_ld16u_i32: 1193 case INDEX_op_ld16s_i32: 1194 case INDEX_op_ld_i32: 1195 case INDEX_op_st8_i32: 1196 case INDEX_op_st16_i32: 1197 case INDEX_op_st_i32: 1198 case INDEX_op_add_i32: 1199 case INDEX_op_sub_i32: 1200 case INDEX_op_mul_i32: 1201 case INDEX_op_and_i32: 1202 case INDEX_op_or_i32: 1203 case INDEX_op_xor_i32: 1204 case INDEX_op_shl_i32: 1205 case INDEX_op_shr_i32: 1206 case INDEX_op_sar_i32: 1207 return true; 1208 1209 case INDEX_op_movcond_i32: 1210 return TCG_TARGET_HAS_movcond_i32; 1211 case INDEX_op_div_i32: 1212 case INDEX_op_divu_i32: 1213 return TCG_TARGET_HAS_div_i32; 1214 case INDEX_op_rem_i32: 1215 case INDEX_op_remu_i32: 1216 return TCG_TARGET_HAS_rem_i32; 1217 case INDEX_op_div2_i32: 1218 case INDEX_op_divu2_i32: 1219 return TCG_TARGET_HAS_div2_i32; 1220 case INDEX_op_rotl_i32: 1221 case INDEX_op_rotr_i32: 1222 return TCG_TARGET_HAS_rot_i32; 1223 case INDEX_op_deposit_i32: 1224 return TCG_TARGET_HAS_deposit_i32; 1225 case INDEX_op_extract_i32: 1226 return TCG_TARGET_HAS_extract_i32; 1227 case INDEX_op_sextract_i32: 1228 return TCG_TARGET_HAS_sextract_i32; 1229 case INDEX_op_extract2_i32: 1230 return TCG_TARGET_HAS_extract2_i32; 1231 case INDEX_op_add2_i32: 1232 return TCG_TARGET_HAS_add2_i32; 1233 case INDEX_op_sub2_i32: 1234 return TCG_TARGET_HAS_sub2_i32; 1235 case INDEX_op_mulu2_i32: 1236 return TCG_TARGET_HAS_mulu2_i32; 1237 case INDEX_op_muls2_i32: 1238 return TCG_TARGET_HAS_muls2_i32; 1239 case INDEX_op_muluh_i32: 1240 return TCG_TARGET_HAS_muluh_i32; 1241 case INDEX_op_mulsh_i32: 1242 return TCG_TARGET_HAS_mulsh_i32; 1243 case INDEX_op_ext8s_i32: 1244 return TCG_TARGET_HAS_ext8s_i32; 1245 case INDEX_op_ext16s_i32: 1246 return TCG_TARGET_HAS_ext16s_i32; 1247 case INDEX_op_ext8u_i32: 1248 return TCG_TARGET_HAS_ext8u_i32; 1249 case INDEX_op_ext16u_i32: 1250 return TCG_TARGET_HAS_ext16u_i32; 1251 case INDEX_op_bswap16_i32: 1252 return TCG_TARGET_HAS_bswap16_i32; 1253 case INDEX_op_bswap32_i32: 1254 return TCG_TARGET_HAS_bswap32_i32; 1255 case INDEX_op_not_i32: 1256 return TCG_TARGET_HAS_not_i32; 1257 case INDEX_op_neg_i32: 1258 return TCG_TARGET_HAS_neg_i32; 1259 case INDEX_op_andc_i32: 1260 return TCG_TARGET_HAS_andc_i32; 1261 case INDEX_op_orc_i32: 1262 return TCG_TARGET_HAS_orc_i32; 1263 case INDEX_op_eqv_i32: 1264 return TCG_TARGET_HAS_eqv_i32; 1265 case INDEX_op_nand_i32: 1266 return TCG_TARGET_HAS_nand_i32; 1267 case INDEX_op_nor_i32: 1268 return TCG_TARGET_HAS_nor_i32; 1269 case INDEX_op_clz_i32: 1270 return TCG_TARGET_HAS_clz_i32; 1271 case INDEX_op_ctz_i32: 1272 return TCG_TARGET_HAS_ctz_i32; 1273 case INDEX_op_ctpop_i32: 1274 return TCG_TARGET_HAS_ctpop_i32; 1275 1276 case INDEX_op_brcond2_i32: 1277 case INDEX_op_setcond2_i32: 1278 return TCG_TARGET_REG_BITS == 32; 1279 1280 case INDEX_op_mov_i64: 1281 case INDEX_op_setcond_i64: 1282 case INDEX_op_brcond_i64: 1283 case INDEX_op_ld8u_i64: 1284 case INDEX_op_ld8s_i64: 1285 case INDEX_op_ld16u_i64: 1286 case INDEX_op_ld16s_i64: 1287 case INDEX_op_ld32u_i64: 1288 case INDEX_op_ld32s_i64: 1289 case INDEX_op_ld_i64: 1290 case INDEX_op_st8_i64: 1291 case INDEX_op_st16_i64: 1292 case INDEX_op_st32_i64: 1293 case INDEX_op_st_i64: 1294 case INDEX_op_add_i64: 1295 case INDEX_op_sub_i64: 1296 case INDEX_op_mul_i64: 1297 case INDEX_op_and_i64: 1298 case INDEX_op_or_i64: 1299 case INDEX_op_xor_i64: 1300 case INDEX_op_shl_i64: 1301 case INDEX_op_shr_i64: 1302 case INDEX_op_sar_i64: 1303 case INDEX_op_ext_i32_i64: 1304 case INDEX_op_extu_i32_i64: 1305 return TCG_TARGET_REG_BITS == 64; 1306 1307 case INDEX_op_movcond_i64: 1308 return TCG_TARGET_HAS_movcond_i64; 1309 case INDEX_op_div_i64: 1310 case INDEX_op_divu_i64: 1311 return TCG_TARGET_HAS_div_i64; 1312 case INDEX_op_rem_i64: 1313 case INDEX_op_remu_i64: 1314 return TCG_TARGET_HAS_rem_i64; 1315 case INDEX_op_div2_i64: 1316 case INDEX_op_divu2_i64: 1317 return TCG_TARGET_HAS_div2_i64; 1318 case INDEX_op_rotl_i64: 1319 case INDEX_op_rotr_i64: 1320 return TCG_TARGET_HAS_rot_i64; 1321 case INDEX_op_deposit_i64: 1322 return TCG_TARGET_HAS_deposit_i64; 1323 case INDEX_op_extract_i64: 1324 return TCG_TARGET_HAS_extract_i64; 1325 case INDEX_op_sextract_i64: 1326 return TCG_TARGET_HAS_sextract_i64; 1327 case INDEX_op_extract2_i64: 1328 return TCG_TARGET_HAS_extract2_i64; 1329 case INDEX_op_extrl_i64_i32: 1330 return TCG_TARGET_HAS_extrl_i64_i32; 1331 case INDEX_op_extrh_i64_i32: 1332 return TCG_TARGET_HAS_extrh_i64_i32; 1333 case INDEX_op_ext8s_i64: 1334 return TCG_TARGET_HAS_ext8s_i64; 1335 case INDEX_op_ext16s_i64: 1336 return TCG_TARGET_HAS_ext16s_i64; 1337 case INDEX_op_ext32s_i64: 1338 return TCG_TARGET_HAS_ext32s_i64; 1339 case INDEX_op_ext8u_i64: 1340 return TCG_TARGET_HAS_ext8u_i64; 1341 case INDEX_op_ext16u_i64: 1342 return TCG_TARGET_HAS_ext16u_i64; 1343 case INDEX_op_ext32u_i64: 1344 return TCG_TARGET_HAS_ext32u_i64; 1345 case INDEX_op_bswap16_i64: 1346 return TCG_TARGET_HAS_bswap16_i64; 1347 case INDEX_op_bswap32_i64: 1348 return TCG_TARGET_HAS_bswap32_i64; 1349 case INDEX_op_bswap64_i64: 1350 return TCG_TARGET_HAS_bswap64_i64; 1351 case INDEX_op_not_i64: 1352 return TCG_TARGET_HAS_not_i64; 1353 case INDEX_op_neg_i64: 1354 return TCG_TARGET_HAS_neg_i64; 1355 case INDEX_op_andc_i64: 1356 return TCG_TARGET_HAS_andc_i64; 1357 case INDEX_op_orc_i64: 1358 return TCG_TARGET_HAS_orc_i64; 1359 case INDEX_op_eqv_i64: 1360 return TCG_TARGET_HAS_eqv_i64; 1361 case INDEX_op_nand_i64: 1362 return TCG_TARGET_HAS_nand_i64; 1363 case INDEX_op_nor_i64: 1364 return TCG_TARGET_HAS_nor_i64; 1365 case INDEX_op_clz_i64: 1366 return TCG_TARGET_HAS_clz_i64; 1367 case INDEX_op_ctz_i64: 1368 return TCG_TARGET_HAS_ctz_i64; 1369 case INDEX_op_ctpop_i64: 1370 return TCG_TARGET_HAS_ctpop_i64; 1371 case INDEX_op_add2_i64: 1372 return TCG_TARGET_HAS_add2_i64; 1373 case INDEX_op_sub2_i64: 1374 return TCG_TARGET_HAS_sub2_i64; 1375 case INDEX_op_mulu2_i64: 1376 return TCG_TARGET_HAS_mulu2_i64; 1377 case INDEX_op_muls2_i64: 1378 return TCG_TARGET_HAS_muls2_i64; 1379 case INDEX_op_muluh_i64: 1380 return TCG_TARGET_HAS_muluh_i64; 1381 case INDEX_op_mulsh_i64: 1382 return TCG_TARGET_HAS_mulsh_i64; 1383 1384 case INDEX_op_mov_vec: 1385 case INDEX_op_dup_vec: 1386 case INDEX_op_dupm_vec: 1387 case INDEX_op_ld_vec: 1388 case INDEX_op_st_vec: 1389 case INDEX_op_add_vec: 1390 case INDEX_op_sub_vec: 1391 case INDEX_op_and_vec: 1392 case INDEX_op_or_vec: 1393 case INDEX_op_xor_vec: 1394 case INDEX_op_cmp_vec: 1395 return have_vec; 1396 case INDEX_op_dup2_vec: 1397 return have_vec && TCG_TARGET_REG_BITS == 32; 1398 case INDEX_op_not_vec: 1399 return have_vec && TCG_TARGET_HAS_not_vec; 1400 case INDEX_op_neg_vec: 1401 return have_vec && TCG_TARGET_HAS_neg_vec; 1402 case INDEX_op_abs_vec: 1403 return have_vec && TCG_TARGET_HAS_abs_vec; 1404 case INDEX_op_andc_vec: 1405 return have_vec && TCG_TARGET_HAS_andc_vec; 1406 case INDEX_op_orc_vec: 1407 return have_vec && TCG_TARGET_HAS_orc_vec; 1408 case INDEX_op_mul_vec: 1409 return have_vec && TCG_TARGET_HAS_mul_vec; 1410 case INDEX_op_shli_vec: 1411 case INDEX_op_shri_vec: 1412 case INDEX_op_sari_vec: 1413 return have_vec && TCG_TARGET_HAS_shi_vec; 1414 case INDEX_op_shls_vec: 1415 case INDEX_op_shrs_vec: 1416 case INDEX_op_sars_vec: 1417 return have_vec && TCG_TARGET_HAS_shs_vec; 1418 case INDEX_op_shlv_vec: 1419 case INDEX_op_shrv_vec: 1420 case INDEX_op_sarv_vec: 1421 return have_vec && TCG_TARGET_HAS_shv_vec; 1422 case INDEX_op_rotli_vec: 1423 return have_vec && TCG_TARGET_HAS_roti_vec; 1424 case INDEX_op_rotls_vec: 1425 return have_vec && TCG_TARGET_HAS_rots_vec; 1426 case INDEX_op_rotlv_vec: 1427 case INDEX_op_rotrv_vec: 1428 return have_vec && TCG_TARGET_HAS_rotv_vec; 1429 case INDEX_op_ssadd_vec: 1430 case INDEX_op_usadd_vec: 1431 case INDEX_op_sssub_vec: 1432 case INDEX_op_ussub_vec: 1433 return have_vec && TCG_TARGET_HAS_sat_vec; 1434 case INDEX_op_smin_vec: 1435 case INDEX_op_umin_vec: 1436 case INDEX_op_smax_vec: 1437 case INDEX_op_umax_vec: 1438 return have_vec && TCG_TARGET_HAS_minmax_vec; 1439 case INDEX_op_bitsel_vec: 1440 return have_vec && TCG_TARGET_HAS_bitsel_vec; 1441 case INDEX_op_cmpsel_vec: 1442 return have_vec && TCG_TARGET_HAS_cmpsel_vec; 1443 1444 default: 1445 tcg_debug_assert(op > INDEX_op_last_generic && op < NB_OPS); 1446 return true; 1447 } 1448 } 1449 1450 /* Note: we convert the 64 bit args to 32 bit and do some alignment 1451 and endian swap. Maybe it would be better to do the alignment 1452 and endian swap in tcg_reg_alloc_call(). */ 1453 void tcg_gen_callN(void *func, TCGTemp *ret, int nargs, TCGTemp **args) 1454 { 1455 int i, real_args, nb_rets, pi; 1456 unsigned typemask; 1457 const TCGHelperInfo *info; 1458 TCGOp *op; 1459 1460 info = g_hash_table_lookup(helper_table, (gpointer)func); 1461 typemask = info->typemask; 1462 1463 #ifdef CONFIG_PLUGIN 1464 /* detect non-plugin helpers */ 1465 if (tcg_ctx->plugin_insn && unlikely(strncmp(info->name, "plugin_", 7))) { 1466 tcg_ctx->plugin_insn->calls_helpers = true; 1467 } 1468 #endif 1469 1470 #if defined(__sparc__) && !defined(__arch64__) \ 1471 && !defined(CONFIG_TCG_INTERPRETER) 1472 /* We have 64-bit values in one register, but need to pass as two 1473 separate parameters. Split them. */ 1474 int orig_typemask = typemask; 1475 int orig_nargs = nargs; 1476 TCGv_i64 retl, reth; 1477 TCGTemp *split_args[MAX_OPC_PARAM]; 1478 1479 retl = NULL; 1480 reth = NULL; 1481 typemask = 0; 1482 for (i = real_args = 0; i < nargs; ++i) { 1483 int argtype = extract32(orig_typemask, (i + 1) * 3, 3); 1484 bool is_64bit = (argtype & ~1) == dh_typecode_i64; 1485 1486 if (is_64bit) { 1487 TCGv_i64 orig = temp_tcgv_i64(args[i]); 1488 TCGv_i32 h = tcg_temp_new_i32(); 1489 TCGv_i32 l = tcg_temp_new_i32(); 1490 tcg_gen_extr_i64_i32(l, h, orig); 1491 split_args[real_args++] = tcgv_i32_temp(h); 1492 typemask |= dh_typecode_i32 << (real_args * 3); 1493 split_args[real_args++] = tcgv_i32_temp(l); 1494 typemask |= dh_typecode_i32 << (real_args * 3); 1495 } else { 1496 split_args[real_args++] = args[i]; 1497 typemask |= argtype << (real_args * 3); 1498 } 1499 } 1500 nargs = real_args; 1501 args = split_args; 1502 #elif defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 1503 for (i = 0; i < nargs; ++i) { 1504 int argtype = extract32(typemask, (i + 1) * 3, 3); 1505 bool is_32bit = (argtype & ~1) == dh_typecode_i32; 1506 bool is_signed = argtype & 1; 1507 1508 if (is_32bit) { 1509 TCGv_i64 temp = tcg_temp_new_i64(); 1510 TCGv_i64 orig = temp_tcgv_i64(args[i]); 1511 if (is_signed) { 1512 tcg_gen_ext32s_i64(temp, orig); 1513 } else { 1514 tcg_gen_ext32u_i64(temp, orig); 1515 } 1516 args[i] = tcgv_i64_temp(temp); 1517 } 1518 } 1519 #endif /* TCG_TARGET_EXTEND_ARGS */ 1520 1521 op = tcg_emit_op(INDEX_op_call); 1522 1523 pi = 0; 1524 if (ret != NULL) { 1525 #if defined(__sparc__) && !defined(__arch64__) \ 1526 && !defined(CONFIG_TCG_INTERPRETER) 1527 if ((typemask & 6) == dh_typecode_i64) { 1528 /* The 32-bit ABI is going to return the 64-bit value in 1529 the %o0/%o1 register pair. Prepare for this by using 1530 two return temporaries, and reassemble below. */ 1531 retl = tcg_temp_new_i64(); 1532 reth = tcg_temp_new_i64(); 1533 op->args[pi++] = tcgv_i64_arg(reth); 1534 op->args[pi++] = tcgv_i64_arg(retl); 1535 nb_rets = 2; 1536 } else { 1537 op->args[pi++] = temp_arg(ret); 1538 nb_rets = 1; 1539 } 1540 #else 1541 if (TCG_TARGET_REG_BITS < 64 && (typemask & 6) == dh_typecode_i64) { 1542 #ifdef HOST_WORDS_BIGENDIAN 1543 op->args[pi++] = temp_arg(ret + 1); 1544 op->args[pi++] = temp_arg(ret); 1545 #else 1546 op->args[pi++] = temp_arg(ret); 1547 op->args[pi++] = temp_arg(ret + 1); 1548 #endif 1549 nb_rets = 2; 1550 } else { 1551 op->args[pi++] = temp_arg(ret); 1552 nb_rets = 1; 1553 } 1554 #endif 1555 } else { 1556 nb_rets = 0; 1557 } 1558 TCGOP_CALLO(op) = nb_rets; 1559 1560 real_args = 0; 1561 for (i = 0; i < nargs; i++) { 1562 int argtype = extract32(typemask, (i + 1) * 3, 3); 1563 bool is_64bit = (argtype & ~1) == dh_typecode_i64; 1564 bool want_align = false; 1565 1566 #if defined(CONFIG_TCG_INTERPRETER) 1567 /* 1568 * Align all arguments, so that they land in predictable places 1569 * for passing off to ffi_call. 1570 */ 1571 want_align = true; 1572 #elif defined(TCG_TARGET_CALL_ALIGN_ARGS) 1573 /* Some targets want aligned 64 bit args */ 1574 want_align = is_64bit; 1575 #endif 1576 1577 if (TCG_TARGET_REG_BITS < 64 && want_align && (real_args & 1)) { 1578 op->args[pi++] = TCG_CALL_DUMMY_ARG; 1579 real_args++; 1580 } 1581 1582 if (TCG_TARGET_REG_BITS < 64 && is_64bit) { 1583 /* 1584 * If stack grows up, then we will be placing successive 1585 * arguments at lower addresses, which means we need to 1586 * reverse the order compared to how we would normally 1587 * treat either big or little-endian. For those arguments 1588 * that will wind up in registers, this still works for 1589 * HPPA (the only current STACK_GROWSUP target) since the 1590 * argument registers are *also* allocated in decreasing 1591 * order. If another such target is added, this logic may 1592 * have to get more complicated to differentiate between 1593 * stack arguments and register arguments. 1594 */ 1595 #if defined(HOST_WORDS_BIGENDIAN) != defined(TCG_TARGET_STACK_GROWSUP) 1596 op->args[pi++] = temp_arg(args[i] + 1); 1597 op->args[pi++] = temp_arg(args[i]); 1598 #else 1599 op->args[pi++] = temp_arg(args[i]); 1600 op->args[pi++] = temp_arg(args[i] + 1); 1601 #endif 1602 real_args += 2; 1603 continue; 1604 } 1605 1606 op->args[pi++] = temp_arg(args[i]); 1607 real_args++; 1608 } 1609 op->args[pi++] = (uintptr_t)func; 1610 op->args[pi++] = (uintptr_t)info; 1611 TCGOP_CALLI(op) = real_args; 1612 1613 /* Make sure the fields didn't overflow. */ 1614 tcg_debug_assert(TCGOP_CALLI(op) == real_args); 1615 tcg_debug_assert(pi <= ARRAY_SIZE(op->args)); 1616 1617 #if defined(__sparc__) && !defined(__arch64__) \ 1618 && !defined(CONFIG_TCG_INTERPRETER) 1619 /* Free all of the parts we allocated above. */ 1620 for (i = real_args = 0; i < orig_nargs; ++i) { 1621 int argtype = extract32(orig_typemask, (i + 1) * 3, 3); 1622 bool is_64bit = (argtype & ~1) == dh_typecode_i64; 1623 1624 if (is_64bit) { 1625 tcg_temp_free_internal(args[real_args++]); 1626 tcg_temp_free_internal(args[real_args++]); 1627 } else { 1628 real_args++; 1629 } 1630 } 1631 if ((orig_typemask & 6) == dh_typecode_i64) { 1632 /* The 32-bit ABI returned two 32-bit pieces. Re-assemble them. 1633 Note that describing these as TCGv_i64 eliminates an unnecessary 1634 zero-extension that tcg_gen_concat_i32_i64 would create. */ 1635 tcg_gen_concat32_i64(temp_tcgv_i64(ret), retl, reth); 1636 tcg_temp_free_i64(retl); 1637 tcg_temp_free_i64(reth); 1638 } 1639 #elif defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 1640 for (i = 0; i < nargs; ++i) { 1641 int argtype = extract32(typemask, (i + 1) * 3, 3); 1642 bool is_32bit = (argtype & ~1) == dh_typecode_i32; 1643 1644 if (is_32bit) { 1645 tcg_temp_free_internal(args[i]); 1646 } 1647 } 1648 #endif /* TCG_TARGET_EXTEND_ARGS */ 1649 } 1650 1651 static void tcg_reg_alloc_start(TCGContext *s) 1652 { 1653 int i, n; 1654 1655 for (i = 0, n = s->nb_temps; i < n; i++) { 1656 TCGTemp *ts = &s->temps[i]; 1657 TCGTempVal val = TEMP_VAL_MEM; 1658 1659 switch (ts->kind) { 1660 case TEMP_CONST: 1661 val = TEMP_VAL_CONST; 1662 break; 1663 case TEMP_FIXED: 1664 val = TEMP_VAL_REG; 1665 break; 1666 case TEMP_GLOBAL: 1667 break; 1668 case TEMP_NORMAL: 1669 val = TEMP_VAL_DEAD; 1670 /* fall through */ 1671 case TEMP_LOCAL: 1672 ts->mem_allocated = 0; 1673 break; 1674 default: 1675 g_assert_not_reached(); 1676 } 1677 ts->val_type = val; 1678 } 1679 1680 memset(s->reg_to_temp, 0, sizeof(s->reg_to_temp)); 1681 } 1682 1683 static char *tcg_get_arg_str_ptr(TCGContext *s, char *buf, int buf_size, 1684 TCGTemp *ts) 1685 { 1686 int idx = temp_idx(ts); 1687 1688 switch (ts->kind) { 1689 case TEMP_FIXED: 1690 case TEMP_GLOBAL: 1691 pstrcpy(buf, buf_size, ts->name); 1692 break; 1693 case TEMP_LOCAL: 1694 snprintf(buf, buf_size, "loc%d", idx - s->nb_globals); 1695 break; 1696 case TEMP_NORMAL: 1697 snprintf(buf, buf_size, "tmp%d", idx - s->nb_globals); 1698 break; 1699 case TEMP_CONST: 1700 switch (ts->type) { 1701 case TCG_TYPE_I32: 1702 snprintf(buf, buf_size, "$0x%x", (int32_t)ts->val); 1703 break; 1704 #if TCG_TARGET_REG_BITS > 32 1705 case TCG_TYPE_I64: 1706 snprintf(buf, buf_size, "$0x%" PRIx64, ts->val); 1707 break; 1708 #endif 1709 case TCG_TYPE_V64: 1710 case TCG_TYPE_V128: 1711 case TCG_TYPE_V256: 1712 snprintf(buf, buf_size, "v%d$0x%" PRIx64, 1713 64 << (ts->type - TCG_TYPE_V64), ts->val); 1714 break; 1715 default: 1716 g_assert_not_reached(); 1717 } 1718 break; 1719 } 1720 return buf; 1721 } 1722 1723 static char *tcg_get_arg_str(TCGContext *s, char *buf, 1724 int buf_size, TCGArg arg) 1725 { 1726 return tcg_get_arg_str_ptr(s, buf, buf_size, arg_temp(arg)); 1727 } 1728 1729 static const char * const cond_name[] = 1730 { 1731 [TCG_COND_NEVER] = "never", 1732 [TCG_COND_ALWAYS] = "always", 1733 [TCG_COND_EQ] = "eq", 1734 [TCG_COND_NE] = "ne", 1735 [TCG_COND_LT] = "lt", 1736 [TCG_COND_GE] = "ge", 1737 [TCG_COND_LE] = "le", 1738 [TCG_COND_GT] = "gt", 1739 [TCG_COND_LTU] = "ltu", 1740 [TCG_COND_GEU] = "geu", 1741 [TCG_COND_LEU] = "leu", 1742 [TCG_COND_GTU] = "gtu" 1743 }; 1744 1745 static const char * const ldst_name[] = 1746 { 1747 [MO_UB] = "ub", 1748 [MO_SB] = "sb", 1749 [MO_LEUW] = "leuw", 1750 [MO_LESW] = "lesw", 1751 [MO_LEUL] = "leul", 1752 [MO_LESL] = "lesl", 1753 [MO_LEQ] = "leq", 1754 [MO_BEUW] = "beuw", 1755 [MO_BESW] = "besw", 1756 [MO_BEUL] = "beul", 1757 [MO_BESL] = "besl", 1758 [MO_BEQ] = "beq", 1759 }; 1760 1761 static const char * const alignment_name[(MO_AMASK >> MO_ASHIFT) + 1] = { 1762 #ifdef TARGET_ALIGNED_ONLY 1763 [MO_UNALN >> MO_ASHIFT] = "un+", 1764 [MO_ALIGN >> MO_ASHIFT] = "", 1765 #else 1766 [MO_UNALN >> MO_ASHIFT] = "", 1767 [MO_ALIGN >> MO_ASHIFT] = "al+", 1768 #endif 1769 [MO_ALIGN_2 >> MO_ASHIFT] = "al2+", 1770 [MO_ALIGN_4 >> MO_ASHIFT] = "al4+", 1771 [MO_ALIGN_8 >> MO_ASHIFT] = "al8+", 1772 [MO_ALIGN_16 >> MO_ASHIFT] = "al16+", 1773 [MO_ALIGN_32 >> MO_ASHIFT] = "al32+", 1774 [MO_ALIGN_64 >> MO_ASHIFT] = "al64+", 1775 }; 1776 1777 static const char bswap_flag_name[][6] = { 1778 [TCG_BSWAP_IZ] = "iz", 1779 [TCG_BSWAP_OZ] = "oz", 1780 [TCG_BSWAP_OS] = "os", 1781 [TCG_BSWAP_IZ | TCG_BSWAP_OZ] = "iz,oz", 1782 [TCG_BSWAP_IZ | TCG_BSWAP_OS] = "iz,os", 1783 }; 1784 1785 static inline bool tcg_regset_single(TCGRegSet d) 1786 { 1787 return (d & (d - 1)) == 0; 1788 } 1789 1790 static inline TCGReg tcg_regset_first(TCGRegSet d) 1791 { 1792 if (TCG_TARGET_NB_REGS <= 32) { 1793 return ctz32(d); 1794 } else { 1795 return ctz64(d); 1796 } 1797 } 1798 1799 static void tcg_dump_ops(TCGContext *s, bool have_prefs) 1800 { 1801 char buf[128]; 1802 TCGOp *op; 1803 1804 QTAILQ_FOREACH(op, &s->ops, link) { 1805 int i, k, nb_oargs, nb_iargs, nb_cargs; 1806 const TCGOpDef *def; 1807 TCGOpcode c; 1808 int col = 0; 1809 1810 c = op->opc; 1811 def = &tcg_op_defs[c]; 1812 1813 if (c == INDEX_op_insn_start) { 1814 nb_oargs = 0; 1815 col += qemu_log("\n ----"); 1816 1817 for (i = 0; i < TARGET_INSN_START_WORDS; ++i) { 1818 target_ulong a; 1819 #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS 1820 a = deposit64(op->args[i * 2], 32, 32, op->args[i * 2 + 1]); 1821 #else 1822 a = op->args[i]; 1823 #endif 1824 col += qemu_log(" " TARGET_FMT_lx, a); 1825 } 1826 } else if (c == INDEX_op_call) { 1827 const TCGHelperInfo *info = tcg_call_info(op); 1828 void *func = tcg_call_func(op); 1829 1830 /* variable number of arguments */ 1831 nb_oargs = TCGOP_CALLO(op); 1832 nb_iargs = TCGOP_CALLI(op); 1833 nb_cargs = def->nb_cargs; 1834 1835 col += qemu_log(" %s ", def->name); 1836 1837 /* 1838 * Print the function name from TCGHelperInfo, if available. 1839 * Note that plugins have a template function for the info, 1840 * but the actual function pointer comes from the plugin. 1841 */ 1842 if (func == info->func) { 1843 col += qemu_log("%s", info->name); 1844 } else { 1845 col += qemu_log("plugin(%p)", func); 1846 } 1847 1848 col += qemu_log(",$0x%x,$%d", info->flags, nb_oargs); 1849 for (i = 0; i < nb_oargs; i++) { 1850 col += qemu_log(",%s", tcg_get_arg_str(s, buf, sizeof(buf), 1851 op->args[i])); 1852 } 1853 for (i = 0; i < nb_iargs; i++) { 1854 TCGArg arg = op->args[nb_oargs + i]; 1855 const char *t = "<dummy>"; 1856 if (arg != TCG_CALL_DUMMY_ARG) { 1857 t = tcg_get_arg_str(s, buf, sizeof(buf), arg); 1858 } 1859 col += qemu_log(",%s", t); 1860 } 1861 } else { 1862 col += qemu_log(" %s ", def->name); 1863 1864 nb_oargs = def->nb_oargs; 1865 nb_iargs = def->nb_iargs; 1866 nb_cargs = def->nb_cargs; 1867 1868 if (def->flags & TCG_OPF_VECTOR) { 1869 col += qemu_log("v%d,e%d,", 64 << TCGOP_VECL(op), 1870 8 << TCGOP_VECE(op)); 1871 } 1872 1873 k = 0; 1874 for (i = 0; i < nb_oargs; i++) { 1875 if (k != 0) { 1876 col += qemu_log(","); 1877 } 1878 col += qemu_log("%s", tcg_get_arg_str(s, buf, sizeof(buf), 1879 op->args[k++])); 1880 } 1881 for (i = 0; i < nb_iargs; i++) { 1882 if (k != 0) { 1883 col += qemu_log(","); 1884 } 1885 col += qemu_log("%s", tcg_get_arg_str(s, buf, sizeof(buf), 1886 op->args[k++])); 1887 } 1888 switch (c) { 1889 case INDEX_op_brcond_i32: 1890 case INDEX_op_setcond_i32: 1891 case INDEX_op_movcond_i32: 1892 case INDEX_op_brcond2_i32: 1893 case INDEX_op_setcond2_i32: 1894 case INDEX_op_brcond_i64: 1895 case INDEX_op_setcond_i64: 1896 case INDEX_op_movcond_i64: 1897 case INDEX_op_cmp_vec: 1898 case INDEX_op_cmpsel_vec: 1899 if (op->args[k] < ARRAY_SIZE(cond_name) 1900 && cond_name[op->args[k]]) { 1901 col += qemu_log(",%s", cond_name[op->args[k++]]); 1902 } else { 1903 col += qemu_log(",$0x%" TCG_PRIlx, op->args[k++]); 1904 } 1905 i = 1; 1906 break; 1907 case INDEX_op_qemu_ld_i32: 1908 case INDEX_op_qemu_st_i32: 1909 case INDEX_op_qemu_st8_i32: 1910 case INDEX_op_qemu_ld_i64: 1911 case INDEX_op_qemu_st_i64: 1912 { 1913 TCGMemOpIdx oi = op->args[k++]; 1914 MemOp op = get_memop(oi); 1915 unsigned ix = get_mmuidx(oi); 1916 1917 if (op & ~(MO_AMASK | MO_BSWAP | MO_SSIZE)) { 1918 col += qemu_log(",$0x%x,%u", op, ix); 1919 } else { 1920 const char *s_al, *s_op; 1921 s_al = alignment_name[(op & MO_AMASK) >> MO_ASHIFT]; 1922 s_op = ldst_name[op & (MO_BSWAP | MO_SSIZE)]; 1923 col += qemu_log(",%s%s,%u", s_al, s_op, ix); 1924 } 1925 i = 1; 1926 } 1927 break; 1928 case INDEX_op_bswap16_i32: 1929 case INDEX_op_bswap16_i64: 1930 case INDEX_op_bswap32_i32: 1931 case INDEX_op_bswap32_i64: 1932 case INDEX_op_bswap64_i64: 1933 { 1934 TCGArg flags = op->args[k]; 1935 const char *name = NULL; 1936 1937 if (flags < ARRAY_SIZE(bswap_flag_name)) { 1938 name = bswap_flag_name[flags]; 1939 } 1940 if (name) { 1941 col += qemu_log(",%s", name); 1942 } else { 1943 col += qemu_log(",$0x%" TCG_PRIlx, flags); 1944 } 1945 i = k = 1; 1946 } 1947 break; 1948 default: 1949 i = 0; 1950 break; 1951 } 1952 switch (c) { 1953 case INDEX_op_set_label: 1954 case INDEX_op_br: 1955 case INDEX_op_brcond_i32: 1956 case INDEX_op_brcond_i64: 1957 case INDEX_op_brcond2_i32: 1958 col += qemu_log("%s$L%d", k ? "," : "", 1959 arg_label(op->args[k])->id); 1960 i++, k++; 1961 break; 1962 default: 1963 break; 1964 } 1965 for (; i < nb_cargs; i++, k++) { 1966 col += qemu_log("%s$0x%" TCG_PRIlx, k ? "," : "", op->args[k]); 1967 } 1968 } 1969 1970 if (have_prefs || op->life) { 1971 1972 QemuLogFile *logfile; 1973 1974 rcu_read_lock(); 1975 logfile = qatomic_rcu_read(&qemu_logfile); 1976 if (logfile) { 1977 for (; col < 40; ++col) { 1978 putc(' ', logfile->fd); 1979 } 1980 } 1981 rcu_read_unlock(); 1982 } 1983 1984 if (op->life) { 1985 unsigned life = op->life; 1986 1987 if (life & (SYNC_ARG * 3)) { 1988 qemu_log(" sync:"); 1989 for (i = 0; i < 2; ++i) { 1990 if (life & (SYNC_ARG << i)) { 1991 qemu_log(" %d", i); 1992 } 1993 } 1994 } 1995 life /= DEAD_ARG; 1996 if (life) { 1997 qemu_log(" dead:"); 1998 for (i = 0; life; ++i, life >>= 1) { 1999 if (life & 1) { 2000 qemu_log(" %d", i); 2001 } 2002 } 2003 } 2004 } 2005 2006 if (have_prefs) { 2007 for (i = 0; i < nb_oargs; ++i) { 2008 TCGRegSet set = op->output_pref[i]; 2009 2010 if (i == 0) { 2011 qemu_log(" pref="); 2012 } else { 2013 qemu_log(","); 2014 } 2015 if (set == 0) { 2016 qemu_log("none"); 2017 } else if (set == MAKE_64BIT_MASK(0, TCG_TARGET_NB_REGS)) { 2018 qemu_log("all"); 2019 #ifdef CONFIG_DEBUG_TCG 2020 } else if (tcg_regset_single(set)) { 2021 TCGReg reg = tcg_regset_first(set); 2022 qemu_log("%s", tcg_target_reg_names[reg]); 2023 #endif 2024 } else if (TCG_TARGET_NB_REGS <= 32) { 2025 qemu_log("%#x", (uint32_t)set); 2026 } else { 2027 qemu_log("%#" PRIx64, (uint64_t)set); 2028 } 2029 } 2030 } 2031 2032 qemu_log("\n"); 2033 } 2034 } 2035 2036 /* we give more priority to constraints with less registers */ 2037 static int get_constraint_priority(const TCGOpDef *def, int k) 2038 { 2039 const TCGArgConstraint *arg_ct = &def->args_ct[k]; 2040 int n; 2041 2042 if (arg_ct->oalias) { 2043 /* an alias is equivalent to a single register */ 2044 n = 1; 2045 } else { 2046 n = ctpop64(arg_ct->regs); 2047 } 2048 return TCG_TARGET_NB_REGS - n + 1; 2049 } 2050 2051 /* sort from highest priority to lowest */ 2052 static void sort_constraints(TCGOpDef *def, int start, int n) 2053 { 2054 int i, j; 2055 TCGArgConstraint *a = def->args_ct; 2056 2057 for (i = 0; i < n; i++) { 2058 a[start + i].sort_index = start + i; 2059 } 2060 if (n <= 1) { 2061 return; 2062 } 2063 for (i = 0; i < n - 1; i++) { 2064 for (j = i + 1; j < n; j++) { 2065 int p1 = get_constraint_priority(def, a[start + i].sort_index); 2066 int p2 = get_constraint_priority(def, a[start + j].sort_index); 2067 if (p1 < p2) { 2068 int tmp = a[start + i].sort_index; 2069 a[start + i].sort_index = a[start + j].sort_index; 2070 a[start + j].sort_index = tmp; 2071 } 2072 } 2073 } 2074 } 2075 2076 static void process_op_defs(TCGContext *s) 2077 { 2078 TCGOpcode op; 2079 2080 for (op = 0; op < NB_OPS; op++) { 2081 TCGOpDef *def = &tcg_op_defs[op]; 2082 const TCGTargetOpDef *tdefs; 2083 int i, nb_args; 2084 2085 if (def->flags & TCG_OPF_NOT_PRESENT) { 2086 continue; 2087 } 2088 2089 nb_args = def->nb_iargs + def->nb_oargs; 2090 if (nb_args == 0) { 2091 continue; 2092 } 2093 2094 /* 2095 * Macro magic should make it impossible, but double-check that 2096 * the array index is in range. Since the signness of an enum 2097 * is implementation defined, force the result to unsigned. 2098 */ 2099 unsigned con_set = tcg_target_op_def(op); 2100 tcg_debug_assert(con_set < ARRAY_SIZE(constraint_sets)); 2101 tdefs = &constraint_sets[con_set]; 2102 2103 for (i = 0; i < nb_args; i++) { 2104 const char *ct_str = tdefs->args_ct_str[i]; 2105 /* Incomplete TCGTargetOpDef entry. */ 2106 tcg_debug_assert(ct_str != NULL); 2107 2108 while (*ct_str != '\0') { 2109 switch(*ct_str) { 2110 case '0' ... '9': 2111 { 2112 int oarg = *ct_str - '0'; 2113 tcg_debug_assert(ct_str == tdefs->args_ct_str[i]); 2114 tcg_debug_assert(oarg < def->nb_oargs); 2115 tcg_debug_assert(def->args_ct[oarg].regs != 0); 2116 def->args_ct[i] = def->args_ct[oarg]; 2117 /* The output sets oalias. */ 2118 def->args_ct[oarg].oalias = true; 2119 def->args_ct[oarg].alias_index = i; 2120 /* The input sets ialias. */ 2121 def->args_ct[i].ialias = true; 2122 def->args_ct[i].alias_index = oarg; 2123 } 2124 ct_str++; 2125 break; 2126 case '&': 2127 def->args_ct[i].newreg = true; 2128 ct_str++; 2129 break; 2130 case 'i': 2131 def->args_ct[i].ct |= TCG_CT_CONST; 2132 ct_str++; 2133 break; 2134 2135 /* Include all of the target-specific constraints. */ 2136 2137 #undef CONST 2138 #define CONST(CASE, MASK) \ 2139 case CASE: def->args_ct[i].ct |= MASK; ct_str++; break; 2140 #define REGS(CASE, MASK) \ 2141 case CASE: def->args_ct[i].regs |= MASK; ct_str++; break; 2142 2143 #include "tcg-target-con-str.h" 2144 2145 #undef REGS 2146 #undef CONST 2147 default: 2148 /* Typo in TCGTargetOpDef constraint. */ 2149 g_assert_not_reached(); 2150 } 2151 } 2152 } 2153 2154 /* TCGTargetOpDef entry with too much information? */ 2155 tcg_debug_assert(i == TCG_MAX_OP_ARGS || tdefs->args_ct_str[i] == NULL); 2156 2157 /* sort the constraints (XXX: this is just an heuristic) */ 2158 sort_constraints(def, 0, def->nb_oargs); 2159 sort_constraints(def, def->nb_oargs, def->nb_iargs); 2160 } 2161 } 2162 2163 void tcg_op_remove(TCGContext *s, TCGOp *op) 2164 { 2165 TCGLabel *label; 2166 2167 switch (op->opc) { 2168 case INDEX_op_br: 2169 label = arg_label(op->args[0]); 2170 label->refs--; 2171 break; 2172 case INDEX_op_brcond_i32: 2173 case INDEX_op_brcond_i64: 2174 label = arg_label(op->args[3]); 2175 label->refs--; 2176 break; 2177 case INDEX_op_brcond2_i32: 2178 label = arg_label(op->args[5]); 2179 label->refs--; 2180 break; 2181 default: 2182 break; 2183 } 2184 2185 QTAILQ_REMOVE(&s->ops, op, link); 2186 QTAILQ_INSERT_TAIL(&s->free_ops, op, link); 2187 s->nb_ops--; 2188 2189 #ifdef CONFIG_PROFILER 2190 qatomic_set(&s->prof.del_op_count, s->prof.del_op_count + 1); 2191 #endif 2192 } 2193 2194 void tcg_remove_ops_after(TCGOp *op) 2195 { 2196 TCGContext *s = tcg_ctx; 2197 2198 while (true) { 2199 TCGOp *last = tcg_last_op(); 2200 if (last == op) { 2201 return; 2202 } 2203 tcg_op_remove(s, last); 2204 } 2205 } 2206 2207 static TCGOp *tcg_op_alloc(TCGOpcode opc) 2208 { 2209 TCGContext *s = tcg_ctx; 2210 TCGOp *op; 2211 2212 if (likely(QTAILQ_EMPTY(&s->free_ops))) { 2213 op = tcg_malloc(sizeof(TCGOp)); 2214 } else { 2215 op = QTAILQ_FIRST(&s->free_ops); 2216 QTAILQ_REMOVE(&s->free_ops, op, link); 2217 } 2218 memset(op, 0, offsetof(TCGOp, link)); 2219 op->opc = opc; 2220 s->nb_ops++; 2221 2222 return op; 2223 } 2224 2225 TCGOp *tcg_emit_op(TCGOpcode opc) 2226 { 2227 TCGOp *op = tcg_op_alloc(opc); 2228 QTAILQ_INSERT_TAIL(&tcg_ctx->ops, op, link); 2229 return op; 2230 } 2231 2232 TCGOp *tcg_op_insert_before(TCGContext *s, TCGOp *old_op, TCGOpcode opc) 2233 { 2234 TCGOp *new_op = tcg_op_alloc(opc); 2235 QTAILQ_INSERT_BEFORE(old_op, new_op, link); 2236 return new_op; 2237 } 2238 2239 TCGOp *tcg_op_insert_after(TCGContext *s, TCGOp *old_op, TCGOpcode opc) 2240 { 2241 TCGOp *new_op = tcg_op_alloc(opc); 2242 QTAILQ_INSERT_AFTER(&s->ops, old_op, new_op, link); 2243 return new_op; 2244 } 2245 2246 /* Reachable analysis : remove unreachable code. */ 2247 static void reachable_code_pass(TCGContext *s) 2248 { 2249 TCGOp *op, *op_next; 2250 bool dead = false; 2251 2252 QTAILQ_FOREACH_SAFE(op, &s->ops, link, op_next) { 2253 bool remove = dead; 2254 TCGLabel *label; 2255 2256 switch (op->opc) { 2257 case INDEX_op_set_label: 2258 label = arg_label(op->args[0]); 2259 if (label->refs == 0) { 2260 /* 2261 * While there is an occasional backward branch, virtually 2262 * all branches generated by the translators are forward. 2263 * Which means that generally we will have already removed 2264 * all references to the label that will be, and there is 2265 * little to be gained by iterating. 2266 */ 2267 remove = true; 2268 } else { 2269 /* Once we see a label, insns become live again. */ 2270 dead = false; 2271 remove = false; 2272 2273 /* 2274 * Optimization can fold conditional branches to unconditional. 2275 * If we find a label with one reference which is preceded by 2276 * an unconditional branch to it, remove both. This needed to 2277 * wait until the dead code in between them was removed. 2278 */ 2279 if (label->refs == 1) { 2280 TCGOp *op_prev = QTAILQ_PREV(op, link); 2281 if (op_prev->opc == INDEX_op_br && 2282 label == arg_label(op_prev->args[0])) { 2283 tcg_op_remove(s, op_prev); 2284 remove = true; 2285 } 2286 } 2287 } 2288 break; 2289 2290 case INDEX_op_br: 2291 case INDEX_op_exit_tb: 2292 case INDEX_op_goto_ptr: 2293 /* Unconditional branches; everything following is dead. */ 2294 dead = true; 2295 break; 2296 2297 case INDEX_op_call: 2298 /* Notice noreturn helper calls, raising exceptions. */ 2299 if (tcg_call_flags(op) & TCG_CALL_NO_RETURN) { 2300 dead = true; 2301 } 2302 break; 2303 2304 case INDEX_op_insn_start: 2305 /* Never remove -- we need to keep these for unwind. */ 2306 remove = false; 2307 break; 2308 2309 default: 2310 break; 2311 } 2312 2313 if (remove) { 2314 tcg_op_remove(s, op); 2315 } 2316 } 2317 } 2318 2319 #define TS_DEAD 1 2320 #define TS_MEM 2 2321 2322 #define IS_DEAD_ARG(n) (arg_life & (DEAD_ARG << (n))) 2323 #define NEED_SYNC_ARG(n) (arg_life & (SYNC_ARG << (n))) 2324 2325 /* For liveness_pass_1, the register preferences for a given temp. */ 2326 static inline TCGRegSet *la_temp_pref(TCGTemp *ts) 2327 { 2328 return ts->state_ptr; 2329 } 2330 2331 /* For liveness_pass_1, reset the preferences for a given temp to the 2332 * maximal regset for its type. 2333 */ 2334 static inline void la_reset_pref(TCGTemp *ts) 2335 { 2336 *la_temp_pref(ts) 2337 = (ts->state == TS_DEAD ? 0 : tcg_target_available_regs[ts->type]); 2338 } 2339 2340 /* liveness analysis: end of function: all temps are dead, and globals 2341 should be in memory. */ 2342 static void la_func_end(TCGContext *s, int ng, int nt) 2343 { 2344 int i; 2345 2346 for (i = 0; i < ng; ++i) { 2347 s->temps[i].state = TS_DEAD | TS_MEM; 2348 la_reset_pref(&s->temps[i]); 2349 } 2350 for (i = ng; i < nt; ++i) { 2351 s->temps[i].state = TS_DEAD; 2352 la_reset_pref(&s->temps[i]); 2353 } 2354 } 2355 2356 /* liveness analysis: end of basic block: all temps are dead, globals 2357 and local temps should be in memory. */ 2358 static void la_bb_end(TCGContext *s, int ng, int nt) 2359 { 2360 int i; 2361 2362 for (i = 0; i < nt; ++i) { 2363 TCGTemp *ts = &s->temps[i]; 2364 int state; 2365 2366 switch (ts->kind) { 2367 case TEMP_FIXED: 2368 case TEMP_GLOBAL: 2369 case TEMP_LOCAL: 2370 state = TS_DEAD | TS_MEM; 2371 break; 2372 case TEMP_NORMAL: 2373 case TEMP_CONST: 2374 state = TS_DEAD; 2375 break; 2376 default: 2377 g_assert_not_reached(); 2378 } 2379 ts->state = state; 2380 la_reset_pref(ts); 2381 } 2382 } 2383 2384 /* liveness analysis: sync globals back to memory. */ 2385 static void la_global_sync(TCGContext *s, int ng) 2386 { 2387 int i; 2388 2389 for (i = 0; i < ng; ++i) { 2390 int state = s->temps[i].state; 2391 s->temps[i].state = state | TS_MEM; 2392 if (state == TS_DEAD) { 2393 /* If the global was previously dead, reset prefs. */ 2394 la_reset_pref(&s->temps[i]); 2395 } 2396 } 2397 } 2398 2399 /* 2400 * liveness analysis: conditional branch: all temps are dead, 2401 * globals and local temps should be synced. 2402 */ 2403 static void la_bb_sync(TCGContext *s, int ng, int nt) 2404 { 2405 la_global_sync(s, ng); 2406 2407 for (int i = ng; i < nt; ++i) { 2408 TCGTemp *ts = &s->temps[i]; 2409 int state; 2410 2411 switch (ts->kind) { 2412 case TEMP_LOCAL: 2413 state = ts->state; 2414 ts->state = state | TS_MEM; 2415 if (state != TS_DEAD) { 2416 continue; 2417 } 2418 break; 2419 case TEMP_NORMAL: 2420 s->temps[i].state = TS_DEAD; 2421 break; 2422 case TEMP_CONST: 2423 continue; 2424 default: 2425 g_assert_not_reached(); 2426 } 2427 la_reset_pref(&s->temps[i]); 2428 } 2429 } 2430 2431 /* liveness analysis: sync globals back to memory and kill. */ 2432 static void la_global_kill(TCGContext *s, int ng) 2433 { 2434 int i; 2435 2436 for (i = 0; i < ng; i++) { 2437 s->temps[i].state = TS_DEAD | TS_MEM; 2438 la_reset_pref(&s->temps[i]); 2439 } 2440 } 2441 2442 /* liveness analysis: note live globals crossing calls. */ 2443 static void la_cross_call(TCGContext *s, int nt) 2444 { 2445 TCGRegSet mask = ~tcg_target_call_clobber_regs; 2446 int i; 2447 2448 for (i = 0; i < nt; i++) { 2449 TCGTemp *ts = &s->temps[i]; 2450 if (!(ts->state & TS_DEAD)) { 2451 TCGRegSet *pset = la_temp_pref(ts); 2452 TCGRegSet set = *pset; 2453 2454 set &= mask; 2455 /* If the combination is not possible, restart. */ 2456 if (set == 0) { 2457 set = tcg_target_available_regs[ts->type] & mask; 2458 } 2459 *pset = set; 2460 } 2461 } 2462 } 2463 2464 /* Liveness analysis : update the opc_arg_life array to tell if a 2465 given input arguments is dead. Instructions updating dead 2466 temporaries are removed. */ 2467 static void liveness_pass_1(TCGContext *s) 2468 { 2469 int nb_globals = s->nb_globals; 2470 int nb_temps = s->nb_temps; 2471 TCGOp *op, *op_prev; 2472 TCGRegSet *prefs; 2473 int i; 2474 2475 prefs = tcg_malloc(sizeof(TCGRegSet) * nb_temps); 2476 for (i = 0; i < nb_temps; ++i) { 2477 s->temps[i].state_ptr = prefs + i; 2478 } 2479 2480 /* ??? Should be redundant with the exit_tb that ends the TB. */ 2481 la_func_end(s, nb_globals, nb_temps); 2482 2483 QTAILQ_FOREACH_REVERSE_SAFE(op, &s->ops, link, op_prev) { 2484 int nb_iargs, nb_oargs; 2485 TCGOpcode opc_new, opc_new2; 2486 bool have_opc_new2; 2487 TCGLifeData arg_life = 0; 2488 TCGTemp *ts; 2489 TCGOpcode opc = op->opc; 2490 const TCGOpDef *def = &tcg_op_defs[opc]; 2491 2492 switch (opc) { 2493 case INDEX_op_call: 2494 { 2495 int call_flags; 2496 int nb_call_regs; 2497 2498 nb_oargs = TCGOP_CALLO(op); 2499 nb_iargs = TCGOP_CALLI(op); 2500 call_flags = tcg_call_flags(op); 2501 2502 /* pure functions can be removed if their result is unused */ 2503 if (call_flags & TCG_CALL_NO_SIDE_EFFECTS) { 2504 for (i = 0; i < nb_oargs; i++) { 2505 ts = arg_temp(op->args[i]); 2506 if (ts->state != TS_DEAD) { 2507 goto do_not_remove_call; 2508 } 2509 } 2510 goto do_remove; 2511 } 2512 do_not_remove_call: 2513 2514 /* Output args are dead. */ 2515 for (i = 0; i < nb_oargs; i++) { 2516 ts = arg_temp(op->args[i]); 2517 if (ts->state & TS_DEAD) { 2518 arg_life |= DEAD_ARG << i; 2519 } 2520 if (ts->state & TS_MEM) { 2521 arg_life |= SYNC_ARG << i; 2522 } 2523 ts->state = TS_DEAD; 2524 la_reset_pref(ts); 2525 2526 /* Not used -- it will be tcg_target_call_oarg_regs[i]. */ 2527 op->output_pref[i] = 0; 2528 } 2529 2530 if (!(call_flags & (TCG_CALL_NO_WRITE_GLOBALS | 2531 TCG_CALL_NO_READ_GLOBALS))) { 2532 la_global_kill(s, nb_globals); 2533 } else if (!(call_flags & TCG_CALL_NO_READ_GLOBALS)) { 2534 la_global_sync(s, nb_globals); 2535 } 2536 2537 /* Record arguments that die in this helper. */ 2538 for (i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 2539 ts = arg_temp(op->args[i]); 2540 if (ts && ts->state & TS_DEAD) { 2541 arg_life |= DEAD_ARG << i; 2542 } 2543 } 2544 2545 /* For all live registers, remove call-clobbered prefs. */ 2546 la_cross_call(s, nb_temps); 2547 2548 nb_call_regs = ARRAY_SIZE(tcg_target_call_iarg_regs); 2549 2550 /* Input arguments are live for preceding opcodes. */ 2551 for (i = 0; i < nb_iargs; i++) { 2552 ts = arg_temp(op->args[i + nb_oargs]); 2553 if (ts && ts->state & TS_DEAD) { 2554 /* For those arguments that die, and will be allocated 2555 * in registers, clear the register set for that arg, 2556 * to be filled in below. For args that will be on 2557 * the stack, reset to any available reg. 2558 */ 2559 *la_temp_pref(ts) 2560 = (i < nb_call_regs ? 0 : 2561 tcg_target_available_regs[ts->type]); 2562 ts->state &= ~TS_DEAD; 2563 } 2564 } 2565 2566 /* For each input argument, add its input register to prefs. 2567 If a temp is used once, this produces a single set bit. */ 2568 for (i = 0; i < MIN(nb_call_regs, nb_iargs); i++) { 2569 ts = arg_temp(op->args[i + nb_oargs]); 2570 if (ts) { 2571 tcg_regset_set_reg(*la_temp_pref(ts), 2572 tcg_target_call_iarg_regs[i]); 2573 } 2574 } 2575 } 2576 break; 2577 case INDEX_op_insn_start: 2578 break; 2579 case INDEX_op_discard: 2580 /* mark the temporary as dead */ 2581 ts = arg_temp(op->args[0]); 2582 ts->state = TS_DEAD; 2583 la_reset_pref(ts); 2584 break; 2585 2586 case INDEX_op_add2_i32: 2587 opc_new = INDEX_op_add_i32; 2588 goto do_addsub2; 2589 case INDEX_op_sub2_i32: 2590 opc_new = INDEX_op_sub_i32; 2591 goto do_addsub2; 2592 case INDEX_op_add2_i64: 2593 opc_new = INDEX_op_add_i64; 2594 goto do_addsub2; 2595 case INDEX_op_sub2_i64: 2596 opc_new = INDEX_op_sub_i64; 2597 do_addsub2: 2598 nb_iargs = 4; 2599 nb_oargs = 2; 2600 /* Test if the high part of the operation is dead, but not 2601 the low part. The result can be optimized to a simple 2602 add or sub. This happens often for x86_64 guest when the 2603 cpu mode is set to 32 bit. */ 2604 if (arg_temp(op->args[1])->state == TS_DEAD) { 2605 if (arg_temp(op->args[0])->state == TS_DEAD) { 2606 goto do_remove; 2607 } 2608 /* Replace the opcode and adjust the args in place, 2609 leaving 3 unused args at the end. */ 2610 op->opc = opc = opc_new; 2611 op->args[1] = op->args[2]; 2612 op->args[2] = op->args[4]; 2613 /* Fall through and mark the single-word operation live. */ 2614 nb_iargs = 2; 2615 nb_oargs = 1; 2616 } 2617 goto do_not_remove; 2618 2619 case INDEX_op_mulu2_i32: 2620 opc_new = INDEX_op_mul_i32; 2621 opc_new2 = INDEX_op_muluh_i32; 2622 have_opc_new2 = TCG_TARGET_HAS_muluh_i32; 2623 goto do_mul2; 2624 case INDEX_op_muls2_i32: 2625 opc_new = INDEX_op_mul_i32; 2626 opc_new2 = INDEX_op_mulsh_i32; 2627 have_opc_new2 = TCG_TARGET_HAS_mulsh_i32; 2628 goto do_mul2; 2629 case INDEX_op_mulu2_i64: 2630 opc_new = INDEX_op_mul_i64; 2631 opc_new2 = INDEX_op_muluh_i64; 2632 have_opc_new2 = TCG_TARGET_HAS_muluh_i64; 2633 goto do_mul2; 2634 case INDEX_op_muls2_i64: 2635 opc_new = INDEX_op_mul_i64; 2636 opc_new2 = INDEX_op_mulsh_i64; 2637 have_opc_new2 = TCG_TARGET_HAS_mulsh_i64; 2638 goto do_mul2; 2639 do_mul2: 2640 nb_iargs = 2; 2641 nb_oargs = 2; 2642 if (arg_temp(op->args[1])->state == TS_DEAD) { 2643 if (arg_temp(op->args[0])->state == TS_DEAD) { 2644 /* Both parts of the operation are dead. */ 2645 goto do_remove; 2646 } 2647 /* The high part of the operation is dead; generate the low. */ 2648 op->opc = opc = opc_new; 2649 op->args[1] = op->args[2]; 2650 op->args[2] = op->args[3]; 2651 } else if (arg_temp(op->args[0])->state == TS_DEAD && have_opc_new2) { 2652 /* The low part of the operation is dead; generate the high. */ 2653 op->opc = opc = opc_new2; 2654 op->args[0] = op->args[1]; 2655 op->args[1] = op->args[2]; 2656 op->args[2] = op->args[3]; 2657 } else { 2658 goto do_not_remove; 2659 } 2660 /* Mark the single-word operation live. */ 2661 nb_oargs = 1; 2662 goto do_not_remove; 2663 2664 default: 2665 /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */ 2666 nb_iargs = def->nb_iargs; 2667 nb_oargs = def->nb_oargs; 2668 2669 /* Test if the operation can be removed because all 2670 its outputs are dead. We assume that nb_oargs == 0 2671 implies side effects */ 2672 if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) { 2673 for (i = 0; i < nb_oargs; i++) { 2674 if (arg_temp(op->args[i])->state != TS_DEAD) { 2675 goto do_not_remove; 2676 } 2677 } 2678 goto do_remove; 2679 } 2680 goto do_not_remove; 2681 2682 do_remove: 2683 tcg_op_remove(s, op); 2684 break; 2685 2686 do_not_remove: 2687 for (i = 0; i < nb_oargs; i++) { 2688 ts = arg_temp(op->args[i]); 2689 2690 /* Remember the preference of the uses that followed. */ 2691 op->output_pref[i] = *la_temp_pref(ts); 2692 2693 /* Output args are dead. */ 2694 if (ts->state & TS_DEAD) { 2695 arg_life |= DEAD_ARG << i; 2696 } 2697 if (ts->state & TS_MEM) { 2698 arg_life |= SYNC_ARG << i; 2699 } 2700 ts->state = TS_DEAD; 2701 la_reset_pref(ts); 2702 } 2703 2704 /* If end of basic block, update. */ 2705 if (def->flags & TCG_OPF_BB_EXIT) { 2706 la_func_end(s, nb_globals, nb_temps); 2707 } else if (def->flags & TCG_OPF_COND_BRANCH) { 2708 la_bb_sync(s, nb_globals, nb_temps); 2709 } else if (def->flags & TCG_OPF_BB_END) { 2710 la_bb_end(s, nb_globals, nb_temps); 2711 } else if (def->flags & TCG_OPF_SIDE_EFFECTS) { 2712 la_global_sync(s, nb_globals); 2713 if (def->flags & TCG_OPF_CALL_CLOBBER) { 2714 la_cross_call(s, nb_temps); 2715 } 2716 } 2717 2718 /* Record arguments that die in this opcode. */ 2719 for (i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 2720 ts = arg_temp(op->args[i]); 2721 if (ts->state & TS_DEAD) { 2722 arg_life |= DEAD_ARG << i; 2723 } 2724 } 2725 2726 /* Input arguments are live for preceding opcodes. */ 2727 for (i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 2728 ts = arg_temp(op->args[i]); 2729 if (ts->state & TS_DEAD) { 2730 /* For operands that were dead, initially allow 2731 all regs for the type. */ 2732 *la_temp_pref(ts) = tcg_target_available_regs[ts->type]; 2733 ts->state &= ~TS_DEAD; 2734 } 2735 } 2736 2737 /* Incorporate constraints for this operand. */ 2738 switch (opc) { 2739 case INDEX_op_mov_i32: 2740 case INDEX_op_mov_i64: 2741 /* Note that these are TCG_OPF_NOT_PRESENT and do not 2742 have proper constraints. That said, special case 2743 moves to propagate preferences backward. */ 2744 if (IS_DEAD_ARG(1)) { 2745 *la_temp_pref(arg_temp(op->args[0])) 2746 = *la_temp_pref(arg_temp(op->args[1])); 2747 } 2748 break; 2749 2750 default: 2751 for (i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 2752 const TCGArgConstraint *ct = &def->args_ct[i]; 2753 TCGRegSet set, *pset; 2754 2755 ts = arg_temp(op->args[i]); 2756 pset = la_temp_pref(ts); 2757 set = *pset; 2758 2759 set &= ct->regs; 2760 if (ct->ialias) { 2761 set &= op->output_pref[ct->alias_index]; 2762 } 2763 /* If the combination is not possible, restart. */ 2764 if (set == 0) { 2765 set = ct->regs; 2766 } 2767 *pset = set; 2768 } 2769 break; 2770 } 2771 break; 2772 } 2773 op->life = arg_life; 2774 } 2775 } 2776 2777 /* Liveness analysis: Convert indirect regs to direct temporaries. */ 2778 static bool liveness_pass_2(TCGContext *s) 2779 { 2780 int nb_globals = s->nb_globals; 2781 int nb_temps, i; 2782 bool changes = false; 2783 TCGOp *op, *op_next; 2784 2785 /* Create a temporary for each indirect global. */ 2786 for (i = 0; i < nb_globals; ++i) { 2787 TCGTemp *its = &s->temps[i]; 2788 if (its->indirect_reg) { 2789 TCGTemp *dts = tcg_temp_alloc(s); 2790 dts->type = its->type; 2791 dts->base_type = its->base_type; 2792 its->state_ptr = dts; 2793 } else { 2794 its->state_ptr = NULL; 2795 } 2796 /* All globals begin dead. */ 2797 its->state = TS_DEAD; 2798 } 2799 for (nb_temps = s->nb_temps; i < nb_temps; ++i) { 2800 TCGTemp *its = &s->temps[i]; 2801 its->state_ptr = NULL; 2802 its->state = TS_DEAD; 2803 } 2804 2805 QTAILQ_FOREACH_SAFE(op, &s->ops, link, op_next) { 2806 TCGOpcode opc = op->opc; 2807 const TCGOpDef *def = &tcg_op_defs[opc]; 2808 TCGLifeData arg_life = op->life; 2809 int nb_iargs, nb_oargs, call_flags; 2810 TCGTemp *arg_ts, *dir_ts; 2811 2812 if (opc == INDEX_op_call) { 2813 nb_oargs = TCGOP_CALLO(op); 2814 nb_iargs = TCGOP_CALLI(op); 2815 call_flags = tcg_call_flags(op); 2816 } else { 2817 nb_iargs = def->nb_iargs; 2818 nb_oargs = def->nb_oargs; 2819 2820 /* Set flags similar to how calls require. */ 2821 if (def->flags & TCG_OPF_COND_BRANCH) { 2822 /* Like reading globals: sync_globals */ 2823 call_flags = TCG_CALL_NO_WRITE_GLOBALS; 2824 } else if (def->flags & TCG_OPF_BB_END) { 2825 /* Like writing globals: save_globals */ 2826 call_flags = 0; 2827 } else if (def->flags & TCG_OPF_SIDE_EFFECTS) { 2828 /* Like reading globals: sync_globals */ 2829 call_flags = TCG_CALL_NO_WRITE_GLOBALS; 2830 } else { 2831 /* No effect on globals. */ 2832 call_flags = (TCG_CALL_NO_READ_GLOBALS | 2833 TCG_CALL_NO_WRITE_GLOBALS); 2834 } 2835 } 2836 2837 /* Make sure that input arguments are available. */ 2838 for (i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 2839 arg_ts = arg_temp(op->args[i]); 2840 if (arg_ts) { 2841 dir_ts = arg_ts->state_ptr; 2842 if (dir_ts && arg_ts->state == TS_DEAD) { 2843 TCGOpcode lopc = (arg_ts->type == TCG_TYPE_I32 2844 ? INDEX_op_ld_i32 2845 : INDEX_op_ld_i64); 2846 TCGOp *lop = tcg_op_insert_before(s, op, lopc); 2847 2848 lop->args[0] = temp_arg(dir_ts); 2849 lop->args[1] = temp_arg(arg_ts->mem_base); 2850 lop->args[2] = arg_ts->mem_offset; 2851 2852 /* Loaded, but synced with memory. */ 2853 arg_ts->state = TS_MEM; 2854 } 2855 } 2856 } 2857 2858 /* Perform input replacement, and mark inputs that became dead. 2859 No action is required except keeping temp_state up to date 2860 so that we reload when needed. */ 2861 for (i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 2862 arg_ts = arg_temp(op->args[i]); 2863 if (arg_ts) { 2864 dir_ts = arg_ts->state_ptr; 2865 if (dir_ts) { 2866 op->args[i] = temp_arg(dir_ts); 2867 changes = true; 2868 if (IS_DEAD_ARG(i)) { 2869 arg_ts->state = TS_DEAD; 2870 } 2871 } 2872 } 2873 } 2874 2875 /* Liveness analysis should ensure that the following are 2876 all correct, for call sites and basic block end points. */ 2877 if (call_flags & TCG_CALL_NO_READ_GLOBALS) { 2878 /* Nothing to do */ 2879 } else if (call_flags & TCG_CALL_NO_WRITE_GLOBALS) { 2880 for (i = 0; i < nb_globals; ++i) { 2881 /* Liveness should see that globals are synced back, 2882 that is, either TS_DEAD or TS_MEM. */ 2883 arg_ts = &s->temps[i]; 2884 tcg_debug_assert(arg_ts->state_ptr == 0 2885 || arg_ts->state != 0); 2886 } 2887 } else { 2888 for (i = 0; i < nb_globals; ++i) { 2889 /* Liveness should see that globals are saved back, 2890 that is, TS_DEAD, waiting to be reloaded. */ 2891 arg_ts = &s->temps[i]; 2892 tcg_debug_assert(arg_ts->state_ptr == 0 2893 || arg_ts->state == TS_DEAD); 2894 } 2895 } 2896 2897 /* Outputs become available. */ 2898 if (opc == INDEX_op_mov_i32 || opc == INDEX_op_mov_i64) { 2899 arg_ts = arg_temp(op->args[0]); 2900 dir_ts = arg_ts->state_ptr; 2901 if (dir_ts) { 2902 op->args[0] = temp_arg(dir_ts); 2903 changes = true; 2904 2905 /* The output is now live and modified. */ 2906 arg_ts->state = 0; 2907 2908 if (NEED_SYNC_ARG(0)) { 2909 TCGOpcode sopc = (arg_ts->type == TCG_TYPE_I32 2910 ? INDEX_op_st_i32 2911 : INDEX_op_st_i64); 2912 TCGOp *sop = tcg_op_insert_after(s, op, sopc); 2913 TCGTemp *out_ts = dir_ts; 2914 2915 if (IS_DEAD_ARG(0)) { 2916 out_ts = arg_temp(op->args[1]); 2917 arg_ts->state = TS_DEAD; 2918 tcg_op_remove(s, op); 2919 } else { 2920 arg_ts->state = TS_MEM; 2921 } 2922 2923 sop->args[0] = temp_arg(out_ts); 2924 sop->args[1] = temp_arg(arg_ts->mem_base); 2925 sop->args[2] = arg_ts->mem_offset; 2926 } else { 2927 tcg_debug_assert(!IS_DEAD_ARG(0)); 2928 } 2929 } 2930 } else { 2931 for (i = 0; i < nb_oargs; i++) { 2932 arg_ts = arg_temp(op->args[i]); 2933 dir_ts = arg_ts->state_ptr; 2934 if (!dir_ts) { 2935 continue; 2936 } 2937 op->args[i] = temp_arg(dir_ts); 2938 changes = true; 2939 2940 /* The output is now live and modified. */ 2941 arg_ts->state = 0; 2942 2943 /* Sync outputs upon their last write. */ 2944 if (NEED_SYNC_ARG(i)) { 2945 TCGOpcode sopc = (arg_ts->type == TCG_TYPE_I32 2946 ? INDEX_op_st_i32 2947 : INDEX_op_st_i64); 2948 TCGOp *sop = tcg_op_insert_after(s, op, sopc); 2949 2950 sop->args[0] = temp_arg(dir_ts); 2951 sop->args[1] = temp_arg(arg_ts->mem_base); 2952 sop->args[2] = arg_ts->mem_offset; 2953 2954 arg_ts->state = TS_MEM; 2955 } 2956 /* Drop outputs that are dead. */ 2957 if (IS_DEAD_ARG(i)) { 2958 arg_ts->state = TS_DEAD; 2959 } 2960 } 2961 } 2962 } 2963 2964 return changes; 2965 } 2966 2967 #ifdef CONFIG_DEBUG_TCG 2968 static void dump_regs(TCGContext *s) 2969 { 2970 TCGTemp *ts; 2971 int i; 2972 char buf[64]; 2973 2974 for(i = 0; i < s->nb_temps; i++) { 2975 ts = &s->temps[i]; 2976 printf(" %10s: ", tcg_get_arg_str_ptr(s, buf, sizeof(buf), ts)); 2977 switch(ts->val_type) { 2978 case TEMP_VAL_REG: 2979 printf("%s", tcg_target_reg_names[ts->reg]); 2980 break; 2981 case TEMP_VAL_MEM: 2982 printf("%d(%s)", (int)ts->mem_offset, 2983 tcg_target_reg_names[ts->mem_base->reg]); 2984 break; 2985 case TEMP_VAL_CONST: 2986 printf("$0x%" PRIx64, ts->val); 2987 break; 2988 case TEMP_VAL_DEAD: 2989 printf("D"); 2990 break; 2991 default: 2992 printf("???"); 2993 break; 2994 } 2995 printf("\n"); 2996 } 2997 2998 for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 2999 if (s->reg_to_temp[i] != NULL) { 3000 printf("%s: %s\n", 3001 tcg_target_reg_names[i], 3002 tcg_get_arg_str_ptr(s, buf, sizeof(buf), s->reg_to_temp[i])); 3003 } 3004 } 3005 } 3006 3007 static void check_regs(TCGContext *s) 3008 { 3009 int reg; 3010 int k; 3011 TCGTemp *ts; 3012 char buf[64]; 3013 3014 for (reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 3015 ts = s->reg_to_temp[reg]; 3016 if (ts != NULL) { 3017 if (ts->val_type != TEMP_VAL_REG || ts->reg != reg) { 3018 printf("Inconsistency for register %s:\n", 3019 tcg_target_reg_names[reg]); 3020 goto fail; 3021 } 3022 } 3023 } 3024 for (k = 0; k < s->nb_temps; k++) { 3025 ts = &s->temps[k]; 3026 if (ts->val_type == TEMP_VAL_REG 3027 && ts->kind != TEMP_FIXED 3028 && s->reg_to_temp[ts->reg] != ts) { 3029 printf("Inconsistency for temp %s:\n", 3030 tcg_get_arg_str_ptr(s, buf, sizeof(buf), ts)); 3031 fail: 3032 printf("reg state:\n"); 3033 dump_regs(s); 3034 tcg_abort(); 3035 } 3036 } 3037 } 3038 #endif 3039 3040 static void temp_allocate_frame(TCGContext *s, TCGTemp *ts) 3041 { 3042 intptr_t off, size, align; 3043 3044 switch (ts->type) { 3045 case TCG_TYPE_I32: 3046 size = align = 4; 3047 break; 3048 case TCG_TYPE_I64: 3049 case TCG_TYPE_V64: 3050 size = align = 8; 3051 break; 3052 case TCG_TYPE_V128: 3053 size = align = 16; 3054 break; 3055 case TCG_TYPE_V256: 3056 /* Note that we do not require aligned storage for V256. */ 3057 size = 32, align = 16; 3058 break; 3059 default: 3060 g_assert_not_reached(); 3061 } 3062 3063 assert(align <= TCG_TARGET_STACK_ALIGN); 3064 off = ROUND_UP(s->current_frame_offset, align); 3065 3066 /* If we've exhausted the stack frame, restart with a smaller TB. */ 3067 if (off + size > s->frame_end) { 3068 tcg_raise_tb_overflow(s); 3069 } 3070 s->current_frame_offset = off + size; 3071 3072 ts->mem_offset = off; 3073 #if defined(__sparc__) 3074 ts->mem_offset += TCG_TARGET_STACK_BIAS; 3075 #endif 3076 ts->mem_base = s->frame_temp; 3077 ts->mem_allocated = 1; 3078 } 3079 3080 static void temp_load(TCGContext *, TCGTemp *, TCGRegSet, TCGRegSet, TCGRegSet); 3081 3082 /* Mark a temporary as free or dead. If 'free_or_dead' is negative, 3083 mark it free; otherwise mark it dead. */ 3084 static void temp_free_or_dead(TCGContext *s, TCGTemp *ts, int free_or_dead) 3085 { 3086 TCGTempVal new_type; 3087 3088 switch (ts->kind) { 3089 case TEMP_FIXED: 3090 return; 3091 case TEMP_GLOBAL: 3092 case TEMP_LOCAL: 3093 new_type = TEMP_VAL_MEM; 3094 break; 3095 case TEMP_NORMAL: 3096 new_type = free_or_dead < 0 ? TEMP_VAL_MEM : TEMP_VAL_DEAD; 3097 break; 3098 case TEMP_CONST: 3099 new_type = TEMP_VAL_CONST; 3100 break; 3101 default: 3102 g_assert_not_reached(); 3103 } 3104 if (ts->val_type == TEMP_VAL_REG) { 3105 s->reg_to_temp[ts->reg] = NULL; 3106 } 3107 ts->val_type = new_type; 3108 } 3109 3110 /* Mark a temporary as dead. */ 3111 static inline void temp_dead(TCGContext *s, TCGTemp *ts) 3112 { 3113 temp_free_or_dead(s, ts, 1); 3114 } 3115 3116 /* Sync a temporary to memory. 'allocated_regs' is used in case a temporary 3117 registers needs to be allocated to store a constant. If 'free_or_dead' 3118 is non-zero, subsequently release the temporary; if it is positive, the 3119 temp is dead; if it is negative, the temp is free. */ 3120 static void temp_sync(TCGContext *s, TCGTemp *ts, TCGRegSet allocated_regs, 3121 TCGRegSet preferred_regs, int free_or_dead) 3122 { 3123 if (!temp_readonly(ts) && !ts->mem_coherent) { 3124 if (!ts->mem_allocated) { 3125 temp_allocate_frame(s, ts); 3126 } 3127 switch (ts->val_type) { 3128 case TEMP_VAL_CONST: 3129 /* If we're going to free the temp immediately, then we won't 3130 require it later in a register, so attempt to store the 3131 constant to memory directly. */ 3132 if (free_or_dead 3133 && tcg_out_sti(s, ts->type, ts->val, 3134 ts->mem_base->reg, ts->mem_offset)) { 3135 break; 3136 } 3137 temp_load(s, ts, tcg_target_available_regs[ts->type], 3138 allocated_regs, preferred_regs); 3139 /* fallthrough */ 3140 3141 case TEMP_VAL_REG: 3142 tcg_out_st(s, ts->type, ts->reg, 3143 ts->mem_base->reg, ts->mem_offset); 3144 break; 3145 3146 case TEMP_VAL_MEM: 3147 break; 3148 3149 case TEMP_VAL_DEAD: 3150 default: 3151 tcg_abort(); 3152 } 3153 ts->mem_coherent = 1; 3154 } 3155 if (free_or_dead) { 3156 temp_free_or_dead(s, ts, free_or_dead); 3157 } 3158 } 3159 3160 /* free register 'reg' by spilling the corresponding temporary if necessary */ 3161 static void tcg_reg_free(TCGContext *s, TCGReg reg, TCGRegSet allocated_regs) 3162 { 3163 TCGTemp *ts = s->reg_to_temp[reg]; 3164 if (ts != NULL) { 3165 temp_sync(s, ts, allocated_regs, 0, -1); 3166 } 3167 } 3168 3169 /** 3170 * tcg_reg_alloc: 3171 * @required_regs: Set of registers in which we must allocate. 3172 * @allocated_regs: Set of registers which must be avoided. 3173 * @preferred_regs: Set of registers we should prefer. 3174 * @rev: True if we search the registers in "indirect" order. 3175 * 3176 * The allocated register must be in @required_regs & ~@allocated_regs, 3177 * but if we can put it in @preferred_regs we may save a move later. 3178 */ 3179 static TCGReg tcg_reg_alloc(TCGContext *s, TCGRegSet required_regs, 3180 TCGRegSet allocated_regs, 3181 TCGRegSet preferred_regs, bool rev) 3182 { 3183 int i, j, f, n = ARRAY_SIZE(tcg_target_reg_alloc_order); 3184 TCGRegSet reg_ct[2]; 3185 const int *order; 3186 3187 reg_ct[1] = required_regs & ~allocated_regs; 3188 tcg_debug_assert(reg_ct[1] != 0); 3189 reg_ct[0] = reg_ct[1] & preferred_regs; 3190 3191 /* Skip the preferred_regs option if it cannot be satisfied, 3192 or if the preference made no difference. */ 3193 f = reg_ct[0] == 0 || reg_ct[0] == reg_ct[1]; 3194 3195 order = rev ? indirect_reg_alloc_order : tcg_target_reg_alloc_order; 3196 3197 /* Try free registers, preferences first. */ 3198 for (j = f; j < 2; j++) { 3199 TCGRegSet set = reg_ct[j]; 3200 3201 if (tcg_regset_single(set)) { 3202 /* One register in the set. */ 3203 TCGReg reg = tcg_regset_first(set); 3204 if (s->reg_to_temp[reg] == NULL) { 3205 return reg; 3206 } 3207 } else { 3208 for (i = 0; i < n; i++) { 3209 TCGReg reg = order[i]; 3210 if (s->reg_to_temp[reg] == NULL && 3211 tcg_regset_test_reg(set, reg)) { 3212 return reg; 3213 } 3214 } 3215 } 3216 } 3217 3218 /* We must spill something. */ 3219 for (j = f; j < 2; j++) { 3220 TCGRegSet set = reg_ct[j]; 3221 3222 if (tcg_regset_single(set)) { 3223 /* One register in the set. */ 3224 TCGReg reg = tcg_regset_first(set); 3225 tcg_reg_free(s, reg, allocated_regs); 3226 return reg; 3227 } else { 3228 for (i = 0; i < n; i++) { 3229 TCGReg reg = order[i]; 3230 if (tcg_regset_test_reg(set, reg)) { 3231 tcg_reg_free(s, reg, allocated_regs); 3232 return reg; 3233 } 3234 } 3235 } 3236 } 3237 3238 tcg_abort(); 3239 } 3240 3241 /* Make sure the temporary is in a register. If needed, allocate the register 3242 from DESIRED while avoiding ALLOCATED. */ 3243 static void temp_load(TCGContext *s, TCGTemp *ts, TCGRegSet desired_regs, 3244 TCGRegSet allocated_regs, TCGRegSet preferred_regs) 3245 { 3246 TCGReg reg; 3247 3248 switch (ts->val_type) { 3249 case TEMP_VAL_REG: 3250 return; 3251 case TEMP_VAL_CONST: 3252 reg = tcg_reg_alloc(s, desired_regs, allocated_regs, 3253 preferred_regs, ts->indirect_base); 3254 if (ts->type <= TCG_TYPE_I64) { 3255 tcg_out_movi(s, ts->type, reg, ts->val); 3256 } else { 3257 uint64_t val = ts->val; 3258 MemOp vece = MO_64; 3259 3260 /* 3261 * Find the minimal vector element that matches the constant. 3262 * The targets will, in general, have to do this search anyway, 3263 * do this generically. 3264 */ 3265 if (val == dup_const(MO_8, val)) { 3266 vece = MO_8; 3267 } else if (val == dup_const(MO_16, val)) { 3268 vece = MO_16; 3269 } else if (val == dup_const(MO_32, val)) { 3270 vece = MO_32; 3271 } 3272 3273 tcg_out_dupi_vec(s, ts->type, vece, reg, ts->val); 3274 } 3275 ts->mem_coherent = 0; 3276 break; 3277 case TEMP_VAL_MEM: 3278 reg = tcg_reg_alloc(s, desired_regs, allocated_regs, 3279 preferred_regs, ts->indirect_base); 3280 tcg_out_ld(s, ts->type, reg, ts->mem_base->reg, ts->mem_offset); 3281 ts->mem_coherent = 1; 3282 break; 3283 case TEMP_VAL_DEAD: 3284 default: 3285 tcg_abort(); 3286 } 3287 ts->reg = reg; 3288 ts->val_type = TEMP_VAL_REG; 3289 s->reg_to_temp[reg] = ts; 3290 } 3291 3292 /* Save a temporary to memory. 'allocated_regs' is used in case a 3293 temporary registers needs to be allocated to store a constant. */ 3294 static void temp_save(TCGContext *s, TCGTemp *ts, TCGRegSet allocated_regs) 3295 { 3296 /* The liveness analysis already ensures that globals are back 3297 in memory. Keep an tcg_debug_assert for safety. */ 3298 tcg_debug_assert(ts->val_type == TEMP_VAL_MEM || temp_readonly(ts)); 3299 } 3300 3301 /* save globals to their canonical location and assume they can be 3302 modified be the following code. 'allocated_regs' is used in case a 3303 temporary registers needs to be allocated to store a constant. */ 3304 static void save_globals(TCGContext *s, TCGRegSet allocated_regs) 3305 { 3306 int i, n; 3307 3308 for (i = 0, n = s->nb_globals; i < n; i++) { 3309 temp_save(s, &s->temps[i], allocated_regs); 3310 } 3311 } 3312 3313 /* sync globals to their canonical location and assume they can be 3314 read by the following code. 'allocated_regs' is used in case a 3315 temporary registers needs to be allocated to store a constant. */ 3316 static void sync_globals(TCGContext *s, TCGRegSet allocated_regs) 3317 { 3318 int i, n; 3319 3320 for (i = 0, n = s->nb_globals; i < n; i++) { 3321 TCGTemp *ts = &s->temps[i]; 3322 tcg_debug_assert(ts->val_type != TEMP_VAL_REG 3323 || ts->kind == TEMP_FIXED 3324 || ts->mem_coherent); 3325 } 3326 } 3327 3328 /* at the end of a basic block, we assume all temporaries are dead and 3329 all globals are stored at their canonical location. */ 3330 static void tcg_reg_alloc_bb_end(TCGContext *s, TCGRegSet allocated_regs) 3331 { 3332 int i; 3333 3334 for (i = s->nb_globals; i < s->nb_temps; i++) { 3335 TCGTemp *ts = &s->temps[i]; 3336 3337 switch (ts->kind) { 3338 case TEMP_LOCAL: 3339 temp_save(s, ts, allocated_regs); 3340 break; 3341 case TEMP_NORMAL: 3342 /* The liveness analysis already ensures that temps are dead. 3343 Keep an tcg_debug_assert for safety. */ 3344 tcg_debug_assert(ts->val_type == TEMP_VAL_DEAD); 3345 break; 3346 case TEMP_CONST: 3347 /* Similarly, we should have freed any allocated register. */ 3348 tcg_debug_assert(ts->val_type == TEMP_VAL_CONST); 3349 break; 3350 default: 3351 g_assert_not_reached(); 3352 } 3353 } 3354 3355 save_globals(s, allocated_regs); 3356 } 3357 3358 /* 3359 * At a conditional branch, we assume all temporaries are dead and 3360 * all globals and local temps are synced to their location. 3361 */ 3362 static void tcg_reg_alloc_cbranch(TCGContext *s, TCGRegSet allocated_regs) 3363 { 3364 sync_globals(s, allocated_regs); 3365 3366 for (int i = s->nb_globals; i < s->nb_temps; i++) { 3367 TCGTemp *ts = &s->temps[i]; 3368 /* 3369 * The liveness analysis already ensures that temps are dead. 3370 * Keep tcg_debug_asserts for safety. 3371 */ 3372 switch (ts->kind) { 3373 case TEMP_LOCAL: 3374 tcg_debug_assert(ts->val_type != TEMP_VAL_REG || ts->mem_coherent); 3375 break; 3376 case TEMP_NORMAL: 3377 tcg_debug_assert(ts->val_type == TEMP_VAL_DEAD); 3378 break; 3379 case TEMP_CONST: 3380 break; 3381 default: 3382 g_assert_not_reached(); 3383 } 3384 } 3385 } 3386 3387 /* 3388 * Specialized code generation for INDEX_op_mov_* with a constant. 3389 */ 3390 static void tcg_reg_alloc_do_movi(TCGContext *s, TCGTemp *ots, 3391 tcg_target_ulong val, TCGLifeData arg_life, 3392 TCGRegSet preferred_regs) 3393 { 3394 /* ENV should not be modified. */ 3395 tcg_debug_assert(!temp_readonly(ots)); 3396 3397 /* The movi is not explicitly generated here. */ 3398 if (ots->val_type == TEMP_VAL_REG) { 3399 s->reg_to_temp[ots->reg] = NULL; 3400 } 3401 ots->val_type = TEMP_VAL_CONST; 3402 ots->val = val; 3403 ots->mem_coherent = 0; 3404 if (NEED_SYNC_ARG(0)) { 3405 temp_sync(s, ots, s->reserved_regs, preferred_regs, IS_DEAD_ARG(0)); 3406 } else if (IS_DEAD_ARG(0)) { 3407 temp_dead(s, ots); 3408 } 3409 } 3410 3411 /* 3412 * Specialized code generation for INDEX_op_mov_*. 3413 */ 3414 static void tcg_reg_alloc_mov(TCGContext *s, const TCGOp *op) 3415 { 3416 const TCGLifeData arg_life = op->life; 3417 TCGRegSet allocated_regs, preferred_regs; 3418 TCGTemp *ts, *ots; 3419 TCGType otype, itype; 3420 3421 allocated_regs = s->reserved_regs; 3422 preferred_regs = op->output_pref[0]; 3423 ots = arg_temp(op->args[0]); 3424 ts = arg_temp(op->args[1]); 3425 3426 /* ENV should not be modified. */ 3427 tcg_debug_assert(!temp_readonly(ots)); 3428 3429 /* Note that otype != itype for no-op truncation. */ 3430 otype = ots->type; 3431 itype = ts->type; 3432 3433 if (ts->val_type == TEMP_VAL_CONST) { 3434 /* propagate constant or generate sti */ 3435 tcg_target_ulong val = ts->val; 3436 if (IS_DEAD_ARG(1)) { 3437 temp_dead(s, ts); 3438 } 3439 tcg_reg_alloc_do_movi(s, ots, val, arg_life, preferred_regs); 3440 return; 3441 } 3442 3443 /* If the source value is in memory we're going to be forced 3444 to have it in a register in order to perform the copy. Copy 3445 the SOURCE value into its own register first, that way we 3446 don't have to reload SOURCE the next time it is used. */ 3447 if (ts->val_type == TEMP_VAL_MEM) { 3448 temp_load(s, ts, tcg_target_available_regs[itype], 3449 allocated_regs, preferred_regs); 3450 } 3451 3452 tcg_debug_assert(ts->val_type == TEMP_VAL_REG); 3453 if (IS_DEAD_ARG(0)) { 3454 /* mov to a non-saved dead register makes no sense (even with 3455 liveness analysis disabled). */ 3456 tcg_debug_assert(NEED_SYNC_ARG(0)); 3457 if (!ots->mem_allocated) { 3458 temp_allocate_frame(s, ots); 3459 } 3460 tcg_out_st(s, otype, ts->reg, ots->mem_base->reg, ots->mem_offset); 3461 if (IS_DEAD_ARG(1)) { 3462 temp_dead(s, ts); 3463 } 3464 temp_dead(s, ots); 3465 } else { 3466 if (IS_DEAD_ARG(1) && ts->kind != TEMP_FIXED) { 3467 /* the mov can be suppressed */ 3468 if (ots->val_type == TEMP_VAL_REG) { 3469 s->reg_to_temp[ots->reg] = NULL; 3470 } 3471 ots->reg = ts->reg; 3472 temp_dead(s, ts); 3473 } else { 3474 if (ots->val_type != TEMP_VAL_REG) { 3475 /* When allocating a new register, make sure to not spill the 3476 input one. */ 3477 tcg_regset_set_reg(allocated_regs, ts->reg); 3478 ots->reg = tcg_reg_alloc(s, tcg_target_available_regs[otype], 3479 allocated_regs, preferred_regs, 3480 ots->indirect_base); 3481 } 3482 if (!tcg_out_mov(s, otype, ots->reg, ts->reg)) { 3483 /* 3484 * Cross register class move not supported. 3485 * Store the source register into the destination slot 3486 * and leave the destination temp as TEMP_VAL_MEM. 3487 */ 3488 assert(!temp_readonly(ots)); 3489 if (!ts->mem_allocated) { 3490 temp_allocate_frame(s, ots); 3491 } 3492 tcg_out_st(s, ts->type, ts->reg, 3493 ots->mem_base->reg, ots->mem_offset); 3494 ots->mem_coherent = 1; 3495 temp_free_or_dead(s, ots, -1); 3496 return; 3497 } 3498 } 3499 ots->val_type = TEMP_VAL_REG; 3500 ots->mem_coherent = 0; 3501 s->reg_to_temp[ots->reg] = ots; 3502 if (NEED_SYNC_ARG(0)) { 3503 temp_sync(s, ots, allocated_regs, 0, 0); 3504 } 3505 } 3506 } 3507 3508 /* 3509 * Specialized code generation for INDEX_op_dup_vec. 3510 */ 3511 static void tcg_reg_alloc_dup(TCGContext *s, const TCGOp *op) 3512 { 3513 const TCGLifeData arg_life = op->life; 3514 TCGRegSet dup_out_regs, dup_in_regs; 3515 TCGTemp *its, *ots; 3516 TCGType itype, vtype; 3517 intptr_t endian_fixup; 3518 unsigned vece; 3519 bool ok; 3520 3521 ots = arg_temp(op->args[0]); 3522 its = arg_temp(op->args[1]); 3523 3524 /* ENV should not be modified. */ 3525 tcg_debug_assert(!temp_readonly(ots)); 3526 3527 itype = its->type; 3528 vece = TCGOP_VECE(op); 3529 vtype = TCGOP_VECL(op) + TCG_TYPE_V64; 3530 3531 if (its->val_type == TEMP_VAL_CONST) { 3532 /* Propagate constant via movi -> dupi. */ 3533 tcg_target_ulong val = its->val; 3534 if (IS_DEAD_ARG(1)) { 3535 temp_dead(s, its); 3536 } 3537 tcg_reg_alloc_do_movi(s, ots, val, arg_life, op->output_pref[0]); 3538 return; 3539 } 3540 3541 dup_out_regs = tcg_op_defs[INDEX_op_dup_vec].args_ct[0].regs; 3542 dup_in_regs = tcg_op_defs[INDEX_op_dup_vec].args_ct[1].regs; 3543 3544 /* Allocate the output register now. */ 3545 if (ots->val_type != TEMP_VAL_REG) { 3546 TCGRegSet allocated_regs = s->reserved_regs; 3547 3548 if (!IS_DEAD_ARG(1) && its->val_type == TEMP_VAL_REG) { 3549 /* Make sure to not spill the input register. */ 3550 tcg_regset_set_reg(allocated_regs, its->reg); 3551 } 3552 ots->reg = tcg_reg_alloc(s, dup_out_regs, allocated_regs, 3553 op->output_pref[0], ots->indirect_base); 3554 ots->val_type = TEMP_VAL_REG; 3555 ots->mem_coherent = 0; 3556 s->reg_to_temp[ots->reg] = ots; 3557 } 3558 3559 switch (its->val_type) { 3560 case TEMP_VAL_REG: 3561 /* 3562 * The dup constriaints must be broad, covering all possible VECE. 3563 * However, tcg_op_dup_vec() gets to see the VECE and we allow it 3564 * to fail, indicating that extra moves are required for that case. 3565 */ 3566 if (tcg_regset_test_reg(dup_in_regs, its->reg)) { 3567 if (tcg_out_dup_vec(s, vtype, vece, ots->reg, its->reg)) { 3568 goto done; 3569 } 3570 /* Try again from memory or a vector input register. */ 3571 } 3572 if (!its->mem_coherent) { 3573 /* 3574 * The input register is not synced, and so an extra store 3575 * would be required to use memory. Attempt an integer-vector 3576 * register move first. We do not have a TCGRegSet for this. 3577 */ 3578 if (tcg_out_mov(s, itype, ots->reg, its->reg)) { 3579 break; 3580 } 3581 /* Sync the temp back to its slot and load from there. */ 3582 temp_sync(s, its, s->reserved_regs, 0, 0); 3583 } 3584 /* fall through */ 3585 3586 case TEMP_VAL_MEM: 3587 #ifdef HOST_WORDS_BIGENDIAN 3588 endian_fixup = itype == TCG_TYPE_I32 ? 4 : 8; 3589 endian_fixup -= 1 << vece; 3590 #else 3591 endian_fixup = 0; 3592 #endif 3593 if (tcg_out_dupm_vec(s, vtype, vece, ots->reg, its->mem_base->reg, 3594 its->mem_offset + endian_fixup)) { 3595 goto done; 3596 } 3597 tcg_out_ld(s, itype, ots->reg, its->mem_base->reg, its->mem_offset); 3598 break; 3599 3600 default: 3601 g_assert_not_reached(); 3602 } 3603 3604 /* We now have a vector input register, so dup must succeed. */ 3605 ok = tcg_out_dup_vec(s, vtype, vece, ots->reg, ots->reg); 3606 tcg_debug_assert(ok); 3607 3608 done: 3609 if (IS_DEAD_ARG(1)) { 3610 temp_dead(s, its); 3611 } 3612 if (NEED_SYNC_ARG(0)) { 3613 temp_sync(s, ots, s->reserved_regs, 0, 0); 3614 } 3615 if (IS_DEAD_ARG(0)) { 3616 temp_dead(s, ots); 3617 } 3618 } 3619 3620 static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op) 3621 { 3622 const TCGLifeData arg_life = op->life; 3623 const TCGOpDef * const def = &tcg_op_defs[op->opc]; 3624 TCGRegSet i_allocated_regs; 3625 TCGRegSet o_allocated_regs; 3626 int i, k, nb_iargs, nb_oargs; 3627 TCGReg reg; 3628 TCGArg arg; 3629 const TCGArgConstraint *arg_ct; 3630 TCGTemp *ts; 3631 TCGArg new_args[TCG_MAX_OP_ARGS]; 3632 int const_args[TCG_MAX_OP_ARGS]; 3633 3634 nb_oargs = def->nb_oargs; 3635 nb_iargs = def->nb_iargs; 3636 3637 /* copy constants */ 3638 memcpy(new_args + nb_oargs + nb_iargs, 3639 op->args + nb_oargs + nb_iargs, 3640 sizeof(TCGArg) * def->nb_cargs); 3641 3642 i_allocated_regs = s->reserved_regs; 3643 o_allocated_regs = s->reserved_regs; 3644 3645 /* satisfy input constraints */ 3646 for (k = 0; k < nb_iargs; k++) { 3647 TCGRegSet i_preferred_regs, o_preferred_regs; 3648 3649 i = def->args_ct[nb_oargs + k].sort_index; 3650 arg = op->args[i]; 3651 arg_ct = &def->args_ct[i]; 3652 ts = arg_temp(arg); 3653 3654 if (ts->val_type == TEMP_VAL_CONST 3655 && tcg_target_const_match(ts->val, ts->type, arg_ct->ct)) { 3656 /* constant is OK for instruction */ 3657 const_args[i] = 1; 3658 new_args[i] = ts->val; 3659 continue; 3660 } 3661 3662 i_preferred_regs = o_preferred_regs = 0; 3663 if (arg_ct->ialias) { 3664 o_preferred_regs = op->output_pref[arg_ct->alias_index]; 3665 3666 /* 3667 * If the input is readonly, then it cannot also be an 3668 * output and aliased to itself. If the input is not 3669 * dead after the instruction, we must allocate a new 3670 * register and move it. 3671 */ 3672 if (temp_readonly(ts) || !IS_DEAD_ARG(i)) { 3673 goto allocate_in_reg; 3674 } 3675 3676 /* 3677 * Check if the current register has already been allocated 3678 * for another input aliased to an output. 3679 */ 3680 if (ts->val_type == TEMP_VAL_REG) { 3681 reg = ts->reg; 3682 for (int k2 = 0; k2 < k; k2++) { 3683 int i2 = def->args_ct[nb_oargs + k2].sort_index; 3684 if (def->args_ct[i2].ialias && reg == new_args[i2]) { 3685 goto allocate_in_reg; 3686 } 3687 } 3688 } 3689 i_preferred_regs = o_preferred_regs; 3690 } 3691 3692 temp_load(s, ts, arg_ct->regs, i_allocated_regs, i_preferred_regs); 3693 reg = ts->reg; 3694 3695 if (!tcg_regset_test_reg(arg_ct->regs, reg)) { 3696 allocate_in_reg: 3697 /* 3698 * Allocate a new register matching the constraint 3699 * and move the temporary register into it. 3700 */ 3701 temp_load(s, ts, tcg_target_available_regs[ts->type], 3702 i_allocated_regs, 0); 3703 reg = tcg_reg_alloc(s, arg_ct->regs, i_allocated_regs, 3704 o_preferred_regs, ts->indirect_base); 3705 if (!tcg_out_mov(s, ts->type, reg, ts->reg)) { 3706 /* 3707 * Cross register class move not supported. Sync the 3708 * temp back to its slot and load from there. 3709 */ 3710 temp_sync(s, ts, i_allocated_regs, 0, 0); 3711 tcg_out_ld(s, ts->type, reg, 3712 ts->mem_base->reg, ts->mem_offset); 3713 } 3714 } 3715 new_args[i] = reg; 3716 const_args[i] = 0; 3717 tcg_regset_set_reg(i_allocated_regs, reg); 3718 } 3719 3720 /* mark dead temporaries and free the associated registers */ 3721 for (i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 3722 if (IS_DEAD_ARG(i)) { 3723 temp_dead(s, arg_temp(op->args[i])); 3724 } 3725 } 3726 3727 if (def->flags & TCG_OPF_COND_BRANCH) { 3728 tcg_reg_alloc_cbranch(s, i_allocated_regs); 3729 } else if (def->flags & TCG_OPF_BB_END) { 3730 tcg_reg_alloc_bb_end(s, i_allocated_regs); 3731 } else { 3732 if (def->flags & TCG_OPF_CALL_CLOBBER) { 3733 /* XXX: permit generic clobber register list ? */ 3734 for (i = 0; i < TCG_TARGET_NB_REGS; i++) { 3735 if (tcg_regset_test_reg(tcg_target_call_clobber_regs, i)) { 3736 tcg_reg_free(s, i, i_allocated_regs); 3737 } 3738 } 3739 } 3740 if (def->flags & TCG_OPF_SIDE_EFFECTS) { 3741 /* sync globals if the op has side effects and might trigger 3742 an exception. */ 3743 sync_globals(s, i_allocated_regs); 3744 } 3745 3746 /* satisfy the output constraints */ 3747 for(k = 0; k < nb_oargs; k++) { 3748 i = def->args_ct[k].sort_index; 3749 arg = op->args[i]; 3750 arg_ct = &def->args_ct[i]; 3751 ts = arg_temp(arg); 3752 3753 /* ENV should not be modified. */ 3754 tcg_debug_assert(!temp_readonly(ts)); 3755 3756 if (arg_ct->oalias && !const_args[arg_ct->alias_index]) { 3757 reg = new_args[arg_ct->alias_index]; 3758 } else if (arg_ct->newreg) { 3759 reg = tcg_reg_alloc(s, arg_ct->regs, 3760 i_allocated_regs | o_allocated_regs, 3761 op->output_pref[k], ts->indirect_base); 3762 } else { 3763 reg = tcg_reg_alloc(s, arg_ct->regs, o_allocated_regs, 3764 op->output_pref[k], ts->indirect_base); 3765 } 3766 tcg_regset_set_reg(o_allocated_regs, reg); 3767 if (ts->val_type == TEMP_VAL_REG) { 3768 s->reg_to_temp[ts->reg] = NULL; 3769 } 3770 ts->val_type = TEMP_VAL_REG; 3771 ts->reg = reg; 3772 /* 3773 * Temp value is modified, so the value kept in memory is 3774 * potentially not the same. 3775 */ 3776 ts->mem_coherent = 0; 3777 s->reg_to_temp[reg] = ts; 3778 new_args[i] = reg; 3779 } 3780 } 3781 3782 /* emit instruction */ 3783 if (def->flags & TCG_OPF_VECTOR) { 3784 tcg_out_vec_op(s, op->opc, TCGOP_VECL(op), TCGOP_VECE(op), 3785 new_args, const_args); 3786 } else { 3787 tcg_out_op(s, op->opc, new_args, const_args); 3788 } 3789 3790 /* move the outputs in the correct register if needed */ 3791 for(i = 0; i < nb_oargs; i++) { 3792 ts = arg_temp(op->args[i]); 3793 3794 /* ENV should not be modified. */ 3795 tcg_debug_assert(!temp_readonly(ts)); 3796 3797 if (NEED_SYNC_ARG(i)) { 3798 temp_sync(s, ts, o_allocated_regs, 0, IS_DEAD_ARG(i)); 3799 } else if (IS_DEAD_ARG(i)) { 3800 temp_dead(s, ts); 3801 } 3802 } 3803 } 3804 3805 static bool tcg_reg_alloc_dup2(TCGContext *s, const TCGOp *op) 3806 { 3807 const TCGLifeData arg_life = op->life; 3808 TCGTemp *ots, *itsl, *itsh; 3809 TCGType vtype = TCGOP_VECL(op) + TCG_TYPE_V64; 3810 3811 /* This opcode is only valid for 32-bit hosts, for 64-bit elements. */ 3812 tcg_debug_assert(TCG_TARGET_REG_BITS == 32); 3813 tcg_debug_assert(TCGOP_VECE(op) == MO_64); 3814 3815 ots = arg_temp(op->args[0]); 3816 itsl = arg_temp(op->args[1]); 3817 itsh = arg_temp(op->args[2]); 3818 3819 /* ENV should not be modified. */ 3820 tcg_debug_assert(!temp_readonly(ots)); 3821 3822 /* Allocate the output register now. */ 3823 if (ots->val_type != TEMP_VAL_REG) { 3824 TCGRegSet allocated_regs = s->reserved_regs; 3825 TCGRegSet dup_out_regs = 3826 tcg_op_defs[INDEX_op_dup_vec].args_ct[0].regs; 3827 3828 /* Make sure to not spill the input registers. */ 3829 if (!IS_DEAD_ARG(1) && itsl->val_type == TEMP_VAL_REG) { 3830 tcg_regset_set_reg(allocated_regs, itsl->reg); 3831 } 3832 if (!IS_DEAD_ARG(2) && itsh->val_type == TEMP_VAL_REG) { 3833 tcg_regset_set_reg(allocated_regs, itsh->reg); 3834 } 3835 3836 ots->reg = tcg_reg_alloc(s, dup_out_regs, allocated_regs, 3837 op->output_pref[0], ots->indirect_base); 3838 ots->val_type = TEMP_VAL_REG; 3839 ots->mem_coherent = 0; 3840 s->reg_to_temp[ots->reg] = ots; 3841 } 3842 3843 /* Promote dup2 of immediates to dupi_vec. */ 3844 if (itsl->val_type == TEMP_VAL_CONST && itsh->val_type == TEMP_VAL_CONST) { 3845 uint64_t val = deposit64(itsl->val, 32, 32, itsh->val); 3846 MemOp vece = MO_64; 3847 3848 if (val == dup_const(MO_8, val)) { 3849 vece = MO_8; 3850 } else if (val == dup_const(MO_16, val)) { 3851 vece = MO_16; 3852 } else if (val == dup_const(MO_32, val)) { 3853 vece = MO_32; 3854 } 3855 3856 tcg_out_dupi_vec(s, vtype, vece, ots->reg, val); 3857 goto done; 3858 } 3859 3860 /* If the two inputs form one 64-bit value, try dupm_vec. */ 3861 if (itsl + 1 == itsh && itsl->base_type == TCG_TYPE_I64) { 3862 if (!itsl->mem_coherent) { 3863 temp_sync(s, itsl, s->reserved_regs, 0, 0); 3864 } 3865 if (!itsh->mem_coherent) { 3866 temp_sync(s, itsh, s->reserved_regs, 0, 0); 3867 } 3868 #ifdef HOST_WORDS_BIGENDIAN 3869 TCGTemp *its = itsh; 3870 #else 3871 TCGTemp *its = itsl; 3872 #endif 3873 if (tcg_out_dupm_vec(s, vtype, MO_64, ots->reg, 3874 its->mem_base->reg, its->mem_offset)) { 3875 goto done; 3876 } 3877 } 3878 3879 /* Fall back to generic expansion. */ 3880 return false; 3881 3882 done: 3883 if (IS_DEAD_ARG(1)) { 3884 temp_dead(s, itsl); 3885 } 3886 if (IS_DEAD_ARG(2)) { 3887 temp_dead(s, itsh); 3888 } 3889 if (NEED_SYNC_ARG(0)) { 3890 temp_sync(s, ots, s->reserved_regs, 0, IS_DEAD_ARG(0)); 3891 } else if (IS_DEAD_ARG(0)) { 3892 temp_dead(s, ots); 3893 } 3894 return true; 3895 } 3896 3897 #ifdef TCG_TARGET_STACK_GROWSUP 3898 #define STACK_DIR(x) (-(x)) 3899 #else 3900 #define STACK_DIR(x) (x) 3901 #endif 3902 3903 static void tcg_reg_alloc_call(TCGContext *s, TCGOp *op) 3904 { 3905 const int nb_oargs = TCGOP_CALLO(op); 3906 const int nb_iargs = TCGOP_CALLI(op); 3907 const TCGLifeData arg_life = op->life; 3908 const TCGHelperInfo *info; 3909 int flags, nb_regs, i; 3910 TCGReg reg; 3911 TCGArg arg; 3912 TCGTemp *ts; 3913 intptr_t stack_offset; 3914 size_t call_stack_size; 3915 tcg_insn_unit *func_addr; 3916 int allocate_args; 3917 TCGRegSet allocated_regs; 3918 3919 func_addr = tcg_call_func(op); 3920 info = tcg_call_info(op); 3921 flags = info->flags; 3922 3923 nb_regs = ARRAY_SIZE(tcg_target_call_iarg_regs); 3924 if (nb_regs > nb_iargs) { 3925 nb_regs = nb_iargs; 3926 } 3927 3928 /* assign stack slots first */ 3929 call_stack_size = (nb_iargs - nb_regs) * sizeof(tcg_target_long); 3930 call_stack_size = (call_stack_size + TCG_TARGET_STACK_ALIGN - 1) & 3931 ~(TCG_TARGET_STACK_ALIGN - 1); 3932 allocate_args = (call_stack_size > TCG_STATIC_CALL_ARGS_SIZE); 3933 if (allocate_args) { 3934 /* XXX: if more than TCG_STATIC_CALL_ARGS_SIZE is needed, 3935 preallocate call stack */ 3936 tcg_abort(); 3937 } 3938 3939 stack_offset = TCG_TARGET_CALL_STACK_OFFSET; 3940 for (i = nb_regs; i < nb_iargs; i++) { 3941 arg = op->args[nb_oargs + i]; 3942 #ifdef TCG_TARGET_STACK_GROWSUP 3943 stack_offset -= sizeof(tcg_target_long); 3944 #endif 3945 if (arg != TCG_CALL_DUMMY_ARG) { 3946 ts = arg_temp(arg); 3947 temp_load(s, ts, tcg_target_available_regs[ts->type], 3948 s->reserved_regs, 0); 3949 tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset); 3950 } 3951 #ifndef TCG_TARGET_STACK_GROWSUP 3952 stack_offset += sizeof(tcg_target_long); 3953 #endif 3954 } 3955 3956 /* assign input registers */ 3957 allocated_regs = s->reserved_regs; 3958 for (i = 0; i < nb_regs; i++) { 3959 arg = op->args[nb_oargs + i]; 3960 if (arg != TCG_CALL_DUMMY_ARG) { 3961 ts = arg_temp(arg); 3962 reg = tcg_target_call_iarg_regs[i]; 3963 3964 if (ts->val_type == TEMP_VAL_REG) { 3965 if (ts->reg != reg) { 3966 tcg_reg_free(s, reg, allocated_regs); 3967 if (!tcg_out_mov(s, ts->type, reg, ts->reg)) { 3968 /* 3969 * Cross register class move not supported. Sync the 3970 * temp back to its slot and load from there. 3971 */ 3972 temp_sync(s, ts, allocated_regs, 0, 0); 3973 tcg_out_ld(s, ts->type, reg, 3974 ts->mem_base->reg, ts->mem_offset); 3975 } 3976 } 3977 } else { 3978 TCGRegSet arg_set = 0; 3979 3980 tcg_reg_free(s, reg, allocated_regs); 3981 tcg_regset_set_reg(arg_set, reg); 3982 temp_load(s, ts, arg_set, allocated_regs, 0); 3983 } 3984 3985 tcg_regset_set_reg(allocated_regs, reg); 3986 } 3987 } 3988 3989 /* mark dead temporaries and free the associated registers */ 3990 for (i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 3991 if (IS_DEAD_ARG(i)) { 3992 temp_dead(s, arg_temp(op->args[i])); 3993 } 3994 } 3995 3996 /* clobber call registers */ 3997 for (i = 0; i < TCG_TARGET_NB_REGS; i++) { 3998 if (tcg_regset_test_reg(tcg_target_call_clobber_regs, i)) { 3999 tcg_reg_free(s, i, allocated_regs); 4000 } 4001 } 4002 4003 /* Save globals if they might be written by the helper, sync them if 4004 they might be read. */ 4005 if (flags & TCG_CALL_NO_READ_GLOBALS) { 4006 /* Nothing to do */ 4007 } else if (flags & TCG_CALL_NO_WRITE_GLOBALS) { 4008 sync_globals(s, allocated_regs); 4009 } else { 4010 save_globals(s, allocated_regs); 4011 } 4012 4013 #ifdef CONFIG_TCG_INTERPRETER 4014 { 4015 gpointer hash = (gpointer)(uintptr_t)info->typemask; 4016 ffi_cif *cif = g_hash_table_lookup(ffi_table, hash); 4017 assert(cif != NULL); 4018 tcg_out_call(s, func_addr, cif); 4019 } 4020 #else 4021 tcg_out_call(s, func_addr); 4022 #endif 4023 4024 /* assign output registers and emit moves if needed */ 4025 for(i = 0; i < nb_oargs; i++) { 4026 arg = op->args[i]; 4027 ts = arg_temp(arg); 4028 4029 /* ENV should not be modified. */ 4030 tcg_debug_assert(!temp_readonly(ts)); 4031 4032 reg = tcg_target_call_oarg_regs[i]; 4033 tcg_debug_assert(s->reg_to_temp[reg] == NULL); 4034 if (ts->val_type == TEMP_VAL_REG) { 4035 s->reg_to_temp[ts->reg] = NULL; 4036 } 4037 ts->val_type = TEMP_VAL_REG; 4038 ts->reg = reg; 4039 ts->mem_coherent = 0; 4040 s->reg_to_temp[reg] = ts; 4041 if (NEED_SYNC_ARG(i)) { 4042 temp_sync(s, ts, allocated_regs, 0, IS_DEAD_ARG(i)); 4043 } else if (IS_DEAD_ARG(i)) { 4044 temp_dead(s, ts); 4045 } 4046 } 4047 } 4048 4049 #ifdef CONFIG_PROFILER 4050 4051 /* avoid copy/paste errors */ 4052 #define PROF_ADD(to, from, field) \ 4053 do { \ 4054 (to)->field += qatomic_read(&((from)->field)); \ 4055 } while (0) 4056 4057 #define PROF_MAX(to, from, field) \ 4058 do { \ 4059 typeof((from)->field) val__ = qatomic_read(&((from)->field)); \ 4060 if (val__ > (to)->field) { \ 4061 (to)->field = val__; \ 4062 } \ 4063 } while (0) 4064 4065 /* Pass in a zero'ed @prof */ 4066 static inline 4067 void tcg_profile_snapshot(TCGProfile *prof, bool counters, bool table) 4068 { 4069 unsigned int n_ctxs = qatomic_read(&tcg_cur_ctxs); 4070 unsigned int i; 4071 4072 for (i = 0; i < n_ctxs; i++) { 4073 TCGContext *s = qatomic_read(&tcg_ctxs[i]); 4074 const TCGProfile *orig = &s->prof; 4075 4076 if (counters) { 4077 PROF_ADD(prof, orig, cpu_exec_time); 4078 PROF_ADD(prof, orig, tb_count1); 4079 PROF_ADD(prof, orig, tb_count); 4080 PROF_ADD(prof, orig, op_count); 4081 PROF_MAX(prof, orig, op_count_max); 4082 PROF_ADD(prof, orig, temp_count); 4083 PROF_MAX(prof, orig, temp_count_max); 4084 PROF_ADD(prof, orig, del_op_count); 4085 PROF_ADD(prof, orig, code_in_len); 4086 PROF_ADD(prof, orig, code_out_len); 4087 PROF_ADD(prof, orig, search_out_len); 4088 PROF_ADD(prof, orig, interm_time); 4089 PROF_ADD(prof, orig, code_time); 4090 PROF_ADD(prof, orig, la_time); 4091 PROF_ADD(prof, orig, opt_time); 4092 PROF_ADD(prof, orig, restore_count); 4093 PROF_ADD(prof, orig, restore_time); 4094 } 4095 if (table) { 4096 int i; 4097 4098 for (i = 0; i < NB_OPS; i++) { 4099 PROF_ADD(prof, orig, table_op_count[i]); 4100 } 4101 } 4102 } 4103 } 4104 4105 #undef PROF_ADD 4106 #undef PROF_MAX 4107 4108 static void tcg_profile_snapshot_counters(TCGProfile *prof) 4109 { 4110 tcg_profile_snapshot(prof, true, false); 4111 } 4112 4113 static void tcg_profile_snapshot_table(TCGProfile *prof) 4114 { 4115 tcg_profile_snapshot(prof, false, true); 4116 } 4117 4118 void tcg_dump_op_count(void) 4119 { 4120 TCGProfile prof = {}; 4121 int i; 4122 4123 tcg_profile_snapshot_table(&prof); 4124 for (i = 0; i < NB_OPS; i++) { 4125 qemu_printf("%s %" PRId64 "\n", tcg_op_defs[i].name, 4126 prof.table_op_count[i]); 4127 } 4128 } 4129 4130 int64_t tcg_cpu_exec_time(void) 4131 { 4132 unsigned int n_ctxs = qatomic_read(&tcg_cur_ctxs); 4133 unsigned int i; 4134 int64_t ret = 0; 4135 4136 for (i = 0; i < n_ctxs; i++) { 4137 const TCGContext *s = qatomic_read(&tcg_ctxs[i]); 4138 const TCGProfile *prof = &s->prof; 4139 4140 ret += qatomic_read(&prof->cpu_exec_time); 4141 } 4142 return ret; 4143 } 4144 #else 4145 void tcg_dump_op_count(void) 4146 { 4147 qemu_printf("[TCG profiler not compiled]\n"); 4148 } 4149 4150 int64_t tcg_cpu_exec_time(void) 4151 { 4152 error_report("%s: TCG profiler not compiled", __func__); 4153 exit(EXIT_FAILURE); 4154 } 4155 #endif 4156 4157 4158 int tcg_gen_code(TCGContext *s, TranslationBlock *tb) 4159 { 4160 #ifdef CONFIG_PROFILER 4161 TCGProfile *prof = &s->prof; 4162 #endif 4163 int i, num_insns; 4164 TCGOp *op; 4165 4166 #ifdef CONFIG_PROFILER 4167 { 4168 int n = 0; 4169 4170 QTAILQ_FOREACH(op, &s->ops, link) { 4171 n++; 4172 } 4173 qatomic_set(&prof->op_count, prof->op_count + n); 4174 if (n > prof->op_count_max) { 4175 qatomic_set(&prof->op_count_max, n); 4176 } 4177 4178 n = s->nb_temps; 4179 qatomic_set(&prof->temp_count, prof->temp_count + n); 4180 if (n > prof->temp_count_max) { 4181 qatomic_set(&prof->temp_count_max, n); 4182 } 4183 } 4184 #endif 4185 4186 #ifdef DEBUG_DISAS 4187 if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP) 4188 && qemu_log_in_addr_range(tb->pc))) { 4189 FILE *logfile = qemu_log_lock(); 4190 qemu_log("OP:\n"); 4191 tcg_dump_ops(s, false); 4192 qemu_log("\n"); 4193 qemu_log_unlock(logfile); 4194 } 4195 #endif 4196 4197 #ifdef CONFIG_DEBUG_TCG 4198 /* Ensure all labels referenced have been emitted. */ 4199 { 4200 TCGLabel *l; 4201 bool error = false; 4202 4203 QSIMPLEQ_FOREACH(l, &s->labels, next) { 4204 if (unlikely(!l->present) && l->refs) { 4205 qemu_log_mask(CPU_LOG_TB_OP, 4206 "$L%d referenced but not present.\n", l->id); 4207 error = true; 4208 } 4209 } 4210 assert(!error); 4211 } 4212 #endif 4213 4214 #ifdef CONFIG_PROFILER 4215 qatomic_set(&prof->opt_time, prof->opt_time - profile_getclock()); 4216 #endif 4217 4218 #ifdef USE_TCG_OPTIMIZATIONS 4219 tcg_optimize(s); 4220 #endif 4221 4222 #ifdef CONFIG_PROFILER 4223 qatomic_set(&prof->opt_time, prof->opt_time + profile_getclock()); 4224 qatomic_set(&prof->la_time, prof->la_time - profile_getclock()); 4225 #endif 4226 4227 reachable_code_pass(s); 4228 liveness_pass_1(s); 4229 4230 if (s->nb_indirects > 0) { 4231 #ifdef DEBUG_DISAS 4232 if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_IND) 4233 && qemu_log_in_addr_range(tb->pc))) { 4234 FILE *logfile = qemu_log_lock(); 4235 qemu_log("OP before indirect lowering:\n"); 4236 tcg_dump_ops(s, false); 4237 qemu_log("\n"); 4238 qemu_log_unlock(logfile); 4239 } 4240 #endif 4241 /* Replace indirect temps with direct temps. */ 4242 if (liveness_pass_2(s)) { 4243 /* If changes were made, re-run liveness. */ 4244 liveness_pass_1(s); 4245 } 4246 } 4247 4248 #ifdef CONFIG_PROFILER 4249 qatomic_set(&prof->la_time, prof->la_time + profile_getclock()); 4250 #endif 4251 4252 #ifdef DEBUG_DISAS 4253 if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT) 4254 && qemu_log_in_addr_range(tb->pc))) { 4255 FILE *logfile = qemu_log_lock(); 4256 qemu_log("OP after optimization and liveness analysis:\n"); 4257 tcg_dump_ops(s, true); 4258 qemu_log("\n"); 4259 qemu_log_unlock(logfile); 4260 } 4261 #endif 4262 4263 tcg_reg_alloc_start(s); 4264 4265 /* 4266 * Reset the buffer pointers when restarting after overflow. 4267 * TODO: Move this into translate-all.c with the rest of the 4268 * buffer management. Having only this done here is confusing. 4269 */ 4270 s->code_buf = tcg_splitwx_to_rw(tb->tc.ptr); 4271 s->code_ptr = s->code_buf; 4272 4273 #ifdef TCG_TARGET_NEED_LDST_LABELS 4274 QSIMPLEQ_INIT(&s->ldst_labels); 4275 #endif 4276 #ifdef TCG_TARGET_NEED_POOL_LABELS 4277 s->pool_labels = NULL; 4278 #endif 4279 4280 num_insns = -1; 4281 QTAILQ_FOREACH(op, &s->ops, link) { 4282 TCGOpcode opc = op->opc; 4283 4284 #ifdef CONFIG_PROFILER 4285 qatomic_set(&prof->table_op_count[opc], prof->table_op_count[opc] + 1); 4286 #endif 4287 4288 switch (opc) { 4289 case INDEX_op_mov_i32: 4290 case INDEX_op_mov_i64: 4291 case INDEX_op_mov_vec: 4292 tcg_reg_alloc_mov(s, op); 4293 break; 4294 case INDEX_op_dup_vec: 4295 tcg_reg_alloc_dup(s, op); 4296 break; 4297 case INDEX_op_insn_start: 4298 if (num_insns >= 0) { 4299 size_t off = tcg_current_code_size(s); 4300 s->gen_insn_end_off[num_insns] = off; 4301 /* Assert that we do not overflow our stored offset. */ 4302 assert(s->gen_insn_end_off[num_insns] == off); 4303 } 4304 num_insns++; 4305 for (i = 0; i < TARGET_INSN_START_WORDS; ++i) { 4306 target_ulong a; 4307 #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS 4308 a = deposit64(op->args[i * 2], 32, 32, op->args[i * 2 + 1]); 4309 #else 4310 a = op->args[i]; 4311 #endif 4312 s->gen_insn_data[num_insns][i] = a; 4313 } 4314 break; 4315 case INDEX_op_discard: 4316 temp_dead(s, arg_temp(op->args[0])); 4317 break; 4318 case INDEX_op_set_label: 4319 tcg_reg_alloc_bb_end(s, s->reserved_regs); 4320 tcg_out_label(s, arg_label(op->args[0])); 4321 break; 4322 case INDEX_op_call: 4323 tcg_reg_alloc_call(s, op); 4324 break; 4325 case INDEX_op_dup2_vec: 4326 if (tcg_reg_alloc_dup2(s, op)) { 4327 break; 4328 } 4329 /* fall through */ 4330 default: 4331 /* Sanity check that we've not introduced any unhandled opcodes. */ 4332 tcg_debug_assert(tcg_op_supported(opc)); 4333 /* Note: in order to speed up the code, it would be much 4334 faster to have specialized register allocator functions for 4335 some common argument patterns */ 4336 tcg_reg_alloc_op(s, op); 4337 break; 4338 } 4339 #ifdef CONFIG_DEBUG_TCG 4340 check_regs(s); 4341 #endif 4342 /* Test for (pending) buffer overflow. The assumption is that any 4343 one operation beginning below the high water mark cannot overrun 4344 the buffer completely. Thus we can test for overflow after 4345 generating code without having to check during generation. */ 4346 if (unlikely((void *)s->code_ptr > s->code_gen_highwater)) { 4347 return -1; 4348 } 4349 /* Test for TB overflow, as seen by gen_insn_end_off. */ 4350 if (unlikely(tcg_current_code_size(s) > UINT16_MAX)) { 4351 return -2; 4352 } 4353 } 4354 tcg_debug_assert(num_insns >= 0); 4355 s->gen_insn_end_off[num_insns] = tcg_current_code_size(s); 4356 4357 /* Generate TB finalization at the end of block */ 4358 #ifdef TCG_TARGET_NEED_LDST_LABELS 4359 i = tcg_out_ldst_finalize(s); 4360 if (i < 0) { 4361 return i; 4362 } 4363 #endif 4364 #ifdef TCG_TARGET_NEED_POOL_LABELS 4365 i = tcg_out_pool_finalize(s); 4366 if (i < 0) { 4367 return i; 4368 } 4369 #endif 4370 if (!tcg_resolve_relocs(s)) { 4371 return -2; 4372 } 4373 4374 #ifndef CONFIG_TCG_INTERPRETER 4375 /* flush instruction cache */ 4376 flush_idcache_range((uintptr_t)tcg_splitwx_to_rx(s->code_buf), 4377 (uintptr_t)s->code_buf, 4378 tcg_ptr_byte_diff(s->code_ptr, s->code_buf)); 4379 #endif 4380 4381 return tcg_current_code_size(s); 4382 } 4383 4384 #ifdef CONFIG_PROFILER 4385 void tcg_dump_info(void) 4386 { 4387 TCGProfile prof = {}; 4388 const TCGProfile *s; 4389 int64_t tb_count; 4390 int64_t tb_div_count; 4391 int64_t tot; 4392 4393 tcg_profile_snapshot_counters(&prof); 4394 s = &prof; 4395 tb_count = s->tb_count; 4396 tb_div_count = tb_count ? tb_count : 1; 4397 tot = s->interm_time + s->code_time; 4398 4399 qemu_printf("JIT cycles %" PRId64 " (%0.3f s at 2.4 GHz)\n", 4400 tot, tot / 2.4e9); 4401 qemu_printf("translated TBs %" PRId64 " (aborted=%" PRId64 4402 " %0.1f%%)\n", 4403 tb_count, s->tb_count1 - tb_count, 4404 (double)(s->tb_count1 - s->tb_count) 4405 / (s->tb_count1 ? s->tb_count1 : 1) * 100.0); 4406 qemu_printf("avg ops/TB %0.1f max=%d\n", 4407 (double)s->op_count / tb_div_count, s->op_count_max); 4408 qemu_printf("deleted ops/TB %0.2f\n", 4409 (double)s->del_op_count / tb_div_count); 4410 qemu_printf("avg temps/TB %0.2f max=%d\n", 4411 (double)s->temp_count / tb_div_count, s->temp_count_max); 4412 qemu_printf("avg host code/TB %0.1f\n", 4413 (double)s->code_out_len / tb_div_count); 4414 qemu_printf("avg search data/TB %0.1f\n", 4415 (double)s->search_out_len / tb_div_count); 4416 4417 qemu_printf("cycles/op %0.1f\n", 4418 s->op_count ? (double)tot / s->op_count : 0); 4419 qemu_printf("cycles/in byte %0.1f\n", 4420 s->code_in_len ? (double)tot / s->code_in_len : 0); 4421 qemu_printf("cycles/out byte %0.1f\n", 4422 s->code_out_len ? (double)tot / s->code_out_len : 0); 4423 qemu_printf("cycles/search byte %0.1f\n", 4424 s->search_out_len ? (double)tot / s->search_out_len : 0); 4425 if (tot == 0) { 4426 tot = 1; 4427 } 4428 qemu_printf(" gen_interm time %0.1f%%\n", 4429 (double)s->interm_time / tot * 100.0); 4430 qemu_printf(" gen_code time %0.1f%%\n", 4431 (double)s->code_time / tot * 100.0); 4432 qemu_printf("optim./code time %0.1f%%\n", 4433 (double)s->opt_time / (s->code_time ? s->code_time : 1) 4434 * 100.0); 4435 qemu_printf("liveness/code time %0.1f%%\n", 4436 (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0); 4437 qemu_printf("cpu_restore count %" PRId64 "\n", 4438 s->restore_count); 4439 qemu_printf(" avg cycles %0.1f\n", 4440 s->restore_count ? (double)s->restore_time / s->restore_count : 0); 4441 } 4442 #else 4443 void tcg_dump_info(void) 4444 { 4445 qemu_printf("[TCG profiler not compiled]\n"); 4446 } 4447 #endif 4448 4449 #ifdef ELF_HOST_MACHINE 4450 /* In order to use this feature, the backend needs to do three things: 4451 4452 (1) Define ELF_HOST_MACHINE to indicate both what value to 4453 put into the ELF image and to indicate support for the feature. 4454 4455 (2) Define tcg_register_jit. This should create a buffer containing 4456 the contents of a .debug_frame section that describes the post- 4457 prologue unwind info for the tcg machine. 4458 4459 (3) Call tcg_register_jit_int, with the constructed .debug_frame. 4460 */ 4461 4462 /* Begin GDB interface. THE FOLLOWING MUST MATCH GDB DOCS. */ 4463 typedef enum { 4464 JIT_NOACTION = 0, 4465 JIT_REGISTER_FN, 4466 JIT_UNREGISTER_FN 4467 } jit_actions_t; 4468 4469 struct jit_code_entry { 4470 struct jit_code_entry *next_entry; 4471 struct jit_code_entry *prev_entry; 4472 const void *symfile_addr; 4473 uint64_t symfile_size; 4474 }; 4475 4476 struct jit_descriptor { 4477 uint32_t version; 4478 uint32_t action_flag; 4479 struct jit_code_entry *relevant_entry; 4480 struct jit_code_entry *first_entry; 4481 }; 4482 4483 void __jit_debug_register_code(void) __attribute__((noinline)); 4484 void __jit_debug_register_code(void) 4485 { 4486 asm(""); 4487 } 4488 4489 /* Must statically initialize the version, because GDB may check 4490 the version before we can set it. */ 4491 struct jit_descriptor __jit_debug_descriptor = { 1, 0, 0, 0 }; 4492 4493 /* End GDB interface. */ 4494 4495 static int find_string(const char *strtab, const char *str) 4496 { 4497 const char *p = strtab + 1; 4498 4499 while (1) { 4500 if (strcmp(p, str) == 0) { 4501 return p - strtab; 4502 } 4503 p += strlen(p) + 1; 4504 } 4505 } 4506 4507 static void tcg_register_jit_int(const void *buf_ptr, size_t buf_size, 4508 const void *debug_frame, 4509 size_t debug_frame_size) 4510 { 4511 struct __attribute__((packed)) DebugInfo { 4512 uint32_t len; 4513 uint16_t version; 4514 uint32_t abbrev; 4515 uint8_t ptr_size; 4516 uint8_t cu_die; 4517 uint16_t cu_lang; 4518 uintptr_t cu_low_pc; 4519 uintptr_t cu_high_pc; 4520 uint8_t fn_die; 4521 char fn_name[16]; 4522 uintptr_t fn_low_pc; 4523 uintptr_t fn_high_pc; 4524 uint8_t cu_eoc; 4525 }; 4526 4527 struct ElfImage { 4528 ElfW(Ehdr) ehdr; 4529 ElfW(Phdr) phdr; 4530 ElfW(Shdr) shdr[7]; 4531 ElfW(Sym) sym[2]; 4532 struct DebugInfo di; 4533 uint8_t da[24]; 4534 char str[80]; 4535 }; 4536 4537 struct ElfImage *img; 4538 4539 static const struct ElfImage img_template = { 4540 .ehdr = { 4541 .e_ident[EI_MAG0] = ELFMAG0, 4542 .e_ident[EI_MAG1] = ELFMAG1, 4543 .e_ident[EI_MAG2] = ELFMAG2, 4544 .e_ident[EI_MAG3] = ELFMAG3, 4545 .e_ident[EI_CLASS] = ELF_CLASS, 4546 .e_ident[EI_DATA] = ELF_DATA, 4547 .e_ident[EI_VERSION] = EV_CURRENT, 4548 .e_type = ET_EXEC, 4549 .e_machine = ELF_HOST_MACHINE, 4550 .e_version = EV_CURRENT, 4551 .e_phoff = offsetof(struct ElfImage, phdr), 4552 .e_shoff = offsetof(struct ElfImage, shdr), 4553 .e_ehsize = sizeof(ElfW(Shdr)), 4554 .e_phentsize = sizeof(ElfW(Phdr)), 4555 .e_phnum = 1, 4556 .e_shentsize = sizeof(ElfW(Shdr)), 4557 .e_shnum = ARRAY_SIZE(img->shdr), 4558 .e_shstrndx = ARRAY_SIZE(img->shdr) - 1, 4559 #ifdef ELF_HOST_FLAGS 4560 .e_flags = ELF_HOST_FLAGS, 4561 #endif 4562 #ifdef ELF_OSABI 4563 .e_ident[EI_OSABI] = ELF_OSABI, 4564 #endif 4565 }, 4566 .phdr = { 4567 .p_type = PT_LOAD, 4568 .p_flags = PF_X, 4569 }, 4570 .shdr = { 4571 [0] = { .sh_type = SHT_NULL }, 4572 /* Trick: The contents of code_gen_buffer are not present in 4573 this fake ELF file; that got allocated elsewhere. Therefore 4574 we mark .text as SHT_NOBITS (similar to .bss) so that readers 4575 will not look for contents. We can record any address. */ 4576 [1] = { /* .text */ 4577 .sh_type = SHT_NOBITS, 4578 .sh_flags = SHF_EXECINSTR | SHF_ALLOC, 4579 }, 4580 [2] = { /* .debug_info */ 4581 .sh_type = SHT_PROGBITS, 4582 .sh_offset = offsetof(struct ElfImage, di), 4583 .sh_size = sizeof(struct DebugInfo), 4584 }, 4585 [3] = { /* .debug_abbrev */ 4586 .sh_type = SHT_PROGBITS, 4587 .sh_offset = offsetof(struct ElfImage, da), 4588 .sh_size = sizeof(img->da), 4589 }, 4590 [4] = { /* .debug_frame */ 4591 .sh_type = SHT_PROGBITS, 4592 .sh_offset = sizeof(struct ElfImage), 4593 }, 4594 [5] = { /* .symtab */ 4595 .sh_type = SHT_SYMTAB, 4596 .sh_offset = offsetof(struct ElfImage, sym), 4597 .sh_size = sizeof(img->sym), 4598 .sh_info = 1, 4599 .sh_link = ARRAY_SIZE(img->shdr) - 1, 4600 .sh_entsize = sizeof(ElfW(Sym)), 4601 }, 4602 [6] = { /* .strtab */ 4603 .sh_type = SHT_STRTAB, 4604 .sh_offset = offsetof(struct ElfImage, str), 4605 .sh_size = sizeof(img->str), 4606 } 4607 }, 4608 .sym = { 4609 [1] = { /* code_gen_buffer */ 4610 .st_info = ELF_ST_INFO(STB_GLOBAL, STT_FUNC), 4611 .st_shndx = 1, 4612 } 4613 }, 4614 .di = { 4615 .len = sizeof(struct DebugInfo) - 4, 4616 .version = 2, 4617 .ptr_size = sizeof(void *), 4618 .cu_die = 1, 4619 .cu_lang = 0x8001, /* DW_LANG_Mips_Assembler */ 4620 .fn_die = 2, 4621 .fn_name = "code_gen_buffer" 4622 }, 4623 .da = { 4624 1, /* abbrev number (the cu) */ 4625 0x11, 1, /* DW_TAG_compile_unit, has children */ 4626 0x13, 0x5, /* DW_AT_language, DW_FORM_data2 */ 4627 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */ 4628 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */ 4629 0, 0, /* end of abbrev */ 4630 2, /* abbrev number (the fn) */ 4631 0x2e, 0, /* DW_TAG_subprogram, no children */ 4632 0x3, 0x8, /* DW_AT_name, DW_FORM_string */ 4633 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */ 4634 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */ 4635 0, 0, /* end of abbrev */ 4636 0 /* no more abbrev */ 4637 }, 4638 .str = "\0" ".text\0" ".debug_info\0" ".debug_abbrev\0" 4639 ".debug_frame\0" ".symtab\0" ".strtab\0" "code_gen_buffer", 4640 }; 4641 4642 /* We only need a single jit entry; statically allocate it. */ 4643 static struct jit_code_entry one_entry; 4644 4645 uintptr_t buf = (uintptr_t)buf_ptr; 4646 size_t img_size = sizeof(struct ElfImage) + debug_frame_size; 4647 DebugFrameHeader *dfh; 4648 4649 img = g_malloc(img_size); 4650 *img = img_template; 4651 4652 img->phdr.p_vaddr = buf; 4653 img->phdr.p_paddr = buf; 4654 img->phdr.p_memsz = buf_size; 4655 4656 img->shdr[1].sh_name = find_string(img->str, ".text"); 4657 img->shdr[1].sh_addr = buf; 4658 img->shdr[1].sh_size = buf_size; 4659 4660 img->shdr[2].sh_name = find_string(img->str, ".debug_info"); 4661 img->shdr[3].sh_name = find_string(img->str, ".debug_abbrev"); 4662 4663 img->shdr[4].sh_name = find_string(img->str, ".debug_frame"); 4664 img->shdr[4].sh_size = debug_frame_size; 4665 4666 img->shdr[5].sh_name = find_string(img->str, ".symtab"); 4667 img->shdr[6].sh_name = find_string(img->str, ".strtab"); 4668 4669 img->sym[1].st_name = find_string(img->str, "code_gen_buffer"); 4670 img->sym[1].st_value = buf; 4671 img->sym[1].st_size = buf_size; 4672 4673 img->di.cu_low_pc = buf; 4674 img->di.cu_high_pc = buf + buf_size; 4675 img->di.fn_low_pc = buf; 4676 img->di.fn_high_pc = buf + buf_size; 4677 4678 dfh = (DebugFrameHeader *)(img + 1); 4679 memcpy(dfh, debug_frame, debug_frame_size); 4680 dfh->fde.func_start = buf; 4681 dfh->fde.func_len = buf_size; 4682 4683 #ifdef DEBUG_JIT 4684 /* Enable this block to be able to debug the ELF image file creation. 4685 One can use readelf, objdump, or other inspection utilities. */ 4686 { 4687 FILE *f = fopen("/tmp/qemu.jit", "w+b"); 4688 if (f) { 4689 if (fwrite(img, img_size, 1, f) != img_size) { 4690 /* Avoid stupid unused return value warning for fwrite. */ 4691 } 4692 fclose(f); 4693 } 4694 } 4695 #endif 4696 4697 one_entry.symfile_addr = img; 4698 one_entry.symfile_size = img_size; 4699 4700 __jit_debug_descriptor.action_flag = JIT_REGISTER_FN; 4701 __jit_debug_descriptor.relevant_entry = &one_entry; 4702 __jit_debug_descriptor.first_entry = &one_entry; 4703 __jit_debug_register_code(); 4704 } 4705 #else 4706 /* No support for the feature. Provide the entry point expected by exec.c, 4707 and implement the internal function we declared earlier. */ 4708 4709 static void tcg_register_jit_int(const void *buf, size_t size, 4710 const void *debug_frame, 4711 size_t debug_frame_size) 4712 { 4713 } 4714 4715 void tcg_register_jit(const void *buf, size_t buf_size) 4716 { 4717 } 4718 #endif /* ELF_HOST_MACHINE */ 4719 4720 #if !TCG_TARGET_MAYBE_vec 4721 void tcg_expand_vec_op(TCGOpcode o, TCGType t, unsigned e, TCGArg a0, ...) 4722 { 4723 g_assert_not_reached(); 4724 } 4725 #endif 4726