1c896fe29Sbellard /* 2c896fe29Sbellard * Tiny Code Generator for QEMU 3c896fe29Sbellard * 4c896fe29Sbellard * Copyright (c) 2008 Fabrice Bellard 5c896fe29Sbellard * 6c896fe29Sbellard * Permission is hereby granted, free of charge, to any person obtaining a copy 7c896fe29Sbellard * of this software and associated documentation files (the "Software"), to deal 8c896fe29Sbellard * in the Software without restriction, including without limitation the rights 9c896fe29Sbellard * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10c896fe29Sbellard * copies of the Software, and to permit persons to whom the Software is 11c896fe29Sbellard * furnished to do so, subject to the following conditions: 12c896fe29Sbellard * 13c896fe29Sbellard * The above copyright notice and this permission notice shall be included in 14c896fe29Sbellard * all copies or substantial portions of the Software. 15c896fe29Sbellard * 16c896fe29Sbellard * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17c896fe29Sbellard * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18c896fe29Sbellard * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19c896fe29Sbellard * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20c896fe29Sbellard * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21c896fe29Sbellard * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22c896fe29Sbellard * THE SOFTWARE. 23c896fe29Sbellard */ 24c896fe29Sbellard 25c896fe29Sbellard /* define it to use liveness analysis (better code) */ 26c896fe29Sbellard #define USE_LIVENESS_ANALYSIS 278f2e8c07SKirill Batuzov #define USE_TCG_OPTIMIZATIONS 28c896fe29Sbellard 29cca82982Saurel32 #include "config.h" 30cca82982Saurel32 31813da627SRichard Henderson /* Define to jump the ELF file used to communicate with GDB. */ 32813da627SRichard Henderson #undef DEBUG_JIT 33813da627SRichard Henderson 34a6c6f76cSBlue Swirl #if !defined(CONFIG_DEBUG_TCG) && !defined(NDEBUG) 35cca82982Saurel32 /* define it to suppress various consistency checks (faster) */ 36cca82982Saurel32 #define NDEBUG 37cca82982Saurel32 #endif 38cca82982Saurel32 39ca10f867Saurel32 #include "qemu-common.h" 40902b3d5cSmalc #include "cache-utils.h" 41379f6698SPaul Brook #include "host-utils.h" 422d8ebcf9SRichard Henderson #include "qemu-timer.h" 43c896fe29Sbellard 44c896fe29Sbellard /* Note: the long term plan is to reduce the dependancies on the QEMU 45c896fe29Sbellard CPU definitions. Currently they are used for qemu_ld/st 46c896fe29Sbellard instructions */ 47c896fe29Sbellard #define NO_CPU_IO_DEFS 48c896fe29Sbellard #include "cpu.h" 49c896fe29Sbellard 50c896fe29Sbellard #include "tcg-op.h" 51813da627SRichard Henderson 52813da627SRichard Henderson #if TCG_TARGET_REG_BITS == 64 53813da627SRichard Henderson # define ELF_CLASS ELFCLASS64 54813da627SRichard Henderson #else 55813da627SRichard Henderson # define ELF_CLASS ELFCLASS32 56813da627SRichard Henderson #endif 57813da627SRichard Henderson #ifdef HOST_WORDS_BIGENDIAN 58813da627SRichard Henderson # define ELF_DATA ELFDATA2MSB 59813da627SRichard Henderson #else 60813da627SRichard Henderson # define ELF_DATA ELFDATA2LSB 61813da627SRichard Henderson #endif 62813da627SRichard Henderson 63c896fe29Sbellard #include "elf.h" 64c896fe29Sbellard 65c0ad3001SStefan Weil /* Forward declarations for functions declared in tcg-target.c and used here. */ 66e4d58b41SRichard Henderson static void tcg_target_init(TCGContext *s); 67e4d58b41SRichard Henderson static void tcg_target_qemu_prologue(TCGContext *s); 68c896fe29Sbellard static void patch_reloc(uint8_t *code_ptr, int type, 69f54b3f92Saurel32 tcg_target_long value, tcg_target_long addend); 70c896fe29Sbellard 71813da627SRichard Henderson static void tcg_register_jit_int(void *buf, size_t size, 72813da627SRichard Henderson void *debug_frame, size_t debug_frame_size) 73813da627SRichard Henderson __attribute__((unused)); 74813da627SRichard Henderson 75c0ad3001SStefan Weil /* Forward declarations for functions declared and used in tcg-target.c. */ 76c0ad3001SStefan Weil static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str); 772a534affSRichard Henderson static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1, 78c0ad3001SStefan Weil tcg_target_long arg2); 792a534affSRichard Henderson static void tcg_out_mov(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg); 80c0ad3001SStefan Weil static void tcg_out_movi(TCGContext *s, TCGType type, 812a534affSRichard Henderson TCGReg ret, tcg_target_long arg); 82c0ad3001SStefan Weil static void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args, 83c0ad3001SStefan Weil const int *const_args); 842a534affSRichard Henderson static void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1, 85c0ad3001SStefan Weil tcg_target_long arg2); 86c0ad3001SStefan Weil static int tcg_target_const_match(tcg_target_long val, 87c0ad3001SStefan Weil const TCGArgConstraint *arg_ct); 88c0ad3001SStefan Weil 898399ad59SRichard Henderson TCGOpDef tcg_op_defs[] = { 900e2029a0SAurelien Jarno #define DEF(s, oargs, iargs, cargs, flags) { #s, oargs, iargs, cargs, iargs + oargs + cargs, flags }, 91c896fe29Sbellard #include "tcg-opc.h" 92c896fe29Sbellard #undef DEF 93c896fe29Sbellard }; 942a24374aSStefan Weil const size_t tcg_op_defs_max = ARRAY_SIZE(tcg_op_defs); 95c896fe29Sbellard 96b1d8e52eSblueswir1 static TCGRegSet tcg_target_available_regs[2]; 97b1d8e52eSblueswir1 static TCGRegSet tcg_target_call_clobber_regs; 98c896fe29Sbellard 99c896fe29Sbellard /* XXX: move that inside the context */ 100c896fe29Sbellard uint16_t *gen_opc_ptr; 101c896fe29Sbellard TCGArg *gen_opparam_ptr; 102c896fe29Sbellard 103c896fe29Sbellard static inline void tcg_out8(TCGContext *s, uint8_t v) 104c896fe29Sbellard { 105c896fe29Sbellard *s->code_ptr++ = v; 106c896fe29Sbellard } 107c896fe29Sbellard 108c896fe29Sbellard static inline void tcg_out16(TCGContext *s, uint16_t v) 109c896fe29Sbellard { 110c896fe29Sbellard *(uint16_t *)s->code_ptr = v; 111c896fe29Sbellard s->code_ptr += 2; 112c896fe29Sbellard } 113c896fe29Sbellard 114c896fe29Sbellard static inline void tcg_out32(TCGContext *s, uint32_t v) 115c896fe29Sbellard { 116c896fe29Sbellard *(uint32_t *)s->code_ptr = v; 117c896fe29Sbellard s->code_ptr += 4; 118c896fe29Sbellard } 119c896fe29Sbellard 120c896fe29Sbellard /* label relocation processing */ 121c896fe29Sbellard 122a5ad5916SStefan Weil static void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type, 123c896fe29Sbellard int label_index, long addend) 124c896fe29Sbellard { 125c896fe29Sbellard TCGLabel *l; 126c896fe29Sbellard TCGRelocation *r; 127c896fe29Sbellard 128c896fe29Sbellard l = &s->labels[label_index]; 129c896fe29Sbellard if (l->has_value) { 130623e265cSpbrook /* FIXME: This may break relocations on RISC targets that 131623e265cSpbrook modify instruction fields in place. The caller may not have 132623e265cSpbrook written the initial value. */ 133f54b3f92Saurel32 patch_reloc(code_ptr, type, l->u.value, addend); 134c896fe29Sbellard } else { 135c896fe29Sbellard /* add a new relocation entry */ 136c896fe29Sbellard r = tcg_malloc(sizeof(TCGRelocation)); 137c896fe29Sbellard r->type = type; 138c896fe29Sbellard r->ptr = code_ptr; 139c896fe29Sbellard r->addend = addend; 140c896fe29Sbellard r->next = l->u.first_reloc; 141c896fe29Sbellard l->u.first_reloc = r; 142c896fe29Sbellard } 143c896fe29Sbellard } 144c896fe29Sbellard 1459d6fca70SStefan Weil static void tcg_out_label(TCGContext *s, int label_index, void *ptr) 146c896fe29Sbellard { 147c896fe29Sbellard TCGLabel *l; 148c896fe29Sbellard TCGRelocation *r; 1499d6fca70SStefan Weil tcg_target_long value = (tcg_target_long)ptr; 150c896fe29Sbellard 151c896fe29Sbellard l = &s->labels[label_index]; 152c896fe29Sbellard if (l->has_value) 153c896fe29Sbellard tcg_abort(); 154c896fe29Sbellard r = l->u.first_reloc; 155c896fe29Sbellard while (r != NULL) { 156f54b3f92Saurel32 patch_reloc(r->ptr, r->type, value, r->addend); 157c896fe29Sbellard r = r->next; 158c896fe29Sbellard } 159c896fe29Sbellard l->has_value = 1; 160c896fe29Sbellard l->u.value = value; 161c896fe29Sbellard } 162c896fe29Sbellard 163c896fe29Sbellard int gen_new_label(void) 164c896fe29Sbellard { 165c896fe29Sbellard TCGContext *s = &tcg_ctx; 166c896fe29Sbellard int idx; 167c896fe29Sbellard TCGLabel *l; 168c896fe29Sbellard 169c896fe29Sbellard if (s->nb_labels >= TCG_MAX_LABELS) 170c896fe29Sbellard tcg_abort(); 171c896fe29Sbellard idx = s->nb_labels++; 172c896fe29Sbellard l = &s->labels[idx]; 173c896fe29Sbellard l->has_value = 0; 174c896fe29Sbellard l->u.first_reloc = NULL; 175c896fe29Sbellard return idx; 176c896fe29Sbellard } 177c896fe29Sbellard 178c896fe29Sbellard #include "tcg-target.c" 179c896fe29Sbellard 180c896fe29Sbellard /* pool based memory allocation */ 181c896fe29Sbellard void *tcg_malloc_internal(TCGContext *s, int size) 182c896fe29Sbellard { 183c896fe29Sbellard TCGPool *p; 184c896fe29Sbellard int pool_size; 185c896fe29Sbellard 186c896fe29Sbellard if (size > TCG_POOL_CHUNK_SIZE) { 187c896fe29Sbellard /* big malloc: insert a new pool (XXX: could optimize) */ 1887267c094SAnthony Liguori p = g_malloc(sizeof(TCGPool) + size); 189c896fe29Sbellard p->size = size; 1904055299eSKirill Batuzov p->next = s->pool_first_large; 1914055299eSKirill Batuzov s->pool_first_large = p; 1924055299eSKirill Batuzov return p->data; 193c896fe29Sbellard } else { 194c896fe29Sbellard p = s->pool_current; 195c896fe29Sbellard if (!p) { 196c896fe29Sbellard p = s->pool_first; 197c896fe29Sbellard if (!p) 198c896fe29Sbellard goto new_pool; 199c896fe29Sbellard } else { 200c896fe29Sbellard if (!p->next) { 201c896fe29Sbellard new_pool: 202c896fe29Sbellard pool_size = TCG_POOL_CHUNK_SIZE; 2037267c094SAnthony Liguori p = g_malloc(sizeof(TCGPool) + pool_size); 204c896fe29Sbellard p->size = pool_size; 205c896fe29Sbellard p->next = NULL; 206c896fe29Sbellard if (s->pool_current) 207c896fe29Sbellard s->pool_current->next = p; 208c896fe29Sbellard else 209c896fe29Sbellard s->pool_first = p; 210c896fe29Sbellard } else { 211c896fe29Sbellard p = p->next; 212c896fe29Sbellard } 213c896fe29Sbellard } 214c896fe29Sbellard } 215c896fe29Sbellard s->pool_current = p; 216c896fe29Sbellard s->pool_cur = p->data + size; 217c896fe29Sbellard s->pool_end = p->data + p->size; 218c896fe29Sbellard return p->data; 219c896fe29Sbellard } 220c896fe29Sbellard 221c896fe29Sbellard void tcg_pool_reset(TCGContext *s) 222c896fe29Sbellard { 2234055299eSKirill Batuzov TCGPool *p, *t; 2244055299eSKirill Batuzov for (p = s->pool_first_large; p; p = t) { 2254055299eSKirill Batuzov t = p->next; 2264055299eSKirill Batuzov g_free(p); 2274055299eSKirill Batuzov } 2284055299eSKirill Batuzov s->pool_first_large = NULL; 229c896fe29Sbellard s->pool_cur = s->pool_end = NULL; 230c896fe29Sbellard s->pool_current = NULL; 231c896fe29Sbellard } 232c896fe29Sbellard 233c896fe29Sbellard void tcg_context_init(TCGContext *s) 234c896fe29Sbellard { 235c896fe29Sbellard int op, total_args, n; 236c896fe29Sbellard TCGOpDef *def; 237c896fe29Sbellard TCGArgConstraint *args_ct; 238c896fe29Sbellard int *sorted_args; 239c896fe29Sbellard 240c896fe29Sbellard memset(s, 0, sizeof(*s)); 241c896fe29Sbellard s->nb_globals = 0; 242c896fe29Sbellard 243c896fe29Sbellard /* Count total number of arguments and allocate the corresponding 244c896fe29Sbellard space */ 245c896fe29Sbellard total_args = 0; 246c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 247c896fe29Sbellard def = &tcg_op_defs[op]; 248c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 249c896fe29Sbellard total_args += n; 250c896fe29Sbellard } 251c896fe29Sbellard 2527267c094SAnthony Liguori args_ct = g_malloc(sizeof(TCGArgConstraint) * total_args); 2537267c094SAnthony Liguori sorted_args = g_malloc(sizeof(int) * total_args); 254c896fe29Sbellard 255c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 256c896fe29Sbellard def = &tcg_op_defs[op]; 257c896fe29Sbellard def->args_ct = args_ct; 258c896fe29Sbellard def->sorted_args = sorted_args; 259c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 260c896fe29Sbellard sorted_args += n; 261c896fe29Sbellard args_ct += n; 262c896fe29Sbellard } 263c896fe29Sbellard 264c896fe29Sbellard tcg_target_init(s); 2659002ec79SRichard Henderson } 266b03cce8eSbellard 2679002ec79SRichard Henderson void tcg_prologue_init(TCGContext *s) 2689002ec79SRichard Henderson { 269b03cce8eSbellard /* init global prologue and epilogue */ 270b03cce8eSbellard s->code_buf = code_gen_prologue; 271b03cce8eSbellard s->code_ptr = s->code_buf; 272b03cce8eSbellard tcg_target_qemu_prologue(s); 2732aeabc08SStefan Weil flush_icache_range((tcg_target_ulong)s->code_buf, 2742aeabc08SStefan Weil (tcg_target_ulong)s->code_ptr); 275c896fe29Sbellard } 276c896fe29Sbellard 277c896fe29Sbellard void tcg_set_frame(TCGContext *s, int reg, 278c896fe29Sbellard tcg_target_long start, tcg_target_long size) 279c896fe29Sbellard { 280c896fe29Sbellard s->frame_start = start; 281c896fe29Sbellard s->frame_end = start + size; 282c896fe29Sbellard s->frame_reg = reg; 283c896fe29Sbellard } 284c896fe29Sbellard 285c896fe29Sbellard void tcg_func_start(TCGContext *s) 286c896fe29Sbellard { 287e8996ee0Sbellard int i; 288c896fe29Sbellard tcg_pool_reset(s); 289c896fe29Sbellard s->nb_temps = s->nb_globals; 290641d5fbeSbellard for(i = 0; i < (TCG_TYPE_COUNT * 2); i++) 291e8996ee0Sbellard s->first_free_temp[i] = -1; 292c896fe29Sbellard s->labels = tcg_malloc(sizeof(TCGLabel) * TCG_MAX_LABELS); 293c896fe29Sbellard s->nb_labels = 0; 294c896fe29Sbellard s->current_frame_offset = s->frame_start; 295c896fe29Sbellard 2960a209d4bSRichard Henderson #ifdef CONFIG_DEBUG_TCG 2970a209d4bSRichard Henderson s->goto_tb_issue_mask = 0; 2980a209d4bSRichard Henderson #endif 2990a209d4bSRichard Henderson 300c896fe29Sbellard gen_opc_ptr = gen_opc_buf; 301c896fe29Sbellard gen_opparam_ptr = gen_opparam_buf; 302c896fe29Sbellard } 303c896fe29Sbellard 304c896fe29Sbellard static inline void tcg_temp_alloc(TCGContext *s, int n) 305c896fe29Sbellard { 306c896fe29Sbellard if (n > TCG_MAX_TEMPS) 307c896fe29Sbellard tcg_abort(); 308c896fe29Sbellard } 309c896fe29Sbellard 310a7812ae4Spbrook static inline int tcg_global_reg_new_internal(TCGType type, int reg, 311a7812ae4Spbrook const char *name) 312c896fe29Sbellard { 313c896fe29Sbellard TCGContext *s = &tcg_ctx; 314c896fe29Sbellard TCGTemp *ts; 315c896fe29Sbellard int idx; 316c896fe29Sbellard 317c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 318c896fe29Sbellard if (type != TCG_TYPE_I32) 319c896fe29Sbellard tcg_abort(); 320c896fe29Sbellard #endif 321c896fe29Sbellard if (tcg_regset_test_reg(s->reserved_regs, reg)) 322c896fe29Sbellard tcg_abort(); 323c896fe29Sbellard idx = s->nb_globals; 324c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 325c896fe29Sbellard ts = &s->temps[s->nb_globals]; 326c896fe29Sbellard ts->base_type = type; 327c896fe29Sbellard ts->type = type; 328c896fe29Sbellard ts->fixed_reg = 1; 329c896fe29Sbellard ts->reg = reg; 330c896fe29Sbellard ts->name = name; 331c896fe29Sbellard s->nb_globals++; 332c896fe29Sbellard tcg_regset_set_reg(s->reserved_regs, reg); 333a7812ae4Spbrook return idx; 334a7812ae4Spbrook } 335a7812ae4Spbrook 336a7812ae4Spbrook TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name) 337a7812ae4Spbrook { 338a7812ae4Spbrook int idx; 339a7812ae4Spbrook 340a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name); 341a7812ae4Spbrook return MAKE_TCGV_I32(idx); 342a7812ae4Spbrook } 343a7812ae4Spbrook 344a7812ae4Spbrook TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name) 345a7812ae4Spbrook { 346a7812ae4Spbrook int idx; 347a7812ae4Spbrook 348a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I64, reg, name); 349a7812ae4Spbrook return MAKE_TCGV_I64(idx); 350c896fe29Sbellard } 351c896fe29Sbellard 352a7812ae4Spbrook static inline int tcg_global_mem_new_internal(TCGType type, int reg, 353a7812ae4Spbrook tcg_target_long offset, 354c896fe29Sbellard const char *name) 355c896fe29Sbellard { 356c896fe29Sbellard TCGContext *s = &tcg_ctx; 357c896fe29Sbellard TCGTemp *ts; 358c896fe29Sbellard int idx; 359c896fe29Sbellard 360c896fe29Sbellard idx = s->nb_globals; 361c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 362c896fe29Sbellard if (type == TCG_TYPE_I64) { 363c896fe29Sbellard char buf[64]; 364c588979bSths tcg_temp_alloc(s, s->nb_globals + 2); 365c896fe29Sbellard ts = &s->temps[s->nb_globals]; 366c896fe29Sbellard ts->base_type = type; 367c896fe29Sbellard ts->type = TCG_TYPE_I32; 368c896fe29Sbellard ts->fixed_reg = 0; 369c896fe29Sbellard ts->mem_allocated = 1; 370c896fe29Sbellard ts->mem_reg = reg; 371c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 372c896fe29Sbellard ts->mem_offset = offset + 4; 373c896fe29Sbellard #else 374c896fe29Sbellard ts->mem_offset = offset; 375c896fe29Sbellard #endif 376c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 377c896fe29Sbellard pstrcat(buf, sizeof(buf), "_0"); 378c896fe29Sbellard ts->name = strdup(buf); 379c896fe29Sbellard ts++; 380c896fe29Sbellard 381c896fe29Sbellard ts->base_type = type; 382c896fe29Sbellard ts->type = TCG_TYPE_I32; 383c896fe29Sbellard ts->fixed_reg = 0; 384c896fe29Sbellard ts->mem_allocated = 1; 385c896fe29Sbellard ts->mem_reg = reg; 386c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 387c896fe29Sbellard ts->mem_offset = offset; 388c896fe29Sbellard #else 389c896fe29Sbellard ts->mem_offset = offset + 4; 390c896fe29Sbellard #endif 391c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 392c896fe29Sbellard pstrcat(buf, sizeof(buf), "_1"); 393c896fe29Sbellard ts->name = strdup(buf); 394c896fe29Sbellard 395c896fe29Sbellard s->nb_globals += 2; 396c896fe29Sbellard } else 397c896fe29Sbellard #endif 398c896fe29Sbellard { 399c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 400c896fe29Sbellard ts = &s->temps[s->nb_globals]; 401c896fe29Sbellard ts->base_type = type; 402c896fe29Sbellard ts->type = type; 403c896fe29Sbellard ts->fixed_reg = 0; 404c896fe29Sbellard ts->mem_allocated = 1; 405c896fe29Sbellard ts->mem_reg = reg; 406c896fe29Sbellard ts->mem_offset = offset; 407c896fe29Sbellard ts->name = name; 408c896fe29Sbellard s->nb_globals++; 409c896fe29Sbellard } 410a7812ae4Spbrook return idx; 411c896fe29Sbellard } 412c896fe29Sbellard 413a7812ae4Spbrook TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset, 414a7812ae4Spbrook const char *name) 415a7812ae4Spbrook { 416a7812ae4Spbrook int idx; 417a7812ae4Spbrook 418a7812ae4Spbrook idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name); 419a7812ae4Spbrook return MAKE_TCGV_I32(idx); 420a7812ae4Spbrook } 421a7812ae4Spbrook 422a7812ae4Spbrook TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset, 423a7812ae4Spbrook const char *name) 424a7812ae4Spbrook { 425a7812ae4Spbrook int idx; 426a7812ae4Spbrook 427a7812ae4Spbrook idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name); 428a7812ae4Spbrook return MAKE_TCGV_I64(idx); 429a7812ae4Spbrook } 430a7812ae4Spbrook 431a7812ae4Spbrook static inline int tcg_temp_new_internal(TCGType type, int temp_local) 432c896fe29Sbellard { 433c896fe29Sbellard TCGContext *s = &tcg_ctx; 434c896fe29Sbellard TCGTemp *ts; 435641d5fbeSbellard int idx, k; 436c896fe29Sbellard 437641d5fbeSbellard k = type; 438641d5fbeSbellard if (temp_local) 439641d5fbeSbellard k += TCG_TYPE_COUNT; 440641d5fbeSbellard idx = s->first_free_temp[k]; 441e8996ee0Sbellard if (idx != -1) { 442e8996ee0Sbellard /* There is already an available temp with the 443e8996ee0Sbellard right type */ 444e8996ee0Sbellard ts = &s->temps[idx]; 445641d5fbeSbellard s->first_free_temp[k] = ts->next_free_temp; 446e8996ee0Sbellard ts->temp_allocated = 1; 447641d5fbeSbellard assert(ts->temp_local == temp_local); 448e8996ee0Sbellard } else { 449c896fe29Sbellard idx = s->nb_temps; 450c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 451c896fe29Sbellard if (type == TCG_TYPE_I64) { 4528df1ca4bSths tcg_temp_alloc(s, s->nb_temps + 2); 453c896fe29Sbellard ts = &s->temps[s->nb_temps]; 454c896fe29Sbellard ts->base_type = type; 455c896fe29Sbellard ts->type = TCG_TYPE_I32; 456e8996ee0Sbellard ts->temp_allocated = 1; 457641d5fbeSbellard ts->temp_local = temp_local; 458c896fe29Sbellard ts->name = NULL; 459c896fe29Sbellard ts++; 460c896fe29Sbellard ts->base_type = TCG_TYPE_I32; 461c896fe29Sbellard ts->type = TCG_TYPE_I32; 462e8996ee0Sbellard ts->temp_allocated = 1; 463641d5fbeSbellard ts->temp_local = temp_local; 464c896fe29Sbellard ts->name = NULL; 465c896fe29Sbellard s->nb_temps += 2; 466c896fe29Sbellard } else 467c896fe29Sbellard #endif 468c896fe29Sbellard { 469c896fe29Sbellard tcg_temp_alloc(s, s->nb_temps + 1); 470c896fe29Sbellard ts = &s->temps[s->nb_temps]; 471c896fe29Sbellard ts->base_type = type; 472c896fe29Sbellard ts->type = type; 473e8996ee0Sbellard ts->temp_allocated = 1; 474641d5fbeSbellard ts->temp_local = temp_local; 475c896fe29Sbellard ts->name = NULL; 476c896fe29Sbellard s->nb_temps++; 477c896fe29Sbellard } 478e8996ee0Sbellard } 47927bfd83cSPeter Maydell 48027bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 48127bfd83cSPeter Maydell s->temps_in_use++; 48227bfd83cSPeter Maydell #endif 483a7812ae4Spbrook return idx; 484c896fe29Sbellard } 485c896fe29Sbellard 486a7812ae4Spbrook TCGv_i32 tcg_temp_new_internal_i32(int temp_local) 487a7812ae4Spbrook { 488a7812ae4Spbrook int idx; 489a7812ae4Spbrook 490a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I32, temp_local); 491a7812ae4Spbrook return MAKE_TCGV_I32(idx); 492a7812ae4Spbrook } 493a7812ae4Spbrook 494a7812ae4Spbrook TCGv_i64 tcg_temp_new_internal_i64(int temp_local) 495a7812ae4Spbrook { 496a7812ae4Spbrook int idx; 497a7812ae4Spbrook 498a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I64, temp_local); 499a7812ae4Spbrook return MAKE_TCGV_I64(idx); 500a7812ae4Spbrook } 501a7812ae4Spbrook 502a7812ae4Spbrook static inline void tcg_temp_free_internal(int idx) 503c896fe29Sbellard { 504c896fe29Sbellard TCGContext *s = &tcg_ctx; 505c896fe29Sbellard TCGTemp *ts; 506641d5fbeSbellard int k; 507c896fe29Sbellard 50827bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 50927bfd83cSPeter Maydell s->temps_in_use--; 51027bfd83cSPeter Maydell if (s->temps_in_use < 0) { 51127bfd83cSPeter Maydell fprintf(stderr, "More temporaries freed than allocated!\n"); 51227bfd83cSPeter Maydell } 51327bfd83cSPeter Maydell #endif 51427bfd83cSPeter Maydell 515e8996ee0Sbellard assert(idx >= s->nb_globals && idx < s->nb_temps); 516c896fe29Sbellard ts = &s->temps[idx]; 517e8996ee0Sbellard assert(ts->temp_allocated != 0); 518e8996ee0Sbellard ts->temp_allocated = 0; 519641d5fbeSbellard k = ts->base_type; 520641d5fbeSbellard if (ts->temp_local) 521641d5fbeSbellard k += TCG_TYPE_COUNT; 522641d5fbeSbellard ts->next_free_temp = s->first_free_temp[k]; 523641d5fbeSbellard s->first_free_temp[k] = idx; 524e8996ee0Sbellard } 525e8996ee0Sbellard 526a7812ae4Spbrook void tcg_temp_free_i32(TCGv_i32 arg) 527e8996ee0Sbellard { 528a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I32(arg)); 529a7812ae4Spbrook } 530a7812ae4Spbrook 531a7812ae4Spbrook void tcg_temp_free_i64(TCGv_i64 arg) 532a7812ae4Spbrook { 533a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I64(arg)); 534a7812ae4Spbrook } 535a7812ae4Spbrook 536a7812ae4Spbrook TCGv_i32 tcg_const_i32(int32_t val) 537a7812ae4Spbrook { 538a7812ae4Spbrook TCGv_i32 t0; 539a7812ae4Spbrook t0 = tcg_temp_new_i32(); 540e8996ee0Sbellard tcg_gen_movi_i32(t0, val); 541e8996ee0Sbellard return t0; 542c896fe29Sbellard } 543c896fe29Sbellard 544a7812ae4Spbrook TCGv_i64 tcg_const_i64(int64_t val) 545c896fe29Sbellard { 546a7812ae4Spbrook TCGv_i64 t0; 547a7812ae4Spbrook t0 = tcg_temp_new_i64(); 548e8996ee0Sbellard tcg_gen_movi_i64(t0, val); 549e8996ee0Sbellard return t0; 550c896fe29Sbellard } 551c896fe29Sbellard 552a7812ae4Spbrook TCGv_i32 tcg_const_local_i32(int32_t val) 553bdffd4a9Saurel32 { 554a7812ae4Spbrook TCGv_i32 t0; 555a7812ae4Spbrook t0 = tcg_temp_local_new_i32(); 556bdffd4a9Saurel32 tcg_gen_movi_i32(t0, val); 557bdffd4a9Saurel32 return t0; 558bdffd4a9Saurel32 } 559bdffd4a9Saurel32 560a7812ae4Spbrook TCGv_i64 tcg_const_local_i64(int64_t val) 561bdffd4a9Saurel32 { 562a7812ae4Spbrook TCGv_i64 t0; 563a7812ae4Spbrook t0 = tcg_temp_local_new_i64(); 564bdffd4a9Saurel32 tcg_gen_movi_i64(t0, val); 565bdffd4a9Saurel32 return t0; 566bdffd4a9Saurel32 } 567bdffd4a9Saurel32 56827bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 56927bfd83cSPeter Maydell void tcg_clear_temp_count(void) 57027bfd83cSPeter Maydell { 57127bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 57227bfd83cSPeter Maydell s->temps_in_use = 0; 57327bfd83cSPeter Maydell } 57427bfd83cSPeter Maydell 57527bfd83cSPeter Maydell int tcg_check_temp_count(void) 57627bfd83cSPeter Maydell { 57727bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 57827bfd83cSPeter Maydell if (s->temps_in_use) { 57927bfd83cSPeter Maydell /* Clear the count so that we don't give another 58027bfd83cSPeter Maydell * warning immediately next time around. 58127bfd83cSPeter Maydell */ 58227bfd83cSPeter Maydell s->temps_in_use = 0; 58327bfd83cSPeter Maydell return 1; 58427bfd83cSPeter Maydell } 58527bfd83cSPeter Maydell return 0; 58627bfd83cSPeter Maydell } 58727bfd83cSPeter Maydell #endif 58827bfd83cSPeter Maydell 589c896fe29Sbellard void tcg_register_helper(void *func, const char *name) 590c896fe29Sbellard { 591c896fe29Sbellard TCGContext *s = &tcg_ctx; 592c896fe29Sbellard int n; 593c896fe29Sbellard if ((s->nb_helpers + 1) > s->allocated_helpers) { 594c896fe29Sbellard n = s->allocated_helpers; 595c896fe29Sbellard if (n == 0) { 596c896fe29Sbellard n = 4; 597c896fe29Sbellard } else { 598c896fe29Sbellard n *= 2; 599c896fe29Sbellard } 600c896fe29Sbellard s->helpers = realloc(s->helpers, n * sizeof(TCGHelperInfo)); 601c896fe29Sbellard s->allocated_helpers = n; 602c896fe29Sbellard } 6034dc81f28Sbellard s->helpers[s->nb_helpers].func = (tcg_target_ulong)func; 604c896fe29Sbellard s->helpers[s->nb_helpers].name = name; 605c896fe29Sbellard s->nb_helpers++; 606c896fe29Sbellard } 607c896fe29Sbellard 60839cf05d3Sbellard /* Note: we convert the 64 bit args to 32 bit and do some alignment 60939cf05d3Sbellard and endian swap. Maybe it would be better to do the alignment 61039cf05d3Sbellard and endian swap in tcg_reg_alloc_call(). */ 611a7812ae4Spbrook void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags, 612a7812ae4Spbrook int sizemask, TCGArg ret, int nargs, TCGArg *args) 613c896fe29Sbellard { 614a7812ae4Spbrook int i; 615a7812ae4Spbrook int real_args; 616a7812ae4Spbrook int nb_rets; 617a7812ae4Spbrook TCGArg *nparam; 6182bece2c8SRichard Henderson 6192bece2c8SRichard Henderson #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 6202bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 6212bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 6222bece2c8SRichard Henderson int is_signed = sizemask & (2 << (i+1)*2); 6232bece2c8SRichard Henderson if (!is_64bit) { 6242bece2c8SRichard Henderson TCGv_i64 temp = tcg_temp_new_i64(); 6252bece2c8SRichard Henderson TCGv_i64 orig = MAKE_TCGV_I64(args[i]); 6262bece2c8SRichard Henderson if (is_signed) { 6272bece2c8SRichard Henderson tcg_gen_ext32s_i64(temp, orig); 6282bece2c8SRichard Henderson } else { 6292bece2c8SRichard Henderson tcg_gen_ext32u_i64(temp, orig); 6302bece2c8SRichard Henderson } 6312bece2c8SRichard Henderson args[i] = GET_TCGV_I64(temp); 6322bece2c8SRichard Henderson } 6332bece2c8SRichard Henderson } 6342bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 6352bece2c8SRichard Henderson 636a7812ae4Spbrook *gen_opc_ptr++ = INDEX_op_call; 637a7812ae4Spbrook nparam = gen_opparam_ptr++; 638a7812ae4Spbrook if (ret != TCG_CALL_DUMMY_ARG) { 639a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 640a7812ae4Spbrook if (sizemask & 1) { 641a7812ae4Spbrook #ifdef TCG_TARGET_WORDS_BIGENDIAN 642a7812ae4Spbrook *gen_opparam_ptr++ = ret + 1; 643a7812ae4Spbrook *gen_opparam_ptr++ = ret; 644a7812ae4Spbrook #else 645a7812ae4Spbrook *gen_opparam_ptr++ = ret; 646a7812ae4Spbrook *gen_opparam_ptr++ = ret + 1; 647a7812ae4Spbrook #endif 648a7812ae4Spbrook nb_rets = 2; 649a7812ae4Spbrook } else 650a7812ae4Spbrook #endif 651a7812ae4Spbrook { 652a7812ae4Spbrook *gen_opparam_ptr++ = ret; 653a7812ae4Spbrook nb_rets = 1; 654a7812ae4Spbrook } 655a7812ae4Spbrook } else { 656a7812ae4Spbrook nb_rets = 0; 657a7812ae4Spbrook } 658a7812ae4Spbrook real_args = 0; 659a7812ae4Spbrook for (i = 0; i < nargs; i++) { 660a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 6612bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 6622bece2c8SRichard Henderson if (is_64bit) { 66339cf05d3Sbellard #ifdef TCG_TARGET_CALL_ALIGN_ARGS 66439cf05d3Sbellard /* some targets want aligned 64 bit args */ 665ebd486d5Smalc if (real_args & 1) { 666a7812ae4Spbrook *gen_opparam_ptr++ = TCG_CALL_DUMMY_ARG; 667ebd486d5Smalc real_args++; 66839cf05d3Sbellard } 66939cf05d3Sbellard #endif 6703f90f252SRichard Henderson /* If stack grows up, then we will be placing successive 6713f90f252SRichard Henderson arguments at lower addresses, which means we need to 6723f90f252SRichard Henderson reverse the order compared to how we would normally 6733f90f252SRichard Henderson treat either big or little-endian. For those arguments 6743f90f252SRichard Henderson that will wind up in registers, this still works for 6753f90f252SRichard Henderson HPPA (the only current STACK_GROWSUP target) since the 6763f90f252SRichard Henderson argument registers are *also* allocated in decreasing 6773f90f252SRichard Henderson order. If another such target is added, this logic may 6783f90f252SRichard Henderson have to get more complicated to differentiate between 6793f90f252SRichard Henderson stack arguments and register arguments. */ 6803f90f252SRichard Henderson #if defined(TCG_TARGET_WORDS_BIGENDIAN) != defined(TCG_TARGET_STACK_GROWSUP) 681a7812ae4Spbrook *gen_opparam_ptr++ = args[i] + 1; 682a7812ae4Spbrook *gen_opparam_ptr++ = args[i]; 683c896fe29Sbellard #else 684a7812ae4Spbrook *gen_opparam_ptr++ = args[i]; 685a7812ae4Spbrook *gen_opparam_ptr++ = args[i] + 1; 686c896fe29Sbellard #endif 687a7812ae4Spbrook real_args += 2; 6882bece2c8SRichard Henderson continue; 6892bece2c8SRichard Henderson } 6902bece2c8SRichard Henderson #endif /* TCG_TARGET_REG_BITS < 64 */ 6912bece2c8SRichard Henderson 692a7812ae4Spbrook *gen_opparam_ptr++ = args[i]; 693a7812ae4Spbrook real_args++; 694c896fe29Sbellard } 695a7812ae4Spbrook *gen_opparam_ptr++ = GET_TCGV_PTR(func); 696a7812ae4Spbrook 697a7812ae4Spbrook *gen_opparam_ptr++ = flags; 698a7812ae4Spbrook 699a7812ae4Spbrook *nparam = (nb_rets << 16) | (real_args + 1); 700a7812ae4Spbrook 701a7812ae4Spbrook /* total parameters, needed to go backward in the instruction stream */ 702a7812ae4Spbrook *gen_opparam_ptr++ = 1 + nb_rets + real_args + 3; 7032bece2c8SRichard Henderson 7042bece2c8SRichard Henderson #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 7052bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 7062bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 7072bece2c8SRichard Henderson if (!is_64bit) { 7082bece2c8SRichard Henderson TCGv_i64 temp = MAKE_TCGV_I64(args[i]); 7092bece2c8SRichard Henderson tcg_temp_free_i64(temp); 7102bece2c8SRichard Henderson } 7112bece2c8SRichard Henderson } 7122bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 713a7812ae4Spbrook } 714c896fe29Sbellard 715ac56dd48Spbrook #if TCG_TARGET_REG_BITS == 32 716a7812ae4Spbrook void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, 717c896fe29Sbellard int c, int right, int arith) 718c896fe29Sbellard { 719cf60bce4Sbellard if (c == 0) { 720a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1)); 721cf60bce4Sbellard tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1)); 722cf60bce4Sbellard } else if (c >= 32) { 723c896fe29Sbellard c -= 32; 724c896fe29Sbellard if (right) { 725c896fe29Sbellard if (arith) { 726a7812ae4Spbrook tcg_gen_sari_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 727ac56dd48Spbrook tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 31); 728c896fe29Sbellard } else { 729a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 730ac56dd48Spbrook tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 731c896fe29Sbellard } 732c896fe29Sbellard } else { 733a7812ae4Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_LOW(arg1), c); 734a7812ae4Spbrook tcg_gen_movi_i32(TCGV_LOW(ret), 0); 735c896fe29Sbellard } 736c896fe29Sbellard } else { 737a7812ae4Spbrook TCGv_i32 t0, t1; 738c896fe29Sbellard 739a7812ae4Spbrook t0 = tcg_temp_new_i32(); 740a7812ae4Spbrook t1 = tcg_temp_new_i32(); 741c896fe29Sbellard if (right) { 742ac56dd48Spbrook tcg_gen_shli_i32(t0, TCGV_HIGH(arg1), 32 - c); 743c896fe29Sbellard if (arith) 744ac56dd48Spbrook tcg_gen_sari_i32(t1, TCGV_HIGH(arg1), c); 745c896fe29Sbellard else 746ac56dd48Spbrook tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c); 747a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_LOW(arg1), c); 748a7812ae4Spbrook tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t0); 749ac56dd48Spbrook tcg_gen_mov_i32(TCGV_HIGH(ret), t1); 750c896fe29Sbellard } else { 751a7812ae4Spbrook tcg_gen_shri_i32(t0, TCGV_LOW(arg1), 32 - c); 752c896fe29Sbellard /* Note: ret can be the same as arg1, so we use t1 */ 753a7812ae4Spbrook tcg_gen_shli_i32(t1, TCGV_LOW(arg1), c); 754ac56dd48Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c); 755ac56dd48Spbrook tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0); 756a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), t1); 757c896fe29Sbellard } 758a7812ae4Spbrook tcg_temp_free_i32(t0); 759a7812ae4Spbrook tcg_temp_free_i32(t1); 760c896fe29Sbellard } 761c896fe29Sbellard } 762ac56dd48Spbrook #endif 763c896fe29Sbellard 764be210acbSRichard Henderson 7658fcd3692Sblueswir1 static void tcg_reg_alloc_start(TCGContext *s) 766c896fe29Sbellard { 767c896fe29Sbellard int i; 768c896fe29Sbellard TCGTemp *ts; 769c896fe29Sbellard for(i = 0; i < s->nb_globals; i++) { 770c896fe29Sbellard ts = &s->temps[i]; 771c896fe29Sbellard if (ts->fixed_reg) { 772c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 773c896fe29Sbellard } else { 774c896fe29Sbellard ts->val_type = TEMP_VAL_MEM; 775c896fe29Sbellard } 776c896fe29Sbellard } 777e8996ee0Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 778e8996ee0Sbellard ts = &s->temps[i]; 779*7dfd8c6aSAurelien Jarno if (ts->temp_local) { 780*7dfd8c6aSAurelien Jarno ts->val_type = TEMP_VAL_MEM; 781*7dfd8c6aSAurelien Jarno } else { 782e8996ee0Sbellard ts->val_type = TEMP_VAL_DEAD; 783*7dfd8c6aSAurelien Jarno } 784e8996ee0Sbellard ts->mem_allocated = 0; 785e8996ee0Sbellard ts->fixed_reg = 0; 786e8996ee0Sbellard } 787c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 788c896fe29Sbellard s->reg_to_temp[i] = -1; 789c896fe29Sbellard } 790c896fe29Sbellard } 791c896fe29Sbellard 792ac56dd48Spbrook static char *tcg_get_arg_str_idx(TCGContext *s, char *buf, int buf_size, 793ac56dd48Spbrook int idx) 794c896fe29Sbellard { 795c896fe29Sbellard TCGTemp *ts; 796ac56dd48Spbrook 7977f6f0ae5SStefan Weil assert(idx >= 0 && idx < s->nb_temps); 798ac56dd48Spbrook ts = &s->temps[idx]; 7997f6f0ae5SStefan Weil assert(ts); 800ac56dd48Spbrook if (idx < s->nb_globals) { 801ac56dd48Spbrook pstrcpy(buf, buf_size, ts->name); 802c896fe29Sbellard } else { 803641d5fbeSbellard if (ts->temp_local) 804641d5fbeSbellard snprintf(buf, buf_size, "loc%d", idx - s->nb_globals); 805641d5fbeSbellard else 806ac56dd48Spbrook snprintf(buf, buf_size, "tmp%d", idx - s->nb_globals); 807c896fe29Sbellard } 808c896fe29Sbellard return buf; 809c896fe29Sbellard } 810c896fe29Sbellard 811a7812ae4Spbrook char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg) 812ac56dd48Spbrook { 813a7812ae4Spbrook return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I32(arg)); 814a7812ae4Spbrook } 815a7812ae4Spbrook 816a7812ae4Spbrook char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg) 817a7812ae4Spbrook { 818a810a2deSblueswir1 return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I64(arg)); 819ac56dd48Spbrook } 820ac56dd48Spbrook 821e8996ee0Sbellard static int helper_cmp(const void *p1, const void *p2) 822e8996ee0Sbellard { 823e8996ee0Sbellard const TCGHelperInfo *th1 = p1; 824e8996ee0Sbellard const TCGHelperInfo *th2 = p2; 825e8996ee0Sbellard if (th1->func < th2->func) 826e8996ee0Sbellard return -1; 827e8996ee0Sbellard else if (th1->func == th2->func) 828e8996ee0Sbellard return 0; 829e8996ee0Sbellard else 830e8996ee0Sbellard return 1; 831e8996ee0Sbellard } 832e8996ee0Sbellard 833e8996ee0Sbellard /* find helper definition (Note: A hash table would be better) */ 8344dc81f28Sbellard static TCGHelperInfo *tcg_find_helper(TCGContext *s, tcg_target_ulong val) 8354dc81f28Sbellard { 836e8996ee0Sbellard int m, m_min, m_max; 837e8996ee0Sbellard TCGHelperInfo *th; 838e8996ee0Sbellard tcg_target_ulong v; 839e8996ee0Sbellard 840e8996ee0Sbellard if (unlikely(!s->helpers_sorted)) { 841e8996ee0Sbellard qsort(s->helpers, s->nb_helpers, sizeof(TCGHelperInfo), 842e8996ee0Sbellard helper_cmp); 843e8996ee0Sbellard s->helpers_sorted = 1; 844e8996ee0Sbellard } 845e8996ee0Sbellard 846e8996ee0Sbellard /* binary search */ 847e8996ee0Sbellard m_min = 0; 848e8996ee0Sbellard m_max = s->nb_helpers - 1; 849e8996ee0Sbellard while (m_min <= m_max) { 850e8996ee0Sbellard m = (m_min + m_max) >> 1; 851e8996ee0Sbellard th = &s->helpers[m]; 852e8996ee0Sbellard v = th->func; 853e8996ee0Sbellard if (v == val) 854e8996ee0Sbellard return th; 855e8996ee0Sbellard else if (val < v) { 856e8996ee0Sbellard m_max = m - 1; 857e8996ee0Sbellard } else { 858e8996ee0Sbellard m_min = m + 1; 859e8996ee0Sbellard } 8604dc81f28Sbellard } 8614dc81f28Sbellard return NULL; 8624dc81f28Sbellard } 8634dc81f28Sbellard 864f48f3edeSblueswir1 static const char * const cond_name[] = 865f48f3edeSblueswir1 { 8660aed257fSRichard Henderson [TCG_COND_NEVER] = "never", 8670aed257fSRichard Henderson [TCG_COND_ALWAYS] = "always", 868f48f3edeSblueswir1 [TCG_COND_EQ] = "eq", 869f48f3edeSblueswir1 [TCG_COND_NE] = "ne", 870f48f3edeSblueswir1 [TCG_COND_LT] = "lt", 871f48f3edeSblueswir1 [TCG_COND_GE] = "ge", 872f48f3edeSblueswir1 [TCG_COND_LE] = "le", 873f48f3edeSblueswir1 [TCG_COND_GT] = "gt", 874f48f3edeSblueswir1 [TCG_COND_LTU] = "ltu", 875f48f3edeSblueswir1 [TCG_COND_GEU] = "geu", 876f48f3edeSblueswir1 [TCG_COND_LEU] = "leu", 877f48f3edeSblueswir1 [TCG_COND_GTU] = "gtu" 878f48f3edeSblueswir1 }; 879f48f3edeSblueswir1 880eeacee4dSBlue Swirl void tcg_dump_ops(TCGContext *s) 881c896fe29Sbellard { 882c896fe29Sbellard const uint16_t *opc_ptr; 883c896fe29Sbellard const TCGArg *args; 884c896fe29Sbellard TCGArg arg; 885a9751609SRichard Henderson TCGOpcode c; 886a9751609SRichard Henderson int i, k, nb_oargs, nb_iargs, nb_cargs, first_insn; 887c896fe29Sbellard const TCGOpDef *def; 888c896fe29Sbellard char buf[128]; 889c896fe29Sbellard 8907e4597d7Sbellard first_insn = 1; 891c896fe29Sbellard opc_ptr = gen_opc_buf; 892c896fe29Sbellard args = gen_opparam_buf; 893c896fe29Sbellard while (opc_ptr < gen_opc_ptr) { 894c896fe29Sbellard c = *opc_ptr++; 895c896fe29Sbellard def = &tcg_op_defs[c]; 8967e4597d7Sbellard if (c == INDEX_op_debug_insn_start) { 8977e4597d7Sbellard uint64_t pc; 8987e4597d7Sbellard #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS 8997e4597d7Sbellard pc = ((uint64_t)args[1] << 32) | args[0]; 9007e4597d7Sbellard #else 9017e4597d7Sbellard pc = args[0]; 9027e4597d7Sbellard #endif 903eeacee4dSBlue Swirl if (!first_insn) { 904eeacee4dSBlue Swirl qemu_log("\n"); 905eeacee4dSBlue Swirl } 906eeacee4dSBlue Swirl qemu_log(" ---- 0x%" PRIx64, pc); 9077e4597d7Sbellard first_insn = 0; 9087e4597d7Sbellard nb_oargs = def->nb_oargs; 9097e4597d7Sbellard nb_iargs = def->nb_iargs; 9107e4597d7Sbellard nb_cargs = def->nb_cargs; 9117e4597d7Sbellard } else if (c == INDEX_op_call) { 912c896fe29Sbellard TCGArg arg; 9134dc81f28Sbellard 914c896fe29Sbellard /* variable number of arguments */ 915c896fe29Sbellard arg = *args++; 916c896fe29Sbellard nb_oargs = arg >> 16; 917c896fe29Sbellard nb_iargs = arg & 0xffff; 918c896fe29Sbellard nb_cargs = def->nb_cargs; 919b03cce8eSbellard 920eeacee4dSBlue Swirl qemu_log(" %s ", def->name); 9217e4597d7Sbellard 922b03cce8eSbellard /* function name */ 923eeacee4dSBlue Swirl qemu_log("%s", 924eeacee4dSBlue Swirl tcg_get_arg_str_idx(s, buf, sizeof(buf), 925eeacee4dSBlue Swirl args[nb_oargs + nb_iargs - 1])); 926b03cce8eSbellard /* flags */ 927eeacee4dSBlue Swirl qemu_log(",$0x%" TCG_PRIlx, args[nb_oargs + nb_iargs]); 928b03cce8eSbellard /* nb out args */ 929eeacee4dSBlue Swirl qemu_log(",$%d", nb_oargs); 930b03cce8eSbellard for(i = 0; i < nb_oargs; i++) { 931eeacee4dSBlue Swirl qemu_log(","); 932eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 933eeacee4dSBlue Swirl args[i])); 934b03cce8eSbellard } 935b03cce8eSbellard for(i = 0; i < (nb_iargs - 1); i++) { 936eeacee4dSBlue Swirl qemu_log(","); 93739cf05d3Sbellard if (args[nb_oargs + i] == TCG_CALL_DUMMY_ARG) { 938eeacee4dSBlue Swirl qemu_log("<dummy>"); 93939cf05d3Sbellard } else { 940eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 941eeacee4dSBlue Swirl args[nb_oargs + i])); 942b03cce8eSbellard } 94339cf05d3Sbellard } 944fba3161fSAurelien Jarno } else if (c == INDEX_op_movi_i32 || c == INDEX_op_movi_i64) { 945e8996ee0Sbellard tcg_target_ulong val; 946e8996ee0Sbellard TCGHelperInfo *th; 947e8996ee0Sbellard 948e8996ee0Sbellard nb_oargs = def->nb_oargs; 949e8996ee0Sbellard nb_iargs = def->nb_iargs; 950e8996ee0Sbellard nb_cargs = def->nb_cargs; 951eeacee4dSBlue Swirl qemu_log(" %s %s,$", def->name, 952e8996ee0Sbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[0])); 953e8996ee0Sbellard val = args[1]; 954e8996ee0Sbellard th = tcg_find_helper(s, val); 955e8996ee0Sbellard if (th) { 956eeacee4dSBlue Swirl qemu_log("%s", th->name); 957e8996ee0Sbellard } else { 958eeacee4dSBlue Swirl if (c == INDEX_op_movi_i32) { 959eeacee4dSBlue Swirl qemu_log("0x%x", (uint32_t)val); 960eeacee4dSBlue Swirl } else { 961eeacee4dSBlue Swirl qemu_log("0x%" PRIx64 , (uint64_t)val); 962eeacee4dSBlue Swirl } 963e8996ee0Sbellard } 964b03cce8eSbellard } else { 965eeacee4dSBlue Swirl qemu_log(" %s ", def->name); 966b03cce8eSbellard if (c == INDEX_op_nopn) { 967c896fe29Sbellard /* variable number of arguments */ 968c896fe29Sbellard nb_cargs = *args; 969c896fe29Sbellard nb_oargs = 0; 970c896fe29Sbellard nb_iargs = 0; 971c896fe29Sbellard } else { 972c896fe29Sbellard nb_oargs = def->nb_oargs; 973c896fe29Sbellard nb_iargs = def->nb_iargs; 974c896fe29Sbellard nb_cargs = def->nb_cargs; 975c896fe29Sbellard } 976c896fe29Sbellard 977c896fe29Sbellard k = 0; 978c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 979eeacee4dSBlue Swirl if (k != 0) { 980eeacee4dSBlue Swirl qemu_log(","); 981eeacee4dSBlue Swirl } 982eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 983eeacee4dSBlue Swirl args[k++])); 984c896fe29Sbellard } 985c896fe29Sbellard for(i = 0; i < nb_iargs; i++) { 986eeacee4dSBlue Swirl if (k != 0) { 987eeacee4dSBlue Swirl qemu_log(","); 988eeacee4dSBlue Swirl } 989eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 990eeacee4dSBlue Swirl args[k++])); 991c896fe29Sbellard } 992be210acbSRichard Henderson switch (c) { 993be210acbSRichard Henderson case INDEX_op_brcond_i32: 994ffc5ea09SRichard Henderson case INDEX_op_setcond_i32: 995ffc5ea09SRichard Henderson case INDEX_op_movcond_i32: 996be210acbSRichard Henderson case INDEX_op_brcond2_i32: 997be210acbSRichard Henderson case INDEX_op_setcond2_i32: 998ffc5ea09SRichard Henderson case INDEX_op_brcond_i64: 999be210acbSRichard Henderson case INDEX_op_setcond_i64: 1000ffc5ea09SRichard Henderson case INDEX_op_movcond_i64: 1001eeacee4dSBlue Swirl if (args[k] < ARRAY_SIZE(cond_name) && cond_name[args[k]]) { 1002eeacee4dSBlue Swirl qemu_log(",%s", cond_name[args[k++]]); 1003eeacee4dSBlue Swirl } else { 1004eeacee4dSBlue Swirl qemu_log(",$0x%" TCG_PRIlx, args[k++]); 1005eeacee4dSBlue Swirl } 1006f48f3edeSblueswir1 i = 1; 1007be210acbSRichard Henderson break; 1008be210acbSRichard Henderson default: 1009f48f3edeSblueswir1 i = 0; 1010be210acbSRichard Henderson break; 1011be210acbSRichard Henderson } 1012f48f3edeSblueswir1 for(; i < nb_cargs; i++) { 1013eeacee4dSBlue Swirl if (k != 0) { 1014eeacee4dSBlue Swirl qemu_log(","); 1015eeacee4dSBlue Swirl } 1016c896fe29Sbellard arg = args[k++]; 1017eeacee4dSBlue Swirl qemu_log("$0x%" TCG_PRIlx, arg); 1018c896fe29Sbellard } 1019b03cce8eSbellard } 1020eeacee4dSBlue Swirl qemu_log("\n"); 1021c896fe29Sbellard args += nb_iargs + nb_oargs + nb_cargs; 1022c896fe29Sbellard } 1023c896fe29Sbellard } 1024c896fe29Sbellard 1025c896fe29Sbellard /* we give more priority to constraints with less registers */ 1026c896fe29Sbellard static int get_constraint_priority(const TCGOpDef *def, int k) 1027c896fe29Sbellard { 1028c896fe29Sbellard const TCGArgConstraint *arg_ct; 1029c896fe29Sbellard 1030c896fe29Sbellard int i, n; 1031c896fe29Sbellard arg_ct = &def->args_ct[k]; 1032c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 1033c896fe29Sbellard /* an alias is equivalent to a single register */ 1034c896fe29Sbellard n = 1; 1035c896fe29Sbellard } else { 1036c896fe29Sbellard if (!(arg_ct->ct & TCG_CT_REG)) 1037c896fe29Sbellard return 0; 1038c896fe29Sbellard n = 0; 1039c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1040c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, i)) 1041c896fe29Sbellard n++; 1042c896fe29Sbellard } 1043c896fe29Sbellard } 1044c896fe29Sbellard return TCG_TARGET_NB_REGS - n + 1; 1045c896fe29Sbellard } 1046c896fe29Sbellard 1047c896fe29Sbellard /* sort from highest priority to lowest */ 1048c896fe29Sbellard static void sort_constraints(TCGOpDef *def, int start, int n) 1049c896fe29Sbellard { 1050c896fe29Sbellard int i, j, p1, p2, tmp; 1051c896fe29Sbellard 1052c896fe29Sbellard for(i = 0; i < n; i++) 1053c896fe29Sbellard def->sorted_args[start + i] = start + i; 1054c896fe29Sbellard if (n <= 1) 1055c896fe29Sbellard return; 1056c896fe29Sbellard for(i = 0; i < n - 1; i++) { 1057c896fe29Sbellard for(j = i + 1; j < n; j++) { 1058c896fe29Sbellard p1 = get_constraint_priority(def, def->sorted_args[start + i]); 1059c896fe29Sbellard p2 = get_constraint_priority(def, def->sorted_args[start + j]); 1060c896fe29Sbellard if (p1 < p2) { 1061c896fe29Sbellard tmp = def->sorted_args[start + i]; 1062c896fe29Sbellard def->sorted_args[start + i] = def->sorted_args[start + j]; 1063c896fe29Sbellard def->sorted_args[start + j] = tmp; 1064c896fe29Sbellard } 1065c896fe29Sbellard } 1066c896fe29Sbellard } 1067c896fe29Sbellard } 1068c896fe29Sbellard 1069c896fe29Sbellard void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs) 1070c896fe29Sbellard { 1071a9751609SRichard Henderson TCGOpcode op; 1072c896fe29Sbellard TCGOpDef *def; 1073c896fe29Sbellard const char *ct_str; 1074c896fe29Sbellard int i, nb_args; 1075c896fe29Sbellard 1076c896fe29Sbellard for(;;) { 1077a9751609SRichard Henderson if (tdefs->op == (TCGOpcode)-1) 1078c896fe29Sbellard break; 1079c896fe29Sbellard op = tdefs->op; 1080c3b08d0eSStefan Weil assert((unsigned)op < NB_OPS); 1081c896fe29Sbellard def = &tcg_op_defs[op]; 1082c68aaa18SStefan Weil #if defined(CONFIG_DEBUG_TCG) 1083c68aaa18SStefan Weil /* Duplicate entry in op definitions? */ 1084c68aaa18SStefan Weil assert(!def->used); 1085c68aaa18SStefan Weil def->used = 1; 1086c68aaa18SStefan Weil #endif 1087c896fe29Sbellard nb_args = def->nb_iargs + def->nb_oargs; 1088c896fe29Sbellard for(i = 0; i < nb_args; i++) { 1089c896fe29Sbellard ct_str = tdefs->args_ct_str[i]; 1090c68aaa18SStefan Weil /* Incomplete TCGTargetOpDef entry? */ 1091c68aaa18SStefan Weil assert(ct_str != NULL); 1092c896fe29Sbellard tcg_regset_clear(def->args_ct[i].u.regs); 1093c896fe29Sbellard def->args_ct[i].ct = 0; 1094c896fe29Sbellard if (ct_str[0] >= '0' && ct_str[0] <= '9') { 1095c896fe29Sbellard int oarg; 1096c896fe29Sbellard oarg = ct_str[0] - '0'; 1097c896fe29Sbellard assert(oarg < def->nb_oargs); 1098c896fe29Sbellard assert(def->args_ct[oarg].ct & TCG_CT_REG); 1099c896fe29Sbellard /* TCG_CT_ALIAS is for the output arguments. The input 11005ff9d6a4Sbellard argument is tagged with TCG_CT_IALIAS. */ 1101c896fe29Sbellard def->args_ct[i] = def->args_ct[oarg]; 11025ff9d6a4Sbellard def->args_ct[oarg].ct = TCG_CT_ALIAS; 11035ff9d6a4Sbellard def->args_ct[oarg].alias_index = i; 1104c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_IALIAS; 11055ff9d6a4Sbellard def->args_ct[i].alias_index = oarg; 1106c896fe29Sbellard } else { 1107c896fe29Sbellard for(;;) { 1108c896fe29Sbellard if (*ct_str == '\0') 1109c896fe29Sbellard break; 1110c896fe29Sbellard switch(*ct_str) { 1111c896fe29Sbellard case 'i': 1112c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_CONST; 1113c896fe29Sbellard ct_str++; 1114c896fe29Sbellard break; 1115c896fe29Sbellard default: 1116c896fe29Sbellard if (target_parse_constraint(&def->args_ct[i], &ct_str) < 0) { 1117c896fe29Sbellard fprintf(stderr, "Invalid constraint '%s' for arg %d of operation '%s'\n", 1118c896fe29Sbellard ct_str, i, def->name); 1119c896fe29Sbellard exit(1); 1120c896fe29Sbellard } 1121c896fe29Sbellard } 1122c896fe29Sbellard } 1123c896fe29Sbellard } 1124c896fe29Sbellard } 1125c896fe29Sbellard 1126c68aaa18SStefan Weil /* TCGTargetOpDef entry with too much information? */ 1127c68aaa18SStefan Weil assert(i == TCG_MAX_OP_ARGS || tdefs->args_ct_str[i] == NULL); 1128c68aaa18SStefan Weil 1129c896fe29Sbellard /* sort the constraints (XXX: this is just an heuristic) */ 1130c896fe29Sbellard sort_constraints(def, 0, def->nb_oargs); 1131c896fe29Sbellard sort_constraints(def, def->nb_oargs, def->nb_iargs); 1132c896fe29Sbellard 1133c896fe29Sbellard #if 0 1134c896fe29Sbellard { 1135c896fe29Sbellard int i; 1136c896fe29Sbellard 1137c896fe29Sbellard printf("%s: sorted=", def->name); 1138c896fe29Sbellard for(i = 0; i < def->nb_oargs + def->nb_iargs; i++) 1139c896fe29Sbellard printf(" %d", def->sorted_args[i]); 1140c896fe29Sbellard printf("\n"); 1141c896fe29Sbellard } 1142c896fe29Sbellard #endif 1143c896fe29Sbellard tdefs++; 1144c896fe29Sbellard } 1145c896fe29Sbellard 1146c68aaa18SStefan Weil #if defined(CONFIG_DEBUG_TCG) 1147a9751609SRichard Henderson i = 0; 1148c68aaa18SStefan Weil for (op = 0; op < ARRAY_SIZE(tcg_op_defs); op++) { 1149f412c762SRichard Henderson const TCGOpDef *def = &tcg_op_defs[op]; 1150f412c762SRichard Henderson if (op < INDEX_op_call 1151f412c762SRichard Henderson || op == INDEX_op_debug_insn_start 1152f412c762SRichard Henderson || (def->flags & TCG_OPF_NOT_PRESENT)) { 1153c68aaa18SStefan Weil /* Wrong entry in op definitions? */ 1154f412c762SRichard Henderson if (def->used) { 1155f412c762SRichard Henderson fprintf(stderr, "Invalid op definition for %s\n", def->name); 1156a9751609SRichard Henderson i = 1; 1157a9751609SRichard Henderson } 1158c68aaa18SStefan Weil } else { 1159c68aaa18SStefan Weil /* Missing entry in op definitions? */ 1160f412c762SRichard Henderson if (!def->used) { 1161f412c762SRichard Henderson fprintf(stderr, "Missing op definition for %s\n", def->name); 1162a9751609SRichard Henderson i = 1; 1163c68aaa18SStefan Weil } 1164c68aaa18SStefan Weil } 1165a9751609SRichard Henderson } 1166a9751609SRichard Henderson if (i == 1) { 1167a9751609SRichard Henderson tcg_abort(); 1168a9751609SRichard Henderson } 1169c68aaa18SStefan Weil #endif 1170c896fe29Sbellard } 1171c896fe29Sbellard 1172c896fe29Sbellard #ifdef USE_LIVENESS_ANALYSIS 1173c896fe29Sbellard 1174c896fe29Sbellard /* set a nop for an operation using 'nb_args' */ 1175c896fe29Sbellard static inline void tcg_set_nop(TCGContext *s, uint16_t *opc_ptr, 1176c896fe29Sbellard TCGArg *args, int nb_args) 1177c896fe29Sbellard { 1178c896fe29Sbellard if (nb_args == 0) { 1179c896fe29Sbellard *opc_ptr = INDEX_op_nop; 1180c896fe29Sbellard } else { 1181c896fe29Sbellard *opc_ptr = INDEX_op_nopn; 1182c896fe29Sbellard args[0] = nb_args; 1183c896fe29Sbellard args[nb_args - 1] = nb_args; 1184c896fe29Sbellard } 1185c896fe29Sbellard } 1186c896fe29Sbellard 11879c43b68dSAurelien Jarno /* liveness analysis: end of function: all temps are dead, and globals 11889c43b68dSAurelien Jarno should be in memory. */ 11899c43b68dSAurelien Jarno static inline void tcg_la_func_end(TCGContext *s, uint8_t *dead_temps, 11909c43b68dSAurelien Jarno uint8_t *mem_temps) 1191c896fe29Sbellard { 11929c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_temps); 11939c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 11949c43b68dSAurelien Jarno memset(mem_temps + s->nb_globals, 0, s->nb_temps - s->nb_globals); 1195c896fe29Sbellard } 1196c896fe29Sbellard 11979c43b68dSAurelien Jarno /* liveness analysis: end of basic block: all temps are dead, globals 11989c43b68dSAurelien Jarno and local temps should be in memory. */ 11999c43b68dSAurelien Jarno static inline void tcg_la_bb_end(TCGContext *s, uint8_t *dead_temps, 12009c43b68dSAurelien Jarno uint8_t *mem_temps) 1201641d5fbeSbellard { 1202641d5fbeSbellard int i; 1203641d5fbeSbellard 12049c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_temps); 12059c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 1206641d5fbeSbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 12079c43b68dSAurelien Jarno mem_temps[i] = s->temps[i].temp_local; 1208641d5fbeSbellard } 1209641d5fbeSbellard } 1210641d5fbeSbellard 1211866cb6cbSAurelien Jarno /* Liveness analysis : update the opc_dead_args array to tell if a 1212c896fe29Sbellard given input arguments is dead. Instructions updating dead 1213c896fe29Sbellard temporaries are removed. */ 12148fcd3692Sblueswir1 static void tcg_liveness_analysis(TCGContext *s) 1215c896fe29Sbellard { 1216a9751609SRichard Henderson int i, op_index, nb_args, nb_iargs, nb_oargs, arg, nb_ops; 1217a9751609SRichard Henderson TCGOpcode op; 1218c896fe29Sbellard TCGArg *args; 1219c896fe29Sbellard const TCGOpDef *def; 12209c43b68dSAurelien Jarno uint8_t *dead_temps, *mem_temps; 1221ec7a869dSAurelien Jarno uint16_t dead_args; 1222ec7a869dSAurelien Jarno uint8_t sync_args; 1223c896fe29Sbellard 1224c896fe29Sbellard gen_opc_ptr++; /* skip end */ 1225c896fe29Sbellard 1226c896fe29Sbellard nb_ops = gen_opc_ptr - gen_opc_buf; 1227c896fe29Sbellard 1228866cb6cbSAurelien Jarno s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t)); 1229ec7a869dSAurelien Jarno s->op_sync_args = tcg_malloc(nb_ops * sizeof(uint8_t)); 1230c896fe29Sbellard 1231c896fe29Sbellard dead_temps = tcg_malloc(s->nb_temps); 12329c43b68dSAurelien Jarno mem_temps = tcg_malloc(s->nb_temps); 12339c43b68dSAurelien Jarno tcg_la_func_end(s, dead_temps, mem_temps); 1234c896fe29Sbellard 1235c896fe29Sbellard args = gen_opparam_ptr; 1236c896fe29Sbellard op_index = nb_ops - 1; 1237c896fe29Sbellard while (op_index >= 0) { 1238c896fe29Sbellard op = gen_opc_buf[op_index]; 1239c896fe29Sbellard def = &tcg_op_defs[op]; 1240c896fe29Sbellard switch(op) { 1241c896fe29Sbellard case INDEX_op_call: 1242c6e113f5Sbellard { 1243c6e113f5Sbellard int call_flags; 1244c6e113f5Sbellard 1245c896fe29Sbellard nb_args = args[-1]; 1246c896fe29Sbellard args -= nb_args; 1247c896fe29Sbellard nb_iargs = args[0] & 0xffff; 1248c896fe29Sbellard nb_oargs = args[0] >> 16; 1249c896fe29Sbellard args++; 1250c6e113f5Sbellard call_flags = args[nb_oargs + nb_iargs]; 1251c6e113f5Sbellard 1252c6e113f5Sbellard /* pure functions can be removed if their result is not 1253c6e113f5Sbellard used */ 1254c6e113f5Sbellard if (call_flags & TCG_CALL_PURE) { 1255c6e113f5Sbellard for(i = 0; i < nb_oargs; i++) { 1256c6e113f5Sbellard arg = args[i]; 12579c43b68dSAurelien Jarno if (!dead_temps[arg] || mem_temps[arg]) { 1258c6e113f5Sbellard goto do_not_remove_call; 1259c6e113f5Sbellard } 12609c43b68dSAurelien Jarno } 1261c6e113f5Sbellard tcg_set_nop(s, gen_opc_buf + op_index, 1262c6e113f5Sbellard args - 1, nb_args); 1263c6e113f5Sbellard } else { 1264c6e113f5Sbellard do_not_remove_call: 1265c896fe29Sbellard 1266c896fe29Sbellard /* output args are dead */ 12676b64b624SAurelien Jarno dead_args = 0; 1268ec7a869dSAurelien Jarno sync_args = 0; 1269c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1270c896fe29Sbellard arg = args[i]; 12716b64b624SAurelien Jarno if (dead_temps[arg]) { 12726b64b624SAurelien Jarno dead_args |= (1 << i); 12736b64b624SAurelien Jarno } 12749c43b68dSAurelien Jarno if (mem_temps[arg]) { 12759c43b68dSAurelien Jarno sync_args |= (1 << i); 12769c43b68dSAurelien Jarno } 1277c896fe29Sbellard dead_temps[arg] = 1; 12789c43b68dSAurelien Jarno mem_temps[arg] = 0; 1279c896fe29Sbellard } 1280c896fe29Sbellard 1281b9c18f56Saurel32 if (!(call_flags & TCG_CALL_CONST)) { 12829c43b68dSAurelien Jarno /* globals should go back to memory */ 12839c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_globals); 12849c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 1285b9c18f56Saurel32 } 1286c896fe29Sbellard 1287c896fe29Sbellard /* input args are live */ 1288866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 1289866cb6cbSAurelien Jarno arg = args[i]; 129039cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 1291c896fe29Sbellard if (dead_temps[arg]) { 1292866cb6cbSAurelien Jarno dead_args |= (1 << i); 1293c896fe29Sbellard } 1294c896fe29Sbellard dead_temps[arg] = 0; 1295c896fe29Sbellard } 129639cf05d3Sbellard } 1297866cb6cbSAurelien Jarno s->op_dead_args[op_index] = dead_args; 1298ec7a869dSAurelien Jarno s->op_sync_args[op_index] = sync_args; 1299c6e113f5Sbellard } 1300c896fe29Sbellard args--; 1301c6e113f5Sbellard } 1302c896fe29Sbellard break; 13037e4597d7Sbellard case INDEX_op_debug_insn_start: 13047e4597d7Sbellard args -= def->nb_args; 13057e4597d7Sbellard break; 1306c896fe29Sbellard case INDEX_op_nopn: 1307c896fe29Sbellard nb_args = args[-1]; 1308c896fe29Sbellard args -= nb_args; 1309c896fe29Sbellard break; 13105ff9d6a4Sbellard case INDEX_op_discard: 13115ff9d6a4Sbellard args--; 13125ff9d6a4Sbellard /* mark the temporary as dead */ 13135ff9d6a4Sbellard dead_temps[args[0]] = 1; 13149c43b68dSAurelien Jarno mem_temps[args[0]] = 0; 13155ff9d6a4Sbellard break; 1316c896fe29Sbellard case INDEX_op_end: 1317c896fe29Sbellard break; 13181305c451SRichard Henderson 13191305c451SRichard Henderson case INDEX_op_add2_i32: 13201305c451SRichard Henderson case INDEX_op_sub2_i32: 13211305c451SRichard Henderson args -= 6; 13221305c451SRichard Henderson nb_iargs = 4; 13231305c451SRichard Henderson nb_oargs = 2; 13241305c451SRichard Henderson /* Test if the high part of the operation is dead, but not 13251305c451SRichard Henderson the low part. The result can be optimized to a simple 13261305c451SRichard Henderson add or sub. This happens often for x86_64 guest when the 13271305c451SRichard Henderson cpu mode is set to 32 bit. */ 13281305c451SRichard Henderson if (dead_temps[args[1]]) { 13291305c451SRichard Henderson if (dead_temps[args[0]]) { 13301305c451SRichard Henderson goto do_remove; 13311305c451SRichard Henderson } 13321305c451SRichard Henderson /* Create the single operation plus nop. */ 13331305c451SRichard Henderson if (op == INDEX_op_add2_i32) { 13341305c451SRichard Henderson op = INDEX_op_add_i32; 13351305c451SRichard Henderson } else { 13361305c451SRichard Henderson op = INDEX_op_sub_i32; 13371305c451SRichard Henderson } 13381305c451SRichard Henderson gen_opc_buf[op_index] = op; 13391305c451SRichard Henderson args[1] = args[2]; 13401305c451SRichard Henderson args[2] = args[4]; 13411305c451SRichard Henderson assert(gen_opc_buf[op_index + 1] == INDEX_op_nop); 13421305c451SRichard Henderson tcg_set_nop(s, gen_opc_buf + op_index + 1, args + 3, 3); 13431305c451SRichard Henderson /* Fall through and mark the single-word operation live. */ 13441305c451SRichard Henderson nb_iargs = 2; 13451305c451SRichard Henderson nb_oargs = 1; 13461305c451SRichard Henderson } 13471305c451SRichard Henderson goto do_not_remove; 13481305c451SRichard Henderson 13491414968aSRichard Henderson case INDEX_op_mulu2_i32: 13501414968aSRichard Henderson args -= 4; 13511414968aSRichard Henderson nb_iargs = 2; 13521414968aSRichard Henderson nb_oargs = 2; 13531414968aSRichard Henderson /* Likewise, test for the high part of the operation dead. */ 13541414968aSRichard Henderson if (dead_temps[args[1]]) { 13551414968aSRichard Henderson if (dead_temps[args[0]]) { 13561414968aSRichard Henderson goto do_remove; 13571414968aSRichard Henderson } 13581414968aSRichard Henderson gen_opc_buf[op_index] = op = INDEX_op_mul_i32; 13591414968aSRichard Henderson args[1] = args[2]; 13601414968aSRichard Henderson args[2] = args[3]; 13611414968aSRichard Henderson assert(gen_opc_buf[op_index + 1] == INDEX_op_nop); 13621414968aSRichard Henderson tcg_set_nop(s, gen_opc_buf + op_index + 1, args + 3, 1); 13631414968aSRichard Henderson /* Fall through and mark the single-word operation live. */ 13641414968aSRichard Henderson nb_oargs = 1; 13651414968aSRichard Henderson } 13661414968aSRichard Henderson goto do_not_remove; 13671414968aSRichard Henderson 1368c896fe29Sbellard default: 13691305c451SRichard Henderson /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */ 1370c896fe29Sbellard args -= def->nb_args; 1371c896fe29Sbellard nb_iargs = def->nb_iargs; 1372c896fe29Sbellard nb_oargs = def->nb_oargs; 1373c896fe29Sbellard 1374c896fe29Sbellard /* Test if the operation can be removed because all 13755ff9d6a4Sbellard its outputs are dead. We assume that nb_oargs == 0 13765ff9d6a4Sbellard implies side effects */ 13775ff9d6a4Sbellard if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) { 1378c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1379c896fe29Sbellard arg = args[i]; 13809c43b68dSAurelien Jarno if (!dead_temps[arg] || mem_temps[arg]) { 1381c896fe29Sbellard goto do_not_remove; 1382c896fe29Sbellard } 13839c43b68dSAurelien Jarno } 13841305c451SRichard Henderson do_remove: 1385c896fe29Sbellard tcg_set_nop(s, gen_opc_buf + op_index, args, def->nb_args); 1386c896fe29Sbellard #ifdef CONFIG_PROFILER 1387a23a9ec6Sbellard s->del_op_count++; 1388c896fe29Sbellard #endif 1389c896fe29Sbellard } else { 1390c896fe29Sbellard do_not_remove: 1391c896fe29Sbellard 1392c896fe29Sbellard /* output args are dead */ 13936b64b624SAurelien Jarno dead_args = 0; 1394ec7a869dSAurelien Jarno sync_args = 0; 1395c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1396c896fe29Sbellard arg = args[i]; 13976b64b624SAurelien Jarno if (dead_temps[arg]) { 13986b64b624SAurelien Jarno dead_args |= (1 << i); 13996b64b624SAurelien Jarno } 14009c43b68dSAurelien Jarno if (mem_temps[arg]) { 14019c43b68dSAurelien Jarno sync_args |= (1 << i); 14029c43b68dSAurelien Jarno } 1403c896fe29Sbellard dead_temps[arg] = 1; 14049c43b68dSAurelien Jarno mem_temps[arg] = 0; 1405c896fe29Sbellard } 1406c896fe29Sbellard 1407c896fe29Sbellard /* if end of basic block, update */ 1408c896fe29Sbellard if (def->flags & TCG_OPF_BB_END) { 14099c43b68dSAurelien Jarno tcg_la_bb_end(s, dead_temps, mem_temps); 1410b03cce8eSbellard } else if (def->flags & TCG_OPF_CALL_CLOBBER) { 14119c43b68dSAurelien Jarno /* globals should go back to memory */ 14129c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_globals); 14139c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 1414c896fe29Sbellard } 1415c896fe29Sbellard 1416c896fe29Sbellard /* input args are live */ 1417866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 1418866cb6cbSAurelien Jarno arg = args[i]; 1419c896fe29Sbellard if (dead_temps[arg]) { 1420866cb6cbSAurelien Jarno dead_args |= (1 << i); 1421c896fe29Sbellard } 1422c896fe29Sbellard dead_temps[arg] = 0; 1423c896fe29Sbellard } 1424866cb6cbSAurelien Jarno s->op_dead_args[op_index] = dead_args; 1425ec7a869dSAurelien Jarno s->op_sync_args[op_index] = sync_args; 1426c896fe29Sbellard } 1427c896fe29Sbellard break; 1428c896fe29Sbellard } 1429c896fe29Sbellard op_index--; 1430c896fe29Sbellard } 1431c896fe29Sbellard 1432c896fe29Sbellard if (args != gen_opparam_buf) 1433c896fe29Sbellard tcg_abort(); 1434c896fe29Sbellard } 1435c896fe29Sbellard #else 1436c896fe29Sbellard /* dummy liveness analysis */ 1437655feed5Smalc static void tcg_liveness_analysis(TCGContext *s) 1438c896fe29Sbellard { 1439c896fe29Sbellard int nb_ops; 1440c896fe29Sbellard nb_ops = gen_opc_ptr - gen_opc_buf; 1441c896fe29Sbellard 1442866cb6cbSAurelien Jarno s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t)); 1443866cb6cbSAurelien Jarno memset(s->op_dead_args, 0, nb_ops * sizeof(uint16_t)); 1444ec7a869dSAurelien Jarno s->op_sync_args = tcg_malloc(nb_ops * sizeof(uint8_t)); 1445ec7a869dSAurelien Jarno memset(s->op_sync_args, 0, nb_ops * sizeof(uint8_t)); 1446c896fe29Sbellard } 1447c896fe29Sbellard #endif 1448c896fe29Sbellard 1449c896fe29Sbellard #ifndef NDEBUG 1450c896fe29Sbellard static void dump_regs(TCGContext *s) 1451c896fe29Sbellard { 1452c896fe29Sbellard TCGTemp *ts; 1453c896fe29Sbellard int i; 1454c896fe29Sbellard char buf[64]; 1455c896fe29Sbellard 1456c896fe29Sbellard for(i = 0; i < s->nb_temps; i++) { 1457c896fe29Sbellard ts = &s->temps[i]; 1458ac56dd48Spbrook printf(" %10s: ", tcg_get_arg_str_idx(s, buf, sizeof(buf), i)); 1459c896fe29Sbellard switch(ts->val_type) { 1460c896fe29Sbellard case TEMP_VAL_REG: 1461c896fe29Sbellard printf("%s", tcg_target_reg_names[ts->reg]); 1462c896fe29Sbellard break; 1463c896fe29Sbellard case TEMP_VAL_MEM: 1464c896fe29Sbellard printf("%d(%s)", (int)ts->mem_offset, tcg_target_reg_names[ts->mem_reg]); 1465c896fe29Sbellard break; 1466c896fe29Sbellard case TEMP_VAL_CONST: 1467c896fe29Sbellard printf("$0x%" TCG_PRIlx, ts->val); 1468c896fe29Sbellard break; 1469c896fe29Sbellard case TEMP_VAL_DEAD: 1470c896fe29Sbellard printf("D"); 1471c896fe29Sbellard break; 1472c896fe29Sbellard default: 1473c896fe29Sbellard printf("???"); 1474c896fe29Sbellard break; 1475c896fe29Sbellard } 1476c896fe29Sbellard printf("\n"); 1477c896fe29Sbellard } 1478c896fe29Sbellard 1479c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1480c896fe29Sbellard if (s->reg_to_temp[i] >= 0) { 1481c896fe29Sbellard printf("%s: %s\n", 1482c896fe29Sbellard tcg_target_reg_names[i], 1483ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), s->reg_to_temp[i])); 1484c896fe29Sbellard } 1485c896fe29Sbellard } 1486c896fe29Sbellard } 1487c896fe29Sbellard 1488c896fe29Sbellard static void check_regs(TCGContext *s) 1489c896fe29Sbellard { 1490c896fe29Sbellard int reg, k; 1491c896fe29Sbellard TCGTemp *ts; 1492c896fe29Sbellard char buf[64]; 1493c896fe29Sbellard 1494c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1495c896fe29Sbellard k = s->reg_to_temp[reg]; 1496c896fe29Sbellard if (k >= 0) { 1497c896fe29Sbellard ts = &s->temps[k]; 1498c896fe29Sbellard if (ts->val_type != TEMP_VAL_REG || 1499c896fe29Sbellard ts->reg != reg) { 1500c896fe29Sbellard printf("Inconsistency for register %s:\n", 1501c896fe29Sbellard tcg_target_reg_names[reg]); 1502b03cce8eSbellard goto fail; 1503c896fe29Sbellard } 1504c896fe29Sbellard } 1505c896fe29Sbellard } 1506c896fe29Sbellard for(k = 0; k < s->nb_temps; k++) { 1507c896fe29Sbellard ts = &s->temps[k]; 1508c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG && 1509c896fe29Sbellard !ts->fixed_reg && 1510c896fe29Sbellard s->reg_to_temp[ts->reg] != k) { 1511c896fe29Sbellard printf("Inconsistency for temp %s:\n", 1512ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), k)); 1513b03cce8eSbellard fail: 1514c896fe29Sbellard printf("reg state:\n"); 1515c896fe29Sbellard dump_regs(s); 1516c896fe29Sbellard tcg_abort(); 1517c896fe29Sbellard } 1518c896fe29Sbellard } 1519c896fe29Sbellard } 1520c896fe29Sbellard #endif 1521c896fe29Sbellard 1522c896fe29Sbellard static void temp_allocate_frame(TCGContext *s, int temp) 1523c896fe29Sbellard { 1524c896fe29Sbellard TCGTemp *ts; 1525c896fe29Sbellard ts = &s->temps[temp]; 15269b9c37c3SRichard Henderson #if !(defined(__sparc__) && TCG_TARGET_REG_BITS == 64) 15279b9c37c3SRichard Henderson /* Sparc64 stack is accessed with offset of 2047 */ 1528b591dc59SBlue Swirl s->current_frame_offset = (s->current_frame_offset + 1529b591dc59SBlue Swirl (tcg_target_long)sizeof(tcg_target_long) - 1) & 1530b591dc59SBlue Swirl ~(sizeof(tcg_target_long) - 1); 1531f44c9960SBlue Swirl #endif 1532b591dc59SBlue Swirl if (s->current_frame_offset + (tcg_target_long)sizeof(tcg_target_long) > 1533b591dc59SBlue Swirl s->frame_end) { 15345ff9d6a4Sbellard tcg_abort(); 1535b591dc59SBlue Swirl } 1536c896fe29Sbellard ts->mem_offset = s->current_frame_offset; 1537c896fe29Sbellard ts->mem_reg = s->frame_reg; 1538c896fe29Sbellard ts->mem_allocated = 1; 1539b591dc59SBlue Swirl s->current_frame_offset += (tcg_target_long)sizeof(tcg_target_long); 1540c896fe29Sbellard } 1541c896fe29Sbellard 15427f6ceedfSAurelien Jarno /* sync register 'reg' by saving it to the corresponding temporary */ 15437f6ceedfSAurelien Jarno static inline void tcg_reg_sync(TCGContext *s, int reg) 1544c896fe29Sbellard { 1545c896fe29Sbellard TCGTemp *ts; 1546c896fe29Sbellard int temp; 1547c896fe29Sbellard 1548c896fe29Sbellard temp = s->reg_to_temp[reg]; 1549c896fe29Sbellard ts = &s->temps[temp]; 1550c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 15517f6ceedfSAurelien Jarno if (!ts->mem_coherent && !ts->fixed_reg) { 15527f6ceedfSAurelien Jarno if (!ts->mem_allocated) { 1553c896fe29Sbellard temp_allocate_frame(s, temp); 15547f6ceedfSAurelien Jarno } 1555e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1556c896fe29Sbellard } 15577f6ceedfSAurelien Jarno ts->mem_coherent = 1; 15587f6ceedfSAurelien Jarno } 15597f6ceedfSAurelien Jarno 15607f6ceedfSAurelien Jarno /* free register 'reg' by spilling the corresponding temporary if necessary */ 15617f6ceedfSAurelien Jarno static void tcg_reg_free(TCGContext *s, int reg) 15627f6ceedfSAurelien Jarno { 15637f6ceedfSAurelien Jarno int temp; 15647f6ceedfSAurelien Jarno 15657f6ceedfSAurelien Jarno temp = s->reg_to_temp[reg]; 15667f6ceedfSAurelien Jarno if (temp != -1) { 15677f6ceedfSAurelien Jarno tcg_reg_sync(s, reg); 15687f6ceedfSAurelien Jarno s->temps[temp].val_type = TEMP_VAL_MEM; 1569c896fe29Sbellard s->reg_to_temp[reg] = -1; 1570c896fe29Sbellard } 1571c896fe29Sbellard } 1572c896fe29Sbellard 1573c896fe29Sbellard /* Allocate a register belonging to reg1 & ~reg2 */ 1574c896fe29Sbellard static int tcg_reg_alloc(TCGContext *s, TCGRegSet reg1, TCGRegSet reg2) 1575c896fe29Sbellard { 1576c896fe29Sbellard int i, reg; 1577c896fe29Sbellard TCGRegSet reg_ct; 1578c896fe29Sbellard 1579c896fe29Sbellard tcg_regset_andnot(reg_ct, reg1, reg2); 1580c896fe29Sbellard 1581c896fe29Sbellard /* first try free registers */ 15820954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1583c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1584c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg) && s->reg_to_temp[reg] == -1) 1585c896fe29Sbellard return reg; 1586c896fe29Sbellard } 1587c896fe29Sbellard 1588c896fe29Sbellard /* XXX: do better spill choice */ 15890954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1590c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1591c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg)) { 1592c896fe29Sbellard tcg_reg_free(s, reg); 1593c896fe29Sbellard return reg; 1594c896fe29Sbellard } 1595c896fe29Sbellard } 1596c896fe29Sbellard 1597c896fe29Sbellard tcg_abort(); 1598c896fe29Sbellard } 1599c896fe29Sbellard 1600639368ddSAurelien Jarno /* mark a temporary as dead. */ 1601639368ddSAurelien Jarno static inline void temp_dead(TCGContext *s, int temp) 1602639368ddSAurelien Jarno { 1603639368ddSAurelien Jarno TCGTemp *ts; 1604639368ddSAurelien Jarno 1605639368ddSAurelien Jarno ts = &s->temps[temp]; 1606639368ddSAurelien Jarno if (!ts->fixed_reg) { 1607639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 1608639368ddSAurelien Jarno s->reg_to_temp[ts->reg] = -1; 1609639368ddSAurelien Jarno } 1610639368ddSAurelien Jarno if (temp < s->nb_globals || (ts->temp_local && ts->mem_allocated)) { 1611639368ddSAurelien Jarno ts->val_type = TEMP_VAL_MEM; 1612639368ddSAurelien Jarno } else { 1613639368ddSAurelien Jarno ts->val_type = TEMP_VAL_DEAD; 1614639368ddSAurelien Jarno } 1615639368ddSAurelien Jarno } 1616639368ddSAurelien Jarno } 1617639368ddSAurelien Jarno 16181ad80729SAurelien Jarno /* sync a temporary to memory. 'allocated_regs' is used in case a 1619e8996ee0Sbellard temporary registers needs to be allocated to store a constant. */ 16201ad80729SAurelien Jarno static inline void temp_sync(TCGContext *s, int temp, TCGRegSet allocated_regs) 1621c896fe29Sbellard { 1622c896fe29Sbellard TCGTemp *ts; 1623c896fe29Sbellard 1624641d5fbeSbellard ts = &s->temps[temp]; 1625c896fe29Sbellard if (!ts->fixed_reg) { 1626e8996ee0Sbellard switch(ts->val_type) { 16271ad80729SAurelien Jarno case TEMP_VAL_CONST: 16281ad80729SAurelien Jarno ts->reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 16291ad80729SAurelien Jarno allocated_regs); 16301ad80729SAurelien Jarno ts->val_type = TEMP_VAL_REG; 16311ad80729SAurelien Jarno s->reg_to_temp[ts->reg] = temp; 16321ad80729SAurelien Jarno ts->mem_coherent = 0; 16331ad80729SAurelien Jarno tcg_out_movi(s, ts->type, ts->reg, ts->val); 16341ad80729SAurelien Jarno /* fallthrough*/ 1635e8996ee0Sbellard case TEMP_VAL_REG: 16361ad80729SAurelien Jarno tcg_reg_sync(s, ts->reg); 1637e8996ee0Sbellard break; 1638e8996ee0Sbellard case TEMP_VAL_DEAD: 1639e8996ee0Sbellard case TEMP_VAL_MEM: 1640e8996ee0Sbellard break; 1641e8996ee0Sbellard default: 1642e8996ee0Sbellard tcg_abort(); 1643c896fe29Sbellard } 1644c896fe29Sbellard } 1645c896fe29Sbellard } 1646641d5fbeSbellard 16471ad80729SAurelien Jarno /* save a temporary to memory. 'allocated_regs' is used in case a 16481ad80729SAurelien Jarno temporary registers needs to be allocated to store a constant. */ 16491ad80729SAurelien Jarno static inline void temp_save(TCGContext *s, int temp, TCGRegSet allocated_regs) 16501ad80729SAurelien Jarno { 16511ad80729SAurelien Jarno temp_sync(s, temp, allocated_regs); 16521ad80729SAurelien Jarno temp_dead(s, temp); 16531ad80729SAurelien Jarno } 16541ad80729SAurelien Jarno 16559814dd27SDong Xu Wang /* save globals to their canonical location and assume they can be 1656641d5fbeSbellard modified be the following code. 'allocated_regs' is used in case a 1657641d5fbeSbellard temporary registers needs to be allocated to store a constant. */ 1658641d5fbeSbellard static void save_globals(TCGContext *s, TCGRegSet allocated_regs) 1659641d5fbeSbellard { 1660641d5fbeSbellard int i; 1661641d5fbeSbellard 1662641d5fbeSbellard for(i = 0; i < s->nb_globals; i++) { 1663641d5fbeSbellard temp_save(s, i, allocated_regs); 1664641d5fbeSbellard } 1665e5097dc8Sbellard } 1666e5097dc8Sbellard 1667e5097dc8Sbellard /* at the end of a basic block, we assume all temporaries are dead and 1668e8996ee0Sbellard all globals are stored at their canonical location. */ 1669e8996ee0Sbellard static void tcg_reg_alloc_bb_end(TCGContext *s, TCGRegSet allocated_regs) 1670e5097dc8Sbellard { 1671e5097dc8Sbellard TCGTemp *ts; 1672e5097dc8Sbellard int i; 1673e5097dc8Sbellard 1674c896fe29Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 1675c896fe29Sbellard ts = &s->temps[i]; 1676641d5fbeSbellard if (ts->temp_local) { 1677641d5fbeSbellard temp_save(s, i, allocated_regs); 1678641d5fbeSbellard } else { 1679639368ddSAurelien Jarno temp_dead(s, i); 1680c896fe29Sbellard } 1681641d5fbeSbellard } 1682e8996ee0Sbellard 1683e8996ee0Sbellard save_globals(s, allocated_regs); 1684c896fe29Sbellard } 1685c896fe29Sbellard 1686866cb6cbSAurelien Jarno #define IS_DEAD_ARG(n) ((dead_args >> (n)) & 1) 1687ec7a869dSAurelien Jarno #define NEED_SYNC_ARG(n) ((sync_args >> (n)) & 1) 1688c896fe29Sbellard 1689ec7a869dSAurelien Jarno static void tcg_reg_alloc_movi(TCGContext *s, const TCGArg *args, 1690ec7a869dSAurelien Jarno uint16_t dead_args, uint8_t sync_args) 1691e8996ee0Sbellard { 1692e8996ee0Sbellard TCGTemp *ots; 1693e8996ee0Sbellard tcg_target_ulong val; 1694e8996ee0Sbellard 1695e8996ee0Sbellard ots = &s->temps[args[0]]; 1696e8996ee0Sbellard val = args[1]; 1697e8996ee0Sbellard 1698e8996ee0Sbellard if (ots->fixed_reg) { 1699e8996ee0Sbellard /* for fixed registers, we do not do any constant 1700e8996ee0Sbellard propagation */ 1701e8996ee0Sbellard tcg_out_movi(s, ots->type, ots->reg, val); 1702e8996ee0Sbellard } else { 17031235fc06Sths /* The movi is not explicitly generated here */ 1704e8996ee0Sbellard if (ots->val_type == TEMP_VAL_REG) 1705e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 1706e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 1707e8996ee0Sbellard ots->val = val; 1708e8996ee0Sbellard } 1709ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(0)) { 1710ec7a869dSAurelien Jarno temp_sync(s, args[0], s->reserved_regs); 1711ec7a869dSAurelien Jarno } 17124c4e1ab2SAurelien Jarno if (IS_DEAD_ARG(0)) { 17134c4e1ab2SAurelien Jarno temp_dead(s, args[0]); 17144c4e1ab2SAurelien Jarno } 1715e8996ee0Sbellard } 1716e8996ee0Sbellard 1717c896fe29Sbellard static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def, 1718ec7a869dSAurelien Jarno const TCGArg *args, uint16_t dead_args, 1719ec7a869dSAurelien Jarno uint8_t sync_args) 1720c896fe29Sbellard { 1721c29c1d7eSAurelien Jarno TCGRegSet allocated_regs; 1722c896fe29Sbellard TCGTemp *ts, *ots; 1723c29c1d7eSAurelien Jarno const TCGArgConstraint *arg_ct, *oarg_ct; 1724c896fe29Sbellard 1725c29c1d7eSAurelien Jarno tcg_regset_set(allocated_regs, s->reserved_regs); 1726c896fe29Sbellard ots = &s->temps[args[0]]; 1727c896fe29Sbellard ts = &s->temps[args[1]]; 1728c29c1d7eSAurelien Jarno oarg_ct = &def->args_ct[0]; 1729c29c1d7eSAurelien Jarno arg_ct = &def->args_ct[1]; 1730c896fe29Sbellard 1731c29c1d7eSAurelien Jarno /* If the source value is not in a register, and we're going to be 1732c29c1d7eSAurelien Jarno forced to have it in a register in order to perform the copy, 1733c29c1d7eSAurelien Jarno then copy the SOURCE value into its own register first. That way 1734c29c1d7eSAurelien Jarno we don't have to reload SOURCE the next time it is used. */ 1735c29c1d7eSAurelien Jarno if (((NEED_SYNC_ARG(0) || ots->fixed_reg) && ts->val_type != TEMP_VAL_REG) 1736c29c1d7eSAurelien Jarno || ts->val_type == TEMP_VAL_MEM) { 1737c29c1d7eSAurelien Jarno ts->reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1738c29c1d7eSAurelien Jarno if (ts->val_type == TEMP_VAL_MEM) { 1739c29c1d7eSAurelien Jarno tcg_out_ld(s, ts->type, ts->reg, ts->mem_reg, ts->mem_offset); 1740c29c1d7eSAurelien Jarno ts->mem_coherent = 1; 1741c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1742c29c1d7eSAurelien Jarno tcg_out_movi(s, ts->type, ts->reg, ts->val); 1743c29c1d7eSAurelien Jarno } 1744c29c1d7eSAurelien Jarno s->reg_to_temp[ts->reg] = args[1]; 1745c29c1d7eSAurelien Jarno ts->val_type = TEMP_VAL_REG; 1746c29c1d7eSAurelien Jarno } 1747c29c1d7eSAurelien Jarno 1748c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(0) && !ots->fixed_reg) { 1749c29c1d7eSAurelien Jarno /* mov to a non-saved dead register makes no sense (even with 1750c29c1d7eSAurelien Jarno liveness analysis disabled). */ 1751c29c1d7eSAurelien Jarno assert(NEED_SYNC_ARG(0)); 1752c29c1d7eSAurelien Jarno /* The code above should have moved the temp to a register. */ 1753c29c1d7eSAurelien Jarno assert(ts->val_type == TEMP_VAL_REG); 1754c29c1d7eSAurelien Jarno if (!ots->mem_allocated) { 1755c29c1d7eSAurelien Jarno temp_allocate_frame(s, args[0]); 1756c29c1d7eSAurelien Jarno } 1757c29c1d7eSAurelien Jarno tcg_out_st(s, ots->type, ts->reg, ots->mem_reg, ots->mem_offset); 1758c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(1)) { 1759c29c1d7eSAurelien Jarno temp_dead(s, args[1]); 1760c29c1d7eSAurelien Jarno } 1761c29c1d7eSAurelien Jarno temp_dead(s, args[0]); 1762c29c1d7eSAurelien Jarno } else if (ts->val_type == TEMP_VAL_CONST) { 1763e8996ee0Sbellard /* propagate constant */ 1764c29c1d7eSAurelien Jarno if (ots->val_type == TEMP_VAL_REG) { 1765e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 1766c29c1d7eSAurelien Jarno } 1767e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 1768e8996ee0Sbellard ots->val = ts->val; 1769e8996ee0Sbellard } else { 1770c29c1d7eSAurelien Jarno /* The code in the first if block should have moved the 1771c29c1d7eSAurelien Jarno temp to a register. */ 1772c29c1d7eSAurelien Jarno assert(ts->val_type == TEMP_VAL_REG); 1773c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(1) && !ts->fixed_reg && !ots->fixed_reg) { 1774c29c1d7eSAurelien Jarno /* the mov can be suppressed */ 1775c29c1d7eSAurelien Jarno if (ots->val_type == TEMP_VAL_REG) { 1776c29c1d7eSAurelien Jarno s->reg_to_temp[ots->reg] = -1; 1777c896fe29Sbellard } 1778c29c1d7eSAurelien Jarno ots->reg = ts->reg; 1779c29c1d7eSAurelien Jarno temp_dead(s, args[1]); 1780c29c1d7eSAurelien Jarno } else { 1781c29c1d7eSAurelien Jarno if (ots->val_type != TEMP_VAL_REG) { 1782c29c1d7eSAurelien Jarno /* When allocating a new register, make sure to not spill the 1783c29c1d7eSAurelien Jarno input one. */ 1784c29c1d7eSAurelien Jarno tcg_regset_set_reg(allocated_regs, ts->reg); 1785c29c1d7eSAurelien Jarno ots->reg = tcg_reg_alloc(s, oarg_ct->u.regs, allocated_regs); 1786c29c1d7eSAurelien Jarno } 1787c29c1d7eSAurelien Jarno tcg_out_mov(s, ots->type, ots->reg, ts->reg); 1788c29c1d7eSAurelien Jarno } 1789c896fe29Sbellard ots->val_type = TEMP_VAL_REG; 1790c896fe29Sbellard ots->mem_coherent = 0; 1791c29c1d7eSAurelien Jarno s->reg_to_temp[ots->reg] = args[0]; 1792ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(0)) { 1793c29c1d7eSAurelien Jarno tcg_reg_sync(s, ots->reg); 1794c29c1d7eSAurelien Jarno } 1795ec7a869dSAurelien Jarno } 1796c896fe29Sbellard } 1797c896fe29Sbellard 1798c896fe29Sbellard static void tcg_reg_alloc_op(TCGContext *s, 1799a9751609SRichard Henderson const TCGOpDef *def, TCGOpcode opc, 1800ec7a869dSAurelien Jarno const TCGArg *args, uint16_t dead_args, 1801ec7a869dSAurelien Jarno uint8_t sync_args) 1802c896fe29Sbellard { 1803c896fe29Sbellard TCGRegSet allocated_regs; 1804c896fe29Sbellard int i, k, nb_iargs, nb_oargs, reg; 1805c896fe29Sbellard TCGArg arg; 1806c896fe29Sbellard const TCGArgConstraint *arg_ct; 1807c896fe29Sbellard TCGTemp *ts; 1808c896fe29Sbellard TCGArg new_args[TCG_MAX_OP_ARGS]; 1809c896fe29Sbellard int const_args[TCG_MAX_OP_ARGS]; 1810c896fe29Sbellard 1811c896fe29Sbellard nb_oargs = def->nb_oargs; 1812c896fe29Sbellard nb_iargs = def->nb_iargs; 1813c896fe29Sbellard 1814c896fe29Sbellard /* copy constants */ 1815c896fe29Sbellard memcpy(new_args + nb_oargs + nb_iargs, 1816c896fe29Sbellard args + nb_oargs + nb_iargs, 1817c896fe29Sbellard sizeof(TCGArg) * def->nb_cargs); 1818c896fe29Sbellard 1819c896fe29Sbellard /* satisfy input constraints */ 1820c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 1821c896fe29Sbellard for(k = 0; k < nb_iargs; k++) { 1822c896fe29Sbellard i = def->sorted_args[nb_oargs + k]; 1823c896fe29Sbellard arg = args[i]; 1824c896fe29Sbellard arg_ct = &def->args_ct[i]; 1825c896fe29Sbellard ts = &s->temps[arg]; 1826c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 1827c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1828e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1829c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 1830c896fe29Sbellard ts->reg = reg; 1831c896fe29Sbellard ts->mem_coherent = 1; 1832c896fe29Sbellard s->reg_to_temp[reg] = arg; 1833c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1834c896fe29Sbellard if (tcg_target_const_match(ts->val, arg_ct)) { 1835c896fe29Sbellard /* constant is OK for instruction */ 1836c896fe29Sbellard const_args[i] = 1; 1837c896fe29Sbellard new_args[i] = ts->val; 1838c896fe29Sbellard goto iarg_end; 1839c896fe29Sbellard } else { 1840c896fe29Sbellard /* need to move to a register */ 1841c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1842c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1843e8996ee0Sbellard ts->val_type = TEMP_VAL_REG; 1844e8996ee0Sbellard ts->reg = reg; 1845e8996ee0Sbellard ts->mem_coherent = 0; 1846e8996ee0Sbellard s->reg_to_temp[reg] = arg; 1847c896fe29Sbellard } 1848c896fe29Sbellard } 1849c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 18505ff9d6a4Sbellard if (arg_ct->ct & TCG_CT_IALIAS) { 18515ff9d6a4Sbellard if (ts->fixed_reg) { 18525ff9d6a4Sbellard /* if fixed register, we must allocate a new register 18535ff9d6a4Sbellard if the alias is not the same register */ 18545ff9d6a4Sbellard if (arg != args[arg_ct->alias_index]) 18555ff9d6a4Sbellard goto allocate_in_reg; 18565ff9d6a4Sbellard } else { 1857c896fe29Sbellard /* if the input is aliased to an output and if it is 1858c896fe29Sbellard not dead after the instruction, we must allocate 1859c896fe29Sbellard a new register and move it */ 1860866cb6cbSAurelien Jarno if (!IS_DEAD_ARG(i)) { 1861c896fe29Sbellard goto allocate_in_reg; 1862c896fe29Sbellard } 18635ff9d6a4Sbellard } 1864866cb6cbSAurelien Jarno } 1865c896fe29Sbellard reg = ts->reg; 1866c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1867c896fe29Sbellard /* nothing to do : the constraint is satisfied */ 1868c896fe29Sbellard } else { 1869c896fe29Sbellard allocate_in_reg: 1870c896fe29Sbellard /* allocate a new register matching the constraint 1871c896fe29Sbellard and move the temporary register into it */ 1872c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 18733b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 1874c896fe29Sbellard } 1875c896fe29Sbellard new_args[i] = reg; 1876c896fe29Sbellard const_args[i] = 0; 1877c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 1878c896fe29Sbellard iarg_end: ; 1879c896fe29Sbellard } 1880c896fe29Sbellard 1881c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 1882866cb6cbSAurelien Jarno for (i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 1883866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 1884639368ddSAurelien Jarno temp_dead(s, args[i]); 1885c896fe29Sbellard } 1886c896fe29Sbellard } 1887c896fe29Sbellard 1888a52ad07eSAurelien Jarno if (def->flags & TCG_OPF_BB_END) { 1889a52ad07eSAurelien Jarno tcg_reg_alloc_bb_end(s, allocated_regs); 1890a52ad07eSAurelien Jarno } else { 1891c896fe29Sbellard if (def->flags & TCG_OPF_CALL_CLOBBER) { 1892b03cce8eSbellard /* XXX: permit generic clobber register list ? */ 1893c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1894c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 1895c896fe29Sbellard tcg_reg_free(s, reg); 1896c896fe29Sbellard } 1897c896fe29Sbellard } 1898b03cce8eSbellard /* XXX: for load/store we could do that only for the slow path 1899b03cce8eSbellard (i.e. when a memory callback is called) */ 1900b03cce8eSbellard 1901b03cce8eSbellard /* store globals and free associated registers (we assume the insn 1902b03cce8eSbellard can modify any global. */ 1903e8996ee0Sbellard save_globals(s, allocated_regs); 1904c896fe29Sbellard } 1905c896fe29Sbellard 1906c896fe29Sbellard /* satisfy the output constraints */ 1907c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 1908c896fe29Sbellard for(k = 0; k < nb_oargs; k++) { 1909c896fe29Sbellard i = def->sorted_args[k]; 1910c896fe29Sbellard arg = args[i]; 1911c896fe29Sbellard arg_ct = &def->args_ct[i]; 1912c896fe29Sbellard ts = &s->temps[arg]; 1913c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 19145ff9d6a4Sbellard reg = new_args[arg_ct->alias_index]; 1915c896fe29Sbellard } else { 1916c896fe29Sbellard /* if fixed register, we try to use it */ 1917c896fe29Sbellard reg = ts->reg; 1918c896fe29Sbellard if (ts->fixed_reg && 1919c896fe29Sbellard tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1920c896fe29Sbellard goto oarg_end; 1921c896fe29Sbellard } 1922c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1923c896fe29Sbellard } 1924c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 1925c896fe29Sbellard /* if a fixed register is used, then a move will be done afterwards */ 1926c896fe29Sbellard if (!ts->fixed_reg) { 1927639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 1928639368ddSAurelien Jarno s->reg_to_temp[ts->reg] = -1; 1929639368ddSAurelien Jarno } 1930c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 1931c896fe29Sbellard ts->reg = reg; 1932c896fe29Sbellard /* temp value is modified, so the value kept in memory is 1933c896fe29Sbellard potentially not the same */ 1934c896fe29Sbellard ts->mem_coherent = 0; 1935c896fe29Sbellard s->reg_to_temp[reg] = arg; 1936c896fe29Sbellard } 1937c896fe29Sbellard oarg_end: 1938c896fe29Sbellard new_args[i] = reg; 1939c896fe29Sbellard } 1940e8996ee0Sbellard } 1941c896fe29Sbellard 1942c896fe29Sbellard /* emit instruction */ 1943c896fe29Sbellard tcg_out_op(s, opc, new_args, const_args); 1944c896fe29Sbellard 1945c896fe29Sbellard /* move the outputs in the correct register if needed */ 1946c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1947c896fe29Sbellard ts = &s->temps[args[i]]; 1948c896fe29Sbellard reg = new_args[i]; 1949c896fe29Sbellard if (ts->fixed_reg && ts->reg != reg) { 19503b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 1951c896fe29Sbellard } 1952ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(i)) { 1953ec7a869dSAurelien Jarno tcg_reg_sync(s, reg); 1954ec7a869dSAurelien Jarno } 1955ec7a869dSAurelien Jarno if (IS_DEAD_ARG(i)) { 1956ec7a869dSAurelien Jarno temp_dead(s, args[i]); 1957ec7a869dSAurelien Jarno } 1958c896fe29Sbellard } 1959c896fe29Sbellard } 1960c896fe29Sbellard 1961b03cce8eSbellard #ifdef TCG_TARGET_STACK_GROWSUP 1962b03cce8eSbellard #define STACK_DIR(x) (-(x)) 1963b03cce8eSbellard #else 1964b03cce8eSbellard #define STACK_DIR(x) (x) 1965b03cce8eSbellard #endif 1966b03cce8eSbellard 1967c896fe29Sbellard static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def, 1968a9751609SRichard Henderson TCGOpcode opc, const TCGArg *args, 1969ec7a869dSAurelien Jarno uint16_t dead_args, uint8_t sync_args) 1970c896fe29Sbellard { 1971c896fe29Sbellard int nb_iargs, nb_oargs, flags, nb_regs, i, reg, nb_params; 1972c896fe29Sbellard TCGArg arg, func_arg; 1973c896fe29Sbellard TCGTemp *ts; 1974f54b3f92Saurel32 tcg_target_long stack_offset, call_stack_size, func_addr; 1975b03cce8eSbellard int const_func_arg, allocate_args; 1976c896fe29Sbellard TCGRegSet allocated_regs; 1977c896fe29Sbellard const TCGArgConstraint *arg_ct; 1978c896fe29Sbellard 1979c896fe29Sbellard arg = *args++; 1980c896fe29Sbellard 1981c896fe29Sbellard nb_oargs = arg >> 16; 1982c896fe29Sbellard nb_iargs = arg & 0xffff; 1983c896fe29Sbellard nb_params = nb_iargs - 1; 1984c896fe29Sbellard 1985c896fe29Sbellard flags = args[nb_oargs + nb_iargs]; 1986c896fe29Sbellard 19876e17d0c5SStefan Weil nb_regs = ARRAY_SIZE(tcg_target_call_iarg_regs); 1988c896fe29Sbellard if (nb_regs > nb_params) 1989c896fe29Sbellard nb_regs = nb_params; 1990c896fe29Sbellard 1991c896fe29Sbellard /* assign stack slots first */ 1992c896fe29Sbellard call_stack_size = (nb_params - nb_regs) * sizeof(tcg_target_long); 1993c896fe29Sbellard call_stack_size = (call_stack_size + TCG_TARGET_STACK_ALIGN - 1) & 1994c896fe29Sbellard ~(TCG_TARGET_STACK_ALIGN - 1); 1995b03cce8eSbellard allocate_args = (call_stack_size > TCG_STATIC_CALL_ARGS_SIZE); 1996b03cce8eSbellard if (allocate_args) { 1997345649c0SBlue Swirl /* XXX: if more than TCG_STATIC_CALL_ARGS_SIZE is needed, 1998345649c0SBlue Swirl preallocate call stack */ 1999345649c0SBlue Swirl tcg_abort(); 2000b03cce8eSbellard } 200139cf05d3Sbellard 200239cf05d3Sbellard stack_offset = TCG_TARGET_CALL_STACK_OFFSET; 2003c896fe29Sbellard for(i = nb_regs; i < nb_params; i++) { 2004c896fe29Sbellard arg = args[nb_oargs + i]; 200539cf05d3Sbellard #ifdef TCG_TARGET_STACK_GROWSUP 200639cf05d3Sbellard stack_offset -= sizeof(tcg_target_long); 200739cf05d3Sbellard #endif 200839cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 2009c896fe29Sbellard ts = &s->temps[arg]; 2010c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 2011e4d5434cSblueswir1 tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset); 2012c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 2013c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 2014c896fe29Sbellard s->reserved_regs); 2015c896fe29Sbellard /* XXX: not correct if reading values from the stack */ 2016e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2017e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 2018c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2019c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 2020c896fe29Sbellard s->reserved_regs); 2021c896fe29Sbellard /* XXX: sign extend may be needed on some targets */ 2022c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 2023e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 2024c896fe29Sbellard } else { 2025c896fe29Sbellard tcg_abort(); 2026c896fe29Sbellard } 202739cf05d3Sbellard } 202839cf05d3Sbellard #ifndef TCG_TARGET_STACK_GROWSUP 202939cf05d3Sbellard stack_offset += sizeof(tcg_target_long); 203039cf05d3Sbellard #endif 2031c896fe29Sbellard } 2032c896fe29Sbellard 2033c896fe29Sbellard /* assign input registers */ 2034c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 2035c896fe29Sbellard for(i = 0; i < nb_regs; i++) { 2036c896fe29Sbellard arg = args[nb_oargs + i]; 203739cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 2038c896fe29Sbellard ts = &s->temps[arg]; 2039c896fe29Sbellard reg = tcg_target_call_iarg_regs[i]; 2040c896fe29Sbellard tcg_reg_free(s, reg); 2041c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 2042c896fe29Sbellard if (ts->reg != reg) { 20433b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 2044c896fe29Sbellard } 2045c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 2046e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2047c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2048c896fe29Sbellard /* XXX: sign extend ? */ 2049c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 2050c896fe29Sbellard } else { 2051c896fe29Sbellard tcg_abort(); 2052c896fe29Sbellard } 2053c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 2054c896fe29Sbellard } 205539cf05d3Sbellard } 2056c896fe29Sbellard 2057c896fe29Sbellard /* assign function address */ 2058c896fe29Sbellard func_arg = args[nb_oargs + nb_iargs - 1]; 2059c896fe29Sbellard arg_ct = &def->args_ct[0]; 2060c896fe29Sbellard ts = &s->temps[func_arg]; 2061f54b3f92Saurel32 func_addr = ts->val; 2062c896fe29Sbellard const_func_arg = 0; 2063c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 2064c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2065e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2066c896fe29Sbellard func_arg = reg; 2067e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 2068c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_REG) { 2069c896fe29Sbellard reg = ts->reg; 2070c896fe29Sbellard if (!tcg_regset_test_reg(arg_ct->u.regs, reg)) { 2071c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 20723b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 2073c896fe29Sbellard } 2074c896fe29Sbellard func_arg = reg; 2075e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 2076c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2077f54b3f92Saurel32 if (tcg_target_const_match(func_addr, arg_ct)) { 2078c896fe29Sbellard const_func_arg = 1; 2079f54b3f92Saurel32 func_arg = func_addr; 2080c896fe29Sbellard } else { 2081c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2082f54b3f92Saurel32 tcg_out_movi(s, ts->type, reg, func_addr); 2083c896fe29Sbellard func_arg = reg; 2084e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 2085c896fe29Sbellard } 2086c896fe29Sbellard } else { 2087c896fe29Sbellard tcg_abort(); 2088c896fe29Sbellard } 2089c896fe29Sbellard 2090e8996ee0Sbellard 2091c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 2092866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 2093866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 2094639368ddSAurelien Jarno temp_dead(s, args[i]); 2095c896fe29Sbellard } 2096c896fe29Sbellard } 2097c896fe29Sbellard 2098c896fe29Sbellard /* clobber call registers */ 2099c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 2100c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 2101c896fe29Sbellard tcg_reg_free(s, reg); 2102c896fe29Sbellard } 2103c896fe29Sbellard } 2104c896fe29Sbellard 2105c896fe29Sbellard /* store globals and free associated registers (we assume the call 2106c896fe29Sbellard can modify any global. */ 2107b9c18f56Saurel32 if (!(flags & TCG_CALL_CONST)) { 2108e8996ee0Sbellard save_globals(s, allocated_regs); 2109b9c18f56Saurel32 } 2110c896fe29Sbellard 2111c896fe29Sbellard tcg_out_op(s, opc, &func_arg, &const_func_arg); 2112c896fe29Sbellard 2113c896fe29Sbellard /* assign output registers and emit moves if needed */ 2114c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 2115c896fe29Sbellard arg = args[i]; 2116c896fe29Sbellard ts = &s->temps[arg]; 2117c896fe29Sbellard reg = tcg_target_call_oarg_regs[i]; 2118e8996ee0Sbellard assert(s->reg_to_temp[reg] == -1); 2119c896fe29Sbellard if (ts->fixed_reg) { 2120c896fe29Sbellard if (ts->reg != reg) { 21213b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 2122c896fe29Sbellard } 2123c896fe29Sbellard } else { 2124639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 2125639368ddSAurelien Jarno s->reg_to_temp[ts->reg] = -1; 2126639368ddSAurelien Jarno } 2127c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 2128c896fe29Sbellard ts->reg = reg; 2129c896fe29Sbellard ts->mem_coherent = 0; 2130c896fe29Sbellard s->reg_to_temp[reg] = arg; 2131ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(i)) { 2132ec7a869dSAurelien Jarno tcg_reg_sync(s, reg); 2133ec7a869dSAurelien Jarno } 2134ec7a869dSAurelien Jarno if (IS_DEAD_ARG(i)) { 2135ec7a869dSAurelien Jarno temp_dead(s, args[i]); 2136c896fe29Sbellard } 2137c896fe29Sbellard } 21388c11ad25SAurelien Jarno } 2139c896fe29Sbellard 2140c896fe29Sbellard return nb_iargs + nb_oargs + def->nb_cargs + 1; 2141c896fe29Sbellard } 2142c896fe29Sbellard 2143c896fe29Sbellard #ifdef CONFIG_PROFILER 2144c896fe29Sbellard 214554604f74Saurel32 static int64_t tcg_table_op_count[NB_OPS]; 2146c896fe29Sbellard 2147871e6c35SBlue Swirl static void dump_op_count(void) 2148c896fe29Sbellard { 2149c896fe29Sbellard int i; 2150c896fe29Sbellard FILE *f; 215154604f74Saurel32 f = fopen("/tmp/op.log", "w"); 2152c896fe29Sbellard for(i = INDEX_op_end; i < NB_OPS; i++) { 215354604f74Saurel32 fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, tcg_table_op_count[i]); 2154c896fe29Sbellard } 2155c896fe29Sbellard fclose(f); 2156c896fe29Sbellard } 2157c896fe29Sbellard #endif 2158c896fe29Sbellard 2159c896fe29Sbellard 2160c896fe29Sbellard static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf, 21612ba1eeb6Spbrook long search_pc) 2162c896fe29Sbellard { 2163a9751609SRichard Henderson TCGOpcode opc; 2164a9751609SRichard Henderson int op_index; 2165c896fe29Sbellard const TCGOpDef *def; 2166c896fe29Sbellard const TCGArg *args; 2167c896fe29Sbellard 2168c896fe29Sbellard #ifdef DEBUG_DISAS 21698fec2b8cSaliguori if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) { 217093fcfe39Saliguori qemu_log("OP:\n"); 2171eeacee4dSBlue Swirl tcg_dump_ops(s); 217293fcfe39Saliguori qemu_log("\n"); 2173c896fe29Sbellard } 2174c896fe29Sbellard #endif 2175c896fe29Sbellard 2176c5cc28ffSAurelien Jarno #ifdef CONFIG_PROFILER 2177c5cc28ffSAurelien Jarno s->opt_time -= profile_getclock(); 2178c5cc28ffSAurelien Jarno #endif 2179c5cc28ffSAurelien Jarno 21808f2e8c07SKirill Batuzov #ifdef USE_TCG_OPTIMIZATIONS 21818f2e8c07SKirill Batuzov gen_opparam_ptr = 21828f2e8c07SKirill Batuzov tcg_optimize(s, gen_opc_ptr, gen_opparam_buf, tcg_op_defs); 21838f2e8c07SKirill Batuzov #endif 21848f2e8c07SKirill Batuzov 2185a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2186c5cc28ffSAurelien Jarno s->opt_time += profile_getclock(); 2187a23a9ec6Sbellard s->la_time -= profile_getclock(); 2188a23a9ec6Sbellard #endif 2189c5cc28ffSAurelien Jarno 2190c896fe29Sbellard tcg_liveness_analysis(s); 2191c5cc28ffSAurelien Jarno 2192a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2193a23a9ec6Sbellard s->la_time += profile_getclock(); 2194a23a9ec6Sbellard #endif 2195c896fe29Sbellard 2196c896fe29Sbellard #ifdef DEBUG_DISAS 21978fec2b8cSaliguori if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT))) { 2198c5cc28ffSAurelien Jarno qemu_log("OP after optimization and liveness analysis:\n"); 2199eeacee4dSBlue Swirl tcg_dump_ops(s); 220093fcfe39Saliguori qemu_log("\n"); 2201c896fe29Sbellard } 2202c896fe29Sbellard #endif 2203c896fe29Sbellard 2204c896fe29Sbellard tcg_reg_alloc_start(s); 2205c896fe29Sbellard 2206c896fe29Sbellard s->code_buf = gen_code_buf; 2207c896fe29Sbellard s->code_ptr = gen_code_buf; 2208c896fe29Sbellard 2209c896fe29Sbellard args = gen_opparam_buf; 2210c896fe29Sbellard op_index = 0; 2211b3db8758Sblueswir1 2212c896fe29Sbellard for(;;) { 2213c896fe29Sbellard opc = gen_opc_buf[op_index]; 2214c896fe29Sbellard #ifdef CONFIG_PROFILER 221554604f74Saurel32 tcg_table_op_count[opc]++; 2216c896fe29Sbellard #endif 2217c896fe29Sbellard def = &tcg_op_defs[opc]; 2218c896fe29Sbellard #if 0 2219c896fe29Sbellard printf("%s: %d %d %d\n", def->name, 2220c896fe29Sbellard def->nb_oargs, def->nb_iargs, def->nb_cargs); 2221c896fe29Sbellard // dump_regs(s); 2222c896fe29Sbellard #endif 2223c896fe29Sbellard switch(opc) { 2224c896fe29Sbellard case INDEX_op_mov_i32: 2225c896fe29Sbellard case INDEX_op_mov_i64: 2226ec7a869dSAurelien Jarno tcg_reg_alloc_mov(s, def, args, s->op_dead_args[op_index], 2227ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2228c896fe29Sbellard break; 2229e8996ee0Sbellard case INDEX_op_movi_i32: 2230e8996ee0Sbellard case INDEX_op_movi_i64: 2231ec7a869dSAurelien Jarno tcg_reg_alloc_movi(s, args, s->op_dead_args[op_index], 2232ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2233e8996ee0Sbellard break; 22347e4597d7Sbellard case INDEX_op_debug_insn_start: 22357e4597d7Sbellard /* debug instruction */ 22367e4597d7Sbellard break; 2237c896fe29Sbellard case INDEX_op_nop: 2238c896fe29Sbellard case INDEX_op_nop1: 2239c896fe29Sbellard case INDEX_op_nop2: 2240c896fe29Sbellard case INDEX_op_nop3: 2241c896fe29Sbellard break; 2242c896fe29Sbellard case INDEX_op_nopn: 2243c896fe29Sbellard args += args[0]; 2244c896fe29Sbellard goto next; 22455ff9d6a4Sbellard case INDEX_op_discard: 2246639368ddSAurelien Jarno temp_dead(s, args[0]); 22475ff9d6a4Sbellard break; 2248c896fe29Sbellard case INDEX_op_set_label: 2249e8996ee0Sbellard tcg_reg_alloc_bb_end(s, s->reserved_regs); 22509d6fca70SStefan Weil tcg_out_label(s, args[0], s->code_ptr); 2251c896fe29Sbellard break; 2252c896fe29Sbellard case INDEX_op_call: 2253ec7a869dSAurelien Jarno args += tcg_reg_alloc_call(s, def, opc, args, 2254ec7a869dSAurelien Jarno s->op_dead_args[op_index], 2255ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2256c896fe29Sbellard goto next; 2257c896fe29Sbellard case INDEX_op_end: 2258c896fe29Sbellard goto the_end; 2259c896fe29Sbellard default: 226025c4d9ccSRichard Henderson /* Sanity check that we've not introduced any unhandled opcodes. */ 226125c4d9ccSRichard Henderson if (def->flags & TCG_OPF_NOT_PRESENT) { 226225c4d9ccSRichard Henderson tcg_abort(); 226325c4d9ccSRichard Henderson } 2264c896fe29Sbellard /* Note: in order to speed up the code, it would be much 2265c896fe29Sbellard faster to have specialized register allocator functions for 2266c896fe29Sbellard some common argument patterns */ 2267ec7a869dSAurelien Jarno tcg_reg_alloc_op(s, def, opc, args, s->op_dead_args[op_index], 2268ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2269c896fe29Sbellard break; 2270c896fe29Sbellard } 2271c896fe29Sbellard args += def->nb_args; 22728df1ca4bSths next: 22732ba1eeb6Spbrook if (search_pc >= 0 && search_pc < s->code_ptr - gen_code_buf) { 2274c896fe29Sbellard return op_index; 2275c896fe29Sbellard } 2276c896fe29Sbellard op_index++; 2277c896fe29Sbellard #ifndef NDEBUG 2278c896fe29Sbellard check_regs(s); 2279c896fe29Sbellard #endif 2280c896fe29Sbellard } 2281c896fe29Sbellard the_end: 2282c896fe29Sbellard return -1; 2283c896fe29Sbellard } 2284c896fe29Sbellard 228554604f74Saurel32 int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf) 2286c896fe29Sbellard { 2287c896fe29Sbellard #ifdef CONFIG_PROFILER 2288c896fe29Sbellard { 2289c896fe29Sbellard int n; 2290c896fe29Sbellard n = (gen_opc_ptr - gen_opc_buf); 2291a23a9ec6Sbellard s->op_count += n; 2292a23a9ec6Sbellard if (n > s->op_count_max) 2293a23a9ec6Sbellard s->op_count_max = n; 2294a23a9ec6Sbellard 2295a23a9ec6Sbellard s->temp_count += s->nb_temps; 2296a23a9ec6Sbellard if (s->nb_temps > s->temp_count_max) 2297a23a9ec6Sbellard s->temp_count_max = s->nb_temps; 2298c896fe29Sbellard } 2299c896fe29Sbellard #endif 2300c896fe29Sbellard 23012ba1eeb6Spbrook tcg_gen_code_common(s, gen_code_buf, -1); 2302c896fe29Sbellard 2303c896fe29Sbellard /* flush instruction cache */ 23042aeabc08SStefan Weil flush_icache_range((tcg_target_ulong)gen_code_buf, 23052aeabc08SStefan Weil (tcg_target_ulong)s->code_ptr); 23062aeabc08SStefan Weil 2307c896fe29Sbellard return s->code_ptr - gen_code_buf; 2308c896fe29Sbellard } 2309c896fe29Sbellard 23102ba1eeb6Spbrook /* Return the index of the micro operation such as the pc after is < 2311623e265cSpbrook offset bytes from the start of the TB. The contents of gen_code_buf must 2312623e265cSpbrook not be changed, though writing the same values is ok. 2313623e265cSpbrook Return -1 if not found. */ 231454604f74Saurel32 int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset) 2315c896fe29Sbellard { 2316623e265cSpbrook return tcg_gen_code_common(s, gen_code_buf, offset); 2317c896fe29Sbellard } 2318a23a9ec6Sbellard 2319a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2320405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2321a23a9ec6Sbellard { 2322a23a9ec6Sbellard TCGContext *s = &tcg_ctx; 2323a23a9ec6Sbellard int64_t tot; 2324a23a9ec6Sbellard 2325a23a9ec6Sbellard tot = s->interm_time + s->code_time; 2326a23a9ec6Sbellard cpu_fprintf(f, "JIT cycles %" PRId64 " (%0.3f s at 2.4 GHz)\n", 2327a23a9ec6Sbellard tot, tot / 2.4e9); 2328a23a9ec6Sbellard cpu_fprintf(f, "translated TBs %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n", 2329a23a9ec6Sbellard s->tb_count, 2330a23a9ec6Sbellard s->tb_count1 - s->tb_count, 2331a23a9ec6Sbellard s->tb_count1 ? (double)(s->tb_count1 - s->tb_count) / s->tb_count1 * 100.0 : 0); 2332a23a9ec6Sbellard cpu_fprintf(f, "avg ops/TB %0.1f max=%d\n", 2333a23a9ec6Sbellard s->tb_count ? (double)s->op_count / s->tb_count : 0, s->op_count_max); 2334a23a9ec6Sbellard cpu_fprintf(f, "deleted ops/TB %0.2f\n", 2335a23a9ec6Sbellard s->tb_count ? 2336a23a9ec6Sbellard (double)s->del_op_count / s->tb_count : 0); 2337a23a9ec6Sbellard cpu_fprintf(f, "avg temps/TB %0.2f max=%d\n", 2338a23a9ec6Sbellard s->tb_count ? 2339a23a9ec6Sbellard (double)s->temp_count / s->tb_count : 0, 2340a23a9ec6Sbellard s->temp_count_max); 2341a23a9ec6Sbellard 2342a23a9ec6Sbellard cpu_fprintf(f, "cycles/op %0.1f\n", 2343a23a9ec6Sbellard s->op_count ? (double)tot / s->op_count : 0); 2344a23a9ec6Sbellard cpu_fprintf(f, "cycles/in byte %0.1f\n", 2345a23a9ec6Sbellard s->code_in_len ? (double)tot / s->code_in_len : 0); 2346a23a9ec6Sbellard cpu_fprintf(f, "cycles/out byte %0.1f\n", 2347a23a9ec6Sbellard s->code_out_len ? (double)tot / s->code_out_len : 0); 2348a23a9ec6Sbellard if (tot == 0) 2349a23a9ec6Sbellard tot = 1; 2350a23a9ec6Sbellard cpu_fprintf(f, " gen_interm time %0.1f%%\n", 2351a23a9ec6Sbellard (double)s->interm_time / tot * 100.0); 2352a23a9ec6Sbellard cpu_fprintf(f, " gen_code time %0.1f%%\n", 2353a23a9ec6Sbellard (double)s->code_time / tot * 100.0); 2354c5cc28ffSAurelien Jarno cpu_fprintf(f, "optim./code time %0.1f%%\n", 2355c5cc28ffSAurelien Jarno (double)s->opt_time / (s->code_time ? s->code_time : 1) 2356c5cc28ffSAurelien Jarno * 100.0); 2357a23a9ec6Sbellard cpu_fprintf(f, "liveness/code time %0.1f%%\n", 2358a23a9ec6Sbellard (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0); 2359a23a9ec6Sbellard cpu_fprintf(f, "cpu_restore count %" PRId64 "\n", 2360a23a9ec6Sbellard s->restore_count); 2361a23a9ec6Sbellard cpu_fprintf(f, " avg cycles %0.1f\n", 2362a23a9ec6Sbellard s->restore_count ? (double)s->restore_time / s->restore_count : 0); 2363871e6c35SBlue Swirl 2364a23a9ec6Sbellard dump_op_count(); 2365a23a9ec6Sbellard } 2366a23a9ec6Sbellard #else 2367405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2368a23a9ec6Sbellard { 236924bf7b3aSbellard cpu_fprintf(f, "[TCG profiler not compiled]\n"); 2370a23a9ec6Sbellard } 2371a23a9ec6Sbellard #endif 2372813da627SRichard Henderson 2373813da627SRichard Henderson #ifdef ELF_HOST_MACHINE 23745872bbf2SRichard Henderson /* In order to use this feature, the backend needs to do three things: 23755872bbf2SRichard Henderson 23765872bbf2SRichard Henderson (1) Define ELF_HOST_MACHINE to indicate both what value to 23775872bbf2SRichard Henderson put into the ELF image and to indicate support for the feature. 23785872bbf2SRichard Henderson 23795872bbf2SRichard Henderson (2) Define tcg_register_jit. This should create a buffer containing 23805872bbf2SRichard Henderson the contents of a .debug_frame section that describes the post- 23815872bbf2SRichard Henderson prologue unwind info for the tcg machine. 23825872bbf2SRichard Henderson 23835872bbf2SRichard Henderson (3) Call tcg_register_jit_int, with the constructed .debug_frame. 23845872bbf2SRichard Henderson */ 2385813da627SRichard Henderson 2386813da627SRichard Henderson /* Begin GDB interface. THE FOLLOWING MUST MATCH GDB DOCS. */ 2387813da627SRichard Henderson typedef enum { 2388813da627SRichard Henderson JIT_NOACTION = 0, 2389813da627SRichard Henderson JIT_REGISTER_FN, 2390813da627SRichard Henderson JIT_UNREGISTER_FN 2391813da627SRichard Henderson } jit_actions_t; 2392813da627SRichard Henderson 2393813da627SRichard Henderson struct jit_code_entry { 2394813da627SRichard Henderson struct jit_code_entry *next_entry; 2395813da627SRichard Henderson struct jit_code_entry *prev_entry; 2396813da627SRichard Henderson const void *symfile_addr; 2397813da627SRichard Henderson uint64_t symfile_size; 2398813da627SRichard Henderson }; 2399813da627SRichard Henderson 2400813da627SRichard Henderson struct jit_descriptor { 2401813da627SRichard Henderson uint32_t version; 2402813da627SRichard Henderson uint32_t action_flag; 2403813da627SRichard Henderson struct jit_code_entry *relevant_entry; 2404813da627SRichard Henderson struct jit_code_entry *first_entry; 2405813da627SRichard Henderson }; 2406813da627SRichard Henderson 2407813da627SRichard Henderson void __jit_debug_register_code(void) __attribute__((noinline)); 2408813da627SRichard Henderson void __jit_debug_register_code(void) 2409813da627SRichard Henderson { 2410813da627SRichard Henderson asm(""); 2411813da627SRichard Henderson } 2412813da627SRichard Henderson 2413813da627SRichard Henderson /* Must statically initialize the version, because GDB may check 2414813da627SRichard Henderson the version before we can set it. */ 2415813da627SRichard Henderson struct jit_descriptor __jit_debug_descriptor = { 1, 0, 0, 0 }; 2416813da627SRichard Henderson 2417813da627SRichard Henderson /* End GDB interface. */ 2418813da627SRichard Henderson 2419813da627SRichard Henderson static int find_string(const char *strtab, const char *str) 2420813da627SRichard Henderson { 2421813da627SRichard Henderson const char *p = strtab + 1; 2422813da627SRichard Henderson 2423813da627SRichard Henderson while (1) { 2424813da627SRichard Henderson if (strcmp(p, str) == 0) { 2425813da627SRichard Henderson return p - strtab; 2426813da627SRichard Henderson } 2427813da627SRichard Henderson p += strlen(p) + 1; 2428813da627SRichard Henderson } 2429813da627SRichard Henderson } 2430813da627SRichard Henderson 24315872bbf2SRichard Henderson static void tcg_register_jit_int(void *buf_ptr, size_t buf_size, 2432813da627SRichard Henderson void *debug_frame, size_t debug_frame_size) 2433813da627SRichard Henderson { 24345872bbf2SRichard Henderson struct __attribute__((packed)) DebugInfo { 24355872bbf2SRichard Henderson uint32_t len; 24365872bbf2SRichard Henderson uint16_t version; 24375872bbf2SRichard Henderson uint32_t abbrev; 24385872bbf2SRichard Henderson uint8_t ptr_size; 24395872bbf2SRichard Henderson uint8_t cu_die; 24405872bbf2SRichard Henderson uint16_t cu_lang; 24415872bbf2SRichard Henderson uintptr_t cu_low_pc; 24425872bbf2SRichard Henderson uintptr_t cu_high_pc; 24435872bbf2SRichard Henderson uint8_t fn_die; 24445872bbf2SRichard Henderson char fn_name[16]; 24455872bbf2SRichard Henderson uintptr_t fn_low_pc; 24465872bbf2SRichard Henderson uintptr_t fn_high_pc; 24475872bbf2SRichard Henderson uint8_t cu_eoc; 24485872bbf2SRichard Henderson }; 2449813da627SRichard Henderson 2450813da627SRichard Henderson struct ElfImage { 2451813da627SRichard Henderson ElfW(Ehdr) ehdr; 2452813da627SRichard Henderson ElfW(Phdr) phdr; 24535872bbf2SRichard Henderson ElfW(Shdr) shdr[7]; 24545872bbf2SRichard Henderson ElfW(Sym) sym[2]; 24555872bbf2SRichard Henderson struct DebugInfo di; 24565872bbf2SRichard Henderson uint8_t da[24]; 24575872bbf2SRichard Henderson char str[80]; 24585872bbf2SRichard Henderson }; 24595872bbf2SRichard Henderson 24605872bbf2SRichard Henderson struct ElfImage *img; 24615872bbf2SRichard Henderson 24625872bbf2SRichard Henderson static const struct ElfImage img_template = { 24635872bbf2SRichard Henderson .ehdr = { 24645872bbf2SRichard Henderson .e_ident[EI_MAG0] = ELFMAG0, 24655872bbf2SRichard Henderson .e_ident[EI_MAG1] = ELFMAG1, 24665872bbf2SRichard Henderson .e_ident[EI_MAG2] = ELFMAG2, 24675872bbf2SRichard Henderson .e_ident[EI_MAG3] = ELFMAG3, 24685872bbf2SRichard Henderson .e_ident[EI_CLASS] = ELF_CLASS, 24695872bbf2SRichard Henderson .e_ident[EI_DATA] = ELF_DATA, 24705872bbf2SRichard Henderson .e_ident[EI_VERSION] = EV_CURRENT, 24715872bbf2SRichard Henderson .e_type = ET_EXEC, 24725872bbf2SRichard Henderson .e_machine = ELF_HOST_MACHINE, 24735872bbf2SRichard Henderson .e_version = EV_CURRENT, 24745872bbf2SRichard Henderson .e_phoff = offsetof(struct ElfImage, phdr), 24755872bbf2SRichard Henderson .e_shoff = offsetof(struct ElfImage, shdr), 24765872bbf2SRichard Henderson .e_ehsize = sizeof(ElfW(Shdr)), 24775872bbf2SRichard Henderson .e_phentsize = sizeof(ElfW(Phdr)), 24785872bbf2SRichard Henderson .e_phnum = 1, 24795872bbf2SRichard Henderson .e_shentsize = sizeof(ElfW(Shdr)), 24805872bbf2SRichard Henderson .e_shnum = ARRAY_SIZE(img->shdr), 24815872bbf2SRichard Henderson .e_shstrndx = ARRAY_SIZE(img->shdr) - 1, 2482abbb3eaeSRichard Henderson #ifdef ELF_HOST_FLAGS 2483abbb3eaeSRichard Henderson .e_flags = ELF_HOST_FLAGS, 2484abbb3eaeSRichard Henderson #endif 2485abbb3eaeSRichard Henderson #ifdef ELF_OSABI 2486abbb3eaeSRichard Henderson .e_ident[EI_OSABI] = ELF_OSABI, 2487abbb3eaeSRichard Henderson #endif 24885872bbf2SRichard Henderson }, 24895872bbf2SRichard Henderson .phdr = { 24905872bbf2SRichard Henderson .p_type = PT_LOAD, 24915872bbf2SRichard Henderson .p_flags = PF_X, 24925872bbf2SRichard Henderson }, 24935872bbf2SRichard Henderson .shdr = { 24945872bbf2SRichard Henderson [0] = { .sh_type = SHT_NULL }, 24955872bbf2SRichard Henderson /* Trick: The contents of code_gen_buffer are not present in 24965872bbf2SRichard Henderson this fake ELF file; that got allocated elsewhere. Therefore 24975872bbf2SRichard Henderson we mark .text as SHT_NOBITS (similar to .bss) so that readers 24985872bbf2SRichard Henderson will not look for contents. We can record any address. */ 24995872bbf2SRichard Henderson [1] = { /* .text */ 25005872bbf2SRichard Henderson .sh_type = SHT_NOBITS, 25015872bbf2SRichard Henderson .sh_flags = SHF_EXECINSTR | SHF_ALLOC, 25025872bbf2SRichard Henderson }, 25035872bbf2SRichard Henderson [2] = { /* .debug_info */ 25045872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 25055872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, di), 25065872bbf2SRichard Henderson .sh_size = sizeof(struct DebugInfo), 25075872bbf2SRichard Henderson }, 25085872bbf2SRichard Henderson [3] = { /* .debug_abbrev */ 25095872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 25105872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, da), 25115872bbf2SRichard Henderson .sh_size = sizeof(img->da), 25125872bbf2SRichard Henderson }, 25135872bbf2SRichard Henderson [4] = { /* .debug_frame */ 25145872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 25155872bbf2SRichard Henderson .sh_offset = sizeof(struct ElfImage), 25165872bbf2SRichard Henderson }, 25175872bbf2SRichard Henderson [5] = { /* .symtab */ 25185872bbf2SRichard Henderson .sh_type = SHT_SYMTAB, 25195872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, sym), 25205872bbf2SRichard Henderson .sh_size = sizeof(img->sym), 25215872bbf2SRichard Henderson .sh_info = 1, 25225872bbf2SRichard Henderson .sh_link = ARRAY_SIZE(img->shdr) - 1, 25235872bbf2SRichard Henderson .sh_entsize = sizeof(ElfW(Sym)), 25245872bbf2SRichard Henderson }, 25255872bbf2SRichard Henderson [6] = { /* .strtab */ 25265872bbf2SRichard Henderson .sh_type = SHT_STRTAB, 25275872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, str), 25285872bbf2SRichard Henderson .sh_size = sizeof(img->str), 25295872bbf2SRichard Henderson } 25305872bbf2SRichard Henderson }, 25315872bbf2SRichard Henderson .sym = { 25325872bbf2SRichard Henderson [1] = { /* code_gen_buffer */ 25335872bbf2SRichard Henderson .st_info = ELF_ST_INFO(STB_GLOBAL, STT_FUNC), 25345872bbf2SRichard Henderson .st_shndx = 1, 25355872bbf2SRichard Henderson } 25365872bbf2SRichard Henderson }, 25375872bbf2SRichard Henderson .di = { 25385872bbf2SRichard Henderson .len = sizeof(struct DebugInfo) - 4, 25395872bbf2SRichard Henderson .version = 2, 25405872bbf2SRichard Henderson .ptr_size = sizeof(void *), 25415872bbf2SRichard Henderson .cu_die = 1, 25425872bbf2SRichard Henderson .cu_lang = 0x8001, /* DW_LANG_Mips_Assembler */ 25435872bbf2SRichard Henderson .fn_die = 2, 25445872bbf2SRichard Henderson .fn_name = "code_gen_buffer" 25455872bbf2SRichard Henderson }, 25465872bbf2SRichard Henderson .da = { 25475872bbf2SRichard Henderson 1, /* abbrev number (the cu) */ 25485872bbf2SRichard Henderson 0x11, 1, /* DW_TAG_compile_unit, has children */ 25495872bbf2SRichard Henderson 0x13, 0x5, /* DW_AT_language, DW_FORM_data2 */ 25505872bbf2SRichard Henderson 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */ 25515872bbf2SRichard Henderson 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */ 25525872bbf2SRichard Henderson 0, 0, /* end of abbrev */ 25535872bbf2SRichard Henderson 2, /* abbrev number (the fn) */ 25545872bbf2SRichard Henderson 0x2e, 0, /* DW_TAG_subprogram, no children */ 25555872bbf2SRichard Henderson 0x3, 0x8, /* DW_AT_name, DW_FORM_string */ 25565872bbf2SRichard Henderson 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */ 25575872bbf2SRichard Henderson 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */ 25585872bbf2SRichard Henderson 0, 0, /* end of abbrev */ 25595872bbf2SRichard Henderson 0 /* no more abbrev */ 25605872bbf2SRichard Henderson }, 25615872bbf2SRichard Henderson .str = "\0" ".text\0" ".debug_info\0" ".debug_abbrev\0" 25625872bbf2SRichard Henderson ".debug_frame\0" ".symtab\0" ".strtab\0" "code_gen_buffer", 2563813da627SRichard Henderson }; 2564813da627SRichard Henderson 2565813da627SRichard Henderson /* We only need a single jit entry; statically allocate it. */ 2566813da627SRichard Henderson static struct jit_code_entry one_entry; 2567813da627SRichard Henderson 25685872bbf2SRichard Henderson uintptr_t buf = (uintptr_t)buf_ptr; 2569813da627SRichard Henderson size_t img_size = sizeof(struct ElfImage) + debug_frame_size; 2570813da627SRichard Henderson 25715872bbf2SRichard Henderson img = g_malloc(img_size); 25725872bbf2SRichard Henderson *img = img_template; 2573813da627SRichard Henderson memcpy(img + 1, debug_frame, debug_frame_size); 2574813da627SRichard Henderson 25755872bbf2SRichard Henderson img->phdr.p_vaddr = buf; 25765872bbf2SRichard Henderson img->phdr.p_paddr = buf; 25775872bbf2SRichard Henderson img->phdr.p_memsz = buf_size; 2578813da627SRichard Henderson 25795872bbf2SRichard Henderson img->shdr[1].sh_name = find_string(img->str, ".text"); 25805872bbf2SRichard Henderson img->shdr[1].sh_addr = buf; 25815872bbf2SRichard Henderson img->shdr[1].sh_size = buf_size; 2582813da627SRichard Henderson 25835872bbf2SRichard Henderson img->shdr[2].sh_name = find_string(img->str, ".debug_info"); 25845872bbf2SRichard Henderson img->shdr[3].sh_name = find_string(img->str, ".debug_abbrev"); 25855872bbf2SRichard Henderson 25865872bbf2SRichard Henderson img->shdr[4].sh_name = find_string(img->str, ".debug_frame"); 25875872bbf2SRichard Henderson img->shdr[4].sh_size = debug_frame_size; 25885872bbf2SRichard Henderson 25895872bbf2SRichard Henderson img->shdr[5].sh_name = find_string(img->str, ".symtab"); 25905872bbf2SRichard Henderson img->shdr[6].sh_name = find_string(img->str, ".strtab"); 25915872bbf2SRichard Henderson 25925872bbf2SRichard Henderson img->sym[1].st_name = find_string(img->str, "code_gen_buffer"); 25935872bbf2SRichard Henderson img->sym[1].st_value = buf; 25945872bbf2SRichard Henderson img->sym[1].st_size = buf_size; 25955872bbf2SRichard Henderson 25965872bbf2SRichard Henderson img->di.cu_low_pc = buf; 25975872bbf2SRichard Henderson img->di.cu_high_pc = buf_size; 25985872bbf2SRichard Henderson img->di.fn_low_pc = buf; 25995872bbf2SRichard Henderson img->di.fn_high_pc = buf_size; 2600813da627SRichard Henderson 2601813da627SRichard Henderson #ifdef DEBUG_JIT 2602813da627SRichard Henderson /* Enable this block to be able to debug the ELF image file creation. 2603813da627SRichard Henderson One can use readelf, objdump, or other inspection utilities. */ 2604813da627SRichard Henderson { 2605813da627SRichard Henderson FILE *f = fopen("/tmp/qemu.jit", "w+b"); 2606813da627SRichard Henderson if (f) { 26075872bbf2SRichard Henderson if (fwrite(img, img_size, 1, f) != img_size) { 2608813da627SRichard Henderson /* Avoid stupid unused return value warning for fwrite. */ 2609813da627SRichard Henderson } 2610813da627SRichard Henderson fclose(f); 2611813da627SRichard Henderson } 2612813da627SRichard Henderson } 2613813da627SRichard Henderson #endif 2614813da627SRichard Henderson 2615813da627SRichard Henderson one_entry.symfile_addr = img; 2616813da627SRichard Henderson one_entry.symfile_size = img_size; 2617813da627SRichard Henderson 2618813da627SRichard Henderson __jit_debug_descriptor.action_flag = JIT_REGISTER_FN; 2619813da627SRichard Henderson __jit_debug_descriptor.relevant_entry = &one_entry; 2620813da627SRichard Henderson __jit_debug_descriptor.first_entry = &one_entry; 2621813da627SRichard Henderson __jit_debug_register_code(); 2622813da627SRichard Henderson } 2623813da627SRichard Henderson #else 26245872bbf2SRichard Henderson /* No support for the feature. Provide the entry point expected by exec.c, 26255872bbf2SRichard Henderson and implement the internal function we declared earlier. */ 2626813da627SRichard Henderson 2627813da627SRichard Henderson static void tcg_register_jit_int(void *buf, size_t size, 2628813da627SRichard Henderson void *debug_frame, size_t debug_frame_size) 2629813da627SRichard Henderson { 2630813da627SRichard Henderson } 2631813da627SRichard Henderson 2632813da627SRichard Henderson void tcg_register_jit(void *buf, size_t buf_size) 2633813da627SRichard Henderson { 2634813da627SRichard Henderson } 2635813da627SRichard Henderson #endif /* ELF_HOST_MACHINE */ 2636