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 52813da627SRichard Henderson #if TCG_TARGET_REG_BITS == 64 53813da627SRichard Henderson # define ELF_CLASS ELFCLASS64 54813da627SRichard Henderson #else 55813da627SRichard Henderson # define ELF_CLASS ELFCLASS32 56813da627SRichard Henderson #endif 57813da627SRichard Henderson #ifdef HOST_WORDS_BIGENDIAN 58813da627SRichard Henderson # define ELF_DATA ELFDATA2MSB 59813da627SRichard Henderson #else 60813da627SRichard Henderson # define ELF_DATA ELFDATA2LSB 61813da627SRichard Henderson #endif 62813da627SRichard Henderson 63c896fe29Sbellard #include "elf.h" 64c896fe29Sbellard 65c0ad3001SStefan Weil /* Forward declarations for functions declared in tcg-target.c and used here. */ 66e4d58b41SRichard Henderson static void tcg_target_init(TCGContext *s); 67e4d58b41SRichard Henderson static void tcg_target_qemu_prologue(TCGContext *s); 68c896fe29Sbellard static void patch_reloc(uint8_t *code_ptr, int type, 69f54b3f92Saurel32 tcg_target_long value, tcg_target_long addend); 70c896fe29Sbellard 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; 85497a22ebSRichard Henderson tcg_target_long func_start; 86497a22ebSRichard Henderson tcg_target_long 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, 96c0ad3001SStefan Weil tcg_target_long 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, 103c0ad3001SStefan Weil tcg_target_long 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, 146c896fe29Sbellard int label_index, long 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; 1729d6fca70SStefan Weil tcg_target_long value = (tcg_target_long)ptr; 173c896fe29Sbellard 174c896fe29Sbellard l = &s->labels[label_index]; 175c896fe29Sbellard if (l->has_value) 176c896fe29Sbellard tcg_abort(); 177c896fe29Sbellard r = l->u.first_reloc; 178c896fe29Sbellard while (r != NULL) { 179f54b3f92Saurel32 patch_reloc(r->ptr, r->type, value, r->addend); 180c896fe29Sbellard r = r->next; 181c896fe29Sbellard } 182c896fe29Sbellard l->has_value = 1; 183c896fe29Sbellard l->u.value = value; 184c896fe29Sbellard } 185c896fe29Sbellard 186c896fe29Sbellard int gen_new_label(void) 187c896fe29Sbellard { 188c896fe29Sbellard TCGContext *s = &tcg_ctx; 189c896fe29Sbellard int idx; 190c896fe29Sbellard TCGLabel *l; 191c896fe29Sbellard 192c896fe29Sbellard if (s->nb_labels >= TCG_MAX_LABELS) 193c896fe29Sbellard tcg_abort(); 194c896fe29Sbellard idx = s->nb_labels++; 195c896fe29Sbellard l = &s->labels[idx]; 196c896fe29Sbellard l->has_value = 0; 197c896fe29Sbellard l->u.first_reloc = NULL; 198c896fe29Sbellard return idx; 199c896fe29Sbellard } 200c896fe29Sbellard 201c896fe29Sbellard #include "tcg-target.c" 202c896fe29Sbellard 203c896fe29Sbellard /* pool based memory allocation */ 204c896fe29Sbellard void *tcg_malloc_internal(TCGContext *s, int size) 205c896fe29Sbellard { 206c896fe29Sbellard TCGPool *p; 207c896fe29Sbellard int pool_size; 208c896fe29Sbellard 209c896fe29Sbellard if (size > TCG_POOL_CHUNK_SIZE) { 210c896fe29Sbellard /* big malloc: insert a new pool (XXX: could optimize) */ 2117267c094SAnthony Liguori p = g_malloc(sizeof(TCGPool) + size); 212c896fe29Sbellard p->size = size; 2134055299eSKirill Batuzov p->next = s->pool_first_large; 2144055299eSKirill Batuzov s->pool_first_large = p; 2154055299eSKirill Batuzov return p->data; 216c896fe29Sbellard } else { 217c896fe29Sbellard p = s->pool_current; 218c896fe29Sbellard if (!p) { 219c896fe29Sbellard p = s->pool_first; 220c896fe29Sbellard if (!p) 221c896fe29Sbellard goto new_pool; 222c896fe29Sbellard } else { 223c896fe29Sbellard if (!p->next) { 224c896fe29Sbellard new_pool: 225c896fe29Sbellard pool_size = TCG_POOL_CHUNK_SIZE; 2267267c094SAnthony Liguori p = g_malloc(sizeof(TCGPool) + pool_size); 227c896fe29Sbellard p->size = pool_size; 228c896fe29Sbellard p->next = NULL; 229c896fe29Sbellard if (s->pool_current) 230c896fe29Sbellard s->pool_current->next = p; 231c896fe29Sbellard else 232c896fe29Sbellard s->pool_first = p; 233c896fe29Sbellard } else { 234c896fe29Sbellard p = p->next; 235c896fe29Sbellard } 236c896fe29Sbellard } 237c896fe29Sbellard } 238c896fe29Sbellard s->pool_current = p; 239c896fe29Sbellard s->pool_cur = p->data + size; 240c896fe29Sbellard s->pool_end = p->data + p->size; 241c896fe29Sbellard return p->data; 242c896fe29Sbellard } 243c896fe29Sbellard 244c896fe29Sbellard void tcg_pool_reset(TCGContext *s) 245c896fe29Sbellard { 2464055299eSKirill Batuzov TCGPool *p, *t; 2474055299eSKirill Batuzov for (p = s->pool_first_large; p; p = t) { 2484055299eSKirill Batuzov t = p->next; 2494055299eSKirill Batuzov g_free(p); 2504055299eSKirill Batuzov } 2514055299eSKirill Batuzov s->pool_first_large = NULL; 252c896fe29Sbellard s->pool_cur = s->pool_end = NULL; 253c896fe29Sbellard s->pool_current = NULL; 254c896fe29Sbellard } 255c896fe29Sbellard 256c896fe29Sbellard void tcg_context_init(TCGContext *s) 257c896fe29Sbellard { 258c896fe29Sbellard int op, total_args, n; 259c896fe29Sbellard TCGOpDef *def; 260c896fe29Sbellard TCGArgConstraint *args_ct; 261c896fe29Sbellard int *sorted_args; 262c896fe29Sbellard 263c896fe29Sbellard memset(s, 0, sizeof(*s)); 264c896fe29Sbellard s->nb_globals = 0; 265c896fe29Sbellard 266c896fe29Sbellard /* Count total number of arguments and allocate the corresponding 267c896fe29Sbellard space */ 268c896fe29Sbellard total_args = 0; 269c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 270c896fe29Sbellard def = &tcg_op_defs[op]; 271c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 272c896fe29Sbellard total_args += n; 273c896fe29Sbellard } 274c896fe29Sbellard 2757267c094SAnthony Liguori args_ct = g_malloc(sizeof(TCGArgConstraint) * total_args); 2767267c094SAnthony Liguori sorted_args = g_malloc(sizeof(int) * total_args); 277c896fe29Sbellard 278c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 279c896fe29Sbellard def = &tcg_op_defs[op]; 280c896fe29Sbellard def->args_ct = args_ct; 281c896fe29Sbellard def->sorted_args = sorted_args; 282c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 283c896fe29Sbellard sorted_args += n; 284c896fe29Sbellard args_ct += n; 285c896fe29Sbellard } 286c896fe29Sbellard 287c896fe29Sbellard tcg_target_init(s); 2889002ec79SRichard Henderson } 289b03cce8eSbellard 2909002ec79SRichard Henderson void tcg_prologue_init(TCGContext *s) 2919002ec79SRichard Henderson { 292b03cce8eSbellard /* init global prologue and epilogue */ 2930b0d3320SEvgeny Voevodin s->code_buf = s->code_gen_prologue; 294b03cce8eSbellard s->code_ptr = s->code_buf; 295b03cce8eSbellard tcg_target_qemu_prologue(s); 296b93949efSRichard Henderson flush_icache_range((uintptr_t)s->code_buf, (uintptr_t)s->code_ptr); 297d6b64b2bSRichard Henderson 298d6b64b2bSRichard Henderson #ifdef DEBUG_DISAS 299d6b64b2bSRichard Henderson if (qemu_loglevel_mask(CPU_LOG_TB_OUT_ASM)) { 300d6b64b2bSRichard Henderson size_t size = s->code_ptr - s->code_buf; 301d6b64b2bSRichard Henderson qemu_log("PROLOGUE: [size=%zu]\n", size); 302d6b64b2bSRichard Henderson log_disas(s->code_buf, size); 303d6b64b2bSRichard Henderson qemu_log("\n"); 304d6b64b2bSRichard Henderson qemu_log_flush(); 305d6b64b2bSRichard Henderson } 306d6b64b2bSRichard Henderson #endif 307c896fe29Sbellard } 308c896fe29Sbellard 309e2c6d1b4SRichard Henderson void tcg_set_frame(TCGContext *s, int reg, intptr_t start, intptr_t size) 310c896fe29Sbellard { 311c896fe29Sbellard s->frame_start = start; 312c896fe29Sbellard s->frame_end = start + size; 313c896fe29Sbellard s->frame_reg = reg; 314c896fe29Sbellard } 315c896fe29Sbellard 316c896fe29Sbellard void tcg_func_start(TCGContext *s) 317c896fe29Sbellard { 318e8996ee0Sbellard int i; 319c896fe29Sbellard tcg_pool_reset(s); 320c896fe29Sbellard s->nb_temps = s->nb_globals; 321641d5fbeSbellard for(i = 0; i < (TCG_TYPE_COUNT * 2); i++) 322e8996ee0Sbellard s->first_free_temp[i] = -1; 323c896fe29Sbellard s->labels = tcg_malloc(sizeof(TCGLabel) * TCG_MAX_LABELS); 324c896fe29Sbellard s->nb_labels = 0; 325c896fe29Sbellard s->current_frame_offset = s->frame_start; 326c896fe29Sbellard 3270a209d4bSRichard Henderson #ifdef CONFIG_DEBUG_TCG 3280a209d4bSRichard Henderson s->goto_tb_issue_mask = 0; 3290a209d4bSRichard Henderson #endif 3300a209d4bSRichard Henderson 33192414b31SEvgeny Voevodin s->gen_opc_ptr = s->gen_opc_buf; 3321ff0a2c5SEvgeny Voevodin s->gen_opparam_ptr = s->gen_opparam_buf; 333b76f0d8cSYeongkyoon Lee 334b76f0d8cSYeongkyoon Lee #if defined(CONFIG_QEMU_LDST_OPTIMIZATION) && defined(CONFIG_SOFTMMU) 335b76f0d8cSYeongkyoon Lee /* Initialize qemu_ld/st labels to assist code generation at the end of TB 336b76f0d8cSYeongkyoon Lee for TLB miss cases at the end of TB */ 337b76f0d8cSYeongkyoon Lee s->qemu_ldst_labels = tcg_malloc(sizeof(TCGLabelQemuLdst) * 338b76f0d8cSYeongkyoon Lee TCG_MAX_QEMU_LDST); 339b76f0d8cSYeongkyoon Lee s->nb_qemu_ldst_labels = 0; 340b76f0d8cSYeongkyoon Lee #endif 341c896fe29Sbellard } 342c896fe29Sbellard 343c896fe29Sbellard static inline void tcg_temp_alloc(TCGContext *s, int n) 344c896fe29Sbellard { 345c896fe29Sbellard if (n > TCG_MAX_TEMPS) 346c896fe29Sbellard tcg_abort(); 347c896fe29Sbellard } 348c896fe29Sbellard 349a7812ae4Spbrook static inline int tcg_global_reg_new_internal(TCGType type, int reg, 350a7812ae4Spbrook const char *name) 351c896fe29Sbellard { 352c896fe29Sbellard TCGContext *s = &tcg_ctx; 353c896fe29Sbellard TCGTemp *ts; 354c896fe29Sbellard int idx; 355c896fe29Sbellard 356c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 357c896fe29Sbellard if (type != TCG_TYPE_I32) 358c896fe29Sbellard tcg_abort(); 359c896fe29Sbellard #endif 360c896fe29Sbellard if (tcg_regset_test_reg(s->reserved_regs, reg)) 361c896fe29Sbellard tcg_abort(); 362c896fe29Sbellard idx = s->nb_globals; 363c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 364c896fe29Sbellard ts = &s->temps[s->nb_globals]; 365c896fe29Sbellard ts->base_type = type; 366c896fe29Sbellard ts->type = type; 367c896fe29Sbellard ts->fixed_reg = 1; 368c896fe29Sbellard ts->reg = reg; 369c896fe29Sbellard ts->name = name; 370c896fe29Sbellard s->nb_globals++; 371c896fe29Sbellard tcg_regset_set_reg(s->reserved_regs, reg); 372a7812ae4Spbrook return idx; 373a7812ae4Spbrook } 374a7812ae4Spbrook 375a7812ae4Spbrook TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name) 376a7812ae4Spbrook { 377a7812ae4Spbrook int idx; 378a7812ae4Spbrook 379a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name); 380a7812ae4Spbrook return MAKE_TCGV_I32(idx); 381a7812ae4Spbrook } 382a7812ae4Spbrook 383a7812ae4Spbrook TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name) 384a7812ae4Spbrook { 385a7812ae4Spbrook int idx; 386a7812ae4Spbrook 387a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I64, reg, name); 388a7812ae4Spbrook return MAKE_TCGV_I64(idx); 389c896fe29Sbellard } 390c896fe29Sbellard 391a7812ae4Spbrook static inline int tcg_global_mem_new_internal(TCGType type, int reg, 392*2f2f244dSRichard Henderson intptr_t offset, 393c896fe29Sbellard const char *name) 394c896fe29Sbellard { 395c896fe29Sbellard TCGContext *s = &tcg_ctx; 396c896fe29Sbellard TCGTemp *ts; 397c896fe29Sbellard int idx; 398c896fe29Sbellard 399c896fe29Sbellard idx = s->nb_globals; 400c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 401c896fe29Sbellard if (type == TCG_TYPE_I64) { 402c896fe29Sbellard char buf[64]; 403c588979bSths tcg_temp_alloc(s, s->nb_globals + 2); 404c896fe29Sbellard ts = &s->temps[s->nb_globals]; 405c896fe29Sbellard ts->base_type = type; 406c896fe29Sbellard ts->type = TCG_TYPE_I32; 407c896fe29Sbellard ts->fixed_reg = 0; 408c896fe29Sbellard ts->mem_allocated = 1; 409c896fe29Sbellard ts->mem_reg = reg; 410c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 411c896fe29Sbellard ts->mem_offset = offset + 4; 412c896fe29Sbellard #else 413c896fe29Sbellard ts->mem_offset = offset; 414c896fe29Sbellard #endif 415c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 416c896fe29Sbellard pstrcat(buf, sizeof(buf), "_0"); 417c896fe29Sbellard ts->name = strdup(buf); 418c896fe29Sbellard ts++; 419c896fe29Sbellard 420c896fe29Sbellard ts->base_type = type; 421c896fe29Sbellard ts->type = TCG_TYPE_I32; 422c896fe29Sbellard ts->fixed_reg = 0; 423c896fe29Sbellard ts->mem_allocated = 1; 424c896fe29Sbellard ts->mem_reg = reg; 425c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 426c896fe29Sbellard ts->mem_offset = offset; 427c896fe29Sbellard #else 428c896fe29Sbellard ts->mem_offset = offset + 4; 429c896fe29Sbellard #endif 430c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 431c896fe29Sbellard pstrcat(buf, sizeof(buf), "_1"); 432c896fe29Sbellard ts->name = strdup(buf); 433c896fe29Sbellard 434c896fe29Sbellard s->nb_globals += 2; 435c896fe29Sbellard } else 436c896fe29Sbellard #endif 437c896fe29Sbellard { 438c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 439c896fe29Sbellard ts = &s->temps[s->nb_globals]; 440c896fe29Sbellard ts->base_type = type; 441c896fe29Sbellard ts->type = type; 442c896fe29Sbellard ts->fixed_reg = 0; 443c896fe29Sbellard ts->mem_allocated = 1; 444c896fe29Sbellard ts->mem_reg = reg; 445c896fe29Sbellard ts->mem_offset = offset; 446c896fe29Sbellard ts->name = name; 447c896fe29Sbellard s->nb_globals++; 448c896fe29Sbellard } 449a7812ae4Spbrook return idx; 450c896fe29Sbellard } 451c896fe29Sbellard 452*2f2f244dSRichard Henderson TCGv_i32 tcg_global_mem_new_i32(int reg, intptr_t offset, const char *name) 453a7812ae4Spbrook { 454*2f2f244dSRichard Henderson int idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name); 455a7812ae4Spbrook return MAKE_TCGV_I32(idx); 456a7812ae4Spbrook } 457a7812ae4Spbrook 458*2f2f244dSRichard Henderson TCGv_i64 tcg_global_mem_new_i64(int reg, intptr_t offset, const char *name) 459a7812ae4Spbrook { 460*2f2f244dSRichard Henderson int idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name); 461a7812ae4Spbrook return MAKE_TCGV_I64(idx); 462a7812ae4Spbrook } 463a7812ae4Spbrook 464a7812ae4Spbrook static inline int tcg_temp_new_internal(TCGType type, int temp_local) 465c896fe29Sbellard { 466c896fe29Sbellard TCGContext *s = &tcg_ctx; 467c896fe29Sbellard TCGTemp *ts; 468641d5fbeSbellard int idx, k; 469c896fe29Sbellard 470641d5fbeSbellard k = type; 471641d5fbeSbellard if (temp_local) 472641d5fbeSbellard k += TCG_TYPE_COUNT; 473641d5fbeSbellard idx = s->first_free_temp[k]; 474e8996ee0Sbellard if (idx != -1) { 475e8996ee0Sbellard /* There is already an available temp with the 476e8996ee0Sbellard right type */ 477e8996ee0Sbellard ts = &s->temps[idx]; 478641d5fbeSbellard s->first_free_temp[k] = ts->next_free_temp; 479e8996ee0Sbellard ts->temp_allocated = 1; 480641d5fbeSbellard assert(ts->temp_local == temp_local); 481e8996ee0Sbellard } else { 482c896fe29Sbellard idx = s->nb_temps; 483c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 484c896fe29Sbellard if (type == TCG_TYPE_I64) { 4858df1ca4bSths tcg_temp_alloc(s, s->nb_temps + 2); 486c896fe29Sbellard ts = &s->temps[s->nb_temps]; 487c896fe29Sbellard ts->base_type = type; 488c896fe29Sbellard ts->type = TCG_TYPE_I32; 489e8996ee0Sbellard ts->temp_allocated = 1; 490641d5fbeSbellard ts->temp_local = temp_local; 491c896fe29Sbellard ts->name = NULL; 492c896fe29Sbellard ts++; 493c896fe29Sbellard ts->base_type = TCG_TYPE_I32; 494c896fe29Sbellard ts->type = TCG_TYPE_I32; 495e8996ee0Sbellard ts->temp_allocated = 1; 496641d5fbeSbellard ts->temp_local = temp_local; 497c896fe29Sbellard ts->name = NULL; 498c896fe29Sbellard s->nb_temps += 2; 499c896fe29Sbellard } else 500c896fe29Sbellard #endif 501c896fe29Sbellard { 502c896fe29Sbellard tcg_temp_alloc(s, s->nb_temps + 1); 503c896fe29Sbellard ts = &s->temps[s->nb_temps]; 504c896fe29Sbellard ts->base_type = type; 505c896fe29Sbellard ts->type = type; 506e8996ee0Sbellard ts->temp_allocated = 1; 507641d5fbeSbellard ts->temp_local = temp_local; 508c896fe29Sbellard ts->name = NULL; 509c896fe29Sbellard s->nb_temps++; 510c896fe29Sbellard } 511e8996ee0Sbellard } 51227bfd83cSPeter Maydell 51327bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 51427bfd83cSPeter Maydell s->temps_in_use++; 51527bfd83cSPeter Maydell #endif 516a7812ae4Spbrook return idx; 517c896fe29Sbellard } 518c896fe29Sbellard 519a7812ae4Spbrook TCGv_i32 tcg_temp_new_internal_i32(int temp_local) 520a7812ae4Spbrook { 521a7812ae4Spbrook int idx; 522a7812ae4Spbrook 523a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I32, temp_local); 524a7812ae4Spbrook return MAKE_TCGV_I32(idx); 525a7812ae4Spbrook } 526a7812ae4Spbrook 527a7812ae4Spbrook TCGv_i64 tcg_temp_new_internal_i64(int temp_local) 528a7812ae4Spbrook { 529a7812ae4Spbrook int idx; 530a7812ae4Spbrook 531a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I64, temp_local); 532a7812ae4Spbrook return MAKE_TCGV_I64(idx); 533a7812ae4Spbrook } 534a7812ae4Spbrook 535a7812ae4Spbrook static inline void tcg_temp_free_internal(int idx) 536c896fe29Sbellard { 537c896fe29Sbellard TCGContext *s = &tcg_ctx; 538c896fe29Sbellard TCGTemp *ts; 539641d5fbeSbellard int k; 540c896fe29Sbellard 54127bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 54227bfd83cSPeter Maydell s->temps_in_use--; 54327bfd83cSPeter Maydell if (s->temps_in_use < 0) { 54427bfd83cSPeter Maydell fprintf(stderr, "More temporaries freed than allocated!\n"); 54527bfd83cSPeter Maydell } 54627bfd83cSPeter Maydell #endif 54727bfd83cSPeter Maydell 548e8996ee0Sbellard assert(idx >= s->nb_globals && idx < s->nb_temps); 549c896fe29Sbellard ts = &s->temps[idx]; 550e8996ee0Sbellard assert(ts->temp_allocated != 0); 551e8996ee0Sbellard ts->temp_allocated = 0; 552641d5fbeSbellard k = ts->base_type; 553641d5fbeSbellard if (ts->temp_local) 554641d5fbeSbellard k += TCG_TYPE_COUNT; 555641d5fbeSbellard ts->next_free_temp = s->first_free_temp[k]; 556641d5fbeSbellard s->first_free_temp[k] = idx; 557e8996ee0Sbellard } 558e8996ee0Sbellard 559a7812ae4Spbrook void tcg_temp_free_i32(TCGv_i32 arg) 560e8996ee0Sbellard { 561a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I32(arg)); 562a7812ae4Spbrook } 563a7812ae4Spbrook 564a7812ae4Spbrook void tcg_temp_free_i64(TCGv_i64 arg) 565a7812ae4Spbrook { 566a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I64(arg)); 567a7812ae4Spbrook } 568a7812ae4Spbrook 569a7812ae4Spbrook TCGv_i32 tcg_const_i32(int32_t val) 570a7812ae4Spbrook { 571a7812ae4Spbrook TCGv_i32 t0; 572a7812ae4Spbrook t0 = tcg_temp_new_i32(); 573e8996ee0Sbellard tcg_gen_movi_i32(t0, val); 574e8996ee0Sbellard return t0; 575c896fe29Sbellard } 576c896fe29Sbellard 577a7812ae4Spbrook TCGv_i64 tcg_const_i64(int64_t val) 578c896fe29Sbellard { 579a7812ae4Spbrook TCGv_i64 t0; 580a7812ae4Spbrook t0 = tcg_temp_new_i64(); 581e8996ee0Sbellard tcg_gen_movi_i64(t0, val); 582e8996ee0Sbellard return t0; 583c896fe29Sbellard } 584c896fe29Sbellard 585a7812ae4Spbrook TCGv_i32 tcg_const_local_i32(int32_t val) 586bdffd4a9Saurel32 { 587a7812ae4Spbrook TCGv_i32 t0; 588a7812ae4Spbrook t0 = tcg_temp_local_new_i32(); 589bdffd4a9Saurel32 tcg_gen_movi_i32(t0, val); 590bdffd4a9Saurel32 return t0; 591bdffd4a9Saurel32 } 592bdffd4a9Saurel32 593a7812ae4Spbrook TCGv_i64 tcg_const_local_i64(int64_t val) 594bdffd4a9Saurel32 { 595a7812ae4Spbrook TCGv_i64 t0; 596a7812ae4Spbrook t0 = tcg_temp_local_new_i64(); 597bdffd4a9Saurel32 tcg_gen_movi_i64(t0, val); 598bdffd4a9Saurel32 return t0; 599bdffd4a9Saurel32 } 600bdffd4a9Saurel32 60127bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 60227bfd83cSPeter Maydell void tcg_clear_temp_count(void) 60327bfd83cSPeter Maydell { 60427bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 60527bfd83cSPeter Maydell s->temps_in_use = 0; 60627bfd83cSPeter Maydell } 60727bfd83cSPeter Maydell 60827bfd83cSPeter Maydell int tcg_check_temp_count(void) 60927bfd83cSPeter Maydell { 61027bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 61127bfd83cSPeter Maydell if (s->temps_in_use) { 61227bfd83cSPeter Maydell /* Clear the count so that we don't give another 61327bfd83cSPeter Maydell * warning immediately next time around. 61427bfd83cSPeter Maydell */ 61527bfd83cSPeter Maydell s->temps_in_use = 0; 61627bfd83cSPeter Maydell return 1; 61727bfd83cSPeter Maydell } 61827bfd83cSPeter Maydell return 0; 61927bfd83cSPeter Maydell } 62027bfd83cSPeter Maydell #endif 62127bfd83cSPeter Maydell 622c896fe29Sbellard void tcg_register_helper(void *func, const char *name) 623c896fe29Sbellard { 624c896fe29Sbellard TCGContext *s = &tcg_ctx; 625c896fe29Sbellard int n; 626c896fe29Sbellard if ((s->nb_helpers + 1) > s->allocated_helpers) { 627c896fe29Sbellard n = s->allocated_helpers; 628c896fe29Sbellard if (n == 0) { 629c896fe29Sbellard n = 4; 630c896fe29Sbellard } else { 631c896fe29Sbellard n *= 2; 632c896fe29Sbellard } 633c896fe29Sbellard s->helpers = realloc(s->helpers, n * sizeof(TCGHelperInfo)); 634c896fe29Sbellard s->allocated_helpers = n; 635c896fe29Sbellard } 6364dc81f28Sbellard s->helpers[s->nb_helpers].func = (tcg_target_ulong)func; 637c896fe29Sbellard s->helpers[s->nb_helpers].name = name; 638c896fe29Sbellard s->nb_helpers++; 639c896fe29Sbellard } 640c896fe29Sbellard 64139cf05d3Sbellard /* Note: we convert the 64 bit args to 32 bit and do some alignment 64239cf05d3Sbellard and endian swap. Maybe it would be better to do the alignment 64339cf05d3Sbellard and endian swap in tcg_reg_alloc_call(). */ 644a7812ae4Spbrook void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags, 645a7812ae4Spbrook int sizemask, TCGArg ret, int nargs, TCGArg *args) 646c896fe29Sbellard { 647a7812ae4Spbrook int i; 648a7812ae4Spbrook int real_args; 649a7812ae4Spbrook int nb_rets; 650a7812ae4Spbrook TCGArg *nparam; 6512bece2c8SRichard Henderson 6522bece2c8SRichard Henderson #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 6532bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 6542bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 6552bece2c8SRichard Henderson int is_signed = sizemask & (2 << (i+1)*2); 6562bece2c8SRichard Henderson if (!is_64bit) { 6572bece2c8SRichard Henderson TCGv_i64 temp = tcg_temp_new_i64(); 6582bece2c8SRichard Henderson TCGv_i64 orig = MAKE_TCGV_I64(args[i]); 6592bece2c8SRichard Henderson if (is_signed) { 6602bece2c8SRichard Henderson tcg_gen_ext32s_i64(temp, orig); 6612bece2c8SRichard Henderson } else { 6622bece2c8SRichard Henderson tcg_gen_ext32u_i64(temp, orig); 6632bece2c8SRichard Henderson } 6642bece2c8SRichard Henderson args[i] = GET_TCGV_I64(temp); 6652bece2c8SRichard Henderson } 6662bece2c8SRichard Henderson } 6672bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 6682bece2c8SRichard Henderson 669efd7f486SEvgeny Voevodin *s->gen_opc_ptr++ = INDEX_op_call; 670c4afe5c4SEvgeny Voevodin nparam = s->gen_opparam_ptr++; 671a7812ae4Spbrook if (ret != TCG_CALL_DUMMY_ARG) { 672a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 673a7812ae4Spbrook if (sizemask & 1) { 674a7812ae4Spbrook #ifdef TCG_TARGET_WORDS_BIGENDIAN 675c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret + 1; 676c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret; 677a7812ae4Spbrook #else 678c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret; 679c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret + 1; 680a7812ae4Spbrook #endif 681a7812ae4Spbrook nb_rets = 2; 682a7812ae4Spbrook } else 683a7812ae4Spbrook #endif 684a7812ae4Spbrook { 685c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = ret; 686a7812ae4Spbrook nb_rets = 1; 687a7812ae4Spbrook } 688a7812ae4Spbrook } else { 689a7812ae4Spbrook nb_rets = 0; 690a7812ae4Spbrook } 691a7812ae4Spbrook real_args = 0; 692a7812ae4Spbrook for (i = 0; i < nargs; i++) { 693a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 6942bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 6952bece2c8SRichard Henderson if (is_64bit) { 69639cf05d3Sbellard #ifdef TCG_TARGET_CALL_ALIGN_ARGS 69739cf05d3Sbellard /* some targets want aligned 64 bit args */ 698ebd486d5Smalc if (real_args & 1) { 699c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = TCG_CALL_DUMMY_ARG; 700ebd486d5Smalc real_args++; 70139cf05d3Sbellard } 70239cf05d3Sbellard #endif 7033f90f252SRichard Henderson /* If stack grows up, then we will be placing successive 7043f90f252SRichard Henderson arguments at lower addresses, which means we need to 7053f90f252SRichard Henderson reverse the order compared to how we would normally 7063f90f252SRichard Henderson treat either big or little-endian. For those arguments 7073f90f252SRichard Henderson that will wind up in registers, this still works for 7083f90f252SRichard Henderson HPPA (the only current STACK_GROWSUP target) since the 7093f90f252SRichard Henderson argument registers are *also* allocated in decreasing 7103f90f252SRichard Henderson order. If another such target is added, this logic may 7113f90f252SRichard Henderson have to get more complicated to differentiate between 7123f90f252SRichard Henderson stack arguments and register arguments. */ 7133f90f252SRichard Henderson #if defined(TCG_TARGET_WORDS_BIGENDIAN) != defined(TCG_TARGET_STACK_GROWSUP) 714c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i] + 1; 715c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i]; 716c896fe29Sbellard #else 717c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i]; 718c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i] + 1; 719c896fe29Sbellard #endif 720a7812ae4Spbrook real_args += 2; 7212bece2c8SRichard Henderson continue; 7222bece2c8SRichard Henderson } 7232bece2c8SRichard Henderson #endif /* TCG_TARGET_REG_BITS < 64 */ 7242bece2c8SRichard Henderson 725c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = args[i]; 726a7812ae4Spbrook real_args++; 727c896fe29Sbellard } 728c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = GET_TCGV_PTR(func); 729a7812ae4Spbrook 730c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = flags; 731a7812ae4Spbrook 732a7812ae4Spbrook *nparam = (nb_rets << 16) | (real_args + 1); 733a7812ae4Spbrook 734a7812ae4Spbrook /* total parameters, needed to go backward in the instruction stream */ 735c4afe5c4SEvgeny Voevodin *s->gen_opparam_ptr++ = 1 + nb_rets + real_args + 3; 7362bece2c8SRichard Henderson 7372bece2c8SRichard Henderson #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 7382bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 7392bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 7402bece2c8SRichard Henderson if (!is_64bit) { 7412bece2c8SRichard Henderson TCGv_i64 temp = MAKE_TCGV_I64(args[i]); 7422bece2c8SRichard Henderson tcg_temp_free_i64(temp); 7432bece2c8SRichard Henderson } 7442bece2c8SRichard Henderson } 7452bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 746a7812ae4Spbrook } 747c896fe29Sbellard 748ac56dd48Spbrook #if TCG_TARGET_REG_BITS == 32 749a7812ae4Spbrook void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, 750c896fe29Sbellard int c, int right, int arith) 751c896fe29Sbellard { 752cf60bce4Sbellard if (c == 0) { 753a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1)); 754cf60bce4Sbellard tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1)); 755cf60bce4Sbellard } else if (c >= 32) { 756c896fe29Sbellard c -= 32; 757c896fe29Sbellard if (right) { 758c896fe29Sbellard if (arith) { 759a7812ae4Spbrook tcg_gen_sari_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 760ac56dd48Spbrook tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 31); 761c896fe29Sbellard } else { 762a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 763ac56dd48Spbrook tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 764c896fe29Sbellard } 765c896fe29Sbellard } else { 766a7812ae4Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_LOW(arg1), c); 767a7812ae4Spbrook tcg_gen_movi_i32(TCGV_LOW(ret), 0); 768c896fe29Sbellard } 769c896fe29Sbellard } else { 770a7812ae4Spbrook TCGv_i32 t0, t1; 771c896fe29Sbellard 772a7812ae4Spbrook t0 = tcg_temp_new_i32(); 773a7812ae4Spbrook t1 = tcg_temp_new_i32(); 774c896fe29Sbellard if (right) { 775ac56dd48Spbrook tcg_gen_shli_i32(t0, TCGV_HIGH(arg1), 32 - c); 776c896fe29Sbellard if (arith) 777ac56dd48Spbrook tcg_gen_sari_i32(t1, TCGV_HIGH(arg1), c); 778c896fe29Sbellard else 779ac56dd48Spbrook tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c); 780a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_LOW(arg1), c); 781a7812ae4Spbrook tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t0); 782ac56dd48Spbrook tcg_gen_mov_i32(TCGV_HIGH(ret), t1); 783c896fe29Sbellard } else { 784a7812ae4Spbrook tcg_gen_shri_i32(t0, TCGV_LOW(arg1), 32 - c); 785c896fe29Sbellard /* Note: ret can be the same as arg1, so we use t1 */ 786a7812ae4Spbrook tcg_gen_shli_i32(t1, TCGV_LOW(arg1), c); 787ac56dd48Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c); 788ac56dd48Spbrook tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0); 789a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), t1); 790c896fe29Sbellard } 791a7812ae4Spbrook tcg_temp_free_i32(t0); 792a7812ae4Spbrook tcg_temp_free_i32(t1); 793c896fe29Sbellard } 794c896fe29Sbellard } 795ac56dd48Spbrook #endif 796c896fe29Sbellard 797be210acbSRichard Henderson 7988fcd3692Sblueswir1 static void tcg_reg_alloc_start(TCGContext *s) 799c896fe29Sbellard { 800c896fe29Sbellard int i; 801c896fe29Sbellard TCGTemp *ts; 802c896fe29Sbellard for(i = 0; i < s->nb_globals; i++) { 803c896fe29Sbellard ts = &s->temps[i]; 804c896fe29Sbellard if (ts->fixed_reg) { 805c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 806c896fe29Sbellard } else { 807c896fe29Sbellard ts->val_type = TEMP_VAL_MEM; 808c896fe29Sbellard } 809c896fe29Sbellard } 810e8996ee0Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 811e8996ee0Sbellard ts = &s->temps[i]; 8127dfd8c6aSAurelien Jarno if (ts->temp_local) { 8137dfd8c6aSAurelien Jarno ts->val_type = TEMP_VAL_MEM; 8147dfd8c6aSAurelien Jarno } else { 815e8996ee0Sbellard ts->val_type = TEMP_VAL_DEAD; 8167dfd8c6aSAurelien Jarno } 817e8996ee0Sbellard ts->mem_allocated = 0; 818e8996ee0Sbellard ts->fixed_reg = 0; 819e8996ee0Sbellard } 820c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 821c896fe29Sbellard s->reg_to_temp[i] = -1; 822c896fe29Sbellard } 823c896fe29Sbellard } 824c896fe29Sbellard 825ac56dd48Spbrook static char *tcg_get_arg_str_idx(TCGContext *s, char *buf, int buf_size, 826ac56dd48Spbrook int idx) 827c896fe29Sbellard { 828c896fe29Sbellard TCGTemp *ts; 829ac56dd48Spbrook 8307f6f0ae5SStefan Weil assert(idx >= 0 && idx < s->nb_temps); 831ac56dd48Spbrook ts = &s->temps[idx]; 832ac56dd48Spbrook if (idx < s->nb_globals) { 833ac56dd48Spbrook pstrcpy(buf, buf_size, ts->name); 834c896fe29Sbellard } else { 835641d5fbeSbellard if (ts->temp_local) 836641d5fbeSbellard snprintf(buf, buf_size, "loc%d", idx - s->nb_globals); 837641d5fbeSbellard else 838ac56dd48Spbrook snprintf(buf, buf_size, "tmp%d", idx - s->nb_globals); 839c896fe29Sbellard } 840c896fe29Sbellard return buf; 841c896fe29Sbellard } 842c896fe29Sbellard 843a7812ae4Spbrook char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg) 844ac56dd48Spbrook { 845a7812ae4Spbrook return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I32(arg)); 846a7812ae4Spbrook } 847a7812ae4Spbrook 848a7812ae4Spbrook char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg) 849a7812ae4Spbrook { 850a810a2deSblueswir1 return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I64(arg)); 851ac56dd48Spbrook } 852ac56dd48Spbrook 853e8996ee0Sbellard static int helper_cmp(const void *p1, const void *p2) 854e8996ee0Sbellard { 855e8996ee0Sbellard const TCGHelperInfo *th1 = p1; 856e8996ee0Sbellard const TCGHelperInfo *th2 = p2; 857e8996ee0Sbellard if (th1->func < th2->func) 858e8996ee0Sbellard return -1; 859e8996ee0Sbellard else if (th1->func == th2->func) 860e8996ee0Sbellard return 0; 861e8996ee0Sbellard else 862e8996ee0Sbellard return 1; 863e8996ee0Sbellard } 864e8996ee0Sbellard 865e8996ee0Sbellard /* find helper definition (Note: A hash table would be better) */ 8664dc81f28Sbellard static TCGHelperInfo *tcg_find_helper(TCGContext *s, tcg_target_ulong val) 8674dc81f28Sbellard { 868e8996ee0Sbellard int m, m_min, m_max; 869e8996ee0Sbellard TCGHelperInfo *th; 870e8996ee0Sbellard tcg_target_ulong v; 871e8996ee0Sbellard 872e8996ee0Sbellard if (unlikely(!s->helpers_sorted)) { 873e8996ee0Sbellard qsort(s->helpers, s->nb_helpers, sizeof(TCGHelperInfo), 874e8996ee0Sbellard helper_cmp); 875e8996ee0Sbellard s->helpers_sorted = 1; 876e8996ee0Sbellard } 877e8996ee0Sbellard 878e8996ee0Sbellard /* binary search */ 879e8996ee0Sbellard m_min = 0; 880e8996ee0Sbellard m_max = s->nb_helpers - 1; 881e8996ee0Sbellard while (m_min <= m_max) { 882e8996ee0Sbellard m = (m_min + m_max) >> 1; 883e8996ee0Sbellard th = &s->helpers[m]; 884e8996ee0Sbellard v = th->func; 885e8996ee0Sbellard if (v == val) 886e8996ee0Sbellard return th; 887e8996ee0Sbellard else if (val < v) { 888e8996ee0Sbellard m_max = m - 1; 889e8996ee0Sbellard } else { 890e8996ee0Sbellard m_min = m + 1; 891e8996ee0Sbellard } 8924dc81f28Sbellard } 8934dc81f28Sbellard return NULL; 8944dc81f28Sbellard } 8954dc81f28Sbellard 896f48f3edeSblueswir1 static const char * const cond_name[] = 897f48f3edeSblueswir1 { 8980aed257fSRichard Henderson [TCG_COND_NEVER] = "never", 8990aed257fSRichard Henderson [TCG_COND_ALWAYS] = "always", 900f48f3edeSblueswir1 [TCG_COND_EQ] = "eq", 901f48f3edeSblueswir1 [TCG_COND_NE] = "ne", 902f48f3edeSblueswir1 [TCG_COND_LT] = "lt", 903f48f3edeSblueswir1 [TCG_COND_GE] = "ge", 904f48f3edeSblueswir1 [TCG_COND_LE] = "le", 905f48f3edeSblueswir1 [TCG_COND_GT] = "gt", 906f48f3edeSblueswir1 [TCG_COND_LTU] = "ltu", 907f48f3edeSblueswir1 [TCG_COND_GEU] = "geu", 908f48f3edeSblueswir1 [TCG_COND_LEU] = "leu", 909f48f3edeSblueswir1 [TCG_COND_GTU] = "gtu" 910f48f3edeSblueswir1 }; 911f48f3edeSblueswir1 912eeacee4dSBlue Swirl void tcg_dump_ops(TCGContext *s) 913c896fe29Sbellard { 914c896fe29Sbellard const uint16_t *opc_ptr; 915c896fe29Sbellard const TCGArg *args; 916c896fe29Sbellard TCGArg arg; 917a9751609SRichard Henderson TCGOpcode c; 918a9751609SRichard Henderson int i, k, nb_oargs, nb_iargs, nb_cargs, first_insn; 919c896fe29Sbellard const TCGOpDef *def; 920c896fe29Sbellard char buf[128]; 921c896fe29Sbellard 9227e4597d7Sbellard first_insn = 1; 92392414b31SEvgeny Voevodin opc_ptr = s->gen_opc_buf; 9241ff0a2c5SEvgeny Voevodin args = s->gen_opparam_buf; 925efd7f486SEvgeny Voevodin while (opc_ptr < s->gen_opc_ptr) { 926c896fe29Sbellard c = *opc_ptr++; 927c896fe29Sbellard def = &tcg_op_defs[c]; 9287e4597d7Sbellard if (c == INDEX_op_debug_insn_start) { 9297e4597d7Sbellard uint64_t pc; 9307e4597d7Sbellard #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS 9317e4597d7Sbellard pc = ((uint64_t)args[1] << 32) | args[0]; 9327e4597d7Sbellard #else 9337e4597d7Sbellard pc = args[0]; 9347e4597d7Sbellard #endif 935eeacee4dSBlue Swirl if (!first_insn) { 936eeacee4dSBlue Swirl qemu_log("\n"); 937eeacee4dSBlue Swirl } 938eeacee4dSBlue Swirl qemu_log(" ---- 0x%" PRIx64, pc); 9397e4597d7Sbellard first_insn = 0; 9407e4597d7Sbellard nb_oargs = def->nb_oargs; 9417e4597d7Sbellard nb_iargs = def->nb_iargs; 9427e4597d7Sbellard nb_cargs = def->nb_cargs; 9437e4597d7Sbellard } else if (c == INDEX_op_call) { 944c896fe29Sbellard TCGArg arg; 9454dc81f28Sbellard 946c896fe29Sbellard /* variable number of arguments */ 947c896fe29Sbellard arg = *args++; 948c896fe29Sbellard nb_oargs = arg >> 16; 949c896fe29Sbellard nb_iargs = arg & 0xffff; 950c896fe29Sbellard nb_cargs = def->nb_cargs; 951b03cce8eSbellard 952eeacee4dSBlue Swirl qemu_log(" %s ", def->name); 9537e4597d7Sbellard 954b03cce8eSbellard /* function name */ 955eeacee4dSBlue Swirl qemu_log("%s", 956eeacee4dSBlue Swirl tcg_get_arg_str_idx(s, buf, sizeof(buf), 957eeacee4dSBlue Swirl args[nb_oargs + nb_iargs - 1])); 958b03cce8eSbellard /* flags */ 959eeacee4dSBlue Swirl qemu_log(",$0x%" TCG_PRIlx, args[nb_oargs + nb_iargs]); 960b03cce8eSbellard /* nb out args */ 961eeacee4dSBlue Swirl qemu_log(",$%d", nb_oargs); 962b03cce8eSbellard for(i = 0; i < nb_oargs; i++) { 963eeacee4dSBlue Swirl qemu_log(","); 964eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 965eeacee4dSBlue Swirl args[i])); 966b03cce8eSbellard } 967b03cce8eSbellard for(i = 0; i < (nb_iargs - 1); i++) { 968eeacee4dSBlue Swirl qemu_log(","); 96939cf05d3Sbellard if (args[nb_oargs + i] == TCG_CALL_DUMMY_ARG) { 970eeacee4dSBlue Swirl qemu_log("<dummy>"); 97139cf05d3Sbellard } else { 972eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 973eeacee4dSBlue Swirl args[nb_oargs + i])); 974b03cce8eSbellard } 97539cf05d3Sbellard } 976fba3161fSAurelien Jarno } else if (c == INDEX_op_movi_i32 || c == INDEX_op_movi_i64) { 977e8996ee0Sbellard tcg_target_ulong val; 978e8996ee0Sbellard TCGHelperInfo *th; 979e8996ee0Sbellard 980e8996ee0Sbellard nb_oargs = def->nb_oargs; 981e8996ee0Sbellard nb_iargs = def->nb_iargs; 982e8996ee0Sbellard nb_cargs = def->nb_cargs; 983eeacee4dSBlue Swirl qemu_log(" %s %s,$", def->name, 984e8996ee0Sbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[0])); 985e8996ee0Sbellard val = args[1]; 986e8996ee0Sbellard th = tcg_find_helper(s, val); 987e8996ee0Sbellard if (th) { 988eeacee4dSBlue Swirl qemu_log("%s", th->name); 989e8996ee0Sbellard } else { 990eeacee4dSBlue Swirl if (c == INDEX_op_movi_i32) { 991eeacee4dSBlue Swirl qemu_log("0x%x", (uint32_t)val); 992eeacee4dSBlue Swirl } else { 993eeacee4dSBlue Swirl qemu_log("0x%" PRIx64 , (uint64_t)val); 994eeacee4dSBlue Swirl } 995e8996ee0Sbellard } 996b03cce8eSbellard } else { 997eeacee4dSBlue Swirl qemu_log(" %s ", def->name); 998b03cce8eSbellard if (c == INDEX_op_nopn) { 999c896fe29Sbellard /* variable number of arguments */ 1000c896fe29Sbellard nb_cargs = *args; 1001c896fe29Sbellard nb_oargs = 0; 1002c896fe29Sbellard nb_iargs = 0; 1003c896fe29Sbellard } else { 1004c896fe29Sbellard nb_oargs = def->nb_oargs; 1005c896fe29Sbellard nb_iargs = def->nb_iargs; 1006c896fe29Sbellard nb_cargs = def->nb_cargs; 1007c896fe29Sbellard } 1008c896fe29Sbellard 1009c896fe29Sbellard k = 0; 1010c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1011eeacee4dSBlue Swirl if (k != 0) { 1012eeacee4dSBlue Swirl qemu_log(","); 1013eeacee4dSBlue Swirl } 1014eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 1015eeacee4dSBlue Swirl args[k++])); 1016c896fe29Sbellard } 1017c896fe29Sbellard for(i = 0; i < nb_iargs; i++) { 1018eeacee4dSBlue Swirl if (k != 0) { 1019eeacee4dSBlue Swirl qemu_log(","); 1020eeacee4dSBlue Swirl } 1021eeacee4dSBlue Swirl qemu_log("%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), 1022eeacee4dSBlue Swirl args[k++])); 1023c896fe29Sbellard } 1024be210acbSRichard Henderson switch (c) { 1025be210acbSRichard Henderson case INDEX_op_brcond_i32: 1026ffc5ea09SRichard Henderson case INDEX_op_setcond_i32: 1027ffc5ea09SRichard Henderson case INDEX_op_movcond_i32: 1028be210acbSRichard Henderson case INDEX_op_brcond2_i32: 1029be210acbSRichard Henderson case INDEX_op_setcond2_i32: 1030ffc5ea09SRichard Henderson case INDEX_op_brcond_i64: 1031be210acbSRichard Henderson case INDEX_op_setcond_i64: 1032ffc5ea09SRichard Henderson case INDEX_op_movcond_i64: 1033eeacee4dSBlue Swirl if (args[k] < ARRAY_SIZE(cond_name) && cond_name[args[k]]) { 1034eeacee4dSBlue Swirl qemu_log(",%s", cond_name[args[k++]]); 1035eeacee4dSBlue Swirl } else { 1036eeacee4dSBlue Swirl qemu_log(",$0x%" TCG_PRIlx, args[k++]); 1037eeacee4dSBlue Swirl } 1038f48f3edeSblueswir1 i = 1; 1039be210acbSRichard Henderson break; 1040be210acbSRichard Henderson default: 1041f48f3edeSblueswir1 i = 0; 1042be210acbSRichard Henderson break; 1043be210acbSRichard Henderson } 1044f48f3edeSblueswir1 for(; i < nb_cargs; i++) { 1045eeacee4dSBlue Swirl if (k != 0) { 1046eeacee4dSBlue Swirl qemu_log(","); 1047eeacee4dSBlue Swirl } 1048c896fe29Sbellard arg = args[k++]; 1049eeacee4dSBlue Swirl qemu_log("$0x%" TCG_PRIlx, arg); 1050c896fe29Sbellard } 1051b03cce8eSbellard } 1052eeacee4dSBlue Swirl qemu_log("\n"); 1053c896fe29Sbellard args += nb_iargs + nb_oargs + nb_cargs; 1054c896fe29Sbellard } 1055c896fe29Sbellard } 1056c896fe29Sbellard 1057c896fe29Sbellard /* we give more priority to constraints with less registers */ 1058c896fe29Sbellard static int get_constraint_priority(const TCGOpDef *def, int k) 1059c896fe29Sbellard { 1060c896fe29Sbellard const TCGArgConstraint *arg_ct; 1061c896fe29Sbellard 1062c896fe29Sbellard int i, n; 1063c896fe29Sbellard arg_ct = &def->args_ct[k]; 1064c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 1065c896fe29Sbellard /* an alias is equivalent to a single register */ 1066c896fe29Sbellard n = 1; 1067c896fe29Sbellard } else { 1068c896fe29Sbellard if (!(arg_ct->ct & TCG_CT_REG)) 1069c896fe29Sbellard return 0; 1070c896fe29Sbellard n = 0; 1071c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1072c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, i)) 1073c896fe29Sbellard n++; 1074c896fe29Sbellard } 1075c896fe29Sbellard } 1076c896fe29Sbellard return TCG_TARGET_NB_REGS - n + 1; 1077c896fe29Sbellard } 1078c896fe29Sbellard 1079c896fe29Sbellard /* sort from highest priority to lowest */ 1080c896fe29Sbellard static void sort_constraints(TCGOpDef *def, int start, int n) 1081c896fe29Sbellard { 1082c896fe29Sbellard int i, j, p1, p2, tmp; 1083c896fe29Sbellard 1084c896fe29Sbellard for(i = 0; i < n; i++) 1085c896fe29Sbellard def->sorted_args[start + i] = start + i; 1086c896fe29Sbellard if (n <= 1) 1087c896fe29Sbellard return; 1088c896fe29Sbellard for(i = 0; i < n - 1; i++) { 1089c896fe29Sbellard for(j = i + 1; j < n; j++) { 1090c896fe29Sbellard p1 = get_constraint_priority(def, def->sorted_args[start + i]); 1091c896fe29Sbellard p2 = get_constraint_priority(def, def->sorted_args[start + j]); 1092c896fe29Sbellard if (p1 < p2) { 1093c896fe29Sbellard tmp = def->sorted_args[start + i]; 1094c896fe29Sbellard def->sorted_args[start + i] = def->sorted_args[start + j]; 1095c896fe29Sbellard def->sorted_args[start + j] = tmp; 1096c896fe29Sbellard } 1097c896fe29Sbellard } 1098c896fe29Sbellard } 1099c896fe29Sbellard } 1100c896fe29Sbellard 1101c896fe29Sbellard void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs) 1102c896fe29Sbellard { 1103a9751609SRichard Henderson TCGOpcode op; 1104c896fe29Sbellard TCGOpDef *def; 1105c896fe29Sbellard const char *ct_str; 1106c896fe29Sbellard int i, nb_args; 1107c896fe29Sbellard 1108c896fe29Sbellard for(;;) { 1109a9751609SRichard Henderson if (tdefs->op == (TCGOpcode)-1) 1110c896fe29Sbellard break; 1111c896fe29Sbellard op = tdefs->op; 1112c3b08d0eSStefan Weil assert((unsigned)op < NB_OPS); 1113c896fe29Sbellard def = &tcg_op_defs[op]; 1114c68aaa18SStefan Weil #if defined(CONFIG_DEBUG_TCG) 1115c68aaa18SStefan Weil /* Duplicate entry in op definitions? */ 1116c68aaa18SStefan Weil assert(!def->used); 1117c68aaa18SStefan Weil def->used = 1; 1118c68aaa18SStefan Weil #endif 1119c896fe29Sbellard nb_args = def->nb_iargs + def->nb_oargs; 1120c896fe29Sbellard for(i = 0; i < nb_args; i++) { 1121c896fe29Sbellard ct_str = tdefs->args_ct_str[i]; 1122c68aaa18SStefan Weil /* Incomplete TCGTargetOpDef entry? */ 1123c68aaa18SStefan Weil assert(ct_str != NULL); 1124c896fe29Sbellard tcg_regset_clear(def->args_ct[i].u.regs); 1125c896fe29Sbellard def->args_ct[i].ct = 0; 1126c896fe29Sbellard if (ct_str[0] >= '0' && ct_str[0] <= '9') { 1127c896fe29Sbellard int oarg; 1128c896fe29Sbellard oarg = ct_str[0] - '0'; 1129c896fe29Sbellard assert(oarg < def->nb_oargs); 1130c896fe29Sbellard assert(def->args_ct[oarg].ct & TCG_CT_REG); 1131c896fe29Sbellard /* TCG_CT_ALIAS is for the output arguments. The input 11325ff9d6a4Sbellard argument is tagged with TCG_CT_IALIAS. */ 1133c896fe29Sbellard def->args_ct[i] = def->args_ct[oarg]; 11345ff9d6a4Sbellard def->args_ct[oarg].ct = TCG_CT_ALIAS; 11355ff9d6a4Sbellard def->args_ct[oarg].alias_index = i; 1136c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_IALIAS; 11375ff9d6a4Sbellard def->args_ct[i].alias_index = oarg; 1138c896fe29Sbellard } else { 1139c896fe29Sbellard for(;;) { 1140c896fe29Sbellard if (*ct_str == '\0') 1141c896fe29Sbellard break; 1142c896fe29Sbellard switch(*ct_str) { 1143c896fe29Sbellard case 'i': 1144c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_CONST; 1145c896fe29Sbellard ct_str++; 1146c896fe29Sbellard break; 1147c896fe29Sbellard default: 1148c896fe29Sbellard if (target_parse_constraint(&def->args_ct[i], &ct_str) < 0) { 1149c896fe29Sbellard fprintf(stderr, "Invalid constraint '%s' for arg %d of operation '%s'\n", 1150c896fe29Sbellard ct_str, i, def->name); 1151c896fe29Sbellard exit(1); 1152c896fe29Sbellard } 1153c896fe29Sbellard } 1154c896fe29Sbellard } 1155c896fe29Sbellard } 1156c896fe29Sbellard } 1157c896fe29Sbellard 1158c68aaa18SStefan Weil /* TCGTargetOpDef entry with too much information? */ 1159c68aaa18SStefan Weil assert(i == TCG_MAX_OP_ARGS || tdefs->args_ct_str[i] == NULL); 1160c68aaa18SStefan Weil 1161c896fe29Sbellard /* sort the constraints (XXX: this is just an heuristic) */ 1162c896fe29Sbellard sort_constraints(def, 0, def->nb_oargs); 1163c896fe29Sbellard sort_constraints(def, def->nb_oargs, def->nb_iargs); 1164c896fe29Sbellard 1165c896fe29Sbellard #if 0 1166c896fe29Sbellard { 1167c896fe29Sbellard int i; 1168c896fe29Sbellard 1169c896fe29Sbellard printf("%s: sorted=", def->name); 1170c896fe29Sbellard for(i = 0; i < def->nb_oargs + def->nb_iargs; i++) 1171c896fe29Sbellard printf(" %d", def->sorted_args[i]); 1172c896fe29Sbellard printf("\n"); 1173c896fe29Sbellard } 1174c896fe29Sbellard #endif 1175c896fe29Sbellard tdefs++; 1176c896fe29Sbellard } 1177c896fe29Sbellard 1178c68aaa18SStefan Weil #if defined(CONFIG_DEBUG_TCG) 1179a9751609SRichard Henderson i = 0; 1180c68aaa18SStefan Weil for (op = 0; op < ARRAY_SIZE(tcg_op_defs); op++) { 1181f412c762SRichard Henderson const TCGOpDef *def = &tcg_op_defs[op]; 1182c1a61f6cSRichard Henderson if (def->flags & TCG_OPF_NOT_PRESENT) { 1183c68aaa18SStefan Weil /* Wrong entry in op definitions? */ 1184f412c762SRichard Henderson if (def->used) { 1185f412c762SRichard Henderson fprintf(stderr, "Invalid op definition for %s\n", def->name); 1186a9751609SRichard Henderson i = 1; 1187a9751609SRichard Henderson } 1188c68aaa18SStefan Weil } else { 1189c68aaa18SStefan Weil /* Missing entry in op definitions? */ 1190f412c762SRichard Henderson if (!def->used) { 1191f412c762SRichard Henderson fprintf(stderr, "Missing op definition for %s\n", def->name); 1192a9751609SRichard Henderson i = 1; 1193c68aaa18SStefan Weil } 1194c68aaa18SStefan Weil } 1195a9751609SRichard Henderson } 1196a9751609SRichard Henderson if (i == 1) { 1197a9751609SRichard Henderson tcg_abort(); 1198a9751609SRichard Henderson } 1199c68aaa18SStefan Weil #endif 1200c896fe29Sbellard } 1201c896fe29Sbellard 1202c896fe29Sbellard #ifdef USE_LIVENESS_ANALYSIS 1203c896fe29Sbellard 1204c896fe29Sbellard /* set a nop for an operation using 'nb_args' */ 1205c896fe29Sbellard static inline void tcg_set_nop(TCGContext *s, uint16_t *opc_ptr, 1206c896fe29Sbellard TCGArg *args, int nb_args) 1207c896fe29Sbellard { 1208c896fe29Sbellard if (nb_args == 0) { 1209c896fe29Sbellard *opc_ptr = INDEX_op_nop; 1210c896fe29Sbellard } else { 1211c896fe29Sbellard *opc_ptr = INDEX_op_nopn; 1212c896fe29Sbellard args[0] = nb_args; 1213c896fe29Sbellard args[nb_args - 1] = nb_args; 1214c896fe29Sbellard } 1215c896fe29Sbellard } 1216c896fe29Sbellard 12179c43b68dSAurelien Jarno /* liveness analysis: end of function: all temps are dead, and globals 12189c43b68dSAurelien Jarno should be in memory. */ 12199c43b68dSAurelien Jarno static inline void tcg_la_func_end(TCGContext *s, uint8_t *dead_temps, 12209c43b68dSAurelien Jarno uint8_t *mem_temps) 1221c896fe29Sbellard { 12229c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_temps); 12239c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 12249c43b68dSAurelien Jarno memset(mem_temps + s->nb_globals, 0, s->nb_temps - s->nb_globals); 1225c896fe29Sbellard } 1226c896fe29Sbellard 12279c43b68dSAurelien Jarno /* liveness analysis: end of basic block: all temps are dead, globals 12289c43b68dSAurelien Jarno and local temps should be in memory. */ 12299c43b68dSAurelien Jarno static inline void tcg_la_bb_end(TCGContext *s, uint8_t *dead_temps, 12309c43b68dSAurelien Jarno uint8_t *mem_temps) 1231641d5fbeSbellard { 1232641d5fbeSbellard int i; 1233641d5fbeSbellard 12349c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_temps); 12359c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 1236641d5fbeSbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 12379c43b68dSAurelien Jarno mem_temps[i] = s->temps[i].temp_local; 1238641d5fbeSbellard } 1239641d5fbeSbellard } 1240641d5fbeSbellard 1241866cb6cbSAurelien Jarno /* Liveness analysis : update the opc_dead_args array to tell if a 1242c896fe29Sbellard given input arguments is dead. Instructions updating dead 1243c896fe29Sbellard temporaries are removed. */ 12448fcd3692Sblueswir1 static void tcg_liveness_analysis(TCGContext *s) 1245c896fe29Sbellard { 1246a9751609SRichard Henderson int i, op_index, nb_args, nb_iargs, nb_oargs, arg, nb_ops; 124703271524SRichard Henderson TCGOpcode op, op_new, op_new2; 1248c896fe29Sbellard TCGArg *args; 1249c896fe29Sbellard const TCGOpDef *def; 12509c43b68dSAurelien Jarno uint8_t *dead_temps, *mem_temps; 1251ec7a869dSAurelien Jarno uint16_t dead_args; 1252ec7a869dSAurelien Jarno uint8_t sync_args; 125303271524SRichard Henderson bool have_op_new2; 1254c896fe29Sbellard 1255efd7f486SEvgeny Voevodin s->gen_opc_ptr++; /* skip end */ 1256c896fe29Sbellard 125792414b31SEvgeny Voevodin nb_ops = s->gen_opc_ptr - s->gen_opc_buf; 1258c896fe29Sbellard 1259866cb6cbSAurelien Jarno s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t)); 1260ec7a869dSAurelien Jarno s->op_sync_args = tcg_malloc(nb_ops * sizeof(uint8_t)); 1261c896fe29Sbellard 1262c896fe29Sbellard dead_temps = tcg_malloc(s->nb_temps); 12639c43b68dSAurelien Jarno mem_temps = tcg_malloc(s->nb_temps); 12649c43b68dSAurelien Jarno tcg_la_func_end(s, dead_temps, mem_temps); 1265c896fe29Sbellard 1266c4afe5c4SEvgeny Voevodin args = s->gen_opparam_ptr; 1267c896fe29Sbellard op_index = nb_ops - 1; 1268c896fe29Sbellard while (op_index >= 0) { 126992414b31SEvgeny Voevodin op = s->gen_opc_buf[op_index]; 1270c896fe29Sbellard def = &tcg_op_defs[op]; 1271c896fe29Sbellard switch(op) { 1272c896fe29Sbellard case INDEX_op_call: 1273c6e113f5Sbellard { 1274c6e113f5Sbellard int call_flags; 1275c6e113f5Sbellard 1276c896fe29Sbellard nb_args = args[-1]; 1277c896fe29Sbellard args -= nb_args; 1278c896fe29Sbellard nb_iargs = args[0] & 0xffff; 1279c896fe29Sbellard nb_oargs = args[0] >> 16; 1280c896fe29Sbellard args++; 1281c6e113f5Sbellard call_flags = args[nb_oargs + nb_iargs]; 1282c6e113f5Sbellard 1283c6e113f5Sbellard /* pure functions can be removed if their result is not 1284c6e113f5Sbellard used */ 128578505279SAurelien Jarno if (call_flags & TCG_CALL_NO_SIDE_EFFECTS) { 1286c6e113f5Sbellard for(i = 0; i < nb_oargs; i++) { 1287c6e113f5Sbellard arg = args[i]; 12889c43b68dSAurelien Jarno if (!dead_temps[arg] || mem_temps[arg]) { 1289c6e113f5Sbellard goto do_not_remove_call; 1290c6e113f5Sbellard } 12919c43b68dSAurelien Jarno } 129292414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index, 1293c6e113f5Sbellard args - 1, nb_args); 1294c6e113f5Sbellard } else { 1295c6e113f5Sbellard do_not_remove_call: 1296c896fe29Sbellard 1297c896fe29Sbellard /* output args are dead */ 12986b64b624SAurelien Jarno dead_args = 0; 1299ec7a869dSAurelien Jarno sync_args = 0; 1300c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1301c896fe29Sbellard arg = args[i]; 13026b64b624SAurelien Jarno if (dead_temps[arg]) { 13036b64b624SAurelien Jarno dead_args |= (1 << i); 13046b64b624SAurelien Jarno } 13059c43b68dSAurelien Jarno if (mem_temps[arg]) { 13069c43b68dSAurelien Jarno sync_args |= (1 << i); 13079c43b68dSAurelien Jarno } 1308c896fe29Sbellard dead_temps[arg] = 1; 13099c43b68dSAurelien Jarno mem_temps[arg] = 0; 1310c896fe29Sbellard } 1311c896fe29Sbellard 131278505279SAurelien Jarno if (!(call_flags & TCG_CALL_NO_READ_GLOBALS)) { 131378505279SAurelien Jarno /* globals should be synced to memory */ 131478505279SAurelien Jarno memset(mem_temps, 1, s->nb_globals); 131578505279SAurelien Jarno } 131678505279SAurelien Jarno if (!(call_flags & (TCG_CALL_NO_WRITE_GLOBALS | 131778505279SAurelien Jarno TCG_CALL_NO_READ_GLOBALS))) { 13189c43b68dSAurelien Jarno /* globals should go back to memory */ 13199c43b68dSAurelien Jarno memset(dead_temps, 1, s->nb_globals); 1320b9c18f56Saurel32 } 1321c896fe29Sbellard 1322c896fe29Sbellard /* input args are live */ 1323866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 1324866cb6cbSAurelien Jarno arg = args[i]; 132539cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 1326c896fe29Sbellard if (dead_temps[arg]) { 1327866cb6cbSAurelien Jarno dead_args |= (1 << i); 1328c896fe29Sbellard } 1329c896fe29Sbellard dead_temps[arg] = 0; 1330c896fe29Sbellard } 133139cf05d3Sbellard } 1332866cb6cbSAurelien Jarno s->op_dead_args[op_index] = dead_args; 1333ec7a869dSAurelien Jarno s->op_sync_args[op_index] = sync_args; 1334c6e113f5Sbellard } 1335c896fe29Sbellard args--; 1336c6e113f5Sbellard } 1337c896fe29Sbellard break; 13387e4597d7Sbellard case INDEX_op_debug_insn_start: 13397e4597d7Sbellard args -= def->nb_args; 13407e4597d7Sbellard break; 1341c896fe29Sbellard case INDEX_op_nopn: 1342c896fe29Sbellard nb_args = args[-1]; 1343c896fe29Sbellard args -= nb_args; 1344c896fe29Sbellard break; 13455ff9d6a4Sbellard case INDEX_op_discard: 13465ff9d6a4Sbellard args--; 13475ff9d6a4Sbellard /* mark the temporary as dead */ 13485ff9d6a4Sbellard dead_temps[args[0]] = 1; 13499c43b68dSAurelien Jarno mem_temps[args[0]] = 0; 13505ff9d6a4Sbellard break; 1351c896fe29Sbellard case INDEX_op_end: 1352c896fe29Sbellard break; 13531305c451SRichard Henderson 13541305c451SRichard Henderson case INDEX_op_add2_i32: 1355f1fae40cSRichard Henderson op_new = INDEX_op_add_i32; 1356f1fae40cSRichard Henderson goto do_addsub2; 13571305c451SRichard Henderson case INDEX_op_sub2_i32: 1358f1fae40cSRichard Henderson op_new = INDEX_op_sub_i32; 1359f1fae40cSRichard Henderson goto do_addsub2; 1360f1fae40cSRichard Henderson case INDEX_op_add2_i64: 1361f1fae40cSRichard Henderson op_new = INDEX_op_add_i64; 1362f1fae40cSRichard Henderson goto do_addsub2; 1363f1fae40cSRichard Henderson case INDEX_op_sub2_i64: 1364f1fae40cSRichard Henderson op_new = INDEX_op_sub_i64; 1365f1fae40cSRichard Henderson do_addsub2: 13661305c451SRichard Henderson args -= 6; 13671305c451SRichard Henderson nb_iargs = 4; 13681305c451SRichard Henderson nb_oargs = 2; 13691305c451SRichard Henderson /* Test if the high part of the operation is dead, but not 13701305c451SRichard Henderson the low part. The result can be optimized to a simple 13711305c451SRichard Henderson add or sub. This happens often for x86_64 guest when the 13721305c451SRichard Henderson cpu mode is set to 32 bit. */ 13733c5645faSKirill Batuzov if (dead_temps[args[1]] && !mem_temps[args[1]]) { 13743c5645faSKirill Batuzov if (dead_temps[args[0]] && !mem_temps[args[0]]) { 13751305c451SRichard Henderson goto do_remove; 13761305c451SRichard Henderson } 13771305c451SRichard Henderson /* Create the single operation plus nop. */ 1378f1fae40cSRichard Henderson s->gen_opc_buf[op_index] = op = op_new; 13791305c451SRichard Henderson args[1] = args[2]; 13801305c451SRichard Henderson args[2] = args[4]; 138192414b31SEvgeny Voevodin assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop); 138292414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 3); 13831305c451SRichard Henderson /* Fall through and mark the single-word operation live. */ 13841305c451SRichard Henderson nb_iargs = 2; 13851305c451SRichard Henderson nb_oargs = 1; 13861305c451SRichard Henderson } 13871305c451SRichard Henderson goto do_not_remove; 13881305c451SRichard Henderson 13891414968aSRichard Henderson case INDEX_op_mulu2_i32: 139003271524SRichard Henderson op_new = INDEX_op_mul_i32; 139103271524SRichard Henderson op_new2 = INDEX_op_muluh_i32; 139203271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_muluh_i32; 139303271524SRichard Henderson goto do_mul2; 1394f1fae40cSRichard Henderson case INDEX_op_muls2_i32: 1395f1fae40cSRichard Henderson op_new = INDEX_op_mul_i32; 139603271524SRichard Henderson op_new2 = INDEX_op_mulsh_i32; 139703271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_mulsh_i32; 1398f1fae40cSRichard Henderson goto do_mul2; 1399f1fae40cSRichard Henderson case INDEX_op_mulu2_i64: 140003271524SRichard Henderson op_new = INDEX_op_mul_i64; 140103271524SRichard Henderson op_new2 = INDEX_op_muluh_i64; 140203271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_muluh_i64; 140303271524SRichard Henderson goto do_mul2; 1404f1fae40cSRichard Henderson case INDEX_op_muls2_i64: 1405f1fae40cSRichard Henderson op_new = INDEX_op_mul_i64; 140603271524SRichard Henderson op_new2 = INDEX_op_mulsh_i64; 140703271524SRichard Henderson have_op_new2 = TCG_TARGET_HAS_mulsh_i64; 140803271524SRichard Henderson goto do_mul2; 1409f1fae40cSRichard Henderson do_mul2: 14101414968aSRichard Henderson args -= 4; 14111414968aSRichard Henderson nb_iargs = 2; 14121414968aSRichard Henderson nb_oargs = 2; 14133c5645faSKirill Batuzov if (dead_temps[args[1]] && !mem_temps[args[1]]) { 14143c5645faSKirill Batuzov if (dead_temps[args[0]] && !mem_temps[args[0]]) { 141503271524SRichard Henderson /* Both parts of the operation are dead. */ 14161414968aSRichard Henderson goto do_remove; 14171414968aSRichard Henderson } 141803271524SRichard Henderson /* The high part of the operation is dead; generate the low. */ 1419f1fae40cSRichard Henderson s->gen_opc_buf[op_index] = op = op_new; 14201414968aSRichard Henderson args[1] = args[2]; 14211414968aSRichard Henderson args[2] = args[3]; 142203271524SRichard Henderson } else if (have_op_new2 && dead_temps[args[0]] 142303271524SRichard Henderson && !mem_temps[args[0]]) { 142403271524SRichard Henderson /* The low part of the operation is dead; generate the high. */ 142503271524SRichard Henderson s->gen_opc_buf[op_index] = op = op_new2; 142603271524SRichard Henderson args[0] = args[1]; 142703271524SRichard Henderson args[1] = args[2]; 142803271524SRichard Henderson args[2] = args[3]; 142903271524SRichard Henderson } else { 143003271524SRichard Henderson goto do_not_remove; 143103271524SRichard Henderson } 143292414b31SEvgeny Voevodin assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop); 143392414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 1); 143403271524SRichard Henderson /* Mark the single-word operation live. */ 14351414968aSRichard Henderson nb_oargs = 1; 14361414968aSRichard Henderson goto do_not_remove; 14371414968aSRichard Henderson 1438c896fe29Sbellard default: 14391305c451SRichard Henderson /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */ 1440c896fe29Sbellard args -= def->nb_args; 1441c896fe29Sbellard nb_iargs = def->nb_iargs; 1442c896fe29Sbellard nb_oargs = def->nb_oargs; 1443c896fe29Sbellard 1444c896fe29Sbellard /* Test if the operation can be removed because all 14455ff9d6a4Sbellard its outputs are dead. We assume that nb_oargs == 0 14465ff9d6a4Sbellard implies side effects */ 14475ff9d6a4Sbellard if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) { 1448c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1449c896fe29Sbellard arg = args[i]; 14509c43b68dSAurelien Jarno if (!dead_temps[arg] || mem_temps[arg]) { 1451c896fe29Sbellard goto do_not_remove; 1452c896fe29Sbellard } 14539c43b68dSAurelien Jarno } 14541305c451SRichard Henderson do_remove: 145592414b31SEvgeny Voevodin tcg_set_nop(s, s->gen_opc_buf + op_index, args, def->nb_args); 1456c896fe29Sbellard #ifdef CONFIG_PROFILER 1457a23a9ec6Sbellard s->del_op_count++; 1458c896fe29Sbellard #endif 1459c896fe29Sbellard } else { 1460c896fe29Sbellard do_not_remove: 1461c896fe29Sbellard 1462c896fe29Sbellard /* output args are dead */ 14636b64b624SAurelien Jarno dead_args = 0; 1464ec7a869dSAurelien Jarno sync_args = 0; 1465c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1466c896fe29Sbellard arg = args[i]; 14676b64b624SAurelien Jarno if (dead_temps[arg]) { 14686b64b624SAurelien Jarno dead_args |= (1 << i); 14696b64b624SAurelien Jarno } 14709c43b68dSAurelien Jarno if (mem_temps[arg]) { 14719c43b68dSAurelien Jarno sync_args |= (1 << i); 14729c43b68dSAurelien Jarno } 1473c896fe29Sbellard dead_temps[arg] = 1; 14749c43b68dSAurelien Jarno mem_temps[arg] = 0; 1475c896fe29Sbellard } 1476c896fe29Sbellard 1477c896fe29Sbellard /* if end of basic block, update */ 1478c896fe29Sbellard if (def->flags & TCG_OPF_BB_END) { 14799c43b68dSAurelien Jarno tcg_la_bb_end(s, dead_temps, mem_temps); 14803d5c5f87SAurelien Jarno } else if (def->flags & TCG_OPF_SIDE_EFFECTS) { 14813d5c5f87SAurelien Jarno /* globals should be synced to memory */ 14829c43b68dSAurelien Jarno memset(mem_temps, 1, s->nb_globals); 1483c896fe29Sbellard } 1484c896fe29Sbellard 1485c896fe29Sbellard /* input args are live */ 1486866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 1487866cb6cbSAurelien Jarno arg = args[i]; 1488c896fe29Sbellard if (dead_temps[arg]) { 1489866cb6cbSAurelien Jarno dead_args |= (1 << i); 1490c896fe29Sbellard } 1491c896fe29Sbellard dead_temps[arg] = 0; 1492c896fe29Sbellard } 1493866cb6cbSAurelien Jarno s->op_dead_args[op_index] = dead_args; 1494ec7a869dSAurelien Jarno s->op_sync_args[op_index] = sync_args; 1495c896fe29Sbellard } 1496c896fe29Sbellard break; 1497c896fe29Sbellard } 1498c896fe29Sbellard op_index--; 1499c896fe29Sbellard } 1500c896fe29Sbellard 15011ff0a2c5SEvgeny Voevodin if (args != s->gen_opparam_buf) { 1502c896fe29Sbellard tcg_abort(); 1503c896fe29Sbellard } 15041ff0a2c5SEvgeny Voevodin } 1505c896fe29Sbellard #else 1506c896fe29Sbellard /* dummy liveness analysis */ 1507655feed5Smalc static void tcg_liveness_analysis(TCGContext *s) 1508c896fe29Sbellard { 1509c896fe29Sbellard int nb_ops; 151092414b31SEvgeny Voevodin nb_ops = s->gen_opc_ptr - s->gen_opc_buf; 1511c896fe29Sbellard 1512866cb6cbSAurelien Jarno s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t)); 1513866cb6cbSAurelien Jarno memset(s->op_dead_args, 0, nb_ops * sizeof(uint16_t)); 1514ec7a869dSAurelien Jarno s->op_sync_args = tcg_malloc(nb_ops * sizeof(uint8_t)); 1515ec7a869dSAurelien Jarno memset(s->op_sync_args, 0, nb_ops * sizeof(uint8_t)); 1516c896fe29Sbellard } 1517c896fe29Sbellard #endif 1518c896fe29Sbellard 1519c896fe29Sbellard #ifndef NDEBUG 1520c896fe29Sbellard static void dump_regs(TCGContext *s) 1521c896fe29Sbellard { 1522c896fe29Sbellard TCGTemp *ts; 1523c896fe29Sbellard int i; 1524c896fe29Sbellard char buf[64]; 1525c896fe29Sbellard 1526c896fe29Sbellard for(i = 0; i < s->nb_temps; i++) { 1527c896fe29Sbellard ts = &s->temps[i]; 1528ac56dd48Spbrook printf(" %10s: ", tcg_get_arg_str_idx(s, buf, sizeof(buf), i)); 1529c896fe29Sbellard switch(ts->val_type) { 1530c896fe29Sbellard case TEMP_VAL_REG: 1531c896fe29Sbellard printf("%s", tcg_target_reg_names[ts->reg]); 1532c896fe29Sbellard break; 1533c896fe29Sbellard case TEMP_VAL_MEM: 1534c896fe29Sbellard printf("%d(%s)", (int)ts->mem_offset, tcg_target_reg_names[ts->mem_reg]); 1535c896fe29Sbellard break; 1536c896fe29Sbellard case TEMP_VAL_CONST: 1537c896fe29Sbellard printf("$0x%" TCG_PRIlx, ts->val); 1538c896fe29Sbellard break; 1539c896fe29Sbellard case TEMP_VAL_DEAD: 1540c896fe29Sbellard printf("D"); 1541c896fe29Sbellard break; 1542c896fe29Sbellard default: 1543c896fe29Sbellard printf("???"); 1544c896fe29Sbellard break; 1545c896fe29Sbellard } 1546c896fe29Sbellard printf("\n"); 1547c896fe29Sbellard } 1548c896fe29Sbellard 1549c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1550c896fe29Sbellard if (s->reg_to_temp[i] >= 0) { 1551c896fe29Sbellard printf("%s: %s\n", 1552c896fe29Sbellard tcg_target_reg_names[i], 1553ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), s->reg_to_temp[i])); 1554c896fe29Sbellard } 1555c896fe29Sbellard } 1556c896fe29Sbellard } 1557c896fe29Sbellard 1558c896fe29Sbellard static void check_regs(TCGContext *s) 1559c896fe29Sbellard { 1560c896fe29Sbellard int reg, k; 1561c896fe29Sbellard TCGTemp *ts; 1562c896fe29Sbellard char buf[64]; 1563c896fe29Sbellard 1564c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1565c896fe29Sbellard k = s->reg_to_temp[reg]; 1566c896fe29Sbellard if (k >= 0) { 1567c896fe29Sbellard ts = &s->temps[k]; 1568c896fe29Sbellard if (ts->val_type != TEMP_VAL_REG || 1569c896fe29Sbellard ts->reg != reg) { 1570c896fe29Sbellard printf("Inconsistency for register %s:\n", 1571c896fe29Sbellard tcg_target_reg_names[reg]); 1572b03cce8eSbellard goto fail; 1573c896fe29Sbellard } 1574c896fe29Sbellard } 1575c896fe29Sbellard } 1576c896fe29Sbellard for(k = 0; k < s->nb_temps; k++) { 1577c896fe29Sbellard ts = &s->temps[k]; 1578c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG && 1579c896fe29Sbellard !ts->fixed_reg && 1580c896fe29Sbellard s->reg_to_temp[ts->reg] != k) { 1581c896fe29Sbellard printf("Inconsistency for temp %s:\n", 1582ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), k)); 1583b03cce8eSbellard fail: 1584c896fe29Sbellard printf("reg state:\n"); 1585c896fe29Sbellard dump_regs(s); 1586c896fe29Sbellard tcg_abort(); 1587c896fe29Sbellard } 1588c896fe29Sbellard } 1589c896fe29Sbellard } 1590c896fe29Sbellard #endif 1591c896fe29Sbellard 1592c896fe29Sbellard static void temp_allocate_frame(TCGContext *s, int temp) 1593c896fe29Sbellard { 1594c896fe29Sbellard TCGTemp *ts; 1595c896fe29Sbellard ts = &s->temps[temp]; 15969b9c37c3SRichard Henderson #if !(defined(__sparc__) && TCG_TARGET_REG_BITS == 64) 15979b9c37c3SRichard Henderson /* Sparc64 stack is accessed with offset of 2047 */ 1598b591dc59SBlue Swirl s->current_frame_offset = (s->current_frame_offset + 1599b591dc59SBlue Swirl (tcg_target_long)sizeof(tcg_target_long) - 1) & 1600b591dc59SBlue Swirl ~(sizeof(tcg_target_long) - 1); 1601f44c9960SBlue Swirl #endif 1602b591dc59SBlue Swirl if (s->current_frame_offset + (tcg_target_long)sizeof(tcg_target_long) > 1603b591dc59SBlue Swirl s->frame_end) { 16045ff9d6a4Sbellard tcg_abort(); 1605b591dc59SBlue Swirl } 1606c896fe29Sbellard ts->mem_offset = s->current_frame_offset; 1607c896fe29Sbellard ts->mem_reg = s->frame_reg; 1608c896fe29Sbellard ts->mem_allocated = 1; 1609e2c6d1b4SRichard Henderson s->current_frame_offset += sizeof(tcg_target_long); 1610c896fe29Sbellard } 1611c896fe29Sbellard 16127f6ceedfSAurelien Jarno /* sync register 'reg' by saving it to the corresponding temporary */ 16137f6ceedfSAurelien Jarno static inline void tcg_reg_sync(TCGContext *s, int reg) 1614c896fe29Sbellard { 1615c896fe29Sbellard TCGTemp *ts; 1616c896fe29Sbellard int temp; 1617c896fe29Sbellard 1618c896fe29Sbellard temp = s->reg_to_temp[reg]; 1619c896fe29Sbellard ts = &s->temps[temp]; 1620c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 16217f6ceedfSAurelien Jarno if (!ts->mem_coherent && !ts->fixed_reg) { 16227f6ceedfSAurelien Jarno if (!ts->mem_allocated) { 1623c896fe29Sbellard temp_allocate_frame(s, temp); 16247f6ceedfSAurelien Jarno } 1625e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1626c896fe29Sbellard } 16277f6ceedfSAurelien Jarno ts->mem_coherent = 1; 16287f6ceedfSAurelien Jarno } 16297f6ceedfSAurelien Jarno 16307f6ceedfSAurelien Jarno /* free register 'reg' by spilling the corresponding temporary if necessary */ 16317f6ceedfSAurelien Jarno static void tcg_reg_free(TCGContext *s, int reg) 16327f6ceedfSAurelien Jarno { 16337f6ceedfSAurelien Jarno int temp; 16347f6ceedfSAurelien Jarno 16357f6ceedfSAurelien Jarno temp = s->reg_to_temp[reg]; 16367f6ceedfSAurelien Jarno if (temp != -1) { 16377f6ceedfSAurelien Jarno tcg_reg_sync(s, reg); 16387f6ceedfSAurelien Jarno s->temps[temp].val_type = TEMP_VAL_MEM; 1639c896fe29Sbellard s->reg_to_temp[reg] = -1; 1640c896fe29Sbellard } 1641c896fe29Sbellard } 1642c896fe29Sbellard 1643c896fe29Sbellard /* Allocate a register belonging to reg1 & ~reg2 */ 1644c896fe29Sbellard static int tcg_reg_alloc(TCGContext *s, TCGRegSet reg1, TCGRegSet reg2) 1645c896fe29Sbellard { 1646c896fe29Sbellard int i, reg; 1647c896fe29Sbellard TCGRegSet reg_ct; 1648c896fe29Sbellard 1649c896fe29Sbellard tcg_regset_andnot(reg_ct, reg1, reg2); 1650c896fe29Sbellard 1651c896fe29Sbellard /* first try free registers */ 16520954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1653c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1654c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg) && s->reg_to_temp[reg] == -1) 1655c896fe29Sbellard return reg; 1656c896fe29Sbellard } 1657c896fe29Sbellard 1658c896fe29Sbellard /* XXX: do better spill choice */ 16590954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1660c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1661c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg)) { 1662c896fe29Sbellard tcg_reg_free(s, reg); 1663c896fe29Sbellard return reg; 1664c896fe29Sbellard } 1665c896fe29Sbellard } 1666c896fe29Sbellard 1667c896fe29Sbellard tcg_abort(); 1668c896fe29Sbellard } 1669c896fe29Sbellard 1670639368ddSAurelien Jarno /* mark a temporary as dead. */ 1671639368ddSAurelien Jarno static inline void temp_dead(TCGContext *s, int temp) 1672639368ddSAurelien Jarno { 1673639368ddSAurelien Jarno TCGTemp *ts; 1674639368ddSAurelien Jarno 1675639368ddSAurelien Jarno ts = &s->temps[temp]; 1676639368ddSAurelien Jarno if (!ts->fixed_reg) { 1677639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 1678639368ddSAurelien Jarno s->reg_to_temp[ts->reg] = -1; 1679639368ddSAurelien Jarno } 1680e5138db5SAurelien Jarno if (temp < s->nb_globals || ts->temp_local) { 1681639368ddSAurelien Jarno ts->val_type = TEMP_VAL_MEM; 1682639368ddSAurelien Jarno } else { 1683639368ddSAurelien Jarno ts->val_type = TEMP_VAL_DEAD; 1684639368ddSAurelien Jarno } 1685639368ddSAurelien Jarno } 1686639368ddSAurelien Jarno } 1687639368ddSAurelien Jarno 16881ad80729SAurelien Jarno /* sync a temporary to memory. 'allocated_regs' is used in case a 1689e8996ee0Sbellard temporary registers needs to be allocated to store a constant. */ 16901ad80729SAurelien Jarno static inline void temp_sync(TCGContext *s, int temp, TCGRegSet allocated_regs) 1691c896fe29Sbellard { 1692c896fe29Sbellard TCGTemp *ts; 1693c896fe29Sbellard 1694641d5fbeSbellard ts = &s->temps[temp]; 1695c896fe29Sbellard if (!ts->fixed_reg) { 1696e8996ee0Sbellard switch(ts->val_type) { 16971ad80729SAurelien Jarno case TEMP_VAL_CONST: 16981ad80729SAurelien Jarno ts->reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 16991ad80729SAurelien Jarno allocated_regs); 17001ad80729SAurelien Jarno ts->val_type = TEMP_VAL_REG; 17011ad80729SAurelien Jarno s->reg_to_temp[ts->reg] = temp; 17021ad80729SAurelien Jarno ts->mem_coherent = 0; 17031ad80729SAurelien Jarno tcg_out_movi(s, ts->type, ts->reg, ts->val); 17041ad80729SAurelien Jarno /* fallthrough*/ 1705e8996ee0Sbellard case TEMP_VAL_REG: 17061ad80729SAurelien Jarno tcg_reg_sync(s, ts->reg); 1707e8996ee0Sbellard break; 1708e8996ee0Sbellard case TEMP_VAL_DEAD: 1709e8996ee0Sbellard case TEMP_VAL_MEM: 1710e8996ee0Sbellard break; 1711e8996ee0Sbellard default: 1712e8996ee0Sbellard tcg_abort(); 1713c896fe29Sbellard } 1714c896fe29Sbellard } 1715c896fe29Sbellard } 1716641d5fbeSbellard 17171ad80729SAurelien Jarno /* save a temporary to memory. 'allocated_regs' is used in case a 17181ad80729SAurelien Jarno temporary registers needs to be allocated to store a constant. */ 17191ad80729SAurelien Jarno static inline void temp_save(TCGContext *s, int temp, TCGRegSet allocated_regs) 17201ad80729SAurelien Jarno { 17212c0366f0SAurelien Jarno #ifdef USE_LIVENESS_ANALYSIS 17222c0366f0SAurelien Jarno /* The liveness analysis already ensures that globals are back 17232c0366f0SAurelien Jarno in memory. Keep an assert for safety. */ 17242c0366f0SAurelien Jarno assert(s->temps[temp].val_type == TEMP_VAL_MEM || s->temps[temp].fixed_reg); 17252c0366f0SAurelien Jarno #else 17261ad80729SAurelien Jarno temp_sync(s, temp, allocated_regs); 17271ad80729SAurelien Jarno temp_dead(s, temp); 17282c0366f0SAurelien Jarno #endif 17291ad80729SAurelien Jarno } 17301ad80729SAurelien Jarno 17319814dd27SDong Xu Wang /* save globals to their canonical location and assume they can be 1732641d5fbeSbellard modified be the following code. 'allocated_regs' is used in case a 1733641d5fbeSbellard temporary registers needs to be allocated to store a constant. */ 1734641d5fbeSbellard static void save_globals(TCGContext *s, TCGRegSet allocated_regs) 1735641d5fbeSbellard { 1736641d5fbeSbellard int i; 1737641d5fbeSbellard 1738641d5fbeSbellard for(i = 0; i < s->nb_globals; i++) { 1739641d5fbeSbellard temp_save(s, i, allocated_regs); 1740641d5fbeSbellard } 1741e5097dc8Sbellard } 1742e5097dc8Sbellard 17433d5c5f87SAurelien Jarno /* sync globals to their canonical location and assume they can be 17443d5c5f87SAurelien Jarno read by the following code. 'allocated_regs' is used in case a 17453d5c5f87SAurelien Jarno temporary registers needs to be allocated to store a constant. */ 17463d5c5f87SAurelien Jarno static void sync_globals(TCGContext *s, TCGRegSet allocated_regs) 17473d5c5f87SAurelien Jarno { 17483d5c5f87SAurelien Jarno int i; 17493d5c5f87SAurelien Jarno 17503d5c5f87SAurelien Jarno for (i = 0; i < s->nb_globals; i++) { 17513d5c5f87SAurelien Jarno #ifdef USE_LIVENESS_ANALYSIS 17523d5c5f87SAurelien Jarno assert(s->temps[i].val_type != TEMP_VAL_REG || s->temps[i].fixed_reg || 17533d5c5f87SAurelien Jarno s->temps[i].mem_coherent); 17543d5c5f87SAurelien Jarno #else 17553d5c5f87SAurelien Jarno temp_sync(s, i, allocated_regs); 17563d5c5f87SAurelien Jarno #endif 17573d5c5f87SAurelien Jarno } 17583d5c5f87SAurelien Jarno } 17593d5c5f87SAurelien Jarno 1760e5097dc8Sbellard /* at the end of a basic block, we assume all temporaries are dead and 1761e8996ee0Sbellard all globals are stored at their canonical location. */ 1762e8996ee0Sbellard static void tcg_reg_alloc_bb_end(TCGContext *s, TCGRegSet allocated_regs) 1763e5097dc8Sbellard { 1764e5097dc8Sbellard TCGTemp *ts; 1765e5097dc8Sbellard int i; 1766e5097dc8Sbellard 1767c896fe29Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 1768c896fe29Sbellard ts = &s->temps[i]; 1769641d5fbeSbellard if (ts->temp_local) { 1770641d5fbeSbellard temp_save(s, i, allocated_regs); 1771641d5fbeSbellard } else { 17722c0366f0SAurelien Jarno #ifdef USE_LIVENESS_ANALYSIS 17732c0366f0SAurelien Jarno /* The liveness analysis already ensures that temps are dead. 17742c0366f0SAurelien Jarno Keep an assert for safety. */ 17752c0366f0SAurelien Jarno assert(ts->val_type == TEMP_VAL_DEAD); 17762c0366f0SAurelien Jarno #else 1777639368ddSAurelien Jarno temp_dead(s, i); 17782c0366f0SAurelien Jarno #endif 1779c896fe29Sbellard } 1780641d5fbeSbellard } 1781e8996ee0Sbellard 1782e8996ee0Sbellard save_globals(s, allocated_regs); 1783c896fe29Sbellard } 1784c896fe29Sbellard 1785866cb6cbSAurelien Jarno #define IS_DEAD_ARG(n) ((dead_args >> (n)) & 1) 1786ec7a869dSAurelien Jarno #define NEED_SYNC_ARG(n) ((sync_args >> (n)) & 1) 1787c896fe29Sbellard 1788ec7a869dSAurelien Jarno static void tcg_reg_alloc_movi(TCGContext *s, const TCGArg *args, 1789ec7a869dSAurelien Jarno uint16_t dead_args, uint8_t sync_args) 1790e8996ee0Sbellard { 1791e8996ee0Sbellard TCGTemp *ots; 1792e8996ee0Sbellard tcg_target_ulong val; 1793e8996ee0Sbellard 1794e8996ee0Sbellard ots = &s->temps[args[0]]; 1795e8996ee0Sbellard val = args[1]; 1796e8996ee0Sbellard 1797e8996ee0Sbellard if (ots->fixed_reg) { 1798e8996ee0Sbellard /* for fixed registers, we do not do any constant 1799e8996ee0Sbellard propagation */ 1800e8996ee0Sbellard tcg_out_movi(s, ots->type, ots->reg, val); 1801e8996ee0Sbellard } else { 18021235fc06Sths /* The movi is not explicitly generated here */ 1803e8996ee0Sbellard if (ots->val_type == TEMP_VAL_REG) 1804e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 1805e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 1806e8996ee0Sbellard ots->val = val; 1807e8996ee0Sbellard } 1808ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(0)) { 1809ec7a869dSAurelien Jarno temp_sync(s, args[0], s->reserved_regs); 1810ec7a869dSAurelien Jarno } 18114c4e1ab2SAurelien Jarno if (IS_DEAD_ARG(0)) { 18124c4e1ab2SAurelien Jarno temp_dead(s, args[0]); 18134c4e1ab2SAurelien Jarno } 1814e8996ee0Sbellard } 1815e8996ee0Sbellard 1816c896fe29Sbellard static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def, 1817ec7a869dSAurelien Jarno const TCGArg *args, uint16_t dead_args, 1818ec7a869dSAurelien Jarno uint8_t sync_args) 1819c896fe29Sbellard { 1820c29c1d7eSAurelien Jarno TCGRegSet allocated_regs; 1821c896fe29Sbellard TCGTemp *ts, *ots; 1822c29c1d7eSAurelien Jarno const TCGArgConstraint *arg_ct, *oarg_ct; 1823c896fe29Sbellard 1824c29c1d7eSAurelien Jarno tcg_regset_set(allocated_regs, s->reserved_regs); 1825c896fe29Sbellard ots = &s->temps[args[0]]; 1826c896fe29Sbellard ts = &s->temps[args[1]]; 1827c29c1d7eSAurelien Jarno oarg_ct = &def->args_ct[0]; 1828c29c1d7eSAurelien Jarno arg_ct = &def->args_ct[1]; 1829c896fe29Sbellard 1830c29c1d7eSAurelien Jarno /* If the source value is not in a register, and we're going to be 1831c29c1d7eSAurelien Jarno forced to have it in a register in order to perform the copy, 1832c29c1d7eSAurelien Jarno then copy the SOURCE value into its own register first. That way 1833c29c1d7eSAurelien Jarno we don't have to reload SOURCE the next time it is used. */ 1834c29c1d7eSAurelien Jarno if (((NEED_SYNC_ARG(0) || ots->fixed_reg) && ts->val_type != TEMP_VAL_REG) 1835c29c1d7eSAurelien Jarno || ts->val_type == TEMP_VAL_MEM) { 1836c29c1d7eSAurelien Jarno ts->reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1837c29c1d7eSAurelien Jarno if (ts->val_type == TEMP_VAL_MEM) { 1838c29c1d7eSAurelien Jarno tcg_out_ld(s, ts->type, ts->reg, ts->mem_reg, ts->mem_offset); 1839c29c1d7eSAurelien Jarno ts->mem_coherent = 1; 1840c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1841c29c1d7eSAurelien Jarno tcg_out_movi(s, ts->type, ts->reg, ts->val); 1842c29c1d7eSAurelien Jarno } 1843c29c1d7eSAurelien Jarno s->reg_to_temp[ts->reg] = args[1]; 1844c29c1d7eSAurelien Jarno ts->val_type = TEMP_VAL_REG; 1845c29c1d7eSAurelien Jarno } 1846c29c1d7eSAurelien Jarno 1847c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(0) && !ots->fixed_reg) { 1848c29c1d7eSAurelien Jarno /* mov to a non-saved dead register makes no sense (even with 1849c29c1d7eSAurelien Jarno liveness analysis disabled). */ 1850c29c1d7eSAurelien Jarno assert(NEED_SYNC_ARG(0)); 1851c29c1d7eSAurelien Jarno /* The code above should have moved the temp to a register. */ 1852c29c1d7eSAurelien Jarno assert(ts->val_type == TEMP_VAL_REG); 1853c29c1d7eSAurelien Jarno if (!ots->mem_allocated) { 1854c29c1d7eSAurelien Jarno temp_allocate_frame(s, args[0]); 1855c29c1d7eSAurelien Jarno } 1856c29c1d7eSAurelien Jarno tcg_out_st(s, ots->type, ts->reg, ots->mem_reg, ots->mem_offset); 1857c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(1)) { 1858c29c1d7eSAurelien Jarno temp_dead(s, args[1]); 1859c29c1d7eSAurelien Jarno } 1860c29c1d7eSAurelien Jarno temp_dead(s, args[0]); 1861c29c1d7eSAurelien Jarno } else if (ts->val_type == TEMP_VAL_CONST) { 1862e8996ee0Sbellard /* propagate constant */ 1863c29c1d7eSAurelien Jarno if (ots->val_type == TEMP_VAL_REG) { 1864e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 1865c29c1d7eSAurelien Jarno } 1866e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 1867e8996ee0Sbellard ots->val = ts->val; 1868e8996ee0Sbellard } else { 1869c29c1d7eSAurelien Jarno /* The code in the first if block should have moved the 1870c29c1d7eSAurelien Jarno temp to a register. */ 1871c29c1d7eSAurelien Jarno assert(ts->val_type == TEMP_VAL_REG); 1872c29c1d7eSAurelien Jarno if (IS_DEAD_ARG(1) && !ts->fixed_reg && !ots->fixed_reg) { 1873c29c1d7eSAurelien Jarno /* the mov can be suppressed */ 1874c29c1d7eSAurelien Jarno if (ots->val_type == TEMP_VAL_REG) { 1875c29c1d7eSAurelien Jarno s->reg_to_temp[ots->reg] = -1; 1876c896fe29Sbellard } 1877c29c1d7eSAurelien Jarno ots->reg = ts->reg; 1878c29c1d7eSAurelien Jarno temp_dead(s, args[1]); 1879c29c1d7eSAurelien Jarno } else { 1880c29c1d7eSAurelien Jarno if (ots->val_type != TEMP_VAL_REG) { 1881c29c1d7eSAurelien Jarno /* When allocating a new register, make sure to not spill the 1882c29c1d7eSAurelien Jarno input one. */ 1883c29c1d7eSAurelien Jarno tcg_regset_set_reg(allocated_regs, ts->reg); 1884c29c1d7eSAurelien Jarno ots->reg = tcg_reg_alloc(s, oarg_ct->u.regs, allocated_regs); 1885c29c1d7eSAurelien Jarno } 1886c29c1d7eSAurelien Jarno tcg_out_mov(s, ots->type, ots->reg, ts->reg); 1887c29c1d7eSAurelien Jarno } 1888c896fe29Sbellard ots->val_type = TEMP_VAL_REG; 1889c896fe29Sbellard ots->mem_coherent = 0; 1890c29c1d7eSAurelien Jarno s->reg_to_temp[ots->reg] = args[0]; 1891ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(0)) { 1892c29c1d7eSAurelien Jarno tcg_reg_sync(s, ots->reg); 1893c29c1d7eSAurelien Jarno } 1894ec7a869dSAurelien Jarno } 1895c896fe29Sbellard } 1896c896fe29Sbellard 1897c896fe29Sbellard static void tcg_reg_alloc_op(TCGContext *s, 1898a9751609SRichard Henderson const TCGOpDef *def, TCGOpcode opc, 1899ec7a869dSAurelien Jarno const TCGArg *args, uint16_t dead_args, 1900ec7a869dSAurelien Jarno uint8_t sync_args) 1901c896fe29Sbellard { 1902c896fe29Sbellard TCGRegSet allocated_regs; 1903c896fe29Sbellard int i, k, nb_iargs, nb_oargs, reg; 1904c896fe29Sbellard TCGArg arg; 1905c896fe29Sbellard const TCGArgConstraint *arg_ct; 1906c896fe29Sbellard TCGTemp *ts; 1907c896fe29Sbellard TCGArg new_args[TCG_MAX_OP_ARGS]; 1908c896fe29Sbellard int const_args[TCG_MAX_OP_ARGS]; 1909c896fe29Sbellard 1910c896fe29Sbellard nb_oargs = def->nb_oargs; 1911c896fe29Sbellard nb_iargs = def->nb_iargs; 1912c896fe29Sbellard 1913c896fe29Sbellard /* copy constants */ 1914c896fe29Sbellard memcpy(new_args + nb_oargs + nb_iargs, 1915c896fe29Sbellard args + nb_oargs + nb_iargs, 1916c896fe29Sbellard sizeof(TCGArg) * def->nb_cargs); 1917c896fe29Sbellard 1918c896fe29Sbellard /* satisfy input constraints */ 1919c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 1920c896fe29Sbellard for(k = 0; k < nb_iargs; k++) { 1921c896fe29Sbellard i = def->sorted_args[nb_oargs + k]; 1922c896fe29Sbellard arg = args[i]; 1923c896fe29Sbellard arg_ct = &def->args_ct[i]; 1924c896fe29Sbellard ts = &s->temps[arg]; 1925c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 1926c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1927e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1928c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 1929c896fe29Sbellard ts->reg = reg; 1930c896fe29Sbellard ts->mem_coherent = 1; 1931c896fe29Sbellard s->reg_to_temp[reg] = arg; 1932c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1933c896fe29Sbellard if (tcg_target_const_match(ts->val, arg_ct)) { 1934c896fe29Sbellard /* constant is OK for instruction */ 1935c896fe29Sbellard const_args[i] = 1; 1936c896fe29Sbellard new_args[i] = ts->val; 1937c896fe29Sbellard goto iarg_end; 1938c896fe29Sbellard } else { 1939c896fe29Sbellard /* need to move to a register */ 1940c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1941c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1942e8996ee0Sbellard ts->val_type = TEMP_VAL_REG; 1943e8996ee0Sbellard ts->reg = reg; 1944e8996ee0Sbellard ts->mem_coherent = 0; 1945e8996ee0Sbellard s->reg_to_temp[reg] = arg; 1946c896fe29Sbellard } 1947c896fe29Sbellard } 1948c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 19495ff9d6a4Sbellard if (arg_ct->ct & TCG_CT_IALIAS) { 19505ff9d6a4Sbellard if (ts->fixed_reg) { 19515ff9d6a4Sbellard /* if fixed register, we must allocate a new register 19525ff9d6a4Sbellard if the alias is not the same register */ 19535ff9d6a4Sbellard if (arg != args[arg_ct->alias_index]) 19545ff9d6a4Sbellard goto allocate_in_reg; 19555ff9d6a4Sbellard } else { 1956c896fe29Sbellard /* if the input is aliased to an output and if it is 1957c896fe29Sbellard not dead after the instruction, we must allocate 1958c896fe29Sbellard a new register and move it */ 1959866cb6cbSAurelien Jarno if (!IS_DEAD_ARG(i)) { 1960c896fe29Sbellard goto allocate_in_reg; 1961c896fe29Sbellard } 19625ff9d6a4Sbellard } 1963866cb6cbSAurelien Jarno } 1964c896fe29Sbellard reg = ts->reg; 1965c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1966c896fe29Sbellard /* nothing to do : the constraint is satisfied */ 1967c896fe29Sbellard } else { 1968c896fe29Sbellard allocate_in_reg: 1969c896fe29Sbellard /* allocate a new register matching the constraint 1970c896fe29Sbellard and move the temporary register into it */ 1971c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 19723b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 1973c896fe29Sbellard } 1974c896fe29Sbellard new_args[i] = reg; 1975c896fe29Sbellard const_args[i] = 0; 1976c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 1977c896fe29Sbellard iarg_end: ; 1978c896fe29Sbellard } 1979c896fe29Sbellard 1980c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 1981866cb6cbSAurelien Jarno for (i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 1982866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 1983639368ddSAurelien Jarno temp_dead(s, args[i]); 1984c896fe29Sbellard } 1985c896fe29Sbellard } 1986c896fe29Sbellard 1987a52ad07eSAurelien Jarno if (def->flags & TCG_OPF_BB_END) { 1988a52ad07eSAurelien Jarno tcg_reg_alloc_bb_end(s, allocated_regs); 1989a52ad07eSAurelien Jarno } else { 1990c896fe29Sbellard if (def->flags & TCG_OPF_CALL_CLOBBER) { 1991b03cce8eSbellard /* XXX: permit generic clobber register list ? */ 1992c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1993c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 1994c896fe29Sbellard tcg_reg_free(s, reg); 1995c896fe29Sbellard } 1996c896fe29Sbellard } 19973d5c5f87SAurelien Jarno } 19983d5c5f87SAurelien Jarno if (def->flags & TCG_OPF_SIDE_EFFECTS) { 19993d5c5f87SAurelien Jarno /* sync globals if the op has side effects and might trigger 20003d5c5f87SAurelien Jarno an exception. */ 20013d5c5f87SAurelien Jarno sync_globals(s, allocated_regs); 2002c896fe29Sbellard } 2003c896fe29Sbellard 2004c896fe29Sbellard /* satisfy the output constraints */ 2005c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 2006c896fe29Sbellard for(k = 0; k < nb_oargs; k++) { 2007c896fe29Sbellard i = def->sorted_args[k]; 2008c896fe29Sbellard arg = args[i]; 2009c896fe29Sbellard arg_ct = &def->args_ct[i]; 2010c896fe29Sbellard ts = &s->temps[arg]; 2011c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 20125ff9d6a4Sbellard reg = new_args[arg_ct->alias_index]; 2013c896fe29Sbellard } else { 2014c896fe29Sbellard /* if fixed register, we try to use it */ 2015c896fe29Sbellard reg = ts->reg; 2016c896fe29Sbellard if (ts->fixed_reg && 2017c896fe29Sbellard tcg_regset_test_reg(arg_ct->u.regs, reg)) { 2018c896fe29Sbellard goto oarg_end; 2019c896fe29Sbellard } 2020c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2021c896fe29Sbellard } 2022c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 2023c896fe29Sbellard /* if a fixed register is used, then a move will be done afterwards */ 2024c896fe29Sbellard if (!ts->fixed_reg) { 2025639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 2026639368ddSAurelien Jarno s->reg_to_temp[ts->reg] = -1; 2027639368ddSAurelien Jarno } 2028c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 2029c896fe29Sbellard ts->reg = reg; 2030c896fe29Sbellard /* temp value is modified, so the value kept in memory is 2031c896fe29Sbellard potentially not the same */ 2032c896fe29Sbellard ts->mem_coherent = 0; 2033c896fe29Sbellard s->reg_to_temp[reg] = arg; 2034c896fe29Sbellard } 2035c896fe29Sbellard oarg_end: 2036c896fe29Sbellard new_args[i] = reg; 2037c896fe29Sbellard } 2038e8996ee0Sbellard } 2039c896fe29Sbellard 2040c896fe29Sbellard /* emit instruction */ 2041c896fe29Sbellard tcg_out_op(s, opc, new_args, const_args); 2042c896fe29Sbellard 2043c896fe29Sbellard /* move the outputs in the correct register if needed */ 2044c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 2045c896fe29Sbellard ts = &s->temps[args[i]]; 2046c896fe29Sbellard reg = new_args[i]; 2047c896fe29Sbellard if (ts->fixed_reg && ts->reg != reg) { 20483b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 2049c896fe29Sbellard } 2050ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(i)) { 2051ec7a869dSAurelien Jarno tcg_reg_sync(s, reg); 2052ec7a869dSAurelien Jarno } 2053ec7a869dSAurelien Jarno if (IS_DEAD_ARG(i)) { 2054ec7a869dSAurelien Jarno temp_dead(s, args[i]); 2055ec7a869dSAurelien Jarno } 2056c896fe29Sbellard } 2057c896fe29Sbellard } 2058c896fe29Sbellard 2059b03cce8eSbellard #ifdef TCG_TARGET_STACK_GROWSUP 2060b03cce8eSbellard #define STACK_DIR(x) (-(x)) 2061b03cce8eSbellard #else 2062b03cce8eSbellard #define STACK_DIR(x) (x) 2063b03cce8eSbellard #endif 2064b03cce8eSbellard 2065c896fe29Sbellard static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def, 2066a9751609SRichard Henderson TCGOpcode opc, const TCGArg *args, 2067ec7a869dSAurelien Jarno uint16_t dead_args, uint8_t sync_args) 2068c896fe29Sbellard { 2069c896fe29Sbellard int nb_iargs, nb_oargs, flags, nb_regs, i, reg, nb_params; 2070c896fe29Sbellard TCGArg arg, func_arg; 2071c896fe29Sbellard TCGTemp *ts; 2072f54b3f92Saurel32 tcg_target_long stack_offset, call_stack_size, func_addr; 2073b03cce8eSbellard int const_func_arg, allocate_args; 2074c896fe29Sbellard TCGRegSet allocated_regs; 2075c896fe29Sbellard const TCGArgConstraint *arg_ct; 2076c896fe29Sbellard 2077c896fe29Sbellard arg = *args++; 2078c896fe29Sbellard 2079c896fe29Sbellard nb_oargs = arg >> 16; 2080c896fe29Sbellard nb_iargs = arg & 0xffff; 2081c896fe29Sbellard nb_params = nb_iargs - 1; 2082c896fe29Sbellard 2083c896fe29Sbellard flags = args[nb_oargs + nb_iargs]; 2084c896fe29Sbellard 20856e17d0c5SStefan Weil nb_regs = ARRAY_SIZE(tcg_target_call_iarg_regs); 2086c896fe29Sbellard if (nb_regs > nb_params) 2087c896fe29Sbellard nb_regs = nb_params; 2088c896fe29Sbellard 2089c896fe29Sbellard /* assign stack slots first */ 2090c896fe29Sbellard call_stack_size = (nb_params - nb_regs) * sizeof(tcg_target_long); 2091c896fe29Sbellard call_stack_size = (call_stack_size + TCG_TARGET_STACK_ALIGN - 1) & 2092c896fe29Sbellard ~(TCG_TARGET_STACK_ALIGN - 1); 2093b03cce8eSbellard allocate_args = (call_stack_size > TCG_STATIC_CALL_ARGS_SIZE); 2094b03cce8eSbellard if (allocate_args) { 2095345649c0SBlue Swirl /* XXX: if more than TCG_STATIC_CALL_ARGS_SIZE is needed, 2096345649c0SBlue Swirl preallocate call stack */ 2097345649c0SBlue Swirl tcg_abort(); 2098b03cce8eSbellard } 209939cf05d3Sbellard 210039cf05d3Sbellard stack_offset = TCG_TARGET_CALL_STACK_OFFSET; 2101c896fe29Sbellard for(i = nb_regs; i < nb_params; i++) { 2102c896fe29Sbellard arg = args[nb_oargs + i]; 210339cf05d3Sbellard #ifdef TCG_TARGET_STACK_GROWSUP 210439cf05d3Sbellard stack_offset -= sizeof(tcg_target_long); 210539cf05d3Sbellard #endif 210639cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 2107c896fe29Sbellard ts = &s->temps[arg]; 2108c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 2109e4d5434cSblueswir1 tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset); 2110c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 2111c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 2112c896fe29Sbellard s->reserved_regs); 2113c896fe29Sbellard /* XXX: not correct if reading values from the stack */ 2114e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2115e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 2116c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2117c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 2118c896fe29Sbellard s->reserved_regs); 2119c896fe29Sbellard /* XXX: sign extend may be needed on some targets */ 2120c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 2121e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 2122c896fe29Sbellard } else { 2123c896fe29Sbellard tcg_abort(); 2124c896fe29Sbellard } 212539cf05d3Sbellard } 212639cf05d3Sbellard #ifndef TCG_TARGET_STACK_GROWSUP 212739cf05d3Sbellard stack_offset += sizeof(tcg_target_long); 212839cf05d3Sbellard #endif 2129c896fe29Sbellard } 2130c896fe29Sbellard 2131c896fe29Sbellard /* assign input registers */ 2132c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 2133c896fe29Sbellard for(i = 0; i < nb_regs; i++) { 2134c896fe29Sbellard arg = args[nb_oargs + i]; 213539cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 2136c896fe29Sbellard ts = &s->temps[arg]; 2137c896fe29Sbellard reg = tcg_target_call_iarg_regs[i]; 2138c896fe29Sbellard tcg_reg_free(s, reg); 2139c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 2140c896fe29Sbellard if (ts->reg != reg) { 21413b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 2142c896fe29Sbellard } 2143c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 2144e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2145c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2146c896fe29Sbellard /* XXX: sign extend ? */ 2147c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 2148c896fe29Sbellard } else { 2149c896fe29Sbellard tcg_abort(); 2150c896fe29Sbellard } 2151c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 2152c896fe29Sbellard } 215339cf05d3Sbellard } 2154c896fe29Sbellard 2155c896fe29Sbellard /* assign function address */ 2156c896fe29Sbellard func_arg = args[nb_oargs + nb_iargs - 1]; 2157c896fe29Sbellard arg_ct = &def->args_ct[0]; 2158c896fe29Sbellard ts = &s->temps[func_arg]; 2159f54b3f92Saurel32 func_addr = ts->val; 2160c896fe29Sbellard const_func_arg = 0; 2161c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 2162c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2163e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 2164c896fe29Sbellard func_arg = reg; 2165e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 2166c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_REG) { 2167c896fe29Sbellard reg = ts->reg; 2168c896fe29Sbellard if (!tcg_regset_test_reg(arg_ct->u.regs, reg)) { 2169c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 21703b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 2171c896fe29Sbellard } 2172c896fe29Sbellard func_arg = reg; 2173e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 2174c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 2175f54b3f92Saurel32 if (tcg_target_const_match(func_addr, arg_ct)) { 2176c896fe29Sbellard const_func_arg = 1; 2177f54b3f92Saurel32 func_arg = func_addr; 2178c896fe29Sbellard } else { 2179c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 2180f54b3f92Saurel32 tcg_out_movi(s, ts->type, reg, func_addr); 2181c896fe29Sbellard func_arg = reg; 2182e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 2183c896fe29Sbellard } 2184c896fe29Sbellard } else { 2185c896fe29Sbellard tcg_abort(); 2186c896fe29Sbellard } 2187c896fe29Sbellard 2188e8996ee0Sbellard 2189c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 2190866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 2191866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 2192639368ddSAurelien Jarno temp_dead(s, args[i]); 2193c896fe29Sbellard } 2194c896fe29Sbellard } 2195c896fe29Sbellard 2196c896fe29Sbellard /* clobber call registers */ 2197c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 2198c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 2199c896fe29Sbellard tcg_reg_free(s, reg); 2200c896fe29Sbellard } 2201c896fe29Sbellard } 2202c896fe29Sbellard 220378505279SAurelien Jarno /* Save globals if they might be written by the helper, sync them if 220478505279SAurelien Jarno they might be read. */ 220578505279SAurelien Jarno if (flags & TCG_CALL_NO_READ_GLOBALS) { 220678505279SAurelien Jarno /* Nothing to do */ 220778505279SAurelien Jarno } else if (flags & TCG_CALL_NO_WRITE_GLOBALS) { 220878505279SAurelien Jarno sync_globals(s, allocated_regs); 220978505279SAurelien Jarno } else { 2210e8996ee0Sbellard save_globals(s, allocated_regs); 2211b9c18f56Saurel32 } 2212c896fe29Sbellard 2213c896fe29Sbellard tcg_out_op(s, opc, &func_arg, &const_func_arg); 2214c896fe29Sbellard 2215c896fe29Sbellard /* assign output registers and emit moves if needed */ 2216c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 2217c896fe29Sbellard arg = args[i]; 2218c896fe29Sbellard ts = &s->temps[arg]; 2219c896fe29Sbellard reg = tcg_target_call_oarg_regs[i]; 2220e8996ee0Sbellard assert(s->reg_to_temp[reg] == -1); 2221c896fe29Sbellard if (ts->fixed_reg) { 2222c896fe29Sbellard if (ts->reg != reg) { 22233b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 2224c896fe29Sbellard } 2225c896fe29Sbellard } else { 2226639368ddSAurelien Jarno if (ts->val_type == TEMP_VAL_REG) { 2227639368ddSAurelien Jarno s->reg_to_temp[ts->reg] = -1; 2228639368ddSAurelien Jarno } 2229c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 2230c896fe29Sbellard ts->reg = reg; 2231c896fe29Sbellard ts->mem_coherent = 0; 2232c896fe29Sbellard s->reg_to_temp[reg] = arg; 2233ec7a869dSAurelien Jarno if (NEED_SYNC_ARG(i)) { 2234ec7a869dSAurelien Jarno tcg_reg_sync(s, reg); 2235ec7a869dSAurelien Jarno } 2236ec7a869dSAurelien Jarno if (IS_DEAD_ARG(i)) { 2237ec7a869dSAurelien Jarno temp_dead(s, args[i]); 2238c896fe29Sbellard } 2239c896fe29Sbellard } 22408c11ad25SAurelien Jarno } 2241c896fe29Sbellard 2242c896fe29Sbellard return nb_iargs + nb_oargs + def->nb_cargs + 1; 2243c896fe29Sbellard } 2244c896fe29Sbellard 2245c896fe29Sbellard #ifdef CONFIG_PROFILER 2246c896fe29Sbellard 224754604f74Saurel32 static int64_t tcg_table_op_count[NB_OPS]; 2248c896fe29Sbellard 2249871e6c35SBlue Swirl static void dump_op_count(void) 2250c896fe29Sbellard { 2251c896fe29Sbellard int i; 2252c896fe29Sbellard FILE *f; 225354604f74Saurel32 f = fopen("/tmp/op.log", "w"); 2254c896fe29Sbellard for(i = INDEX_op_end; i < NB_OPS; i++) { 225554604f74Saurel32 fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, tcg_table_op_count[i]); 2256c896fe29Sbellard } 2257c896fe29Sbellard fclose(f); 2258c896fe29Sbellard } 2259c896fe29Sbellard #endif 2260c896fe29Sbellard 2261c896fe29Sbellard 2262c896fe29Sbellard static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf, 22632ba1eeb6Spbrook long search_pc) 2264c896fe29Sbellard { 2265a9751609SRichard Henderson TCGOpcode opc; 2266a9751609SRichard Henderson int op_index; 2267c896fe29Sbellard const TCGOpDef *def; 2268c896fe29Sbellard const TCGArg *args; 2269c896fe29Sbellard 2270c896fe29Sbellard #ifdef DEBUG_DISAS 22718fec2b8cSaliguori if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) { 227293fcfe39Saliguori qemu_log("OP:\n"); 2273eeacee4dSBlue Swirl tcg_dump_ops(s); 227493fcfe39Saliguori qemu_log("\n"); 2275c896fe29Sbellard } 2276c896fe29Sbellard #endif 2277c896fe29Sbellard 2278c5cc28ffSAurelien Jarno #ifdef CONFIG_PROFILER 2279c5cc28ffSAurelien Jarno s->opt_time -= profile_getclock(); 2280c5cc28ffSAurelien Jarno #endif 2281c5cc28ffSAurelien Jarno 22828f2e8c07SKirill Batuzov #ifdef USE_TCG_OPTIMIZATIONS 2283c4afe5c4SEvgeny Voevodin s->gen_opparam_ptr = 22841ff0a2c5SEvgeny Voevodin tcg_optimize(s, s->gen_opc_ptr, s->gen_opparam_buf, tcg_op_defs); 22858f2e8c07SKirill Batuzov #endif 22868f2e8c07SKirill Batuzov 2287a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2288c5cc28ffSAurelien Jarno s->opt_time += profile_getclock(); 2289a23a9ec6Sbellard s->la_time -= profile_getclock(); 2290a23a9ec6Sbellard #endif 2291c5cc28ffSAurelien Jarno 2292c896fe29Sbellard tcg_liveness_analysis(s); 2293c5cc28ffSAurelien Jarno 2294a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2295a23a9ec6Sbellard s->la_time += profile_getclock(); 2296a23a9ec6Sbellard #endif 2297c896fe29Sbellard 2298c896fe29Sbellard #ifdef DEBUG_DISAS 22998fec2b8cSaliguori if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT))) { 2300c5cc28ffSAurelien Jarno qemu_log("OP after optimization and liveness analysis:\n"); 2301eeacee4dSBlue Swirl tcg_dump_ops(s); 230293fcfe39Saliguori qemu_log("\n"); 2303c896fe29Sbellard } 2304c896fe29Sbellard #endif 2305c896fe29Sbellard 2306c896fe29Sbellard tcg_reg_alloc_start(s); 2307c896fe29Sbellard 2308c896fe29Sbellard s->code_buf = gen_code_buf; 2309c896fe29Sbellard s->code_ptr = gen_code_buf; 2310c896fe29Sbellard 23111ff0a2c5SEvgeny Voevodin args = s->gen_opparam_buf; 2312c896fe29Sbellard op_index = 0; 2313b3db8758Sblueswir1 2314c896fe29Sbellard for(;;) { 231592414b31SEvgeny Voevodin opc = s->gen_opc_buf[op_index]; 2316c896fe29Sbellard #ifdef CONFIG_PROFILER 231754604f74Saurel32 tcg_table_op_count[opc]++; 2318c896fe29Sbellard #endif 2319c896fe29Sbellard def = &tcg_op_defs[opc]; 2320c896fe29Sbellard #if 0 2321c896fe29Sbellard printf("%s: %d %d %d\n", def->name, 2322c896fe29Sbellard def->nb_oargs, def->nb_iargs, def->nb_cargs); 2323c896fe29Sbellard // dump_regs(s); 2324c896fe29Sbellard #endif 2325c896fe29Sbellard switch(opc) { 2326c896fe29Sbellard case INDEX_op_mov_i32: 2327c896fe29Sbellard case INDEX_op_mov_i64: 2328ec7a869dSAurelien Jarno tcg_reg_alloc_mov(s, def, args, s->op_dead_args[op_index], 2329ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2330c896fe29Sbellard break; 2331e8996ee0Sbellard case INDEX_op_movi_i32: 2332e8996ee0Sbellard case INDEX_op_movi_i64: 2333ec7a869dSAurelien Jarno tcg_reg_alloc_movi(s, args, s->op_dead_args[op_index], 2334ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2335e8996ee0Sbellard break; 23367e4597d7Sbellard case INDEX_op_debug_insn_start: 23377e4597d7Sbellard /* debug instruction */ 23387e4597d7Sbellard break; 2339c896fe29Sbellard case INDEX_op_nop: 2340c896fe29Sbellard case INDEX_op_nop1: 2341c896fe29Sbellard case INDEX_op_nop2: 2342c896fe29Sbellard case INDEX_op_nop3: 2343c896fe29Sbellard break; 2344c896fe29Sbellard case INDEX_op_nopn: 2345c896fe29Sbellard args += args[0]; 2346c896fe29Sbellard goto next; 23475ff9d6a4Sbellard case INDEX_op_discard: 2348639368ddSAurelien Jarno temp_dead(s, args[0]); 23495ff9d6a4Sbellard break; 2350c896fe29Sbellard case INDEX_op_set_label: 2351e8996ee0Sbellard tcg_reg_alloc_bb_end(s, s->reserved_regs); 23529d6fca70SStefan Weil tcg_out_label(s, args[0], s->code_ptr); 2353c896fe29Sbellard break; 2354c896fe29Sbellard case INDEX_op_call: 2355ec7a869dSAurelien Jarno args += tcg_reg_alloc_call(s, def, opc, args, 2356ec7a869dSAurelien Jarno s->op_dead_args[op_index], 2357ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2358c896fe29Sbellard goto next; 2359c896fe29Sbellard case INDEX_op_end: 2360c896fe29Sbellard goto the_end; 2361c896fe29Sbellard default: 236225c4d9ccSRichard Henderson /* Sanity check that we've not introduced any unhandled opcodes. */ 236325c4d9ccSRichard Henderson if (def->flags & TCG_OPF_NOT_PRESENT) { 236425c4d9ccSRichard Henderson tcg_abort(); 236525c4d9ccSRichard Henderson } 2366c896fe29Sbellard /* Note: in order to speed up the code, it would be much 2367c896fe29Sbellard faster to have specialized register allocator functions for 2368c896fe29Sbellard some common argument patterns */ 2369ec7a869dSAurelien Jarno tcg_reg_alloc_op(s, def, opc, args, s->op_dead_args[op_index], 2370ec7a869dSAurelien Jarno s->op_sync_args[op_index]); 2371c896fe29Sbellard break; 2372c896fe29Sbellard } 2373c896fe29Sbellard args += def->nb_args; 23748df1ca4bSths next: 23752ba1eeb6Spbrook if (search_pc >= 0 && search_pc < s->code_ptr - gen_code_buf) { 2376c896fe29Sbellard return op_index; 2377c896fe29Sbellard } 2378c896fe29Sbellard op_index++; 2379c896fe29Sbellard #ifndef NDEBUG 2380c896fe29Sbellard check_regs(s); 2381c896fe29Sbellard #endif 2382c896fe29Sbellard } 2383c896fe29Sbellard the_end: 2384b76f0d8cSYeongkyoon Lee #if defined(CONFIG_QEMU_LDST_OPTIMIZATION) && defined(CONFIG_SOFTMMU) 2385b76f0d8cSYeongkyoon Lee /* Generate TB finalization at the end of block */ 2386b76f0d8cSYeongkyoon Lee tcg_out_tb_finalize(s); 2387b76f0d8cSYeongkyoon Lee #endif 2388c896fe29Sbellard return -1; 2389c896fe29Sbellard } 2390c896fe29Sbellard 239154604f74Saurel32 int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf) 2392c896fe29Sbellard { 2393c896fe29Sbellard #ifdef CONFIG_PROFILER 2394c896fe29Sbellard { 2395c896fe29Sbellard int n; 239692414b31SEvgeny Voevodin n = (s->gen_opc_ptr - s->gen_opc_buf); 2397a23a9ec6Sbellard s->op_count += n; 2398a23a9ec6Sbellard if (n > s->op_count_max) 2399a23a9ec6Sbellard s->op_count_max = n; 2400a23a9ec6Sbellard 2401a23a9ec6Sbellard s->temp_count += s->nb_temps; 2402a23a9ec6Sbellard if (s->nb_temps > s->temp_count_max) 2403a23a9ec6Sbellard s->temp_count_max = s->nb_temps; 2404c896fe29Sbellard } 2405c896fe29Sbellard #endif 2406c896fe29Sbellard 24072ba1eeb6Spbrook tcg_gen_code_common(s, gen_code_buf, -1); 2408c896fe29Sbellard 2409c896fe29Sbellard /* flush instruction cache */ 2410b93949efSRichard Henderson flush_icache_range((uintptr_t)gen_code_buf, (uintptr_t)s->code_ptr); 24112aeabc08SStefan Weil 2412c896fe29Sbellard return s->code_ptr - gen_code_buf; 2413c896fe29Sbellard } 2414c896fe29Sbellard 24152ba1eeb6Spbrook /* Return the index of the micro operation such as the pc after is < 2416623e265cSpbrook offset bytes from the start of the TB. The contents of gen_code_buf must 2417623e265cSpbrook not be changed, though writing the same values is ok. 2418623e265cSpbrook Return -1 if not found. */ 241954604f74Saurel32 int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset) 2420c896fe29Sbellard { 2421623e265cSpbrook return tcg_gen_code_common(s, gen_code_buf, offset); 2422c896fe29Sbellard } 2423a23a9ec6Sbellard 2424a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2425405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2426a23a9ec6Sbellard { 2427a23a9ec6Sbellard TCGContext *s = &tcg_ctx; 2428a23a9ec6Sbellard int64_t tot; 2429a23a9ec6Sbellard 2430a23a9ec6Sbellard tot = s->interm_time + s->code_time; 2431a23a9ec6Sbellard cpu_fprintf(f, "JIT cycles %" PRId64 " (%0.3f s at 2.4 GHz)\n", 2432a23a9ec6Sbellard tot, tot / 2.4e9); 2433a23a9ec6Sbellard cpu_fprintf(f, "translated TBs %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n", 2434a23a9ec6Sbellard s->tb_count, 2435a23a9ec6Sbellard s->tb_count1 - s->tb_count, 2436a23a9ec6Sbellard s->tb_count1 ? (double)(s->tb_count1 - s->tb_count) / s->tb_count1 * 100.0 : 0); 2437a23a9ec6Sbellard cpu_fprintf(f, "avg ops/TB %0.1f max=%d\n", 2438a23a9ec6Sbellard s->tb_count ? (double)s->op_count / s->tb_count : 0, s->op_count_max); 2439a23a9ec6Sbellard cpu_fprintf(f, "deleted ops/TB %0.2f\n", 2440a23a9ec6Sbellard s->tb_count ? 2441a23a9ec6Sbellard (double)s->del_op_count / s->tb_count : 0); 2442a23a9ec6Sbellard cpu_fprintf(f, "avg temps/TB %0.2f max=%d\n", 2443a23a9ec6Sbellard s->tb_count ? 2444a23a9ec6Sbellard (double)s->temp_count / s->tb_count : 0, 2445a23a9ec6Sbellard s->temp_count_max); 2446a23a9ec6Sbellard 2447a23a9ec6Sbellard cpu_fprintf(f, "cycles/op %0.1f\n", 2448a23a9ec6Sbellard s->op_count ? (double)tot / s->op_count : 0); 2449a23a9ec6Sbellard cpu_fprintf(f, "cycles/in byte %0.1f\n", 2450a23a9ec6Sbellard s->code_in_len ? (double)tot / s->code_in_len : 0); 2451a23a9ec6Sbellard cpu_fprintf(f, "cycles/out byte %0.1f\n", 2452a23a9ec6Sbellard s->code_out_len ? (double)tot / s->code_out_len : 0); 2453a23a9ec6Sbellard if (tot == 0) 2454a23a9ec6Sbellard tot = 1; 2455a23a9ec6Sbellard cpu_fprintf(f, " gen_interm time %0.1f%%\n", 2456a23a9ec6Sbellard (double)s->interm_time / tot * 100.0); 2457a23a9ec6Sbellard cpu_fprintf(f, " gen_code time %0.1f%%\n", 2458a23a9ec6Sbellard (double)s->code_time / tot * 100.0); 2459c5cc28ffSAurelien Jarno cpu_fprintf(f, "optim./code time %0.1f%%\n", 2460c5cc28ffSAurelien Jarno (double)s->opt_time / (s->code_time ? s->code_time : 1) 2461c5cc28ffSAurelien Jarno * 100.0); 2462a23a9ec6Sbellard cpu_fprintf(f, "liveness/code time %0.1f%%\n", 2463a23a9ec6Sbellard (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0); 2464a23a9ec6Sbellard cpu_fprintf(f, "cpu_restore count %" PRId64 "\n", 2465a23a9ec6Sbellard s->restore_count); 2466a23a9ec6Sbellard cpu_fprintf(f, " avg cycles %0.1f\n", 2467a23a9ec6Sbellard s->restore_count ? (double)s->restore_time / s->restore_count : 0); 2468871e6c35SBlue Swirl 2469a23a9ec6Sbellard dump_op_count(); 2470a23a9ec6Sbellard } 2471a23a9ec6Sbellard #else 2472405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2473a23a9ec6Sbellard { 247424bf7b3aSbellard cpu_fprintf(f, "[TCG profiler not compiled]\n"); 2475a23a9ec6Sbellard } 2476a23a9ec6Sbellard #endif 2477813da627SRichard Henderson 2478813da627SRichard Henderson #ifdef ELF_HOST_MACHINE 24795872bbf2SRichard Henderson /* In order to use this feature, the backend needs to do three things: 24805872bbf2SRichard Henderson 24815872bbf2SRichard Henderson (1) Define ELF_HOST_MACHINE to indicate both what value to 24825872bbf2SRichard Henderson put into the ELF image and to indicate support for the feature. 24835872bbf2SRichard Henderson 24845872bbf2SRichard Henderson (2) Define tcg_register_jit. This should create a buffer containing 24855872bbf2SRichard Henderson the contents of a .debug_frame section that describes the post- 24865872bbf2SRichard Henderson prologue unwind info for the tcg machine. 24875872bbf2SRichard Henderson 24885872bbf2SRichard Henderson (3) Call tcg_register_jit_int, with the constructed .debug_frame. 24895872bbf2SRichard Henderson */ 2490813da627SRichard Henderson 2491813da627SRichard Henderson /* Begin GDB interface. THE FOLLOWING MUST MATCH GDB DOCS. */ 2492813da627SRichard Henderson typedef enum { 2493813da627SRichard Henderson JIT_NOACTION = 0, 2494813da627SRichard Henderson JIT_REGISTER_FN, 2495813da627SRichard Henderson JIT_UNREGISTER_FN 2496813da627SRichard Henderson } jit_actions_t; 2497813da627SRichard Henderson 2498813da627SRichard Henderson struct jit_code_entry { 2499813da627SRichard Henderson struct jit_code_entry *next_entry; 2500813da627SRichard Henderson struct jit_code_entry *prev_entry; 2501813da627SRichard Henderson const void *symfile_addr; 2502813da627SRichard Henderson uint64_t symfile_size; 2503813da627SRichard Henderson }; 2504813da627SRichard Henderson 2505813da627SRichard Henderson struct jit_descriptor { 2506813da627SRichard Henderson uint32_t version; 2507813da627SRichard Henderson uint32_t action_flag; 2508813da627SRichard Henderson struct jit_code_entry *relevant_entry; 2509813da627SRichard Henderson struct jit_code_entry *first_entry; 2510813da627SRichard Henderson }; 2511813da627SRichard Henderson 2512813da627SRichard Henderson void __jit_debug_register_code(void) __attribute__((noinline)); 2513813da627SRichard Henderson void __jit_debug_register_code(void) 2514813da627SRichard Henderson { 2515813da627SRichard Henderson asm(""); 2516813da627SRichard Henderson } 2517813da627SRichard Henderson 2518813da627SRichard Henderson /* Must statically initialize the version, because GDB may check 2519813da627SRichard Henderson the version before we can set it. */ 2520813da627SRichard Henderson struct jit_descriptor __jit_debug_descriptor = { 1, 0, 0, 0 }; 2521813da627SRichard Henderson 2522813da627SRichard Henderson /* End GDB interface. */ 2523813da627SRichard Henderson 2524813da627SRichard Henderson static int find_string(const char *strtab, const char *str) 2525813da627SRichard Henderson { 2526813da627SRichard Henderson const char *p = strtab + 1; 2527813da627SRichard Henderson 2528813da627SRichard Henderson while (1) { 2529813da627SRichard Henderson if (strcmp(p, str) == 0) { 2530813da627SRichard Henderson return p - strtab; 2531813da627SRichard Henderson } 2532813da627SRichard Henderson p += strlen(p) + 1; 2533813da627SRichard Henderson } 2534813da627SRichard Henderson } 2535813da627SRichard Henderson 25365872bbf2SRichard Henderson static void tcg_register_jit_int(void *buf_ptr, size_t buf_size, 2537813da627SRichard Henderson void *debug_frame, size_t debug_frame_size) 2538813da627SRichard Henderson { 25395872bbf2SRichard Henderson struct __attribute__((packed)) DebugInfo { 25405872bbf2SRichard Henderson uint32_t len; 25415872bbf2SRichard Henderson uint16_t version; 25425872bbf2SRichard Henderson uint32_t abbrev; 25435872bbf2SRichard Henderson uint8_t ptr_size; 25445872bbf2SRichard Henderson uint8_t cu_die; 25455872bbf2SRichard Henderson uint16_t cu_lang; 25465872bbf2SRichard Henderson uintptr_t cu_low_pc; 25475872bbf2SRichard Henderson uintptr_t cu_high_pc; 25485872bbf2SRichard Henderson uint8_t fn_die; 25495872bbf2SRichard Henderson char fn_name[16]; 25505872bbf2SRichard Henderson uintptr_t fn_low_pc; 25515872bbf2SRichard Henderson uintptr_t fn_high_pc; 25525872bbf2SRichard Henderson uint8_t cu_eoc; 25535872bbf2SRichard Henderson }; 2554813da627SRichard Henderson 2555813da627SRichard Henderson struct ElfImage { 2556813da627SRichard Henderson ElfW(Ehdr) ehdr; 2557813da627SRichard Henderson ElfW(Phdr) phdr; 25585872bbf2SRichard Henderson ElfW(Shdr) shdr[7]; 25595872bbf2SRichard Henderson ElfW(Sym) sym[2]; 25605872bbf2SRichard Henderson struct DebugInfo di; 25615872bbf2SRichard Henderson uint8_t da[24]; 25625872bbf2SRichard Henderson char str[80]; 25635872bbf2SRichard Henderson }; 25645872bbf2SRichard Henderson 25655872bbf2SRichard Henderson struct ElfImage *img; 25665872bbf2SRichard Henderson 25675872bbf2SRichard Henderson static const struct ElfImage img_template = { 25685872bbf2SRichard Henderson .ehdr = { 25695872bbf2SRichard Henderson .e_ident[EI_MAG0] = ELFMAG0, 25705872bbf2SRichard Henderson .e_ident[EI_MAG1] = ELFMAG1, 25715872bbf2SRichard Henderson .e_ident[EI_MAG2] = ELFMAG2, 25725872bbf2SRichard Henderson .e_ident[EI_MAG3] = ELFMAG3, 25735872bbf2SRichard Henderson .e_ident[EI_CLASS] = ELF_CLASS, 25745872bbf2SRichard Henderson .e_ident[EI_DATA] = ELF_DATA, 25755872bbf2SRichard Henderson .e_ident[EI_VERSION] = EV_CURRENT, 25765872bbf2SRichard Henderson .e_type = ET_EXEC, 25775872bbf2SRichard Henderson .e_machine = ELF_HOST_MACHINE, 25785872bbf2SRichard Henderson .e_version = EV_CURRENT, 25795872bbf2SRichard Henderson .e_phoff = offsetof(struct ElfImage, phdr), 25805872bbf2SRichard Henderson .e_shoff = offsetof(struct ElfImage, shdr), 25815872bbf2SRichard Henderson .e_ehsize = sizeof(ElfW(Shdr)), 25825872bbf2SRichard Henderson .e_phentsize = sizeof(ElfW(Phdr)), 25835872bbf2SRichard Henderson .e_phnum = 1, 25845872bbf2SRichard Henderson .e_shentsize = sizeof(ElfW(Shdr)), 25855872bbf2SRichard Henderson .e_shnum = ARRAY_SIZE(img->shdr), 25865872bbf2SRichard Henderson .e_shstrndx = ARRAY_SIZE(img->shdr) - 1, 2587abbb3eaeSRichard Henderson #ifdef ELF_HOST_FLAGS 2588abbb3eaeSRichard Henderson .e_flags = ELF_HOST_FLAGS, 2589abbb3eaeSRichard Henderson #endif 2590abbb3eaeSRichard Henderson #ifdef ELF_OSABI 2591abbb3eaeSRichard Henderson .e_ident[EI_OSABI] = ELF_OSABI, 2592abbb3eaeSRichard Henderson #endif 25935872bbf2SRichard Henderson }, 25945872bbf2SRichard Henderson .phdr = { 25955872bbf2SRichard Henderson .p_type = PT_LOAD, 25965872bbf2SRichard Henderson .p_flags = PF_X, 25975872bbf2SRichard Henderson }, 25985872bbf2SRichard Henderson .shdr = { 25995872bbf2SRichard Henderson [0] = { .sh_type = SHT_NULL }, 26005872bbf2SRichard Henderson /* Trick: The contents of code_gen_buffer are not present in 26015872bbf2SRichard Henderson this fake ELF file; that got allocated elsewhere. Therefore 26025872bbf2SRichard Henderson we mark .text as SHT_NOBITS (similar to .bss) so that readers 26035872bbf2SRichard Henderson will not look for contents. We can record any address. */ 26045872bbf2SRichard Henderson [1] = { /* .text */ 26055872bbf2SRichard Henderson .sh_type = SHT_NOBITS, 26065872bbf2SRichard Henderson .sh_flags = SHF_EXECINSTR | SHF_ALLOC, 26075872bbf2SRichard Henderson }, 26085872bbf2SRichard Henderson [2] = { /* .debug_info */ 26095872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 26105872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, di), 26115872bbf2SRichard Henderson .sh_size = sizeof(struct DebugInfo), 26125872bbf2SRichard Henderson }, 26135872bbf2SRichard Henderson [3] = { /* .debug_abbrev */ 26145872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 26155872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, da), 26165872bbf2SRichard Henderson .sh_size = sizeof(img->da), 26175872bbf2SRichard Henderson }, 26185872bbf2SRichard Henderson [4] = { /* .debug_frame */ 26195872bbf2SRichard Henderson .sh_type = SHT_PROGBITS, 26205872bbf2SRichard Henderson .sh_offset = sizeof(struct ElfImage), 26215872bbf2SRichard Henderson }, 26225872bbf2SRichard Henderson [5] = { /* .symtab */ 26235872bbf2SRichard Henderson .sh_type = SHT_SYMTAB, 26245872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, sym), 26255872bbf2SRichard Henderson .sh_size = sizeof(img->sym), 26265872bbf2SRichard Henderson .sh_info = 1, 26275872bbf2SRichard Henderson .sh_link = ARRAY_SIZE(img->shdr) - 1, 26285872bbf2SRichard Henderson .sh_entsize = sizeof(ElfW(Sym)), 26295872bbf2SRichard Henderson }, 26305872bbf2SRichard Henderson [6] = { /* .strtab */ 26315872bbf2SRichard Henderson .sh_type = SHT_STRTAB, 26325872bbf2SRichard Henderson .sh_offset = offsetof(struct ElfImage, str), 26335872bbf2SRichard Henderson .sh_size = sizeof(img->str), 26345872bbf2SRichard Henderson } 26355872bbf2SRichard Henderson }, 26365872bbf2SRichard Henderson .sym = { 26375872bbf2SRichard Henderson [1] = { /* code_gen_buffer */ 26385872bbf2SRichard Henderson .st_info = ELF_ST_INFO(STB_GLOBAL, STT_FUNC), 26395872bbf2SRichard Henderson .st_shndx = 1, 26405872bbf2SRichard Henderson } 26415872bbf2SRichard Henderson }, 26425872bbf2SRichard Henderson .di = { 26435872bbf2SRichard Henderson .len = sizeof(struct DebugInfo) - 4, 26445872bbf2SRichard Henderson .version = 2, 26455872bbf2SRichard Henderson .ptr_size = sizeof(void *), 26465872bbf2SRichard Henderson .cu_die = 1, 26475872bbf2SRichard Henderson .cu_lang = 0x8001, /* DW_LANG_Mips_Assembler */ 26485872bbf2SRichard Henderson .fn_die = 2, 26495872bbf2SRichard Henderson .fn_name = "code_gen_buffer" 26505872bbf2SRichard Henderson }, 26515872bbf2SRichard Henderson .da = { 26525872bbf2SRichard Henderson 1, /* abbrev number (the cu) */ 26535872bbf2SRichard Henderson 0x11, 1, /* DW_TAG_compile_unit, has children */ 26545872bbf2SRichard Henderson 0x13, 0x5, /* DW_AT_language, DW_FORM_data2 */ 26555872bbf2SRichard Henderson 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */ 26565872bbf2SRichard Henderson 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */ 26575872bbf2SRichard Henderson 0, 0, /* end of abbrev */ 26585872bbf2SRichard Henderson 2, /* abbrev number (the fn) */ 26595872bbf2SRichard Henderson 0x2e, 0, /* DW_TAG_subprogram, no children */ 26605872bbf2SRichard Henderson 0x3, 0x8, /* DW_AT_name, DW_FORM_string */ 26615872bbf2SRichard Henderson 0x11, 0x1, /* DW_AT_low_pc, DW_FORM_addr */ 26625872bbf2SRichard Henderson 0x12, 0x1, /* DW_AT_high_pc, DW_FORM_addr */ 26635872bbf2SRichard Henderson 0, 0, /* end of abbrev */ 26645872bbf2SRichard Henderson 0 /* no more abbrev */ 26655872bbf2SRichard Henderson }, 26665872bbf2SRichard Henderson .str = "\0" ".text\0" ".debug_info\0" ".debug_abbrev\0" 26675872bbf2SRichard Henderson ".debug_frame\0" ".symtab\0" ".strtab\0" "code_gen_buffer", 2668813da627SRichard Henderson }; 2669813da627SRichard Henderson 2670813da627SRichard Henderson /* We only need a single jit entry; statically allocate it. */ 2671813da627SRichard Henderson static struct jit_code_entry one_entry; 2672813da627SRichard Henderson 26735872bbf2SRichard Henderson uintptr_t buf = (uintptr_t)buf_ptr; 2674813da627SRichard Henderson size_t img_size = sizeof(struct ElfImage) + debug_frame_size; 2675813da627SRichard Henderson 26765872bbf2SRichard Henderson img = g_malloc(img_size); 26775872bbf2SRichard Henderson *img = img_template; 2678813da627SRichard Henderson memcpy(img + 1, debug_frame, debug_frame_size); 2679813da627SRichard Henderson 26805872bbf2SRichard Henderson img->phdr.p_vaddr = buf; 26815872bbf2SRichard Henderson img->phdr.p_paddr = buf; 26825872bbf2SRichard Henderson img->phdr.p_memsz = buf_size; 2683813da627SRichard Henderson 26845872bbf2SRichard Henderson img->shdr[1].sh_name = find_string(img->str, ".text"); 26855872bbf2SRichard Henderson img->shdr[1].sh_addr = buf; 26865872bbf2SRichard Henderson img->shdr[1].sh_size = buf_size; 2687813da627SRichard Henderson 26885872bbf2SRichard Henderson img->shdr[2].sh_name = find_string(img->str, ".debug_info"); 26895872bbf2SRichard Henderson img->shdr[3].sh_name = find_string(img->str, ".debug_abbrev"); 26905872bbf2SRichard Henderson 26915872bbf2SRichard Henderson img->shdr[4].sh_name = find_string(img->str, ".debug_frame"); 26925872bbf2SRichard Henderson img->shdr[4].sh_size = debug_frame_size; 26935872bbf2SRichard Henderson 26945872bbf2SRichard Henderson img->shdr[5].sh_name = find_string(img->str, ".symtab"); 26955872bbf2SRichard Henderson img->shdr[6].sh_name = find_string(img->str, ".strtab"); 26965872bbf2SRichard Henderson 26975872bbf2SRichard Henderson img->sym[1].st_name = find_string(img->str, "code_gen_buffer"); 26985872bbf2SRichard Henderson img->sym[1].st_value = buf; 26995872bbf2SRichard Henderson img->sym[1].st_size = buf_size; 27005872bbf2SRichard Henderson 27015872bbf2SRichard Henderson img->di.cu_low_pc = buf; 270245aba097SRichard Henderson img->di.cu_high_pc = buf + buf_size; 27035872bbf2SRichard Henderson img->di.fn_low_pc = buf; 270445aba097SRichard Henderson img->di.fn_high_pc = buf + buf_size; 2705813da627SRichard Henderson 2706813da627SRichard Henderson #ifdef DEBUG_JIT 2707813da627SRichard Henderson /* Enable this block to be able to debug the ELF image file creation. 2708813da627SRichard Henderson One can use readelf, objdump, or other inspection utilities. */ 2709813da627SRichard Henderson { 2710813da627SRichard Henderson FILE *f = fopen("/tmp/qemu.jit", "w+b"); 2711813da627SRichard Henderson if (f) { 27125872bbf2SRichard Henderson if (fwrite(img, img_size, 1, f) != img_size) { 2713813da627SRichard Henderson /* Avoid stupid unused return value warning for fwrite. */ 2714813da627SRichard Henderson } 2715813da627SRichard Henderson fclose(f); 2716813da627SRichard Henderson } 2717813da627SRichard Henderson } 2718813da627SRichard Henderson #endif 2719813da627SRichard Henderson 2720813da627SRichard Henderson one_entry.symfile_addr = img; 2721813da627SRichard Henderson one_entry.symfile_size = img_size; 2722813da627SRichard Henderson 2723813da627SRichard Henderson __jit_debug_descriptor.action_flag = JIT_REGISTER_FN; 2724813da627SRichard Henderson __jit_debug_descriptor.relevant_entry = &one_entry; 2725813da627SRichard Henderson __jit_debug_descriptor.first_entry = &one_entry; 2726813da627SRichard Henderson __jit_debug_register_code(); 2727813da627SRichard Henderson } 2728813da627SRichard Henderson #else 27295872bbf2SRichard Henderson /* No support for the feature. Provide the entry point expected by exec.c, 27305872bbf2SRichard Henderson and implement the internal function we declared earlier. */ 2731813da627SRichard Henderson 2732813da627SRichard Henderson static void tcg_register_jit_int(void *buf, size_t size, 2733813da627SRichard Henderson void *debug_frame, size_t debug_frame_size) 2734813da627SRichard Henderson { 2735813da627SRichard Henderson } 2736813da627SRichard Henderson 2737813da627SRichard Henderson void tcg_register_jit(void *buf, size_t buf_size) 2738813da627SRichard Henderson { 2739813da627SRichard Henderson } 2740813da627SRichard Henderson #endif /* ELF_HOST_MACHINE */ 2741