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 31a6c6f76cSBlue Swirl #if !defined(CONFIG_DEBUG_TCG) && !defined(NDEBUG) 32cca82982Saurel32 /* define it to suppress various consistency checks (faster) */ 33cca82982Saurel32 #define NDEBUG 34cca82982Saurel32 #endif 35cca82982Saurel32 36ca10f867Saurel32 #include "qemu-common.h" 37902b3d5cSmalc #include "cache-utils.h" 38379f6698SPaul Brook #include "host-utils.h" 392d8ebcf9SRichard Henderson #include "qemu-timer.h" 40c896fe29Sbellard 41c896fe29Sbellard /* Note: the long term plan is to reduce the dependancies on the QEMU 42c896fe29Sbellard CPU definitions. Currently they are used for qemu_ld/st 43c896fe29Sbellard instructions */ 44c896fe29Sbellard #define NO_CPU_IO_DEFS 45c896fe29Sbellard #include "cpu.h" 46c896fe29Sbellard 47c896fe29Sbellard #include "tcg-op.h" 48c896fe29Sbellard #include "elf.h" 49c896fe29Sbellard 50379f6698SPaul Brook #if defined(CONFIG_USE_GUEST_BASE) && !defined(TCG_TARGET_HAS_GUEST_BASE) 51379f6698SPaul Brook #error GUEST_BASE not supported on this host. 52379f6698SPaul Brook #endif 53c896fe29Sbellard 54c0ad3001SStefan Weil /* Forward declarations for functions declared in tcg-target.c and used here. */ 55e4d58b41SRichard Henderson static void tcg_target_init(TCGContext *s); 56e4d58b41SRichard Henderson static void tcg_target_qemu_prologue(TCGContext *s); 57c896fe29Sbellard static void patch_reloc(uint8_t *code_ptr, int type, 58f54b3f92Saurel32 tcg_target_long value, tcg_target_long addend); 59c896fe29Sbellard 60c0ad3001SStefan Weil /* Forward declarations for functions declared and used in tcg-target.c. */ 61c0ad3001SStefan Weil static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str); 622a534affSRichard Henderson static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1, 63c0ad3001SStefan Weil tcg_target_long arg2); 642a534affSRichard Henderson static void tcg_out_mov(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg); 65c0ad3001SStefan Weil static void tcg_out_movi(TCGContext *s, TCGType type, 662a534affSRichard Henderson TCGReg ret, tcg_target_long arg); 67c0ad3001SStefan Weil static void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args, 68c0ad3001SStefan Weil const int *const_args); 692a534affSRichard Henderson static void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1, 70c0ad3001SStefan Weil tcg_target_long arg2); 71c0ad3001SStefan Weil static int tcg_target_const_match(tcg_target_long val, 72c0ad3001SStefan Weil const TCGArgConstraint *arg_ct); 73c0ad3001SStefan Weil static int tcg_target_get_call_iarg_regs_count(int flags); 74c0ad3001SStefan Weil 758399ad59SRichard Henderson TCGOpDef tcg_op_defs[] = { 760e2029a0SAurelien Jarno #define DEF(s, oargs, iargs, cargs, flags) { #s, oargs, iargs, cargs, iargs + oargs + cargs, flags }, 77c896fe29Sbellard #include "tcg-opc.h" 78c896fe29Sbellard #undef DEF 79c896fe29Sbellard }; 802a24374aSStefan Weil const size_t tcg_op_defs_max = ARRAY_SIZE(tcg_op_defs); 81c896fe29Sbellard 82b1d8e52eSblueswir1 static TCGRegSet tcg_target_available_regs[2]; 83b1d8e52eSblueswir1 static TCGRegSet tcg_target_call_clobber_regs; 84c896fe29Sbellard 85c896fe29Sbellard /* XXX: move that inside the context */ 86c896fe29Sbellard uint16_t *gen_opc_ptr; 87c896fe29Sbellard TCGArg *gen_opparam_ptr; 88c896fe29Sbellard 89c896fe29Sbellard static inline void tcg_out8(TCGContext *s, uint8_t v) 90c896fe29Sbellard { 91c896fe29Sbellard *s->code_ptr++ = v; 92c896fe29Sbellard } 93c896fe29Sbellard 94c896fe29Sbellard static inline void tcg_out16(TCGContext *s, uint16_t v) 95c896fe29Sbellard { 96c896fe29Sbellard *(uint16_t *)s->code_ptr = v; 97c896fe29Sbellard s->code_ptr += 2; 98c896fe29Sbellard } 99c896fe29Sbellard 100c896fe29Sbellard static inline void tcg_out32(TCGContext *s, uint32_t v) 101c896fe29Sbellard { 102c896fe29Sbellard *(uint32_t *)s->code_ptr = v; 103c896fe29Sbellard s->code_ptr += 4; 104c896fe29Sbellard } 105c896fe29Sbellard 106c896fe29Sbellard /* label relocation processing */ 107c896fe29Sbellard 108a5ad5916SStefan Weil static void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type, 109c896fe29Sbellard int label_index, long addend) 110c896fe29Sbellard { 111c896fe29Sbellard TCGLabel *l; 112c896fe29Sbellard TCGRelocation *r; 113c896fe29Sbellard 114c896fe29Sbellard l = &s->labels[label_index]; 115c896fe29Sbellard if (l->has_value) { 116623e265cSpbrook /* FIXME: This may break relocations on RISC targets that 117623e265cSpbrook modify instruction fields in place. The caller may not have 118623e265cSpbrook written the initial value. */ 119f54b3f92Saurel32 patch_reloc(code_ptr, type, l->u.value, addend); 120c896fe29Sbellard } else { 121c896fe29Sbellard /* add a new relocation entry */ 122c896fe29Sbellard r = tcg_malloc(sizeof(TCGRelocation)); 123c896fe29Sbellard r->type = type; 124c896fe29Sbellard r->ptr = code_ptr; 125c896fe29Sbellard r->addend = addend; 126c896fe29Sbellard r->next = l->u.first_reloc; 127c896fe29Sbellard l->u.first_reloc = r; 128c896fe29Sbellard } 129c896fe29Sbellard } 130c896fe29Sbellard 131*9d6fca70SStefan Weil static void tcg_out_label(TCGContext *s, int label_index, void *ptr) 132c896fe29Sbellard { 133c896fe29Sbellard TCGLabel *l; 134c896fe29Sbellard TCGRelocation *r; 135*9d6fca70SStefan Weil tcg_target_long value = (tcg_target_long)ptr; 136c896fe29Sbellard 137c896fe29Sbellard l = &s->labels[label_index]; 138c896fe29Sbellard if (l->has_value) 139c896fe29Sbellard tcg_abort(); 140c896fe29Sbellard r = l->u.first_reloc; 141c896fe29Sbellard while (r != NULL) { 142f54b3f92Saurel32 patch_reloc(r->ptr, r->type, value, r->addend); 143c896fe29Sbellard r = r->next; 144c896fe29Sbellard } 145c896fe29Sbellard l->has_value = 1; 146c896fe29Sbellard l->u.value = value; 147c896fe29Sbellard } 148c896fe29Sbellard 149c896fe29Sbellard int gen_new_label(void) 150c896fe29Sbellard { 151c896fe29Sbellard TCGContext *s = &tcg_ctx; 152c896fe29Sbellard int idx; 153c896fe29Sbellard TCGLabel *l; 154c896fe29Sbellard 155c896fe29Sbellard if (s->nb_labels >= TCG_MAX_LABELS) 156c896fe29Sbellard tcg_abort(); 157c896fe29Sbellard idx = s->nb_labels++; 158c896fe29Sbellard l = &s->labels[idx]; 159c896fe29Sbellard l->has_value = 0; 160c896fe29Sbellard l->u.first_reloc = NULL; 161c896fe29Sbellard return idx; 162c896fe29Sbellard } 163c896fe29Sbellard 164c896fe29Sbellard #include "tcg-target.c" 165c896fe29Sbellard 166c896fe29Sbellard /* pool based memory allocation */ 167c896fe29Sbellard void *tcg_malloc_internal(TCGContext *s, int size) 168c896fe29Sbellard { 169c896fe29Sbellard TCGPool *p; 170c896fe29Sbellard int pool_size; 171c896fe29Sbellard 172c896fe29Sbellard if (size > TCG_POOL_CHUNK_SIZE) { 173c896fe29Sbellard /* big malloc: insert a new pool (XXX: could optimize) */ 1747267c094SAnthony Liguori p = g_malloc(sizeof(TCGPool) + size); 175c896fe29Sbellard p->size = size; 176c896fe29Sbellard if (s->pool_current) 177c896fe29Sbellard s->pool_current->next = p; 178c896fe29Sbellard else 179c896fe29Sbellard s->pool_first = p; 180c896fe29Sbellard p->next = s->pool_current; 181c896fe29Sbellard } else { 182c896fe29Sbellard p = s->pool_current; 183c896fe29Sbellard if (!p) { 184c896fe29Sbellard p = s->pool_first; 185c896fe29Sbellard if (!p) 186c896fe29Sbellard goto new_pool; 187c896fe29Sbellard } else { 188c896fe29Sbellard if (!p->next) { 189c896fe29Sbellard new_pool: 190c896fe29Sbellard pool_size = TCG_POOL_CHUNK_SIZE; 1917267c094SAnthony Liguori p = g_malloc(sizeof(TCGPool) + pool_size); 192c896fe29Sbellard p->size = pool_size; 193c896fe29Sbellard p->next = NULL; 194c896fe29Sbellard if (s->pool_current) 195c896fe29Sbellard s->pool_current->next = p; 196c896fe29Sbellard else 197c896fe29Sbellard s->pool_first = p; 198c896fe29Sbellard } else { 199c896fe29Sbellard p = p->next; 200c896fe29Sbellard } 201c896fe29Sbellard } 202c896fe29Sbellard } 203c896fe29Sbellard s->pool_current = p; 204c896fe29Sbellard s->pool_cur = p->data + size; 205c896fe29Sbellard s->pool_end = p->data + p->size; 206c896fe29Sbellard return p->data; 207c896fe29Sbellard } 208c896fe29Sbellard 209c896fe29Sbellard void tcg_pool_reset(TCGContext *s) 210c896fe29Sbellard { 211c896fe29Sbellard s->pool_cur = s->pool_end = NULL; 212c896fe29Sbellard s->pool_current = NULL; 213c896fe29Sbellard } 214c896fe29Sbellard 215c896fe29Sbellard void tcg_context_init(TCGContext *s) 216c896fe29Sbellard { 217c896fe29Sbellard int op, total_args, n; 218c896fe29Sbellard TCGOpDef *def; 219c896fe29Sbellard TCGArgConstraint *args_ct; 220c896fe29Sbellard int *sorted_args; 221c896fe29Sbellard 222c896fe29Sbellard memset(s, 0, sizeof(*s)); 223c896fe29Sbellard s->temps = s->static_temps; 224c896fe29Sbellard s->nb_globals = 0; 225c896fe29Sbellard 226c896fe29Sbellard /* Count total number of arguments and allocate the corresponding 227c896fe29Sbellard space */ 228c896fe29Sbellard total_args = 0; 229c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 230c896fe29Sbellard def = &tcg_op_defs[op]; 231c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 232c896fe29Sbellard total_args += n; 233c896fe29Sbellard } 234c896fe29Sbellard 2357267c094SAnthony Liguori args_ct = g_malloc(sizeof(TCGArgConstraint) * total_args); 2367267c094SAnthony Liguori sorted_args = g_malloc(sizeof(int) * total_args); 237c896fe29Sbellard 238c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 239c896fe29Sbellard def = &tcg_op_defs[op]; 240c896fe29Sbellard def->args_ct = args_ct; 241c896fe29Sbellard def->sorted_args = sorted_args; 242c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 243c896fe29Sbellard sorted_args += n; 244c896fe29Sbellard args_ct += n; 245c896fe29Sbellard } 246c896fe29Sbellard 247c896fe29Sbellard tcg_target_init(s); 2489002ec79SRichard Henderson } 249b03cce8eSbellard 2509002ec79SRichard Henderson void tcg_prologue_init(TCGContext *s) 2519002ec79SRichard Henderson { 252b03cce8eSbellard /* init global prologue and epilogue */ 253b03cce8eSbellard s->code_buf = code_gen_prologue; 254b03cce8eSbellard s->code_ptr = s->code_buf; 255b03cce8eSbellard tcg_target_qemu_prologue(s); 2562aeabc08SStefan Weil flush_icache_range((tcg_target_ulong)s->code_buf, 2572aeabc08SStefan Weil (tcg_target_ulong)s->code_ptr); 258c896fe29Sbellard } 259c896fe29Sbellard 260c896fe29Sbellard void tcg_set_frame(TCGContext *s, int reg, 261c896fe29Sbellard tcg_target_long start, tcg_target_long size) 262c896fe29Sbellard { 263c896fe29Sbellard s->frame_start = start; 264c896fe29Sbellard s->frame_end = start + size; 265c896fe29Sbellard s->frame_reg = reg; 266c896fe29Sbellard } 267c896fe29Sbellard 268c896fe29Sbellard void tcg_func_start(TCGContext *s) 269c896fe29Sbellard { 270e8996ee0Sbellard int i; 271c896fe29Sbellard tcg_pool_reset(s); 272c896fe29Sbellard s->nb_temps = s->nb_globals; 273641d5fbeSbellard for(i = 0; i < (TCG_TYPE_COUNT * 2); i++) 274e8996ee0Sbellard s->first_free_temp[i] = -1; 275c896fe29Sbellard s->labels = tcg_malloc(sizeof(TCGLabel) * TCG_MAX_LABELS); 276c896fe29Sbellard s->nb_labels = 0; 277c896fe29Sbellard s->current_frame_offset = s->frame_start; 278c896fe29Sbellard 279c896fe29Sbellard gen_opc_ptr = gen_opc_buf; 280c896fe29Sbellard gen_opparam_ptr = gen_opparam_buf; 281c896fe29Sbellard } 282c896fe29Sbellard 283c896fe29Sbellard static inline void tcg_temp_alloc(TCGContext *s, int n) 284c896fe29Sbellard { 285c896fe29Sbellard if (n > TCG_MAX_TEMPS) 286c896fe29Sbellard tcg_abort(); 287c896fe29Sbellard } 288c896fe29Sbellard 289a7812ae4Spbrook static inline int tcg_global_reg_new_internal(TCGType type, int reg, 290a7812ae4Spbrook const char *name) 291c896fe29Sbellard { 292c896fe29Sbellard TCGContext *s = &tcg_ctx; 293c896fe29Sbellard TCGTemp *ts; 294c896fe29Sbellard int idx; 295c896fe29Sbellard 296c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 297c896fe29Sbellard if (type != TCG_TYPE_I32) 298c896fe29Sbellard tcg_abort(); 299c896fe29Sbellard #endif 300c896fe29Sbellard if (tcg_regset_test_reg(s->reserved_regs, reg)) 301c896fe29Sbellard tcg_abort(); 302c896fe29Sbellard idx = s->nb_globals; 303c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 304c896fe29Sbellard ts = &s->temps[s->nb_globals]; 305c896fe29Sbellard ts->base_type = type; 306c896fe29Sbellard ts->type = type; 307c896fe29Sbellard ts->fixed_reg = 1; 308c896fe29Sbellard ts->reg = reg; 309c896fe29Sbellard ts->name = name; 310c896fe29Sbellard s->nb_globals++; 311c896fe29Sbellard tcg_regset_set_reg(s->reserved_regs, reg); 312a7812ae4Spbrook return idx; 313a7812ae4Spbrook } 314a7812ae4Spbrook 315a7812ae4Spbrook TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name) 316a7812ae4Spbrook { 317a7812ae4Spbrook int idx; 318a7812ae4Spbrook 319a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name); 320a7812ae4Spbrook return MAKE_TCGV_I32(idx); 321a7812ae4Spbrook } 322a7812ae4Spbrook 323a7812ae4Spbrook TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name) 324a7812ae4Spbrook { 325a7812ae4Spbrook int idx; 326a7812ae4Spbrook 327a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I64, reg, name); 328a7812ae4Spbrook return MAKE_TCGV_I64(idx); 329c896fe29Sbellard } 330c896fe29Sbellard 331a7812ae4Spbrook static inline int tcg_global_mem_new_internal(TCGType type, int reg, 332a7812ae4Spbrook tcg_target_long offset, 333c896fe29Sbellard const char *name) 334c896fe29Sbellard { 335c896fe29Sbellard TCGContext *s = &tcg_ctx; 336c896fe29Sbellard TCGTemp *ts; 337c896fe29Sbellard int idx; 338c896fe29Sbellard 339c896fe29Sbellard idx = s->nb_globals; 340c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 341c896fe29Sbellard if (type == TCG_TYPE_I64) { 342c896fe29Sbellard char buf[64]; 343c588979bSths tcg_temp_alloc(s, s->nb_globals + 2); 344c896fe29Sbellard ts = &s->temps[s->nb_globals]; 345c896fe29Sbellard ts->base_type = type; 346c896fe29Sbellard ts->type = TCG_TYPE_I32; 347c896fe29Sbellard ts->fixed_reg = 0; 348c896fe29Sbellard ts->mem_allocated = 1; 349c896fe29Sbellard ts->mem_reg = reg; 350c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 351c896fe29Sbellard ts->mem_offset = offset + 4; 352c896fe29Sbellard #else 353c896fe29Sbellard ts->mem_offset = offset; 354c896fe29Sbellard #endif 355c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 356c896fe29Sbellard pstrcat(buf, sizeof(buf), "_0"); 357c896fe29Sbellard ts->name = strdup(buf); 358c896fe29Sbellard ts++; 359c896fe29Sbellard 360c896fe29Sbellard ts->base_type = type; 361c896fe29Sbellard ts->type = TCG_TYPE_I32; 362c896fe29Sbellard ts->fixed_reg = 0; 363c896fe29Sbellard ts->mem_allocated = 1; 364c896fe29Sbellard ts->mem_reg = reg; 365c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 366c896fe29Sbellard ts->mem_offset = offset; 367c896fe29Sbellard #else 368c896fe29Sbellard ts->mem_offset = offset + 4; 369c896fe29Sbellard #endif 370c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 371c896fe29Sbellard pstrcat(buf, sizeof(buf), "_1"); 372c896fe29Sbellard ts->name = strdup(buf); 373c896fe29Sbellard 374c896fe29Sbellard s->nb_globals += 2; 375c896fe29Sbellard } else 376c896fe29Sbellard #endif 377c896fe29Sbellard { 378c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 379c896fe29Sbellard ts = &s->temps[s->nb_globals]; 380c896fe29Sbellard ts->base_type = type; 381c896fe29Sbellard ts->type = type; 382c896fe29Sbellard ts->fixed_reg = 0; 383c896fe29Sbellard ts->mem_allocated = 1; 384c896fe29Sbellard ts->mem_reg = reg; 385c896fe29Sbellard ts->mem_offset = offset; 386c896fe29Sbellard ts->name = name; 387c896fe29Sbellard s->nb_globals++; 388c896fe29Sbellard } 389a7812ae4Spbrook return idx; 390c896fe29Sbellard } 391c896fe29Sbellard 392a7812ae4Spbrook TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset, 393a7812ae4Spbrook const char *name) 394a7812ae4Spbrook { 395a7812ae4Spbrook int idx; 396a7812ae4Spbrook 397a7812ae4Spbrook idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name); 398a7812ae4Spbrook return MAKE_TCGV_I32(idx); 399a7812ae4Spbrook } 400a7812ae4Spbrook 401a7812ae4Spbrook TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset, 402a7812ae4Spbrook const char *name) 403a7812ae4Spbrook { 404a7812ae4Spbrook int idx; 405a7812ae4Spbrook 406a7812ae4Spbrook idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name); 407a7812ae4Spbrook return MAKE_TCGV_I64(idx); 408a7812ae4Spbrook } 409a7812ae4Spbrook 410a7812ae4Spbrook static inline int tcg_temp_new_internal(TCGType type, int temp_local) 411c896fe29Sbellard { 412c896fe29Sbellard TCGContext *s = &tcg_ctx; 413c896fe29Sbellard TCGTemp *ts; 414641d5fbeSbellard int idx, k; 415c896fe29Sbellard 416641d5fbeSbellard k = type; 417641d5fbeSbellard if (temp_local) 418641d5fbeSbellard k += TCG_TYPE_COUNT; 419641d5fbeSbellard idx = s->first_free_temp[k]; 420e8996ee0Sbellard if (idx != -1) { 421e8996ee0Sbellard /* There is already an available temp with the 422e8996ee0Sbellard right type */ 423e8996ee0Sbellard ts = &s->temps[idx]; 424641d5fbeSbellard s->first_free_temp[k] = ts->next_free_temp; 425e8996ee0Sbellard ts->temp_allocated = 1; 426641d5fbeSbellard assert(ts->temp_local == temp_local); 427e8996ee0Sbellard } else { 428c896fe29Sbellard idx = s->nb_temps; 429c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 430c896fe29Sbellard if (type == TCG_TYPE_I64) { 4318df1ca4bSths tcg_temp_alloc(s, s->nb_temps + 2); 432c896fe29Sbellard ts = &s->temps[s->nb_temps]; 433c896fe29Sbellard ts->base_type = type; 434c896fe29Sbellard ts->type = TCG_TYPE_I32; 435e8996ee0Sbellard ts->temp_allocated = 1; 436641d5fbeSbellard ts->temp_local = temp_local; 437c896fe29Sbellard ts->name = NULL; 438c896fe29Sbellard ts++; 439c896fe29Sbellard ts->base_type = TCG_TYPE_I32; 440c896fe29Sbellard ts->type = TCG_TYPE_I32; 441e8996ee0Sbellard ts->temp_allocated = 1; 442641d5fbeSbellard ts->temp_local = temp_local; 443c896fe29Sbellard ts->name = NULL; 444c896fe29Sbellard s->nb_temps += 2; 445c896fe29Sbellard } else 446c896fe29Sbellard #endif 447c896fe29Sbellard { 448c896fe29Sbellard tcg_temp_alloc(s, s->nb_temps + 1); 449c896fe29Sbellard ts = &s->temps[s->nb_temps]; 450c896fe29Sbellard ts->base_type = type; 451c896fe29Sbellard ts->type = type; 452e8996ee0Sbellard ts->temp_allocated = 1; 453641d5fbeSbellard ts->temp_local = temp_local; 454c896fe29Sbellard ts->name = NULL; 455c896fe29Sbellard s->nb_temps++; 456c896fe29Sbellard } 457e8996ee0Sbellard } 45827bfd83cSPeter Maydell 45927bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 46027bfd83cSPeter Maydell s->temps_in_use++; 46127bfd83cSPeter Maydell #endif 462a7812ae4Spbrook return idx; 463c896fe29Sbellard } 464c896fe29Sbellard 465a7812ae4Spbrook TCGv_i32 tcg_temp_new_internal_i32(int temp_local) 466a7812ae4Spbrook { 467a7812ae4Spbrook int idx; 468a7812ae4Spbrook 469a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I32, temp_local); 470a7812ae4Spbrook return MAKE_TCGV_I32(idx); 471a7812ae4Spbrook } 472a7812ae4Spbrook 473a7812ae4Spbrook TCGv_i64 tcg_temp_new_internal_i64(int temp_local) 474a7812ae4Spbrook { 475a7812ae4Spbrook int idx; 476a7812ae4Spbrook 477a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I64, temp_local); 478a7812ae4Spbrook return MAKE_TCGV_I64(idx); 479a7812ae4Spbrook } 480a7812ae4Spbrook 481a7812ae4Spbrook static inline void tcg_temp_free_internal(int idx) 482c896fe29Sbellard { 483c896fe29Sbellard TCGContext *s = &tcg_ctx; 484c896fe29Sbellard TCGTemp *ts; 485641d5fbeSbellard int k; 486c896fe29Sbellard 48727bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 48827bfd83cSPeter Maydell s->temps_in_use--; 48927bfd83cSPeter Maydell if (s->temps_in_use < 0) { 49027bfd83cSPeter Maydell fprintf(stderr, "More temporaries freed than allocated!\n"); 49127bfd83cSPeter Maydell } 49227bfd83cSPeter Maydell #endif 49327bfd83cSPeter Maydell 494e8996ee0Sbellard assert(idx >= s->nb_globals && idx < s->nb_temps); 495c896fe29Sbellard ts = &s->temps[idx]; 496e8996ee0Sbellard assert(ts->temp_allocated != 0); 497e8996ee0Sbellard ts->temp_allocated = 0; 498641d5fbeSbellard k = ts->base_type; 499641d5fbeSbellard if (ts->temp_local) 500641d5fbeSbellard k += TCG_TYPE_COUNT; 501641d5fbeSbellard ts->next_free_temp = s->first_free_temp[k]; 502641d5fbeSbellard s->first_free_temp[k] = idx; 503e8996ee0Sbellard } 504e8996ee0Sbellard 505a7812ae4Spbrook void tcg_temp_free_i32(TCGv_i32 arg) 506e8996ee0Sbellard { 507a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I32(arg)); 508a7812ae4Spbrook } 509a7812ae4Spbrook 510a7812ae4Spbrook void tcg_temp_free_i64(TCGv_i64 arg) 511a7812ae4Spbrook { 512a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I64(arg)); 513a7812ae4Spbrook } 514a7812ae4Spbrook 515a7812ae4Spbrook TCGv_i32 tcg_const_i32(int32_t val) 516a7812ae4Spbrook { 517a7812ae4Spbrook TCGv_i32 t0; 518a7812ae4Spbrook t0 = tcg_temp_new_i32(); 519e8996ee0Sbellard tcg_gen_movi_i32(t0, val); 520e8996ee0Sbellard return t0; 521c896fe29Sbellard } 522c896fe29Sbellard 523a7812ae4Spbrook TCGv_i64 tcg_const_i64(int64_t val) 524c896fe29Sbellard { 525a7812ae4Spbrook TCGv_i64 t0; 526a7812ae4Spbrook t0 = tcg_temp_new_i64(); 527e8996ee0Sbellard tcg_gen_movi_i64(t0, val); 528e8996ee0Sbellard return t0; 529c896fe29Sbellard } 530c896fe29Sbellard 531a7812ae4Spbrook TCGv_i32 tcg_const_local_i32(int32_t val) 532bdffd4a9Saurel32 { 533a7812ae4Spbrook TCGv_i32 t0; 534a7812ae4Spbrook t0 = tcg_temp_local_new_i32(); 535bdffd4a9Saurel32 tcg_gen_movi_i32(t0, val); 536bdffd4a9Saurel32 return t0; 537bdffd4a9Saurel32 } 538bdffd4a9Saurel32 539a7812ae4Spbrook TCGv_i64 tcg_const_local_i64(int64_t val) 540bdffd4a9Saurel32 { 541a7812ae4Spbrook TCGv_i64 t0; 542a7812ae4Spbrook t0 = tcg_temp_local_new_i64(); 543bdffd4a9Saurel32 tcg_gen_movi_i64(t0, val); 544bdffd4a9Saurel32 return t0; 545bdffd4a9Saurel32 } 546bdffd4a9Saurel32 54727bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 54827bfd83cSPeter Maydell void tcg_clear_temp_count(void) 54927bfd83cSPeter Maydell { 55027bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 55127bfd83cSPeter Maydell s->temps_in_use = 0; 55227bfd83cSPeter Maydell } 55327bfd83cSPeter Maydell 55427bfd83cSPeter Maydell int tcg_check_temp_count(void) 55527bfd83cSPeter Maydell { 55627bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 55727bfd83cSPeter Maydell if (s->temps_in_use) { 55827bfd83cSPeter Maydell /* Clear the count so that we don't give another 55927bfd83cSPeter Maydell * warning immediately next time around. 56027bfd83cSPeter Maydell */ 56127bfd83cSPeter Maydell s->temps_in_use = 0; 56227bfd83cSPeter Maydell return 1; 56327bfd83cSPeter Maydell } 56427bfd83cSPeter Maydell return 0; 56527bfd83cSPeter Maydell } 56627bfd83cSPeter Maydell #endif 56727bfd83cSPeter Maydell 568c896fe29Sbellard void tcg_register_helper(void *func, const char *name) 569c896fe29Sbellard { 570c896fe29Sbellard TCGContext *s = &tcg_ctx; 571c896fe29Sbellard int n; 572c896fe29Sbellard if ((s->nb_helpers + 1) > s->allocated_helpers) { 573c896fe29Sbellard n = s->allocated_helpers; 574c896fe29Sbellard if (n == 0) { 575c896fe29Sbellard n = 4; 576c896fe29Sbellard } else { 577c896fe29Sbellard n *= 2; 578c896fe29Sbellard } 579c896fe29Sbellard s->helpers = realloc(s->helpers, n * sizeof(TCGHelperInfo)); 580c896fe29Sbellard s->allocated_helpers = n; 581c896fe29Sbellard } 5824dc81f28Sbellard s->helpers[s->nb_helpers].func = (tcg_target_ulong)func; 583c896fe29Sbellard s->helpers[s->nb_helpers].name = name; 584c896fe29Sbellard s->nb_helpers++; 585c896fe29Sbellard } 586c896fe29Sbellard 58739cf05d3Sbellard /* Note: we convert the 64 bit args to 32 bit and do some alignment 58839cf05d3Sbellard and endian swap. Maybe it would be better to do the alignment 58939cf05d3Sbellard and endian swap in tcg_reg_alloc_call(). */ 590a7812ae4Spbrook void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags, 591a7812ae4Spbrook int sizemask, TCGArg ret, int nargs, TCGArg *args) 592c896fe29Sbellard { 593568fffe3SChristophe Fergeau #if defined(TCG_TARGET_I386) && TCG_TARGET_REG_BITS < 64 594a7812ae4Spbrook int call_type; 5959678d950SBlue Swirl #endif 596a7812ae4Spbrook int i; 597a7812ae4Spbrook int real_args; 598a7812ae4Spbrook int nb_rets; 599a7812ae4Spbrook TCGArg *nparam; 6002bece2c8SRichard Henderson 6012bece2c8SRichard Henderson #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 6022bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 6032bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 6042bece2c8SRichard Henderson int is_signed = sizemask & (2 << (i+1)*2); 6052bece2c8SRichard Henderson if (!is_64bit) { 6062bece2c8SRichard Henderson TCGv_i64 temp = tcg_temp_new_i64(); 6072bece2c8SRichard Henderson TCGv_i64 orig = MAKE_TCGV_I64(args[i]); 6082bece2c8SRichard Henderson if (is_signed) { 6092bece2c8SRichard Henderson tcg_gen_ext32s_i64(temp, orig); 6102bece2c8SRichard Henderson } else { 6112bece2c8SRichard Henderson tcg_gen_ext32u_i64(temp, orig); 6122bece2c8SRichard Henderson } 6132bece2c8SRichard Henderson args[i] = GET_TCGV_I64(temp); 6142bece2c8SRichard Henderson } 6152bece2c8SRichard Henderson } 6162bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 6172bece2c8SRichard Henderson 618a7812ae4Spbrook *gen_opc_ptr++ = INDEX_op_call; 619a7812ae4Spbrook nparam = gen_opparam_ptr++; 620568fffe3SChristophe Fergeau #if defined(TCG_TARGET_I386) && TCG_TARGET_REG_BITS < 64 621c896fe29Sbellard call_type = (flags & TCG_CALL_TYPE_MASK); 6229678d950SBlue Swirl #endif 623a7812ae4Spbrook if (ret != TCG_CALL_DUMMY_ARG) { 624a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 625a7812ae4Spbrook if (sizemask & 1) { 626a7812ae4Spbrook #ifdef TCG_TARGET_WORDS_BIGENDIAN 627a7812ae4Spbrook *gen_opparam_ptr++ = ret + 1; 628a7812ae4Spbrook *gen_opparam_ptr++ = ret; 629a7812ae4Spbrook #else 630a7812ae4Spbrook *gen_opparam_ptr++ = ret; 631a7812ae4Spbrook *gen_opparam_ptr++ = ret + 1; 632a7812ae4Spbrook #endif 633a7812ae4Spbrook nb_rets = 2; 634a7812ae4Spbrook } else 635a7812ae4Spbrook #endif 636a7812ae4Spbrook { 637a7812ae4Spbrook *gen_opparam_ptr++ = ret; 638a7812ae4Spbrook nb_rets = 1; 639a7812ae4Spbrook } 640a7812ae4Spbrook } else { 641a7812ae4Spbrook nb_rets = 0; 642a7812ae4Spbrook } 643a7812ae4Spbrook real_args = 0; 644a7812ae4Spbrook for (i = 0; i < nargs; i++) { 645a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 6462bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 6472bece2c8SRichard Henderson if (is_64bit) { 648c896fe29Sbellard #ifdef TCG_TARGET_I386 649c896fe29Sbellard /* REGPARM case: if the third parameter is 64 bit, it is 650c896fe29Sbellard allocated on the stack */ 651a7812ae4Spbrook if (i == 2 && call_type == TCG_CALL_TYPE_REGPARM) { 652c896fe29Sbellard call_type = TCG_CALL_TYPE_REGPARM_2; 653c896fe29Sbellard flags = (flags & ~TCG_CALL_TYPE_MASK) | call_type; 654c896fe29Sbellard } 655a7812ae4Spbrook #endif 65639cf05d3Sbellard #ifdef TCG_TARGET_CALL_ALIGN_ARGS 65739cf05d3Sbellard /* some targets want aligned 64 bit args */ 658ebd486d5Smalc if (real_args & 1) { 659a7812ae4Spbrook *gen_opparam_ptr++ = TCG_CALL_DUMMY_ARG; 660ebd486d5Smalc real_args++; 66139cf05d3Sbellard } 66239cf05d3Sbellard #endif 6633f90f252SRichard Henderson /* If stack grows up, then we will be placing successive 6643f90f252SRichard Henderson arguments at lower addresses, which means we need to 6653f90f252SRichard Henderson reverse the order compared to how we would normally 6663f90f252SRichard Henderson treat either big or little-endian. For those arguments 6673f90f252SRichard Henderson that will wind up in registers, this still works for 6683f90f252SRichard Henderson HPPA (the only current STACK_GROWSUP target) since the 6693f90f252SRichard Henderson argument registers are *also* allocated in decreasing 6703f90f252SRichard Henderson order. If another such target is added, this logic may 6713f90f252SRichard Henderson have to get more complicated to differentiate between 6723f90f252SRichard Henderson stack arguments and register arguments. */ 6733f90f252SRichard Henderson #if defined(TCG_TARGET_WORDS_BIGENDIAN) != defined(TCG_TARGET_STACK_GROWSUP) 674a7812ae4Spbrook *gen_opparam_ptr++ = args[i] + 1; 675a7812ae4Spbrook *gen_opparam_ptr++ = args[i]; 676c896fe29Sbellard #else 677a7812ae4Spbrook *gen_opparam_ptr++ = args[i]; 678a7812ae4Spbrook *gen_opparam_ptr++ = args[i] + 1; 679c896fe29Sbellard #endif 680a7812ae4Spbrook real_args += 2; 6812bece2c8SRichard Henderson continue; 6822bece2c8SRichard Henderson } 6832bece2c8SRichard Henderson #endif /* TCG_TARGET_REG_BITS < 64 */ 6842bece2c8SRichard Henderson 685a7812ae4Spbrook *gen_opparam_ptr++ = args[i]; 686a7812ae4Spbrook real_args++; 687c896fe29Sbellard } 688a7812ae4Spbrook *gen_opparam_ptr++ = GET_TCGV_PTR(func); 689a7812ae4Spbrook 690a7812ae4Spbrook *gen_opparam_ptr++ = flags; 691a7812ae4Spbrook 692a7812ae4Spbrook *nparam = (nb_rets << 16) | (real_args + 1); 693a7812ae4Spbrook 694a7812ae4Spbrook /* total parameters, needed to go backward in the instruction stream */ 695a7812ae4Spbrook *gen_opparam_ptr++ = 1 + nb_rets + real_args + 3; 6962bece2c8SRichard Henderson 6972bece2c8SRichard Henderson #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 6982bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 6992bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 7002bece2c8SRichard Henderson if (!is_64bit) { 7012bece2c8SRichard Henderson TCGv_i64 temp = MAKE_TCGV_I64(args[i]); 7022bece2c8SRichard Henderson tcg_temp_free_i64(temp); 7032bece2c8SRichard Henderson } 7042bece2c8SRichard Henderson } 7052bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 706a7812ae4Spbrook } 707c896fe29Sbellard 708ac56dd48Spbrook #if TCG_TARGET_REG_BITS == 32 709a7812ae4Spbrook void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, 710c896fe29Sbellard int c, int right, int arith) 711c896fe29Sbellard { 712cf60bce4Sbellard if (c == 0) { 713a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1)); 714cf60bce4Sbellard tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1)); 715cf60bce4Sbellard } else if (c >= 32) { 716c896fe29Sbellard c -= 32; 717c896fe29Sbellard if (right) { 718c896fe29Sbellard if (arith) { 719a7812ae4Spbrook tcg_gen_sari_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 720ac56dd48Spbrook tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 31); 721c896fe29Sbellard } else { 722a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 723ac56dd48Spbrook tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 724c896fe29Sbellard } 725c896fe29Sbellard } else { 726a7812ae4Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_LOW(arg1), c); 727a7812ae4Spbrook tcg_gen_movi_i32(TCGV_LOW(ret), 0); 728c896fe29Sbellard } 729c896fe29Sbellard } else { 730a7812ae4Spbrook TCGv_i32 t0, t1; 731c896fe29Sbellard 732a7812ae4Spbrook t0 = tcg_temp_new_i32(); 733a7812ae4Spbrook t1 = tcg_temp_new_i32(); 734c896fe29Sbellard if (right) { 735ac56dd48Spbrook tcg_gen_shli_i32(t0, TCGV_HIGH(arg1), 32 - c); 736c896fe29Sbellard if (arith) 737ac56dd48Spbrook tcg_gen_sari_i32(t1, TCGV_HIGH(arg1), c); 738c896fe29Sbellard else 739ac56dd48Spbrook tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c); 740a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_LOW(arg1), c); 741a7812ae4Spbrook tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t0); 742ac56dd48Spbrook tcg_gen_mov_i32(TCGV_HIGH(ret), t1); 743c896fe29Sbellard } else { 744a7812ae4Spbrook tcg_gen_shri_i32(t0, TCGV_LOW(arg1), 32 - c); 745c896fe29Sbellard /* Note: ret can be the same as arg1, so we use t1 */ 746a7812ae4Spbrook tcg_gen_shli_i32(t1, TCGV_LOW(arg1), c); 747ac56dd48Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c); 748ac56dd48Spbrook tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0); 749a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), t1); 750c896fe29Sbellard } 751a7812ae4Spbrook tcg_temp_free_i32(t0); 752a7812ae4Spbrook tcg_temp_free_i32(t1); 753c896fe29Sbellard } 754c896fe29Sbellard } 755ac56dd48Spbrook #endif 756c896fe29Sbellard 757be210acbSRichard Henderson 7588fcd3692Sblueswir1 static void tcg_reg_alloc_start(TCGContext *s) 759c896fe29Sbellard { 760c896fe29Sbellard int i; 761c896fe29Sbellard TCGTemp *ts; 762c896fe29Sbellard for(i = 0; i < s->nb_globals; i++) { 763c896fe29Sbellard ts = &s->temps[i]; 764c896fe29Sbellard if (ts->fixed_reg) { 765c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 766c896fe29Sbellard } else { 767c896fe29Sbellard ts->val_type = TEMP_VAL_MEM; 768c896fe29Sbellard } 769c896fe29Sbellard } 770e8996ee0Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 771e8996ee0Sbellard ts = &s->temps[i]; 772e8996ee0Sbellard ts->val_type = TEMP_VAL_DEAD; 773e8996ee0Sbellard ts->mem_allocated = 0; 774e8996ee0Sbellard ts->fixed_reg = 0; 775e8996ee0Sbellard } 776c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 777c896fe29Sbellard s->reg_to_temp[i] = -1; 778c896fe29Sbellard } 779c896fe29Sbellard } 780c896fe29Sbellard 781ac56dd48Spbrook static char *tcg_get_arg_str_idx(TCGContext *s, char *buf, int buf_size, 782ac56dd48Spbrook int idx) 783c896fe29Sbellard { 784c896fe29Sbellard TCGTemp *ts; 785ac56dd48Spbrook 7867f6f0ae5SStefan Weil assert(idx >= 0 && idx < s->nb_temps); 787ac56dd48Spbrook ts = &s->temps[idx]; 7887f6f0ae5SStefan Weil assert(ts); 789ac56dd48Spbrook if (idx < s->nb_globals) { 790ac56dd48Spbrook pstrcpy(buf, buf_size, ts->name); 791c896fe29Sbellard } else { 792641d5fbeSbellard if (ts->temp_local) 793641d5fbeSbellard snprintf(buf, buf_size, "loc%d", idx - s->nb_globals); 794641d5fbeSbellard else 795ac56dd48Spbrook snprintf(buf, buf_size, "tmp%d", idx - s->nb_globals); 796c896fe29Sbellard } 797c896fe29Sbellard return buf; 798c896fe29Sbellard } 799c896fe29Sbellard 800a7812ae4Spbrook char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg) 801ac56dd48Spbrook { 802a7812ae4Spbrook return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I32(arg)); 803a7812ae4Spbrook } 804a7812ae4Spbrook 805a7812ae4Spbrook char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg) 806a7812ae4Spbrook { 807a810a2deSblueswir1 return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I64(arg)); 808ac56dd48Spbrook } 809ac56dd48Spbrook 810e8996ee0Sbellard static int helper_cmp(const void *p1, const void *p2) 811e8996ee0Sbellard { 812e8996ee0Sbellard const TCGHelperInfo *th1 = p1; 813e8996ee0Sbellard const TCGHelperInfo *th2 = p2; 814e8996ee0Sbellard if (th1->func < th2->func) 815e8996ee0Sbellard return -1; 816e8996ee0Sbellard else if (th1->func == th2->func) 817e8996ee0Sbellard return 0; 818e8996ee0Sbellard else 819e8996ee0Sbellard return 1; 820e8996ee0Sbellard } 821e8996ee0Sbellard 822e8996ee0Sbellard /* find helper definition (Note: A hash table would be better) */ 8234dc81f28Sbellard static TCGHelperInfo *tcg_find_helper(TCGContext *s, tcg_target_ulong val) 8244dc81f28Sbellard { 825e8996ee0Sbellard int m, m_min, m_max; 826e8996ee0Sbellard TCGHelperInfo *th; 827e8996ee0Sbellard tcg_target_ulong v; 828e8996ee0Sbellard 829e8996ee0Sbellard if (unlikely(!s->helpers_sorted)) { 830e8996ee0Sbellard qsort(s->helpers, s->nb_helpers, sizeof(TCGHelperInfo), 831e8996ee0Sbellard helper_cmp); 832e8996ee0Sbellard s->helpers_sorted = 1; 833e8996ee0Sbellard } 834e8996ee0Sbellard 835e8996ee0Sbellard /* binary search */ 836e8996ee0Sbellard m_min = 0; 837e8996ee0Sbellard m_max = s->nb_helpers - 1; 838e8996ee0Sbellard while (m_min <= m_max) { 839e8996ee0Sbellard m = (m_min + m_max) >> 1; 840e8996ee0Sbellard th = &s->helpers[m]; 841e8996ee0Sbellard v = th->func; 842e8996ee0Sbellard if (v == val) 843e8996ee0Sbellard return th; 844e8996ee0Sbellard else if (val < v) { 845e8996ee0Sbellard m_max = m - 1; 846e8996ee0Sbellard } else { 847e8996ee0Sbellard m_min = m + 1; 848e8996ee0Sbellard } 8494dc81f28Sbellard } 8504dc81f28Sbellard return NULL; 8514dc81f28Sbellard } 8524dc81f28Sbellard 853f48f3edeSblueswir1 static const char * const cond_name[] = 854f48f3edeSblueswir1 { 855f48f3edeSblueswir1 [TCG_COND_EQ] = "eq", 856f48f3edeSblueswir1 [TCG_COND_NE] = "ne", 857f48f3edeSblueswir1 [TCG_COND_LT] = "lt", 858f48f3edeSblueswir1 [TCG_COND_GE] = "ge", 859f48f3edeSblueswir1 [TCG_COND_LE] = "le", 860f48f3edeSblueswir1 [TCG_COND_GT] = "gt", 861f48f3edeSblueswir1 [TCG_COND_LTU] = "ltu", 862f48f3edeSblueswir1 [TCG_COND_GEU] = "geu", 863f48f3edeSblueswir1 [TCG_COND_LEU] = "leu", 864f48f3edeSblueswir1 [TCG_COND_GTU] = "gtu" 865f48f3edeSblueswir1 }; 866f48f3edeSblueswir1 867c896fe29Sbellard void tcg_dump_ops(TCGContext *s, FILE *outfile) 868c896fe29Sbellard { 869c896fe29Sbellard const uint16_t *opc_ptr; 870c896fe29Sbellard const TCGArg *args; 871c896fe29Sbellard TCGArg arg; 872a9751609SRichard Henderson TCGOpcode c; 873a9751609SRichard Henderson int i, k, nb_oargs, nb_iargs, nb_cargs, first_insn; 874c896fe29Sbellard const TCGOpDef *def; 875c896fe29Sbellard char buf[128]; 876c896fe29Sbellard 8777e4597d7Sbellard first_insn = 1; 878c896fe29Sbellard opc_ptr = gen_opc_buf; 879c896fe29Sbellard args = gen_opparam_buf; 880c896fe29Sbellard while (opc_ptr < gen_opc_ptr) { 881c896fe29Sbellard c = *opc_ptr++; 882c896fe29Sbellard def = &tcg_op_defs[c]; 8837e4597d7Sbellard if (c == INDEX_op_debug_insn_start) { 8847e4597d7Sbellard uint64_t pc; 8857e4597d7Sbellard #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS 8867e4597d7Sbellard pc = ((uint64_t)args[1] << 32) | args[0]; 8877e4597d7Sbellard #else 8887e4597d7Sbellard pc = args[0]; 8897e4597d7Sbellard #endif 8907e4597d7Sbellard if (!first_insn) 8917e4597d7Sbellard fprintf(outfile, "\n"); 8927e4597d7Sbellard fprintf(outfile, " ---- 0x%" PRIx64, pc); 8937e4597d7Sbellard first_insn = 0; 8947e4597d7Sbellard nb_oargs = def->nb_oargs; 8957e4597d7Sbellard nb_iargs = def->nb_iargs; 8967e4597d7Sbellard nb_cargs = def->nb_cargs; 8977e4597d7Sbellard } else if (c == INDEX_op_call) { 898c896fe29Sbellard TCGArg arg; 8994dc81f28Sbellard 900c896fe29Sbellard /* variable number of arguments */ 901c896fe29Sbellard arg = *args++; 902c896fe29Sbellard nb_oargs = arg >> 16; 903c896fe29Sbellard nb_iargs = arg & 0xffff; 904c896fe29Sbellard nb_cargs = def->nb_cargs; 905b03cce8eSbellard 9067e4597d7Sbellard fprintf(outfile, " %s ", def->name); 9077e4597d7Sbellard 908b03cce8eSbellard /* function name */ 909b03cce8eSbellard fprintf(outfile, "%s", 910e8996ee0Sbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + nb_iargs - 1])); 911b03cce8eSbellard /* flags */ 912b03cce8eSbellard fprintf(outfile, ",$0x%" TCG_PRIlx, 913b03cce8eSbellard args[nb_oargs + nb_iargs]); 914b03cce8eSbellard /* nb out args */ 915b03cce8eSbellard fprintf(outfile, ",$%d", nb_oargs); 916b03cce8eSbellard for(i = 0; i < nb_oargs; i++) { 917b03cce8eSbellard fprintf(outfile, ","); 918b03cce8eSbellard fprintf(outfile, "%s", 919b03cce8eSbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[i])); 920b03cce8eSbellard } 921b03cce8eSbellard for(i = 0; i < (nb_iargs - 1); i++) { 922b03cce8eSbellard fprintf(outfile, ","); 92339cf05d3Sbellard if (args[nb_oargs + i] == TCG_CALL_DUMMY_ARG) { 92439cf05d3Sbellard fprintf(outfile, "<dummy>"); 92539cf05d3Sbellard } else { 926b03cce8eSbellard fprintf(outfile, "%s", 927b03cce8eSbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + i])); 928b03cce8eSbellard } 92939cf05d3Sbellard } 930e8996ee0Sbellard } else if (c == INDEX_op_movi_i32 931e8996ee0Sbellard #if TCG_TARGET_REG_BITS == 64 932e8996ee0Sbellard || c == INDEX_op_movi_i64 933e8996ee0Sbellard #endif 934e8996ee0Sbellard ) { 935e8996ee0Sbellard tcg_target_ulong val; 936e8996ee0Sbellard TCGHelperInfo *th; 937e8996ee0Sbellard 938e8996ee0Sbellard nb_oargs = def->nb_oargs; 939e8996ee0Sbellard nb_iargs = def->nb_iargs; 940e8996ee0Sbellard nb_cargs = def->nb_cargs; 941e8996ee0Sbellard fprintf(outfile, " %s %s,$", def->name, 942e8996ee0Sbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[0])); 943e8996ee0Sbellard val = args[1]; 944e8996ee0Sbellard th = tcg_find_helper(s, val); 945e8996ee0Sbellard if (th) { 9463e9a474eSaurel32 fprintf(outfile, "%s", th->name); 947e8996ee0Sbellard } else { 948e8996ee0Sbellard if (c == INDEX_op_movi_i32) 949e8996ee0Sbellard fprintf(outfile, "0x%x", (uint32_t)val); 950e8996ee0Sbellard else 951e8996ee0Sbellard fprintf(outfile, "0x%" PRIx64 , (uint64_t)val); 952e8996ee0Sbellard } 953b03cce8eSbellard } else { 9547e4597d7Sbellard fprintf(outfile, " %s ", def->name); 955b03cce8eSbellard if (c == INDEX_op_nopn) { 956c896fe29Sbellard /* variable number of arguments */ 957c896fe29Sbellard nb_cargs = *args; 958c896fe29Sbellard nb_oargs = 0; 959c896fe29Sbellard nb_iargs = 0; 960c896fe29Sbellard } else { 961c896fe29Sbellard nb_oargs = def->nb_oargs; 962c896fe29Sbellard nb_iargs = def->nb_iargs; 963c896fe29Sbellard nb_cargs = def->nb_cargs; 964c896fe29Sbellard } 965c896fe29Sbellard 966c896fe29Sbellard k = 0; 967c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 968c896fe29Sbellard if (k != 0) 969c896fe29Sbellard fprintf(outfile, ","); 970ac56dd48Spbrook fprintf(outfile, "%s", 971ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), args[k++])); 972c896fe29Sbellard } 973c896fe29Sbellard for(i = 0; i < nb_iargs; i++) { 974c896fe29Sbellard if (k != 0) 975c896fe29Sbellard fprintf(outfile, ","); 976ac56dd48Spbrook fprintf(outfile, "%s", 977ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), args[k++])); 978c896fe29Sbellard } 979be210acbSRichard Henderson switch (c) { 980be210acbSRichard Henderson case INDEX_op_brcond_i32: 981f48f3edeSblueswir1 #if TCG_TARGET_REG_BITS == 32 982be210acbSRichard Henderson case INDEX_op_brcond2_i32: 983f48f3edeSblueswir1 #elif TCG_TARGET_REG_BITS == 64 984be210acbSRichard Henderson case INDEX_op_brcond_i64: 985f48f3edeSblueswir1 #endif 986be210acbSRichard Henderson case INDEX_op_setcond_i32: 987be210acbSRichard Henderson #if TCG_TARGET_REG_BITS == 32 988be210acbSRichard Henderson case INDEX_op_setcond2_i32: 989be210acbSRichard Henderson #elif TCG_TARGET_REG_BITS == 64 990be210acbSRichard Henderson case INDEX_op_setcond_i64: 991be210acbSRichard Henderson #endif 992f48f3edeSblueswir1 if (args[k] < ARRAY_SIZE(cond_name) && cond_name[args[k]]) 993f48f3edeSblueswir1 fprintf(outfile, ",%s", cond_name[args[k++]]); 994f48f3edeSblueswir1 else 995f48f3edeSblueswir1 fprintf(outfile, ",$0x%" TCG_PRIlx, args[k++]); 996f48f3edeSblueswir1 i = 1; 997be210acbSRichard Henderson break; 998be210acbSRichard Henderson default: 999f48f3edeSblueswir1 i = 0; 1000be210acbSRichard Henderson break; 1001be210acbSRichard Henderson } 1002f48f3edeSblueswir1 for(; i < nb_cargs; i++) { 1003c896fe29Sbellard if (k != 0) 1004c896fe29Sbellard fprintf(outfile, ","); 1005c896fe29Sbellard arg = args[k++]; 1006c896fe29Sbellard fprintf(outfile, "$0x%" TCG_PRIlx, arg); 1007c896fe29Sbellard } 1008b03cce8eSbellard } 1009c896fe29Sbellard fprintf(outfile, "\n"); 1010c896fe29Sbellard args += nb_iargs + nb_oargs + nb_cargs; 1011c896fe29Sbellard } 1012c896fe29Sbellard } 1013c896fe29Sbellard 1014c896fe29Sbellard /* we give more priority to constraints with less registers */ 1015c896fe29Sbellard static int get_constraint_priority(const TCGOpDef *def, int k) 1016c896fe29Sbellard { 1017c896fe29Sbellard const TCGArgConstraint *arg_ct; 1018c896fe29Sbellard 1019c896fe29Sbellard int i, n; 1020c896fe29Sbellard arg_ct = &def->args_ct[k]; 1021c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 1022c896fe29Sbellard /* an alias is equivalent to a single register */ 1023c896fe29Sbellard n = 1; 1024c896fe29Sbellard } else { 1025c896fe29Sbellard if (!(arg_ct->ct & TCG_CT_REG)) 1026c896fe29Sbellard return 0; 1027c896fe29Sbellard n = 0; 1028c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1029c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, i)) 1030c896fe29Sbellard n++; 1031c896fe29Sbellard } 1032c896fe29Sbellard } 1033c896fe29Sbellard return TCG_TARGET_NB_REGS - n + 1; 1034c896fe29Sbellard } 1035c896fe29Sbellard 1036c896fe29Sbellard /* sort from highest priority to lowest */ 1037c896fe29Sbellard static void sort_constraints(TCGOpDef *def, int start, int n) 1038c896fe29Sbellard { 1039c896fe29Sbellard int i, j, p1, p2, tmp; 1040c896fe29Sbellard 1041c896fe29Sbellard for(i = 0; i < n; i++) 1042c896fe29Sbellard def->sorted_args[start + i] = start + i; 1043c896fe29Sbellard if (n <= 1) 1044c896fe29Sbellard return; 1045c896fe29Sbellard for(i = 0; i < n - 1; i++) { 1046c896fe29Sbellard for(j = i + 1; j < n; j++) { 1047c896fe29Sbellard p1 = get_constraint_priority(def, def->sorted_args[start + i]); 1048c896fe29Sbellard p2 = get_constraint_priority(def, def->sorted_args[start + j]); 1049c896fe29Sbellard if (p1 < p2) { 1050c896fe29Sbellard tmp = def->sorted_args[start + i]; 1051c896fe29Sbellard def->sorted_args[start + i] = def->sorted_args[start + j]; 1052c896fe29Sbellard def->sorted_args[start + j] = tmp; 1053c896fe29Sbellard } 1054c896fe29Sbellard } 1055c896fe29Sbellard } 1056c896fe29Sbellard } 1057c896fe29Sbellard 1058c896fe29Sbellard void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs) 1059c896fe29Sbellard { 1060a9751609SRichard Henderson TCGOpcode op; 1061c896fe29Sbellard TCGOpDef *def; 1062c896fe29Sbellard const char *ct_str; 1063c896fe29Sbellard int i, nb_args; 1064c896fe29Sbellard 1065c896fe29Sbellard for(;;) { 1066a9751609SRichard Henderson if (tdefs->op == (TCGOpcode)-1) 1067c896fe29Sbellard break; 1068c896fe29Sbellard op = tdefs->op; 1069c3b08d0eSStefan Weil assert((unsigned)op < NB_OPS); 1070c896fe29Sbellard def = &tcg_op_defs[op]; 1071c68aaa18SStefan Weil #if defined(CONFIG_DEBUG_TCG) 1072c68aaa18SStefan Weil /* Duplicate entry in op definitions? */ 1073c68aaa18SStefan Weil assert(!def->used); 1074c68aaa18SStefan Weil def->used = 1; 1075c68aaa18SStefan Weil #endif 1076c896fe29Sbellard nb_args = def->nb_iargs + def->nb_oargs; 1077c896fe29Sbellard for(i = 0; i < nb_args; i++) { 1078c896fe29Sbellard ct_str = tdefs->args_ct_str[i]; 1079c68aaa18SStefan Weil /* Incomplete TCGTargetOpDef entry? */ 1080c68aaa18SStefan Weil assert(ct_str != NULL); 1081c896fe29Sbellard tcg_regset_clear(def->args_ct[i].u.regs); 1082c896fe29Sbellard def->args_ct[i].ct = 0; 1083c896fe29Sbellard if (ct_str[0] >= '0' && ct_str[0] <= '9') { 1084c896fe29Sbellard int oarg; 1085c896fe29Sbellard oarg = ct_str[0] - '0'; 1086c896fe29Sbellard assert(oarg < def->nb_oargs); 1087c896fe29Sbellard assert(def->args_ct[oarg].ct & TCG_CT_REG); 1088c896fe29Sbellard /* TCG_CT_ALIAS is for the output arguments. The input 10895ff9d6a4Sbellard argument is tagged with TCG_CT_IALIAS. */ 1090c896fe29Sbellard def->args_ct[i] = def->args_ct[oarg]; 10915ff9d6a4Sbellard def->args_ct[oarg].ct = TCG_CT_ALIAS; 10925ff9d6a4Sbellard def->args_ct[oarg].alias_index = i; 1093c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_IALIAS; 10945ff9d6a4Sbellard def->args_ct[i].alias_index = oarg; 1095c896fe29Sbellard } else { 1096c896fe29Sbellard for(;;) { 1097c896fe29Sbellard if (*ct_str == '\0') 1098c896fe29Sbellard break; 1099c896fe29Sbellard switch(*ct_str) { 1100c896fe29Sbellard case 'i': 1101c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_CONST; 1102c896fe29Sbellard ct_str++; 1103c896fe29Sbellard break; 1104c896fe29Sbellard default: 1105c896fe29Sbellard if (target_parse_constraint(&def->args_ct[i], &ct_str) < 0) { 1106c896fe29Sbellard fprintf(stderr, "Invalid constraint '%s' for arg %d of operation '%s'\n", 1107c896fe29Sbellard ct_str, i, def->name); 1108c896fe29Sbellard exit(1); 1109c896fe29Sbellard } 1110c896fe29Sbellard } 1111c896fe29Sbellard } 1112c896fe29Sbellard } 1113c896fe29Sbellard } 1114c896fe29Sbellard 1115c68aaa18SStefan Weil /* TCGTargetOpDef entry with too much information? */ 1116c68aaa18SStefan Weil assert(i == TCG_MAX_OP_ARGS || tdefs->args_ct_str[i] == NULL); 1117c68aaa18SStefan Weil 1118c896fe29Sbellard /* sort the constraints (XXX: this is just an heuristic) */ 1119c896fe29Sbellard sort_constraints(def, 0, def->nb_oargs); 1120c896fe29Sbellard sort_constraints(def, def->nb_oargs, def->nb_iargs); 1121c896fe29Sbellard 1122c896fe29Sbellard #if 0 1123c896fe29Sbellard { 1124c896fe29Sbellard int i; 1125c896fe29Sbellard 1126c896fe29Sbellard printf("%s: sorted=", def->name); 1127c896fe29Sbellard for(i = 0; i < def->nb_oargs + def->nb_iargs; i++) 1128c896fe29Sbellard printf(" %d", def->sorted_args[i]); 1129c896fe29Sbellard printf("\n"); 1130c896fe29Sbellard } 1131c896fe29Sbellard #endif 1132c896fe29Sbellard tdefs++; 1133c896fe29Sbellard } 1134c896fe29Sbellard 1135c68aaa18SStefan Weil #if defined(CONFIG_DEBUG_TCG) 1136a9751609SRichard Henderson i = 0; 1137c68aaa18SStefan Weil for (op = 0; op < ARRAY_SIZE(tcg_op_defs); op++) { 1138f412c762SRichard Henderson const TCGOpDef *def = &tcg_op_defs[op]; 1139f412c762SRichard Henderson if (op < INDEX_op_call 1140f412c762SRichard Henderson || op == INDEX_op_debug_insn_start 1141f412c762SRichard Henderson || (def->flags & TCG_OPF_NOT_PRESENT)) { 1142c68aaa18SStefan Weil /* Wrong entry in op definitions? */ 1143f412c762SRichard Henderson if (def->used) { 1144f412c762SRichard Henderson fprintf(stderr, "Invalid op definition for %s\n", def->name); 1145a9751609SRichard Henderson i = 1; 1146a9751609SRichard Henderson } 1147c68aaa18SStefan Weil } else { 1148c68aaa18SStefan Weil /* Missing entry in op definitions? */ 1149f412c762SRichard Henderson if (!def->used) { 1150f412c762SRichard Henderson fprintf(stderr, "Missing op definition for %s\n", def->name); 1151a9751609SRichard Henderson i = 1; 1152c68aaa18SStefan Weil } 1153c68aaa18SStefan Weil } 1154a9751609SRichard Henderson } 1155a9751609SRichard Henderson if (i == 1) { 1156a9751609SRichard Henderson tcg_abort(); 1157a9751609SRichard Henderson } 1158c68aaa18SStefan Weil #endif 1159c896fe29Sbellard } 1160c896fe29Sbellard 1161c896fe29Sbellard #ifdef USE_LIVENESS_ANALYSIS 1162c896fe29Sbellard 1163c896fe29Sbellard /* set a nop for an operation using 'nb_args' */ 1164c896fe29Sbellard static inline void tcg_set_nop(TCGContext *s, uint16_t *opc_ptr, 1165c896fe29Sbellard TCGArg *args, int nb_args) 1166c896fe29Sbellard { 1167c896fe29Sbellard if (nb_args == 0) { 1168c896fe29Sbellard *opc_ptr = INDEX_op_nop; 1169c896fe29Sbellard } else { 1170c896fe29Sbellard *opc_ptr = INDEX_op_nopn; 1171c896fe29Sbellard args[0] = nb_args; 1172c896fe29Sbellard args[nb_args - 1] = nb_args; 1173c896fe29Sbellard } 1174c896fe29Sbellard } 1175c896fe29Sbellard 1176641d5fbeSbellard /* liveness analysis: end of function: globals are live, temps are 1177641d5fbeSbellard dead. */ 1178641d5fbeSbellard /* XXX: at this stage, not used as there would be little gains because 1179641d5fbeSbellard most TBs end with a conditional jump. */ 1180641d5fbeSbellard static inline void tcg_la_func_end(TCGContext *s, uint8_t *dead_temps) 1181c896fe29Sbellard { 1182c896fe29Sbellard memset(dead_temps, 0, s->nb_globals); 1183c896fe29Sbellard memset(dead_temps + s->nb_globals, 1, s->nb_temps - s->nb_globals); 1184c896fe29Sbellard } 1185c896fe29Sbellard 1186641d5fbeSbellard /* liveness analysis: end of basic block: globals are live, temps are 1187641d5fbeSbellard dead, local temps are live. */ 1188641d5fbeSbellard static inline void tcg_la_bb_end(TCGContext *s, uint8_t *dead_temps) 1189641d5fbeSbellard { 1190641d5fbeSbellard int i; 1191641d5fbeSbellard TCGTemp *ts; 1192641d5fbeSbellard 1193641d5fbeSbellard memset(dead_temps, 0, s->nb_globals); 1194641d5fbeSbellard ts = &s->temps[s->nb_globals]; 1195641d5fbeSbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 1196641d5fbeSbellard if (ts->temp_local) 1197641d5fbeSbellard dead_temps[i] = 0; 1198641d5fbeSbellard else 1199641d5fbeSbellard dead_temps[i] = 1; 1200641d5fbeSbellard ts++; 1201641d5fbeSbellard } 1202641d5fbeSbellard } 1203641d5fbeSbellard 1204866cb6cbSAurelien Jarno /* Liveness analysis : update the opc_dead_args array to tell if a 1205c896fe29Sbellard given input arguments is dead. Instructions updating dead 1206c896fe29Sbellard temporaries are removed. */ 12078fcd3692Sblueswir1 static void tcg_liveness_analysis(TCGContext *s) 1208c896fe29Sbellard { 1209a9751609SRichard Henderson int i, op_index, nb_args, nb_iargs, nb_oargs, arg, nb_ops; 1210a9751609SRichard Henderson TCGOpcode op; 1211c896fe29Sbellard TCGArg *args; 1212c896fe29Sbellard const TCGOpDef *def; 1213c896fe29Sbellard uint8_t *dead_temps; 1214866cb6cbSAurelien Jarno unsigned int dead_args; 1215c896fe29Sbellard 1216c896fe29Sbellard gen_opc_ptr++; /* skip end */ 1217c896fe29Sbellard 1218c896fe29Sbellard nb_ops = gen_opc_ptr - gen_opc_buf; 1219c896fe29Sbellard 1220866cb6cbSAurelien Jarno s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t)); 1221c896fe29Sbellard 1222c896fe29Sbellard dead_temps = tcg_malloc(s->nb_temps); 1223c896fe29Sbellard memset(dead_temps, 1, s->nb_temps); 1224c896fe29Sbellard 1225c896fe29Sbellard args = gen_opparam_ptr; 1226c896fe29Sbellard op_index = nb_ops - 1; 1227c896fe29Sbellard while (op_index >= 0) { 1228c896fe29Sbellard op = gen_opc_buf[op_index]; 1229c896fe29Sbellard def = &tcg_op_defs[op]; 1230c896fe29Sbellard switch(op) { 1231c896fe29Sbellard case INDEX_op_call: 1232c6e113f5Sbellard { 1233c6e113f5Sbellard int call_flags; 1234c6e113f5Sbellard 1235c896fe29Sbellard nb_args = args[-1]; 1236c896fe29Sbellard args -= nb_args; 1237c896fe29Sbellard nb_iargs = args[0] & 0xffff; 1238c896fe29Sbellard nb_oargs = args[0] >> 16; 1239c896fe29Sbellard args++; 1240c6e113f5Sbellard call_flags = args[nb_oargs + nb_iargs]; 1241c6e113f5Sbellard 1242c6e113f5Sbellard /* pure functions can be removed if their result is not 1243c6e113f5Sbellard used */ 1244c6e113f5Sbellard if (call_flags & TCG_CALL_PURE) { 1245c6e113f5Sbellard for(i = 0; i < nb_oargs; i++) { 1246c6e113f5Sbellard arg = args[i]; 1247c6e113f5Sbellard if (!dead_temps[arg]) 1248c6e113f5Sbellard goto do_not_remove_call; 1249c6e113f5Sbellard } 1250c6e113f5Sbellard tcg_set_nop(s, gen_opc_buf + op_index, 1251c6e113f5Sbellard args - 1, nb_args); 1252c6e113f5Sbellard } else { 1253c6e113f5Sbellard do_not_remove_call: 1254c896fe29Sbellard 1255c896fe29Sbellard /* output args are dead */ 12566b64b624SAurelien Jarno dead_args = 0; 1257c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1258c896fe29Sbellard arg = args[i]; 12596b64b624SAurelien Jarno if (dead_temps[arg]) { 12606b64b624SAurelien Jarno dead_args |= (1 << i); 12616b64b624SAurelien Jarno } 1262c896fe29Sbellard dead_temps[arg] = 1; 1263c896fe29Sbellard } 1264c896fe29Sbellard 1265b9c18f56Saurel32 if (!(call_flags & TCG_CALL_CONST)) { 1266c896fe29Sbellard /* globals are live (they may be used by the call) */ 1267c896fe29Sbellard memset(dead_temps, 0, s->nb_globals); 1268b9c18f56Saurel32 } 1269c896fe29Sbellard 1270c896fe29Sbellard /* input args are live */ 1271866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 1272866cb6cbSAurelien Jarno arg = args[i]; 127339cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 1274c896fe29Sbellard if (dead_temps[arg]) { 1275866cb6cbSAurelien Jarno dead_args |= (1 << i); 1276c896fe29Sbellard } 1277c896fe29Sbellard dead_temps[arg] = 0; 1278c896fe29Sbellard } 127939cf05d3Sbellard } 1280866cb6cbSAurelien Jarno s->op_dead_args[op_index] = dead_args; 1281c6e113f5Sbellard } 1282c896fe29Sbellard args--; 1283c6e113f5Sbellard } 1284c896fe29Sbellard break; 1285c896fe29Sbellard case INDEX_op_set_label: 1286c896fe29Sbellard args--; 1287c896fe29Sbellard /* mark end of basic block */ 1288c896fe29Sbellard tcg_la_bb_end(s, dead_temps); 1289c896fe29Sbellard break; 12907e4597d7Sbellard case INDEX_op_debug_insn_start: 12917e4597d7Sbellard args -= def->nb_args; 12927e4597d7Sbellard break; 1293c896fe29Sbellard case INDEX_op_nopn: 1294c896fe29Sbellard nb_args = args[-1]; 1295c896fe29Sbellard args -= nb_args; 1296c896fe29Sbellard break; 12975ff9d6a4Sbellard case INDEX_op_discard: 12985ff9d6a4Sbellard args--; 12995ff9d6a4Sbellard /* mark the temporary as dead */ 13005ff9d6a4Sbellard dead_temps[args[0]] = 1; 13015ff9d6a4Sbellard break; 1302c896fe29Sbellard case INDEX_op_end: 1303c896fe29Sbellard break; 1304c896fe29Sbellard /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */ 1305c896fe29Sbellard default: 1306c896fe29Sbellard args -= def->nb_args; 1307c896fe29Sbellard nb_iargs = def->nb_iargs; 1308c896fe29Sbellard nb_oargs = def->nb_oargs; 1309c896fe29Sbellard 1310c896fe29Sbellard /* Test if the operation can be removed because all 13115ff9d6a4Sbellard its outputs are dead. We assume that nb_oargs == 0 13125ff9d6a4Sbellard implies side effects */ 13135ff9d6a4Sbellard if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) { 1314c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1315c896fe29Sbellard arg = args[i]; 1316c896fe29Sbellard if (!dead_temps[arg]) 1317c896fe29Sbellard goto do_not_remove; 1318c896fe29Sbellard } 1319c896fe29Sbellard tcg_set_nop(s, gen_opc_buf + op_index, args, def->nb_args); 1320c896fe29Sbellard #ifdef CONFIG_PROFILER 1321a23a9ec6Sbellard s->del_op_count++; 1322c896fe29Sbellard #endif 1323c896fe29Sbellard } else { 1324c896fe29Sbellard do_not_remove: 1325c896fe29Sbellard 1326c896fe29Sbellard /* output args are dead */ 13276b64b624SAurelien Jarno dead_args = 0; 1328c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1329c896fe29Sbellard arg = args[i]; 13306b64b624SAurelien Jarno if (dead_temps[arg]) { 13316b64b624SAurelien Jarno dead_args |= (1 << i); 13326b64b624SAurelien Jarno } 1333c896fe29Sbellard dead_temps[arg] = 1; 1334c896fe29Sbellard } 1335c896fe29Sbellard 1336c896fe29Sbellard /* if end of basic block, update */ 1337c896fe29Sbellard if (def->flags & TCG_OPF_BB_END) { 1338c896fe29Sbellard tcg_la_bb_end(s, dead_temps); 1339b03cce8eSbellard } else if (def->flags & TCG_OPF_CALL_CLOBBER) { 1340b03cce8eSbellard /* globals are live */ 1341b03cce8eSbellard memset(dead_temps, 0, s->nb_globals); 1342c896fe29Sbellard } 1343c896fe29Sbellard 1344c896fe29Sbellard /* input args are live */ 1345866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 1346866cb6cbSAurelien Jarno arg = args[i]; 1347c896fe29Sbellard if (dead_temps[arg]) { 1348866cb6cbSAurelien Jarno dead_args |= (1 << i); 1349c896fe29Sbellard } 1350c896fe29Sbellard dead_temps[arg] = 0; 1351c896fe29Sbellard } 1352866cb6cbSAurelien Jarno s->op_dead_args[op_index] = dead_args; 1353c896fe29Sbellard } 1354c896fe29Sbellard break; 1355c896fe29Sbellard } 1356c896fe29Sbellard op_index--; 1357c896fe29Sbellard } 1358c896fe29Sbellard 1359c896fe29Sbellard if (args != gen_opparam_buf) 1360c896fe29Sbellard tcg_abort(); 1361c896fe29Sbellard } 1362c896fe29Sbellard #else 1363c896fe29Sbellard /* dummy liveness analysis */ 1364655feed5Smalc static void tcg_liveness_analysis(TCGContext *s) 1365c896fe29Sbellard { 1366c896fe29Sbellard int nb_ops; 1367c896fe29Sbellard nb_ops = gen_opc_ptr - gen_opc_buf; 1368c896fe29Sbellard 1369866cb6cbSAurelien Jarno s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t)); 1370866cb6cbSAurelien Jarno memset(s->op_dead_args, 0, nb_ops * sizeof(uint16_t)); 1371c896fe29Sbellard } 1372c896fe29Sbellard #endif 1373c896fe29Sbellard 1374c896fe29Sbellard #ifndef NDEBUG 1375c896fe29Sbellard static void dump_regs(TCGContext *s) 1376c896fe29Sbellard { 1377c896fe29Sbellard TCGTemp *ts; 1378c896fe29Sbellard int i; 1379c896fe29Sbellard char buf[64]; 1380c896fe29Sbellard 1381c896fe29Sbellard for(i = 0; i < s->nb_temps; i++) { 1382c896fe29Sbellard ts = &s->temps[i]; 1383ac56dd48Spbrook printf(" %10s: ", tcg_get_arg_str_idx(s, buf, sizeof(buf), i)); 1384c896fe29Sbellard switch(ts->val_type) { 1385c896fe29Sbellard case TEMP_VAL_REG: 1386c896fe29Sbellard printf("%s", tcg_target_reg_names[ts->reg]); 1387c896fe29Sbellard break; 1388c896fe29Sbellard case TEMP_VAL_MEM: 1389c896fe29Sbellard printf("%d(%s)", (int)ts->mem_offset, tcg_target_reg_names[ts->mem_reg]); 1390c896fe29Sbellard break; 1391c896fe29Sbellard case TEMP_VAL_CONST: 1392c896fe29Sbellard printf("$0x%" TCG_PRIlx, ts->val); 1393c896fe29Sbellard break; 1394c896fe29Sbellard case TEMP_VAL_DEAD: 1395c896fe29Sbellard printf("D"); 1396c896fe29Sbellard break; 1397c896fe29Sbellard default: 1398c896fe29Sbellard printf("???"); 1399c896fe29Sbellard break; 1400c896fe29Sbellard } 1401c896fe29Sbellard printf("\n"); 1402c896fe29Sbellard } 1403c896fe29Sbellard 1404c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1405c896fe29Sbellard if (s->reg_to_temp[i] >= 0) { 1406c896fe29Sbellard printf("%s: %s\n", 1407c896fe29Sbellard tcg_target_reg_names[i], 1408ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), s->reg_to_temp[i])); 1409c896fe29Sbellard } 1410c896fe29Sbellard } 1411c896fe29Sbellard } 1412c896fe29Sbellard 1413c896fe29Sbellard static void check_regs(TCGContext *s) 1414c896fe29Sbellard { 1415c896fe29Sbellard int reg, k; 1416c896fe29Sbellard TCGTemp *ts; 1417c896fe29Sbellard char buf[64]; 1418c896fe29Sbellard 1419c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1420c896fe29Sbellard k = s->reg_to_temp[reg]; 1421c896fe29Sbellard if (k >= 0) { 1422c896fe29Sbellard ts = &s->temps[k]; 1423c896fe29Sbellard if (ts->val_type != TEMP_VAL_REG || 1424c896fe29Sbellard ts->reg != reg) { 1425c896fe29Sbellard printf("Inconsistency for register %s:\n", 1426c896fe29Sbellard tcg_target_reg_names[reg]); 1427b03cce8eSbellard goto fail; 1428c896fe29Sbellard } 1429c896fe29Sbellard } 1430c896fe29Sbellard } 1431c896fe29Sbellard for(k = 0; k < s->nb_temps; k++) { 1432c896fe29Sbellard ts = &s->temps[k]; 1433c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG && 1434c896fe29Sbellard !ts->fixed_reg && 1435c896fe29Sbellard s->reg_to_temp[ts->reg] != k) { 1436c896fe29Sbellard printf("Inconsistency for temp %s:\n", 1437ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), k)); 1438b03cce8eSbellard fail: 1439c896fe29Sbellard printf("reg state:\n"); 1440c896fe29Sbellard dump_regs(s); 1441c896fe29Sbellard tcg_abort(); 1442c896fe29Sbellard } 1443c896fe29Sbellard } 1444c896fe29Sbellard } 1445c896fe29Sbellard #endif 1446c896fe29Sbellard 1447c896fe29Sbellard static void temp_allocate_frame(TCGContext *s, int temp) 1448c896fe29Sbellard { 1449c896fe29Sbellard TCGTemp *ts; 1450c896fe29Sbellard ts = &s->temps[temp]; 1451f44c9960SBlue Swirl #ifndef __sparc_v9__ /* Sparc64 stack is accessed with offset of 2047 */ 1452b591dc59SBlue Swirl s->current_frame_offset = (s->current_frame_offset + 1453b591dc59SBlue Swirl (tcg_target_long)sizeof(tcg_target_long) - 1) & 1454b591dc59SBlue Swirl ~(sizeof(tcg_target_long) - 1); 1455f44c9960SBlue Swirl #endif 1456b591dc59SBlue Swirl if (s->current_frame_offset + (tcg_target_long)sizeof(tcg_target_long) > 1457b591dc59SBlue Swirl s->frame_end) { 14585ff9d6a4Sbellard tcg_abort(); 1459b591dc59SBlue Swirl } 1460c896fe29Sbellard ts->mem_offset = s->current_frame_offset; 1461c896fe29Sbellard ts->mem_reg = s->frame_reg; 1462c896fe29Sbellard ts->mem_allocated = 1; 1463b591dc59SBlue Swirl s->current_frame_offset += (tcg_target_long)sizeof(tcg_target_long); 1464c896fe29Sbellard } 1465c896fe29Sbellard 1466c896fe29Sbellard /* free register 'reg' by spilling the corresponding temporary if necessary */ 1467c896fe29Sbellard static void tcg_reg_free(TCGContext *s, int reg) 1468c896fe29Sbellard { 1469c896fe29Sbellard TCGTemp *ts; 1470c896fe29Sbellard int temp; 1471c896fe29Sbellard 1472c896fe29Sbellard temp = s->reg_to_temp[reg]; 1473c896fe29Sbellard if (temp != -1) { 1474c896fe29Sbellard ts = &s->temps[temp]; 1475c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 1476c896fe29Sbellard if (!ts->mem_coherent) { 1477c896fe29Sbellard if (!ts->mem_allocated) 1478c896fe29Sbellard temp_allocate_frame(s, temp); 1479e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1480c896fe29Sbellard } 1481c896fe29Sbellard ts->val_type = TEMP_VAL_MEM; 1482c896fe29Sbellard s->reg_to_temp[reg] = -1; 1483c896fe29Sbellard } 1484c896fe29Sbellard } 1485c896fe29Sbellard 1486c896fe29Sbellard /* Allocate a register belonging to reg1 & ~reg2 */ 1487c896fe29Sbellard static int tcg_reg_alloc(TCGContext *s, TCGRegSet reg1, TCGRegSet reg2) 1488c896fe29Sbellard { 1489c896fe29Sbellard int i, reg; 1490c896fe29Sbellard TCGRegSet reg_ct; 1491c896fe29Sbellard 1492c896fe29Sbellard tcg_regset_andnot(reg_ct, reg1, reg2); 1493c896fe29Sbellard 1494c896fe29Sbellard /* first try free registers */ 14950954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1496c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1497c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg) && s->reg_to_temp[reg] == -1) 1498c896fe29Sbellard return reg; 1499c896fe29Sbellard } 1500c896fe29Sbellard 1501c896fe29Sbellard /* XXX: do better spill choice */ 15020954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1503c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1504c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg)) { 1505c896fe29Sbellard tcg_reg_free(s, reg); 1506c896fe29Sbellard return reg; 1507c896fe29Sbellard } 1508c896fe29Sbellard } 1509c896fe29Sbellard 1510c896fe29Sbellard tcg_abort(); 1511c896fe29Sbellard } 1512c896fe29Sbellard 1513641d5fbeSbellard /* save a temporary to memory. 'allocated_regs' is used in case a 1514e8996ee0Sbellard temporary registers needs to be allocated to store a constant. */ 1515641d5fbeSbellard static void temp_save(TCGContext *s, int temp, TCGRegSet allocated_regs) 1516c896fe29Sbellard { 1517c896fe29Sbellard TCGTemp *ts; 1518641d5fbeSbellard int reg; 1519c896fe29Sbellard 1520641d5fbeSbellard ts = &s->temps[temp]; 1521c896fe29Sbellard if (!ts->fixed_reg) { 1522e8996ee0Sbellard switch(ts->val_type) { 1523e8996ee0Sbellard case TEMP_VAL_REG: 1524c896fe29Sbellard tcg_reg_free(s, ts->reg); 1525e8996ee0Sbellard break; 1526e8996ee0Sbellard case TEMP_VAL_DEAD: 1527e5097dc8Sbellard ts->val_type = TEMP_VAL_MEM; 1528e8996ee0Sbellard break; 1529e8996ee0Sbellard case TEMP_VAL_CONST: 15306692b043SAurelien Jarno reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 15316692b043SAurelien Jarno allocated_regs); 1532d6859202SAurelien Jarno if (!ts->mem_allocated) 1533d6859202SAurelien Jarno temp_allocate_frame(s, temp); 1534e8996ee0Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1535e8996ee0Sbellard tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1536e8996ee0Sbellard ts->val_type = TEMP_VAL_MEM; 1537e8996ee0Sbellard break; 1538e8996ee0Sbellard case TEMP_VAL_MEM: 1539e8996ee0Sbellard break; 1540e8996ee0Sbellard default: 1541e8996ee0Sbellard tcg_abort(); 1542c896fe29Sbellard } 1543c896fe29Sbellard } 1544c896fe29Sbellard } 1545641d5fbeSbellard 15469814dd27SDong Xu Wang /* save globals to their canonical location and assume they can be 1547641d5fbeSbellard modified be the following code. 'allocated_regs' is used in case a 1548641d5fbeSbellard temporary registers needs to be allocated to store a constant. */ 1549641d5fbeSbellard static void save_globals(TCGContext *s, TCGRegSet allocated_regs) 1550641d5fbeSbellard { 1551641d5fbeSbellard int i; 1552641d5fbeSbellard 1553641d5fbeSbellard for(i = 0; i < s->nb_globals; i++) { 1554641d5fbeSbellard temp_save(s, i, allocated_regs); 1555641d5fbeSbellard } 1556e5097dc8Sbellard } 1557e5097dc8Sbellard 1558e5097dc8Sbellard /* at the end of a basic block, we assume all temporaries are dead and 1559e8996ee0Sbellard all globals are stored at their canonical location. */ 1560e8996ee0Sbellard static void tcg_reg_alloc_bb_end(TCGContext *s, TCGRegSet allocated_regs) 1561e5097dc8Sbellard { 1562e5097dc8Sbellard TCGTemp *ts; 1563e5097dc8Sbellard int i; 1564e5097dc8Sbellard 1565c896fe29Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 1566c896fe29Sbellard ts = &s->temps[i]; 1567641d5fbeSbellard if (ts->temp_local) { 1568641d5fbeSbellard temp_save(s, i, allocated_regs); 1569641d5fbeSbellard } else { 1570c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 1571c896fe29Sbellard s->reg_to_temp[ts->reg] = -1; 1572c896fe29Sbellard } 1573c896fe29Sbellard ts->val_type = TEMP_VAL_DEAD; 1574c896fe29Sbellard } 1575641d5fbeSbellard } 1576e8996ee0Sbellard 1577e8996ee0Sbellard save_globals(s, allocated_regs); 1578c896fe29Sbellard } 1579c896fe29Sbellard 1580866cb6cbSAurelien Jarno #define IS_DEAD_ARG(n) ((dead_args >> (n)) & 1) 1581c896fe29Sbellard 1582e8996ee0Sbellard static void tcg_reg_alloc_movi(TCGContext *s, const TCGArg *args) 1583e8996ee0Sbellard { 1584e8996ee0Sbellard TCGTemp *ots; 1585e8996ee0Sbellard tcg_target_ulong val; 1586e8996ee0Sbellard 1587e8996ee0Sbellard ots = &s->temps[args[0]]; 1588e8996ee0Sbellard val = args[1]; 1589e8996ee0Sbellard 1590e8996ee0Sbellard if (ots->fixed_reg) { 1591e8996ee0Sbellard /* for fixed registers, we do not do any constant 1592e8996ee0Sbellard propagation */ 1593e8996ee0Sbellard tcg_out_movi(s, ots->type, ots->reg, val); 1594e8996ee0Sbellard } else { 15951235fc06Sths /* The movi is not explicitly generated here */ 1596e8996ee0Sbellard if (ots->val_type == TEMP_VAL_REG) 1597e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 1598e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 1599e8996ee0Sbellard ots->val = val; 1600e8996ee0Sbellard } 1601e8996ee0Sbellard } 1602e8996ee0Sbellard 1603c896fe29Sbellard static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def, 1604c896fe29Sbellard const TCGArg *args, 1605866cb6cbSAurelien Jarno unsigned int dead_args) 1606c896fe29Sbellard { 1607c896fe29Sbellard TCGTemp *ts, *ots; 1608c896fe29Sbellard int reg; 1609c896fe29Sbellard const TCGArgConstraint *arg_ct; 1610c896fe29Sbellard 1611c896fe29Sbellard ots = &s->temps[args[0]]; 1612c896fe29Sbellard ts = &s->temps[args[1]]; 1613c896fe29Sbellard arg_ct = &def->args_ct[0]; 1614c896fe29Sbellard 1615866cb6cbSAurelien Jarno /* XXX: always mark arg dead if IS_DEAD_ARG(1) */ 1616c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 1617866cb6cbSAurelien Jarno if (IS_DEAD_ARG(1) && !ts->fixed_reg && !ots->fixed_reg) { 1618c896fe29Sbellard /* the mov can be suppressed */ 1619c896fe29Sbellard if (ots->val_type == TEMP_VAL_REG) 1620c896fe29Sbellard s->reg_to_temp[ots->reg] = -1; 1621c896fe29Sbellard reg = ts->reg; 1622c896fe29Sbellard s->reg_to_temp[reg] = -1; 1623c896fe29Sbellard ts->val_type = TEMP_VAL_DEAD; 1624c896fe29Sbellard } else { 1625c896fe29Sbellard if (ots->val_type == TEMP_VAL_REG) { 1626c896fe29Sbellard reg = ots->reg; 1627c896fe29Sbellard } else { 1628c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, s->reserved_regs); 1629c896fe29Sbellard } 1630c896fe29Sbellard if (ts->reg != reg) { 16313b6dac34SRichard Henderson tcg_out_mov(s, ots->type, reg, ts->reg); 1632c896fe29Sbellard } 1633c896fe29Sbellard } 1634c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 1635c896fe29Sbellard if (ots->val_type == TEMP_VAL_REG) { 1636c896fe29Sbellard reg = ots->reg; 1637c896fe29Sbellard } else { 1638c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, s->reserved_regs); 1639c896fe29Sbellard } 1640e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1641c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1642e8996ee0Sbellard if (ots->fixed_reg) { 1643c896fe29Sbellard reg = ots->reg; 1644c896fe29Sbellard tcg_out_movi(s, ots->type, reg, ts->val); 1645c896fe29Sbellard } else { 1646e8996ee0Sbellard /* propagate constant */ 1647e8996ee0Sbellard if (ots->val_type == TEMP_VAL_REG) 1648e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 1649e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 1650e8996ee0Sbellard ots->val = ts->val; 1651e8996ee0Sbellard return; 1652e8996ee0Sbellard } 1653e8996ee0Sbellard } else { 1654c896fe29Sbellard tcg_abort(); 1655c896fe29Sbellard } 1656c896fe29Sbellard s->reg_to_temp[reg] = args[0]; 1657c896fe29Sbellard ots->reg = reg; 1658c896fe29Sbellard ots->val_type = TEMP_VAL_REG; 1659c896fe29Sbellard ots->mem_coherent = 0; 1660c896fe29Sbellard } 1661c896fe29Sbellard 1662c896fe29Sbellard static void tcg_reg_alloc_op(TCGContext *s, 1663a9751609SRichard Henderson const TCGOpDef *def, TCGOpcode opc, 1664c896fe29Sbellard const TCGArg *args, 1665866cb6cbSAurelien Jarno unsigned int dead_args) 1666c896fe29Sbellard { 1667c896fe29Sbellard TCGRegSet allocated_regs; 1668c896fe29Sbellard int i, k, nb_iargs, nb_oargs, reg; 1669c896fe29Sbellard TCGArg arg; 1670c896fe29Sbellard const TCGArgConstraint *arg_ct; 1671c896fe29Sbellard TCGTemp *ts; 1672c896fe29Sbellard TCGArg new_args[TCG_MAX_OP_ARGS]; 1673c896fe29Sbellard int const_args[TCG_MAX_OP_ARGS]; 1674c896fe29Sbellard 1675c896fe29Sbellard nb_oargs = def->nb_oargs; 1676c896fe29Sbellard nb_iargs = def->nb_iargs; 1677c896fe29Sbellard 1678c896fe29Sbellard /* copy constants */ 1679c896fe29Sbellard memcpy(new_args + nb_oargs + nb_iargs, 1680c896fe29Sbellard args + nb_oargs + nb_iargs, 1681c896fe29Sbellard sizeof(TCGArg) * def->nb_cargs); 1682c896fe29Sbellard 1683c896fe29Sbellard /* satisfy input constraints */ 1684c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 1685c896fe29Sbellard for(k = 0; k < nb_iargs; k++) { 1686c896fe29Sbellard i = def->sorted_args[nb_oargs + k]; 1687c896fe29Sbellard arg = args[i]; 1688c896fe29Sbellard arg_ct = &def->args_ct[i]; 1689c896fe29Sbellard ts = &s->temps[arg]; 1690c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 1691c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1692e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1693c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 1694c896fe29Sbellard ts->reg = reg; 1695c896fe29Sbellard ts->mem_coherent = 1; 1696c896fe29Sbellard s->reg_to_temp[reg] = arg; 1697c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1698c896fe29Sbellard if (tcg_target_const_match(ts->val, arg_ct)) { 1699c896fe29Sbellard /* constant is OK for instruction */ 1700c896fe29Sbellard const_args[i] = 1; 1701c896fe29Sbellard new_args[i] = ts->val; 1702c896fe29Sbellard goto iarg_end; 1703c896fe29Sbellard } else { 1704c896fe29Sbellard /* need to move to a register */ 1705c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1706c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1707e8996ee0Sbellard ts->val_type = TEMP_VAL_REG; 1708e8996ee0Sbellard ts->reg = reg; 1709e8996ee0Sbellard ts->mem_coherent = 0; 1710e8996ee0Sbellard s->reg_to_temp[reg] = arg; 1711c896fe29Sbellard } 1712c896fe29Sbellard } 1713c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 17145ff9d6a4Sbellard if (arg_ct->ct & TCG_CT_IALIAS) { 17155ff9d6a4Sbellard if (ts->fixed_reg) { 17165ff9d6a4Sbellard /* if fixed register, we must allocate a new register 17175ff9d6a4Sbellard if the alias is not the same register */ 17185ff9d6a4Sbellard if (arg != args[arg_ct->alias_index]) 17195ff9d6a4Sbellard goto allocate_in_reg; 17205ff9d6a4Sbellard } else { 1721c896fe29Sbellard /* if the input is aliased to an output and if it is 1722c896fe29Sbellard not dead after the instruction, we must allocate 1723c896fe29Sbellard a new register and move it */ 1724866cb6cbSAurelien Jarno if (!IS_DEAD_ARG(i)) { 1725c896fe29Sbellard goto allocate_in_reg; 1726c896fe29Sbellard } 17275ff9d6a4Sbellard } 1728866cb6cbSAurelien Jarno } 1729c896fe29Sbellard reg = ts->reg; 1730c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1731c896fe29Sbellard /* nothing to do : the constraint is satisfied */ 1732c896fe29Sbellard } else { 1733c896fe29Sbellard allocate_in_reg: 1734c896fe29Sbellard /* allocate a new register matching the constraint 1735c896fe29Sbellard and move the temporary register into it */ 1736c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 17373b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 1738c896fe29Sbellard } 1739c896fe29Sbellard new_args[i] = reg; 1740c896fe29Sbellard const_args[i] = 0; 1741c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 1742c896fe29Sbellard iarg_end: ; 1743c896fe29Sbellard } 1744c896fe29Sbellard 1745e8996ee0Sbellard if (def->flags & TCG_OPF_BB_END) { 1746e8996ee0Sbellard tcg_reg_alloc_bb_end(s, allocated_regs); 1747e8996ee0Sbellard } else { 1748c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 1749866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 1750866cb6cbSAurelien Jarno arg = args[i]; 1751866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 1752c896fe29Sbellard ts = &s->temps[arg]; 1753e8996ee0Sbellard if (!ts->fixed_reg) { 1754c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) 1755c896fe29Sbellard s->reg_to_temp[ts->reg] = -1; 1756c896fe29Sbellard ts->val_type = TEMP_VAL_DEAD; 1757c896fe29Sbellard } 1758c896fe29Sbellard } 1759c896fe29Sbellard } 1760c896fe29Sbellard 1761c896fe29Sbellard if (def->flags & TCG_OPF_CALL_CLOBBER) { 1762b03cce8eSbellard /* XXX: permit generic clobber register list ? */ 1763c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1764c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 1765c896fe29Sbellard tcg_reg_free(s, reg); 1766c896fe29Sbellard } 1767c896fe29Sbellard } 1768b03cce8eSbellard /* XXX: for load/store we could do that only for the slow path 1769b03cce8eSbellard (i.e. when a memory callback is called) */ 1770b03cce8eSbellard 1771b03cce8eSbellard /* store globals and free associated registers (we assume the insn 1772b03cce8eSbellard can modify any global. */ 1773e8996ee0Sbellard save_globals(s, allocated_regs); 1774c896fe29Sbellard } 1775c896fe29Sbellard 1776c896fe29Sbellard /* satisfy the output constraints */ 1777c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 1778c896fe29Sbellard for(k = 0; k < nb_oargs; k++) { 1779c896fe29Sbellard i = def->sorted_args[k]; 1780c896fe29Sbellard arg = args[i]; 1781c896fe29Sbellard arg_ct = &def->args_ct[i]; 1782c896fe29Sbellard ts = &s->temps[arg]; 1783c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 17845ff9d6a4Sbellard reg = new_args[arg_ct->alias_index]; 1785c896fe29Sbellard } else { 1786c896fe29Sbellard /* if fixed register, we try to use it */ 1787c896fe29Sbellard reg = ts->reg; 1788c896fe29Sbellard if (ts->fixed_reg && 1789c896fe29Sbellard tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1790c896fe29Sbellard goto oarg_end; 1791c896fe29Sbellard } 1792c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1793c896fe29Sbellard } 1794c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 1795c896fe29Sbellard /* if a fixed register is used, then a move will be done afterwards */ 1796c896fe29Sbellard if (!ts->fixed_reg) { 1797c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) 1798c896fe29Sbellard s->reg_to_temp[ts->reg] = -1; 17998c11ad25SAurelien Jarno if (IS_DEAD_ARG(i)) { 18008c11ad25SAurelien Jarno ts->val_type = TEMP_VAL_DEAD; 18018c11ad25SAurelien Jarno } else { 1802c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 1803c896fe29Sbellard ts->reg = reg; 1804c896fe29Sbellard /* temp value is modified, so the value kept in memory is 1805c896fe29Sbellard potentially not the same */ 1806c896fe29Sbellard ts->mem_coherent = 0; 1807c896fe29Sbellard s->reg_to_temp[reg] = arg; 1808c896fe29Sbellard } 18098c11ad25SAurelien Jarno } 1810c896fe29Sbellard oarg_end: 1811c896fe29Sbellard new_args[i] = reg; 1812c896fe29Sbellard } 1813e8996ee0Sbellard } 1814c896fe29Sbellard 1815c896fe29Sbellard /* emit instruction */ 1816c896fe29Sbellard tcg_out_op(s, opc, new_args, const_args); 1817c896fe29Sbellard 1818c896fe29Sbellard /* move the outputs in the correct register if needed */ 1819c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1820c896fe29Sbellard ts = &s->temps[args[i]]; 1821c896fe29Sbellard reg = new_args[i]; 1822c896fe29Sbellard if (ts->fixed_reg && ts->reg != reg) { 18233b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 1824c896fe29Sbellard } 1825c896fe29Sbellard } 1826c896fe29Sbellard } 1827c896fe29Sbellard 1828b03cce8eSbellard #ifdef TCG_TARGET_STACK_GROWSUP 1829b03cce8eSbellard #define STACK_DIR(x) (-(x)) 1830b03cce8eSbellard #else 1831b03cce8eSbellard #define STACK_DIR(x) (x) 1832b03cce8eSbellard #endif 1833b03cce8eSbellard 1834c896fe29Sbellard static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def, 1835a9751609SRichard Henderson TCGOpcode opc, const TCGArg *args, 1836866cb6cbSAurelien Jarno unsigned int dead_args) 1837c896fe29Sbellard { 1838c896fe29Sbellard int nb_iargs, nb_oargs, flags, nb_regs, i, reg, nb_params; 1839c896fe29Sbellard TCGArg arg, func_arg; 1840c896fe29Sbellard TCGTemp *ts; 1841f54b3f92Saurel32 tcg_target_long stack_offset, call_stack_size, func_addr; 1842b03cce8eSbellard int const_func_arg, allocate_args; 1843c896fe29Sbellard TCGRegSet allocated_regs; 1844c896fe29Sbellard const TCGArgConstraint *arg_ct; 1845c896fe29Sbellard 1846c896fe29Sbellard arg = *args++; 1847c896fe29Sbellard 1848c896fe29Sbellard nb_oargs = arg >> 16; 1849c896fe29Sbellard nb_iargs = arg & 0xffff; 1850c896fe29Sbellard nb_params = nb_iargs - 1; 1851c896fe29Sbellard 1852c896fe29Sbellard flags = args[nb_oargs + nb_iargs]; 1853c896fe29Sbellard 1854c896fe29Sbellard nb_regs = tcg_target_get_call_iarg_regs_count(flags); 1855c896fe29Sbellard if (nb_regs > nb_params) 1856c896fe29Sbellard nb_regs = nb_params; 1857c896fe29Sbellard 1858c896fe29Sbellard /* assign stack slots first */ 1859c896fe29Sbellard call_stack_size = (nb_params - nb_regs) * sizeof(tcg_target_long); 1860c896fe29Sbellard call_stack_size = (call_stack_size + TCG_TARGET_STACK_ALIGN - 1) & 1861c896fe29Sbellard ~(TCG_TARGET_STACK_ALIGN - 1); 1862b03cce8eSbellard allocate_args = (call_stack_size > TCG_STATIC_CALL_ARGS_SIZE); 1863b03cce8eSbellard if (allocate_args) { 1864345649c0SBlue Swirl /* XXX: if more than TCG_STATIC_CALL_ARGS_SIZE is needed, 1865345649c0SBlue Swirl preallocate call stack */ 1866345649c0SBlue Swirl tcg_abort(); 1867b03cce8eSbellard } 186839cf05d3Sbellard 186939cf05d3Sbellard stack_offset = TCG_TARGET_CALL_STACK_OFFSET; 1870c896fe29Sbellard for(i = nb_regs; i < nb_params; i++) { 1871c896fe29Sbellard arg = args[nb_oargs + i]; 187239cf05d3Sbellard #ifdef TCG_TARGET_STACK_GROWSUP 187339cf05d3Sbellard stack_offset -= sizeof(tcg_target_long); 187439cf05d3Sbellard #endif 187539cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 1876c896fe29Sbellard ts = &s->temps[arg]; 1877c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 1878e4d5434cSblueswir1 tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset); 1879c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 1880c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 1881c896fe29Sbellard s->reserved_regs); 1882c896fe29Sbellard /* XXX: not correct if reading values from the stack */ 1883e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1884e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 1885c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1886c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 1887c896fe29Sbellard s->reserved_regs); 1888c896fe29Sbellard /* XXX: sign extend may be needed on some targets */ 1889c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1890e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 1891c896fe29Sbellard } else { 1892c896fe29Sbellard tcg_abort(); 1893c896fe29Sbellard } 189439cf05d3Sbellard } 189539cf05d3Sbellard #ifndef TCG_TARGET_STACK_GROWSUP 189639cf05d3Sbellard stack_offset += sizeof(tcg_target_long); 189739cf05d3Sbellard #endif 1898c896fe29Sbellard } 1899c896fe29Sbellard 1900c896fe29Sbellard /* assign input registers */ 1901c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 1902c896fe29Sbellard for(i = 0; i < nb_regs; i++) { 1903c896fe29Sbellard arg = args[nb_oargs + i]; 190439cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 1905c896fe29Sbellard ts = &s->temps[arg]; 1906c896fe29Sbellard reg = tcg_target_call_iarg_regs[i]; 1907c896fe29Sbellard tcg_reg_free(s, reg); 1908c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 1909c896fe29Sbellard if (ts->reg != reg) { 19103b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 1911c896fe29Sbellard } 1912c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 1913e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1914c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1915c896fe29Sbellard /* XXX: sign extend ? */ 1916c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1917c896fe29Sbellard } else { 1918c896fe29Sbellard tcg_abort(); 1919c896fe29Sbellard } 1920c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 1921c896fe29Sbellard } 192239cf05d3Sbellard } 1923c896fe29Sbellard 1924c896fe29Sbellard /* assign function address */ 1925c896fe29Sbellard func_arg = args[nb_oargs + nb_iargs - 1]; 1926c896fe29Sbellard arg_ct = &def->args_ct[0]; 1927c896fe29Sbellard ts = &s->temps[func_arg]; 1928f54b3f92Saurel32 func_addr = ts->val; 1929c896fe29Sbellard const_func_arg = 0; 1930c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 1931c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1932e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1933c896fe29Sbellard func_arg = reg; 1934e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 1935c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_REG) { 1936c896fe29Sbellard reg = ts->reg; 1937c896fe29Sbellard if (!tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1938c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 19393b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 1940c896fe29Sbellard } 1941c896fe29Sbellard func_arg = reg; 1942e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 1943c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1944f54b3f92Saurel32 if (tcg_target_const_match(func_addr, arg_ct)) { 1945c896fe29Sbellard const_func_arg = 1; 1946f54b3f92Saurel32 func_arg = func_addr; 1947c896fe29Sbellard } else { 1948c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1949f54b3f92Saurel32 tcg_out_movi(s, ts->type, reg, func_addr); 1950c896fe29Sbellard func_arg = reg; 1951e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 1952c896fe29Sbellard } 1953c896fe29Sbellard } else { 1954c896fe29Sbellard tcg_abort(); 1955c896fe29Sbellard } 1956c896fe29Sbellard 1957e8996ee0Sbellard 1958c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 1959866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 1960866cb6cbSAurelien Jarno arg = args[i]; 1961866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 1962c896fe29Sbellard ts = &s->temps[arg]; 1963e8996ee0Sbellard if (!ts->fixed_reg) { 1964c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) 1965c896fe29Sbellard s->reg_to_temp[ts->reg] = -1; 1966c896fe29Sbellard ts->val_type = TEMP_VAL_DEAD; 1967c896fe29Sbellard } 1968c896fe29Sbellard } 1969c896fe29Sbellard } 1970c896fe29Sbellard 1971c896fe29Sbellard /* clobber call registers */ 1972c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1973c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 1974c896fe29Sbellard tcg_reg_free(s, reg); 1975c896fe29Sbellard } 1976c896fe29Sbellard } 1977c896fe29Sbellard 1978c896fe29Sbellard /* store globals and free associated registers (we assume the call 1979c896fe29Sbellard can modify any global. */ 1980b9c18f56Saurel32 if (!(flags & TCG_CALL_CONST)) { 1981e8996ee0Sbellard save_globals(s, allocated_regs); 1982b9c18f56Saurel32 } 1983c896fe29Sbellard 1984c896fe29Sbellard tcg_out_op(s, opc, &func_arg, &const_func_arg); 1985c896fe29Sbellard 1986c896fe29Sbellard /* assign output registers and emit moves if needed */ 1987c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1988c896fe29Sbellard arg = args[i]; 1989c896fe29Sbellard ts = &s->temps[arg]; 1990c896fe29Sbellard reg = tcg_target_call_oarg_regs[i]; 1991e8996ee0Sbellard assert(s->reg_to_temp[reg] == -1); 1992c896fe29Sbellard if (ts->fixed_reg) { 1993c896fe29Sbellard if (ts->reg != reg) { 19943b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 1995c896fe29Sbellard } 1996c896fe29Sbellard } else { 1997c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) 1998c896fe29Sbellard s->reg_to_temp[ts->reg] = -1; 19998c11ad25SAurelien Jarno if (IS_DEAD_ARG(i)) { 20008c11ad25SAurelien Jarno ts->val_type = TEMP_VAL_DEAD; 20018c11ad25SAurelien Jarno } else { 2002c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 2003c896fe29Sbellard ts->reg = reg; 2004c896fe29Sbellard ts->mem_coherent = 0; 2005c896fe29Sbellard s->reg_to_temp[reg] = arg; 2006c896fe29Sbellard } 2007c896fe29Sbellard } 20088c11ad25SAurelien Jarno } 2009c896fe29Sbellard 2010c896fe29Sbellard return nb_iargs + nb_oargs + def->nb_cargs + 1; 2011c896fe29Sbellard } 2012c896fe29Sbellard 2013c896fe29Sbellard #ifdef CONFIG_PROFILER 2014c896fe29Sbellard 201554604f74Saurel32 static int64_t tcg_table_op_count[NB_OPS]; 2016c896fe29Sbellard 2017871e6c35SBlue Swirl static void dump_op_count(void) 2018c896fe29Sbellard { 2019c896fe29Sbellard int i; 2020c896fe29Sbellard FILE *f; 202154604f74Saurel32 f = fopen("/tmp/op.log", "w"); 2022c896fe29Sbellard for(i = INDEX_op_end; i < NB_OPS; i++) { 202354604f74Saurel32 fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, tcg_table_op_count[i]); 2024c896fe29Sbellard } 2025c896fe29Sbellard fclose(f); 2026c896fe29Sbellard } 2027c896fe29Sbellard #endif 2028c896fe29Sbellard 2029c896fe29Sbellard 2030c896fe29Sbellard static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf, 20312ba1eeb6Spbrook long search_pc) 2032c896fe29Sbellard { 2033a9751609SRichard Henderson TCGOpcode opc; 2034a9751609SRichard Henderson int op_index; 2035c896fe29Sbellard const TCGOpDef *def; 2036866cb6cbSAurelien Jarno unsigned int dead_args; 2037c896fe29Sbellard const TCGArg *args; 2038c896fe29Sbellard 2039c896fe29Sbellard #ifdef DEBUG_DISAS 20408fec2b8cSaliguori if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) { 204193fcfe39Saliguori qemu_log("OP:\n"); 2042c896fe29Sbellard tcg_dump_ops(s, logfile); 204393fcfe39Saliguori qemu_log("\n"); 2044c896fe29Sbellard } 2045c896fe29Sbellard #endif 2046c896fe29Sbellard 20478f2e8c07SKirill Batuzov #ifdef USE_TCG_OPTIMIZATIONS 20488f2e8c07SKirill Batuzov gen_opparam_ptr = 20498f2e8c07SKirill Batuzov tcg_optimize(s, gen_opc_ptr, gen_opparam_buf, tcg_op_defs); 20508f2e8c07SKirill Batuzov #endif 20518f2e8c07SKirill Batuzov 2052a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2053a23a9ec6Sbellard s->la_time -= profile_getclock(); 2054a23a9ec6Sbellard #endif 2055c896fe29Sbellard tcg_liveness_analysis(s); 2056a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2057a23a9ec6Sbellard s->la_time += profile_getclock(); 2058a23a9ec6Sbellard #endif 2059c896fe29Sbellard 2060c896fe29Sbellard #ifdef DEBUG_DISAS 20618fec2b8cSaliguori if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT))) { 20626a957025SAurelien Jarno qemu_log("OP after liveness analysis:\n"); 2063c896fe29Sbellard tcg_dump_ops(s, logfile); 206493fcfe39Saliguori qemu_log("\n"); 2065c896fe29Sbellard } 2066c896fe29Sbellard #endif 2067c896fe29Sbellard 2068c896fe29Sbellard tcg_reg_alloc_start(s); 2069c896fe29Sbellard 2070c896fe29Sbellard s->code_buf = gen_code_buf; 2071c896fe29Sbellard s->code_ptr = gen_code_buf; 2072c896fe29Sbellard 2073c896fe29Sbellard args = gen_opparam_buf; 2074c896fe29Sbellard op_index = 0; 2075b3db8758Sblueswir1 2076c896fe29Sbellard for(;;) { 2077c896fe29Sbellard opc = gen_opc_buf[op_index]; 2078c896fe29Sbellard #ifdef CONFIG_PROFILER 207954604f74Saurel32 tcg_table_op_count[opc]++; 2080c896fe29Sbellard #endif 2081c896fe29Sbellard def = &tcg_op_defs[opc]; 2082c896fe29Sbellard #if 0 2083c896fe29Sbellard printf("%s: %d %d %d\n", def->name, 2084c896fe29Sbellard def->nb_oargs, def->nb_iargs, def->nb_cargs); 2085c896fe29Sbellard // dump_regs(s); 2086c896fe29Sbellard #endif 2087c896fe29Sbellard switch(opc) { 2088c896fe29Sbellard case INDEX_op_mov_i32: 2089c896fe29Sbellard #if TCG_TARGET_REG_BITS == 64 2090c896fe29Sbellard case INDEX_op_mov_i64: 2091c896fe29Sbellard #endif 2092866cb6cbSAurelien Jarno dead_args = s->op_dead_args[op_index]; 2093866cb6cbSAurelien Jarno tcg_reg_alloc_mov(s, def, args, dead_args); 2094c896fe29Sbellard break; 2095e8996ee0Sbellard case INDEX_op_movi_i32: 2096e8996ee0Sbellard #if TCG_TARGET_REG_BITS == 64 2097e8996ee0Sbellard case INDEX_op_movi_i64: 2098e8996ee0Sbellard #endif 2099e8996ee0Sbellard tcg_reg_alloc_movi(s, args); 2100e8996ee0Sbellard break; 21017e4597d7Sbellard case INDEX_op_debug_insn_start: 21027e4597d7Sbellard /* debug instruction */ 21037e4597d7Sbellard break; 2104c896fe29Sbellard case INDEX_op_nop: 2105c896fe29Sbellard case INDEX_op_nop1: 2106c896fe29Sbellard case INDEX_op_nop2: 2107c896fe29Sbellard case INDEX_op_nop3: 2108c896fe29Sbellard break; 2109c896fe29Sbellard case INDEX_op_nopn: 2110c896fe29Sbellard args += args[0]; 2111c896fe29Sbellard goto next; 21125ff9d6a4Sbellard case INDEX_op_discard: 21135ff9d6a4Sbellard { 21145ff9d6a4Sbellard TCGTemp *ts; 21155ff9d6a4Sbellard ts = &s->temps[args[0]]; 21165ff9d6a4Sbellard /* mark the temporary as dead */ 2117e8996ee0Sbellard if (!ts->fixed_reg) { 21185ff9d6a4Sbellard if (ts->val_type == TEMP_VAL_REG) 21195ff9d6a4Sbellard s->reg_to_temp[ts->reg] = -1; 21205ff9d6a4Sbellard ts->val_type = TEMP_VAL_DEAD; 21215ff9d6a4Sbellard } 21225ff9d6a4Sbellard } 21235ff9d6a4Sbellard break; 2124c896fe29Sbellard case INDEX_op_set_label: 2125e8996ee0Sbellard tcg_reg_alloc_bb_end(s, s->reserved_regs); 2126*9d6fca70SStefan Weil tcg_out_label(s, args[0], s->code_ptr); 2127c896fe29Sbellard break; 2128c896fe29Sbellard case INDEX_op_call: 2129866cb6cbSAurelien Jarno dead_args = s->op_dead_args[op_index]; 2130866cb6cbSAurelien Jarno args += tcg_reg_alloc_call(s, def, opc, args, dead_args); 2131c896fe29Sbellard goto next; 2132c896fe29Sbellard case INDEX_op_end: 2133c896fe29Sbellard goto the_end; 2134c896fe29Sbellard default: 213525c4d9ccSRichard Henderson /* Sanity check that we've not introduced any unhandled opcodes. */ 213625c4d9ccSRichard Henderson if (def->flags & TCG_OPF_NOT_PRESENT) { 213725c4d9ccSRichard Henderson tcg_abort(); 213825c4d9ccSRichard Henderson } 2139c896fe29Sbellard /* Note: in order to speed up the code, it would be much 2140c896fe29Sbellard faster to have specialized register allocator functions for 2141c896fe29Sbellard some common argument patterns */ 2142866cb6cbSAurelien Jarno dead_args = s->op_dead_args[op_index]; 2143866cb6cbSAurelien Jarno tcg_reg_alloc_op(s, def, opc, args, dead_args); 2144c896fe29Sbellard break; 2145c896fe29Sbellard } 2146c896fe29Sbellard args += def->nb_args; 21478df1ca4bSths next: 21482ba1eeb6Spbrook if (search_pc >= 0 && search_pc < s->code_ptr - gen_code_buf) { 2149c896fe29Sbellard return op_index; 2150c896fe29Sbellard } 2151c896fe29Sbellard op_index++; 2152c896fe29Sbellard #ifndef NDEBUG 2153c896fe29Sbellard check_regs(s); 2154c896fe29Sbellard #endif 2155c896fe29Sbellard } 2156c896fe29Sbellard the_end: 2157c896fe29Sbellard return -1; 2158c896fe29Sbellard } 2159c896fe29Sbellard 216054604f74Saurel32 int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf) 2161c896fe29Sbellard { 2162c896fe29Sbellard #ifdef CONFIG_PROFILER 2163c896fe29Sbellard { 2164c896fe29Sbellard int n; 2165c896fe29Sbellard n = (gen_opc_ptr - gen_opc_buf); 2166a23a9ec6Sbellard s->op_count += n; 2167a23a9ec6Sbellard if (n > s->op_count_max) 2168a23a9ec6Sbellard s->op_count_max = n; 2169a23a9ec6Sbellard 2170a23a9ec6Sbellard s->temp_count += s->nb_temps; 2171a23a9ec6Sbellard if (s->nb_temps > s->temp_count_max) 2172a23a9ec6Sbellard s->temp_count_max = s->nb_temps; 2173c896fe29Sbellard } 2174c896fe29Sbellard #endif 2175c896fe29Sbellard 21762ba1eeb6Spbrook tcg_gen_code_common(s, gen_code_buf, -1); 2177c896fe29Sbellard 2178c896fe29Sbellard /* flush instruction cache */ 21792aeabc08SStefan Weil flush_icache_range((tcg_target_ulong)gen_code_buf, 21802aeabc08SStefan Weil (tcg_target_ulong)s->code_ptr); 21812aeabc08SStefan Weil 2182c896fe29Sbellard return s->code_ptr - gen_code_buf; 2183c896fe29Sbellard } 2184c896fe29Sbellard 21852ba1eeb6Spbrook /* Return the index of the micro operation such as the pc after is < 2186623e265cSpbrook offset bytes from the start of the TB. The contents of gen_code_buf must 2187623e265cSpbrook not be changed, though writing the same values is ok. 2188623e265cSpbrook Return -1 if not found. */ 218954604f74Saurel32 int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset) 2190c896fe29Sbellard { 2191623e265cSpbrook return tcg_gen_code_common(s, gen_code_buf, offset); 2192c896fe29Sbellard } 2193a23a9ec6Sbellard 2194a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2195405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2196a23a9ec6Sbellard { 2197a23a9ec6Sbellard TCGContext *s = &tcg_ctx; 2198a23a9ec6Sbellard int64_t tot; 2199a23a9ec6Sbellard 2200a23a9ec6Sbellard tot = s->interm_time + s->code_time; 2201a23a9ec6Sbellard cpu_fprintf(f, "JIT cycles %" PRId64 " (%0.3f s at 2.4 GHz)\n", 2202a23a9ec6Sbellard tot, tot / 2.4e9); 2203a23a9ec6Sbellard cpu_fprintf(f, "translated TBs %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n", 2204a23a9ec6Sbellard s->tb_count, 2205a23a9ec6Sbellard s->tb_count1 - s->tb_count, 2206a23a9ec6Sbellard s->tb_count1 ? (double)(s->tb_count1 - s->tb_count) / s->tb_count1 * 100.0 : 0); 2207a23a9ec6Sbellard cpu_fprintf(f, "avg ops/TB %0.1f max=%d\n", 2208a23a9ec6Sbellard s->tb_count ? (double)s->op_count / s->tb_count : 0, s->op_count_max); 2209a23a9ec6Sbellard cpu_fprintf(f, "deleted ops/TB %0.2f\n", 2210a23a9ec6Sbellard s->tb_count ? 2211a23a9ec6Sbellard (double)s->del_op_count / s->tb_count : 0); 2212a23a9ec6Sbellard cpu_fprintf(f, "avg temps/TB %0.2f max=%d\n", 2213a23a9ec6Sbellard s->tb_count ? 2214a23a9ec6Sbellard (double)s->temp_count / s->tb_count : 0, 2215a23a9ec6Sbellard s->temp_count_max); 2216a23a9ec6Sbellard 2217a23a9ec6Sbellard cpu_fprintf(f, "cycles/op %0.1f\n", 2218a23a9ec6Sbellard s->op_count ? (double)tot / s->op_count : 0); 2219a23a9ec6Sbellard cpu_fprintf(f, "cycles/in byte %0.1f\n", 2220a23a9ec6Sbellard s->code_in_len ? (double)tot / s->code_in_len : 0); 2221a23a9ec6Sbellard cpu_fprintf(f, "cycles/out byte %0.1f\n", 2222a23a9ec6Sbellard s->code_out_len ? (double)tot / s->code_out_len : 0); 2223a23a9ec6Sbellard if (tot == 0) 2224a23a9ec6Sbellard tot = 1; 2225a23a9ec6Sbellard cpu_fprintf(f, " gen_interm time %0.1f%%\n", 2226a23a9ec6Sbellard (double)s->interm_time / tot * 100.0); 2227a23a9ec6Sbellard cpu_fprintf(f, " gen_code time %0.1f%%\n", 2228a23a9ec6Sbellard (double)s->code_time / tot * 100.0); 2229a23a9ec6Sbellard cpu_fprintf(f, "liveness/code time %0.1f%%\n", 2230a23a9ec6Sbellard (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0); 2231a23a9ec6Sbellard cpu_fprintf(f, "cpu_restore count %" PRId64 "\n", 2232a23a9ec6Sbellard s->restore_count); 2233a23a9ec6Sbellard cpu_fprintf(f, " avg cycles %0.1f\n", 2234a23a9ec6Sbellard s->restore_count ? (double)s->restore_time / s->restore_count : 0); 2235871e6c35SBlue Swirl 2236a23a9ec6Sbellard dump_op_count(); 2237a23a9ec6Sbellard } 2238a23a9ec6Sbellard #else 2239405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2240a23a9ec6Sbellard { 224124bf7b3aSbellard cpu_fprintf(f, "[TCG profiler not compiled]\n"); 2242a23a9ec6Sbellard } 2243a23a9ec6Sbellard #endif 2244