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 suppress various consistency checks (faster) */ 26c896fe29Sbellard #define NDEBUG 27c896fe29Sbellard 28c896fe29Sbellard /* define it to use liveness analysis (better code) */ 29c896fe29Sbellard #define USE_LIVENESS_ANALYSIS 30c896fe29Sbellard 31c896fe29Sbellard #include <assert.h> 32c896fe29Sbellard #include <stdarg.h> 33c896fe29Sbellard #include <stdlib.h> 34c896fe29Sbellard #include <stdio.h> 35c896fe29Sbellard #include <string.h> 36c896fe29Sbellard #include <inttypes.h> 373fe43da7Sbellard #ifdef _WIN32 383fe43da7Sbellard #include <malloc.h> 393fe43da7Sbellard #endif 40b29fe3edSmalc #ifdef _AIX 41b29fe3edSmalc #include <alloca.h> 42b29fe3edSmalc #endif 43c896fe29Sbellard 44c896fe29Sbellard #include "config.h" 45ca10f867Saurel32 #include "qemu-common.h" 46c896fe29Sbellard 47c896fe29Sbellard /* Note: the long term plan is to reduce the dependancies on the QEMU 48c896fe29Sbellard CPU definitions. Currently they are used for qemu_ld/st 49c896fe29Sbellard instructions */ 50c896fe29Sbellard #define NO_CPU_IO_DEFS 51c896fe29Sbellard #include "cpu.h" 52c896fe29Sbellard #include "exec-all.h" 53c896fe29Sbellard 54c896fe29Sbellard #include "tcg-op.h" 55c896fe29Sbellard #include "elf.h" 56c896fe29Sbellard 57c896fe29Sbellard 58c896fe29Sbellard static void patch_reloc(uint8_t *code_ptr, int type, 59f54b3f92Saurel32 tcg_target_long value, tcg_target_long addend); 60c896fe29Sbellard 61c896fe29Sbellard TCGOpDef tcg_op_defs[] = { 62c896fe29Sbellard #define DEF(s, n, copy_size) { #s, 0, 0, n, n, 0, copy_size }, 63c896fe29Sbellard #define DEF2(s, iargs, oargs, cargs, flags) { #s, iargs, oargs, cargs, iargs + oargs + cargs, flags, 0 }, 64c896fe29Sbellard #include "tcg-opc.h" 65c896fe29Sbellard #undef DEF 66c896fe29Sbellard #undef DEF2 67c896fe29Sbellard }; 68c896fe29Sbellard 69b1d8e52eSblueswir1 static TCGRegSet tcg_target_available_regs[2]; 70b1d8e52eSblueswir1 static TCGRegSet tcg_target_call_clobber_regs; 71c896fe29Sbellard 72c896fe29Sbellard /* XXX: move that inside the context */ 73c896fe29Sbellard uint16_t *gen_opc_ptr; 74c896fe29Sbellard TCGArg *gen_opparam_ptr; 75c896fe29Sbellard 76c896fe29Sbellard static inline void tcg_out8(TCGContext *s, uint8_t v) 77c896fe29Sbellard { 78c896fe29Sbellard *s->code_ptr++ = v; 79c896fe29Sbellard } 80c896fe29Sbellard 81c896fe29Sbellard static inline void tcg_out16(TCGContext *s, uint16_t v) 82c896fe29Sbellard { 83c896fe29Sbellard *(uint16_t *)s->code_ptr = v; 84c896fe29Sbellard s->code_ptr += 2; 85c896fe29Sbellard } 86c896fe29Sbellard 87c896fe29Sbellard static inline void tcg_out32(TCGContext *s, uint32_t v) 88c896fe29Sbellard { 89c896fe29Sbellard *(uint32_t *)s->code_ptr = v; 90c896fe29Sbellard s->code_ptr += 4; 91c896fe29Sbellard } 92c896fe29Sbellard 93c896fe29Sbellard /* label relocation processing */ 94c896fe29Sbellard 95c896fe29Sbellard void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type, 96c896fe29Sbellard int label_index, long addend) 97c896fe29Sbellard { 98c896fe29Sbellard TCGLabel *l; 99c896fe29Sbellard TCGRelocation *r; 100c896fe29Sbellard 101c896fe29Sbellard l = &s->labels[label_index]; 102c896fe29Sbellard if (l->has_value) { 103623e265cSpbrook /* FIXME: This may break relocations on RISC targets that 104623e265cSpbrook modify instruction fields in place. The caller may not have 105623e265cSpbrook written the initial value. */ 106f54b3f92Saurel32 patch_reloc(code_ptr, type, l->u.value, addend); 107c896fe29Sbellard } else { 108c896fe29Sbellard /* add a new relocation entry */ 109c896fe29Sbellard r = tcg_malloc(sizeof(TCGRelocation)); 110c896fe29Sbellard r->type = type; 111c896fe29Sbellard r->ptr = code_ptr; 112c896fe29Sbellard r->addend = addend; 113c896fe29Sbellard r->next = l->u.first_reloc; 114c896fe29Sbellard l->u.first_reloc = r; 115c896fe29Sbellard } 116c896fe29Sbellard } 117c896fe29Sbellard 118c896fe29Sbellard static void tcg_out_label(TCGContext *s, int label_index, 119c896fe29Sbellard tcg_target_long value) 120c896fe29Sbellard { 121c896fe29Sbellard TCGLabel *l; 122c896fe29Sbellard TCGRelocation *r; 123c896fe29Sbellard 124c896fe29Sbellard l = &s->labels[label_index]; 125c896fe29Sbellard if (l->has_value) 126c896fe29Sbellard tcg_abort(); 127c896fe29Sbellard r = l->u.first_reloc; 128c896fe29Sbellard while (r != NULL) { 129f54b3f92Saurel32 patch_reloc(r->ptr, r->type, value, r->addend); 130c896fe29Sbellard r = r->next; 131c896fe29Sbellard } 132c896fe29Sbellard l->has_value = 1; 133c896fe29Sbellard l->u.value = value; 134c896fe29Sbellard } 135c896fe29Sbellard 136c896fe29Sbellard int gen_new_label(void) 137c896fe29Sbellard { 138c896fe29Sbellard TCGContext *s = &tcg_ctx; 139c896fe29Sbellard int idx; 140c896fe29Sbellard TCGLabel *l; 141c896fe29Sbellard 142c896fe29Sbellard if (s->nb_labels >= TCG_MAX_LABELS) 143c896fe29Sbellard tcg_abort(); 144c896fe29Sbellard idx = s->nb_labels++; 145c896fe29Sbellard l = &s->labels[idx]; 146c896fe29Sbellard l->has_value = 0; 147c896fe29Sbellard l->u.first_reloc = NULL; 148c896fe29Sbellard return idx; 149c896fe29Sbellard } 150c896fe29Sbellard 151c896fe29Sbellard #include "tcg-target.c" 152c896fe29Sbellard 153c896fe29Sbellard /* pool based memory allocation */ 154c896fe29Sbellard void *tcg_malloc_internal(TCGContext *s, int size) 155c896fe29Sbellard { 156c896fe29Sbellard TCGPool *p; 157c896fe29Sbellard int pool_size; 158c896fe29Sbellard 159c896fe29Sbellard if (size > TCG_POOL_CHUNK_SIZE) { 160c896fe29Sbellard /* big malloc: insert a new pool (XXX: could optimize) */ 161c896fe29Sbellard p = qemu_malloc(sizeof(TCGPool) + size); 162c896fe29Sbellard p->size = size; 163c896fe29Sbellard if (s->pool_current) 164c896fe29Sbellard s->pool_current->next = p; 165c896fe29Sbellard else 166c896fe29Sbellard s->pool_first = p; 167c896fe29Sbellard p->next = s->pool_current; 168c896fe29Sbellard } else { 169c896fe29Sbellard p = s->pool_current; 170c896fe29Sbellard if (!p) { 171c896fe29Sbellard p = s->pool_first; 172c896fe29Sbellard if (!p) 173c896fe29Sbellard goto new_pool; 174c896fe29Sbellard } else { 175c896fe29Sbellard if (!p->next) { 176c896fe29Sbellard new_pool: 177c896fe29Sbellard pool_size = TCG_POOL_CHUNK_SIZE; 178c896fe29Sbellard p = qemu_malloc(sizeof(TCGPool) + pool_size); 179c896fe29Sbellard p->size = pool_size; 180c896fe29Sbellard p->next = NULL; 181c896fe29Sbellard if (s->pool_current) 182c896fe29Sbellard s->pool_current->next = p; 183c896fe29Sbellard else 184c896fe29Sbellard s->pool_first = p; 185c896fe29Sbellard } else { 186c896fe29Sbellard p = p->next; 187c896fe29Sbellard } 188c896fe29Sbellard } 189c896fe29Sbellard } 190c896fe29Sbellard s->pool_current = p; 191c896fe29Sbellard s->pool_cur = p->data + size; 192c896fe29Sbellard s->pool_end = p->data + p->size; 193c896fe29Sbellard return p->data; 194c896fe29Sbellard } 195c896fe29Sbellard 196c896fe29Sbellard void tcg_pool_reset(TCGContext *s) 197c896fe29Sbellard { 198c896fe29Sbellard s->pool_cur = s->pool_end = NULL; 199c896fe29Sbellard s->pool_current = NULL; 200c896fe29Sbellard } 201c896fe29Sbellard 202c896fe29Sbellard void tcg_context_init(TCGContext *s) 203c896fe29Sbellard { 204c896fe29Sbellard int op, total_args, n; 205c896fe29Sbellard TCGOpDef *def; 206c896fe29Sbellard TCGArgConstraint *args_ct; 207c896fe29Sbellard int *sorted_args; 208c896fe29Sbellard 209c896fe29Sbellard memset(s, 0, sizeof(*s)); 210c896fe29Sbellard s->temps = s->static_temps; 211c896fe29Sbellard s->nb_globals = 0; 212c896fe29Sbellard 213c896fe29Sbellard /* Count total number of arguments and allocate the corresponding 214c896fe29Sbellard space */ 215c896fe29Sbellard total_args = 0; 216c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 217c896fe29Sbellard def = &tcg_op_defs[op]; 218c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 219c896fe29Sbellard total_args += n; 220c896fe29Sbellard } 221c896fe29Sbellard 222c896fe29Sbellard args_ct = qemu_malloc(sizeof(TCGArgConstraint) * total_args); 223c896fe29Sbellard sorted_args = qemu_malloc(sizeof(int) * total_args); 224c896fe29Sbellard 225c896fe29Sbellard for(op = 0; op < NB_OPS; op++) { 226c896fe29Sbellard def = &tcg_op_defs[op]; 227c896fe29Sbellard def->args_ct = args_ct; 228c896fe29Sbellard def->sorted_args = sorted_args; 229c896fe29Sbellard n = def->nb_iargs + def->nb_oargs; 230c896fe29Sbellard sorted_args += n; 231c896fe29Sbellard args_ct += n; 232c896fe29Sbellard } 233c896fe29Sbellard 234c896fe29Sbellard tcg_target_init(s); 235b03cce8eSbellard 236b03cce8eSbellard /* init global prologue and epilogue */ 237b03cce8eSbellard s->code_buf = code_gen_prologue; 238b03cce8eSbellard s->code_ptr = s->code_buf; 239b03cce8eSbellard tcg_target_qemu_prologue(s); 240b03cce8eSbellard flush_icache_range((unsigned long)s->code_buf, 241b03cce8eSbellard (unsigned long)s->code_ptr); 242c896fe29Sbellard } 243c896fe29Sbellard 244c896fe29Sbellard void tcg_set_frame(TCGContext *s, int reg, 245c896fe29Sbellard tcg_target_long start, tcg_target_long size) 246c896fe29Sbellard { 247c896fe29Sbellard s->frame_start = start; 248c896fe29Sbellard s->frame_end = start + size; 249c896fe29Sbellard s->frame_reg = reg; 250c896fe29Sbellard } 251c896fe29Sbellard 252c896fe29Sbellard void tcg_func_start(TCGContext *s) 253c896fe29Sbellard { 254e8996ee0Sbellard int i; 255c896fe29Sbellard tcg_pool_reset(s); 256c896fe29Sbellard s->nb_temps = s->nb_globals; 257641d5fbeSbellard for(i = 0; i < (TCG_TYPE_COUNT * 2); i++) 258e8996ee0Sbellard s->first_free_temp[i] = -1; 259c896fe29Sbellard s->labels = tcg_malloc(sizeof(TCGLabel) * TCG_MAX_LABELS); 260c896fe29Sbellard s->nb_labels = 0; 261c896fe29Sbellard s->current_frame_offset = s->frame_start; 262c896fe29Sbellard 263c896fe29Sbellard gen_opc_ptr = gen_opc_buf; 264c896fe29Sbellard gen_opparam_ptr = gen_opparam_buf; 265c896fe29Sbellard } 266c896fe29Sbellard 267c896fe29Sbellard static inline void tcg_temp_alloc(TCGContext *s, int n) 268c896fe29Sbellard { 269c896fe29Sbellard if (n > TCG_MAX_TEMPS) 270c896fe29Sbellard tcg_abort(); 271c896fe29Sbellard } 272c896fe29Sbellard 273a7812ae4Spbrook static inline int tcg_global_reg_new_internal(TCGType type, int reg, 274a7812ae4Spbrook const char *name) 275c896fe29Sbellard { 276c896fe29Sbellard TCGContext *s = &tcg_ctx; 277c896fe29Sbellard TCGTemp *ts; 278c896fe29Sbellard int idx; 279c896fe29Sbellard 280c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 281c896fe29Sbellard if (type != TCG_TYPE_I32) 282c896fe29Sbellard tcg_abort(); 283c896fe29Sbellard #endif 284c896fe29Sbellard if (tcg_regset_test_reg(s->reserved_regs, reg)) 285c896fe29Sbellard tcg_abort(); 286c896fe29Sbellard idx = s->nb_globals; 287c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 288c896fe29Sbellard ts = &s->temps[s->nb_globals]; 289c896fe29Sbellard ts->base_type = type; 290c896fe29Sbellard ts->type = type; 291c896fe29Sbellard ts->fixed_reg = 1; 292c896fe29Sbellard ts->reg = reg; 293c896fe29Sbellard ts->name = name; 294c896fe29Sbellard s->nb_globals++; 295c896fe29Sbellard tcg_regset_set_reg(s->reserved_regs, reg); 296a7812ae4Spbrook return idx; 297a7812ae4Spbrook } 298a7812ae4Spbrook 299a7812ae4Spbrook TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name) 300a7812ae4Spbrook { 301a7812ae4Spbrook int idx; 302a7812ae4Spbrook 303a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name); 304a7812ae4Spbrook return MAKE_TCGV_I32(idx); 305a7812ae4Spbrook } 306a7812ae4Spbrook 307a7812ae4Spbrook TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name) 308a7812ae4Spbrook { 309a7812ae4Spbrook int idx; 310a7812ae4Spbrook 311a7812ae4Spbrook idx = tcg_global_reg_new_internal(TCG_TYPE_I64, reg, name); 312a7812ae4Spbrook return MAKE_TCGV_I64(idx); 313c896fe29Sbellard } 314c896fe29Sbellard 3156a8d7b76Sbellard #if TCG_TARGET_REG_BITS == 32 3166a8d7b76Sbellard /* temporary hack to avoid register shortage for tcg_qemu_st64() */ 317a7812ae4Spbrook TCGv_i64 tcg_global_reg2_new_hack(TCGType type, int reg1, int reg2, 3186a8d7b76Sbellard const char *name) 3196a8d7b76Sbellard { 3206a8d7b76Sbellard TCGContext *s = &tcg_ctx; 3216a8d7b76Sbellard TCGTemp *ts; 3226a8d7b76Sbellard int idx; 3236a8d7b76Sbellard char buf[64]; 3246a8d7b76Sbellard 3256a8d7b76Sbellard if (type != TCG_TYPE_I64) 3266a8d7b76Sbellard tcg_abort(); 3276a8d7b76Sbellard idx = s->nb_globals; 3286a8d7b76Sbellard tcg_temp_alloc(s, s->nb_globals + 2); 3296a8d7b76Sbellard ts = &s->temps[s->nb_globals]; 3306a8d7b76Sbellard ts->base_type = type; 3316a8d7b76Sbellard ts->type = TCG_TYPE_I32; 3326a8d7b76Sbellard ts->fixed_reg = 1; 3336a8d7b76Sbellard ts->reg = reg1; 3346a8d7b76Sbellard pstrcpy(buf, sizeof(buf), name); 3356a8d7b76Sbellard pstrcat(buf, sizeof(buf), "_0"); 3366a8d7b76Sbellard ts->name = strdup(buf); 3376a8d7b76Sbellard 3386a8d7b76Sbellard ts++; 3396a8d7b76Sbellard ts->base_type = type; 3406a8d7b76Sbellard ts->type = TCG_TYPE_I32; 3416a8d7b76Sbellard ts->fixed_reg = 1; 3426a8d7b76Sbellard ts->reg = reg2; 3436a8d7b76Sbellard pstrcpy(buf, sizeof(buf), name); 3446a8d7b76Sbellard pstrcat(buf, sizeof(buf), "_1"); 3456a8d7b76Sbellard ts->name = strdup(buf); 3466a8d7b76Sbellard 3476a8d7b76Sbellard s->nb_globals += 2; 348a7812ae4Spbrook return MAKE_TCGV_I64(idx); 3496a8d7b76Sbellard } 3506a8d7b76Sbellard #endif 3516a8d7b76Sbellard 352a7812ae4Spbrook static inline int tcg_global_mem_new_internal(TCGType type, int reg, 353a7812ae4Spbrook tcg_target_long offset, 354c896fe29Sbellard const char *name) 355c896fe29Sbellard { 356c896fe29Sbellard TCGContext *s = &tcg_ctx; 357c896fe29Sbellard TCGTemp *ts; 358c896fe29Sbellard int idx; 359c896fe29Sbellard 360c896fe29Sbellard idx = s->nb_globals; 361c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 362c896fe29Sbellard if (type == TCG_TYPE_I64) { 363c896fe29Sbellard char buf[64]; 364c588979bSths tcg_temp_alloc(s, s->nb_globals + 2); 365c896fe29Sbellard ts = &s->temps[s->nb_globals]; 366c896fe29Sbellard ts->base_type = type; 367c896fe29Sbellard ts->type = TCG_TYPE_I32; 368c896fe29Sbellard ts->fixed_reg = 0; 369c896fe29Sbellard ts->mem_allocated = 1; 370c896fe29Sbellard ts->mem_reg = reg; 371c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 372c896fe29Sbellard ts->mem_offset = offset + 4; 373c896fe29Sbellard #else 374c896fe29Sbellard ts->mem_offset = offset; 375c896fe29Sbellard #endif 376c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 377c896fe29Sbellard pstrcat(buf, sizeof(buf), "_0"); 378c896fe29Sbellard ts->name = strdup(buf); 379c896fe29Sbellard ts++; 380c896fe29Sbellard 381c896fe29Sbellard ts->base_type = type; 382c896fe29Sbellard ts->type = TCG_TYPE_I32; 383c896fe29Sbellard ts->fixed_reg = 0; 384c896fe29Sbellard ts->mem_allocated = 1; 385c896fe29Sbellard ts->mem_reg = reg; 386c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 387c896fe29Sbellard ts->mem_offset = offset; 388c896fe29Sbellard #else 389c896fe29Sbellard ts->mem_offset = offset + 4; 390c896fe29Sbellard #endif 391c896fe29Sbellard pstrcpy(buf, sizeof(buf), name); 392c896fe29Sbellard pstrcat(buf, sizeof(buf), "_1"); 393c896fe29Sbellard ts->name = strdup(buf); 394c896fe29Sbellard 395c896fe29Sbellard s->nb_globals += 2; 396c896fe29Sbellard } else 397c896fe29Sbellard #endif 398c896fe29Sbellard { 399c896fe29Sbellard tcg_temp_alloc(s, s->nb_globals + 1); 400c896fe29Sbellard ts = &s->temps[s->nb_globals]; 401c896fe29Sbellard ts->base_type = type; 402c896fe29Sbellard ts->type = type; 403c896fe29Sbellard ts->fixed_reg = 0; 404c896fe29Sbellard ts->mem_allocated = 1; 405c896fe29Sbellard ts->mem_reg = reg; 406c896fe29Sbellard ts->mem_offset = offset; 407c896fe29Sbellard ts->name = name; 408c896fe29Sbellard s->nb_globals++; 409c896fe29Sbellard } 410a7812ae4Spbrook return idx; 411c896fe29Sbellard } 412c896fe29Sbellard 413a7812ae4Spbrook TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset, 414a7812ae4Spbrook const char *name) 415a7812ae4Spbrook { 416a7812ae4Spbrook int idx; 417a7812ae4Spbrook 418a7812ae4Spbrook idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name); 419a7812ae4Spbrook return MAKE_TCGV_I32(idx); 420a7812ae4Spbrook } 421a7812ae4Spbrook 422a7812ae4Spbrook TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset, 423a7812ae4Spbrook const char *name) 424a7812ae4Spbrook { 425a7812ae4Spbrook int idx; 426a7812ae4Spbrook 427a7812ae4Spbrook idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name); 428a7812ae4Spbrook return MAKE_TCGV_I64(idx); 429a7812ae4Spbrook } 430a7812ae4Spbrook 431a7812ae4Spbrook static inline int tcg_temp_new_internal(TCGType type, int temp_local) 432c896fe29Sbellard { 433c896fe29Sbellard TCGContext *s = &tcg_ctx; 434c896fe29Sbellard TCGTemp *ts; 435641d5fbeSbellard int idx, k; 436c896fe29Sbellard 437641d5fbeSbellard k = type; 438641d5fbeSbellard if (temp_local) 439641d5fbeSbellard k += TCG_TYPE_COUNT; 440641d5fbeSbellard idx = s->first_free_temp[k]; 441e8996ee0Sbellard if (idx != -1) { 442e8996ee0Sbellard /* There is already an available temp with the 443e8996ee0Sbellard right type */ 444e8996ee0Sbellard ts = &s->temps[idx]; 445641d5fbeSbellard s->first_free_temp[k] = ts->next_free_temp; 446e8996ee0Sbellard ts->temp_allocated = 1; 447641d5fbeSbellard assert(ts->temp_local == temp_local); 448e8996ee0Sbellard } else { 449c896fe29Sbellard idx = s->nb_temps; 450c896fe29Sbellard #if TCG_TARGET_REG_BITS == 32 451c896fe29Sbellard if (type == TCG_TYPE_I64) { 4528df1ca4bSths tcg_temp_alloc(s, s->nb_temps + 2); 453c896fe29Sbellard ts = &s->temps[s->nb_temps]; 454c896fe29Sbellard ts->base_type = type; 455c896fe29Sbellard ts->type = TCG_TYPE_I32; 456e8996ee0Sbellard ts->temp_allocated = 1; 457641d5fbeSbellard ts->temp_local = temp_local; 458c896fe29Sbellard ts->name = NULL; 459c896fe29Sbellard ts++; 460c896fe29Sbellard ts->base_type = TCG_TYPE_I32; 461c896fe29Sbellard ts->type = TCG_TYPE_I32; 462e8996ee0Sbellard ts->temp_allocated = 1; 463641d5fbeSbellard ts->temp_local = temp_local; 464c896fe29Sbellard ts->name = NULL; 465c896fe29Sbellard s->nb_temps += 2; 466c896fe29Sbellard } else 467c896fe29Sbellard #endif 468c896fe29Sbellard { 469c896fe29Sbellard tcg_temp_alloc(s, s->nb_temps + 1); 470c896fe29Sbellard ts = &s->temps[s->nb_temps]; 471c896fe29Sbellard ts->base_type = type; 472c896fe29Sbellard ts->type = type; 473e8996ee0Sbellard ts->temp_allocated = 1; 474641d5fbeSbellard ts->temp_local = temp_local; 475c896fe29Sbellard ts->name = NULL; 476c896fe29Sbellard s->nb_temps++; 477c896fe29Sbellard } 478e8996ee0Sbellard } 479a7812ae4Spbrook return idx; 480c896fe29Sbellard } 481c896fe29Sbellard 482a7812ae4Spbrook TCGv_i32 tcg_temp_new_internal_i32(int temp_local) 483a7812ae4Spbrook { 484a7812ae4Spbrook int idx; 485a7812ae4Spbrook 486a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I32, temp_local); 487a7812ae4Spbrook return MAKE_TCGV_I32(idx); 488a7812ae4Spbrook } 489a7812ae4Spbrook 490a7812ae4Spbrook TCGv_i64 tcg_temp_new_internal_i64(int temp_local) 491a7812ae4Spbrook { 492a7812ae4Spbrook int idx; 493a7812ae4Spbrook 494a7812ae4Spbrook idx = tcg_temp_new_internal(TCG_TYPE_I64, temp_local); 495a7812ae4Spbrook return MAKE_TCGV_I64(idx); 496a7812ae4Spbrook } 497a7812ae4Spbrook 498a7812ae4Spbrook static inline void tcg_temp_free_internal(int idx) 499c896fe29Sbellard { 500c896fe29Sbellard TCGContext *s = &tcg_ctx; 501c896fe29Sbellard TCGTemp *ts; 502641d5fbeSbellard int k; 503c896fe29Sbellard 504e8996ee0Sbellard assert(idx >= s->nb_globals && idx < s->nb_temps); 505c896fe29Sbellard ts = &s->temps[idx]; 506e8996ee0Sbellard assert(ts->temp_allocated != 0); 507e8996ee0Sbellard ts->temp_allocated = 0; 508641d5fbeSbellard k = ts->base_type; 509641d5fbeSbellard if (ts->temp_local) 510641d5fbeSbellard k += TCG_TYPE_COUNT; 511641d5fbeSbellard ts->next_free_temp = s->first_free_temp[k]; 512641d5fbeSbellard s->first_free_temp[k] = idx; 513e8996ee0Sbellard } 514e8996ee0Sbellard 515a7812ae4Spbrook void tcg_temp_free_i32(TCGv_i32 arg) 516e8996ee0Sbellard { 517a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I32(arg)); 518a7812ae4Spbrook } 519a7812ae4Spbrook 520a7812ae4Spbrook void tcg_temp_free_i64(TCGv_i64 arg) 521a7812ae4Spbrook { 522a7812ae4Spbrook tcg_temp_free_internal(GET_TCGV_I64(arg)); 523a7812ae4Spbrook } 524a7812ae4Spbrook 525a7812ae4Spbrook TCGv_i32 tcg_const_i32(int32_t val) 526a7812ae4Spbrook { 527a7812ae4Spbrook TCGv_i32 t0; 528a7812ae4Spbrook t0 = tcg_temp_new_i32(); 529e8996ee0Sbellard tcg_gen_movi_i32(t0, val); 530e8996ee0Sbellard return t0; 531c896fe29Sbellard } 532c896fe29Sbellard 533a7812ae4Spbrook TCGv_i64 tcg_const_i64(int64_t val) 534c896fe29Sbellard { 535a7812ae4Spbrook TCGv_i64 t0; 536a7812ae4Spbrook t0 = tcg_temp_new_i64(); 537e8996ee0Sbellard tcg_gen_movi_i64(t0, val); 538e8996ee0Sbellard return t0; 539c896fe29Sbellard } 540c896fe29Sbellard 541a7812ae4Spbrook TCGv_i32 tcg_const_local_i32(int32_t val) 542bdffd4a9Saurel32 { 543a7812ae4Spbrook TCGv_i32 t0; 544a7812ae4Spbrook t0 = tcg_temp_local_new_i32(); 545bdffd4a9Saurel32 tcg_gen_movi_i32(t0, val); 546bdffd4a9Saurel32 return t0; 547bdffd4a9Saurel32 } 548bdffd4a9Saurel32 549a7812ae4Spbrook TCGv_i64 tcg_const_local_i64(int64_t val) 550bdffd4a9Saurel32 { 551a7812ae4Spbrook TCGv_i64 t0; 552a7812ae4Spbrook t0 = tcg_temp_local_new_i64(); 553bdffd4a9Saurel32 tcg_gen_movi_i64(t0, val); 554bdffd4a9Saurel32 return t0; 555bdffd4a9Saurel32 } 556bdffd4a9Saurel32 557c896fe29Sbellard void tcg_register_helper(void *func, const char *name) 558c896fe29Sbellard { 559c896fe29Sbellard TCGContext *s = &tcg_ctx; 560c896fe29Sbellard int n; 561c896fe29Sbellard if ((s->nb_helpers + 1) > s->allocated_helpers) { 562c896fe29Sbellard n = s->allocated_helpers; 563c896fe29Sbellard if (n == 0) { 564c896fe29Sbellard n = 4; 565c896fe29Sbellard } else { 566c896fe29Sbellard n *= 2; 567c896fe29Sbellard } 568c896fe29Sbellard s->helpers = realloc(s->helpers, n * sizeof(TCGHelperInfo)); 569c896fe29Sbellard s->allocated_helpers = n; 570c896fe29Sbellard } 5714dc81f28Sbellard s->helpers[s->nb_helpers].func = (tcg_target_ulong)func; 572c896fe29Sbellard s->helpers[s->nb_helpers].name = name; 573c896fe29Sbellard s->nb_helpers++; 574c896fe29Sbellard } 575c896fe29Sbellard 57639cf05d3Sbellard /* Note: we convert the 64 bit args to 32 bit and do some alignment 57739cf05d3Sbellard and endian swap. Maybe it would be better to do the alignment 57839cf05d3Sbellard and endian swap in tcg_reg_alloc_call(). */ 579a7812ae4Spbrook void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags, 580a7812ae4Spbrook int sizemask, TCGArg ret, int nargs, TCGArg *args) 581c896fe29Sbellard { 582a7812ae4Spbrook int call_type; 583a7812ae4Spbrook int i; 584a7812ae4Spbrook int real_args; 585a7812ae4Spbrook int nb_rets; 586a7812ae4Spbrook TCGArg *nparam; 587a7812ae4Spbrook *gen_opc_ptr++ = INDEX_op_call; 588a7812ae4Spbrook nparam = gen_opparam_ptr++; 589c896fe29Sbellard call_type = (flags & TCG_CALL_TYPE_MASK); 590a7812ae4Spbrook if (ret != TCG_CALL_DUMMY_ARG) { 591a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 592a7812ae4Spbrook if (sizemask & 1) { 593a7812ae4Spbrook #ifdef TCG_TARGET_WORDS_BIGENDIAN 594a7812ae4Spbrook *gen_opparam_ptr++ = ret + 1; 595a7812ae4Spbrook *gen_opparam_ptr++ = ret; 596a7812ae4Spbrook #else 597a7812ae4Spbrook *gen_opparam_ptr++ = ret; 598a7812ae4Spbrook *gen_opparam_ptr++ = ret + 1; 599a7812ae4Spbrook #endif 600a7812ae4Spbrook nb_rets = 2; 601a7812ae4Spbrook } else 602a7812ae4Spbrook #endif 603a7812ae4Spbrook { 604a7812ae4Spbrook *gen_opparam_ptr++ = ret; 605a7812ae4Spbrook nb_rets = 1; 606a7812ae4Spbrook } 607a7812ae4Spbrook } else { 608a7812ae4Spbrook nb_rets = 0; 609a7812ae4Spbrook } 610a7812ae4Spbrook real_args = 0; 611a7812ae4Spbrook for (i = 0; i < nargs; i++) { 612a7812ae4Spbrook #if TCG_TARGET_REG_BITS < 64 613a7812ae4Spbrook if (sizemask & (2 << i)) { 614c896fe29Sbellard #ifdef TCG_TARGET_I386 615c896fe29Sbellard /* REGPARM case: if the third parameter is 64 bit, it is 616c896fe29Sbellard allocated on the stack */ 617a7812ae4Spbrook if (i == 2 && call_type == TCG_CALL_TYPE_REGPARM) { 618c896fe29Sbellard call_type = TCG_CALL_TYPE_REGPARM_2; 619c896fe29Sbellard flags = (flags & ~TCG_CALL_TYPE_MASK) | call_type; 620c896fe29Sbellard } 621a7812ae4Spbrook #endif 62239cf05d3Sbellard #ifdef TCG_TARGET_CALL_ALIGN_ARGS 62339cf05d3Sbellard /* some targets want aligned 64 bit args */ 624ebd486d5Smalc if (real_args & 1) { 625a7812ae4Spbrook *gen_opparam_ptr++ = TCG_CALL_DUMMY_ARG; 626ebd486d5Smalc real_args++; 62739cf05d3Sbellard } 62839cf05d3Sbellard #endif 629c896fe29Sbellard #ifdef TCG_TARGET_WORDS_BIGENDIAN 630a7812ae4Spbrook *gen_opparam_ptr++ = args[i] + 1; 631a7812ae4Spbrook *gen_opparam_ptr++ = args[i]; 632c896fe29Sbellard #else 633a7812ae4Spbrook *gen_opparam_ptr++ = args[i]; 634a7812ae4Spbrook *gen_opparam_ptr++ = args[i] + 1; 635c896fe29Sbellard #endif 636a7812ae4Spbrook real_args += 2; 637a7812ae4Spbrook } else 638c896fe29Sbellard #endif 639c896fe29Sbellard { 640a7812ae4Spbrook *gen_opparam_ptr++ = args[i]; 641a7812ae4Spbrook real_args++; 642c896fe29Sbellard } 643a7812ae4Spbrook } 644a7812ae4Spbrook *gen_opparam_ptr++ = GET_TCGV_PTR(func); 645a7812ae4Spbrook 646a7812ae4Spbrook *gen_opparam_ptr++ = flags; 647a7812ae4Spbrook 648a7812ae4Spbrook *nparam = (nb_rets << 16) | (real_args + 1); 649a7812ae4Spbrook 650a7812ae4Spbrook /* total parameters, needed to go backward in the instruction stream */ 651a7812ae4Spbrook *gen_opparam_ptr++ = 1 + nb_rets + real_args + 3; 652a7812ae4Spbrook } 653c896fe29Sbellard 654ac56dd48Spbrook #if TCG_TARGET_REG_BITS == 32 655a7812ae4Spbrook void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, 656c896fe29Sbellard int c, int right, int arith) 657c896fe29Sbellard { 658cf60bce4Sbellard if (c == 0) { 659a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1)); 660cf60bce4Sbellard tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1)); 661cf60bce4Sbellard } else if (c >= 32) { 662c896fe29Sbellard c -= 32; 663c896fe29Sbellard if (right) { 664c896fe29Sbellard if (arith) { 665a7812ae4Spbrook tcg_gen_sari_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 666ac56dd48Spbrook tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 31); 667c896fe29Sbellard } else { 668a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c); 669ac56dd48Spbrook tcg_gen_movi_i32(TCGV_HIGH(ret), 0); 670c896fe29Sbellard } 671c896fe29Sbellard } else { 672a7812ae4Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_LOW(arg1), c); 673a7812ae4Spbrook tcg_gen_movi_i32(TCGV_LOW(ret), 0); 674c896fe29Sbellard } 675c896fe29Sbellard } else { 676a7812ae4Spbrook TCGv_i32 t0, t1; 677c896fe29Sbellard 678a7812ae4Spbrook t0 = tcg_temp_new_i32(); 679a7812ae4Spbrook t1 = tcg_temp_new_i32(); 680c896fe29Sbellard if (right) { 681ac56dd48Spbrook tcg_gen_shli_i32(t0, TCGV_HIGH(arg1), 32 - c); 682c896fe29Sbellard if (arith) 683ac56dd48Spbrook tcg_gen_sari_i32(t1, TCGV_HIGH(arg1), c); 684c896fe29Sbellard else 685ac56dd48Spbrook tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c); 686a7812ae4Spbrook tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_LOW(arg1), c); 687a7812ae4Spbrook tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t0); 688ac56dd48Spbrook tcg_gen_mov_i32(TCGV_HIGH(ret), t1); 689c896fe29Sbellard } else { 690a7812ae4Spbrook tcg_gen_shri_i32(t0, TCGV_LOW(arg1), 32 - c); 691c896fe29Sbellard /* Note: ret can be the same as arg1, so we use t1 */ 692a7812ae4Spbrook tcg_gen_shli_i32(t1, TCGV_LOW(arg1), c); 693ac56dd48Spbrook tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c); 694ac56dd48Spbrook tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0); 695a7812ae4Spbrook tcg_gen_mov_i32(TCGV_LOW(ret), t1); 696c896fe29Sbellard } 697a7812ae4Spbrook tcg_temp_free_i32(t0); 698a7812ae4Spbrook tcg_temp_free_i32(t1); 699c896fe29Sbellard } 700c896fe29Sbellard } 701ac56dd48Spbrook #endif 702c896fe29Sbellard 7038fcd3692Sblueswir1 static void tcg_reg_alloc_start(TCGContext *s) 704c896fe29Sbellard { 705c896fe29Sbellard int i; 706c896fe29Sbellard TCGTemp *ts; 707c896fe29Sbellard for(i = 0; i < s->nb_globals; i++) { 708c896fe29Sbellard ts = &s->temps[i]; 709c896fe29Sbellard if (ts->fixed_reg) { 710c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 711c896fe29Sbellard } else { 712c896fe29Sbellard ts->val_type = TEMP_VAL_MEM; 713c896fe29Sbellard } 714c896fe29Sbellard } 715e8996ee0Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 716e8996ee0Sbellard ts = &s->temps[i]; 717e8996ee0Sbellard ts->val_type = TEMP_VAL_DEAD; 718e8996ee0Sbellard ts->mem_allocated = 0; 719e8996ee0Sbellard ts->fixed_reg = 0; 720e8996ee0Sbellard } 721c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 722c896fe29Sbellard s->reg_to_temp[i] = -1; 723c896fe29Sbellard } 724c896fe29Sbellard } 725c896fe29Sbellard 726ac56dd48Spbrook static char *tcg_get_arg_str_idx(TCGContext *s, char *buf, int buf_size, 727ac56dd48Spbrook int idx) 728c896fe29Sbellard { 729c896fe29Sbellard TCGTemp *ts; 730ac56dd48Spbrook 731ac56dd48Spbrook ts = &s->temps[idx]; 732ac56dd48Spbrook if (idx < s->nb_globals) { 733ac56dd48Spbrook pstrcpy(buf, buf_size, ts->name); 734c896fe29Sbellard } else { 735641d5fbeSbellard if (ts->temp_local) 736641d5fbeSbellard snprintf(buf, buf_size, "loc%d", idx - s->nb_globals); 737641d5fbeSbellard else 738ac56dd48Spbrook snprintf(buf, buf_size, "tmp%d", idx - s->nb_globals); 739c896fe29Sbellard } 740c896fe29Sbellard return buf; 741c896fe29Sbellard } 742c896fe29Sbellard 743a7812ae4Spbrook char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg) 744ac56dd48Spbrook { 745a7812ae4Spbrook return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I32(arg)); 746a7812ae4Spbrook } 747a7812ae4Spbrook 748a7812ae4Spbrook char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg) 749a7812ae4Spbrook { 750*a810a2deSblueswir1 return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I64(arg)); 751ac56dd48Spbrook } 752ac56dd48Spbrook 753e8996ee0Sbellard static int helper_cmp(const void *p1, const void *p2) 754e8996ee0Sbellard { 755e8996ee0Sbellard const TCGHelperInfo *th1 = p1; 756e8996ee0Sbellard const TCGHelperInfo *th2 = p2; 757e8996ee0Sbellard if (th1->func < th2->func) 758e8996ee0Sbellard return -1; 759e8996ee0Sbellard else if (th1->func == th2->func) 760e8996ee0Sbellard return 0; 761e8996ee0Sbellard else 762e8996ee0Sbellard return 1; 763e8996ee0Sbellard } 764e8996ee0Sbellard 765e8996ee0Sbellard /* find helper definition (Note: A hash table would be better) */ 7664dc81f28Sbellard static TCGHelperInfo *tcg_find_helper(TCGContext *s, tcg_target_ulong val) 7674dc81f28Sbellard { 768e8996ee0Sbellard int m, m_min, m_max; 769e8996ee0Sbellard TCGHelperInfo *th; 770e8996ee0Sbellard tcg_target_ulong v; 771e8996ee0Sbellard 772e8996ee0Sbellard if (unlikely(!s->helpers_sorted)) { 773e8996ee0Sbellard qsort(s->helpers, s->nb_helpers, sizeof(TCGHelperInfo), 774e8996ee0Sbellard helper_cmp); 775e8996ee0Sbellard s->helpers_sorted = 1; 776e8996ee0Sbellard } 777e8996ee0Sbellard 778e8996ee0Sbellard /* binary search */ 779e8996ee0Sbellard m_min = 0; 780e8996ee0Sbellard m_max = s->nb_helpers - 1; 781e8996ee0Sbellard while (m_min <= m_max) { 782e8996ee0Sbellard m = (m_min + m_max) >> 1; 783e8996ee0Sbellard th = &s->helpers[m]; 784e8996ee0Sbellard v = th->func; 785e8996ee0Sbellard if (v == val) 786e8996ee0Sbellard return th; 787e8996ee0Sbellard else if (val < v) { 788e8996ee0Sbellard m_max = m - 1; 789e8996ee0Sbellard } else { 790e8996ee0Sbellard m_min = m + 1; 791e8996ee0Sbellard } 7924dc81f28Sbellard } 7934dc81f28Sbellard return NULL; 7944dc81f28Sbellard } 7954dc81f28Sbellard 796f48f3edeSblueswir1 static const char * const cond_name[] = 797f48f3edeSblueswir1 { 798f48f3edeSblueswir1 [TCG_COND_EQ] = "eq", 799f48f3edeSblueswir1 [TCG_COND_NE] = "ne", 800f48f3edeSblueswir1 [TCG_COND_LT] = "lt", 801f48f3edeSblueswir1 [TCG_COND_GE] = "ge", 802f48f3edeSblueswir1 [TCG_COND_LE] = "le", 803f48f3edeSblueswir1 [TCG_COND_GT] = "gt", 804f48f3edeSblueswir1 [TCG_COND_LTU] = "ltu", 805f48f3edeSblueswir1 [TCG_COND_GEU] = "geu", 806f48f3edeSblueswir1 [TCG_COND_LEU] = "leu", 807f48f3edeSblueswir1 [TCG_COND_GTU] = "gtu" 808f48f3edeSblueswir1 }; 809f48f3edeSblueswir1 810c896fe29Sbellard void tcg_dump_ops(TCGContext *s, FILE *outfile) 811c896fe29Sbellard { 812c896fe29Sbellard const uint16_t *opc_ptr; 813c896fe29Sbellard const TCGArg *args; 814c896fe29Sbellard TCGArg arg; 8157e4597d7Sbellard int c, i, k, nb_oargs, nb_iargs, nb_cargs, first_insn; 816c896fe29Sbellard const TCGOpDef *def; 817c896fe29Sbellard char buf[128]; 818c896fe29Sbellard 8197e4597d7Sbellard first_insn = 1; 820c896fe29Sbellard opc_ptr = gen_opc_buf; 821c896fe29Sbellard args = gen_opparam_buf; 822c896fe29Sbellard while (opc_ptr < gen_opc_ptr) { 823c896fe29Sbellard c = *opc_ptr++; 824c896fe29Sbellard def = &tcg_op_defs[c]; 8257e4597d7Sbellard if (c == INDEX_op_debug_insn_start) { 8267e4597d7Sbellard uint64_t pc; 8277e4597d7Sbellard #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS 8287e4597d7Sbellard pc = ((uint64_t)args[1] << 32) | args[0]; 8297e4597d7Sbellard #else 8307e4597d7Sbellard pc = args[0]; 8317e4597d7Sbellard #endif 8327e4597d7Sbellard if (!first_insn) 8337e4597d7Sbellard fprintf(outfile, "\n"); 8347e4597d7Sbellard fprintf(outfile, " ---- 0x%" PRIx64, pc); 8357e4597d7Sbellard first_insn = 0; 8367e4597d7Sbellard nb_oargs = def->nb_oargs; 8377e4597d7Sbellard nb_iargs = def->nb_iargs; 8387e4597d7Sbellard nb_cargs = def->nb_cargs; 8397e4597d7Sbellard } else if (c == INDEX_op_call) { 840c896fe29Sbellard TCGArg arg; 8414dc81f28Sbellard 842c896fe29Sbellard /* variable number of arguments */ 843c896fe29Sbellard arg = *args++; 844c896fe29Sbellard nb_oargs = arg >> 16; 845c896fe29Sbellard nb_iargs = arg & 0xffff; 846c896fe29Sbellard nb_cargs = def->nb_cargs; 847b03cce8eSbellard 8487e4597d7Sbellard fprintf(outfile, " %s ", def->name); 8497e4597d7Sbellard 850b03cce8eSbellard /* function name */ 851b03cce8eSbellard fprintf(outfile, "%s", 852e8996ee0Sbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + nb_iargs - 1])); 853b03cce8eSbellard /* flags */ 854b03cce8eSbellard fprintf(outfile, ",$0x%" TCG_PRIlx, 855b03cce8eSbellard args[nb_oargs + nb_iargs]); 856b03cce8eSbellard /* nb out args */ 857b03cce8eSbellard fprintf(outfile, ",$%d", nb_oargs); 858b03cce8eSbellard for(i = 0; i < nb_oargs; i++) { 859b03cce8eSbellard fprintf(outfile, ","); 860b03cce8eSbellard fprintf(outfile, "%s", 861b03cce8eSbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[i])); 862b03cce8eSbellard } 863b03cce8eSbellard for(i = 0; i < (nb_iargs - 1); i++) { 864b03cce8eSbellard fprintf(outfile, ","); 86539cf05d3Sbellard if (args[nb_oargs + i] == TCG_CALL_DUMMY_ARG) { 86639cf05d3Sbellard fprintf(outfile, "<dummy>"); 86739cf05d3Sbellard } else { 868b03cce8eSbellard fprintf(outfile, "%s", 869b03cce8eSbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[nb_oargs + i])); 870b03cce8eSbellard } 87139cf05d3Sbellard } 872e8996ee0Sbellard } else if (c == INDEX_op_movi_i32 873e8996ee0Sbellard #if TCG_TARGET_REG_BITS == 64 874e8996ee0Sbellard || c == INDEX_op_movi_i64 875e8996ee0Sbellard #endif 876e8996ee0Sbellard ) { 877e8996ee0Sbellard tcg_target_ulong val; 878e8996ee0Sbellard TCGHelperInfo *th; 879e8996ee0Sbellard 880e8996ee0Sbellard nb_oargs = def->nb_oargs; 881e8996ee0Sbellard nb_iargs = def->nb_iargs; 882e8996ee0Sbellard nb_cargs = def->nb_cargs; 883e8996ee0Sbellard fprintf(outfile, " %s %s,$", def->name, 884e8996ee0Sbellard tcg_get_arg_str_idx(s, buf, sizeof(buf), args[0])); 885e8996ee0Sbellard val = args[1]; 886e8996ee0Sbellard th = tcg_find_helper(s, val); 887e8996ee0Sbellard if (th) { 888e8996ee0Sbellard fprintf(outfile, th->name); 889e8996ee0Sbellard } else { 890e8996ee0Sbellard if (c == INDEX_op_movi_i32) 891e8996ee0Sbellard fprintf(outfile, "0x%x", (uint32_t)val); 892e8996ee0Sbellard else 893e8996ee0Sbellard fprintf(outfile, "0x%" PRIx64 , (uint64_t)val); 894e8996ee0Sbellard } 895b03cce8eSbellard } else { 8967e4597d7Sbellard fprintf(outfile, " %s ", def->name); 897b03cce8eSbellard if (c == INDEX_op_nopn) { 898c896fe29Sbellard /* variable number of arguments */ 899c896fe29Sbellard nb_cargs = *args; 900c896fe29Sbellard nb_oargs = 0; 901c896fe29Sbellard nb_iargs = 0; 902c896fe29Sbellard } else { 903c896fe29Sbellard nb_oargs = def->nb_oargs; 904c896fe29Sbellard nb_iargs = def->nb_iargs; 905c896fe29Sbellard nb_cargs = def->nb_cargs; 906c896fe29Sbellard } 907c896fe29Sbellard 908c896fe29Sbellard k = 0; 909c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 910c896fe29Sbellard if (k != 0) 911c896fe29Sbellard fprintf(outfile, ","); 912ac56dd48Spbrook fprintf(outfile, "%s", 913ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), args[k++])); 914c896fe29Sbellard } 915c896fe29Sbellard for(i = 0; i < nb_iargs; i++) { 916c896fe29Sbellard if (k != 0) 917c896fe29Sbellard fprintf(outfile, ","); 918ac56dd48Spbrook fprintf(outfile, "%s", 919ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), args[k++])); 920c896fe29Sbellard } 921f48f3edeSblueswir1 if (c == INDEX_op_brcond_i32 922f48f3edeSblueswir1 #if TCG_TARGET_REG_BITS == 32 923f48f3edeSblueswir1 || c == INDEX_op_brcond2_i32 924f48f3edeSblueswir1 #elif TCG_TARGET_REG_BITS == 64 925f48f3edeSblueswir1 || c == INDEX_op_brcond_i64 926f48f3edeSblueswir1 #endif 927f48f3edeSblueswir1 ) { 928f48f3edeSblueswir1 if (args[k] < ARRAY_SIZE(cond_name) && cond_name[args[k]]) 929f48f3edeSblueswir1 fprintf(outfile, ",%s", cond_name[args[k++]]); 930f48f3edeSblueswir1 else 931f48f3edeSblueswir1 fprintf(outfile, ",$0x%" TCG_PRIlx, args[k++]); 932f48f3edeSblueswir1 i = 1; 933f48f3edeSblueswir1 } 934f48f3edeSblueswir1 else 935f48f3edeSblueswir1 i = 0; 936f48f3edeSblueswir1 for(; i < nb_cargs; i++) { 937c896fe29Sbellard if (k != 0) 938c896fe29Sbellard fprintf(outfile, ","); 939c896fe29Sbellard arg = args[k++]; 940c896fe29Sbellard fprintf(outfile, "$0x%" TCG_PRIlx, arg); 941c896fe29Sbellard } 942b03cce8eSbellard } 943c896fe29Sbellard fprintf(outfile, "\n"); 944c896fe29Sbellard args += nb_iargs + nb_oargs + nb_cargs; 945c896fe29Sbellard } 946c896fe29Sbellard } 947c896fe29Sbellard 948c896fe29Sbellard /* we give more priority to constraints with less registers */ 949c896fe29Sbellard static int get_constraint_priority(const TCGOpDef *def, int k) 950c896fe29Sbellard { 951c896fe29Sbellard const TCGArgConstraint *arg_ct; 952c896fe29Sbellard 953c896fe29Sbellard int i, n; 954c896fe29Sbellard arg_ct = &def->args_ct[k]; 955c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 956c896fe29Sbellard /* an alias is equivalent to a single register */ 957c896fe29Sbellard n = 1; 958c896fe29Sbellard } else { 959c896fe29Sbellard if (!(arg_ct->ct & TCG_CT_REG)) 960c896fe29Sbellard return 0; 961c896fe29Sbellard n = 0; 962c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 963c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, i)) 964c896fe29Sbellard n++; 965c896fe29Sbellard } 966c896fe29Sbellard } 967c896fe29Sbellard return TCG_TARGET_NB_REGS - n + 1; 968c896fe29Sbellard } 969c896fe29Sbellard 970c896fe29Sbellard /* sort from highest priority to lowest */ 971c896fe29Sbellard static void sort_constraints(TCGOpDef *def, int start, int n) 972c896fe29Sbellard { 973c896fe29Sbellard int i, j, p1, p2, tmp; 974c896fe29Sbellard 975c896fe29Sbellard for(i = 0; i < n; i++) 976c896fe29Sbellard def->sorted_args[start + i] = start + i; 977c896fe29Sbellard if (n <= 1) 978c896fe29Sbellard return; 979c896fe29Sbellard for(i = 0; i < n - 1; i++) { 980c896fe29Sbellard for(j = i + 1; j < n; j++) { 981c896fe29Sbellard p1 = get_constraint_priority(def, def->sorted_args[start + i]); 982c896fe29Sbellard p2 = get_constraint_priority(def, def->sorted_args[start + j]); 983c896fe29Sbellard if (p1 < p2) { 984c896fe29Sbellard tmp = def->sorted_args[start + i]; 985c896fe29Sbellard def->sorted_args[start + i] = def->sorted_args[start + j]; 986c896fe29Sbellard def->sorted_args[start + j] = tmp; 987c896fe29Sbellard } 988c896fe29Sbellard } 989c896fe29Sbellard } 990c896fe29Sbellard } 991c896fe29Sbellard 992c896fe29Sbellard void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs) 993c896fe29Sbellard { 994c896fe29Sbellard int op; 995c896fe29Sbellard TCGOpDef *def; 996c896fe29Sbellard const char *ct_str; 997c896fe29Sbellard int i, nb_args; 998c896fe29Sbellard 999c896fe29Sbellard for(;;) { 1000c896fe29Sbellard if (tdefs->op < 0) 1001c896fe29Sbellard break; 1002c896fe29Sbellard op = tdefs->op; 1003c896fe29Sbellard assert(op >= 0 && op < NB_OPS); 1004c896fe29Sbellard def = &tcg_op_defs[op]; 1005c896fe29Sbellard nb_args = def->nb_iargs + def->nb_oargs; 1006c896fe29Sbellard for(i = 0; i < nb_args; i++) { 1007c896fe29Sbellard ct_str = tdefs->args_ct_str[i]; 1008c896fe29Sbellard tcg_regset_clear(def->args_ct[i].u.regs); 1009c896fe29Sbellard def->args_ct[i].ct = 0; 1010c896fe29Sbellard if (ct_str[0] >= '0' && ct_str[0] <= '9') { 1011c896fe29Sbellard int oarg; 1012c896fe29Sbellard oarg = ct_str[0] - '0'; 1013c896fe29Sbellard assert(oarg < def->nb_oargs); 1014c896fe29Sbellard assert(def->args_ct[oarg].ct & TCG_CT_REG); 1015c896fe29Sbellard /* TCG_CT_ALIAS is for the output arguments. The input 10165ff9d6a4Sbellard argument is tagged with TCG_CT_IALIAS. */ 1017c896fe29Sbellard def->args_ct[i] = def->args_ct[oarg]; 10185ff9d6a4Sbellard def->args_ct[oarg].ct = TCG_CT_ALIAS; 10195ff9d6a4Sbellard def->args_ct[oarg].alias_index = i; 1020c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_IALIAS; 10215ff9d6a4Sbellard def->args_ct[i].alias_index = oarg; 1022c896fe29Sbellard } else { 1023c896fe29Sbellard for(;;) { 1024c896fe29Sbellard if (*ct_str == '\0') 1025c896fe29Sbellard break; 1026c896fe29Sbellard switch(*ct_str) { 1027c896fe29Sbellard case 'i': 1028c896fe29Sbellard def->args_ct[i].ct |= TCG_CT_CONST; 1029c896fe29Sbellard ct_str++; 1030c896fe29Sbellard break; 1031c896fe29Sbellard default: 1032c896fe29Sbellard if (target_parse_constraint(&def->args_ct[i], &ct_str) < 0) { 1033c896fe29Sbellard fprintf(stderr, "Invalid constraint '%s' for arg %d of operation '%s'\n", 1034c896fe29Sbellard ct_str, i, def->name); 1035c896fe29Sbellard exit(1); 1036c896fe29Sbellard } 1037c896fe29Sbellard } 1038c896fe29Sbellard } 1039c896fe29Sbellard } 1040c896fe29Sbellard } 1041c896fe29Sbellard 1042c896fe29Sbellard /* sort the constraints (XXX: this is just an heuristic) */ 1043c896fe29Sbellard sort_constraints(def, 0, def->nb_oargs); 1044c896fe29Sbellard sort_constraints(def, def->nb_oargs, def->nb_iargs); 1045c896fe29Sbellard 1046c896fe29Sbellard #if 0 1047c896fe29Sbellard { 1048c896fe29Sbellard int i; 1049c896fe29Sbellard 1050c896fe29Sbellard printf("%s: sorted=", def->name); 1051c896fe29Sbellard for(i = 0; i < def->nb_oargs + def->nb_iargs; i++) 1052c896fe29Sbellard printf(" %d", def->sorted_args[i]); 1053c896fe29Sbellard printf("\n"); 1054c896fe29Sbellard } 1055c896fe29Sbellard #endif 1056c896fe29Sbellard tdefs++; 1057c896fe29Sbellard } 1058c896fe29Sbellard 1059c896fe29Sbellard } 1060c896fe29Sbellard 1061c896fe29Sbellard #ifdef USE_LIVENESS_ANALYSIS 1062c896fe29Sbellard 1063c896fe29Sbellard /* set a nop for an operation using 'nb_args' */ 1064c896fe29Sbellard static inline void tcg_set_nop(TCGContext *s, uint16_t *opc_ptr, 1065c896fe29Sbellard TCGArg *args, int nb_args) 1066c896fe29Sbellard { 1067c896fe29Sbellard if (nb_args == 0) { 1068c896fe29Sbellard *opc_ptr = INDEX_op_nop; 1069c896fe29Sbellard } else { 1070c896fe29Sbellard *opc_ptr = INDEX_op_nopn; 1071c896fe29Sbellard args[0] = nb_args; 1072c896fe29Sbellard args[nb_args - 1] = nb_args; 1073c896fe29Sbellard } 1074c896fe29Sbellard } 1075c896fe29Sbellard 1076641d5fbeSbellard /* liveness analysis: end of function: globals are live, temps are 1077641d5fbeSbellard dead. */ 1078641d5fbeSbellard /* XXX: at this stage, not used as there would be little gains because 1079641d5fbeSbellard most TBs end with a conditional jump. */ 1080641d5fbeSbellard static inline void tcg_la_func_end(TCGContext *s, uint8_t *dead_temps) 1081c896fe29Sbellard { 1082c896fe29Sbellard memset(dead_temps, 0, s->nb_globals); 1083c896fe29Sbellard memset(dead_temps + s->nb_globals, 1, s->nb_temps - s->nb_globals); 1084c896fe29Sbellard } 1085c896fe29Sbellard 1086641d5fbeSbellard /* liveness analysis: end of basic block: globals are live, temps are 1087641d5fbeSbellard dead, local temps are live. */ 1088641d5fbeSbellard static inline void tcg_la_bb_end(TCGContext *s, uint8_t *dead_temps) 1089641d5fbeSbellard { 1090641d5fbeSbellard int i; 1091641d5fbeSbellard TCGTemp *ts; 1092641d5fbeSbellard 1093641d5fbeSbellard memset(dead_temps, 0, s->nb_globals); 1094641d5fbeSbellard ts = &s->temps[s->nb_globals]; 1095641d5fbeSbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 1096641d5fbeSbellard if (ts->temp_local) 1097641d5fbeSbellard dead_temps[i] = 0; 1098641d5fbeSbellard else 1099641d5fbeSbellard dead_temps[i] = 1; 1100641d5fbeSbellard ts++; 1101641d5fbeSbellard } 1102641d5fbeSbellard } 1103641d5fbeSbellard 1104c896fe29Sbellard /* Liveness analysis : update the opc_dead_iargs array to tell if a 1105c896fe29Sbellard given input arguments is dead. Instructions updating dead 1106c896fe29Sbellard temporaries are removed. */ 11078fcd3692Sblueswir1 static void tcg_liveness_analysis(TCGContext *s) 1108c896fe29Sbellard { 1109c896fe29Sbellard int i, op_index, op, nb_args, nb_iargs, nb_oargs, arg, nb_ops; 1110c896fe29Sbellard TCGArg *args; 1111c896fe29Sbellard const TCGOpDef *def; 1112c896fe29Sbellard uint8_t *dead_temps; 1113c896fe29Sbellard unsigned int dead_iargs; 1114c896fe29Sbellard 1115c896fe29Sbellard gen_opc_ptr++; /* skip end */ 1116c896fe29Sbellard 1117c896fe29Sbellard nb_ops = gen_opc_ptr - gen_opc_buf; 1118c896fe29Sbellard 1119c896fe29Sbellard /* XXX: make it really dynamic */ 1120c896fe29Sbellard s->op_dead_iargs = tcg_malloc(OPC_BUF_SIZE * sizeof(uint16_t)); 1121c896fe29Sbellard 1122c896fe29Sbellard dead_temps = tcg_malloc(s->nb_temps); 1123c896fe29Sbellard memset(dead_temps, 1, s->nb_temps); 1124c896fe29Sbellard 1125c896fe29Sbellard args = gen_opparam_ptr; 1126c896fe29Sbellard op_index = nb_ops - 1; 1127c896fe29Sbellard while (op_index >= 0) { 1128c896fe29Sbellard op = gen_opc_buf[op_index]; 1129c896fe29Sbellard def = &tcg_op_defs[op]; 1130c896fe29Sbellard switch(op) { 1131c896fe29Sbellard case INDEX_op_call: 1132c6e113f5Sbellard { 1133c6e113f5Sbellard int call_flags; 1134c6e113f5Sbellard 1135c896fe29Sbellard nb_args = args[-1]; 1136c896fe29Sbellard args -= nb_args; 1137c896fe29Sbellard nb_iargs = args[0] & 0xffff; 1138c896fe29Sbellard nb_oargs = args[0] >> 16; 1139c896fe29Sbellard args++; 1140c6e113f5Sbellard call_flags = args[nb_oargs + nb_iargs]; 1141c6e113f5Sbellard 1142c6e113f5Sbellard /* pure functions can be removed if their result is not 1143c6e113f5Sbellard used */ 1144c6e113f5Sbellard if (call_flags & TCG_CALL_PURE) { 1145c6e113f5Sbellard for(i = 0; i < nb_oargs; i++) { 1146c6e113f5Sbellard arg = args[i]; 1147c6e113f5Sbellard if (!dead_temps[arg]) 1148c6e113f5Sbellard goto do_not_remove_call; 1149c6e113f5Sbellard } 1150c6e113f5Sbellard tcg_set_nop(s, gen_opc_buf + op_index, 1151c6e113f5Sbellard args - 1, nb_args); 1152c6e113f5Sbellard } else { 1153c6e113f5Sbellard do_not_remove_call: 1154c896fe29Sbellard 1155c896fe29Sbellard /* output args are dead */ 1156c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1157c896fe29Sbellard arg = args[i]; 1158c896fe29Sbellard dead_temps[arg] = 1; 1159c896fe29Sbellard } 1160c896fe29Sbellard 1161c896fe29Sbellard /* globals are live (they may be used by the call) */ 1162c896fe29Sbellard memset(dead_temps, 0, s->nb_globals); 1163c896fe29Sbellard 1164c896fe29Sbellard /* input args are live */ 1165c896fe29Sbellard dead_iargs = 0; 1166c896fe29Sbellard for(i = 0; i < nb_iargs; i++) { 1167c896fe29Sbellard arg = args[i + nb_oargs]; 116839cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 1169c896fe29Sbellard if (dead_temps[arg]) { 1170c896fe29Sbellard dead_iargs |= (1 << i); 1171c896fe29Sbellard } 1172c896fe29Sbellard dead_temps[arg] = 0; 1173c896fe29Sbellard } 117439cf05d3Sbellard } 1175c896fe29Sbellard s->op_dead_iargs[op_index] = dead_iargs; 1176c6e113f5Sbellard } 1177c896fe29Sbellard args--; 1178c6e113f5Sbellard } 1179c896fe29Sbellard break; 1180c896fe29Sbellard case INDEX_op_set_label: 1181c896fe29Sbellard args--; 1182c896fe29Sbellard /* mark end of basic block */ 1183c896fe29Sbellard tcg_la_bb_end(s, dead_temps); 1184c896fe29Sbellard break; 11857e4597d7Sbellard case INDEX_op_debug_insn_start: 11867e4597d7Sbellard args -= def->nb_args; 11877e4597d7Sbellard break; 1188c896fe29Sbellard case INDEX_op_nopn: 1189c896fe29Sbellard nb_args = args[-1]; 1190c896fe29Sbellard args -= nb_args; 1191c896fe29Sbellard break; 11925ff9d6a4Sbellard case INDEX_op_discard: 11935ff9d6a4Sbellard args--; 11945ff9d6a4Sbellard /* mark the temporary as dead */ 11955ff9d6a4Sbellard dead_temps[args[0]] = 1; 11965ff9d6a4Sbellard break; 1197c896fe29Sbellard case INDEX_op_end: 1198c896fe29Sbellard break; 1199c896fe29Sbellard /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */ 1200c896fe29Sbellard default: 1201c896fe29Sbellard if (op > INDEX_op_end) { 1202c896fe29Sbellard args -= def->nb_args; 1203c896fe29Sbellard nb_iargs = def->nb_iargs; 1204c896fe29Sbellard nb_oargs = def->nb_oargs; 1205c896fe29Sbellard 1206c896fe29Sbellard /* Test if the operation can be removed because all 12075ff9d6a4Sbellard its outputs are dead. We assume that nb_oargs == 0 12085ff9d6a4Sbellard implies side effects */ 12095ff9d6a4Sbellard if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) { 1210c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1211c896fe29Sbellard arg = args[i]; 1212c896fe29Sbellard if (!dead_temps[arg]) 1213c896fe29Sbellard goto do_not_remove; 1214c896fe29Sbellard } 1215c896fe29Sbellard tcg_set_nop(s, gen_opc_buf + op_index, args, def->nb_args); 1216c896fe29Sbellard #ifdef CONFIG_PROFILER 1217a23a9ec6Sbellard s->del_op_count++; 1218c896fe29Sbellard #endif 1219c896fe29Sbellard } else { 1220c896fe29Sbellard do_not_remove: 1221c896fe29Sbellard 1222c896fe29Sbellard /* output args are dead */ 1223c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1224c896fe29Sbellard arg = args[i]; 1225c896fe29Sbellard dead_temps[arg] = 1; 1226c896fe29Sbellard } 1227c896fe29Sbellard 1228c896fe29Sbellard /* if end of basic block, update */ 1229c896fe29Sbellard if (def->flags & TCG_OPF_BB_END) { 1230c896fe29Sbellard tcg_la_bb_end(s, dead_temps); 1231b03cce8eSbellard } else if (def->flags & TCG_OPF_CALL_CLOBBER) { 1232b03cce8eSbellard /* globals are live */ 1233b03cce8eSbellard memset(dead_temps, 0, s->nb_globals); 1234c896fe29Sbellard } 1235c896fe29Sbellard 1236c896fe29Sbellard /* input args are live */ 1237c896fe29Sbellard dead_iargs = 0; 1238c896fe29Sbellard for(i = 0; i < nb_iargs; i++) { 1239c896fe29Sbellard arg = args[i + nb_oargs]; 1240c896fe29Sbellard if (dead_temps[arg]) { 1241c896fe29Sbellard dead_iargs |= (1 << i); 1242c896fe29Sbellard } 1243c896fe29Sbellard dead_temps[arg] = 0; 1244c896fe29Sbellard } 1245c896fe29Sbellard s->op_dead_iargs[op_index] = dead_iargs; 1246c896fe29Sbellard } 1247c896fe29Sbellard } else { 1248c896fe29Sbellard /* legacy dyngen operations */ 1249c896fe29Sbellard args -= def->nb_args; 1250c896fe29Sbellard /* mark end of basic block */ 1251c896fe29Sbellard tcg_la_bb_end(s, dead_temps); 1252c896fe29Sbellard } 1253c896fe29Sbellard break; 1254c896fe29Sbellard } 1255c896fe29Sbellard op_index--; 1256c896fe29Sbellard } 1257c896fe29Sbellard 1258c896fe29Sbellard if (args != gen_opparam_buf) 1259c896fe29Sbellard tcg_abort(); 1260c896fe29Sbellard } 1261c896fe29Sbellard #else 1262c896fe29Sbellard /* dummy liveness analysis */ 1263c896fe29Sbellard void tcg_liveness_analysis(TCGContext *s) 1264c896fe29Sbellard { 1265c896fe29Sbellard int nb_ops; 1266c896fe29Sbellard nb_ops = gen_opc_ptr - gen_opc_buf; 1267c896fe29Sbellard 1268c896fe29Sbellard s->op_dead_iargs = tcg_malloc(nb_ops * sizeof(uint16_t)); 1269c896fe29Sbellard memset(s->op_dead_iargs, 0, nb_ops * sizeof(uint16_t)); 1270c896fe29Sbellard } 1271c896fe29Sbellard #endif 1272c896fe29Sbellard 1273c896fe29Sbellard #ifndef NDEBUG 1274c896fe29Sbellard static void dump_regs(TCGContext *s) 1275c896fe29Sbellard { 1276c896fe29Sbellard TCGTemp *ts; 1277c896fe29Sbellard int i; 1278c896fe29Sbellard char buf[64]; 1279c896fe29Sbellard 1280c896fe29Sbellard for(i = 0; i < s->nb_temps; i++) { 1281c896fe29Sbellard ts = &s->temps[i]; 1282ac56dd48Spbrook printf(" %10s: ", tcg_get_arg_str_idx(s, buf, sizeof(buf), i)); 1283c896fe29Sbellard switch(ts->val_type) { 1284c896fe29Sbellard case TEMP_VAL_REG: 1285c896fe29Sbellard printf("%s", tcg_target_reg_names[ts->reg]); 1286c896fe29Sbellard break; 1287c896fe29Sbellard case TEMP_VAL_MEM: 1288c896fe29Sbellard printf("%d(%s)", (int)ts->mem_offset, tcg_target_reg_names[ts->mem_reg]); 1289c896fe29Sbellard break; 1290c896fe29Sbellard case TEMP_VAL_CONST: 1291c896fe29Sbellard printf("$0x%" TCG_PRIlx, ts->val); 1292c896fe29Sbellard break; 1293c896fe29Sbellard case TEMP_VAL_DEAD: 1294c896fe29Sbellard printf("D"); 1295c896fe29Sbellard break; 1296c896fe29Sbellard default: 1297c896fe29Sbellard printf("???"); 1298c896fe29Sbellard break; 1299c896fe29Sbellard } 1300c896fe29Sbellard printf("\n"); 1301c896fe29Sbellard } 1302c896fe29Sbellard 1303c896fe29Sbellard for(i = 0; i < TCG_TARGET_NB_REGS; i++) { 1304c896fe29Sbellard if (s->reg_to_temp[i] >= 0) { 1305c896fe29Sbellard printf("%s: %s\n", 1306c896fe29Sbellard tcg_target_reg_names[i], 1307ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), s->reg_to_temp[i])); 1308c896fe29Sbellard } 1309c896fe29Sbellard } 1310c896fe29Sbellard } 1311c896fe29Sbellard 1312c896fe29Sbellard static void check_regs(TCGContext *s) 1313c896fe29Sbellard { 1314c896fe29Sbellard int reg, k; 1315c896fe29Sbellard TCGTemp *ts; 1316c896fe29Sbellard char buf[64]; 1317c896fe29Sbellard 1318c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1319c896fe29Sbellard k = s->reg_to_temp[reg]; 1320c896fe29Sbellard if (k >= 0) { 1321c896fe29Sbellard ts = &s->temps[k]; 1322c896fe29Sbellard if (ts->val_type != TEMP_VAL_REG || 1323c896fe29Sbellard ts->reg != reg) { 1324c896fe29Sbellard printf("Inconsistency for register %s:\n", 1325c896fe29Sbellard tcg_target_reg_names[reg]); 1326b03cce8eSbellard goto fail; 1327c896fe29Sbellard } 1328c896fe29Sbellard } 1329c896fe29Sbellard } 1330c896fe29Sbellard for(k = 0; k < s->nb_temps; k++) { 1331c896fe29Sbellard ts = &s->temps[k]; 1332c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG && 1333c896fe29Sbellard !ts->fixed_reg && 1334c896fe29Sbellard s->reg_to_temp[ts->reg] != k) { 1335c896fe29Sbellard printf("Inconsistency for temp %s:\n", 1336ac56dd48Spbrook tcg_get_arg_str_idx(s, buf, sizeof(buf), k)); 1337b03cce8eSbellard fail: 1338c896fe29Sbellard printf("reg state:\n"); 1339c896fe29Sbellard dump_regs(s); 1340c896fe29Sbellard tcg_abort(); 1341c896fe29Sbellard } 1342c896fe29Sbellard } 1343c896fe29Sbellard } 1344c896fe29Sbellard #endif 1345c896fe29Sbellard 1346c896fe29Sbellard static void temp_allocate_frame(TCGContext *s, int temp) 1347c896fe29Sbellard { 1348c896fe29Sbellard TCGTemp *ts; 1349c896fe29Sbellard ts = &s->temps[temp]; 1350c896fe29Sbellard s->current_frame_offset = (s->current_frame_offset + sizeof(tcg_target_long) - 1) & ~(sizeof(tcg_target_long) - 1); 1351c896fe29Sbellard if (s->current_frame_offset + sizeof(tcg_target_long) > s->frame_end) 13525ff9d6a4Sbellard tcg_abort(); 1353c896fe29Sbellard ts->mem_offset = s->current_frame_offset; 1354c896fe29Sbellard ts->mem_reg = s->frame_reg; 1355c896fe29Sbellard ts->mem_allocated = 1; 1356c896fe29Sbellard s->current_frame_offset += sizeof(tcg_target_long); 1357c896fe29Sbellard } 1358c896fe29Sbellard 1359c896fe29Sbellard /* free register 'reg' by spilling the corresponding temporary if necessary */ 1360c896fe29Sbellard static void tcg_reg_free(TCGContext *s, int reg) 1361c896fe29Sbellard { 1362c896fe29Sbellard TCGTemp *ts; 1363c896fe29Sbellard int temp; 1364c896fe29Sbellard 1365c896fe29Sbellard temp = s->reg_to_temp[reg]; 1366c896fe29Sbellard if (temp != -1) { 1367c896fe29Sbellard ts = &s->temps[temp]; 1368c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 1369c896fe29Sbellard if (!ts->mem_coherent) { 1370c896fe29Sbellard if (!ts->mem_allocated) 1371c896fe29Sbellard temp_allocate_frame(s, temp); 1372e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1373c896fe29Sbellard } 1374c896fe29Sbellard ts->val_type = TEMP_VAL_MEM; 1375c896fe29Sbellard s->reg_to_temp[reg] = -1; 1376c896fe29Sbellard } 1377c896fe29Sbellard } 1378c896fe29Sbellard 1379c896fe29Sbellard /* Allocate a register belonging to reg1 & ~reg2 */ 1380c896fe29Sbellard static int tcg_reg_alloc(TCGContext *s, TCGRegSet reg1, TCGRegSet reg2) 1381c896fe29Sbellard { 1382c896fe29Sbellard int i, reg; 1383c896fe29Sbellard TCGRegSet reg_ct; 1384c896fe29Sbellard 1385c896fe29Sbellard tcg_regset_andnot(reg_ct, reg1, reg2); 1386c896fe29Sbellard 1387c896fe29Sbellard /* first try free registers */ 13880954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1389c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1390c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg) && s->reg_to_temp[reg] == -1) 1391c896fe29Sbellard return reg; 1392c896fe29Sbellard } 1393c896fe29Sbellard 1394c896fe29Sbellard /* XXX: do better spill choice */ 13950954d0d9Sblueswir1 for(i = 0; i < ARRAY_SIZE(tcg_target_reg_alloc_order); i++) { 1396c896fe29Sbellard reg = tcg_target_reg_alloc_order[i]; 1397c896fe29Sbellard if (tcg_regset_test_reg(reg_ct, reg)) { 1398c896fe29Sbellard tcg_reg_free(s, reg); 1399c896fe29Sbellard return reg; 1400c896fe29Sbellard } 1401c896fe29Sbellard } 1402c896fe29Sbellard 1403c896fe29Sbellard tcg_abort(); 1404c896fe29Sbellard } 1405c896fe29Sbellard 1406641d5fbeSbellard /* save a temporary to memory. 'allocated_regs' is used in case a 1407e8996ee0Sbellard temporary registers needs to be allocated to store a constant. */ 1408641d5fbeSbellard static void temp_save(TCGContext *s, int temp, TCGRegSet allocated_regs) 1409c896fe29Sbellard { 1410c896fe29Sbellard TCGTemp *ts; 1411641d5fbeSbellard int reg; 1412c896fe29Sbellard 1413641d5fbeSbellard ts = &s->temps[temp]; 1414c896fe29Sbellard if (!ts->fixed_reg) { 1415e8996ee0Sbellard switch(ts->val_type) { 1416e8996ee0Sbellard case TEMP_VAL_REG: 1417c896fe29Sbellard tcg_reg_free(s, ts->reg); 1418e8996ee0Sbellard break; 1419e8996ee0Sbellard case TEMP_VAL_DEAD: 1420e5097dc8Sbellard ts->val_type = TEMP_VAL_MEM; 1421e8996ee0Sbellard break; 1422e8996ee0Sbellard case TEMP_VAL_CONST: 1423e8996ee0Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 1424e8996ee0Sbellard allocated_regs); 1425641d5fbeSbellard if (!ts->mem_allocated) 1426641d5fbeSbellard temp_allocate_frame(s, temp); 1427e8996ee0Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1428e8996ee0Sbellard tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1429e8996ee0Sbellard ts->val_type = TEMP_VAL_MEM; 1430e8996ee0Sbellard break; 1431e8996ee0Sbellard case TEMP_VAL_MEM: 1432e8996ee0Sbellard break; 1433e8996ee0Sbellard default: 1434e8996ee0Sbellard tcg_abort(); 1435c896fe29Sbellard } 1436c896fe29Sbellard } 1437c896fe29Sbellard } 1438641d5fbeSbellard 1439641d5fbeSbellard /* save globals to their cannonical location and assume they can be 1440641d5fbeSbellard modified be the following code. 'allocated_regs' is used in case a 1441641d5fbeSbellard temporary registers needs to be allocated to store a constant. */ 1442641d5fbeSbellard static void save_globals(TCGContext *s, TCGRegSet allocated_regs) 1443641d5fbeSbellard { 1444641d5fbeSbellard int i; 1445641d5fbeSbellard 1446641d5fbeSbellard for(i = 0; i < s->nb_globals; i++) { 1447641d5fbeSbellard temp_save(s, i, allocated_regs); 1448641d5fbeSbellard } 1449e5097dc8Sbellard } 1450e5097dc8Sbellard 1451e5097dc8Sbellard /* at the end of a basic block, we assume all temporaries are dead and 1452e8996ee0Sbellard all globals are stored at their canonical location. */ 1453e8996ee0Sbellard static void tcg_reg_alloc_bb_end(TCGContext *s, TCGRegSet allocated_regs) 1454e5097dc8Sbellard { 1455e5097dc8Sbellard TCGTemp *ts; 1456e5097dc8Sbellard int i; 1457e5097dc8Sbellard 1458c896fe29Sbellard for(i = s->nb_globals; i < s->nb_temps; i++) { 1459c896fe29Sbellard ts = &s->temps[i]; 1460641d5fbeSbellard if (ts->temp_local) { 1461641d5fbeSbellard temp_save(s, i, allocated_regs); 1462641d5fbeSbellard } else { 1463c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 1464c896fe29Sbellard s->reg_to_temp[ts->reg] = -1; 1465c896fe29Sbellard } 1466c896fe29Sbellard ts->val_type = TEMP_VAL_DEAD; 1467c896fe29Sbellard } 1468641d5fbeSbellard } 1469e8996ee0Sbellard 1470e8996ee0Sbellard save_globals(s, allocated_regs); 1471c896fe29Sbellard } 1472c896fe29Sbellard 1473c896fe29Sbellard #define IS_DEAD_IARG(n) ((dead_iargs >> (n)) & 1) 1474c896fe29Sbellard 1475e8996ee0Sbellard static void tcg_reg_alloc_movi(TCGContext *s, const TCGArg *args) 1476e8996ee0Sbellard { 1477e8996ee0Sbellard TCGTemp *ots; 1478e8996ee0Sbellard tcg_target_ulong val; 1479e8996ee0Sbellard 1480e8996ee0Sbellard ots = &s->temps[args[0]]; 1481e8996ee0Sbellard val = args[1]; 1482e8996ee0Sbellard 1483e8996ee0Sbellard if (ots->fixed_reg) { 1484e8996ee0Sbellard /* for fixed registers, we do not do any constant 1485e8996ee0Sbellard propagation */ 1486e8996ee0Sbellard tcg_out_movi(s, ots->type, ots->reg, val); 1487e8996ee0Sbellard } else { 14881235fc06Sths /* The movi is not explicitly generated here */ 1489e8996ee0Sbellard if (ots->val_type == TEMP_VAL_REG) 1490e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 1491e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 1492e8996ee0Sbellard ots->val = val; 1493e8996ee0Sbellard } 1494e8996ee0Sbellard } 1495e8996ee0Sbellard 1496c896fe29Sbellard static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def, 1497c896fe29Sbellard const TCGArg *args, 1498c896fe29Sbellard unsigned int dead_iargs) 1499c896fe29Sbellard { 1500c896fe29Sbellard TCGTemp *ts, *ots; 1501c896fe29Sbellard int reg; 1502c896fe29Sbellard const TCGArgConstraint *arg_ct; 1503c896fe29Sbellard 1504c896fe29Sbellard ots = &s->temps[args[0]]; 1505c896fe29Sbellard ts = &s->temps[args[1]]; 1506c896fe29Sbellard arg_ct = &def->args_ct[0]; 1507c896fe29Sbellard 1508e8996ee0Sbellard /* XXX: always mark arg dead if IS_DEAD_IARG(0) */ 1509c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 1510c896fe29Sbellard if (IS_DEAD_IARG(0) && !ts->fixed_reg && !ots->fixed_reg) { 1511c896fe29Sbellard /* the mov can be suppressed */ 1512c896fe29Sbellard if (ots->val_type == TEMP_VAL_REG) 1513c896fe29Sbellard s->reg_to_temp[ots->reg] = -1; 1514c896fe29Sbellard reg = ts->reg; 1515c896fe29Sbellard s->reg_to_temp[reg] = -1; 1516c896fe29Sbellard ts->val_type = TEMP_VAL_DEAD; 1517c896fe29Sbellard } else { 1518c896fe29Sbellard if (ots->val_type == TEMP_VAL_REG) { 1519c896fe29Sbellard reg = ots->reg; 1520c896fe29Sbellard } else { 1521c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, s->reserved_regs); 1522c896fe29Sbellard } 1523c896fe29Sbellard if (ts->reg != reg) { 1524c896fe29Sbellard tcg_out_mov(s, reg, ts->reg); 1525c896fe29Sbellard } 1526c896fe29Sbellard } 1527c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 1528c896fe29Sbellard if (ots->val_type == TEMP_VAL_REG) { 1529c896fe29Sbellard reg = ots->reg; 1530c896fe29Sbellard } else { 1531c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, s->reserved_regs); 1532c896fe29Sbellard } 1533e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1534c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1535e8996ee0Sbellard if (ots->fixed_reg) { 1536c896fe29Sbellard reg = ots->reg; 1537c896fe29Sbellard tcg_out_movi(s, ots->type, reg, ts->val); 1538c896fe29Sbellard } else { 1539e8996ee0Sbellard /* propagate constant */ 1540e8996ee0Sbellard if (ots->val_type == TEMP_VAL_REG) 1541e8996ee0Sbellard s->reg_to_temp[ots->reg] = -1; 1542e8996ee0Sbellard ots->val_type = TEMP_VAL_CONST; 1543e8996ee0Sbellard ots->val = ts->val; 1544e8996ee0Sbellard return; 1545e8996ee0Sbellard } 1546e8996ee0Sbellard } else { 1547c896fe29Sbellard tcg_abort(); 1548c896fe29Sbellard } 1549c896fe29Sbellard s->reg_to_temp[reg] = args[0]; 1550c896fe29Sbellard ots->reg = reg; 1551c896fe29Sbellard ots->val_type = TEMP_VAL_REG; 1552c896fe29Sbellard ots->mem_coherent = 0; 1553c896fe29Sbellard } 1554c896fe29Sbellard 1555c896fe29Sbellard static void tcg_reg_alloc_op(TCGContext *s, 1556c896fe29Sbellard const TCGOpDef *def, int opc, 1557c896fe29Sbellard const TCGArg *args, 1558c896fe29Sbellard unsigned int dead_iargs) 1559c896fe29Sbellard { 1560c896fe29Sbellard TCGRegSet allocated_regs; 1561c896fe29Sbellard int i, k, nb_iargs, nb_oargs, reg; 1562c896fe29Sbellard TCGArg arg; 1563c896fe29Sbellard const TCGArgConstraint *arg_ct; 1564c896fe29Sbellard TCGTemp *ts; 1565c896fe29Sbellard TCGArg new_args[TCG_MAX_OP_ARGS]; 1566c896fe29Sbellard int const_args[TCG_MAX_OP_ARGS]; 1567c896fe29Sbellard 1568c896fe29Sbellard nb_oargs = def->nb_oargs; 1569c896fe29Sbellard nb_iargs = def->nb_iargs; 1570c896fe29Sbellard 1571c896fe29Sbellard /* copy constants */ 1572c896fe29Sbellard memcpy(new_args + nb_oargs + nb_iargs, 1573c896fe29Sbellard args + nb_oargs + nb_iargs, 1574c896fe29Sbellard sizeof(TCGArg) * def->nb_cargs); 1575c896fe29Sbellard 1576c896fe29Sbellard /* satisfy input constraints */ 1577c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 1578c896fe29Sbellard for(k = 0; k < nb_iargs; k++) { 1579c896fe29Sbellard i = def->sorted_args[nb_oargs + k]; 1580c896fe29Sbellard arg = args[i]; 1581c896fe29Sbellard arg_ct = &def->args_ct[i]; 1582c896fe29Sbellard ts = &s->temps[arg]; 1583c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 1584c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1585e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1586c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 1587c896fe29Sbellard ts->reg = reg; 1588c896fe29Sbellard ts->mem_coherent = 1; 1589c896fe29Sbellard s->reg_to_temp[reg] = arg; 1590c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1591c896fe29Sbellard if (tcg_target_const_match(ts->val, arg_ct)) { 1592c896fe29Sbellard /* constant is OK for instruction */ 1593c896fe29Sbellard const_args[i] = 1; 1594c896fe29Sbellard new_args[i] = ts->val; 1595c896fe29Sbellard goto iarg_end; 1596c896fe29Sbellard } else { 1597c896fe29Sbellard /* need to move to a register */ 1598c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1599c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1600e8996ee0Sbellard ts->val_type = TEMP_VAL_REG; 1601e8996ee0Sbellard ts->reg = reg; 1602e8996ee0Sbellard ts->mem_coherent = 0; 1603e8996ee0Sbellard s->reg_to_temp[reg] = arg; 1604c896fe29Sbellard } 1605c896fe29Sbellard } 1606c896fe29Sbellard assert(ts->val_type == TEMP_VAL_REG); 16075ff9d6a4Sbellard if (arg_ct->ct & TCG_CT_IALIAS) { 16085ff9d6a4Sbellard if (ts->fixed_reg) { 16095ff9d6a4Sbellard /* if fixed register, we must allocate a new register 16105ff9d6a4Sbellard if the alias is not the same register */ 16115ff9d6a4Sbellard if (arg != args[arg_ct->alias_index]) 16125ff9d6a4Sbellard goto allocate_in_reg; 16135ff9d6a4Sbellard } else { 1614c896fe29Sbellard /* if the input is aliased to an output and if it is 1615c896fe29Sbellard not dead after the instruction, we must allocate 1616c896fe29Sbellard a new register and move it */ 16175ff9d6a4Sbellard if (!IS_DEAD_IARG(i - nb_oargs)) 1618c896fe29Sbellard goto allocate_in_reg; 1619c896fe29Sbellard } 16205ff9d6a4Sbellard } 1621c896fe29Sbellard reg = ts->reg; 1622c896fe29Sbellard if (tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1623c896fe29Sbellard /* nothing to do : the constraint is satisfied */ 1624c896fe29Sbellard } else { 1625c896fe29Sbellard allocate_in_reg: 1626c896fe29Sbellard /* allocate a new register matching the constraint 1627c896fe29Sbellard and move the temporary register into it */ 1628c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1629c896fe29Sbellard tcg_out_mov(s, reg, ts->reg); 1630c896fe29Sbellard } 1631c896fe29Sbellard new_args[i] = reg; 1632c896fe29Sbellard const_args[i] = 0; 1633c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 1634c896fe29Sbellard iarg_end: ; 1635c896fe29Sbellard } 1636c896fe29Sbellard 1637e8996ee0Sbellard if (def->flags & TCG_OPF_BB_END) { 1638e8996ee0Sbellard tcg_reg_alloc_bb_end(s, allocated_regs); 1639e8996ee0Sbellard } else { 1640c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 1641c896fe29Sbellard for(i = 0; i < nb_iargs; i++) { 1642c896fe29Sbellard arg = args[nb_oargs + i]; 1643c896fe29Sbellard if (IS_DEAD_IARG(i)) { 1644c896fe29Sbellard ts = &s->temps[arg]; 1645e8996ee0Sbellard if (!ts->fixed_reg) { 1646c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) 1647c896fe29Sbellard s->reg_to_temp[ts->reg] = -1; 1648c896fe29Sbellard ts->val_type = TEMP_VAL_DEAD; 1649c896fe29Sbellard } 1650c896fe29Sbellard } 1651c896fe29Sbellard } 1652c896fe29Sbellard 1653c896fe29Sbellard if (def->flags & TCG_OPF_CALL_CLOBBER) { 1654b03cce8eSbellard /* XXX: permit generic clobber register list ? */ 1655c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1656c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 1657c896fe29Sbellard tcg_reg_free(s, reg); 1658c896fe29Sbellard } 1659c896fe29Sbellard } 1660b03cce8eSbellard /* XXX: for load/store we could do that only for the slow path 1661b03cce8eSbellard (i.e. when a memory callback is called) */ 1662b03cce8eSbellard 1663b03cce8eSbellard /* store globals and free associated registers (we assume the insn 1664b03cce8eSbellard can modify any global. */ 1665e8996ee0Sbellard save_globals(s, allocated_regs); 1666c896fe29Sbellard } 1667c896fe29Sbellard 1668c896fe29Sbellard /* satisfy the output constraints */ 1669c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 1670c896fe29Sbellard for(k = 0; k < nb_oargs; k++) { 1671c896fe29Sbellard i = def->sorted_args[k]; 1672c896fe29Sbellard arg = args[i]; 1673c896fe29Sbellard arg_ct = &def->args_ct[i]; 1674c896fe29Sbellard ts = &s->temps[arg]; 1675c896fe29Sbellard if (arg_ct->ct & TCG_CT_ALIAS) { 16765ff9d6a4Sbellard reg = new_args[arg_ct->alias_index]; 1677c896fe29Sbellard } else { 1678c896fe29Sbellard /* if fixed register, we try to use it */ 1679c896fe29Sbellard reg = ts->reg; 1680c896fe29Sbellard if (ts->fixed_reg && 1681c896fe29Sbellard tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1682c896fe29Sbellard goto oarg_end; 1683c896fe29Sbellard } 1684c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1685c896fe29Sbellard } 1686c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 1687c896fe29Sbellard /* if a fixed register is used, then a move will be done afterwards */ 1688c896fe29Sbellard if (!ts->fixed_reg) { 1689c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) 1690c896fe29Sbellard s->reg_to_temp[ts->reg] = -1; 1691c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 1692c896fe29Sbellard ts->reg = reg; 1693c896fe29Sbellard /* temp value is modified, so the value kept in memory is 1694c896fe29Sbellard potentially not the same */ 1695c896fe29Sbellard ts->mem_coherent = 0; 1696c896fe29Sbellard s->reg_to_temp[reg] = arg; 1697c896fe29Sbellard } 1698c896fe29Sbellard oarg_end: 1699c896fe29Sbellard new_args[i] = reg; 1700c896fe29Sbellard } 1701e8996ee0Sbellard } 1702c896fe29Sbellard 1703c896fe29Sbellard /* emit instruction */ 1704c896fe29Sbellard tcg_out_op(s, opc, new_args, const_args); 1705c896fe29Sbellard 1706c896fe29Sbellard /* move the outputs in the correct register if needed */ 1707c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1708c896fe29Sbellard ts = &s->temps[args[i]]; 1709c896fe29Sbellard reg = new_args[i]; 1710c896fe29Sbellard if (ts->fixed_reg && ts->reg != reg) { 1711c896fe29Sbellard tcg_out_mov(s, ts->reg, reg); 1712c896fe29Sbellard } 1713c896fe29Sbellard } 1714c896fe29Sbellard } 1715c896fe29Sbellard 1716b03cce8eSbellard #ifdef TCG_TARGET_STACK_GROWSUP 1717b03cce8eSbellard #define STACK_DIR(x) (-(x)) 1718b03cce8eSbellard #else 1719b03cce8eSbellard #define STACK_DIR(x) (x) 1720b03cce8eSbellard #endif 1721b03cce8eSbellard 1722c896fe29Sbellard static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def, 1723c896fe29Sbellard int opc, const TCGArg *args, 1724c896fe29Sbellard unsigned int dead_iargs) 1725c896fe29Sbellard { 1726c896fe29Sbellard int nb_iargs, nb_oargs, flags, nb_regs, i, reg, nb_params; 1727c896fe29Sbellard TCGArg arg, func_arg; 1728c896fe29Sbellard TCGTemp *ts; 1729f54b3f92Saurel32 tcg_target_long stack_offset, call_stack_size, func_addr; 1730b03cce8eSbellard int const_func_arg, allocate_args; 1731c896fe29Sbellard TCGRegSet allocated_regs; 1732c896fe29Sbellard const TCGArgConstraint *arg_ct; 1733c896fe29Sbellard 1734c896fe29Sbellard arg = *args++; 1735c896fe29Sbellard 1736c896fe29Sbellard nb_oargs = arg >> 16; 1737c896fe29Sbellard nb_iargs = arg & 0xffff; 1738c896fe29Sbellard nb_params = nb_iargs - 1; 1739c896fe29Sbellard 1740c896fe29Sbellard flags = args[nb_oargs + nb_iargs]; 1741c896fe29Sbellard 1742c896fe29Sbellard nb_regs = tcg_target_get_call_iarg_regs_count(flags); 1743c896fe29Sbellard if (nb_regs > nb_params) 1744c896fe29Sbellard nb_regs = nb_params; 1745c896fe29Sbellard 1746c896fe29Sbellard /* assign stack slots first */ 1747c896fe29Sbellard /* XXX: preallocate call stack */ 1748c896fe29Sbellard call_stack_size = (nb_params - nb_regs) * sizeof(tcg_target_long); 1749c896fe29Sbellard call_stack_size = (call_stack_size + TCG_TARGET_STACK_ALIGN - 1) & 1750c896fe29Sbellard ~(TCG_TARGET_STACK_ALIGN - 1); 1751b03cce8eSbellard allocate_args = (call_stack_size > TCG_STATIC_CALL_ARGS_SIZE); 1752b03cce8eSbellard if (allocate_args) { 1753b03cce8eSbellard tcg_out_addi(s, TCG_REG_CALL_STACK, -STACK_DIR(call_stack_size)); 1754b03cce8eSbellard } 175539cf05d3Sbellard 175639cf05d3Sbellard stack_offset = TCG_TARGET_CALL_STACK_OFFSET; 1757c896fe29Sbellard for(i = nb_regs; i < nb_params; i++) { 1758c896fe29Sbellard arg = args[nb_oargs + i]; 175939cf05d3Sbellard #ifdef TCG_TARGET_STACK_GROWSUP 176039cf05d3Sbellard stack_offset -= sizeof(tcg_target_long); 176139cf05d3Sbellard #endif 176239cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 1763c896fe29Sbellard ts = &s->temps[arg]; 1764c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 1765e4d5434cSblueswir1 tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset); 1766c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 1767c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 1768c896fe29Sbellard s->reserved_regs); 1769c896fe29Sbellard /* XXX: not correct if reading values from the stack */ 1770e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1771e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 1772c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1773c896fe29Sbellard reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 1774c896fe29Sbellard s->reserved_regs); 1775c896fe29Sbellard /* XXX: sign extend may be needed on some targets */ 1776c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1777e4d5434cSblueswir1 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset); 1778c896fe29Sbellard } else { 1779c896fe29Sbellard tcg_abort(); 1780c896fe29Sbellard } 178139cf05d3Sbellard } 178239cf05d3Sbellard #ifndef TCG_TARGET_STACK_GROWSUP 178339cf05d3Sbellard stack_offset += sizeof(tcg_target_long); 178439cf05d3Sbellard #endif 1785c896fe29Sbellard } 1786c896fe29Sbellard 1787c896fe29Sbellard /* assign input registers */ 1788c896fe29Sbellard tcg_regset_set(allocated_regs, s->reserved_regs); 1789c896fe29Sbellard for(i = 0; i < nb_regs; i++) { 1790c896fe29Sbellard arg = args[nb_oargs + i]; 179139cf05d3Sbellard if (arg != TCG_CALL_DUMMY_ARG) { 1792c896fe29Sbellard ts = &s->temps[arg]; 1793c896fe29Sbellard reg = tcg_target_call_iarg_regs[i]; 1794c896fe29Sbellard tcg_reg_free(s, reg); 1795c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) { 1796c896fe29Sbellard if (ts->reg != reg) { 1797c896fe29Sbellard tcg_out_mov(s, reg, ts->reg); 1798c896fe29Sbellard } 1799c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_MEM) { 1800e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1801c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1802c896fe29Sbellard /* XXX: sign extend ? */ 1803c896fe29Sbellard tcg_out_movi(s, ts->type, reg, ts->val); 1804c896fe29Sbellard } else { 1805c896fe29Sbellard tcg_abort(); 1806c896fe29Sbellard } 1807c896fe29Sbellard tcg_regset_set_reg(allocated_regs, reg); 1808c896fe29Sbellard } 180939cf05d3Sbellard } 1810c896fe29Sbellard 1811c896fe29Sbellard /* assign function address */ 1812c896fe29Sbellard func_arg = args[nb_oargs + nb_iargs - 1]; 1813c896fe29Sbellard arg_ct = &def->args_ct[0]; 1814c896fe29Sbellard ts = &s->temps[func_arg]; 1815f54b3f92Saurel32 func_addr = ts->val; 1816c896fe29Sbellard const_func_arg = 0; 1817c896fe29Sbellard if (ts->val_type == TEMP_VAL_MEM) { 1818c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1819e4d5434cSblueswir1 tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset); 1820c896fe29Sbellard func_arg = reg; 1821e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 1822c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_REG) { 1823c896fe29Sbellard reg = ts->reg; 1824c896fe29Sbellard if (!tcg_regset_test_reg(arg_ct->u.regs, reg)) { 1825c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1826c896fe29Sbellard tcg_out_mov(s, reg, ts->reg); 1827c896fe29Sbellard } 1828c896fe29Sbellard func_arg = reg; 1829e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 1830c896fe29Sbellard } else if (ts->val_type == TEMP_VAL_CONST) { 1831f54b3f92Saurel32 if (tcg_target_const_match(func_addr, arg_ct)) { 1832c896fe29Sbellard const_func_arg = 1; 1833f54b3f92Saurel32 func_arg = func_addr; 1834c896fe29Sbellard } else { 1835c896fe29Sbellard reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs); 1836f54b3f92Saurel32 tcg_out_movi(s, ts->type, reg, func_addr); 1837c896fe29Sbellard func_arg = reg; 1838e8996ee0Sbellard tcg_regset_set_reg(allocated_regs, reg); 1839c896fe29Sbellard } 1840c896fe29Sbellard } else { 1841c896fe29Sbellard tcg_abort(); 1842c896fe29Sbellard } 1843c896fe29Sbellard 1844e8996ee0Sbellard 1845c896fe29Sbellard /* mark dead temporaries and free the associated registers */ 1846c6e113f5Sbellard for(i = 0; i < nb_iargs; i++) { 1847c896fe29Sbellard arg = args[nb_oargs + i]; 1848c896fe29Sbellard if (IS_DEAD_IARG(i)) { 1849c896fe29Sbellard ts = &s->temps[arg]; 1850e8996ee0Sbellard if (!ts->fixed_reg) { 1851c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) 1852c896fe29Sbellard s->reg_to_temp[ts->reg] = -1; 1853c896fe29Sbellard ts->val_type = TEMP_VAL_DEAD; 1854c896fe29Sbellard } 1855c896fe29Sbellard } 1856c896fe29Sbellard } 1857c896fe29Sbellard 1858c896fe29Sbellard /* clobber call registers */ 1859c896fe29Sbellard for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) { 1860c896fe29Sbellard if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) { 1861c896fe29Sbellard tcg_reg_free(s, reg); 1862c896fe29Sbellard } 1863c896fe29Sbellard } 1864c896fe29Sbellard 1865c896fe29Sbellard /* store globals and free associated registers (we assume the call 1866c896fe29Sbellard can modify any global. */ 1867e8996ee0Sbellard save_globals(s, allocated_regs); 1868c896fe29Sbellard 1869c896fe29Sbellard tcg_out_op(s, opc, &func_arg, &const_func_arg); 1870c896fe29Sbellard 1871b03cce8eSbellard if (allocate_args) { 1872b03cce8eSbellard tcg_out_addi(s, TCG_REG_CALL_STACK, STACK_DIR(call_stack_size)); 1873b03cce8eSbellard } 1874c896fe29Sbellard 1875c896fe29Sbellard /* assign output registers and emit moves if needed */ 1876c896fe29Sbellard for(i = 0; i < nb_oargs; i++) { 1877c896fe29Sbellard arg = args[i]; 1878c896fe29Sbellard ts = &s->temps[arg]; 1879c896fe29Sbellard reg = tcg_target_call_oarg_regs[i]; 1880e8996ee0Sbellard assert(s->reg_to_temp[reg] == -1); 1881c896fe29Sbellard if (ts->fixed_reg) { 1882c896fe29Sbellard if (ts->reg != reg) { 1883c896fe29Sbellard tcg_out_mov(s, ts->reg, reg); 1884c896fe29Sbellard } 1885c896fe29Sbellard } else { 1886c896fe29Sbellard if (ts->val_type == TEMP_VAL_REG) 1887c896fe29Sbellard s->reg_to_temp[ts->reg] = -1; 1888c896fe29Sbellard ts->val_type = TEMP_VAL_REG; 1889c896fe29Sbellard ts->reg = reg; 1890c896fe29Sbellard ts->mem_coherent = 0; 1891c896fe29Sbellard s->reg_to_temp[reg] = arg; 1892c896fe29Sbellard } 1893c896fe29Sbellard } 1894c896fe29Sbellard 1895c896fe29Sbellard return nb_iargs + nb_oargs + def->nb_cargs + 1; 1896c896fe29Sbellard } 1897c896fe29Sbellard 1898c896fe29Sbellard #ifdef CONFIG_PROFILER 1899c896fe29Sbellard 1900c896fe29Sbellard static int64_t dyngen_table_op_count[NB_OPS]; 1901c896fe29Sbellard 1902c896fe29Sbellard void dump_op_count(void) 1903c896fe29Sbellard { 1904c896fe29Sbellard int i; 1905c896fe29Sbellard FILE *f; 1906c896fe29Sbellard f = fopen("/tmp/op1.log", "w"); 1907c896fe29Sbellard for(i = 0; i < INDEX_op_end; i++) { 1908c896fe29Sbellard fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, dyngen_table_op_count[i]); 1909c896fe29Sbellard } 1910c896fe29Sbellard fclose(f); 1911c896fe29Sbellard f = fopen("/tmp/op2.log", "w"); 1912c896fe29Sbellard for(i = INDEX_op_end; i < NB_OPS; i++) { 1913c896fe29Sbellard fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, dyngen_table_op_count[i]); 1914c896fe29Sbellard } 1915c896fe29Sbellard fclose(f); 1916c896fe29Sbellard } 1917c896fe29Sbellard #endif 1918c896fe29Sbellard 1919c896fe29Sbellard 1920c896fe29Sbellard static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf, 19212ba1eeb6Spbrook long search_pc) 1922c896fe29Sbellard { 1923b314f270Sbellard int opc, op_index; 1924c896fe29Sbellard const TCGOpDef *def; 1925c896fe29Sbellard unsigned int dead_iargs; 1926c896fe29Sbellard const TCGArg *args; 1927c896fe29Sbellard 1928c896fe29Sbellard #ifdef DEBUG_DISAS 1929c896fe29Sbellard if (unlikely(loglevel & CPU_LOG_TB_OP)) { 1930c896fe29Sbellard fprintf(logfile, "OP:\n"); 1931c896fe29Sbellard tcg_dump_ops(s, logfile); 1932c896fe29Sbellard fprintf(logfile, "\n"); 1933c896fe29Sbellard } 1934c896fe29Sbellard #endif 1935c896fe29Sbellard 1936a23a9ec6Sbellard #ifdef CONFIG_PROFILER 1937a23a9ec6Sbellard s->la_time -= profile_getclock(); 1938a23a9ec6Sbellard #endif 1939c896fe29Sbellard tcg_liveness_analysis(s); 1940a23a9ec6Sbellard #ifdef CONFIG_PROFILER 1941a23a9ec6Sbellard s->la_time += profile_getclock(); 1942a23a9ec6Sbellard #endif 1943c896fe29Sbellard 1944c896fe29Sbellard #ifdef DEBUG_DISAS 1945c896fe29Sbellard if (unlikely(loglevel & CPU_LOG_TB_OP_OPT)) { 1946c896fe29Sbellard fprintf(logfile, "OP after la:\n"); 1947c896fe29Sbellard tcg_dump_ops(s, logfile); 1948c896fe29Sbellard fprintf(logfile, "\n"); 1949c896fe29Sbellard } 1950c896fe29Sbellard #endif 1951c896fe29Sbellard 1952c896fe29Sbellard tcg_reg_alloc_start(s); 1953c896fe29Sbellard 1954c896fe29Sbellard s->code_buf = gen_code_buf; 1955c896fe29Sbellard s->code_ptr = gen_code_buf; 1956c896fe29Sbellard 1957c896fe29Sbellard args = gen_opparam_buf; 1958c896fe29Sbellard op_index = 0; 1959b3db8758Sblueswir1 1960c896fe29Sbellard for(;;) { 1961c896fe29Sbellard opc = gen_opc_buf[op_index]; 1962c896fe29Sbellard #ifdef CONFIG_PROFILER 1963c896fe29Sbellard dyngen_table_op_count[opc]++; 1964c896fe29Sbellard #endif 1965c896fe29Sbellard def = &tcg_op_defs[opc]; 1966c896fe29Sbellard #if 0 1967c896fe29Sbellard printf("%s: %d %d %d\n", def->name, 1968c896fe29Sbellard def->nb_oargs, def->nb_iargs, def->nb_cargs); 1969c896fe29Sbellard // dump_regs(s); 1970c896fe29Sbellard #endif 1971c896fe29Sbellard switch(opc) { 1972c896fe29Sbellard case INDEX_op_mov_i32: 1973c896fe29Sbellard #if TCG_TARGET_REG_BITS == 64 1974c896fe29Sbellard case INDEX_op_mov_i64: 1975c896fe29Sbellard #endif 1976c896fe29Sbellard dead_iargs = s->op_dead_iargs[op_index]; 1977c896fe29Sbellard tcg_reg_alloc_mov(s, def, args, dead_iargs); 1978c896fe29Sbellard break; 1979e8996ee0Sbellard case INDEX_op_movi_i32: 1980e8996ee0Sbellard #if TCG_TARGET_REG_BITS == 64 1981e8996ee0Sbellard case INDEX_op_movi_i64: 1982e8996ee0Sbellard #endif 1983e8996ee0Sbellard tcg_reg_alloc_movi(s, args); 1984e8996ee0Sbellard break; 19857e4597d7Sbellard case INDEX_op_debug_insn_start: 19867e4597d7Sbellard /* debug instruction */ 19877e4597d7Sbellard break; 1988c896fe29Sbellard case INDEX_op_nop: 1989c896fe29Sbellard case INDEX_op_nop1: 1990c896fe29Sbellard case INDEX_op_nop2: 1991c896fe29Sbellard case INDEX_op_nop3: 1992c896fe29Sbellard break; 1993c896fe29Sbellard case INDEX_op_nopn: 1994c896fe29Sbellard args += args[0]; 1995c896fe29Sbellard goto next; 19965ff9d6a4Sbellard case INDEX_op_discard: 19975ff9d6a4Sbellard { 19985ff9d6a4Sbellard TCGTemp *ts; 19995ff9d6a4Sbellard ts = &s->temps[args[0]]; 20005ff9d6a4Sbellard /* mark the temporary as dead */ 2001e8996ee0Sbellard if (!ts->fixed_reg) { 20025ff9d6a4Sbellard if (ts->val_type == TEMP_VAL_REG) 20035ff9d6a4Sbellard s->reg_to_temp[ts->reg] = -1; 20045ff9d6a4Sbellard ts->val_type = TEMP_VAL_DEAD; 20055ff9d6a4Sbellard } 20065ff9d6a4Sbellard } 20075ff9d6a4Sbellard break; 2008c896fe29Sbellard case INDEX_op_set_label: 2009e8996ee0Sbellard tcg_reg_alloc_bb_end(s, s->reserved_regs); 2010c896fe29Sbellard tcg_out_label(s, args[0], (long)s->code_ptr); 2011c896fe29Sbellard break; 2012c896fe29Sbellard case INDEX_op_call: 2013c896fe29Sbellard dead_iargs = s->op_dead_iargs[op_index]; 2014c896fe29Sbellard args += tcg_reg_alloc_call(s, def, opc, args, dead_iargs); 2015c896fe29Sbellard goto next; 2016c896fe29Sbellard case INDEX_op_end: 2017c896fe29Sbellard goto the_end; 2018cf2be984Sblueswir1 2019bf6247fbSblueswir1 #ifdef CONFIG_DYNGEN_OP 2020c896fe29Sbellard case 0 ... INDEX_op_end - 1: 2021c896fe29Sbellard /* legacy dyngen ops */ 2022c896fe29Sbellard #ifdef CONFIG_PROFILER 2023a23a9ec6Sbellard s->old_op_count++; 2024c896fe29Sbellard #endif 2025e8996ee0Sbellard tcg_reg_alloc_bb_end(s, s->reserved_regs); 20262ba1eeb6Spbrook if (search_pc >= 0) { 2027c896fe29Sbellard s->code_ptr += def->copy_size; 2028c896fe29Sbellard args += def->nb_args; 2029c896fe29Sbellard } else { 2030c896fe29Sbellard args = dyngen_op(s, opc, args); 2031c896fe29Sbellard } 2032c896fe29Sbellard goto next; 2033cf2be984Sblueswir1 #endif 2034c896fe29Sbellard default: 2035c896fe29Sbellard /* Note: in order to speed up the code, it would be much 2036c896fe29Sbellard faster to have specialized register allocator functions for 2037c896fe29Sbellard some common argument patterns */ 2038c896fe29Sbellard dead_iargs = s->op_dead_iargs[op_index]; 2039c896fe29Sbellard tcg_reg_alloc_op(s, def, opc, args, dead_iargs); 2040c896fe29Sbellard break; 2041c896fe29Sbellard } 2042c896fe29Sbellard args += def->nb_args; 20438df1ca4bSths next: 20442ba1eeb6Spbrook if (search_pc >= 0 && search_pc < s->code_ptr - gen_code_buf) { 2045c896fe29Sbellard return op_index; 2046c896fe29Sbellard } 2047c896fe29Sbellard op_index++; 2048c896fe29Sbellard #ifndef NDEBUG 2049c896fe29Sbellard check_regs(s); 2050c896fe29Sbellard #endif 2051c896fe29Sbellard } 2052c896fe29Sbellard the_end: 2053c896fe29Sbellard return -1; 2054c896fe29Sbellard } 2055c896fe29Sbellard 2056c896fe29Sbellard int dyngen_code(TCGContext *s, uint8_t *gen_code_buf) 2057c896fe29Sbellard { 2058c896fe29Sbellard #ifdef CONFIG_PROFILER 2059c896fe29Sbellard { 2060c896fe29Sbellard int n; 2061c896fe29Sbellard n = (gen_opc_ptr - gen_opc_buf); 2062a23a9ec6Sbellard s->op_count += n; 2063a23a9ec6Sbellard if (n > s->op_count_max) 2064a23a9ec6Sbellard s->op_count_max = n; 2065a23a9ec6Sbellard 2066a23a9ec6Sbellard s->temp_count += s->nb_temps; 2067a23a9ec6Sbellard if (s->nb_temps > s->temp_count_max) 2068a23a9ec6Sbellard s->temp_count_max = s->nb_temps; 2069c896fe29Sbellard } 2070c896fe29Sbellard #endif 2071c896fe29Sbellard 20722ba1eeb6Spbrook tcg_gen_code_common(s, gen_code_buf, -1); 2073c896fe29Sbellard 2074c896fe29Sbellard /* flush instruction cache */ 2075c896fe29Sbellard flush_icache_range((unsigned long)gen_code_buf, 2076c896fe29Sbellard (unsigned long)s->code_ptr); 2077c896fe29Sbellard return s->code_ptr - gen_code_buf; 2078c896fe29Sbellard } 2079c896fe29Sbellard 20802ba1eeb6Spbrook /* Return the index of the micro operation such as the pc after is < 2081623e265cSpbrook offset bytes from the start of the TB. The contents of gen_code_buf must 2082623e265cSpbrook not be changed, though writing the same values is ok. 2083623e265cSpbrook Return -1 if not found. */ 2084623e265cSpbrook int dyngen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset) 2085c896fe29Sbellard { 2086623e265cSpbrook return tcg_gen_code_common(s, gen_code_buf, offset); 2087c896fe29Sbellard } 2088a23a9ec6Sbellard 2089a23a9ec6Sbellard #ifdef CONFIG_PROFILER 2090a23a9ec6Sbellard void tcg_dump_info(FILE *f, 2091a23a9ec6Sbellard int (*cpu_fprintf)(FILE *f, const char *fmt, ...)) 2092a23a9ec6Sbellard { 2093a23a9ec6Sbellard TCGContext *s = &tcg_ctx; 2094a23a9ec6Sbellard int64_t tot; 2095a23a9ec6Sbellard 2096a23a9ec6Sbellard tot = s->interm_time + s->code_time; 2097a23a9ec6Sbellard cpu_fprintf(f, "JIT cycles %" PRId64 " (%0.3f s at 2.4 GHz)\n", 2098a23a9ec6Sbellard tot, tot / 2.4e9); 2099a23a9ec6Sbellard cpu_fprintf(f, "translated TBs %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n", 2100a23a9ec6Sbellard s->tb_count, 2101a23a9ec6Sbellard s->tb_count1 - s->tb_count, 2102a23a9ec6Sbellard s->tb_count1 ? (double)(s->tb_count1 - s->tb_count) / s->tb_count1 * 100.0 : 0); 2103a23a9ec6Sbellard cpu_fprintf(f, "avg ops/TB %0.1f max=%d\n", 2104a23a9ec6Sbellard s->tb_count ? (double)s->op_count / s->tb_count : 0, s->op_count_max); 2105a23a9ec6Sbellard cpu_fprintf(f, "old ops/total ops %0.1f%%\n", 2106a23a9ec6Sbellard s->op_count ? (double)s->old_op_count / s->op_count * 100.0 : 0); 2107a23a9ec6Sbellard cpu_fprintf(f, "deleted ops/TB %0.2f\n", 2108a23a9ec6Sbellard s->tb_count ? 2109a23a9ec6Sbellard (double)s->del_op_count / s->tb_count : 0); 2110a23a9ec6Sbellard cpu_fprintf(f, "avg temps/TB %0.2f max=%d\n", 2111a23a9ec6Sbellard s->tb_count ? 2112a23a9ec6Sbellard (double)s->temp_count / s->tb_count : 0, 2113a23a9ec6Sbellard s->temp_count_max); 2114a23a9ec6Sbellard 2115a23a9ec6Sbellard cpu_fprintf(f, "cycles/op %0.1f\n", 2116a23a9ec6Sbellard s->op_count ? (double)tot / s->op_count : 0); 2117a23a9ec6Sbellard cpu_fprintf(f, "cycles/in byte %0.1f\n", 2118a23a9ec6Sbellard s->code_in_len ? (double)tot / s->code_in_len : 0); 2119a23a9ec6Sbellard cpu_fprintf(f, "cycles/out byte %0.1f\n", 2120a23a9ec6Sbellard s->code_out_len ? (double)tot / s->code_out_len : 0); 2121a23a9ec6Sbellard if (tot == 0) 2122a23a9ec6Sbellard tot = 1; 2123a23a9ec6Sbellard cpu_fprintf(f, " gen_interm time %0.1f%%\n", 2124a23a9ec6Sbellard (double)s->interm_time / tot * 100.0); 2125a23a9ec6Sbellard cpu_fprintf(f, " gen_code time %0.1f%%\n", 2126a23a9ec6Sbellard (double)s->code_time / tot * 100.0); 2127a23a9ec6Sbellard cpu_fprintf(f, "liveness/code time %0.1f%%\n", 2128a23a9ec6Sbellard (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0); 2129a23a9ec6Sbellard cpu_fprintf(f, "cpu_restore count %" PRId64 "\n", 2130a23a9ec6Sbellard s->restore_count); 2131a23a9ec6Sbellard cpu_fprintf(f, " avg cycles %0.1f\n", 2132a23a9ec6Sbellard s->restore_count ? (double)s->restore_time / s->restore_count : 0); 2133a23a9ec6Sbellard { 2134a23a9ec6Sbellard extern void dump_op_count(void); 2135a23a9ec6Sbellard dump_op_count(); 2136a23a9ec6Sbellard } 2137a23a9ec6Sbellard } 2138a23a9ec6Sbellard #else 213924bf7b3aSbellard void tcg_dump_info(FILE *f, 2140a23a9ec6Sbellard int (*cpu_fprintf)(FILE *f, const char *fmt, ...)) 2141a23a9ec6Sbellard { 214224bf7b3aSbellard cpu_fprintf(f, "[TCG profiler not compiled]\n"); 2143a23a9ec6Sbellard } 2144a23a9ec6Sbellard #endif 2145