1c896fe29Sbellard /* 2c896fe29Sbellard * Tiny Code Generator for QEMU 3c896fe29Sbellard * 4c896fe29Sbellard * Copyright (c) 2008 Fabrice Bellard 5c896fe29Sbellard * 6c896fe29Sbellard * Permission is hereby granted, free of charge, to any person obtaining a copy 7c896fe29Sbellard * of this software and associated documentation files (the "Software"), to deal 8c896fe29Sbellard * in the Software without restriction, including without limitation the rights 9c896fe29Sbellard * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10c896fe29Sbellard * copies of the Software, and to permit persons to whom the Software is 11c896fe29Sbellard * furnished to do so, subject to the following conditions: 12c896fe29Sbellard * 13c896fe29Sbellard * The above copyright notice and this permission notice shall be included in 14c896fe29Sbellard * all copies or substantial portions of the Software. 15c896fe29Sbellard * 16c896fe29Sbellard * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17c896fe29Sbellard * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18c896fe29Sbellard * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19c896fe29Sbellard * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20c896fe29Sbellard * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21c896fe29Sbellard * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22c896fe29Sbellard * THE SOFTWARE. 23c896fe29Sbellard */ 24c896fe29Sbellard 25c896fe29Sbellard /* define it to use liveness analysis (better code) */ 26c896fe29Sbellard #define USE_LIVENESS_ANALYSIS 278f2e8c07SKirill Batuzov #define USE_TCG_OPTIMIZATIONS 28c896fe29Sbellard 29cca82982Saurel32 #include "config.h" 30cca82982Saurel32 31813da627SRichard Henderson /* Define to jump the ELF file used to communicate with GDB. */ 32813da627SRichard Henderson #undef DEBUG_JIT 33813da627SRichard Henderson 34a6c6f76cSBlue Swirl #if !defined(CONFIG_DEBUG_TCG) && !defined(NDEBUG) 35cca82982Saurel32 /* define it to suppress various consistency checks (faster) */ 36cca82982Saurel32 #define NDEBUG 37cca82982Saurel32 #endif 38cca82982Saurel32 39ca10f867Saurel32 #include "qemu-common.h" 401de7afc9SPaolo Bonzini #include "qemu/cache-utils.h" 411de7afc9SPaolo Bonzini #include "qemu/host-utils.h" 421de7afc9SPaolo Bonzini #include "qemu/timer.h" 43c896fe29Sbellard 44c896fe29Sbellard /* Note: the long term plan is to reduce the dependancies on the QEMU 45c896fe29Sbellard CPU definitions. Currently they are used for qemu_ld/st 46c896fe29Sbellard instructions */ 47c896fe29Sbellard #define NO_CPU_IO_DEFS 48c896fe29Sbellard #include "cpu.h" 49c896fe29Sbellard 50c896fe29Sbellard #include "tcg-op.h" 51813da627SRichard Henderson 52edee2579SRichard Henderson #if UINTPTR_MAX == UINT32_MAX 53813da627SRichard Henderson # define ELF_CLASS ELFCLASS32 54edee2579SRichard Henderson #else 55edee2579SRichard Henderson # define ELF_CLASS ELFCLASS64 56813da627SRichard Henderson #endif 57813da627SRichard Henderson #ifdef HOST_WORDS_BIGENDIAN 58813da627SRichard Henderson # define ELF_DATA ELFDATA2MSB 59813da627SRichard Henderson #else 60813da627SRichard Henderson # define ELF_DATA ELFDATA2LSB 61813da627SRichard Henderson #endif 62813da627SRichard Henderson 63c896fe29Sbellard #include "elf.h" 64c896fe29Sbellard 65c0ad3001SStefan Weil /* Forward declarations for functions declared in tcg-target.c and used here. */ 66e4d58b41SRichard Henderson static void tcg_target_init(TCGContext *s); 67e4d58b41SRichard Henderson static void tcg_target_qemu_prologue(TCGContext *s); 68c896fe29Sbellard static void patch_reloc(uint8_t *code_ptr, int type, 692ba7fae2SRichard Henderson intptr_t value, intptr_t addend); 70c896fe29Sbellard 71497a22ebSRichard Henderson /* The CIE and FDE header definitions will be common to all hosts. */ 72497a22ebSRichard Henderson typedef struct { 73497a22ebSRichard Henderson uint32_t len __attribute__((aligned((sizeof(void *))))); 74497a22ebSRichard Henderson uint32_t id; 75497a22ebSRichard Henderson uint8_t version; 76497a22ebSRichard Henderson char augmentation[1]; 77497a22ebSRichard Henderson uint8_t code_align; 78497a22ebSRichard Henderson uint8_t data_align; 79497a22ebSRichard Henderson uint8_t return_column; 80497a22ebSRichard Henderson } DebugFrameCIE; 81497a22ebSRichard Henderson 82497a22ebSRichard Henderson typedef struct QEMU_PACKED { 83497a22ebSRichard Henderson uint32_t len __attribute__((aligned((sizeof(void *))))); 84497a22ebSRichard Henderson uint32_t cie_offset; 85edee2579SRichard Henderson uintptr_t func_start; 86edee2579SRichard Henderson uintptr_t func_len; 87497a22ebSRichard Henderson } DebugFrameFDEHeader; 88497a22ebSRichard Henderson 89813da627SRichard Henderson static void tcg_register_jit_int(void *buf, size_t size, 90813da627SRichard Henderson void *debug_frame, size_t debug_frame_size) 91813da627SRichard Henderson __attribute__((unused)); 92813da627SRichard Henderson 93c0ad3001SStefan Weil /* Forward declarations for functions declared and used in tcg-target.c. */ 94c0ad3001SStefan Weil static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str); 952a534affSRichard Henderson static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1, 96a05b5b9bSRichard Henderson intptr_t arg2); 972a534affSRichard Henderson static void tcg_out_mov(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg); 98c0ad3001SStefan Weil static void tcg_out_movi(TCGContext *s, TCGType type, 992a534affSRichard Henderson TCGReg ret, tcg_target_long arg); 100c0ad3001SStefan Weil static void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args, 101c0ad3001SStefan Weil const int *const_args); 1022a534affSRichard Henderson static void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1, 103a05b5b9bSRichard Henderson intptr_t arg2); 104c0ad3001SStefan Weil static int tcg_target_const_match(tcg_target_long val, 105c0ad3001SStefan Weil const TCGArgConstraint *arg_ct); 106c0ad3001SStefan Weil 1078399ad59SRichard Henderson TCGOpDef tcg_op_defs[] = { 1080e2029a0SAurelien Jarno #define DEF(s, oargs, iargs, cargs, flags) { #s, oargs, iargs, cargs, iargs + oargs + cargs, flags }, 109c896fe29Sbellard #include "tcg-opc.h" 110c896fe29Sbellard #undef DEF 111c896fe29Sbellard }; 1122a24374aSStefan Weil const size_t tcg_op_defs_max = ARRAY_SIZE(tcg_op_defs); 113c896fe29Sbellard 114b1d8e52eSblueswir1 static TCGRegSet tcg_target_available_regs[2]; 115b1d8e52eSblueswir1 static TCGRegSet tcg_target_call_clobber_regs; 116c896fe29Sbellard 117c896fe29Sbellard static inline void tcg_out8(TCGContext *s, uint8_t v) 118c896fe29Sbellard { 119c896fe29Sbellard *s->code_ptr++ = v; 120c896fe29Sbellard } 121c896fe29Sbellard 122c896fe29Sbellard static inline void tcg_out16(TCGContext *s, uint16_t v) 123c896fe29Sbellard { 1242bb8656dSRichard Henderson uint8_t *p = s->code_ptr; 1252bb8656dSRichard Henderson *(uint16_t *)p = v; 1262bb8656dSRichard Henderson s->code_ptr = p + 2; 127c896fe29Sbellard } 128c896fe29Sbellard 129c896fe29Sbellard static inline void tcg_out32(TCGContext *s, uint32_t v) 130c896fe29Sbellard { 1312bb8656dSRichard Henderson uint8_t *p = s->code_ptr; 1322bb8656dSRichard Henderson *(uint32_t *)p = v; 1332bb8656dSRichard Henderson s->code_ptr = p + 4; 134c896fe29Sbellard } 135c896fe29Sbellard 136ac26eb69SRichard Henderson static inline void tcg_out64(TCGContext *s, uint64_t v) 137ac26eb69SRichard Henderson { 138ac26eb69SRichard Henderson uint8_t *p = s->code_ptr; 139ac26eb69SRichard Henderson *(uint64_t *)p = v; 140ac26eb69SRichard Henderson s->code_ptr = p + 8; 141ac26eb69SRichard Henderson } 142ac26eb69SRichard Henderson 143c896fe29Sbellard /* label relocation processing */ 144c896fe29Sbellard 145a5ad5916SStefan Weil static void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type, 1462ba7fae2SRichard Henderson int label_index, intptr_t addend) 147c896fe29Sbellard { 148c896fe29Sbellard TCGLabel *l; 149c896fe29Sbellard TCGRelocation *r; 150c896fe29Sbellard 151c896fe29Sbellard l = &s->labels[label_index]; 152c896fe29Sbellard if (l->has_value) { 153623e265cSpbrook /* FIXME: This may break relocations on RISC targets that 154623e265cSpbrook modify instruction fields in place. The caller may not have 155623e265cSpbrook written the initial value. */ 156f54b3f92Saurel32 patch_reloc(code_ptr, type, l->u.value, addend); 157c896fe29Sbellard } else { 158c896fe29Sbellard /* add a new relocation entry */ 159c896fe29Sbellard r = tcg_malloc(sizeof(TCGRelocation)); 160c896fe29Sbellard r->type = type; 161c896fe29Sbellard r->ptr = code_ptr; 162c896fe29Sbellard r->addend = addend; 163c896fe29Sbellard r->next = l->u.first_reloc; 164c896fe29Sbellard l->u.first_reloc = r; 165c896fe29Sbellard } 166c896fe29Sbellard } 167c896fe29Sbellard 1689d6fca70SStefan Weil static void tcg_out_label(TCGContext *s, int label_index, void *ptr) 169c896fe29Sbellard { 170c896fe29Sbellard TCGLabel *l; 171c896fe29Sbellard TCGRelocation *r; 1722ba7fae2SRichard Henderson intptr_t value = (intptr_t)ptr; 173c896fe29Sbellard 174c896fe29Sbellard l = &s->labels[label_index]; 1752ba7fae2SRichard Henderson if (l->has_value) { 176c896fe29Sbellard tcg_abort(); 1772ba7fae2SRichard Henderson } 178c896fe29Sbellard r = l->u.first_reloc; 179c896fe29Sbellard while (r != NULL) { 180f54b3f92Saurel32 patch_reloc(r->ptr, r->type, value, r->addend); 181c896fe29Sbellard r = r->next; 182c896fe29Sbellard } 183c896fe29Sbellard l->has_value = 1; 184c896fe29Sbellard l->u.value = value; 185c896fe29Sbellard } 186c896fe29Sbellard 187c896fe29Sbellard int gen_new_label(void) 188c896fe29Sbellard { 189c896fe29Sbellard TCGContext *s = &tcg_ctx; 190c896fe29Sbellard int idx; 191c896fe29Sbellard TCGLabel *l; 192c896fe29Sbellard 193c896fe29Sbellard if (s->nb_labels >= TCG_MAX_LABELS) 194c896fe29Sbellard tcg_abort(); 195c896fe29Sbellard idx = s->nb_labels++; 196c896fe29Sbellard l = &s->labels[idx]; 197c896fe29Sbellard l->has_value = 0; 198c896fe29Sbellard l->u.first_reloc = NULL; 199c896fe29Sbellard return idx; 200c896fe29Sbellard } 201c896fe29Sbellard 202c896fe29Sbellard #include "tcg-target.c" 203c896fe29Sbellard 204c896fe29Sbellard /* pool based memory allocation */ 205c896fe29Sbellard void *tcg_malloc_internal(TCGContext *s, int size) 206c896fe29Sbellard { 207c896fe29Sbellard TCGPool *p; 208c896fe29Sbellard int pool_size; 209c896fe29Sbellard 210c896fe29Sbellard if (size > TCG_POOL_CHUNK_SIZE) { 211c896fe29Sbellard /* big malloc: insert a new pool (XXX: could optimize) */ 2127267c094SAnthony Liguori p = g_malloc(sizeof(TCGPool) + size); 213c896fe29Sbellard p->size = size; 2144055299eSKirill Batuzov p->next = s->pool_first_large; 2154055299eSKirill Batuzov s->pool_first_large = p; 2164055299eSKirill Batuzov return p->data; 217c896fe29Sbellard } else { 218c896fe29Sbellard p = s->pool_current; 219c896fe29Sbellard if (!p) { 220c896fe29Sbellard p = s->pool_first; 221c896fe29Sbellard if (!p) 222c896fe29Sbellard goto new_pool; 223c896fe29Sbellard } else { 224c896fe29Sbellard if (!p->next) { 225c896fe29Sbellard new_pool: 226c896fe29Sbellard pool_size = TCG_POOL_CHUNK_SIZE; 2277267c094SAnthony Liguori p = g_malloc(sizeof(TCGPool) + pool_size); 228c896fe29Sbellard p->size = pool_size; 229c896fe29Sbellard p->next = NULL; 230c896fe29Sbellard if (s->pool_current) 231c896fe29Sbellard s->pool_current->next = p; 232c896fe29Sbellard else 233c896fe29Sbellard s->pool_first = p; 234c896fe29Sbellard } else { 235c896fe29Sbellard p = p->next; 236c896fe29Sbellard } 237c896fe29Sbellard } 238c896fe29Sbellard } 239c896fe29Sbellard s->pool_current = p; 240c896fe29Sbellard s->pool_cur = p->data + size; 241c896fe29Sbellard s->pool_end = p->data + p->size; 242c896fe29Sbellard return p->data; 243c896fe29Sbellard } 244c896fe29Sbellard 245c896fe29Sbellard void tcg_pool_reset(TCGContext *s) 246c896fe29Sbellard { 2474055299eSKirill Batuzov TCGPool *p, *t; 2484055299eSKirill Batuzov for (p = s->pool_first_large; p; p = t) { 2494055299eSKirill Batuzov t = p->next; 2504055299eSKirill Batuzov g_free(p); 2514055299eSKirill Batuzov } 2524055299eSKirill Batuzov s->pool_first_large = NULL; 253c896fe29Sbellard s->pool_cur = s->pool_end = NULL; 254c896fe29Sbellard s->pool_current = NULL; 255c896fe29Sbellard } 256c896fe29Sbellard 2575cd8f621SRichard Henderson #include "helper.h" 2585cd8f621SRichard Henderson 259100b5e01SRichard Henderson typedef struct TCGHelperInfo { 260100b5e01SRichard Henderson void *func; 261100b5e01SRichard Henderson const char *name; 262100b5e01SRichard Henderson } TCGHelperInfo; 263100b5e01SRichard Henderson 264100b5e01SRichard Henderson static const TCGHelperInfo all_helpers[] = { 265100b5e01SRichard Henderson #define GEN_HELPER 2 266100b5e01SRichard Henderson #include "helper.h" 267*4953ee62SRichard Henderson 268*4953ee62SRichard Henderson /* Include tcg-runtime.c functions. */ 269*4953ee62SRichard Henderson { tcg_helper_div_i32, "div_i32" }, 270*4953ee62SRichard Henderson { tcg_helper_rem_i32, "rem_i32" }, 271*4953ee62SRichard Henderson { tcg_helper_divu_i32, "divu_i32" }, 272*4953ee62SRichard Henderson { tcg_helper_remu_i32, "remu_i32" }, 273*4953ee62SRichard Henderson 274*4953ee62SRichard Henderson { tcg_helper_shl_i64, "shl_i64" }, 275*4953ee62SRichard Henderson { tcg_helper_shr_i64, "shr_i64" }, 276*4953ee62SRichard Henderson { tcg_helper_sar_i64, "sar_i64" }, 277*4953ee62SRichard Henderson { tcg_helper_div_i64, "div_i64" }, 278*4953ee62SRichard Henderson { tcg_helper_rem_i64, "rem_i64" }, 279*4953ee62SRichard Henderson { tcg_helper_divu_i64, "divu_i64" }, 280*4953ee62SRichard Henderson { tcg_helper_remu_i64, "remu_i64" }, 281*4953ee62SRichard Henderson { tcg_helper_mulsh_i64, "mulsh_i64" }, 282*4953ee62SRichard Henderson { tcg_helper_muluh_i64, "muluh_i64" }, 283100b5e01SRichard Henderson }; 284100b5e01SRichard Henderson 285c896fe29Sbellard void tcg_context_init(TCGContext *s) 286c896fe29Sbellard { 287100b5e01SRichard Henderson int op, total_args, n, i; 288c896fe29Sbellard TCGOpDef *def; 289c896fe29Sbellard TCGArgConstraint *args_ct; 290c896fe29Sbellard int *sorted_args; 291c896fe29Sbellard 292c896fe29Sbellard memset(s, 0, sizeof(*s)); 293c896fe29Sbellard s->nb_globals = 0; 294c896fe29Sbellard 295c896fe29Sbellard /* Count total number of arguments and allocate the corresponding 296c896fe29Sbellard space */ 297c896fe29Sbellard total_args = 0; 298c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 299c896fe29Sbellard def = &tcg_op_defs[op]; 300c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 301c896fe29Sbellard total_args += n; 302c896fe29Sbellard } 303c896fe29Sbellard 3047267c094SAnthony Liguori args_ct = g_malloc(sizeof(TCGArgConstraint) * total_args); 3057267c094SAnthony Liguori sorted_args = g_malloc(sizeof(int) * total_args); 306c896fe29Sbellard 307c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 308c896fe29Sbellard def = &tcg_op_defs[op]; 309c896fe29Sbellard def->args_ct = args_ct; 310c896fe29Sbellard def->sorted_args = sorted_args; 311c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 312c896fe29Sbellard sorted_args += n; 313c896fe29Sbellard args_ct += n; 314c896fe29Sbellard } 315c896fe29Sbellard 3165cd8f621SRichard Henderson /* Register helpers. */ 317100b5e01SRichard Henderson for (i = 0; i < ARRAY_SIZE(all_helpers); ++i) { 318100b5e01SRichard Henderson tcg_register_helper(all_helpers[i].func, all_helpers[i].name); 319100b5e01SRichard Henderson } 3205cd8f621SRichard Henderson 321c896fe29Sbellard tcg_target_init(s); 3229002ec79SRichard Henderson } 323b03cce8eSbellard 3249002ec79SRichard Henderson void tcg_prologue_init(TCGContext *s) 3259002ec79SRichard Henderson { 326b03cce8eSbellard /* init global prologue and epilogue */ 3270b0d3320SEvgeny Voevodin s->code_buf = s->code_gen_prologue; 328b03cce8eSbellard s->code_ptr = s->code_buf; 329b03cce8eSbellard tcg_target_qemu_prologue(s); 330b93949efSRichard Henderson flush_icache_range((uintptr_t)s->code_buf, (uintptr_t)s->code_ptr); 331d6b64b2bSRichard Henderson 332d6b64b2bSRichard Henderson #ifdef DEBUG_DISAS 333d6b64b2bSRichard Henderson if (qemu_loglevel_mask(CPU_LOG_TB_OUT_ASM)) { 334d6b64b2bSRichard Henderson size_t size = s->code_ptr - s->code_buf; 335d6b64b2bSRichard Henderson qemu_log("PROLOGUE: [size=%zu]\n", size); 336d6b64b2bSRichard Henderson log_disas(s->code_buf, size); 337d6b64b2bSRichard Henderson qemu_log("\n"); 338d6b64b2bSRichard Henderson qemu_log_flush(); 339d6b64b2bSRichard Henderson } 340d6b64b2bSRichard Henderson #endif 341c896fe29Sbellard } 342c896fe29Sbellard 343e2c6d1b4SRichard Henderson void tcg_set_frame(TCGContext *s, int reg, intptr_t start, intptr_t size) 344c896fe29Sbellard { 345c896fe29Sbellard s->frame_start = start; 346c896fe29Sbellard s->frame_end = start + size; 347c896fe29Sbellard s->frame_reg = reg; 348c896fe29Sbellard } 349c896fe29Sbellard 350c896fe29Sbellard void tcg_func_start(TCGContext *s) 351c896fe29Sbellard { 352e8996ee0Sbellard int i; 353c896fe29Sbellard tcg_pool_reset(s); 354c896fe29Sbellard s->nb_temps = s->nb_globals; 355641d5fbeSbellard for(i = 0; i < (TCG_TYPE_COUNT * 2); i++) 356e8996ee0Sbellard s->first_free_temp[i] = -1; 357c896fe29Sbellard s->labels = tcg_malloc(sizeof(TCGLabel) * TCG_MAX_LABELS); 358c896fe29Sbellard s->nb_labels = 0; 359c896fe29Sbellard s->current_frame_offset = s->frame_start; 360c896fe29Sbellard 3610a209d4bSRichard Henderson #ifdef CONFIG_DEBUG_TCG 3620a209d4bSRichard Henderson s->goto_tb_issue_mask = 0; 3630a209d4bSRichard Henderson #endif 3640a209d4bSRichard Henderson 36592414b31SEvgeny Voevodin s->gen_opc_ptr = s->gen_opc_buf; 3661ff0a2c5SEvgeny Voevodin s->gen_opparam_ptr = s->gen_opparam_buf; 367b76f0d8cSYeongkyoon Lee 368b76f0d8cSYeongkyoon Lee #if defined(CONFIG_QEMU_LDST_OPTIMIZATION) && defined(CONFIG_SOFTMMU) 369b76f0d8cSYeongkyoon Lee /* Initialize qemu_ld/st labels to assist code generation at the end of TB 370b76f0d8cSYeongkyoon Lee for TLB miss cases at the end of TB */ 371b76f0d8cSYeongkyoon Lee s->qemu_ldst_labels = tcg_malloc(sizeof(TCGLabelQemuLdst) * 372b76f0d8cSYeongkyoon Lee TCG_MAX_QEMU_LDST); 373b76f0d8cSYeongkyoon Lee s->nb_qemu_ldst_labels = 0; 374b76f0d8cSYeongkyoon Lee #endif 375c896fe29Sbellard } 376c896fe29Sbellard 377c896fe29Sbellard static inline void tcg_temp_alloc(TCGContext *s, int n) 378c896fe29Sbellard { 379c896fe29Sbellard if (n > TCG_MAX_TEMPS) 380c896fe29Sbellard tcg_abort(); 381c896fe29Sbellard } 382c896fe29Sbellard 383a7812ae4Spbrook static inline int tcg_global_reg_new_internal(TCGType type, int reg, 384a7812ae4Spbrook const char *name) 385c896fe29Sbellard { 386c896fe29Sbellard TCGContext *s = &tcg_ctx; 387c896fe29Sbellard TCGTemp *ts; 388c896fe29Sbellard int idx; 389c896fe29Sbellard 390c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 391c896fe29Sbellard if (type != TCG_TYPE_I32) 392c896fe29Sbellard tcg_abort(); 393c896fe29Sbellard #endif 394c896fe29Sbellard if (tcg_regset_test_reg(s->reserved_regs, reg)) 395c896fe29Sbellard tcg_abort(); 396c896fe29Sbellard idx = s->nb_globals; 397c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 398c896fe29Sbellard ts = &s->temps[s->nb_globals]; 399c896fe29Sbellard ts->base_type = type; 400c896fe29Sbellard ts->type = type; 401c896fe29Sbellard ts->fixed_reg = 1; 402c896fe29Sbellard ts->reg = reg; 403c896fe29Sbellard ts->name = name; 404c896fe29Sbellard s->nb_globals++; 405c896fe29Sbellard tcg_regset_set_reg(s->reserved_regs, reg); 406a7812ae4Spbrook return idx; 407a7812ae4Spbrook } 408a7812ae4Spbrook 409a7812ae4Spbrook TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name) 410a7812ae4Spbrook { 411a7812ae4Spbrook int idx; 412a7812ae4Spbrook 413a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name); 414a7812ae4Spbrook return MAKE_TCGV_I32(idx); 415a7812ae4Spbrook } 416a7812ae4Spbrook 417a7812ae4Spbrook TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name) 418a7812ae4Spbrook { 419a7812ae4Spbrook int idx; 420a7812ae4Spbrook 421a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I64, reg, name); 422a7812ae4Spbrook return MAKE_TCGV_I64(idx); 423c896fe29Sbellard } 424c896fe29Sbellard 425a7812ae4Spbrook static inline int tcg_global_mem_new_internal(TCGType type, int reg, 4262f2f244dSRichard Henderson intptr_t offset, 427c896fe29Sbellard const char *name) 428c896fe29Sbellard { 429c896fe29Sbellard TCGContext *s = &tcg_ctx; 430c896fe29Sbellard TCGTemp *ts; 431c896fe29Sbellard int idx; 432c896fe29Sbellard 433c896fe29Sbellard idx = s->nb_globals; 434c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 435c896fe29Sbellard if (type == TCG_TYPE_I64) { 436c896fe29Sbellard char buf[64]; 437c588979bSths tcg_temp_alloc(s, s->nb_globals + 2); 438c896fe29Sbellard ts = &s->temps[s->nb_globals]; 439c896fe29Sbellard ts->base_type = type; 440c896fe29Sbellard ts->type = TCG_TYPE_I32; 441c896fe29Sbellard ts->fixed_reg = 0; 442c896fe29Sbellard ts->mem_allocated = 1; 443c896fe29Sbellard ts->mem_reg = reg; 444c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 445c896fe29Sbellard ts->mem_offset = offset + 4; 446c896fe29Sbellard #else 447c896fe29Sbellard ts->mem_offset = offset; 448c896fe29Sbellard #endif 449c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 450c896fe29Sbellard pstrcat(buf, sizeof(buf), "_0"); 451c896fe29Sbellard ts->name = strdup(buf); 452c896fe29Sbellard ts++; 453c896fe29Sbellard 454c896fe29Sbellard ts->base_type = type; 455c896fe29Sbellard ts->type = TCG_TYPE_I32; 456c896fe29Sbellard ts->fixed_reg = 0; 457c896fe29Sbellard ts->mem_allocated = 1; 458c896fe29Sbellard ts->mem_reg = reg; 459c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 460c896fe29Sbellard ts->mem_offset = offset; 461c896fe29Sbellard #else 462c896fe29Sbellard ts->mem_offset = offset + 4; 463c896fe29Sbellard #endif 464c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 465c896fe29Sbellard pstrcat(buf, sizeof(buf), "_1"); 466c896fe29Sbellard ts->name = strdup(buf); 467c896fe29Sbellard 468c896fe29Sbellard s->nb_globals += 2; 469c896fe29Sbellard } else 470c896fe29Sbellard #endif 471c896fe29Sbellard { 472c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 473c896fe29Sbellard ts = &s->temps[s->nb_globals]; 474c896fe29Sbellard ts->base_type = type; 475c896fe29Sbellard ts->type = type; 476c896fe29Sbellard ts->fixed_reg = 0; 477c896fe29Sbellard ts->mem_allocated = 1; 478c896fe29Sbellard ts->mem_reg = reg; 479c896fe29Sbellard ts->mem_offset = offset; 480c896fe29Sbellard ts->name = name; 481c896fe29Sbellard s->nb_globals++; 482c896fe29Sbellard } 483a7812ae4Spbrook return idx; 484c896fe29Sbellard } 485c896fe29Sbellard 4862f2f244dSRichard Henderson TCGv_i32 tcg_global_mem_new_i32(int reg, intptr_t offset, const char *name) 487a7812ae4Spbrook { 4882f2f244dSRichard Henderson int idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name); 489a7812ae4Spbrook return MAKE_TCGV_I32(idx); 490a7812ae4Spbrook } 491a7812ae4Spbrook 4922f2f244dSRichard Henderson TCGv_i64 tcg_global_mem_new_i64(int reg, intptr_t offset, const char *name) 493a7812ae4Spbrook { 4942f2f244dSRichard Henderson int idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name); 495a7812ae4Spbrook return MAKE_TCGV_I64(idx); 496a7812ae4Spbrook } 497a7812ae4Spbrook 498a7812ae4Spbrook static inline int tcg_temp_new_internal(TCGType type, int temp_local) 499c896fe29Sbellard { 500c896fe29Sbellard TCGContext *s = &tcg_ctx; 501c896fe29Sbellard TCGTemp *ts; 502641d5fbeSbellard int idx, k; 503c896fe29Sbellard 504641d5fbeSbellard k = type; 505641d5fbeSbellard if (temp_local) 506641d5fbeSbellard k += TCG_TYPE_COUNT; 507641d5fbeSbellard idx = s->first_free_temp[k]; 508e8996ee0Sbellard if (idx != -1) { 509e8996ee0Sbellard /* There is already an available temp with the 510e8996ee0Sbellard right type */ 511e8996ee0Sbellard ts = &s->temps[idx]; 512641d5fbeSbellard s->first_free_temp[k] = ts->next_free_temp; 513e8996ee0Sbellard ts->temp_allocated = 1; 514641d5fbeSbellard assert(ts->temp_local == temp_local); 515e8996ee0Sbellard } else { 516c896fe29Sbellard idx = s->nb_temps; 517c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 518c896fe29Sbellard if (type == TCG_TYPE_I64) { 5198df1ca4bSths tcg_temp_alloc(s, s->nb_temps + 2); 520c896fe29Sbellard ts = &s->temps[s->nb_temps]; 521c896fe29Sbellard ts->base_type = type; 522c896fe29Sbellard ts->type = TCG_TYPE_I32; 523e8996ee0Sbellard ts->temp_allocated = 1; 524641d5fbeSbellard ts->temp_local = temp_local; 525c896fe29Sbellard ts->name = NULL; 526c896fe29Sbellard ts++; 527c896fe29Sbellard ts->base_type = TCG_TYPE_I32; 528c896fe29Sbellard ts->type = TCG_TYPE_I32; 529e8996ee0Sbellard ts->temp_allocated = 1; 530641d5fbeSbellard ts->temp_local = temp_local; 531c896fe29Sbellard ts->name = NULL; 532c896fe29Sbellard s->nb_temps += 2; 533c896fe29Sbellard } else 534c896fe29Sbellard #endif 535c896fe29Sbellard { 536c896fe29Sbellard tcg_temp_alloc(s, s->nb_temps + 1); 537c896fe29Sbellard ts = &s->temps[s->nb_temps]; 538c896fe29Sbellard ts->base_type = type; 539c896fe29Sbellard ts->type = type; 540e8996ee0Sbellard ts->temp_allocated = 1; 541641d5fbeSbellard ts->temp_local = temp_local; 542c896fe29Sbellard ts->name = NULL; 543c896fe29Sbellard s->nb_temps++; 544c896fe29Sbellard } 545e8996ee0Sbellard } 54627bfd83cSPeter Maydell 54727bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 54827bfd83cSPeter Maydell s->temps_in_use++; 54927bfd83cSPeter Maydell #endif 550a7812ae4Spbrook return idx; 551c896fe29Sbellard } 552c896fe29Sbellard 553a7812ae4Spbrook TCGv_i32 tcg_temp_new_internal_i32(int temp_local) 554a7812ae4Spbrook { 555a7812ae4Spbrook int idx; 556a7812ae4Spbrook 557a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I32, temp_local); 558a7812ae4Spbrook return MAKE_TCGV_I32(idx); 559a7812ae4Spbrook } 560a7812ae4Spbrook 561a7812ae4Spbrook TCGv_i64 tcg_temp_new_internal_i64(int temp_local) 562a7812ae4Spbrook { 563a7812ae4Spbrook int idx; 564a7812ae4Spbrook 565a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I64, temp_local); 566a7812ae4Spbrook return MAKE_TCGV_I64(idx); 567a7812ae4Spbrook } 568a7812ae4Spbrook 569a7812ae4Spbrook static inline void tcg_temp_free_internal(int idx) 570c896fe29Sbellard { 571c896fe29Sbellard TCGContext *s = &tcg_ctx; 572c896fe29Sbellard TCGTemp *ts; 573641d5fbeSbellard int k; 574c896fe29Sbellard 57527bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 57627bfd83cSPeter Maydell s->temps_in_use--; 57727bfd83cSPeter Maydell if (s->temps_in_use < 0) { 57827bfd83cSPeter Maydell fprintf(stderr, "More temporaries freed than allocated!\n"); 57927bfd83cSPeter Maydell } 58027bfd83cSPeter Maydell #endif 58127bfd83cSPeter Maydell 582e8996ee0Sbellard assert(idx >= s->nb_globals && idx < s->nb_temps); 583c896fe29Sbellard ts = &s->temps[idx]; 584e8996ee0Sbellard assert(ts->temp_allocated != 0); 585e8996ee0Sbellard ts->temp_allocated = 0; 586641d5fbeSbellard k = ts->base_type; 587641d5fbeSbellard if (ts->temp_local) 588641d5fbeSbellard k += TCG_TYPE_COUNT; 589641d5fbeSbellard ts->next_free_temp = s->first_free_temp[k]; 590641d5fbeSbellard s->first_free_temp[k] = idx; 591e8996ee0Sbellard } 592e8996ee0Sbellard 593a7812ae4Spbrook void tcg_temp_free_i32(TCGv_i32 arg) 594e8996ee0Sbellard { 595a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I32(arg)); 596a7812ae4Spbrook } 597a7812ae4Spbrook 598a7812ae4Spbrook void tcg_temp_free_i64(TCGv_i64 arg) 599a7812ae4Spbrook { 600a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I64(arg)); 601a7812ae4Spbrook } 602a7812ae4Spbrook 603a7812ae4Spbrook TCGv_i32 tcg_const_i32(int32_t val) 604a7812ae4Spbrook { 605a7812ae4Spbrook TCGv_i32 t0; 606a7812ae4Spbrook t0 = tcg_temp_new_i32(); 607e8996ee0Sbellard tcg_gen_movi_i32(t0, val); 608e8996ee0Sbellard return t0; 609c896fe29Sbellard } 610c896fe29Sbellard 611a7812ae4Spbrook TCGv_i64 tcg_const_i64(int64_t val) 612c896fe29Sbellard { 613a7812ae4Spbrook TCGv_i64 t0; 614a7812ae4Spbrook t0 = tcg_temp_new_i64(); 615e8996ee0Sbellard tcg_gen_movi_i64(t0, val); 616e8996ee0Sbellard return t0; 617c896fe29Sbellard } 618c896fe29Sbellard 619a7812ae4Spbrook TCGv_i32 tcg_const_local_i32(int32_t val) 620bdffd4a9Saurel32 { 621a7812ae4Spbrook TCGv_i32 t0; 622a7812ae4Spbrook t0 = tcg_temp_local_new_i32(); 623bdffd4a9Saurel32 tcg_gen_movi_i32(t0, val); 624bdffd4a9Saurel32 return t0; 625bdffd4a9Saurel32 } 626bdffd4a9Saurel32 627a7812ae4Spbrook TCGv_i64 tcg_const_local_i64(int64_t val) 628bdffd4a9Saurel32 { 629a7812ae4Spbrook TCGv_i64 t0; 630a7812ae4Spbrook t0 = tcg_temp_local_new_i64(); 631bdffd4a9Saurel32 tcg_gen_movi_i64(t0, val); 632bdffd4a9Saurel32 return t0; 633bdffd4a9Saurel32 } 634bdffd4a9Saurel32 63527bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 63627bfd83cSPeter Maydell void tcg_clear_temp_count(void) 63727bfd83cSPeter Maydell { 63827bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 63927bfd83cSPeter Maydell s->temps_in_use = 0; 64027bfd83cSPeter Maydell } 64127bfd83cSPeter Maydell 64227bfd83cSPeter Maydell int tcg_check_temp_count(void) 64327bfd83cSPeter Maydell { 64427bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 64527bfd83cSPeter Maydell if (s->temps_in_use) { 64627bfd83cSPeter Maydell /* Clear the count so that we don't give another 64727bfd83cSPeter Maydell * warning immediately next time around. 64827bfd83cSPeter Maydell */ 64927bfd83cSPeter Maydell s->temps_in_use = 0; 65027bfd83cSPeter Maydell return 1; 65127bfd83cSPeter Maydell } 65227bfd83cSPeter Maydell return 0; 65327bfd83cSPeter Maydell } 65427bfd83cSPeter Maydell #endif 65527bfd83cSPeter Maydell 656c896fe29Sbellard void tcg_register_helper(void *func, const char *name) 657c896fe29Sbellard { 658c896fe29Sbellard TCGContext *s = &tcg_ctx; 6596e085f72SRichard Henderson GHashTable *table = s->helpers; 6606e085f72SRichard Henderson 6616e085f72SRichard Henderson if (table == NULL) { 6626e085f72SRichard Henderson /* Use g_direct_hash/equal for direct pointer comparisons on func. */ 6636e085f72SRichard Henderson table = g_hash_table_new(NULL, NULL); 6646e085f72SRichard Henderson s->helpers = table; 665c896fe29Sbellard } 6666e085f72SRichard Henderson 6676e085f72SRichard Henderson g_hash_table_insert(table, (gpointer)func, (gpointer)name); 668c896fe29Sbellard } 669c896fe29Sbellard 67039cf05d3Sbellard /* Note: we convert the 64 bit args to 32 bit and do some alignment 67139cf05d3Sbellard and endian swap. Maybe it would be better to do the alignment 67239cf05d3Sbellard and endian swap in tcg_reg_alloc_call(). */ 673a7812ae4Spbrook void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags, 674a7812ae4Spbrook int sizemask, TCGArg ret, int nargs, TCGArg *args) 675c896fe29Sbellard { 676a7812ae4Spbrook int i; 677a7812ae4Spbrook int real_args; 678a7812ae4Spbrook int nb_rets; 679a7812ae4Spbrook TCGArg *nparam; 6802bece2c8SRichard Henderson 6812bece2c8SRichard Henderson #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 6822bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 6832bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 6842bece2c8SRichard Henderson int is_signed = sizemask & (2 << (i+1)*2); 6852bece2c8SRichard Henderson if (!is_64bit) { 6862bece2c8SRichard Henderson TCGv_i64 temp = tcg_temp_new_i64(); 6872bece2c8SRichard Henderson TCGv_i64 orig = MAKE_TCGV_I64(args[i]); 6882bece2c8SRichard Henderson if (is_signed) { 6892bece2c8SRichard Henderson tcg_gen_ext32s_i64(temp, orig); 6902bece2c8SRichard Henderson } else { 6912bece2c8SRichard Henderson tcg_gen_ext32u_i64(temp, orig); 6922bece2c8SRichard Henderson } 6932bece2c8SRichard Henderson args[i] = GET_TCGV_I64(temp); 6942bece2c8SRichard Henderson } 6952bece2c8SRichard Henderson } 6962bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 6972bece2c8SRichard Henderson 698efd7f486SEvgeny Voevodin *s->gen_opc_ptr++ = INDEX_op_call; 699c4afe5c4SEvgeny Voevodin nparam = s->gen_opparam_ptr++; 700a7812ae4Spbrook if (ret != TCG_CALL_DUMMY_ARG) { 701a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 702a7812ae4Spbrook if (sizemask & 1) { 703a7812ae4Spbrook #ifdef TCG_TARGET_WORDS_BIGENDIAN 704c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret + 1; 705c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret; 706a7812ae4Spbrook #else 707c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret; 708c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret + 1; 709a7812ae4Spbrook #endif 710a7812ae4Spbrook nb_rets = 2; 711a7812ae4Spbrook } else 712a7812ae4Spbrook #endif 713a7812ae4Spbrook { 714c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret; 715a7812ae4Spbrook nb_rets = 1; 716a7812ae4Spbrook } 717a7812ae4Spbrook } else { 718a7812ae4Spbrook nb_rets = 0; 719a7812ae4Spbrook } 720a7812ae4Spbrook real_args = 0; 721a7812ae4Spbrook for (i = 0; i < nargs; i++) { 722a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 7232bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 7242bece2c8SRichard Henderson if (is_64bit) { 72539cf05d3Sbellard #ifdef TCG_TARGET_CALL_ALIGN_ARGS 72639cf05d3Sbellard /* some targets want aligned 64 bit args */ 727ebd486d5Smalc if (real_args & 1) { 728c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = TCG_CALL_DUMMY_ARG; 729ebd486d5Smalc real_args++; 73039cf05d3Sbellard } 73139cf05d3Sbellard #endif 7323f90f252SRichard Henderson /* If stack grows up, then we will be placing successive 7333f90f252SRichard Henderson arguments at lower addresses, which means we need to 7343f90f252SRichard Henderson reverse the order compared to how we would normally 7353f90f252SRichard Henderson treat either big or little-endian. For those arguments 7363f90f252SRichard Henderson that will wind up in registers, this still works for 7373f90f252SRichard Henderson HPPA (the only current STACK_GROWSUP target) since the 7383f90f252SRichard Henderson argument registers are *also* allocated in decreasing 7393f90f252SRichard Henderson order. If another such target is added, this logic may 7403f90f252SRichard Henderson have to get more complicated to differentiate between 7413f90f252SRichard Henderson stack arguments and register arguments. */ 7423f90f252SRichard Henderson #if defined(TCG_TARGET_WORDS_BIGENDIAN) != defined(TCG_TARGET_STACK_GROWSUP) 743c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i] + 1; 744c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i]; 745c896fe29Sbellard #else 746c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i]; 747c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i] + 1; 748c896fe29Sbellard #endif 749a7812ae4Spbrook real_args += 2; 7502bece2c8SRichard Henderson continue; 7512bece2c8SRichard Henderson } 7522bece2c8SRichard Henderson #endif /* TCG_TARGET_REG_BITS < 64 */ 7532bece2c8SRichard Henderson 754c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i]; 755a7812ae4Spbrook real_args++; 756c896fe29Sbellard } 757c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = GET_TCGV_PTR(func); 758a7812ae4Spbrook 759c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = flags; 760a7812ae4Spbrook 761a7812ae4Spbrook *nparam = (nb_rets << 16) | (real_args + 1); 762a7812ae4Spbrook 763a7812ae4Spbrook /* total parameters, needed to go backward in the instruction stream */ 764c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = 1 + nb_rets + real_args + 3; 7652bece2c8SRichard Henderson 7662bece2c8SRichard Henderson #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 7672bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 7682bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 7692bece2c8SRichard Henderson if (!is_64bit) { 7702bece2c8SRichard Henderson TCGv_i64 temp = MAKE_TCGV_I64(args[i]); 7712bece2c8SRichard Henderson tcg_temp_free_i64(temp); 7722bece2c8SRichard Henderson } 7732bece2c8SRichard Henderson } 7742bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 775a7812ae4Spbrook } 776c896fe29Sbellard 777ac56dd48Spbrook #if TCG_TARGET_REG_BITS == 32 778a7812ae4Spbrook void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, 779c896fe29Sbellard int c, int right, int arith) 780c896fe29Sbellard { 781cf60bce4Sbellard if (c == 0) { 782a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1)); 783cf60bce4Sbellard tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1)); 784cf60bce4Sbellard } else if (c >= 32) { 785c896fe29Sbellard c -= 32; 786c896fe29Sbellard if (right) { 787c896fe29Sbellard if (arith) { 788a7812ae4Spbrook tcg_gen_sari_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 789ac56dd48Spbrook tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 31); 790c896fe29Sbellard } else { 791a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 792ac56dd48Spbrook tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 793c896fe29Sbellard } 794c896fe29Sbellard } else { 795a7812ae4Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_LOW(arg1), c); 796a7812ae4Spbrook tcg_gen_movi_i32(TCGV_LOW(ret), 0); 797c896fe29Sbellard } 798c896fe29Sbellard } else { 799a7812ae4Spbrook TCGv_i32 t0, t1; 800c896fe29Sbellard 801a7812ae4Spbrook t0 = tcg_temp_new_i32(); 802a7812ae4Spbrook t1 = tcg_temp_new_i32(); 803c896fe29Sbellard if (right) { 804ac56dd48Spbrook tcg_gen_shli_i32(t0, TCGV_HIGH(arg1), 32 - c); 805c896fe29Sbellard if (arith) 806ac56dd48Spbrook tcg_gen_sari_i32(t1, TCGV_HIGH(arg1), c); 807c896fe29Sbellard else 808ac56dd48Spbrook tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c); 809a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_LOW(arg1), c); 810a7812ae4Spbrook tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t0); 811ac56dd48Spbrook tcg_gen_mov_i32(TCGV_HIGH(ret), t1); 812c896fe29Sbellard } else { 813a7812ae4Spbrook tcg_gen_shri_i32(t0, TCGV_LOW(arg1), 32 - c); 814c896fe29Sbellard /* Note: ret can be the same as arg1, so we use t1 */ 815a7812ae4Spbrook tcg_gen_shli_i32(t1, TCGV_LOW(arg1), c); 816ac56dd48Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c); 817ac56dd48Spbrook tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0); 818a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), t1); 819c896fe29Sbellard } 820a7812ae4Spbrook tcg_temp_free_i32(t0); 821a7812ae4Spbrook tcg_temp_free_i32(t1); 822c896fe29Sbellard } 823c896fe29Sbellard } 824ac56dd48Spbrook #endif 825c896fe29Sbellard 826be210acbSRichard Henderson 8278fcd3692Sblueswir1 static void tcg_reg_alloc_start(TCGContext *s) 828c896fe29Sbellard { 829c896fe29Sbellard int i; 830c896fe29Sbellard TCGTemp *ts; 831c896fe29Sbellard for(i = 0; i < s->nb_globals; i++) { 832c896fe29Sbellard ts = &s->temps[i]; 833c896fe29Sbellard if (ts->fixed_reg) { 834c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 835c896fe29Sbellard } else { 836c896fe29Sbellard ts->val_type = TEMP_VAL_MEM; 837c896fe29Sbellard } 838c896fe29Sbellard } 839e8996ee0Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 840e8996ee0Sbellard ts = &s->temps[i]; 8417dfd8c6aSAurelien Jarno if (ts->temp_local) { 8427dfd8c6aSAurelien Jarno ts->val_type = TEMP_VAL_MEM; 8437dfd8c6aSAurelien Jarno } else { 844e8996ee0Sbellard ts->val_type = TEMP_VAL_DEAD; 8457dfd8c6aSAurelien Jarno } 846e8996ee0Sbellard ts->mem_allocated = 0; 847e8996ee0Sbellard ts->fixed_reg = 0; 848e8996ee0Sbellard } 849c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 850c896fe29Sbellard s->reg_to_temp[i] = -1; 851c896fe29Sbellard } 852c896fe29Sbellard } 853c896fe29Sbellard 854ac56dd48Spbrook static char *tcg_get_arg_str_idx(TCGContext *s, char *buf, int buf_size, 855ac56dd48Spbrook int idx) 856c896fe29Sbellard { 857c896fe29Sbellard TCGTemp *ts; 858ac56dd48Spbrook 8597f6f0ae5SStefan Weil assert(idx >= 0 && idx < s->nb_temps); 860ac56dd48Spbrook ts = &s->temps[idx]; 861ac56dd48Spbrook if (idx < s->nb_globals) { 862ac56dd48Spbrook pstrcpy(buf, buf_size, ts->name); 863c896fe29Sbellard } else { 864641d5fbeSbellard if (ts->temp_local) 865641d5fbeSbellard snprintf(buf, buf_size, "loc%d", idx - s->nb_globals); 866641d5fbeSbellard else 867ac56dd48Spbrook snprintf(buf, buf_size, "tmp%d", idx - s->nb_globals); 868c896fe29Sbellard } 869c896fe29Sbellard return buf; 870c896fe29Sbellard } 871c896fe29Sbellard 872a7812ae4Spbrook char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg) 873ac56dd48Spbrook { 874a7812ae4Spbrook return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I32(arg)); 875a7812ae4Spbrook } 876a7812ae4Spbrook 877a7812ae4Spbrook char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg) 878a7812ae4Spbrook { 879a810a2deSblueswir1 return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I64(arg)); 880ac56dd48Spbrook } 881ac56dd48Spbrook 8826e085f72SRichard Henderson /* Find helper name. */ 8836e085f72SRichard Henderson static inline const char *tcg_find_helper(TCGContext *s, uintptr_t val) 884e8996ee0Sbellard { 8856e085f72SRichard Henderson const char *ret = NULL; 8866e085f72SRichard Henderson if (s->helpers) { 8876e085f72SRichard Henderson ret = g_hash_table_lookup(s->helpers, (gpointer)val); 888e8996ee0Sbellard } 8896e085f72SRichard Henderson return ret; 8904dc81f28Sbellard } 8914dc81f28Sbellard 892f48f3edeSblueswir1 static const char * const cond_name[] = 893f48f3edeSblueswir1 { 8940aed257fSRichard Henderson [TCG_COND_NEVER] = "never", 8950aed257fSRichard Henderson [TCG_COND_ALWAYS] = "always", 896f48f3edeSblueswir1 [TCG_COND_EQ] = "eq", 897f48f3edeSblueswir1 [TCG_COND_NE] = "ne", 898f48f3edeSblueswir1 [TCG_COND_LT] = "lt", 899f48f3edeSblueswir1 [TCG_COND_GE] = "ge", 900f48f3edeSblueswir1 [TCG_COND_LE] = "le", 901f48f3edeSblueswir1 [TCG_COND_GT] = "gt", 902f48f3edeSblueswir1 [TCG_COND_LTU] = "ltu", 903f48f3edeSblueswir1 [TCG_COND_GEU] = "geu", 904f48f3edeSblueswir1 [TCG_COND_LEU] = "leu", 905f48f3edeSblueswir1 [TCG_COND_GTU] = "gtu" 906f48f3edeSblueswir1 }; 907f48f3edeSblueswir1 908eeacee4dSBlue Swirl void tcg_dump_ops(TCGContext *s) 909c896fe29Sbellard { 910c896fe29Sbellard const uint16_t *opc_ptr; 911c896fe29Sbellard const TCGArg *args; 912c896fe29Sbellard TCGArg arg; 913a9751609SRichard Henderson TCGOpcode c; 914a9751609SRichard Henderson int i, k, nb_oargs, nb_iargs, nb_cargs, first_insn; 915c896fe29Sbellard const TCGOpDef *def; 916c896fe29Sbellard char buf[128]; 917c896fe29Sbellard 9187e4597d7Sbellard first_insn = 1; 91992414b31SEvgeny Voevodin opc_ptr = s->gen_opc_buf; 9201ff0a2c5SEvgeny Voevodin args = s->gen_opparam_buf; 921efd7f486SEvgeny Voevodin while (opc_ptr < s->gen_opc_ptr) { 922c896fe29Sbellard c = *opc_ptr++; 923c896fe29Sbellard def = &tcg_op_defs[c]; 9247e4597d7Sbellard if (c == INDEX_op_debug_insn_start) { 9257e4597d7Sbellard uint64_t pc; 9267e4597d7Sbellard #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS 9277e4597d7Sbellard pc = ((uint64_t)args[1] << 32) | args[0]; 9287e4597d7Sbellard #else 9297e4597d7Sbellard pc = args[0]; 9307e4597d7Sbellard #endif 931eeacee4dSBlue Swirl if (!first_insn) { 932eeacee4dSBlue Swirl qemu_log("\n"); 933eeacee4dSBlue Swirl } 934eeacee4dSBlue Swirl qemu_log(" ---- 0x%" PRIx64, pc); 9357e4597d7Sbellard first_insn = 0; 9367e4597d7Sbellard nb_oargs = def->nb_oargs; 9377e4597d7Sbellard nb_iargs = def->nb_iargs; 9387e4597d7Sbellard nb_cargs = def->nb_cargs; 9397e4597d7Sbellard } else if (c == INDEX_op_call) { 940c896fe29Sbellard TCGArg arg; 9414dc81f28Sbellard 942c896fe29Sbellard /* variable number of arguments */ 943c896fe29Sbellard arg = *args++; 944c896fe29Sbellard nb_oargs = arg >> 16; 945c896fe29Sbellard nb_iargs = arg & 0xffff; 946c896fe29Sbellard nb_cargs = def->nb_cargs; 947b03cce8eSbellard 948eeacee4dSBlue Swirl qemu_log(" %s ", def->name); 9497e4597d7Sbellard 950b03cce8eSbellard /* function name */ 951eeacee4dSBlue Swirl qemu_log("%s", 952eeacee4dSBlue Swirl tcg_get_arg_str_idx(s, buf, sizeof(buf), 953eeacee4dSBlue Swirl args[nb_oargs + nb_iargs - 1])); 954b03cce8eSbellard /* flags */ 955eeacee4dSBlue Swirl qemu_log(",$0x%" TCG_PRIlx, args[nb_oargs + nb_iargs]); 956b03cce8eSbellard /* nb out args */ 957eeacee4dSBlue Swirl qemu_log(",$%d", nb_oargs); 958b03cce8eSbellard for(i = 0; i < nb_oargs; i++) { 959eeacee4dSBlue Swirl qemu_log(","); 960eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 961eeacee4dSBlue Swirl args[i])); 962b03cce8eSbellard } 963b03cce8eSbellard for(i = 0; i < (nb_iargs - 1); i++) { 964eeacee4dSBlue Swirl qemu_log(","); 96539cf05d3Sbellard if (args[nb_oargs + i] == TCG_CALL_DUMMY_ARG) { 966eeacee4dSBlue Swirl qemu_log("<dummy>"); 96739cf05d3Sbellard } else { 968eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 969eeacee4dSBlue Swirl args[nb_oargs + i])); 970b03cce8eSbellard } 97139cf05d3Sbellard } 972fba3161fSAurelien Jarno } else if (c == INDEX_op_movi_i32 || c == INDEX_op_movi_i64) { 973e8996ee0Sbellard tcg_target_ulong val; 9746e085f72SRichard Henderson const char *name; 975e8996ee0Sbellard 976e8996ee0Sbellard nb_oargs = def->nb_oargs; 977e8996ee0Sbellard nb_iargs = def->nb_iargs; 978e8996ee0Sbellard nb_cargs = def->nb_cargs; 979eeacee4dSBlue Swirl qemu_log(" %s %s,$", def->name, 980e8996ee0Sbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[0])); 981e8996ee0Sbellard val = args[1]; 9826e085f72SRichard Henderson name = tcg_find_helper(s, val); 9836e085f72SRichard Henderson if (name) { 9846e085f72SRichard Henderson qemu_log("%s", name); 985e8996ee0Sbellard } else { 986eeacee4dSBlue Swirl if (c == INDEX_op_movi_i32) { 987eeacee4dSBlue Swirl qemu_log("0x%x", (uint32_t)val); 988eeacee4dSBlue Swirl } else { 989eeacee4dSBlue Swirl qemu_log("0x%" PRIx64 , (uint64_t)val); 990eeacee4dSBlue Swirl } 991e8996ee0Sbellard } 992b03cce8eSbellard } else { 993eeacee4dSBlue Swirl qemu_log(" %s ", def->name); 994b03cce8eSbellard if (c == INDEX_op_nopn) { 995c896fe29Sbellard /* variable number of arguments */ 996c896fe29Sbellard nb_cargs = *args; 997c896fe29Sbellard nb_oargs = 0; 998c896fe29Sbellard nb_iargs = 0; 999c896fe29Sbellard } else { 1000c896fe29Sbellard nb_oargs = def->nb_oargs; 1001c896fe29Sbellard nb_iargs = def->nb_iargs; 1002c896fe29Sbellard nb_cargs = def->nb_cargs; 1003c896fe29Sbellard } 1004c896fe29Sbellard 1005c896fe29Sbellard k = 0; 1006c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1007eeacee4dSBlue Swirl if (k != 0) { 1008eeacee4dSBlue Swirl qemu_log(","); 1009eeacee4dSBlue Swirl } 1010eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 1011eeacee4dSBlue Swirl args[k++])); 1012c896fe29Sbellard } 1013c896fe29Sbellard for(i = 0; i < nb_iargs; i++) { 1014eeacee4dSBlue Swirl if (k != 0) { 1015eeacee4dSBlue Swirl qemu_log(","); 1016eeacee4dSBlue Swirl } 1017eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 1018eeacee4dSBlue Swirl args[k++])); 1019c896fe29Sbellard } 1020be210acbSRichard Henderson switch (c) { 1021be210acbSRichard Henderson case INDEX_op_brcond_i32: 1022ffc5ea09SRichard Henderson case INDEX_op_setcond_i32: 1023ffc5ea09SRichard Henderson case INDEX_op_movcond_i32: 1024be210acbSRichard Henderson case INDEX_op_brcond2_i32: 1025be210acbSRichard Henderson case INDEX_op_setcond2_i32: 1026ffc5ea09SRichard Henderson case INDEX_op_brcond_i64: 1027be210acbSRichard Henderson case INDEX_op_setcond_i64: 1028ffc5ea09SRichard Henderson case INDEX_op_movcond_i64: 1029eeacee4dSBlue Swirl if (args[k] < ARRAY_SIZE(cond_name) && cond_name[args[k]]) { 1030eeacee4dSBlue Swirl qemu_log(",%s", cond_name[args[k++]]); 1031eeacee4dSBlue Swirl } else { 1032eeacee4dSBlue Swirl qemu_log(",$0x%" TCG_PRIlx, args[k++]); 1033eeacee4dSBlue Swirl } 1034f48f3edeSblueswir1 i = 1; 1035be210acbSRichard Henderson break; 1036be210acbSRichard Henderson default: 1037f48f3edeSblueswir1 i = 0; 1038be210acbSRichard Henderson break; 1039be210acbSRichard Henderson } 1040f48f3edeSblueswir1 for(; i < nb_cargs; i++) { 1041eeacee4dSBlue Swirl if (k != 0) { 1042eeacee4dSBlue Swirl qemu_log(","); 1043eeacee4dSBlue Swirl } 1044c896fe29Sbellard arg = args[k++]; 1045eeacee4dSBlue Swirl qemu_log("$0x%" TCG_PRIlx, arg); 1046c896fe29Sbellard } 1047b03cce8eSbellard } 1048eeacee4dSBlue Swirl qemu_log("\n"); 1049c896fe29Sbellard args += nb_iargs + nb_oargs + nb_cargs; 1050c896fe29Sbellard } 1051c896fe29Sbellard } 1052c896fe29Sbellard 1053c896fe29Sbellard /* we give more priority to constraints with less registers */ 1054c896fe29Sbellard static int get_constraint_priority(const TCGOpDef *def, int k) 1055c896fe29Sbellard { 1056c896fe29Sbellard const TCGArgConstraint *arg_ct; 1057c896fe29Sbellard 1058c896fe29Sbellard int i, n; 1059c896fe29Sbellard arg_ct = &def->args_ct[k]; 1060c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 1061c896fe29Sbellard /* an alias is equivalent to a single register */ 1062c896fe29Sbellard n = 1; 1063c896fe29Sbellard } else { 1064c896fe29Sbellard if (!(arg_ct->ct & TCG_CT_REG)) 1065c896fe29Sbellard return 0; 1066c896fe29Sbellard n = 0; 1067c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1068c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, i)) 1069c896fe29Sbellard n++; 1070c896fe29Sbellard } 1071c896fe29Sbellard } 1072c896fe29Sbellard return TCG_TARGET_NB_REGS - n + 1; 1073c896fe29Sbellard } 1074c896fe29Sbellard 1075c896fe29Sbellard /* sort from highest priority to lowest */ 1076c896fe29Sbellard static void sort_constraints(TCGOpDef *def, int start, int n) 1077c896fe29Sbellard { 1078c896fe29Sbellard int i, j, p1, p2, tmp; 1079c896fe29Sbellard 1080c896fe29Sbellard for(i = 0; i < n; i++) 1081c896fe29Sbellard def->sorted_args[start + i] = start + i; 1082c896fe29Sbellard if (n <= 1) 1083c896fe29Sbellard return; 1084c896fe29Sbellard for(i = 0; i < n - 1; i++) { 1085c896fe29Sbellard for(j = i + 1; j < n; j++) { 1086c896fe29Sbellard p1 = get_constraint_priority(def, def->sorted_args[start + i]); 1087c896fe29Sbellard p2 = get_constraint_priority(def, def->sorted_args[start + j]); 1088c896fe29Sbellard if (p1 < p2) { 1089c896fe29Sbellard tmp = def->sorted_args[start + i]; 1090c896fe29Sbellard def->sorted_args[start + i] = def->sorted_args[start + j]; 1091c896fe29Sbellard def->sorted_args[start + j] = tmp; 1092c896fe29Sbellard } 1093c896fe29Sbellard } 1094c896fe29Sbellard } 1095c896fe29Sbellard } 1096c896fe29Sbellard 1097c896fe29Sbellard void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs) 1098c896fe29Sbellard { 1099a9751609SRichard Henderson TCGOpcode op; 1100c896fe29Sbellard TCGOpDef *def; 1101c896fe29Sbellard const char *ct_str; 1102c896fe29Sbellard int i, nb_args; 1103c896fe29Sbellard 1104c896fe29Sbellard for(;;) { 1105a9751609SRichard Henderson if (tdefs->op == (TCGOpcode)-1) 1106c896fe29Sbellard break; 1107c896fe29Sbellard op = tdefs->op; 1108c3b08d0eSStefan Weil assert((unsigned)op < NB_OPS); 1109c896fe29Sbellard def = &tcg_op_defs[op]; 1110c68aaa18SStefan Weil #if defined(CONFIG_DEBUG_TCG) 1111c68aaa18SStefan Weil /* Duplicate entry in op definitions? */ 1112c68aaa18SStefan Weil assert(!def->used); 1113c68aaa18SStefan Weil def->used = 1; 1114c68aaa18SStefan Weil #endif 1115c896fe29Sbellard nb_args = def->nb_iargs + def->nb_oargs; 1116c896fe29Sbellard for(i = 0; i < nb_args; i++) { 1117c896fe29Sbellard ct_str = tdefs->args_ct_str[i]; 1118c68aaa18SStefan Weil /* Incomplete TCGTargetOpDef entry? */ 1119c68aaa18SStefan Weil assert(ct_str != NULL); 1120c896fe29Sbellard tcg_regset_clear(def->args_ct[i].u.regs); 1121c896fe29Sbellard def->args_ct[i].ct = 0; 1122c896fe29Sbellard if (ct_str[0] >= '0' && ct_str[0] <= '9') { 1123c896fe29Sbellard int oarg; 1124c896fe29Sbellard oarg = ct_str[0] - '0'; 1125c896fe29Sbellard assert(oarg < def->nb_oargs); 1126c896fe29Sbellard assert(def->args_ct[oarg].ct & TCG_CT_REG); 1127c896fe29Sbellard /* TCG_CT_ALIAS is for the output arguments. The input 11285ff9d6a4Sbellard argument is tagged with TCG_CT_IALIAS. */ 1129c896fe29Sbellard def->args_ct[i] = def->args_ct[oarg]; 11305ff9d6a4Sbellard def->args_ct[oarg].ct = TCG_CT_ALIAS; 11315ff9d6a4Sbellard def->args_ct[oarg].alias_index = i; 1132c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_IALIAS; 11335ff9d6a4Sbellard def->args_ct[i].alias_index = oarg; 1134c896fe29Sbellard } else { 1135c896fe29Sbellard for(;;) { 1136c896fe29Sbellard if (*ct_str == '\0') 1137c896fe29Sbellard break; 1138c896fe29Sbellard switch(*ct_str) { 1139c896fe29Sbellard case 'i': 1140c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_CONST; 1141c896fe29Sbellard ct_str++; 1142c896fe29Sbellard break; 1143c896fe29Sbellard default: 1144c896fe29Sbellard if (target_parse_constraint(&def->args_ct[i], &ct_str) < 0) { 1145c896fe29Sbellard fprintf(stderr, "Invalid constraint '%s' for arg %d of operation '%s'\n", 1146c896fe29Sbellard ct_str, i, def->name); 1147c896fe29Sbellard exit(1); 1148c896fe29Sbellard } 1149c896fe29Sbellard } 1150c896fe29Sbellard } 1151c896fe29Sbellard } 1152c896fe29Sbellard } 1153c896fe29Sbellard 1154c68aaa18SStefan Weil /* TCGTargetOpDef entry with too much information? */ 1155c68aaa18SStefan Weil assert(i == TCG_MAX_OP_ARGS || tdefs->args_ct_str[i] == NULL); 1156c68aaa18SStefan Weil 1157c896fe29Sbellard /* sort the constraints (XXX: this is just an heuristic) */ 1158c896fe29Sbellard sort_constraints(def, 0, def->nb_oargs); 1159c896fe29Sbellard sort_constraints(def, def->nb_oargs, def->nb_iargs); 1160c896fe29Sbellard 1161c896fe29Sbellard #if 0 1162c896fe29Sbellard { 1163c896fe29Sbellard int i; 1164c896fe29Sbellard 1165c896fe29Sbellard printf("%s: sorted=", def->name); 1166c896fe29Sbellard for(i = 0; i < def->nb_oargs + def->nb_iargs; i++) 1167c896fe29Sbellard printf(" %d", def->sorted_args[i]); 1168c896fe29Sbellard printf("\n"); 1169c896fe29Sbellard } 1170c896fe29Sbellard #endif 1171c896fe29Sbellard tdefs++; 1172c896fe29Sbellard } 1173c896fe29Sbellard 1174c68aaa18SStefan Weil #if defined(CONFIG_DEBUG_TCG) 1175a9751609SRichard Henderson i = 0; 1176c68aaa18SStefan Weil for (op = 0; op < ARRAY_SIZE(tcg_op_defs); op++) { 1177f412c762SRichard Henderson const TCGOpDef *def = &tcg_op_defs[op]; 1178c1a61f6cSRichard Henderson if (def->flags & TCG_OPF_NOT_PRESENT) { 1179c68aaa18SStefan Weil /* Wrong entry in op definitions? */ 1180f412c762SRichard Henderson if (def->used) { 1181f412c762SRichard Henderson fprintf(stderr, "Invalid op definition for %s\n", def->name); 1182a9751609SRichard Henderson i = 1; 1183a9751609SRichard Henderson } 1184c68aaa18SStefan Weil } else { 1185c68aaa18SStefan Weil /* Missing entry in op definitions? */ 1186f412c762SRichard Henderson if (!def->used) { 1187f412c762SRichard Henderson fprintf(stderr, "Missing op definition for %s\n", def->name); 1188a9751609SRichard Henderson i = 1; 1189c68aaa18SStefan Weil } 1190c68aaa18SStefan Weil } 1191a9751609SRichard Henderson } 1192a9751609SRichard Henderson if (i == 1) { 1193a9751609SRichard Henderson tcg_abort(); 1194a9751609SRichard Henderson } 1195c68aaa18SStefan Weil #endif 1196c896fe29Sbellard } 1197c896fe29Sbellard 1198c896fe29Sbellard #ifdef USE_LIVENESS_ANALYSIS 1199c896fe29Sbellard 1200c896fe29Sbellard /* set a nop for an operation using 'nb_args' */ 1201c896fe29Sbellard static inline void tcg_set_nop(TCGContext *s, uint16_t *opc_ptr, 1202c896fe29Sbellard TCGArg *args, int nb_args) 1203c896fe29Sbellard { 1204c896fe29Sbellard if (nb_args == 0) { 1205c896fe29Sbellard *opc_ptr = INDEX_op_nop; 1206c896fe29Sbellard } else { 1207c896fe29Sbellard *opc_ptr = INDEX_op_nopn; 1208c896fe29Sbellard args[0] = nb_args; 1209c896fe29Sbellard args[nb_args - 1] = nb_args; 1210c896fe29Sbellard } 1211c896fe29Sbellard } 1212c896fe29Sbellard 12139c43b68dSAurelien Jarno /* liveness analysis: end of function: all temps are dead, and globals 12149c43b68dSAurelien Jarno should be in memory. */ 12159c43b68dSAurelien Jarno static inline void tcg_la_func_end(TCGContext *s, uint8_t *dead_temps, 12169c43b68dSAurelien Jarno uint8_t *mem_temps) 1217c896fe29Sbellard { 12189c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_temps); 12199c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 12209c43b68dSAurelien Jarno memset(mem_temps + s->nb_globals, 0, s->nb_temps - s->nb_globals); 1221c896fe29Sbellard } 1222c896fe29Sbellard 12239c43b68dSAurelien Jarno /* liveness analysis: end of basic block: all temps are dead, globals 12249c43b68dSAurelien Jarno and local temps should be in memory. */ 12259c43b68dSAurelien Jarno static inline void tcg_la_bb_end(TCGContext *s, uint8_t *dead_temps, 12269c43b68dSAurelien Jarno uint8_t *mem_temps) 1227641d5fbeSbellard { 1228641d5fbeSbellard int i; 1229641d5fbeSbellard 12309c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_temps); 12319c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 1232641d5fbeSbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 12339c43b68dSAurelien Jarno mem_temps[i] = s->temps[i].temp_local; 1234641d5fbeSbellard } 1235641d5fbeSbellard } 1236641d5fbeSbellard 1237866cb6cbSAurelien Jarno /* Liveness analysis : update the opc_dead_args array to tell if a 1238c896fe29Sbellard given input arguments is dead. Instructions updating dead 1239c896fe29Sbellard temporaries are removed. */ 12408fcd3692Sblueswir1 static void tcg_liveness_analysis(TCGContext *s) 1241c896fe29Sbellard { 1242a9751609SRichard Henderson int i, op_index, nb_args, nb_iargs, nb_oargs, arg, nb_ops; 124303271524SRichard Henderson TCGOpcode op, op_new, op_new2; 1244c896fe29Sbellard TCGArg *args; 1245c896fe29Sbellard const TCGOpDef *def; 12469c43b68dSAurelien Jarno uint8_t *dead_temps, *mem_temps; 1247ec7a869dSAurelien Jarno uint16_t dead_args; 1248ec7a869dSAurelien Jarno uint8_t sync_args; 124903271524SRichard Henderson bool have_op_new2; 1250c896fe29Sbellard 1251efd7f486SEvgeny Voevodin s->gen_opc_ptr++; /* skip end */ 1252c896fe29Sbellard 125392414b31SEvgeny Voevodin nb_ops = s->gen_opc_ptr - s->gen_opc_buf; 1254c896fe29Sbellard 1255866cb6cbSAurelien Jarno s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t)); 1256ec7a869dSAurelien Jarno s->op_sync_args = tcg_malloc(nb_ops * sizeof(uint8_t)); 1257c896fe29Sbellard 1258c896fe29Sbellard dead_temps = tcg_malloc(s->nb_temps); 12599c43b68dSAurelien Jarno mem_temps = tcg_malloc(s->nb_temps); 12609c43b68dSAurelien Jarno tcg_la_func_end(s, dead_temps, mem_temps); 1261c896fe29Sbellard 1262c4afe5c4SEvgeny Voevodin args = s->gen_opparam_ptr; 1263c896fe29Sbellard op_index = nb_ops - 1; 1264c896fe29Sbellard while (op_index >= 0) { 126592414b31SEvgeny Voevodin op = s->gen_opc_buf[op_index]; 1266c896fe29Sbellard def = &tcg_op_defs[op]; 1267c896fe29Sbellard switch(op) { 1268c896fe29Sbellard case INDEX_op_call: 1269c6e113f5Sbellard { 1270c6e113f5Sbellard int call_flags; 1271c6e113f5Sbellard 1272c896fe29Sbellard nb_args = args[-1]; 1273c896fe29Sbellard args -= nb_args; 1274c896fe29Sbellard nb_iargs = args[0] & 0xffff; 1275c896fe29Sbellard nb_oargs = args[0] >> 16; 1276c896fe29Sbellard args++; 1277c6e113f5Sbellard call_flags = args[nb_oargs + nb_iargs]; 1278c6e113f5Sbellard 1279c6e113f5Sbellard /* pure functions can be removed if their result is not 1280c6e113f5Sbellard used */ 128178505279SAurelien Jarno if (call_flags & TCG_CALL_NO_SIDE_EFFECTS) { 1282c6e113f5Sbellard for(i = 0; i < nb_oargs; i++) { 1283c6e113f5Sbellard arg = args[i]; 12849c43b68dSAurelien Jarno if (!dead_temps[arg] || mem_temps[arg]) { 1285c6e113f5Sbellard goto do_not_remove_call; 1286c6e113f5Sbellard } 12879c43b68dSAurelien Jarno } 128892414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index, 1289c6e113f5Sbellard args - 1, nb_args); 1290c6e113f5Sbellard } else { 1291c6e113f5Sbellard do_not_remove_call: 1292c896fe29Sbellard 1293c896fe29Sbellard /* output args are dead */ 12946b64b624SAurelien Jarno dead_args = 0; 1295ec7a869dSAurelien Jarno sync_args = 0; 1296c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1297c896fe29Sbellard arg = args[i]; 12986b64b624SAurelien Jarno if (dead_temps[arg]) { 12996b64b624SAurelien Jarno dead_args |= (1 << i); 13006b64b624SAurelien Jarno } 13019c43b68dSAurelien Jarno if (mem_temps[arg]) { 13029c43b68dSAurelien Jarno sync_args |= (1 << i); 13039c43b68dSAurelien Jarno } 1304c896fe29Sbellard dead_temps[arg] = 1; 13059c43b68dSAurelien Jarno mem_temps[arg] = 0; 1306c896fe29Sbellard } 1307c896fe29Sbellard 130878505279SAurelien Jarno if (!(call_flags & TCG_CALL_NO_READ_GLOBALS)) { 130978505279SAurelien Jarno /* globals should be synced to memory */ 131078505279SAurelien Jarno memset(mem_temps, 1, s->nb_globals); 131178505279SAurelien Jarno } 131278505279SAurelien Jarno if (!(call_flags & (TCG_CALL_NO_WRITE_GLOBALS | 131378505279SAurelien Jarno TCG_CALL_NO_READ_GLOBALS))) { 13149c43b68dSAurelien Jarno /* globals should go back to memory */ 13159c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_globals); 1316b9c18f56Saurel32 } 1317c896fe29Sbellard 1318c896fe29Sbellard /* input args are live */ 1319866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 1320866cb6cbSAurelien Jarno arg = args[i]; 132139cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 1322c896fe29Sbellard if (dead_temps[arg]) { 1323866cb6cbSAurelien Jarno dead_args |= (1 << i); 1324c896fe29Sbellard } 1325c896fe29Sbellard dead_temps[arg] = 0; 1326c896fe29Sbellard } 132739cf05d3Sbellard } 1328866cb6cbSAurelien Jarno s->op_dead_args[op_index] = dead_args; 1329ec7a869dSAurelien Jarno s->op_sync_args[op_index] = sync_args; 1330c6e113f5Sbellard } 1331c896fe29Sbellard args--; 1332c6e113f5Sbellard } 1333c896fe29Sbellard break; 13347e4597d7Sbellard case INDEX_op_debug_insn_start: 13357e4597d7Sbellard args -= def->nb_args; 13367e4597d7Sbellard break; 1337c896fe29Sbellard case INDEX_op_nopn: 1338c896fe29Sbellard nb_args = args[-1]; 1339c896fe29Sbellard args -= nb_args; 1340c896fe29Sbellard break; 13415ff9d6a4Sbellard case INDEX_op_discard: 13425ff9d6a4Sbellard args--; 13435ff9d6a4Sbellard /* mark the temporary as dead */ 13445ff9d6a4Sbellard dead_temps[args[0]] = 1; 13459c43b68dSAurelien Jarno mem_temps[args[0]] = 0; 13465ff9d6a4Sbellard break; 1347c896fe29Sbellard case INDEX_op_end: 1348c896fe29Sbellard break; 13491305c451SRichard Henderson 13501305c451SRichard Henderson case INDEX_op_add2_i32: 1351f1fae40cSRichard Henderson op_new = INDEX_op_add_i32; 1352f1fae40cSRichard Henderson goto do_addsub2; 13531305c451SRichard Henderson case INDEX_op_sub2_i32: 1354f1fae40cSRichard Henderson op_new = INDEX_op_sub_i32; 1355f1fae40cSRichard Henderson goto do_addsub2; 1356f1fae40cSRichard Henderson case INDEX_op_add2_i64: 1357f1fae40cSRichard Henderson op_new = INDEX_op_add_i64; 1358f1fae40cSRichard Henderson goto do_addsub2; 1359f1fae40cSRichard Henderson case INDEX_op_sub2_i64: 1360f1fae40cSRichard Henderson op_new = INDEX_op_sub_i64; 1361f1fae40cSRichard Henderson do_addsub2: 13621305c451SRichard Henderson args -= 6; 13631305c451SRichard Henderson nb_iargs = 4; 13641305c451SRichard Henderson nb_oargs = 2; 13651305c451SRichard Henderson /* Test if the high part of the operation is dead, but not 13661305c451SRichard Henderson the low part. The result can be optimized to a simple 13671305c451SRichard Henderson add or sub. This happens often for x86_64 guest when the 13681305c451SRichard Henderson cpu mode is set to 32 bit. */ 13693c5645faSKirill Batuzov if (dead_temps[args[1]] && !mem_temps[args[1]]) { 13703c5645faSKirill Batuzov if (dead_temps[args[0]] && !mem_temps[args[0]]) { 13711305c451SRichard Henderson goto do_remove; 13721305c451SRichard Henderson } 13731305c451SRichard Henderson /* Create the single operation plus nop. */ 1374f1fae40cSRichard Henderson s->gen_opc_buf[op_index] = op = op_new; 13751305c451SRichard Henderson args[1] = args[2]; 13761305c451SRichard Henderson args[2] = args[4]; 137792414b31SEvgeny Voevodin assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop); 137892414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 3); 13791305c451SRichard Henderson /* Fall through and mark the single-word operation live. */ 13801305c451SRichard Henderson nb_iargs = 2; 13811305c451SRichard Henderson nb_oargs = 1; 13821305c451SRichard Henderson } 13831305c451SRichard Henderson goto do_not_remove; 13841305c451SRichard Henderson 13851414968aSRichard Henderson case INDEX_op_mulu2_i32: 138603271524SRichard Henderson op_new = INDEX_op_mul_i32; 138703271524SRichard Henderson op_new2 = INDEX_op_muluh_i32; 138803271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_muluh_i32; 138903271524SRichard Henderson goto do_mul2; 1390f1fae40cSRichard Henderson case INDEX_op_muls2_i32: 1391f1fae40cSRichard Henderson op_new = INDEX_op_mul_i32; 139203271524SRichard Henderson op_new2 = INDEX_op_mulsh_i32; 139303271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_mulsh_i32; 1394f1fae40cSRichard Henderson goto do_mul2; 1395f1fae40cSRichard Henderson case INDEX_op_mulu2_i64: 139603271524SRichard Henderson op_new = INDEX_op_mul_i64; 139703271524SRichard Henderson op_new2 = INDEX_op_muluh_i64; 139803271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_muluh_i64; 139903271524SRichard Henderson goto do_mul2; 1400f1fae40cSRichard Henderson case INDEX_op_muls2_i64: 1401f1fae40cSRichard Henderson op_new = INDEX_op_mul_i64; 140203271524SRichard Henderson op_new2 = INDEX_op_mulsh_i64; 140303271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_mulsh_i64; 140403271524SRichard Henderson goto do_mul2; 1405f1fae40cSRichard Henderson do_mul2: 14061414968aSRichard Henderson args -= 4; 14071414968aSRichard Henderson nb_iargs = 2; 14081414968aSRichard Henderson nb_oargs = 2; 14093c5645faSKirill Batuzov if (dead_temps[args[1]] && !mem_temps[args[1]]) { 14103c5645faSKirill Batuzov if (dead_temps[args[0]] && !mem_temps[args[0]]) { 141103271524SRichard Henderson /* Both parts of the operation are dead. */ 14121414968aSRichard Henderson goto do_remove; 14131414968aSRichard Henderson } 141403271524SRichard Henderson /* The high part of the operation is dead; generate the low. */ 1415f1fae40cSRichard Henderson s->gen_opc_buf[op_index] = op = op_new; 14161414968aSRichard Henderson args[1] = args[2]; 14171414968aSRichard Henderson args[2] = args[3]; 141803271524SRichard Henderson } else if (have_op_new2 && dead_temps[args[0]] 141903271524SRichard Henderson && !mem_temps[args[0]]) { 142003271524SRichard Henderson /* The low part of the operation is dead; generate the high. */ 142103271524SRichard Henderson s->gen_opc_buf[op_index] = op = op_new2; 142203271524SRichard Henderson args[0] = args[1]; 142303271524SRichard Henderson args[1] = args[2]; 142403271524SRichard Henderson args[2] = args[3]; 142503271524SRichard Henderson } else { 142603271524SRichard Henderson goto do_not_remove; 142703271524SRichard Henderson } 142892414b31SEvgeny Voevodin assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop); 142992414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 1); 143003271524SRichard Henderson /* Mark the single-word operation live. */ 14311414968aSRichard Henderson nb_oargs = 1; 14321414968aSRichard Henderson goto do_not_remove; 14331414968aSRichard Henderson 1434c896fe29Sbellard default: 14351305c451SRichard Henderson /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */ 1436c896fe29Sbellard args -= def->nb_args; 1437c896fe29Sbellard nb_iargs = def->nb_iargs; 1438c896fe29Sbellard nb_oargs = def->nb_oargs; 1439c896fe29Sbellard 1440c896fe29Sbellard /* Test if the operation can be removed because all 14415ff9d6a4Sbellard its outputs are dead. We assume that nb_oargs == 0 14425ff9d6a4Sbellard implies side effects */ 14435ff9d6a4Sbellard if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) { 1444c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1445c896fe29Sbellard arg = args[i]; 14469c43b68dSAurelien Jarno if (!dead_temps[arg] || mem_temps[arg]) { 1447c896fe29Sbellard goto do_not_remove; 1448c896fe29Sbellard } 14499c43b68dSAurelien Jarno } 14501305c451SRichard Henderson do_remove: 145192414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index, args, def->nb_args); 1452c896fe29Sbellard #ifdef CONFIG_PROFILER 1453a23a9ec6Sbellard s->del_op_count++; 1454c896fe29Sbellard #endif 1455c896fe29Sbellard } else { 1456c896fe29Sbellard do_not_remove: 1457c896fe29Sbellard 1458c896fe29Sbellard /* output args are dead */ 14596b64b624SAurelien Jarno dead_args = 0; 1460ec7a869dSAurelien Jarno sync_args = 0; 1461c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1462c896fe29Sbellard arg = args[i]; 14636b64b624SAurelien Jarno if (dead_temps[arg]) { 14646b64b624SAurelien Jarno dead_args |= (1 << i); 14656b64b624SAurelien Jarno } 14669c43b68dSAurelien Jarno if (mem_temps[arg]) { 14679c43b68dSAurelien Jarno sync_args |= (1 << i); 14689c43b68dSAurelien Jarno } 1469c896fe29Sbellard dead_temps[arg] = 1; 14709c43b68dSAurelien Jarno mem_temps[arg] = 0; 1471c896fe29Sbellard } 1472c896fe29Sbellard 1473c896fe29Sbellard /* if end of basic block, update */ 1474c896fe29Sbellard if (def->flags & TCG_OPF_BB_END) { 14759c43b68dSAurelien Jarno tcg_la_bb_end(s, dead_temps, mem_temps); 14763d5c5f87SAurelien Jarno } else if (def->flags & TCG_OPF_SIDE_EFFECTS) { 14773d5c5f87SAurelien Jarno /* globals should be synced to memory */ 14789c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 1479c896fe29Sbellard } 1480c896fe29Sbellard 1481c896fe29Sbellard /* input args are live */ 1482866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 1483866cb6cbSAurelien Jarno arg = args[i]; 1484c896fe29Sbellard if (dead_temps[arg]) { 1485866cb6cbSAurelien Jarno dead_args |= (1 << i); 1486c896fe29Sbellard } 1487c896fe29Sbellard dead_temps[arg] = 0; 1488c896fe29Sbellard } 1489866cb6cbSAurelien Jarno s->op_dead_args[op_index] = dead_args; 1490ec7a869dSAurelien Jarno s->op_sync_args[op_index] = sync_args; 1491c896fe29Sbellard } 1492c896fe29Sbellard break; 1493c896fe29Sbellard } 1494c896fe29Sbellard op_index--; 1495c896fe29Sbellard } 1496c896fe29Sbellard 14971ff0a2c5SEvgeny Voevodin if (args != s->gen_opparam_buf) { 1498c896fe29Sbellard tcg_abort(); 1499c896fe29Sbellard } 15001ff0a2c5SEvgeny Voevodin } 1501c896fe29Sbellard #else 1502c896fe29Sbellard /* dummy liveness analysis */ 1503655feed5Smalc static void tcg_liveness_analysis(TCGContext *s) 1504c896fe29Sbellard { 1505c896fe29Sbellard int nb_ops; 150692414b31SEvgeny Voevodin nb_ops = s->gen_opc_ptr - s->gen_opc_buf; 1507c896fe29Sbellard 1508866cb6cbSAurelien Jarno s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t)); 1509866cb6cbSAurelien Jarno memset(s->op_dead_args, 0, nb_ops * sizeof(uint16_t)); 1510ec7a869dSAurelien Jarno s->op_sync_args = tcg_malloc(nb_ops * sizeof(uint8_t)); 1511ec7a869dSAurelien Jarno memset(s->op_sync_args, 0, nb_ops * sizeof(uint8_t)); 1512c896fe29Sbellard } 1513c896fe29Sbellard #endif 1514c896fe29Sbellard 1515c896fe29Sbellard #ifndef NDEBUG 1516c896fe29Sbellard static void dump_regs(TCGContext *s) 1517c896fe29Sbellard { 1518c896fe29Sbellard TCGTemp *ts; 1519c896fe29Sbellard int i; 1520c896fe29Sbellard char buf[64]; 1521c896fe29Sbellard 1522c896fe29Sbellard for(i = 0; i < s->nb_temps; i++) { 1523c896fe29Sbellard ts = &s->temps[i]; 1524ac56dd48Spbrook printf(" %10s: ", tcg_get_arg_str_idx(s, buf, sizeof(buf), i)); 1525c896fe29Sbellard switch(ts->val_type) { 1526c896fe29Sbellard case TEMP_VAL_REG: 1527c896fe29Sbellard printf("%s", tcg_target_reg_names[ts->reg]); 1528c896fe29Sbellard break; 1529c896fe29Sbellard case TEMP_VAL_MEM: 1530c896fe29Sbellard printf("%d(%s)", (int)ts->mem_offset, tcg_target_reg_names[ts->mem_reg]); 1531c896fe29Sbellard break; 1532c896fe29Sbellard case TEMP_VAL_CONST: 1533c896fe29Sbellard printf("$0x%" TCG_PRIlx, ts->val); 1534c896fe29Sbellard break; 1535c896fe29Sbellard case TEMP_VAL_DEAD: 1536c896fe29Sbellard printf("D"); 1537c896fe29Sbellard break; 1538c896fe29Sbellard default: 1539c896fe29Sbellard printf("???"); 1540c896fe29Sbellard break; 1541c896fe29Sbellard } 1542c896fe29Sbellard printf("\n"); 1543c896fe29Sbellard } 1544c896fe29Sbellard 1545c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1546c896fe29Sbellard if (s->reg_to_temp[i] >= 0) { 1547c896fe29Sbellard printf("%s: %s\n", 1548c896fe29Sbellard tcg_target_reg_names[i], 1549ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), s->reg_to_temp[i])); 1550c896fe29Sbellard } 1551c896fe29Sbellard } 1552c896fe29Sbellard } 1553c896fe29Sbellard 1554c896fe29Sbellard static void check_regs(TCGContext *s) 1555c896fe29Sbellard { 1556c896fe29Sbellard int reg, k; 1557c896fe29Sbellard TCGTemp *ts; 1558c896fe29Sbellard char buf[64]; 1559c896fe29Sbellard 1560c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1561c896fe29Sbellard k = s->reg_to_temp[reg]; 1562c896fe29Sbellard if (k >= 0) { 1563c896fe29Sbellard ts = &s->temps[k]; 1564c896fe29Sbellard if (ts->val_type != TEMP_VAL_REG || 1565c896fe29Sbellard ts->reg != reg) { 1566c896fe29Sbellard printf("Inconsistency for register %s:\n", 1567c896fe29Sbellard tcg_target_reg_names[reg]); 1568b03cce8eSbellard goto fail; 1569c896fe29Sbellard } 1570c896fe29Sbellard } 1571c896fe29Sbellard } 1572c896fe29Sbellard for(k = 0; k < s->nb_temps; k++) { 1573c896fe29Sbellard ts = &s->temps[k]; 1574c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG && 1575c896fe29Sbellard !ts->fixed_reg && 1576c896fe29Sbellard s->reg_to_temp[ts->reg] != k) { 1577c896fe29Sbellard printf("Inconsistency for temp %s:\n", 1578ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), k)); 1579b03cce8eSbellard fail: 1580c896fe29Sbellard printf("reg state:\n"); 1581c896fe29Sbellard dump_regs(s); 1582c896fe29Sbellard tcg_abort(); 1583c896fe29Sbellard } 1584c896fe29Sbellard } 1585c896fe29Sbellard } 1586c896fe29Sbellard #endif 1587c896fe29Sbellard 1588c896fe29Sbellard static void temp_allocate_frame(TCGContext *s, int temp) 1589c896fe29Sbellard { 1590c896fe29Sbellard TCGTemp *ts; 1591c896fe29Sbellard ts = &s->temps[temp]; 15929b9c37c3SRichard Henderson #if !(defined(__sparc__) && TCG_TARGET_REG_BITS == 64) 15939b9c37c3SRichard Henderson /* Sparc64 stack is accessed with offset of 2047 */ 1594b591dc59SBlue Swirl s->current_frame_offset = (s->current_frame_offset + 1595b591dc59SBlue Swirl (tcg_target_long)sizeof(tcg_target_long) - 1) & 1596b591dc59SBlue Swirl ~(sizeof(tcg_target_long) - 1); 1597f44c9960SBlue Swirl #endif 1598b591dc59SBlue Swirl if (s->current_frame_offset + (tcg_target_long)sizeof(tcg_target_long) > 1599b591dc59SBlue Swirl s->frame_end) { 16005ff9d6a4Sbellard tcg_abort(); 1601b591dc59SBlue Swirl } 1602c896fe29Sbellard ts->mem_offset = s->current_frame_offset; 1603c896fe29Sbellard ts->mem_reg = s->frame_reg; 1604c896fe29Sbellard ts->mem_allocated = 1; 1605e2c6d1b4SRichard Henderson s->current_frame_offset += sizeof(tcg_target_long); 1606c896fe29Sbellard } 1607c896fe29Sbellard 16087f6ceedfSAurelien Jarno /* sync register 'reg' by saving it to the corresponding temporary */ 16097f6ceedfSAurelien Jarno static inline void tcg_reg_sync(TCGContext *s, int reg) 1610c896fe29Sbellard { 1611c896fe29Sbellard TCGTemp *ts; 1612c896fe29Sbellard int temp; 1613c896fe29Sbellard 1614c896fe29Sbellard temp = s->reg_to_temp[reg]; 1615c896fe29Sbellard ts = &s->temps[temp]; 1616c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 16177f6ceedfSAurelien Jarno if (!ts->mem_coherent && !ts->fixed_reg) { 16187f6ceedfSAurelien Jarno if (!ts->mem_allocated) { 1619c896fe29Sbellard temp_allocate_frame(s, temp); 16207f6ceedfSAurelien Jarno } 1621e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1622c896fe29Sbellard } 16237f6ceedfSAurelien Jarno ts->mem_coherent = 1; 16247f6ceedfSAurelien Jarno } 16257f6ceedfSAurelien Jarno 16267f6ceedfSAurelien Jarno /* free register 'reg' by spilling the corresponding temporary if necessary */ 16277f6ceedfSAurelien Jarno static void tcg_reg_free(TCGContext *s, int reg) 16287f6ceedfSAurelien Jarno { 16297f6ceedfSAurelien Jarno int temp; 16307f6ceedfSAurelien Jarno 16317f6ceedfSAurelien Jarno temp = s->reg_to_temp[reg]; 16327f6ceedfSAurelien Jarno if (temp != -1) { 16337f6ceedfSAurelien Jarno tcg_reg_sync(s, reg); 16347f6ceedfSAurelien Jarno s->temps[temp].val_type = TEMP_VAL_MEM; 1635c896fe29Sbellard s->reg_to_temp[reg] = -1; 1636c896fe29Sbellard } 1637c896fe29Sbellard } 1638c896fe29Sbellard 1639c896fe29Sbellard /* Allocate a register belonging to reg1 & ~reg2 */ 1640c896fe29Sbellard static int tcg_reg_alloc(TCGContext *s, TCGRegSet reg1, TCGRegSet reg2) 1641c896fe29Sbellard { 1642c896fe29Sbellard int i, reg; 1643c896fe29Sbellard TCGRegSet reg_ct; 1644c896fe29Sbellard 1645c896fe29Sbellard tcg_regset_andnot(reg_ct, reg1, reg2); 1646c896fe29Sbellard 1647c896fe29Sbellard /* first try free registers */ 16480954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1649c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1650c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg) && s->reg_to_temp[reg] == -1) 1651c896fe29Sbellard return reg; 1652c896fe29Sbellard } 1653c896fe29Sbellard 1654c896fe29Sbellard /* XXX: do better spill choice */ 16550954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1656c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1657c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg)) { 1658c896fe29Sbellard tcg_reg_free(s, reg); 1659c896fe29Sbellard return reg; 1660c896fe29Sbellard } 1661c896fe29Sbellard } 1662c896fe29Sbellard 1663c896fe29Sbellard tcg_abort(); 1664c896fe29Sbellard } 1665c896fe29Sbellard 1666639368ddSAurelien Jarno /* mark a temporary as dead. */ 1667639368ddSAurelien Jarno static inline void temp_dead(TCGContext *s, int temp) 1668639368ddSAurelien Jarno { 1669639368ddSAurelien Jarno TCGTemp *ts; 1670639368ddSAurelien Jarno 1671639368ddSAurelien Jarno ts = &s->temps[temp]; 1672639368ddSAurelien Jarno if (!ts->fixed_reg) { 1673639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 1674639368ddSAurelien Jarno s->reg_to_temp[ts->reg] = -1; 1675639368ddSAurelien Jarno } 1676e5138db5SAurelien Jarno if (temp < s->nb_globals || ts->temp_local) { 1677639368ddSAurelien Jarno ts->val_type = TEMP_VAL_MEM; 1678639368ddSAurelien Jarno } else { 1679639368ddSAurelien Jarno ts->val_type = TEMP_VAL_DEAD; 1680639368ddSAurelien Jarno } 1681639368ddSAurelien Jarno } 1682639368ddSAurelien Jarno } 1683639368ddSAurelien Jarno 16841ad80729SAurelien Jarno /* sync a temporary to memory. 'allocated_regs' is used in case a 1685e8996ee0Sbellard temporary registers needs to be allocated to store a constant. */ 16861ad80729SAurelien Jarno static inline void temp_sync(TCGContext *s, int temp, TCGRegSet allocated_regs) 1687c896fe29Sbellard { 1688c896fe29Sbellard TCGTemp *ts; 1689c896fe29Sbellard 1690641d5fbeSbellard ts = &s->temps[temp]; 1691c896fe29Sbellard if (!ts->fixed_reg) { 1692e8996ee0Sbellard switch(ts->val_type) { 16931ad80729SAurelien Jarno case TEMP_VAL_CONST: 16941ad80729SAurelien Jarno ts->reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 16951ad80729SAurelien Jarno allocated_regs); 16961ad80729SAurelien Jarno ts->val_type = TEMP_VAL_REG; 16971ad80729SAurelien Jarno s->reg_to_temp[ts->reg] = temp; 16981ad80729SAurelien Jarno ts->mem_coherent = 0; 16991ad80729SAurelien Jarno tcg_out_movi(s, ts->type, ts->reg, ts->val); 17001ad80729SAurelien Jarno /* fallthrough*/ 1701e8996ee0Sbellard case TEMP_VAL_REG: 17021ad80729SAurelien Jarno tcg_reg_sync(s, ts->reg); 1703e8996ee0Sbellard break; 1704e8996ee0Sbellard case TEMP_VAL_DEAD: 1705e8996ee0Sbellard case TEMP_VAL_MEM: 1706e8996ee0Sbellard break; 1707e8996ee0Sbellard default: 1708e8996ee0Sbellard tcg_abort(); 1709c896fe29Sbellard } 1710c896fe29Sbellard } 1711c896fe29Sbellard } 1712641d5fbeSbellard 17131ad80729SAurelien Jarno /* save a temporary to memory. 'allocated_regs' is used in case a 17141ad80729SAurelien Jarno temporary registers needs to be allocated to store a constant. */ 17151ad80729SAurelien Jarno static inline void temp_save(TCGContext *s, int temp, TCGRegSet allocated_regs) 17161ad80729SAurelien Jarno { 17172c0366f0SAurelien Jarno #ifdef USE_LIVENESS_ANALYSIS 17182c0366f0SAurelien Jarno /* The liveness analysis already ensures that globals are back 17192c0366f0SAurelien Jarno in memory. Keep an assert for safety. */ 17202c0366f0SAurelien Jarno assert(s->temps[temp].val_type == TEMP_VAL_MEM || s->temps[temp].fixed_reg); 17212c0366f0SAurelien Jarno #else 17221ad80729SAurelien Jarno temp_sync(s, temp, allocated_regs); 17231ad80729SAurelien Jarno temp_dead(s, temp); 17242c0366f0SAurelien Jarno #endif 17251ad80729SAurelien Jarno } 17261ad80729SAurelien Jarno 17279814dd27SDong Xu Wang /* save globals to their canonical location and assume they can be 1728641d5fbeSbellard modified be the following code. 'allocated_regs' is used in case a 1729641d5fbeSbellard temporary registers needs to be allocated to store a constant. */ 1730641d5fbeSbellard static void save_globals(TCGContext *s, TCGRegSet allocated_regs) 1731641d5fbeSbellard { 1732641d5fbeSbellard int i; 1733641d5fbeSbellard 1734641d5fbeSbellard for(i = 0; i < s->nb_globals; i++) { 1735641d5fbeSbellard temp_save(s, i, allocated_regs); 1736641d5fbeSbellard } 1737e5097dc8Sbellard } 1738e5097dc8Sbellard 17393d5c5f87SAurelien Jarno /* sync globals to their canonical location and assume they can be 17403d5c5f87SAurelien Jarno read by the following code. 'allocated_regs' is used in case a 17413d5c5f87SAurelien Jarno temporary registers needs to be allocated to store a constant. */ 17423d5c5f87SAurelien Jarno static void sync_globals(TCGContext *s, TCGRegSet allocated_regs) 17433d5c5f87SAurelien Jarno { 17443d5c5f87SAurelien Jarno int i; 17453d5c5f87SAurelien Jarno 17463d5c5f87SAurelien Jarno for (i = 0; i < s->nb_globals; i++) { 17473d5c5f87SAurelien Jarno #ifdef USE_LIVENESS_ANALYSIS 17483d5c5f87SAurelien Jarno assert(s->temps[i].val_type != TEMP_VAL_REG || s->temps[i].fixed_reg || 17493d5c5f87SAurelien Jarno s->temps[i].mem_coherent); 17503d5c5f87SAurelien Jarno #else 17513d5c5f87SAurelien Jarno temp_sync(s, i, allocated_regs); 17523d5c5f87SAurelien Jarno #endif 17533d5c5f87SAurelien Jarno } 17543d5c5f87SAurelien Jarno } 17553d5c5f87SAurelien Jarno 1756e5097dc8Sbellard /* at the end of a basic block, we assume all temporaries are dead and 1757e8996ee0Sbellard all globals are stored at their canonical location. */ 1758e8996ee0Sbellard static void tcg_reg_alloc_bb_end(TCGContext *s, TCGRegSet allocated_regs) 1759e5097dc8Sbellard { 1760e5097dc8Sbellard TCGTemp *ts; 1761e5097dc8Sbellard int i; 1762e5097dc8Sbellard 1763c896fe29Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 1764c896fe29Sbellard ts = &s->temps[i]; 1765641d5fbeSbellard if (ts->temp_local) { 1766641d5fbeSbellard temp_save(s, i, allocated_regs); 1767641d5fbeSbellard } else { 17682c0366f0SAurelien Jarno #ifdef USE_LIVENESS_ANALYSIS 17692c0366f0SAurelien Jarno /* The liveness analysis already ensures that temps are dead. 17702c0366f0SAurelien Jarno Keep an assert for safety. */ 17712c0366f0SAurelien Jarno assert(ts->val_type == TEMP_VAL_DEAD); 17722c0366f0SAurelien Jarno #else 1773639368ddSAurelien Jarno temp_dead(s, i); 17742c0366f0SAurelien Jarno #endif 1775c896fe29Sbellard } 1776641d5fbeSbellard } 1777e8996ee0Sbellard 1778e8996ee0Sbellard save_globals(s, allocated_regs); 1779c896fe29Sbellard } 1780c896fe29Sbellard 1781866cb6cbSAurelien Jarno #define IS_DEAD_ARG(n) ((dead_args >> (n)) & 1) 1782ec7a869dSAurelien Jarno #define NEED_SYNC_ARG(n) ((sync_args >> (n)) & 1) 1783c896fe29Sbellard 1784ec7a869dSAurelien Jarno static void tcg_reg_alloc_movi(TCGContext *s, const TCGArg *args, 1785ec7a869dSAurelien Jarno uint16_t dead_args, uint8_t sync_args) 1786e8996ee0Sbellard { 1787e8996ee0Sbellard TCGTemp *ots; 1788e8996ee0Sbellard tcg_target_ulong val; 1789e8996ee0Sbellard 1790e8996ee0Sbellard ots = &s->temps[args[0]]; 1791e8996ee0Sbellard val = args[1]; 1792e8996ee0Sbellard 1793e8996ee0Sbellard if (ots->fixed_reg) { 1794e8996ee0Sbellard /* for fixed registers, we do not do any constant 1795e8996ee0Sbellard propagation */ 1796e8996ee0Sbellard tcg_out_movi(s, ots->type, ots->reg, val); 1797e8996ee0Sbellard } else { 17981235fc06Sths /* The movi is not explicitly generated here */ 1799e8996ee0Sbellard if (ots->val_type == TEMP_VAL_REG) 1800e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 1801e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 1802e8996ee0Sbellard ots->val = val; 1803e8996ee0Sbellard } 1804ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(0)) { 1805ec7a869dSAurelien Jarno temp_sync(s, args[0], s->reserved_regs); 1806ec7a869dSAurelien Jarno } 18074c4e1ab2SAurelien Jarno if (IS_DEAD_ARG(0)) { 18084c4e1ab2SAurelien Jarno temp_dead(s, args[0]); 18094c4e1ab2SAurelien Jarno } 1810e8996ee0Sbellard } 1811e8996ee0Sbellard 1812c896fe29Sbellard static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def, 1813ec7a869dSAurelien Jarno const TCGArg *args, uint16_t dead_args, 1814ec7a869dSAurelien Jarno uint8_t sync_args) 1815c896fe29Sbellard { 1816c29c1d7eSAurelien Jarno TCGRegSet allocated_regs; 1817c896fe29Sbellard TCGTemp *ts, *ots; 1818c29c1d7eSAurelien Jarno const TCGArgConstraint *arg_ct, *oarg_ct; 1819c896fe29Sbellard 1820c29c1d7eSAurelien Jarno tcg_regset_set(allocated_regs, s->reserved_regs); 1821c896fe29Sbellard ots = &s->temps[args[0]]; 1822c896fe29Sbellard ts = &s->temps[args[1]]; 1823c29c1d7eSAurelien Jarno oarg_ct = &def->args_ct[0]; 1824c29c1d7eSAurelien Jarno arg_ct = &def->args_ct[1]; 1825c896fe29Sbellard 1826c29c1d7eSAurelien Jarno /* If the source value is not in a register, and we're going to be 1827c29c1d7eSAurelien Jarno forced to have it in a register in order to perform the copy, 1828c29c1d7eSAurelien Jarno then copy the SOURCE value into its own register first. That way 1829c29c1d7eSAurelien Jarno we don't have to reload SOURCE the next time it is used. */ 1830c29c1d7eSAurelien Jarno if (((NEED_SYNC_ARG(0) || ots->fixed_reg) && ts->val_type != TEMP_VAL_REG) 1831c29c1d7eSAurelien Jarno || ts->val_type == TEMP_VAL_MEM) { 1832c29c1d7eSAurelien Jarno ts->reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1833c29c1d7eSAurelien Jarno if (ts->val_type == TEMP_VAL_MEM) { 1834c29c1d7eSAurelien Jarno tcg_out_ld(s, ts->type, ts->reg, ts->mem_reg, ts->mem_offset); 1835c29c1d7eSAurelien Jarno ts->mem_coherent = 1; 1836c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1837c29c1d7eSAurelien Jarno tcg_out_movi(s, ts->type, ts->reg, ts->val); 1838c29c1d7eSAurelien Jarno } 1839c29c1d7eSAurelien Jarno s->reg_to_temp[ts->reg] = args[1]; 1840c29c1d7eSAurelien Jarno ts->val_type = TEMP_VAL_REG; 1841c29c1d7eSAurelien Jarno } 1842c29c1d7eSAurelien Jarno 1843c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(0) && !ots->fixed_reg) { 1844c29c1d7eSAurelien Jarno /* mov to a non-saved dead register makes no sense (even with 1845c29c1d7eSAurelien Jarno liveness analysis disabled). */ 1846c29c1d7eSAurelien Jarno assert(NEED_SYNC_ARG(0)); 1847c29c1d7eSAurelien Jarno /* The code above should have moved the temp to a register. */ 1848c29c1d7eSAurelien Jarno assert(ts->val_type == TEMP_VAL_REG); 1849c29c1d7eSAurelien Jarno if (!ots->mem_allocated) { 1850c29c1d7eSAurelien Jarno temp_allocate_frame(s, args[0]); 1851c29c1d7eSAurelien Jarno } 1852c29c1d7eSAurelien Jarno tcg_out_st(s, ots->type, ts->reg, ots->mem_reg, ots->mem_offset); 1853c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(1)) { 1854c29c1d7eSAurelien Jarno temp_dead(s, args[1]); 1855c29c1d7eSAurelien Jarno } 1856c29c1d7eSAurelien Jarno temp_dead(s, args[0]); 1857c29c1d7eSAurelien Jarno } else if (ts->val_type == TEMP_VAL_CONST) { 1858e8996ee0Sbellard /* propagate constant */ 1859c29c1d7eSAurelien Jarno if (ots->val_type == TEMP_VAL_REG) { 1860e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 1861c29c1d7eSAurelien Jarno } 1862e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 1863e8996ee0Sbellard ots->val = ts->val; 1864e8996ee0Sbellard } else { 1865c29c1d7eSAurelien Jarno /* The code in the first if block should have moved the 1866c29c1d7eSAurelien Jarno temp to a register. */ 1867c29c1d7eSAurelien Jarno assert(ts->val_type == TEMP_VAL_REG); 1868c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(1) && !ts->fixed_reg && !ots->fixed_reg) { 1869c29c1d7eSAurelien Jarno /* the mov can be suppressed */ 1870c29c1d7eSAurelien Jarno if (ots->val_type == TEMP_VAL_REG) { 1871c29c1d7eSAurelien Jarno s->reg_to_temp[ots->reg] = -1; 1872c896fe29Sbellard } 1873c29c1d7eSAurelien Jarno ots->reg = ts->reg; 1874c29c1d7eSAurelien Jarno temp_dead(s, args[1]); 1875c29c1d7eSAurelien Jarno } else { 1876c29c1d7eSAurelien Jarno if (ots->val_type != TEMP_VAL_REG) { 1877c29c1d7eSAurelien Jarno /* When allocating a new register, make sure to not spill the 1878c29c1d7eSAurelien Jarno input one. */ 1879c29c1d7eSAurelien Jarno tcg_regset_set_reg(allocated_regs, ts->reg); 1880c29c1d7eSAurelien Jarno ots->reg = tcg_reg_alloc(s, oarg_ct->u.regs, allocated_regs); 1881c29c1d7eSAurelien Jarno } 1882c29c1d7eSAurelien Jarno tcg_out_mov(s, ots->type, ots->reg, ts->reg); 1883c29c1d7eSAurelien Jarno } 1884c896fe29Sbellard ots->val_type = TEMP_VAL_REG; 1885c896fe29Sbellard ots->mem_coherent = 0; 1886c29c1d7eSAurelien Jarno s->reg_to_temp[ots->reg] = args[0]; 1887ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(0)) { 1888c29c1d7eSAurelien Jarno tcg_reg_sync(s, ots->reg); 1889c29c1d7eSAurelien Jarno } 1890ec7a869dSAurelien Jarno } 1891c896fe29Sbellard } 1892c896fe29Sbellard 1893c896fe29Sbellard static void tcg_reg_alloc_op(TCGContext *s, 1894a9751609SRichard Henderson const TCGOpDef *def, TCGOpcode opc, 1895ec7a869dSAurelien Jarno const TCGArg *args, uint16_t dead_args, 1896ec7a869dSAurelien Jarno uint8_t sync_args) 1897c896fe29Sbellard { 1898c896fe29Sbellard TCGRegSet allocated_regs; 1899c896fe29Sbellard int i, k, nb_iargs, nb_oargs, reg; 1900c896fe29Sbellard TCGArg arg; 1901c896fe29Sbellard const TCGArgConstraint *arg_ct; 1902c896fe29Sbellard TCGTemp *ts; 1903c896fe29Sbellard TCGArg new_args[TCG_MAX_OP_ARGS]; 1904c896fe29Sbellard int const_args[TCG_MAX_OP_ARGS]; 1905c896fe29Sbellard 1906c896fe29Sbellard nb_oargs = def->nb_oargs; 1907c896fe29Sbellard nb_iargs = def->nb_iargs; 1908c896fe29Sbellard 1909c896fe29Sbellard /* copy constants */ 1910c896fe29Sbellard memcpy(new_args + nb_oargs + nb_iargs, 1911c896fe29Sbellard args + nb_oargs + nb_iargs, 1912c896fe29Sbellard sizeof(TCGArg) * def->nb_cargs); 1913c896fe29Sbellard 1914c896fe29Sbellard /* satisfy input constraints */ 1915c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 1916c896fe29Sbellard for(k = 0; k < nb_iargs; k++) { 1917c896fe29Sbellard i = def->sorted_args[nb_oargs + k]; 1918c896fe29Sbellard arg = args[i]; 1919c896fe29Sbellard arg_ct = &def->args_ct[i]; 1920c896fe29Sbellard ts = &s->temps[arg]; 1921c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 1922c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1923e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1924c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 1925c896fe29Sbellard ts->reg = reg; 1926c896fe29Sbellard ts->mem_coherent = 1; 1927c896fe29Sbellard s->reg_to_temp[reg] = arg; 1928c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1929c896fe29Sbellard if (tcg_target_const_match(ts->val, arg_ct)) { 1930c896fe29Sbellard /* constant is OK for instruction */ 1931c896fe29Sbellard const_args[i] = 1; 1932c896fe29Sbellard new_args[i] = ts->val; 1933c896fe29Sbellard goto iarg_end; 1934c896fe29Sbellard } else { 1935c896fe29Sbellard /* need to move to a register */ 1936c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1937c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1938e8996ee0Sbellard ts->val_type = TEMP_VAL_REG; 1939e8996ee0Sbellard ts->reg = reg; 1940e8996ee0Sbellard ts->mem_coherent = 0; 1941e8996ee0Sbellard s->reg_to_temp[reg] = arg; 1942c896fe29Sbellard } 1943c896fe29Sbellard } 1944c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 19455ff9d6a4Sbellard if (arg_ct->ct & TCG_CT_IALIAS) { 19465ff9d6a4Sbellard if (ts->fixed_reg) { 19475ff9d6a4Sbellard /* if fixed register, we must allocate a new register 19485ff9d6a4Sbellard if the alias is not the same register */ 19495ff9d6a4Sbellard if (arg != args[arg_ct->alias_index]) 19505ff9d6a4Sbellard goto allocate_in_reg; 19515ff9d6a4Sbellard } else { 1952c896fe29Sbellard /* if the input is aliased to an output and if it is 1953c896fe29Sbellard not dead after the instruction, we must allocate 1954c896fe29Sbellard a new register and move it */ 1955866cb6cbSAurelien Jarno if (!IS_DEAD_ARG(i)) { 1956c896fe29Sbellard goto allocate_in_reg; 1957c896fe29Sbellard } 19585ff9d6a4Sbellard } 1959866cb6cbSAurelien Jarno } 1960c896fe29Sbellard reg = ts->reg; 1961c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1962c896fe29Sbellard /* nothing to do : the constraint is satisfied */ 1963c896fe29Sbellard } else { 1964c896fe29Sbellard allocate_in_reg: 1965c896fe29Sbellard /* allocate a new register matching the constraint 1966c896fe29Sbellard and move the temporary register into it */ 1967c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 19683b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 1969c896fe29Sbellard } 1970c896fe29Sbellard new_args[i] = reg; 1971c896fe29Sbellard const_args[i] = 0; 1972c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 1973c896fe29Sbellard iarg_end: ; 1974c896fe29Sbellard } 1975c896fe29Sbellard 1976c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 1977866cb6cbSAurelien Jarno for (i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 1978866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 1979639368ddSAurelien Jarno temp_dead(s, args[i]); 1980c896fe29Sbellard } 1981c896fe29Sbellard } 1982c896fe29Sbellard 1983a52ad07eSAurelien Jarno if (def->flags & TCG_OPF_BB_END) { 1984a52ad07eSAurelien Jarno tcg_reg_alloc_bb_end(s, allocated_regs); 1985a52ad07eSAurelien Jarno } else { 1986c896fe29Sbellard if (def->flags & TCG_OPF_CALL_CLOBBER) { 1987b03cce8eSbellard /* XXX: permit generic clobber register list ? */ 1988c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1989c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 1990c896fe29Sbellard tcg_reg_free(s, reg); 1991c896fe29Sbellard } 1992c896fe29Sbellard } 19933d5c5f87SAurelien Jarno } 19943d5c5f87SAurelien Jarno if (def->flags & TCG_OPF_SIDE_EFFECTS) { 19953d5c5f87SAurelien Jarno /* sync globals if the op has side effects and might trigger 19963d5c5f87SAurelien Jarno an exception. */ 19973d5c5f87SAurelien Jarno sync_globals(s, allocated_regs); 1998c896fe29Sbellard } 1999c896fe29Sbellard 2000c896fe29Sbellard /* satisfy the output constraints */ 2001c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 2002c896fe29Sbellard for(k = 0; k < nb_oargs; k++) { 2003c896fe29Sbellard i = def->sorted_args[k]; 2004c896fe29Sbellard arg = args[i]; 2005c896fe29Sbellard arg_ct = &def->args_ct[i]; 2006c896fe29Sbellard ts = &s->temps[arg]; 2007c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 20085ff9d6a4Sbellard reg = new_args[arg_ct->alias_index]; 2009c896fe29Sbellard } else { 2010c896fe29Sbellard /* if fixed register, we try to use it */ 2011c896fe29Sbellard reg = ts->reg; 2012c896fe29Sbellard if (ts->fixed_reg && 2013c896fe29Sbellard tcg_regset_test_reg(arg_ct->u.regs, reg)) { 2014c896fe29Sbellard goto oarg_end; 2015c896fe29Sbellard } 2016c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2017c896fe29Sbellard } 2018c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 2019c896fe29Sbellard /* if a fixed register is used, then a move will be done afterwards */ 2020c896fe29Sbellard if (!ts->fixed_reg) { 2021639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 2022639368ddSAurelien Jarno s->reg_to_temp[ts->reg] = -1; 2023639368ddSAurelien Jarno } 2024c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 2025c896fe29Sbellard ts->reg = reg; 2026c896fe29Sbellard /* temp value is modified, so the value kept in memory is 2027c896fe29Sbellard potentially not the same */ 2028c896fe29Sbellard ts->mem_coherent = 0; 2029c896fe29Sbellard s->reg_to_temp[reg] = arg; 2030c896fe29Sbellard } 2031c896fe29Sbellard oarg_end: 2032c896fe29Sbellard new_args[i] = reg; 2033c896fe29Sbellard } 2034e8996ee0Sbellard } 2035c896fe29Sbellard 2036c896fe29Sbellard /* emit instruction */ 2037c896fe29Sbellard tcg_out_op(s, opc, new_args, const_args); 2038c896fe29Sbellard 2039c896fe29Sbellard /* move the outputs in the correct register if needed */ 2040c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 2041c896fe29Sbellard ts = &s->temps[args[i]]; 2042c896fe29Sbellard reg = new_args[i]; 2043c896fe29Sbellard if (ts->fixed_reg && ts->reg != reg) { 20443b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 2045c896fe29Sbellard } 2046ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(i)) { 2047ec7a869dSAurelien Jarno tcg_reg_sync(s, reg); 2048ec7a869dSAurelien Jarno } 2049ec7a869dSAurelien Jarno if (IS_DEAD_ARG(i)) { 2050ec7a869dSAurelien Jarno temp_dead(s, args[i]); 2051ec7a869dSAurelien Jarno } 2052c896fe29Sbellard } 2053c896fe29Sbellard } 2054c896fe29Sbellard 2055b03cce8eSbellard #ifdef TCG_TARGET_STACK_GROWSUP 2056b03cce8eSbellard #define STACK_DIR(x) (-(x)) 2057b03cce8eSbellard #else 2058b03cce8eSbellard #define STACK_DIR(x) (x) 2059b03cce8eSbellard #endif 2060b03cce8eSbellard 2061c896fe29Sbellard static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def, 2062a9751609SRichard Henderson TCGOpcode opc, const TCGArg *args, 2063ec7a869dSAurelien Jarno uint16_t dead_args, uint8_t sync_args) 2064c896fe29Sbellard { 2065c896fe29Sbellard int nb_iargs, nb_oargs, flags, nb_regs, i, reg, nb_params; 2066c896fe29Sbellard TCGArg arg, func_arg; 2067c896fe29Sbellard TCGTemp *ts; 2068d3452f1fSRichard Henderson intptr_t stack_offset; 2069d3452f1fSRichard Henderson size_t call_stack_size; 2070d3452f1fSRichard Henderson uintptr_t func_addr; 2071b03cce8eSbellard int const_func_arg, allocate_args; 2072c896fe29Sbellard TCGRegSet allocated_regs; 2073c896fe29Sbellard const TCGArgConstraint *arg_ct; 2074c896fe29Sbellard 2075c896fe29Sbellard arg = *args++; 2076c896fe29Sbellard 2077c896fe29Sbellard nb_oargs = arg >> 16; 2078c896fe29Sbellard nb_iargs = arg & 0xffff; 2079c896fe29Sbellard nb_params = nb_iargs - 1; 2080c896fe29Sbellard 2081c896fe29Sbellard flags = args[nb_oargs + nb_iargs]; 2082c896fe29Sbellard 20836e17d0c5SStefan Weil nb_regs = ARRAY_SIZE(tcg_target_call_iarg_regs); 2084c896fe29Sbellard if (nb_regs > nb_params) 2085c896fe29Sbellard nb_regs = nb_params; 2086c896fe29Sbellard 2087c896fe29Sbellard /* assign stack slots first */ 2088c896fe29Sbellard call_stack_size = (nb_params - nb_regs) * sizeof(tcg_target_long); 2089c896fe29Sbellard call_stack_size = (call_stack_size + TCG_TARGET_STACK_ALIGN - 1) & 2090c896fe29Sbellard ~(TCG_TARGET_STACK_ALIGN - 1); 2091b03cce8eSbellard allocate_args = (call_stack_size > TCG_STATIC_CALL_ARGS_SIZE); 2092b03cce8eSbellard if (allocate_args) { 2093345649c0SBlue Swirl /* XXX: if more than TCG_STATIC_CALL_ARGS_SIZE is needed, 2094345649c0SBlue Swirl preallocate call stack */ 2095345649c0SBlue Swirl tcg_abort(); 2096b03cce8eSbellard } 209739cf05d3Sbellard 209839cf05d3Sbellard stack_offset = TCG_TARGET_CALL_STACK_OFFSET; 2099c896fe29Sbellard for(i = nb_regs; i < nb_params; i++) { 2100c896fe29Sbellard arg = args[nb_oargs + i]; 210139cf05d3Sbellard #ifdef TCG_TARGET_STACK_GROWSUP 210239cf05d3Sbellard stack_offset -= sizeof(tcg_target_long); 210339cf05d3Sbellard #endif 210439cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 2105c896fe29Sbellard ts = &s->temps[arg]; 2106c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 2107e4d5434cSblueswir1 tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset); 2108c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 2109c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 2110c896fe29Sbellard s->reserved_regs); 2111c896fe29Sbellard /* XXX: not correct if reading values from the stack */ 2112e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2113e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 2114c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2115c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 2116c896fe29Sbellard s->reserved_regs); 2117c896fe29Sbellard /* XXX: sign extend may be needed on some targets */ 2118c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 2119e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 2120c896fe29Sbellard } else { 2121c896fe29Sbellard tcg_abort(); 2122c896fe29Sbellard } 212339cf05d3Sbellard } 212439cf05d3Sbellard #ifndef TCG_TARGET_STACK_GROWSUP 212539cf05d3Sbellard stack_offset += sizeof(tcg_target_long); 212639cf05d3Sbellard #endif 2127c896fe29Sbellard } 2128c896fe29Sbellard 2129c896fe29Sbellard /* assign input registers */ 2130c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 2131c896fe29Sbellard for(i = 0; i < nb_regs; i++) { 2132c896fe29Sbellard arg = args[nb_oargs + i]; 213339cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 2134c896fe29Sbellard ts = &s->temps[arg]; 2135c896fe29Sbellard reg = tcg_target_call_iarg_regs[i]; 2136c896fe29Sbellard tcg_reg_free(s, reg); 2137c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 2138c896fe29Sbellard if (ts->reg != reg) { 21393b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 2140c896fe29Sbellard } 2141c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 2142e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2143c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2144c896fe29Sbellard /* XXX: sign extend ? */ 2145c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 2146c896fe29Sbellard } else { 2147c896fe29Sbellard tcg_abort(); 2148c896fe29Sbellard } 2149c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 2150c896fe29Sbellard } 215139cf05d3Sbellard } 2152c896fe29Sbellard 2153c896fe29Sbellard /* assign function address */ 2154c896fe29Sbellard func_arg = args[nb_oargs + nb_iargs - 1]; 2155c896fe29Sbellard arg_ct = &def->args_ct[0]; 2156c896fe29Sbellard ts = &s->temps[func_arg]; 2157f54b3f92Saurel32 func_addr = ts->val; 2158c896fe29Sbellard const_func_arg = 0; 2159c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 2160c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2161e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2162c896fe29Sbellard func_arg = reg; 2163e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 2164c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_REG) { 2165c896fe29Sbellard reg = ts->reg; 2166c896fe29Sbellard if (!tcg_regset_test_reg(arg_ct->u.regs, reg)) { 2167c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 21683b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 2169c896fe29Sbellard } 2170c896fe29Sbellard func_arg = reg; 2171e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 2172c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2173f54b3f92Saurel32 if (tcg_target_const_match(func_addr, arg_ct)) { 2174c896fe29Sbellard const_func_arg = 1; 2175f54b3f92Saurel32 func_arg = func_addr; 2176c896fe29Sbellard } else { 2177c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2178f54b3f92Saurel32 tcg_out_movi(s, ts->type, reg, func_addr); 2179c896fe29Sbellard func_arg = reg; 2180e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 2181c896fe29Sbellard } 2182c896fe29Sbellard } else { 2183c896fe29Sbellard tcg_abort(); 2184c896fe29Sbellard } 2185c896fe29Sbellard 2186e8996ee0Sbellard 2187c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 2188866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 2189866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 2190639368ddSAurelien Jarno temp_dead(s, args[i]); 2191c896fe29Sbellard } 2192c896fe29Sbellard } 2193c896fe29Sbellard 2194c896fe29Sbellard /* clobber call registers */ 2195c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 2196c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 2197c896fe29Sbellard tcg_reg_free(s, reg); 2198c896fe29Sbellard } 2199c896fe29Sbellard } 2200c896fe29Sbellard 220178505279SAurelien Jarno /* Save globals if they might be written by the helper, sync them if 220278505279SAurelien Jarno they might be read. */ 220378505279SAurelien Jarno if (flags & TCG_CALL_NO_READ_GLOBALS) { 220478505279SAurelien Jarno /* Nothing to do */ 220578505279SAurelien Jarno } else if (flags & TCG_CALL_NO_WRITE_GLOBALS) { 220678505279SAurelien Jarno sync_globals(s, allocated_regs); 220778505279SAurelien Jarno } else { 2208e8996ee0Sbellard save_globals(s, allocated_regs); 2209b9c18f56Saurel32 } 2210c896fe29Sbellard 2211c896fe29Sbellard tcg_out_op(s, opc, &func_arg, &const_func_arg); 2212c896fe29Sbellard 2213c896fe29Sbellard /* assign output registers and emit moves if needed */ 2214c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 2215c896fe29Sbellard arg = args[i]; 2216c896fe29Sbellard ts = &s->temps[arg]; 2217c896fe29Sbellard reg = tcg_target_call_oarg_regs[i]; 2218e8996ee0Sbellard assert(s->reg_to_temp[reg] == -1); 2219c896fe29Sbellard if (ts->fixed_reg) { 2220c896fe29Sbellard if (ts->reg != reg) { 22213b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 2222c896fe29Sbellard } 2223c896fe29Sbellard } else { 2224639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 2225639368ddSAurelien Jarno s->reg_to_temp[ts->reg] = -1; 2226639368ddSAurelien Jarno } 2227c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 2228c896fe29Sbellard ts->reg = reg; 2229c896fe29Sbellard ts->mem_coherent = 0; 2230c896fe29Sbellard s->reg_to_temp[reg] = arg; 2231ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(i)) { 2232ec7a869dSAurelien Jarno tcg_reg_sync(s, reg); 2233ec7a869dSAurelien Jarno } 2234ec7a869dSAurelien Jarno if (IS_DEAD_ARG(i)) { 2235ec7a869dSAurelien Jarno temp_dead(s, args[i]); 2236c896fe29Sbellard } 2237c896fe29Sbellard } 22388c11ad25SAurelien Jarno } 2239c896fe29Sbellard 2240c896fe29Sbellard return nb_iargs + nb_oargs + def->nb_cargs + 1; 2241c896fe29Sbellard } 2242c896fe29Sbellard 2243c896fe29Sbellard #ifdef CONFIG_PROFILER 2244c896fe29Sbellard 224554604f74Saurel32 static int64_t tcg_table_op_count[NB_OPS]; 2246c896fe29Sbellard 2247871e6c35SBlue Swirl static void dump_op_count(void) 2248c896fe29Sbellard { 2249c896fe29Sbellard int i; 2250c896fe29Sbellard FILE *f; 225154604f74Saurel32 f = fopen("/tmp/op.log", "w"); 2252c896fe29Sbellard for(i = INDEX_op_end; i < NB_OPS; i++) { 225354604f74Saurel32 fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, tcg_table_op_count[i]); 2254c896fe29Sbellard } 2255c896fe29Sbellard fclose(f); 2256c896fe29Sbellard } 2257c896fe29Sbellard #endif 2258c896fe29Sbellard 2259c896fe29Sbellard 2260c896fe29Sbellard static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf, 22612ba1eeb6Spbrook long search_pc) 2262c896fe29Sbellard { 2263a9751609SRichard Henderson TCGOpcode opc; 2264a9751609SRichard Henderson int op_index; 2265c896fe29Sbellard const TCGOpDef *def; 2266c896fe29Sbellard const TCGArg *args; 2267c896fe29Sbellard 2268c896fe29Sbellard #ifdef DEBUG_DISAS 22698fec2b8cSaliguori if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) { 227093fcfe39Saliguori qemu_log("OP:\n"); 2271eeacee4dSBlue Swirl tcg_dump_ops(s); 227293fcfe39Saliguori qemu_log("\n"); 2273c896fe29Sbellard } 2274c896fe29Sbellard #endif 2275c896fe29Sbellard 2276c5cc28ffSAurelien Jarno #ifdef CONFIG_PROFILER 2277c5cc28ffSAurelien Jarno s->opt_time -= profile_getclock(); 2278c5cc28ffSAurelien Jarno #endif 2279c5cc28ffSAurelien Jarno 22808f2e8c07SKirill Batuzov #ifdef USE_TCG_OPTIMIZATIONS 2281c4afe5c4SEvgeny Voevodin s->gen_opparam_ptr = 22821ff0a2c5SEvgeny Voevodin tcg_optimize(s, s->gen_opc_ptr, s->gen_opparam_buf, tcg_op_defs); 22838f2e8c07SKirill Batuzov #endif 22848f2e8c07SKirill Batuzov 2285a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2286c5cc28ffSAurelien Jarno s->opt_time += profile_getclock(); 2287a23a9ec6Sbellard s->la_time -= profile_getclock(); 2288a23a9ec6Sbellard #endif 2289c5cc28ffSAurelien Jarno 2290c896fe29Sbellard tcg_liveness_analysis(s); 2291c5cc28ffSAurelien Jarno 2292a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2293a23a9ec6Sbellard s->la_time += profile_getclock(); 2294a23a9ec6Sbellard #endif 2295c896fe29Sbellard 2296c896fe29Sbellard #ifdef DEBUG_DISAS 22978fec2b8cSaliguori if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT))) { 2298c5cc28ffSAurelien Jarno qemu_log("OP after optimization and liveness analysis:\n"); 2299eeacee4dSBlue Swirl tcg_dump_ops(s); 230093fcfe39Saliguori qemu_log("\n"); 2301c896fe29Sbellard } 2302c896fe29Sbellard #endif 2303c896fe29Sbellard 2304c896fe29Sbellard tcg_reg_alloc_start(s); 2305c896fe29Sbellard 2306c896fe29Sbellard s->code_buf = gen_code_buf; 2307c896fe29Sbellard s->code_ptr = gen_code_buf; 2308c896fe29Sbellard 23091ff0a2c5SEvgeny Voevodin args = s->gen_opparam_buf; 2310c896fe29Sbellard op_index = 0; 2311b3db8758Sblueswir1 2312c896fe29Sbellard for(;;) { 231392414b31SEvgeny Voevodin opc = s->gen_opc_buf[op_index]; 2314c896fe29Sbellard #ifdef CONFIG_PROFILER 231554604f74Saurel32 tcg_table_op_count[opc]++; 2316c896fe29Sbellard #endif 2317c896fe29Sbellard def = &tcg_op_defs[opc]; 2318c896fe29Sbellard #if 0 2319c896fe29Sbellard printf("%s: %d %d %d\n", def->name, 2320c896fe29Sbellard def->nb_oargs, def->nb_iargs, def->nb_cargs); 2321c896fe29Sbellard // dump_regs(s); 2322c896fe29Sbellard #endif 2323c896fe29Sbellard switch(opc) { 2324c896fe29Sbellard case INDEX_op_mov_i32: 2325c896fe29Sbellard case INDEX_op_mov_i64: 2326ec7a869dSAurelien Jarno tcg_reg_alloc_mov(s, def, args, s->op_dead_args[op_index], 2327ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2328c896fe29Sbellard break; 2329e8996ee0Sbellard case INDEX_op_movi_i32: 2330e8996ee0Sbellard case INDEX_op_movi_i64: 2331ec7a869dSAurelien Jarno tcg_reg_alloc_movi(s, args, s->op_dead_args[op_index], 2332ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2333e8996ee0Sbellard break; 23347e4597d7Sbellard case INDEX_op_debug_insn_start: 23357e4597d7Sbellard /* debug instruction */ 23367e4597d7Sbellard break; 2337c896fe29Sbellard case INDEX_op_nop: 2338c896fe29Sbellard case INDEX_op_nop1: 2339c896fe29Sbellard case INDEX_op_nop2: 2340c896fe29Sbellard case INDEX_op_nop3: 2341c896fe29Sbellard break; 2342c896fe29Sbellard case INDEX_op_nopn: 2343c896fe29Sbellard args += args[0]; 2344c896fe29Sbellard goto next; 23455ff9d6a4Sbellard case INDEX_op_discard: 2346639368ddSAurelien Jarno temp_dead(s, args[0]); 23475ff9d6a4Sbellard break; 2348c896fe29Sbellard case INDEX_op_set_label: 2349e8996ee0Sbellard tcg_reg_alloc_bb_end(s, s->reserved_regs); 23509d6fca70SStefan Weil tcg_out_label(s, args[0], s->code_ptr); 2351c896fe29Sbellard break; 2352c896fe29Sbellard case INDEX_op_call: 2353ec7a869dSAurelien Jarno args += tcg_reg_alloc_call(s, def, opc, args, 2354ec7a869dSAurelien Jarno s->op_dead_args[op_index], 2355ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2356c896fe29Sbellard goto next; 2357c896fe29Sbellard case INDEX_op_end: 2358c896fe29Sbellard goto the_end; 2359c896fe29Sbellard default: 236025c4d9ccSRichard Henderson /* Sanity check that we've not introduced any unhandled opcodes. */ 236125c4d9ccSRichard Henderson if (def->flags & TCG_OPF_NOT_PRESENT) { 236225c4d9ccSRichard Henderson tcg_abort(); 236325c4d9ccSRichard Henderson } 2364c896fe29Sbellard /* Note: in order to speed up the code, it would be much 2365c896fe29Sbellard faster to have specialized register allocator functions for 2366c896fe29Sbellard some common argument patterns */ 2367ec7a869dSAurelien Jarno tcg_reg_alloc_op(s, def, opc, args, s->op_dead_args[op_index], 2368ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2369c896fe29Sbellard break; 2370c896fe29Sbellard } 2371c896fe29Sbellard args += def->nb_args; 23728df1ca4bSths next: 23732ba1eeb6Spbrook if (search_pc >= 0 && search_pc < s->code_ptr - gen_code_buf) { 2374c896fe29Sbellard return op_index; 2375c896fe29Sbellard } 2376c896fe29Sbellard op_index++; 2377c896fe29Sbellard #ifndef NDEBUG 2378c896fe29Sbellard check_regs(s); 2379c896fe29Sbellard #endif 2380c896fe29Sbellard } 2381c896fe29Sbellard the_end: 2382b76f0d8cSYeongkyoon Lee #if defined(CONFIG_QEMU_LDST_OPTIMIZATION) && defined(CONFIG_SOFTMMU) 2383b76f0d8cSYeongkyoon Lee /* Generate TB finalization at the end of block */ 2384b76f0d8cSYeongkyoon Lee tcg_out_tb_finalize(s); 2385b76f0d8cSYeongkyoon Lee #endif 2386c896fe29Sbellard return -1; 2387c896fe29Sbellard } 2388c896fe29Sbellard 238954604f74Saurel32 int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf) 2390c896fe29Sbellard { 2391c896fe29Sbellard #ifdef CONFIG_PROFILER 2392c896fe29Sbellard { 2393c896fe29Sbellard int n; 239492414b31SEvgeny Voevodin n = (s->gen_opc_ptr - s->gen_opc_buf); 2395a23a9ec6Sbellard s->op_count += n; 2396a23a9ec6Sbellard if (n > s->op_count_max) 2397a23a9ec6Sbellard s->op_count_max = n; 2398a23a9ec6Sbellard 2399a23a9ec6Sbellard s->temp_count += s->nb_temps; 2400a23a9ec6Sbellard if (s->nb_temps > s->temp_count_max) 2401a23a9ec6Sbellard s->temp_count_max = s->nb_temps; 2402c896fe29Sbellard } 2403c896fe29Sbellard #endif 2404c896fe29Sbellard 24052ba1eeb6Spbrook tcg_gen_code_common(s, gen_code_buf, -1); 2406c896fe29Sbellard 2407c896fe29Sbellard /* flush instruction cache */ 2408b93949efSRichard Henderson flush_icache_range((uintptr_t)gen_code_buf, (uintptr_t)s->code_ptr); 24092aeabc08SStefan Weil 2410c896fe29Sbellard return s->code_ptr - gen_code_buf; 2411c896fe29Sbellard } 2412c896fe29Sbellard 24132ba1eeb6Spbrook /* Return the index of the micro operation such as the pc after is < 2414623e265cSpbrook offset bytes from the start of the TB. The contents of gen_code_buf must 2415623e265cSpbrook not be changed, though writing the same values is ok. 2416623e265cSpbrook Return -1 if not found. */ 241754604f74Saurel32 int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset) 2418c896fe29Sbellard { 2419623e265cSpbrook return tcg_gen_code_common(s, gen_code_buf, offset); 2420c896fe29Sbellard } 2421a23a9ec6Sbellard 2422a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2423405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2424a23a9ec6Sbellard { 2425a23a9ec6Sbellard TCGContext *s = &tcg_ctx; 2426a23a9ec6Sbellard int64_t tot; 2427a23a9ec6Sbellard 2428a23a9ec6Sbellard tot = s->interm_time + s->code_time; 2429a23a9ec6Sbellard cpu_fprintf(f, "JIT cycles %" PRId64 " (%0.3f s at 2.4 GHz)\n", 2430a23a9ec6Sbellard tot, tot / 2.4e9); 2431a23a9ec6Sbellard cpu_fprintf(f, "translated TBs %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n", 2432a23a9ec6Sbellard s->tb_count, 2433a23a9ec6Sbellard s->tb_count1 - s->tb_count, 2434a23a9ec6Sbellard s->tb_count1 ? (double)(s->tb_count1 - s->tb_count) / s->tb_count1 * 100.0 : 0); 2435a23a9ec6Sbellard cpu_fprintf(f, "avg ops/TB %0.1f max=%d\n", 2436a23a9ec6Sbellard s->tb_count ? (double)s->op_count / s->tb_count : 0, s->op_count_max); 2437a23a9ec6Sbellard cpu_fprintf(f, "deleted ops/TB %0.2f\n", 2438a23a9ec6Sbellard s->tb_count ? 2439a23a9ec6Sbellard (double)s->del_op_count / s->tb_count : 0); 2440a23a9ec6Sbellard cpu_fprintf(f, "avg temps/TB %0.2f max=%d\n", 2441a23a9ec6Sbellard s->tb_count ? 2442a23a9ec6Sbellard (double)s->temp_count / s->tb_count : 0, 2443a23a9ec6Sbellard s->temp_count_max); 2444a23a9ec6Sbellard 2445a23a9ec6Sbellard cpu_fprintf(f, "cycles/op %0.1f\n", 2446a23a9ec6Sbellard s->op_count ? (double)tot / s->op_count : 0); 2447a23a9ec6Sbellard cpu_fprintf(f, "cycles/in byte %0.1f\n", 2448a23a9ec6Sbellard s->code_in_len ? (double)tot / s->code_in_len : 0); 2449a23a9ec6Sbellard cpu_fprintf(f, "cycles/out byte %0.1f\n", 2450a23a9ec6Sbellard s->code_out_len ? (double)tot / s->code_out_len : 0); 2451a23a9ec6Sbellard if (tot == 0) 2452a23a9ec6Sbellard tot = 1; 2453a23a9ec6Sbellard cpu_fprintf(f, " gen_interm time %0.1f%%\n", 2454a23a9ec6Sbellard (double)s->interm_time / tot * 100.0); 2455a23a9ec6Sbellard cpu_fprintf(f, " gen_code time %0.1f%%\n", 2456a23a9ec6Sbellard (double)s->code_time / tot * 100.0); 2457c5cc28ffSAurelien Jarno cpu_fprintf(f, "optim./code time %0.1f%%\n", 2458c5cc28ffSAurelien Jarno (double)s->opt_time / (s->code_time ? s->code_time : 1) 2459c5cc28ffSAurelien Jarno * 100.0); 2460a23a9ec6Sbellard cpu_fprintf(f, "liveness/code time %0.1f%%\n", 2461a23a9ec6Sbellard (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0); 2462a23a9ec6Sbellard cpu_fprintf(f, "cpu_restore count %" PRId64 "\n", 2463a23a9ec6Sbellard s->restore_count); 2464a23a9ec6Sbellard cpu_fprintf(f, " avg cycles %0.1f\n", 2465a23a9ec6Sbellard s->restore_count ? (double)s->restore_time / s->restore_count : 0); 2466871e6c35SBlue Swirl 2467a23a9ec6Sbellard dump_op_count(); 2468a23a9ec6Sbellard } 2469a23a9ec6Sbellard #else 2470405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2471a23a9ec6Sbellard { 247224bf7b3aSbellard cpu_fprintf(f, "[TCG profiler not compiled]\n"); 2473a23a9ec6Sbellard } 2474a23a9ec6Sbellard #endif 2475813da627SRichard Henderson 2476813da627SRichard Henderson #ifdef ELF_HOST_MACHINE 24775872bbf2SRichard Henderson /* In order to use this feature, the backend needs to do three things: 24785872bbf2SRichard Henderson 24795872bbf2SRichard Henderson (1) Define ELF_HOST_MACHINE to indicate both what value to 24805872bbf2SRichard Henderson put into the ELF image and to indicate support for the feature. 24815872bbf2SRichard Henderson 24825872bbf2SRichard Henderson (2) Define tcg_register_jit. This should create a buffer containing 24835872bbf2SRichard Henderson the contents of a .debug_frame section that describes the post- 24845872bbf2SRichard Henderson prologue unwind info for the tcg machine. 24855872bbf2SRichard Henderson 24865872bbf2SRichard Henderson (3) Call tcg_register_jit_int, with the constructed .debug_frame. 24875872bbf2SRichard Henderson */ 2488813da627SRichard Henderson 2489813da627SRichard Henderson /* Begin GDB interface. THE FOLLOWING MUST MATCH GDB DOCS. */ 2490813da627SRichard Henderson typedef enum { 2491813da627SRichard Henderson JIT_NOACTION = 0, 2492813da627SRichard Henderson JIT_REGISTER_FN, 2493813da627SRichard Henderson JIT_UNREGISTER_FN 2494813da627SRichard Henderson } jit_actions_t; 2495813da627SRichard Henderson 2496813da627SRichard Henderson struct jit_code_entry { 2497813da627SRichard Henderson struct jit_code_entry *next_entry; 2498813da627SRichard Henderson struct jit_code_entry *prev_entry; 2499813da627SRichard Henderson const void *symfile_addr; 2500813da627SRichard Henderson uint64_t symfile_size; 2501813da627SRichard Henderson }; 2502813da627SRichard Henderson 2503813da627SRichard Henderson struct jit_descriptor { 2504813da627SRichard Henderson uint32_t version; 2505813da627SRichard Henderson uint32_t action_flag; 2506813da627SRichard Henderson struct jit_code_entry *relevant_entry; 2507813da627SRichard Henderson struct jit_code_entry *first_entry; 2508813da627SRichard Henderson }; 2509813da627SRichard Henderson 2510813da627SRichard Henderson void __jit_debug_register_code(void) __attribute__((noinline)); 2511813da627SRichard Henderson void __jit_debug_register_code(void) 2512813da627SRichard Henderson { 2513813da627SRichard Henderson asm(""); 2514813da627SRichard Henderson } 2515813da627SRichard Henderson 2516813da627SRichard Henderson /* Must statically initialize the version, because GDB may check 2517813da627SRichard Henderson the version before we can set it. */ 2518813da627SRichard Henderson struct jit_descriptor __jit_debug_descriptor = { 1, 0, 0, 0 }; 2519813da627SRichard Henderson 2520813da627SRichard Henderson /* End GDB interface. */ 2521813da627SRichard Henderson 2522813da627SRichard Henderson static int find_string(const char *strtab, const char *str) 2523813da627SRichard Henderson { 2524813da627SRichard Henderson const char *p = strtab + 1; 2525813da627SRichard Henderson 2526813da627SRichard Henderson while (1) { 2527813da627SRichard Henderson if (strcmp(p, str) == 0) { 2528813da627SRichard Henderson return p - strtab; 2529813da627SRichard Henderson } 2530813da627SRichard Henderson p += strlen(p) + 1; 2531813da627SRichard Henderson } 2532813da627SRichard Henderson } 2533813da627SRichard Henderson 25345872bbf2SRichard Henderson static void tcg_register_jit_int(void *buf_ptr, size_t buf_size, 2535813da627SRichard Henderson void *debug_frame, size_t debug_frame_size) 2536813da627SRichard Henderson { 25375872bbf2SRichard Henderson struct __attribute__((packed)) DebugInfo { 25385872bbf2SRichard Henderson uint32_t len; 25395872bbf2SRichard Henderson uint16_t version; 25405872bbf2SRichard Henderson uint32_t abbrev; 25415872bbf2SRichard Henderson uint8_t ptr_size; 25425872bbf2SRichard Henderson uint8_t cu_die; 25435872bbf2SRichard Henderson uint16_t cu_lang; 25445872bbf2SRichard Henderson uintptr_t cu_low_pc; 25455872bbf2SRichard Henderson uintptr_t cu_high_pc; 25465872bbf2SRichard Henderson uint8_t fn_die; 25475872bbf2SRichard Henderson char fn_name[16]; 25485872bbf2SRichard Henderson uintptr_t fn_low_pc; 25495872bbf2SRichard Henderson uintptr_t fn_high_pc; 25505872bbf2SRichard Henderson uint8_t cu_eoc; 25515872bbf2SRichard Henderson }; 2552813da627SRichard Henderson 2553813da627SRichard Henderson struct ElfImage { 2554813da627SRichard Henderson ElfW(Ehdr) ehdr; 2555813da627SRichard Henderson ElfW(Phdr) phdr; 25565872bbf2SRichard Henderson ElfW(Shdr) shdr[7]; 25575872bbf2SRichard Henderson ElfW(Sym) sym[2]; 25585872bbf2SRichard Henderson struct DebugInfo di; 25595872bbf2SRichard Henderson uint8_t da[24]; 25605872bbf2SRichard Henderson char str[80]; 25615872bbf2SRichard Henderson }; 25625872bbf2SRichard Henderson 25635872bbf2SRichard Henderson struct ElfImage *img; 25645872bbf2SRichard Henderson 25655872bbf2SRichard Henderson static const struct ElfImage img_template = { 25665872bbf2SRichard Henderson .ehdr = { 25675872bbf2SRichard Henderson .e_ident[EI_MAG0] = ELFMAG0, 25685872bbf2SRichard Henderson .e_ident[EI_MAG1] = ELFMAG1, 25695872bbf2SRichard Henderson .e_ident[EI_MAG2] = ELFMAG2, 25705872bbf2SRichard Henderson .e_ident[EI_MAG3] = ELFMAG3, 25715872bbf2SRichard Henderson .e_ident[EI_CLASS] = ELF_CLASS, 25725872bbf2SRichard Henderson .e_ident[EI_DATA] = ELF_DATA, 25735872bbf2SRichard Henderson .e_ident[EI_VERSION] = EV_CURRENT, 25745872bbf2SRichard Henderson .e_type = ET_EXEC, 25755872bbf2SRichard Henderson .e_machine = ELF_HOST_MACHINE, 25765872bbf2SRichard Henderson .e_version = EV_CURRENT, 25775872bbf2SRichard Henderson .e_phoff = offsetof(struct ElfImage, phdr), 25785872bbf2SRichard Henderson .e_shoff = offsetof(struct ElfImage, shdr), 25795872bbf2SRichard Henderson .e_ehsize = sizeof(ElfW(Shdr)), 25805872bbf2SRichard Henderson .e_phentsize = sizeof(ElfW(Phdr)), 25815872bbf2SRichard Henderson .e_phnum = 1, 25825872bbf2SRichard Henderson .e_shentsize = sizeof(ElfW(Shdr)), 25835872bbf2SRichard Henderson .e_shnum = ARRAY_SIZE(img->shdr), 25845872bbf2SRichard Henderson .e_shstrndx = ARRAY_SIZE(img->shdr) - 1, 2585abbb3eaeSRichard Henderson #ifdef ELF_HOST_FLAGS 2586abbb3eaeSRichard Henderson .e_flags = ELF_HOST_FLAGS, 2587abbb3eaeSRichard Henderson #endif 2588abbb3eaeSRichard Henderson #ifdef ELF_OSABI 2589abbb3eaeSRichard Henderson .e_ident[EI_OSABI] = ELF_OSABI, 2590abbb3eaeSRichard Henderson #endif 25915872bbf2SRichard Henderson }, 25925872bbf2SRichard Henderson .phdr = { 25935872bbf2SRichard Henderson .p_type = PT_LOAD, 25945872bbf2SRichard Henderson .p_flags = PF_X, 25955872bbf2SRichard Henderson }, 25965872bbf2SRichard Henderson .shdr = { 25975872bbf2SRichard Henderson [0] = { .sh_type = SHT_NULL }, 25985872bbf2SRichard Henderson /* Trick: The contents of code_gen_buffer are not present in 25995872bbf2SRichard Henderson this fake ELF file; that got allocated elsewhere. Therefore 26005872bbf2SRichard Henderson we mark .text as SHT_NOBITS (similar to .bss) so that readers 26015872bbf2SRichard Henderson will not look for contents. We can record any address. */ 26025872bbf2SRichard Henderson [1] = { /* .text */ 26035872bbf2SRichard Henderson .sh_type = SHT_NOBITS, 26045872bbf2SRichard Henderson .sh_flags = SHF_EXECINSTR | SHF_ALLOC, 26055872bbf2SRichard Henderson }, 26065872bbf2SRichard Henderson [2] = { /* .debug_info */ 26075872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 26085872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, di), 26095872bbf2SRichard Henderson .sh_size = sizeof(struct DebugInfo), 26105872bbf2SRichard Henderson }, 26115872bbf2SRichard Henderson [3] = { /* .debug_abbrev */ 26125872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 26135872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, da), 26145872bbf2SRichard Henderson .sh_size = sizeof(img->da), 26155872bbf2SRichard Henderson }, 26165872bbf2SRichard Henderson [4] = { /* .debug_frame */ 26175872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 26185872bbf2SRichard Henderson .sh_offset = sizeof(struct ElfImage), 26195872bbf2SRichard Henderson }, 26205872bbf2SRichard Henderson [5] = { /* .symtab */ 26215872bbf2SRichard Henderson .sh_type = SHT_SYMTAB, 26225872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, sym), 26235872bbf2SRichard Henderson .sh_size = sizeof(img->sym), 26245872bbf2SRichard Henderson .sh_info = 1, 26255872bbf2SRichard Henderson .sh_link = ARRAY_SIZE(img->shdr) - 1, 26265872bbf2SRichard Henderson .sh_entsize = sizeof(ElfW(Sym)), 26275872bbf2SRichard Henderson }, 26285872bbf2SRichard Henderson [6] = { /* .strtab */ 26295872bbf2SRichard Henderson .sh_type = SHT_STRTAB, 26305872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, str), 26315872bbf2SRichard Henderson .sh_size = sizeof(img->str), 26325872bbf2SRichard Henderson } 26335872bbf2SRichard Henderson }, 26345872bbf2SRichard Henderson .sym = { 26355872bbf2SRichard Henderson [1] = { /* code_gen_buffer */ 26365872bbf2SRichard Henderson .st_info = ELF_ST_INFO(STB_GLOBAL, STT_FUNC), 26375872bbf2SRichard Henderson .st_shndx = 1, 26385872bbf2SRichard Henderson } 26395872bbf2SRichard Henderson }, 26405872bbf2SRichard Henderson .di = { 26415872bbf2SRichard Henderson .len = sizeof(struct DebugInfo) - 4, 26425872bbf2SRichard Henderson .version = 2, 26435872bbf2SRichard Henderson .ptr_size = sizeof(void *), 26445872bbf2SRichard Henderson .cu_die = 1, 26455872bbf2SRichard Henderson .cu_lang = 0x8001, /* DW_LANG_Mips_Assembler */ 26465872bbf2SRichard Henderson .fn_die = 2, 26475872bbf2SRichard Henderson .fn_name = "code_gen_buffer" 26485872bbf2SRichard Henderson }, 26495872bbf2SRichard Henderson .da = { 26505872bbf2SRichard Henderson 1, /* abbrev number (the cu) */ 26515872bbf2SRichard Henderson 0x11, 1, /* DW_TAG_compile_unit, has children */ 26525872bbf2SRichard Henderson 0x13, 0x5, /* DW_AT_language, DW_FORM_data2 */ 26535872bbf2SRichard Henderson 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */ 26545872bbf2SRichard Henderson 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */ 26555872bbf2SRichard Henderson 0, 0, /* end of abbrev */ 26565872bbf2SRichard Henderson 2, /* abbrev number (the fn) */ 26575872bbf2SRichard Henderson 0x2e, 0, /* DW_TAG_subprogram, no children */ 26585872bbf2SRichard Henderson 0x3, 0x8, /* DW_AT_name, DW_FORM_string */ 26595872bbf2SRichard Henderson 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */ 26605872bbf2SRichard Henderson 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */ 26615872bbf2SRichard Henderson 0, 0, /* end of abbrev */ 26625872bbf2SRichard Henderson 0 /* no more abbrev */ 26635872bbf2SRichard Henderson }, 26645872bbf2SRichard Henderson .str = "\0" ".text\0" ".debug_info\0" ".debug_abbrev\0" 26655872bbf2SRichard Henderson ".debug_frame\0" ".symtab\0" ".strtab\0" "code_gen_buffer", 2666813da627SRichard Henderson }; 2667813da627SRichard Henderson 2668813da627SRichard Henderson /* We only need a single jit entry; statically allocate it. */ 2669813da627SRichard Henderson static struct jit_code_entry one_entry; 2670813da627SRichard Henderson 26715872bbf2SRichard Henderson uintptr_t buf = (uintptr_t)buf_ptr; 2672813da627SRichard Henderson size_t img_size = sizeof(struct ElfImage) + debug_frame_size; 2673813da627SRichard Henderson 26745872bbf2SRichard Henderson img = g_malloc(img_size); 26755872bbf2SRichard Henderson *img = img_template; 2676813da627SRichard Henderson memcpy(img + 1, debug_frame, debug_frame_size); 2677813da627SRichard Henderson 26785872bbf2SRichard Henderson img->phdr.p_vaddr = buf; 26795872bbf2SRichard Henderson img->phdr.p_paddr = buf; 26805872bbf2SRichard Henderson img->phdr.p_memsz = buf_size; 2681813da627SRichard Henderson 26825872bbf2SRichard Henderson img->shdr[1].sh_name = find_string(img->str, ".text"); 26835872bbf2SRichard Henderson img->shdr[1].sh_addr = buf; 26845872bbf2SRichard Henderson img->shdr[1].sh_size = buf_size; 2685813da627SRichard Henderson 26865872bbf2SRichard Henderson img->shdr[2].sh_name = find_string(img->str, ".debug_info"); 26875872bbf2SRichard Henderson img->shdr[3].sh_name = find_string(img->str, ".debug_abbrev"); 26885872bbf2SRichard Henderson 26895872bbf2SRichard Henderson img->shdr[4].sh_name = find_string(img->str, ".debug_frame"); 26905872bbf2SRichard Henderson img->shdr[4].sh_size = debug_frame_size; 26915872bbf2SRichard Henderson 26925872bbf2SRichard Henderson img->shdr[5].sh_name = find_string(img->str, ".symtab"); 26935872bbf2SRichard Henderson img->shdr[6].sh_name = find_string(img->str, ".strtab"); 26945872bbf2SRichard Henderson 26955872bbf2SRichard Henderson img->sym[1].st_name = find_string(img->str, "code_gen_buffer"); 26965872bbf2SRichard Henderson img->sym[1].st_value = buf; 26975872bbf2SRichard Henderson img->sym[1].st_size = buf_size; 26985872bbf2SRichard Henderson 26995872bbf2SRichard Henderson img->di.cu_low_pc = buf; 270045aba097SRichard Henderson img->di.cu_high_pc = buf + buf_size; 27015872bbf2SRichard Henderson img->di.fn_low_pc = buf; 270245aba097SRichard Henderson img->di.fn_high_pc = buf + buf_size; 2703813da627SRichard Henderson 2704813da627SRichard Henderson #ifdef DEBUG_JIT 2705813da627SRichard Henderson /* Enable this block to be able to debug the ELF image file creation. 2706813da627SRichard Henderson One can use readelf, objdump, or other inspection utilities. */ 2707813da627SRichard Henderson { 2708813da627SRichard Henderson FILE *f = fopen("/tmp/qemu.jit", "w+b"); 2709813da627SRichard Henderson if (f) { 27105872bbf2SRichard Henderson if (fwrite(img, img_size, 1, f) != img_size) { 2711813da627SRichard Henderson /* Avoid stupid unused return value warning for fwrite. */ 2712813da627SRichard Henderson } 2713813da627SRichard Henderson fclose(f); 2714813da627SRichard Henderson } 2715813da627SRichard Henderson } 2716813da627SRichard Henderson #endif 2717813da627SRichard Henderson 2718813da627SRichard Henderson one_entry.symfile_addr = img; 2719813da627SRichard Henderson one_entry.symfile_size = img_size; 2720813da627SRichard Henderson 2721813da627SRichard Henderson __jit_debug_descriptor.action_flag = JIT_REGISTER_FN; 2722813da627SRichard Henderson __jit_debug_descriptor.relevant_entry = &one_entry; 2723813da627SRichard Henderson __jit_debug_descriptor.first_entry = &one_entry; 2724813da627SRichard Henderson __jit_debug_register_code(); 2725813da627SRichard Henderson } 2726813da627SRichard Henderson #else 27275872bbf2SRichard Henderson /* No support for the feature. Provide the entry point expected by exec.c, 27285872bbf2SRichard Henderson and implement the internal function we declared earlier. */ 2729813da627SRichard Henderson 2730813da627SRichard Henderson static void tcg_register_jit_int(void *buf, size_t size, 2731813da627SRichard Henderson void *debug_frame, size_t debug_frame_size) 2732813da627SRichard Henderson { 2733813da627SRichard Henderson } 2734813da627SRichard Henderson 2735813da627SRichard Henderson void tcg_register_jit(void *buf, size_t buf_size) 2736813da627SRichard Henderson { 2737813da627SRichard Henderson } 2738813da627SRichard Henderson #endif /* ELF_HOST_MACHINE */ 2739