1c896fe29Sbellard /* 2c896fe29Sbellard * Tiny Code Generator for QEMU 3c896fe29Sbellard * 4c896fe29Sbellard * Copyright (c) 2008 Fabrice Bellard 5c896fe29Sbellard * 6c896fe29Sbellard * Permission is hereby granted, free of charge, to any person obtaining a copy 7c896fe29Sbellard * of this software and associated documentation files (the "Software"), to deal 8c896fe29Sbellard * in the Software without restriction, including without limitation the rights 9c896fe29Sbellard * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10c896fe29Sbellard * copies of the Software, and to permit persons to whom the Software is 11c896fe29Sbellard * furnished to do so, subject to the following conditions: 12c896fe29Sbellard * 13c896fe29Sbellard * The above copyright notice and this permission notice shall be included in 14c896fe29Sbellard * all copies or substantial portions of the Software. 15c896fe29Sbellard * 16c896fe29Sbellard * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17c896fe29Sbellard * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18c896fe29Sbellard * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19c896fe29Sbellard * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20c896fe29Sbellard * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21c896fe29Sbellard * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22c896fe29Sbellard * THE SOFTWARE. 23c896fe29Sbellard */ 24c896fe29Sbellard 25c896fe29Sbellard /* define it to use liveness analysis (better code) */ 26c896fe29Sbellard #define USE_LIVENESS_ANALYSIS 278f2e8c07SKirill Batuzov #define USE_TCG_OPTIMIZATIONS 28c896fe29Sbellard 29cca82982Saurel32 #include "config.h" 30cca82982Saurel32 31813da627SRichard Henderson /* Define to jump the ELF file used to communicate with GDB. */ 32813da627SRichard Henderson #undef DEBUG_JIT 33813da627SRichard Henderson 34a6c6f76cSBlue Swirl #if !defined(CONFIG_DEBUG_TCG) && !defined(NDEBUG) 35cca82982Saurel32 /* define it to suppress various consistency checks (faster) */ 36cca82982Saurel32 #define NDEBUG 37cca82982Saurel32 #endif 38cca82982Saurel32 39ca10f867Saurel32 #include "qemu-common.h" 401de7afc9SPaolo Bonzini #include "qemu/cache-utils.h" 411de7afc9SPaolo Bonzini #include "qemu/host-utils.h" 421de7afc9SPaolo Bonzini #include "qemu/timer.h" 43c896fe29Sbellard 44c896fe29Sbellard /* Note: the long term plan is to reduce the dependancies on the QEMU 45c896fe29Sbellard CPU definitions. Currently they are used for qemu_ld/st 46c896fe29Sbellard instructions */ 47c896fe29Sbellard #define NO_CPU_IO_DEFS 48c896fe29Sbellard #include "cpu.h" 49c896fe29Sbellard 50c896fe29Sbellard #include "tcg-op.h" 51813da627SRichard Henderson 52edee2579SRichard Henderson #if UINTPTR_MAX == UINT32_MAX 53813da627SRichard Henderson # define ELF_CLASS ELFCLASS32 54edee2579SRichard Henderson #else 55edee2579SRichard Henderson # define ELF_CLASS ELFCLASS64 56813da627SRichard Henderson #endif 57813da627SRichard Henderson #ifdef HOST_WORDS_BIGENDIAN 58813da627SRichard Henderson # define ELF_DATA ELFDATA2MSB 59813da627SRichard Henderson #else 60813da627SRichard Henderson # define ELF_DATA ELFDATA2LSB 61813da627SRichard Henderson #endif 62813da627SRichard Henderson 63c896fe29Sbellard #include "elf.h" 64c896fe29Sbellard 65c0ad3001SStefan Weil /* Forward declarations for functions declared in tcg-target.c and used here. */ 66e4d58b41SRichard Henderson static void tcg_target_init(TCGContext *s); 67e4d58b41SRichard Henderson static void tcg_target_qemu_prologue(TCGContext *s); 68c896fe29Sbellard static void patch_reloc(uint8_t *code_ptr, int type, 692ba7fae2SRichard Henderson intptr_t value, intptr_t addend); 70c896fe29Sbellard 71497a22ebSRichard Henderson /* The CIE and FDE header definitions will be common to all hosts. */ 72497a22ebSRichard Henderson typedef struct { 73497a22ebSRichard Henderson uint32_t len __attribute__((aligned((sizeof(void *))))); 74497a22ebSRichard Henderson uint32_t id; 75497a22ebSRichard Henderson uint8_t version; 76497a22ebSRichard Henderson char augmentation[1]; 77497a22ebSRichard Henderson uint8_t code_align; 78497a22ebSRichard Henderson uint8_t data_align; 79497a22ebSRichard Henderson uint8_t return_column; 80497a22ebSRichard Henderson } DebugFrameCIE; 81497a22ebSRichard Henderson 82497a22ebSRichard Henderson typedef struct QEMU_PACKED { 83497a22ebSRichard Henderson uint32_t len __attribute__((aligned((sizeof(void *))))); 84497a22ebSRichard Henderson uint32_t cie_offset; 85edee2579SRichard Henderson uintptr_t func_start; 86edee2579SRichard Henderson uintptr_t func_len; 87497a22ebSRichard Henderson } DebugFrameFDEHeader; 88497a22ebSRichard Henderson 89813da627SRichard Henderson static void tcg_register_jit_int(void *buf, size_t size, 90813da627SRichard Henderson void *debug_frame, size_t debug_frame_size) 91813da627SRichard Henderson __attribute__((unused)); 92813da627SRichard Henderson 93c0ad3001SStefan Weil /* Forward declarations for functions declared and used in tcg-target.c. */ 94c0ad3001SStefan Weil static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str); 952a534affSRichard Henderson static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1, 96a05b5b9bSRichard Henderson intptr_t arg2); 972a534affSRichard Henderson static void tcg_out_mov(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg); 98c0ad3001SStefan Weil static void tcg_out_movi(TCGContext *s, TCGType type, 992a534affSRichard Henderson TCGReg ret, tcg_target_long arg); 100c0ad3001SStefan Weil static void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args, 101c0ad3001SStefan Weil const int *const_args); 1022a534affSRichard Henderson static void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1, 103a05b5b9bSRichard Henderson intptr_t arg2); 104c0ad3001SStefan Weil static int tcg_target_const_match(tcg_target_long val, 105c0ad3001SStefan Weil const TCGArgConstraint *arg_ct); 1069ecefc84SRichard Henderson static void tcg_out_tb_init(TCGContext *s); 1079ecefc84SRichard Henderson static void tcg_out_tb_finalize(TCGContext *s); 1089ecefc84SRichard Henderson 109c0ad3001SStefan Weil 1108399ad59SRichard Henderson TCGOpDef tcg_op_defs[] = { 1110e2029a0SAurelien Jarno #define DEF(s, oargs, iargs, cargs, flags) { #s, oargs, iargs, cargs, iargs + oargs + cargs, flags }, 112c896fe29Sbellard #include "tcg-opc.h" 113c896fe29Sbellard #undef DEF 114c896fe29Sbellard }; 1152a24374aSStefan Weil const size_t tcg_op_defs_max = ARRAY_SIZE(tcg_op_defs); 116c896fe29Sbellard 117b1d8e52eSblueswir1 static TCGRegSet tcg_target_available_regs[2]; 118b1d8e52eSblueswir1 static TCGRegSet tcg_target_call_clobber_regs; 119c896fe29Sbellard 120c896fe29Sbellard static inline void tcg_out8(TCGContext *s, uint8_t v) 121c896fe29Sbellard { 122c896fe29Sbellard *s->code_ptr++ = v; 123c896fe29Sbellard } 124c896fe29Sbellard 125c896fe29Sbellard static inline void tcg_out16(TCGContext *s, uint16_t v) 126c896fe29Sbellard { 1272bb8656dSRichard Henderson uint8_t *p = s->code_ptr; 1282bb8656dSRichard Henderson *(uint16_t *)p = v; 1292bb8656dSRichard Henderson s->code_ptr = p + 2; 130c896fe29Sbellard } 131c896fe29Sbellard 132c896fe29Sbellard static inline void tcg_out32(TCGContext *s, uint32_t v) 133c896fe29Sbellard { 1342bb8656dSRichard Henderson uint8_t *p = s->code_ptr; 1352bb8656dSRichard Henderson *(uint32_t *)p = v; 1362bb8656dSRichard Henderson s->code_ptr = p + 4; 137c896fe29Sbellard } 138c896fe29Sbellard 139ac26eb69SRichard Henderson static inline void tcg_out64(TCGContext *s, uint64_t v) 140ac26eb69SRichard Henderson { 141ac26eb69SRichard Henderson uint8_t *p = s->code_ptr; 142ac26eb69SRichard Henderson *(uint64_t *)p = v; 143ac26eb69SRichard Henderson s->code_ptr = p + 8; 144ac26eb69SRichard Henderson } 145ac26eb69SRichard Henderson 146c896fe29Sbellard /* label relocation processing */ 147c896fe29Sbellard 148a5ad5916SStefan Weil static void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type, 1492ba7fae2SRichard Henderson int label_index, intptr_t addend) 150c896fe29Sbellard { 151c896fe29Sbellard TCGLabel *l; 152c896fe29Sbellard TCGRelocation *r; 153c896fe29Sbellard 154c896fe29Sbellard l = &s->labels[label_index]; 155c896fe29Sbellard if (l->has_value) { 156623e265cSpbrook /* FIXME: This may break relocations on RISC targets that 157623e265cSpbrook modify instruction fields in place. The caller may not have 158623e265cSpbrook written the initial value. */ 159f54b3f92Saurel32 patch_reloc(code_ptr, type, l->u.value, addend); 160c896fe29Sbellard } else { 161c896fe29Sbellard /* add a new relocation entry */ 162c896fe29Sbellard r = tcg_malloc(sizeof(TCGRelocation)); 163c896fe29Sbellard r->type = type; 164c896fe29Sbellard r->ptr = code_ptr; 165c896fe29Sbellard r->addend = addend; 166c896fe29Sbellard r->next = l->u.first_reloc; 167c896fe29Sbellard l->u.first_reloc = r; 168c896fe29Sbellard } 169c896fe29Sbellard } 170c896fe29Sbellard 1719d6fca70SStefan Weil static void tcg_out_label(TCGContext *s, int label_index, void *ptr) 172c896fe29Sbellard { 173c896fe29Sbellard TCGLabel *l; 174c896fe29Sbellard TCGRelocation *r; 1752ba7fae2SRichard Henderson intptr_t value = (intptr_t)ptr; 176c896fe29Sbellard 177c896fe29Sbellard l = &s->labels[label_index]; 1782ba7fae2SRichard Henderson if (l->has_value) { 179c896fe29Sbellard tcg_abort(); 1802ba7fae2SRichard Henderson } 181c896fe29Sbellard r = l->u.first_reloc; 182c896fe29Sbellard while (r != NULL) { 183f54b3f92Saurel32 patch_reloc(r->ptr, r->type, value, r->addend); 184c896fe29Sbellard r = r->next; 185c896fe29Sbellard } 186c896fe29Sbellard l->has_value = 1; 187c896fe29Sbellard l->u.value = value; 188c896fe29Sbellard } 189c896fe29Sbellard 190c896fe29Sbellard int gen_new_label(void) 191c896fe29Sbellard { 192c896fe29Sbellard TCGContext *s = &tcg_ctx; 193c896fe29Sbellard int idx; 194c896fe29Sbellard TCGLabel *l; 195c896fe29Sbellard 196c896fe29Sbellard if (s->nb_labels >= TCG_MAX_LABELS) 197c896fe29Sbellard tcg_abort(); 198c896fe29Sbellard idx = s->nb_labels++; 199c896fe29Sbellard l = &s->labels[idx]; 200c896fe29Sbellard l->has_value = 0; 201c896fe29Sbellard l->u.first_reloc = NULL; 202c896fe29Sbellard return idx; 203c896fe29Sbellard } 204c896fe29Sbellard 205c896fe29Sbellard #include "tcg-target.c" 206c896fe29Sbellard 207c896fe29Sbellard /* pool based memory allocation */ 208c896fe29Sbellard void *tcg_malloc_internal(TCGContext *s, int size) 209c896fe29Sbellard { 210c896fe29Sbellard TCGPool *p; 211c896fe29Sbellard int pool_size; 212c896fe29Sbellard 213c896fe29Sbellard if (size > TCG_POOL_CHUNK_SIZE) { 214c896fe29Sbellard /* big malloc: insert a new pool (XXX: could optimize) */ 2157267c094SAnthony Liguori p = g_malloc(sizeof(TCGPool) + size); 216c896fe29Sbellard p->size = size; 2174055299eSKirill Batuzov p->next = s->pool_first_large; 2184055299eSKirill Batuzov s->pool_first_large = p; 2194055299eSKirill Batuzov return p->data; 220c896fe29Sbellard } else { 221c896fe29Sbellard p = s->pool_current; 222c896fe29Sbellard if (!p) { 223c896fe29Sbellard p = s->pool_first; 224c896fe29Sbellard if (!p) 225c896fe29Sbellard goto new_pool; 226c896fe29Sbellard } else { 227c896fe29Sbellard if (!p->next) { 228c896fe29Sbellard new_pool: 229c896fe29Sbellard pool_size = TCG_POOL_CHUNK_SIZE; 2307267c094SAnthony Liguori p = g_malloc(sizeof(TCGPool) + pool_size); 231c896fe29Sbellard p->size = pool_size; 232c896fe29Sbellard p->next = NULL; 233c896fe29Sbellard if (s->pool_current) 234c896fe29Sbellard s->pool_current->next = p; 235c896fe29Sbellard else 236c896fe29Sbellard s->pool_first = p; 237c896fe29Sbellard } else { 238c896fe29Sbellard p = p->next; 239c896fe29Sbellard } 240c896fe29Sbellard } 241c896fe29Sbellard } 242c896fe29Sbellard s->pool_current = p; 243c896fe29Sbellard s->pool_cur = p->data + size; 244c896fe29Sbellard s->pool_end = p->data + p->size; 245c896fe29Sbellard return p->data; 246c896fe29Sbellard } 247c896fe29Sbellard 248c896fe29Sbellard void tcg_pool_reset(TCGContext *s) 249c896fe29Sbellard { 2504055299eSKirill Batuzov TCGPool *p, *t; 2514055299eSKirill Batuzov for (p = s->pool_first_large; p; p = t) { 2524055299eSKirill Batuzov t = p->next; 2534055299eSKirill Batuzov g_free(p); 2544055299eSKirill Batuzov } 2554055299eSKirill Batuzov s->pool_first_large = NULL; 256c896fe29Sbellard s->pool_cur = s->pool_end = NULL; 257c896fe29Sbellard s->pool_current = NULL; 258c896fe29Sbellard } 259c896fe29Sbellard 2605cd8f621SRichard Henderson #include "helper.h" 2615cd8f621SRichard Henderson 262100b5e01SRichard Henderson typedef struct TCGHelperInfo { 263100b5e01SRichard Henderson void *func; 264100b5e01SRichard Henderson const char *name; 265100b5e01SRichard Henderson } TCGHelperInfo; 266100b5e01SRichard Henderson 267100b5e01SRichard Henderson static const TCGHelperInfo all_helpers[] = { 268100b5e01SRichard Henderson #define GEN_HELPER 2 269100b5e01SRichard Henderson #include "helper.h" 2704953ee62SRichard Henderson 2714953ee62SRichard Henderson /* Include tcg-runtime.c functions. */ 2724953ee62SRichard Henderson { tcg_helper_div_i32, "div_i32" }, 2734953ee62SRichard Henderson { tcg_helper_rem_i32, "rem_i32" }, 2744953ee62SRichard Henderson { tcg_helper_divu_i32, "divu_i32" }, 2754953ee62SRichard Henderson { tcg_helper_remu_i32, "remu_i32" }, 2764953ee62SRichard Henderson 2774953ee62SRichard Henderson { tcg_helper_shl_i64, "shl_i64" }, 2784953ee62SRichard Henderson { tcg_helper_shr_i64, "shr_i64" }, 2794953ee62SRichard Henderson { tcg_helper_sar_i64, "sar_i64" }, 2804953ee62SRichard Henderson { tcg_helper_div_i64, "div_i64" }, 2814953ee62SRichard Henderson { tcg_helper_rem_i64, "rem_i64" }, 2824953ee62SRichard Henderson { tcg_helper_divu_i64, "divu_i64" }, 2834953ee62SRichard Henderson { tcg_helper_remu_i64, "remu_i64" }, 2844953ee62SRichard Henderson { tcg_helper_mulsh_i64, "mulsh_i64" }, 2854953ee62SRichard Henderson { tcg_helper_muluh_i64, "muluh_i64" }, 286100b5e01SRichard Henderson }; 287100b5e01SRichard Henderson 288c896fe29Sbellard void tcg_context_init(TCGContext *s) 289c896fe29Sbellard { 290100b5e01SRichard Henderson int op, total_args, n, i; 291c896fe29Sbellard TCGOpDef *def; 292c896fe29Sbellard TCGArgConstraint *args_ct; 293c896fe29Sbellard int *sorted_args; 29484fd9dd3SRichard Henderson GHashTable *helper_table; 295c896fe29Sbellard 296c896fe29Sbellard memset(s, 0, sizeof(*s)); 297c896fe29Sbellard s->nb_globals = 0; 298c896fe29Sbellard 299c896fe29Sbellard /* Count total number of arguments and allocate the corresponding 300c896fe29Sbellard space */ 301c896fe29Sbellard total_args = 0; 302c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 303c896fe29Sbellard def = &tcg_op_defs[op]; 304c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 305c896fe29Sbellard total_args += n; 306c896fe29Sbellard } 307c896fe29Sbellard 3087267c094SAnthony Liguori args_ct = g_malloc(sizeof(TCGArgConstraint) * total_args); 3097267c094SAnthony Liguori sorted_args = g_malloc(sizeof(int) * total_args); 310c896fe29Sbellard 311c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 312c896fe29Sbellard def = &tcg_op_defs[op]; 313c896fe29Sbellard def->args_ct = args_ct; 314c896fe29Sbellard def->sorted_args = sorted_args; 315c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 316c896fe29Sbellard sorted_args += n; 317c896fe29Sbellard args_ct += n; 318c896fe29Sbellard } 319c896fe29Sbellard 3205cd8f621SRichard Henderson /* Register helpers. */ 32184fd9dd3SRichard Henderson /* Use g_direct_hash/equal for direct pointer comparisons on func. */ 32284fd9dd3SRichard Henderson s->helpers = helper_table = g_hash_table_new(NULL, NULL); 32384fd9dd3SRichard Henderson 324100b5e01SRichard Henderson for (i = 0; i < ARRAY_SIZE(all_helpers); ++i) { 32584fd9dd3SRichard Henderson g_hash_table_insert(helper_table, (gpointer)all_helpers[i].func, 32684fd9dd3SRichard Henderson (gpointer)all_helpers[i].name); 327100b5e01SRichard Henderson } 3285cd8f621SRichard Henderson 329c896fe29Sbellard tcg_target_init(s); 3309002ec79SRichard Henderson } 331b03cce8eSbellard 3329002ec79SRichard Henderson void tcg_prologue_init(TCGContext *s) 3339002ec79SRichard Henderson { 334b03cce8eSbellard /* init global prologue and epilogue */ 3350b0d3320SEvgeny Voevodin s->code_buf = s->code_gen_prologue; 336b03cce8eSbellard s->code_ptr = s->code_buf; 337b03cce8eSbellard tcg_target_qemu_prologue(s); 338b93949efSRichard Henderson flush_icache_range((uintptr_t)s->code_buf, (uintptr_t)s->code_ptr); 339d6b64b2bSRichard Henderson 340d6b64b2bSRichard Henderson #ifdef DEBUG_DISAS 341d6b64b2bSRichard Henderson if (qemu_loglevel_mask(CPU_LOG_TB_OUT_ASM)) { 342d6b64b2bSRichard Henderson size_t size = s->code_ptr - s->code_buf; 343d6b64b2bSRichard Henderson qemu_log("PROLOGUE: [size=%zu]\n", size); 344d6b64b2bSRichard Henderson log_disas(s->code_buf, size); 345d6b64b2bSRichard Henderson qemu_log("\n"); 346d6b64b2bSRichard Henderson qemu_log_flush(); 347d6b64b2bSRichard Henderson } 348d6b64b2bSRichard Henderson #endif 349c896fe29Sbellard } 350c896fe29Sbellard 351e2c6d1b4SRichard Henderson void tcg_set_frame(TCGContext *s, int reg, intptr_t start, intptr_t size) 352c896fe29Sbellard { 353c896fe29Sbellard s->frame_start = start; 354c896fe29Sbellard s->frame_end = start + size; 355c896fe29Sbellard s->frame_reg = reg; 356c896fe29Sbellard } 357c896fe29Sbellard 358c896fe29Sbellard void tcg_func_start(TCGContext *s) 359c896fe29Sbellard { 360c896fe29Sbellard tcg_pool_reset(s); 361c896fe29Sbellard s->nb_temps = s->nb_globals; 3620ec9eabcSRichard Henderson 3630ec9eabcSRichard Henderson /* No temps have been previously allocated for size or locality. */ 3640ec9eabcSRichard Henderson memset(s->free_temps, 0, sizeof(s->free_temps)); 3650ec9eabcSRichard Henderson 366c896fe29Sbellard s->labels = tcg_malloc(sizeof(TCGLabel) * TCG_MAX_LABELS); 367c896fe29Sbellard s->nb_labels = 0; 368c896fe29Sbellard s->current_frame_offset = s->frame_start; 369c896fe29Sbellard 3700a209d4bSRichard Henderson #ifdef CONFIG_DEBUG_TCG 3710a209d4bSRichard Henderson s->goto_tb_issue_mask = 0; 3720a209d4bSRichard Henderson #endif 3730a209d4bSRichard Henderson 37492414b31SEvgeny Voevodin s->gen_opc_ptr = s->gen_opc_buf; 3751ff0a2c5SEvgeny Voevodin s->gen_opparam_ptr = s->gen_opparam_buf; 376b76f0d8cSYeongkyoon Lee 3779ecefc84SRichard Henderson s->be = tcg_malloc(sizeof(TCGBackendData)); 378c896fe29Sbellard } 379c896fe29Sbellard 380c896fe29Sbellard static inline void tcg_temp_alloc(TCGContext *s, int n) 381c896fe29Sbellard { 382c896fe29Sbellard if (n > TCG_MAX_TEMPS) 383c896fe29Sbellard tcg_abort(); 384c896fe29Sbellard } 385c896fe29Sbellard 386a7812ae4Spbrook static inline int tcg_global_reg_new_internal(TCGType type, int reg, 387a7812ae4Spbrook const char *name) 388c896fe29Sbellard { 389c896fe29Sbellard TCGContext *s = &tcg_ctx; 390c896fe29Sbellard TCGTemp *ts; 391c896fe29Sbellard int idx; 392c896fe29Sbellard 393c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 394c896fe29Sbellard if (type != TCG_TYPE_I32) 395c896fe29Sbellard tcg_abort(); 396c896fe29Sbellard #endif 397c896fe29Sbellard if (tcg_regset_test_reg(s->reserved_regs, reg)) 398c896fe29Sbellard tcg_abort(); 399c896fe29Sbellard idx = s->nb_globals; 400c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 401c896fe29Sbellard ts = &s->temps[s->nb_globals]; 402c896fe29Sbellard ts->base_type = type; 403c896fe29Sbellard ts->type = type; 404c896fe29Sbellard ts->fixed_reg = 1; 405c896fe29Sbellard ts->reg = reg; 406c896fe29Sbellard ts->name = name; 407c896fe29Sbellard s->nb_globals++; 408c896fe29Sbellard tcg_regset_set_reg(s->reserved_regs, reg); 409a7812ae4Spbrook return idx; 410a7812ae4Spbrook } 411a7812ae4Spbrook 412a7812ae4Spbrook TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name) 413a7812ae4Spbrook { 414a7812ae4Spbrook int idx; 415a7812ae4Spbrook 416a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name); 417a7812ae4Spbrook return MAKE_TCGV_I32(idx); 418a7812ae4Spbrook } 419a7812ae4Spbrook 420a7812ae4Spbrook TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name) 421a7812ae4Spbrook { 422a7812ae4Spbrook int idx; 423a7812ae4Spbrook 424a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I64, reg, name); 425a7812ae4Spbrook return MAKE_TCGV_I64(idx); 426c896fe29Sbellard } 427c896fe29Sbellard 428a7812ae4Spbrook static inline int tcg_global_mem_new_internal(TCGType type, int reg, 4292f2f244dSRichard Henderson intptr_t offset, 430c896fe29Sbellard const char *name) 431c896fe29Sbellard { 432c896fe29Sbellard TCGContext *s = &tcg_ctx; 433c896fe29Sbellard TCGTemp *ts; 434c896fe29Sbellard int idx; 435c896fe29Sbellard 436c896fe29Sbellard idx = s->nb_globals; 437c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 438c896fe29Sbellard if (type == TCG_TYPE_I64) { 439c896fe29Sbellard char buf[64]; 440c588979bSths tcg_temp_alloc(s, s->nb_globals + 2); 441c896fe29Sbellard ts = &s->temps[s->nb_globals]; 442c896fe29Sbellard ts->base_type = type; 443c896fe29Sbellard ts->type = TCG_TYPE_I32; 444c896fe29Sbellard ts->fixed_reg = 0; 445c896fe29Sbellard ts->mem_allocated = 1; 446c896fe29Sbellard ts->mem_reg = reg; 447c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 448c896fe29Sbellard ts->mem_offset = offset + 4; 449c896fe29Sbellard #else 450c896fe29Sbellard ts->mem_offset = offset; 451c896fe29Sbellard #endif 452c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 453c896fe29Sbellard pstrcat(buf, sizeof(buf), "_0"); 454c896fe29Sbellard ts->name = strdup(buf); 455c896fe29Sbellard ts++; 456c896fe29Sbellard 457c896fe29Sbellard ts->base_type = type; 458c896fe29Sbellard ts->type = TCG_TYPE_I32; 459c896fe29Sbellard ts->fixed_reg = 0; 460c896fe29Sbellard ts->mem_allocated = 1; 461c896fe29Sbellard ts->mem_reg = reg; 462c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 463c896fe29Sbellard ts->mem_offset = offset; 464c896fe29Sbellard #else 465c896fe29Sbellard ts->mem_offset = offset + 4; 466c896fe29Sbellard #endif 467c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 468c896fe29Sbellard pstrcat(buf, sizeof(buf), "_1"); 469c896fe29Sbellard ts->name = strdup(buf); 470c896fe29Sbellard 471c896fe29Sbellard s->nb_globals += 2; 472c896fe29Sbellard } else 473c896fe29Sbellard #endif 474c896fe29Sbellard { 475c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 476c896fe29Sbellard ts = &s->temps[s->nb_globals]; 477c896fe29Sbellard ts->base_type = type; 478c896fe29Sbellard ts->type = type; 479c896fe29Sbellard ts->fixed_reg = 0; 480c896fe29Sbellard ts->mem_allocated = 1; 481c896fe29Sbellard ts->mem_reg = reg; 482c896fe29Sbellard ts->mem_offset = offset; 483c896fe29Sbellard ts->name = name; 484c896fe29Sbellard s->nb_globals++; 485c896fe29Sbellard } 486a7812ae4Spbrook return idx; 487c896fe29Sbellard } 488c896fe29Sbellard 4892f2f244dSRichard Henderson TCGv_i32 tcg_global_mem_new_i32(int reg, intptr_t offset, const char *name) 490a7812ae4Spbrook { 4912f2f244dSRichard Henderson int idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name); 492a7812ae4Spbrook return MAKE_TCGV_I32(idx); 493a7812ae4Spbrook } 494a7812ae4Spbrook 4952f2f244dSRichard Henderson TCGv_i64 tcg_global_mem_new_i64(int reg, intptr_t offset, const char *name) 496a7812ae4Spbrook { 4972f2f244dSRichard Henderson int idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name); 498a7812ae4Spbrook return MAKE_TCGV_I64(idx); 499a7812ae4Spbrook } 500a7812ae4Spbrook 501a7812ae4Spbrook static inline int tcg_temp_new_internal(TCGType type, int temp_local) 502c896fe29Sbellard { 503c896fe29Sbellard TCGContext *s = &tcg_ctx; 504c896fe29Sbellard TCGTemp *ts; 505641d5fbeSbellard int idx, k; 506c896fe29Sbellard 5070ec9eabcSRichard Henderson k = type + (temp_local ? TCG_TYPE_COUNT : 0); 5080ec9eabcSRichard Henderson idx = find_first_bit(s->free_temps[k].l, TCG_MAX_TEMPS); 5090ec9eabcSRichard Henderson if (idx < TCG_MAX_TEMPS) { 5100ec9eabcSRichard Henderson /* There is already an available temp with the right type. */ 5110ec9eabcSRichard Henderson clear_bit(idx, s->free_temps[k].l); 5120ec9eabcSRichard Henderson 513e8996ee0Sbellard ts = &s->temps[idx]; 514e8996ee0Sbellard ts->temp_allocated = 1; 5150ec9eabcSRichard Henderson assert(ts->base_type == type); 516641d5fbeSbellard assert(ts->temp_local == temp_local); 517e8996ee0Sbellard } else { 518c896fe29Sbellard idx = s->nb_temps; 519c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 520c896fe29Sbellard if (type == TCG_TYPE_I64) { 5218df1ca4bSths tcg_temp_alloc(s, s->nb_temps + 2); 522c896fe29Sbellard ts = &s->temps[s->nb_temps]; 523c896fe29Sbellard ts->base_type = type; 524c896fe29Sbellard ts->type = TCG_TYPE_I32; 525e8996ee0Sbellard ts->temp_allocated = 1; 526641d5fbeSbellard ts->temp_local = temp_local; 527c896fe29Sbellard ts->name = NULL; 528c896fe29Sbellard ts++; 529*f6aa2f7dSRichard Henderson ts->base_type = type; 530c896fe29Sbellard ts->type = TCG_TYPE_I32; 531e8996ee0Sbellard ts->temp_allocated = 1; 532641d5fbeSbellard ts->temp_local = temp_local; 533c896fe29Sbellard ts->name = NULL; 534c896fe29Sbellard s->nb_temps += 2; 535c896fe29Sbellard } else 536c896fe29Sbellard #endif 537c896fe29Sbellard { 538c896fe29Sbellard tcg_temp_alloc(s, s->nb_temps + 1); 539c896fe29Sbellard ts = &s->temps[s->nb_temps]; 540c896fe29Sbellard ts->base_type = type; 541c896fe29Sbellard ts->type = type; 542e8996ee0Sbellard ts->temp_allocated = 1; 543641d5fbeSbellard ts->temp_local = temp_local; 544c896fe29Sbellard ts->name = NULL; 545c896fe29Sbellard s->nb_temps++; 546c896fe29Sbellard } 547e8996ee0Sbellard } 54827bfd83cSPeter Maydell 54927bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 55027bfd83cSPeter Maydell s->temps_in_use++; 55127bfd83cSPeter Maydell #endif 552a7812ae4Spbrook return idx; 553c896fe29Sbellard } 554c896fe29Sbellard 555a7812ae4Spbrook TCGv_i32 tcg_temp_new_internal_i32(int temp_local) 556a7812ae4Spbrook { 557a7812ae4Spbrook int idx; 558a7812ae4Spbrook 559a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I32, temp_local); 560a7812ae4Spbrook return MAKE_TCGV_I32(idx); 561a7812ae4Spbrook } 562a7812ae4Spbrook 563a7812ae4Spbrook TCGv_i64 tcg_temp_new_internal_i64(int temp_local) 564a7812ae4Spbrook { 565a7812ae4Spbrook int idx; 566a7812ae4Spbrook 567a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I64, temp_local); 568a7812ae4Spbrook return MAKE_TCGV_I64(idx); 569a7812ae4Spbrook } 570a7812ae4Spbrook 5710ec9eabcSRichard Henderson static void tcg_temp_free_internal(int idx) 572c896fe29Sbellard { 573c896fe29Sbellard TCGContext *s = &tcg_ctx; 574c896fe29Sbellard TCGTemp *ts; 575641d5fbeSbellard int k; 576c896fe29Sbellard 57727bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 57827bfd83cSPeter Maydell s->temps_in_use--; 57927bfd83cSPeter Maydell if (s->temps_in_use < 0) { 58027bfd83cSPeter Maydell fprintf(stderr, "More temporaries freed than allocated!\n"); 58127bfd83cSPeter Maydell } 58227bfd83cSPeter Maydell #endif 58327bfd83cSPeter Maydell 584e8996ee0Sbellard assert(idx >= s->nb_globals && idx < s->nb_temps); 585c896fe29Sbellard ts = &s->temps[idx]; 586e8996ee0Sbellard assert(ts->temp_allocated != 0); 587e8996ee0Sbellard ts->temp_allocated = 0; 5880ec9eabcSRichard Henderson 58918d13fa2SAlexander Graf k = ts->base_type + (ts->temp_local ? TCG_TYPE_COUNT : 0); 5900ec9eabcSRichard Henderson set_bit(idx, s->free_temps[k].l); 591e8996ee0Sbellard } 592e8996ee0Sbellard 593a7812ae4Spbrook void tcg_temp_free_i32(TCGv_i32 arg) 594e8996ee0Sbellard { 595a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I32(arg)); 596a7812ae4Spbrook } 597a7812ae4Spbrook 598a7812ae4Spbrook void tcg_temp_free_i64(TCGv_i64 arg) 599a7812ae4Spbrook { 600a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I64(arg)); 601a7812ae4Spbrook } 602a7812ae4Spbrook 603a7812ae4Spbrook TCGv_i32 tcg_const_i32(int32_t val) 604a7812ae4Spbrook { 605a7812ae4Spbrook TCGv_i32 t0; 606a7812ae4Spbrook t0 = tcg_temp_new_i32(); 607e8996ee0Sbellard tcg_gen_movi_i32(t0, val); 608e8996ee0Sbellard return t0; 609c896fe29Sbellard } 610c896fe29Sbellard 611a7812ae4Spbrook TCGv_i64 tcg_const_i64(int64_t val) 612c896fe29Sbellard { 613a7812ae4Spbrook TCGv_i64 t0; 614a7812ae4Spbrook t0 = tcg_temp_new_i64(); 615e8996ee0Sbellard tcg_gen_movi_i64(t0, val); 616e8996ee0Sbellard return t0; 617c896fe29Sbellard } 618c896fe29Sbellard 619a7812ae4Spbrook TCGv_i32 tcg_const_local_i32(int32_t val) 620bdffd4a9Saurel32 { 621a7812ae4Spbrook TCGv_i32 t0; 622a7812ae4Spbrook t0 = tcg_temp_local_new_i32(); 623bdffd4a9Saurel32 tcg_gen_movi_i32(t0, val); 624bdffd4a9Saurel32 return t0; 625bdffd4a9Saurel32 } 626bdffd4a9Saurel32 627a7812ae4Spbrook TCGv_i64 tcg_const_local_i64(int64_t val) 628bdffd4a9Saurel32 { 629a7812ae4Spbrook TCGv_i64 t0; 630a7812ae4Spbrook t0 = tcg_temp_local_new_i64(); 631bdffd4a9Saurel32 tcg_gen_movi_i64(t0, val); 632bdffd4a9Saurel32 return t0; 633bdffd4a9Saurel32 } 634bdffd4a9Saurel32 63527bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 63627bfd83cSPeter Maydell void tcg_clear_temp_count(void) 63727bfd83cSPeter Maydell { 63827bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 63927bfd83cSPeter Maydell s->temps_in_use = 0; 64027bfd83cSPeter Maydell } 64127bfd83cSPeter Maydell 64227bfd83cSPeter Maydell int tcg_check_temp_count(void) 64327bfd83cSPeter Maydell { 64427bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 64527bfd83cSPeter Maydell if (s->temps_in_use) { 64627bfd83cSPeter Maydell /* Clear the count so that we don't give another 64727bfd83cSPeter Maydell * warning immediately next time around. 64827bfd83cSPeter Maydell */ 64927bfd83cSPeter Maydell s->temps_in_use = 0; 65027bfd83cSPeter Maydell return 1; 65127bfd83cSPeter Maydell } 65227bfd83cSPeter Maydell return 0; 65327bfd83cSPeter Maydell } 65427bfd83cSPeter Maydell #endif 65527bfd83cSPeter Maydell 65639cf05d3Sbellard /* Note: we convert the 64 bit args to 32 bit and do some alignment 65739cf05d3Sbellard and endian swap. Maybe it would be better to do the alignment 65839cf05d3Sbellard and endian swap in tcg_reg_alloc_call(). */ 659a7812ae4Spbrook void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags, 660a7812ae4Spbrook int sizemask, TCGArg ret, int nargs, TCGArg *args) 661c896fe29Sbellard { 662a7812ae4Spbrook int i; 663a7812ae4Spbrook int real_args; 664a7812ae4Spbrook int nb_rets; 665a7812ae4Spbrook TCGArg *nparam; 6662bece2c8SRichard Henderson 6672bece2c8SRichard Henderson #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 6682bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 6692bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 6702bece2c8SRichard Henderson int is_signed = sizemask & (2 << (i+1)*2); 6712bece2c8SRichard Henderson if (!is_64bit) { 6722bece2c8SRichard Henderson TCGv_i64 temp = tcg_temp_new_i64(); 6732bece2c8SRichard Henderson TCGv_i64 orig = MAKE_TCGV_I64(args[i]); 6742bece2c8SRichard Henderson if (is_signed) { 6752bece2c8SRichard Henderson tcg_gen_ext32s_i64(temp, orig); 6762bece2c8SRichard Henderson } else { 6772bece2c8SRichard Henderson tcg_gen_ext32u_i64(temp, orig); 6782bece2c8SRichard Henderson } 6792bece2c8SRichard Henderson args[i] = GET_TCGV_I64(temp); 6802bece2c8SRichard Henderson } 6812bece2c8SRichard Henderson } 6822bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 6832bece2c8SRichard Henderson 684efd7f486SEvgeny Voevodin *s->gen_opc_ptr++ = INDEX_op_call; 685c4afe5c4SEvgeny Voevodin nparam = s->gen_opparam_ptr++; 686a7812ae4Spbrook if (ret != TCG_CALL_DUMMY_ARG) { 687a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 688a7812ae4Spbrook if (sizemask & 1) { 689a7812ae4Spbrook #ifdef TCG_TARGET_WORDS_BIGENDIAN 690c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret + 1; 691c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret; 692a7812ae4Spbrook #else 693c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret; 694c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret + 1; 695a7812ae4Spbrook #endif 696a7812ae4Spbrook nb_rets = 2; 697a7812ae4Spbrook } else 698a7812ae4Spbrook #endif 699a7812ae4Spbrook { 700c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret; 701a7812ae4Spbrook nb_rets = 1; 702a7812ae4Spbrook } 703a7812ae4Spbrook } else { 704a7812ae4Spbrook nb_rets = 0; 705a7812ae4Spbrook } 706a7812ae4Spbrook real_args = 0; 707a7812ae4Spbrook for (i = 0; i < nargs; i++) { 708a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 7092bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 7102bece2c8SRichard Henderson if (is_64bit) { 71139cf05d3Sbellard #ifdef TCG_TARGET_CALL_ALIGN_ARGS 71239cf05d3Sbellard /* some targets want aligned 64 bit args */ 713ebd486d5Smalc if (real_args & 1) { 714c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = TCG_CALL_DUMMY_ARG; 715ebd486d5Smalc real_args++; 71639cf05d3Sbellard } 71739cf05d3Sbellard #endif 7183f90f252SRichard Henderson /* If stack grows up, then we will be placing successive 7193f90f252SRichard Henderson arguments at lower addresses, which means we need to 7203f90f252SRichard Henderson reverse the order compared to how we would normally 7213f90f252SRichard Henderson treat either big or little-endian. For those arguments 7223f90f252SRichard Henderson that will wind up in registers, this still works for 7233f90f252SRichard Henderson HPPA (the only current STACK_GROWSUP target) since the 7243f90f252SRichard Henderson argument registers are *also* allocated in decreasing 7253f90f252SRichard Henderson order. If another such target is added, this logic may 7263f90f252SRichard Henderson have to get more complicated to differentiate between 7273f90f252SRichard Henderson stack arguments and register arguments. */ 7283f90f252SRichard Henderson #if defined(TCG_TARGET_WORDS_BIGENDIAN) != defined(TCG_TARGET_STACK_GROWSUP) 729c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i] + 1; 730c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i]; 731c896fe29Sbellard #else 732c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i]; 733c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i] + 1; 734c896fe29Sbellard #endif 735a7812ae4Spbrook real_args += 2; 7362bece2c8SRichard Henderson continue; 7372bece2c8SRichard Henderson } 7382bece2c8SRichard Henderson #endif /* TCG_TARGET_REG_BITS < 64 */ 7392bece2c8SRichard Henderson 740c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i]; 741a7812ae4Spbrook real_args++; 742c896fe29Sbellard } 743c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = GET_TCGV_PTR(func); 744a7812ae4Spbrook 745c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = flags; 746a7812ae4Spbrook 747a7812ae4Spbrook *nparam = (nb_rets << 16) | (real_args + 1); 748a7812ae4Spbrook 749a7812ae4Spbrook /* total parameters, needed to go backward in the instruction stream */ 750c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = 1 + nb_rets + real_args + 3; 7512bece2c8SRichard Henderson 7522bece2c8SRichard Henderson #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 7532bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 7542bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 7552bece2c8SRichard Henderson if (!is_64bit) { 7562bece2c8SRichard Henderson TCGv_i64 temp = MAKE_TCGV_I64(args[i]); 7572bece2c8SRichard Henderson tcg_temp_free_i64(temp); 7582bece2c8SRichard Henderson } 7592bece2c8SRichard Henderson } 7602bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 761a7812ae4Spbrook } 762c896fe29Sbellard 763ac56dd48Spbrook #if TCG_TARGET_REG_BITS == 32 764a7812ae4Spbrook void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, 765c896fe29Sbellard int c, int right, int arith) 766c896fe29Sbellard { 767cf60bce4Sbellard if (c == 0) { 768a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1)); 769cf60bce4Sbellard tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1)); 770cf60bce4Sbellard } else if (c >= 32) { 771c896fe29Sbellard c -= 32; 772c896fe29Sbellard if (right) { 773c896fe29Sbellard if (arith) { 774a7812ae4Spbrook tcg_gen_sari_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 775ac56dd48Spbrook tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 31); 776c896fe29Sbellard } else { 777a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 778ac56dd48Spbrook tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 779c896fe29Sbellard } 780c896fe29Sbellard } else { 781a7812ae4Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_LOW(arg1), c); 782a7812ae4Spbrook tcg_gen_movi_i32(TCGV_LOW(ret), 0); 783c896fe29Sbellard } 784c896fe29Sbellard } else { 785a7812ae4Spbrook TCGv_i32 t0, t1; 786c896fe29Sbellard 787a7812ae4Spbrook t0 = tcg_temp_new_i32(); 788a7812ae4Spbrook t1 = tcg_temp_new_i32(); 789c896fe29Sbellard if (right) { 790ac56dd48Spbrook tcg_gen_shli_i32(t0, TCGV_HIGH(arg1), 32 - c); 791c896fe29Sbellard if (arith) 792ac56dd48Spbrook tcg_gen_sari_i32(t1, TCGV_HIGH(arg1), c); 793c896fe29Sbellard else 794ac56dd48Spbrook tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c); 795a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_LOW(arg1), c); 796a7812ae4Spbrook tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t0); 797ac56dd48Spbrook tcg_gen_mov_i32(TCGV_HIGH(ret), t1); 798c896fe29Sbellard } else { 799a7812ae4Spbrook tcg_gen_shri_i32(t0, TCGV_LOW(arg1), 32 - c); 800c896fe29Sbellard /* Note: ret can be the same as arg1, so we use t1 */ 801a7812ae4Spbrook tcg_gen_shli_i32(t1, TCGV_LOW(arg1), c); 802ac56dd48Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c); 803ac56dd48Spbrook tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0); 804a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), t1); 805c896fe29Sbellard } 806a7812ae4Spbrook tcg_temp_free_i32(t0); 807a7812ae4Spbrook tcg_temp_free_i32(t1); 808c896fe29Sbellard } 809c896fe29Sbellard } 810ac56dd48Spbrook #endif 811c896fe29Sbellard 812f713d6adSRichard Henderson static inline TCGMemOp tcg_canonicalize_memop(TCGMemOp op, bool is64, bool st) 813f713d6adSRichard Henderson { 814f713d6adSRichard Henderson switch (op & MO_SIZE) { 815f713d6adSRichard Henderson case MO_8: 816f713d6adSRichard Henderson op &= ~MO_BSWAP; 817f713d6adSRichard Henderson break; 818f713d6adSRichard Henderson case MO_16: 819f713d6adSRichard Henderson break; 820f713d6adSRichard Henderson case MO_32: 821f713d6adSRichard Henderson if (!is64) { 822f713d6adSRichard Henderson op &= ~MO_SIGN; 823f713d6adSRichard Henderson } 824f713d6adSRichard Henderson break; 825f713d6adSRichard Henderson case MO_64: 826f713d6adSRichard Henderson if (!is64) { 827f713d6adSRichard Henderson tcg_abort(); 828f713d6adSRichard Henderson } 829f713d6adSRichard Henderson break; 830f713d6adSRichard Henderson } 831f713d6adSRichard Henderson if (st) { 832f713d6adSRichard Henderson op &= ~MO_SIGN; 833f713d6adSRichard Henderson } 834f713d6adSRichard Henderson return op; 835f713d6adSRichard Henderson } 836f713d6adSRichard Henderson 837f713d6adSRichard Henderson static const TCGOpcode old_ld_opc[8] = { 838f713d6adSRichard Henderson [MO_UB] = INDEX_op_qemu_ld8u, 839f713d6adSRichard Henderson [MO_SB] = INDEX_op_qemu_ld8s, 840f713d6adSRichard Henderson [MO_UW] = INDEX_op_qemu_ld16u, 841f713d6adSRichard Henderson [MO_SW] = INDEX_op_qemu_ld16s, 842f713d6adSRichard Henderson #if TCG_TARGET_REG_BITS == 32 843f713d6adSRichard Henderson [MO_UL] = INDEX_op_qemu_ld32, 844f713d6adSRichard Henderson [MO_SL] = INDEX_op_qemu_ld32, 845f713d6adSRichard Henderson #else 846f713d6adSRichard Henderson [MO_UL] = INDEX_op_qemu_ld32u, 847f713d6adSRichard Henderson [MO_SL] = INDEX_op_qemu_ld32s, 848f713d6adSRichard Henderson #endif 849f713d6adSRichard Henderson [MO_Q] = INDEX_op_qemu_ld64, 850f713d6adSRichard Henderson }; 851f713d6adSRichard Henderson 852f713d6adSRichard Henderson static const TCGOpcode old_st_opc[4] = { 853f713d6adSRichard Henderson [MO_UB] = INDEX_op_qemu_st8, 854f713d6adSRichard Henderson [MO_UW] = INDEX_op_qemu_st16, 855f713d6adSRichard Henderson [MO_UL] = INDEX_op_qemu_st32, 856f713d6adSRichard Henderson [MO_Q] = INDEX_op_qemu_st64, 857f713d6adSRichard Henderson }; 858f713d6adSRichard Henderson 859f713d6adSRichard Henderson void tcg_gen_qemu_ld_i32(TCGv_i32 val, TCGv addr, TCGArg idx, TCGMemOp memop) 860f713d6adSRichard Henderson { 861f713d6adSRichard Henderson memop = tcg_canonicalize_memop(memop, 0, 0); 862f713d6adSRichard Henderson 863f713d6adSRichard Henderson if (TCG_TARGET_HAS_new_ldst) { 864f713d6adSRichard Henderson *tcg_ctx.gen_opc_ptr++ = INDEX_op_qemu_ld_i32; 865f713d6adSRichard Henderson tcg_add_param_i32(val); 866f713d6adSRichard Henderson tcg_add_param_tl(addr); 867f713d6adSRichard Henderson *tcg_ctx.gen_opparam_ptr++ = memop; 868f713d6adSRichard Henderson *tcg_ctx.gen_opparam_ptr++ = idx; 869f713d6adSRichard Henderson return; 870f713d6adSRichard Henderson } 871f713d6adSRichard Henderson 872f713d6adSRichard Henderson /* The old opcodes only support target-endian memory operations. */ 873f713d6adSRichard Henderson assert((memop & MO_BSWAP) == MO_TE || (memop & MO_SIZE) == MO_8); 874f713d6adSRichard Henderson assert(old_ld_opc[memop & MO_SSIZE] != 0); 875f713d6adSRichard Henderson 876f713d6adSRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 877f713d6adSRichard Henderson *tcg_ctx.gen_opc_ptr++ = old_ld_opc[memop & MO_SSIZE]; 878f713d6adSRichard Henderson tcg_add_param_i32(val); 879f713d6adSRichard Henderson tcg_add_param_tl(addr); 880f713d6adSRichard Henderson *tcg_ctx.gen_opparam_ptr++ = idx; 881f713d6adSRichard Henderson } else { 882f713d6adSRichard Henderson TCGv_i64 val64 = tcg_temp_new_i64(); 883f713d6adSRichard Henderson 884f713d6adSRichard Henderson *tcg_ctx.gen_opc_ptr++ = old_ld_opc[memop & MO_SSIZE]; 885f713d6adSRichard Henderson tcg_add_param_i64(val64); 886f713d6adSRichard Henderson tcg_add_param_tl(addr); 887f713d6adSRichard Henderson *tcg_ctx.gen_opparam_ptr++ = idx; 888f713d6adSRichard Henderson 889f713d6adSRichard Henderson tcg_gen_trunc_i64_i32(val, val64); 890f713d6adSRichard Henderson tcg_temp_free_i64(val64); 891f713d6adSRichard Henderson } 892f713d6adSRichard Henderson } 893f713d6adSRichard Henderson 894f713d6adSRichard Henderson void tcg_gen_qemu_st_i32(TCGv_i32 val, TCGv addr, TCGArg idx, TCGMemOp memop) 895f713d6adSRichard Henderson { 896f713d6adSRichard Henderson memop = tcg_canonicalize_memop(memop, 0, 1); 897f713d6adSRichard Henderson 898f713d6adSRichard Henderson if (TCG_TARGET_HAS_new_ldst) { 899f713d6adSRichard Henderson *tcg_ctx.gen_opc_ptr++ = INDEX_op_qemu_st_i32; 900f713d6adSRichard Henderson tcg_add_param_i32(val); 901f713d6adSRichard Henderson tcg_add_param_tl(addr); 902f713d6adSRichard Henderson *tcg_ctx.gen_opparam_ptr++ = memop; 903f713d6adSRichard Henderson *tcg_ctx.gen_opparam_ptr++ = idx; 904f713d6adSRichard Henderson return; 905f713d6adSRichard Henderson } 906f713d6adSRichard Henderson 907f713d6adSRichard Henderson /* The old opcodes only support target-endian memory operations. */ 908f713d6adSRichard Henderson assert((memop & MO_BSWAP) == MO_TE || (memop & MO_SIZE) == MO_8); 909f713d6adSRichard Henderson assert(old_st_opc[memop & MO_SIZE] != 0); 910f713d6adSRichard Henderson 911f713d6adSRichard Henderson if (TCG_TARGET_REG_BITS == 32) { 912f713d6adSRichard Henderson *tcg_ctx.gen_opc_ptr++ = old_st_opc[memop & MO_SIZE]; 913f713d6adSRichard Henderson tcg_add_param_i32(val); 914f713d6adSRichard Henderson tcg_add_param_tl(addr); 915f713d6adSRichard Henderson *tcg_ctx.gen_opparam_ptr++ = idx; 916f713d6adSRichard Henderson } else { 917f713d6adSRichard Henderson TCGv_i64 val64 = tcg_temp_new_i64(); 918f713d6adSRichard Henderson 919f713d6adSRichard Henderson tcg_gen_extu_i32_i64(val64, val); 920f713d6adSRichard Henderson 921f713d6adSRichard Henderson *tcg_ctx.gen_opc_ptr++ = old_st_opc[memop & MO_SIZE]; 922f713d6adSRichard Henderson tcg_add_param_i64(val64); 923f713d6adSRichard Henderson tcg_add_param_tl(addr); 924f713d6adSRichard Henderson *tcg_ctx.gen_opparam_ptr++ = idx; 925f713d6adSRichard Henderson 926f713d6adSRichard Henderson tcg_temp_free_i64(val64); 927f713d6adSRichard Henderson } 928f713d6adSRichard Henderson } 929f713d6adSRichard Henderson 930f713d6adSRichard Henderson void tcg_gen_qemu_ld_i64(TCGv_i64 val, TCGv addr, TCGArg idx, TCGMemOp memop) 931f713d6adSRichard Henderson { 932f713d6adSRichard Henderson memop = tcg_canonicalize_memop(memop, 1, 0); 933f713d6adSRichard Henderson 934f713d6adSRichard Henderson #if TCG_TARGET_REG_BITS == 32 935f713d6adSRichard Henderson if ((memop & MO_SIZE) < MO_64) { 936f713d6adSRichard Henderson tcg_gen_qemu_ld_i32(TCGV_LOW(val), addr, idx, memop); 937f713d6adSRichard Henderson if (memop & MO_SIGN) { 938f713d6adSRichard Henderson tcg_gen_sari_i32(TCGV_HIGH(val), TCGV_LOW(val), 31); 939f713d6adSRichard Henderson } else { 940f713d6adSRichard Henderson tcg_gen_movi_i32(TCGV_HIGH(val), 0); 941f713d6adSRichard Henderson } 942f713d6adSRichard Henderson return; 943f713d6adSRichard Henderson } 944f713d6adSRichard Henderson #endif 945f713d6adSRichard Henderson 946f713d6adSRichard Henderson if (TCG_TARGET_HAS_new_ldst) { 947f713d6adSRichard Henderson *tcg_ctx.gen_opc_ptr++ = INDEX_op_qemu_ld_i64; 948f713d6adSRichard Henderson tcg_add_param_i64(val); 949f713d6adSRichard Henderson tcg_add_param_tl(addr); 950f713d6adSRichard Henderson *tcg_ctx.gen_opparam_ptr++ = memop; 951f713d6adSRichard Henderson *tcg_ctx.gen_opparam_ptr++ = idx; 952f713d6adSRichard Henderson return; 953f713d6adSRichard Henderson } 954f713d6adSRichard Henderson 955f713d6adSRichard Henderson /* The old opcodes only support target-endian memory operations. */ 956f713d6adSRichard Henderson assert((memop & MO_BSWAP) == MO_TE || (memop & MO_SIZE) == MO_8); 957f713d6adSRichard Henderson assert(old_ld_opc[memop & MO_SSIZE] != 0); 958f713d6adSRichard Henderson 959f713d6adSRichard Henderson *tcg_ctx.gen_opc_ptr++ = old_ld_opc[memop & MO_SSIZE]; 960f713d6adSRichard Henderson tcg_add_param_i64(val); 961f713d6adSRichard Henderson tcg_add_param_tl(addr); 962f713d6adSRichard Henderson *tcg_ctx.gen_opparam_ptr++ = idx; 963f713d6adSRichard Henderson } 964f713d6adSRichard Henderson 965f713d6adSRichard Henderson void tcg_gen_qemu_st_i64(TCGv_i64 val, TCGv addr, TCGArg idx, TCGMemOp memop) 966f713d6adSRichard Henderson { 967f713d6adSRichard Henderson memop = tcg_canonicalize_memop(memop, 1, 1); 968f713d6adSRichard Henderson 969f713d6adSRichard Henderson #if TCG_TARGET_REG_BITS == 32 970f713d6adSRichard Henderson if ((memop & MO_SIZE) < MO_64) { 971f713d6adSRichard Henderson tcg_gen_qemu_st_i32(TCGV_LOW(val), addr, idx, memop); 972f713d6adSRichard Henderson return; 973f713d6adSRichard Henderson } 974f713d6adSRichard Henderson #endif 975f713d6adSRichard Henderson 976f713d6adSRichard Henderson if (TCG_TARGET_HAS_new_ldst) { 977f713d6adSRichard Henderson *tcg_ctx.gen_opc_ptr++ = INDEX_op_qemu_st_i64; 978f713d6adSRichard Henderson tcg_add_param_i64(val); 979f713d6adSRichard Henderson tcg_add_param_tl(addr); 980f713d6adSRichard Henderson *tcg_ctx.gen_opparam_ptr++ = memop; 981f713d6adSRichard Henderson *tcg_ctx.gen_opparam_ptr++ = idx; 982f713d6adSRichard Henderson return; 983f713d6adSRichard Henderson } 984f713d6adSRichard Henderson 985f713d6adSRichard Henderson /* The old opcodes only support target-endian memory operations. */ 986f713d6adSRichard Henderson assert((memop & MO_BSWAP) == MO_TE || (memop & MO_SIZE) == MO_8); 987f713d6adSRichard Henderson assert(old_st_opc[memop & MO_SIZE] != 0); 988f713d6adSRichard Henderson 989f713d6adSRichard Henderson *tcg_ctx.gen_opc_ptr++ = old_st_opc[memop & MO_SIZE]; 990f713d6adSRichard Henderson tcg_add_param_i64(val); 991f713d6adSRichard Henderson tcg_add_param_tl(addr); 992f713d6adSRichard Henderson *tcg_ctx.gen_opparam_ptr++ = idx; 993f713d6adSRichard Henderson } 994be210acbSRichard Henderson 9958fcd3692Sblueswir1 static void tcg_reg_alloc_start(TCGContext *s) 996c896fe29Sbellard { 997c896fe29Sbellard int i; 998c896fe29Sbellard TCGTemp *ts; 999c896fe29Sbellard for(i = 0; i < s->nb_globals; i++) { 1000c896fe29Sbellard ts = &s->temps[i]; 1001c896fe29Sbellard if (ts->fixed_reg) { 1002c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 1003c896fe29Sbellard } else { 1004c896fe29Sbellard ts->val_type = TEMP_VAL_MEM; 1005c896fe29Sbellard } 1006c896fe29Sbellard } 1007e8996ee0Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 1008e8996ee0Sbellard ts = &s->temps[i]; 10097dfd8c6aSAurelien Jarno if (ts->temp_local) { 10107dfd8c6aSAurelien Jarno ts->val_type = TEMP_VAL_MEM; 10117dfd8c6aSAurelien Jarno } else { 1012e8996ee0Sbellard ts->val_type = TEMP_VAL_DEAD; 10137dfd8c6aSAurelien Jarno } 1014e8996ee0Sbellard ts->mem_allocated = 0; 1015e8996ee0Sbellard ts->fixed_reg = 0; 1016e8996ee0Sbellard } 1017c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1018c896fe29Sbellard s->reg_to_temp[i] = -1; 1019c896fe29Sbellard } 1020c896fe29Sbellard } 1021c896fe29Sbellard 1022ac56dd48Spbrook static char *tcg_get_arg_str_idx(TCGContext *s, char *buf, int buf_size, 1023ac56dd48Spbrook int idx) 1024c896fe29Sbellard { 1025c896fe29Sbellard TCGTemp *ts; 1026ac56dd48Spbrook 10277f6f0ae5SStefan Weil assert(idx >= 0 && idx < s->nb_temps); 1028ac56dd48Spbrook ts = &s->temps[idx]; 1029ac56dd48Spbrook if (idx < s->nb_globals) { 1030ac56dd48Spbrook pstrcpy(buf, buf_size, ts->name); 1031c896fe29Sbellard } else { 1032641d5fbeSbellard if (ts->temp_local) 1033641d5fbeSbellard snprintf(buf, buf_size, "loc%d", idx - s->nb_globals); 1034641d5fbeSbellard else 1035ac56dd48Spbrook snprintf(buf, buf_size, "tmp%d", idx - s->nb_globals); 1036c896fe29Sbellard } 1037c896fe29Sbellard return buf; 1038c896fe29Sbellard } 1039c896fe29Sbellard 1040a7812ae4Spbrook char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg) 1041ac56dd48Spbrook { 1042a7812ae4Spbrook return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I32(arg)); 1043a7812ae4Spbrook } 1044a7812ae4Spbrook 1045a7812ae4Spbrook char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg) 1046a7812ae4Spbrook { 1047a810a2deSblueswir1 return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I64(arg)); 1048ac56dd48Spbrook } 1049ac56dd48Spbrook 10506e085f72SRichard Henderson /* Find helper name. */ 10516e085f72SRichard Henderson static inline const char *tcg_find_helper(TCGContext *s, uintptr_t val) 1052e8996ee0Sbellard { 10536e085f72SRichard Henderson const char *ret = NULL; 10546e085f72SRichard Henderson if (s->helpers) { 10556e085f72SRichard Henderson ret = g_hash_table_lookup(s->helpers, (gpointer)val); 1056e8996ee0Sbellard } 10576e085f72SRichard Henderson return ret; 10584dc81f28Sbellard } 10594dc81f28Sbellard 1060f48f3edeSblueswir1 static const char * const cond_name[] = 1061f48f3edeSblueswir1 { 10620aed257fSRichard Henderson [TCG_COND_NEVER] = "never", 10630aed257fSRichard Henderson [TCG_COND_ALWAYS] = "always", 1064f48f3edeSblueswir1 [TCG_COND_EQ] = "eq", 1065f48f3edeSblueswir1 [TCG_COND_NE] = "ne", 1066f48f3edeSblueswir1 [TCG_COND_LT] = "lt", 1067f48f3edeSblueswir1 [TCG_COND_GE] = "ge", 1068f48f3edeSblueswir1 [TCG_COND_LE] = "le", 1069f48f3edeSblueswir1 [TCG_COND_GT] = "gt", 1070f48f3edeSblueswir1 [TCG_COND_LTU] = "ltu", 1071f48f3edeSblueswir1 [TCG_COND_GEU] = "geu", 1072f48f3edeSblueswir1 [TCG_COND_LEU] = "leu", 1073f48f3edeSblueswir1 [TCG_COND_GTU] = "gtu" 1074f48f3edeSblueswir1 }; 1075f48f3edeSblueswir1 1076f713d6adSRichard Henderson static const char * const ldst_name[] = 1077f713d6adSRichard Henderson { 1078f713d6adSRichard Henderson [MO_UB] = "ub", 1079f713d6adSRichard Henderson [MO_SB] = "sb", 1080f713d6adSRichard Henderson [MO_LEUW] = "leuw", 1081f713d6adSRichard Henderson [MO_LESW] = "lesw", 1082f713d6adSRichard Henderson [MO_LEUL] = "leul", 1083f713d6adSRichard Henderson [MO_LESL] = "lesl", 1084f713d6adSRichard Henderson [MO_LEQ] = "leq", 1085f713d6adSRichard Henderson [MO_BEUW] = "beuw", 1086f713d6adSRichard Henderson [MO_BESW] = "besw", 1087f713d6adSRichard Henderson [MO_BEUL] = "beul", 1088f713d6adSRichard Henderson [MO_BESL] = "besl", 1089f713d6adSRichard Henderson [MO_BEQ] = "beq", 1090f713d6adSRichard Henderson }; 1091f713d6adSRichard Henderson 1092eeacee4dSBlue Swirl void tcg_dump_ops(TCGContext *s) 1093c896fe29Sbellard { 1094c896fe29Sbellard const uint16_t *opc_ptr; 1095c896fe29Sbellard const TCGArg *args; 1096c896fe29Sbellard TCGArg arg; 1097a9751609SRichard Henderson TCGOpcode c; 1098a9751609SRichard Henderson int i, k, nb_oargs, nb_iargs, nb_cargs, first_insn; 1099c896fe29Sbellard const TCGOpDef *def; 1100c896fe29Sbellard char buf[128]; 1101c896fe29Sbellard 11027e4597d7Sbellard first_insn = 1; 110392414b31SEvgeny Voevodin opc_ptr = s->gen_opc_buf; 11041ff0a2c5SEvgeny Voevodin args = s->gen_opparam_buf; 1105efd7f486SEvgeny Voevodin while (opc_ptr < s->gen_opc_ptr) { 1106c896fe29Sbellard c = *opc_ptr++; 1107c896fe29Sbellard def = &tcg_op_defs[c]; 11087e4597d7Sbellard if (c == INDEX_op_debug_insn_start) { 11097e4597d7Sbellard uint64_t pc; 11107e4597d7Sbellard #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS 11117e4597d7Sbellard pc = ((uint64_t)args[1] << 32) | args[0]; 11127e4597d7Sbellard #else 11137e4597d7Sbellard pc = args[0]; 11147e4597d7Sbellard #endif 1115eeacee4dSBlue Swirl if (!first_insn) { 1116eeacee4dSBlue Swirl qemu_log("\n"); 1117eeacee4dSBlue Swirl } 1118eeacee4dSBlue Swirl qemu_log(" ---- 0x%" PRIx64, pc); 11197e4597d7Sbellard first_insn = 0; 11207e4597d7Sbellard nb_oargs = def->nb_oargs; 11217e4597d7Sbellard nb_iargs = def->nb_iargs; 11227e4597d7Sbellard nb_cargs = def->nb_cargs; 11237e4597d7Sbellard } else if (c == INDEX_op_call) { 1124c896fe29Sbellard TCGArg arg; 11254dc81f28Sbellard 1126c896fe29Sbellard /* variable number of arguments */ 1127c896fe29Sbellard arg = *args++; 1128c896fe29Sbellard nb_oargs = arg >> 16; 1129c896fe29Sbellard nb_iargs = arg & 0xffff; 1130c896fe29Sbellard nb_cargs = def->nb_cargs; 1131b03cce8eSbellard 1132eeacee4dSBlue Swirl qemu_log(" %s ", def->name); 11337e4597d7Sbellard 1134b03cce8eSbellard /* function name */ 1135eeacee4dSBlue Swirl qemu_log("%s", 1136eeacee4dSBlue Swirl tcg_get_arg_str_idx(s, buf, sizeof(buf), 1137eeacee4dSBlue Swirl args[nb_oargs + nb_iargs - 1])); 1138b03cce8eSbellard /* flags */ 1139eeacee4dSBlue Swirl qemu_log(",$0x%" TCG_PRIlx, args[nb_oargs + nb_iargs]); 1140b03cce8eSbellard /* nb out args */ 1141eeacee4dSBlue Swirl qemu_log(",$%d", nb_oargs); 1142b03cce8eSbellard for(i = 0; i < nb_oargs; i++) { 1143eeacee4dSBlue Swirl qemu_log(","); 1144eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 1145eeacee4dSBlue Swirl args[i])); 1146b03cce8eSbellard } 1147b03cce8eSbellard for(i = 0; i < (nb_iargs - 1); i++) { 1148eeacee4dSBlue Swirl qemu_log(","); 114939cf05d3Sbellard if (args[nb_oargs + i] == TCG_CALL_DUMMY_ARG) { 1150eeacee4dSBlue Swirl qemu_log("<dummy>"); 115139cf05d3Sbellard } else { 1152eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 1153eeacee4dSBlue Swirl args[nb_oargs + i])); 1154b03cce8eSbellard } 115539cf05d3Sbellard } 1156fba3161fSAurelien Jarno } else if (c == INDEX_op_movi_i32 || c == INDEX_op_movi_i64) { 1157e8996ee0Sbellard tcg_target_ulong val; 11586e085f72SRichard Henderson const char *name; 1159e8996ee0Sbellard 1160e8996ee0Sbellard nb_oargs = def->nb_oargs; 1161e8996ee0Sbellard nb_iargs = def->nb_iargs; 1162e8996ee0Sbellard nb_cargs = def->nb_cargs; 1163eeacee4dSBlue Swirl qemu_log(" %s %s,$", def->name, 1164e8996ee0Sbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[0])); 1165e8996ee0Sbellard val = args[1]; 11666e085f72SRichard Henderson name = tcg_find_helper(s, val); 11676e085f72SRichard Henderson if (name) { 11686e085f72SRichard Henderson qemu_log("%s", name); 1169e8996ee0Sbellard } else { 1170eeacee4dSBlue Swirl if (c == INDEX_op_movi_i32) { 1171eeacee4dSBlue Swirl qemu_log("0x%x", (uint32_t)val); 1172eeacee4dSBlue Swirl } else { 1173eeacee4dSBlue Swirl qemu_log("0x%" PRIx64 , (uint64_t)val); 1174eeacee4dSBlue Swirl } 1175e8996ee0Sbellard } 1176b03cce8eSbellard } else { 1177eeacee4dSBlue Swirl qemu_log(" %s ", def->name); 1178b03cce8eSbellard if (c == INDEX_op_nopn) { 1179c896fe29Sbellard /* variable number of arguments */ 1180c896fe29Sbellard nb_cargs = *args; 1181c896fe29Sbellard nb_oargs = 0; 1182c896fe29Sbellard nb_iargs = 0; 1183c896fe29Sbellard } else { 1184c896fe29Sbellard nb_oargs = def->nb_oargs; 1185c896fe29Sbellard nb_iargs = def->nb_iargs; 1186c896fe29Sbellard nb_cargs = def->nb_cargs; 1187c896fe29Sbellard } 1188c896fe29Sbellard 1189c896fe29Sbellard k = 0; 1190c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1191eeacee4dSBlue Swirl if (k != 0) { 1192eeacee4dSBlue Swirl qemu_log(","); 1193eeacee4dSBlue Swirl } 1194eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 1195eeacee4dSBlue Swirl args[k++])); 1196c896fe29Sbellard } 1197c896fe29Sbellard for(i = 0; i < nb_iargs; i++) { 1198eeacee4dSBlue Swirl if (k != 0) { 1199eeacee4dSBlue Swirl qemu_log(","); 1200eeacee4dSBlue Swirl } 1201eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 1202eeacee4dSBlue Swirl args[k++])); 1203c896fe29Sbellard } 1204be210acbSRichard Henderson switch (c) { 1205be210acbSRichard Henderson case INDEX_op_brcond_i32: 1206ffc5ea09SRichard Henderson case INDEX_op_setcond_i32: 1207ffc5ea09SRichard Henderson case INDEX_op_movcond_i32: 1208be210acbSRichard Henderson case INDEX_op_brcond2_i32: 1209be210acbSRichard Henderson case INDEX_op_setcond2_i32: 1210ffc5ea09SRichard Henderson case INDEX_op_brcond_i64: 1211be210acbSRichard Henderson case INDEX_op_setcond_i64: 1212ffc5ea09SRichard Henderson case INDEX_op_movcond_i64: 1213eeacee4dSBlue Swirl if (args[k] < ARRAY_SIZE(cond_name) && cond_name[args[k]]) { 1214eeacee4dSBlue Swirl qemu_log(",%s", cond_name[args[k++]]); 1215eeacee4dSBlue Swirl } else { 1216eeacee4dSBlue Swirl qemu_log(",$0x%" TCG_PRIlx, args[k++]); 1217eeacee4dSBlue Swirl } 1218f48f3edeSblueswir1 i = 1; 1219be210acbSRichard Henderson break; 1220f713d6adSRichard Henderson case INDEX_op_qemu_ld_i32: 1221f713d6adSRichard Henderson case INDEX_op_qemu_st_i32: 1222f713d6adSRichard Henderson case INDEX_op_qemu_ld_i64: 1223f713d6adSRichard Henderson case INDEX_op_qemu_st_i64: 1224f713d6adSRichard Henderson if (args[k] < ARRAY_SIZE(ldst_name) && ldst_name[args[k]]) { 1225f713d6adSRichard Henderson qemu_log(",%s", ldst_name[args[k++]]); 1226f713d6adSRichard Henderson } else { 1227f713d6adSRichard Henderson qemu_log(",$0x%" TCG_PRIlx, args[k++]); 1228f713d6adSRichard Henderson } 1229f713d6adSRichard Henderson i = 1; 1230f713d6adSRichard Henderson break; 1231be210acbSRichard Henderson default: 1232f48f3edeSblueswir1 i = 0; 1233be210acbSRichard Henderson break; 1234be210acbSRichard Henderson } 1235f48f3edeSblueswir1 for(; i < nb_cargs; i++) { 1236eeacee4dSBlue Swirl if (k != 0) { 1237eeacee4dSBlue Swirl qemu_log(","); 1238eeacee4dSBlue Swirl } 1239c896fe29Sbellard arg = args[k++]; 1240eeacee4dSBlue Swirl qemu_log("$0x%" TCG_PRIlx, arg); 1241c896fe29Sbellard } 1242b03cce8eSbellard } 1243eeacee4dSBlue Swirl qemu_log("\n"); 1244c896fe29Sbellard args += nb_iargs + nb_oargs + nb_cargs; 1245c896fe29Sbellard } 1246c896fe29Sbellard } 1247c896fe29Sbellard 1248c896fe29Sbellard /* we give more priority to constraints with less registers */ 1249c896fe29Sbellard static int get_constraint_priority(const TCGOpDef *def, int k) 1250c896fe29Sbellard { 1251c896fe29Sbellard const TCGArgConstraint *arg_ct; 1252c896fe29Sbellard 1253c896fe29Sbellard int i, n; 1254c896fe29Sbellard arg_ct = &def->args_ct[k]; 1255c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 1256c896fe29Sbellard /* an alias is equivalent to a single register */ 1257c896fe29Sbellard n = 1; 1258c896fe29Sbellard } else { 1259c896fe29Sbellard if (!(arg_ct->ct & TCG_CT_REG)) 1260c896fe29Sbellard return 0; 1261c896fe29Sbellard n = 0; 1262c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1263c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, i)) 1264c896fe29Sbellard n++; 1265c896fe29Sbellard } 1266c896fe29Sbellard } 1267c896fe29Sbellard return TCG_TARGET_NB_REGS - n + 1; 1268c896fe29Sbellard } 1269c896fe29Sbellard 1270c896fe29Sbellard /* sort from highest priority to lowest */ 1271c896fe29Sbellard static void sort_constraints(TCGOpDef *def, int start, int n) 1272c896fe29Sbellard { 1273c896fe29Sbellard int i, j, p1, p2, tmp; 1274c896fe29Sbellard 1275c896fe29Sbellard for(i = 0; i < n; i++) 1276c896fe29Sbellard def->sorted_args[start + i] = start + i; 1277c896fe29Sbellard if (n <= 1) 1278c896fe29Sbellard return; 1279c896fe29Sbellard for(i = 0; i < n - 1; i++) { 1280c896fe29Sbellard for(j = i + 1; j < n; j++) { 1281c896fe29Sbellard p1 = get_constraint_priority(def, def->sorted_args[start + i]); 1282c896fe29Sbellard p2 = get_constraint_priority(def, def->sorted_args[start + j]); 1283c896fe29Sbellard if (p1 < p2) { 1284c896fe29Sbellard tmp = def->sorted_args[start + i]; 1285c896fe29Sbellard def->sorted_args[start + i] = def->sorted_args[start + j]; 1286c896fe29Sbellard def->sorted_args[start + j] = tmp; 1287c896fe29Sbellard } 1288c896fe29Sbellard } 1289c896fe29Sbellard } 1290c896fe29Sbellard } 1291c896fe29Sbellard 1292c896fe29Sbellard void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs) 1293c896fe29Sbellard { 1294a9751609SRichard Henderson TCGOpcode op; 1295c896fe29Sbellard TCGOpDef *def; 1296c896fe29Sbellard const char *ct_str; 1297c896fe29Sbellard int i, nb_args; 1298c896fe29Sbellard 1299c896fe29Sbellard for(;;) { 1300a9751609SRichard Henderson if (tdefs->op == (TCGOpcode)-1) 1301c896fe29Sbellard break; 1302c896fe29Sbellard op = tdefs->op; 1303c3b08d0eSStefan Weil assert((unsigned)op < NB_OPS); 1304c896fe29Sbellard def = &tcg_op_defs[op]; 1305c68aaa18SStefan Weil #if defined(CONFIG_DEBUG_TCG) 1306c68aaa18SStefan Weil /* Duplicate entry in op definitions? */ 1307c68aaa18SStefan Weil assert(!def->used); 1308c68aaa18SStefan Weil def->used = 1; 1309c68aaa18SStefan Weil #endif 1310c896fe29Sbellard nb_args = def->nb_iargs + def->nb_oargs; 1311c896fe29Sbellard for(i = 0; i < nb_args; i++) { 1312c896fe29Sbellard ct_str = tdefs->args_ct_str[i]; 1313c68aaa18SStefan Weil /* Incomplete TCGTargetOpDef entry? */ 1314c68aaa18SStefan Weil assert(ct_str != NULL); 1315c896fe29Sbellard tcg_regset_clear(def->args_ct[i].u.regs); 1316c896fe29Sbellard def->args_ct[i].ct = 0; 1317c896fe29Sbellard if (ct_str[0] >= '0' && ct_str[0] <= '9') { 1318c896fe29Sbellard int oarg; 1319c896fe29Sbellard oarg = ct_str[0] - '0'; 1320c896fe29Sbellard assert(oarg < def->nb_oargs); 1321c896fe29Sbellard assert(def->args_ct[oarg].ct & TCG_CT_REG); 1322c896fe29Sbellard /* TCG_CT_ALIAS is for the output arguments. The input 13235ff9d6a4Sbellard argument is tagged with TCG_CT_IALIAS. */ 1324c896fe29Sbellard def->args_ct[i] = def->args_ct[oarg]; 13255ff9d6a4Sbellard def->args_ct[oarg].ct = TCG_CT_ALIAS; 13265ff9d6a4Sbellard def->args_ct[oarg].alias_index = i; 1327c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_IALIAS; 13285ff9d6a4Sbellard def->args_ct[i].alias_index = oarg; 1329c896fe29Sbellard } else { 1330c896fe29Sbellard for(;;) { 1331c896fe29Sbellard if (*ct_str == '\0') 1332c896fe29Sbellard break; 1333c896fe29Sbellard switch(*ct_str) { 1334c896fe29Sbellard case 'i': 1335c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_CONST; 1336c896fe29Sbellard ct_str++; 1337c896fe29Sbellard break; 1338c896fe29Sbellard default: 1339c896fe29Sbellard if (target_parse_constraint(&def->args_ct[i], &ct_str) < 0) { 1340c896fe29Sbellard fprintf(stderr, "Invalid constraint '%s' for arg %d of operation '%s'\n", 1341c896fe29Sbellard ct_str, i, def->name); 1342c896fe29Sbellard exit(1); 1343c896fe29Sbellard } 1344c896fe29Sbellard } 1345c896fe29Sbellard } 1346c896fe29Sbellard } 1347c896fe29Sbellard } 1348c896fe29Sbellard 1349c68aaa18SStefan Weil /* TCGTargetOpDef entry with too much information? */ 1350c68aaa18SStefan Weil assert(i == TCG_MAX_OP_ARGS || tdefs->args_ct_str[i] == NULL); 1351c68aaa18SStefan Weil 1352c896fe29Sbellard /* sort the constraints (XXX: this is just an heuristic) */ 1353c896fe29Sbellard sort_constraints(def, 0, def->nb_oargs); 1354c896fe29Sbellard sort_constraints(def, def->nb_oargs, def->nb_iargs); 1355c896fe29Sbellard 1356c896fe29Sbellard #if 0 1357c896fe29Sbellard { 1358c896fe29Sbellard int i; 1359c896fe29Sbellard 1360c896fe29Sbellard printf("%s: sorted=", def->name); 1361c896fe29Sbellard for(i = 0; i < def->nb_oargs + def->nb_iargs; i++) 1362c896fe29Sbellard printf(" %d", def->sorted_args[i]); 1363c896fe29Sbellard printf("\n"); 1364c896fe29Sbellard } 1365c896fe29Sbellard #endif 1366c896fe29Sbellard tdefs++; 1367c896fe29Sbellard } 1368c896fe29Sbellard 1369c68aaa18SStefan Weil #if defined(CONFIG_DEBUG_TCG) 1370a9751609SRichard Henderson i = 0; 1371c68aaa18SStefan Weil for (op = 0; op < ARRAY_SIZE(tcg_op_defs); op++) { 1372f412c762SRichard Henderson const TCGOpDef *def = &tcg_op_defs[op]; 1373c1a61f6cSRichard Henderson if (def->flags & TCG_OPF_NOT_PRESENT) { 1374c68aaa18SStefan Weil /* Wrong entry in op definitions? */ 1375f412c762SRichard Henderson if (def->used) { 1376f412c762SRichard Henderson fprintf(stderr, "Invalid op definition for %s\n", def->name); 1377a9751609SRichard Henderson i = 1; 1378a9751609SRichard Henderson } 1379c68aaa18SStefan Weil } else { 1380c68aaa18SStefan Weil /* Missing entry in op definitions? */ 1381f412c762SRichard Henderson if (!def->used) { 1382f412c762SRichard Henderson fprintf(stderr, "Missing op definition for %s\n", def->name); 1383a9751609SRichard Henderson i = 1; 1384c68aaa18SStefan Weil } 1385c68aaa18SStefan Weil } 1386a9751609SRichard Henderson } 1387a9751609SRichard Henderson if (i == 1) { 1388a9751609SRichard Henderson tcg_abort(); 1389a9751609SRichard Henderson } 1390c68aaa18SStefan Weil #endif 1391c896fe29Sbellard } 1392c896fe29Sbellard 1393c896fe29Sbellard #ifdef USE_LIVENESS_ANALYSIS 1394c896fe29Sbellard 1395c896fe29Sbellard /* set a nop for an operation using 'nb_args' */ 1396c896fe29Sbellard static inline void tcg_set_nop(TCGContext *s, uint16_t *opc_ptr, 1397c896fe29Sbellard TCGArg *args, int nb_args) 1398c896fe29Sbellard { 1399c896fe29Sbellard if (nb_args == 0) { 1400c896fe29Sbellard *opc_ptr = INDEX_op_nop; 1401c896fe29Sbellard } else { 1402c896fe29Sbellard *opc_ptr = INDEX_op_nopn; 1403c896fe29Sbellard args[0] = nb_args; 1404c896fe29Sbellard args[nb_args - 1] = nb_args; 1405c896fe29Sbellard } 1406c896fe29Sbellard } 1407c896fe29Sbellard 14089c43b68dSAurelien Jarno /* liveness analysis: end of function: all temps are dead, and globals 14099c43b68dSAurelien Jarno should be in memory. */ 14109c43b68dSAurelien Jarno static inline void tcg_la_func_end(TCGContext *s, uint8_t *dead_temps, 14119c43b68dSAurelien Jarno uint8_t *mem_temps) 1412c896fe29Sbellard { 14139c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_temps); 14149c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 14159c43b68dSAurelien Jarno memset(mem_temps + s->nb_globals, 0, s->nb_temps - s->nb_globals); 1416c896fe29Sbellard } 1417c896fe29Sbellard 14189c43b68dSAurelien Jarno /* liveness analysis: end of basic block: all temps are dead, globals 14199c43b68dSAurelien Jarno and local temps should be in memory. */ 14209c43b68dSAurelien Jarno static inline void tcg_la_bb_end(TCGContext *s, uint8_t *dead_temps, 14219c43b68dSAurelien Jarno uint8_t *mem_temps) 1422641d5fbeSbellard { 1423641d5fbeSbellard int i; 1424641d5fbeSbellard 14259c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_temps); 14269c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 1427641d5fbeSbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 14289c43b68dSAurelien Jarno mem_temps[i] = s->temps[i].temp_local; 1429641d5fbeSbellard } 1430641d5fbeSbellard } 1431641d5fbeSbellard 1432866cb6cbSAurelien Jarno /* Liveness analysis : update the opc_dead_args array to tell if a 1433c896fe29Sbellard given input arguments is dead. Instructions updating dead 1434c896fe29Sbellard temporaries are removed. */ 14358fcd3692Sblueswir1 static void tcg_liveness_analysis(TCGContext *s) 1436c896fe29Sbellard { 1437a9751609SRichard Henderson int i, op_index, nb_args, nb_iargs, nb_oargs, arg, nb_ops; 143803271524SRichard Henderson TCGOpcode op, op_new, op_new2; 1439c896fe29Sbellard TCGArg *args; 1440c896fe29Sbellard const TCGOpDef *def; 14419c43b68dSAurelien Jarno uint8_t *dead_temps, *mem_temps; 1442ec7a869dSAurelien Jarno uint16_t dead_args; 1443ec7a869dSAurelien Jarno uint8_t sync_args; 144403271524SRichard Henderson bool have_op_new2; 1445c896fe29Sbellard 1446efd7f486SEvgeny Voevodin s->gen_opc_ptr++; /* skip end */ 1447c896fe29Sbellard 144892414b31SEvgeny Voevodin nb_ops = s->gen_opc_ptr - s->gen_opc_buf; 1449c896fe29Sbellard 1450866cb6cbSAurelien Jarno s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t)); 1451ec7a869dSAurelien Jarno s->op_sync_args = tcg_malloc(nb_ops * sizeof(uint8_t)); 1452c896fe29Sbellard 1453c896fe29Sbellard dead_temps = tcg_malloc(s->nb_temps); 14549c43b68dSAurelien Jarno mem_temps = tcg_malloc(s->nb_temps); 14559c43b68dSAurelien Jarno tcg_la_func_end(s, dead_temps, mem_temps); 1456c896fe29Sbellard 1457c4afe5c4SEvgeny Voevodin args = s->gen_opparam_ptr; 1458c896fe29Sbellard op_index = nb_ops - 1; 1459c896fe29Sbellard while (op_index >= 0) { 146092414b31SEvgeny Voevodin op = s->gen_opc_buf[op_index]; 1461c896fe29Sbellard def = &tcg_op_defs[op]; 1462c896fe29Sbellard switch(op) { 1463c896fe29Sbellard case INDEX_op_call: 1464c6e113f5Sbellard { 1465c6e113f5Sbellard int call_flags; 1466c6e113f5Sbellard 1467c896fe29Sbellard nb_args = args[-1]; 1468c896fe29Sbellard args -= nb_args; 1469c896fe29Sbellard nb_iargs = args[0] & 0xffff; 1470c896fe29Sbellard nb_oargs = args[0] >> 16; 1471c896fe29Sbellard args++; 1472c6e113f5Sbellard call_flags = args[nb_oargs + nb_iargs]; 1473c6e113f5Sbellard 1474c6e113f5Sbellard /* pure functions can be removed if their result is not 1475c6e113f5Sbellard used */ 147678505279SAurelien Jarno if (call_flags & TCG_CALL_NO_SIDE_EFFECTS) { 1477c6e113f5Sbellard for(i = 0; i < nb_oargs; i++) { 1478c6e113f5Sbellard arg = args[i]; 14799c43b68dSAurelien Jarno if (!dead_temps[arg] || mem_temps[arg]) { 1480c6e113f5Sbellard goto do_not_remove_call; 1481c6e113f5Sbellard } 14829c43b68dSAurelien Jarno } 148392414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index, 1484c6e113f5Sbellard args - 1, nb_args); 1485c6e113f5Sbellard } else { 1486c6e113f5Sbellard do_not_remove_call: 1487c896fe29Sbellard 1488c896fe29Sbellard /* output args are dead */ 14896b64b624SAurelien Jarno dead_args = 0; 1490ec7a869dSAurelien Jarno sync_args = 0; 1491c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1492c896fe29Sbellard arg = args[i]; 14936b64b624SAurelien Jarno if (dead_temps[arg]) { 14946b64b624SAurelien Jarno dead_args |= (1 << i); 14956b64b624SAurelien Jarno } 14969c43b68dSAurelien Jarno if (mem_temps[arg]) { 14979c43b68dSAurelien Jarno sync_args |= (1 << i); 14989c43b68dSAurelien Jarno } 1499c896fe29Sbellard dead_temps[arg] = 1; 15009c43b68dSAurelien Jarno mem_temps[arg] = 0; 1501c896fe29Sbellard } 1502c896fe29Sbellard 150378505279SAurelien Jarno if (!(call_flags & TCG_CALL_NO_READ_GLOBALS)) { 150478505279SAurelien Jarno /* globals should be synced to memory */ 150578505279SAurelien Jarno memset(mem_temps, 1, s->nb_globals); 150678505279SAurelien Jarno } 150778505279SAurelien Jarno if (!(call_flags & (TCG_CALL_NO_WRITE_GLOBALS | 150878505279SAurelien Jarno TCG_CALL_NO_READ_GLOBALS))) { 15099c43b68dSAurelien Jarno /* globals should go back to memory */ 15109c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_globals); 1511b9c18f56Saurel32 } 1512c896fe29Sbellard 1513c896fe29Sbellard /* input args are live */ 1514866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 1515866cb6cbSAurelien Jarno arg = args[i]; 151639cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 1517c896fe29Sbellard if (dead_temps[arg]) { 1518866cb6cbSAurelien Jarno dead_args |= (1 << i); 1519c896fe29Sbellard } 1520c896fe29Sbellard dead_temps[arg] = 0; 1521c896fe29Sbellard } 152239cf05d3Sbellard } 1523866cb6cbSAurelien Jarno s->op_dead_args[op_index] = dead_args; 1524ec7a869dSAurelien Jarno s->op_sync_args[op_index] = sync_args; 1525c6e113f5Sbellard } 1526c896fe29Sbellard args--; 1527c6e113f5Sbellard } 1528c896fe29Sbellard break; 15297e4597d7Sbellard case INDEX_op_debug_insn_start: 15307e4597d7Sbellard args -= def->nb_args; 15317e4597d7Sbellard break; 1532c896fe29Sbellard case INDEX_op_nopn: 1533c896fe29Sbellard nb_args = args[-1]; 1534c896fe29Sbellard args -= nb_args; 1535c896fe29Sbellard break; 15365ff9d6a4Sbellard case INDEX_op_discard: 15375ff9d6a4Sbellard args--; 15385ff9d6a4Sbellard /* mark the temporary as dead */ 15395ff9d6a4Sbellard dead_temps[args[0]] = 1; 15409c43b68dSAurelien Jarno mem_temps[args[0]] = 0; 15415ff9d6a4Sbellard break; 1542c896fe29Sbellard case INDEX_op_end: 1543c896fe29Sbellard break; 15441305c451SRichard Henderson 15451305c451SRichard Henderson case INDEX_op_add2_i32: 1546f1fae40cSRichard Henderson op_new = INDEX_op_add_i32; 1547f1fae40cSRichard Henderson goto do_addsub2; 15481305c451SRichard Henderson case INDEX_op_sub2_i32: 1549f1fae40cSRichard Henderson op_new = INDEX_op_sub_i32; 1550f1fae40cSRichard Henderson goto do_addsub2; 1551f1fae40cSRichard Henderson case INDEX_op_add2_i64: 1552f1fae40cSRichard Henderson op_new = INDEX_op_add_i64; 1553f1fae40cSRichard Henderson goto do_addsub2; 1554f1fae40cSRichard Henderson case INDEX_op_sub2_i64: 1555f1fae40cSRichard Henderson op_new = INDEX_op_sub_i64; 1556f1fae40cSRichard Henderson do_addsub2: 15571305c451SRichard Henderson args -= 6; 15581305c451SRichard Henderson nb_iargs = 4; 15591305c451SRichard Henderson nb_oargs = 2; 15601305c451SRichard Henderson /* Test if the high part of the operation is dead, but not 15611305c451SRichard Henderson the low part. The result can be optimized to a simple 15621305c451SRichard Henderson add or sub. This happens often for x86_64 guest when the 15631305c451SRichard Henderson cpu mode is set to 32 bit. */ 15643c5645faSKirill Batuzov if (dead_temps[args[1]] && !mem_temps[args[1]]) { 15653c5645faSKirill Batuzov if (dead_temps[args[0]] && !mem_temps[args[0]]) { 15661305c451SRichard Henderson goto do_remove; 15671305c451SRichard Henderson } 15681305c451SRichard Henderson /* Create the single operation plus nop. */ 1569f1fae40cSRichard Henderson s->gen_opc_buf[op_index] = op = op_new; 15701305c451SRichard Henderson args[1] = args[2]; 15711305c451SRichard Henderson args[2] = args[4]; 157292414b31SEvgeny Voevodin assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop); 157392414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 3); 15741305c451SRichard Henderson /* Fall through and mark the single-word operation live. */ 15751305c451SRichard Henderson nb_iargs = 2; 15761305c451SRichard Henderson nb_oargs = 1; 15771305c451SRichard Henderson } 15781305c451SRichard Henderson goto do_not_remove; 15791305c451SRichard Henderson 15801414968aSRichard Henderson case INDEX_op_mulu2_i32: 158103271524SRichard Henderson op_new = INDEX_op_mul_i32; 158203271524SRichard Henderson op_new2 = INDEX_op_muluh_i32; 158303271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_muluh_i32; 158403271524SRichard Henderson goto do_mul2; 1585f1fae40cSRichard Henderson case INDEX_op_muls2_i32: 1586f1fae40cSRichard Henderson op_new = INDEX_op_mul_i32; 158703271524SRichard Henderson op_new2 = INDEX_op_mulsh_i32; 158803271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_mulsh_i32; 1589f1fae40cSRichard Henderson goto do_mul2; 1590f1fae40cSRichard Henderson case INDEX_op_mulu2_i64: 159103271524SRichard Henderson op_new = INDEX_op_mul_i64; 159203271524SRichard Henderson op_new2 = INDEX_op_muluh_i64; 159303271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_muluh_i64; 159403271524SRichard Henderson goto do_mul2; 1595f1fae40cSRichard Henderson case INDEX_op_muls2_i64: 1596f1fae40cSRichard Henderson op_new = INDEX_op_mul_i64; 159703271524SRichard Henderson op_new2 = INDEX_op_mulsh_i64; 159803271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_mulsh_i64; 159903271524SRichard Henderson goto do_mul2; 1600f1fae40cSRichard Henderson do_mul2: 16011414968aSRichard Henderson args -= 4; 16021414968aSRichard Henderson nb_iargs = 2; 16031414968aSRichard Henderson nb_oargs = 2; 16043c5645faSKirill Batuzov if (dead_temps[args[1]] && !mem_temps[args[1]]) { 16053c5645faSKirill Batuzov if (dead_temps[args[0]] && !mem_temps[args[0]]) { 160603271524SRichard Henderson /* Both parts of the operation are dead. */ 16071414968aSRichard Henderson goto do_remove; 16081414968aSRichard Henderson } 160903271524SRichard Henderson /* The high part of the operation is dead; generate the low. */ 1610f1fae40cSRichard Henderson s->gen_opc_buf[op_index] = op = op_new; 16111414968aSRichard Henderson args[1] = args[2]; 16121414968aSRichard Henderson args[2] = args[3]; 161303271524SRichard Henderson } else if (have_op_new2 && dead_temps[args[0]] 161403271524SRichard Henderson && !mem_temps[args[0]]) { 161503271524SRichard Henderson /* The low part of the operation is dead; generate the high. */ 161603271524SRichard Henderson s->gen_opc_buf[op_index] = op = op_new2; 161703271524SRichard Henderson args[0] = args[1]; 161803271524SRichard Henderson args[1] = args[2]; 161903271524SRichard Henderson args[2] = args[3]; 162003271524SRichard Henderson } else { 162103271524SRichard Henderson goto do_not_remove; 162203271524SRichard Henderson } 162392414b31SEvgeny Voevodin assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop); 162492414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 1); 162503271524SRichard Henderson /* Mark the single-word operation live. */ 16261414968aSRichard Henderson nb_oargs = 1; 16271414968aSRichard Henderson goto do_not_remove; 16281414968aSRichard Henderson 1629c896fe29Sbellard default: 16301305c451SRichard Henderson /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */ 1631c896fe29Sbellard args -= def->nb_args; 1632c896fe29Sbellard nb_iargs = def->nb_iargs; 1633c896fe29Sbellard nb_oargs = def->nb_oargs; 1634c896fe29Sbellard 1635c896fe29Sbellard /* Test if the operation can be removed because all 16365ff9d6a4Sbellard its outputs are dead. We assume that nb_oargs == 0 16375ff9d6a4Sbellard implies side effects */ 16385ff9d6a4Sbellard if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) { 1639c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1640c896fe29Sbellard arg = args[i]; 16419c43b68dSAurelien Jarno if (!dead_temps[arg] || mem_temps[arg]) { 1642c896fe29Sbellard goto do_not_remove; 1643c896fe29Sbellard } 16449c43b68dSAurelien Jarno } 16451305c451SRichard Henderson do_remove: 164692414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index, args, def->nb_args); 1647c896fe29Sbellard #ifdef CONFIG_PROFILER 1648a23a9ec6Sbellard s->del_op_count++; 1649c896fe29Sbellard #endif 1650c896fe29Sbellard } else { 1651c896fe29Sbellard do_not_remove: 1652c896fe29Sbellard 1653c896fe29Sbellard /* output args are dead */ 16546b64b624SAurelien Jarno dead_args = 0; 1655ec7a869dSAurelien Jarno sync_args = 0; 1656c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1657c896fe29Sbellard arg = args[i]; 16586b64b624SAurelien Jarno if (dead_temps[arg]) { 16596b64b624SAurelien Jarno dead_args |= (1 << i); 16606b64b624SAurelien Jarno } 16619c43b68dSAurelien Jarno if (mem_temps[arg]) { 16629c43b68dSAurelien Jarno sync_args |= (1 << i); 16639c43b68dSAurelien Jarno } 1664c896fe29Sbellard dead_temps[arg] = 1; 16659c43b68dSAurelien Jarno mem_temps[arg] = 0; 1666c896fe29Sbellard } 1667c896fe29Sbellard 1668c896fe29Sbellard /* if end of basic block, update */ 1669c896fe29Sbellard if (def->flags & TCG_OPF_BB_END) { 16709c43b68dSAurelien Jarno tcg_la_bb_end(s, dead_temps, mem_temps); 16713d5c5f87SAurelien Jarno } else if (def->flags & TCG_OPF_SIDE_EFFECTS) { 16723d5c5f87SAurelien Jarno /* globals should be synced to memory */ 16739c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 1674c896fe29Sbellard } 1675c896fe29Sbellard 1676c896fe29Sbellard /* input args are live */ 1677866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 1678866cb6cbSAurelien Jarno arg = args[i]; 1679c896fe29Sbellard if (dead_temps[arg]) { 1680866cb6cbSAurelien Jarno dead_args |= (1 << i); 1681c896fe29Sbellard } 1682c896fe29Sbellard dead_temps[arg] = 0; 1683c896fe29Sbellard } 1684866cb6cbSAurelien Jarno s->op_dead_args[op_index] = dead_args; 1685ec7a869dSAurelien Jarno s->op_sync_args[op_index] = sync_args; 1686c896fe29Sbellard } 1687c896fe29Sbellard break; 1688c896fe29Sbellard } 1689c896fe29Sbellard op_index--; 1690c896fe29Sbellard } 1691c896fe29Sbellard 16921ff0a2c5SEvgeny Voevodin if (args != s->gen_opparam_buf) { 1693c896fe29Sbellard tcg_abort(); 1694c896fe29Sbellard } 16951ff0a2c5SEvgeny Voevodin } 1696c896fe29Sbellard #else 1697c896fe29Sbellard /* dummy liveness analysis */ 1698655feed5Smalc static void tcg_liveness_analysis(TCGContext *s) 1699c896fe29Sbellard { 1700c896fe29Sbellard int nb_ops; 170192414b31SEvgeny Voevodin nb_ops = s->gen_opc_ptr - s->gen_opc_buf; 1702c896fe29Sbellard 1703866cb6cbSAurelien Jarno s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t)); 1704866cb6cbSAurelien Jarno memset(s->op_dead_args, 0, nb_ops * sizeof(uint16_t)); 1705ec7a869dSAurelien Jarno s->op_sync_args = tcg_malloc(nb_ops * sizeof(uint8_t)); 1706ec7a869dSAurelien Jarno memset(s->op_sync_args, 0, nb_ops * sizeof(uint8_t)); 1707c896fe29Sbellard } 1708c896fe29Sbellard #endif 1709c896fe29Sbellard 1710c896fe29Sbellard #ifndef NDEBUG 1711c896fe29Sbellard static void dump_regs(TCGContext *s) 1712c896fe29Sbellard { 1713c896fe29Sbellard TCGTemp *ts; 1714c896fe29Sbellard int i; 1715c896fe29Sbellard char buf[64]; 1716c896fe29Sbellard 1717c896fe29Sbellard for(i = 0; i < s->nb_temps; i++) { 1718c896fe29Sbellard ts = &s->temps[i]; 1719ac56dd48Spbrook printf(" %10s: ", tcg_get_arg_str_idx(s, buf, sizeof(buf), i)); 1720c896fe29Sbellard switch(ts->val_type) { 1721c896fe29Sbellard case TEMP_VAL_REG: 1722c896fe29Sbellard printf("%s", tcg_target_reg_names[ts->reg]); 1723c896fe29Sbellard break; 1724c896fe29Sbellard case TEMP_VAL_MEM: 1725c896fe29Sbellard printf("%d(%s)", (int)ts->mem_offset, tcg_target_reg_names[ts->mem_reg]); 1726c896fe29Sbellard break; 1727c896fe29Sbellard case TEMP_VAL_CONST: 1728c896fe29Sbellard printf("$0x%" TCG_PRIlx, ts->val); 1729c896fe29Sbellard break; 1730c896fe29Sbellard case TEMP_VAL_DEAD: 1731c896fe29Sbellard printf("D"); 1732c896fe29Sbellard break; 1733c896fe29Sbellard default: 1734c896fe29Sbellard printf("???"); 1735c896fe29Sbellard break; 1736c896fe29Sbellard } 1737c896fe29Sbellard printf("\n"); 1738c896fe29Sbellard } 1739c896fe29Sbellard 1740c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1741c896fe29Sbellard if (s->reg_to_temp[i] >= 0) { 1742c896fe29Sbellard printf("%s: %s\n", 1743c896fe29Sbellard tcg_target_reg_names[i], 1744ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), s->reg_to_temp[i])); 1745c896fe29Sbellard } 1746c896fe29Sbellard } 1747c896fe29Sbellard } 1748c896fe29Sbellard 1749c896fe29Sbellard static void check_regs(TCGContext *s) 1750c896fe29Sbellard { 1751c896fe29Sbellard int reg, k; 1752c896fe29Sbellard TCGTemp *ts; 1753c896fe29Sbellard char buf[64]; 1754c896fe29Sbellard 1755c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1756c896fe29Sbellard k = s->reg_to_temp[reg]; 1757c896fe29Sbellard if (k >= 0) { 1758c896fe29Sbellard ts = &s->temps[k]; 1759c896fe29Sbellard if (ts->val_type != TEMP_VAL_REG || 1760c896fe29Sbellard ts->reg != reg) { 1761c896fe29Sbellard printf("Inconsistency for register %s:\n", 1762c896fe29Sbellard tcg_target_reg_names[reg]); 1763b03cce8eSbellard goto fail; 1764c896fe29Sbellard } 1765c896fe29Sbellard } 1766c896fe29Sbellard } 1767c896fe29Sbellard for(k = 0; k < s->nb_temps; k++) { 1768c896fe29Sbellard ts = &s->temps[k]; 1769c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG && 1770c896fe29Sbellard !ts->fixed_reg && 1771c896fe29Sbellard s->reg_to_temp[ts->reg] != k) { 1772c896fe29Sbellard printf("Inconsistency for temp %s:\n", 1773ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), k)); 1774b03cce8eSbellard fail: 1775c896fe29Sbellard printf("reg state:\n"); 1776c896fe29Sbellard dump_regs(s); 1777c896fe29Sbellard tcg_abort(); 1778c896fe29Sbellard } 1779c896fe29Sbellard } 1780c896fe29Sbellard } 1781c896fe29Sbellard #endif 1782c896fe29Sbellard 1783c896fe29Sbellard static void temp_allocate_frame(TCGContext *s, int temp) 1784c896fe29Sbellard { 1785c896fe29Sbellard TCGTemp *ts; 1786c896fe29Sbellard ts = &s->temps[temp]; 17879b9c37c3SRichard Henderson #if !(defined(__sparc__) && TCG_TARGET_REG_BITS == 64) 17889b9c37c3SRichard Henderson /* Sparc64 stack is accessed with offset of 2047 */ 1789b591dc59SBlue Swirl s->current_frame_offset = (s->current_frame_offset + 1790b591dc59SBlue Swirl (tcg_target_long)sizeof(tcg_target_long) - 1) & 1791b591dc59SBlue Swirl ~(sizeof(tcg_target_long) - 1); 1792f44c9960SBlue Swirl #endif 1793b591dc59SBlue Swirl if (s->current_frame_offset + (tcg_target_long)sizeof(tcg_target_long) > 1794b591dc59SBlue Swirl s->frame_end) { 17955ff9d6a4Sbellard tcg_abort(); 1796b591dc59SBlue Swirl } 1797c896fe29Sbellard ts->mem_offset = s->current_frame_offset; 1798c896fe29Sbellard ts->mem_reg = s->frame_reg; 1799c896fe29Sbellard ts->mem_allocated = 1; 1800e2c6d1b4SRichard Henderson s->current_frame_offset += sizeof(tcg_target_long); 1801c896fe29Sbellard } 1802c896fe29Sbellard 18037f6ceedfSAurelien Jarno /* sync register 'reg' by saving it to the corresponding temporary */ 18047f6ceedfSAurelien Jarno static inline void tcg_reg_sync(TCGContext *s, int reg) 1805c896fe29Sbellard { 1806c896fe29Sbellard TCGTemp *ts; 1807c896fe29Sbellard int temp; 1808c896fe29Sbellard 1809c896fe29Sbellard temp = s->reg_to_temp[reg]; 1810c896fe29Sbellard ts = &s->temps[temp]; 1811c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 18127f6ceedfSAurelien Jarno if (!ts->mem_coherent && !ts->fixed_reg) { 18137f6ceedfSAurelien Jarno if (!ts->mem_allocated) { 1814c896fe29Sbellard temp_allocate_frame(s, temp); 18157f6ceedfSAurelien Jarno } 1816e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1817c896fe29Sbellard } 18187f6ceedfSAurelien Jarno ts->mem_coherent = 1; 18197f6ceedfSAurelien Jarno } 18207f6ceedfSAurelien Jarno 18217f6ceedfSAurelien Jarno /* free register 'reg' by spilling the corresponding temporary if necessary */ 18227f6ceedfSAurelien Jarno static void tcg_reg_free(TCGContext *s, int reg) 18237f6ceedfSAurelien Jarno { 18247f6ceedfSAurelien Jarno int temp; 18257f6ceedfSAurelien Jarno 18267f6ceedfSAurelien Jarno temp = s->reg_to_temp[reg]; 18277f6ceedfSAurelien Jarno if (temp != -1) { 18287f6ceedfSAurelien Jarno tcg_reg_sync(s, reg); 18297f6ceedfSAurelien Jarno s->temps[temp].val_type = TEMP_VAL_MEM; 1830c896fe29Sbellard s->reg_to_temp[reg] = -1; 1831c896fe29Sbellard } 1832c896fe29Sbellard } 1833c896fe29Sbellard 1834c896fe29Sbellard /* Allocate a register belonging to reg1 & ~reg2 */ 1835c896fe29Sbellard static int tcg_reg_alloc(TCGContext *s, TCGRegSet reg1, TCGRegSet reg2) 1836c896fe29Sbellard { 1837c896fe29Sbellard int i, reg; 1838c896fe29Sbellard TCGRegSet reg_ct; 1839c896fe29Sbellard 1840c896fe29Sbellard tcg_regset_andnot(reg_ct, reg1, reg2); 1841c896fe29Sbellard 1842c896fe29Sbellard /* first try free registers */ 18430954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1844c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1845c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg) && s->reg_to_temp[reg] == -1) 1846c896fe29Sbellard return reg; 1847c896fe29Sbellard } 1848c896fe29Sbellard 1849c896fe29Sbellard /* XXX: do better spill choice */ 18500954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1851c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1852c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg)) { 1853c896fe29Sbellard tcg_reg_free(s, reg); 1854c896fe29Sbellard return reg; 1855c896fe29Sbellard } 1856c896fe29Sbellard } 1857c896fe29Sbellard 1858c896fe29Sbellard tcg_abort(); 1859c896fe29Sbellard } 1860c896fe29Sbellard 1861639368ddSAurelien Jarno /* mark a temporary as dead. */ 1862639368ddSAurelien Jarno static inline void temp_dead(TCGContext *s, int temp) 1863639368ddSAurelien Jarno { 1864639368ddSAurelien Jarno TCGTemp *ts; 1865639368ddSAurelien Jarno 1866639368ddSAurelien Jarno ts = &s->temps[temp]; 1867639368ddSAurelien Jarno if (!ts->fixed_reg) { 1868639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 1869639368ddSAurelien Jarno s->reg_to_temp[ts->reg] = -1; 1870639368ddSAurelien Jarno } 1871e5138db5SAurelien Jarno if (temp < s->nb_globals || ts->temp_local) { 1872639368ddSAurelien Jarno ts->val_type = TEMP_VAL_MEM; 1873639368ddSAurelien Jarno } else { 1874639368ddSAurelien Jarno ts->val_type = TEMP_VAL_DEAD; 1875639368ddSAurelien Jarno } 1876639368ddSAurelien Jarno } 1877639368ddSAurelien Jarno } 1878639368ddSAurelien Jarno 18791ad80729SAurelien Jarno /* sync a temporary to memory. 'allocated_regs' is used in case a 1880e8996ee0Sbellard temporary registers needs to be allocated to store a constant. */ 18811ad80729SAurelien Jarno static inline void temp_sync(TCGContext *s, int temp, TCGRegSet allocated_regs) 1882c896fe29Sbellard { 1883c896fe29Sbellard TCGTemp *ts; 1884c896fe29Sbellard 1885641d5fbeSbellard ts = &s->temps[temp]; 1886c896fe29Sbellard if (!ts->fixed_reg) { 1887e8996ee0Sbellard switch(ts->val_type) { 18881ad80729SAurelien Jarno case TEMP_VAL_CONST: 18891ad80729SAurelien Jarno ts->reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 18901ad80729SAurelien Jarno allocated_regs); 18911ad80729SAurelien Jarno ts->val_type = TEMP_VAL_REG; 18921ad80729SAurelien Jarno s->reg_to_temp[ts->reg] = temp; 18931ad80729SAurelien Jarno ts->mem_coherent = 0; 18941ad80729SAurelien Jarno tcg_out_movi(s, ts->type, ts->reg, ts->val); 18951ad80729SAurelien Jarno /* fallthrough*/ 1896e8996ee0Sbellard case TEMP_VAL_REG: 18971ad80729SAurelien Jarno tcg_reg_sync(s, ts->reg); 1898e8996ee0Sbellard break; 1899e8996ee0Sbellard case TEMP_VAL_DEAD: 1900e8996ee0Sbellard case TEMP_VAL_MEM: 1901e8996ee0Sbellard break; 1902e8996ee0Sbellard default: 1903e8996ee0Sbellard tcg_abort(); 1904c896fe29Sbellard } 1905c896fe29Sbellard } 1906c896fe29Sbellard } 1907641d5fbeSbellard 19081ad80729SAurelien Jarno /* save a temporary to memory. 'allocated_regs' is used in case a 19091ad80729SAurelien Jarno temporary registers needs to be allocated to store a constant. */ 19101ad80729SAurelien Jarno static inline void temp_save(TCGContext *s, int temp, TCGRegSet allocated_regs) 19111ad80729SAurelien Jarno { 19122c0366f0SAurelien Jarno #ifdef USE_LIVENESS_ANALYSIS 19132c0366f0SAurelien Jarno /* The liveness analysis already ensures that globals are back 19142c0366f0SAurelien Jarno in memory. Keep an assert for safety. */ 19152c0366f0SAurelien Jarno assert(s->temps[temp].val_type == TEMP_VAL_MEM || s->temps[temp].fixed_reg); 19162c0366f0SAurelien Jarno #else 19171ad80729SAurelien Jarno temp_sync(s, temp, allocated_regs); 19181ad80729SAurelien Jarno temp_dead(s, temp); 19192c0366f0SAurelien Jarno #endif 19201ad80729SAurelien Jarno } 19211ad80729SAurelien Jarno 19229814dd27SDong Xu Wang /* save globals to their canonical location and assume they can be 1923641d5fbeSbellard modified be the following code. 'allocated_regs' is used in case a 1924641d5fbeSbellard temporary registers needs to be allocated to store a constant. */ 1925641d5fbeSbellard static void save_globals(TCGContext *s, TCGRegSet allocated_regs) 1926641d5fbeSbellard { 1927641d5fbeSbellard int i; 1928641d5fbeSbellard 1929641d5fbeSbellard for(i = 0; i < s->nb_globals; i++) { 1930641d5fbeSbellard temp_save(s, i, allocated_regs); 1931641d5fbeSbellard } 1932e5097dc8Sbellard } 1933e5097dc8Sbellard 19343d5c5f87SAurelien Jarno /* sync globals to their canonical location and assume they can be 19353d5c5f87SAurelien Jarno read by the following code. 'allocated_regs' is used in case a 19363d5c5f87SAurelien Jarno temporary registers needs to be allocated to store a constant. */ 19373d5c5f87SAurelien Jarno static void sync_globals(TCGContext *s, TCGRegSet allocated_regs) 19383d5c5f87SAurelien Jarno { 19393d5c5f87SAurelien Jarno int i; 19403d5c5f87SAurelien Jarno 19413d5c5f87SAurelien Jarno for (i = 0; i < s->nb_globals; i++) { 19423d5c5f87SAurelien Jarno #ifdef USE_LIVENESS_ANALYSIS 19433d5c5f87SAurelien Jarno assert(s->temps[i].val_type != TEMP_VAL_REG || s->temps[i].fixed_reg || 19443d5c5f87SAurelien Jarno s->temps[i].mem_coherent); 19453d5c5f87SAurelien Jarno #else 19463d5c5f87SAurelien Jarno temp_sync(s, i, allocated_regs); 19473d5c5f87SAurelien Jarno #endif 19483d5c5f87SAurelien Jarno } 19493d5c5f87SAurelien Jarno } 19503d5c5f87SAurelien Jarno 1951e5097dc8Sbellard /* at the end of a basic block, we assume all temporaries are dead and 1952e8996ee0Sbellard all globals are stored at their canonical location. */ 1953e8996ee0Sbellard static void tcg_reg_alloc_bb_end(TCGContext *s, TCGRegSet allocated_regs) 1954e5097dc8Sbellard { 1955e5097dc8Sbellard TCGTemp *ts; 1956e5097dc8Sbellard int i; 1957e5097dc8Sbellard 1958c896fe29Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 1959c896fe29Sbellard ts = &s->temps[i]; 1960641d5fbeSbellard if (ts->temp_local) { 1961641d5fbeSbellard temp_save(s, i, allocated_regs); 1962641d5fbeSbellard } else { 19632c0366f0SAurelien Jarno #ifdef USE_LIVENESS_ANALYSIS 19642c0366f0SAurelien Jarno /* The liveness analysis already ensures that temps are dead. 19652c0366f0SAurelien Jarno Keep an assert for safety. */ 19662c0366f0SAurelien Jarno assert(ts->val_type == TEMP_VAL_DEAD); 19672c0366f0SAurelien Jarno #else 1968639368ddSAurelien Jarno temp_dead(s, i); 19692c0366f0SAurelien Jarno #endif 1970c896fe29Sbellard } 1971641d5fbeSbellard } 1972e8996ee0Sbellard 1973e8996ee0Sbellard save_globals(s, allocated_regs); 1974c896fe29Sbellard } 1975c896fe29Sbellard 1976866cb6cbSAurelien Jarno #define IS_DEAD_ARG(n) ((dead_args >> (n)) & 1) 1977ec7a869dSAurelien Jarno #define NEED_SYNC_ARG(n) ((sync_args >> (n)) & 1) 1978c896fe29Sbellard 1979ec7a869dSAurelien Jarno static void tcg_reg_alloc_movi(TCGContext *s, const TCGArg *args, 1980ec7a869dSAurelien Jarno uint16_t dead_args, uint8_t sync_args) 1981e8996ee0Sbellard { 1982e8996ee0Sbellard TCGTemp *ots; 1983e8996ee0Sbellard tcg_target_ulong val; 1984e8996ee0Sbellard 1985e8996ee0Sbellard ots = &s->temps[args[0]]; 1986e8996ee0Sbellard val = args[1]; 1987e8996ee0Sbellard 1988e8996ee0Sbellard if (ots->fixed_reg) { 1989e8996ee0Sbellard /* for fixed registers, we do not do any constant 1990e8996ee0Sbellard propagation */ 1991e8996ee0Sbellard tcg_out_movi(s, ots->type, ots->reg, val); 1992e8996ee0Sbellard } else { 19931235fc06Sths /* The movi is not explicitly generated here */ 1994e8996ee0Sbellard if (ots->val_type == TEMP_VAL_REG) 1995e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 1996e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 1997e8996ee0Sbellard ots->val = val; 1998e8996ee0Sbellard } 1999ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(0)) { 2000ec7a869dSAurelien Jarno temp_sync(s, args[0], s->reserved_regs); 2001ec7a869dSAurelien Jarno } 20024c4e1ab2SAurelien Jarno if (IS_DEAD_ARG(0)) { 20034c4e1ab2SAurelien Jarno temp_dead(s, args[0]); 20044c4e1ab2SAurelien Jarno } 2005e8996ee0Sbellard } 2006e8996ee0Sbellard 2007c896fe29Sbellard static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def, 2008ec7a869dSAurelien Jarno const TCGArg *args, uint16_t dead_args, 2009ec7a869dSAurelien Jarno uint8_t sync_args) 2010c896fe29Sbellard { 2011c29c1d7eSAurelien Jarno TCGRegSet allocated_regs; 2012c896fe29Sbellard TCGTemp *ts, *ots; 2013c29c1d7eSAurelien Jarno const TCGArgConstraint *arg_ct, *oarg_ct; 2014c896fe29Sbellard 2015c29c1d7eSAurelien Jarno tcg_regset_set(allocated_regs, s->reserved_regs); 2016c896fe29Sbellard ots = &s->temps[args[0]]; 2017c896fe29Sbellard ts = &s->temps[args[1]]; 2018c29c1d7eSAurelien Jarno oarg_ct = &def->args_ct[0]; 2019c29c1d7eSAurelien Jarno arg_ct = &def->args_ct[1]; 2020c896fe29Sbellard 2021c29c1d7eSAurelien Jarno /* If the source value is not in a register, and we're going to be 2022c29c1d7eSAurelien Jarno forced to have it in a register in order to perform the copy, 2023c29c1d7eSAurelien Jarno then copy the SOURCE value into its own register first. That way 2024c29c1d7eSAurelien Jarno we don't have to reload SOURCE the next time it is used. */ 2025c29c1d7eSAurelien Jarno if (((NEED_SYNC_ARG(0) || ots->fixed_reg) && ts->val_type != TEMP_VAL_REG) 2026c29c1d7eSAurelien Jarno || ts->val_type == TEMP_VAL_MEM) { 2027c29c1d7eSAurelien Jarno ts->reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2028c29c1d7eSAurelien Jarno if (ts->val_type == TEMP_VAL_MEM) { 2029c29c1d7eSAurelien Jarno tcg_out_ld(s, ts->type, ts->reg, ts->mem_reg, ts->mem_offset); 2030c29c1d7eSAurelien Jarno ts->mem_coherent = 1; 2031c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2032c29c1d7eSAurelien Jarno tcg_out_movi(s, ts->type, ts->reg, ts->val); 2033c29c1d7eSAurelien Jarno } 2034c29c1d7eSAurelien Jarno s->reg_to_temp[ts->reg] = args[1]; 2035c29c1d7eSAurelien Jarno ts->val_type = TEMP_VAL_REG; 2036c29c1d7eSAurelien Jarno } 2037c29c1d7eSAurelien Jarno 2038c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(0) && !ots->fixed_reg) { 2039c29c1d7eSAurelien Jarno /* mov to a non-saved dead register makes no sense (even with 2040c29c1d7eSAurelien Jarno liveness analysis disabled). */ 2041c29c1d7eSAurelien Jarno assert(NEED_SYNC_ARG(0)); 2042c29c1d7eSAurelien Jarno /* The code above should have moved the temp to a register. */ 2043c29c1d7eSAurelien Jarno assert(ts->val_type == TEMP_VAL_REG); 2044c29c1d7eSAurelien Jarno if (!ots->mem_allocated) { 2045c29c1d7eSAurelien Jarno temp_allocate_frame(s, args[0]); 2046c29c1d7eSAurelien Jarno } 2047c29c1d7eSAurelien Jarno tcg_out_st(s, ots->type, ts->reg, ots->mem_reg, ots->mem_offset); 2048c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(1)) { 2049c29c1d7eSAurelien Jarno temp_dead(s, args[1]); 2050c29c1d7eSAurelien Jarno } 2051c29c1d7eSAurelien Jarno temp_dead(s, args[0]); 2052c29c1d7eSAurelien Jarno } else if (ts->val_type == TEMP_VAL_CONST) { 2053e8996ee0Sbellard /* propagate constant */ 2054c29c1d7eSAurelien Jarno if (ots->val_type == TEMP_VAL_REG) { 2055e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 2056c29c1d7eSAurelien Jarno } 2057e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 2058e8996ee0Sbellard ots->val = ts->val; 2059e8996ee0Sbellard } else { 2060c29c1d7eSAurelien Jarno /* The code in the first if block should have moved the 2061c29c1d7eSAurelien Jarno temp to a register. */ 2062c29c1d7eSAurelien Jarno assert(ts->val_type == TEMP_VAL_REG); 2063c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(1) && !ts->fixed_reg && !ots->fixed_reg) { 2064c29c1d7eSAurelien Jarno /* the mov can be suppressed */ 2065c29c1d7eSAurelien Jarno if (ots->val_type == TEMP_VAL_REG) { 2066c29c1d7eSAurelien Jarno s->reg_to_temp[ots->reg] = -1; 2067c896fe29Sbellard } 2068c29c1d7eSAurelien Jarno ots->reg = ts->reg; 2069c29c1d7eSAurelien Jarno temp_dead(s, args[1]); 2070c29c1d7eSAurelien Jarno } else { 2071c29c1d7eSAurelien Jarno if (ots->val_type != TEMP_VAL_REG) { 2072c29c1d7eSAurelien Jarno /* When allocating a new register, make sure to not spill the 2073c29c1d7eSAurelien Jarno input one. */ 2074c29c1d7eSAurelien Jarno tcg_regset_set_reg(allocated_regs, ts->reg); 2075c29c1d7eSAurelien Jarno ots->reg = tcg_reg_alloc(s, oarg_ct->u.regs, allocated_regs); 2076c29c1d7eSAurelien Jarno } 2077c29c1d7eSAurelien Jarno tcg_out_mov(s, ots->type, ots->reg, ts->reg); 2078c29c1d7eSAurelien Jarno } 2079c896fe29Sbellard ots->val_type = TEMP_VAL_REG; 2080c896fe29Sbellard ots->mem_coherent = 0; 2081c29c1d7eSAurelien Jarno s->reg_to_temp[ots->reg] = args[0]; 2082ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(0)) { 2083c29c1d7eSAurelien Jarno tcg_reg_sync(s, ots->reg); 2084c29c1d7eSAurelien Jarno } 2085ec7a869dSAurelien Jarno } 2086c896fe29Sbellard } 2087c896fe29Sbellard 2088c896fe29Sbellard static void tcg_reg_alloc_op(TCGContext *s, 2089a9751609SRichard Henderson const TCGOpDef *def, TCGOpcode opc, 2090ec7a869dSAurelien Jarno const TCGArg *args, uint16_t dead_args, 2091ec7a869dSAurelien Jarno uint8_t sync_args) 2092c896fe29Sbellard { 2093c896fe29Sbellard TCGRegSet allocated_regs; 2094c896fe29Sbellard int i, k, nb_iargs, nb_oargs, reg; 2095c896fe29Sbellard TCGArg arg; 2096c896fe29Sbellard const TCGArgConstraint *arg_ct; 2097c896fe29Sbellard TCGTemp *ts; 2098c896fe29Sbellard TCGArg new_args[TCG_MAX_OP_ARGS]; 2099c896fe29Sbellard int const_args[TCG_MAX_OP_ARGS]; 2100c896fe29Sbellard 2101c896fe29Sbellard nb_oargs = def->nb_oargs; 2102c896fe29Sbellard nb_iargs = def->nb_iargs; 2103c896fe29Sbellard 2104c896fe29Sbellard /* copy constants */ 2105c896fe29Sbellard memcpy(new_args + nb_oargs + nb_iargs, 2106c896fe29Sbellard args + nb_oargs + nb_iargs, 2107c896fe29Sbellard sizeof(TCGArg) * def->nb_cargs); 2108c896fe29Sbellard 2109c896fe29Sbellard /* satisfy input constraints */ 2110c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 2111c896fe29Sbellard for(k = 0; k < nb_iargs; k++) { 2112c896fe29Sbellard i = def->sorted_args[nb_oargs + k]; 2113c896fe29Sbellard arg = args[i]; 2114c896fe29Sbellard arg_ct = &def->args_ct[i]; 2115c896fe29Sbellard ts = &s->temps[arg]; 2116c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 2117c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2118e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2119c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 2120c896fe29Sbellard ts->reg = reg; 2121c896fe29Sbellard ts->mem_coherent = 1; 2122c896fe29Sbellard s->reg_to_temp[reg] = arg; 2123c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2124c896fe29Sbellard if (tcg_target_const_match(ts->val, arg_ct)) { 2125c896fe29Sbellard /* constant is OK for instruction */ 2126c896fe29Sbellard const_args[i] = 1; 2127c896fe29Sbellard new_args[i] = ts->val; 2128c896fe29Sbellard goto iarg_end; 2129c896fe29Sbellard } else { 2130c896fe29Sbellard /* need to move to a register */ 2131c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2132c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 2133e8996ee0Sbellard ts->val_type = TEMP_VAL_REG; 2134e8996ee0Sbellard ts->reg = reg; 2135e8996ee0Sbellard ts->mem_coherent = 0; 2136e8996ee0Sbellard s->reg_to_temp[reg] = arg; 2137c896fe29Sbellard } 2138c896fe29Sbellard } 2139c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 21405ff9d6a4Sbellard if (arg_ct->ct & TCG_CT_IALIAS) { 21415ff9d6a4Sbellard if (ts->fixed_reg) { 21425ff9d6a4Sbellard /* if fixed register, we must allocate a new register 21435ff9d6a4Sbellard if the alias is not the same register */ 21445ff9d6a4Sbellard if (arg != args[arg_ct->alias_index]) 21455ff9d6a4Sbellard goto allocate_in_reg; 21465ff9d6a4Sbellard } else { 2147c896fe29Sbellard /* if the input is aliased to an output and if it is 2148c896fe29Sbellard not dead after the instruction, we must allocate 2149c896fe29Sbellard a new register and move it */ 2150866cb6cbSAurelien Jarno if (!IS_DEAD_ARG(i)) { 2151c896fe29Sbellard goto allocate_in_reg; 2152c896fe29Sbellard } 21535ff9d6a4Sbellard } 2154866cb6cbSAurelien Jarno } 2155c896fe29Sbellard reg = ts->reg; 2156c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, reg)) { 2157c896fe29Sbellard /* nothing to do : the constraint is satisfied */ 2158c896fe29Sbellard } else { 2159c896fe29Sbellard allocate_in_reg: 2160c896fe29Sbellard /* allocate a new register matching the constraint 2161c896fe29Sbellard and move the temporary register into it */ 2162c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 21633b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 2164c896fe29Sbellard } 2165c896fe29Sbellard new_args[i] = reg; 2166c896fe29Sbellard const_args[i] = 0; 2167c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 2168c896fe29Sbellard iarg_end: ; 2169c896fe29Sbellard } 2170c896fe29Sbellard 2171c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 2172866cb6cbSAurelien Jarno for (i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 2173866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 2174639368ddSAurelien Jarno temp_dead(s, args[i]); 2175c896fe29Sbellard } 2176c896fe29Sbellard } 2177c896fe29Sbellard 2178a52ad07eSAurelien Jarno if (def->flags & TCG_OPF_BB_END) { 2179a52ad07eSAurelien Jarno tcg_reg_alloc_bb_end(s, allocated_regs); 2180a52ad07eSAurelien Jarno } else { 2181c896fe29Sbellard if (def->flags & TCG_OPF_CALL_CLOBBER) { 2182b03cce8eSbellard /* XXX: permit generic clobber register list ? */ 2183c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 2184c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 2185c896fe29Sbellard tcg_reg_free(s, reg); 2186c896fe29Sbellard } 2187c896fe29Sbellard } 21883d5c5f87SAurelien Jarno } 21893d5c5f87SAurelien Jarno if (def->flags & TCG_OPF_SIDE_EFFECTS) { 21903d5c5f87SAurelien Jarno /* sync globals if the op has side effects and might trigger 21913d5c5f87SAurelien Jarno an exception. */ 21923d5c5f87SAurelien Jarno sync_globals(s, allocated_regs); 2193c896fe29Sbellard } 2194c896fe29Sbellard 2195c896fe29Sbellard /* satisfy the output constraints */ 2196c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 2197c896fe29Sbellard for(k = 0; k < nb_oargs; k++) { 2198c896fe29Sbellard i = def->sorted_args[k]; 2199c896fe29Sbellard arg = args[i]; 2200c896fe29Sbellard arg_ct = &def->args_ct[i]; 2201c896fe29Sbellard ts = &s->temps[arg]; 2202c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 22035ff9d6a4Sbellard reg = new_args[arg_ct->alias_index]; 2204c896fe29Sbellard } else { 2205c896fe29Sbellard /* if fixed register, we try to use it */ 2206c896fe29Sbellard reg = ts->reg; 2207c896fe29Sbellard if (ts->fixed_reg && 2208c896fe29Sbellard tcg_regset_test_reg(arg_ct->u.regs, reg)) { 2209c896fe29Sbellard goto oarg_end; 2210c896fe29Sbellard } 2211c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2212c896fe29Sbellard } 2213c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 2214c896fe29Sbellard /* if a fixed register is used, then a move will be done afterwards */ 2215c896fe29Sbellard if (!ts->fixed_reg) { 2216639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 2217639368ddSAurelien Jarno s->reg_to_temp[ts->reg] = -1; 2218639368ddSAurelien Jarno } 2219c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 2220c896fe29Sbellard ts->reg = reg; 2221c896fe29Sbellard /* temp value is modified, so the value kept in memory is 2222c896fe29Sbellard potentially not the same */ 2223c896fe29Sbellard ts->mem_coherent = 0; 2224c896fe29Sbellard s->reg_to_temp[reg] = arg; 2225c896fe29Sbellard } 2226c896fe29Sbellard oarg_end: 2227c896fe29Sbellard new_args[i] = reg; 2228c896fe29Sbellard } 2229e8996ee0Sbellard } 2230c896fe29Sbellard 2231c896fe29Sbellard /* emit instruction */ 2232c896fe29Sbellard tcg_out_op(s, opc, new_args, const_args); 2233c896fe29Sbellard 2234c896fe29Sbellard /* move the outputs in the correct register if needed */ 2235c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 2236c896fe29Sbellard ts = &s->temps[args[i]]; 2237c896fe29Sbellard reg = new_args[i]; 2238c896fe29Sbellard if (ts->fixed_reg && ts->reg != reg) { 22393b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 2240c896fe29Sbellard } 2241ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(i)) { 2242ec7a869dSAurelien Jarno tcg_reg_sync(s, reg); 2243ec7a869dSAurelien Jarno } 2244ec7a869dSAurelien Jarno if (IS_DEAD_ARG(i)) { 2245ec7a869dSAurelien Jarno temp_dead(s, args[i]); 2246ec7a869dSAurelien Jarno } 2247c896fe29Sbellard } 2248c896fe29Sbellard } 2249c896fe29Sbellard 2250b03cce8eSbellard #ifdef TCG_TARGET_STACK_GROWSUP 2251b03cce8eSbellard #define STACK_DIR(x) (-(x)) 2252b03cce8eSbellard #else 2253b03cce8eSbellard #define STACK_DIR(x) (x) 2254b03cce8eSbellard #endif 2255b03cce8eSbellard 2256c896fe29Sbellard static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def, 2257a9751609SRichard Henderson TCGOpcode opc, const TCGArg *args, 2258ec7a869dSAurelien Jarno uint16_t dead_args, uint8_t sync_args) 2259c896fe29Sbellard { 2260c896fe29Sbellard int nb_iargs, nb_oargs, flags, nb_regs, i, reg, nb_params; 2261c896fe29Sbellard TCGArg arg, func_arg; 2262c896fe29Sbellard TCGTemp *ts; 2263d3452f1fSRichard Henderson intptr_t stack_offset; 2264d3452f1fSRichard Henderson size_t call_stack_size; 2265d3452f1fSRichard Henderson uintptr_t func_addr; 2266b03cce8eSbellard int const_func_arg, allocate_args; 2267c896fe29Sbellard TCGRegSet allocated_regs; 2268c896fe29Sbellard const TCGArgConstraint *arg_ct; 2269c896fe29Sbellard 2270c896fe29Sbellard arg = *args++; 2271c896fe29Sbellard 2272c896fe29Sbellard nb_oargs = arg >> 16; 2273c896fe29Sbellard nb_iargs = arg & 0xffff; 2274c896fe29Sbellard nb_params = nb_iargs - 1; 2275c896fe29Sbellard 2276c896fe29Sbellard flags = args[nb_oargs + nb_iargs]; 2277c896fe29Sbellard 22786e17d0c5SStefan Weil nb_regs = ARRAY_SIZE(tcg_target_call_iarg_regs); 2279c896fe29Sbellard if (nb_regs > nb_params) 2280c896fe29Sbellard nb_regs = nb_params; 2281c896fe29Sbellard 2282c896fe29Sbellard /* assign stack slots first */ 2283c896fe29Sbellard call_stack_size = (nb_params - nb_regs) * sizeof(tcg_target_long); 2284c896fe29Sbellard call_stack_size = (call_stack_size + TCG_TARGET_STACK_ALIGN - 1) & 2285c896fe29Sbellard ~(TCG_TARGET_STACK_ALIGN - 1); 2286b03cce8eSbellard allocate_args = (call_stack_size > TCG_STATIC_CALL_ARGS_SIZE); 2287b03cce8eSbellard if (allocate_args) { 2288345649c0SBlue Swirl /* XXX: if more than TCG_STATIC_CALL_ARGS_SIZE is needed, 2289345649c0SBlue Swirl preallocate call stack */ 2290345649c0SBlue Swirl tcg_abort(); 2291b03cce8eSbellard } 229239cf05d3Sbellard 229339cf05d3Sbellard stack_offset = TCG_TARGET_CALL_STACK_OFFSET; 2294c896fe29Sbellard for(i = nb_regs; i < nb_params; i++) { 2295c896fe29Sbellard arg = args[nb_oargs + i]; 229639cf05d3Sbellard #ifdef TCG_TARGET_STACK_GROWSUP 229739cf05d3Sbellard stack_offset -= sizeof(tcg_target_long); 229839cf05d3Sbellard #endif 229939cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 2300c896fe29Sbellard ts = &s->temps[arg]; 2301c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 2302e4d5434cSblueswir1 tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset); 2303c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 2304c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 2305c896fe29Sbellard s->reserved_regs); 2306c896fe29Sbellard /* XXX: not correct if reading values from the stack */ 2307e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2308e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 2309c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2310c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 2311c896fe29Sbellard s->reserved_regs); 2312c896fe29Sbellard /* XXX: sign extend may be needed on some targets */ 2313c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 2314e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 2315c896fe29Sbellard } else { 2316c896fe29Sbellard tcg_abort(); 2317c896fe29Sbellard } 231839cf05d3Sbellard } 231939cf05d3Sbellard #ifndef TCG_TARGET_STACK_GROWSUP 232039cf05d3Sbellard stack_offset += sizeof(tcg_target_long); 232139cf05d3Sbellard #endif 2322c896fe29Sbellard } 2323c896fe29Sbellard 2324c896fe29Sbellard /* assign input registers */ 2325c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 2326c896fe29Sbellard for(i = 0; i < nb_regs; i++) { 2327c896fe29Sbellard arg = args[nb_oargs + i]; 232839cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 2329c896fe29Sbellard ts = &s->temps[arg]; 2330c896fe29Sbellard reg = tcg_target_call_iarg_regs[i]; 2331c896fe29Sbellard tcg_reg_free(s, reg); 2332c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 2333c896fe29Sbellard if (ts->reg != reg) { 23343b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 2335c896fe29Sbellard } 2336c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 2337e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2338c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2339c896fe29Sbellard /* XXX: sign extend ? */ 2340c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 2341c896fe29Sbellard } else { 2342c896fe29Sbellard tcg_abort(); 2343c896fe29Sbellard } 2344c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 2345c896fe29Sbellard } 234639cf05d3Sbellard } 2347c896fe29Sbellard 2348c896fe29Sbellard /* assign function address */ 2349c896fe29Sbellard func_arg = args[nb_oargs + nb_iargs - 1]; 2350c896fe29Sbellard arg_ct = &def->args_ct[0]; 2351c896fe29Sbellard ts = &s->temps[func_arg]; 2352f54b3f92Saurel32 func_addr = ts->val; 2353c896fe29Sbellard const_func_arg = 0; 2354c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 2355c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2356e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2357c896fe29Sbellard func_arg = reg; 2358e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 2359c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_REG) { 2360c896fe29Sbellard reg = ts->reg; 2361c896fe29Sbellard if (!tcg_regset_test_reg(arg_ct->u.regs, reg)) { 2362c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 23633b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 2364c896fe29Sbellard } 2365c896fe29Sbellard func_arg = reg; 2366e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 2367c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2368f54b3f92Saurel32 if (tcg_target_const_match(func_addr, arg_ct)) { 2369c896fe29Sbellard const_func_arg = 1; 2370f54b3f92Saurel32 func_arg = func_addr; 2371c896fe29Sbellard } else { 2372c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2373f54b3f92Saurel32 tcg_out_movi(s, ts->type, reg, func_addr); 2374c896fe29Sbellard func_arg = reg; 2375e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 2376c896fe29Sbellard } 2377c896fe29Sbellard } else { 2378c896fe29Sbellard tcg_abort(); 2379c896fe29Sbellard } 2380c896fe29Sbellard 2381e8996ee0Sbellard 2382c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 2383866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 2384866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 2385639368ddSAurelien Jarno temp_dead(s, args[i]); 2386c896fe29Sbellard } 2387c896fe29Sbellard } 2388c896fe29Sbellard 2389c896fe29Sbellard /* clobber call registers */ 2390c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 2391c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 2392c896fe29Sbellard tcg_reg_free(s, reg); 2393c896fe29Sbellard } 2394c896fe29Sbellard } 2395c896fe29Sbellard 239678505279SAurelien Jarno /* Save globals if they might be written by the helper, sync them if 239778505279SAurelien Jarno they might be read. */ 239878505279SAurelien Jarno if (flags & TCG_CALL_NO_READ_GLOBALS) { 239978505279SAurelien Jarno /* Nothing to do */ 240078505279SAurelien Jarno } else if (flags & TCG_CALL_NO_WRITE_GLOBALS) { 240178505279SAurelien Jarno sync_globals(s, allocated_regs); 240278505279SAurelien Jarno } else { 2403e8996ee0Sbellard save_globals(s, allocated_regs); 2404b9c18f56Saurel32 } 2405c896fe29Sbellard 2406c896fe29Sbellard tcg_out_op(s, opc, &func_arg, &const_func_arg); 2407c896fe29Sbellard 2408c896fe29Sbellard /* assign output registers and emit moves if needed */ 2409c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 2410c896fe29Sbellard arg = args[i]; 2411c896fe29Sbellard ts = &s->temps[arg]; 2412c896fe29Sbellard reg = tcg_target_call_oarg_regs[i]; 2413e8996ee0Sbellard assert(s->reg_to_temp[reg] == -1); 2414c896fe29Sbellard if (ts->fixed_reg) { 2415c896fe29Sbellard if (ts->reg != reg) { 24163b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 2417c896fe29Sbellard } 2418c896fe29Sbellard } else { 2419639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 2420639368ddSAurelien Jarno s->reg_to_temp[ts->reg] = -1; 2421639368ddSAurelien Jarno } 2422c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 2423c896fe29Sbellard ts->reg = reg; 2424c896fe29Sbellard ts->mem_coherent = 0; 2425c896fe29Sbellard s->reg_to_temp[reg] = arg; 2426ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(i)) { 2427ec7a869dSAurelien Jarno tcg_reg_sync(s, reg); 2428ec7a869dSAurelien Jarno } 2429ec7a869dSAurelien Jarno if (IS_DEAD_ARG(i)) { 2430ec7a869dSAurelien Jarno temp_dead(s, args[i]); 2431c896fe29Sbellard } 2432c896fe29Sbellard } 24338c11ad25SAurelien Jarno } 2434c896fe29Sbellard 2435c896fe29Sbellard return nb_iargs + nb_oargs + def->nb_cargs + 1; 2436c896fe29Sbellard } 2437c896fe29Sbellard 2438c896fe29Sbellard #ifdef CONFIG_PROFILER 2439c896fe29Sbellard 244054604f74Saurel32 static int64_t tcg_table_op_count[NB_OPS]; 2441c896fe29Sbellard 2442871e6c35SBlue Swirl static void dump_op_count(void) 2443c896fe29Sbellard { 2444c896fe29Sbellard int i; 2445c896fe29Sbellard FILE *f; 244654604f74Saurel32 f = fopen("/tmp/op.log", "w"); 2447c896fe29Sbellard for(i = INDEX_op_end; i < NB_OPS; i++) { 244854604f74Saurel32 fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, tcg_table_op_count[i]); 2449c896fe29Sbellard } 2450c896fe29Sbellard fclose(f); 2451c896fe29Sbellard } 2452c896fe29Sbellard #endif 2453c896fe29Sbellard 2454c896fe29Sbellard 2455c896fe29Sbellard static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf, 24562ba1eeb6Spbrook long search_pc) 2457c896fe29Sbellard { 2458a9751609SRichard Henderson TCGOpcode opc; 2459a9751609SRichard Henderson int op_index; 2460c896fe29Sbellard const TCGOpDef *def; 2461c896fe29Sbellard const TCGArg *args; 2462c896fe29Sbellard 2463c896fe29Sbellard #ifdef DEBUG_DISAS 24648fec2b8cSaliguori if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) { 246593fcfe39Saliguori qemu_log("OP:\n"); 2466eeacee4dSBlue Swirl tcg_dump_ops(s); 246793fcfe39Saliguori qemu_log("\n"); 2468c896fe29Sbellard } 2469c896fe29Sbellard #endif 2470c896fe29Sbellard 2471c5cc28ffSAurelien Jarno #ifdef CONFIG_PROFILER 2472c5cc28ffSAurelien Jarno s->opt_time -= profile_getclock(); 2473c5cc28ffSAurelien Jarno #endif 2474c5cc28ffSAurelien Jarno 24758f2e8c07SKirill Batuzov #ifdef USE_TCG_OPTIMIZATIONS 2476c4afe5c4SEvgeny Voevodin s->gen_opparam_ptr = 24771ff0a2c5SEvgeny Voevodin tcg_optimize(s, s->gen_opc_ptr, s->gen_opparam_buf, tcg_op_defs); 24788f2e8c07SKirill Batuzov #endif 24798f2e8c07SKirill Batuzov 2480a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2481c5cc28ffSAurelien Jarno s->opt_time += profile_getclock(); 2482a23a9ec6Sbellard s->la_time -= profile_getclock(); 2483a23a9ec6Sbellard #endif 2484c5cc28ffSAurelien Jarno 2485c896fe29Sbellard tcg_liveness_analysis(s); 2486c5cc28ffSAurelien Jarno 2487a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2488a23a9ec6Sbellard s->la_time += profile_getclock(); 2489a23a9ec6Sbellard #endif 2490c896fe29Sbellard 2491c896fe29Sbellard #ifdef DEBUG_DISAS 24928fec2b8cSaliguori if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT))) { 2493c5cc28ffSAurelien Jarno qemu_log("OP after optimization and liveness analysis:\n"); 2494eeacee4dSBlue Swirl tcg_dump_ops(s); 249593fcfe39Saliguori qemu_log("\n"); 2496c896fe29Sbellard } 2497c896fe29Sbellard #endif 2498c896fe29Sbellard 2499c896fe29Sbellard tcg_reg_alloc_start(s); 2500c896fe29Sbellard 2501c896fe29Sbellard s->code_buf = gen_code_buf; 2502c896fe29Sbellard s->code_ptr = gen_code_buf; 2503c896fe29Sbellard 25049ecefc84SRichard Henderson tcg_out_tb_init(s); 25059ecefc84SRichard Henderson 25061ff0a2c5SEvgeny Voevodin args = s->gen_opparam_buf; 2507c896fe29Sbellard op_index = 0; 2508b3db8758Sblueswir1 2509c896fe29Sbellard for(;;) { 251092414b31SEvgeny Voevodin opc = s->gen_opc_buf[op_index]; 2511c896fe29Sbellard #ifdef CONFIG_PROFILER 251254604f74Saurel32 tcg_table_op_count[opc]++; 2513c896fe29Sbellard #endif 2514c896fe29Sbellard def = &tcg_op_defs[opc]; 2515c896fe29Sbellard #if 0 2516c896fe29Sbellard printf("%s: %d %d %d\n", def->name, 2517c896fe29Sbellard def->nb_oargs, def->nb_iargs, def->nb_cargs); 2518c896fe29Sbellard // dump_regs(s); 2519c896fe29Sbellard #endif 2520c896fe29Sbellard switch(opc) { 2521c896fe29Sbellard case INDEX_op_mov_i32: 2522c896fe29Sbellard case INDEX_op_mov_i64: 2523ec7a869dSAurelien Jarno tcg_reg_alloc_mov(s, def, args, s->op_dead_args[op_index], 2524ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2525c896fe29Sbellard break; 2526e8996ee0Sbellard case INDEX_op_movi_i32: 2527e8996ee0Sbellard case INDEX_op_movi_i64: 2528ec7a869dSAurelien Jarno tcg_reg_alloc_movi(s, args, s->op_dead_args[op_index], 2529ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2530e8996ee0Sbellard break; 25317e4597d7Sbellard case INDEX_op_debug_insn_start: 25327e4597d7Sbellard /* debug instruction */ 25337e4597d7Sbellard break; 2534c896fe29Sbellard case INDEX_op_nop: 2535c896fe29Sbellard case INDEX_op_nop1: 2536c896fe29Sbellard case INDEX_op_nop2: 2537c896fe29Sbellard case INDEX_op_nop3: 2538c896fe29Sbellard break; 2539c896fe29Sbellard case INDEX_op_nopn: 2540c896fe29Sbellard args += args[0]; 2541c896fe29Sbellard goto next; 25425ff9d6a4Sbellard case INDEX_op_discard: 2543639368ddSAurelien Jarno temp_dead(s, args[0]); 25445ff9d6a4Sbellard break; 2545c896fe29Sbellard case INDEX_op_set_label: 2546e8996ee0Sbellard tcg_reg_alloc_bb_end(s, s->reserved_regs); 25479d6fca70SStefan Weil tcg_out_label(s, args[0], s->code_ptr); 2548c896fe29Sbellard break; 2549c896fe29Sbellard case INDEX_op_call: 2550ec7a869dSAurelien Jarno args += tcg_reg_alloc_call(s, def, opc, args, 2551ec7a869dSAurelien Jarno s->op_dead_args[op_index], 2552ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2553c896fe29Sbellard goto next; 2554c896fe29Sbellard case INDEX_op_end: 2555c896fe29Sbellard goto the_end; 2556c896fe29Sbellard default: 255725c4d9ccSRichard Henderson /* Sanity check that we've not introduced any unhandled opcodes. */ 255825c4d9ccSRichard Henderson if (def->flags & TCG_OPF_NOT_PRESENT) { 255925c4d9ccSRichard Henderson tcg_abort(); 256025c4d9ccSRichard Henderson } 2561c896fe29Sbellard /* Note: in order to speed up the code, it would be much 2562c896fe29Sbellard faster to have specialized register allocator functions for 2563c896fe29Sbellard some common argument patterns */ 2564ec7a869dSAurelien Jarno tcg_reg_alloc_op(s, def, opc, args, s->op_dead_args[op_index], 2565ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2566c896fe29Sbellard break; 2567c896fe29Sbellard } 2568c896fe29Sbellard args += def->nb_args; 25698df1ca4bSths next: 25702ba1eeb6Spbrook if (search_pc >= 0 && search_pc < s->code_ptr - gen_code_buf) { 2571c896fe29Sbellard return op_index; 2572c896fe29Sbellard } 2573c896fe29Sbellard op_index++; 2574c896fe29Sbellard #ifndef NDEBUG 2575c896fe29Sbellard check_regs(s); 2576c896fe29Sbellard #endif 2577c896fe29Sbellard } 2578c896fe29Sbellard the_end: 2579b76f0d8cSYeongkyoon Lee /* Generate TB finalization at the end of block */ 2580b76f0d8cSYeongkyoon Lee tcg_out_tb_finalize(s); 2581c896fe29Sbellard return -1; 2582c896fe29Sbellard } 2583c896fe29Sbellard 258454604f74Saurel32 int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf) 2585c896fe29Sbellard { 2586c896fe29Sbellard #ifdef CONFIG_PROFILER 2587c896fe29Sbellard { 2588c896fe29Sbellard int n; 258992414b31SEvgeny Voevodin n = (s->gen_opc_ptr - s->gen_opc_buf); 2590a23a9ec6Sbellard s->op_count += n; 2591a23a9ec6Sbellard if (n > s->op_count_max) 2592a23a9ec6Sbellard s->op_count_max = n; 2593a23a9ec6Sbellard 2594a23a9ec6Sbellard s->temp_count += s->nb_temps; 2595a23a9ec6Sbellard if (s->nb_temps > s->temp_count_max) 2596a23a9ec6Sbellard s->temp_count_max = s->nb_temps; 2597c896fe29Sbellard } 2598c896fe29Sbellard #endif 2599c896fe29Sbellard 26002ba1eeb6Spbrook tcg_gen_code_common(s, gen_code_buf, -1); 2601c896fe29Sbellard 2602c896fe29Sbellard /* flush instruction cache */ 2603b93949efSRichard Henderson flush_icache_range((uintptr_t)gen_code_buf, (uintptr_t)s->code_ptr); 26042aeabc08SStefan Weil 2605c896fe29Sbellard return s->code_ptr - gen_code_buf; 2606c896fe29Sbellard } 2607c896fe29Sbellard 26082ba1eeb6Spbrook /* Return the index of the micro operation such as the pc after is < 2609623e265cSpbrook offset bytes from the start of the TB. The contents of gen_code_buf must 2610623e265cSpbrook not be changed, though writing the same values is ok. 2611623e265cSpbrook Return -1 if not found. */ 261254604f74Saurel32 int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset) 2613c896fe29Sbellard { 2614623e265cSpbrook return tcg_gen_code_common(s, gen_code_buf, offset); 2615c896fe29Sbellard } 2616a23a9ec6Sbellard 2617a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2618405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2619a23a9ec6Sbellard { 2620a23a9ec6Sbellard TCGContext *s = &tcg_ctx; 2621a23a9ec6Sbellard int64_t tot; 2622a23a9ec6Sbellard 2623a23a9ec6Sbellard tot = s->interm_time + s->code_time; 2624a23a9ec6Sbellard cpu_fprintf(f, "JIT cycles %" PRId64 " (%0.3f s at 2.4 GHz)\n", 2625a23a9ec6Sbellard tot, tot / 2.4e9); 2626a23a9ec6Sbellard cpu_fprintf(f, "translated TBs %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n", 2627a23a9ec6Sbellard s->tb_count, 2628a23a9ec6Sbellard s->tb_count1 - s->tb_count, 2629a23a9ec6Sbellard s->tb_count1 ? (double)(s->tb_count1 - s->tb_count) / s->tb_count1 * 100.0 : 0); 2630a23a9ec6Sbellard cpu_fprintf(f, "avg ops/TB %0.1f max=%d\n", 2631a23a9ec6Sbellard s->tb_count ? (double)s->op_count / s->tb_count : 0, s->op_count_max); 2632a23a9ec6Sbellard cpu_fprintf(f, "deleted ops/TB %0.2f\n", 2633a23a9ec6Sbellard s->tb_count ? 2634a23a9ec6Sbellard (double)s->del_op_count / s->tb_count : 0); 2635a23a9ec6Sbellard cpu_fprintf(f, "avg temps/TB %0.2f max=%d\n", 2636a23a9ec6Sbellard s->tb_count ? 2637a23a9ec6Sbellard (double)s->temp_count / s->tb_count : 0, 2638a23a9ec6Sbellard s->temp_count_max); 2639a23a9ec6Sbellard 2640a23a9ec6Sbellard cpu_fprintf(f, "cycles/op %0.1f\n", 2641a23a9ec6Sbellard s->op_count ? (double)tot / s->op_count : 0); 2642a23a9ec6Sbellard cpu_fprintf(f, "cycles/in byte %0.1f\n", 2643a23a9ec6Sbellard s->code_in_len ? (double)tot / s->code_in_len : 0); 2644a23a9ec6Sbellard cpu_fprintf(f, "cycles/out byte %0.1f\n", 2645a23a9ec6Sbellard s->code_out_len ? (double)tot / s->code_out_len : 0); 2646a23a9ec6Sbellard if (tot == 0) 2647a23a9ec6Sbellard tot = 1; 2648a23a9ec6Sbellard cpu_fprintf(f, " gen_interm time %0.1f%%\n", 2649a23a9ec6Sbellard (double)s->interm_time / tot * 100.0); 2650a23a9ec6Sbellard cpu_fprintf(f, " gen_code time %0.1f%%\n", 2651a23a9ec6Sbellard (double)s->code_time / tot * 100.0); 2652c5cc28ffSAurelien Jarno cpu_fprintf(f, "optim./code time %0.1f%%\n", 2653c5cc28ffSAurelien Jarno (double)s->opt_time / (s->code_time ? s->code_time : 1) 2654c5cc28ffSAurelien Jarno * 100.0); 2655a23a9ec6Sbellard cpu_fprintf(f, "liveness/code time %0.1f%%\n", 2656a23a9ec6Sbellard (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0); 2657a23a9ec6Sbellard cpu_fprintf(f, "cpu_restore count %" PRId64 "\n", 2658a23a9ec6Sbellard s->restore_count); 2659a23a9ec6Sbellard cpu_fprintf(f, " avg cycles %0.1f\n", 2660a23a9ec6Sbellard s->restore_count ? (double)s->restore_time / s->restore_count : 0); 2661871e6c35SBlue Swirl 2662a23a9ec6Sbellard dump_op_count(); 2663a23a9ec6Sbellard } 2664a23a9ec6Sbellard #else 2665405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2666a23a9ec6Sbellard { 266724bf7b3aSbellard cpu_fprintf(f, "[TCG profiler not compiled]\n"); 2668a23a9ec6Sbellard } 2669a23a9ec6Sbellard #endif 2670813da627SRichard Henderson 2671813da627SRichard Henderson #ifdef ELF_HOST_MACHINE 26725872bbf2SRichard Henderson /* In order to use this feature, the backend needs to do three things: 26735872bbf2SRichard Henderson 26745872bbf2SRichard Henderson (1) Define ELF_HOST_MACHINE to indicate both what value to 26755872bbf2SRichard Henderson put into the ELF image and to indicate support for the feature. 26765872bbf2SRichard Henderson 26775872bbf2SRichard Henderson (2) Define tcg_register_jit. This should create a buffer containing 26785872bbf2SRichard Henderson the contents of a .debug_frame section that describes the post- 26795872bbf2SRichard Henderson prologue unwind info for the tcg machine. 26805872bbf2SRichard Henderson 26815872bbf2SRichard Henderson (3) Call tcg_register_jit_int, with the constructed .debug_frame. 26825872bbf2SRichard Henderson */ 2683813da627SRichard Henderson 2684813da627SRichard Henderson /* Begin GDB interface. THE FOLLOWING MUST MATCH GDB DOCS. */ 2685813da627SRichard Henderson typedef enum { 2686813da627SRichard Henderson JIT_NOACTION = 0, 2687813da627SRichard Henderson JIT_REGISTER_FN, 2688813da627SRichard Henderson JIT_UNREGISTER_FN 2689813da627SRichard Henderson } jit_actions_t; 2690813da627SRichard Henderson 2691813da627SRichard Henderson struct jit_code_entry { 2692813da627SRichard Henderson struct jit_code_entry *next_entry; 2693813da627SRichard Henderson struct jit_code_entry *prev_entry; 2694813da627SRichard Henderson const void *symfile_addr; 2695813da627SRichard Henderson uint64_t symfile_size; 2696813da627SRichard Henderson }; 2697813da627SRichard Henderson 2698813da627SRichard Henderson struct jit_descriptor { 2699813da627SRichard Henderson uint32_t version; 2700813da627SRichard Henderson uint32_t action_flag; 2701813da627SRichard Henderson struct jit_code_entry *relevant_entry; 2702813da627SRichard Henderson struct jit_code_entry *first_entry; 2703813da627SRichard Henderson }; 2704813da627SRichard Henderson 2705813da627SRichard Henderson void __jit_debug_register_code(void) __attribute__((noinline)); 2706813da627SRichard Henderson void __jit_debug_register_code(void) 2707813da627SRichard Henderson { 2708813da627SRichard Henderson asm(""); 2709813da627SRichard Henderson } 2710813da627SRichard Henderson 2711813da627SRichard Henderson /* Must statically initialize the version, because GDB may check 2712813da627SRichard Henderson the version before we can set it. */ 2713813da627SRichard Henderson struct jit_descriptor __jit_debug_descriptor = { 1, 0, 0, 0 }; 2714813da627SRichard Henderson 2715813da627SRichard Henderson /* End GDB interface. */ 2716813da627SRichard Henderson 2717813da627SRichard Henderson static int find_string(const char *strtab, const char *str) 2718813da627SRichard Henderson { 2719813da627SRichard Henderson const char *p = strtab + 1; 2720813da627SRichard Henderson 2721813da627SRichard Henderson while (1) { 2722813da627SRichard Henderson if (strcmp(p, str) == 0) { 2723813da627SRichard Henderson return p - strtab; 2724813da627SRichard Henderson } 2725813da627SRichard Henderson p += strlen(p) + 1; 2726813da627SRichard Henderson } 2727813da627SRichard Henderson } 2728813da627SRichard Henderson 27295872bbf2SRichard Henderson static void tcg_register_jit_int(void *buf_ptr, size_t buf_size, 2730813da627SRichard Henderson void *debug_frame, size_t debug_frame_size) 2731813da627SRichard Henderson { 27325872bbf2SRichard Henderson struct __attribute__((packed)) DebugInfo { 27335872bbf2SRichard Henderson uint32_t len; 27345872bbf2SRichard Henderson uint16_t version; 27355872bbf2SRichard Henderson uint32_t abbrev; 27365872bbf2SRichard Henderson uint8_t ptr_size; 27375872bbf2SRichard Henderson uint8_t cu_die; 27385872bbf2SRichard Henderson uint16_t cu_lang; 27395872bbf2SRichard Henderson uintptr_t cu_low_pc; 27405872bbf2SRichard Henderson uintptr_t cu_high_pc; 27415872bbf2SRichard Henderson uint8_t fn_die; 27425872bbf2SRichard Henderson char fn_name[16]; 27435872bbf2SRichard Henderson uintptr_t fn_low_pc; 27445872bbf2SRichard Henderson uintptr_t fn_high_pc; 27455872bbf2SRichard Henderson uint8_t cu_eoc; 27465872bbf2SRichard Henderson }; 2747813da627SRichard Henderson 2748813da627SRichard Henderson struct ElfImage { 2749813da627SRichard Henderson ElfW(Ehdr) ehdr; 2750813da627SRichard Henderson ElfW(Phdr) phdr; 27515872bbf2SRichard Henderson ElfW(Shdr) shdr[7]; 27525872bbf2SRichard Henderson ElfW(Sym) sym[2]; 27535872bbf2SRichard Henderson struct DebugInfo di; 27545872bbf2SRichard Henderson uint8_t da[24]; 27555872bbf2SRichard Henderson char str[80]; 27565872bbf2SRichard Henderson }; 27575872bbf2SRichard Henderson 27585872bbf2SRichard Henderson struct ElfImage *img; 27595872bbf2SRichard Henderson 27605872bbf2SRichard Henderson static const struct ElfImage img_template = { 27615872bbf2SRichard Henderson .ehdr = { 27625872bbf2SRichard Henderson .e_ident[EI_MAG0] = ELFMAG0, 27635872bbf2SRichard Henderson .e_ident[EI_MAG1] = ELFMAG1, 27645872bbf2SRichard Henderson .e_ident[EI_MAG2] = ELFMAG2, 27655872bbf2SRichard Henderson .e_ident[EI_MAG3] = ELFMAG3, 27665872bbf2SRichard Henderson .e_ident[EI_CLASS] = ELF_CLASS, 27675872bbf2SRichard Henderson .e_ident[EI_DATA] = ELF_DATA, 27685872bbf2SRichard Henderson .e_ident[EI_VERSION] = EV_CURRENT, 27695872bbf2SRichard Henderson .e_type = ET_EXEC, 27705872bbf2SRichard Henderson .e_machine = ELF_HOST_MACHINE, 27715872bbf2SRichard Henderson .e_version = EV_CURRENT, 27725872bbf2SRichard Henderson .e_phoff = offsetof(struct ElfImage, phdr), 27735872bbf2SRichard Henderson .e_shoff = offsetof(struct ElfImage, shdr), 27745872bbf2SRichard Henderson .e_ehsize = sizeof(ElfW(Shdr)), 27755872bbf2SRichard Henderson .e_phentsize = sizeof(ElfW(Phdr)), 27765872bbf2SRichard Henderson .e_phnum = 1, 27775872bbf2SRichard Henderson .e_shentsize = sizeof(ElfW(Shdr)), 27785872bbf2SRichard Henderson .e_shnum = ARRAY_SIZE(img->shdr), 27795872bbf2SRichard Henderson .e_shstrndx = ARRAY_SIZE(img->shdr) - 1, 2780abbb3eaeSRichard Henderson #ifdef ELF_HOST_FLAGS 2781abbb3eaeSRichard Henderson .e_flags = ELF_HOST_FLAGS, 2782abbb3eaeSRichard Henderson #endif 2783abbb3eaeSRichard Henderson #ifdef ELF_OSABI 2784abbb3eaeSRichard Henderson .e_ident[EI_OSABI] = ELF_OSABI, 2785abbb3eaeSRichard Henderson #endif 27865872bbf2SRichard Henderson }, 27875872bbf2SRichard Henderson .phdr = { 27885872bbf2SRichard Henderson .p_type = PT_LOAD, 27895872bbf2SRichard Henderson .p_flags = PF_X, 27905872bbf2SRichard Henderson }, 27915872bbf2SRichard Henderson .shdr = { 27925872bbf2SRichard Henderson [0] = { .sh_type = SHT_NULL }, 27935872bbf2SRichard Henderson /* Trick: The contents of code_gen_buffer are not present in 27945872bbf2SRichard Henderson this fake ELF file; that got allocated elsewhere. Therefore 27955872bbf2SRichard Henderson we mark .text as SHT_NOBITS (similar to .bss) so that readers 27965872bbf2SRichard Henderson will not look for contents. We can record any address. */ 27975872bbf2SRichard Henderson [1] = { /* .text */ 27985872bbf2SRichard Henderson .sh_type = SHT_NOBITS, 27995872bbf2SRichard Henderson .sh_flags = SHF_EXECINSTR | SHF_ALLOC, 28005872bbf2SRichard Henderson }, 28015872bbf2SRichard Henderson [2] = { /* .debug_info */ 28025872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 28035872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, di), 28045872bbf2SRichard Henderson .sh_size = sizeof(struct DebugInfo), 28055872bbf2SRichard Henderson }, 28065872bbf2SRichard Henderson [3] = { /* .debug_abbrev */ 28075872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 28085872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, da), 28095872bbf2SRichard Henderson .sh_size = sizeof(img->da), 28105872bbf2SRichard Henderson }, 28115872bbf2SRichard Henderson [4] = { /* .debug_frame */ 28125872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 28135872bbf2SRichard Henderson .sh_offset = sizeof(struct ElfImage), 28145872bbf2SRichard Henderson }, 28155872bbf2SRichard Henderson [5] = { /* .symtab */ 28165872bbf2SRichard Henderson .sh_type = SHT_SYMTAB, 28175872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, sym), 28185872bbf2SRichard Henderson .sh_size = sizeof(img->sym), 28195872bbf2SRichard Henderson .sh_info = 1, 28205872bbf2SRichard Henderson .sh_link = ARRAY_SIZE(img->shdr) - 1, 28215872bbf2SRichard Henderson .sh_entsize = sizeof(ElfW(Sym)), 28225872bbf2SRichard Henderson }, 28235872bbf2SRichard Henderson [6] = { /* .strtab */ 28245872bbf2SRichard Henderson .sh_type = SHT_STRTAB, 28255872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, str), 28265872bbf2SRichard Henderson .sh_size = sizeof(img->str), 28275872bbf2SRichard Henderson } 28285872bbf2SRichard Henderson }, 28295872bbf2SRichard Henderson .sym = { 28305872bbf2SRichard Henderson [1] = { /* code_gen_buffer */ 28315872bbf2SRichard Henderson .st_info = ELF_ST_INFO(STB_GLOBAL, STT_FUNC), 28325872bbf2SRichard Henderson .st_shndx = 1, 28335872bbf2SRichard Henderson } 28345872bbf2SRichard Henderson }, 28355872bbf2SRichard Henderson .di = { 28365872bbf2SRichard Henderson .len = sizeof(struct DebugInfo) - 4, 28375872bbf2SRichard Henderson .version = 2, 28385872bbf2SRichard Henderson .ptr_size = sizeof(void *), 28395872bbf2SRichard Henderson .cu_die = 1, 28405872bbf2SRichard Henderson .cu_lang = 0x8001, /* DW_LANG_Mips_Assembler */ 28415872bbf2SRichard Henderson .fn_die = 2, 28425872bbf2SRichard Henderson .fn_name = "code_gen_buffer" 28435872bbf2SRichard Henderson }, 28445872bbf2SRichard Henderson .da = { 28455872bbf2SRichard Henderson 1, /* abbrev number (the cu) */ 28465872bbf2SRichard Henderson 0x11, 1, /* DW_TAG_compile_unit, has children */ 28475872bbf2SRichard Henderson 0x13, 0x5, /* DW_AT_language, DW_FORM_data2 */ 28485872bbf2SRichard Henderson 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */ 28495872bbf2SRichard Henderson 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */ 28505872bbf2SRichard Henderson 0, 0, /* end of abbrev */ 28515872bbf2SRichard Henderson 2, /* abbrev number (the fn) */ 28525872bbf2SRichard Henderson 0x2e, 0, /* DW_TAG_subprogram, no children */ 28535872bbf2SRichard Henderson 0x3, 0x8, /* DW_AT_name, DW_FORM_string */ 28545872bbf2SRichard Henderson 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */ 28555872bbf2SRichard Henderson 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */ 28565872bbf2SRichard Henderson 0, 0, /* end of abbrev */ 28575872bbf2SRichard Henderson 0 /* no more abbrev */ 28585872bbf2SRichard Henderson }, 28595872bbf2SRichard Henderson .str = "\0" ".text\0" ".debug_info\0" ".debug_abbrev\0" 28605872bbf2SRichard Henderson ".debug_frame\0" ".symtab\0" ".strtab\0" "code_gen_buffer", 2861813da627SRichard Henderson }; 2862813da627SRichard Henderson 2863813da627SRichard Henderson /* We only need a single jit entry; statically allocate it. */ 2864813da627SRichard Henderson static struct jit_code_entry one_entry; 2865813da627SRichard Henderson 28665872bbf2SRichard Henderson uintptr_t buf = (uintptr_t)buf_ptr; 2867813da627SRichard Henderson size_t img_size = sizeof(struct ElfImage) + debug_frame_size; 2868813da627SRichard Henderson 28695872bbf2SRichard Henderson img = g_malloc(img_size); 28705872bbf2SRichard Henderson *img = img_template; 2871813da627SRichard Henderson memcpy(img + 1, debug_frame, debug_frame_size); 2872813da627SRichard Henderson 28735872bbf2SRichard Henderson img->phdr.p_vaddr = buf; 28745872bbf2SRichard Henderson img->phdr.p_paddr = buf; 28755872bbf2SRichard Henderson img->phdr.p_memsz = buf_size; 2876813da627SRichard Henderson 28775872bbf2SRichard Henderson img->shdr[1].sh_name = find_string(img->str, ".text"); 28785872bbf2SRichard Henderson img->shdr[1].sh_addr = buf; 28795872bbf2SRichard Henderson img->shdr[1].sh_size = buf_size; 2880813da627SRichard Henderson 28815872bbf2SRichard Henderson img->shdr[2].sh_name = find_string(img->str, ".debug_info"); 28825872bbf2SRichard Henderson img->shdr[3].sh_name = find_string(img->str, ".debug_abbrev"); 28835872bbf2SRichard Henderson 28845872bbf2SRichard Henderson img->shdr[4].sh_name = find_string(img->str, ".debug_frame"); 28855872bbf2SRichard Henderson img->shdr[4].sh_size = debug_frame_size; 28865872bbf2SRichard Henderson 28875872bbf2SRichard Henderson img->shdr[5].sh_name = find_string(img->str, ".symtab"); 28885872bbf2SRichard Henderson img->shdr[6].sh_name = find_string(img->str, ".strtab"); 28895872bbf2SRichard Henderson 28905872bbf2SRichard Henderson img->sym[1].st_name = find_string(img->str, "code_gen_buffer"); 28915872bbf2SRichard Henderson img->sym[1].st_value = buf; 28925872bbf2SRichard Henderson img->sym[1].st_size = buf_size; 28935872bbf2SRichard Henderson 28945872bbf2SRichard Henderson img->di.cu_low_pc = buf; 289545aba097SRichard Henderson img->di.cu_high_pc = buf + buf_size; 28965872bbf2SRichard Henderson img->di.fn_low_pc = buf; 289745aba097SRichard Henderson img->di.fn_high_pc = buf + buf_size; 2898813da627SRichard Henderson 2899813da627SRichard Henderson #ifdef DEBUG_JIT 2900813da627SRichard Henderson /* Enable this block to be able to debug the ELF image file creation. 2901813da627SRichard Henderson One can use readelf, objdump, or other inspection utilities. */ 2902813da627SRichard Henderson { 2903813da627SRichard Henderson FILE *f = fopen("/tmp/qemu.jit", "w+b"); 2904813da627SRichard Henderson if (f) { 29055872bbf2SRichard Henderson if (fwrite(img, img_size, 1, f) != img_size) { 2906813da627SRichard Henderson /* Avoid stupid unused return value warning for fwrite. */ 2907813da627SRichard Henderson } 2908813da627SRichard Henderson fclose(f); 2909813da627SRichard Henderson } 2910813da627SRichard Henderson } 2911813da627SRichard Henderson #endif 2912813da627SRichard Henderson 2913813da627SRichard Henderson one_entry.symfile_addr = img; 2914813da627SRichard Henderson one_entry.symfile_size = img_size; 2915813da627SRichard Henderson 2916813da627SRichard Henderson __jit_debug_descriptor.action_flag = JIT_REGISTER_FN; 2917813da627SRichard Henderson __jit_debug_descriptor.relevant_entry = &one_entry; 2918813da627SRichard Henderson __jit_debug_descriptor.first_entry = &one_entry; 2919813da627SRichard Henderson __jit_debug_register_code(); 2920813da627SRichard Henderson } 2921813da627SRichard Henderson #else 29225872bbf2SRichard Henderson /* No support for the feature. Provide the entry point expected by exec.c, 29235872bbf2SRichard Henderson and implement the internal function we declared earlier. */ 2924813da627SRichard Henderson 2925813da627SRichard Henderson static void tcg_register_jit_int(void *buf, size_t size, 2926813da627SRichard Henderson void *debug_frame, size_t debug_frame_size) 2927813da627SRichard Henderson { 2928813da627SRichard Henderson } 2929813da627SRichard Henderson 2930813da627SRichard Henderson void tcg_register_jit(void *buf, size_t buf_size) 2931813da627SRichard Henderson { 2932813da627SRichard Henderson } 2933813da627SRichard Henderson #endif /* ELF_HOST_MACHINE */ 2934