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-common.h"
  12 #include "qemu/error-report.h"
  13 #include "cpu.h"
  14 #include "tcg/tcg.h"
  15 #include "tcg/tcg-op.h"
  16 #include "exec/exec-all.h"
  17 #include "exec/gen-icount.h"
  18 #include "exec/log.h"
  19 #include "exec/translator.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 void translator_loop(const TranslatorOps *ops, DisasContextBase *db,
  35                      CPUState *cpu, TranslationBlock *tb)
  36 {
  37     int max_insns;
  38
  39     /* Initialize DisasContext */
  40     db->tb = tb;
  41     db->pc_first = tb->pc;
  42     db->pc_next = db->pc_first;
  43     db->is_jmp = DISAS_NEXT;
  44     db->num_insns = 0;
  45     db->singlestep_enabled = cpu->singlestep_enabled;
  46
  47     /* Instruction counting */
  48     max_insns = tb_cflags(db->tb) & CF_COUNT_MASK;
  49     if (max_insns == 0) {
  50         max_insns = CF_COUNT_MASK;
  51     }
  52     if (max_insns > TCG_MAX_INSNS) {
  53         max_insns = TCG_MAX_INSNS;
  54     }
  55     if (db->singlestep_enabled || singlestep) {
  56         max_insns = 1;
  57     }
  58
  59     max_insns = ops->init_disas_context(db, cpu, max_insns);
  60     tcg_debug_assert(db->is_jmp == DISAS_NEXT);  /* no early exit */
  61
  62     /* Reset the temp count so that we can identify leaks */
  63     tcg_clear_temp_count();
  64
  65     /* Start translating.  */
  66     gen_tb_start(db->tb);
  67     ops->tb_start(db, cpu);
  68     tcg_debug_assert(db->is_jmp == DISAS_NEXT);  /* no early exit */
  69
  70     while (true) {
  71         db->num_insns++;
  72         ops->insn_start(db, cpu);
  73         tcg_debug_assert(db->is_jmp == DISAS_NEXT);  /* no early exit */
  74
  75         /* Pass breakpoint hits to target for further processing */
  76         if (unlikely(!QTAILQ_EMPTY(&cpu->breakpoints))) {
  77             CPUBreakpoint *bp;
  78             QTAILQ_FOREACH(bp, &cpu->breakpoints, entry) {
  79                 if (bp->pc == db->pc_next) {
  80                     if (ops->breakpoint_check(db, cpu, bp)) {
  81                         break;
  82                     }
  83                 }
  84             }
  85             /* The breakpoint_check hook may use DISAS_TOO_MANY to indicate
  86                that only one more instruction is to be executed.  Otherwise
  87                it should use DISAS_NORETURN when generating an exception,
  88                but may use a DISAS_TARGET_* value for Something Else.  */
  89             if (db->is_jmp > DISAS_TOO_MANY) {
  90                 break;
  91             }
  92         }
  93
  94         /* Disassemble one instruction.  The translate_insn hook should
  95            update db->pc_next and db->is_jmp to indicate what should be
  96            done next -- either exiting this loop or locate the start of
  97            the next instruction.  */
  98         if (db->num_insns == max_insns && (tb_cflags(db->tb) & CF_LAST_IO)) {
  99             /* Accept I/O on the last instruction.  */
 100             gen_io_start();
 101             ops->translate_insn(db, cpu);
 102             gen_io_end();
 103         } else {
 104             ops->translate_insn(db, cpu);
 105         }
 106
 107         /* Stop translation if translate_insn so indicated.  */
 108         if (db->is_jmp != DISAS_NEXT) {
 109             break;
 110         }
 111
 112         /* Stop translation if the output buffer is full,
 113            or we have executed all of the allowed instructions.  */
 114         if (tcg_op_buf_full() || db->num_insns >= max_insns) {
 115             db->is_jmp = DISAS_TOO_MANY;
 116             break;
 117         }
 118     }
 119
 120     /* Emit code to exit the TB, as indicated by db->is_jmp.  */
 121     ops->tb_stop(db, cpu);
 122     gen_tb_end(db->tb, db->num_insns);
 123
 124     /* The disas_log hook may use these values rather than recompute.  */
 125     db->tb->size = db->pc_next - db->pc_first;
 126     db->tb->icount = db->num_insns;
 127
 128 #ifdef DEBUG_DISAS
 129     if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)
 130         && qemu_log_in_addr_range(db->pc_first)) {
 131         qemu_log_lock();
 132         qemu_log("----------------\n");
 133         ops->disas_log(db, cpu);
 134         qemu_log("\n");
 135         qemu_log_unlock();
 136     }
 137 #endif
 138 }