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) */ 268f2e8c07SKirill Batuzov #define USE_TCG_OPTIMIZATIONS 27c896fe29Sbellard 28757e725bSPeter Maydell #include "qemu/osdep.h" 29cca82982Saurel32 30813da627SRichard Henderson /* Define to jump the ELF file used to communicate with GDB. */ 31813da627SRichard Henderson #undef DEBUG_JIT 32813da627SRichard Henderson 33f348b6d1SVeronia Bahaa #include "qemu/cutils.h" 341de7afc9SPaolo Bonzini #include "qemu/host-utils.h" 351de7afc9SPaolo Bonzini #include "qemu/timer.h" 36c896fe29Sbellard 37c5d3c498SStefan Weil /* Note: the long term plan is to reduce the dependencies on the QEMU 38c896fe29Sbellard CPU definitions. Currently they are used for qemu_ld/st 39c896fe29Sbellard instructions */ 40c896fe29Sbellard #define NO_CPU_IO_DEFS 41c896fe29Sbellard #include "cpu.h" 42c896fe29Sbellard 4363c91552SPaolo Bonzini #include "exec/cpu-common.h" 4463c91552SPaolo Bonzini #include "exec/exec-all.h" 4563c91552SPaolo Bonzini 46c896fe29Sbellard #include "tcg-op.h" 47813da627SRichard Henderson 48edee2579SRichard Henderson #if UINTPTR_MAX == UINT32_MAX 49813da627SRichard Henderson # define ELF_CLASS ELFCLASS32 50edee2579SRichard Henderson #else 51edee2579SRichard Henderson # define ELF_CLASS ELFCLASS64 52813da627SRichard Henderson #endif 53813da627SRichard Henderson #ifdef HOST_WORDS_BIGENDIAN 54813da627SRichard Henderson # define ELF_DATA ELFDATA2MSB 55813da627SRichard Henderson #else 56813da627SRichard Henderson # define ELF_DATA ELFDATA2LSB 57813da627SRichard Henderson #endif 58813da627SRichard Henderson 59c896fe29Sbellard #include "elf.h" 60508127e2SPaolo Bonzini #include "exec/log.h" 61c896fe29Sbellard 62ce151109SPeter Maydell /* Forward declarations for functions declared in tcg-target.inc.c and 63ce151109SPeter Maydell used here. */ 64e4d58b41SRichard Henderson static void tcg_target_init(TCGContext *s); 65f69d277eSRichard Henderson static const TCGTargetOpDef *tcg_target_op_def(TCGOpcode); 66e4d58b41SRichard Henderson static void tcg_target_qemu_prologue(TCGContext *s); 671813e175SRichard Henderson static void patch_reloc(tcg_insn_unit *code_ptr, int type, 682ba7fae2SRichard Henderson intptr_t value, intptr_t addend); 69c896fe29Sbellard 70497a22ebSRichard Henderson /* The CIE and FDE header definitions will be common to all hosts. */ 71497a22ebSRichard Henderson typedef struct { 72497a22ebSRichard Henderson uint32_t len __attribute__((aligned((sizeof(void *))))); 73497a22ebSRichard Henderson uint32_t id; 74497a22ebSRichard Henderson uint8_t version; 75497a22ebSRichard Henderson char augmentation[1]; 76497a22ebSRichard Henderson uint8_t code_align; 77497a22ebSRichard Henderson uint8_t data_align; 78497a22ebSRichard Henderson uint8_t return_column; 79497a22ebSRichard Henderson } DebugFrameCIE; 80497a22ebSRichard Henderson 81497a22ebSRichard Henderson typedef struct QEMU_PACKED { 82497a22ebSRichard Henderson uint32_t len __attribute__((aligned((sizeof(void *))))); 83497a22ebSRichard Henderson uint32_t cie_offset; 84edee2579SRichard Henderson uintptr_t func_start; 85edee2579SRichard Henderson uintptr_t func_len; 86497a22ebSRichard Henderson } DebugFrameFDEHeader; 87497a22ebSRichard Henderson 882c90784aSRichard Henderson typedef struct QEMU_PACKED { 892c90784aSRichard Henderson DebugFrameCIE cie; 902c90784aSRichard Henderson DebugFrameFDEHeader fde; 912c90784aSRichard Henderson } DebugFrameHeader; 922c90784aSRichard Henderson 93813da627SRichard Henderson static void tcg_register_jit_int(void *buf, size_t size, 942c90784aSRichard Henderson const void *debug_frame, 952c90784aSRichard Henderson size_t debug_frame_size) 96813da627SRichard Henderson __attribute__((unused)); 97813da627SRichard Henderson 98ce151109SPeter Maydell /* Forward declarations for functions declared and used in tcg-target.inc.c. */ 99069ea736SRichard Henderson static const char *target_parse_constraint(TCGArgConstraint *ct, 100069ea736SRichard Henderson const char *ct_str, TCGType type); 1012a534affSRichard Henderson static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1, 102a05b5b9bSRichard Henderson intptr_t arg2); 1032a534affSRichard Henderson static void tcg_out_mov(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg); 104c0ad3001SStefan Weil static void tcg_out_movi(TCGContext *s, TCGType type, 1052a534affSRichard Henderson TCGReg ret, tcg_target_long arg); 106c0ad3001SStefan Weil static void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args, 107c0ad3001SStefan Weil const int *const_args); 1082a534affSRichard Henderson static void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1, 109a05b5b9bSRichard Henderson intptr_t arg2); 11059d7c14eSRichard Henderson static bool tcg_out_sti(TCGContext *s, TCGType type, TCGArg val, 11159d7c14eSRichard Henderson TCGReg base, intptr_t ofs); 112cf066674SRichard Henderson static void tcg_out_call(TCGContext *s, tcg_insn_unit *target); 113f6c6afc1SRichard Henderson static int tcg_target_const_match(tcg_target_long val, TCGType type, 114c0ad3001SStefan Weil const TCGArgConstraint *arg_ct); 115659ef5cbSRichard Henderson #ifdef TCG_TARGET_NEED_LDST_LABELS 116659ef5cbSRichard Henderson static bool tcg_out_ldst_finalize(TCGContext *s); 117659ef5cbSRichard Henderson #endif 118c896fe29Sbellard 119a505785cSEmilio G. Cota #define TCG_HIGHWATER 1024 120a505785cSEmilio G. Cota 121b1d8e52eSblueswir1 static TCGRegSet tcg_target_available_regs[2]; 122b1d8e52eSblueswir1 static TCGRegSet tcg_target_call_clobber_regs; 123c896fe29Sbellard 1241813e175SRichard Henderson #if TCG_TARGET_INSN_UNIT_SIZE == 1 1254196dca6SPeter Maydell static __attribute__((unused)) inline void tcg_out8(TCGContext *s, uint8_t v) 126c896fe29Sbellard { 127c896fe29Sbellard *s->code_ptr++ = v; 128c896fe29Sbellard } 129c896fe29Sbellard 1304196dca6SPeter Maydell static __attribute__((unused)) inline void tcg_patch8(tcg_insn_unit *p, 1314196dca6SPeter Maydell uint8_t v) 1325c53bb81SPeter Maydell { 1331813e175SRichard Henderson *p = v; 1345c53bb81SPeter Maydell } 1351813e175SRichard Henderson #endif 1365c53bb81SPeter Maydell 1371813e175SRichard Henderson #if TCG_TARGET_INSN_UNIT_SIZE <= 2 1384196dca6SPeter Maydell static __attribute__((unused)) inline void tcg_out16(TCGContext *s, uint16_t v) 139c896fe29Sbellard { 1401813e175SRichard Henderson if (TCG_TARGET_INSN_UNIT_SIZE == 2) { 1411813e175SRichard Henderson *s->code_ptr++ = v; 1421813e175SRichard Henderson } else { 1431813e175SRichard Henderson tcg_insn_unit *p = s->code_ptr; 1444387345aSPeter Maydell memcpy(p, &v, sizeof(v)); 1451813e175SRichard Henderson s->code_ptr = p + (2 / TCG_TARGET_INSN_UNIT_SIZE); 1461813e175SRichard Henderson } 147c896fe29Sbellard } 148c896fe29Sbellard 1494196dca6SPeter Maydell static __attribute__((unused)) inline void tcg_patch16(tcg_insn_unit *p, 1504196dca6SPeter Maydell uint16_t v) 1515c53bb81SPeter Maydell { 1521813e175SRichard Henderson if (TCG_TARGET_INSN_UNIT_SIZE == 2) { 1531813e175SRichard Henderson *p = v; 1541813e175SRichard Henderson } else { 1555c53bb81SPeter Maydell memcpy(p, &v, sizeof(v)); 1565c53bb81SPeter Maydell } 1571813e175SRichard Henderson } 1581813e175SRichard Henderson #endif 1595c53bb81SPeter Maydell 1601813e175SRichard Henderson #if TCG_TARGET_INSN_UNIT_SIZE <= 4 1614196dca6SPeter Maydell static __attribute__((unused)) inline void tcg_out32(TCGContext *s, uint32_t v) 162c896fe29Sbellard { 1631813e175SRichard Henderson if (TCG_TARGET_INSN_UNIT_SIZE == 4) { 1641813e175SRichard Henderson *s->code_ptr++ = v; 1651813e175SRichard Henderson } else { 1661813e175SRichard Henderson tcg_insn_unit *p = s->code_ptr; 1674387345aSPeter Maydell memcpy(p, &v, sizeof(v)); 1681813e175SRichard Henderson s->code_ptr = p + (4 / TCG_TARGET_INSN_UNIT_SIZE); 1691813e175SRichard Henderson } 170c896fe29Sbellard } 171c896fe29Sbellard 1724196dca6SPeter Maydell static __attribute__((unused)) inline void tcg_patch32(tcg_insn_unit *p, 1734196dca6SPeter Maydell uint32_t v) 1745c53bb81SPeter Maydell { 1751813e175SRichard Henderson if (TCG_TARGET_INSN_UNIT_SIZE == 4) { 1761813e175SRichard Henderson *p = v; 1771813e175SRichard Henderson } else { 1785c53bb81SPeter Maydell memcpy(p, &v, sizeof(v)); 1795c53bb81SPeter Maydell } 1801813e175SRichard Henderson } 1811813e175SRichard Henderson #endif 1825c53bb81SPeter Maydell 1831813e175SRichard Henderson #if TCG_TARGET_INSN_UNIT_SIZE <= 8 1844196dca6SPeter Maydell static __attribute__((unused)) inline void tcg_out64(TCGContext *s, uint64_t v) 185ac26eb69SRichard Henderson { 1861813e175SRichard Henderson if (TCG_TARGET_INSN_UNIT_SIZE == 8) { 1871813e175SRichard Henderson *s->code_ptr++ = v; 1881813e175SRichard Henderson } else { 1891813e175SRichard Henderson tcg_insn_unit *p = s->code_ptr; 1904387345aSPeter Maydell memcpy(p, &v, sizeof(v)); 1911813e175SRichard Henderson s->code_ptr = p + (8 / TCG_TARGET_INSN_UNIT_SIZE); 1921813e175SRichard Henderson } 193ac26eb69SRichard Henderson } 194ac26eb69SRichard Henderson 1954196dca6SPeter Maydell static __attribute__((unused)) inline void tcg_patch64(tcg_insn_unit *p, 1964196dca6SPeter Maydell uint64_t v) 1975c53bb81SPeter Maydell { 1981813e175SRichard Henderson if (TCG_TARGET_INSN_UNIT_SIZE == 8) { 1991813e175SRichard Henderson *p = v; 2001813e175SRichard Henderson } else { 2015c53bb81SPeter Maydell memcpy(p, &v, sizeof(v)); 2025c53bb81SPeter Maydell } 2031813e175SRichard Henderson } 2041813e175SRichard Henderson #endif 2055c53bb81SPeter Maydell 206c896fe29Sbellard /* label relocation processing */ 207c896fe29Sbellard 2081813e175SRichard Henderson static void tcg_out_reloc(TCGContext *s, tcg_insn_unit *code_ptr, int type, 209bec16311SRichard Henderson TCGLabel *l, intptr_t addend) 210c896fe29Sbellard { 211c896fe29Sbellard TCGRelocation *r; 212c896fe29Sbellard 213c896fe29Sbellard if (l->has_value) { 214623e265cSpbrook /* FIXME: This may break relocations on RISC targets that 215623e265cSpbrook modify instruction fields in place. The caller may not have 216623e265cSpbrook written the initial value. */ 217f54b3f92Saurel32 patch_reloc(code_ptr, type, l->u.value, addend); 218c896fe29Sbellard } else { 219c896fe29Sbellard /* add a new relocation entry */ 220c896fe29Sbellard r = tcg_malloc(sizeof(TCGRelocation)); 221c896fe29Sbellard r->type = type; 222c896fe29Sbellard r->ptr = code_ptr; 223c896fe29Sbellard r->addend = addend; 224c896fe29Sbellard r->next = l->u.first_reloc; 225c896fe29Sbellard l->u.first_reloc = r; 226c896fe29Sbellard } 227c896fe29Sbellard } 228c896fe29Sbellard 229bec16311SRichard Henderson static void tcg_out_label(TCGContext *s, TCGLabel *l, tcg_insn_unit *ptr) 230c896fe29Sbellard { 2312ba7fae2SRichard Henderson intptr_t value = (intptr_t)ptr; 2321813e175SRichard Henderson TCGRelocation *r; 233c896fe29Sbellard 234eabb7b91SAurelien Jarno tcg_debug_assert(!l->has_value); 2351813e175SRichard Henderson 2361813e175SRichard Henderson for (r = l->u.first_reloc; r != NULL; r = r->next) { 237f54b3f92Saurel32 patch_reloc(r->ptr, r->type, value, r->addend); 238c896fe29Sbellard } 2391813e175SRichard Henderson 240c896fe29Sbellard l->has_value = 1; 2411813e175SRichard Henderson l->u.value_ptr = ptr; 242c896fe29Sbellard } 243c896fe29Sbellard 24442a268c2SRichard Henderson TCGLabel *gen_new_label(void) 245c896fe29Sbellard { 246c896fe29Sbellard TCGContext *s = &tcg_ctx; 24751e3972cSRichard Henderson TCGLabel *l = tcg_malloc(sizeof(TCGLabel)); 248c896fe29Sbellard 24951e3972cSRichard Henderson *l = (TCGLabel){ 25051e3972cSRichard Henderson .id = s->nb_labels++ 25151e3972cSRichard Henderson }; 25242a268c2SRichard Henderson 25342a268c2SRichard Henderson return l; 254c896fe29Sbellard } 255c896fe29Sbellard 256ce151109SPeter Maydell #include "tcg-target.inc.c" 257c896fe29Sbellard 258c896fe29Sbellard /* pool based memory allocation */ 259c896fe29Sbellard void *tcg_malloc_internal(TCGContext *s, int size) 260c896fe29Sbellard { 261c896fe29Sbellard TCGPool *p; 262c896fe29Sbellard int pool_size; 263c896fe29Sbellard 264c896fe29Sbellard if (size > TCG_POOL_CHUNK_SIZE) { 265c896fe29Sbellard /* big malloc: insert a new pool (XXX: could optimize) */ 2667267c094SAnthony Liguori p = g_malloc(sizeof(TCGPool) + size); 267c896fe29Sbellard p->size = size; 2684055299eSKirill Batuzov p->next = s->pool_first_large; 2694055299eSKirill Batuzov s->pool_first_large = p; 2704055299eSKirill Batuzov return p->data; 271c896fe29Sbellard } else { 272c896fe29Sbellard p = s->pool_current; 273c896fe29Sbellard if (!p) { 274c896fe29Sbellard p = s->pool_first; 275c896fe29Sbellard if (!p) 276c896fe29Sbellard goto new_pool; 277c896fe29Sbellard } else { 278c896fe29Sbellard if (!p->next) { 279c896fe29Sbellard new_pool: 280c896fe29Sbellard pool_size = TCG_POOL_CHUNK_SIZE; 2817267c094SAnthony Liguori p = g_malloc(sizeof(TCGPool) + pool_size); 282c896fe29Sbellard p->size = pool_size; 283c896fe29Sbellard p->next = NULL; 284c896fe29Sbellard if (s->pool_current) 285c896fe29Sbellard s->pool_current->next = p; 286c896fe29Sbellard else 287c896fe29Sbellard s->pool_first = p; 288c896fe29Sbellard } else { 289c896fe29Sbellard p = p->next; 290c896fe29Sbellard } 291c896fe29Sbellard } 292c896fe29Sbellard } 293c896fe29Sbellard s->pool_current = p; 294c896fe29Sbellard s->pool_cur = p->data + size; 295c896fe29Sbellard s->pool_end = p->data + p->size; 296c896fe29Sbellard return p->data; 297c896fe29Sbellard } 298c896fe29Sbellard 299c896fe29Sbellard void tcg_pool_reset(TCGContext *s) 300c896fe29Sbellard { 3014055299eSKirill Batuzov TCGPool *p, *t; 3024055299eSKirill Batuzov for (p = s->pool_first_large; p; p = t) { 3034055299eSKirill Batuzov t = p->next; 3044055299eSKirill Batuzov g_free(p); 3054055299eSKirill Batuzov } 3064055299eSKirill Batuzov s->pool_first_large = NULL; 307c896fe29Sbellard s->pool_cur = s->pool_end = NULL; 308c896fe29Sbellard s->pool_current = NULL; 309c896fe29Sbellard } 310c896fe29Sbellard 311100b5e01SRichard Henderson typedef struct TCGHelperInfo { 312100b5e01SRichard Henderson void *func; 313100b5e01SRichard Henderson const char *name; 314afb49896SRichard Henderson unsigned flags; 315afb49896SRichard Henderson unsigned sizemask; 316100b5e01SRichard Henderson } TCGHelperInfo; 317100b5e01SRichard Henderson 3182ef6175aSRichard Henderson #include "exec/helper-proto.h" 3192ef6175aSRichard Henderson 320100b5e01SRichard Henderson static const TCGHelperInfo all_helpers[] = { 3212ef6175aSRichard Henderson #include "exec/helper-tcg.h" 322100b5e01SRichard Henderson }; 323619205fdSEmilio G. Cota static GHashTable *helper_table; 324100b5e01SRichard Henderson 32591478cefSRichard Henderson static int indirect_reg_alloc_order[ARRAY_SIZE(tcg_target_reg_alloc_order)]; 326f69d277eSRichard Henderson static void process_op_defs(TCGContext *s); 32791478cefSRichard Henderson 328c896fe29Sbellard void tcg_context_init(TCGContext *s) 329c896fe29Sbellard { 330100b5e01SRichard Henderson int op, total_args, n, i; 331c896fe29Sbellard TCGOpDef *def; 332c896fe29Sbellard TCGArgConstraint *args_ct; 333c896fe29Sbellard int *sorted_args; 334c896fe29Sbellard 335c896fe29Sbellard memset(s, 0, sizeof(*s)); 336c896fe29Sbellard s->nb_globals = 0; 337c896fe29Sbellard 338c896fe29Sbellard /* Count total number of arguments and allocate the corresponding 339c896fe29Sbellard space */ 340c896fe29Sbellard total_args = 0; 341c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 342c896fe29Sbellard def = &tcg_op_defs[op]; 343c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 344c896fe29Sbellard total_args += n; 345c896fe29Sbellard } 346c896fe29Sbellard 3477267c094SAnthony Liguori args_ct = g_malloc(sizeof(TCGArgConstraint) * total_args); 3487267c094SAnthony Liguori sorted_args = g_malloc(sizeof(int) * total_args); 349c896fe29Sbellard 350c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 351c896fe29Sbellard def = &tcg_op_defs[op]; 352c896fe29Sbellard def->args_ct = args_ct; 353c896fe29Sbellard def->sorted_args = sorted_args; 354c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 355c896fe29Sbellard sorted_args += n; 356c896fe29Sbellard args_ct += n; 357c896fe29Sbellard } 358c896fe29Sbellard 3595cd8f621SRichard Henderson /* Register helpers. */ 36084fd9dd3SRichard Henderson /* Use g_direct_hash/equal for direct pointer comparisons on func. */ 361619205fdSEmilio G. Cota helper_table = g_hash_table_new(NULL, NULL); 36284fd9dd3SRichard Henderson 363100b5e01SRichard Henderson for (i = 0; i < ARRAY_SIZE(all_helpers); ++i) { 36484fd9dd3SRichard Henderson g_hash_table_insert(helper_table, (gpointer)all_helpers[i].func, 36572866e82SRichard Henderson (gpointer)&all_helpers[i]); 366100b5e01SRichard Henderson } 3675cd8f621SRichard Henderson 368c896fe29Sbellard tcg_target_init(s); 369f69d277eSRichard Henderson process_op_defs(s); 37091478cefSRichard Henderson 37191478cefSRichard Henderson /* Reverse the order of the saved registers, assuming they're all at 37291478cefSRichard Henderson the start of tcg_target_reg_alloc_order. */ 37391478cefSRichard Henderson for (n = 0; n < ARRAY_SIZE(tcg_target_reg_alloc_order); ++n) { 37491478cefSRichard Henderson int r = tcg_target_reg_alloc_order[n]; 37591478cefSRichard Henderson if (tcg_regset_test_reg(tcg_target_call_clobber_regs, r)) { 37691478cefSRichard Henderson break; 37791478cefSRichard Henderson } 37891478cefSRichard Henderson } 37991478cefSRichard Henderson for (i = 0; i < n; ++i) { 38091478cefSRichard Henderson indirect_reg_alloc_order[i] = tcg_target_reg_alloc_order[n - 1 - i]; 38191478cefSRichard Henderson } 38291478cefSRichard Henderson for (; i < ARRAY_SIZE(tcg_target_reg_alloc_order); ++i) { 38391478cefSRichard Henderson indirect_reg_alloc_order[i] = tcg_target_reg_alloc_order[i]; 38491478cefSRichard Henderson } 3859002ec79SRichard Henderson } 386b03cce8eSbellard 3876e3b2bfdSEmilio G. Cota /* 3886e3b2bfdSEmilio G. Cota * Allocate TBs right before their corresponding translated code, making 3896e3b2bfdSEmilio G. Cota * sure that TBs and code are on different cache lines. 3906e3b2bfdSEmilio G. Cota */ 3916e3b2bfdSEmilio G. Cota TranslationBlock *tcg_tb_alloc(TCGContext *s) 3926e3b2bfdSEmilio G. Cota { 3936e3b2bfdSEmilio G. Cota uintptr_t align = qemu_icache_linesize; 3946e3b2bfdSEmilio G. Cota TranslationBlock *tb; 3956e3b2bfdSEmilio G. Cota void *next; 3966e3b2bfdSEmilio G. Cota 3976e3b2bfdSEmilio G. Cota tb = (void *)ROUND_UP((uintptr_t)s->code_gen_ptr, align); 3986e3b2bfdSEmilio G. Cota next = (void *)ROUND_UP((uintptr_t)(tb + 1), align); 3996e3b2bfdSEmilio G. Cota 4006e3b2bfdSEmilio G. Cota if (unlikely(next > s->code_gen_highwater)) { 4016e3b2bfdSEmilio G. Cota return NULL; 4026e3b2bfdSEmilio G. Cota } 4036e3b2bfdSEmilio G. Cota s->code_gen_ptr = next; 40457a26946SRichard Henderson s->data_gen_ptr = NULL; 4056e3b2bfdSEmilio G. Cota return tb; 4066e3b2bfdSEmilio G. Cota } 4076e3b2bfdSEmilio G. Cota 4089002ec79SRichard Henderson void tcg_prologue_init(TCGContext *s) 4099002ec79SRichard Henderson { 4108163b749SRichard Henderson size_t prologue_size, total_size; 4118163b749SRichard Henderson void *buf0, *buf1; 4128163b749SRichard Henderson 4138163b749SRichard Henderson /* Put the prologue at the beginning of code_gen_buffer. */ 4148163b749SRichard Henderson buf0 = s->code_gen_buffer; 4158163b749SRichard Henderson s->code_ptr = buf0; 4168163b749SRichard Henderson s->code_buf = buf0; 4178163b749SRichard Henderson s->code_gen_prologue = buf0; 4188163b749SRichard Henderson 4198163b749SRichard Henderson /* Generate the prologue. */ 420b03cce8eSbellard tcg_target_qemu_prologue(s); 4218163b749SRichard Henderson buf1 = s->code_ptr; 4228163b749SRichard Henderson flush_icache_range((uintptr_t)buf0, (uintptr_t)buf1); 4238163b749SRichard Henderson 4248163b749SRichard Henderson /* Deduct the prologue from the buffer. */ 4258163b749SRichard Henderson prologue_size = tcg_current_code_size(s); 4268163b749SRichard Henderson s->code_gen_ptr = buf1; 4278163b749SRichard Henderson s->code_gen_buffer = buf1; 4288163b749SRichard Henderson s->code_buf = buf1; 4298163b749SRichard Henderson total_size = s->code_gen_buffer_size - prologue_size; 4308163b749SRichard Henderson s->code_gen_buffer_size = total_size; 4318163b749SRichard Henderson 432b125f9dcSRichard Henderson /* Compute a high-water mark, at which we voluntarily flush the buffer 433b125f9dcSRichard Henderson and start over. The size here is arbitrary, significantly larger 434b125f9dcSRichard Henderson than we expect the code generation for any one opcode to require. */ 435a505785cSEmilio G. Cota s->code_gen_highwater = s->code_gen_buffer + (total_size - TCG_HIGHWATER); 4368163b749SRichard Henderson 4378163b749SRichard Henderson tcg_register_jit(s->code_gen_buffer, total_size); 438d6b64b2bSRichard Henderson 439d6b64b2bSRichard Henderson #ifdef DEBUG_DISAS 440d6b64b2bSRichard Henderson if (qemu_loglevel_mask(CPU_LOG_TB_OUT_ASM)) { 4411ee73216SRichard Henderson qemu_log_lock(); 4428163b749SRichard Henderson qemu_log("PROLOGUE: [size=%zu]\n", prologue_size); 4438163b749SRichard Henderson log_disas(buf0, prologue_size); 444d6b64b2bSRichard Henderson qemu_log("\n"); 445d6b64b2bSRichard Henderson qemu_log_flush(); 4461ee73216SRichard Henderson qemu_log_unlock(); 447d6b64b2bSRichard Henderson } 448d6b64b2bSRichard Henderson #endif 449cedbcb01SEmilio G. Cota 450cedbcb01SEmilio G. Cota /* Assert that goto_ptr is implemented completely. */ 451cedbcb01SEmilio G. Cota if (TCG_TARGET_HAS_goto_ptr) { 452cedbcb01SEmilio G. Cota tcg_debug_assert(s->code_gen_epilogue != NULL); 453cedbcb01SEmilio G. Cota } 454c896fe29Sbellard } 455c896fe29Sbellard 456c896fe29Sbellard void tcg_func_start(TCGContext *s) 457c896fe29Sbellard { 458c896fe29Sbellard tcg_pool_reset(s); 459c896fe29Sbellard s->nb_temps = s->nb_globals; 4600ec9eabcSRichard Henderson 4610ec9eabcSRichard Henderson /* No temps have been previously allocated for size or locality. */ 4620ec9eabcSRichard Henderson memset(s->free_temps, 0, sizeof(s->free_temps)); 4630ec9eabcSRichard Henderson 464c896fe29Sbellard s->nb_labels = 0; 465c896fe29Sbellard s->current_frame_offset = s->frame_start; 466c896fe29Sbellard 4670a209d4bSRichard Henderson #ifdef CONFIG_DEBUG_TCG 4680a209d4bSRichard Henderson s->goto_tb_issue_mask = 0; 4690a209d4bSRichard Henderson #endif 4700a209d4bSRichard Henderson 471dcb8e758SRichard Henderson s->gen_op_buf[0].next = 1; 472dcb8e758SRichard Henderson s->gen_op_buf[0].prev = 0; 473dcb8e758SRichard Henderson s->gen_next_op_idx = 1; 474c896fe29Sbellard } 475c896fe29Sbellard 4767ca4b752SRichard Henderson static inline TCGTemp *tcg_temp_alloc(TCGContext *s) 4777ca4b752SRichard Henderson { 4787ca4b752SRichard Henderson int n = s->nb_temps++; 4797ca4b752SRichard Henderson tcg_debug_assert(n < TCG_MAX_TEMPS); 4807ca4b752SRichard Henderson return memset(&s->temps[n], 0, sizeof(TCGTemp)); 4817ca4b752SRichard Henderson } 4827ca4b752SRichard Henderson 4837ca4b752SRichard Henderson static inline TCGTemp *tcg_global_alloc(TCGContext *s) 4847ca4b752SRichard Henderson { 485fa477d25SRichard Henderson TCGTemp *ts; 486fa477d25SRichard Henderson 4877ca4b752SRichard Henderson tcg_debug_assert(s->nb_globals == s->nb_temps); 4887ca4b752SRichard Henderson s->nb_globals++; 489fa477d25SRichard Henderson ts = tcg_temp_alloc(s); 490fa477d25SRichard Henderson ts->temp_global = 1; 491fa477d25SRichard Henderson 492fa477d25SRichard Henderson return ts; 493c896fe29Sbellard } 494c896fe29Sbellard 495b3a62939SRichard Henderson static int tcg_global_reg_new_internal(TCGContext *s, TCGType type, 496b6638662SRichard Henderson TCGReg reg, const char *name) 497c896fe29Sbellard { 498c896fe29Sbellard TCGTemp *ts; 499c896fe29Sbellard 500b3a62939SRichard Henderson if (TCG_TARGET_REG_BITS == 32 && type != TCG_TYPE_I32) { 501c896fe29Sbellard tcg_abort(); 502b3a62939SRichard Henderson } 5037ca4b752SRichard Henderson 5047ca4b752SRichard Henderson ts = tcg_global_alloc(s); 505c896fe29Sbellard ts->base_type = type; 506c896fe29Sbellard ts->type = type; 507c896fe29Sbellard ts->fixed_reg = 1; 508c896fe29Sbellard ts->reg = reg; 509c896fe29Sbellard ts->name = name; 510c896fe29Sbellard tcg_regset_set_reg(s->reserved_regs, reg); 5117ca4b752SRichard Henderson 512*1807f4c4SRichard Henderson return temp_idx(ts); 513a7812ae4Spbrook } 514a7812ae4Spbrook 515b6638662SRichard Henderson void tcg_set_frame(TCGContext *s, TCGReg reg, intptr_t start, intptr_t size) 516a7812ae4Spbrook { 517a7812ae4Spbrook int idx; 518b3a62939SRichard Henderson s->frame_start = start; 519b3a62939SRichard Henderson s->frame_end = start + size; 520b3a62939SRichard Henderson idx = tcg_global_reg_new_internal(s, TCG_TYPE_PTR, reg, "_frame"); 521b3a62939SRichard Henderson s->frame_temp = &s->temps[idx]; 522b3a62939SRichard Henderson } 523a7812ae4Spbrook 524b6638662SRichard Henderson TCGv_i32 tcg_global_reg_new_i32(TCGReg reg, const char *name) 525b3a62939SRichard Henderson { 526b3a62939SRichard Henderson TCGContext *s = &tcg_ctx; 527b3a62939SRichard Henderson int idx; 528b3a62939SRichard Henderson 529b3a62939SRichard Henderson if (tcg_regset_test_reg(s->reserved_regs, reg)) { 530b3a62939SRichard Henderson tcg_abort(); 531b3a62939SRichard Henderson } 532b3a62939SRichard Henderson idx = tcg_global_reg_new_internal(s, TCG_TYPE_I32, reg, name); 533a7812ae4Spbrook return MAKE_TCGV_I32(idx); 534a7812ae4Spbrook } 535a7812ae4Spbrook 536b6638662SRichard Henderson TCGv_i64 tcg_global_reg_new_i64(TCGReg reg, const char *name) 537a7812ae4Spbrook { 538b3a62939SRichard Henderson TCGContext *s = &tcg_ctx; 539a7812ae4Spbrook int idx; 540a7812ae4Spbrook 541b3a62939SRichard Henderson if (tcg_regset_test_reg(s->reserved_regs, reg)) { 542b3a62939SRichard Henderson tcg_abort(); 543b3a62939SRichard Henderson } 544b3a62939SRichard Henderson idx = tcg_global_reg_new_internal(s, TCG_TYPE_I64, reg, name); 545a7812ae4Spbrook return MAKE_TCGV_I64(idx); 546c896fe29Sbellard } 547c896fe29Sbellard 548e1ccc054SRichard Henderson int tcg_global_mem_new_internal(TCGType type, TCGv_ptr base, 549e1ccc054SRichard Henderson intptr_t offset, const char *name) 550c896fe29Sbellard { 551c896fe29Sbellard TCGContext *s = &tcg_ctx; 5527ca4b752SRichard Henderson TCGTemp *base_ts = &s->temps[GET_TCGV_PTR(base)]; 5537ca4b752SRichard Henderson TCGTemp *ts = tcg_global_alloc(s); 554b3915dbbSRichard Henderson int indirect_reg = 0, bigendian = 0; 5557ca4b752SRichard Henderson #ifdef HOST_WORDS_BIGENDIAN 5567ca4b752SRichard Henderson bigendian = 1; 5577ca4b752SRichard Henderson #endif 558c896fe29Sbellard 559b3915dbbSRichard Henderson if (!base_ts->fixed_reg) { 5605a18407fSRichard Henderson /* We do not support double-indirect registers. */ 5615a18407fSRichard Henderson tcg_debug_assert(!base_ts->indirect_reg); 562b3915dbbSRichard Henderson base_ts->indirect_base = 1; 5635a18407fSRichard Henderson s->nb_indirects += (TCG_TARGET_REG_BITS == 32 && type == TCG_TYPE_I64 5645a18407fSRichard Henderson ? 2 : 1); 5655a18407fSRichard Henderson indirect_reg = 1; 566b3915dbbSRichard Henderson } 567b3915dbbSRichard Henderson 5687ca4b752SRichard Henderson if (TCG_TARGET_REG_BITS == 32 && type == TCG_TYPE_I64) { 5697ca4b752SRichard Henderson TCGTemp *ts2 = tcg_global_alloc(s); 570c896fe29Sbellard char buf[64]; 5717ca4b752SRichard Henderson 5727ca4b752SRichard Henderson ts->base_type = TCG_TYPE_I64; 573c896fe29Sbellard ts->type = TCG_TYPE_I32; 574b3915dbbSRichard Henderson ts->indirect_reg = indirect_reg; 575c896fe29Sbellard ts->mem_allocated = 1; 576b3a62939SRichard Henderson ts->mem_base = base_ts; 5777ca4b752SRichard Henderson ts->mem_offset = offset + bigendian * 4; 578c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 579c896fe29Sbellard pstrcat(buf, sizeof(buf), "_0"); 580c896fe29Sbellard ts->name = strdup(buf); 581c896fe29Sbellard 5827ca4b752SRichard Henderson tcg_debug_assert(ts2 == ts + 1); 5837ca4b752SRichard Henderson ts2->base_type = TCG_TYPE_I64; 5847ca4b752SRichard Henderson ts2->type = TCG_TYPE_I32; 585b3915dbbSRichard Henderson ts2->indirect_reg = indirect_reg; 5867ca4b752SRichard Henderson ts2->mem_allocated = 1; 5877ca4b752SRichard Henderson ts2->mem_base = base_ts; 5887ca4b752SRichard Henderson ts2->mem_offset = offset + (1 - bigendian) * 4; 589c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 590c896fe29Sbellard pstrcat(buf, sizeof(buf), "_1"); 591120c1084SRichard Henderson ts2->name = strdup(buf); 5927ca4b752SRichard Henderson } else { 593c896fe29Sbellard ts->base_type = type; 594c896fe29Sbellard ts->type = type; 595b3915dbbSRichard Henderson ts->indirect_reg = indirect_reg; 596c896fe29Sbellard ts->mem_allocated = 1; 597b3a62939SRichard Henderson ts->mem_base = base_ts; 598c896fe29Sbellard ts->mem_offset = offset; 599c896fe29Sbellard ts->name = name; 600c896fe29Sbellard } 601*1807f4c4SRichard Henderson return temp_idx(ts); 602c896fe29Sbellard } 603c896fe29Sbellard 6047ca4b752SRichard Henderson static int tcg_temp_new_internal(TCGType type, int temp_local) 605c896fe29Sbellard { 606c896fe29Sbellard TCGContext *s = &tcg_ctx; 607c896fe29Sbellard TCGTemp *ts; 608641d5fbeSbellard int idx, k; 609c896fe29Sbellard 6100ec9eabcSRichard Henderson k = type + (temp_local ? TCG_TYPE_COUNT : 0); 6110ec9eabcSRichard Henderson idx = find_first_bit(s->free_temps[k].l, TCG_MAX_TEMPS); 6120ec9eabcSRichard Henderson if (idx < TCG_MAX_TEMPS) { 6130ec9eabcSRichard Henderson /* There is already an available temp with the right type. */ 6140ec9eabcSRichard Henderson clear_bit(idx, s->free_temps[k].l); 6150ec9eabcSRichard Henderson 616e8996ee0Sbellard ts = &s->temps[idx]; 617e8996ee0Sbellard ts->temp_allocated = 1; 6187ca4b752SRichard Henderson tcg_debug_assert(ts->base_type == type); 6197ca4b752SRichard Henderson tcg_debug_assert(ts->temp_local == temp_local); 620e8996ee0Sbellard } else { 6217ca4b752SRichard Henderson ts = tcg_temp_alloc(s); 6227ca4b752SRichard Henderson if (TCG_TARGET_REG_BITS == 32 && type == TCG_TYPE_I64) { 6237ca4b752SRichard Henderson TCGTemp *ts2 = tcg_temp_alloc(s); 6247ca4b752SRichard Henderson 625c896fe29Sbellard ts->base_type = type; 626c896fe29Sbellard ts->type = TCG_TYPE_I32; 627e8996ee0Sbellard ts->temp_allocated = 1; 628641d5fbeSbellard ts->temp_local = temp_local; 6297ca4b752SRichard Henderson 6307ca4b752SRichard Henderson tcg_debug_assert(ts2 == ts + 1); 6317ca4b752SRichard Henderson ts2->base_type = TCG_TYPE_I64; 6327ca4b752SRichard Henderson ts2->type = TCG_TYPE_I32; 6337ca4b752SRichard Henderson ts2->temp_allocated = 1; 6347ca4b752SRichard Henderson ts2->temp_local = temp_local; 6357ca4b752SRichard Henderson } else { 636c896fe29Sbellard ts->base_type = type; 637c896fe29Sbellard ts->type = type; 638e8996ee0Sbellard ts->temp_allocated = 1; 639641d5fbeSbellard ts->temp_local = temp_local; 640c896fe29Sbellard } 641*1807f4c4SRichard Henderson idx = temp_idx(ts); 642e8996ee0Sbellard } 64327bfd83cSPeter Maydell 64427bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 64527bfd83cSPeter Maydell s->temps_in_use++; 64627bfd83cSPeter Maydell #endif 647a7812ae4Spbrook return idx; 648c896fe29Sbellard } 649c896fe29Sbellard 650a7812ae4Spbrook TCGv_i32 tcg_temp_new_internal_i32(int temp_local) 651a7812ae4Spbrook { 652a7812ae4Spbrook int idx; 653a7812ae4Spbrook 654a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I32, temp_local); 655a7812ae4Spbrook return MAKE_TCGV_I32(idx); 656a7812ae4Spbrook } 657a7812ae4Spbrook 658a7812ae4Spbrook TCGv_i64 tcg_temp_new_internal_i64(int temp_local) 659a7812ae4Spbrook { 660a7812ae4Spbrook int idx; 661a7812ae4Spbrook 662a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I64, temp_local); 663a7812ae4Spbrook return MAKE_TCGV_I64(idx); 664a7812ae4Spbrook } 665a7812ae4Spbrook 6660ec9eabcSRichard Henderson static void tcg_temp_free_internal(int idx) 667c896fe29Sbellard { 668c896fe29Sbellard TCGContext *s = &tcg_ctx; 669c896fe29Sbellard TCGTemp *ts; 670641d5fbeSbellard int k; 671c896fe29Sbellard 67227bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 67327bfd83cSPeter Maydell s->temps_in_use--; 67427bfd83cSPeter Maydell if (s->temps_in_use < 0) { 67527bfd83cSPeter Maydell fprintf(stderr, "More temporaries freed than allocated!\n"); 67627bfd83cSPeter Maydell } 67727bfd83cSPeter Maydell #endif 67827bfd83cSPeter Maydell 679eabb7b91SAurelien Jarno tcg_debug_assert(idx >= s->nb_globals && idx < s->nb_temps); 680c896fe29Sbellard ts = &s->temps[idx]; 681eabb7b91SAurelien Jarno tcg_debug_assert(ts->temp_allocated != 0); 682e8996ee0Sbellard ts->temp_allocated = 0; 6830ec9eabcSRichard Henderson 68418d13fa2SAlexander Graf k = ts->base_type + (ts->temp_local ? TCG_TYPE_COUNT : 0); 6850ec9eabcSRichard Henderson set_bit(idx, s->free_temps[k].l); 686e8996ee0Sbellard } 687e8996ee0Sbellard 688a7812ae4Spbrook void tcg_temp_free_i32(TCGv_i32 arg) 689e8996ee0Sbellard { 690a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I32(arg)); 691a7812ae4Spbrook } 692a7812ae4Spbrook 693a7812ae4Spbrook void tcg_temp_free_i64(TCGv_i64 arg) 694a7812ae4Spbrook { 695a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I64(arg)); 696a7812ae4Spbrook } 697a7812ae4Spbrook 698a7812ae4Spbrook TCGv_i32 tcg_const_i32(int32_t val) 699a7812ae4Spbrook { 700a7812ae4Spbrook TCGv_i32 t0; 701a7812ae4Spbrook t0 = tcg_temp_new_i32(); 702e8996ee0Sbellard tcg_gen_movi_i32(t0, val); 703e8996ee0Sbellard return t0; 704c896fe29Sbellard } 705c896fe29Sbellard 706a7812ae4Spbrook TCGv_i64 tcg_const_i64(int64_t val) 707c896fe29Sbellard { 708a7812ae4Spbrook TCGv_i64 t0; 709a7812ae4Spbrook t0 = tcg_temp_new_i64(); 710e8996ee0Sbellard tcg_gen_movi_i64(t0, val); 711e8996ee0Sbellard return t0; 712c896fe29Sbellard } 713c896fe29Sbellard 714a7812ae4Spbrook TCGv_i32 tcg_const_local_i32(int32_t val) 715bdffd4a9Saurel32 { 716a7812ae4Spbrook TCGv_i32 t0; 717a7812ae4Spbrook t0 = tcg_temp_local_new_i32(); 718bdffd4a9Saurel32 tcg_gen_movi_i32(t0, val); 719bdffd4a9Saurel32 return t0; 720bdffd4a9Saurel32 } 721bdffd4a9Saurel32 722a7812ae4Spbrook TCGv_i64 tcg_const_local_i64(int64_t val) 723bdffd4a9Saurel32 { 724a7812ae4Spbrook TCGv_i64 t0; 725a7812ae4Spbrook t0 = tcg_temp_local_new_i64(); 726bdffd4a9Saurel32 tcg_gen_movi_i64(t0, val); 727bdffd4a9Saurel32 return t0; 728bdffd4a9Saurel32 } 729bdffd4a9Saurel32 73027bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 73127bfd83cSPeter Maydell void tcg_clear_temp_count(void) 73227bfd83cSPeter Maydell { 73327bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 73427bfd83cSPeter Maydell s->temps_in_use = 0; 73527bfd83cSPeter Maydell } 73627bfd83cSPeter Maydell 73727bfd83cSPeter Maydell int tcg_check_temp_count(void) 73827bfd83cSPeter Maydell { 73927bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 74027bfd83cSPeter Maydell if (s->temps_in_use) { 74127bfd83cSPeter Maydell /* Clear the count so that we don't give another 74227bfd83cSPeter Maydell * warning immediately next time around. 74327bfd83cSPeter Maydell */ 74427bfd83cSPeter Maydell s->temps_in_use = 0; 74527bfd83cSPeter Maydell return 1; 74627bfd83cSPeter Maydell } 74727bfd83cSPeter Maydell return 0; 74827bfd83cSPeter Maydell } 74927bfd83cSPeter Maydell #endif 75027bfd83cSPeter Maydell 751be0f34b5SRichard Henderson /* Return true if OP may appear in the opcode stream. 752be0f34b5SRichard Henderson Test the runtime variable that controls each opcode. */ 753be0f34b5SRichard Henderson bool tcg_op_supported(TCGOpcode op) 754be0f34b5SRichard Henderson { 755be0f34b5SRichard Henderson switch (op) { 756be0f34b5SRichard Henderson case INDEX_op_discard: 757be0f34b5SRichard Henderson case INDEX_op_set_label: 758be0f34b5SRichard Henderson case INDEX_op_call: 759be0f34b5SRichard Henderson case INDEX_op_br: 760be0f34b5SRichard Henderson case INDEX_op_mb: 761be0f34b5SRichard Henderson case INDEX_op_insn_start: 762be0f34b5SRichard Henderson case INDEX_op_exit_tb: 763be0f34b5SRichard Henderson case INDEX_op_goto_tb: 764be0f34b5SRichard Henderson case INDEX_op_qemu_ld_i32: 765be0f34b5SRichard Henderson case INDEX_op_qemu_st_i32: 766be0f34b5SRichard Henderson case INDEX_op_qemu_ld_i64: 767be0f34b5SRichard Henderson case INDEX_op_qemu_st_i64: 768be0f34b5SRichard Henderson return true; 769be0f34b5SRichard Henderson 770be0f34b5SRichard Henderson case INDEX_op_goto_ptr: 771be0f34b5SRichard Henderson return TCG_TARGET_HAS_goto_ptr; 772be0f34b5SRichard Henderson 773be0f34b5SRichard Henderson case INDEX_op_mov_i32: 774be0f34b5SRichard Henderson case INDEX_op_movi_i32: 775be0f34b5SRichard Henderson case INDEX_op_setcond_i32: 776be0f34b5SRichard Henderson case INDEX_op_brcond_i32: 777be0f34b5SRichard Henderson case INDEX_op_ld8u_i32: 778be0f34b5SRichard Henderson case INDEX_op_ld8s_i32: 779be0f34b5SRichard Henderson case INDEX_op_ld16u_i32: 780be0f34b5SRichard Henderson case INDEX_op_ld16s_i32: 781be0f34b5SRichard Henderson case INDEX_op_ld_i32: 782be0f34b5SRichard Henderson case INDEX_op_st8_i32: 783be0f34b5SRichard Henderson case INDEX_op_st16_i32: 784be0f34b5SRichard Henderson case INDEX_op_st_i32: 785be0f34b5SRichard Henderson case INDEX_op_add_i32: 786be0f34b5SRichard Henderson case INDEX_op_sub_i32: 787be0f34b5SRichard Henderson case INDEX_op_mul_i32: 788be0f34b5SRichard Henderson case INDEX_op_and_i32: 789be0f34b5SRichard Henderson case INDEX_op_or_i32: 790be0f34b5SRichard Henderson case INDEX_op_xor_i32: 791be0f34b5SRichard Henderson case INDEX_op_shl_i32: 792be0f34b5SRichard Henderson case INDEX_op_shr_i32: 793be0f34b5SRichard Henderson case INDEX_op_sar_i32: 794be0f34b5SRichard Henderson return true; 795be0f34b5SRichard Henderson 796be0f34b5SRichard Henderson case INDEX_op_movcond_i32: 797be0f34b5SRichard Henderson return TCG_TARGET_HAS_movcond_i32; 798be0f34b5SRichard Henderson case INDEX_op_div_i32: 799be0f34b5SRichard Henderson case INDEX_op_divu_i32: 800be0f34b5SRichard Henderson return TCG_TARGET_HAS_div_i32; 801be0f34b5SRichard Henderson case INDEX_op_rem_i32: 802be0f34b5SRichard Henderson case INDEX_op_remu_i32: 803be0f34b5SRichard Henderson return TCG_TARGET_HAS_rem_i32; 804be0f34b5SRichard Henderson case INDEX_op_div2_i32: 805be0f34b5SRichard Henderson case INDEX_op_divu2_i32: 806be0f34b5SRichard Henderson return TCG_TARGET_HAS_div2_i32; 807be0f34b5SRichard Henderson case INDEX_op_rotl_i32: 808be0f34b5SRichard Henderson case INDEX_op_rotr_i32: 809be0f34b5SRichard Henderson return TCG_TARGET_HAS_rot_i32; 810be0f34b5SRichard Henderson case INDEX_op_deposit_i32: 811be0f34b5SRichard Henderson return TCG_TARGET_HAS_deposit_i32; 812be0f34b5SRichard Henderson case INDEX_op_extract_i32: 813be0f34b5SRichard Henderson return TCG_TARGET_HAS_extract_i32; 814be0f34b5SRichard Henderson case INDEX_op_sextract_i32: 815be0f34b5SRichard Henderson return TCG_TARGET_HAS_sextract_i32; 816be0f34b5SRichard Henderson case INDEX_op_add2_i32: 817be0f34b5SRichard Henderson return TCG_TARGET_HAS_add2_i32; 818be0f34b5SRichard Henderson case INDEX_op_sub2_i32: 819be0f34b5SRichard Henderson return TCG_TARGET_HAS_sub2_i32; 820be0f34b5SRichard Henderson case INDEX_op_mulu2_i32: 821be0f34b5SRichard Henderson return TCG_TARGET_HAS_mulu2_i32; 822be0f34b5SRichard Henderson case INDEX_op_muls2_i32: 823be0f34b5SRichard Henderson return TCG_TARGET_HAS_muls2_i32; 824be0f34b5SRichard Henderson case INDEX_op_muluh_i32: 825be0f34b5SRichard Henderson return TCG_TARGET_HAS_muluh_i32; 826be0f34b5SRichard Henderson case INDEX_op_mulsh_i32: 827be0f34b5SRichard Henderson return TCG_TARGET_HAS_mulsh_i32; 828be0f34b5SRichard Henderson case INDEX_op_ext8s_i32: 829be0f34b5SRichard Henderson return TCG_TARGET_HAS_ext8s_i32; 830be0f34b5SRichard Henderson case INDEX_op_ext16s_i32: 831be0f34b5SRichard Henderson return TCG_TARGET_HAS_ext16s_i32; 832be0f34b5SRichard Henderson case INDEX_op_ext8u_i32: 833be0f34b5SRichard Henderson return TCG_TARGET_HAS_ext8u_i32; 834be0f34b5SRichard Henderson case INDEX_op_ext16u_i32: 835be0f34b5SRichard Henderson return TCG_TARGET_HAS_ext16u_i32; 836be0f34b5SRichard Henderson case INDEX_op_bswap16_i32: 837be0f34b5SRichard Henderson return TCG_TARGET_HAS_bswap16_i32; 838be0f34b5SRichard Henderson case INDEX_op_bswap32_i32: 839be0f34b5SRichard Henderson return TCG_TARGET_HAS_bswap32_i32; 840be0f34b5SRichard Henderson case INDEX_op_not_i32: 841be0f34b5SRichard Henderson return TCG_TARGET_HAS_not_i32; 842be0f34b5SRichard Henderson case INDEX_op_neg_i32: 843be0f34b5SRichard Henderson return TCG_TARGET_HAS_neg_i32; 844be0f34b5SRichard Henderson case INDEX_op_andc_i32: 845be0f34b5SRichard Henderson return TCG_TARGET_HAS_andc_i32; 846be0f34b5SRichard Henderson case INDEX_op_orc_i32: 847be0f34b5SRichard Henderson return TCG_TARGET_HAS_orc_i32; 848be0f34b5SRichard Henderson case INDEX_op_eqv_i32: 849be0f34b5SRichard Henderson return TCG_TARGET_HAS_eqv_i32; 850be0f34b5SRichard Henderson case INDEX_op_nand_i32: 851be0f34b5SRichard Henderson return TCG_TARGET_HAS_nand_i32; 852be0f34b5SRichard Henderson case INDEX_op_nor_i32: 853be0f34b5SRichard Henderson return TCG_TARGET_HAS_nor_i32; 854be0f34b5SRichard Henderson case INDEX_op_clz_i32: 855be0f34b5SRichard Henderson return TCG_TARGET_HAS_clz_i32; 856be0f34b5SRichard Henderson case INDEX_op_ctz_i32: 857be0f34b5SRichard Henderson return TCG_TARGET_HAS_ctz_i32; 858be0f34b5SRichard Henderson case INDEX_op_ctpop_i32: 859be0f34b5SRichard Henderson return TCG_TARGET_HAS_ctpop_i32; 860be0f34b5SRichard Henderson 861be0f34b5SRichard Henderson case INDEX_op_brcond2_i32: 862be0f34b5SRichard Henderson case INDEX_op_setcond2_i32: 863be0f34b5SRichard Henderson return TCG_TARGET_REG_BITS == 32; 864be0f34b5SRichard Henderson 865be0f34b5SRichard Henderson case INDEX_op_mov_i64: 866be0f34b5SRichard Henderson case INDEX_op_movi_i64: 867be0f34b5SRichard Henderson case INDEX_op_setcond_i64: 868be0f34b5SRichard Henderson case INDEX_op_brcond_i64: 869be0f34b5SRichard Henderson case INDEX_op_ld8u_i64: 870be0f34b5SRichard Henderson case INDEX_op_ld8s_i64: 871be0f34b5SRichard Henderson case INDEX_op_ld16u_i64: 872be0f34b5SRichard Henderson case INDEX_op_ld16s_i64: 873be0f34b5SRichard Henderson case INDEX_op_ld32u_i64: 874be0f34b5SRichard Henderson case INDEX_op_ld32s_i64: 875be0f34b5SRichard Henderson case INDEX_op_ld_i64: 876be0f34b5SRichard Henderson case INDEX_op_st8_i64: 877be0f34b5SRichard Henderson case INDEX_op_st16_i64: 878be0f34b5SRichard Henderson case INDEX_op_st32_i64: 879be0f34b5SRichard Henderson case INDEX_op_st_i64: 880be0f34b5SRichard Henderson case INDEX_op_add_i64: 881be0f34b5SRichard Henderson case INDEX_op_sub_i64: 882be0f34b5SRichard Henderson case INDEX_op_mul_i64: 883be0f34b5SRichard Henderson case INDEX_op_and_i64: 884be0f34b5SRichard Henderson case INDEX_op_or_i64: 885be0f34b5SRichard Henderson case INDEX_op_xor_i64: 886be0f34b5SRichard Henderson case INDEX_op_shl_i64: 887be0f34b5SRichard Henderson case INDEX_op_shr_i64: 888be0f34b5SRichard Henderson case INDEX_op_sar_i64: 889be0f34b5SRichard Henderson case INDEX_op_ext_i32_i64: 890be0f34b5SRichard Henderson case INDEX_op_extu_i32_i64: 891be0f34b5SRichard Henderson return TCG_TARGET_REG_BITS == 64; 892be0f34b5SRichard Henderson 893be0f34b5SRichard Henderson case INDEX_op_movcond_i64: 894be0f34b5SRichard Henderson return TCG_TARGET_HAS_movcond_i64; 895be0f34b5SRichard Henderson case INDEX_op_div_i64: 896be0f34b5SRichard Henderson case INDEX_op_divu_i64: 897be0f34b5SRichard Henderson return TCG_TARGET_HAS_div_i64; 898be0f34b5SRichard Henderson case INDEX_op_rem_i64: 899be0f34b5SRichard Henderson case INDEX_op_remu_i64: 900be0f34b5SRichard Henderson return TCG_TARGET_HAS_rem_i64; 901be0f34b5SRichard Henderson case INDEX_op_div2_i64: 902be0f34b5SRichard Henderson case INDEX_op_divu2_i64: 903be0f34b5SRichard Henderson return TCG_TARGET_HAS_div2_i64; 904be0f34b5SRichard Henderson case INDEX_op_rotl_i64: 905be0f34b5SRichard Henderson case INDEX_op_rotr_i64: 906be0f34b5SRichard Henderson return TCG_TARGET_HAS_rot_i64; 907be0f34b5SRichard Henderson case INDEX_op_deposit_i64: 908be0f34b5SRichard Henderson return TCG_TARGET_HAS_deposit_i64; 909be0f34b5SRichard Henderson case INDEX_op_extract_i64: 910be0f34b5SRichard Henderson return TCG_TARGET_HAS_extract_i64; 911be0f34b5SRichard Henderson case INDEX_op_sextract_i64: 912be0f34b5SRichard Henderson return TCG_TARGET_HAS_sextract_i64; 913be0f34b5SRichard Henderson case INDEX_op_extrl_i64_i32: 914be0f34b5SRichard Henderson return TCG_TARGET_HAS_extrl_i64_i32; 915be0f34b5SRichard Henderson case INDEX_op_extrh_i64_i32: 916be0f34b5SRichard Henderson return TCG_TARGET_HAS_extrh_i64_i32; 917be0f34b5SRichard Henderson case INDEX_op_ext8s_i64: 918be0f34b5SRichard Henderson return TCG_TARGET_HAS_ext8s_i64; 919be0f34b5SRichard Henderson case INDEX_op_ext16s_i64: 920be0f34b5SRichard Henderson return TCG_TARGET_HAS_ext16s_i64; 921be0f34b5SRichard Henderson case INDEX_op_ext32s_i64: 922be0f34b5SRichard Henderson return TCG_TARGET_HAS_ext32s_i64; 923be0f34b5SRichard Henderson case INDEX_op_ext8u_i64: 924be0f34b5SRichard Henderson return TCG_TARGET_HAS_ext8u_i64; 925be0f34b5SRichard Henderson case INDEX_op_ext16u_i64: 926be0f34b5SRichard Henderson return TCG_TARGET_HAS_ext16u_i64; 927be0f34b5SRichard Henderson case INDEX_op_ext32u_i64: 928be0f34b5SRichard Henderson return TCG_TARGET_HAS_ext32u_i64; 929be0f34b5SRichard Henderson case INDEX_op_bswap16_i64: 930be0f34b5SRichard Henderson return TCG_TARGET_HAS_bswap16_i64; 931be0f34b5SRichard Henderson case INDEX_op_bswap32_i64: 932be0f34b5SRichard Henderson return TCG_TARGET_HAS_bswap32_i64; 933be0f34b5SRichard Henderson case INDEX_op_bswap64_i64: 934be0f34b5SRichard Henderson return TCG_TARGET_HAS_bswap64_i64; 935be0f34b5SRichard Henderson case INDEX_op_not_i64: 936be0f34b5SRichard Henderson return TCG_TARGET_HAS_not_i64; 937be0f34b5SRichard Henderson case INDEX_op_neg_i64: 938be0f34b5SRichard Henderson return TCG_TARGET_HAS_neg_i64; 939be0f34b5SRichard Henderson case INDEX_op_andc_i64: 940be0f34b5SRichard Henderson return TCG_TARGET_HAS_andc_i64; 941be0f34b5SRichard Henderson case INDEX_op_orc_i64: 942be0f34b5SRichard Henderson return TCG_TARGET_HAS_orc_i64; 943be0f34b5SRichard Henderson case INDEX_op_eqv_i64: 944be0f34b5SRichard Henderson return TCG_TARGET_HAS_eqv_i64; 945be0f34b5SRichard Henderson case INDEX_op_nand_i64: 946be0f34b5SRichard Henderson return TCG_TARGET_HAS_nand_i64; 947be0f34b5SRichard Henderson case INDEX_op_nor_i64: 948be0f34b5SRichard Henderson return TCG_TARGET_HAS_nor_i64; 949be0f34b5SRichard Henderson case INDEX_op_clz_i64: 950be0f34b5SRichard Henderson return TCG_TARGET_HAS_clz_i64; 951be0f34b5SRichard Henderson case INDEX_op_ctz_i64: 952be0f34b5SRichard Henderson return TCG_TARGET_HAS_ctz_i64; 953be0f34b5SRichard Henderson case INDEX_op_ctpop_i64: 954be0f34b5SRichard Henderson return TCG_TARGET_HAS_ctpop_i64; 955be0f34b5SRichard Henderson case INDEX_op_add2_i64: 956be0f34b5SRichard Henderson return TCG_TARGET_HAS_add2_i64; 957be0f34b5SRichard Henderson case INDEX_op_sub2_i64: 958be0f34b5SRichard Henderson return TCG_TARGET_HAS_sub2_i64; 959be0f34b5SRichard Henderson case INDEX_op_mulu2_i64: 960be0f34b5SRichard Henderson return TCG_TARGET_HAS_mulu2_i64; 961be0f34b5SRichard Henderson case INDEX_op_muls2_i64: 962be0f34b5SRichard Henderson return TCG_TARGET_HAS_muls2_i64; 963be0f34b5SRichard Henderson case INDEX_op_muluh_i64: 964be0f34b5SRichard Henderson return TCG_TARGET_HAS_muluh_i64; 965be0f34b5SRichard Henderson case INDEX_op_mulsh_i64: 966be0f34b5SRichard Henderson return TCG_TARGET_HAS_mulsh_i64; 967be0f34b5SRichard Henderson 968be0f34b5SRichard Henderson case NB_OPS: 969be0f34b5SRichard Henderson break; 970be0f34b5SRichard Henderson } 971be0f34b5SRichard Henderson g_assert_not_reached(); 972be0f34b5SRichard Henderson } 973be0f34b5SRichard Henderson 97439cf05d3Sbellard /* Note: we convert the 64 bit args to 32 bit and do some alignment 97539cf05d3Sbellard and endian swap. Maybe it would be better to do the alignment 97639cf05d3Sbellard and endian swap in tcg_reg_alloc_call(). */ 977bbb8a1b4SRichard Henderson void tcg_gen_callN(TCGContext *s, void *func, TCGArg ret, 978bbb8a1b4SRichard Henderson int nargs, TCGArg *args) 979c896fe29Sbellard { 98075e8b9b7SRichard Henderson int i, real_args, nb_rets, pi; 981bbb8a1b4SRichard Henderson unsigned sizemask, flags; 982afb49896SRichard Henderson TCGHelperInfo *info; 98375e8b9b7SRichard Henderson TCGOp *op; 984afb49896SRichard Henderson 985619205fdSEmilio G. Cota info = g_hash_table_lookup(helper_table, (gpointer)func); 986bbb8a1b4SRichard Henderson flags = info->flags; 987bbb8a1b4SRichard Henderson sizemask = info->sizemask; 9882bece2c8SRichard Henderson 98934b1a49cSRichard Henderson #if defined(__sparc__) && !defined(__arch64__) \ 99034b1a49cSRichard Henderson && !defined(CONFIG_TCG_INTERPRETER) 99134b1a49cSRichard Henderson /* We have 64-bit values in one register, but need to pass as two 99234b1a49cSRichard Henderson separate parameters. Split them. */ 99334b1a49cSRichard Henderson int orig_sizemask = sizemask; 99434b1a49cSRichard Henderson int orig_nargs = nargs; 99534b1a49cSRichard Henderson TCGv_i64 retl, reth; 99675e8b9b7SRichard Henderson TCGArg split_args[MAX_OPC_PARAM]; 99734b1a49cSRichard Henderson 99834b1a49cSRichard Henderson TCGV_UNUSED_I64(retl); 99934b1a49cSRichard Henderson TCGV_UNUSED_I64(reth); 100034b1a49cSRichard Henderson if (sizemask != 0) { 100134b1a49cSRichard Henderson for (i = real_args = 0; i < nargs; ++i) { 100234b1a49cSRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 100334b1a49cSRichard Henderson if (is_64bit) { 100434b1a49cSRichard Henderson TCGv_i64 orig = MAKE_TCGV_I64(args[i]); 100534b1a49cSRichard Henderson TCGv_i32 h = tcg_temp_new_i32(); 100634b1a49cSRichard Henderson TCGv_i32 l = tcg_temp_new_i32(); 100734b1a49cSRichard Henderson tcg_gen_extr_i64_i32(l, h, orig); 100834b1a49cSRichard Henderson split_args[real_args++] = GET_TCGV_I32(h); 100934b1a49cSRichard Henderson split_args[real_args++] = GET_TCGV_I32(l); 101034b1a49cSRichard Henderson } else { 101134b1a49cSRichard Henderson split_args[real_args++] = args[i]; 101234b1a49cSRichard Henderson } 101334b1a49cSRichard Henderson } 101434b1a49cSRichard Henderson nargs = real_args; 101534b1a49cSRichard Henderson args = split_args; 101634b1a49cSRichard Henderson sizemask = 0; 101734b1a49cSRichard Henderson } 101834b1a49cSRichard Henderson #elif defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 10192bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 10202bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 10212bece2c8SRichard Henderson int is_signed = sizemask & (2 << (i+1)*2); 10222bece2c8SRichard Henderson if (!is_64bit) { 10232bece2c8SRichard Henderson TCGv_i64 temp = tcg_temp_new_i64(); 10242bece2c8SRichard Henderson TCGv_i64 orig = MAKE_TCGV_I64(args[i]); 10252bece2c8SRichard Henderson if (is_signed) { 10262bece2c8SRichard Henderson tcg_gen_ext32s_i64(temp, orig); 10272bece2c8SRichard Henderson } else { 10282bece2c8SRichard Henderson tcg_gen_ext32u_i64(temp, orig); 10292bece2c8SRichard Henderson } 10302bece2c8SRichard Henderson args[i] = GET_TCGV_I64(temp); 10312bece2c8SRichard Henderson } 10322bece2c8SRichard Henderson } 10332bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 10342bece2c8SRichard Henderson 103575e8b9b7SRichard Henderson i = s->gen_next_op_idx; 103675e8b9b7SRichard Henderson tcg_debug_assert(i < OPC_BUF_SIZE); 103775e8b9b7SRichard Henderson s->gen_op_buf[0].prev = i; 103875e8b9b7SRichard Henderson s->gen_next_op_idx = i + 1; 103975e8b9b7SRichard Henderson op = &s->gen_op_buf[i]; 104075e8b9b7SRichard Henderson 104175e8b9b7SRichard Henderson /* Set links for sequential allocation during translation. */ 104275e8b9b7SRichard Henderson memset(op, 0, offsetof(TCGOp, args)); 104375e8b9b7SRichard Henderson op->opc = INDEX_op_call; 104475e8b9b7SRichard Henderson op->prev = i - 1; 104575e8b9b7SRichard Henderson op->next = i + 1; 104675e8b9b7SRichard Henderson 104775e8b9b7SRichard Henderson pi = 0; 1048a7812ae4Spbrook if (ret != TCG_CALL_DUMMY_ARG) { 104934b1a49cSRichard Henderson #if defined(__sparc__) && !defined(__arch64__) \ 105034b1a49cSRichard Henderson && !defined(CONFIG_TCG_INTERPRETER) 105134b1a49cSRichard Henderson if (orig_sizemask & 1) { 105234b1a49cSRichard Henderson /* The 32-bit ABI is going to return the 64-bit value in 105334b1a49cSRichard Henderson the %o0/%o1 register pair. Prepare for this by using 105434b1a49cSRichard Henderson two return temporaries, and reassemble below. */ 105534b1a49cSRichard Henderson retl = tcg_temp_new_i64(); 105634b1a49cSRichard Henderson reth = tcg_temp_new_i64(); 105775e8b9b7SRichard Henderson op->args[pi++] = GET_TCGV_I64(reth); 105875e8b9b7SRichard Henderson op->args[pi++] = GET_TCGV_I64(retl); 105934b1a49cSRichard Henderson nb_rets = 2; 106034b1a49cSRichard Henderson } else { 106175e8b9b7SRichard Henderson op->args[pi++] = ret; 106234b1a49cSRichard Henderson nb_rets = 1; 106334b1a49cSRichard Henderson } 106434b1a49cSRichard Henderson #else 106534b1a49cSRichard Henderson if (TCG_TARGET_REG_BITS < 64 && (sizemask & 1)) { 106602eb19d0SRichard Henderson #ifdef HOST_WORDS_BIGENDIAN 106775e8b9b7SRichard Henderson op->args[pi++] = ret + 1; 106875e8b9b7SRichard Henderson op->args[pi++] = ret; 1069a7812ae4Spbrook #else 107075e8b9b7SRichard Henderson op->args[pi++] = ret; 107175e8b9b7SRichard Henderson op->args[pi++] = ret + 1; 1072a7812ae4Spbrook #endif 1073a7812ae4Spbrook nb_rets = 2; 107434b1a49cSRichard Henderson } else { 107575e8b9b7SRichard Henderson op->args[pi++] = ret; 1076a7812ae4Spbrook nb_rets = 1; 1077a7812ae4Spbrook } 107834b1a49cSRichard Henderson #endif 1079a7812ae4Spbrook } else { 1080a7812ae4Spbrook nb_rets = 0; 1081a7812ae4Spbrook } 108275e8b9b7SRichard Henderson op->callo = nb_rets; 108375e8b9b7SRichard Henderson 1084a7812ae4Spbrook real_args = 0; 1085a7812ae4Spbrook for (i = 0; i < nargs; i++) { 10862bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 1087bbb8a1b4SRichard Henderson if (TCG_TARGET_REG_BITS < 64 && is_64bit) { 108839cf05d3Sbellard #ifdef TCG_TARGET_CALL_ALIGN_ARGS 108939cf05d3Sbellard /* some targets want aligned 64 bit args */ 1090ebd486d5Smalc if (real_args & 1) { 109175e8b9b7SRichard Henderson op->args[pi++] = TCG_CALL_DUMMY_ARG; 1092ebd486d5Smalc real_args++; 109339cf05d3Sbellard } 109439cf05d3Sbellard #endif 10953f90f252SRichard Henderson /* If stack grows up, then we will be placing successive 10963f90f252SRichard Henderson arguments at lower addresses, which means we need to 10973f90f252SRichard Henderson reverse the order compared to how we would normally 10983f90f252SRichard Henderson treat either big or little-endian. For those arguments 10993f90f252SRichard Henderson that will wind up in registers, this still works for 11003f90f252SRichard Henderson HPPA (the only current STACK_GROWSUP target) since the 11013f90f252SRichard Henderson argument registers are *also* allocated in decreasing 11023f90f252SRichard Henderson order. If another such target is added, this logic may 11033f90f252SRichard Henderson have to get more complicated to differentiate between 11043f90f252SRichard Henderson stack arguments and register arguments. */ 110502eb19d0SRichard Henderson #if defined(HOST_WORDS_BIGENDIAN) != defined(TCG_TARGET_STACK_GROWSUP) 110675e8b9b7SRichard Henderson op->args[pi++] = args[i] + 1; 110775e8b9b7SRichard Henderson op->args[pi++] = args[i]; 1108c896fe29Sbellard #else 110975e8b9b7SRichard Henderson op->args[pi++] = args[i]; 111075e8b9b7SRichard Henderson op->args[pi++] = args[i] + 1; 1111c896fe29Sbellard #endif 1112a7812ae4Spbrook real_args += 2; 11132bece2c8SRichard Henderson continue; 11142bece2c8SRichard Henderson } 11152bece2c8SRichard Henderson 111675e8b9b7SRichard Henderson op->args[pi++] = args[i]; 1117a7812ae4Spbrook real_args++; 1118c896fe29Sbellard } 111975e8b9b7SRichard Henderson op->args[pi++] = (uintptr_t)func; 112075e8b9b7SRichard Henderson op->args[pi++] = flags; 112175e8b9b7SRichard Henderson op->calli = real_args; 1122a7812ae4Spbrook 112375e8b9b7SRichard Henderson /* Make sure the fields didn't overflow. */ 112475e8b9b7SRichard Henderson tcg_debug_assert(op->calli == real_args); 112575e8b9b7SRichard Henderson tcg_debug_assert(pi <= ARRAY_SIZE(op->args)); 11262bece2c8SRichard Henderson 112734b1a49cSRichard Henderson #if defined(__sparc__) && !defined(__arch64__) \ 112834b1a49cSRichard Henderson && !defined(CONFIG_TCG_INTERPRETER) 112934b1a49cSRichard Henderson /* Free all of the parts we allocated above. */ 113034b1a49cSRichard Henderson for (i = real_args = 0; i < orig_nargs; ++i) { 113134b1a49cSRichard Henderson int is_64bit = orig_sizemask & (1 << (i+1)*2); 113234b1a49cSRichard Henderson if (is_64bit) { 113334b1a49cSRichard Henderson TCGv_i32 h = MAKE_TCGV_I32(args[real_args++]); 113434b1a49cSRichard Henderson TCGv_i32 l = MAKE_TCGV_I32(args[real_args++]); 113534b1a49cSRichard Henderson tcg_temp_free_i32(h); 113634b1a49cSRichard Henderson tcg_temp_free_i32(l); 113734b1a49cSRichard Henderson } else { 113834b1a49cSRichard Henderson real_args++; 113934b1a49cSRichard Henderson } 114034b1a49cSRichard Henderson } 114134b1a49cSRichard Henderson if (orig_sizemask & 1) { 114234b1a49cSRichard Henderson /* The 32-bit ABI returned two 32-bit pieces. Re-assemble them. 114334b1a49cSRichard Henderson Note that describing these as TCGv_i64 eliminates an unnecessary 114434b1a49cSRichard Henderson zero-extension that tcg_gen_concat_i32_i64 would create. */ 114534b1a49cSRichard Henderson tcg_gen_concat32_i64(MAKE_TCGV_I64(ret), retl, reth); 114634b1a49cSRichard Henderson tcg_temp_free_i64(retl); 114734b1a49cSRichard Henderson tcg_temp_free_i64(reth); 114834b1a49cSRichard Henderson } 114934b1a49cSRichard Henderson #elif defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 11502bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 11512bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 11522bece2c8SRichard Henderson if (!is_64bit) { 11532bece2c8SRichard Henderson TCGv_i64 temp = MAKE_TCGV_I64(args[i]); 11542bece2c8SRichard Henderson tcg_temp_free_i64(temp); 11552bece2c8SRichard Henderson } 11562bece2c8SRichard Henderson } 11572bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 1158a7812ae4Spbrook } 1159c896fe29Sbellard 11608fcd3692Sblueswir1 static void tcg_reg_alloc_start(TCGContext *s) 1161c896fe29Sbellard { 1162c896fe29Sbellard int i; 1163c896fe29Sbellard TCGTemp *ts; 1164c896fe29Sbellard for(i = 0; i < s->nb_globals; i++) { 1165c896fe29Sbellard ts = &s->temps[i]; 1166c896fe29Sbellard if (ts->fixed_reg) { 1167c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 1168c896fe29Sbellard } else { 1169c896fe29Sbellard ts->val_type = TEMP_VAL_MEM; 1170c896fe29Sbellard } 1171c896fe29Sbellard } 1172e8996ee0Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 1173e8996ee0Sbellard ts = &s->temps[i]; 11747dfd8c6aSAurelien Jarno if (ts->temp_local) { 11757dfd8c6aSAurelien Jarno ts->val_type = TEMP_VAL_MEM; 11767dfd8c6aSAurelien Jarno } else { 1177e8996ee0Sbellard ts->val_type = TEMP_VAL_DEAD; 11787dfd8c6aSAurelien Jarno } 1179e8996ee0Sbellard ts->mem_allocated = 0; 1180e8996ee0Sbellard ts->fixed_reg = 0; 1181e8996ee0Sbellard } 1182f8b2f202SRichard Henderson 1183f8b2f202SRichard Henderson memset(s->reg_to_temp, 0, sizeof(s->reg_to_temp)); 1184c896fe29Sbellard } 1185c896fe29Sbellard 1186f8b2f202SRichard Henderson static char *tcg_get_arg_str_ptr(TCGContext *s, char *buf, int buf_size, 1187f8b2f202SRichard Henderson TCGTemp *ts) 1188c896fe29Sbellard { 1189*1807f4c4SRichard Henderson int idx = temp_idx(ts); 1190ac56dd48Spbrook 1191fa477d25SRichard Henderson if (ts->temp_global) { 1192ac56dd48Spbrook pstrcpy(buf, buf_size, ts->name); 1193f8b2f202SRichard Henderson } else if (ts->temp_local) { 1194641d5fbeSbellard snprintf(buf, buf_size, "loc%d", idx - s->nb_globals); 1195f8b2f202SRichard Henderson } else { 1196ac56dd48Spbrook snprintf(buf, buf_size, "tmp%d", idx - s->nb_globals); 1197c896fe29Sbellard } 1198c896fe29Sbellard return buf; 1199c896fe29Sbellard } 1200c896fe29Sbellard 120143439139SRichard Henderson static char *tcg_get_arg_str(TCGContext *s, char *buf, 120243439139SRichard Henderson int buf_size, TCGArg arg) 1203f8b2f202SRichard Henderson { 120443439139SRichard Henderson return tcg_get_arg_str_ptr(s, buf, buf_size, arg_temp(arg)); 1205f8b2f202SRichard Henderson } 1206f8b2f202SRichard Henderson 12076e085f72SRichard Henderson /* Find helper name. */ 12086e085f72SRichard Henderson static inline const char *tcg_find_helper(TCGContext *s, uintptr_t val) 1209e8996ee0Sbellard { 12106e085f72SRichard Henderson const char *ret = NULL; 1211619205fdSEmilio G. Cota if (helper_table) { 1212619205fdSEmilio G. Cota TCGHelperInfo *info = g_hash_table_lookup(helper_table, (gpointer)val); 121372866e82SRichard Henderson if (info) { 121472866e82SRichard Henderson ret = info->name; 121572866e82SRichard Henderson } 1216e8996ee0Sbellard } 12176e085f72SRichard Henderson return ret; 12184dc81f28Sbellard } 12194dc81f28Sbellard 1220f48f3edeSblueswir1 static const char * const cond_name[] = 1221f48f3edeSblueswir1 { 12220aed257fSRichard Henderson [TCG_COND_NEVER] = "never", 12230aed257fSRichard Henderson [TCG_COND_ALWAYS] = "always", 1224f48f3edeSblueswir1 [TCG_COND_EQ] = "eq", 1225f48f3edeSblueswir1 [TCG_COND_NE] = "ne", 1226f48f3edeSblueswir1 [TCG_COND_LT] = "lt", 1227f48f3edeSblueswir1 [TCG_COND_GE] = "ge", 1228f48f3edeSblueswir1 [TCG_COND_LE] = "le", 1229f48f3edeSblueswir1 [TCG_COND_GT] = "gt", 1230f48f3edeSblueswir1 [TCG_COND_LTU] = "ltu", 1231f48f3edeSblueswir1 [TCG_COND_GEU] = "geu", 1232f48f3edeSblueswir1 [TCG_COND_LEU] = "leu", 1233f48f3edeSblueswir1 [TCG_COND_GTU] = "gtu" 1234f48f3edeSblueswir1 }; 1235f48f3edeSblueswir1 1236f713d6adSRichard Henderson static const char * const ldst_name[] = 1237f713d6adSRichard Henderson { 1238f713d6adSRichard Henderson [MO_UB] = "ub", 1239f713d6adSRichard Henderson [MO_SB] = "sb", 1240f713d6adSRichard Henderson [MO_LEUW] = "leuw", 1241f713d6adSRichard Henderson [MO_LESW] = "lesw", 1242f713d6adSRichard Henderson [MO_LEUL] = "leul", 1243f713d6adSRichard Henderson [MO_LESL] = "lesl", 1244f713d6adSRichard Henderson [MO_LEQ] = "leq", 1245f713d6adSRichard Henderson [MO_BEUW] = "beuw", 1246f713d6adSRichard Henderson [MO_BESW] = "besw", 1247f713d6adSRichard Henderson [MO_BEUL] = "beul", 1248f713d6adSRichard Henderson [MO_BESL] = "besl", 1249f713d6adSRichard Henderson [MO_BEQ] = "beq", 1250f713d6adSRichard Henderson }; 1251f713d6adSRichard Henderson 12521f00b27fSSergey Sorokin static const char * const alignment_name[(MO_AMASK >> MO_ASHIFT) + 1] = { 12531f00b27fSSergey Sorokin #ifdef ALIGNED_ONLY 12541f00b27fSSergey Sorokin [MO_UNALN >> MO_ASHIFT] = "un+", 12551f00b27fSSergey Sorokin [MO_ALIGN >> MO_ASHIFT] = "", 12561f00b27fSSergey Sorokin #else 12571f00b27fSSergey Sorokin [MO_UNALN >> MO_ASHIFT] = "", 12581f00b27fSSergey Sorokin [MO_ALIGN >> MO_ASHIFT] = "al+", 12591f00b27fSSergey Sorokin #endif 12601f00b27fSSergey Sorokin [MO_ALIGN_2 >> MO_ASHIFT] = "al2+", 12611f00b27fSSergey Sorokin [MO_ALIGN_4 >> MO_ASHIFT] = "al4+", 12621f00b27fSSergey Sorokin [MO_ALIGN_8 >> MO_ASHIFT] = "al8+", 12631f00b27fSSergey Sorokin [MO_ALIGN_16 >> MO_ASHIFT] = "al16+", 12641f00b27fSSergey Sorokin [MO_ALIGN_32 >> MO_ASHIFT] = "al32+", 12651f00b27fSSergey Sorokin [MO_ALIGN_64 >> MO_ASHIFT] = "al64+", 12661f00b27fSSergey Sorokin }; 12671f00b27fSSergey Sorokin 1268eeacee4dSBlue Swirl void tcg_dump_ops(TCGContext *s) 1269c896fe29Sbellard { 1270c896fe29Sbellard char buf[128]; 1271c45cb8bbSRichard Henderson TCGOp *op; 1272c45cb8bbSRichard Henderson int oi; 1273c896fe29Sbellard 1274dcb8e758SRichard Henderson for (oi = s->gen_op_buf[0].next; oi != 0; oi = op->next) { 1275c45cb8bbSRichard Henderson int i, k, nb_oargs, nb_iargs, nb_cargs; 1276c45cb8bbSRichard Henderson const TCGOpDef *def; 1277c45cb8bbSRichard Henderson TCGOpcode c; 1278bdfb460eSRichard Henderson int col = 0; 1279c45cb8bbSRichard Henderson 1280c45cb8bbSRichard Henderson op = &s->gen_op_buf[oi]; 1281c45cb8bbSRichard Henderson c = op->opc; 1282c896fe29Sbellard def = &tcg_op_defs[c]; 1283c45cb8bbSRichard Henderson 1284765b842aSRichard Henderson if (c == INDEX_op_insn_start) { 1285bdfb460eSRichard Henderson col += qemu_log("%s ----", oi != s->gen_op_buf[0].next ? "\n" : ""); 12869aef40edSRichard Henderson 12879aef40edSRichard Henderson for (i = 0; i < TARGET_INSN_START_WORDS; ++i) { 12889aef40edSRichard Henderson target_ulong a; 12897e4597d7Sbellard #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS 1290efee3746SRichard Henderson a = deposit64(op->args[i * 2], 32, 32, op->args[i * 2 + 1]); 12917e4597d7Sbellard #else 1292efee3746SRichard Henderson a = op->args[i]; 12937e4597d7Sbellard #endif 1294bdfb460eSRichard Henderson col += qemu_log(" " TARGET_FMT_lx, a); 1295eeacee4dSBlue Swirl } 12967e4597d7Sbellard } else if (c == INDEX_op_call) { 1297c896fe29Sbellard /* variable number of arguments */ 1298c45cb8bbSRichard Henderson nb_oargs = op->callo; 1299c45cb8bbSRichard Henderson nb_iargs = op->calli; 1300c896fe29Sbellard nb_cargs = def->nb_cargs; 1301b03cce8eSbellard 1302cf066674SRichard Henderson /* function name, flags, out args */ 1303bdfb460eSRichard Henderson col += qemu_log(" %s %s,$0x%" TCG_PRIlx ",$%d", def->name, 1304efee3746SRichard Henderson tcg_find_helper(s, op->args[nb_oargs + nb_iargs]), 1305efee3746SRichard Henderson op->args[nb_oargs + nb_iargs + 1], nb_oargs); 1306b03cce8eSbellard for (i = 0; i < nb_oargs; i++) { 130743439139SRichard Henderson col += qemu_log(",%s", tcg_get_arg_str(s, buf, sizeof(buf), 1308efee3746SRichard Henderson op->args[i])); 1309b03cce8eSbellard } 1310cf066674SRichard Henderson for (i = 0; i < nb_iargs; i++) { 1311efee3746SRichard Henderson TCGArg arg = op->args[nb_oargs + i]; 1312cf066674SRichard Henderson const char *t = "<dummy>"; 1313cf066674SRichard Henderson if (arg != TCG_CALL_DUMMY_ARG) { 131443439139SRichard Henderson t = tcg_get_arg_str(s, buf, sizeof(buf), arg); 1315b03cce8eSbellard } 1316bdfb460eSRichard Henderson col += qemu_log(",%s", t); 1317e8996ee0Sbellard } 1318b03cce8eSbellard } else { 1319bdfb460eSRichard Henderson col += qemu_log(" %s ", def->name); 1320c45cb8bbSRichard Henderson 1321c896fe29Sbellard nb_oargs = def->nb_oargs; 1322c896fe29Sbellard nb_iargs = def->nb_iargs; 1323c896fe29Sbellard nb_cargs = def->nb_cargs; 1324c896fe29Sbellard 1325c896fe29Sbellard k = 0; 1326c896fe29Sbellard for (i = 0; i < nb_oargs; i++) { 1327eeacee4dSBlue Swirl if (k != 0) { 1328bdfb460eSRichard Henderson col += qemu_log(","); 1329eeacee4dSBlue Swirl } 133043439139SRichard Henderson col += qemu_log("%s", tcg_get_arg_str(s, buf, sizeof(buf), 1331efee3746SRichard Henderson op->args[k++])); 1332c896fe29Sbellard } 1333c896fe29Sbellard for (i = 0; i < nb_iargs; i++) { 1334eeacee4dSBlue Swirl if (k != 0) { 1335bdfb460eSRichard Henderson col += qemu_log(","); 1336eeacee4dSBlue Swirl } 133743439139SRichard Henderson col += qemu_log("%s", tcg_get_arg_str(s, buf, sizeof(buf), 1338efee3746SRichard Henderson op->args[k++])); 1339c896fe29Sbellard } 1340be210acbSRichard Henderson switch (c) { 1341be210acbSRichard Henderson case INDEX_op_brcond_i32: 1342ffc5ea09SRichard Henderson case INDEX_op_setcond_i32: 1343ffc5ea09SRichard Henderson case INDEX_op_movcond_i32: 1344be210acbSRichard Henderson case INDEX_op_brcond2_i32: 1345be210acbSRichard Henderson case INDEX_op_setcond2_i32: 1346ffc5ea09SRichard Henderson case INDEX_op_brcond_i64: 1347be210acbSRichard Henderson case INDEX_op_setcond_i64: 1348ffc5ea09SRichard Henderson case INDEX_op_movcond_i64: 1349efee3746SRichard Henderson if (op->args[k] < ARRAY_SIZE(cond_name) 1350efee3746SRichard Henderson && cond_name[op->args[k]]) { 1351efee3746SRichard Henderson col += qemu_log(",%s", cond_name[op->args[k++]]); 1352eeacee4dSBlue Swirl } else { 1353efee3746SRichard Henderson col += qemu_log(",$0x%" TCG_PRIlx, op->args[k++]); 1354eeacee4dSBlue Swirl } 1355f48f3edeSblueswir1 i = 1; 1356be210acbSRichard Henderson break; 1357f713d6adSRichard Henderson case INDEX_op_qemu_ld_i32: 1358f713d6adSRichard Henderson case INDEX_op_qemu_st_i32: 1359f713d6adSRichard Henderson case INDEX_op_qemu_ld_i64: 1360f713d6adSRichard Henderson case INDEX_op_qemu_st_i64: 136159227d5dSRichard Henderson { 1362efee3746SRichard Henderson TCGMemOpIdx oi = op->args[k++]; 136359227d5dSRichard Henderson TCGMemOp op = get_memop(oi); 136459227d5dSRichard Henderson unsigned ix = get_mmuidx(oi); 136559227d5dSRichard Henderson 136659c4b7e8SRichard Henderson if (op & ~(MO_AMASK | MO_BSWAP | MO_SSIZE)) { 1367bdfb460eSRichard Henderson col += qemu_log(",$0x%x,%u", op, ix); 136859c4b7e8SRichard Henderson } else { 13691f00b27fSSergey Sorokin const char *s_al, *s_op; 13701f00b27fSSergey Sorokin s_al = alignment_name[(op & MO_AMASK) >> MO_ASHIFT]; 137159c4b7e8SRichard Henderson s_op = ldst_name[op & (MO_BSWAP | MO_SSIZE)]; 1372bdfb460eSRichard Henderson col += qemu_log(",%s%s,%u", s_al, s_op, ix); 1373f713d6adSRichard Henderson } 1374f713d6adSRichard Henderson i = 1; 137559227d5dSRichard Henderson } 1376f713d6adSRichard Henderson break; 1377be210acbSRichard Henderson default: 1378f48f3edeSblueswir1 i = 0; 1379be210acbSRichard Henderson break; 1380be210acbSRichard Henderson } 138151e3972cSRichard Henderson switch (c) { 138251e3972cSRichard Henderson case INDEX_op_set_label: 138351e3972cSRichard Henderson case INDEX_op_br: 138451e3972cSRichard Henderson case INDEX_op_brcond_i32: 138551e3972cSRichard Henderson case INDEX_op_brcond_i64: 138651e3972cSRichard Henderson case INDEX_op_brcond2_i32: 1387efee3746SRichard Henderson col += qemu_log("%s$L%d", k ? "," : "", 1388efee3746SRichard Henderson arg_label(op->args[k])->id); 138951e3972cSRichard Henderson i++, k++; 139051e3972cSRichard Henderson break; 139151e3972cSRichard Henderson default: 139251e3972cSRichard Henderson break; 1393eeacee4dSBlue Swirl } 139451e3972cSRichard Henderson for (; i < nb_cargs; i++, k++) { 1395efee3746SRichard Henderson col += qemu_log("%s$0x%" TCG_PRIlx, k ? "," : "", op->args[k]); 1396bdfb460eSRichard Henderson } 1397bdfb460eSRichard Henderson } 1398bdfb460eSRichard Henderson if (op->life) { 1399bdfb460eSRichard Henderson unsigned life = op->life; 1400bdfb460eSRichard Henderson 1401bdfb460eSRichard Henderson for (; col < 48; ++col) { 1402bdfb460eSRichard Henderson putc(' ', qemu_logfile); 1403bdfb460eSRichard Henderson } 1404bdfb460eSRichard Henderson 1405bdfb460eSRichard Henderson if (life & (SYNC_ARG * 3)) { 1406bdfb460eSRichard Henderson qemu_log(" sync:"); 1407bdfb460eSRichard Henderson for (i = 0; i < 2; ++i) { 1408bdfb460eSRichard Henderson if (life & (SYNC_ARG << i)) { 1409bdfb460eSRichard Henderson qemu_log(" %d", i); 1410bdfb460eSRichard Henderson } 1411bdfb460eSRichard Henderson } 1412bdfb460eSRichard Henderson } 1413bdfb460eSRichard Henderson life /= DEAD_ARG; 1414bdfb460eSRichard Henderson if (life) { 1415bdfb460eSRichard Henderson qemu_log(" dead:"); 1416bdfb460eSRichard Henderson for (i = 0; life; ++i, life >>= 1) { 1417bdfb460eSRichard Henderson if (life & 1) { 1418bdfb460eSRichard Henderson qemu_log(" %d", i); 1419bdfb460eSRichard Henderson } 1420bdfb460eSRichard Henderson } 1421c896fe29Sbellard } 1422b03cce8eSbellard } 1423eeacee4dSBlue Swirl qemu_log("\n"); 1424c896fe29Sbellard } 1425c896fe29Sbellard } 1426c896fe29Sbellard 1427c896fe29Sbellard /* we give more priority to constraints with less registers */ 1428c896fe29Sbellard static int get_constraint_priority(const TCGOpDef *def, int k) 1429c896fe29Sbellard { 1430c896fe29Sbellard const TCGArgConstraint *arg_ct; 1431c896fe29Sbellard 1432c896fe29Sbellard int i, n; 1433c896fe29Sbellard arg_ct = &def->args_ct[k]; 1434c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 1435c896fe29Sbellard /* an alias is equivalent to a single register */ 1436c896fe29Sbellard n = 1; 1437c896fe29Sbellard } else { 1438c896fe29Sbellard if (!(arg_ct->ct & TCG_CT_REG)) 1439c896fe29Sbellard return 0; 1440c896fe29Sbellard n = 0; 1441c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1442c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, i)) 1443c896fe29Sbellard n++; 1444c896fe29Sbellard } 1445c896fe29Sbellard } 1446c896fe29Sbellard return TCG_TARGET_NB_REGS - n + 1; 1447c896fe29Sbellard } 1448c896fe29Sbellard 1449c896fe29Sbellard /* sort from highest priority to lowest */ 1450c896fe29Sbellard static void sort_constraints(TCGOpDef *def, int start, int n) 1451c896fe29Sbellard { 1452c896fe29Sbellard int i, j, p1, p2, tmp; 1453c896fe29Sbellard 1454c896fe29Sbellard for(i = 0; i < n; i++) 1455c896fe29Sbellard def->sorted_args[start + i] = start + i; 1456c896fe29Sbellard if (n <= 1) 1457c896fe29Sbellard return; 1458c896fe29Sbellard for(i = 0; i < n - 1; i++) { 1459c896fe29Sbellard for(j = i + 1; j < n; j++) { 1460c896fe29Sbellard p1 = get_constraint_priority(def, def->sorted_args[start + i]); 1461c896fe29Sbellard p2 = get_constraint_priority(def, def->sorted_args[start + j]); 1462c896fe29Sbellard if (p1 < p2) { 1463c896fe29Sbellard tmp = def->sorted_args[start + i]; 1464c896fe29Sbellard def->sorted_args[start + i] = def->sorted_args[start + j]; 1465c896fe29Sbellard def->sorted_args[start + j] = tmp; 1466c896fe29Sbellard } 1467c896fe29Sbellard } 1468c896fe29Sbellard } 1469c896fe29Sbellard } 1470c896fe29Sbellard 1471f69d277eSRichard Henderson static void process_op_defs(TCGContext *s) 1472c896fe29Sbellard { 1473a9751609SRichard Henderson TCGOpcode op; 1474c896fe29Sbellard 1475f69d277eSRichard Henderson for (op = 0; op < NB_OPS; op++) { 1476f69d277eSRichard Henderson TCGOpDef *def = &tcg_op_defs[op]; 1477f69d277eSRichard Henderson const TCGTargetOpDef *tdefs; 1478069ea736SRichard Henderson TCGType type; 1479069ea736SRichard Henderson int i, nb_args; 1480f69d277eSRichard Henderson 1481f69d277eSRichard Henderson if (def->flags & TCG_OPF_NOT_PRESENT) { 1482f69d277eSRichard Henderson continue; 1483f69d277eSRichard Henderson } 1484f69d277eSRichard Henderson 1485c896fe29Sbellard nb_args = def->nb_iargs + def->nb_oargs; 1486f69d277eSRichard Henderson if (nb_args == 0) { 1487f69d277eSRichard Henderson continue; 1488f69d277eSRichard Henderson } 1489f69d277eSRichard Henderson 1490f69d277eSRichard Henderson tdefs = tcg_target_op_def(op); 1491f69d277eSRichard Henderson /* Missing TCGTargetOpDef entry. */ 1492f69d277eSRichard Henderson tcg_debug_assert(tdefs != NULL); 1493f69d277eSRichard Henderson 1494069ea736SRichard Henderson type = (def->flags & TCG_OPF_64BIT ? TCG_TYPE_I64 : TCG_TYPE_I32); 1495c896fe29Sbellard for (i = 0; i < nb_args; i++) { 1496f69d277eSRichard Henderson const char *ct_str = tdefs->args_ct_str[i]; 1497f69d277eSRichard Henderson /* Incomplete TCGTargetOpDef entry. */ 1498eabb7b91SAurelien Jarno tcg_debug_assert(ct_str != NULL); 1499f69d277eSRichard Henderson 1500ccb1bb66SRichard Henderson def->args_ct[i].u.regs = 0; 1501c896fe29Sbellard def->args_ct[i].ct = 0; 150217280ff4SRichard Henderson while (*ct_str != '\0') { 150317280ff4SRichard Henderson switch(*ct_str) { 150417280ff4SRichard Henderson case '0' ... '9': 150517280ff4SRichard Henderson { 150617280ff4SRichard Henderson int oarg = *ct_str - '0'; 150717280ff4SRichard Henderson tcg_debug_assert(ct_str == tdefs->args_ct_str[i]); 1508eabb7b91SAurelien Jarno tcg_debug_assert(oarg < def->nb_oargs); 1509eabb7b91SAurelien Jarno tcg_debug_assert(def->args_ct[oarg].ct & TCG_CT_REG); 151017280ff4SRichard Henderson /* TCG_CT_ALIAS is for the output arguments. 151117280ff4SRichard Henderson The input is tagged with TCG_CT_IALIAS. */ 1512c896fe29Sbellard def->args_ct[i] = def->args_ct[oarg]; 151317280ff4SRichard Henderson def->args_ct[oarg].ct |= TCG_CT_ALIAS; 15145ff9d6a4Sbellard def->args_ct[oarg].alias_index = i; 1515c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_IALIAS; 15165ff9d6a4Sbellard def->args_ct[i].alias_index = oarg; 151717280ff4SRichard Henderson } 151817280ff4SRichard Henderson ct_str++; 1519c896fe29Sbellard break; 152082790a87SRichard Henderson case '&': 152182790a87SRichard Henderson def->args_ct[i].ct |= TCG_CT_NEWREG; 152282790a87SRichard Henderson ct_str++; 152382790a87SRichard Henderson break; 1524c896fe29Sbellard case 'i': 1525c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_CONST; 1526c896fe29Sbellard ct_str++; 1527c896fe29Sbellard break; 1528c896fe29Sbellard default: 1529069ea736SRichard Henderson ct_str = target_parse_constraint(&def->args_ct[i], 1530069ea736SRichard Henderson ct_str, type); 1531f69d277eSRichard Henderson /* Typo in TCGTargetOpDef constraint. */ 1532069ea736SRichard Henderson tcg_debug_assert(ct_str != NULL); 1533c896fe29Sbellard } 1534c896fe29Sbellard } 1535c896fe29Sbellard } 1536c896fe29Sbellard 1537c68aaa18SStefan Weil /* TCGTargetOpDef entry with too much information? */ 1538eabb7b91SAurelien Jarno tcg_debug_assert(i == TCG_MAX_OP_ARGS || tdefs->args_ct_str[i] == NULL); 1539c68aaa18SStefan Weil 1540c896fe29Sbellard /* sort the constraints (XXX: this is just an heuristic) */ 1541c896fe29Sbellard sort_constraints(def, 0, def->nb_oargs); 1542c896fe29Sbellard sort_constraints(def, def->nb_oargs, def->nb_iargs); 1543c896fe29Sbellard } 1544c896fe29Sbellard } 1545c896fe29Sbellard 15460c627cdcSRichard Henderson void tcg_op_remove(TCGContext *s, TCGOp *op) 15470c627cdcSRichard Henderson { 15480c627cdcSRichard Henderson int next = op->next; 15490c627cdcSRichard Henderson int prev = op->prev; 15500c627cdcSRichard Henderson 1551dcb8e758SRichard Henderson /* We should never attempt to remove the list terminator. */ 1552dcb8e758SRichard Henderson tcg_debug_assert(op != &s->gen_op_buf[0]); 15530c627cdcSRichard Henderson 1554dcb8e758SRichard Henderson s->gen_op_buf[next].prev = prev; 1555dcb8e758SRichard Henderson s->gen_op_buf[prev].next = next; 1556dcb8e758SRichard Henderson 1557dcb8e758SRichard Henderson memset(op, 0, sizeof(*op)); 15580c627cdcSRichard Henderson 15590c627cdcSRichard Henderson #ifdef CONFIG_PROFILER 15600c627cdcSRichard Henderson s->del_op_count++; 15610c627cdcSRichard Henderson #endif 15620c627cdcSRichard Henderson } 15630c627cdcSRichard Henderson 15645a18407fSRichard Henderson TCGOp *tcg_op_insert_before(TCGContext *s, TCGOp *old_op, 15655a18407fSRichard Henderson TCGOpcode opc, int nargs) 15665a18407fSRichard Henderson { 15675a18407fSRichard Henderson int oi = s->gen_next_op_idx; 15685a18407fSRichard Henderson int prev = old_op->prev; 15695a18407fSRichard Henderson int next = old_op - s->gen_op_buf; 15705a18407fSRichard Henderson TCGOp *new_op; 15715a18407fSRichard Henderson 15725a18407fSRichard Henderson tcg_debug_assert(oi < OPC_BUF_SIZE); 15735a18407fSRichard Henderson s->gen_next_op_idx = oi + 1; 15745a18407fSRichard Henderson 15755a18407fSRichard Henderson new_op = &s->gen_op_buf[oi]; 15765a18407fSRichard Henderson *new_op = (TCGOp){ 15775a18407fSRichard Henderson .opc = opc, 15785a18407fSRichard Henderson .prev = prev, 15795a18407fSRichard Henderson .next = next 15805a18407fSRichard Henderson }; 15815a18407fSRichard Henderson s->gen_op_buf[prev].next = oi; 15825a18407fSRichard Henderson old_op->prev = oi; 15835a18407fSRichard Henderson 15845a18407fSRichard Henderson return new_op; 15855a18407fSRichard Henderson } 15865a18407fSRichard Henderson 15875a18407fSRichard Henderson TCGOp *tcg_op_insert_after(TCGContext *s, TCGOp *old_op, 15885a18407fSRichard Henderson TCGOpcode opc, int nargs) 15895a18407fSRichard Henderson { 15905a18407fSRichard Henderson int oi = s->gen_next_op_idx; 15915a18407fSRichard Henderson int prev = old_op - s->gen_op_buf; 15925a18407fSRichard Henderson int next = old_op->next; 15935a18407fSRichard Henderson TCGOp *new_op; 15945a18407fSRichard Henderson 15955a18407fSRichard Henderson tcg_debug_assert(oi < OPC_BUF_SIZE); 15965a18407fSRichard Henderson s->gen_next_op_idx = oi + 1; 15975a18407fSRichard Henderson 15985a18407fSRichard Henderson new_op = &s->gen_op_buf[oi]; 15995a18407fSRichard Henderson *new_op = (TCGOp){ 16005a18407fSRichard Henderson .opc = opc, 16015a18407fSRichard Henderson .prev = prev, 16025a18407fSRichard Henderson .next = next 16035a18407fSRichard Henderson }; 16045a18407fSRichard Henderson s->gen_op_buf[next].prev = oi; 16055a18407fSRichard Henderson old_op->next = oi; 16065a18407fSRichard Henderson 16075a18407fSRichard Henderson return new_op; 16085a18407fSRichard Henderson } 16095a18407fSRichard Henderson 1610c70fbf0aSRichard Henderson #define TS_DEAD 1 1611c70fbf0aSRichard Henderson #define TS_MEM 2 1612c70fbf0aSRichard Henderson 16135a18407fSRichard Henderson #define IS_DEAD_ARG(n) (arg_life & (DEAD_ARG << (n))) 16145a18407fSRichard Henderson #define NEED_SYNC_ARG(n) (arg_life & (SYNC_ARG << (n))) 16155a18407fSRichard Henderson 16169c43b68dSAurelien Jarno /* liveness analysis: end of function: all temps are dead, and globals 16179c43b68dSAurelien Jarno should be in memory. */ 1618c70fbf0aSRichard Henderson static inline void tcg_la_func_end(TCGContext *s, uint8_t *temp_state) 1619c896fe29Sbellard { 1620c70fbf0aSRichard Henderson memset(temp_state, TS_DEAD | TS_MEM, s->nb_globals); 1621c70fbf0aSRichard Henderson memset(temp_state + s->nb_globals, TS_DEAD, s->nb_temps - s->nb_globals); 1622c896fe29Sbellard } 1623c896fe29Sbellard 16249c43b68dSAurelien Jarno /* liveness analysis: end of basic block: all temps are dead, globals 16259c43b68dSAurelien Jarno and local temps should be in memory. */ 1626c70fbf0aSRichard Henderson static inline void tcg_la_bb_end(TCGContext *s, uint8_t *temp_state) 1627641d5fbeSbellard { 1628c70fbf0aSRichard Henderson int i, n; 1629641d5fbeSbellard 1630c70fbf0aSRichard Henderson tcg_la_func_end(s, temp_state); 1631c70fbf0aSRichard Henderson for (i = s->nb_globals, n = s->nb_temps; i < n; i++) { 1632c70fbf0aSRichard Henderson if (s->temps[i].temp_local) { 1633c70fbf0aSRichard Henderson temp_state[i] |= TS_MEM; 1634c70fbf0aSRichard Henderson } 1635641d5fbeSbellard } 1636641d5fbeSbellard } 1637641d5fbeSbellard 1638a1b3c48dSRichard Henderson /* Liveness analysis : update the opc_arg_life array to tell if a 1639c896fe29Sbellard given input arguments is dead. Instructions updating dead 1640c896fe29Sbellard temporaries are removed. */ 16415a18407fSRichard Henderson static void liveness_pass_1(TCGContext *s, uint8_t *temp_state) 1642c896fe29Sbellard { 1643c70fbf0aSRichard Henderson int nb_globals = s->nb_globals; 16445a18407fSRichard Henderson int oi, oi_prev; 1645c896fe29Sbellard 1646c70fbf0aSRichard Henderson tcg_la_func_end(s, temp_state); 1647c896fe29Sbellard 1648dcb8e758SRichard Henderson for (oi = s->gen_op_buf[0].prev; oi != 0; oi = oi_prev) { 1649c45cb8bbSRichard Henderson int i, nb_iargs, nb_oargs; 1650c45cb8bbSRichard Henderson TCGOpcode opc_new, opc_new2; 1651c45cb8bbSRichard Henderson bool have_opc_new2; 1652a1b3c48dSRichard Henderson TCGLifeData arg_life = 0; 1653c45cb8bbSRichard Henderson TCGArg arg; 1654c45cb8bbSRichard Henderson 1655c45cb8bbSRichard Henderson TCGOp * const op = &s->gen_op_buf[oi]; 1656c45cb8bbSRichard Henderson TCGOpcode opc = op->opc; 1657c45cb8bbSRichard Henderson const TCGOpDef *def = &tcg_op_defs[opc]; 1658c45cb8bbSRichard Henderson 1659c45cb8bbSRichard Henderson oi_prev = op->prev; 1660c45cb8bbSRichard Henderson 1661c45cb8bbSRichard Henderson switch (opc) { 1662c896fe29Sbellard case INDEX_op_call: 1663c6e113f5Sbellard { 1664c6e113f5Sbellard int call_flags; 1665c6e113f5Sbellard 1666c45cb8bbSRichard Henderson nb_oargs = op->callo; 1667c45cb8bbSRichard Henderson nb_iargs = op->calli; 1668efee3746SRichard Henderson call_flags = op->args[nb_oargs + nb_iargs + 1]; 1669c6e113f5Sbellard 1670c45cb8bbSRichard Henderson /* pure functions can be removed if their result is unused */ 167178505279SAurelien Jarno if (call_flags & TCG_CALL_NO_SIDE_EFFECTS) { 1672c6e113f5Sbellard for (i = 0; i < nb_oargs; i++) { 1673efee3746SRichard Henderson arg = op->args[i]; 1674c70fbf0aSRichard Henderson if (temp_state[arg] != TS_DEAD) { 1675c6e113f5Sbellard goto do_not_remove_call; 1676c6e113f5Sbellard } 16779c43b68dSAurelien Jarno } 1678c45cb8bbSRichard Henderson goto do_remove; 1679c6e113f5Sbellard } else { 1680c6e113f5Sbellard do_not_remove_call: 1681c896fe29Sbellard 1682c896fe29Sbellard /* output args are dead */ 1683c896fe29Sbellard for (i = 0; i < nb_oargs; i++) { 1684efee3746SRichard Henderson arg = op->args[i]; 1685c70fbf0aSRichard Henderson if (temp_state[arg] & TS_DEAD) { 1686a1b3c48dSRichard Henderson arg_life |= DEAD_ARG << i; 16876b64b624SAurelien Jarno } 1688c70fbf0aSRichard Henderson if (temp_state[arg] & TS_MEM) { 1689a1b3c48dSRichard Henderson arg_life |= SYNC_ARG << i; 16909c43b68dSAurelien Jarno } 1691c70fbf0aSRichard Henderson temp_state[arg] = TS_DEAD; 1692c896fe29Sbellard } 1693c896fe29Sbellard 169478505279SAurelien Jarno if (!(call_flags & (TCG_CALL_NO_WRITE_GLOBALS | 169578505279SAurelien Jarno TCG_CALL_NO_READ_GLOBALS))) { 16969c43b68dSAurelien Jarno /* globals should go back to memory */ 1697c70fbf0aSRichard Henderson memset(temp_state, TS_DEAD | TS_MEM, nb_globals); 1698c70fbf0aSRichard Henderson } else if (!(call_flags & TCG_CALL_NO_READ_GLOBALS)) { 1699c70fbf0aSRichard Henderson /* globals should be synced to memory */ 1700c70fbf0aSRichard Henderson for (i = 0; i < nb_globals; i++) { 1701c70fbf0aSRichard Henderson temp_state[i] |= TS_MEM; 1702c70fbf0aSRichard Henderson } 1703b9c18f56Saurel32 } 1704c896fe29Sbellard 1705c19f47bfSAurelien Jarno /* record arguments that die in this helper */ 1706866cb6cbSAurelien Jarno for (i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 1707efee3746SRichard Henderson arg = op->args[i]; 170839cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 1709c70fbf0aSRichard Henderson if (temp_state[arg] & TS_DEAD) { 1710a1b3c48dSRichard Henderson arg_life |= DEAD_ARG << i; 1711c896fe29Sbellard } 1712c896fe29Sbellard } 171339cf05d3Sbellard } 171467cc32ebSVeres Lajos /* input arguments are live for preceding opcodes */ 1715c70fbf0aSRichard Henderson for (i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 1716efee3746SRichard Henderson arg = op->args[i]; 1717c70fbf0aSRichard Henderson if (arg != TCG_CALL_DUMMY_ARG) { 1718c70fbf0aSRichard Henderson temp_state[arg] &= ~TS_DEAD; 1719c70fbf0aSRichard Henderson } 1720c19f47bfSAurelien Jarno } 1721c6e113f5Sbellard } 1722c6e113f5Sbellard } 1723c896fe29Sbellard break; 1724765b842aSRichard Henderson case INDEX_op_insn_start: 1725c896fe29Sbellard break; 17265ff9d6a4Sbellard case INDEX_op_discard: 17275ff9d6a4Sbellard /* mark the temporary as dead */ 1728efee3746SRichard Henderson temp_state[op->args[0]] = TS_DEAD; 17295ff9d6a4Sbellard break; 17301305c451SRichard Henderson 17311305c451SRichard Henderson case INDEX_op_add2_i32: 1732c45cb8bbSRichard Henderson opc_new = INDEX_op_add_i32; 1733f1fae40cSRichard Henderson goto do_addsub2; 17341305c451SRichard Henderson case INDEX_op_sub2_i32: 1735c45cb8bbSRichard Henderson opc_new = INDEX_op_sub_i32; 1736f1fae40cSRichard Henderson goto do_addsub2; 1737f1fae40cSRichard Henderson case INDEX_op_add2_i64: 1738c45cb8bbSRichard Henderson opc_new = INDEX_op_add_i64; 1739f1fae40cSRichard Henderson goto do_addsub2; 1740f1fae40cSRichard Henderson case INDEX_op_sub2_i64: 1741c45cb8bbSRichard Henderson opc_new = INDEX_op_sub_i64; 1742f1fae40cSRichard Henderson do_addsub2: 17431305c451SRichard Henderson nb_iargs = 4; 17441305c451SRichard Henderson nb_oargs = 2; 17451305c451SRichard Henderson /* Test if the high part of the operation is dead, but not 17461305c451SRichard Henderson the low part. The result can be optimized to a simple 17471305c451SRichard Henderson add or sub. This happens often for x86_64 guest when the 17481305c451SRichard Henderson cpu mode is set to 32 bit. */ 1749efee3746SRichard Henderson if (temp_state[op->args[1]] == TS_DEAD) { 1750efee3746SRichard Henderson if (temp_state[op->args[0]] == TS_DEAD) { 17511305c451SRichard Henderson goto do_remove; 17521305c451SRichard Henderson } 1753c45cb8bbSRichard Henderson /* Replace the opcode and adjust the args in place, 1754c45cb8bbSRichard Henderson leaving 3 unused args at the end. */ 1755c45cb8bbSRichard Henderson op->opc = opc = opc_new; 1756efee3746SRichard Henderson op->args[1] = op->args[2]; 1757efee3746SRichard Henderson op->args[2] = op->args[4]; 17581305c451SRichard Henderson /* Fall through and mark the single-word operation live. */ 17591305c451SRichard Henderson nb_iargs = 2; 17601305c451SRichard Henderson nb_oargs = 1; 17611305c451SRichard Henderson } 17621305c451SRichard Henderson goto do_not_remove; 17631305c451SRichard Henderson 17641414968aSRichard Henderson case INDEX_op_mulu2_i32: 1765c45cb8bbSRichard Henderson opc_new = INDEX_op_mul_i32; 1766c45cb8bbSRichard Henderson opc_new2 = INDEX_op_muluh_i32; 1767c45cb8bbSRichard Henderson have_opc_new2 = TCG_TARGET_HAS_muluh_i32; 176803271524SRichard Henderson goto do_mul2; 1769f1fae40cSRichard Henderson case INDEX_op_muls2_i32: 1770c45cb8bbSRichard Henderson opc_new = INDEX_op_mul_i32; 1771c45cb8bbSRichard Henderson opc_new2 = INDEX_op_mulsh_i32; 1772c45cb8bbSRichard Henderson have_opc_new2 = TCG_TARGET_HAS_mulsh_i32; 1773f1fae40cSRichard Henderson goto do_mul2; 1774f1fae40cSRichard Henderson case INDEX_op_mulu2_i64: 1775c45cb8bbSRichard Henderson opc_new = INDEX_op_mul_i64; 1776c45cb8bbSRichard Henderson opc_new2 = INDEX_op_muluh_i64; 1777c45cb8bbSRichard Henderson have_opc_new2 = TCG_TARGET_HAS_muluh_i64; 177803271524SRichard Henderson goto do_mul2; 1779f1fae40cSRichard Henderson case INDEX_op_muls2_i64: 1780c45cb8bbSRichard Henderson opc_new = INDEX_op_mul_i64; 1781c45cb8bbSRichard Henderson opc_new2 = INDEX_op_mulsh_i64; 1782c45cb8bbSRichard Henderson have_opc_new2 = TCG_TARGET_HAS_mulsh_i64; 178303271524SRichard Henderson goto do_mul2; 1784f1fae40cSRichard Henderson do_mul2: 17851414968aSRichard Henderson nb_iargs = 2; 17861414968aSRichard Henderson nb_oargs = 2; 1787efee3746SRichard Henderson if (temp_state[op->args[1]] == TS_DEAD) { 1788efee3746SRichard Henderson if (temp_state[op->args[0]] == TS_DEAD) { 178903271524SRichard Henderson /* Both parts of the operation are dead. */ 17901414968aSRichard Henderson goto do_remove; 17911414968aSRichard Henderson } 179203271524SRichard Henderson /* The high part of the operation is dead; generate the low. */ 1793c45cb8bbSRichard Henderson op->opc = opc = opc_new; 1794efee3746SRichard Henderson op->args[1] = op->args[2]; 1795efee3746SRichard Henderson op->args[2] = op->args[3]; 1796efee3746SRichard Henderson } else if (temp_state[op->args[0]] == TS_DEAD && have_opc_new2) { 179703271524SRichard Henderson /* The low part of the operation is dead; generate the high. */ 1798c45cb8bbSRichard Henderson op->opc = opc = opc_new2; 1799efee3746SRichard Henderson op->args[0] = op->args[1]; 1800efee3746SRichard Henderson op->args[1] = op->args[2]; 1801efee3746SRichard Henderson op->args[2] = op->args[3]; 180203271524SRichard Henderson } else { 180303271524SRichard Henderson goto do_not_remove; 180403271524SRichard Henderson } 180503271524SRichard Henderson /* Mark the single-word operation live. */ 18061414968aSRichard Henderson nb_oargs = 1; 18071414968aSRichard Henderson goto do_not_remove; 18081414968aSRichard Henderson 1809c896fe29Sbellard default: 18101305c451SRichard Henderson /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */ 1811c896fe29Sbellard nb_iargs = def->nb_iargs; 1812c896fe29Sbellard nb_oargs = def->nb_oargs; 1813c896fe29Sbellard 1814c896fe29Sbellard /* Test if the operation can be removed because all 18155ff9d6a4Sbellard its outputs are dead. We assume that nb_oargs == 0 18165ff9d6a4Sbellard implies side effects */ 18175ff9d6a4Sbellard if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) { 1818c896fe29Sbellard for (i = 0; i < nb_oargs; i++) { 1819efee3746SRichard Henderson if (temp_state[op->args[i]] != TS_DEAD) { 1820c896fe29Sbellard goto do_not_remove; 1821c896fe29Sbellard } 18229c43b68dSAurelien Jarno } 18231305c451SRichard Henderson do_remove: 18240c627cdcSRichard Henderson tcg_op_remove(s, op); 1825c896fe29Sbellard } else { 1826c896fe29Sbellard do_not_remove: 1827c896fe29Sbellard /* output args are dead */ 1828c896fe29Sbellard for (i = 0; i < nb_oargs; i++) { 1829efee3746SRichard Henderson arg = op->args[i]; 1830c70fbf0aSRichard Henderson if (temp_state[arg] & TS_DEAD) { 1831a1b3c48dSRichard Henderson arg_life |= DEAD_ARG << i; 18326b64b624SAurelien Jarno } 1833c70fbf0aSRichard Henderson if (temp_state[arg] & TS_MEM) { 1834a1b3c48dSRichard Henderson arg_life |= SYNC_ARG << i; 18359c43b68dSAurelien Jarno } 1836c70fbf0aSRichard Henderson temp_state[arg] = TS_DEAD; 1837c896fe29Sbellard } 1838c896fe29Sbellard 1839c896fe29Sbellard /* if end of basic block, update */ 1840c896fe29Sbellard if (def->flags & TCG_OPF_BB_END) { 1841c70fbf0aSRichard Henderson tcg_la_bb_end(s, temp_state); 18423d5c5f87SAurelien Jarno } else if (def->flags & TCG_OPF_SIDE_EFFECTS) { 18433d5c5f87SAurelien Jarno /* globals should be synced to memory */ 1844c70fbf0aSRichard Henderson for (i = 0; i < nb_globals; i++) { 1845c70fbf0aSRichard Henderson temp_state[i] |= TS_MEM; 1846c70fbf0aSRichard Henderson } 1847c896fe29Sbellard } 1848c896fe29Sbellard 1849c19f47bfSAurelien Jarno /* record arguments that die in this opcode */ 1850866cb6cbSAurelien Jarno for (i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 1851efee3746SRichard Henderson arg = op->args[i]; 1852c70fbf0aSRichard Henderson if (temp_state[arg] & TS_DEAD) { 1853a1b3c48dSRichard Henderson arg_life |= DEAD_ARG << i; 1854c896fe29Sbellard } 1855c19f47bfSAurelien Jarno } 185667cc32ebSVeres Lajos /* input arguments are live for preceding opcodes */ 1857c19f47bfSAurelien Jarno for (i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 1858efee3746SRichard Henderson temp_state[op->args[i]] &= ~TS_DEAD; 1859c896fe29Sbellard } 1860c896fe29Sbellard } 1861c896fe29Sbellard break; 1862c896fe29Sbellard } 1863bee158cbSRichard Henderson op->life = arg_life; 1864c896fe29Sbellard } 18651ff0a2c5SEvgeny Voevodin } 1866c896fe29Sbellard 18675a18407fSRichard Henderson /* Liveness analysis: Convert indirect regs to direct temporaries. */ 18685a18407fSRichard Henderson static bool liveness_pass_2(TCGContext *s, uint8_t *temp_state) 18695a18407fSRichard Henderson { 18705a18407fSRichard Henderson int nb_globals = s->nb_globals; 18715a18407fSRichard Henderson int16_t *dir_temps; 18725a18407fSRichard Henderson int i, oi, oi_next; 18735a18407fSRichard Henderson bool changes = false; 18745a18407fSRichard Henderson 18755a18407fSRichard Henderson dir_temps = tcg_malloc(nb_globals * sizeof(int16_t)); 18765a18407fSRichard Henderson memset(dir_temps, 0, nb_globals * sizeof(int16_t)); 18775a18407fSRichard Henderson 18785a18407fSRichard Henderson /* Create a temporary for each indirect global. */ 18795a18407fSRichard Henderson for (i = 0; i < nb_globals; ++i) { 18805a18407fSRichard Henderson TCGTemp *its = &s->temps[i]; 18815a18407fSRichard Henderson if (its->indirect_reg) { 18825a18407fSRichard Henderson TCGTemp *dts = tcg_temp_alloc(s); 18835a18407fSRichard Henderson dts->type = its->type; 18845a18407fSRichard Henderson dts->base_type = its->base_type; 18855a18407fSRichard Henderson dir_temps[i] = temp_idx(s, dts); 18865a18407fSRichard Henderson } 18875a18407fSRichard Henderson } 18885a18407fSRichard Henderson 18895a18407fSRichard Henderson memset(temp_state, TS_DEAD, nb_globals); 18905a18407fSRichard Henderson 18915a18407fSRichard Henderson for (oi = s->gen_op_buf[0].next; oi != 0; oi = oi_next) { 18925a18407fSRichard Henderson TCGOp *op = &s->gen_op_buf[oi]; 18935a18407fSRichard Henderson TCGOpcode opc = op->opc; 18945a18407fSRichard Henderson const TCGOpDef *def = &tcg_op_defs[opc]; 18955a18407fSRichard Henderson TCGLifeData arg_life = op->life; 18965a18407fSRichard Henderson int nb_iargs, nb_oargs, call_flags; 18975a18407fSRichard Henderson TCGArg arg, dir; 18985a18407fSRichard Henderson 18995a18407fSRichard Henderson oi_next = op->next; 19005a18407fSRichard Henderson 19015a18407fSRichard Henderson if (opc == INDEX_op_call) { 19025a18407fSRichard Henderson nb_oargs = op->callo; 19035a18407fSRichard Henderson nb_iargs = op->calli; 1904efee3746SRichard Henderson call_flags = op->args[nb_oargs + nb_iargs + 1]; 19055a18407fSRichard Henderson } else { 19065a18407fSRichard Henderson nb_iargs = def->nb_iargs; 19075a18407fSRichard Henderson nb_oargs = def->nb_oargs; 19085a18407fSRichard Henderson 19095a18407fSRichard Henderson /* Set flags similar to how calls require. */ 19105a18407fSRichard Henderson if (def->flags & TCG_OPF_BB_END) { 19115a18407fSRichard Henderson /* Like writing globals: save_globals */ 19125a18407fSRichard Henderson call_flags = 0; 19135a18407fSRichard Henderson } else if (def->flags & TCG_OPF_SIDE_EFFECTS) { 19145a18407fSRichard Henderson /* Like reading globals: sync_globals */ 19155a18407fSRichard Henderson call_flags = TCG_CALL_NO_WRITE_GLOBALS; 19165a18407fSRichard Henderson } else { 19175a18407fSRichard Henderson /* No effect on globals. */ 19185a18407fSRichard Henderson call_flags = (TCG_CALL_NO_READ_GLOBALS | 19195a18407fSRichard Henderson TCG_CALL_NO_WRITE_GLOBALS); 19205a18407fSRichard Henderson } 19215a18407fSRichard Henderson } 19225a18407fSRichard Henderson 19235a18407fSRichard Henderson /* Make sure that input arguments are available. */ 19245a18407fSRichard Henderson for (i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 1925efee3746SRichard Henderson arg = op->args[i]; 19265a18407fSRichard Henderson /* Note this unsigned test catches TCG_CALL_ARG_DUMMY too. */ 19275a18407fSRichard Henderson if (arg < nb_globals) { 19285a18407fSRichard Henderson dir = dir_temps[arg]; 19295a18407fSRichard Henderson if (dir != 0 && temp_state[arg] == TS_DEAD) { 193043439139SRichard Henderson TCGTemp *its = arg_temp(arg); 19315a18407fSRichard Henderson TCGOpcode lopc = (its->type == TCG_TYPE_I32 19325a18407fSRichard Henderson ? INDEX_op_ld_i32 19335a18407fSRichard Henderson : INDEX_op_ld_i64); 19345a18407fSRichard Henderson TCGOp *lop = tcg_op_insert_before(s, op, lopc, 3); 19355a18407fSRichard Henderson 1936efee3746SRichard Henderson lop->args[0] = dir; 1937*1807f4c4SRichard Henderson lop->args[1] = temp_arg(its->mem_base); 1938efee3746SRichard Henderson lop->args[2] = its->mem_offset; 19395a18407fSRichard Henderson 19405a18407fSRichard Henderson /* Loaded, but synced with memory. */ 19415a18407fSRichard Henderson temp_state[arg] = TS_MEM; 19425a18407fSRichard Henderson } 19435a18407fSRichard Henderson } 19445a18407fSRichard Henderson } 19455a18407fSRichard Henderson 19465a18407fSRichard Henderson /* Perform input replacement, and mark inputs that became dead. 19475a18407fSRichard Henderson No action is required except keeping temp_state up to date 19485a18407fSRichard Henderson so that we reload when needed. */ 19495a18407fSRichard Henderson for (i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 1950efee3746SRichard Henderson arg = op->args[i]; 19515a18407fSRichard Henderson if (arg < nb_globals) { 19525a18407fSRichard Henderson dir = dir_temps[arg]; 19535a18407fSRichard Henderson if (dir != 0) { 1954efee3746SRichard Henderson op->args[i] = dir; 19555a18407fSRichard Henderson changes = true; 19565a18407fSRichard Henderson if (IS_DEAD_ARG(i)) { 19575a18407fSRichard Henderson temp_state[arg] = TS_DEAD; 19585a18407fSRichard Henderson } 19595a18407fSRichard Henderson } 19605a18407fSRichard Henderson } 19615a18407fSRichard Henderson } 19625a18407fSRichard Henderson 19635a18407fSRichard Henderson /* Liveness analysis should ensure that the following are 19645a18407fSRichard Henderson all correct, for call sites and basic block end points. */ 19655a18407fSRichard Henderson if (call_flags & TCG_CALL_NO_READ_GLOBALS) { 19665a18407fSRichard Henderson /* Nothing to do */ 19675a18407fSRichard Henderson } else if (call_flags & TCG_CALL_NO_WRITE_GLOBALS) { 19685a18407fSRichard Henderson for (i = 0; i < nb_globals; ++i) { 19695a18407fSRichard Henderson /* Liveness should see that globals are synced back, 19705a18407fSRichard Henderson that is, either TS_DEAD or TS_MEM. */ 19715a18407fSRichard Henderson tcg_debug_assert(dir_temps[i] == 0 19725a18407fSRichard Henderson || temp_state[i] != 0); 19735a18407fSRichard Henderson } 19745a18407fSRichard Henderson } else { 19755a18407fSRichard Henderson for (i = 0; i < nb_globals; ++i) { 19765a18407fSRichard Henderson /* Liveness should see that globals are saved back, 19775a18407fSRichard Henderson that is, TS_DEAD, waiting to be reloaded. */ 19785a18407fSRichard Henderson tcg_debug_assert(dir_temps[i] == 0 19795a18407fSRichard Henderson || temp_state[i] == TS_DEAD); 19805a18407fSRichard Henderson } 19815a18407fSRichard Henderson } 19825a18407fSRichard Henderson 19835a18407fSRichard Henderson /* Outputs become available. */ 19845a18407fSRichard Henderson for (i = 0; i < nb_oargs; i++) { 1985efee3746SRichard Henderson arg = op->args[i]; 19865a18407fSRichard Henderson if (arg >= nb_globals) { 19875a18407fSRichard Henderson continue; 19885a18407fSRichard Henderson } 19895a18407fSRichard Henderson dir = dir_temps[arg]; 19905a18407fSRichard Henderson if (dir == 0) { 19915a18407fSRichard Henderson continue; 19925a18407fSRichard Henderson } 1993efee3746SRichard Henderson op->args[i] = dir; 19945a18407fSRichard Henderson changes = true; 19955a18407fSRichard Henderson 19965a18407fSRichard Henderson /* The output is now live and modified. */ 19975a18407fSRichard Henderson temp_state[arg] = 0; 19985a18407fSRichard Henderson 19995a18407fSRichard Henderson /* Sync outputs upon their last write. */ 20005a18407fSRichard Henderson if (NEED_SYNC_ARG(i)) { 200143439139SRichard Henderson TCGTemp *its = arg_temp(arg); 20025a18407fSRichard Henderson TCGOpcode sopc = (its->type == TCG_TYPE_I32 20035a18407fSRichard Henderson ? INDEX_op_st_i32 20045a18407fSRichard Henderson : INDEX_op_st_i64); 20055a18407fSRichard Henderson TCGOp *sop = tcg_op_insert_after(s, op, sopc, 3); 20065a18407fSRichard Henderson 2007efee3746SRichard Henderson sop->args[0] = dir; 2008*1807f4c4SRichard Henderson sop->args[1] = temp_arg(its->mem_base); 2009efee3746SRichard Henderson sop->args[2] = its->mem_offset; 20105a18407fSRichard Henderson 20115a18407fSRichard Henderson temp_state[arg] = TS_MEM; 20125a18407fSRichard Henderson } 20135a18407fSRichard Henderson /* Drop outputs that are dead. */ 20145a18407fSRichard Henderson if (IS_DEAD_ARG(i)) { 20155a18407fSRichard Henderson temp_state[arg] = TS_DEAD; 20165a18407fSRichard Henderson } 20175a18407fSRichard Henderson } 20185a18407fSRichard Henderson } 20195a18407fSRichard Henderson 20205a18407fSRichard Henderson return changes; 20215a18407fSRichard Henderson } 20225a18407fSRichard Henderson 20238d8fdbaeSAurelien Jarno #ifdef CONFIG_DEBUG_TCG 2024c896fe29Sbellard static void dump_regs(TCGContext *s) 2025c896fe29Sbellard { 2026c896fe29Sbellard TCGTemp *ts; 2027c896fe29Sbellard int i; 2028c896fe29Sbellard char buf[64]; 2029c896fe29Sbellard 2030c896fe29Sbellard for(i = 0; i < s->nb_temps; i++) { 2031c896fe29Sbellard ts = &s->temps[i]; 203243439139SRichard Henderson printf(" %10s: ", tcg_get_arg_str_ptr(s, buf, sizeof(buf), ts)); 2033c896fe29Sbellard switch(ts->val_type) { 2034c896fe29Sbellard case TEMP_VAL_REG: 2035c896fe29Sbellard printf("%s", tcg_target_reg_names[ts->reg]); 2036c896fe29Sbellard break; 2037c896fe29Sbellard case TEMP_VAL_MEM: 2038b3a62939SRichard Henderson printf("%d(%s)", (int)ts->mem_offset, 2039b3a62939SRichard Henderson tcg_target_reg_names[ts->mem_base->reg]); 2040c896fe29Sbellard break; 2041c896fe29Sbellard case TEMP_VAL_CONST: 2042c896fe29Sbellard printf("$0x%" TCG_PRIlx, ts->val); 2043c896fe29Sbellard break; 2044c896fe29Sbellard case TEMP_VAL_DEAD: 2045c896fe29Sbellard printf("D"); 2046c896fe29Sbellard break; 2047c896fe29Sbellard default: 2048c896fe29Sbellard printf("???"); 2049c896fe29Sbellard break; 2050c896fe29Sbellard } 2051c896fe29Sbellard printf("\n"); 2052c896fe29Sbellard } 2053c896fe29Sbellard 2054c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 2055f8b2f202SRichard Henderson if (s->reg_to_temp[i] != NULL) { 2056c896fe29Sbellard printf("%s: %s\n", 2057c896fe29Sbellard tcg_target_reg_names[i], 2058f8b2f202SRichard Henderson tcg_get_arg_str_ptr(s, buf, sizeof(buf), s->reg_to_temp[i])); 2059c896fe29Sbellard } 2060c896fe29Sbellard } 2061c896fe29Sbellard } 2062c896fe29Sbellard 2063c896fe29Sbellard static void check_regs(TCGContext *s) 2064c896fe29Sbellard { 2065869938aeSRichard Henderson int reg; 2066b6638662SRichard Henderson int k; 2067c896fe29Sbellard TCGTemp *ts; 2068c896fe29Sbellard char buf[64]; 2069c896fe29Sbellard 2070c896fe29Sbellard for (reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 2071f8b2f202SRichard Henderson ts = s->reg_to_temp[reg]; 2072f8b2f202SRichard Henderson if (ts != NULL) { 2073f8b2f202SRichard Henderson if (ts->val_type != TEMP_VAL_REG || ts->reg != reg) { 2074c896fe29Sbellard printf("Inconsistency for register %s:\n", 2075c896fe29Sbellard tcg_target_reg_names[reg]); 2076b03cce8eSbellard goto fail; 2077c896fe29Sbellard } 2078c896fe29Sbellard } 2079c896fe29Sbellard } 2080c896fe29Sbellard for (k = 0; k < s->nb_temps; k++) { 2081c896fe29Sbellard ts = &s->temps[k]; 2082f8b2f202SRichard Henderson if (ts->val_type == TEMP_VAL_REG && !ts->fixed_reg 2083f8b2f202SRichard Henderson && s->reg_to_temp[ts->reg] != ts) { 2084c896fe29Sbellard printf("Inconsistency for temp %s:\n", 2085f8b2f202SRichard Henderson tcg_get_arg_str_ptr(s, buf, sizeof(buf), ts)); 2086b03cce8eSbellard fail: 2087c896fe29Sbellard printf("reg state:\n"); 2088c896fe29Sbellard dump_regs(s); 2089c896fe29Sbellard tcg_abort(); 2090c896fe29Sbellard } 2091c896fe29Sbellard } 2092c896fe29Sbellard } 2093c896fe29Sbellard #endif 2094c896fe29Sbellard 2095c896fe29Sbellard static void temp_allocate_frame(TCGContext *s, int temp) 2096c896fe29Sbellard { 2097c896fe29Sbellard TCGTemp *ts; 2098c896fe29Sbellard ts = &s->temps[temp]; 20999b9c37c3SRichard Henderson #if !(defined(__sparc__) && TCG_TARGET_REG_BITS == 64) 21009b9c37c3SRichard Henderson /* Sparc64 stack is accessed with offset of 2047 */ 2101b591dc59SBlue Swirl s->current_frame_offset = (s->current_frame_offset + 2102b591dc59SBlue Swirl (tcg_target_long)sizeof(tcg_target_long) - 1) & 2103b591dc59SBlue Swirl ~(sizeof(tcg_target_long) - 1); 2104f44c9960SBlue Swirl #endif 2105b591dc59SBlue Swirl if (s->current_frame_offset + (tcg_target_long)sizeof(tcg_target_long) > 2106b591dc59SBlue Swirl s->frame_end) { 21075ff9d6a4Sbellard tcg_abort(); 2108b591dc59SBlue Swirl } 2109c896fe29Sbellard ts->mem_offset = s->current_frame_offset; 2110b3a62939SRichard Henderson ts->mem_base = s->frame_temp; 2111c896fe29Sbellard ts->mem_allocated = 1; 2112e2c6d1b4SRichard Henderson s->current_frame_offset += sizeof(tcg_target_long); 2113c896fe29Sbellard } 2114c896fe29Sbellard 2115b3915dbbSRichard Henderson static void temp_load(TCGContext *, TCGTemp *, TCGRegSet, TCGRegSet); 2116b3915dbbSRichard Henderson 211759d7c14eSRichard Henderson /* Mark a temporary as free or dead. If 'free_or_dead' is negative, 211859d7c14eSRichard Henderson mark it free; otherwise mark it dead. */ 211959d7c14eSRichard Henderson static void temp_free_or_dead(TCGContext *s, TCGTemp *ts, int free_or_dead) 2120c896fe29Sbellard { 212159d7c14eSRichard Henderson if (ts->fixed_reg) { 212259d7c14eSRichard Henderson return; 212359d7c14eSRichard Henderson } 212459d7c14eSRichard Henderson if (ts->val_type == TEMP_VAL_REG) { 212559d7c14eSRichard Henderson s->reg_to_temp[ts->reg] = NULL; 212659d7c14eSRichard Henderson } 212759d7c14eSRichard Henderson ts->val_type = (free_or_dead < 0 212859d7c14eSRichard Henderson || ts->temp_local 2129fa477d25SRichard Henderson || ts->temp_global 213059d7c14eSRichard Henderson ? TEMP_VAL_MEM : TEMP_VAL_DEAD); 213159d7c14eSRichard Henderson } 2132c896fe29Sbellard 213359d7c14eSRichard Henderson /* Mark a temporary as dead. */ 213459d7c14eSRichard Henderson static inline void temp_dead(TCGContext *s, TCGTemp *ts) 213559d7c14eSRichard Henderson { 213659d7c14eSRichard Henderson temp_free_or_dead(s, ts, 1); 213759d7c14eSRichard Henderson } 213859d7c14eSRichard Henderson 213959d7c14eSRichard Henderson /* Sync a temporary to memory. 'allocated_regs' is used in case a temporary 214059d7c14eSRichard Henderson registers needs to be allocated to store a constant. If 'free_or_dead' 214159d7c14eSRichard Henderson is non-zero, subsequently release the temporary; if it is positive, the 214259d7c14eSRichard Henderson temp is dead; if it is negative, the temp is free. */ 214359d7c14eSRichard Henderson static void temp_sync(TCGContext *s, TCGTemp *ts, 214459d7c14eSRichard Henderson TCGRegSet allocated_regs, int free_or_dead) 214559d7c14eSRichard Henderson { 214659d7c14eSRichard Henderson if (ts->fixed_reg) { 214759d7c14eSRichard Henderson return; 214859d7c14eSRichard Henderson } 214959d7c14eSRichard Henderson if (!ts->mem_coherent) { 21507f6ceedfSAurelien Jarno if (!ts->mem_allocated) { 2151f8b2f202SRichard Henderson temp_allocate_frame(s, temp_idx(s, ts)); 215259d7c14eSRichard Henderson } 215359d7c14eSRichard Henderson switch (ts->val_type) { 215459d7c14eSRichard Henderson case TEMP_VAL_CONST: 215559d7c14eSRichard Henderson /* If we're going to free the temp immediately, then we won't 215659d7c14eSRichard Henderson require it later in a register, so attempt to store the 215759d7c14eSRichard Henderson constant to memory directly. */ 215859d7c14eSRichard Henderson if (free_or_dead 215959d7c14eSRichard Henderson && tcg_out_sti(s, ts->type, ts->val, 216059d7c14eSRichard Henderson ts->mem_base->reg, ts->mem_offset)) { 216159d7c14eSRichard Henderson break; 216259d7c14eSRichard Henderson } 216359d7c14eSRichard Henderson temp_load(s, ts, tcg_target_available_regs[ts->type], 216459d7c14eSRichard Henderson allocated_regs); 216559d7c14eSRichard Henderson /* fallthrough */ 216659d7c14eSRichard Henderson 216759d7c14eSRichard Henderson case TEMP_VAL_REG: 216859d7c14eSRichard Henderson tcg_out_st(s, ts->type, ts->reg, 216959d7c14eSRichard Henderson ts->mem_base->reg, ts->mem_offset); 217059d7c14eSRichard Henderson break; 217159d7c14eSRichard Henderson 217259d7c14eSRichard Henderson case TEMP_VAL_MEM: 217359d7c14eSRichard Henderson break; 217459d7c14eSRichard Henderson 217559d7c14eSRichard Henderson case TEMP_VAL_DEAD: 217659d7c14eSRichard Henderson default: 217759d7c14eSRichard Henderson tcg_abort(); 2178c896fe29Sbellard } 21797f6ceedfSAurelien Jarno ts->mem_coherent = 1; 21807f6ceedfSAurelien Jarno } 218159d7c14eSRichard Henderson if (free_or_dead) { 218259d7c14eSRichard Henderson temp_free_or_dead(s, ts, free_or_dead); 218359d7c14eSRichard Henderson } 218459d7c14eSRichard Henderson } 21857f6ceedfSAurelien Jarno 21867f6ceedfSAurelien Jarno /* free register 'reg' by spilling the corresponding temporary if necessary */ 2187b3915dbbSRichard Henderson static void tcg_reg_free(TCGContext *s, TCGReg reg, TCGRegSet allocated_regs) 21887f6ceedfSAurelien Jarno { 2189f8b2f202SRichard Henderson TCGTemp *ts = s->reg_to_temp[reg]; 2190f8b2f202SRichard Henderson if (ts != NULL) { 219159d7c14eSRichard Henderson temp_sync(s, ts, allocated_regs, -1); 2192c896fe29Sbellard } 2193c896fe29Sbellard } 2194c896fe29Sbellard 2195c896fe29Sbellard /* Allocate a register belonging to reg1 & ~reg2 */ 2196b3915dbbSRichard Henderson static TCGReg tcg_reg_alloc(TCGContext *s, TCGRegSet desired_regs, 219791478cefSRichard Henderson TCGRegSet allocated_regs, bool rev) 2198c896fe29Sbellard { 219991478cefSRichard Henderson int i, n = ARRAY_SIZE(tcg_target_reg_alloc_order); 220091478cefSRichard Henderson const int *order; 2201b6638662SRichard Henderson TCGReg reg; 2202c896fe29Sbellard TCGRegSet reg_ct; 2203c896fe29Sbellard 220407ddf036SRichard Henderson reg_ct = desired_regs & ~allocated_regs; 220591478cefSRichard Henderson order = rev ? indirect_reg_alloc_order : tcg_target_reg_alloc_order; 2206c896fe29Sbellard 2207c896fe29Sbellard /* first try free registers */ 220891478cefSRichard Henderson for(i = 0; i < n; i++) { 220991478cefSRichard Henderson reg = order[i]; 2210f8b2f202SRichard Henderson if (tcg_regset_test_reg(reg_ct, reg) && s->reg_to_temp[reg] == NULL) 2211c896fe29Sbellard return reg; 2212c896fe29Sbellard } 2213c896fe29Sbellard 2214c896fe29Sbellard /* XXX: do better spill choice */ 221591478cefSRichard Henderson for(i = 0; i < n; i++) { 221691478cefSRichard Henderson reg = order[i]; 2217c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg)) { 2218b3915dbbSRichard Henderson tcg_reg_free(s, reg, allocated_regs); 2219c896fe29Sbellard return reg; 2220c896fe29Sbellard } 2221c896fe29Sbellard } 2222c896fe29Sbellard 2223c896fe29Sbellard tcg_abort(); 2224c896fe29Sbellard } 2225c896fe29Sbellard 222640ae5c62SRichard Henderson /* Make sure the temporary is in a register. If needed, allocate the register 222740ae5c62SRichard Henderson from DESIRED while avoiding ALLOCATED. */ 222840ae5c62SRichard Henderson static void temp_load(TCGContext *s, TCGTemp *ts, TCGRegSet desired_regs, 222940ae5c62SRichard Henderson TCGRegSet allocated_regs) 223040ae5c62SRichard Henderson { 223140ae5c62SRichard Henderson TCGReg reg; 223240ae5c62SRichard Henderson 223340ae5c62SRichard Henderson switch (ts->val_type) { 223440ae5c62SRichard Henderson case TEMP_VAL_REG: 223540ae5c62SRichard Henderson return; 223640ae5c62SRichard Henderson case TEMP_VAL_CONST: 223791478cefSRichard Henderson reg = tcg_reg_alloc(s, desired_regs, allocated_regs, ts->indirect_base); 223840ae5c62SRichard Henderson tcg_out_movi(s, ts->type, reg, ts->val); 223940ae5c62SRichard Henderson ts->mem_coherent = 0; 224040ae5c62SRichard Henderson break; 224140ae5c62SRichard Henderson case TEMP_VAL_MEM: 224291478cefSRichard Henderson reg = tcg_reg_alloc(s, desired_regs, allocated_regs, ts->indirect_base); 224340ae5c62SRichard Henderson tcg_out_ld(s, ts->type, reg, ts->mem_base->reg, ts->mem_offset); 224440ae5c62SRichard Henderson ts->mem_coherent = 1; 224540ae5c62SRichard Henderson break; 224640ae5c62SRichard Henderson case TEMP_VAL_DEAD: 224740ae5c62SRichard Henderson default: 224840ae5c62SRichard Henderson tcg_abort(); 224940ae5c62SRichard Henderson } 225040ae5c62SRichard Henderson ts->reg = reg; 225140ae5c62SRichard Henderson ts->val_type = TEMP_VAL_REG; 225240ae5c62SRichard Henderson s->reg_to_temp[reg] = ts; 225340ae5c62SRichard Henderson } 225440ae5c62SRichard Henderson 225559d7c14eSRichard Henderson /* Save a temporary to memory. 'allocated_regs' is used in case a 2256e8996ee0Sbellard temporary registers needs to be allocated to store a constant. */ 225759d7c14eSRichard Henderson static void temp_save(TCGContext *s, TCGTemp *ts, TCGRegSet allocated_regs) 22581ad80729SAurelien Jarno { 22592c0366f0SAurelien Jarno /* The liveness analysis already ensures that globals are back 2260eabb7b91SAurelien Jarno in memory. Keep an tcg_debug_assert for safety. */ 2261f8bf00f1SRichard Henderson tcg_debug_assert(ts->val_type == TEMP_VAL_MEM || ts->fixed_reg); 22621ad80729SAurelien Jarno } 22631ad80729SAurelien Jarno 22649814dd27SDong Xu Wang /* save globals to their canonical location and assume they can be 2265641d5fbeSbellard modified be the following code. 'allocated_regs' is used in case a 2266641d5fbeSbellard temporary registers needs to be allocated to store a constant. */ 2267641d5fbeSbellard static void save_globals(TCGContext *s, TCGRegSet allocated_regs) 2268641d5fbeSbellard { 2269641d5fbeSbellard int i; 2270641d5fbeSbellard 2271641d5fbeSbellard for (i = 0; i < s->nb_globals; i++) { 2272b13eb728SRichard Henderson temp_save(s, &s->temps[i], allocated_regs); 2273641d5fbeSbellard } 2274e5097dc8Sbellard } 2275e5097dc8Sbellard 22763d5c5f87SAurelien Jarno /* sync globals to their canonical location and assume they can be 22773d5c5f87SAurelien Jarno read by the following code. 'allocated_regs' is used in case a 22783d5c5f87SAurelien Jarno temporary registers needs to be allocated to store a constant. */ 22793d5c5f87SAurelien Jarno static void sync_globals(TCGContext *s, TCGRegSet allocated_regs) 22803d5c5f87SAurelien Jarno { 22813d5c5f87SAurelien Jarno int i; 22823d5c5f87SAurelien Jarno 22833d5c5f87SAurelien Jarno for (i = 0; i < s->nb_globals; i++) { 228412b9b11aSRichard Henderson TCGTemp *ts = &s->temps[i]; 228512b9b11aSRichard Henderson tcg_debug_assert(ts->val_type != TEMP_VAL_REG 228612b9b11aSRichard Henderson || ts->fixed_reg 228712b9b11aSRichard Henderson || ts->mem_coherent); 22883d5c5f87SAurelien Jarno } 22893d5c5f87SAurelien Jarno } 22903d5c5f87SAurelien Jarno 2291e5097dc8Sbellard /* at the end of a basic block, we assume all temporaries are dead and 2292e8996ee0Sbellard all globals are stored at their canonical location. */ 2293e8996ee0Sbellard static void tcg_reg_alloc_bb_end(TCGContext *s, TCGRegSet allocated_regs) 2294e5097dc8Sbellard { 2295e5097dc8Sbellard int i; 2296e5097dc8Sbellard 2297c896fe29Sbellard for (i = s->nb_globals; i < s->nb_temps; i++) { 2298b13eb728SRichard Henderson TCGTemp *ts = &s->temps[i]; 2299641d5fbeSbellard if (ts->temp_local) { 2300b13eb728SRichard Henderson temp_save(s, ts, allocated_regs); 2301641d5fbeSbellard } else { 23022c0366f0SAurelien Jarno /* The liveness analysis already ensures that temps are dead. 2303eabb7b91SAurelien Jarno Keep an tcg_debug_assert for safety. */ 2304eabb7b91SAurelien Jarno tcg_debug_assert(ts->val_type == TEMP_VAL_DEAD); 2305c896fe29Sbellard } 2306641d5fbeSbellard } 2307e8996ee0Sbellard 2308e8996ee0Sbellard save_globals(s, allocated_regs); 2309c896fe29Sbellard } 2310c896fe29Sbellard 23110fe4fca4SPaolo Bonzini static void tcg_reg_alloc_do_movi(TCGContext *s, TCGTemp *ots, 23120fe4fca4SPaolo Bonzini tcg_target_ulong val, TCGLifeData arg_life) 2313e8996ee0Sbellard { 2314e8996ee0Sbellard if (ots->fixed_reg) { 231559d7c14eSRichard Henderson /* For fixed registers, we do not do any constant propagation. */ 2316e8996ee0Sbellard tcg_out_movi(s, ots->type, ots->reg, val); 231759d7c14eSRichard Henderson return; 231859d7c14eSRichard Henderson } 231959d7c14eSRichard Henderson 232059d7c14eSRichard Henderson /* The movi is not explicitly generated here. */ 2321f8b2f202SRichard Henderson if (ots->val_type == TEMP_VAL_REG) { 2322f8b2f202SRichard Henderson s->reg_to_temp[ots->reg] = NULL; 2323f8b2f202SRichard Henderson } 2324e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 2325e8996ee0Sbellard ots->val = val; 232659d7c14eSRichard Henderson ots->mem_coherent = 0; 2327ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(0)) { 232859d7c14eSRichard Henderson temp_sync(s, ots, s->reserved_regs, IS_DEAD_ARG(0)); 232959d7c14eSRichard Henderson } else if (IS_DEAD_ARG(0)) { 2330f8bf00f1SRichard Henderson temp_dead(s, ots); 23314c4e1ab2SAurelien Jarno } 2332e8996ee0Sbellard } 2333e8996ee0Sbellard 2334dd186292SRichard Henderson static void tcg_reg_alloc_movi(TCGContext *s, const TCGOp *op) 23350fe4fca4SPaolo Bonzini { 233643439139SRichard Henderson TCGTemp *ots = arg_temp(op->args[0]); 2337dd186292SRichard Henderson tcg_target_ulong val = op->args[1]; 23380fe4fca4SPaolo Bonzini 2339dd186292SRichard Henderson tcg_reg_alloc_do_movi(s, ots, val, op->life); 23400fe4fca4SPaolo Bonzini } 23410fe4fca4SPaolo Bonzini 2342dd186292SRichard Henderson static void tcg_reg_alloc_mov(TCGContext *s, const TCGOp *op) 2343c896fe29Sbellard { 2344dd186292SRichard Henderson const TCGLifeData arg_life = op->life; 2345c29c1d7eSAurelien Jarno TCGRegSet allocated_regs; 2346c896fe29Sbellard TCGTemp *ts, *ots; 2347450445d5SRichard Henderson TCGType otype, itype; 2348c896fe29Sbellard 2349d21369f5SRichard Henderson allocated_regs = s->reserved_regs; 235043439139SRichard Henderson ots = arg_temp(op->args[0]); 235143439139SRichard Henderson ts = arg_temp(op->args[1]); 2352450445d5SRichard Henderson 2353450445d5SRichard Henderson /* Note that otype != itype for no-op truncation. */ 2354450445d5SRichard Henderson otype = ots->type; 2355450445d5SRichard Henderson itype = ts->type; 2356c896fe29Sbellard 23570fe4fca4SPaolo Bonzini if (ts->val_type == TEMP_VAL_CONST) { 23580fe4fca4SPaolo Bonzini /* propagate constant or generate sti */ 23590fe4fca4SPaolo Bonzini tcg_target_ulong val = ts->val; 23600fe4fca4SPaolo Bonzini if (IS_DEAD_ARG(1)) { 23610fe4fca4SPaolo Bonzini temp_dead(s, ts); 23620fe4fca4SPaolo Bonzini } 23630fe4fca4SPaolo Bonzini tcg_reg_alloc_do_movi(s, ots, val, arg_life); 23640fe4fca4SPaolo Bonzini return; 23650fe4fca4SPaolo Bonzini } 23660fe4fca4SPaolo Bonzini 23670fe4fca4SPaolo Bonzini /* If the source value is in memory we're going to be forced 23680fe4fca4SPaolo Bonzini to have it in a register in order to perform the copy. Copy 23690fe4fca4SPaolo Bonzini the SOURCE value into its own register first, that way we 23700fe4fca4SPaolo Bonzini don't have to reload SOURCE the next time it is used. */ 23710fe4fca4SPaolo Bonzini if (ts->val_type == TEMP_VAL_MEM) { 237240ae5c62SRichard Henderson temp_load(s, ts, tcg_target_available_regs[itype], allocated_regs); 2373c29c1d7eSAurelien Jarno } 2374c29c1d7eSAurelien Jarno 23750fe4fca4SPaolo Bonzini tcg_debug_assert(ts->val_type == TEMP_VAL_REG); 2376c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(0) && !ots->fixed_reg) { 2377c29c1d7eSAurelien Jarno /* mov to a non-saved dead register makes no sense (even with 2378c29c1d7eSAurelien Jarno liveness analysis disabled). */ 2379eabb7b91SAurelien Jarno tcg_debug_assert(NEED_SYNC_ARG(0)); 2380c29c1d7eSAurelien Jarno if (!ots->mem_allocated) { 2381dd186292SRichard Henderson temp_allocate_frame(s, op->args[0]); 2382c29c1d7eSAurelien Jarno } 2383b3a62939SRichard Henderson tcg_out_st(s, otype, ts->reg, ots->mem_base->reg, ots->mem_offset); 2384c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(1)) { 2385f8bf00f1SRichard Henderson temp_dead(s, ts); 2386c29c1d7eSAurelien Jarno } 2387f8bf00f1SRichard Henderson temp_dead(s, ots); 2388e8996ee0Sbellard } else { 2389c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(1) && !ts->fixed_reg && !ots->fixed_reg) { 2390c29c1d7eSAurelien Jarno /* the mov can be suppressed */ 2391c29c1d7eSAurelien Jarno if (ots->val_type == TEMP_VAL_REG) { 2392f8b2f202SRichard Henderson s->reg_to_temp[ots->reg] = NULL; 2393c896fe29Sbellard } 2394c29c1d7eSAurelien Jarno ots->reg = ts->reg; 2395f8bf00f1SRichard Henderson temp_dead(s, ts); 2396c29c1d7eSAurelien Jarno } else { 2397c29c1d7eSAurelien Jarno if (ots->val_type != TEMP_VAL_REG) { 2398c29c1d7eSAurelien Jarno /* When allocating a new register, make sure to not spill the 2399c29c1d7eSAurelien Jarno input one. */ 2400c29c1d7eSAurelien Jarno tcg_regset_set_reg(allocated_regs, ts->reg); 2401450445d5SRichard Henderson ots->reg = tcg_reg_alloc(s, tcg_target_available_regs[otype], 240291478cefSRichard Henderson allocated_regs, ots->indirect_base); 2403c29c1d7eSAurelien Jarno } 2404450445d5SRichard Henderson tcg_out_mov(s, otype, ots->reg, ts->reg); 2405c29c1d7eSAurelien Jarno } 2406c896fe29Sbellard ots->val_type = TEMP_VAL_REG; 2407c896fe29Sbellard ots->mem_coherent = 0; 2408f8b2f202SRichard Henderson s->reg_to_temp[ots->reg] = ots; 2409ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(0)) { 241059d7c14eSRichard Henderson temp_sync(s, ots, allocated_regs, 0); 2411c29c1d7eSAurelien Jarno } 2412ec7a869dSAurelien Jarno } 2413c896fe29Sbellard } 2414c896fe29Sbellard 2415dd186292SRichard Henderson static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op) 2416c896fe29Sbellard { 2417dd186292SRichard Henderson const TCGLifeData arg_life = op->life; 2418dd186292SRichard Henderson const TCGOpDef * const def = &tcg_op_defs[op->opc]; 241982790a87SRichard Henderson TCGRegSet i_allocated_regs; 242082790a87SRichard Henderson TCGRegSet o_allocated_regs; 2421b6638662SRichard Henderson int i, k, nb_iargs, nb_oargs; 2422b6638662SRichard Henderson TCGReg reg; 2423c896fe29Sbellard TCGArg arg; 2424c896fe29Sbellard const TCGArgConstraint *arg_ct; 2425c896fe29Sbellard TCGTemp *ts; 2426c896fe29Sbellard TCGArg new_args[TCG_MAX_OP_ARGS]; 2427c896fe29Sbellard int const_args[TCG_MAX_OP_ARGS]; 2428c896fe29Sbellard 2429c896fe29Sbellard nb_oargs = def->nb_oargs; 2430c896fe29Sbellard nb_iargs = def->nb_iargs; 2431c896fe29Sbellard 2432c896fe29Sbellard /* copy constants */ 2433c896fe29Sbellard memcpy(new_args + nb_oargs + nb_iargs, 2434dd186292SRichard Henderson op->args + nb_oargs + nb_iargs, 2435c896fe29Sbellard sizeof(TCGArg) * def->nb_cargs); 2436c896fe29Sbellard 2437d21369f5SRichard Henderson i_allocated_regs = s->reserved_regs; 2438d21369f5SRichard Henderson o_allocated_regs = s->reserved_regs; 243982790a87SRichard Henderson 2440c896fe29Sbellard /* satisfy input constraints */ 2441c896fe29Sbellard for (k = 0; k < nb_iargs; k++) { 2442c896fe29Sbellard i = def->sorted_args[nb_oargs + k]; 2443dd186292SRichard Henderson arg = op->args[i]; 2444c896fe29Sbellard arg_ct = &def->args_ct[i]; 244543439139SRichard Henderson ts = arg_temp(arg); 244640ae5c62SRichard Henderson 244740ae5c62SRichard Henderson if (ts->val_type == TEMP_VAL_CONST 244840ae5c62SRichard Henderson && tcg_target_const_match(ts->val, ts->type, arg_ct)) { 2449c896fe29Sbellard /* constant is OK for instruction */ 2450c896fe29Sbellard const_args[i] = 1; 2451c896fe29Sbellard new_args[i] = ts->val; 2452c896fe29Sbellard goto iarg_end; 2453c896fe29Sbellard } 245440ae5c62SRichard Henderson 245582790a87SRichard Henderson temp_load(s, ts, arg_ct->u.regs, i_allocated_regs); 245640ae5c62SRichard Henderson 24575ff9d6a4Sbellard if (arg_ct->ct & TCG_CT_IALIAS) { 24585ff9d6a4Sbellard if (ts->fixed_reg) { 24595ff9d6a4Sbellard /* if fixed register, we must allocate a new register 24605ff9d6a4Sbellard if the alias is not the same register */ 2461dd186292SRichard Henderson if (arg != op->args[arg_ct->alias_index]) 24625ff9d6a4Sbellard goto allocate_in_reg; 24635ff9d6a4Sbellard } else { 2464c896fe29Sbellard /* if the input is aliased to an output and if it is 2465c896fe29Sbellard not dead after the instruction, we must allocate 2466c896fe29Sbellard a new register and move it */ 2467866cb6cbSAurelien Jarno if (!IS_DEAD_ARG(i)) { 2468c896fe29Sbellard goto allocate_in_reg; 2469c896fe29Sbellard } 24707e1df267SAurelien Jarno /* check if the current register has already been allocated 24717e1df267SAurelien Jarno for another input aliased to an output */ 24727e1df267SAurelien Jarno int k2, i2; 24737e1df267SAurelien Jarno for (k2 = 0 ; k2 < k ; k2++) { 24747e1df267SAurelien Jarno i2 = def->sorted_args[nb_oargs + k2]; 24757e1df267SAurelien Jarno if ((def->args_ct[i2].ct & TCG_CT_IALIAS) && 24767e1df267SAurelien Jarno (new_args[i2] == ts->reg)) { 24777e1df267SAurelien Jarno goto allocate_in_reg; 24787e1df267SAurelien Jarno } 24797e1df267SAurelien Jarno } 24805ff9d6a4Sbellard } 2481866cb6cbSAurelien Jarno } 2482c896fe29Sbellard reg = ts->reg; 2483c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, reg)) { 2484c896fe29Sbellard /* nothing to do : the constraint is satisfied */ 2485c896fe29Sbellard } else { 2486c896fe29Sbellard allocate_in_reg: 2487c896fe29Sbellard /* allocate a new register matching the constraint 2488c896fe29Sbellard and move the temporary register into it */ 248982790a87SRichard Henderson reg = tcg_reg_alloc(s, arg_ct->u.regs, i_allocated_regs, 249091478cefSRichard Henderson ts->indirect_base); 24913b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 2492c896fe29Sbellard } 2493c896fe29Sbellard new_args[i] = reg; 2494c896fe29Sbellard const_args[i] = 0; 249582790a87SRichard Henderson tcg_regset_set_reg(i_allocated_regs, reg); 2496c896fe29Sbellard iarg_end: ; 2497c896fe29Sbellard } 2498c896fe29Sbellard 2499c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 2500866cb6cbSAurelien Jarno for (i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 2501866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 250243439139SRichard Henderson temp_dead(s, arg_temp(op->args[i])); 2503c896fe29Sbellard } 2504c896fe29Sbellard } 2505c896fe29Sbellard 2506a52ad07eSAurelien Jarno if (def->flags & TCG_OPF_BB_END) { 250782790a87SRichard Henderson tcg_reg_alloc_bb_end(s, i_allocated_regs); 2508a52ad07eSAurelien Jarno } else { 2509c896fe29Sbellard if (def->flags & TCG_OPF_CALL_CLOBBER) { 2510b03cce8eSbellard /* XXX: permit generic clobber register list ? */ 2511c8074023SRichard Henderson for (i = 0; i < TCG_TARGET_NB_REGS; i++) { 2512c8074023SRichard Henderson if (tcg_regset_test_reg(tcg_target_call_clobber_regs, i)) { 251382790a87SRichard Henderson tcg_reg_free(s, i, i_allocated_regs); 2514c896fe29Sbellard } 2515c896fe29Sbellard } 25163d5c5f87SAurelien Jarno } 25173d5c5f87SAurelien Jarno if (def->flags & TCG_OPF_SIDE_EFFECTS) { 25183d5c5f87SAurelien Jarno /* sync globals if the op has side effects and might trigger 25193d5c5f87SAurelien Jarno an exception. */ 252082790a87SRichard Henderson sync_globals(s, i_allocated_regs); 2521c896fe29Sbellard } 2522c896fe29Sbellard 2523c896fe29Sbellard /* satisfy the output constraints */ 2524c896fe29Sbellard for(k = 0; k < nb_oargs; k++) { 2525c896fe29Sbellard i = def->sorted_args[k]; 2526dd186292SRichard Henderson arg = op->args[i]; 2527c896fe29Sbellard arg_ct = &def->args_ct[i]; 252843439139SRichard Henderson ts = arg_temp(arg); 252917280ff4SRichard Henderson if ((arg_ct->ct & TCG_CT_ALIAS) 253017280ff4SRichard Henderson && !const_args[arg_ct->alias_index]) { 25315ff9d6a4Sbellard reg = new_args[arg_ct->alias_index]; 253282790a87SRichard Henderson } else if (arg_ct->ct & TCG_CT_NEWREG) { 253382790a87SRichard Henderson reg = tcg_reg_alloc(s, arg_ct->u.regs, 253482790a87SRichard Henderson i_allocated_regs | o_allocated_regs, 253582790a87SRichard Henderson ts->indirect_base); 2536c896fe29Sbellard } else { 2537c896fe29Sbellard /* if fixed register, we try to use it */ 2538c896fe29Sbellard reg = ts->reg; 2539c896fe29Sbellard if (ts->fixed_reg && 2540c896fe29Sbellard tcg_regset_test_reg(arg_ct->u.regs, reg)) { 2541c896fe29Sbellard goto oarg_end; 2542c896fe29Sbellard } 254382790a87SRichard Henderson reg = tcg_reg_alloc(s, arg_ct->u.regs, o_allocated_regs, 254491478cefSRichard Henderson ts->indirect_base); 2545c896fe29Sbellard } 254682790a87SRichard Henderson tcg_regset_set_reg(o_allocated_regs, reg); 2547c896fe29Sbellard /* if a fixed register is used, then a move will be done afterwards */ 2548c896fe29Sbellard if (!ts->fixed_reg) { 2549639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 2550f8b2f202SRichard Henderson s->reg_to_temp[ts->reg] = NULL; 2551639368ddSAurelien Jarno } 2552c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 2553c896fe29Sbellard ts->reg = reg; 2554c896fe29Sbellard /* temp value is modified, so the value kept in memory is 2555c896fe29Sbellard potentially not the same */ 2556c896fe29Sbellard ts->mem_coherent = 0; 2557f8b2f202SRichard Henderson s->reg_to_temp[reg] = ts; 2558c896fe29Sbellard } 2559c896fe29Sbellard oarg_end: 2560c896fe29Sbellard new_args[i] = reg; 2561c896fe29Sbellard } 2562e8996ee0Sbellard } 2563c896fe29Sbellard 2564c896fe29Sbellard /* emit instruction */ 2565dd186292SRichard Henderson tcg_out_op(s, op->opc, new_args, const_args); 2566c896fe29Sbellard 2567c896fe29Sbellard /* move the outputs in the correct register if needed */ 2568c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 256943439139SRichard Henderson ts = arg_temp(op->args[i]); 2570c896fe29Sbellard reg = new_args[i]; 2571c896fe29Sbellard if (ts->fixed_reg && ts->reg != reg) { 25723b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 2573c896fe29Sbellard } 2574ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(i)) { 257582790a87SRichard Henderson temp_sync(s, ts, o_allocated_regs, IS_DEAD_ARG(i)); 257659d7c14eSRichard Henderson } else if (IS_DEAD_ARG(i)) { 2577f8bf00f1SRichard Henderson temp_dead(s, ts); 2578ec7a869dSAurelien Jarno } 2579c896fe29Sbellard } 2580c896fe29Sbellard } 2581c896fe29Sbellard 2582b03cce8eSbellard #ifdef TCG_TARGET_STACK_GROWSUP 2583b03cce8eSbellard #define STACK_DIR(x) (-(x)) 2584b03cce8eSbellard #else 2585b03cce8eSbellard #define STACK_DIR(x) (x) 2586b03cce8eSbellard #endif 2587b03cce8eSbellard 2588dd186292SRichard Henderson static void tcg_reg_alloc_call(TCGContext *s, TCGOp *op) 2589c896fe29Sbellard { 2590dd186292SRichard Henderson const int nb_oargs = op->callo; 2591dd186292SRichard Henderson const int nb_iargs = op->calli; 2592dd186292SRichard Henderson const TCGLifeData arg_life = op->life; 2593b6638662SRichard Henderson int flags, nb_regs, i; 2594b6638662SRichard Henderson TCGReg reg; 2595cf066674SRichard Henderson TCGArg arg; 2596c896fe29Sbellard TCGTemp *ts; 2597d3452f1fSRichard Henderson intptr_t stack_offset; 2598d3452f1fSRichard Henderson size_t call_stack_size; 2599cf066674SRichard Henderson tcg_insn_unit *func_addr; 2600cf066674SRichard Henderson int allocate_args; 2601c896fe29Sbellard TCGRegSet allocated_regs; 2602c896fe29Sbellard 2603dd186292SRichard Henderson func_addr = (tcg_insn_unit *)(intptr_t)op->args[nb_oargs + nb_iargs]; 2604dd186292SRichard Henderson flags = op->args[nb_oargs + nb_iargs + 1]; 2605c896fe29Sbellard 26066e17d0c5SStefan Weil nb_regs = ARRAY_SIZE(tcg_target_call_iarg_regs); 2607c45cb8bbSRichard Henderson if (nb_regs > nb_iargs) { 2608c45cb8bbSRichard Henderson nb_regs = nb_iargs; 2609cf066674SRichard Henderson } 2610c896fe29Sbellard 2611c896fe29Sbellard /* assign stack slots first */ 2612c45cb8bbSRichard Henderson call_stack_size = (nb_iargs - nb_regs) * sizeof(tcg_target_long); 2613c896fe29Sbellard call_stack_size = (call_stack_size + TCG_TARGET_STACK_ALIGN - 1) & 2614c896fe29Sbellard ~(TCG_TARGET_STACK_ALIGN - 1); 2615b03cce8eSbellard allocate_args = (call_stack_size > TCG_STATIC_CALL_ARGS_SIZE); 2616b03cce8eSbellard if (allocate_args) { 2617345649c0SBlue Swirl /* XXX: if more than TCG_STATIC_CALL_ARGS_SIZE is needed, 2618345649c0SBlue Swirl preallocate call stack */ 2619345649c0SBlue Swirl tcg_abort(); 2620b03cce8eSbellard } 262139cf05d3Sbellard 262239cf05d3Sbellard stack_offset = TCG_TARGET_CALL_STACK_OFFSET; 2623c45cb8bbSRichard Henderson for (i = nb_regs; i < nb_iargs; i++) { 2624dd186292SRichard Henderson arg = op->args[nb_oargs + i]; 262539cf05d3Sbellard #ifdef TCG_TARGET_STACK_GROWSUP 262639cf05d3Sbellard stack_offset -= sizeof(tcg_target_long); 262739cf05d3Sbellard #endif 262839cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 262943439139SRichard Henderson ts = arg_temp(arg); 263040ae5c62SRichard Henderson temp_load(s, ts, tcg_target_available_regs[ts->type], 263140ae5c62SRichard Henderson s->reserved_regs); 2632e4d5434cSblueswir1 tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset); 263339cf05d3Sbellard } 263439cf05d3Sbellard #ifndef TCG_TARGET_STACK_GROWSUP 263539cf05d3Sbellard stack_offset += sizeof(tcg_target_long); 263639cf05d3Sbellard #endif 2637c896fe29Sbellard } 2638c896fe29Sbellard 2639c896fe29Sbellard /* assign input registers */ 2640d21369f5SRichard Henderson allocated_regs = s->reserved_regs; 2641c896fe29Sbellard for (i = 0; i < nb_regs; i++) { 2642dd186292SRichard Henderson arg = op->args[nb_oargs + i]; 264339cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 264443439139SRichard Henderson ts = arg_temp(arg); 2645c896fe29Sbellard reg = tcg_target_call_iarg_regs[i]; 2646b3915dbbSRichard Henderson tcg_reg_free(s, reg, allocated_regs); 264740ae5c62SRichard Henderson 2648c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 2649c896fe29Sbellard if (ts->reg != reg) { 26503b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 2651c896fe29Sbellard } 2652c896fe29Sbellard } else { 2653ccb1bb66SRichard Henderson TCGRegSet arg_set = 0; 265440ae5c62SRichard Henderson 265540ae5c62SRichard Henderson tcg_regset_set_reg(arg_set, reg); 265640ae5c62SRichard Henderson temp_load(s, ts, arg_set, allocated_regs); 2657c896fe29Sbellard } 265840ae5c62SRichard Henderson 2659c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 2660c896fe29Sbellard } 266139cf05d3Sbellard } 2662c896fe29Sbellard 2663c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 2664866cb6cbSAurelien Jarno for (i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 2665866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 266643439139SRichard Henderson temp_dead(s, arg_temp(op->args[i])); 2667c896fe29Sbellard } 2668c896fe29Sbellard } 2669c896fe29Sbellard 2670c896fe29Sbellard /* clobber call registers */ 2671c8074023SRichard Henderson for (i = 0; i < TCG_TARGET_NB_REGS; i++) { 2672c8074023SRichard Henderson if (tcg_regset_test_reg(tcg_target_call_clobber_regs, i)) { 2673b3915dbbSRichard Henderson tcg_reg_free(s, i, allocated_regs); 2674c896fe29Sbellard } 2675c896fe29Sbellard } 2676c896fe29Sbellard 267778505279SAurelien Jarno /* Save globals if they might be written by the helper, sync them if 267878505279SAurelien Jarno they might be read. */ 267978505279SAurelien Jarno if (flags & TCG_CALL_NO_READ_GLOBALS) { 268078505279SAurelien Jarno /* Nothing to do */ 268178505279SAurelien Jarno } else if (flags & TCG_CALL_NO_WRITE_GLOBALS) { 268278505279SAurelien Jarno sync_globals(s, allocated_regs); 268378505279SAurelien Jarno } else { 2684e8996ee0Sbellard save_globals(s, allocated_regs); 2685b9c18f56Saurel32 } 2686c896fe29Sbellard 2687cf066674SRichard Henderson tcg_out_call(s, func_addr); 2688c896fe29Sbellard 2689c896fe29Sbellard /* assign output registers and emit moves if needed */ 2690c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 2691dd186292SRichard Henderson arg = op->args[i]; 269243439139SRichard Henderson ts = arg_temp(arg); 2693c896fe29Sbellard reg = tcg_target_call_oarg_regs[i]; 2694eabb7b91SAurelien Jarno tcg_debug_assert(s->reg_to_temp[reg] == NULL); 269534b1a49cSRichard Henderson 2696c896fe29Sbellard if (ts->fixed_reg) { 2697c896fe29Sbellard if (ts->reg != reg) { 26983b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 2699c896fe29Sbellard } 2700c896fe29Sbellard } else { 2701639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 2702f8b2f202SRichard Henderson s->reg_to_temp[ts->reg] = NULL; 2703639368ddSAurelien Jarno } 2704c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 2705c896fe29Sbellard ts->reg = reg; 2706c896fe29Sbellard ts->mem_coherent = 0; 2707f8b2f202SRichard Henderson s->reg_to_temp[reg] = ts; 2708ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(i)) { 270959d7c14eSRichard Henderson temp_sync(s, ts, allocated_regs, IS_DEAD_ARG(i)); 271059d7c14eSRichard Henderson } else if (IS_DEAD_ARG(i)) { 2711f8bf00f1SRichard Henderson temp_dead(s, ts); 2712c896fe29Sbellard } 2713c896fe29Sbellard } 27148c11ad25SAurelien Jarno } 2715c896fe29Sbellard } 2716c896fe29Sbellard 2717c896fe29Sbellard #ifdef CONFIG_PROFILER 2718c896fe29Sbellard 271954604f74Saurel32 static int64_t tcg_table_op_count[NB_OPS]; 2720c896fe29Sbellard 2721246ae24dSMax Filippov void tcg_dump_op_count(FILE *f, fprintf_function cpu_fprintf) 2722c896fe29Sbellard { 2723c896fe29Sbellard int i; 2724d70724ceSzhanghailiang 272515fc7daaSRichard Henderson for (i = 0; i < NB_OPS; i++) { 2726246ae24dSMax Filippov cpu_fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, 2727246ae24dSMax Filippov tcg_table_op_count[i]); 2728c896fe29Sbellard } 2729c896fe29Sbellard } 2730246ae24dSMax Filippov #else 2731246ae24dSMax Filippov void tcg_dump_op_count(FILE *f, fprintf_function cpu_fprintf) 2732246ae24dSMax Filippov { 2733246ae24dSMax Filippov cpu_fprintf(f, "[TCG profiler not compiled]\n"); 2734246ae24dSMax Filippov } 2735c896fe29Sbellard #endif 2736c896fe29Sbellard 2737c896fe29Sbellard 27385bd2ec3dSAlex Bennée int tcg_gen_code(TCGContext *s, TranslationBlock *tb) 2739c896fe29Sbellard { 2740fca8a500SRichard Henderson int i, oi, oi_next, num_insns; 2741c896fe29Sbellard 274204fe6400SRichard Henderson #ifdef CONFIG_PROFILER 274304fe6400SRichard Henderson { 274404fe6400SRichard Henderson int n; 274504fe6400SRichard Henderson 2746dcb8e758SRichard Henderson n = s->gen_op_buf[0].prev + 1; 274704fe6400SRichard Henderson s->op_count += n; 274804fe6400SRichard Henderson if (n > s->op_count_max) { 274904fe6400SRichard Henderson s->op_count_max = n; 275004fe6400SRichard Henderson } 275104fe6400SRichard Henderson 275204fe6400SRichard Henderson n = s->nb_temps; 275304fe6400SRichard Henderson s->temp_count += n; 275404fe6400SRichard Henderson if (n > s->temp_count_max) { 275504fe6400SRichard Henderson s->temp_count_max = n; 275604fe6400SRichard Henderson } 275704fe6400SRichard Henderson } 275804fe6400SRichard Henderson #endif 275904fe6400SRichard Henderson 2760c896fe29Sbellard #ifdef DEBUG_DISAS 2761d977e1c2SAlex Bennée if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP) 2762d977e1c2SAlex Bennée && qemu_log_in_addr_range(tb->pc))) { 27631ee73216SRichard Henderson qemu_log_lock(); 276493fcfe39Saliguori qemu_log("OP:\n"); 2765eeacee4dSBlue Swirl tcg_dump_ops(s); 276693fcfe39Saliguori qemu_log("\n"); 27671ee73216SRichard Henderson qemu_log_unlock(); 2768c896fe29Sbellard } 2769c896fe29Sbellard #endif 2770c896fe29Sbellard 2771c5cc28ffSAurelien Jarno #ifdef CONFIG_PROFILER 2772c5cc28ffSAurelien Jarno s->opt_time -= profile_getclock(); 2773c5cc28ffSAurelien Jarno #endif 2774c5cc28ffSAurelien Jarno 27758f2e8c07SKirill Batuzov #ifdef USE_TCG_OPTIMIZATIONS 2776c45cb8bbSRichard Henderson tcg_optimize(s); 27778f2e8c07SKirill Batuzov #endif 27788f2e8c07SKirill Batuzov 2779a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2780c5cc28ffSAurelien Jarno s->opt_time += profile_getclock(); 2781a23a9ec6Sbellard s->la_time -= profile_getclock(); 2782a23a9ec6Sbellard #endif 2783c5cc28ffSAurelien Jarno 27845a18407fSRichard Henderson { 27855a18407fSRichard Henderson uint8_t *temp_state = tcg_malloc(s->nb_temps + s->nb_indirects); 27865a18407fSRichard Henderson 27875a18407fSRichard Henderson liveness_pass_1(s, temp_state); 27885a18407fSRichard Henderson 27895a18407fSRichard Henderson if (s->nb_indirects > 0) { 27905a18407fSRichard Henderson #ifdef DEBUG_DISAS 27915a18407fSRichard Henderson if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_IND) 27925a18407fSRichard Henderson && qemu_log_in_addr_range(tb->pc))) { 27931ee73216SRichard Henderson qemu_log_lock(); 27945a18407fSRichard Henderson qemu_log("OP before indirect lowering:\n"); 27955a18407fSRichard Henderson tcg_dump_ops(s); 27965a18407fSRichard Henderson qemu_log("\n"); 27971ee73216SRichard Henderson qemu_log_unlock(); 27985a18407fSRichard Henderson } 27995a18407fSRichard Henderson #endif 28005a18407fSRichard Henderson /* Replace indirect temps with direct temps. */ 28015a18407fSRichard Henderson if (liveness_pass_2(s, temp_state)) { 28025a18407fSRichard Henderson /* If changes were made, re-run liveness. */ 28035a18407fSRichard Henderson liveness_pass_1(s, temp_state); 28045a18407fSRichard Henderson } 28055a18407fSRichard Henderson } 28065a18407fSRichard Henderson } 2807c5cc28ffSAurelien Jarno 2808a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2809a23a9ec6Sbellard s->la_time += profile_getclock(); 2810a23a9ec6Sbellard #endif 2811c896fe29Sbellard 2812c896fe29Sbellard #ifdef DEBUG_DISAS 2813d977e1c2SAlex Bennée if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT) 2814d977e1c2SAlex Bennée && qemu_log_in_addr_range(tb->pc))) { 28151ee73216SRichard Henderson qemu_log_lock(); 2816c5cc28ffSAurelien Jarno qemu_log("OP after optimization and liveness analysis:\n"); 2817eeacee4dSBlue Swirl tcg_dump_ops(s); 281893fcfe39Saliguori qemu_log("\n"); 28191ee73216SRichard Henderson qemu_log_unlock(); 2820c896fe29Sbellard } 2821c896fe29Sbellard #endif 2822c896fe29Sbellard 2823c896fe29Sbellard tcg_reg_alloc_start(s); 2824c896fe29Sbellard 2825e7e168f4SEmilio G. Cota s->code_buf = tb->tc.ptr; 2826e7e168f4SEmilio G. Cota s->code_ptr = tb->tc.ptr; 2827c896fe29Sbellard 2828659ef5cbSRichard Henderson #ifdef TCG_TARGET_NEED_LDST_LABELS 2829659ef5cbSRichard Henderson s->ldst_labels = NULL; 2830659ef5cbSRichard Henderson #endif 283157a26946SRichard Henderson #ifdef TCG_TARGET_NEED_POOL_LABELS 283257a26946SRichard Henderson s->pool_labels = NULL; 283357a26946SRichard Henderson #endif 28349ecefc84SRichard Henderson 2835fca8a500SRichard Henderson num_insns = -1; 2836dcb8e758SRichard Henderson for (oi = s->gen_op_buf[0].next; oi != 0; oi = oi_next) { 2837c45cb8bbSRichard Henderson TCGOp * const op = &s->gen_op_buf[oi]; 2838c45cb8bbSRichard Henderson TCGOpcode opc = op->opc; 2839b3db8758Sblueswir1 2840c45cb8bbSRichard Henderson oi_next = op->next; 2841c896fe29Sbellard #ifdef CONFIG_PROFILER 284254604f74Saurel32 tcg_table_op_count[opc]++; 2843c896fe29Sbellard #endif 2844c45cb8bbSRichard Henderson 2845c896fe29Sbellard switch (opc) { 2846c896fe29Sbellard case INDEX_op_mov_i32: 2847c896fe29Sbellard case INDEX_op_mov_i64: 2848dd186292SRichard Henderson tcg_reg_alloc_mov(s, op); 2849c896fe29Sbellard break; 2850e8996ee0Sbellard case INDEX_op_movi_i32: 2851e8996ee0Sbellard case INDEX_op_movi_i64: 2852dd186292SRichard Henderson tcg_reg_alloc_movi(s, op); 2853e8996ee0Sbellard break; 2854765b842aSRichard Henderson case INDEX_op_insn_start: 2855fca8a500SRichard Henderson if (num_insns >= 0) { 2856fca8a500SRichard Henderson s->gen_insn_end_off[num_insns] = tcg_current_code_size(s); 2857fca8a500SRichard Henderson } 2858fca8a500SRichard Henderson num_insns++; 2859bad729e2SRichard Henderson for (i = 0; i < TARGET_INSN_START_WORDS; ++i) { 2860bad729e2SRichard Henderson target_ulong a; 2861bad729e2SRichard Henderson #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS 2862efee3746SRichard Henderson a = deposit64(op->args[i * 2], 32, 32, op->args[i * 2 + 1]); 2863bad729e2SRichard Henderson #else 2864efee3746SRichard Henderson a = op->args[i]; 2865bad729e2SRichard Henderson #endif 2866fca8a500SRichard Henderson s->gen_insn_data[num_insns][i] = a; 2867bad729e2SRichard Henderson } 2868c896fe29Sbellard break; 28695ff9d6a4Sbellard case INDEX_op_discard: 287043439139SRichard Henderson temp_dead(s, arg_temp(op->args[0])); 28715ff9d6a4Sbellard break; 2872c896fe29Sbellard case INDEX_op_set_label: 2873e8996ee0Sbellard tcg_reg_alloc_bb_end(s, s->reserved_regs); 2874efee3746SRichard Henderson tcg_out_label(s, arg_label(op->args[0]), s->code_ptr); 2875c896fe29Sbellard break; 2876c896fe29Sbellard case INDEX_op_call: 2877dd186292SRichard Henderson tcg_reg_alloc_call(s, op); 2878c45cb8bbSRichard Henderson break; 2879c896fe29Sbellard default: 288025c4d9ccSRichard Henderson /* Sanity check that we've not introduced any unhandled opcodes. */ 2881be0f34b5SRichard Henderson tcg_debug_assert(tcg_op_supported(opc)); 2882c896fe29Sbellard /* Note: in order to speed up the code, it would be much 2883c896fe29Sbellard faster to have specialized register allocator functions for 2884c896fe29Sbellard some common argument patterns */ 2885dd186292SRichard Henderson tcg_reg_alloc_op(s, op); 2886c896fe29Sbellard break; 2887c896fe29Sbellard } 28888d8fdbaeSAurelien Jarno #ifdef CONFIG_DEBUG_TCG 2889c896fe29Sbellard check_regs(s); 2890c896fe29Sbellard #endif 2891b125f9dcSRichard Henderson /* Test for (pending) buffer overflow. The assumption is that any 2892b125f9dcSRichard Henderson one operation beginning below the high water mark cannot overrun 2893b125f9dcSRichard Henderson the buffer completely. Thus we can test for overflow after 2894b125f9dcSRichard Henderson generating code without having to check during generation. */ 2895644da9b3SJohn Clarke if (unlikely((void *)s->code_ptr > s->code_gen_highwater)) { 2896b125f9dcSRichard Henderson return -1; 2897b125f9dcSRichard Henderson } 2898c896fe29Sbellard } 2899fca8a500SRichard Henderson tcg_debug_assert(num_insns >= 0); 2900fca8a500SRichard Henderson s->gen_insn_end_off[num_insns] = tcg_current_code_size(s); 2901c45cb8bbSRichard Henderson 2902b76f0d8cSYeongkyoon Lee /* Generate TB finalization at the end of block */ 2903659ef5cbSRichard Henderson #ifdef TCG_TARGET_NEED_LDST_LABELS 2904659ef5cbSRichard Henderson if (!tcg_out_ldst_finalize(s)) { 290523dceda6SRichard Henderson return -1; 290623dceda6SRichard Henderson } 2907659ef5cbSRichard Henderson #endif 290857a26946SRichard Henderson #ifdef TCG_TARGET_NEED_POOL_LABELS 290957a26946SRichard Henderson if (!tcg_out_pool_finalize(s)) { 291057a26946SRichard Henderson return -1; 291157a26946SRichard Henderson } 291257a26946SRichard Henderson #endif 2913c896fe29Sbellard 2914c896fe29Sbellard /* flush instruction cache */ 29151813e175SRichard Henderson flush_icache_range((uintptr_t)s->code_buf, (uintptr_t)s->code_ptr); 29162aeabc08SStefan Weil 29171813e175SRichard Henderson return tcg_current_code_size(s); 2918c896fe29Sbellard } 2919c896fe29Sbellard 2920a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2921405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2922a23a9ec6Sbellard { 2923a23a9ec6Sbellard TCGContext *s = &tcg_ctx; 2924fca8a500SRichard Henderson int64_t tb_count = s->tb_count; 2925fca8a500SRichard Henderson int64_t tb_div_count = tb_count ? tb_count : 1; 2926fca8a500SRichard Henderson int64_t tot = s->interm_time + s->code_time; 2927a23a9ec6Sbellard 2928a23a9ec6Sbellard cpu_fprintf(f, "JIT cycles %" PRId64 " (%0.3f s at 2.4 GHz)\n", 2929a23a9ec6Sbellard tot, tot / 2.4e9); 2930a23a9ec6Sbellard cpu_fprintf(f, "translated TBs %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n", 2931fca8a500SRichard Henderson tb_count, s->tb_count1 - tb_count, 2932fca8a500SRichard Henderson (double)(s->tb_count1 - s->tb_count) 2933fca8a500SRichard Henderson / (s->tb_count1 ? s->tb_count1 : 1) * 100.0); 2934a23a9ec6Sbellard cpu_fprintf(f, "avg ops/TB %0.1f max=%d\n", 2935fca8a500SRichard Henderson (double)s->op_count / tb_div_count, s->op_count_max); 2936a23a9ec6Sbellard cpu_fprintf(f, "deleted ops/TB %0.2f\n", 2937fca8a500SRichard Henderson (double)s->del_op_count / tb_div_count); 2938a23a9ec6Sbellard cpu_fprintf(f, "avg temps/TB %0.2f max=%d\n", 2939fca8a500SRichard Henderson (double)s->temp_count / tb_div_count, s->temp_count_max); 2940fca8a500SRichard Henderson cpu_fprintf(f, "avg host code/TB %0.1f\n", 2941fca8a500SRichard Henderson (double)s->code_out_len / tb_div_count); 2942fca8a500SRichard Henderson cpu_fprintf(f, "avg search data/TB %0.1f\n", 2943fca8a500SRichard Henderson (double)s->search_out_len / tb_div_count); 2944a23a9ec6Sbellard 2945a23a9ec6Sbellard cpu_fprintf(f, "cycles/op %0.1f\n", 2946a23a9ec6Sbellard s->op_count ? (double)tot / s->op_count : 0); 2947a23a9ec6Sbellard cpu_fprintf(f, "cycles/in byte %0.1f\n", 2948a23a9ec6Sbellard s->code_in_len ? (double)tot / s->code_in_len : 0); 2949a23a9ec6Sbellard cpu_fprintf(f, "cycles/out byte %0.1f\n", 2950a23a9ec6Sbellard s->code_out_len ? (double)tot / s->code_out_len : 0); 2951fca8a500SRichard Henderson cpu_fprintf(f, "cycles/search byte %0.1f\n", 2952fca8a500SRichard Henderson s->search_out_len ? (double)tot / s->search_out_len : 0); 2953fca8a500SRichard Henderson if (tot == 0) { 2954a23a9ec6Sbellard tot = 1; 2955fca8a500SRichard Henderson } 2956a23a9ec6Sbellard cpu_fprintf(f, " gen_interm time %0.1f%%\n", 2957a23a9ec6Sbellard (double)s->interm_time / tot * 100.0); 2958a23a9ec6Sbellard cpu_fprintf(f, " gen_code time %0.1f%%\n", 2959a23a9ec6Sbellard (double)s->code_time / tot * 100.0); 2960c5cc28ffSAurelien Jarno cpu_fprintf(f, "optim./code time %0.1f%%\n", 2961c5cc28ffSAurelien Jarno (double)s->opt_time / (s->code_time ? s->code_time : 1) 2962c5cc28ffSAurelien Jarno * 100.0); 2963a23a9ec6Sbellard cpu_fprintf(f, "liveness/code time %0.1f%%\n", 2964a23a9ec6Sbellard (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0); 2965a23a9ec6Sbellard cpu_fprintf(f, "cpu_restore count %" PRId64 "\n", 2966a23a9ec6Sbellard s->restore_count); 2967a23a9ec6Sbellard cpu_fprintf(f, " avg cycles %0.1f\n", 2968a23a9ec6Sbellard s->restore_count ? (double)s->restore_time / s->restore_count : 0); 2969a23a9ec6Sbellard } 2970a23a9ec6Sbellard #else 2971405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2972a23a9ec6Sbellard { 297324bf7b3aSbellard cpu_fprintf(f, "[TCG profiler not compiled]\n"); 2974a23a9ec6Sbellard } 2975a23a9ec6Sbellard #endif 2976813da627SRichard Henderson 2977813da627SRichard Henderson #ifdef ELF_HOST_MACHINE 29785872bbf2SRichard Henderson /* In order to use this feature, the backend needs to do three things: 29795872bbf2SRichard Henderson 29805872bbf2SRichard Henderson (1) Define ELF_HOST_MACHINE to indicate both what value to 29815872bbf2SRichard Henderson put into the ELF image and to indicate support for the feature. 29825872bbf2SRichard Henderson 29835872bbf2SRichard Henderson (2) Define tcg_register_jit. This should create a buffer containing 29845872bbf2SRichard Henderson the contents of a .debug_frame section that describes the post- 29855872bbf2SRichard Henderson prologue unwind info for the tcg machine. 29865872bbf2SRichard Henderson 29875872bbf2SRichard Henderson (3) Call tcg_register_jit_int, with the constructed .debug_frame. 29885872bbf2SRichard Henderson */ 2989813da627SRichard Henderson 2990813da627SRichard Henderson /* Begin GDB interface. THE FOLLOWING MUST MATCH GDB DOCS. */ 2991813da627SRichard Henderson typedef enum { 2992813da627SRichard Henderson JIT_NOACTION = 0, 2993813da627SRichard Henderson JIT_REGISTER_FN, 2994813da627SRichard Henderson JIT_UNREGISTER_FN 2995813da627SRichard Henderson } jit_actions_t; 2996813da627SRichard Henderson 2997813da627SRichard Henderson struct jit_code_entry { 2998813da627SRichard Henderson struct jit_code_entry *next_entry; 2999813da627SRichard Henderson struct jit_code_entry *prev_entry; 3000813da627SRichard Henderson const void *symfile_addr; 3001813da627SRichard Henderson uint64_t symfile_size; 3002813da627SRichard Henderson }; 3003813da627SRichard Henderson 3004813da627SRichard Henderson struct jit_descriptor { 3005813da627SRichard Henderson uint32_t version; 3006813da627SRichard Henderson uint32_t action_flag; 3007813da627SRichard Henderson struct jit_code_entry *relevant_entry; 3008813da627SRichard Henderson struct jit_code_entry *first_entry; 3009813da627SRichard Henderson }; 3010813da627SRichard Henderson 3011813da627SRichard Henderson void __jit_debug_register_code(void) __attribute__((noinline)); 3012813da627SRichard Henderson void __jit_debug_register_code(void) 3013813da627SRichard Henderson { 3014813da627SRichard Henderson asm(""); 3015813da627SRichard Henderson } 3016813da627SRichard Henderson 3017813da627SRichard Henderson /* Must statically initialize the version, because GDB may check 3018813da627SRichard Henderson the version before we can set it. */ 3019813da627SRichard Henderson struct jit_descriptor __jit_debug_descriptor = { 1, 0, 0, 0 }; 3020813da627SRichard Henderson 3021813da627SRichard Henderson /* End GDB interface. */ 3022813da627SRichard Henderson 3023813da627SRichard Henderson static int find_string(const char *strtab, const char *str) 3024813da627SRichard Henderson { 3025813da627SRichard Henderson const char *p = strtab + 1; 3026813da627SRichard Henderson 3027813da627SRichard Henderson while (1) { 3028813da627SRichard Henderson if (strcmp(p, str) == 0) { 3029813da627SRichard Henderson return p - strtab; 3030813da627SRichard Henderson } 3031813da627SRichard Henderson p += strlen(p) + 1; 3032813da627SRichard Henderson } 3033813da627SRichard Henderson } 3034813da627SRichard Henderson 30355872bbf2SRichard Henderson static void tcg_register_jit_int(void *buf_ptr, size_t buf_size, 30362c90784aSRichard Henderson const void *debug_frame, 30372c90784aSRichard Henderson size_t debug_frame_size) 3038813da627SRichard Henderson { 30395872bbf2SRichard Henderson struct __attribute__((packed)) DebugInfo { 30405872bbf2SRichard Henderson uint32_t len; 30415872bbf2SRichard Henderson uint16_t version; 30425872bbf2SRichard Henderson uint32_t abbrev; 30435872bbf2SRichard Henderson uint8_t ptr_size; 30445872bbf2SRichard Henderson uint8_t cu_die; 30455872bbf2SRichard Henderson uint16_t cu_lang; 30465872bbf2SRichard Henderson uintptr_t cu_low_pc; 30475872bbf2SRichard Henderson uintptr_t cu_high_pc; 30485872bbf2SRichard Henderson uint8_t fn_die; 30495872bbf2SRichard Henderson char fn_name[16]; 30505872bbf2SRichard Henderson uintptr_t fn_low_pc; 30515872bbf2SRichard Henderson uintptr_t fn_high_pc; 30525872bbf2SRichard Henderson uint8_t cu_eoc; 30535872bbf2SRichard Henderson }; 3054813da627SRichard Henderson 3055813da627SRichard Henderson struct ElfImage { 3056813da627SRichard Henderson ElfW(Ehdr) ehdr; 3057813da627SRichard Henderson ElfW(Phdr) phdr; 30585872bbf2SRichard Henderson ElfW(Shdr) shdr[7]; 30595872bbf2SRichard Henderson ElfW(Sym) sym[2]; 30605872bbf2SRichard Henderson struct DebugInfo di; 30615872bbf2SRichard Henderson uint8_t da[24]; 30625872bbf2SRichard Henderson char str[80]; 30635872bbf2SRichard Henderson }; 30645872bbf2SRichard Henderson 30655872bbf2SRichard Henderson struct ElfImage *img; 30665872bbf2SRichard Henderson 30675872bbf2SRichard Henderson static const struct ElfImage img_template = { 30685872bbf2SRichard Henderson .ehdr = { 30695872bbf2SRichard Henderson .e_ident[EI_MAG0] = ELFMAG0, 30705872bbf2SRichard Henderson .e_ident[EI_MAG1] = ELFMAG1, 30715872bbf2SRichard Henderson .e_ident[EI_MAG2] = ELFMAG2, 30725872bbf2SRichard Henderson .e_ident[EI_MAG3] = ELFMAG3, 30735872bbf2SRichard Henderson .e_ident[EI_CLASS] = ELF_CLASS, 30745872bbf2SRichard Henderson .e_ident[EI_DATA] = ELF_DATA, 30755872bbf2SRichard Henderson .e_ident[EI_VERSION] = EV_CURRENT, 30765872bbf2SRichard Henderson .e_type = ET_EXEC, 30775872bbf2SRichard Henderson .e_machine = ELF_HOST_MACHINE, 30785872bbf2SRichard Henderson .e_version = EV_CURRENT, 30795872bbf2SRichard Henderson .e_phoff = offsetof(struct ElfImage, phdr), 30805872bbf2SRichard Henderson .e_shoff = offsetof(struct ElfImage, shdr), 30815872bbf2SRichard Henderson .e_ehsize = sizeof(ElfW(Shdr)), 30825872bbf2SRichard Henderson .e_phentsize = sizeof(ElfW(Phdr)), 30835872bbf2SRichard Henderson .e_phnum = 1, 30845872bbf2SRichard Henderson .e_shentsize = sizeof(ElfW(Shdr)), 30855872bbf2SRichard Henderson .e_shnum = ARRAY_SIZE(img->shdr), 30865872bbf2SRichard Henderson .e_shstrndx = ARRAY_SIZE(img->shdr) - 1, 3087abbb3eaeSRichard Henderson #ifdef ELF_HOST_FLAGS 3088abbb3eaeSRichard Henderson .e_flags = ELF_HOST_FLAGS, 3089abbb3eaeSRichard Henderson #endif 3090abbb3eaeSRichard Henderson #ifdef ELF_OSABI 3091abbb3eaeSRichard Henderson .e_ident[EI_OSABI] = ELF_OSABI, 3092abbb3eaeSRichard Henderson #endif 30935872bbf2SRichard Henderson }, 30945872bbf2SRichard Henderson .phdr = { 30955872bbf2SRichard Henderson .p_type = PT_LOAD, 30965872bbf2SRichard Henderson .p_flags = PF_X, 30975872bbf2SRichard Henderson }, 30985872bbf2SRichard Henderson .shdr = { 30995872bbf2SRichard Henderson [0] = { .sh_type = SHT_NULL }, 31005872bbf2SRichard Henderson /* Trick: The contents of code_gen_buffer are not present in 31015872bbf2SRichard Henderson this fake ELF file; that got allocated elsewhere. Therefore 31025872bbf2SRichard Henderson we mark .text as SHT_NOBITS (similar to .bss) so that readers 31035872bbf2SRichard Henderson will not look for contents. We can record any address. */ 31045872bbf2SRichard Henderson [1] = { /* .text */ 31055872bbf2SRichard Henderson .sh_type = SHT_NOBITS, 31065872bbf2SRichard Henderson .sh_flags = SHF_EXECINSTR | SHF_ALLOC, 31075872bbf2SRichard Henderson }, 31085872bbf2SRichard Henderson [2] = { /* .debug_info */ 31095872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 31105872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, di), 31115872bbf2SRichard Henderson .sh_size = sizeof(struct DebugInfo), 31125872bbf2SRichard Henderson }, 31135872bbf2SRichard Henderson [3] = { /* .debug_abbrev */ 31145872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 31155872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, da), 31165872bbf2SRichard Henderson .sh_size = sizeof(img->da), 31175872bbf2SRichard Henderson }, 31185872bbf2SRichard Henderson [4] = { /* .debug_frame */ 31195872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 31205872bbf2SRichard Henderson .sh_offset = sizeof(struct ElfImage), 31215872bbf2SRichard Henderson }, 31225872bbf2SRichard Henderson [5] = { /* .symtab */ 31235872bbf2SRichard Henderson .sh_type = SHT_SYMTAB, 31245872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, sym), 31255872bbf2SRichard Henderson .sh_size = sizeof(img->sym), 31265872bbf2SRichard Henderson .sh_info = 1, 31275872bbf2SRichard Henderson .sh_link = ARRAY_SIZE(img->shdr) - 1, 31285872bbf2SRichard Henderson .sh_entsize = sizeof(ElfW(Sym)), 31295872bbf2SRichard Henderson }, 31305872bbf2SRichard Henderson [6] = { /* .strtab */ 31315872bbf2SRichard Henderson .sh_type = SHT_STRTAB, 31325872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, str), 31335872bbf2SRichard Henderson .sh_size = sizeof(img->str), 31345872bbf2SRichard Henderson } 31355872bbf2SRichard Henderson }, 31365872bbf2SRichard Henderson .sym = { 31375872bbf2SRichard Henderson [1] = { /* code_gen_buffer */ 31385872bbf2SRichard Henderson .st_info = ELF_ST_INFO(STB_GLOBAL, STT_FUNC), 31395872bbf2SRichard Henderson .st_shndx = 1, 31405872bbf2SRichard Henderson } 31415872bbf2SRichard Henderson }, 31425872bbf2SRichard Henderson .di = { 31435872bbf2SRichard Henderson .len = sizeof(struct DebugInfo) - 4, 31445872bbf2SRichard Henderson .version = 2, 31455872bbf2SRichard Henderson .ptr_size = sizeof(void *), 31465872bbf2SRichard Henderson .cu_die = 1, 31475872bbf2SRichard Henderson .cu_lang = 0x8001, /* DW_LANG_Mips_Assembler */ 31485872bbf2SRichard Henderson .fn_die = 2, 31495872bbf2SRichard Henderson .fn_name = "code_gen_buffer" 31505872bbf2SRichard Henderson }, 31515872bbf2SRichard Henderson .da = { 31525872bbf2SRichard Henderson 1, /* abbrev number (the cu) */ 31535872bbf2SRichard Henderson 0x11, 1, /* DW_TAG_compile_unit, has children */ 31545872bbf2SRichard Henderson 0x13, 0x5, /* DW_AT_language, DW_FORM_data2 */ 31555872bbf2SRichard Henderson 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */ 31565872bbf2SRichard Henderson 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */ 31575872bbf2SRichard Henderson 0, 0, /* end of abbrev */ 31585872bbf2SRichard Henderson 2, /* abbrev number (the fn) */ 31595872bbf2SRichard Henderson 0x2e, 0, /* DW_TAG_subprogram, no children */ 31605872bbf2SRichard Henderson 0x3, 0x8, /* DW_AT_name, DW_FORM_string */ 31615872bbf2SRichard Henderson 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */ 31625872bbf2SRichard Henderson 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */ 31635872bbf2SRichard Henderson 0, 0, /* end of abbrev */ 31645872bbf2SRichard Henderson 0 /* no more abbrev */ 31655872bbf2SRichard Henderson }, 31665872bbf2SRichard Henderson .str = "\0" ".text\0" ".debug_info\0" ".debug_abbrev\0" 31675872bbf2SRichard Henderson ".debug_frame\0" ".symtab\0" ".strtab\0" "code_gen_buffer", 3168813da627SRichard Henderson }; 3169813da627SRichard Henderson 3170813da627SRichard Henderson /* We only need a single jit entry; statically allocate it. */ 3171813da627SRichard Henderson static struct jit_code_entry one_entry; 3172813da627SRichard Henderson 31735872bbf2SRichard Henderson uintptr_t buf = (uintptr_t)buf_ptr; 3174813da627SRichard Henderson size_t img_size = sizeof(struct ElfImage) + debug_frame_size; 31752c90784aSRichard Henderson DebugFrameHeader *dfh; 3176813da627SRichard Henderson 31775872bbf2SRichard Henderson img = g_malloc(img_size); 31785872bbf2SRichard Henderson *img = img_template; 3179813da627SRichard Henderson 31805872bbf2SRichard Henderson img->phdr.p_vaddr = buf; 31815872bbf2SRichard Henderson img->phdr.p_paddr = buf; 31825872bbf2SRichard Henderson img->phdr.p_memsz = buf_size; 3183813da627SRichard Henderson 31845872bbf2SRichard Henderson img->shdr[1].sh_name = find_string(img->str, ".text"); 31855872bbf2SRichard Henderson img->shdr[1].sh_addr = buf; 31865872bbf2SRichard Henderson img->shdr[1].sh_size = buf_size; 3187813da627SRichard Henderson 31885872bbf2SRichard Henderson img->shdr[2].sh_name = find_string(img->str, ".debug_info"); 31895872bbf2SRichard Henderson img->shdr[3].sh_name = find_string(img->str, ".debug_abbrev"); 31905872bbf2SRichard Henderson 31915872bbf2SRichard Henderson img->shdr[4].sh_name = find_string(img->str, ".debug_frame"); 31925872bbf2SRichard Henderson img->shdr[4].sh_size = debug_frame_size; 31935872bbf2SRichard Henderson 31945872bbf2SRichard Henderson img->shdr[5].sh_name = find_string(img->str, ".symtab"); 31955872bbf2SRichard Henderson img->shdr[6].sh_name = find_string(img->str, ".strtab"); 31965872bbf2SRichard Henderson 31975872bbf2SRichard Henderson img->sym[1].st_name = find_string(img->str, "code_gen_buffer"); 31985872bbf2SRichard Henderson img->sym[1].st_value = buf; 31995872bbf2SRichard Henderson img->sym[1].st_size = buf_size; 32005872bbf2SRichard Henderson 32015872bbf2SRichard Henderson img->di.cu_low_pc = buf; 320245aba097SRichard Henderson img->di.cu_high_pc = buf + buf_size; 32035872bbf2SRichard Henderson img->di.fn_low_pc = buf; 320445aba097SRichard Henderson img->di.fn_high_pc = buf + buf_size; 3205813da627SRichard Henderson 32062c90784aSRichard Henderson dfh = (DebugFrameHeader *)(img + 1); 32072c90784aSRichard Henderson memcpy(dfh, debug_frame, debug_frame_size); 32082c90784aSRichard Henderson dfh->fde.func_start = buf; 32092c90784aSRichard Henderson dfh->fde.func_len = buf_size; 32102c90784aSRichard Henderson 3211813da627SRichard Henderson #ifdef DEBUG_JIT 3212813da627SRichard Henderson /* Enable this block to be able to debug the ELF image file creation. 3213813da627SRichard Henderson One can use readelf, objdump, or other inspection utilities. */ 3214813da627SRichard Henderson { 3215813da627SRichard Henderson FILE *f = fopen("/tmp/qemu.jit", "w+b"); 3216813da627SRichard Henderson if (f) { 32175872bbf2SRichard Henderson if (fwrite(img, img_size, 1, f) != img_size) { 3218813da627SRichard Henderson /* Avoid stupid unused return value warning for fwrite. */ 3219813da627SRichard Henderson } 3220813da627SRichard Henderson fclose(f); 3221813da627SRichard Henderson } 3222813da627SRichard Henderson } 3223813da627SRichard Henderson #endif 3224813da627SRichard Henderson 3225813da627SRichard Henderson one_entry.symfile_addr = img; 3226813da627SRichard Henderson one_entry.symfile_size = img_size; 3227813da627SRichard Henderson 3228813da627SRichard Henderson __jit_debug_descriptor.action_flag = JIT_REGISTER_FN; 3229813da627SRichard Henderson __jit_debug_descriptor.relevant_entry = &one_entry; 3230813da627SRichard Henderson __jit_debug_descriptor.first_entry = &one_entry; 3231813da627SRichard Henderson __jit_debug_register_code(); 3232813da627SRichard Henderson } 3233813da627SRichard Henderson #else 32345872bbf2SRichard Henderson /* No support for the feature. Provide the entry point expected by exec.c, 32355872bbf2SRichard Henderson and implement the internal function we declared earlier. */ 3236813da627SRichard Henderson 3237813da627SRichard Henderson static void tcg_register_jit_int(void *buf, size_t size, 32382c90784aSRichard Henderson const void *debug_frame, 32392c90784aSRichard Henderson size_t debug_frame_size) 3240813da627SRichard Henderson { 3241813da627SRichard Henderson } 3242813da627SRichard Henderson 3243813da627SRichard Henderson void tcg_register_jit(void *buf, size_t buf_size) 3244813da627SRichard Henderson { 3245813da627SRichard Henderson } 3246813da627SRichard Henderson #endif /* ELF_HOST_MACHINE */ 3247