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 36c896fe29Sbellard #include <stdarg.h> 37c896fe29Sbellard #include <stdlib.h> 38c896fe29Sbellard #include <stdio.h> 39c896fe29Sbellard #include <string.h> 40c896fe29Sbellard #include <inttypes.h> 413fe43da7Sbellard #ifdef _WIN32 423fe43da7Sbellard #include <malloc.h> 433fe43da7Sbellard #endif 44b29fe3edSmalc #ifdef _AIX 45b29fe3edSmalc #include <alloca.h> 46b29fe3edSmalc #endif 47c896fe29Sbellard 48ca10f867Saurel32 #include "qemu-common.h" 49902b3d5cSmalc #include "cache-utils.h" 50379f6698SPaul Brook #include "host-utils.h" 512d8ebcf9SRichard Henderson #include "qemu-timer.h" 52c896fe29Sbellard 53c896fe29Sbellard /* Note: the long term plan is to reduce the dependancies on the QEMU 54c896fe29Sbellard CPU definitions. Currently they are used for qemu_ld/st 55c896fe29Sbellard instructions */ 56c896fe29Sbellard #define NO_CPU_IO_DEFS 57c896fe29Sbellard #include "cpu.h" 58c896fe29Sbellard 59c896fe29Sbellard #include "tcg-op.h" 60c896fe29Sbellard #include "elf.h" 61c896fe29Sbellard 62379f6698SPaul Brook #if defined(CONFIG_USE_GUEST_BASE) && !defined(TCG_TARGET_HAS_GUEST_BASE) 63379f6698SPaul Brook #error GUEST_BASE not supported on this host. 64379f6698SPaul Brook #endif 65c896fe29Sbellard 66c0ad3001SStefan Weil /* Forward declarations for functions declared in tcg-target.c and used here. */ 67e4d58b41SRichard Henderson static void tcg_target_init(TCGContext *s); 68e4d58b41SRichard Henderson static void tcg_target_qemu_prologue(TCGContext *s); 69c896fe29Sbellard static void patch_reloc(uint8_t *code_ptr, int type, 70f54b3f92Saurel32 tcg_target_long value, tcg_target_long addend); 71c896fe29Sbellard 72c0ad3001SStefan Weil /* Forward declarations for functions declared and used in tcg-target.c. */ 73c0ad3001SStefan Weil static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str); 74c0ad3001SStefan Weil static void tcg_out_ld(TCGContext *s, TCGType type, int ret, int arg1, 75c0ad3001SStefan Weil tcg_target_long arg2); 76c0ad3001SStefan Weil static void tcg_out_mov(TCGContext *s, TCGType type, int ret, int arg); 77c0ad3001SStefan Weil static void tcg_out_movi(TCGContext *s, TCGType type, 78c0ad3001SStefan Weil int ret, tcg_target_long arg); 79c0ad3001SStefan Weil static void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args, 80c0ad3001SStefan Weil const int *const_args); 81c0ad3001SStefan Weil static void tcg_out_st(TCGContext *s, TCGType type, int arg, int arg1, 82c0ad3001SStefan Weil tcg_target_long arg2); 83c0ad3001SStefan Weil static int tcg_target_const_match(tcg_target_long val, 84c0ad3001SStefan Weil const TCGArgConstraint *arg_ct); 85c0ad3001SStefan Weil static int tcg_target_get_call_iarg_regs_count(int flags); 86c0ad3001SStefan Weil 878399ad59SRichard Henderson TCGOpDef tcg_op_defs[] = { 880e2029a0SAurelien Jarno #define DEF(s, oargs, iargs, cargs, flags) { #s, oargs, iargs, cargs, iargs + oargs + cargs, flags }, 89c896fe29Sbellard #include "tcg-opc.h" 90c896fe29Sbellard #undef DEF 91c896fe29Sbellard }; 92c896fe29Sbellard 93b1d8e52eSblueswir1 static TCGRegSet tcg_target_available_regs[2]; 94b1d8e52eSblueswir1 static TCGRegSet tcg_target_call_clobber_regs; 95c896fe29Sbellard 96c896fe29Sbellard /* XXX: move that inside the context */ 97c896fe29Sbellard uint16_t *gen_opc_ptr; 98c896fe29Sbellard TCGArg *gen_opparam_ptr; 99c896fe29Sbellard 100c896fe29Sbellard static inline void tcg_out8(TCGContext *s, uint8_t v) 101c896fe29Sbellard { 102c896fe29Sbellard *s->code_ptr++ = v; 103c896fe29Sbellard } 104c896fe29Sbellard 105c896fe29Sbellard static inline void tcg_out16(TCGContext *s, uint16_t v) 106c896fe29Sbellard { 107c896fe29Sbellard *(uint16_t *)s->code_ptr = v; 108c896fe29Sbellard s->code_ptr += 2; 109c896fe29Sbellard } 110c896fe29Sbellard 111c896fe29Sbellard static inline void tcg_out32(TCGContext *s, uint32_t v) 112c896fe29Sbellard { 113c896fe29Sbellard *(uint32_t *)s->code_ptr = v; 114c896fe29Sbellard s->code_ptr += 4; 115c896fe29Sbellard } 116c896fe29Sbellard 117c896fe29Sbellard /* label relocation processing */ 118c896fe29Sbellard 119a5ad5916SStefan Weil static void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type, 120c896fe29Sbellard int label_index, long addend) 121c896fe29Sbellard { 122c896fe29Sbellard TCGLabel *l; 123c896fe29Sbellard TCGRelocation *r; 124c896fe29Sbellard 125c896fe29Sbellard l = &s->labels[label_index]; 126c896fe29Sbellard if (l->has_value) { 127623e265cSpbrook /* FIXME: This may break relocations on RISC targets that 128623e265cSpbrook modify instruction fields in place. The caller may not have 129623e265cSpbrook written the initial value. */ 130f54b3f92Saurel32 patch_reloc(code_ptr, type, l->u.value, addend); 131c896fe29Sbellard } else { 132c896fe29Sbellard /* add a new relocation entry */ 133c896fe29Sbellard r = tcg_malloc(sizeof(TCGRelocation)); 134c896fe29Sbellard r->type = type; 135c896fe29Sbellard r->ptr = code_ptr; 136c896fe29Sbellard r->addend = addend; 137c896fe29Sbellard r->next = l->u.first_reloc; 138c896fe29Sbellard l->u.first_reloc = r; 139c896fe29Sbellard } 140c896fe29Sbellard } 141c896fe29Sbellard 142c896fe29Sbellard static void tcg_out_label(TCGContext *s, int label_index, 143c896fe29Sbellard tcg_target_long value) 144c896fe29Sbellard { 145c896fe29Sbellard TCGLabel *l; 146c896fe29Sbellard TCGRelocation *r; 147c896fe29Sbellard 148c896fe29Sbellard l = &s->labels[label_index]; 149c896fe29Sbellard if (l->has_value) 150c896fe29Sbellard tcg_abort(); 151c896fe29Sbellard r = l->u.first_reloc; 152c896fe29Sbellard while (r != NULL) { 153f54b3f92Saurel32 patch_reloc(r->ptr, r->type, value, r->addend); 154c896fe29Sbellard r = r->next; 155c896fe29Sbellard } 156c896fe29Sbellard l->has_value = 1; 157c896fe29Sbellard l->u.value = value; 158c896fe29Sbellard } 159c896fe29Sbellard 160c896fe29Sbellard int gen_new_label(void) 161c896fe29Sbellard { 162c896fe29Sbellard TCGContext *s = &tcg_ctx; 163c896fe29Sbellard int idx; 164c896fe29Sbellard TCGLabel *l; 165c896fe29Sbellard 166c896fe29Sbellard if (s->nb_labels >= TCG_MAX_LABELS) 167c896fe29Sbellard tcg_abort(); 168c896fe29Sbellard idx = s->nb_labels++; 169c896fe29Sbellard l = &s->labels[idx]; 170c896fe29Sbellard l->has_value = 0; 171c896fe29Sbellard l->u.first_reloc = NULL; 172c896fe29Sbellard return idx; 173c896fe29Sbellard } 174c896fe29Sbellard 175c896fe29Sbellard #include "tcg-target.c" 176c896fe29Sbellard 177c896fe29Sbellard /* pool based memory allocation */ 178c896fe29Sbellard void *tcg_malloc_internal(TCGContext *s, int size) 179c896fe29Sbellard { 180c896fe29Sbellard TCGPool *p; 181c896fe29Sbellard int pool_size; 182c896fe29Sbellard 183c896fe29Sbellard if (size > TCG_POOL_CHUNK_SIZE) { 184c896fe29Sbellard /* big malloc: insert a new pool (XXX: could optimize) */ 1857267c094SAnthony Liguori p = g_malloc(sizeof(TCGPool) + size); 186c896fe29Sbellard p->size = size; 187c896fe29Sbellard if (s->pool_current) 188c896fe29Sbellard s->pool_current->next = p; 189c896fe29Sbellard else 190c896fe29Sbellard s->pool_first = p; 191c896fe29Sbellard p->next = s->pool_current; 192c896fe29Sbellard } else { 193c896fe29Sbellard p = s->pool_current; 194c896fe29Sbellard if (!p) { 195c896fe29Sbellard p = s->pool_first; 196c896fe29Sbellard if (!p) 197c896fe29Sbellard goto new_pool; 198c896fe29Sbellard } else { 199c896fe29Sbellard if (!p->next) { 200c896fe29Sbellard new_pool: 201c896fe29Sbellard pool_size = TCG_POOL_CHUNK_SIZE; 2027267c094SAnthony Liguori p = g_malloc(sizeof(TCGPool) + pool_size); 203c896fe29Sbellard p->size = pool_size; 204c896fe29Sbellard p->next = NULL; 205c896fe29Sbellard if (s->pool_current) 206c896fe29Sbellard s->pool_current->next = p; 207c896fe29Sbellard else 208c896fe29Sbellard s->pool_first = p; 209c896fe29Sbellard } else { 210c896fe29Sbellard p = p->next; 211c896fe29Sbellard } 212c896fe29Sbellard } 213c896fe29Sbellard } 214c896fe29Sbellard s->pool_current = p; 215c896fe29Sbellard s->pool_cur = p->data + size; 216c896fe29Sbellard s->pool_end = p->data + p->size; 217c896fe29Sbellard return p->data; 218c896fe29Sbellard } 219c896fe29Sbellard 220c896fe29Sbellard void tcg_pool_reset(TCGContext *s) 221c896fe29Sbellard { 222c896fe29Sbellard s->pool_cur = s->pool_end = NULL; 223c896fe29Sbellard s->pool_current = NULL; 224c896fe29Sbellard } 225c896fe29Sbellard 226c896fe29Sbellard void tcg_context_init(TCGContext *s) 227c896fe29Sbellard { 228c896fe29Sbellard int op, total_args, n; 229c896fe29Sbellard TCGOpDef *def; 230c896fe29Sbellard TCGArgConstraint *args_ct; 231c896fe29Sbellard int *sorted_args; 232c896fe29Sbellard 233c896fe29Sbellard memset(s, 0, sizeof(*s)); 234c896fe29Sbellard s->temps = s->static_temps; 235c896fe29Sbellard s->nb_globals = 0; 236c896fe29Sbellard 237c896fe29Sbellard /* Count total number of arguments and allocate the corresponding 238c896fe29Sbellard space */ 239c896fe29Sbellard total_args = 0; 240c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 241c896fe29Sbellard def = &tcg_op_defs[op]; 242c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 243c896fe29Sbellard total_args += n; 244c896fe29Sbellard } 245c896fe29Sbellard 2467267c094SAnthony Liguori args_ct = g_malloc(sizeof(TCGArgConstraint) * total_args); 2477267c094SAnthony Liguori sorted_args = g_malloc(sizeof(int) * total_args); 248c896fe29Sbellard 249c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 250c896fe29Sbellard def = &tcg_op_defs[op]; 251c896fe29Sbellard def->args_ct = args_ct; 252c896fe29Sbellard def->sorted_args = sorted_args; 253c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 254c896fe29Sbellard sorted_args += n; 255c896fe29Sbellard args_ct += n; 256c896fe29Sbellard } 257c896fe29Sbellard 258c896fe29Sbellard tcg_target_init(s); 2599002ec79SRichard Henderson } 260b03cce8eSbellard 2619002ec79SRichard Henderson void tcg_prologue_init(TCGContext *s) 2629002ec79SRichard Henderson { 263b03cce8eSbellard /* init global prologue and epilogue */ 264b03cce8eSbellard s->code_buf = code_gen_prologue; 265b03cce8eSbellard s->code_ptr = s->code_buf; 266b03cce8eSbellard tcg_target_qemu_prologue(s); 267b03cce8eSbellard flush_icache_range((unsigned long)s->code_buf, 268b03cce8eSbellard (unsigned long)s->code_ptr); 269c896fe29Sbellard } 270c896fe29Sbellard 271c896fe29Sbellard void tcg_set_frame(TCGContext *s, int reg, 272c896fe29Sbellard tcg_target_long start, tcg_target_long size) 273c896fe29Sbellard { 274c896fe29Sbellard s->frame_start = start; 275c896fe29Sbellard s->frame_end = start + size; 276c896fe29Sbellard s->frame_reg = reg; 277c896fe29Sbellard } 278c896fe29Sbellard 279c896fe29Sbellard void tcg_func_start(TCGContext *s) 280c896fe29Sbellard { 281e8996ee0Sbellard int i; 282c896fe29Sbellard tcg_pool_reset(s); 283c896fe29Sbellard s->nb_temps = s->nb_globals; 284641d5fbeSbellard for(i = 0; i < (TCG_TYPE_COUNT * 2); i++) 285e8996ee0Sbellard s->first_free_temp[i] = -1; 286c896fe29Sbellard s->labels = tcg_malloc(sizeof(TCGLabel) * TCG_MAX_LABELS); 287c896fe29Sbellard s->nb_labels = 0; 288c896fe29Sbellard s->current_frame_offset = s->frame_start; 289c896fe29Sbellard 290c896fe29Sbellard gen_opc_ptr = gen_opc_buf; 291c896fe29Sbellard gen_opparam_ptr = gen_opparam_buf; 292c896fe29Sbellard } 293c896fe29Sbellard 294c896fe29Sbellard static inline void tcg_temp_alloc(TCGContext *s, int n) 295c896fe29Sbellard { 296c896fe29Sbellard if (n > TCG_MAX_TEMPS) 297c896fe29Sbellard tcg_abort(); 298c896fe29Sbellard } 299c896fe29Sbellard 300a7812ae4Spbrook static inline int tcg_global_reg_new_internal(TCGType type, int reg, 301a7812ae4Spbrook const char *name) 302c896fe29Sbellard { 303c896fe29Sbellard TCGContext *s = &tcg_ctx; 304c896fe29Sbellard TCGTemp *ts; 305c896fe29Sbellard int idx; 306c896fe29Sbellard 307c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 308c896fe29Sbellard if (type != TCG_TYPE_I32) 309c896fe29Sbellard tcg_abort(); 310c896fe29Sbellard #endif 311c896fe29Sbellard if (tcg_regset_test_reg(s->reserved_regs, reg)) 312c896fe29Sbellard tcg_abort(); 313c896fe29Sbellard idx = s->nb_globals; 314c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 315c896fe29Sbellard ts = &s->temps[s->nb_globals]; 316c896fe29Sbellard ts->base_type = type; 317c896fe29Sbellard ts->type = type; 318c896fe29Sbellard ts->fixed_reg = 1; 319c896fe29Sbellard ts->reg = reg; 320c896fe29Sbellard ts->name = name; 321c896fe29Sbellard s->nb_globals++; 322c896fe29Sbellard tcg_regset_set_reg(s->reserved_regs, reg); 323a7812ae4Spbrook return idx; 324a7812ae4Spbrook } 325a7812ae4Spbrook 326a7812ae4Spbrook TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name) 327a7812ae4Spbrook { 328a7812ae4Spbrook int idx; 329a7812ae4Spbrook 330a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name); 331a7812ae4Spbrook return MAKE_TCGV_I32(idx); 332a7812ae4Spbrook } 333a7812ae4Spbrook 334a7812ae4Spbrook TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name) 335a7812ae4Spbrook { 336a7812ae4Spbrook int idx; 337a7812ae4Spbrook 338a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I64, reg, name); 339a7812ae4Spbrook return MAKE_TCGV_I64(idx); 340c896fe29Sbellard } 341c896fe29Sbellard 342a7812ae4Spbrook static inline int tcg_global_mem_new_internal(TCGType type, int reg, 343a7812ae4Spbrook tcg_target_long offset, 344c896fe29Sbellard const char *name) 345c896fe29Sbellard { 346c896fe29Sbellard TCGContext *s = &tcg_ctx; 347c896fe29Sbellard TCGTemp *ts; 348c896fe29Sbellard int idx; 349c896fe29Sbellard 350c896fe29Sbellard idx = s->nb_globals; 351c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 352c896fe29Sbellard if (type == TCG_TYPE_I64) { 353c896fe29Sbellard char buf[64]; 354c588979bSths tcg_temp_alloc(s, s->nb_globals + 2); 355c896fe29Sbellard ts = &s->temps[s->nb_globals]; 356c896fe29Sbellard ts->base_type = type; 357c896fe29Sbellard ts->type = TCG_TYPE_I32; 358c896fe29Sbellard ts->fixed_reg = 0; 359c896fe29Sbellard ts->mem_allocated = 1; 360c896fe29Sbellard ts->mem_reg = reg; 361c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 362c896fe29Sbellard ts->mem_offset = offset + 4; 363c896fe29Sbellard #else 364c896fe29Sbellard ts->mem_offset = offset; 365c896fe29Sbellard #endif 366c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 367c896fe29Sbellard pstrcat(buf, sizeof(buf), "_0"); 368c896fe29Sbellard ts->name = strdup(buf); 369c896fe29Sbellard ts++; 370c896fe29Sbellard 371c896fe29Sbellard ts->base_type = type; 372c896fe29Sbellard ts->type = TCG_TYPE_I32; 373c896fe29Sbellard ts->fixed_reg = 0; 374c896fe29Sbellard ts->mem_allocated = 1; 375c896fe29Sbellard ts->mem_reg = reg; 376c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 377c896fe29Sbellard ts->mem_offset = offset; 378c896fe29Sbellard #else 379c896fe29Sbellard ts->mem_offset = offset + 4; 380c896fe29Sbellard #endif 381c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 382c896fe29Sbellard pstrcat(buf, sizeof(buf), "_1"); 383c896fe29Sbellard ts->name = strdup(buf); 384c896fe29Sbellard 385c896fe29Sbellard s->nb_globals += 2; 386c896fe29Sbellard } else 387c896fe29Sbellard #endif 388c896fe29Sbellard { 389c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 390c896fe29Sbellard ts = &s->temps[s->nb_globals]; 391c896fe29Sbellard ts->base_type = type; 392c896fe29Sbellard ts->type = type; 393c896fe29Sbellard ts->fixed_reg = 0; 394c896fe29Sbellard ts->mem_allocated = 1; 395c896fe29Sbellard ts->mem_reg = reg; 396c896fe29Sbellard ts->mem_offset = offset; 397c896fe29Sbellard ts->name = name; 398c896fe29Sbellard s->nb_globals++; 399c896fe29Sbellard } 400a7812ae4Spbrook return idx; 401c896fe29Sbellard } 402c896fe29Sbellard 403a7812ae4Spbrook TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset, 404a7812ae4Spbrook const char *name) 405a7812ae4Spbrook { 406a7812ae4Spbrook int idx; 407a7812ae4Spbrook 408a7812ae4Spbrook idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name); 409a7812ae4Spbrook return MAKE_TCGV_I32(idx); 410a7812ae4Spbrook } 411a7812ae4Spbrook 412a7812ae4Spbrook TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset, 413a7812ae4Spbrook const char *name) 414a7812ae4Spbrook { 415a7812ae4Spbrook int idx; 416a7812ae4Spbrook 417a7812ae4Spbrook idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name); 418a7812ae4Spbrook return MAKE_TCGV_I64(idx); 419a7812ae4Spbrook } 420a7812ae4Spbrook 421a7812ae4Spbrook static inline int tcg_temp_new_internal(TCGType type, int temp_local) 422c896fe29Sbellard { 423c896fe29Sbellard TCGContext *s = &tcg_ctx; 424c896fe29Sbellard TCGTemp *ts; 425641d5fbeSbellard int idx, k; 426c896fe29Sbellard 427641d5fbeSbellard k = type; 428641d5fbeSbellard if (temp_local) 429641d5fbeSbellard k += TCG_TYPE_COUNT; 430641d5fbeSbellard idx = s->first_free_temp[k]; 431e8996ee0Sbellard if (idx != -1) { 432e8996ee0Sbellard /* There is already an available temp with the 433e8996ee0Sbellard right type */ 434e8996ee0Sbellard ts = &s->temps[idx]; 435641d5fbeSbellard s->first_free_temp[k] = ts->next_free_temp; 436e8996ee0Sbellard ts->temp_allocated = 1; 437641d5fbeSbellard assert(ts->temp_local == temp_local); 438e8996ee0Sbellard } else { 439c896fe29Sbellard idx = s->nb_temps; 440c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 441c896fe29Sbellard if (type == TCG_TYPE_I64) { 4428df1ca4bSths tcg_temp_alloc(s, s->nb_temps + 2); 443c896fe29Sbellard ts = &s->temps[s->nb_temps]; 444c896fe29Sbellard ts->base_type = type; 445c896fe29Sbellard ts->type = TCG_TYPE_I32; 446e8996ee0Sbellard ts->temp_allocated = 1; 447641d5fbeSbellard ts->temp_local = temp_local; 448c896fe29Sbellard ts->name = NULL; 449c896fe29Sbellard ts++; 450c896fe29Sbellard ts->base_type = TCG_TYPE_I32; 451c896fe29Sbellard ts->type = TCG_TYPE_I32; 452e8996ee0Sbellard ts->temp_allocated = 1; 453641d5fbeSbellard ts->temp_local = temp_local; 454c896fe29Sbellard ts->name = NULL; 455c896fe29Sbellard s->nb_temps += 2; 456c896fe29Sbellard } else 457c896fe29Sbellard #endif 458c896fe29Sbellard { 459c896fe29Sbellard tcg_temp_alloc(s, s->nb_temps + 1); 460c896fe29Sbellard ts = &s->temps[s->nb_temps]; 461c896fe29Sbellard ts->base_type = type; 462c896fe29Sbellard ts->type = type; 463e8996ee0Sbellard ts->temp_allocated = 1; 464641d5fbeSbellard ts->temp_local = temp_local; 465c896fe29Sbellard ts->name = NULL; 466c896fe29Sbellard s->nb_temps++; 467c896fe29Sbellard } 468e8996ee0Sbellard } 46927bfd83cSPeter Maydell 47027bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 47127bfd83cSPeter Maydell s->temps_in_use++; 47227bfd83cSPeter Maydell #endif 473a7812ae4Spbrook return idx; 474c896fe29Sbellard } 475c896fe29Sbellard 476a7812ae4Spbrook TCGv_i32 tcg_temp_new_internal_i32(int temp_local) 477a7812ae4Spbrook { 478a7812ae4Spbrook int idx; 479a7812ae4Spbrook 480a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I32, temp_local); 481a7812ae4Spbrook return MAKE_TCGV_I32(idx); 482a7812ae4Spbrook } 483a7812ae4Spbrook 484a7812ae4Spbrook TCGv_i64 tcg_temp_new_internal_i64(int temp_local) 485a7812ae4Spbrook { 486a7812ae4Spbrook int idx; 487a7812ae4Spbrook 488a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I64, temp_local); 489a7812ae4Spbrook return MAKE_TCGV_I64(idx); 490a7812ae4Spbrook } 491a7812ae4Spbrook 492a7812ae4Spbrook static inline void tcg_temp_free_internal(int idx) 493c896fe29Sbellard { 494c896fe29Sbellard TCGContext *s = &tcg_ctx; 495c896fe29Sbellard TCGTemp *ts; 496641d5fbeSbellard int k; 497c896fe29Sbellard 49827bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 49927bfd83cSPeter Maydell s->temps_in_use--; 50027bfd83cSPeter Maydell if (s->temps_in_use < 0) { 50127bfd83cSPeter Maydell fprintf(stderr, "More temporaries freed than allocated!\n"); 50227bfd83cSPeter Maydell } 50327bfd83cSPeter Maydell #endif 50427bfd83cSPeter Maydell 505e8996ee0Sbellard assert(idx >= s->nb_globals && idx < s->nb_temps); 506c896fe29Sbellard ts = &s->temps[idx]; 507e8996ee0Sbellard assert(ts->temp_allocated != 0); 508e8996ee0Sbellard ts->temp_allocated = 0; 509641d5fbeSbellard k = ts->base_type; 510641d5fbeSbellard if (ts->temp_local) 511641d5fbeSbellard k += TCG_TYPE_COUNT; 512641d5fbeSbellard ts->next_free_temp = s->first_free_temp[k]; 513641d5fbeSbellard s->first_free_temp[k] = idx; 514e8996ee0Sbellard } 515e8996ee0Sbellard 516a7812ae4Spbrook void tcg_temp_free_i32(TCGv_i32 arg) 517e8996ee0Sbellard { 518a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I32(arg)); 519a7812ae4Spbrook } 520a7812ae4Spbrook 521a7812ae4Spbrook void tcg_temp_free_i64(TCGv_i64 arg) 522a7812ae4Spbrook { 523a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I64(arg)); 524a7812ae4Spbrook } 525a7812ae4Spbrook 526a7812ae4Spbrook TCGv_i32 tcg_const_i32(int32_t val) 527a7812ae4Spbrook { 528a7812ae4Spbrook TCGv_i32 t0; 529a7812ae4Spbrook t0 = tcg_temp_new_i32(); 530e8996ee0Sbellard tcg_gen_movi_i32(t0, val); 531e8996ee0Sbellard return t0; 532c896fe29Sbellard } 533c896fe29Sbellard 534a7812ae4Spbrook TCGv_i64 tcg_const_i64(int64_t val) 535c896fe29Sbellard { 536a7812ae4Spbrook TCGv_i64 t0; 537a7812ae4Spbrook t0 = tcg_temp_new_i64(); 538e8996ee0Sbellard tcg_gen_movi_i64(t0, val); 539e8996ee0Sbellard return t0; 540c896fe29Sbellard } 541c896fe29Sbellard 542a7812ae4Spbrook TCGv_i32 tcg_const_local_i32(int32_t val) 543bdffd4a9Saurel32 { 544a7812ae4Spbrook TCGv_i32 t0; 545a7812ae4Spbrook t0 = tcg_temp_local_new_i32(); 546bdffd4a9Saurel32 tcg_gen_movi_i32(t0, val); 547bdffd4a9Saurel32 return t0; 548bdffd4a9Saurel32 } 549bdffd4a9Saurel32 550a7812ae4Spbrook TCGv_i64 tcg_const_local_i64(int64_t val) 551bdffd4a9Saurel32 { 552a7812ae4Spbrook TCGv_i64 t0; 553a7812ae4Spbrook t0 = tcg_temp_local_new_i64(); 554bdffd4a9Saurel32 tcg_gen_movi_i64(t0, val); 555bdffd4a9Saurel32 return t0; 556bdffd4a9Saurel32 } 557bdffd4a9Saurel32 55827bfd83cSPeter Maydell #if defined(CONFIG_DEBUG_TCG) 55927bfd83cSPeter Maydell void tcg_clear_temp_count(void) 56027bfd83cSPeter Maydell { 56127bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 56227bfd83cSPeter Maydell s->temps_in_use = 0; 56327bfd83cSPeter Maydell } 56427bfd83cSPeter Maydell 56527bfd83cSPeter Maydell int tcg_check_temp_count(void) 56627bfd83cSPeter Maydell { 56727bfd83cSPeter Maydell TCGContext *s = &tcg_ctx; 56827bfd83cSPeter Maydell if (s->temps_in_use) { 56927bfd83cSPeter Maydell /* Clear the count so that we don't give another 57027bfd83cSPeter Maydell * warning immediately next time around. 57127bfd83cSPeter Maydell */ 57227bfd83cSPeter Maydell s->temps_in_use = 0; 57327bfd83cSPeter Maydell return 1; 57427bfd83cSPeter Maydell } 57527bfd83cSPeter Maydell return 0; 57627bfd83cSPeter Maydell } 57727bfd83cSPeter Maydell #endif 57827bfd83cSPeter Maydell 579c896fe29Sbellard void tcg_register_helper(void *func, const char *name) 580c896fe29Sbellard { 581c896fe29Sbellard TCGContext *s = &tcg_ctx; 582c896fe29Sbellard int n; 583c896fe29Sbellard if ((s->nb_helpers + 1) > s->allocated_helpers) { 584c896fe29Sbellard n = s->allocated_helpers; 585c896fe29Sbellard if (n == 0) { 586c896fe29Sbellard n = 4; 587c896fe29Sbellard } else { 588c896fe29Sbellard n *= 2; 589c896fe29Sbellard } 590c896fe29Sbellard s->helpers = realloc(s->helpers, n * sizeof(TCGHelperInfo)); 591c896fe29Sbellard s->allocated_helpers = n; 592c896fe29Sbellard } 5934dc81f28Sbellard s->helpers[s->nb_helpers].func = (tcg_target_ulong)func; 594c896fe29Sbellard s->helpers[s->nb_helpers].name = name; 595c896fe29Sbellard s->nb_helpers++; 596c896fe29Sbellard } 597c896fe29Sbellard 59839cf05d3Sbellard /* Note: we convert the 64 bit args to 32 bit and do some alignment 59939cf05d3Sbellard and endian swap. Maybe it would be better to do the alignment 60039cf05d3Sbellard and endian swap in tcg_reg_alloc_call(). */ 601a7812ae4Spbrook void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags, 602a7812ae4Spbrook int sizemask, TCGArg ret, int nargs, TCGArg *args) 603c896fe29Sbellard { 604568fffe3SChristophe Fergeau #if defined(TCG_TARGET_I386) && TCG_TARGET_REG_BITS < 64 605a7812ae4Spbrook int call_type; 6069678d950SBlue Swirl #endif 607a7812ae4Spbrook int i; 608a7812ae4Spbrook int real_args; 609a7812ae4Spbrook int nb_rets; 610a7812ae4Spbrook TCGArg *nparam; 6112bece2c8SRichard Henderson 6122bece2c8SRichard Henderson #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 6132bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 6142bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 6152bece2c8SRichard Henderson int is_signed = sizemask & (2 << (i+1)*2); 6162bece2c8SRichard Henderson if (!is_64bit) { 6172bece2c8SRichard Henderson TCGv_i64 temp = tcg_temp_new_i64(); 6182bece2c8SRichard Henderson TCGv_i64 orig = MAKE_TCGV_I64(args[i]); 6192bece2c8SRichard Henderson if (is_signed) { 6202bece2c8SRichard Henderson tcg_gen_ext32s_i64(temp, orig); 6212bece2c8SRichard Henderson } else { 6222bece2c8SRichard Henderson tcg_gen_ext32u_i64(temp, orig); 6232bece2c8SRichard Henderson } 6242bece2c8SRichard Henderson args[i] = GET_TCGV_I64(temp); 6252bece2c8SRichard Henderson } 6262bece2c8SRichard Henderson } 6272bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 6282bece2c8SRichard Henderson 629a7812ae4Spbrook *gen_opc_ptr++ = INDEX_op_call; 630a7812ae4Spbrook nparam = gen_opparam_ptr++; 631568fffe3SChristophe Fergeau #if defined(TCG_TARGET_I386) && TCG_TARGET_REG_BITS < 64 632c896fe29Sbellard call_type = (flags & TCG_CALL_TYPE_MASK); 6339678d950SBlue Swirl #endif 634a7812ae4Spbrook if (ret != TCG_CALL_DUMMY_ARG) { 635a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 636a7812ae4Spbrook if (sizemask & 1) { 637a7812ae4Spbrook #ifdef TCG_TARGET_WORDS_BIGENDIAN 638a7812ae4Spbrook *gen_opparam_ptr++ = ret + 1; 639a7812ae4Spbrook *gen_opparam_ptr++ = ret; 640a7812ae4Spbrook #else 641a7812ae4Spbrook *gen_opparam_ptr++ = ret; 642a7812ae4Spbrook *gen_opparam_ptr++ = ret + 1; 643a7812ae4Spbrook #endif 644a7812ae4Spbrook nb_rets = 2; 645a7812ae4Spbrook } else 646a7812ae4Spbrook #endif 647a7812ae4Spbrook { 648a7812ae4Spbrook *gen_opparam_ptr++ = ret; 649a7812ae4Spbrook nb_rets = 1; 650a7812ae4Spbrook } 651a7812ae4Spbrook } else { 652a7812ae4Spbrook nb_rets = 0; 653a7812ae4Spbrook } 654a7812ae4Spbrook real_args = 0; 655a7812ae4Spbrook for (i = 0; i < nargs; i++) { 656a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 6572bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 6582bece2c8SRichard Henderson if (is_64bit) { 659c896fe29Sbellard #ifdef TCG_TARGET_I386 660c896fe29Sbellard /* REGPARM case: if the third parameter is 64 bit, it is 661c896fe29Sbellard allocated on the stack */ 662a7812ae4Spbrook if (i == 2 && call_type == TCG_CALL_TYPE_REGPARM) { 663c896fe29Sbellard call_type = TCG_CALL_TYPE_REGPARM_2; 664c896fe29Sbellard flags = (flags & ~TCG_CALL_TYPE_MASK) | call_type; 665c896fe29Sbellard } 666a7812ae4Spbrook #endif 66739cf05d3Sbellard #ifdef TCG_TARGET_CALL_ALIGN_ARGS 66839cf05d3Sbellard /* some targets want aligned 64 bit args */ 669ebd486d5Smalc if (real_args & 1) { 670a7812ae4Spbrook *gen_opparam_ptr++ = TCG_CALL_DUMMY_ARG; 671ebd486d5Smalc real_args++; 67239cf05d3Sbellard } 67339cf05d3Sbellard #endif 6743f90f252SRichard Henderson /* If stack grows up, then we will be placing successive 6753f90f252SRichard Henderson arguments at lower addresses, which means we need to 6763f90f252SRichard Henderson reverse the order compared to how we would normally 6773f90f252SRichard Henderson treat either big or little-endian. For those arguments 6783f90f252SRichard Henderson that will wind up in registers, this still works for 6793f90f252SRichard Henderson HPPA (the only current STACK_GROWSUP target) since the 6803f90f252SRichard Henderson argument registers are *also* allocated in decreasing 6813f90f252SRichard Henderson order. If another such target is added, this logic may 6823f90f252SRichard Henderson have to get more complicated to differentiate between 6833f90f252SRichard Henderson stack arguments and register arguments. */ 6843f90f252SRichard Henderson #if defined(TCG_TARGET_WORDS_BIGENDIAN) != defined(TCG_TARGET_STACK_GROWSUP) 685a7812ae4Spbrook *gen_opparam_ptr++ = args[i] + 1; 686a7812ae4Spbrook *gen_opparam_ptr++ = args[i]; 687c896fe29Sbellard #else 688a7812ae4Spbrook *gen_opparam_ptr++ = args[i]; 689a7812ae4Spbrook *gen_opparam_ptr++ = args[i] + 1; 690c896fe29Sbellard #endif 691a7812ae4Spbrook real_args += 2; 6922bece2c8SRichard Henderson continue; 6932bece2c8SRichard Henderson } 6942bece2c8SRichard Henderson #endif /* TCG_TARGET_REG_BITS < 64 */ 6952bece2c8SRichard Henderson 696a7812ae4Spbrook *gen_opparam_ptr++ = args[i]; 697a7812ae4Spbrook real_args++; 698c896fe29Sbellard } 699a7812ae4Spbrook *gen_opparam_ptr++ = GET_TCGV_PTR(func); 700a7812ae4Spbrook 701a7812ae4Spbrook *gen_opparam_ptr++ = flags; 702a7812ae4Spbrook 703a7812ae4Spbrook *nparam = (nb_rets << 16) | (real_args + 1); 704a7812ae4Spbrook 705a7812ae4Spbrook /* total parameters, needed to go backward in the instruction stream */ 706a7812ae4Spbrook *gen_opparam_ptr++ = 1 + nb_rets + real_args + 3; 7072bece2c8SRichard Henderson 7082bece2c8SRichard Henderson #if defined(TCG_TARGET_EXTEND_ARGS) && TCG_TARGET_REG_BITS == 64 7092bece2c8SRichard Henderson for (i = 0; i < nargs; ++i) { 7102bece2c8SRichard Henderson int is_64bit = sizemask & (1 << (i+1)*2); 7112bece2c8SRichard Henderson if (!is_64bit) { 7122bece2c8SRichard Henderson TCGv_i64 temp = MAKE_TCGV_I64(args[i]); 7132bece2c8SRichard Henderson tcg_temp_free_i64(temp); 7142bece2c8SRichard Henderson } 7152bece2c8SRichard Henderson } 7162bece2c8SRichard Henderson #endif /* TCG_TARGET_EXTEND_ARGS */ 717a7812ae4Spbrook } 718c896fe29Sbellard 719ac56dd48Spbrook #if TCG_TARGET_REG_BITS == 32 720a7812ae4Spbrook void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, 721c896fe29Sbellard int c, int right, int arith) 722c896fe29Sbellard { 723cf60bce4Sbellard if (c == 0) { 724a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1)); 725cf60bce4Sbellard tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1)); 726cf60bce4Sbellard } else if (c >= 32) { 727c896fe29Sbellard c -= 32; 728c896fe29Sbellard if (right) { 729c896fe29Sbellard if (arith) { 730a7812ae4Spbrook tcg_gen_sari_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 731ac56dd48Spbrook tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 31); 732c896fe29Sbellard } else { 733a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 734ac56dd48Spbrook tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 735c896fe29Sbellard } 736c896fe29Sbellard } else { 737a7812ae4Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_LOW(arg1), c); 738a7812ae4Spbrook tcg_gen_movi_i32(TCGV_LOW(ret), 0); 739c896fe29Sbellard } 740c896fe29Sbellard } else { 741a7812ae4Spbrook TCGv_i32 t0, t1; 742c896fe29Sbellard 743a7812ae4Spbrook t0 = tcg_temp_new_i32(); 744a7812ae4Spbrook t1 = tcg_temp_new_i32(); 745c896fe29Sbellard if (right) { 746ac56dd48Spbrook tcg_gen_shli_i32(t0, TCGV_HIGH(arg1), 32 - c); 747c896fe29Sbellard if (arith) 748ac56dd48Spbrook tcg_gen_sari_i32(t1, TCGV_HIGH(arg1), c); 749c896fe29Sbellard else 750ac56dd48Spbrook tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c); 751a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_LOW(arg1), c); 752a7812ae4Spbrook tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t0); 753ac56dd48Spbrook tcg_gen_mov_i32(TCGV_HIGH(ret), t1); 754c896fe29Sbellard } else { 755a7812ae4Spbrook tcg_gen_shri_i32(t0, TCGV_LOW(arg1), 32 - c); 756c896fe29Sbellard /* Note: ret can be the same as arg1, so we use t1 */ 757a7812ae4Spbrook tcg_gen_shli_i32(t1, TCGV_LOW(arg1), c); 758ac56dd48Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c); 759ac56dd48Spbrook tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0); 760a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), t1); 761c896fe29Sbellard } 762a7812ae4Spbrook tcg_temp_free_i32(t0); 763a7812ae4Spbrook tcg_temp_free_i32(t1); 764c896fe29Sbellard } 765c896fe29Sbellard } 766ac56dd48Spbrook #endif 767c896fe29Sbellard 768be210acbSRichard Henderson 7698fcd3692Sblueswir1 static void tcg_reg_alloc_start(TCGContext *s) 770c896fe29Sbellard { 771c896fe29Sbellard int i; 772c896fe29Sbellard TCGTemp *ts; 773c896fe29Sbellard for(i = 0; i < s->nb_globals; i++) { 774c896fe29Sbellard ts = &s->temps[i]; 775c896fe29Sbellard if (ts->fixed_reg) { 776c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 777c896fe29Sbellard } else { 778c896fe29Sbellard ts->val_type = TEMP_VAL_MEM; 779c896fe29Sbellard } 780c896fe29Sbellard } 781e8996ee0Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 782e8996ee0Sbellard ts = &s->temps[i]; 783e8996ee0Sbellard ts->val_type = TEMP_VAL_DEAD; 784e8996ee0Sbellard ts->mem_allocated = 0; 785e8996ee0Sbellard ts->fixed_reg = 0; 786e8996ee0Sbellard } 787c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 788c896fe29Sbellard s->reg_to_temp[i] = -1; 789c896fe29Sbellard } 790c896fe29Sbellard } 791c896fe29Sbellard 792ac56dd48Spbrook static char *tcg_get_arg_str_idx(TCGContext *s, char *buf, int buf_size, 793ac56dd48Spbrook int idx) 794c896fe29Sbellard { 795c896fe29Sbellard TCGTemp *ts; 796ac56dd48Spbrook 797*7f6f0ae5SStefan Weil assert(idx >= 0 && idx < s->nb_temps); 798ac56dd48Spbrook ts = &s->temps[idx]; 799*7f6f0ae5SStefan Weil assert(ts); 800ac56dd48Spbrook if (idx < s->nb_globals) { 801ac56dd48Spbrook pstrcpy(buf, buf_size, ts->name); 802c896fe29Sbellard } else { 803641d5fbeSbellard if (ts->temp_local) 804641d5fbeSbellard snprintf(buf, buf_size, "loc%d", idx - s->nb_globals); 805641d5fbeSbellard else 806ac56dd48Spbrook snprintf(buf, buf_size, "tmp%d", idx - s->nb_globals); 807c896fe29Sbellard } 808c896fe29Sbellard return buf; 809c896fe29Sbellard } 810c896fe29Sbellard 811a7812ae4Spbrook char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg) 812ac56dd48Spbrook { 813a7812ae4Spbrook return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I32(arg)); 814a7812ae4Spbrook } 815a7812ae4Spbrook 816a7812ae4Spbrook char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg) 817a7812ae4Spbrook { 818a810a2deSblueswir1 return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I64(arg)); 819ac56dd48Spbrook } 820ac56dd48Spbrook 821e8996ee0Sbellard static int helper_cmp(const void *p1, const void *p2) 822e8996ee0Sbellard { 823e8996ee0Sbellard const TCGHelperInfo *th1 = p1; 824e8996ee0Sbellard const TCGHelperInfo *th2 = p2; 825e8996ee0Sbellard if (th1->func < th2->func) 826e8996ee0Sbellard return -1; 827e8996ee0Sbellard else if (th1->func == th2->func) 828e8996ee0Sbellard return 0; 829e8996ee0Sbellard else 830e8996ee0Sbellard return 1; 831e8996ee0Sbellard } 832e8996ee0Sbellard 833e8996ee0Sbellard /* find helper definition (Note: A hash table would be better) */ 8344dc81f28Sbellard static TCGHelperInfo *tcg_find_helper(TCGContext *s, tcg_target_ulong val) 8354dc81f28Sbellard { 836e8996ee0Sbellard int m, m_min, m_max; 837e8996ee0Sbellard TCGHelperInfo *th; 838e8996ee0Sbellard tcg_target_ulong v; 839e8996ee0Sbellard 840e8996ee0Sbellard if (unlikely(!s->helpers_sorted)) { 841e8996ee0Sbellard qsort(s->helpers, s->nb_helpers, sizeof(TCGHelperInfo), 842e8996ee0Sbellard helper_cmp); 843e8996ee0Sbellard s->helpers_sorted = 1; 844e8996ee0Sbellard } 845e8996ee0Sbellard 846e8996ee0Sbellard /* binary search */ 847e8996ee0Sbellard m_min = 0; 848e8996ee0Sbellard m_max = s->nb_helpers - 1; 849e8996ee0Sbellard while (m_min <= m_max) { 850e8996ee0Sbellard m = (m_min + m_max) >> 1; 851e8996ee0Sbellard th = &s->helpers[m]; 852e8996ee0Sbellard v = th->func; 853e8996ee0Sbellard if (v == val) 854e8996ee0Sbellard return th; 855e8996ee0Sbellard else if (val < v) { 856e8996ee0Sbellard m_max = m - 1; 857e8996ee0Sbellard } else { 858e8996ee0Sbellard m_min = m + 1; 859e8996ee0Sbellard } 8604dc81f28Sbellard } 8614dc81f28Sbellard return NULL; 8624dc81f28Sbellard } 8634dc81f28Sbellard 864f48f3edeSblueswir1 static const char * const cond_name[] = 865f48f3edeSblueswir1 { 866f48f3edeSblueswir1 [TCG_COND_EQ] = "eq", 867f48f3edeSblueswir1 [TCG_COND_NE] = "ne", 868f48f3edeSblueswir1 [TCG_COND_LT] = "lt", 869f48f3edeSblueswir1 [TCG_COND_GE] = "ge", 870f48f3edeSblueswir1 [TCG_COND_LE] = "le", 871f48f3edeSblueswir1 [TCG_COND_GT] = "gt", 872f48f3edeSblueswir1 [TCG_COND_LTU] = "ltu", 873f48f3edeSblueswir1 [TCG_COND_GEU] = "geu", 874f48f3edeSblueswir1 [TCG_COND_LEU] = "leu", 875f48f3edeSblueswir1 [TCG_COND_GTU] = "gtu" 876f48f3edeSblueswir1 }; 877f48f3edeSblueswir1 878c896fe29Sbellard void tcg_dump_ops(TCGContext *s, FILE *outfile) 879c896fe29Sbellard { 880c896fe29Sbellard const uint16_t *opc_ptr; 881c896fe29Sbellard const TCGArg *args; 882c896fe29Sbellard TCGArg arg; 883a9751609SRichard Henderson TCGOpcode c; 884a9751609SRichard Henderson int i, k, nb_oargs, nb_iargs, nb_cargs, first_insn; 885c896fe29Sbellard const TCGOpDef *def; 886c896fe29Sbellard char buf[128]; 887c896fe29Sbellard 8887e4597d7Sbellard first_insn = 1; 889c896fe29Sbellard opc_ptr = gen_opc_buf; 890c896fe29Sbellard args = gen_opparam_buf; 891c896fe29Sbellard while (opc_ptr < gen_opc_ptr) { 892c896fe29Sbellard c = *opc_ptr++; 893c896fe29Sbellard def = &tcg_op_defs[c]; 8947e4597d7Sbellard if (c == INDEX_op_debug_insn_start) { 8957e4597d7Sbellard uint64_t pc; 8967e4597d7Sbellard #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS 8977e4597d7Sbellard pc = ((uint64_t)args[1] << 32) | args[0]; 8987e4597d7Sbellard #else 8997e4597d7Sbellard pc = args[0]; 9007e4597d7Sbellard #endif 9017e4597d7Sbellard if (!first_insn) 9027e4597d7Sbellard fprintf(outfile, "\n"); 9037e4597d7Sbellard fprintf(outfile, " ---- 0x%" PRIx64, pc); 9047e4597d7Sbellard first_insn = 0; 9057e4597d7Sbellard nb_oargs = def->nb_oargs; 9067e4597d7Sbellard nb_iargs = def->nb_iargs; 9077e4597d7Sbellard nb_cargs = def->nb_cargs; 9087e4597d7Sbellard } else if (c == INDEX_op_call) { 909c896fe29Sbellard TCGArg arg; 9104dc81f28Sbellard 911c896fe29Sbellard /* variable number of arguments */ 912c896fe29Sbellard arg = *args++; 913c896fe29Sbellard nb_oargs = arg >> 16; 914c896fe29Sbellard nb_iargs = arg & 0xffff; 915c896fe29Sbellard nb_cargs = def->nb_cargs; 916b03cce8eSbellard 9177e4597d7Sbellard fprintf(outfile, " %s ", def->name); 9187e4597d7Sbellard 919b03cce8eSbellard /* function name */ 920b03cce8eSbellard fprintf(outfile, "%s", 921e8996ee0Sbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + nb_iargs - 1])); 922b03cce8eSbellard /* flags */ 923b03cce8eSbellard fprintf(outfile, ",$0x%" TCG_PRIlx, 924b03cce8eSbellard args[nb_oargs + nb_iargs]); 925b03cce8eSbellard /* nb out args */ 926b03cce8eSbellard fprintf(outfile, ",$%d", nb_oargs); 927b03cce8eSbellard for(i = 0; i < nb_oargs; i++) { 928b03cce8eSbellard fprintf(outfile, ","); 929b03cce8eSbellard fprintf(outfile, "%s", 930b03cce8eSbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[i])); 931b03cce8eSbellard } 932b03cce8eSbellard for(i = 0; i < (nb_iargs - 1); i++) { 933b03cce8eSbellard fprintf(outfile, ","); 93439cf05d3Sbellard if (args[nb_oargs + i] == TCG_CALL_DUMMY_ARG) { 93539cf05d3Sbellard fprintf(outfile, "<dummy>"); 93639cf05d3Sbellard } else { 937b03cce8eSbellard fprintf(outfile, "%s", 938b03cce8eSbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + i])); 939b03cce8eSbellard } 94039cf05d3Sbellard } 941e8996ee0Sbellard } else if (c == INDEX_op_movi_i32 942e8996ee0Sbellard #if TCG_TARGET_REG_BITS == 64 943e8996ee0Sbellard || c == INDEX_op_movi_i64 944e8996ee0Sbellard #endif 945e8996ee0Sbellard ) { 946e8996ee0Sbellard tcg_target_ulong val; 947e8996ee0Sbellard TCGHelperInfo *th; 948e8996ee0Sbellard 949e8996ee0Sbellard nb_oargs = def->nb_oargs; 950e8996ee0Sbellard nb_iargs = def->nb_iargs; 951e8996ee0Sbellard nb_cargs = def->nb_cargs; 952e8996ee0Sbellard fprintf(outfile, " %s %s,$", def->name, 953e8996ee0Sbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[0])); 954e8996ee0Sbellard val = args[1]; 955e8996ee0Sbellard th = tcg_find_helper(s, val); 956e8996ee0Sbellard if (th) { 9573e9a474eSaurel32 fprintf(outfile, "%s", th->name); 958e8996ee0Sbellard } else { 959e8996ee0Sbellard if (c == INDEX_op_movi_i32) 960e8996ee0Sbellard fprintf(outfile, "0x%x", (uint32_t)val); 961e8996ee0Sbellard else 962e8996ee0Sbellard fprintf(outfile, "0x%" PRIx64 , (uint64_t)val); 963e8996ee0Sbellard } 964b03cce8eSbellard } else { 9657e4597d7Sbellard fprintf(outfile, " %s ", def->name); 966b03cce8eSbellard if (c == INDEX_op_nopn) { 967c896fe29Sbellard /* variable number of arguments */ 968c896fe29Sbellard nb_cargs = *args; 969c896fe29Sbellard nb_oargs = 0; 970c896fe29Sbellard nb_iargs = 0; 971c896fe29Sbellard } else { 972c896fe29Sbellard nb_oargs = def->nb_oargs; 973c896fe29Sbellard nb_iargs = def->nb_iargs; 974c896fe29Sbellard nb_cargs = def->nb_cargs; 975c896fe29Sbellard } 976c896fe29Sbellard 977c896fe29Sbellard k = 0; 978c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 979c896fe29Sbellard if (k != 0) 980c896fe29Sbellard fprintf(outfile, ","); 981ac56dd48Spbrook fprintf(outfile, "%s", 982ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), args[k++])); 983c896fe29Sbellard } 984c896fe29Sbellard for(i = 0; i < nb_iargs; i++) { 985c896fe29Sbellard if (k != 0) 986c896fe29Sbellard fprintf(outfile, ","); 987ac56dd48Spbrook fprintf(outfile, "%s", 988ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), args[k++])); 989c896fe29Sbellard } 990be210acbSRichard Henderson switch (c) { 991be210acbSRichard Henderson case INDEX_op_brcond_i32: 992f48f3edeSblueswir1 #if TCG_TARGET_REG_BITS == 32 993be210acbSRichard Henderson case INDEX_op_brcond2_i32: 994f48f3edeSblueswir1 #elif TCG_TARGET_REG_BITS == 64 995be210acbSRichard Henderson case INDEX_op_brcond_i64: 996f48f3edeSblueswir1 #endif 997be210acbSRichard Henderson case INDEX_op_setcond_i32: 998be210acbSRichard Henderson #if TCG_TARGET_REG_BITS == 32 999be210acbSRichard Henderson case INDEX_op_setcond2_i32: 1000be210acbSRichard Henderson #elif TCG_TARGET_REG_BITS == 64 1001be210acbSRichard Henderson case INDEX_op_setcond_i64: 1002be210acbSRichard Henderson #endif 1003f48f3edeSblueswir1 if (args[k] < ARRAY_SIZE(cond_name) && cond_name[args[k]]) 1004f48f3edeSblueswir1 fprintf(outfile, ",%s", cond_name[args[k++]]); 1005f48f3edeSblueswir1 else 1006f48f3edeSblueswir1 fprintf(outfile, ",$0x%" TCG_PRIlx, args[k++]); 1007f48f3edeSblueswir1 i = 1; 1008be210acbSRichard Henderson break; 1009be210acbSRichard Henderson default: 1010f48f3edeSblueswir1 i = 0; 1011be210acbSRichard Henderson break; 1012be210acbSRichard Henderson } 1013f48f3edeSblueswir1 for(; i < nb_cargs; i++) { 1014c896fe29Sbellard if (k != 0) 1015c896fe29Sbellard fprintf(outfile, ","); 1016c896fe29Sbellard arg = args[k++]; 1017c896fe29Sbellard fprintf(outfile, "$0x%" TCG_PRIlx, arg); 1018c896fe29Sbellard } 1019b03cce8eSbellard } 1020c896fe29Sbellard fprintf(outfile, "\n"); 1021c896fe29Sbellard args += nb_iargs + nb_oargs + nb_cargs; 1022c896fe29Sbellard } 1023c896fe29Sbellard } 1024c896fe29Sbellard 1025c896fe29Sbellard /* we give more priority to constraints with less registers */ 1026c896fe29Sbellard static int get_constraint_priority(const TCGOpDef *def, int k) 1027c896fe29Sbellard { 1028c896fe29Sbellard const TCGArgConstraint *arg_ct; 1029c896fe29Sbellard 1030c896fe29Sbellard int i, n; 1031c896fe29Sbellard arg_ct = &def->args_ct[k]; 1032c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 1033c896fe29Sbellard /* an alias is equivalent to a single register */ 1034c896fe29Sbellard n = 1; 1035c896fe29Sbellard } else { 1036c896fe29Sbellard if (!(arg_ct->ct & TCG_CT_REG)) 1037c896fe29Sbellard return 0; 1038c896fe29Sbellard n = 0; 1039c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1040c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, i)) 1041c896fe29Sbellard n++; 1042c896fe29Sbellard } 1043c896fe29Sbellard } 1044c896fe29Sbellard return TCG_TARGET_NB_REGS - n + 1; 1045c896fe29Sbellard } 1046c896fe29Sbellard 1047c896fe29Sbellard /* sort from highest priority to lowest */ 1048c896fe29Sbellard static void sort_constraints(TCGOpDef *def, int start, int n) 1049c896fe29Sbellard { 1050c896fe29Sbellard int i, j, p1, p2, tmp; 1051c896fe29Sbellard 1052c896fe29Sbellard for(i = 0; i < n; i++) 1053c896fe29Sbellard def->sorted_args[start + i] = start + i; 1054c896fe29Sbellard if (n <= 1) 1055c896fe29Sbellard return; 1056c896fe29Sbellard for(i = 0; i < n - 1; i++) { 1057c896fe29Sbellard for(j = i + 1; j < n; j++) { 1058c896fe29Sbellard p1 = get_constraint_priority(def, def->sorted_args[start + i]); 1059c896fe29Sbellard p2 = get_constraint_priority(def, def->sorted_args[start + j]); 1060c896fe29Sbellard if (p1 < p2) { 1061c896fe29Sbellard tmp = def->sorted_args[start + i]; 1062c896fe29Sbellard def->sorted_args[start + i] = def->sorted_args[start + j]; 1063c896fe29Sbellard def->sorted_args[start + j] = tmp; 1064c896fe29Sbellard } 1065c896fe29Sbellard } 1066c896fe29Sbellard } 1067c896fe29Sbellard } 1068c896fe29Sbellard 1069c896fe29Sbellard void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs) 1070c896fe29Sbellard { 1071a9751609SRichard Henderson TCGOpcode op; 1072c896fe29Sbellard TCGOpDef *def; 1073c896fe29Sbellard const char *ct_str; 1074c896fe29Sbellard int i, nb_args; 1075c896fe29Sbellard 1076c896fe29Sbellard for(;;) { 1077a9751609SRichard Henderson if (tdefs->op == (TCGOpcode)-1) 1078c896fe29Sbellard break; 1079c896fe29Sbellard op = tdefs->op; 1080c3b08d0eSStefan Weil assert((unsigned)op < NB_OPS); 1081c896fe29Sbellard def = &tcg_op_defs[op]; 1082c68aaa18SStefan Weil #if defined(CONFIG_DEBUG_TCG) 1083c68aaa18SStefan Weil /* Duplicate entry in op definitions? */ 1084c68aaa18SStefan Weil assert(!def->used); 1085c68aaa18SStefan Weil def->used = 1; 1086c68aaa18SStefan Weil #endif 1087c896fe29Sbellard nb_args = def->nb_iargs + def->nb_oargs; 1088c896fe29Sbellard for(i = 0; i < nb_args; i++) { 1089c896fe29Sbellard ct_str = tdefs->args_ct_str[i]; 1090c68aaa18SStefan Weil /* Incomplete TCGTargetOpDef entry? */ 1091c68aaa18SStefan Weil assert(ct_str != NULL); 1092c896fe29Sbellard tcg_regset_clear(def->args_ct[i].u.regs); 1093c896fe29Sbellard def->args_ct[i].ct = 0; 1094c896fe29Sbellard if (ct_str[0] >= '0' && ct_str[0] <= '9') { 1095c896fe29Sbellard int oarg; 1096c896fe29Sbellard oarg = ct_str[0] - '0'; 1097c896fe29Sbellard assert(oarg < def->nb_oargs); 1098c896fe29Sbellard assert(def->args_ct[oarg].ct & TCG_CT_REG); 1099c896fe29Sbellard /* TCG_CT_ALIAS is for the output arguments. The input 11005ff9d6a4Sbellard argument is tagged with TCG_CT_IALIAS. */ 1101c896fe29Sbellard def->args_ct[i] = def->args_ct[oarg]; 11025ff9d6a4Sbellard def->args_ct[oarg].ct = TCG_CT_ALIAS; 11035ff9d6a4Sbellard def->args_ct[oarg].alias_index = i; 1104c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_IALIAS; 11055ff9d6a4Sbellard def->args_ct[i].alias_index = oarg; 1106c896fe29Sbellard } else { 1107c896fe29Sbellard for(;;) { 1108c896fe29Sbellard if (*ct_str == '\0') 1109c896fe29Sbellard break; 1110c896fe29Sbellard switch(*ct_str) { 1111c896fe29Sbellard case 'i': 1112c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_CONST; 1113c896fe29Sbellard ct_str++; 1114c896fe29Sbellard break; 1115c896fe29Sbellard default: 1116c896fe29Sbellard if (target_parse_constraint(&def->args_ct[i], &ct_str) < 0) { 1117c896fe29Sbellard fprintf(stderr, "Invalid constraint '%s' for arg %d of operation '%s'\n", 1118c896fe29Sbellard ct_str, i, def->name); 1119c896fe29Sbellard exit(1); 1120c896fe29Sbellard } 1121c896fe29Sbellard } 1122c896fe29Sbellard } 1123c896fe29Sbellard } 1124c896fe29Sbellard } 1125c896fe29Sbellard 1126c68aaa18SStefan Weil /* TCGTargetOpDef entry with too much information? */ 1127c68aaa18SStefan Weil assert(i == TCG_MAX_OP_ARGS || tdefs->args_ct_str[i] == NULL); 1128c68aaa18SStefan Weil 1129c896fe29Sbellard /* sort the constraints (XXX: this is just an heuristic) */ 1130c896fe29Sbellard sort_constraints(def, 0, def->nb_oargs); 1131c896fe29Sbellard sort_constraints(def, def->nb_oargs, def->nb_iargs); 1132c896fe29Sbellard 1133c896fe29Sbellard #if 0 1134c896fe29Sbellard { 1135c896fe29Sbellard int i; 1136c896fe29Sbellard 1137c896fe29Sbellard printf("%s: sorted=", def->name); 1138c896fe29Sbellard for(i = 0; i < def->nb_oargs + def->nb_iargs; i++) 1139c896fe29Sbellard printf(" %d", def->sorted_args[i]); 1140c896fe29Sbellard printf("\n"); 1141c896fe29Sbellard } 1142c896fe29Sbellard #endif 1143c896fe29Sbellard tdefs++; 1144c896fe29Sbellard } 1145c896fe29Sbellard 1146c68aaa18SStefan Weil #if defined(CONFIG_DEBUG_TCG) 1147a9751609SRichard Henderson i = 0; 1148c68aaa18SStefan Weil for (op = 0; op < ARRAY_SIZE(tcg_op_defs); op++) { 1149f412c762SRichard Henderson const TCGOpDef *def = &tcg_op_defs[op]; 1150f412c762SRichard Henderson if (op < INDEX_op_call 1151f412c762SRichard Henderson || op == INDEX_op_debug_insn_start 1152f412c762SRichard Henderson || (def->flags & TCG_OPF_NOT_PRESENT)) { 1153c68aaa18SStefan Weil /* Wrong entry in op definitions? */ 1154f412c762SRichard Henderson if (def->used) { 1155f412c762SRichard Henderson fprintf(stderr, "Invalid op definition for %s\n", def->name); 1156a9751609SRichard Henderson i = 1; 1157a9751609SRichard Henderson } 1158c68aaa18SStefan Weil } else { 1159c68aaa18SStefan Weil /* Missing entry in op definitions? */ 1160f412c762SRichard Henderson if (!def->used) { 1161f412c762SRichard Henderson fprintf(stderr, "Missing op definition for %s\n", def->name); 1162a9751609SRichard Henderson i = 1; 1163c68aaa18SStefan Weil } 1164c68aaa18SStefan Weil } 1165a9751609SRichard Henderson } 1166a9751609SRichard Henderson if (i == 1) { 1167a9751609SRichard Henderson tcg_abort(); 1168a9751609SRichard Henderson } 1169c68aaa18SStefan Weil #endif 1170c896fe29Sbellard } 1171c896fe29Sbellard 1172c896fe29Sbellard #ifdef USE_LIVENESS_ANALYSIS 1173c896fe29Sbellard 1174c896fe29Sbellard /* set a nop for an operation using 'nb_args' */ 1175c896fe29Sbellard static inline void tcg_set_nop(TCGContext *s, uint16_t *opc_ptr, 1176c896fe29Sbellard TCGArg *args, int nb_args) 1177c896fe29Sbellard { 1178c896fe29Sbellard if (nb_args == 0) { 1179c896fe29Sbellard *opc_ptr = INDEX_op_nop; 1180c896fe29Sbellard } else { 1181c896fe29Sbellard *opc_ptr = INDEX_op_nopn; 1182c896fe29Sbellard args[0] = nb_args; 1183c896fe29Sbellard args[nb_args - 1] = nb_args; 1184c896fe29Sbellard } 1185c896fe29Sbellard } 1186c896fe29Sbellard 1187641d5fbeSbellard /* liveness analysis: end of function: globals are live, temps are 1188641d5fbeSbellard dead. */ 1189641d5fbeSbellard /* XXX: at this stage, not used as there would be little gains because 1190641d5fbeSbellard most TBs end with a conditional jump. */ 1191641d5fbeSbellard static inline void tcg_la_func_end(TCGContext *s, uint8_t *dead_temps) 1192c896fe29Sbellard { 1193c896fe29Sbellard memset(dead_temps, 0, s->nb_globals); 1194c896fe29Sbellard memset(dead_temps + s->nb_globals, 1, s->nb_temps - s->nb_globals); 1195c896fe29Sbellard } 1196c896fe29Sbellard 1197641d5fbeSbellard /* liveness analysis: end of basic block: globals are live, temps are 1198641d5fbeSbellard dead, local temps are live. */ 1199641d5fbeSbellard static inline void tcg_la_bb_end(TCGContext *s, uint8_t *dead_temps) 1200641d5fbeSbellard { 1201641d5fbeSbellard int i; 1202641d5fbeSbellard TCGTemp *ts; 1203641d5fbeSbellard 1204641d5fbeSbellard memset(dead_temps, 0, s->nb_globals); 1205641d5fbeSbellard ts = &s->temps[s->nb_globals]; 1206641d5fbeSbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 1207641d5fbeSbellard if (ts->temp_local) 1208641d5fbeSbellard dead_temps[i] = 0; 1209641d5fbeSbellard else 1210641d5fbeSbellard dead_temps[i] = 1; 1211641d5fbeSbellard ts++; 1212641d5fbeSbellard } 1213641d5fbeSbellard } 1214641d5fbeSbellard 1215866cb6cbSAurelien Jarno /* Liveness analysis : update the opc_dead_args array to tell if a 1216c896fe29Sbellard given input arguments is dead. Instructions updating dead 1217c896fe29Sbellard temporaries are removed. */ 12188fcd3692Sblueswir1 static void tcg_liveness_analysis(TCGContext *s) 1219c896fe29Sbellard { 1220a9751609SRichard Henderson int i, op_index, nb_args, nb_iargs, nb_oargs, arg, nb_ops; 1221a9751609SRichard Henderson TCGOpcode op; 1222c896fe29Sbellard TCGArg *args; 1223c896fe29Sbellard const TCGOpDef *def; 1224c896fe29Sbellard uint8_t *dead_temps; 1225866cb6cbSAurelien Jarno unsigned int dead_args; 1226c896fe29Sbellard 1227c896fe29Sbellard gen_opc_ptr++; /* skip end */ 1228c896fe29Sbellard 1229c896fe29Sbellard nb_ops = gen_opc_ptr - gen_opc_buf; 1230c896fe29Sbellard 1231866cb6cbSAurelien Jarno s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t)); 1232c896fe29Sbellard 1233c896fe29Sbellard dead_temps = tcg_malloc(s->nb_temps); 1234c896fe29Sbellard memset(dead_temps, 1, s->nb_temps); 1235c896fe29Sbellard 1236c896fe29Sbellard args = gen_opparam_ptr; 1237c896fe29Sbellard op_index = nb_ops - 1; 1238c896fe29Sbellard while (op_index >= 0) { 1239c896fe29Sbellard op = gen_opc_buf[op_index]; 1240c896fe29Sbellard def = &tcg_op_defs[op]; 1241c896fe29Sbellard switch(op) { 1242c896fe29Sbellard case INDEX_op_call: 1243c6e113f5Sbellard { 1244c6e113f5Sbellard int call_flags; 1245c6e113f5Sbellard 1246c896fe29Sbellard nb_args = args[-1]; 1247c896fe29Sbellard args -= nb_args; 1248c896fe29Sbellard nb_iargs = args[0] & 0xffff; 1249c896fe29Sbellard nb_oargs = args[0] >> 16; 1250c896fe29Sbellard args++; 1251c6e113f5Sbellard call_flags = args[nb_oargs + nb_iargs]; 1252c6e113f5Sbellard 1253c6e113f5Sbellard /* pure functions can be removed if their result is not 1254c6e113f5Sbellard used */ 1255c6e113f5Sbellard if (call_flags & TCG_CALL_PURE) { 1256c6e113f5Sbellard for(i = 0; i < nb_oargs; i++) { 1257c6e113f5Sbellard arg = args[i]; 1258c6e113f5Sbellard if (!dead_temps[arg]) 1259c6e113f5Sbellard goto do_not_remove_call; 1260c6e113f5Sbellard } 1261c6e113f5Sbellard tcg_set_nop(s, gen_opc_buf + op_index, 1262c6e113f5Sbellard args - 1, nb_args); 1263c6e113f5Sbellard } else { 1264c6e113f5Sbellard do_not_remove_call: 1265c896fe29Sbellard 1266c896fe29Sbellard /* output args are dead */ 12676b64b624SAurelien Jarno dead_args = 0; 1268c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1269c896fe29Sbellard arg = args[i]; 12706b64b624SAurelien Jarno if (dead_temps[arg]) { 12716b64b624SAurelien Jarno dead_args |= (1 << i); 12726b64b624SAurelien Jarno } 1273c896fe29Sbellard dead_temps[arg] = 1; 1274c896fe29Sbellard } 1275c896fe29Sbellard 1276b9c18f56Saurel32 if (!(call_flags & TCG_CALL_CONST)) { 1277c896fe29Sbellard /* globals are live (they may be used by the call) */ 1278c896fe29Sbellard memset(dead_temps, 0, s->nb_globals); 1279b9c18f56Saurel32 } 1280c896fe29Sbellard 1281c896fe29Sbellard /* input args are live */ 1282866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 1283866cb6cbSAurelien Jarno arg = args[i]; 128439cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 1285c896fe29Sbellard if (dead_temps[arg]) { 1286866cb6cbSAurelien Jarno dead_args |= (1 << i); 1287c896fe29Sbellard } 1288c896fe29Sbellard dead_temps[arg] = 0; 1289c896fe29Sbellard } 129039cf05d3Sbellard } 1291866cb6cbSAurelien Jarno s->op_dead_args[op_index] = dead_args; 1292c6e113f5Sbellard } 1293c896fe29Sbellard args--; 1294c6e113f5Sbellard } 1295c896fe29Sbellard break; 1296c896fe29Sbellard case INDEX_op_set_label: 1297c896fe29Sbellard args--; 1298c896fe29Sbellard /* mark end of basic block */ 1299c896fe29Sbellard tcg_la_bb_end(s, dead_temps); 1300c896fe29Sbellard break; 13017e4597d7Sbellard case INDEX_op_debug_insn_start: 13027e4597d7Sbellard args -= def->nb_args; 13037e4597d7Sbellard break; 1304c896fe29Sbellard case INDEX_op_nopn: 1305c896fe29Sbellard nb_args = args[-1]; 1306c896fe29Sbellard args -= nb_args; 1307c896fe29Sbellard break; 13085ff9d6a4Sbellard case INDEX_op_discard: 13095ff9d6a4Sbellard args--; 13105ff9d6a4Sbellard /* mark the temporary as dead */ 13115ff9d6a4Sbellard dead_temps[args[0]] = 1; 13125ff9d6a4Sbellard break; 1313c896fe29Sbellard case INDEX_op_end: 1314c896fe29Sbellard break; 1315c896fe29Sbellard /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */ 1316c896fe29Sbellard default: 1317c896fe29Sbellard args -= def->nb_args; 1318c896fe29Sbellard nb_iargs = def->nb_iargs; 1319c896fe29Sbellard nb_oargs = def->nb_oargs; 1320c896fe29Sbellard 1321c896fe29Sbellard /* Test if the operation can be removed because all 13225ff9d6a4Sbellard its outputs are dead. We assume that nb_oargs == 0 13235ff9d6a4Sbellard implies side effects */ 13245ff9d6a4Sbellard if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) { 1325c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1326c896fe29Sbellard arg = args[i]; 1327c896fe29Sbellard if (!dead_temps[arg]) 1328c896fe29Sbellard goto do_not_remove; 1329c896fe29Sbellard } 1330c896fe29Sbellard tcg_set_nop(s, gen_opc_buf + op_index, args, def->nb_args); 1331c896fe29Sbellard #ifdef CONFIG_PROFILER 1332a23a9ec6Sbellard s->del_op_count++; 1333c896fe29Sbellard #endif 1334c896fe29Sbellard } else { 1335c896fe29Sbellard do_not_remove: 1336c896fe29Sbellard 1337c896fe29Sbellard /* output args are dead */ 13386b64b624SAurelien Jarno dead_args = 0; 1339c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1340c896fe29Sbellard arg = args[i]; 13416b64b624SAurelien Jarno if (dead_temps[arg]) { 13426b64b624SAurelien Jarno dead_args |= (1 << i); 13436b64b624SAurelien Jarno } 1344c896fe29Sbellard dead_temps[arg] = 1; 1345c896fe29Sbellard } 1346c896fe29Sbellard 1347c896fe29Sbellard /* if end of basic block, update */ 1348c896fe29Sbellard if (def->flags & TCG_OPF_BB_END) { 1349c896fe29Sbellard tcg_la_bb_end(s, dead_temps); 1350b03cce8eSbellard } else if (def->flags & TCG_OPF_CALL_CLOBBER) { 1351b03cce8eSbellard /* globals are live */ 1352b03cce8eSbellard memset(dead_temps, 0, s->nb_globals); 1353c896fe29Sbellard } 1354c896fe29Sbellard 1355c896fe29Sbellard /* input args are live */ 1356866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 1357866cb6cbSAurelien Jarno arg = args[i]; 1358c896fe29Sbellard if (dead_temps[arg]) { 1359866cb6cbSAurelien Jarno dead_args |= (1 << i); 1360c896fe29Sbellard } 1361c896fe29Sbellard dead_temps[arg] = 0; 1362c896fe29Sbellard } 1363866cb6cbSAurelien Jarno s->op_dead_args[op_index] = dead_args; 1364c896fe29Sbellard } 1365c896fe29Sbellard break; 1366c896fe29Sbellard } 1367c896fe29Sbellard op_index--; 1368c896fe29Sbellard } 1369c896fe29Sbellard 1370c896fe29Sbellard if (args != gen_opparam_buf) 1371c896fe29Sbellard tcg_abort(); 1372c896fe29Sbellard } 1373c896fe29Sbellard #else 1374c896fe29Sbellard /* dummy liveness analysis */ 1375655feed5Smalc static void tcg_liveness_analysis(TCGContext *s) 1376c896fe29Sbellard { 1377c896fe29Sbellard int nb_ops; 1378c896fe29Sbellard nb_ops = gen_opc_ptr - gen_opc_buf; 1379c896fe29Sbellard 1380866cb6cbSAurelien Jarno s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t)); 1381866cb6cbSAurelien Jarno memset(s->op_dead_args, 0, nb_ops * sizeof(uint16_t)); 1382c896fe29Sbellard } 1383c896fe29Sbellard #endif 1384c896fe29Sbellard 1385c896fe29Sbellard #ifndef NDEBUG 1386c896fe29Sbellard static void dump_regs(TCGContext *s) 1387c896fe29Sbellard { 1388c896fe29Sbellard TCGTemp *ts; 1389c896fe29Sbellard int i; 1390c896fe29Sbellard char buf[64]; 1391c896fe29Sbellard 1392c896fe29Sbellard for(i = 0; i < s->nb_temps; i++) { 1393c896fe29Sbellard ts = &s->temps[i]; 1394ac56dd48Spbrook printf(" %10s: ", tcg_get_arg_str_idx(s, buf, sizeof(buf), i)); 1395c896fe29Sbellard switch(ts->val_type) { 1396c896fe29Sbellard case TEMP_VAL_REG: 1397c896fe29Sbellard printf("%s", tcg_target_reg_names[ts->reg]); 1398c896fe29Sbellard break; 1399c896fe29Sbellard case TEMP_VAL_MEM: 1400c896fe29Sbellard printf("%d(%s)", (int)ts->mem_offset, tcg_target_reg_names[ts->mem_reg]); 1401c896fe29Sbellard break; 1402c896fe29Sbellard case TEMP_VAL_CONST: 1403c896fe29Sbellard printf("$0x%" TCG_PRIlx, ts->val); 1404c896fe29Sbellard break; 1405c896fe29Sbellard case TEMP_VAL_DEAD: 1406c896fe29Sbellard printf("D"); 1407c896fe29Sbellard break; 1408c896fe29Sbellard default: 1409c896fe29Sbellard printf("???"); 1410c896fe29Sbellard break; 1411c896fe29Sbellard } 1412c896fe29Sbellard printf("\n"); 1413c896fe29Sbellard } 1414c896fe29Sbellard 1415c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1416c896fe29Sbellard if (s->reg_to_temp[i] >= 0) { 1417c896fe29Sbellard printf("%s: %s\n", 1418c896fe29Sbellard tcg_target_reg_names[i], 1419ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), s->reg_to_temp[i])); 1420c896fe29Sbellard } 1421c896fe29Sbellard } 1422c896fe29Sbellard } 1423c896fe29Sbellard 1424c896fe29Sbellard static void check_regs(TCGContext *s) 1425c896fe29Sbellard { 1426c896fe29Sbellard int reg, k; 1427c896fe29Sbellard TCGTemp *ts; 1428c896fe29Sbellard char buf[64]; 1429c896fe29Sbellard 1430c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1431c896fe29Sbellard k = s->reg_to_temp[reg]; 1432c896fe29Sbellard if (k >= 0) { 1433c896fe29Sbellard ts = &s->temps[k]; 1434c896fe29Sbellard if (ts->val_type != TEMP_VAL_REG || 1435c896fe29Sbellard ts->reg != reg) { 1436c896fe29Sbellard printf("Inconsistency for register %s:\n", 1437c896fe29Sbellard tcg_target_reg_names[reg]); 1438b03cce8eSbellard goto fail; 1439c896fe29Sbellard } 1440c896fe29Sbellard } 1441c896fe29Sbellard } 1442c896fe29Sbellard for(k = 0; k < s->nb_temps; k++) { 1443c896fe29Sbellard ts = &s->temps[k]; 1444c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG && 1445c896fe29Sbellard !ts->fixed_reg && 1446c896fe29Sbellard s->reg_to_temp[ts->reg] != k) { 1447c896fe29Sbellard printf("Inconsistency for temp %s:\n", 1448ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), k)); 1449b03cce8eSbellard fail: 1450c896fe29Sbellard printf("reg state:\n"); 1451c896fe29Sbellard dump_regs(s); 1452c896fe29Sbellard tcg_abort(); 1453c896fe29Sbellard } 1454c896fe29Sbellard } 1455c896fe29Sbellard } 1456c896fe29Sbellard #endif 1457c896fe29Sbellard 1458c896fe29Sbellard static void temp_allocate_frame(TCGContext *s, int temp) 1459c896fe29Sbellard { 1460c896fe29Sbellard TCGTemp *ts; 1461c896fe29Sbellard ts = &s->temps[temp]; 1462f44c9960SBlue Swirl #ifndef __sparc_v9__ /* Sparc64 stack is accessed with offset of 2047 */ 1463b591dc59SBlue Swirl s->current_frame_offset = (s->current_frame_offset + 1464b591dc59SBlue Swirl (tcg_target_long)sizeof(tcg_target_long) - 1) & 1465b591dc59SBlue Swirl ~(sizeof(tcg_target_long) - 1); 1466f44c9960SBlue Swirl #endif 1467b591dc59SBlue Swirl if (s->current_frame_offset + (tcg_target_long)sizeof(tcg_target_long) > 1468b591dc59SBlue Swirl s->frame_end) { 14695ff9d6a4Sbellard tcg_abort(); 1470b591dc59SBlue Swirl } 1471c896fe29Sbellard ts->mem_offset = s->current_frame_offset; 1472c896fe29Sbellard ts->mem_reg = s->frame_reg; 1473c896fe29Sbellard ts->mem_allocated = 1; 1474b591dc59SBlue Swirl s->current_frame_offset += (tcg_target_long)sizeof(tcg_target_long); 1475c896fe29Sbellard } 1476c896fe29Sbellard 1477c896fe29Sbellard /* free register 'reg' by spilling the corresponding temporary if necessary */ 1478c896fe29Sbellard static void tcg_reg_free(TCGContext *s, int reg) 1479c896fe29Sbellard { 1480c896fe29Sbellard TCGTemp *ts; 1481c896fe29Sbellard int temp; 1482c896fe29Sbellard 1483c896fe29Sbellard temp = s->reg_to_temp[reg]; 1484c896fe29Sbellard if (temp != -1) { 1485c896fe29Sbellard ts = &s->temps[temp]; 1486c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 1487c896fe29Sbellard if (!ts->mem_coherent) { 1488c896fe29Sbellard if (!ts->mem_allocated) 1489c896fe29Sbellard temp_allocate_frame(s, temp); 1490e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1491c896fe29Sbellard } 1492c896fe29Sbellard ts->val_type = TEMP_VAL_MEM; 1493c896fe29Sbellard s->reg_to_temp[reg] = -1; 1494c896fe29Sbellard } 1495c896fe29Sbellard } 1496c896fe29Sbellard 1497c896fe29Sbellard /* Allocate a register belonging to reg1 & ~reg2 */ 1498c896fe29Sbellard static int tcg_reg_alloc(TCGContext *s, TCGRegSet reg1, TCGRegSet reg2) 1499c896fe29Sbellard { 1500c896fe29Sbellard int i, reg; 1501c896fe29Sbellard TCGRegSet reg_ct; 1502c896fe29Sbellard 1503c896fe29Sbellard tcg_regset_andnot(reg_ct, reg1, reg2); 1504c896fe29Sbellard 1505c896fe29Sbellard /* first try free registers */ 15060954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1507c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1508c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg) && s->reg_to_temp[reg] == -1) 1509c896fe29Sbellard return reg; 1510c896fe29Sbellard } 1511c896fe29Sbellard 1512c896fe29Sbellard /* XXX: do better spill choice */ 15130954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1514c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1515c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg)) { 1516c896fe29Sbellard tcg_reg_free(s, reg); 1517c896fe29Sbellard return reg; 1518c896fe29Sbellard } 1519c896fe29Sbellard } 1520c896fe29Sbellard 1521c896fe29Sbellard tcg_abort(); 1522c896fe29Sbellard } 1523c896fe29Sbellard 1524641d5fbeSbellard /* save a temporary to memory. 'allocated_regs' is used in case a 1525e8996ee0Sbellard temporary registers needs to be allocated to store a constant. */ 1526641d5fbeSbellard static void temp_save(TCGContext *s, int temp, TCGRegSet allocated_regs) 1527c896fe29Sbellard { 1528c896fe29Sbellard TCGTemp *ts; 1529641d5fbeSbellard int reg; 1530c896fe29Sbellard 1531641d5fbeSbellard ts = &s->temps[temp]; 1532c896fe29Sbellard if (!ts->fixed_reg) { 1533e8996ee0Sbellard switch(ts->val_type) { 1534e8996ee0Sbellard case TEMP_VAL_REG: 1535c896fe29Sbellard tcg_reg_free(s, ts->reg); 1536e8996ee0Sbellard break; 1537e8996ee0Sbellard case TEMP_VAL_DEAD: 1538e5097dc8Sbellard ts->val_type = TEMP_VAL_MEM; 1539e8996ee0Sbellard break; 1540e8996ee0Sbellard case TEMP_VAL_CONST: 15416692b043SAurelien Jarno reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 15426692b043SAurelien Jarno allocated_regs); 1543d6859202SAurelien Jarno if (!ts->mem_allocated) 1544d6859202SAurelien Jarno temp_allocate_frame(s, temp); 1545e8996ee0Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1546e8996ee0Sbellard tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1547e8996ee0Sbellard ts->val_type = TEMP_VAL_MEM; 1548e8996ee0Sbellard break; 1549e8996ee0Sbellard case TEMP_VAL_MEM: 1550e8996ee0Sbellard break; 1551e8996ee0Sbellard default: 1552e8996ee0Sbellard tcg_abort(); 1553c896fe29Sbellard } 1554c896fe29Sbellard } 1555c896fe29Sbellard } 1556641d5fbeSbellard 1557641d5fbeSbellard /* save globals to their cannonical location and assume they can be 1558641d5fbeSbellard modified be the following code. 'allocated_regs' is used in case a 1559641d5fbeSbellard temporary registers needs to be allocated to store a constant. */ 1560641d5fbeSbellard static void save_globals(TCGContext *s, TCGRegSet allocated_regs) 1561641d5fbeSbellard { 1562641d5fbeSbellard int i; 1563641d5fbeSbellard 1564641d5fbeSbellard for(i = 0; i < s->nb_globals; i++) { 1565641d5fbeSbellard temp_save(s, i, allocated_regs); 1566641d5fbeSbellard } 1567e5097dc8Sbellard } 1568e5097dc8Sbellard 1569e5097dc8Sbellard /* at the end of a basic block, we assume all temporaries are dead and 1570e8996ee0Sbellard all globals are stored at their canonical location. */ 1571e8996ee0Sbellard static void tcg_reg_alloc_bb_end(TCGContext *s, TCGRegSet allocated_regs) 1572e5097dc8Sbellard { 1573e5097dc8Sbellard TCGTemp *ts; 1574e5097dc8Sbellard int i; 1575e5097dc8Sbellard 1576c896fe29Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 1577c896fe29Sbellard ts = &s->temps[i]; 1578641d5fbeSbellard if (ts->temp_local) { 1579641d5fbeSbellard temp_save(s, i, allocated_regs); 1580641d5fbeSbellard } else { 1581c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 1582c896fe29Sbellard s->reg_to_temp[ts->reg] = -1; 1583c896fe29Sbellard } 1584c896fe29Sbellard ts->val_type = TEMP_VAL_DEAD; 1585c896fe29Sbellard } 1586641d5fbeSbellard } 1587e8996ee0Sbellard 1588e8996ee0Sbellard save_globals(s, allocated_regs); 1589c896fe29Sbellard } 1590c896fe29Sbellard 1591866cb6cbSAurelien Jarno #define IS_DEAD_ARG(n) ((dead_args >> (n)) & 1) 1592c896fe29Sbellard 1593e8996ee0Sbellard static void tcg_reg_alloc_movi(TCGContext *s, const TCGArg *args) 1594e8996ee0Sbellard { 1595e8996ee0Sbellard TCGTemp *ots; 1596e8996ee0Sbellard tcg_target_ulong val; 1597e8996ee0Sbellard 1598e8996ee0Sbellard ots = &s->temps[args[0]]; 1599e8996ee0Sbellard val = args[1]; 1600e8996ee0Sbellard 1601e8996ee0Sbellard if (ots->fixed_reg) { 1602e8996ee0Sbellard /* for fixed registers, we do not do any constant 1603e8996ee0Sbellard propagation */ 1604e8996ee0Sbellard tcg_out_movi(s, ots->type, ots->reg, val); 1605e8996ee0Sbellard } else { 16061235fc06Sths /* The movi is not explicitly generated here */ 1607e8996ee0Sbellard if (ots->val_type == TEMP_VAL_REG) 1608e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 1609e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 1610e8996ee0Sbellard ots->val = val; 1611e8996ee0Sbellard } 1612e8996ee0Sbellard } 1613e8996ee0Sbellard 1614c896fe29Sbellard static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def, 1615c896fe29Sbellard const TCGArg *args, 1616866cb6cbSAurelien Jarno unsigned int dead_args) 1617c896fe29Sbellard { 1618c896fe29Sbellard TCGTemp *ts, *ots; 1619c896fe29Sbellard int reg; 1620c896fe29Sbellard const TCGArgConstraint *arg_ct; 1621c896fe29Sbellard 1622c896fe29Sbellard ots = &s->temps[args[0]]; 1623c896fe29Sbellard ts = &s->temps[args[1]]; 1624c896fe29Sbellard arg_ct = &def->args_ct[0]; 1625c896fe29Sbellard 1626866cb6cbSAurelien Jarno /* XXX: always mark arg dead if IS_DEAD_ARG(1) */ 1627c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 1628866cb6cbSAurelien Jarno if (IS_DEAD_ARG(1) && !ts->fixed_reg && !ots->fixed_reg) { 1629c896fe29Sbellard /* the mov can be suppressed */ 1630c896fe29Sbellard if (ots->val_type == TEMP_VAL_REG) 1631c896fe29Sbellard s->reg_to_temp[ots->reg] = -1; 1632c896fe29Sbellard reg = ts->reg; 1633c896fe29Sbellard s->reg_to_temp[reg] = -1; 1634c896fe29Sbellard ts->val_type = TEMP_VAL_DEAD; 1635c896fe29Sbellard } else { 1636c896fe29Sbellard if (ots->val_type == TEMP_VAL_REG) { 1637c896fe29Sbellard reg = ots->reg; 1638c896fe29Sbellard } else { 1639c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, s->reserved_regs); 1640c896fe29Sbellard } 1641c896fe29Sbellard if (ts->reg != reg) { 16423b6dac34SRichard Henderson tcg_out_mov(s, ots->type, reg, ts->reg); 1643c896fe29Sbellard } 1644c896fe29Sbellard } 1645c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 1646c896fe29Sbellard if (ots->val_type == TEMP_VAL_REG) { 1647c896fe29Sbellard reg = ots->reg; 1648c896fe29Sbellard } else { 1649c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, s->reserved_regs); 1650c896fe29Sbellard } 1651e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1652c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1653e8996ee0Sbellard if (ots->fixed_reg) { 1654c896fe29Sbellard reg = ots->reg; 1655c896fe29Sbellard tcg_out_movi(s, ots->type, reg, ts->val); 1656c896fe29Sbellard } else { 1657e8996ee0Sbellard /* propagate constant */ 1658e8996ee0Sbellard if (ots->val_type == TEMP_VAL_REG) 1659e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 1660e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 1661e8996ee0Sbellard ots->val = ts->val; 1662e8996ee0Sbellard return; 1663e8996ee0Sbellard } 1664e8996ee0Sbellard } else { 1665c896fe29Sbellard tcg_abort(); 1666c896fe29Sbellard } 1667c896fe29Sbellard s->reg_to_temp[reg] = args[0]; 1668c896fe29Sbellard ots->reg = reg; 1669c896fe29Sbellard ots->val_type = TEMP_VAL_REG; 1670c896fe29Sbellard ots->mem_coherent = 0; 1671c896fe29Sbellard } 1672c896fe29Sbellard 1673c896fe29Sbellard static void tcg_reg_alloc_op(TCGContext *s, 1674a9751609SRichard Henderson const TCGOpDef *def, TCGOpcode opc, 1675c896fe29Sbellard const TCGArg *args, 1676866cb6cbSAurelien Jarno unsigned int dead_args) 1677c896fe29Sbellard { 1678c896fe29Sbellard TCGRegSet allocated_regs; 1679c896fe29Sbellard int i, k, nb_iargs, nb_oargs, reg; 1680c896fe29Sbellard TCGArg arg; 1681c896fe29Sbellard const TCGArgConstraint *arg_ct; 1682c896fe29Sbellard TCGTemp *ts; 1683c896fe29Sbellard TCGArg new_args[TCG_MAX_OP_ARGS]; 1684c896fe29Sbellard int const_args[TCG_MAX_OP_ARGS]; 1685c896fe29Sbellard 1686c896fe29Sbellard nb_oargs = def->nb_oargs; 1687c896fe29Sbellard nb_iargs = def->nb_iargs; 1688c896fe29Sbellard 1689c896fe29Sbellard /* copy constants */ 1690c896fe29Sbellard memcpy(new_args + nb_oargs + nb_iargs, 1691c896fe29Sbellard args + nb_oargs + nb_iargs, 1692c896fe29Sbellard sizeof(TCGArg) * def->nb_cargs); 1693c896fe29Sbellard 1694c896fe29Sbellard /* satisfy input constraints */ 1695c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 1696c896fe29Sbellard for(k = 0; k < nb_iargs; k++) { 1697c896fe29Sbellard i = def->sorted_args[nb_oargs + k]; 1698c896fe29Sbellard arg = args[i]; 1699c896fe29Sbellard arg_ct = &def->args_ct[i]; 1700c896fe29Sbellard ts = &s->temps[arg]; 1701c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 1702c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1703e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1704c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 1705c896fe29Sbellard ts->reg = reg; 1706c896fe29Sbellard ts->mem_coherent = 1; 1707c896fe29Sbellard s->reg_to_temp[reg] = arg; 1708c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1709c896fe29Sbellard if (tcg_target_const_match(ts->val, arg_ct)) { 1710c896fe29Sbellard /* constant is OK for instruction */ 1711c896fe29Sbellard const_args[i] = 1; 1712c896fe29Sbellard new_args[i] = ts->val; 1713c896fe29Sbellard goto iarg_end; 1714c896fe29Sbellard } else { 1715c896fe29Sbellard /* need to move to a register */ 1716c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1717c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1718e8996ee0Sbellard ts->val_type = TEMP_VAL_REG; 1719e8996ee0Sbellard ts->reg = reg; 1720e8996ee0Sbellard ts->mem_coherent = 0; 1721e8996ee0Sbellard s->reg_to_temp[reg] = arg; 1722c896fe29Sbellard } 1723c896fe29Sbellard } 1724c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 17255ff9d6a4Sbellard if (arg_ct->ct & TCG_CT_IALIAS) { 17265ff9d6a4Sbellard if (ts->fixed_reg) { 17275ff9d6a4Sbellard /* if fixed register, we must allocate a new register 17285ff9d6a4Sbellard if the alias is not the same register */ 17295ff9d6a4Sbellard if (arg != args[arg_ct->alias_index]) 17305ff9d6a4Sbellard goto allocate_in_reg; 17315ff9d6a4Sbellard } else { 1732c896fe29Sbellard /* if the input is aliased to an output and if it is 1733c896fe29Sbellard not dead after the instruction, we must allocate 1734c896fe29Sbellard a new register and move it */ 1735866cb6cbSAurelien Jarno if (!IS_DEAD_ARG(i)) { 1736c896fe29Sbellard goto allocate_in_reg; 1737c896fe29Sbellard } 17385ff9d6a4Sbellard } 1739866cb6cbSAurelien Jarno } 1740c896fe29Sbellard reg = ts->reg; 1741c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1742c896fe29Sbellard /* nothing to do : the constraint is satisfied */ 1743c896fe29Sbellard } else { 1744c896fe29Sbellard allocate_in_reg: 1745c896fe29Sbellard /* allocate a new register matching the constraint 1746c896fe29Sbellard and move the temporary register into it */ 1747c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 17483b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 1749c896fe29Sbellard } 1750c896fe29Sbellard new_args[i] = reg; 1751c896fe29Sbellard const_args[i] = 0; 1752c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 1753c896fe29Sbellard iarg_end: ; 1754c896fe29Sbellard } 1755c896fe29Sbellard 1756e8996ee0Sbellard if (def->flags & TCG_OPF_BB_END) { 1757e8996ee0Sbellard tcg_reg_alloc_bb_end(s, allocated_regs); 1758e8996ee0Sbellard } else { 1759c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 1760866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_oargs + nb_iargs; i++) { 1761866cb6cbSAurelien Jarno arg = args[i]; 1762866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 1763c896fe29Sbellard ts = &s->temps[arg]; 1764e8996ee0Sbellard if (!ts->fixed_reg) { 1765c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) 1766c896fe29Sbellard s->reg_to_temp[ts->reg] = -1; 1767c896fe29Sbellard ts->val_type = TEMP_VAL_DEAD; 1768c896fe29Sbellard } 1769c896fe29Sbellard } 1770c896fe29Sbellard } 1771c896fe29Sbellard 1772c896fe29Sbellard if (def->flags & TCG_OPF_CALL_CLOBBER) { 1773b03cce8eSbellard /* XXX: permit generic clobber register list ? */ 1774c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1775c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 1776c896fe29Sbellard tcg_reg_free(s, reg); 1777c896fe29Sbellard } 1778c896fe29Sbellard } 1779b03cce8eSbellard /* XXX: for load/store we could do that only for the slow path 1780b03cce8eSbellard (i.e. when a memory callback is called) */ 1781b03cce8eSbellard 1782b03cce8eSbellard /* store globals and free associated registers (we assume the insn 1783b03cce8eSbellard can modify any global. */ 1784e8996ee0Sbellard save_globals(s, allocated_regs); 1785c896fe29Sbellard } 1786c896fe29Sbellard 1787c896fe29Sbellard /* satisfy the output constraints */ 1788c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 1789c896fe29Sbellard for(k = 0; k < nb_oargs; k++) { 1790c896fe29Sbellard i = def->sorted_args[k]; 1791c896fe29Sbellard arg = args[i]; 1792c896fe29Sbellard arg_ct = &def->args_ct[i]; 1793c896fe29Sbellard ts = &s->temps[arg]; 1794c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 17955ff9d6a4Sbellard reg = new_args[arg_ct->alias_index]; 1796c896fe29Sbellard } else { 1797c896fe29Sbellard /* if fixed register, we try to use it */ 1798c896fe29Sbellard reg = ts->reg; 1799c896fe29Sbellard if (ts->fixed_reg && 1800c896fe29Sbellard tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1801c896fe29Sbellard goto oarg_end; 1802c896fe29Sbellard } 1803c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1804c896fe29Sbellard } 1805c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 1806c896fe29Sbellard /* if a fixed register is used, then a move will be done afterwards */ 1807c896fe29Sbellard if (!ts->fixed_reg) { 1808c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) 1809c896fe29Sbellard s->reg_to_temp[ts->reg] = -1; 18108c11ad25SAurelien Jarno if (IS_DEAD_ARG(i)) { 18118c11ad25SAurelien Jarno ts->val_type = TEMP_VAL_DEAD; 18128c11ad25SAurelien Jarno } else { 1813c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 1814c896fe29Sbellard ts->reg = reg; 1815c896fe29Sbellard /* temp value is modified, so the value kept in memory is 1816c896fe29Sbellard potentially not the same */ 1817c896fe29Sbellard ts->mem_coherent = 0; 1818c896fe29Sbellard s->reg_to_temp[reg] = arg; 1819c896fe29Sbellard } 18208c11ad25SAurelien Jarno } 1821c896fe29Sbellard oarg_end: 1822c896fe29Sbellard new_args[i] = reg; 1823c896fe29Sbellard } 1824e8996ee0Sbellard } 1825c896fe29Sbellard 1826c896fe29Sbellard /* emit instruction */ 1827c896fe29Sbellard tcg_out_op(s, opc, new_args, const_args); 1828c896fe29Sbellard 1829c896fe29Sbellard /* move the outputs in the correct register if needed */ 1830c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1831c896fe29Sbellard ts = &s->temps[args[i]]; 1832c896fe29Sbellard reg = new_args[i]; 1833c896fe29Sbellard if (ts->fixed_reg && ts->reg != reg) { 18343b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 1835c896fe29Sbellard } 1836c896fe29Sbellard } 1837c896fe29Sbellard } 1838c896fe29Sbellard 1839b03cce8eSbellard #ifdef TCG_TARGET_STACK_GROWSUP 1840b03cce8eSbellard #define STACK_DIR(x) (-(x)) 1841b03cce8eSbellard #else 1842b03cce8eSbellard #define STACK_DIR(x) (x) 1843b03cce8eSbellard #endif 1844b03cce8eSbellard 1845c896fe29Sbellard static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def, 1846a9751609SRichard Henderson TCGOpcode opc, const TCGArg *args, 1847866cb6cbSAurelien Jarno unsigned int dead_args) 1848c896fe29Sbellard { 1849c896fe29Sbellard int nb_iargs, nb_oargs, flags, nb_regs, i, reg, nb_params; 1850c896fe29Sbellard TCGArg arg, func_arg; 1851c896fe29Sbellard TCGTemp *ts; 1852f54b3f92Saurel32 tcg_target_long stack_offset, call_stack_size, func_addr; 1853b03cce8eSbellard int const_func_arg, allocate_args; 1854c896fe29Sbellard TCGRegSet allocated_regs; 1855c896fe29Sbellard const TCGArgConstraint *arg_ct; 1856c896fe29Sbellard 1857c896fe29Sbellard arg = *args++; 1858c896fe29Sbellard 1859c896fe29Sbellard nb_oargs = arg >> 16; 1860c896fe29Sbellard nb_iargs = arg & 0xffff; 1861c896fe29Sbellard nb_params = nb_iargs - 1; 1862c896fe29Sbellard 1863c896fe29Sbellard flags = args[nb_oargs + nb_iargs]; 1864c896fe29Sbellard 1865c896fe29Sbellard nb_regs = tcg_target_get_call_iarg_regs_count(flags); 1866c896fe29Sbellard if (nb_regs > nb_params) 1867c896fe29Sbellard nb_regs = nb_params; 1868c896fe29Sbellard 1869c896fe29Sbellard /* assign stack slots first */ 1870c896fe29Sbellard call_stack_size = (nb_params - nb_regs) * sizeof(tcg_target_long); 1871c896fe29Sbellard call_stack_size = (call_stack_size + TCG_TARGET_STACK_ALIGN - 1) & 1872c896fe29Sbellard ~(TCG_TARGET_STACK_ALIGN - 1); 1873b03cce8eSbellard allocate_args = (call_stack_size > TCG_STATIC_CALL_ARGS_SIZE); 1874b03cce8eSbellard if (allocate_args) { 1875345649c0SBlue Swirl /* XXX: if more than TCG_STATIC_CALL_ARGS_SIZE is needed, 1876345649c0SBlue Swirl preallocate call stack */ 1877345649c0SBlue Swirl tcg_abort(); 1878b03cce8eSbellard } 187939cf05d3Sbellard 188039cf05d3Sbellard stack_offset = TCG_TARGET_CALL_STACK_OFFSET; 1881c896fe29Sbellard for(i = nb_regs; i < nb_params; i++) { 1882c896fe29Sbellard arg = args[nb_oargs + i]; 188339cf05d3Sbellard #ifdef TCG_TARGET_STACK_GROWSUP 188439cf05d3Sbellard stack_offset -= sizeof(tcg_target_long); 188539cf05d3Sbellard #endif 188639cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 1887c896fe29Sbellard ts = &s->temps[arg]; 1888c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 1889e4d5434cSblueswir1 tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset); 1890c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 1891c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 1892c896fe29Sbellard s->reserved_regs); 1893c896fe29Sbellard /* XXX: not correct if reading values from the stack */ 1894e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1895e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 1896c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1897c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 1898c896fe29Sbellard s->reserved_regs); 1899c896fe29Sbellard /* XXX: sign extend may be needed on some targets */ 1900c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1901e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 1902c896fe29Sbellard } else { 1903c896fe29Sbellard tcg_abort(); 1904c896fe29Sbellard } 190539cf05d3Sbellard } 190639cf05d3Sbellard #ifndef TCG_TARGET_STACK_GROWSUP 190739cf05d3Sbellard stack_offset += sizeof(tcg_target_long); 190839cf05d3Sbellard #endif 1909c896fe29Sbellard } 1910c896fe29Sbellard 1911c896fe29Sbellard /* assign input registers */ 1912c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 1913c896fe29Sbellard for(i = 0; i < nb_regs; i++) { 1914c896fe29Sbellard arg = args[nb_oargs + i]; 191539cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 1916c896fe29Sbellard ts = &s->temps[arg]; 1917c896fe29Sbellard reg = tcg_target_call_iarg_regs[i]; 1918c896fe29Sbellard tcg_reg_free(s, reg); 1919c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 1920c896fe29Sbellard if (ts->reg != reg) { 19213b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 1922c896fe29Sbellard } 1923c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 1924e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1925c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1926c896fe29Sbellard /* XXX: sign extend ? */ 1927c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1928c896fe29Sbellard } else { 1929c896fe29Sbellard tcg_abort(); 1930c896fe29Sbellard } 1931c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 1932c896fe29Sbellard } 193339cf05d3Sbellard } 1934c896fe29Sbellard 1935c896fe29Sbellard /* assign function address */ 1936c896fe29Sbellard func_arg = args[nb_oargs + nb_iargs - 1]; 1937c896fe29Sbellard arg_ct = &def->args_ct[0]; 1938c896fe29Sbellard ts = &s->temps[func_arg]; 1939f54b3f92Saurel32 func_addr = ts->val; 1940c896fe29Sbellard const_func_arg = 0; 1941c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 1942c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1943e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1944c896fe29Sbellard func_arg = reg; 1945e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 1946c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_REG) { 1947c896fe29Sbellard reg = ts->reg; 1948c896fe29Sbellard if (!tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1949c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 19503b6dac34SRichard Henderson tcg_out_mov(s, ts->type, reg, ts->reg); 1951c896fe29Sbellard } 1952c896fe29Sbellard func_arg = reg; 1953e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 1954c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1955f54b3f92Saurel32 if (tcg_target_const_match(func_addr, arg_ct)) { 1956c896fe29Sbellard const_func_arg = 1; 1957f54b3f92Saurel32 func_arg = func_addr; 1958c896fe29Sbellard } else { 1959c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1960f54b3f92Saurel32 tcg_out_movi(s, ts->type, reg, func_addr); 1961c896fe29Sbellard func_arg = reg; 1962e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 1963c896fe29Sbellard } 1964c896fe29Sbellard } else { 1965c896fe29Sbellard tcg_abort(); 1966c896fe29Sbellard } 1967c896fe29Sbellard 1968e8996ee0Sbellard 1969c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 1970866cb6cbSAurelien Jarno for(i = nb_oargs; i < nb_iargs + nb_oargs; i++) { 1971866cb6cbSAurelien Jarno arg = args[i]; 1972866cb6cbSAurelien Jarno if (IS_DEAD_ARG(i)) { 1973c896fe29Sbellard ts = &s->temps[arg]; 1974e8996ee0Sbellard if (!ts->fixed_reg) { 1975c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) 1976c896fe29Sbellard s->reg_to_temp[ts->reg] = -1; 1977c896fe29Sbellard ts->val_type = TEMP_VAL_DEAD; 1978c896fe29Sbellard } 1979c896fe29Sbellard } 1980c896fe29Sbellard } 1981c896fe29Sbellard 1982c896fe29Sbellard /* clobber call registers */ 1983c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1984c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 1985c896fe29Sbellard tcg_reg_free(s, reg); 1986c896fe29Sbellard } 1987c896fe29Sbellard } 1988c896fe29Sbellard 1989c896fe29Sbellard /* store globals and free associated registers (we assume the call 1990c896fe29Sbellard can modify any global. */ 1991b9c18f56Saurel32 if (!(flags & TCG_CALL_CONST)) { 1992e8996ee0Sbellard save_globals(s, allocated_regs); 1993b9c18f56Saurel32 } 1994c896fe29Sbellard 1995c896fe29Sbellard tcg_out_op(s, opc, &func_arg, &const_func_arg); 1996c896fe29Sbellard 1997c896fe29Sbellard /* assign output registers and emit moves if needed */ 1998c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1999c896fe29Sbellard arg = args[i]; 2000c896fe29Sbellard ts = &s->temps[arg]; 2001c896fe29Sbellard reg = tcg_target_call_oarg_regs[i]; 2002e8996ee0Sbellard assert(s->reg_to_temp[reg] == -1); 2003c896fe29Sbellard if (ts->fixed_reg) { 2004c896fe29Sbellard if (ts->reg != reg) { 20053b6dac34SRichard Henderson tcg_out_mov(s, ts->type, ts->reg, reg); 2006c896fe29Sbellard } 2007c896fe29Sbellard } else { 2008c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) 2009c896fe29Sbellard s->reg_to_temp[ts->reg] = -1; 20108c11ad25SAurelien Jarno if (IS_DEAD_ARG(i)) { 20118c11ad25SAurelien Jarno ts->val_type = TEMP_VAL_DEAD; 20128c11ad25SAurelien Jarno } else { 2013c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 2014c896fe29Sbellard ts->reg = reg; 2015c896fe29Sbellard ts->mem_coherent = 0; 2016c896fe29Sbellard s->reg_to_temp[reg] = arg; 2017c896fe29Sbellard } 2018c896fe29Sbellard } 20198c11ad25SAurelien Jarno } 2020c896fe29Sbellard 2021c896fe29Sbellard return nb_iargs + nb_oargs + def->nb_cargs + 1; 2022c896fe29Sbellard } 2023c896fe29Sbellard 2024c896fe29Sbellard #ifdef CONFIG_PROFILER 2025c896fe29Sbellard 202654604f74Saurel32 static int64_t tcg_table_op_count[NB_OPS]; 2027c896fe29Sbellard 2028871e6c35SBlue Swirl static void dump_op_count(void) 2029c896fe29Sbellard { 2030c896fe29Sbellard int i; 2031c896fe29Sbellard FILE *f; 203254604f74Saurel32 f = fopen("/tmp/op.log", "w"); 2033c896fe29Sbellard for(i = INDEX_op_end; i < NB_OPS; i++) { 203454604f74Saurel32 fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, tcg_table_op_count[i]); 2035c896fe29Sbellard } 2036c896fe29Sbellard fclose(f); 2037c896fe29Sbellard } 2038c896fe29Sbellard #endif 2039c896fe29Sbellard 2040c896fe29Sbellard 2041c896fe29Sbellard static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf, 20422ba1eeb6Spbrook long search_pc) 2043c896fe29Sbellard { 2044a9751609SRichard Henderson TCGOpcode opc; 2045a9751609SRichard Henderson int op_index; 2046c896fe29Sbellard const TCGOpDef *def; 2047866cb6cbSAurelien Jarno unsigned int dead_args; 2048c896fe29Sbellard const TCGArg *args; 2049c896fe29Sbellard 2050c896fe29Sbellard #ifdef DEBUG_DISAS 20518fec2b8cSaliguori if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) { 205293fcfe39Saliguori qemu_log("OP:\n"); 2053c896fe29Sbellard tcg_dump_ops(s, logfile); 205493fcfe39Saliguori qemu_log("\n"); 2055c896fe29Sbellard } 2056c896fe29Sbellard #endif 2057c896fe29Sbellard 20588f2e8c07SKirill Batuzov #ifdef USE_TCG_OPTIMIZATIONS 20598f2e8c07SKirill Batuzov gen_opparam_ptr = 20608f2e8c07SKirill Batuzov tcg_optimize(s, gen_opc_ptr, gen_opparam_buf, tcg_op_defs); 20618f2e8c07SKirill Batuzov #endif 20628f2e8c07SKirill Batuzov 2063a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2064a23a9ec6Sbellard s->la_time -= profile_getclock(); 2065a23a9ec6Sbellard #endif 2066c896fe29Sbellard tcg_liveness_analysis(s); 2067a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2068a23a9ec6Sbellard s->la_time += profile_getclock(); 2069a23a9ec6Sbellard #endif 2070c896fe29Sbellard 2071c896fe29Sbellard #ifdef DEBUG_DISAS 20728fec2b8cSaliguori if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT))) { 20736a957025SAurelien Jarno qemu_log("OP after liveness analysis:\n"); 2074c896fe29Sbellard tcg_dump_ops(s, logfile); 207593fcfe39Saliguori qemu_log("\n"); 2076c896fe29Sbellard } 2077c896fe29Sbellard #endif 2078c896fe29Sbellard 2079c896fe29Sbellard tcg_reg_alloc_start(s); 2080c896fe29Sbellard 2081c896fe29Sbellard s->code_buf = gen_code_buf; 2082c896fe29Sbellard s->code_ptr = gen_code_buf; 2083c896fe29Sbellard 2084c896fe29Sbellard args = gen_opparam_buf; 2085c896fe29Sbellard op_index = 0; 2086b3db8758Sblueswir1 2087c896fe29Sbellard for(;;) { 2088c896fe29Sbellard opc = gen_opc_buf[op_index]; 2089c896fe29Sbellard #ifdef CONFIG_PROFILER 209054604f74Saurel32 tcg_table_op_count[opc]++; 2091c896fe29Sbellard #endif 2092c896fe29Sbellard def = &tcg_op_defs[opc]; 2093c896fe29Sbellard #if 0 2094c896fe29Sbellard printf("%s: %d %d %d\n", def->name, 2095c896fe29Sbellard def->nb_oargs, def->nb_iargs, def->nb_cargs); 2096c896fe29Sbellard // dump_regs(s); 2097c896fe29Sbellard #endif 2098c896fe29Sbellard switch(opc) { 2099c896fe29Sbellard case INDEX_op_mov_i32: 2100c896fe29Sbellard #if TCG_TARGET_REG_BITS == 64 2101c896fe29Sbellard case INDEX_op_mov_i64: 2102c896fe29Sbellard #endif 2103866cb6cbSAurelien Jarno dead_args = s->op_dead_args[op_index]; 2104866cb6cbSAurelien Jarno tcg_reg_alloc_mov(s, def, args, dead_args); 2105c896fe29Sbellard break; 2106e8996ee0Sbellard case INDEX_op_movi_i32: 2107e8996ee0Sbellard #if TCG_TARGET_REG_BITS == 64 2108e8996ee0Sbellard case INDEX_op_movi_i64: 2109e8996ee0Sbellard #endif 2110e8996ee0Sbellard tcg_reg_alloc_movi(s, args); 2111e8996ee0Sbellard break; 21127e4597d7Sbellard case INDEX_op_debug_insn_start: 21137e4597d7Sbellard /* debug instruction */ 21147e4597d7Sbellard break; 2115c896fe29Sbellard case INDEX_op_nop: 2116c896fe29Sbellard case INDEX_op_nop1: 2117c896fe29Sbellard case INDEX_op_nop2: 2118c896fe29Sbellard case INDEX_op_nop3: 2119c896fe29Sbellard break; 2120c896fe29Sbellard case INDEX_op_nopn: 2121c896fe29Sbellard args += args[0]; 2122c896fe29Sbellard goto next; 21235ff9d6a4Sbellard case INDEX_op_discard: 21245ff9d6a4Sbellard { 21255ff9d6a4Sbellard TCGTemp *ts; 21265ff9d6a4Sbellard ts = &s->temps[args[0]]; 21275ff9d6a4Sbellard /* mark the temporary as dead */ 2128e8996ee0Sbellard if (!ts->fixed_reg) { 21295ff9d6a4Sbellard if (ts->val_type == TEMP_VAL_REG) 21305ff9d6a4Sbellard s->reg_to_temp[ts->reg] = -1; 21315ff9d6a4Sbellard ts->val_type = TEMP_VAL_DEAD; 21325ff9d6a4Sbellard } 21335ff9d6a4Sbellard } 21345ff9d6a4Sbellard break; 2135c896fe29Sbellard case INDEX_op_set_label: 2136e8996ee0Sbellard tcg_reg_alloc_bb_end(s, s->reserved_regs); 2137c896fe29Sbellard tcg_out_label(s, args[0], (long)s->code_ptr); 2138c896fe29Sbellard break; 2139c896fe29Sbellard case INDEX_op_call: 2140866cb6cbSAurelien Jarno dead_args = s->op_dead_args[op_index]; 2141866cb6cbSAurelien Jarno args += tcg_reg_alloc_call(s, def, opc, args, dead_args); 2142c896fe29Sbellard goto next; 2143c896fe29Sbellard case INDEX_op_end: 2144c896fe29Sbellard goto the_end; 2145c896fe29Sbellard default: 214625c4d9ccSRichard Henderson /* Sanity check that we've not introduced any unhandled opcodes. */ 214725c4d9ccSRichard Henderson if (def->flags & TCG_OPF_NOT_PRESENT) { 214825c4d9ccSRichard Henderson tcg_abort(); 214925c4d9ccSRichard Henderson } 2150c896fe29Sbellard /* Note: in order to speed up the code, it would be much 2151c896fe29Sbellard faster to have specialized register allocator functions for 2152c896fe29Sbellard some common argument patterns */ 2153866cb6cbSAurelien Jarno dead_args = s->op_dead_args[op_index]; 2154866cb6cbSAurelien Jarno tcg_reg_alloc_op(s, def, opc, args, dead_args); 2155c896fe29Sbellard break; 2156c896fe29Sbellard } 2157c896fe29Sbellard args += def->nb_args; 21588df1ca4bSths next: 21592ba1eeb6Spbrook if (search_pc >= 0 && search_pc < s->code_ptr - gen_code_buf) { 2160c896fe29Sbellard return op_index; 2161c896fe29Sbellard } 2162c896fe29Sbellard op_index++; 2163c896fe29Sbellard #ifndef NDEBUG 2164c896fe29Sbellard check_regs(s); 2165c896fe29Sbellard #endif 2166c896fe29Sbellard } 2167c896fe29Sbellard the_end: 2168c896fe29Sbellard return -1; 2169c896fe29Sbellard } 2170c896fe29Sbellard 217154604f74Saurel32 int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf) 2172c896fe29Sbellard { 2173c896fe29Sbellard #ifdef CONFIG_PROFILER 2174c896fe29Sbellard { 2175c896fe29Sbellard int n; 2176c896fe29Sbellard n = (gen_opc_ptr - gen_opc_buf); 2177a23a9ec6Sbellard s->op_count += n; 2178a23a9ec6Sbellard if (n > s->op_count_max) 2179a23a9ec6Sbellard s->op_count_max = n; 2180a23a9ec6Sbellard 2181a23a9ec6Sbellard s->temp_count += s->nb_temps; 2182a23a9ec6Sbellard if (s->nb_temps > s->temp_count_max) 2183a23a9ec6Sbellard s->temp_count_max = s->nb_temps; 2184c896fe29Sbellard } 2185c896fe29Sbellard #endif 2186c896fe29Sbellard 21872ba1eeb6Spbrook tcg_gen_code_common(s, gen_code_buf, -1); 2188c896fe29Sbellard 2189c896fe29Sbellard /* flush instruction cache */ 2190c896fe29Sbellard flush_icache_range((unsigned long)gen_code_buf, 2191c896fe29Sbellard (unsigned long)s->code_ptr); 2192c896fe29Sbellard return s->code_ptr - gen_code_buf; 2193c896fe29Sbellard } 2194c896fe29Sbellard 21952ba1eeb6Spbrook /* Return the index of the micro operation such as the pc after is < 2196623e265cSpbrook offset bytes from the start of the TB. The contents of gen_code_buf must 2197623e265cSpbrook not be changed, though writing the same values is ok. 2198623e265cSpbrook Return -1 if not found. */ 219954604f74Saurel32 int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset) 2200c896fe29Sbellard { 2201623e265cSpbrook return tcg_gen_code_common(s, gen_code_buf, offset); 2202c896fe29Sbellard } 2203a23a9ec6Sbellard 2204a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2205405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2206a23a9ec6Sbellard { 2207a23a9ec6Sbellard TCGContext *s = &tcg_ctx; 2208a23a9ec6Sbellard int64_t tot; 2209a23a9ec6Sbellard 2210a23a9ec6Sbellard tot = s->interm_time + s->code_time; 2211a23a9ec6Sbellard cpu_fprintf(f, "JIT cycles %" PRId64 " (%0.3f s at 2.4 GHz)\n", 2212a23a9ec6Sbellard tot, tot / 2.4e9); 2213a23a9ec6Sbellard cpu_fprintf(f, "translated TBs %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n", 2214a23a9ec6Sbellard s->tb_count, 2215a23a9ec6Sbellard s->tb_count1 - s->tb_count, 2216a23a9ec6Sbellard s->tb_count1 ? (double)(s->tb_count1 - s->tb_count) / s->tb_count1 * 100.0 : 0); 2217a23a9ec6Sbellard cpu_fprintf(f, "avg ops/TB %0.1f max=%d\n", 2218a23a9ec6Sbellard s->tb_count ? (double)s->op_count / s->tb_count : 0, s->op_count_max); 2219a23a9ec6Sbellard cpu_fprintf(f, "deleted ops/TB %0.2f\n", 2220a23a9ec6Sbellard s->tb_count ? 2221a23a9ec6Sbellard (double)s->del_op_count / s->tb_count : 0); 2222a23a9ec6Sbellard cpu_fprintf(f, "avg temps/TB %0.2f max=%d\n", 2223a23a9ec6Sbellard s->tb_count ? 2224a23a9ec6Sbellard (double)s->temp_count / s->tb_count : 0, 2225a23a9ec6Sbellard s->temp_count_max); 2226a23a9ec6Sbellard 2227a23a9ec6Sbellard cpu_fprintf(f, "cycles/op %0.1f\n", 2228a23a9ec6Sbellard s->op_count ? (double)tot / s->op_count : 0); 2229a23a9ec6Sbellard cpu_fprintf(f, "cycles/in byte %0.1f\n", 2230a23a9ec6Sbellard s->code_in_len ? (double)tot / s->code_in_len : 0); 2231a23a9ec6Sbellard cpu_fprintf(f, "cycles/out byte %0.1f\n", 2232a23a9ec6Sbellard s->code_out_len ? (double)tot / s->code_out_len : 0); 2233a23a9ec6Sbellard if (tot == 0) 2234a23a9ec6Sbellard tot = 1; 2235a23a9ec6Sbellard cpu_fprintf(f, " gen_interm time %0.1f%%\n", 2236a23a9ec6Sbellard (double)s->interm_time / tot * 100.0); 2237a23a9ec6Sbellard cpu_fprintf(f, " gen_code time %0.1f%%\n", 2238a23a9ec6Sbellard (double)s->code_time / tot * 100.0); 2239a23a9ec6Sbellard cpu_fprintf(f, "liveness/code time %0.1f%%\n", 2240a23a9ec6Sbellard (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0); 2241a23a9ec6Sbellard cpu_fprintf(f, "cpu_restore count %" PRId64 "\n", 2242a23a9ec6Sbellard s->restore_count); 2243a23a9ec6Sbellard cpu_fprintf(f, " avg cycles %0.1f\n", 2244a23a9ec6Sbellard s->restore_count ? (double)s->restore_time / s->restore_count : 0); 2245871e6c35SBlue Swirl 2246a23a9ec6Sbellard dump_op_count(); 2247a23a9ec6Sbellard } 2248a23a9ec6Sbellard #else 2249405cf9ffSStefan Weil void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 2250a23a9ec6Sbellard { 225124bf7b3aSbellard cpu_fprintf(f, "[TCG profiler not compiled]\n"); 2252a23a9ec6Sbellard } 2253a23a9ec6Sbellard #endif 2254