accel/tcg/translator.c

   1 /*
   2  * Generic intermediate code generation.
   3  *
   4  * Copyright (C) 2016-2017 Lluís Vilanova <vilanova@ac.upc.edu>
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   7  * See the COPYING file in the top-level directory.
   8  */
   9
  10 #include "qemu/osdep.h"
  11 #include "qemu/error-report.h"
  12 #include "tcg/tcg.h"
  13 #include "tcg/tcg-op.h"
  14 #include "exec/exec-all.h"
  15 #include "exec/gen-icount.h"
  16 #include "exec/log.h"
  17 #include "exec/translator.h"
  18 #include "exec/plugin-gen.h"
  19 #include "sysemu/replay.h"
  20
  21 /* Pairs with tcg_clear_temp_count.
  22    To be called by #TranslatorOps.{translate_insn,tb_stop} if
  23    (1) the target is sufficiently clean to support reporting,
  24    (2) as and when all temporaries are known to be consumed.
  25    For most targets, (2) is at the end of translate_insn.  */
  26 void translator_loop_temp_check(DisasContextBase *db)
  27 {
  28     if (tcg_check_temp_count()) {
  29         qemu_log("warning: TCG temporary leaks before "
  30                  TARGET_FMT_lx "\n", db->pc_next);
  31     }
  32 }
  33
  34 bool translator_use_goto_tb(DisasContextBase *db, target_ulong dest)
  35 {
  36     /* Suppress goto_tb if requested. */
  37     if (tb_cflags(db->tb) & CF_NO_GOTO_TB) {
  38         return false;
  39     }
  40
  41     /* Check for the dest on the same page as the start of the TB.  */
  42     return ((db->pc_first ^ dest) & TARGET_PAGE_MASK) == 0;
  43 }
  44
  45 void translator_loop(CPUState *cpu, TranslationBlock *tb, int max_insns,
  46                      target_ulong pc, void *host_pc,
  47                      const TranslatorOps *ops, DisasContextBase *db)
  48 {
  49     uint32_t cflags = tb_cflags(tb);
  50     bool plugin_enabled;
  51
  52     /* Initialize DisasContext */
  53     db->tb = tb;
  54     db->pc_first = pc;
  55     db->pc_next = pc;
  56     db->is_jmp = DISAS_NEXT;
  57     db->num_insns = 0;
  58     db->max_insns = max_insns;
  59     db->singlestep_enabled = cflags & CF_SINGLE_STEP;
  60     db->host_addr[0] = host_pc;
  61     db->host_addr[1] = NULL;
  62
  63 #ifdef CONFIG_USER_ONLY
  64     page_protect(pc);
  65 #endif
  66
  67     ops->init_disas_context(db, cpu);
  68     tcg_debug_assert(db->is_jmp == DISAS_NEXT);  /* no early exit */
  69
  70     /* Reset the temp count so that we can identify leaks */
  71     tcg_clear_temp_count();
  72
  73     /* Start translating.  */
  74     gen_tb_start(db->tb);
  75     ops->tb_start(db, cpu);
  76     tcg_debug_assert(db->is_jmp == DISAS_NEXT);  /* no early exit */
  77
  78     plugin_enabled = plugin_gen_tb_start(cpu, db, cflags & CF_MEMI_ONLY);
  79
  80     while (true) {
  81         db->num_insns++;
  82         ops->insn_start(db, cpu);
  83         tcg_debug_assert(db->is_jmp == DISAS_NEXT);  /* no early exit */
  84
  85         if (plugin_enabled) {
  86             plugin_gen_insn_start(cpu, db);
  87         }
  88
  89         /* Disassemble one instruction.  The translate_insn hook should
  90            update db->pc_next and db->is_jmp to indicate what should be
  91            done next -- either exiting this loop or locate the start of
  92            the next instruction.  */
  93         if (db->num_insns == db->max_insns && (cflags & CF_LAST_IO)) {
  94             /* Accept I/O on the last instruction.  */
  95             gen_io_start();
  96             ops->translate_insn(db, cpu);
  97         } else {
  98             /* we should only see CF_MEMI_ONLY for io_recompile */
  99             tcg_debug_assert(!(cflags & CF_MEMI_ONLY));
 100             ops->translate_insn(db, cpu);
 101         }
 102
 103         /* Stop translation if translate_insn so indicated.  */
 104         if (db->is_jmp != DISAS_NEXT) {
 105             break;
 106         }
 107
 108         /*
 109          * We can't instrument after instructions that change control
 110          * flow although this only really affects post-load operations.
 111          */
 112         if (plugin_enabled) {
 113             plugin_gen_insn_end();
 114         }
 115
 116         /* Stop translation if the output buffer is full,
 117            or we have executed all of the allowed instructions.  */
 118         if (tcg_op_buf_full() || db->num_insns >= db->max_insns) {
 119             db->is_jmp = DISAS_TOO_MANY;
 120             break;
 121         }
 122     }
 123
 124     /* Emit code to exit the TB, as indicated by db->is_jmp.  */
 125     ops->tb_stop(db, cpu);
 126     gen_tb_end(db->tb, db->num_insns);
 127
 128     if (plugin_enabled) {
 129         plugin_gen_tb_end(cpu);
 130     }
 131
 132     /* The disas_log hook may use these values rather than recompute.  */
 133     tb->size = db->pc_next - db->pc_first;
 134     tb->icount = db->num_insns;
 135
 136 #ifdef DEBUG_DISAS
 137     if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)
 138         && qemu_log_in_addr_range(db->pc_first)) {
 139         FILE *logfile = qemu_log_trylock();
 140         if (logfile) {
 141             fprintf(logfile, "----------------\n");
 142             ops->disas_log(db, cpu, logfile);
 143             fprintf(logfile, "\n");
 144             qemu_log_unlock(logfile);
 145         }
 146     }
 147 #endif
 148 }
 149
 150 static void *translator_access(CPUArchState *env, DisasContextBase *db,
 151                                target_ulong pc, size_t len)
 152 {
 153     void *host;
 154     target_ulong base, end;
 155     TranslationBlock *tb;
 156
 157     tb = db->tb;
 158
 159     /* Use slow path if first page is MMIO. */
 160     if (unlikely(tb_page_addr0(tb) == -1)) {
 161         return NULL;
 162     }
 163
 164     end = pc + len - 1;
 165     if (likely(is_same_page(db, end))) {
 166         host = db->host_addr[0];
 167         base = db->pc_first;
 168     } else {
 169         host = db->host_addr[1];
 170         base = TARGET_PAGE_ALIGN(db->pc_first);
 171         if (host == NULL) {
 172             tb_page_addr_t phys_page =
 173                 get_page_addr_code_hostp(env, base, &db->host_addr[1]);
 174             /* We cannot handle MMIO as second page. */
 175             assert(phys_page != -1);
 176             tb_set_page_addr1(tb, phys_page);
 177 #ifdef CONFIG_USER_ONLY
 178             page_protect(end);
 179 #endif
 180             host = db->host_addr[1];
 181         }
 182
 183         /* Use slow path when crossing pages. */
 184         if (is_same_page(db, pc)) {
 185             return NULL;
 186         }
 187     }
 188
 189     tcg_debug_assert(pc >= base);
 190     return host + (pc - base);
 191 }
 192
 193 uint8_t translator_ldub(CPUArchState *env, DisasContextBase *db, abi_ptr pc)
 194 {
 195     uint8_t ret;
 196     void *p = translator_access(env, db, pc, sizeof(ret));
 197
 198     if (p) {
 199         plugin_insn_append(pc, p, sizeof(ret));
 200         return ldub_p(p);
 201     }
 202     ret = cpu_ldub_code(env, pc);
 203     plugin_insn_append(pc, &ret, sizeof(ret));
 204     return ret;
 205 }
 206
 207 uint16_t translator_lduw(CPUArchState *env, DisasContextBase *db, abi_ptr pc)
 208 {
 209     uint16_t ret, plug;
 210     void *p = translator_access(env, db, pc, sizeof(ret));
 211
 212     if (p) {
 213         plugin_insn_append(pc, p, sizeof(ret));
 214         return lduw_p(p);
 215     }
 216     ret = cpu_lduw_code(env, pc);
 217     plug = tswap16(ret);
 218     plugin_insn_append(pc, &plug, sizeof(ret));
 219     return ret;
 220 }
 221
 222 uint32_t translator_ldl(CPUArchState *env, DisasContextBase *db, abi_ptr pc)
 223 {
 224     uint32_t ret, plug;
 225     void *p = translator_access(env, db, pc, sizeof(ret));
 226
 227     if (p) {
 228         plugin_insn_append(pc, p, sizeof(ret));
 229         return ldl_p(p);
 230     }
 231     ret = cpu_ldl_code(env, pc);
 232     plug = tswap32(ret);
 233     plugin_insn_append(pc, &plug, sizeof(ret));
 234     return ret;
 235 }
 236
 237 uint64_t translator_ldq(CPUArchState *env, DisasContextBase *db, abi_ptr pc)
 238 {
 239     uint64_t ret, plug;
 240     void *p = translator_access(env, db, pc, sizeof(ret));
 241
 242     if (p) {
 243         plugin_insn_append(pc, p, sizeof(ret));
 244         return ldq_p(p);
 245     }
 246     ret = cpu_ldq_code(env, pc);
 247     plug = tswap64(ret);
 248     plugin_insn_append(pc, &plug, sizeof(ret));
 249     return ret;
 250 }