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