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 257c896fe29Sbellard void tcg_context_init(TCGContext *s) 258c896fe29Sbellard { 259c896fe29Sbellard int op, total_args, n; 260c896fe29Sbellard TCGOpDef *def; 261c896fe29Sbellard TCGArgConstraint *args_ct; 262c896fe29Sbellard int *sorted_args; 263c896fe29Sbellard 264c896fe29Sbellard memset(s, 0, sizeof(*s)); 265c896fe29Sbellard s->nb_globals = 0; 266c896fe29Sbellard 267c896fe29Sbellard /* Count total number of arguments and allocate the corresponding 268c896fe29Sbellard space */ 269c896fe29Sbellard total_args = 0; 270c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 271c896fe29Sbellard def = &tcg_op_defs[op]; 272c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 273c896fe29Sbellard total_args += n; 274c896fe29Sbellard } 275c896fe29Sbellard 2767267c094SAnthony Liguori args_ct = g_malloc(sizeof(TCGArgConstraint) * total_args); 2777267c094SAnthony Liguori sorted_args = g_malloc(sizeof(int) * total_args); 278c896fe29Sbellard 279c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 280c896fe29Sbellard def = &tcg_op_defs[op]; 281c896fe29Sbellard def->args_ct = args_ct; 282c896fe29Sbellard def->sorted_args = sorted_args; 283c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 284c896fe29Sbellard sorted_args += n; 285c896fe29Sbellard args_ct += n; 286c896fe29Sbellard } 287c896fe29Sbellard 288c896fe29Sbellard tcg_target_init(s); 2899002ec79SRichard Henderson } 290b03cce8eSbellard 2919002ec79SRichard Henderson void tcg_prologue_init(TCGContext *s) 2929002ec79SRichard Henderson { 293b03cce8eSbellard /* init global prologue and epilogue */ 2940b0d3320SEvgeny Voevodin s->code_buf = s->code_gen_prologue; 295b03cce8eSbellard s->code_ptr = s->code_buf; 296b03cce8eSbellard tcg_target_qemu_prologue(s); 297b93949efSRichard Henderson flush_icache_range((uintptr_t)s->code_buf, (uintptr_t)s->code_ptr); 298d6b64b2bSRichard Henderson 299d6b64b2bSRichard Henderson #ifdef DEBUG_DISAS 300d6b64b2bSRichard Henderson if (qemu_loglevel_mask(CPU_LOG_TB_OUT_ASM)) { 301d6b64b2bSRichard Henderson size_t size = s->code_ptr - s->code_buf; 302d6b64b2bSRichard Henderson qemu_log("PROLOGUE: [size=%zu]\n", size); 303d6b64b2bSRichard Henderson log_disas(s->code_buf, size); 304d6b64b2bSRichard Henderson qemu_log("\n"); 305d6b64b2bSRichard Henderson qemu_log_flush(); 306d6b64b2bSRichard Henderson } 307d6b64b2bSRichard Henderson #endif 308c896fe29Sbellard } 309c896fe29Sbellard 310e2c6d1b4SRichard Henderson void tcg_set_frame(TCGContext *s, int reg, intptr_t start, intptr_t size) 311c896fe29Sbellard { 312c896fe29Sbellard s->frame_start = start; 313c896fe29Sbellard s->frame_end = start + size; 314c896fe29Sbellard s->frame_reg = reg; 315c896fe29Sbellard } 316c896fe29Sbellard 317c896fe29Sbellard void tcg_func_start(TCGContext *s) 318c896fe29Sbellard { 319e8996ee0Sbellard int i; 320c896fe29Sbellard tcg_pool_reset(s); 321c896fe29Sbellard s->nb_temps = s->nb_globals; 322641d5fbeSbellard for(i = 0; i < (TCG_TYPE_COUNT * 2); i++) 323e8996ee0Sbellard s->first_free_temp[i] = -1; 324c896fe29Sbellard s->labels = tcg_malloc(sizeof(TCGLabel) * TCG_MAX_LABELS); 325c896fe29Sbellard s->nb_labels = 0; 326c896fe29Sbellard s->current_frame_offset = s->frame_start; 327c896fe29Sbellard 3280a209d4bSRichard Henderson #ifdef CONFIG_DEBUG_TCG 3290a209d4bSRichard Henderson s->goto_tb_issue_mask = 0; 3300a209d4bSRichard Henderson #endif 3310a209d4bSRichard Henderson 33292414b31SEvgeny Voevodin s->gen_opc_ptr = s->gen_opc_buf; 3331ff0a2c5SEvgeny Voevodin s->gen_opparam_ptr = s->gen_opparam_buf; 334b76f0d8cSYeongkyoon Lee 335b76f0d8cSYeongkyoon Lee #if defined(CONFIG_QEMU_LDST_OPTIMIZATION) && defined(CONFIG_SOFTMMU) 336b76f0d8cSYeongkyoon Lee /* Initialize qemu_ld/st labels to assist code generation at the end of TB 337b76f0d8cSYeongkyoon Lee for TLB miss cases at the end of TB */ 338b76f0d8cSYeongkyoon Lee s->qemu_ldst_labels = tcg_malloc(sizeof(TCGLabelQemuLdst) * 339b76f0d8cSYeongkyoon Lee TCG_MAX_QEMU_LDST); 340b76f0d8cSYeongkyoon Lee s->nb_qemu_ldst_labels = 0; 341b76f0d8cSYeongkyoon Lee #endif 342c896fe29Sbellard } 343c896fe29Sbellard 344c896fe29Sbellard static inline void tcg_temp_alloc(TCGContext *s, int n) 345c896fe29Sbellard { 346c896fe29Sbellard if (n > TCG_MAX_TEMPS) 347c896fe29Sbellard tcg_abort(); 348c896fe29Sbellard } 349c896fe29Sbellard 350a7812ae4Spbrook static inline int tcg_global_reg_new_internal(TCGType type, int reg, 351a7812ae4Spbrook const char *name) 352c896fe29Sbellard { 353c896fe29Sbellard TCGContext *s = &tcg_ctx; 354c896fe29Sbellard TCGTemp *ts; 355c896fe29Sbellard int idx; 356c896fe29Sbellard 357c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 358c896fe29Sbellard if (type != TCG_TYPE_I32) 359c896fe29Sbellard tcg_abort(); 360c896fe29Sbellard #endif 361c896fe29Sbellard if (tcg_regset_test_reg(s->reserved_regs, reg)) 362c896fe29Sbellard tcg_abort(); 363c896fe29Sbellard idx = s->nb_globals; 364c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 365c896fe29Sbellard ts = &s->temps[s->nb_globals]; 366c896fe29Sbellard ts->base_type = type; 367c896fe29Sbellard ts->type = type; 368c896fe29Sbellard ts->fixed_reg = 1; 369c896fe29Sbellard ts->reg = reg; 370c896fe29Sbellard ts->name = name; 371c896fe29Sbellard s->nb_globals++; 372c896fe29Sbellard tcg_regset_set_reg(s->reserved_regs, reg); 373a7812ae4Spbrook return idx; 374a7812ae4Spbrook } 375a7812ae4Spbrook 376a7812ae4Spbrook TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name) 377a7812ae4Spbrook { 378a7812ae4Spbrook int idx; 379a7812ae4Spbrook 380a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name); 381a7812ae4Spbrook return MAKE_TCGV_I32(idx); 382a7812ae4Spbrook } 383a7812ae4Spbrook 384a7812ae4Spbrook TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name) 385a7812ae4Spbrook { 386a7812ae4Spbrook int idx; 387a7812ae4Spbrook 388a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I64, reg, name); 389a7812ae4Spbrook return MAKE_TCGV_I64(idx); 390c896fe29Sbellard } 391c896fe29Sbellard 392a7812ae4Spbrook static inline int tcg_global_mem_new_internal(TCGType type, int reg, 3932f2f244dSRichard Henderson intptr_t offset, 394c896fe29Sbellard const char *name) 395c896fe29Sbellard { 396c896fe29Sbellard TCGContext *s = &tcg_ctx; 397c896fe29Sbellard TCGTemp *ts; 398c896fe29Sbellard int idx; 399c896fe29Sbellard 400c896fe29Sbellard idx = s->nb_globals; 401c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 402c896fe29Sbellard if (type == TCG_TYPE_I64) { 403c896fe29Sbellard char buf[64]; 404c588979bSths tcg_temp_alloc(s, s->nb_globals + 2); 405c896fe29Sbellard ts = &s->temps[s->nb_globals]; 406c896fe29Sbellard ts->base_type = type; 407c896fe29Sbellard ts->type = TCG_TYPE_I32; 408c896fe29Sbellard ts->fixed_reg = 0; 409c896fe29Sbellard ts->mem_allocated = 1; 410c896fe29Sbellard ts->mem_reg = reg; 411c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 412c896fe29Sbellard ts->mem_offset = offset + 4; 413c896fe29Sbellard #else 414c896fe29Sbellard ts->mem_offset = offset; 415c896fe29Sbellard #endif 416c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 417c896fe29Sbellard pstrcat(buf, sizeof(buf), "_0"); 418c896fe29Sbellard ts->name = strdup(buf); 419c896fe29Sbellard ts++; 420c896fe29Sbellard 421c896fe29Sbellard ts->base_type = type; 422c896fe29Sbellard ts->type = TCG_TYPE_I32; 423c896fe29Sbellard ts->fixed_reg = 0; 424c896fe29Sbellard ts->mem_allocated = 1; 425c896fe29Sbellard ts->mem_reg = reg; 426c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 427c896fe29Sbellard ts->mem_offset = offset; 428c896fe29Sbellard #else 429c896fe29Sbellard ts->mem_offset = offset + 4; 430c896fe29Sbellard #endif 431c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 432c896fe29Sbellard pstrcat(buf, sizeof(buf), "_1"); 433c896fe29Sbellard ts->name = strdup(buf); 434c896fe29Sbellard 435c896fe29Sbellard s->nb_globals += 2; 436c896fe29Sbellard } else 437c896fe29Sbellard #endif 438c896fe29Sbellard { 439c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 440c896fe29Sbellard ts = &s->temps[s->nb_globals]; 441c896fe29Sbellard ts->base_type = type; 442c896fe29Sbellard ts->type = type; 443c896fe29Sbellard ts->fixed_reg = 0; 444c896fe29Sbellard ts->mem_allocated = 1; 445c896fe29Sbellard ts->mem_reg = reg; 446c896fe29Sbellard ts->mem_offset = offset; 447c896fe29Sbellard ts->name = name; 448c896fe29Sbellard s->nb_globals++; 449c896fe29Sbellard } 450a7812ae4Spbrook return idx; 451c896fe29Sbellard } 452c896fe29Sbellard 4532f2f244dSRichard Henderson TCGv_i32 tcg_global_mem_new_i32(int reg, intptr_t offset, const char *name) 454a7812ae4Spbrook { 4552f2f244dSRichard Henderson int idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name); 456a7812ae4Spbrook return MAKE_TCGV_I32(idx); 457a7812ae4Spbrook } 458a7812ae4Spbrook 4592f2f244dSRichard Henderson TCGv_i64 tcg_global_mem_new_i64(int reg, intptr_t offset, const char *name) 460a7812ae4Spbrook { 4612f2f244dSRichard Henderson int idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name); 462a7812ae4Spbrook return MAKE_TCGV_I64(idx); 463a7812ae4Spbrook } 464a7812ae4Spbrook 465a7812ae4Spbrook static inline int tcg_temp_new_internal(TCGType type, int temp_local) 466c896fe29Sbellard { 467c896fe29Sbellard TCGContext *s = &tcg_ctx; 468c896fe29Sbellard TCGTemp *ts; 469641d5fbeSbellard int idx, k; 470c896fe29Sbellard 471641d5fbeSbellard k = type; 472641d5fbeSbellard if (temp_local) 473641d5fbeSbellard k += TCG_TYPE_COUNT; 474641d5fbeSbellard idx = s->first_free_temp[k]; 475e8996ee0Sbellard if (idx != -1) { 476e8996ee0Sbellard /* There is already an available temp with the 477e8996ee0Sbellard right type */ 478e8996ee0Sbellard ts = &s->temps[idx]; 479641d5fbeSbellard s->first_free_temp[k] = ts->next_free_temp; 480e8996ee0Sbellard ts->temp_allocated = 1; 481641d5fbeSbellard assert(ts->temp_local == temp_local); 482e8996ee0Sbellard } else { 483c896fe29Sbellard idx = s->nb_temps; 484c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 485c896fe29Sbellard if (type == TCG_TYPE_I64) { 4868df1ca4bSths tcg_temp_alloc(s, s->nb_temps + 2); 487c896fe29Sbellard ts = &s->temps[s->nb_temps]; 488c896fe29Sbellard ts->base_type = type; 489c896fe29Sbellard ts->type = TCG_TYPE_I32; 490e8996ee0Sbellard ts->temp_allocated = 1; 491641d5fbeSbellard ts->temp_local = temp_local; 492c896fe29Sbellard ts->name = NULL; 493c896fe29Sbellard ts++; 494c896fe29Sbellard ts->base_type = TCG_TYPE_I32; 495c896fe29Sbellard ts->type = TCG_TYPE_I32; 496e8996ee0Sbellard ts->temp_allocated = 1; 497641d5fbeSbellard ts->temp_local = temp_local; 498c896fe29Sbellard ts->name = NULL; 499c896fe29Sbellard s->nb_temps += 2; 500c896fe29Sbellard } else 501c896fe29Sbellard #endif 502c896fe29Sbellard { 503c896fe29Sbellard tcg_temp_alloc(s, s->nb_temps + 1); 504c896fe29Sbellard ts = &s->temps[s->nb_temps]; 505c896fe29Sbellard ts->base_type = type; 506c896fe29Sbellard ts->type = type; 507e8996ee0Sbellard ts->temp_allocated = 1; 508641d5fbeSbellard ts->temp_local = temp_local; 509c896fe29Sbellard ts->name = NULL; 510c896fe29Sbellard s->nb_temps++; 511c896fe29Sbellard } 512e8996ee0Sbellard } 51327bfd83cSPeter Maydell 51427bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 51527bfd83cSPeter Maydell s->temps_in_use++; 51627bfd83cSPeter Maydell #endif 517a7812ae4Spbrook return idx; 518c896fe29Sbellard } 519c896fe29Sbellard 520a7812ae4Spbrook TCGv_i32 tcg_temp_new_internal_i32(int temp_local) 521a7812ae4Spbrook { 522a7812ae4Spbrook int idx; 523a7812ae4Spbrook 524a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I32, temp_local); 525a7812ae4Spbrook return MAKE_TCGV_I32(idx); 526a7812ae4Spbrook } 527a7812ae4Spbrook 528a7812ae4Spbrook TCGv_i64 tcg_temp_new_internal_i64(int temp_local) 529a7812ae4Spbrook { 530a7812ae4Spbrook int idx; 531a7812ae4Spbrook 532a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I64, temp_local); 533a7812ae4Spbrook return MAKE_TCGV_I64(idx); 534a7812ae4Spbrook } 535a7812ae4Spbrook 536a7812ae4Spbrook static inline void tcg_temp_free_internal(int idx) 537c896fe29Sbellard { 538c896fe29Sbellard TCGContext *s = &tcg_ctx; 539c896fe29Sbellard TCGTemp *ts; 540641d5fbeSbellard int k; 541c896fe29Sbellard 54227bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 54327bfd83cSPeter Maydell s->temps_in_use--; 54427bfd83cSPeter Maydell if (s->temps_in_use < 0) { 54527bfd83cSPeter Maydell fprintf(stderr, "More temporaries freed than allocated!\n"); 54627bfd83cSPeter Maydell } 54727bfd83cSPeter Maydell #endif 54827bfd83cSPeter Maydell 549e8996ee0Sbellard assert(idx >= s->nb_globals && idx < s->nb_temps); 550c896fe29Sbellard ts = &s->temps[idx]; 551e8996ee0Sbellard assert(ts->temp_allocated != 0); 552e8996ee0Sbellard ts->temp_allocated = 0; 553641d5fbeSbellard k = ts->base_type; 554641d5fbeSbellard if (ts->temp_local) 555641d5fbeSbellard k += TCG_TYPE_COUNT; 556641d5fbeSbellard ts->next_free_temp = s->first_free_temp[k]; 557641d5fbeSbellard s->first_free_temp[k] = idx; 558e8996ee0Sbellard } 559e8996ee0Sbellard 560a7812ae4Spbrook void tcg_temp_free_i32(TCGv_i32 arg) 561e8996ee0Sbellard { 562a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I32(arg)); 563a7812ae4Spbrook } 564a7812ae4Spbrook 565a7812ae4Spbrook void tcg_temp_free_i64(TCGv_i64 arg) 566a7812ae4Spbrook { 567a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I64(arg)); 568a7812ae4Spbrook } 569a7812ae4Spbrook 570a7812ae4Spbrook TCGv_i32 tcg_const_i32(int32_t val) 571a7812ae4Spbrook { 572a7812ae4Spbrook TCGv_i32 t0; 573a7812ae4Spbrook t0 = tcg_temp_new_i32(); 574e8996ee0Sbellard tcg_gen_movi_i32(t0, val); 575e8996ee0Sbellard return t0; 576c896fe29Sbellard } 577c896fe29Sbellard 578a7812ae4Spbrook TCGv_i64 tcg_const_i64(int64_t val) 579c896fe29Sbellard { 580a7812ae4Spbrook TCGv_i64 t0; 581a7812ae4Spbrook t0 = tcg_temp_new_i64(); 582e8996ee0Sbellard tcg_gen_movi_i64(t0, val); 583e8996ee0Sbellard return t0; 584c896fe29Sbellard } 585c896fe29Sbellard 586a7812ae4Spbrook TCGv_i32 tcg_const_local_i32(int32_t val) 587bdffd4a9Saurel32 { 588a7812ae4Spbrook TCGv_i32 t0; 589a7812ae4Spbrook t0 = tcg_temp_local_new_i32(); 590bdffd4a9Saurel32 tcg_gen_movi_i32(t0, val); 591bdffd4a9Saurel32 return t0; 592bdffd4a9Saurel32 } 593bdffd4a9Saurel32 594a7812ae4Spbrook TCGv_i64 tcg_const_local_i64(int64_t val) 595bdffd4a9Saurel32 { 596a7812ae4Spbrook TCGv_i64 t0; 597a7812ae4Spbrook t0 = tcg_temp_local_new_i64(); 598bdffd4a9Saurel32 tcg_gen_movi_i64(t0, val); 599bdffd4a9Saurel32 return t0; 600bdffd4a9Saurel32 } 601bdffd4a9Saurel32 60227bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 60327bfd83cSPeter Maydell void tcg_clear_temp_count(void) 60427bfd83cSPeter Maydell { 60527bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 60627bfd83cSPeter Maydell s->temps_in_use = 0; 60727bfd83cSPeter Maydell } 60827bfd83cSPeter Maydell 60927bfd83cSPeter Maydell int tcg_check_temp_count(void) 61027bfd83cSPeter Maydell { 61127bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 61227bfd83cSPeter Maydell if (s->temps_in_use) { 61327bfd83cSPeter Maydell /* Clear the count so that we don't give another 61427bfd83cSPeter Maydell * warning immediately next time around. 61527bfd83cSPeter Maydell */ 61627bfd83cSPeter Maydell s->temps_in_use = 0; 61727bfd83cSPeter Maydell return 1; 61827bfd83cSPeter Maydell } 61927bfd83cSPeter Maydell return 0; 62027bfd83cSPeter Maydell } 62127bfd83cSPeter Maydell #endif 62227bfd83cSPeter Maydell 623c896fe29Sbellard void tcg_register_helper(void *func, const char *name) 624c896fe29Sbellard { 625c896fe29Sbellard TCGContext *s = &tcg_ctx; 626*6e085f72SRichard Henderson GHashTable *table = s->helpers; 627*6e085f72SRichard Henderson 628*6e085f72SRichard Henderson if (table == NULL) { 629*6e085f72SRichard Henderson /* Use g_direct_hash/equal for direct pointer comparisons on func. */ 630*6e085f72SRichard Henderson table = g_hash_table_new(NULL, NULL); 631*6e085f72SRichard Henderson s->helpers = table; 632c896fe29Sbellard } 633*6e085f72SRichard Henderson 634*6e085f72SRichard Henderson g_hash_table_insert(table, (gpointer)func, (gpointer)name); 635c896fe29Sbellard } 636c896fe29Sbellard 63739cf05d3Sbellard /* Note: we convert the 64 bit args to 32 bit and do some alignment 63839cf05d3Sbellard and endian swap. Maybe it would be better to do the alignment 63939cf05d3Sbellard and endian swap in tcg_reg_alloc_call(). */ 640a7812ae4Spbrook void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags, 641a7812ae4Spbrook int sizemask, TCGArg ret, int nargs, TCGArg *args) 642c896fe29Sbellard { 643a7812ae4Spbrook int i; 644a7812ae4Spbrook int real_args; 645a7812ae4Spbrook int nb_rets; 646a7812ae4Spbrook TCGArg *nparam; 6472bece2c8SRichard Henderson 6482bece2c8SRichard Henderson #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 6492bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 6502bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 6512bece2c8SRichard Henderson int is_signed = sizemask & (2 << (i+1)*2); 6522bece2c8SRichard Henderson if (!is_64bit) { 6532bece2c8SRichard Henderson TCGv_i64 temp = tcg_temp_new_i64(); 6542bece2c8SRichard Henderson TCGv_i64 orig = MAKE_TCGV_I64(args[i]); 6552bece2c8SRichard Henderson if (is_signed) { 6562bece2c8SRichard Henderson tcg_gen_ext32s_i64(temp, orig); 6572bece2c8SRichard Henderson } else { 6582bece2c8SRichard Henderson tcg_gen_ext32u_i64(temp, orig); 6592bece2c8SRichard Henderson } 6602bece2c8SRichard Henderson args[i] = GET_TCGV_I64(temp); 6612bece2c8SRichard Henderson } 6622bece2c8SRichard Henderson } 6632bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 6642bece2c8SRichard Henderson 665efd7f486SEvgeny Voevodin *s->gen_opc_ptr++ = INDEX_op_call; 666c4afe5c4SEvgeny Voevodin nparam = s->gen_opparam_ptr++; 667a7812ae4Spbrook if (ret != TCG_CALL_DUMMY_ARG) { 668a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 669a7812ae4Spbrook if (sizemask & 1) { 670a7812ae4Spbrook #ifdef TCG_TARGET_WORDS_BIGENDIAN 671c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret + 1; 672c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret; 673a7812ae4Spbrook #else 674c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret; 675c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret + 1; 676a7812ae4Spbrook #endif 677a7812ae4Spbrook nb_rets = 2; 678a7812ae4Spbrook } else 679a7812ae4Spbrook #endif 680a7812ae4Spbrook { 681c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret; 682a7812ae4Spbrook nb_rets = 1; 683a7812ae4Spbrook } 684a7812ae4Spbrook } else { 685a7812ae4Spbrook nb_rets = 0; 686a7812ae4Spbrook } 687a7812ae4Spbrook real_args = 0; 688a7812ae4Spbrook for (i = 0; i < nargs; i++) { 689a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 6902bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 6912bece2c8SRichard Henderson if (is_64bit) { 69239cf05d3Sbellard #ifdef TCG_TARGET_CALL_ALIGN_ARGS 69339cf05d3Sbellard /* some targets want aligned 64 bit args */ 694ebd486d5Smalc if (real_args & 1) { 695c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = TCG_CALL_DUMMY_ARG; 696ebd486d5Smalc real_args++; 69739cf05d3Sbellard } 69839cf05d3Sbellard #endif 6993f90f252SRichard Henderson /* If stack grows up, then we will be placing successive 7003f90f252SRichard Henderson arguments at lower addresses, which means we need to 7013f90f252SRichard Henderson reverse the order compared to how we would normally 7023f90f252SRichard Henderson treat either big or little-endian. For those arguments 7033f90f252SRichard Henderson that will wind up in registers, this still works for 7043f90f252SRichard Henderson HPPA (the only current STACK_GROWSUP target) since the 7053f90f252SRichard Henderson argument registers are *also* allocated in decreasing 7063f90f252SRichard Henderson order. If another such target is added, this logic may 7073f90f252SRichard Henderson have to get more complicated to differentiate between 7083f90f252SRichard Henderson stack arguments and register arguments. */ 7093f90f252SRichard Henderson #if defined(TCG_TARGET_WORDS_BIGENDIAN) != defined(TCG_TARGET_STACK_GROWSUP) 710c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i] + 1; 711c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i]; 712c896fe29Sbellard #else 713c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i]; 714c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i] + 1; 715c896fe29Sbellard #endif 716a7812ae4Spbrook real_args += 2; 7172bece2c8SRichard Henderson continue; 7182bece2c8SRichard Henderson } 7192bece2c8SRichard Henderson #endif /* TCG_TARGET_REG_BITS < 64 */ 7202bece2c8SRichard Henderson 721c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i]; 722a7812ae4Spbrook real_args++; 723c896fe29Sbellard } 724c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = GET_TCGV_PTR(func); 725a7812ae4Spbrook 726c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = flags; 727a7812ae4Spbrook 728a7812ae4Spbrook *nparam = (nb_rets << 16) | (real_args + 1); 729a7812ae4Spbrook 730a7812ae4Spbrook /* total parameters, needed to go backward in the instruction stream */ 731c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = 1 + nb_rets + real_args + 3; 7322bece2c8SRichard Henderson 7332bece2c8SRichard Henderson #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 7342bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 7352bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 7362bece2c8SRichard Henderson if (!is_64bit) { 7372bece2c8SRichard Henderson TCGv_i64 temp = MAKE_TCGV_I64(args[i]); 7382bece2c8SRichard Henderson tcg_temp_free_i64(temp); 7392bece2c8SRichard Henderson } 7402bece2c8SRichard Henderson } 7412bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 742a7812ae4Spbrook } 743c896fe29Sbellard 744ac56dd48Spbrook #if TCG_TARGET_REG_BITS == 32 745a7812ae4Spbrook void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, 746c896fe29Sbellard int c, int right, int arith) 747c896fe29Sbellard { 748cf60bce4Sbellard if (c == 0) { 749a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1)); 750cf60bce4Sbellard tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1)); 751cf60bce4Sbellard } else if (c >= 32) { 752c896fe29Sbellard c -= 32; 753c896fe29Sbellard if (right) { 754c896fe29Sbellard if (arith) { 755a7812ae4Spbrook tcg_gen_sari_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 756ac56dd48Spbrook tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 31); 757c896fe29Sbellard } else { 758a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 759ac56dd48Spbrook tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 760c896fe29Sbellard } 761c896fe29Sbellard } else { 762a7812ae4Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_LOW(arg1), c); 763a7812ae4Spbrook tcg_gen_movi_i32(TCGV_LOW(ret), 0); 764c896fe29Sbellard } 765c896fe29Sbellard } else { 766a7812ae4Spbrook TCGv_i32 t0, t1; 767c896fe29Sbellard 768a7812ae4Spbrook t0 = tcg_temp_new_i32(); 769a7812ae4Spbrook t1 = tcg_temp_new_i32(); 770c896fe29Sbellard if (right) { 771ac56dd48Spbrook tcg_gen_shli_i32(t0, TCGV_HIGH(arg1), 32 - c); 772c896fe29Sbellard if (arith) 773ac56dd48Spbrook tcg_gen_sari_i32(t1, TCGV_HIGH(arg1), c); 774c896fe29Sbellard else 775ac56dd48Spbrook tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c); 776a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_LOW(arg1), c); 777a7812ae4Spbrook tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t0); 778ac56dd48Spbrook tcg_gen_mov_i32(TCGV_HIGH(ret), t1); 779c896fe29Sbellard } else { 780a7812ae4Spbrook tcg_gen_shri_i32(t0, TCGV_LOW(arg1), 32 - c); 781c896fe29Sbellard /* Note: ret can be the same as arg1, so we use t1 */ 782a7812ae4Spbrook tcg_gen_shli_i32(t1, TCGV_LOW(arg1), c); 783ac56dd48Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c); 784ac56dd48Spbrook tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0); 785a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), t1); 786c896fe29Sbellard } 787a7812ae4Spbrook tcg_temp_free_i32(t0); 788a7812ae4Spbrook tcg_temp_free_i32(t1); 789c896fe29Sbellard } 790c896fe29Sbellard } 791ac56dd48Spbrook #endif 792c896fe29Sbellard 793be210acbSRichard Henderson 7948fcd3692Sblueswir1 static void tcg_reg_alloc_start(TCGContext *s) 795c896fe29Sbellard { 796c896fe29Sbellard int i; 797c896fe29Sbellard TCGTemp *ts; 798c896fe29Sbellard for(i = 0; i < s->nb_globals; i++) { 799c896fe29Sbellard ts = &s->temps[i]; 800c896fe29Sbellard if (ts->fixed_reg) { 801c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 802c896fe29Sbellard } else { 803c896fe29Sbellard ts->val_type = TEMP_VAL_MEM; 804c896fe29Sbellard } 805c896fe29Sbellard } 806e8996ee0Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 807e8996ee0Sbellard ts = &s->temps[i]; 8087dfd8c6aSAurelien Jarno if (ts->temp_local) { 8097dfd8c6aSAurelien Jarno ts->val_type = TEMP_VAL_MEM; 8107dfd8c6aSAurelien Jarno } else { 811e8996ee0Sbellard ts->val_type = TEMP_VAL_DEAD; 8127dfd8c6aSAurelien Jarno } 813e8996ee0Sbellard ts->mem_allocated = 0; 814e8996ee0Sbellard ts->fixed_reg = 0; 815e8996ee0Sbellard } 816c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 817c896fe29Sbellard s->reg_to_temp[i] = -1; 818c896fe29Sbellard } 819c896fe29Sbellard } 820c896fe29Sbellard 821ac56dd48Spbrook static char *tcg_get_arg_str_idx(TCGContext *s, char *buf, int buf_size, 822ac56dd48Spbrook int idx) 823c896fe29Sbellard { 824c896fe29Sbellard TCGTemp *ts; 825ac56dd48Spbrook 8267f6f0ae5SStefan Weil assert(idx >= 0 && idx < s->nb_temps); 827ac56dd48Spbrook ts = &s->temps[idx]; 828ac56dd48Spbrook if (idx < s->nb_globals) { 829ac56dd48Spbrook pstrcpy(buf, buf_size, ts->name); 830c896fe29Sbellard } else { 831641d5fbeSbellard if (ts->temp_local) 832641d5fbeSbellard snprintf(buf, buf_size, "loc%d", idx - s->nb_globals); 833641d5fbeSbellard else 834ac56dd48Spbrook snprintf(buf, buf_size, "tmp%d", idx - s->nb_globals); 835c896fe29Sbellard } 836c896fe29Sbellard return buf; 837c896fe29Sbellard } 838c896fe29Sbellard 839a7812ae4Spbrook char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg) 840ac56dd48Spbrook { 841a7812ae4Spbrook return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I32(arg)); 842a7812ae4Spbrook } 843a7812ae4Spbrook 844a7812ae4Spbrook char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg) 845a7812ae4Spbrook { 846a810a2deSblueswir1 return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I64(arg)); 847ac56dd48Spbrook } 848ac56dd48Spbrook 849*6e085f72SRichard Henderson /* Find helper name. */ 850*6e085f72SRichard Henderson static inline const char *tcg_find_helper(TCGContext *s, uintptr_t val) 851e8996ee0Sbellard { 852*6e085f72SRichard Henderson const char *ret = NULL; 853*6e085f72SRichard Henderson if (s->helpers) { 854*6e085f72SRichard Henderson ret = g_hash_table_lookup(s->helpers, (gpointer)val); 855e8996ee0Sbellard } 856*6e085f72SRichard Henderson return ret; 8574dc81f28Sbellard } 8584dc81f28Sbellard 859f48f3edeSblueswir1 static const char * const cond_name[] = 860f48f3edeSblueswir1 { 8610aed257fSRichard Henderson [TCG_COND_NEVER] = "never", 8620aed257fSRichard Henderson [TCG_COND_ALWAYS] = "always", 863f48f3edeSblueswir1 [TCG_COND_EQ] = "eq", 864f48f3edeSblueswir1 [TCG_COND_NE] = "ne", 865f48f3edeSblueswir1 [TCG_COND_LT] = "lt", 866f48f3edeSblueswir1 [TCG_COND_GE] = "ge", 867f48f3edeSblueswir1 [TCG_COND_LE] = "le", 868f48f3edeSblueswir1 [TCG_COND_GT] = "gt", 869f48f3edeSblueswir1 [TCG_COND_LTU] = "ltu", 870f48f3edeSblueswir1 [TCG_COND_GEU] = "geu", 871f48f3edeSblueswir1 [TCG_COND_LEU] = "leu", 872f48f3edeSblueswir1 [TCG_COND_GTU] = "gtu" 873f48f3edeSblueswir1 }; 874f48f3edeSblueswir1 875eeacee4dSBlue Swirl void tcg_dump_ops(TCGContext *s) 876c896fe29Sbellard { 877c896fe29Sbellard const uint16_t *opc_ptr; 878c896fe29Sbellard const TCGArg *args; 879c896fe29Sbellard TCGArg arg; 880a9751609SRichard Henderson TCGOpcode c; 881a9751609SRichard Henderson int i, k, nb_oargs, nb_iargs, nb_cargs, first_insn; 882c896fe29Sbellard const TCGOpDef *def; 883c896fe29Sbellard char buf[128]; 884c896fe29Sbellard 8857e4597d7Sbellard first_insn = 1; 88692414b31SEvgeny Voevodin opc_ptr = s->gen_opc_buf; 8871ff0a2c5SEvgeny Voevodin args = s->gen_opparam_buf; 888efd7f486SEvgeny Voevodin while (opc_ptr < s->gen_opc_ptr) { 889c896fe29Sbellard c = *opc_ptr++; 890c896fe29Sbellard def = &tcg_op_defs[c]; 8917e4597d7Sbellard if (c == INDEX_op_debug_insn_start) { 8927e4597d7Sbellard uint64_t pc; 8937e4597d7Sbellard #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS 8947e4597d7Sbellard pc = ((uint64_t)args[1] << 32) | args[0]; 8957e4597d7Sbellard #else 8967e4597d7Sbellard pc = args[0]; 8977e4597d7Sbellard #endif 898eeacee4dSBlue Swirl if (!first_insn) { 899eeacee4dSBlue Swirl qemu_log("\n"); 900eeacee4dSBlue Swirl } 901eeacee4dSBlue Swirl qemu_log(" ---- 0x%" PRIx64, pc); 9027e4597d7Sbellard first_insn = 0; 9037e4597d7Sbellard nb_oargs = def->nb_oargs; 9047e4597d7Sbellard nb_iargs = def->nb_iargs; 9057e4597d7Sbellard nb_cargs = def->nb_cargs; 9067e4597d7Sbellard } else if (c == INDEX_op_call) { 907c896fe29Sbellard TCGArg arg; 9084dc81f28Sbellard 909c896fe29Sbellard /* variable number of arguments */ 910c896fe29Sbellard arg = *args++; 911c896fe29Sbellard nb_oargs = arg >> 16; 912c896fe29Sbellard nb_iargs = arg & 0xffff; 913c896fe29Sbellard nb_cargs = def->nb_cargs; 914b03cce8eSbellard 915eeacee4dSBlue Swirl qemu_log(" %s ", def->name); 9167e4597d7Sbellard 917b03cce8eSbellard /* function name */ 918eeacee4dSBlue Swirl qemu_log("%s", 919eeacee4dSBlue Swirl tcg_get_arg_str_idx(s, buf, sizeof(buf), 920eeacee4dSBlue Swirl args[nb_oargs + nb_iargs - 1])); 921b03cce8eSbellard /* flags */ 922eeacee4dSBlue Swirl qemu_log(",$0x%" TCG_PRIlx, args[nb_oargs + nb_iargs]); 923b03cce8eSbellard /* nb out args */ 924eeacee4dSBlue Swirl qemu_log(",$%d", nb_oargs); 925b03cce8eSbellard for(i = 0; i < nb_oargs; i++) { 926eeacee4dSBlue Swirl qemu_log(","); 927eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 928eeacee4dSBlue Swirl args[i])); 929b03cce8eSbellard } 930b03cce8eSbellard for(i = 0; i < (nb_iargs - 1); i++) { 931eeacee4dSBlue Swirl qemu_log(","); 93239cf05d3Sbellard if (args[nb_oargs + i] == TCG_CALL_DUMMY_ARG) { 933eeacee4dSBlue Swirl qemu_log("<dummy>"); 93439cf05d3Sbellard } else { 935eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 936eeacee4dSBlue Swirl args[nb_oargs + i])); 937b03cce8eSbellard } 93839cf05d3Sbellard } 939fba3161fSAurelien Jarno } else if (c == INDEX_op_movi_i32 || c == INDEX_op_movi_i64) { 940e8996ee0Sbellard tcg_target_ulong val; 941*6e085f72SRichard Henderson const char *name; 942e8996ee0Sbellard 943e8996ee0Sbellard nb_oargs = def->nb_oargs; 944e8996ee0Sbellard nb_iargs = def->nb_iargs; 945e8996ee0Sbellard nb_cargs = def->nb_cargs; 946eeacee4dSBlue Swirl qemu_log(" %s %s,$", def->name, 947e8996ee0Sbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[0])); 948e8996ee0Sbellard val = args[1]; 949*6e085f72SRichard Henderson name = tcg_find_helper(s, val); 950*6e085f72SRichard Henderson if (name) { 951*6e085f72SRichard Henderson qemu_log("%s", name); 952e8996ee0Sbellard } else { 953eeacee4dSBlue Swirl if (c == INDEX_op_movi_i32) { 954eeacee4dSBlue Swirl qemu_log("0x%x", (uint32_t)val); 955eeacee4dSBlue Swirl } else { 956eeacee4dSBlue Swirl qemu_log("0x%" PRIx64 , (uint64_t)val); 957eeacee4dSBlue Swirl } 958e8996ee0Sbellard } 959b03cce8eSbellard } else { 960eeacee4dSBlue Swirl qemu_log(" %s ", def->name); 961b03cce8eSbellard if (c == INDEX_op_nopn) { 962c896fe29Sbellard /* variable number of arguments */ 963c896fe29Sbellard nb_cargs = *args; 964c896fe29Sbellard nb_oargs = 0; 965c896fe29Sbellard nb_iargs = 0; 966c896fe29Sbellard } else { 967c896fe29Sbellard nb_oargs = def->nb_oargs; 968c896fe29Sbellard nb_iargs = def->nb_iargs; 969c896fe29Sbellard nb_cargs = def->nb_cargs; 970c896fe29Sbellard } 971c896fe29Sbellard 972c896fe29Sbellard k = 0; 973c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 974eeacee4dSBlue Swirl if (k != 0) { 975eeacee4dSBlue Swirl qemu_log(","); 976eeacee4dSBlue Swirl } 977eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 978eeacee4dSBlue Swirl args[k++])); 979c896fe29Sbellard } 980c896fe29Sbellard for(i = 0; i < nb_iargs; i++) { 981eeacee4dSBlue Swirl if (k != 0) { 982eeacee4dSBlue Swirl qemu_log(","); 983eeacee4dSBlue Swirl } 984eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 985eeacee4dSBlue Swirl args[k++])); 986c896fe29Sbellard } 987be210acbSRichard Henderson switch (c) { 988be210acbSRichard Henderson case INDEX_op_brcond_i32: 989ffc5ea09SRichard Henderson case INDEX_op_setcond_i32: 990ffc5ea09SRichard Henderson case INDEX_op_movcond_i32: 991be210acbSRichard Henderson case INDEX_op_brcond2_i32: 992be210acbSRichard Henderson case INDEX_op_setcond2_i32: 993ffc5ea09SRichard Henderson case INDEX_op_brcond_i64: 994be210acbSRichard Henderson case INDEX_op_setcond_i64: 995ffc5ea09SRichard Henderson case INDEX_op_movcond_i64: 996eeacee4dSBlue Swirl if (args[k] < ARRAY_SIZE(cond_name) && cond_name[args[k]]) { 997eeacee4dSBlue Swirl qemu_log(",%s", cond_name[args[k++]]); 998eeacee4dSBlue Swirl } else { 999eeacee4dSBlue Swirl qemu_log(",$0x%" TCG_PRIlx, args[k++]); 1000eeacee4dSBlue Swirl } 1001f48f3edeSblueswir1 i = 1; 1002be210acbSRichard Henderson break; 1003be210acbSRichard Henderson default: 1004f48f3edeSblueswir1 i = 0; 1005be210acbSRichard Henderson break; 1006be210acbSRichard Henderson } 1007f48f3edeSblueswir1 for(; i < nb_cargs; i++) { 1008eeacee4dSBlue Swirl if (k != 0) { 1009eeacee4dSBlue Swirl qemu_log(","); 1010eeacee4dSBlue Swirl } 1011c896fe29Sbellard arg = args[k++]; 1012eeacee4dSBlue Swirl qemu_log("$0x%" TCG_PRIlx, arg); 1013c896fe29Sbellard } 1014b03cce8eSbellard } 1015eeacee4dSBlue Swirl qemu_log("\n"); 1016c896fe29Sbellard args += nb_iargs + nb_oargs + nb_cargs; 1017c896fe29Sbellard } 1018c896fe29Sbellard } 1019c896fe29Sbellard 1020c896fe29Sbellard /* we give more priority to constraints with less registers */ 1021c896fe29Sbellard static int get_constraint_priority(const TCGOpDef *def, int k) 1022c896fe29Sbellard { 1023c896fe29Sbellard const TCGArgConstraint *arg_ct; 1024c896fe29Sbellard 1025c896fe29Sbellard int i, n; 1026c896fe29Sbellard arg_ct = &def->args_ct[k]; 1027c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 1028c896fe29Sbellard /* an alias is equivalent to a single register */ 1029c896fe29Sbellard n = 1; 1030c896fe29Sbellard } else { 1031c896fe29Sbellard if (!(arg_ct->ct & TCG_CT_REG)) 1032c896fe29Sbellard return 0; 1033c896fe29Sbellard n = 0; 1034c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1035c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, i)) 1036c896fe29Sbellard n++; 1037c896fe29Sbellard } 1038c896fe29Sbellard } 1039c896fe29Sbellard return TCG_TARGET_NB_REGS - n + 1; 1040c896fe29Sbellard } 1041c896fe29Sbellard 1042c896fe29Sbellard /* sort from highest priority to lowest */ 1043c896fe29Sbellard static void sort_constraints(TCGOpDef *def, int start, int n) 1044c896fe29Sbellard { 1045c896fe29Sbellard int i, j, p1, p2, tmp; 1046c896fe29Sbellard 1047c896fe29Sbellard for(i = 0; i < n; i++) 1048c896fe29Sbellard def->sorted_args[start + i] = start + i; 1049c896fe29Sbellard if (n <= 1) 1050c896fe29Sbellard return; 1051c896fe29Sbellard for(i = 0; i < n - 1; i++) { 1052c896fe29Sbellard for(j = i + 1; j < n; j++) { 1053c896fe29Sbellard p1 = get_constraint_priority(def, def->sorted_args[start + i]); 1054c896fe29Sbellard p2 = get_constraint_priority(def, def->sorted_args[start + j]); 1055c896fe29Sbellard if (p1 < p2) { 1056c896fe29Sbellard tmp = def->sorted_args[start + i]; 1057c896fe29Sbellard def->sorted_args[start + i] = def->sorted_args[start + j]; 1058c896fe29Sbellard def->sorted_args[start + j] = tmp; 1059c896fe29Sbellard } 1060c896fe29Sbellard } 1061c896fe29Sbellard } 1062c896fe29Sbellard } 1063c896fe29Sbellard 1064c896fe29Sbellard void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs) 1065c896fe29Sbellard { 1066a9751609SRichard Henderson TCGOpcode op; 1067c896fe29Sbellard TCGOpDef *def; 1068c896fe29Sbellard const char *ct_str; 1069c896fe29Sbellard int i, nb_args; 1070c896fe29Sbellard 1071c896fe29Sbellard for(;;) { 1072a9751609SRichard Henderson if (tdefs->op == (TCGOpcode)-1) 1073c896fe29Sbellard break; 1074c896fe29Sbellard op = tdefs->op; 1075c3b08d0eSStefan Weil assert((unsigned)op < NB_OPS); 1076c896fe29Sbellard def = &tcg_op_defs[op]; 1077c68aaa18SStefan Weil #if defined(CONFIG_DEBUG_TCG) 1078c68aaa18SStefan Weil /* Duplicate entry in op definitions? */ 1079c68aaa18SStefan Weil assert(!def->used); 1080c68aaa18SStefan Weil def->used = 1; 1081c68aaa18SStefan Weil #endif 1082c896fe29Sbellard nb_args = def->nb_iargs + def->nb_oargs; 1083c896fe29Sbellard for(i = 0; i < nb_args; i++) { 1084c896fe29Sbellard ct_str = tdefs->args_ct_str[i]; 1085c68aaa18SStefan Weil /* Incomplete TCGTargetOpDef entry? */ 1086c68aaa18SStefan Weil assert(ct_str != NULL); 1087c896fe29Sbellard tcg_regset_clear(def->args_ct[i].u.regs); 1088c896fe29Sbellard def->args_ct[i].ct = 0; 1089c896fe29Sbellard if (ct_str[0] >= '0' && ct_str[0] <= '9') { 1090c896fe29Sbellard int oarg; 1091c896fe29Sbellard oarg = ct_str[0] - '0'; 1092c896fe29Sbellard assert(oarg < def->nb_oargs); 1093c896fe29Sbellard assert(def->args_ct[oarg].ct & TCG_CT_REG); 1094c896fe29Sbellard /* TCG_CT_ALIAS is for the output arguments. The input 10955ff9d6a4Sbellard argument is tagged with TCG_CT_IALIAS. */ 1096c896fe29Sbellard def->args_ct[i] = def->args_ct[oarg]; 10975ff9d6a4Sbellard def->args_ct[oarg].ct = TCG_CT_ALIAS; 10985ff9d6a4Sbellard def->args_ct[oarg].alias_index = i; 1099c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_IALIAS; 11005ff9d6a4Sbellard def->args_ct[i].alias_index = oarg; 1101c896fe29Sbellard } else { 1102c896fe29Sbellard for(;;) { 1103c896fe29Sbellard if (*ct_str == '\0') 1104c896fe29Sbellard break; 1105c896fe29Sbellard switch(*ct_str) { 1106c896fe29Sbellard case 'i': 1107c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_CONST; 1108c896fe29Sbellard ct_str++; 1109c896fe29Sbellard break; 1110c896fe29Sbellard default: 1111c896fe29Sbellard if (target_parse_constraint(&def->args_ct[i], &ct_str) < 0) { 1112c896fe29Sbellard fprintf(stderr, "Invalid constraint '%s' for arg %d of operation '%s'\n", 1113c896fe29Sbellard ct_str, i, def->name); 1114c896fe29Sbellard exit(1); 1115c896fe29Sbellard } 1116c896fe29Sbellard } 1117c896fe29Sbellard } 1118c896fe29Sbellard } 1119c896fe29Sbellard } 1120c896fe29Sbellard 1121c68aaa18SStefan Weil /* TCGTargetOpDef entry with too much information? */ 1122c68aaa18SStefan Weil assert(i == TCG_MAX_OP_ARGS || tdefs->args_ct_str[i] == NULL); 1123c68aaa18SStefan Weil 1124c896fe29Sbellard /* sort the constraints (XXX: this is just an heuristic) */ 1125c896fe29Sbellard sort_constraints(def, 0, def->nb_oargs); 1126c896fe29Sbellard sort_constraints(def, def->nb_oargs, def->nb_iargs); 1127c896fe29Sbellard 1128c896fe29Sbellard #if 0 1129c896fe29Sbellard { 1130c896fe29Sbellard int i; 1131c896fe29Sbellard 1132c896fe29Sbellard printf("%s: sorted=", def->name); 1133c896fe29Sbellard for(i = 0; i < def->nb_oargs + def->nb_iargs; i++) 1134c896fe29Sbellard printf(" %d", def->sorted_args[i]); 1135c896fe29Sbellard printf("\n"); 1136c896fe29Sbellard } 1137c896fe29Sbellard #endif 1138c896fe29Sbellard tdefs++; 1139c896fe29Sbellard } 1140c896fe29Sbellard 1141c68aaa18SStefan Weil #if defined(CONFIG_DEBUG_TCG) 1142a9751609SRichard Henderson i = 0; 1143c68aaa18SStefan Weil for (op = 0; op < ARRAY_SIZE(tcg_op_defs); op++) { 1144f412c762SRichard Henderson const TCGOpDef *def = &tcg_op_defs[op]; 1145c1a61f6cSRichard Henderson if (def->flags & TCG_OPF_NOT_PRESENT) { 1146c68aaa18SStefan Weil /* Wrong entry in op definitions? */ 1147f412c762SRichard Henderson if (def->used) { 1148f412c762SRichard Henderson fprintf(stderr, "Invalid op definition for %s\n", def->name); 1149a9751609SRichard Henderson i = 1; 1150a9751609SRichard Henderson } 1151c68aaa18SStefan Weil } else { 1152c68aaa18SStefan Weil /* Missing entry in op definitions? */ 1153f412c762SRichard Henderson if (!def->used) { 1154f412c762SRichard Henderson fprintf(stderr, "Missing op definition for %s\n", def->name); 1155a9751609SRichard Henderson i = 1; 1156c68aaa18SStefan Weil } 1157c68aaa18SStefan Weil } 1158a9751609SRichard Henderson } 1159a9751609SRichard Henderson if (i == 1) { 1160a9751609SRichard Henderson tcg_abort(); 1161a9751609SRichard Henderson } 1162c68aaa18SStefan Weil #endif 1163c896fe29Sbellard } 1164c896fe29Sbellard 1165c896fe29Sbellard #ifdef USE_LIVENESS_ANALYSIS 1166c896fe29Sbellard 1167c896fe29Sbellard /* set a nop for an operation using 'nb_args' */ 1168c896fe29Sbellard static inline void tcg_set_nop(TCGContext *s, uint16_t *opc_ptr, 1169c896fe29Sbellard TCGArg *args, int nb_args) 1170c896fe29Sbellard { 1171c896fe29Sbellard if (nb_args == 0) { 1172c896fe29Sbellard *opc_ptr = INDEX_op_nop; 1173c896fe29Sbellard } else { 1174c896fe29Sbellard *opc_ptr = INDEX_op_nopn; 1175c896fe29Sbellard args[0] = nb_args; 1176c896fe29Sbellard args[nb_args - 1] = nb_args; 1177c896fe29Sbellard } 1178c896fe29Sbellard } 1179c896fe29Sbellard 11809c43b68dSAurelien Jarno /* liveness analysis: end of function: all temps are dead, and globals 11819c43b68dSAurelien Jarno should be in memory. */ 11829c43b68dSAurelien Jarno static inline void tcg_la_func_end(TCGContext *s, uint8_t *dead_temps, 11839c43b68dSAurelien Jarno uint8_t *mem_temps) 1184c896fe29Sbellard { 11859c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_temps); 11869c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 11879c43b68dSAurelien Jarno memset(mem_temps + s->nb_globals, 0, s->nb_temps - s->nb_globals); 1188c896fe29Sbellard } 1189c896fe29Sbellard 11909c43b68dSAurelien Jarno /* liveness analysis: end of basic block: all temps are dead, globals 11919c43b68dSAurelien Jarno and local temps should be in memory. */ 11929c43b68dSAurelien Jarno static inline void tcg_la_bb_end(TCGContext *s, uint8_t *dead_temps, 11939c43b68dSAurelien Jarno uint8_t *mem_temps) 1194641d5fbeSbellard { 1195641d5fbeSbellard int i; 1196641d5fbeSbellard 11979c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_temps); 11989c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 1199641d5fbeSbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 12009c43b68dSAurelien Jarno mem_temps[i] = s->temps[i].temp_local; 1201641d5fbeSbellard } 1202641d5fbeSbellard } 1203641d5fbeSbellard 1204866cb6cbSAurelien Jarno /* Liveness analysis : update the opc_dead_args array to tell if a 1205c896fe29Sbellard given input arguments is dead. Instructions updating dead 1206c896fe29Sbellard temporaries are removed. */ 12078fcd3692Sblueswir1 static void tcg_liveness_analysis(TCGContext *s) 1208c896fe29Sbellard { 1209a9751609SRichard Henderson int i, op_index, nb_args, nb_iargs, nb_oargs, arg, nb_ops; 121003271524SRichard Henderson TCGOpcode op, op_new, op_new2; 1211c896fe29Sbellard TCGArg *args; 1212c896fe29Sbellard const TCGOpDef *def; 12139c43b68dSAurelien Jarno uint8_t *dead_temps, *mem_temps; 1214ec7a869dSAurelien Jarno uint16_t dead_args; 1215ec7a869dSAurelien Jarno uint8_t sync_args; 121603271524SRichard Henderson bool have_op_new2; 1217c896fe29Sbellard 1218efd7f486SEvgeny Voevodin s->gen_opc_ptr++; /* skip end */ 1219c896fe29Sbellard 122092414b31SEvgeny Voevodin nb_ops = s->gen_opc_ptr - s->gen_opc_buf; 1221c896fe29Sbellard 1222866cb6cbSAurelien Jarno s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t)); 1223ec7a869dSAurelien Jarno s->op_sync_args = tcg_malloc(nb_ops * sizeof(uint8_t)); 1224c896fe29Sbellard 1225c896fe29Sbellard dead_temps = tcg_malloc(s->nb_temps); 12269c43b68dSAurelien Jarno mem_temps = tcg_malloc(s->nb_temps); 12279c43b68dSAurelien Jarno tcg_la_func_end(s, dead_temps, mem_temps); 1228c896fe29Sbellard 1229c4afe5c4SEvgeny Voevodin args = s->gen_opparam_ptr; 1230c896fe29Sbellard op_index = nb_ops - 1; 1231c896fe29Sbellard while (op_index >= 0) { 123292414b31SEvgeny Voevodin op = s->gen_opc_buf[op_index]; 1233c896fe29Sbellard def = &tcg_op_defs[op]; 1234c896fe29Sbellard switch(op) { 1235c896fe29Sbellard case INDEX_op_call: 1236c6e113f5Sbellard { 1237c6e113f5Sbellard int call_flags; 1238c6e113f5Sbellard 1239c896fe29Sbellard nb_args = args[-1]; 1240c896fe29Sbellard args -= nb_args; 1241c896fe29Sbellard nb_iargs = args[0] & 0xffff; 1242c896fe29Sbellard nb_oargs = args[0] >> 16; 1243c896fe29Sbellard args++; 1244c6e113f5Sbellard call_flags = args[nb_oargs + nb_iargs]; 1245c6e113f5Sbellard 1246c6e113f5Sbellard /* pure functions can be removed if their result is not 1247c6e113f5Sbellard used */ 124878505279SAurelien Jarno if (call_flags & TCG_CALL_NO_SIDE_EFFECTS) { 1249c6e113f5Sbellard for(i = 0; i < nb_oargs; i++) { 1250c6e113f5Sbellard arg = args[i]; 12519c43b68dSAurelien Jarno if (!dead_temps[arg] || mem_temps[arg]) { 1252c6e113f5Sbellard goto do_not_remove_call; 1253c6e113f5Sbellard } 12549c43b68dSAurelien Jarno } 125592414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index, 1256c6e113f5Sbellard args - 1, nb_args); 1257c6e113f5Sbellard } else { 1258c6e113f5Sbellard do_not_remove_call: 1259c896fe29Sbellard 1260c896fe29Sbellard /* output args are dead */ 12616b64b624SAurelien Jarno dead_args = 0; 1262ec7a869dSAurelien Jarno sync_args = 0; 1263c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1264c896fe29Sbellard arg = args[i]; 12656b64b624SAurelien Jarno if (dead_temps[arg]) { 12666b64b624SAurelien Jarno dead_args |= (1 << i); 12676b64b624SAurelien Jarno } 12689c43b68dSAurelien Jarno if (mem_temps[arg]) { 12699c43b68dSAurelien Jarno sync_args |= (1 << i); 12709c43b68dSAurelien Jarno } 1271c896fe29Sbellard dead_temps[arg] = 1; 12729c43b68dSAurelien Jarno mem_temps[arg] = 0; 1273c896fe29Sbellard } 1274c896fe29Sbellard 127578505279SAurelien Jarno if (!(call_flags & TCG_CALL_NO_READ_GLOBALS)) { 127678505279SAurelien Jarno /* globals should be synced to memory */ 127778505279SAurelien Jarno memset(mem_temps, 1, s->nb_globals); 127878505279SAurelien Jarno } 127978505279SAurelien Jarno if (!(call_flags & (TCG_CALL_NO_WRITE_GLOBALS | 128078505279SAurelien Jarno TCG_CALL_NO_READ_GLOBALS))) { 12819c43b68dSAurelien Jarno /* globals should go back to memory */ 12829c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_globals); 1283b9c18f56Saurel32 } 1284c896fe29Sbellard 1285c896fe29Sbellard /* input args are live */ 1286866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 1287866cb6cbSAurelien Jarno arg = args[i]; 128839cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 1289c896fe29Sbellard if (dead_temps[arg]) { 1290866cb6cbSAurelien Jarno dead_args |= (1 << i); 1291c896fe29Sbellard } 1292c896fe29Sbellard dead_temps[arg] = 0; 1293c896fe29Sbellard } 129439cf05d3Sbellard } 1295866cb6cbSAurelien Jarno s->op_dead_args[op_index] = dead_args; 1296ec7a869dSAurelien Jarno s->op_sync_args[op_index] = sync_args; 1297c6e113f5Sbellard } 1298c896fe29Sbellard args--; 1299c6e113f5Sbellard } 1300c896fe29Sbellard break; 13017e4597d7Sbellard case INDEX_op_debug_insn_start: 13027e4597d7Sbellard args -= def->nb_args; 13037e4597d7Sbellard break; 1304c896fe29Sbellard case INDEX_op_nopn: 1305c896fe29Sbellard nb_args = args[-1]; 1306c896fe29Sbellard args -= nb_args; 1307c896fe29Sbellard break; 13085ff9d6a4Sbellard case INDEX_op_discard: 13095ff9d6a4Sbellard args--; 13105ff9d6a4Sbellard /* mark the temporary as dead */ 13115ff9d6a4Sbellard dead_temps[args[0]] = 1; 13129c43b68dSAurelien Jarno mem_temps[args[0]] = 0; 13135ff9d6a4Sbellard break; 1314c896fe29Sbellard case INDEX_op_end: 1315c896fe29Sbellard break; 13161305c451SRichard Henderson 13171305c451SRichard Henderson case INDEX_op_add2_i32: 1318f1fae40cSRichard Henderson op_new = INDEX_op_add_i32; 1319f1fae40cSRichard Henderson goto do_addsub2; 13201305c451SRichard Henderson case INDEX_op_sub2_i32: 1321f1fae40cSRichard Henderson op_new = INDEX_op_sub_i32; 1322f1fae40cSRichard Henderson goto do_addsub2; 1323f1fae40cSRichard Henderson case INDEX_op_add2_i64: 1324f1fae40cSRichard Henderson op_new = INDEX_op_add_i64; 1325f1fae40cSRichard Henderson goto do_addsub2; 1326f1fae40cSRichard Henderson case INDEX_op_sub2_i64: 1327f1fae40cSRichard Henderson op_new = INDEX_op_sub_i64; 1328f1fae40cSRichard Henderson do_addsub2: 13291305c451SRichard Henderson args -= 6; 13301305c451SRichard Henderson nb_iargs = 4; 13311305c451SRichard Henderson nb_oargs = 2; 13321305c451SRichard Henderson /* Test if the high part of the operation is dead, but not 13331305c451SRichard Henderson the low part. The result can be optimized to a simple 13341305c451SRichard Henderson add or sub. This happens often for x86_64 guest when the 13351305c451SRichard Henderson cpu mode is set to 32 bit. */ 13363c5645faSKirill Batuzov if (dead_temps[args[1]] && !mem_temps[args[1]]) { 13373c5645faSKirill Batuzov if (dead_temps[args[0]] && !mem_temps[args[0]]) { 13381305c451SRichard Henderson goto do_remove; 13391305c451SRichard Henderson } 13401305c451SRichard Henderson /* Create the single operation plus nop. */ 1341f1fae40cSRichard Henderson s->gen_opc_buf[op_index] = op = op_new; 13421305c451SRichard Henderson args[1] = args[2]; 13431305c451SRichard Henderson args[2] = args[4]; 134492414b31SEvgeny Voevodin assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop); 134592414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 3); 13461305c451SRichard Henderson /* Fall through and mark the single-word operation live. */ 13471305c451SRichard Henderson nb_iargs = 2; 13481305c451SRichard Henderson nb_oargs = 1; 13491305c451SRichard Henderson } 13501305c451SRichard Henderson goto do_not_remove; 13511305c451SRichard Henderson 13521414968aSRichard Henderson case INDEX_op_mulu2_i32: 135303271524SRichard Henderson op_new = INDEX_op_mul_i32; 135403271524SRichard Henderson op_new2 = INDEX_op_muluh_i32; 135503271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_muluh_i32; 135603271524SRichard Henderson goto do_mul2; 1357f1fae40cSRichard Henderson case INDEX_op_muls2_i32: 1358f1fae40cSRichard Henderson op_new = INDEX_op_mul_i32; 135903271524SRichard Henderson op_new2 = INDEX_op_mulsh_i32; 136003271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_mulsh_i32; 1361f1fae40cSRichard Henderson goto do_mul2; 1362f1fae40cSRichard Henderson case INDEX_op_mulu2_i64: 136303271524SRichard Henderson op_new = INDEX_op_mul_i64; 136403271524SRichard Henderson op_new2 = INDEX_op_muluh_i64; 136503271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_muluh_i64; 136603271524SRichard Henderson goto do_mul2; 1367f1fae40cSRichard Henderson case INDEX_op_muls2_i64: 1368f1fae40cSRichard Henderson op_new = INDEX_op_mul_i64; 136903271524SRichard Henderson op_new2 = INDEX_op_mulsh_i64; 137003271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_mulsh_i64; 137103271524SRichard Henderson goto do_mul2; 1372f1fae40cSRichard Henderson do_mul2: 13731414968aSRichard Henderson args -= 4; 13741414968aSRichard Henderson nb_iargs = 2; 13751414968aSRichard Henderson nb_oargs = 2; 13763c5645faSKirill Batuzov if (dead_temps[args[1]] && !mem_temps[args[1]]) { 13773c5645faSKirill Batuzov if (dead_temps[args[0]] && !mem_temps[args[0]]) { 137803271524SRichard Henderson /* Both parts of the operation are dead. */ 13791414968aSRichard Henderson goto do_remove; 13801414968aSRichard Henderson } 138103271524SRichard Henderson /* The high part of the operation is dead; generate the low. */ 1382f1fae40cSRichard Henderson s->gen_opc_buf[op_index] = op = op_new; 13831414968aSRichard Henderson args[1] = args[2]; 13841414968aSRichard Henderson args[2] = args[3]; 138503271524SRichard Henderson } else if (have_op_new2 && dead_temps[args[0]] 138603271524SRichard Henderson && !mem_temps[args[0]]) { 138703271524SRichard Henderson /* The low part of the operation is dead; generate the high. */ 138803271524SRichard Henderson s->gen_opc_buf[op_index] = op = op_new2; 138903271524SRichard Henderson args[0] = args[1]; 139003271524SRichard Henderson args[1] = args[2]; 139103271524SRichard Henderson args[2] = args[3]; 139203271524SRichard Henderson } else { 139303271524SRichard Henderson goto do_not_remove; 139403271524SRichard Henderson } 139592414b31SEvgeny Voevodin assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop); 139692414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 1); 139703271524SRichard Henderson /* Mark the single-word operation live. */ 13981414968aSRichard Henderson nb_oargs = 1; 13991414968aSRichard Henderson goto do_not_remove; 14001414968aSRichard Henderson 1401c896fe29Sbellard default: 14021305c451SRichard Henderson /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */ 1403c896fe29Sbellard args -= def->nb_args; 1404c896fe29Sbellard nb_iargs = def->nb_iargs; 1405c896fe29Sbellard nb_oargs = def->nb_oargs; 1406c896fe29Sbellard 1407c896fe29Sbellard /* Test if the operation can be removed because all 14085ff9d6a4Sbellard its outputs are dead. We assume that nb_oargs == 0 14095ff9d6a4Sbellard implies side effects */ 14105ff9d6a4Sbellard if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) { 1411c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1412c896fe29Sbellard arg = args[i]; 14139c43b68dSAurelien Jarno if (!dead_temps[arg] || mem_temps[arg]) { 1414c896fe29Sbellard goto do_not_remove; 1415c896fe29Sbellard } 14169c43b68dSAurelien Jarno } 14171305c451SRichard Henderson do_remove: 141892414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index, args, def->nb_args); 1419c896fe29Sbellard #ifdef CONFIG_PROFILER 1420a23a9ec6Sbellard s->del_op_count++; 1421c896fe29Sbellard #endif 1422c896fe29Sbellard } else { 1423c896fe29Sbellard do_not_remove: 1424c896fe29Sbellard 1425c896fe29Sbellard /* output args are dead */ 14266b64b624SAurelien Jarno dead_args = 0; 1427ec7a869dSAurelien Jarno sync_args = 0; 1428c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1429c896fe29Sbellard arg = args[i]; 14306b64b624SAurelien Jarno if (dead_temps[arg]) { 14316b64b624SAurelien Jarno dead_args |= (1 << i); 14326b64b624SAurelien Jarno } 14339c43b68dSAurelien Jarno if (mem_temps[arg]) { 14349c43b68dSAurelien Jarno sync_args |= (1 << i); 14359c43b68dSAurelien Jarno } 1436c896fe29Sbellard dead_temps[arg] = 1; 14379c43b68dSAurelien Jarno mem_temps[arg] = 0; 1438c896fe29Sbellard } 1439c896fe29Sbellard 1440c896fe29Sbellard /* if end of basic block, update */ 1441c896fe29Sbellard if (def->flags & TCG_OPF_BB_END) { 14429c43b68dSAurelien Jarno tcg_la_bb_end(s, dead_temps, mem_temps); 14433d5c5f87SAurelien Jarno } else if (def->flags & TCG_OPF_SIDE_EFFECTS) { 14443d5c5f87SAurelien Jarno /* globals should be synced to memory */ 14459c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 1446c896fe29Sbellard } 1447c896fe29Sbellard 1448c896fe29Sbellard /* input args are live */ 1449866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 1450866cb6cbSAurelien Jarno arg = args[i]; 1451c896fe29Sbellard if (dead_temps[arg]) { 1452866cb6cbSAurelien Jarno dead_args |= (1 << i); 1453c896fe29Sbellard } 1454c896fe29Sbellard dead_temps[arg] = 0; 1455c896fe29Sbellard } 1456866cb6cbSAurelien Jarno s->op_dead_args[op_index] = dead_args; 1457ec7a869dSAurelien Jarno s->op_sync_args[op_index] = sync_args; 1458c896fe29Sbellard } 1459c896fe29Sbellard break; 1460c896fe29Sbellard } 1461c896fe29Sbellard op_index--; 1462c896fe29Sbellard } 1463c896fe29Sbellard 14641ff0a2c5SEvgeny Voevodin if (args != s->gen_opparam_buf) { 1465c896fe29Sbellard tcg_abort(); 1466c896fe29Sbellard } 14671ff0a2c5SEvgeny Voevodin } 1468c896fe29Sbellard #else 1469c896fe29Sbellard /* dummy liveness analysis */ 1470655feed5Smalc static void tcg_liveness_analysis(TCGContext *s) 1471c896fe29Sbellard { 1472c896fe29Sbellard int nb_ops; 147392414b31SEvgeny Voevodin nb_ops = s->gen_opc_ptr - s->gen_opc_buf; 1474c896fe29Sbellard 1475866cb6cbSAurelien Jarno s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t)); 1476866cb6cbSAurelien Jarno memset(s->op_dead_args, 0, nb_ops * sizeof(uint16_t)); 1477ec7a869dSAurelien Jarno s->op_sync_args = tcg_malloc(nb_ops * sizeof(uint8_t)); 1478ec7a869dSAurelien Jarno memset(s->op_sync_args, 0, nb_ops * sizeof(uint8_t)); 1479c896fe29Sbellard } 1480c896fe29Sbellard #endif 1481c896fe29Sbellard 1482c896fe29Sbellard #ifndef NDEBUG 1483c896fe29Sbellard static void dump_regs(TCGContext *s) 1484c896fe29Sbellard { 1485c896fe29Sbellard TCGTemp *ts; 1486c896fe29Sbellard int i; 1487c896fe29Sbellard char buf[64]; 1488c896fe29Sbellard 1489c896fe29Sbellard for(i = 0; i < s->nb_temps; i++) { 1490c896fe29Sbellard ts = &s->temps[i]; 1491ac56dd48Spbrook printf(" %10s: ", tcg_get_arg_str_idx(s, buf, sizeof(buf), i)); 1492c896fe29Sbellard switch(ts->val_type) { 1493c896fe29Sbellard case TEMP_VAL_REG: 1494c896fe29Sbellard printf("%s", tcg_target_reg_names[ts->reg]); 1495c896fe29Sbellard break; 1496c896fe29Sbellard case TEMP_VAL_MEM: 1497c896fe29Sbellard printf("%d(%s)", (int)ts->mem_offset, tcg_target_reg_names[ts->mem_reg]); 1498c896fe29Sbellard break; 1499c896fe29Sbellard case TEMP_VAL_CONST: 1500c896fe29Sbellard printf("$0x%" TCG_PRIlx, ts->val); 1501c896fe29Sbellard break; 1502c896fe29Sbellard case TEMP_VAL_DEAD: 1503c896fe29Sbellard printf("D"); 1504c896fe29Sbellard break; 1505c896fe29Sbellard default: 1506c896fe29Sbellard printf("???"); 1507c896fe29Sbellard break; 1508c896fe29Sbellard } 1509c896fe29Sbellard printf("\n"); 1510c896fe29Sbellard } 1511c896fe29Sbellard 1512c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1513c896fe29Sbellard if (s->reg_to_temp[i] >= 0) { 1514c896fe29Sbellard printf("%s: %s\n", 1515c896fe29Sbellard tcg_target_reg_names[i], 1516ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), s->reg_to_temp[i])); 1517c896fe29Sbellard } 1518c896fe29Sbellard } 1519c896fe29Sbellard } 1520c896fe29Sbellard 1521c896fe29Sbellard static void check_regs(TCGContext *s) 1522c896fe29Sbellard { 1523c896fe29Sbellard int reg, k; 1524c896fe29Sbellard TCGTemp *ts; 1525c896fe29Sbellard char buf[64]; 1526c896fe29Sbellard 1527c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1528c896fe29Sbellard k = s->reg_to_temp[reg]; 1529c896fe29Sbellard if (k >= 0) { 1530c896fe29Sbellard ts = &s->temps[k]; 1531c896fe29Sbellard if (ts->val_type != TEMP_VAL_REG || 1532c896fe29Sbellard ts->reg != reg) { 1533c896fe29Sbellard printf("Inconsistency for register %s:\n", 1534c896fe29Sbellard tcg_target_reg_names[reg]); 1535b03cce8eSbellard goto fail; 1536c896fe29Sbellard } 1537c896fe29Sbellard } 1538c896fe29Sbellard } 1539c896fe29Sbellard for(k = 0; k < s->nb_temps; k++) { 1540c896fe29Sbellard ts = &s->temps[k]; 1541c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG && 1542c896fe29Sbellard !ts->fixed_reg && 1543c896fe29Sbellard s->reg_to_temp[ts->reg] != k) { 1544c896fe29Sbellard printf("Inconsistency for temp %s:\n", 1545ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), k)); 1546b03cce8eSbellard fail: 1547c896fe29Sbellard printf("reg state:\n"); 1548c896fe29Sbellard dump_regs(s); 1549c896fe29Sbellard tcg_abort(); 1550c896fe29Sbellard } 1551c896fe29Sbellard } 1552c896fe29Sbellard } 1553c896fe29Sbellard #endif 1554c896fe29Sbellard 1555c896fe29Sbellard static void temp_allocate_frame(TCGContext *s, int temp) 1556c896fe29Sbellard { 1557c896fe29Sbellard TCGTemp *ts; 1558c896fe29Sbellard ts = &s->temps[temp]; 15599b9c37c3SRichard Henderson #if !(defined(__sparc__) && TCG_TARGET_REG_BITS == 64) 15609b9c37c3SRichard Henderson /* Sparc64 stack is accessed with offset of 2047 */ 1561b591dc59SBlue Swirl s->current_frame_offset = (s->current_frame_offset + 1562b591dc59SBlue Swirl (tcg_target_long)sizeof(tcg_target_long) - 1) & 1563b591dc59SBlue Swirl ~(sizeof(tcg_target_long) - 1); 1564f44c9960SBlue Swirl #endif 1565b591dc59SBlue Swirl if (s->current_frame_offset + (tcg_target_long)sizeof(tcg_target_long) > 1566b591dc59SBlue Swirl s->frame_end) { 15675ff9d6a4Sbellard tcg_abort(); 1568b591dc59SBlue Swirl } 1569c896fe29Sbellard ts->mem_offset = s->current_frame_offset; 1570c896fe29Sbellard ts->mem_reg = s->frame_reg; 1571c896fe29Sbellard ts->mem_allocated = 1; 1572e2c6d1b4SRichard Henderson s->current_frame_offset += sizeof(tcg_target_long); 1573c896fe29Sbellard } 1574c896fe29Sbellard 15757f6ceedfSAurelien Jarno /* sync register 'reg' by saving it to the corresponding temporary */ 15767f6ceedfSAurelien Jarno static inline void tcg_reg_sync(TCGContext *s, int reg) 1577c896fe29Sbellard { 1578c896fe29Sbellard TCGTemp *ts; 1579c896fe29Sbellard int temp; 1580c896fe29Sbellard 1581c896fe29Sbellard temp = s->reg_to_temp[reg]; 1582c896fe29Sbellard ts = &s->temps[temp]; 1583c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 15847f6ceedfSAurelien Jarno if (!ts->mem_coherent && !ts->fixed_reg) { 15857f6ceedfSAurelien Jarno if (!ts->mem_allocated) { 1586c896fe29Sbellard temp_allocate_frame(s, temp); 15877f6ceedfSAurelien Jarno } 1588e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1589c896fe29Sbellard } 15907f6ceedfSAurelien Jarno ts->mem_coherent = 1; 15917f6ceedfSAurelien Jarno } 15927f6ceedfSAurelien Jarno 15937f6ceedfSAurelien Jarno /* free register 'reg' by spilling the corresponding temporary if necessary */ 15947f6ceedfSAurelien Jarno static void tcg_reg_free(TCGContext *s, int reg) 15957f6ceedfSAurelien Jarno { 15967f6ceedfSAurelien Jarno int temp; 15977f6ceedfSAurelien Jarno 15987f6ceedfSAurelien Jarno temp = s->reg_to_temp[reg]; 15997f6ceedfSAurelien Jarno if (temp != -1) { 16007f6ceedfSAurelien Jarno tcg_reg_sync(s, reg); 16017f6ceedfSAurelien Jarno s->temps[temp].val_type = TEMP_VAL_MEM; 1602c896fe29Sbellard s->reg_to_temp[reg] = -1; 1603c896fe29Sbellard } 1604c896fe29Sbellard } 1605c896fe29Sbellard 1606c896fe29Sbellard /* Allocate a register belonging to reg1 & ~reg2 */ 1607c896fe29Sbellard static int tcg_reg_alloc(TCGContext *s, TCGRegSet reg1, TCGRegSet reg2) 1608c896fe29Sbellard { 1609c896fe29Sbellard int i, reg; 1610c896fe29Sbellard TCGRegSet reg_ct; 1611c896fe29Sbellard 1612c896fe29Sbellard tcg_regset_andnot(reg_ct, reg1, reg2); 1613c896fe29Sbellard 1614c896fe29Sbellard /* first try free registers */ 16150954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1616c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1617c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg) && s->reg_to_temp[reg] == -1) 1618c896fe29Sbellard return reg; 1619c896fe29Sbellard } 1620c896fe29Sbellard 1621c896fe29Sbellard /* XXX: do better spill choice */ 16220954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1623c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1624c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg)) { 1625c896fe29Sbellard tcg_reg_free(s, reg); 1626c896fe29Sbellard return reg; 1627c896fe29Sbellard } 1628c896fe29Sbellard } 1629c896fe29Sbellard 1630c896fe29Sbellard tcg_abort(); 1631c896fe29Sbellard } 1632c896fe29Sbellard 1633639368ddSAurelien Jarno /* mark a temporary as dead. */ 1634639368ddSAurelien Jarno static inline void temp_dead(TCGContext *s, int temp) 1635639368ddSAurelien Jarno { 1636639368ddSAurelien Jarno TCGTemp *ts; 1637639368ddSAurelien Jarno 1638639368ddSAurelien Jarno ts = &s->temps[temp]; 1639639368ddSAurelien Jarno if (!ts->fixed_reg) { 1640639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 1641639368ddSAurelien Jarno s->reg_to_temp[ts->reg] = -1; 1642639368ddSAurelien Jarno } 1643e5138db5SAurelien Jarno if (temp < s->nb_globals || ts->temp_local) { 1644639368ddSAurelien Jarno ts->val_type = TEMP_VAL_MEM; 1645639368ddSAurelien Jarno } else { 1646639368ddSAurelien Jarno ts->val_type = TEMP_VAL_DEAD; 1647639368ddSAurelien Jarno } 1648639368ddSAurelien Jarno } 1649639368ddSAurelien Jarno } 1650639368ddSAurelien Jarno 16511ad80729SAurelien Jarno /* sync a temporary to memory. 'allocated_regs' is used in case a 1652e8996ee0Sbellard temporary registers needs to be allocated to store a constant. */ 16531ad80729SAurelien Jarno static inline void temp_sync(TCGContext *s, int temp, TCGRegSet allocated_regs) 1654c896fe29Sbellard { 1655c896fe29Sbellard TCGTemp *ts; 1656c896fe29Sbellard 1657641d5fbeSbellard ts = &s->temps[temp]; 1658c896fe29Sbellard if (!ts->fixed_reg) { 1659e8996ee0Sbellard switch(ts->val_type) { 16601ad80729SAurelien Jarno case TEMP_VAL_CONST: 16611ad80729SAurelien Jarno ts->reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 16621ad80729SAurelien Jarno allocated_regs); 16631ad80729SAurelien Jarno ts->val_type = TEMP_VAL_REG; 16641ad80729SAurelien Jarno s->reg_to_temp[ts->reg] = temp; 16651ad80729SAurelien Jarno ts->mem_coherent = 0; 16661ad80729SAurelien Jarno tcg_out_movi(s, ts->type, ts->reg, ts->val); 16671ad80729SAurelien Jarno /* fallthrough*/ 1668e8996ee0Sbellard case TEMP_VAL_REG: 16691ad80729SAurelien Jarno tcg_reg_sync(s, ts->reg); 1670e8996ee0Sbellard break; 1671e8996ee0Sbellard case TEMP_VAL_DEAD: 1672e8996ee0Sbellard case TEMP_VAL_MEM: 1673e8996ee0Sbellard break; 1674e8996ee0Sbellard default: 1675e8996ee0Sbellard tcg_abort(); 1676c896fe29Sbellard } 1677c896fe29Sbellard } 1678c896fe29Sbellard } 1679641d5fbeSbellard 16801ad80729SAurelien Jarno /* save a temporary to memory. 'allocated_regs' is used in case a 16811ad80729SAurelien Jarno temporary registers needs to be allocated to store a constant. */ 16821ad80729SAurelien Jarno static inline void temp_save(TCGContext *s, int temp, TCGRegSet allocated_regs) 16831ad80729SAurelien Jarno { 16842c0366f0SAurelien Jarno #ifdef USE_LIVENESS_ANALYSIS 16852c0366f0SAurelien Jarno /* The liveness analysis already ensures that globals are back 16862c0366f0SAurelien Jarno in memory. Keep an assert for safety. */ 16872c0366f0SAurelien Jarno assert(s->temps[temp].val_type == TEMP_VAL_MEM || s->temps[temp].fixed_reg); 16882c0366f0SAurelien Jarno #else 16891ad80729SAurelien Jarno temp_sync(s, temp, allocated_regs); 16901ad80729SAurelien Jarno temp_dead(s, temp); 16912c0366f0SAurelien Jarno #endif 16921ad80729SAurelien Jarno } 16931ad80729SAurelien Jarno 16949814dd27SDong Xu Wang /* save globals to their canonical location and assume they can be 1695641d5fbeSbellard modified be the following code. 'allocated_regs' is used in case a 1696641d5fbeSbellard temporary registers needs to be allocated to store a constant. */ 1697641d5fbeSbellard static void save_globals(TCGContext *s, TCGRegSet allocated_regs) 1698641d5fbeSbellard { 1699641d5fbeSbellard int i; 1700641d5fbeSbellard 1701641d5fbeSbellard for(i = 0; i < s->nb_globals; i++) { 1702641d5fbeSbellard temp_save(s, i, allocated_regs); 1703641d5fbeSbellard } 1704e5097dc8Sbellard } 1705e5097dc8Sbellard 17063d5c5f87SAurelien Jarno /* sync globals to their canonical location and assume they can be 17073d5c5f87SAurelien Jarno read by the following code. 'allocated_regs' is used in case a 17083d5c5f87SAurelien Jarno temporary registers needs to be allocated to store a constant. */ 17093d5c5f87SAurelien Jarno static void sync_globals(TCGContext *s, TCGRegSet allocated_regs) 17103d5c5f87SAurelien Jarno { 17113d5c5f87SAurelien Jarno int i; 17123d5c5f87SAurelien Jarno 17133d5c5f87SAurelien Jarno for (i = 0; i < s->nb_globals; i++) { 17143d5c5f87SAurelien Jarno #ifdef USE_LIVENESS_ANALYSIS 17153d5c5f87SAurelien Jarno assert(s->temps[i].val_type != TEMP_VAL_REG || s->temps[i].fixed_reg || 17163d5c5f87SAurelien Jarno s->temps[i].mem_coherent); 17173d5c5f87SAurelien Jarno #else 17183d5c5f87SAurelien Jarno temp_sync(s, i, allocated_regs); 17193d5c5f87SAurelien Jarno #endif 17203d5c5f87SAurelien Jarno } 17213d5c5f87SAurelien Jarno } 17223d5c5f87SAurelien Jarno 1723e5097dc8Sbellard /* at the end of a basic block, we assume all temporaries are dead and 1724e8996ee0Sbellard all globals are stored at their canonical location. */ 1725e8996ee0Sbellard static void tcg_reg_alloc_bb_end(TCGContext *s, TCGRegSet allocated_regs) 1726e5097dc8Sbellard { 1727e5097dc8Sbellard TCGTemp *ts; 1728e5097dc8Sbellard int i; 1729e5097dc8Sbellard 1730c896fe29Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 1731c896fe29Sbellard ts = &s->temps[i]; 1732641d5fbeSbellard if (ts->temp_local) { 1733641d5fbeSbellard temp_save(s, i, allocated_regs); 1734641d5fbeSbellard } else { 17352c0366f0SAurelien Jarno #ifdef USE_LIVENESS_ANALYSIS 17362c0366f0SAurelien Jarno /* The liveness analysis already ensures that temps are dead. 17372c0366f0SAurelien Jarno Keep an assert for safety. */ 17382c0366f0SAurelien Jarno assert(ts->val_type == TEMP_VAL_DEAD); 17392c0366f0SAurelien Jarno #else 1740639368ddSAurelien Jarno temp_dead(s, i); 17412c0366f0SAurelien Jarno #endif 1742c896fe29Sbellard } 1743641d5fbeSbellard } 1744e8996ee0Sbellard 1745e8996ee0Sbellard save_globals(s, allocated_regs); 1746c896fe29Sbellard } 1747c896fe29Sbellard 1748866cb6cbSAurelien Jarno #define IS_DEAD_ARG(n) ((dead_args >> (n)) & 1) 1749ec7a869dSAurelien Jarno #define NEED_SYNC_ARG(n) ((sync_args >> (n)) & 1) 1750c896fe29Sbellard 1751ec7a869dSAurelien Jarno static void tcg_reg_alloc_movi(TCGContext *s, const TCGArg *args, 1752ec7a869dSAurelien Jarno uint16_t dead_args, uint8_t sync_args) 1753e8996ee0Sbellard { 1754e8996ee0Sbellard TCGTemp *ots; 1755e8996ee0Sbellard tcg_target_ulong val; 1756e8996ee0Sbellard 1757e8996ee0Sbellard ots = &s->temps[args[0]]; 1758e8996ee0Sbellard val = args[1]; 1759e8996ee0Sbellard 1760e8996ee0Sbellard if (ots->fixed_reg) { 1761e8996ee0Sbellard /* for fixed registers, we do not do any constant 1762e8996ee0Sbellard propagation */ 1763e8996ee0Sbellard tcg_out_movi(s, ots->type, ots->reg, val); 1764e8996ee0Sbellard } else { 17651235fc06Sths /* The movi is not explicitly generated here */ 1766e8996ee0Sbellard if (ots->val_type == TEMP_VAL_REG) 1767e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 1768e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 1769e8996ee0Sbellard ots->val = val; 1770e8996ee0Sbellard } 1771ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(0)) { 1772ec7a869dSAurelien Jarno temp_sync(s, args[0], s->reserved_regs); 1773ec7a869dSAurelien Jarno } 17744c4e1ab2SAurelien Jarno if (IS_DEAD_ARG(0)) { 17754c4e1ab2SAurelien Jarno temp_dead(s, args[0]); 17764c4e1ab2SAurelien Jarno } 1777e8996ee0Sbellard } 1778e8996ee0Sbellard 1779c896fe29Sbellard static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def, 1780ec7a869dSAurelien Jarno const TCGArg *args, uint16_t dead_args, 1781ec7a869dSAurelien Jarno uint8_t sync_args) 1782c896fe29Sbellard { 1783c29c1d7eSAurelien Jarno TCGRegSet allocated_regs; 1784c896fe29Sbellard TCGTemp *ts, *ots; 1785c29c1d7eSAurelien Jarno const TCGArgConstraint *arg_ct, *oarg_ct; 1786c896fe29Sbellard 1787c29c1d7eSAurelien Jarno tcg_regset_set(allocated_regs, s->reserved_regs); 1788c896fe29Sbellard ots = &s->temps[args[0]]; 1789c896fe29Sbellard ts = &s->temps[args[1]]; 1790c29c1d7eSAurelien Jarno oarg_ct = &def->args_ct[0]; 1791c29c1d7eSAurelien Jarno arg_ct = &def->args_ct[1]; 1792c896fe29Sbellard 1793c29c1d7eSAurelien Jarno /* If the source value is not in a register, and we're going to be 1794c29c1d7eSAurelien Jarno forced to have it in a register in order to perform the copy, 1795c29c1d7eSAurelien Jarno then copy the SOURCE value into its own register first. That way 1796c29c1d7eSAurelien Jarno we don't have to reload SOURCE the next time it is used. */ 1797c29c1d7eSAurelien Jarno if (((NEED_SYNC_ARG(0) || ots->fixed_reg) && ts->val_type != TEMP_VAL_REG) 1798c29c1d7eSAurelien Jarno || ts->val_type == TEMP_VAL_MEM) { 1799c29c1d7eSAurelien Jarno ts->reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1800c29c1d7eSAurelien Jarno if (ts->val_type == TEMP_VAL_MEM) { 1801c29c1d7eSAurelien Jarno tcg_out_ld(s, ts->type, ts->reg, ts->mem_reg, ts->mem_offset); 1802c29c1d7eSAurelien Jarno ts->mem_coherent = 1; 1803c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1804c29c1d7eSAurelien Jarno tcg_out_movi(s, ts->type, ts->reg, ts->val); 1805c29c1d7eSAurelien Jarno } 1806c29c1d7eSAurelien Jarno s->reg_to_temp[ts->reg] = args[1]; 1807c29c1d7eSAurelien Jarno ts->val_type = TEMP_VAL_REG; 1808c29c1d7eSAurelien Jarno } 1809c29c1d7eSAurelien Jarno 1810c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(0) && !ots->fixed_reg) { 1811c29c1d7eSAurelien Jarno /* mov to a non-saved dead register makes no sense (even with 1812c29c1d7eSAurelien Jarno liveness analysis disabled). */ 1813c29c1d7eSAurelien Jarno assert(NEED_SYNC_ARG(0)); 1814c29c1d7eSAurelien Jarno /* The code above should have moved the temp to a register. */ 1815c29c1d7eSAurelien Jarno assert(ts->val_type == TEMP_VAL_REG); 1816c29c1d7eSAurelien Jarno if (!ots->mem_allocated) { 1817c29c1d7eSAurelien Jarno temp_allocate_frame(s, args[0]); 1818c29c1d7eSAurelien Jarno } 1819c29c1d7eSAurelien Jarno tcg_out_st(s, ots->type, ts->reg, ots->mem_reg, ots->mem_offset); 1820c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(1)) { 1821c29c1d7eSAurelien Jarno temp_dead(s, args[1]); 1822c29c1d7eSAurelien Jarno } 1823c29c1d7eSAurelien Jarno temp_dead(s, args[0]); 1824c29c1d7eSAurelien Jarno } else if (ts->val_type == TEMP_VAL_CONST) { 1825e8996ee0Sbellard /* propagate constant */ 1826c29c1d7eSAurelien Jarno if (ots->val_type == TEMP_VAL_REG) { 1827e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 1828c29c1d7eSAurelien Jarno } 1829e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 1830e8996ee0Sbellard ots->val = ts->val; 1831e8996ee0Sbellard } else { 1832c29c1d7eSAurelien Jarno /* The code in the first if block should have moved the 1833c29c1d7eSAurelien Jarno temp to a register. */ 1834c29c1d7eSAurelien Jarno assert(ts->val_type == TEMP_VAL_REG); 1835c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(1) && !ts->fixed_reg && !ots->fixed_reg) { 1836c29c1d7eSAurelien Jarno /* the mov can be suppressed */ 1837c29c1d7eSAurelien Jarno if (ots->val_type == TEMP_VAL_REG) { 1838c29c1d7eSAurelien Jarno s->reg_to_temp[ots->reg] = -1; 1839c896fe29Sbellard } 1840c29c1d7eSAurelien Jarno ots->reg = ts->reg; 1841c29c1d7eSAurelien Jarno temp_dead(s, args[1]); 1842c29c1d7eSAurelien Jarno } else { 1843c29c1d7eSAurelien Jarno if (ots->val_type != TEMP_VAL_REG) { 1844c29c1d7eSAurelien Jarno /* When allocating a new register, make sure to not spill the 1845c29c1d7eSAurelien Jarno input one. */ 1846c29c1d7eSAurelien Jarno tcg_regset_set_reg(allocated_regs, ts->reg); 1847c29c1d7eSAurelien Jarno ots->reg = tcg_reg_alloc(s, oarg_ct->u.regs, allocated_regs); 1848c29c1d7eSAurelien Jarno } 1849c29c1d7eSAurelien Jarno tcg_out_mov(s, ots->type, ots->reg, ts->reg); 1850c29c1d7eSAurelien Jarno } 1851c896fe29Sbellard ots->val_type = TEMP_VAL_REG; 1852c896fe29Sbellard ots->mem_coherent = 0; 1853c29c1d7eSAurelien Jarno s->reg_to_temp[ots->reg] = args[0]; 1854ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(0)) { 1855c29c1d7eSAurelien Jarno tcg_reg_sync(s, ots->reg); 1856c29c1d7eSAurelien Jarno } 1857ec7a869dSAurelien Jarno } 1858c896fe29Sbellard } 1859c896fe29Sbellard 1860c896fe29Sbellard static void tcg_reg_alloc_op(TCGContext *s, 1861a9751609SRichard Henderson const TCGOpDef *def, TCGOpcode opc, 1862ec7a869dSAurelien Jarno const TCGArg *args, uint16_t dead_args, 1863ec7a869dSAurelien Jarno uint8_t sync_args) 1864c896fe29Sbellard { 1865c896fe29Sbellard TCGRegSet allocated_regs; 1866c896fe29Sbellard int i, k, nb_iargs, nb_oargs, reg; 1867c896fe29Sbellard TCGArg arg; 1868c896fe29Sbellard const TCGArgConstraint *arg_ct; 1869c896fe29Sbellard TCGTemp *ts; 1870c896fe29Sbellard TCGArg new_args[TCG_MAX_OP_ARGS]; 1871c896fe29Sbellard int const_args[TCG_MAX_OP_ARGS]; 1872c896fe29Sbellard 1873c896fe29Sbellard nb_oargs = def->nb_oargs; 1874c896fe29Sbellard nb_iargs = def->nb_iargs; 1875c896fe29Sbellard 1876c896fe29Sbellard /* copy constants */ 1877c896fe29Sbellard memcpy(new_args + nb_oargs + nb_iargs, 1878c896fe29Sbellard args + nb_oargs + nb_iargs, 1879c896fe29Sbellard sizeof(TCGArg) * def->nb_cargs); 1880c896fe29Sbellard 1881c896fe29Sbellard /* satisfy input constraints */ 1882c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 1883c896fe29Sbellard for(k = 0; k < nb_iargs; k++) { 1884c896fe29Sbellard i = def->sorted_args[nb_oargs + k]; 1885c896fe29Sbellard arg = args[i]; 1886c896fe29Sbellard arg_ct = &def->args_ct[i]; 1887c896fe29Sbellard ts = &s->temps[arg]; 1888c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 1889c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1890e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1891c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 1892c896fe29Sbellard ts->reg = reg; 1893c896fe29Sbellard ts->mem_coherent = 1; 1894c896fe29Sbellard s->reg_to_temp[reg] = arg; 1895c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1896c896fe29Sbellard if (tcg_target_const_match(ts->val, arg_ct)) { 1897c896fe29Sbellard /* constant is OK for instruction */ 1898c896fe29Sbellard const_args[i] = 1; 1899c896fe29Sbellard new_args[i] = ts->val; 1900c896fe29Sbellard goto iarg_end; 1901c896fe29Sbellard } else { 1902c896fe29Sbellard /* need to move to a register */ 1903c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1904c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1905e8996ee0Sbellard ts->val_type = TEMP_VAL_REG; 1906e8996ee0Sbellard ts->reg = reg; 1907e8996ee0Sbellard ts->mem_coherent = 0; 1908e8996ee0Sbellard s->reg_to_temp[reg] = arg; 1909c896fe29Sbellard } 1910c896fe29Sbellard } 1911c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 19125ff9d6a4Sbellard if (arg_ct->ct & TCG_CT_IALIAS) { 19135ff9d6a4Sbellard if (ts->fixed_reg) { 19145ff9d6a4Sbellard /* if fixed register, we must allocate a new register 19155ff9d6a4Sbellard if the alias is not the same register */ 19165ff9d6a4Sbellard if (arg != args[arg_ct->alias_index]) 19175ff9d6a4Sbellard goto allocate_in_reg; 19185ff9d6a4Sbellard } else { 1919c896fe29Sbellard /* if the input is aliased to an output and if it is 1920c896fe29Sbellard not dead after the instruction, we must allocate 1921c896fe29Sbellard a new register and move it */ 1922866cb6cbSAurelien Jarno if (!IS_DEAD_ARG(i)) { 1923c896fe29Sbellard goto allocate_in_reg; 1924c896fe29Sbellard } 19255ff9d6a4Sbellard } 1926866cb6cbSAurelien Jarno } 1927c896fe29Sbellard reg = ts->reg; 1928c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1929c896fe29Sbellard /* nothing to do : the constraint is satisfied */ 1930c896fe29Sbellard } else { 1931c896fe29Sbellard allocate_in_reg: 1932c896fe29Sbellard /* allocate a new register matching the constraint 1933c896fe29Sbellard and move the temporary register into it */ 1934c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 19353b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 1936c896fe29Sbellard } 1937c896fe29Sbellard new_args[i] = reg; 1938c896fe29Sbellard const_args[i] = 0; 1939c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 1940c896fe29Sbellard iarg_end: ; 1941c896fe29Sbellard } 1942c896fe29Sbellard 1943c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 1944866cb6cbSAurelien Jarno for (i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 1945866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 1946639368ddSAurelien Jarno temp_dead(s, args[i]); 1947c896fe29Sbellard } 1948c896fe29Sbellard } 1949c896fe29Sbellard 1950a52ad07eSAurelien Jarno if (def->flags & TCG_OPF_BB_END) { 1951a52ad07eSAurelien Jarno tcg_reg_alloc_bb_end(s, allocated_regs); 1952a52ad07eSAurelien Jarno } else { 1953c896fe29Sbellard if (def->flags & TCG_OPF_CALL_CLOBBER) { 1954b03cce8eSbellard /* XXX: permit generic clobber register list ? */ 1955c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1956c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 1957c896fe29Sbellard tcg_reg_free(s, reg); 1958c896fe29Sbellard } 1959c896fe29Sbellard } 19603d5c5f87SAurelien Jarno } 19613d5c5f87SAurelien Jarno if (def->flags & TCG_OPF_SIDE_EFFECTS) { 19623d5c5f87SAurelien Jarno /* sync globals if the op has side effects and might trigger 19633d5c5f87SAurelien Jarno an exception. */ 19643d5c5f87SAurelien Jarno sync_globals(s, allocated_regs); 1965c896fe29Sbellard } 1966c896fe29Sbellard 1967c896fe29Sbellard /* satisfy the output constraints */ 1968c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 1969c896fe29Sbellard for(k = 0; k < nb_oargs; k++) { 1970c896fe29Sbellard i = def->sorted_args[k]; 1971c896fe29Sbellard arg = args[i]; 1972c896fe29Sbellard arg_ct = &def->args_ct[i]; 1973c896fe29Sbellard ts = &s->temps[arg]; 1974c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 19755ff9d6a4Sbellard reg = new_args[arg_ct->alias_index]; 1976c896fe29Sbellard } else { 1977c896fe29Sbellard /* if fixed register, we try to use it */ 1978c896fe29Sbellard reg = ts->reg; 1979c896fe29Sbellard if (ts->fixed_reg && 1980c896fe29Sbellard tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1981c896fe29Sbellard goto oarg_end; 1982c896fe29Sbellard } 1983c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1984c896fe29Sbellard } 1985c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 1986c896fe29Sbellard /* if a fixed register is used, then a move will be done afterwards */ 1987c896fe29Sbellard if (!ts->fixed_reg) { 1988639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 1989639368ddSAurelien Jarno s->reg_to_temp[ts->reg] = -1; 1990639368ddSAurelien Jarno } 1991c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 1992c896fe29Sbellard ts->reg = reg; 1993c896fe29Sbellard /* temp value is modified, so the value kept in memory is 1994c896fe29Sbellard potentially not the same */ 1995c896fe29Sbellard ts->mem_coherent = 0; 1996c896fe29Sbellard s->reg_to_temp[reg] = arg; 1997c896fe29Sbellard } 1998c896fe29Sbellard oarg_end: 1999c896fe29Sbellard new_args[i] = reg; 2000c896fe29Sbellard } 2001e8996ee0Sbellard } 2002c896fe29Sbellard 2003c896fe29Sbellard /* emit instruction */ 2004c896fe29Sbellard tcg_out_op(s, opc, new_args, const_args); 2005c896fe29Sbellard 2006c896fe29Sbellard /* move the outputs in the correct register if needed */ 2007c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 2008c896fe29Sbellard ts = &s->temps[args[i]]; 2009c896fe29Sbellard reg = new_args[i]; 2010c896fe29Sbellard if (ts->fixed_reg && ts->reg != reg) { 20113b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 2012c896fe29Sbellard } 2013ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(i)) { 2014ec7a869dSAurelien Jarno tcg_reg_sync(s, reg); 2015ec7a869dSAurelien Jarno } 2016ec7a869dSAurelien Jarno if (IS_DEAD_ARG(i)) { 2017ec7a869dSAurelien Jarno temp_dead(s, args[i]); 2018ec7a869dSAurelien Jarno } 2019c896fe29Sbellard } 2020c896fe29Sbellard } 2021c896fe29Sbellard 2022b03cce8eSbellard #ifdef TCG_TARGET_STACK_GROWSUP 2023b03cce8eSbellard #define STACK_DIR(x) (-(x)) 2024b03cce8eSbellard #else 2025b03cce8eSbellard #define STACK_DIR(x) (x) 2026b03cce8eSbellard #endif 2027b03cce8eSbellard 2028c896fe29Sbellard static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def, 2029a9751609SRichard Henderson TCGOpcode opc, const TCGArg *args, 2030ec7a869dSAurelien Jarno uint16_t dead_args, uint8_t sync_args) 2031c896fe29Sbellard { 2032c896fe29Sbellard int nb_iargs, nb_oargs, flags, nb_regs, i, reg, nb_params; 2033c896fe29Sbellard TCGArg arg, func_arg; 2034c896fe29Sbellard TCGTemp *ts; 2035d3452f1fSRichard Henderson intptr_t stack_offset; 2036d3452f1fSRichard Henderson size_t call_stack_size; 2037d3452f1fSRichard Henderson uintptr_t func_addr; 2038b03cce8eSbellard int const_func_arg, allocate_args; 2039c896fe29Sbellard TCGRegSet allocated_regs; 2040c896fe29Sbellard const TCGArgConstraint *arg_ct; 2041c896fe29Sbellard 2042c896fe29Sbellard arg = *args++; 2043c896fe29Sbellard 2044c896fe29Sbellard nb_oargs = arg >> 16; 2045c896fe29Sbellard nb_iargs = arg & 0xffff; 2046c896fe29Sbellard nb_params = nb_iargs - 1; 2047c896fe29Sbellard 2048c896fe29Sbellard flags = args[nb_oargs + nb_iargs]; 2049c896fe29Sbellard 20506e17d0c5SStefan Weil nb_regs = ARRAY_SIZE(tcg_target_call_iarg_regs); 2051c896fe29Sbellard if (nb_regs > nb_params) 2052c896fe29Sbellard nb_regs = nb_params; 2053c896fe29Sbellard 2054c896fe29Sbellard /* assign stack slots first */ 2055c896fe29Sbellard call_stack_size = (nb_params - nb_regs) * sizeof(tcg_target_long); 2056c896fe29Sbellard call_stack_size = (call_stack_size + TCG_TARGET_STACK_ALIGN - 1) & 2057c896fe29Sbellard ~(TCG_TARGET_STACK_ALIGN - 1); 2058b03cce8eSbellard allocate_args = (call_stack_size > TCG_STATIC_CALL_ARGS_SIZE); 2059b03cce8eSbellard if (allocate_args) { 2060345649c0SBlue Swirl /* XXX: if more than TCG_STATIC_CALL_ARGS_SIZE is needed, 2061345649c0SBlue Swirl preallocate call stack */ 2062345649c0SBlue Swirl tcg_abort(); 2063b03cce8eSbellard } 206439cf05d3Sbellard 206539cf05d3Sbellard stack_offset = TCG_TARGET_CALL_STACK_OFFSET; 2066c896fe29Sbellard for(i = nb_regs; i < nb_params; i++) { 2067c896fe29Sbellard arg = args[nb_oargs + i]; 206839cf05d3Sbellard #ifdef TCG_TARGET_STACK_GROWSUP 206939cf05d3Sbellard stack_offset -= sizeof(tcg_target_long); 207039cf05d3Sbellard #endif 207139cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 2072c896fe29Sbellard ts = &s->temps[arg]; 2073c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 2074e4d5434cSblueswir1 tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset); 2075c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 2076c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 2077c896fe29Sbellard s->reserved_regs); 2078c896fe29Sbellard /* XXX: not correct if reading values from the stack */ 2079e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2080e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 2081c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2082c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 2083c896fe29Sbellard s->reserved_regs); 2084c896fe29Sbellard /* XXX: sign extend may be needed on some targets */ 2085c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 2086e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 2087c896fe29Sbellard } else { 2088c896fe29Sbellard tcg_abort(); 2089c896fe29Sbellard } 209039cf05d3Sbellard } 209139cf05d3Sbellard #ifndef TCG_TARGET_STACK_GROWSUP 209239cf05d3Sbellard stack_offset += sizeof(tcg_target_long); 209339cf05d3Sbellard #endif 2094c896fe29Sbellard } 2095c896fe29Sbellard 2096c896fe29Sbellard /* assign input registers */ 2097c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 2098c896fe29Sbellard for(i = 0; i < nb_regs; i++) { 2099c896fe29Sbellard arg = args[nb_oargs + i]; 210039cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 2101c896fe29Sbellard ts = &s->temps[arg]; 2102c896fe29Sbellard reg = tcg_target_call_iarg_regs[i]; 2103c896fe29Sbellard tcg_reg_free(s, reg); 2104c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 2105c896fe29Sbellard if (ts->reg != reg) { 21063b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 2107c896fe29Sbellard } 2108c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 2109e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2110c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2111c896fe29Sbellard /* XXX: sign extend ? */ 2112c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 2113c896fe29Sbellard } else { 2114c896fe29Sbellard tcg_abort(); 2115c896fe29Sbellard } 2116c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 2117c896fe29Sbellard } 211839cf05d3Sbellard } 2119c896fe29Sbellard 2120c896fe29Sbellard /* assign function address */ 2121c896fe29Sbellard func_arg = args[nb_oargs + nb_iargs - 1]; 2122c896fe29Sbellard arg_ct = &def->args_ct[0]; 2123c896fe29Sbellard ts = &s->temps[func_arg]; 2124f54b3f92Saurel32 func_addr = ts->val; 2125c896fe29Sbellard const_func_arg = 0; 2126c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 2127c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2128e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2129c896fe29Sbellard func_arg = reg; 2130e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 2131c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_REG) { 2132c896fe29Sbellard reg = ts->reg; 2133c896fe29Sbellard if (!tcg_regset_test_reg(arg_ct->u.regs, reg)) { 2134c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 21353b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 2136c896fe29Sbellard } 2137c896fe29Sbellard func_arg = reg; 2138e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 2139c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2140f54b3f92Saurel32 if (tcg_target_const_match(func_addr, arg_ct)) { 2141c896fe29Sbellard const_func_arg = 1; 2142f54b3f92Saurel32 func_arg = func_addr; 2143c896fe29Sbellard } else { 2144c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2145f54b3f92Saurel32 tcg_out_movi(s, ts->type, reg, func_addr); 2146c896fe29Sbellard func_arg = reg; 2147e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 2148c896fe29Sbellard } 2149c896fe29Sbellard } else { 2150c896fe29Sbellard tcg_abort(); 2151c896fe29Sbellard } 2152c896fe29Sbellard 2153e8996ee0Sbellard 2154c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 2155866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 2156866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 2157639368ddSAurelien Jarno temp_dead(s, args[i]); 2158c896fe29Sbellard } 2159c896fe29Sbellard } 2160c896fe29Sbellard 2161c896fe29Sbellard /* clobber call registers */ 2162c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 2163c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 2164c896fe29Sbellard tcg_reg_free(s, reg); 2165c896fe29Sbellard } 2166c896fe29Sbellard } 2167c896fe29Sbellard 216878505279SAurelien Jarno /* Save globals if they might be written by the helper, sync them if 216978505279SAurelien Jarno they might be read. */ 217078505279SAurelien Jarno if (flags & TCG_CALL_NO_READ_GLOBALS) { 217178505279SAurelien Jarno /* Nothing to do */ 217278505279SAurelien Jarno } else if (flags & TCG_CALL_NO_WRITE_GLOBALS) { 217378505279SAurelien Jarno sync_globals(s, allocated_regs); 217478505279SAurelien Jarno } else { 2175e8996ee0Sbellard save_globals(s, allocated_regs); 2176b9c18f56Saurel32 } 2177c896fe29Sbellard 2178c896fe29Sbellard tcg_out_op(s, opc, &func_arg, &const_func_arg); 2179c896fe29Sbellard 2180c896fe29Sbellard /* assign output registers and emit moves if needed */ 2181c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 2182c896fe29Sbellard arg = args[i]; 2183c896fe29Sbellard ts = &s->temps[arg]; 2184c896fe29Sbellard reg = tcg_target_call_oarg_regs[i]; 2185e8996ee0Sbellard assert(s->reg_to_temp[reg] == -1); 2186c896fe29Sbellard if (ts->fixed_reg) { 2187c896fe29Sbellard if (ts->reg != reg) { 21883b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 2189c896fe29Sbellard } 2190c896fe29Sbellard } else { 2191639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 2192639368ddSAurelien Jarno s->reg_to_temp[ts->reg] = -1; 2193639368ddSAurelien Jarno } 2194c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 2195c896fe29Sbellard ts->reg = reg; 2196c896fe29Sbellard ts->mem_coherent = 0; 2197c896fe29Sbellard s->reg_to_temp[reg] = arg; 2198ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(i)) { 2199ec7a869dSAurelien Jarno tcg_reg_sync(s, reg); 2200ec7a869dSAurelien Jarno } 2201ec7a869dSAurelien Jarno if (IS_DEAD_ARG(i)) { 2202ec7a869dSAurelien Jarno temp_dead(s, args[i]); 2203c896fe29Sbellard } 2204c896fe29Sbellard } 22058c11ad25SAurelien Jarno } 2206c896fe29Sbellard 2207c896fe29Sbellard return nb_iargs + nb_oargs + def->nb_cargs + 1; 2208c896fe29Sbellard } 2209c896fe29Sbellard 2210c896fe29Sbellard #ifdef CONFIG_PROFILER 2211c896fe29Sbellard 221254604f74Saurel32 static int64_t tcg_table_op_count[NB_OPS]; 2213c896fe29Sbellard 2214871e6c35SBlue Swirl static void dump_op_count(void) 2215c896fe29Sbellard { 2216c896fe29Sbellard int i; 2217c896fe29Sbellard FILE *f; 221854604f74Saurel32 f = fopen("/tmp/op.log", "w"); 2219c896fe29Sbellard for(i = INDEX_op_end; i < NB_OPS; i++) { 222054604f74Saurel32 fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, tcg_table_op_count[i]); 2221c896fe29Sbellard } 2222c896fe29Sbellard fclose(f); 2223c896fe29Sbellard } 2224c896fe29Sbellard #endif 2225c896fe29Sbellard 2226c896fe29Sbellard 2227c896fe29Sbellard static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf, 22282ba1eeb6Spbrook long search_pc) 2229c896fe29Sbellard { 2230a9751609SRichard Henderson TCGOpcode opc; 2231a9751609SRichard Henderson int op_index; 2232c896fe29Sbellard const TCGOpDef *def; 2233c896fe29Sbellard const TCGArg *args; 2234c896fe29Sbellard 2235c896fe29Sbellard #ifdef DEBUG_DISAS 22368fec2b8cSaliguori if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) { 223793fcfe39Saliguori qemu_log("OP:\n"); 2238eeacee4dSBlue Swirl tcg_dump_ops(s); 223993fcfe39Saliguori qemu_log("\n"); 2240c896fe29Sbellard } 2241c896fe29Sbellard #endif 2242c896fe29Sbellard 2243c5cc28ffSAurelien Jarno #ifdef CONFIG_PROFILER 2244c5cc28ffSAurelien Jarno s->opt_time -= profile_getclock(); 2245c5cc28ffSAurelien Jarno #endif 2246c5cc28ffSAurelien Jarno 22478f2e8c07SKirill Batuzov #ifdef USE_TCG_OPTIMIZATIONS 2248c4afe5c4SEvgeny Voevodin s->gen_opparam_ptr = 22491ff0a2c5SEvgeny Voevodin tcg_optimize(s, s->gen_opc_ptr, s->gen_opparam_buf, tcg_op_defs); 22508f2e8c07SKirill Batuzov #endif 22518f2e8c07SKirill Batuzov 2252a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2253c5cc28ffSAurelien Jarno s->opt_time += profile_getclock(); 2254a23a9ec6Sbellard s->la_time -= profile_getclock(); 2255a23a9ec6Sbellard #endif 2256c5cc28ffSAurelien Jarno 2257c896fe29Sbellard tcg_liveness_analysis(s); 2258c5cc28ffSAurelien Jarno 2259a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2260a23a9ec6Sbellard s->la_time += profile_getclock(); 2261a23a9ec6Sbellard #endif 2262c896fe29Sbellard 2263c896fe29Sbellard #ifdef DEBUG_DISAS 22648fec2b8cSaliguori if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT))) { 2265c5cc28ffSAurelien Jarno qemu_log("OP after optimization and liveness analysis:\n"); 2266eeacee4dSBlue Swirl tcg_dump_ops(s); 226793fcfe39Saliguori qemu_log("\n"); 2268c896fe29Sbellard } 2269c896fe29Sbellard #endif 2270c896fe29Sbellard 2271c896fe29Sbellard tcg_reg_alloc_start(s); 2272c896fe29Sbellard 2273c896fe29Sbellard s->code_buf = gen_code_buf; 2274c896fe29Sbellard s->code_ptr = gen_code_buf; 2275c896fe29Sbellard 22761ff0a2c5SEvgeny Voevodin args = s->gen_opparam_buf; 2277c896fe29Sbellard op_index = 0; 2278b3db8758Sblueswir1 2279c896fe29Sbellard for(;;) { 228092414b31SEvgeny Voevodin opc = s->gen_opc_buf[op_index]; 2281c896fe29Sbellard #ifdef CONFIG_PROFILER 228254604f74Saurel32 tcg_table_op_count[opc]++; 2283c896fe29Sbellard #endif 2284c896fe29Sbellard def = &tcg_op_defs[opc]; 2285c896fe29Sbellard #if 0 2286c896fe29Sbellard printf("%s: %d %d %d\n", def->name, 2287c896fe29Sbellard def->nb_oargs, def->nb_iargs, def->nb_cargs); 2288c896fe29Sbellard // dump_regs(s); 2289c896fe29Sbellard #endif 2290c896fe29Sbellard switch(opc) { 2291c896fe29Sbellard case INDEX_op_mov_i32: 2292c896fe29Sbellard case INDEX_op_mov_i64: 2293ec7a869dSAurelien Jarno tcg_reg_alloc_mov(s, def, args, s->op_dead_args[op_index], 2294ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2295c896fe29Sbellard break; 2296e8996ee0Sbellard case INDEX_op_movi_i32: 2297e8996ee0Sbellard case INDEX_op_movi_i64: 2298ec7a869dSAurelien Jarno tcg_reg_alloc_movi(s, args, s->op_dead_args[op_index], 2299ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2300e8996ee0Sbellard break; 23017e4597d7Sbellard case INDEX_op_debug_insn_start: 23027e4597d7Sbellard /* debug instruction */ 23037e4597d7Sbellard break; 2304c896fe29Sbellard case INDEX_op_nop: 2305c896fe29Sbellard case INDEX_op_nop1: 2306c896fe29Sbellard case INDEX_op_nop2: 2307c896fe29Sbellard case INDEX_op_nop3: 2308c896fe29Sbellard break; 2309c896fe29Sbellard case INDEX_op_nopn: 2310c896fe29Sbellard args += args[0]; 2311c896fe29Sbellard goto next; 23125ff9d6a4Sbellard case INDEX_op_discard: 2313639368ddSAurelien Jarno temp_dead(s, args[0]); 23145ff9d6a4Sbellard break; 2315c896fe29Sbellard case INDEX_op_set_label: 2316e8996ee0Sbellard tcg_reg_alloc_bb_end(s, s->reserved_regs); 23179d6fca70SStefan Weil tcg_out_label(s, args[0], s->code_ptr); 2318c896fe29Sbellard break; 2319c896fe29Sbellard case INDEX_op_call: 2320ec7a869dSAurelien Jarno args += tcg_reg_alloc_call(s, def, opc, args, 2321ec7a869dSAurelien Jarno s->op_dead_args[op_index], 2322ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2323c896fe29Sbellard goto next; 2324c896fe29Sbellard case INDEX_op_end: 2325c896fe29Sbellard goto the_end; 2326c896fe29Sbellard default: 232725c4d9ccSRichard Henderson /* Sanity check that we've not introduced any unhandled opcodes. */ 232825c4d9ccSRichard Henderson if (def->flags & TCG_OPF_NOT_PRESENT) { 232925c4d9ccSRichard Henderson tcg_abort(); 233025c4d9ccSRichard Henderson } 2331c896fe29Sbellard /* Note: in order to speed up the code, it would be much 2332c896fe29Sbellard faster to have specialized register allocator functions for 2333c896fe29Sbellard some common argument patterns */ 2334ec7a869dSAurelien Jarno tcg_reg_alloc_op(s, def, opc, args, s->op_dead_args[op_index], 2335ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2336c896fe29Sbellard break; 2337c896fe29Sbellard } 2338c896fe29Sbellard args += def->nb_args; 23398df1ca4bSths next: 23402ba1eeb6Spbrook if (search_pc >= 0 && search_pc < s->code_ptr - gen_code_buf) { 2341c896fe29Sbellard return op_index; 2342c896fe29Sbellard } 2343c896fe29Sbellard op_index++; 2344c896fe29Sbellard #ifndef NDEBUG 2345c896fe29Sbellard check_regs(s); 2346c896fe29Sbellard #endif 2347c896fe29Sbellard } 2348c896fe29Sbellard the_end: 2349b76f0d8cSYeongkyoon Lee #if defined(CONFIG_QEMU_LDST_OPTIMIZATION) && defined(CONFIG_SOFTMMU) 2350b76f0d8cSYeongkyoon Lee /* Generate TB finalization at the end of block */ 2351b76f0d8cSYeongkyoon Lee tcg_out_tb_finalize(s); 2352b76f0d8cSYeongkyoon Lee #endif 2353c896fe29Sbellard return -1; 2354c896fe29Sbellard } 2355c896fe29Sbellard 235654604f74Saurel32 int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf) 2357c896fe29Sbellard { 2358c896fe29Sbellard #ifdef CONFIG_PROFILER 2359c896fe29Sbellard { 2360c896fe29Sbellard int n; 236192414b31SEvgeny Voevodin n = (s->gen_opc_ptr - s->gen_opc_buf); 2362a23a9ec6Sbellard s->op_count += n; 2363a23a9ec6Sbellard if (n > s->op_count_max) 2364a23a9ec6Sbellard s->op_count_max = n; 2365a23a9ec6Sbellard 2366a23a9ec6Sbellard s->temp_count += s->nb_temps; 2367a23a9ec6Sbellard if (s->nb_temps > s->temp_count_max) 2368a23a9ec6Sbellard s->temp_count_max = s->nb_temps; 2369c896fe29Sbellard } 2370c896fe29Sbellard #endif 2371c896fe29Sbellard 23722ba1eeb6Spbrook tcg_gen_code_common(s, gen_code_buf, -1); 2373c896fe29Sbellard 2374c896fe29Sbellard /* flush instruction cache */ 2375b93949efSRichard Henderson flush_icache_range((uintptr_t)gen_code_buf, (uintptr_t)s->code_ptr); 23762aeabc08SStefan Weil 2377c896fe29Sbellard return s->code_ptr - gen_code_buf; 2378c896fe29Sbellard } 2379c896fe29Sbellard 23802ba1eeb6Spbrook /* Return the index of the micro operation such as the pc after is < 2381623e265cSpbrook offset bytes from the start of the TB. The contents of gen_code_buf must 2382623e265cSpbrook not be changed, though writing the same values is ok. 2383623e265cSpbrook Return -1 if not found. */ 238454604f74Saurel32 int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset) 2385c896fe29Sbellard { 2386623e265cSpbrook return tcg_gen_code_common(s, gen_code_buf, offset); 2387c896fe29Sbellard } 2388a23a9ec6Sbellard 2389a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2390405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2391a23a9ec6Sbellard { 2392a23a9ec6Sbellard TCGContext *s = &tcg_ctx; 2393a23a9ec6Sbellard int64_t tot; 2394a23a9ec6Sbellard 2395a23a9ec6Sbellard tot = s->interm_time + s->code_time; 2396a23a9ec6Sbellard cpu_fprintf(f, "JIT cycles %" PRId64 " (%0.3f s at 2.4 GHz)\n", 2397a23a9ec6Sbellard tot, tot / 2.4e9); 2398a23a9ec6Sbellard cpu_fprintf(f, "translated TBs %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n", 2399a23a9ec6Sbellard s->tb_count, 2400a23a9ec6Sbellard s->tb_count1 - s->tb_count, 2401a23a9ec6Sbellard s->tb_count1 ? (double)(s->tb_count1 - s->tb_count) / s->tb_count1 * 100.0 : 0); 2402a23a9ec6Sbellard cpu_fprintf(f, "avg ops/TB %0.1f max=%d\n", 2403a23a9ec6Sbellard s->tb_count ? (double)s->op_count / s->tb_count : 0, s->op_count_max); 2404a23a9ec6Sbellard cpu_fprintf(f, "deleted ops/TB %0.2f\n", 2405a23a9ec6Sbellard s->tb_count ? 2406a23a9ec6Sbellard (double)s->del_op_count / s->tb_count : 0); 2407a23a9ec6Sbellard cpu_fprintf(f, "avg temps/TB %0.2f max=%d\n", 2408a23a9ec6Sbellard s->tb_count ? 2409a23a9ec6Sbellard (double)s->temp_count / s->tb_count : 0, 2410a23a9ec6Sbellard s->temp_count_max); 2411a23a9ec6Sbellard 2412a23a9ec6Sbellard cpu_fprintf(f, "cycles/op %0.1f\n", 2413a23a9ec6Sbellard s->op_count ? (double)tot / s->op_count : 0); 2414a23a9ec6Sbellard cpu_fprintf(f, "cycles/in byte %0.1f\n", 2415a23a9ec6Sbellard s->code_in_len ? (double)tot / s->code_in_len : 0); 2416a23a9ec6Sbellard cpu_fprintf(f, "cycles/out byte %0.1f\n", 2417a23a9ec6Sbellard s->code_out_len ? (double)tot / s->code_out_len : 0); 2418a23a9ec6Sbellard if (tot == 0) 2419a23a9ec6Sbellard tot = 1; 2420a23a9ec6Sbellard cpu_fprintf(f, " gen_interm time %0.1f%%\n", 2421a23a9ec6Sbellard (double)s->interm_time / tot * 100.0); 2422a23a9ec6Sbellard cpu_fprintf(f, " gen_code time %0.1f%%\n", 2423a23a9ec6Sbellard (double)s->code_time / tot * 100.0); 2424c5cc28ffSAurelien Jarno cpu_fprintf(f, "optim./code time %0.1f%%\n", 2425c5cc28ffSAurelien Jarno (double)s->opt_time / (s->code_time ? s->code_time : 1) 2426c5cc28ffSAurelien Jarno * 100.0); 2427a23a9ec6Sbellard cpu_fprintf(f, "liveness/code time %0.1f%%\n", 2428a23a9ec6Sbellard (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0); 2429a23a9ec6Sbellard cpu_fprintf(f, "cpu_restore count %" PRId64 "\n", 2430a23a9ec6Sbellard s->restore_count); 2431a23a9ec6Sbellard cpu_fprintf(f, " avg cycles %0.1f\n", 2432a23a9ec6Sbellard s->restore_count ? (double)s->restore_time / s->restore_count : 0); 2433871e6c35SBlue Swirl 2434a23a9ec6Sbellard dump_op_count(); 2435a23a9ec6Sbellard } 2436a23a9ec6Sbellard #else 2437405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2438a23a9ec6Sbellard { 243924bf7b3aSbellard cpu_fprintf(f, "[TCG profiler not compiled]\n"); 2440a23a9ec6Sbellard } 2441a23a9ec6Sbellard #endif 2442813da627SRichard Henderson 2443813da627SRichard Henderson #ifdef ELF_HOST_MACHINE 24445872bbf2SRichard Henderson /* In order to use this feature, the backend needs to do three things: 24455872bbf2SRichard Henderson 24465872bbf2SRichard Henderson (1) Define ELF_HOST_MACHINE to indicate both what value to 24475872bbf2SRichard Henderson put into the ELF image and to indicate support for the feature. 24485872bbf2SRichard Henderson 24495872bbf2SRichard Henderson (2) Define tcg_register_jit. This should create a buffer containing 24505872bbf2SRichard Henderson the contents of a .debug_frame section that describes the post- 24515872bbf2SRichard Henderson prologue unwind info for the tcg machine. 24525872bbf2SRichard Henderson 24535872bbf2SRichard Henderson (3) Call tcg_register_jit_int, with the constructed .debug_frame. 24545872bbf2SRichard Henderson */ 2455813da627SRichard Henderson 2456813da627SRichard Henderson /* Begin GDB interface. THE FOLLOWING MUST MATCH GDB DOCS. */ 2457813da627SRichard Henderson typedef enum { 2458813da627SRichard Henderson JIT_NOACTION = 0, 2459813da627SRichard Henderson JIT_REGISTER_FN, 2460813da627SRichard Henderson JIT_UNREGISTER_FN 2461813da627SRichard Henderson } jit_actions_t; 2462813da627SRichard Henderson 2463813da627SRichard Henderson struct jit_code_entry { 2464813da627SRichard Henderson struct jit_code_entry *next_entry; 2465813da627SRichard Henderson struct jit_code_entry *prev_entry; 2466813da627SRichard Henderson const void *symfile_addr; 2467813da627SRichard Henderson uint64_t symfile_size; 2468813da627SRichard Henderson }; 2469813da627SRichard Henderson 2470813da627SRichard Henderson struct jit_descriptor { 2471813da627SRichard Henderson uint32_t version; 2472813da627SRichard Henderson uint32_t action_flag; 2473813da627SRichard Henderson struct jit_code_entry *relevant_entry; 2474813da627SRichard Henderson struct jit_code_entry *first_entry; 2475813da627SRichard Henderson }; 2476813da627SRichard Henderson 2477813da627SRichard Henderson void __jit_debug_register_code(void) __attribute__((noinline)); 2478813da627SRichard Henderson void __jit_debug_register_code(void) 2479813da627SRichard Henderson { 2480813da627SRichard Henderson asm(""); 2481813da627SRichard Henderson } 2482813da627SRichard Henderson 2483813da627SRichard Henderson /* Must statically initialize the version, because GDB may check 2484813da627SRichard Henderson the version before we can set it. */ 2485813da627SRichard Henderson struct jit_descriptor __jit_debug_descriptor = { 1, 0, 0, 0 }; 2486813da627SRichard Henderson 2487813da627SRichard Henderson /* End GDB interface. */ 2488813da627SRichard Henderson 2489813da627SRichard Henderson static int find_string(const char *strtab, const char *str) 2490813da627SRichard Henderson { 2491813da627SRichard Henderson const char *p = strtab + 1; 2492813da627SRichard Henderson 2493813da627SRichard Henderson while (1) { 2494813da627SRichard Henderson if (strcmp(p, str) == 0) { 2495813da627SRichard Henderson return p - strtab; 2496813da627SRichard Henderson } 2497813da627SRichard Henderson p += strlen(p) + 1; 2498813da627SRichard Henderson } 2499813da627SRichard Henderson } 2500813da627SRichard Henderson 25015872bbf2SRichard Henderson static void tcg_register_jit_int(void *buf_ptr, size_t buf_size, 2502813da627SRichard Henderson void *debug_frame, size_t debug_frame_size) 2503813da627SRichard Henderson { 25045872bbf2SRichard Henderson struct __attribute__((packed)) DebugInfo { 25055872bbf2SRichard Henderson uint32_t len; 25065872bbf2SRichard Henderson uint16_t version; 25075872bbf2SRichard Henderson uint32_t abbrev; 25085872bbf2SRichard Henderson uint8_t ptr_size; 25095872bbf2SRichard Henderson uint8_t cu_die; 25105872bbf2SRichard Henderson uint16_t cu_lang; 25115872bbf2SRichard Henderson uintptr_t cu_low_pc; 25125872bbf2SRichard Henderson uintptr_t cu_high_pc; 25135872bbf2SRichard Henderson uint8_t fn_die; 25145872bbf2SRichard Henderson char fn_name[16]; 25155872bbf2SRichard Henderson uintptr_t fn_low_pc; 25165872bbf2SRichard Henderson uintptr_t fn_high_pc; 25175872bbf2SRichard Henderson uint8_t cu_eoc; 25185872bbf2SRichard Henderson }; 2519813da627SRichard Henderson 2520813da627SRichard Henderson struct ElfImage { 2521813da627SRichard Henderson ElfW(Ehdr) ehdr; 2522813da627SRichard Henderson ElfW(Phdr) phdr; 25235872bbf2SRichard Henderson ElfW(Shdr) shdr[7]; 25245872bbf2SRichard Henderson ElfW(Sym) sym[2]; 25255872bbf2SRichard Henderson struct DebugInfo di; 25265872bbf2SRichard Henderson uint8_t da[24]; 25275872bbf2SRichard Henderson char str[80]; 25285872bbf2SRichard Henderson }; 25295872bbf2SRichard Henderson 25305872bbf2SRichard Henderson struct ElfImage *img; 25315872bbf2SRichard Henderson 25325872bbf2SRichard Henderson static const struct ElfImage img_template = { 25335872bbf2SRichard Henderson .ehdr = { 25345872bbf2SRichard Henderson .e_ident[EI_MAG0] = ELFMAG0, 25355872bbf2SRichard Henderson .e_ident[EI_MAG1] = ELFMAG1, 25365872bbf2SRichard Henderson .e_ident[EI_MAG2] = ELFMAG2, 25375872bbf2SRichard Henderson .e_ident[EI_MAG3] = ELFMAG3, 25385872bbf2SRichard Henderson .e_ident[EI_CLASS] = ELF_CLASS, 25395872bbf2SRichard Henderson .e_ident[EI_DATA] = ELF_DATA, 25405872bbf2SRichard Henderson .e_ident[EI_VERSION] = EV_CURRENT, 25415872bbf2SRichard Henderson .e_type = ET_EXEC, 25425872bbf2SRichard Henderson .e_machine = ELF_HOST_MACHINE, 25435872bbf2SRichard Henderson .e_version = EV_CURRENT, 25445872bbf2SRichard Henderson .e_phoff = offsetof(struct ElfImage, phdr), 25455872bbf2SRichard Henderson .e_shoff = offsetof(struct ElfImage, shdr), 25465872bbf2SRichard Henderson .e_ehsize = sizeof(ElfW(Shdr)), 25475872bbf2SRichard Henderson .e_phentsize = sizeof(ElfW(Phdr)), 25485872bbf2SRichard Henderson .e_phnum = 1, 25495872bbf2SRichard Henderson .e_shentsize = sizeof(ElfW(Shdr)), 25505872bbf2SRichard Henderson .e_shnum = ARRAY_SIZE(img->shdr), 25515872bbf2SRichard Henderson .e_shstrndx = ARRAY_SIZE(img->shdr) - 1, 2552abbb3eaeSRichard Henderson #ifdef ELF_HOST_FLAGS 2553abbb3eaeSRichard Henderson .e_flags = ELF_HOST_FLAGS, 2554abbb3eaeSRichard Henderson #endif 2555abbb3eaeSRichard Henderson #ifdef ELF_OSABI 2556abbb3eaeSRichard Henderson .e_ident[EI_OSABI] = ELF_OSABI, 2557abbb3eaeSRichard Henderson #endif 25585872bbf2SRichard Henderson }, 25595872bbf2SRichard Henderson .phdr = { 25605872bbf2SRichard Henderson .p_type = PT_LOAD, 25615872bbf2SRichard Henderson .p_flags = PF_X, 25625872bbf2SRichard Henderson }, 25635872bbf2SRichard Henderson .shdr = { 25645872bbf2SRichard Henderson [0] = { .sh_type = SHT_NULL }, 25655872bbf2SRichard Henderson /* Trick: The contents of code_gen_buffer are not present in 25665872bbf2SRichard Henderson this fake ELF file; that got allocated elsewhere. Therefore 25675872bbf2SRichard Henderson we mark .text as SHT_NOBITS (similar to .bss) so that readers 25685872bbf2SRichard Henderson will not look for contents. We can record any address. */ 25695872bbf2SRichard Henderson [1] = { /* .text */ 25705872bbf2SRichard Henderson .sh_type = SHT_NOBITS, 25715872bbf2SRichard Henderson .sh_flags = SHF_EXECINSTR | SHF_ALLOC, 25725872bbf2SRichard Henderson }, 25735872bbf2SRichard Henderson [2] = { /* .debug_info */ 25745872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 25755872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, di), 25765872bbf2SRichard Henderson .sh_size = sizeof(struct DebugInfo), 25775872bbf2SRichard Henderson }, 25785872bbf2SRichard Henderson [3] = { /* .debug_abbrev */ 25795872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 25805872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, da), 25815872bbf2SRichard Henderson .sh_size = sizeof(img->da), 25825872bbf2SRichard Henderson }, 25835872bbf2SRichard Henderson [4] = { /* .debug_frame */ 25845872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 25855872bbf2SRichard Henderson .sh_offset = sizeof(struct ElfImage), 25865872bbf2SRichard Henderson }, 25875872bbf2SRichard Henderson [5] = { /* .symtab */ 25885872bbf2SRichard Henderson .sh_type = SHT_SYMTAB, 25895872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, sym), 25905872bbf2SRichard Henderson .sh_size = sizeof(img->sym), 25915872bbf2SRichard Henderson .sh_info = 1, 25925872bbf2SRichard Henderson .sh_link = ARRAY_SIZE(img->shdr) - 1, 25935872bbf2SRichard Henderson .sh_entsize = sizeof(ElfW(Sym)), 25945872bbf2SRichard Henderson }, 25955872bbf2SRichard Henderson [6] = { /* .strtab */ 25965872bbf2SRichard Henderson .sh_type = SHT_STRTAB, 25975872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, str), 25985872bbf2SRichard Henderson .sh_size = sizeof(img->str), 25995872bbf2SRichard Henderson } 26005872bbf2SRichard Henderson }, 26015872bbf2SRichard Henderson .sym = { 26025872bbf2SRichard Henderson [1] = { /* code_gen_buffer */ 26035872bbf2SRichard Henderson .st_info = ELF_ST_INFO(STB_GLOBAL, STT_FUNC), 26045872bbf2SRichard Henderson .st_shndx = 1, 26055872bbf2SRichard Henderson } 26065872bbf2SRichard Henderson }, 26075872bbf2SRichard Henderson .di = { 26085872bbf2SRichard Henderson .len = sizeof(struct DebugInfo) - 4, 26095872bbf2SRichard Henderson .version = 2, 26105872bbf2SRichard Henderson .ptr_size = sizeof(void *), 26115872bbf2SRichard Henderson .cu_die = 1, 26125872bbf2SRichard Henderson .cu_lang = 0x8001, /* DW_LANG_Mips_Assembler */ 26135872bbf2SRichard Henderson .fn_die = 2, 26145872bbf2SRichard Henderson .fn_name = "code_gen_buffer" 26155872bbf2SRichard Henderson }, 26165872bbf2SRichard Henderson .da = { 26175872bbf2SRichard Henderson 1, /* abbrev number (the cu) */ 26185872bbf2SRichard Henderson 0x11, 1, /* DW_TAG_compile_unit, has children */ 26195872bbf2SRichard Henderson 0x13, 0x5, /* DW_AT_language, DW_FORM_data2 */ 26205872bbf2SRichard Henderson 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */ 26215872bbf2SRichard Henderson 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */ 26225872bbf2SRichard Henderson 0, 0, /* end of abbrev */ 26235872bbf2SRichard Henderson 2, /* abbrev number (the fn) */ 26245872bbf2SRichard Henderson 0x2e, 0, /* DW_TAG_subprogram, no children */ 26255872bbf2SRichard Henderson 0x3, 0x8, /* DW_AT_name, DW_FORM_string */ 26265872bbf2SRichard Henderson 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */ 26275872bbf2SRichard Henderson 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */ 26285872bbf2SRichard Henderson 0, 0, /* end of abbrev */ 26295872bbf2SRichard Henderson 0 /* no more abbrev */ 26305872bbf2SRichard Henderson }, 26315872bbf2SRichard Henderson .str = "\0" ".text\0" ".debug_info\0" ".debug_abbrev\0" 26325872bbf2SRichard Henderson ".debug_frame\0" ".symtab\0" ".strtab\0" "code_gen_buffer", 2633813da627SRichard Henderson }; 2634813da627SRichard Henderson 2635813da627SRichard Henderson /* We only need a single jit entry; statically allocate it. */ 2636813da627SRichard Henderson static struct jit_code_entry one_entry; 2637813da627SRichard Henderson 26385872bbf2SRichard Henderson uintptr_t buf = (uintptr_t)buf_ptr; 2639813da627SRichard Henderson size_t img_size = sizeof(struct ElfImage) + debug_frame_size; 2640813da627SRichard Henderson 26415872bbf2SRichard Henderson img = g_malloc(img_size); 26425872bbf2SRichard Henderson *img = img_template; 2643813da627SRichard Henderson memcpy(img + 1, debug_frame, debug_frame_size); 2644813da627SRichard Henderson 26455872bbf2SRichard Henderson img->phdr.p_vaddr = buf; 26465872bbf2SRichard Henderson img->phdr.p_paddr = buf; 26475872bbf2SRichard Henderson img->phdr.p_memsz = buf_size; 2648813da627SRichard Henderson 26495872bbf2SRichard Henderson img->shdr[1].sh_name = find_string(img->str, ".text"); 26505872bbf2SRichard Henderson img->shdr[1].sh_addr = buf; 26515872bbf2SRichard Henderson img->shdr[1].sh_size = buf_size; 2652813da627SRichard Henderson 26535872bbf2SRichard Henderson img->shdr[2].sh_name = find_string(img->str, ".debug_info"); 26545872bbf2SRichard Henderson img->shdr[3].sh_name = find_string(img->str, ".debug_abbrev"); 26555872bbf2SRichard Henderson 26565872bbf2SRichard Henderson img->shdr[4].sh_name = find_string(img->str, ".debug_frame"); 26575872bbf2SRichard Henderson img->shdr[4].sh_size = debug_frame_size; 26585872bbf2SRichard Henderson 26595872bbf2SRichard Henderson img->shdr[5].sh_name = find_string(img->str, ".symtab"); 26605872bbf2SRichard Henderson img->shdr[6].sh_name = find_string(img->str, ".strtab"); 26615872bbf2SRichard Henderson 26625872bbf2SRichard Henderson img->sym[1].st_name = find_string(img->str, "code_gen_buffer"); 26635872bbf2SRichard Henderson img->sym[1].st_value = buf; 26645872bbf2SRichard Henderson img->sym[1].st_size = buf_size; 26655872bbf2SRichard Henderson 26665872bbf2SRichard Henderson img->di.cu_low_pc = buf; 266745aba097SRichard Henderson img->di.cu_high_pc = buf + buf_size; 26685872bbf2SRichard Henderson img->di.fn_low_pc = buf; 266945aba097SRichard Henderson img->di.fn_high_pc = buf + buf_size; 2670813da627SRichard Henderson 2671813da627SRichard Henderson #ifdef DEBUG_JIT 2672813da627SRichard Henderson /* Enable this block to be able to debug the ELF image file creation. 2673813da627SRichard Henderson One can use readelf, objdump, or other inspection utilities. */ 2674813da627SRichard Henderson { 2675813da627SRichard Henderson FILE *f = fopen("/tmp/qemu.jit", "w+b"); 2676813da627SRichard Henderson if (f) { 26775872bbf2SRichard Henderson if (fwrite(img, img_size, 1, f) != img_size) { 2678813da627SRichard Henderson /* Avoid stupid unused return value warning for fwrite. */ 2679813da627SRichard Henderson } 2680813da627SRichard Henderson fclose(f); 2681813da627SRichard Henderson } 2682813da627SRichard Henderson } 2683813da627SRichard Henderson #endif 2684813da627SRichard Henderson 2685813da627SRichard Henderson one_entry.symfile_addr = img; 2686813da627SRichard Henderson one_entry.symfile_size = img_size; 2687813da627SRichard Henderson 2688813da627SRichard Henderson __jit_debug_descriptor.action_flag = JIT_REGISTER_FN; 2689813da627SRichard Henderson __jit_debug_descriptor.relevant_entry = &one_entry; 2690813da627SRichard Henderson __jit_debug_descriptor.first_entry = &one_entry; 2691813da627SRichard Henderson __jit_debug_register_code(); 2692813da627SRichard Henderson } 2693813da627SRichard Henderson #else 26945872bbf2SRichard Henderson /* No support for the feature. Provide the entry point expected by exec.c, 26955872bbf2SRichard Henderson and implement the internal function we declared earlier. */ 2696813da627SRichard Henderson 2697813da627SRichard Henderson static void tcg_register_jit_int(void *buf, size_t size, 2698813da627SRichard Henderson void *debug_frame, size_t debug_frame_size) 2699813da627SRichard Henderson { 2700813da627SRichard Henderson } 2701813da627SRichard Henderson 2702813da627SRichard Henderson void tcg_register_jit(void *buf, size_t buf_size) 2703813da627SRichard Henderson { 2704813da627SRichard Henderson } 2705813da627SRichard Henderson #endif /* ELF_HOST_MACHINE */ 2706