VirtualBox

Changeset 36170 in vbox for trunk/src/recompiler/tcg/tcg.c


Ignore:
Timestamp:
Mar 4, 2011 12:49:02 PM (14 years ago)
Author:
vboxsync
Message:

rem: synced up to svn://svn.savannah.nongnu.org/qemu/trunk@6686 (repo UUID c046a42c-6fe2-441c-8c8c-71466251a162).

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/recompiler/tcg/tcg.c

    r36140 r36170  
    4343#include <malloc.h>
    4444#endif
     45#ifdef _AIX
     46#include <alloca.h>
     47#endif
    4548
    4649#include "config.h"
    4750#include "qemu-common.h"
     51#include "cache-utils.h"
    4852
    4953/* Note: the long term plan is to reduce the dependancies on the QEMU
     
    7377                        tcg_target_long value, tcg_target_long addend);
    7478
    75 TCGOpDef tcg_op_defs[] = {
     79static TCGOpDef tcg_op_defs[] = {
    7680#define DEF(s, n, copy_size) { #s, 0, 0, n, n, 0, copy_size },
    7781#ifndef VBOX
     
    8589};
    8690
    87 TCGRegSet tcg_target_available_regs[2];
    88 TCGRegSet tcg_target_call_clobber_regs;
     91static TCGRegSet tcg_target_available_regs[2];
     92static TCGRegSet tcg_target_call_clobber_regs;
    8993
    9094/* XXX: move that inside the context */
     
    289293}
    290294
    291 TCGv tcg_global_reg_new(TCGType type, int reg, const char *name)
     295static inline int tcg_global_reg_new_internal(TCGType type, int reg,
     296                                              const char *name)
    292297{
    293298    TCGContext *s = &tcg_ctx;
     
    311316    s->nb_globals++;
    312317    tcg_regset_set_reg(s->reserved_regs, reg);
    313     return MAKE_TCGV(idx);
    314 }
    315 
    316 #if TCG_TARGET_REG_BITS == 32
    317 /* temporary hack to avoid register shortage for tcg_qemu_st64() */
    318 TCGv tcg_global_reg2_new_hack(TCGType type, int reg1, int reg2,
    319                               const char *name)
    320 {
    321     TCGContext *s = &tcg_ctx;
    322     TCGTemp *ts;
     318    return idx;
     319}
     320
     321TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name)
     322{
    323323    int idx;
    324     char buf[64];
    325 
    326     if (type != TCG_TYPE_I64)
    327         tcg_abort();
    328     idx = s->nb_globals;
    329     tcg_temp_alloc(s, s->nb_globals + 2);
    330     ts = &s->temps[s->nb_globals];
    331     ts->base_type = type;
    332     ts->type = TCG_TYPE_I32;
    333     ts->fixed_reg = 1;
    334     ts->reg = reg1;
    335     pstrcpy(buf, sizeof(buf), name);
    336     pstrcat(buf, sizeof(buf), "_0");
    337     ts->name = strdup(buf);
    338 
    339     ts++;
    340     ts->base_type = type;
    341     ts->type = TCG_TYPE_I32;
    342     ts->fixed_reg = 1;
    343     ts->reg = reg2;
    344     pstrcpy(buf, sizeof(buf), name);
    345     pstrcat(buf, sizeof(buf), "_1");
    346     ts->name = strdup(buf);
    347 
    348     s->nb_globals += 2;
    349     return MAKE_TCGV(idx);
    350 }
    351 #endif
    352 
    353 TCGv tcg_global_mem_new(TCGType type, int reg, tcg_target_long offset,
    354                         const char *name)
     324
     325    idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name);
     326    return MAKE_TCGV_I32(idx);
     327}
     328
     329TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name)
     330{
     331    int idx;
     332
     333    idx = tcg_global_reg_new_internal(TCG_TYPE_I64, reg, name);
     334    return MAKE_TCGV_I64(idx);
     335}
     336
     337static inline int tcg_global_mem_new_internal(TCGType type, int reg,
     338                                              tcg_target_long offset,
     339                                              const char *name)
    355340{
    356341    TCGContext *s = &tcg_ctx;
     
    408393        s->nb_globals++;
    409394    }
    410     return MAKE_TCGV(idx);
    411 }
    412 
    413 TCGv tcg_temp_new_internal(TCGType type, int temp_local)
     395    return idx;
     396}
     397
     398TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset,
     399                                const char *name)
     400{
     401    int idx;
     402
     403    idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name);
     404    return MAKE_TCGV_I32(idx);
     405}
     406
     407TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset,
     408                                const char *name)
     409{
     410    int idx;
     411
     412    idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name);
     413    return MAKE_TCGV_I64(idx);
     414}
     415
     416static inline int tcg_temp_new_internal(TCGType type, int temp_local)
    414417{
    415418    TCGContext *s = &tcg_ctx;
     
    459462        }
    460463    }
    461     return MAKE_TCGV(idx);
    462 }
    463 
    464 void tcg_temp_free(TCGv arg)
     464    return idx;
     465}
     466
     467TCGv_i32 tcg_temp_new_internal_i32(int temp_local)
     468{
     469    int idx;
     470
     471    idx = tcg_temp_new_internal(TCG_TYPE_I32, temp_local);
     472    return MAKE_TCGV_I32(idx);
     473}
     474
     475TCGv_i64 tcg_temp_new_internal_i64(int temp_local)
     476{
     477    int idx;
     478
     479    idx = tcg_temp_new_internal(TCG_TYPE_I64, temp_local);
     480    return MAKE_TCGV_I64(idx);
     481}
     482
     483static inline void tcg_temp_free_internal(int idx)
    465484{
    466485    TCGContext *s = &tcg_ctx;
    467486    TCGTemp *ts;
    468     int idx = GET_TCGV(arg);
    469487    int k;
    470488
     
    480498}
    481499
    482 
    483 TCGv tcg_const_i32(int32_t val)
    484 {
    485     TCGv t0;
    486     t0 = tcg_temp_new(TCG_TYPE_I32);
     500void tcg_temp_free_i32(TCGv_i32 arg)
     501{
     502    tcg_temp_free_internal(GET_TCGV_I32(arg));
     503}
     504
     505void tcg_temp_free_i64(TCGv_i64 arg)
     506{
     507    tcg_temp_free_internal(GET_TCGV_I64(arg));
     508}
     509
     510TCGv_i32 tcg_const_i32(int32_t val)
     511{
     512    TCGv_i32 t0;
     513    t0 = tcg_temp_new_i32();
    487514    tcg_gen_movi_i32(t0, val);
    488515    return t0;
    489516}
    490517
    491 TCGv tcg_const_i64(int64_t val)
    492 {
    493     TCGv t0;
    494     t0 = tcg_temp_new(TCG_TYPE_I64);
     518TCGv_i64 tcg_const_i64(int64_t val)
     519{
     520    TCGv_i64 t0;
     521    t0 = tcg_temp_new_i64();
     522    tcg_gen_movi_i64(t0, val);
     523    return t0;
     524}
     525
     526TCGv_i32 tcg_const_local_i32(int32_t val)
     527{
     528    TCGv_i32 t0;
     529    t0 = tcg_temp_local_new_i32();
     530    tcg_gen_movi_i32(t0, val);
     531    return t0;
     532}
     533
     534TCGv_i64 tcg_const_local_i64(int64_t val)
     535{
     536    TCGv_i64 t0;
     537    t0 = tcg_temp_local_new_i64();
    495538    tcg_gen_movi_i64(t0, val);
    496539    return t0;
     
    520563}
    521564
    522 static inline TCGType tcg_get_base_type(TCGContext *s, TCGv arg)
    523 {
    524     return s->temps[GET_TCGV(arg)].base_type;
    525 }
    526 
    527 static void tcg_gen_call_internal(TCGContext *s, TCGv func,
    528                                   unsigned int flags,
    529                                   unsigned int nb_rets, const TCGv *rets,
    530                                   unsigned int nb_params, const TCGv *params)
    531 {
    532 #ifndef VBOX
    533    int i;
    534 #else
    535    unsigned int i;
    536 #endif
    537     *gen_opc_ptr++ = INDEX_op_call;
    538     *gen_opparam_ptr++ = (nb_rets << 16) | (nb_params + 1);
    539     for(i = 0; i < nb_rets; i++) {
    540         *gen_opparam_ptr++ = GET_TCGV(rets[i]);
    541     }
    542     for(i = 0; i < nb_params; i++) {
    543         *gen_opparam_ptr++ = GET_TCGV(params[i]);
    544     }
    545     *gen_opparam_ptr++ = GET_TCGV(func);
    546 
    547     *gen_opparam_ptr++ = flags;
    548     /* total parameters, needed to go backward in the instruction stream */
    549     *gen_opparam_ptr++ = 1 + nb_rets + nb_params + 3;
    550 }
    551 
    552 
    553 #if TCG_TARGET_REG_BITS < 64
    554565/* Note: we convert the 64 bit args to 32 bit and do some alignment
    555566   and endian swap. Maybe it would be better to do the alignment
    556567   and endian swap in tcg_reg_alloc_call(). */
    557 void tcg_gen_call(TCGContext *s, TCGv func, unsigned int flags,
    558                   unsigned int nb_rets, const TCGv *rets,
    559                   unsigned int nb_params, const TCGv *args1)
    560 {
    561     TCGv ret, *args2, rets_2[2], arg;
    562     int j, i, call_type;
    563 
    564     if (nb_rets == 1) {
    565         ret = rets[0];
    566         if (tcg_get_base_type(s, ret) == TCG_TYPE_I64) {
     568void tcg_gen_callN(TCGContext *s, TCGv_ptr func, unsigned int flags,
     569                   int sizemask, TCGArg ret, int nargs, TCGArg *args)
     570{
     571    int call_type;
     572    int i;
     573    int real_args;
     574    int nb_rets;
     575    TCGArg *nparam;
     576    *gen_opc_ptr++ = INDEX_op_call;
     577    nparam = gen_opparam_ptr++;
     578    call_type = (flags & TCG_CALL_TYPE_MASK);
     579    if (ret != TCG_CALL_DUMMY_ARG) {
     580#if TCG_TARGET_REG_BITS < 64
     581        if (sizemask & 1) {
     582#ifdef TCG_TARGET_WORDS_BIGENDIAN
     583            *gen_opparam_ptr++ = ret + 1;
     584            *gen_opparam_ptr++ = ret;
     585#else
     586            *gen_opparam_ptr++ = ret;
     587            *gen_opparam_ptr++ = ret + 1;
     588#endif
    567589            nb_rets = 2;
    568 #ifdef TCG_TARGET_WORDS_BIGENDIAN
    569             rets_2[0] = TCGV_HIGH(ret);
    570             rets_2[1] = ret;
    571 #else
    572             rets_2[0] = ret;
    573             rets_2[1] = TCGV_HIGH(ret);
    574 #endif
    575             rets = rets_2;
    576         }
    577     }
    578     args2 = alloca((nb_params * 3) * sizeof(TCGv));
    579     j = 0;
    580     call_type = (flags & TCG_CALL_TYPE_MASK);
    581     for(i = 0; i < nb_params; i++) {
    582         arg = args1[i];
    583         if (tcg_get_base_type(s, arg) == TCG_TYPE_I64) {
     590        } else
     591#endif
     592        {
     593            *gen_opparam_ptr++ = ret;
     594            nb_rets = 1;
     595        }
     596    } else {
     597        nb_rets = 0;
     598    }
     599    real_args = 0;
     600    for (i = 0; i < nargs; i++) {
     601#if TCG_TARGET_REG_BITS < 64
     602        if (sizemask & (2 << i)) {
    584603#ifdef TCG_TARGET_I386
    585604            /* REGPARM case: if the third parameter is 64 bit, it is
    586605               allocated on the stack */
    587             if (j == 2 && call_type == TCG_CALL_TYPE_REGPARM) {
     606            if (i == 2 && call_type == TCG_CALL_TYPE_REGPARM) {
    588607                call_type = TCG_CALL_TYPE_REGPARM_2;
    589608                flags = (flags & ~TCG_CALL_TYPE_MASK) | call_type;
    590609            }
    591             args2[j++] = arg;
    592             args2[j++] = TCGV_HIGH(arg);
    593 #else
     610#endif
    594611#ifdef TCG_TARGET_CALL_ALIGN_ARGS
    595612            /* some targets want aligned 64 bit args */
    596             if (j & 1) {
    597                 args2[j++] = TCG_CALL_DUMMY_ARG;
     613            if (real_args & 1) {
     614                *gen_opparam_ptr++ = TCG_CALL_DUMMY_ARG;
     615                real_args++;
    598616            }
    599617#endif
    600618#ifdef TCG_TARGET_WORDS_BIGENDIAN
    601             args2[j++] = TCGV_HIGH(arg);
    602             args2[j++] = arg;
     619            *gen_opparam_ptr++ = args[i] + 1;
     620            *gen_opparam_ptr++ = args[i];
    603621#else
    604             args2[j++] = arg;
    605             args2[j++] = TCGV_HIGH(arg);
    606 #endif
    607 #endif
    608         } else {
    609             args2[j++] = arg;
    610         }
    611     }
    612     tcg_gen_call_internal(s, func, flags,
    613                           nb_rets, rets, j, args2);
    614 }
    615 #else
    616 void tcg_gen_call(TCGContext *s, TCGv func, unsigned int flags,
    617                   unsigned int nb_rets, const TCGv *rets,
    618                   unsigned int nb_params, const TCGv *args1)
    619 {
    620     tcg_gen_call_internal(s, func, flags,
    621                           nb_rets, rets, nb_params, args1);
    622 }
    623 #endif
     622            *gen_opparam_ptr++ = args[i];
     623            *gen_opparam_ptr++ = args[i] + 1;
     624#endif
     625            real_args += 2;
     626        } else
     627#endif
     628        {
     629            *gen_opparam_ptr++ = args[i];
     630            real_args++;
     631        }
     632    }
     633    *gen_opparam_ptr++ = GET_TCGV_PTR(func);
     634
     635    *gen_opparam_ptr++ = flags;
     636
     637    *nparam = (nb_rets << 16) | (real_args + 1);
     638
     639    /* total parameters, needed to go backward in the instruction stream */
     640    *gen_opparam_ptr++ = 1 + nb_rets + real_args + 3;
     641}
    624642
    625643#if TCG_TARGET_REG_BITS == 32
    626 void tcg_gen_shifti_i64(TCGv ret, TCGv arg1,
     644void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1,
    627645                        int c, int right, int arith)
    628646{
    629647    if (c == 0) {
    630         tcg_gen_mov_i32(ret, arg1);
     648        tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg1));
    631649        tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1));
    632650    } else if (c >= 32) {
     
    634652        if (right) {
    635653            if (arith) {
    636                 tcg_gen_sari_i32(ret, TCGV_HIGH(arg1), c);
     654                tcg_gen_sari_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c);
    637655                tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), 31);
    638656            } else {
    639                 tcg_gen_shri_i32(ret, TCGV_HIGH(arg1), c);
     657                tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_HIGH(arg1), c);
    640658                tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
    641659            }
    642660        } else {
    643             tcg_gen_shli_i32(TCGV_HIGH(ret), arg1, c);
    644             tcg_gen_movi_i32(ret, 0);
     661            tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_LOW(arg1), c);
     662            tcg_gen_movi_i32(TCGV_LOW(ret), 0);
    645663        }
    646664    } else {
    647         TCGv t0, t1;
    648 
    649         t0 = tcg_temp_new(TCG_TYPE_I32);
    650         t1 = tcg_temp_new(TCG_TYPE_I32);
     665        TCGv_i32 t0, t1;
     666
     667        t0 = tcg_temp_new_i32();
     668        t1 = tcg_temp_new_i32();
    651669        if (right) {
    652670            tcg_gen_shli_i32(t0, TCGV_HIGH(arg1), 32 - c);
     
    655673            else
    656674                tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c);
    657             tcg_gen_shri_i32(ret, arg1, c);
    658             tcg_gen_or_i32(ret, ret, t0);
     675            tcg_gen_shri_i32(TCGV_LOW(ret), TCGV_LOW(arg1), c);
     676            tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(ret), t0);
    659677            tcg_gen_mov_i32(TCGV_HIGH(ret), t1);
    660678        } else {
    661             tcg_gen_shri_i32(t0, arg1, 32 - c);
     679            tcg_gen_shri_i32(t0, TCGV_LOW(arg1), 32 - c);
    662680            /* Note: ret can be the same as arg1, so we use t1 */
    663             tcg_gen_shli_i32(t1, arg1, c);
     681            tcg_gen_shli_i32(t1, TCGV_LOW(arg1), c);
    664682            tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c);
    665683            tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0);
    666             tcg_gen_mov_i32(ret, t1);
    667         }
    668         tcg_temp_free(t0);
    669         tcg_temp_free(t1);
     684            tcg_gen_mov_i32(TCGV_LOW(ret), t1);
     685        }
     686        tcg_temp_free_i32(t0);
     687        tcg_temp_free_i32(t1);
    670688    }
    671689}
     
    712730}
    713731
    714 char *tcg_get_arg_str(TCGContext *s, char *buf, int buf_size, TCGv arg)
    715 {
    716     return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV(arg));
     732char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg)
     733{
     734    return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I32(arg));
     735}
     736
     737char *tcg_get_arg_str_i64(TCGContext *s, char *buf, int buf_size, TCGv_i64 arg)
     738{
     739    return tcg_get_arg_str_idx(s, buf, buf_size, GET_TCGV_I64(arg));
    717740}
    718741
     
    857880            th = tcg_find_helper(s, val);
    858881            if (th) {
    859                 fprintf(outfile, th->name);
     882                fprintf(outfile, "%s", th->name);
    860883            } else {
    861884                if (c == INDEX_op_movi_i32)
     
    11741197            /* XXX: optimize by hardcoding common cases (e.g. triadic ops) */
    11751198        default:
    1176             if (op > INDEX_op_end) {
    1177                 args -= def->nb_args;
    1178                 nb_iargs = def->nb_iargs;
    1179                 nb_oargs = def->nb_oargs;
    1180 
    1181                 /* Test if the operation can be removed because all
    1182                    its outputs are dead. We assume that nb_oargs == 0
    1183                    implies side effects */
    1184                 if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) {
    1185                     for(i = 0; i < nb_oargs; i++) {
    1186                         arg = args[i];
    1187                         if (!dead_temps[arg])
    1188                             goto do_not_remove;
     1199            args -= def->nb_args;
     1200            nb_iargs = def->nb_iargs;
     1201            nb_oargs = def->nb_oargs;
     1202
     1203            /* Test if the operation can be removed because all
     1204               its outputs are dead. We assume that nb_oargs == 0
     1205               implies side effects */
     1206            if (!(def->flags & TCG_OPF_SIDE_EFFECTS) && nb_oargs != 0) {
     1207                for(i = 0; i < nb_oargs; i++) {
     1208                    arg = args[i];
     1209                    if (!dead_temps[arg])
     1210                        goto do_not_remove;
     1211                }
     1212                tcg_set_nop(s, gen_opc_buf + op_index, args, def->nb_args);
     1213#ifdef CONFIG_PROFILER
     1214                s->del_op_count++;
     1215#endif
     1216            } else {
     1217            do_not_remove:
     1218
     1219                /* output args are dead */
     1220                for(i = 0; i < nb_oargs; i++) {
     1221                    arg = args[i];
     1222                    dead_temps[arg] = 1;
     1223                }
     1224
     1225                /* if end of basic block, update */
     1226                if (def->flags & TCG_OPF_BB_END) {
     1227                    tcg_la_bb_end(s, dead_temps);
     1228                } else if (def->flags & TCG_OPF_CALL_CLOBBER) {
     1229                    /* globals are live */
     1230                    memset(dead_temps, 0, s->nb_globals);
     1231                }
     1232
     1233                /* input args are live */
     1234                dead_iargs = 0;
     1235                for(i = 0; i < nb_iargs; i++) {
     1236                    arg = args[i + nb_oargs];
     1237                    if (dead_temps[arg]) {
     1238                        dead_iargs |= (1 << i);
    11891239                    }
    1190                     tcg_set_nop(s, gen_opc_buf + op_index, args, def->nb_args);
    1191 #ifdef CONFIG_PROFILER
    1192                     s->del_op_count++;
    1193 #endif
    1194                 } else {
    1195                 do_not_remove:
    1196 
    1197                     /* output args are dead */
    1198                     for(i = 0; i < nb_oargs; i++) {
    1199                         arg = args[i];
    1200                         dead_temps[arg] = 1;
    1201                     }
    1202 
    1203                     /* if end of basic block, update */
    1204                     if (def->flags & TCG_OPF_BB_END) {
    1205                         tcg_la_bb_end(s, dead_temps);
    1206                     } else if (def->flags & TCG_OPF_CALL_CLOBBER) {
    1207                         /* globals are live */
    1208                         memset(dead_temps, 0, s->nb_globals);
    1209                     }
    1210 
    1211                     /* input args are live */
    1212                     dead_iargs = 0;
    1213                     for(i = 0; i < nb_iargs; i++) {
    1214                         arg = args[i + nb_oargs];
    1215                         if (dead_temps[arg]) {
    1216                             dead_iargs |= (1 << i);
    1217                         }
    1218                         dead_temps[arg] = 0;
    1219                     }
    1220                     s->op_dead_iargs[op_index] = dead_iargs;
     1240                    dead_temps[arg] = 0;
    12211241                }
    1222             } else {
    1223                 /* legacy dyngen operations */
    1224                 args -= def->nb_args;
    1225                 /* mark end of basic block */
    1226                 tcg_la_bb_end(s, dead_temps);
     1242                s->op_dead_iargs[op_index] = dead_iargs;
    12271243            }
    12281244            break;
     
    18771893#ifdef CONFIG_PROFILER
    18781894
    1879 static int64_t dyngen_table_op_count[NB_OPS];
     1895static int64_t tcg_table_op_count[NB_OPS];
    18801896
    18811897void dump_op_count(void)
     
    18831899    int i;
    18841900    FILE *f;
    1885     f = fopen("/tmp/op1.log", "w");
    1886     for(i = 0; i < INDEX_op_end; i++) {
    1887         fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, dyngen_table_op_count[i]);
    1888     }
    1889     fclose(f);
    1890     f = fopen("/tmp/op2.log", "w");
     1901    f = fopen("/tmp/op.log", "w");
    18911902    for(i = INDEX_op_end; i < NB_OPS; i++) {
    1892         fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, dyngen_table_op_count[i]);
     1903        fprintf(f, "%s %" PRId64 "\n", tcg_op_defs[i].name, tcg_table_op_count[i]);
    18931904    }
    18941905    fclose(f);
     
    19061917
    19071918#ifdef DEBUG_DISAS
    1908     if (unlikely(loglevel & CPU_LOG_TB_OP)) {
    1909         fprintf(logfile, "OP:\n");
     1919    if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) {
     1920        qemu_log("OP:\n");
    19101921        tcg_dump_ops(s, logfile);
    1911         fprintf(logfile, "\n");
     1922        qemu_log("\n");
    19121923    }
    19131924#endif
     
    19221933
    19231934#ifdef DEBUG_DISAS
    1924     if (unlikely(loglevel & CPU_LOG_TB_OP_OPT)) {
    1925         fprintf(logfile, "OP after la:\n");
     1935    if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP_OPT))) {
     1936        qemu_log("OP after la:\n");
    19261937        tcg_dump_ops(s, logfile);
    1927         fprintf(logfile, "\n");
     1938        qemu_log("\n");
    19281939    }
    19291940#endif
     
    19401951        opc = gen_opc_buf[op_index];
    19411952#ifdef CONFIG_PROFILER
    1942         dyngen_table_op_count[opc]++;
     1953        tcg_table_op_count[opc]++;
    19431954#endif
    19441955        def = &tcg_op_defs[opc];
     
    19952006        case INDEX_op_end:
    19962007            goto the_end;
    1997 
    1998 #ifdef CONFIG_DYNGEN_OP
    1999         case 0 ... INDEX_op_end - 1:
    2000             /* legacy dyngen ops */
    2001 #ifdef CONFIG_PROFILER
    2002             s->old_op_count++;
    2003 #endif
    2004             tcg_reg_alloc_bb_end(s, s->reserved_regs);
    2005             if (search_pc >= 0) {
    2006                 s->code_ptr += def->copy_size;
    2007                 args += def->nb_args;
    2008             } else {
    2009                 args = dyngen_op(s, opc, args);
    2010             }
    2011             goto next;
    2012 #endif
    20132008        default:
    20142009            /* Note: in order to speed up the code, it would be much
     
    20332028}
    20342029
    2035 int dyngen_code(TCGContext *s, uint8_t *gen_code_buf)
     2030int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf)
    20362031{
    20372032#ifdef CONFIG_PROFILER
     
    20612056   not be changed, though writing the same values is ok.
    20622057   Return -1 if not found. */
    2063 int dyngen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset)
     2058int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset)
    20642059{
    20652060    return tcg_gen_code_common(s, gen_code_buf, offset);
     
    20822077    cpu_fprintf(f, "avg ops/TB          %0.1f max=%d\n",
    20832078                s->tb_count ? (double)s->op_count / s->tb_count : 0, s->op_count_max);
    2084     cpu_fprintf(f, "old ops/total ops   %0.1f%%\n",
    2085                 s->op_count ? (double)s->old_op_count / s->op_count * 100.0 : 0);
    20862079    cpu_fprintf(f, "deleted ops/TB      %0.2f\n",
    20872080                s->tb_count ?
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette