2003-06-15 21:58:51 +02:00
|
|
|
/*
|
|
|
|
* Host code generation
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2003-06-15 21:58:51 +02:00
|
|
|
* Copyright (c) 2003 Fabrice Bellard
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2009-07-16 22:47:01 +02:00
|
|
|
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
2003-06-15 21:58:51 +02:00
|
|
|
*/
|
2012-12-02 17:04:43 +01:00
|
|
|
#ifdef _WIN32
|
|
|
|
#include <windows.h>
|
|
|
|
#else
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/mman.h>
|
|
|
|
#endif
|
2003-06-15 21:58:51 +02:00
|
|
|
#include <stdarg.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <inttypes.h>
|
|
|
|
|
|
|
|
#include "config.h"
|
2003-06-16 01:28:43 +02:00
|
|
|
|
2012-12-02 17:04:43 +01:00
|
|
|
#include "qemu-common.h"
|
2004-01-05 00:28:12 +01:00
|
|
|
#define NO_CPU_IO_DEFS
|
2003-09-30 22:59:51 +02:00
|
|
|
#include "cpu.h"
|
2014-08-01 18:08:57 +02:00
|
|
|
#include "trace.h"
|
2012-10-24 11:12:21 +02:00
|
|
|
#include "disas/disas.h"
|
2008-02-01 11:50:11 +01:00
|
|
|
#include "tcg.h"
|
2012-12-02 17:04:43 +01:00
|
|
|
#if defined(CONFIG_USER_ONLY)
|
|
|
|
#include "qemu.h"
|
|
|
|
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
|
|
|
|
#include <sys/param.h>
|
|
|
|
#if __FreeBSD_version >= 700104
|
|
|
|
#define HAVE_KINFO_GETVMMAP
|
|
|
|
#define sigqueue sigqueue_freebsd /* avoid redefinition */
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/proc.h>
|
|
|
|
#include <machine/profile.h>
|
|
|
|
#define _KERNEL
|
|
|
|
#include <sys/user.h>
|
|
|
|
#undef _KERNEL
|
|
|
|
#undef sigqueue
|
|
|
|
#include <libutil.h>
|
|
|
|
#endif
|
|
|
|
#endif
|
2013-04-08 17:29:59 +02:00
|
|
|
#else
|
|
|
|
#include "exec/address-spaces.h"
|
2012-12-02 17:04:43 +01:00
|
|
|
#endif
|
|
|
|
|
2012-12-17 18:19:49 +01:00
|
|
|
#include "exec/cputlb.h"
|
2015-05-31 08:11:45 +02:00
|
|
|
#include "exec/tb-hash.h"
|
2012-12-02 17:04:43 +01:00
|
|
|
#include "translate-all.h"
|
2015-04-22 23:50:52 +02:00
|
|
|
#include "qemu/bitmap.h"
|
2013-04-22 09:42:50 +02:00
|
|
|
#include "qemu/timer.h"
|
2012-12-02 17:04:43 +01:00
|
|
|
|
|
|
|
//#define DEBUG_TB_INVALIDATE
|
|
|
|
//#define DEBUG_FLUSH
|
|
|
|
/* make various TB consistency checks */
|
|
|
|
//#define DEBUG_TB_CHECK
|
|
|
|
|
|
|
|
#if !defined(CONFIG_USER_ONLY)
|
|
|
|
/* TB consistency checks only implemented for usermode emulation. */
|
|
|
|
#undef DEBUG_TB_CHECK
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define SMC_BITMAP_USE_THRESHOLD 10
|
|
|
|
|
|
|
|
typedef struct PageDesc {
|
|
|
|
/* list of TBs intersecting this ram page */
|
|
|
|
TranslationBlock *first_tb;
|
|
|
|
/* in order to optimize self modifying code, we count the number
|
|
|
|
of lookups we do to a given page to use a bitmap */
|
|
|
|
unsigned int code_write_count;
|
2015-04-22 23:50:52 +02:00
|
|
|
unsigned long *code_bitmap;
|
2012-12-02 17:04:43 +01:00
|
|
|
#if defined(CONFIG_USER_ONLY)
|
|
|
|
unsigned long flags;
|
|
|
|
#endif
|
|
|
|
} PageDesc;
|
|
|
|
|
|
|
|
/* In system mode we want L1_MAP to be based on ram offsets,
|
|
|
|
while in user mode we want it to be based on virtual addresses. */
|
|
|
|
#if !defined(CONFIG_USER_ONLY)
|
|
|
|
#if HOST_LONG_BITS < TARGET_PHYS_ADDR_SPACE_BITS
|
|
|
|
# define L1_MAP_ADDR_SPACE_BITS HOST_LONG_BITS
|
|
|
|
#else
|
|
|
|
# define L1_MAP_ADDR_SPACE_BITS TARGET_PHYS_ADDR_SPACE_BITS
|
|
|
|
#endif
|
|
|
|
#else
|
|
|
|
# define L1_MAP_ADDR_SPACE_BITS TARGET_VIRT_ADDR_SPACE_BITS
|
|
|
|
#endif
|
|
|
|
|
2013-11-07 17:14:36 +01:00
|
|
|
/* Size of the L2 (and L3, etc) page tables. */
|
|
|
|
#define V_L2_BITS 10
|
|
|
|
#define V_L2_SIZE (1 << V_L2_BITS)
|
|
|
|
|
2012-12-02 17:04:43 +01:00
|
|
|
/* The bits remaining after N lower levels of page tables. */
|
|
|
|
#define V_L1_BITS_REM \
|
2013-11-07 17:14:36 +01:00
|
|
|
((L1_MAP_ADDR_SPACE_BITS - TARGET_PAGE_BITS) % V_L2_BITS)
|
2012-12-02 17:04:43 +01:00
|
|
|
|
|
|
|
#if V_L1_BITS_REM < 4
|
2013-11-07 17:14:36 +01:00
|
|
|
#define V_L1_BITS (V_L1_BITS_REM + V_L2_BITS)
|
2012-12-02 17:04:43 +01:00
|
|
|
#else
|
|
|
|
#define V_L1_BITS V_L1_BITS_REM
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define V_L1_SIZE ((target_ulong)1 << V_L1_BITS)
|
|
|
|
|
|
|
|
#define V_L1_SHIFT (L1_MAP_ADDR_SPACE_BITS - TARGET_PAGE_BITS - V_L1_BITS)
|
|
|
|
|
|
|
|
uintptr_t qemu_real_host_page_size;
|
2015-07-06 20:15:12 +02:00
|
|
|
uintptr_t qemu_real_host_page_mask;
|
2012-12-02 17:04:43 +01:00
|
|
|
uintptr_t qemu_host_page_size;
|
|
|
|
uintptr_t qemu_host_page_mask;
|
|
|
|
|
|
|
|
/* This is a multi-level map on the virtual address space.
|
|
|
|
The bottom level has pointers to PageDesc. */
|
|
|
|
static void *l1_map[V_L1_SIZE];
|
|
|
|
|
2008-02-01 11:50:11 +01:00
|
|
|
/* code generation context */
|
|
|
|
TCGContext tcg_ctx;
|
2003-06-15 21:58:51 +02:00
|
|
|
|
2012-12-02 17:04:43 +01:00
|
|
|
static void tb_link_page(TranslationBlock *tb, tb_page_addr_t phys_pc,
|
|
|
|
tb_page_addr_t phys_page2);
|
2012-12-04 21:16:07 +01:00
|
|
|
static TranslationBlock *tb_find_pc(uintptr_t tc_ptr);
|
2012-12-02 17:04:43 +01:00
|
|
|
|
2008-02-01 11:50:11 +01:00
|
|
|
void cpu_gen_init(void)
|
|
|
|
{
|
|
|
|
tcg_context_init(&tcg_ctx);
|
|
|
|
}
|
|
|
|
|
2003-06-15 21:58:51 +02:00
|
|
|
/* return non zero if the very first instruction is invalid so that
|
2007-09-16 23:08:06 +02:00
|
|
|
the virtual CPU can trigger an exception.
|
2003-06-15 21:58:51 +02:00
|
|
|
|
|
|
|
'*gen_code_size_ptr' contains the size of the generated code (host
|
|
|
|
code).
|
|
|
|
*/
|
2012-03-14 01:38:32 +01:00
|
|
|
int cpu_gen_code(CPUArchState *env, TranslationBlock *tb, int *gen_code_size_ptr)
|
2003-06-15 21:58:51 +02:00
|
|
|
{
|
2008-02-01 11:50:11 +01:00
|
|
|
TCGContext *s = &tcg_ctx;
|
2014-03-28 20:56:22 +01:00
|
|
|
tcg_insn_unit *gen_code_buf;
|
2003-06-15 21:58:51 +02:00
|
|
|
int gen_code_size;
|
2008-02-01 11:50:11 +01:00
|
|
|
#ifdef CONFIG_PROFILER
|
|
|
|
int64_t ti;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_PROFILER
|
2008-05-23 11:57:34 +02:00
|
|
|
s->tb_count1++; /* includes aborted translations because of
|
|
|
|
exceptions */
|
2008-02-01 11:50:11 +01:00
|
|
|
ti = profile_getclock();
|
|
|
|
#endif
|
|
|
|
tcg_func_start(s);
|
2003-06-15 21:58:51 +02:00
|
|
|
|
2008-07-18 20:01:29 +02:00
|
|
|
gen_intermediate_code(env, tb);
|
|
|
|
|
2014-08-01 18:08:57 +02:00
|
|
|
trace_translate_block(tb, tb->pc, tb->tc_ptr);
|
|
|
|
|
2007-11-08 15:25:03 +01:00
|
|
|
/* generate machine code */
|
2008-02-01 11:50:11 +01:00
|
|
|
gen_code_buf = tb->tc_ptr;
|
2007-11-08 15:25:03 +01:00
|
|
|
tb->tb_next_offset[0] = 0xffff;
|
|
|
|
tb->tb_next_offset[1] = 0xffff;
|
2008-02-01 11:50:11 +01:00
|
|
|
s->tb_next_offset = tb->tb_next_offset;
|
2003-09-18 00:53:29 +02:00
|
|
|
#ifdef USE_DIRECT_JUMP
|
2008-02-01 11:50:11 +01:00
|
|
|
s->tb_jmp_offset = tb->tb_jmp_offset;
|
|
|
|
s->tb_next = NULL;
|
2003-06-15 21:58:51 +02:00
|
|
|
#else
|
2008-02-01 11:50:11 +01:00
|
|
|
s->tb_jmp_offset = NULL;
|
|
|
|
s->tb_next = tb->tb_next;
|
2003-06-15 21:58:51 +02:00
|
|
|
#endif
|
2008-02-01 11:50:11 +01:00
|
|
|
|
|
|
|
#ifdef CONFIG_PROFILER
|
2008-05-23 11:57:34 +02:00
|
|
|
s->tb_count++;
|
|
|
|
s->interm_time += profile_getclock() - ti;
|
|
|
|
s->code_time -= profile_getclock();
|
2008-02-01 11:50:11 +01:00
|
|
|
#endif
|
2008-12-07 21:35:00 +01:00
|
|
|
gen_code_size = tcg_gen_code(s, gen_code_buf);
|
2003-06-15 21:58:51 +02:00
|
|
|
*gen_code_size_ptr = gen_code_size;
|
2008-02-01 11:50:11 +01:00
|
|
|
#ifdef CONFIG_PROFILER
|
2008-05-23 11:57:34 +02:00
|
|
|
s->code_time += profile_getclock();
|
|
|
|
s->code_in_len += tb->size;
|
|
|
|
s->code_out_len += gen_code_size;
|
2008-02-01 11:50:11 +01:00
|
|
|
#endif
|
|
|
|
|
2003-06-15 21:58:51 +02:00
|
|
|
#ifdef DEBUG_DISAS
|
2009-01-15 23:36:53 +01:00
|
|
|
if (qemu_loglevel_mask(CPU_LOG_TB_OUT_ASM)) {
|
2014-03-28 20:56:22 +01:00
|
|
|
qemu_log("OUT: [size=%d]\n", gen_code_size);
|
|
|
|
log_disas(tb->tc_ptr, gen_code_size);
|
2009-01-15 23:34:14 +01:00
|
|
|
qemu_log("\n");
|
2009-01-15 23:35:09 +01:00
|
|
|
qemu_log_flush();
|
2003-06-15 21:58:51 +02:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-16 23:08:06 +02:00
|
|
|
/* The cpu state corresponding to 'searched_pc' is restored.
|
2003-06-15 21:58:51 +02:00
|
|
|
*/
|
2013-09-01 17:02:58 +02:00
|
|
|
static int cpu_restore_state_from_tb(CPUState *cpu, TranslationBlock *tb,
|
2012-12-04 21:16:07 +01:00
|
|
|
uintptr_t searched_pc)
|
2003-06-15 21:58:51 +02:00
|
|
|
{
|
2013-09-01 17:02:58 +02:00
|
|
|
CPUArchState *env = cpu->env_ptr;
|
2008-02-01 11:50:11 +01:00
|
|
|
TCGContext *s = &tcg_ctx;
|
|
|
|
int j;
|
2012-04-06 22:26:15 +02:00
|
|
|
uintptr_t tc_ptr;
|
2008-02-01 11:50:11 +01:00
|
|
|
#ifdef CONFIG_PROFILER
|
|
|
|
int64_t ti;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_PROFILER
|
|
|
|
ti = profile_getclock();
|
|
|
|
#endif
|
|
|
|
tcg_func_start(s);
|
2003-06-15 21:58:51 +02:00
|
|
|
|
2008-07-18 20:01:29 +02:00
|
|
|
gen_intermediate_code_pc(env, tb);
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2014-11-26 11:39:59 +01:00
|
|
|
if (tb->cflags & CF_USE_ICOUNT) {
|
2008-06-29 03:03:05 +02:00
|
|
|
/* Reset the cycle counter to the start of the block. */
|
2013-08-26 05:51:49 +02:00
|
|
|
cpu->icount_decr.u16.low += tb->icount;
|
2008-06-29 03:03:05 +02:00
|
|
|
/* Clear the IO flag. */
|
2013-08-26 05:15:23 +02:00
|
|
|
cpu->can_do_io = 0;
|
2008-06-29 03:03:05 +02:00
|
|
|
}
|
|
|
|
|
2003-06-15 21:58:51 +02:00
|
|
|
/* find opc index corresponding to search_pc */
|
2012-04-06 22:26:15 +02:00
|
|
|
tc_ptr = (uintptr_t)tb->tc_ptr;
|
2003-06-15 21:58:51 +02:00
|
|
|
if (searched_pc < tc_ptr)
|
|
|
|
return -1;
|
2008-02-01 11:50:11 +01:00
|
|
|
|
|
|
|
s->tb_next_offset = tb->tb_next_offset;
|
|
|
|
#ifdef USE_DIRECT_JUMP
|
|
|
|
s->tb_jmp_offset = tb->tb_jmp_offset;
|
|
|
|
s->tb_next = NULL;
|
|
|
|
#else
|
|
|
|
s->tb_jmp_offset = NULL;
|
|
|
|
s->tb_next = tb->tb_next;
|
|
|
|
#endif
|
2014-03-28 20:56:22 +01:00
|
|
|
j = tcg_gen_code_search_pc(s, (tcg_insn_unit *)tc_ptr,
|
|
|
|
searched_pc - tc_ptr);
|
2008-02-01 11:50:11 +01:00
|
|
|
if (j < 0)
|
|
|
|
return -1;
|
2003-06-15 21:58:51 +02:00
|
|
|
/* now find start of instruction before */
|
2012-11-21 08:43:06 +01:00
|
|
|
while (s->gen_opc_instr_start[j] == 0) {
|
2003-06-15 21:58:51 +02:00
|
|
|
j--;
|
2012-11-21 08:43:06 +01:00
|
|
|
}
|
2013-08-26 05:51:49 +02:00
|
|
|
cpu->icount_decr.u16.low -= s->gen_opc_icount[j];
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2011-04-18 08:39:52 +02:00
|
|
|
restore_state_to_opc(env, tb, j);
|
2008-02-01 11:50:11 +01:00
|
|
|
|
|
|
|
#ifdef CONFIG_PROFILER
|
2008-05-23 11:57:34 +02:00
|
|
|
s->restore_time += profile_getclock() - ti;
|
|
|
|
s->restore_count++;
|
2008-02-01 11:50:11 +01:00
|
|
|
#endif
|
2003-06-15 21:58:51 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2012-12-02 17:04:43 +01:00
|
|
|
|
2013-09-01 16:51:34 +02:00
|
|
|
bool cpu_restore_state(CPUState *cpu, uintptr_t retaddr)
|
2012-12-04 21:16:07 +01:00
|
|
|
{
|
|
|
|
TranslationBlock *tb;
|
|
|
|
|
|
|
|
tb = tb_find_pc(retaddr);
|
|
|
|
if (tb) {
|
2013-09-01 17:02:58 +02:00
|
|
|
cpu_restore_state_from_tb(cpu, tb, retaddr);
|
2014-11-26 11:40:16 +01:00
|
|
|
if (tb->cflags & CF_NOCACHE) {
|
|
|
|
/* one-shot translation, invalidate it immediately */
|
|
|
|
cpu->current_tb = NULL;
|
|
|
|
tb_phys_invalidate(tb, -1);
|
|
|
|
tb_free(tb);
|
|
|
|
}
|
2012-12-04 21:16:07 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-12-02 17:04:43 +01:00
|
|
|
#ifdef _WIN32
|
2014-12-23 23:26:54 +01:00
|
|
|
static __attribute__((unused)) void map_exec(void *addr, long size)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
|
|
|
DWORD old_protect;
|
|
|
|
VirtualProtect(addr, size,
|
|
|
|
PAGE_EXECUTE_READWRITE, &old_protect);
|
|
|
|
}
|
|
|
|
#else
|
2014-12-23 23:26:54 +01:00
|
|
|
static __attribute__((unused)) void map_exec(void *addr, long size)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
|
|
|
unsigned long start, end, page_size;
|
|
|
|
|
|
|
|
page_size = getpagesize();
|
|
|
|
start = (unsigned long)addr;
|
|
|
|
start &= ~(page_size - 1);
|
|
|
|
|
|
|
|
end = (unsigned long)addr + size;
|
|
|
|
end += page_size - 1;
|
|
|
|
end &= ~(page_size - 1);
|
|
|
|
|
|
|
|
mprotect((void *)start, end - start,
|
|
|
|
PROT_READ | PROT_WRITE | PROT_EXEC);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-01-17 19:12:07 +01:00
|
|
|
void page_size_init(void)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
|
|
|
/* NOTE: we can always suppose that qemu_host_page_size >=
|
|
|
|
TARGET_PAGE_SIZE */
|
|
|
|
qemu_real_host_page_size = getpagesize();
|
2015-07-06 20:15:12 +02:00
|
|
|
qemu_real_host_page_mask = ~(qemu_real_host_page_size - 1);
|
2012-12-02 17:04:43 +01:00
|
|
|
if (qemu_host_page_size == 0) {
|
|
|
|
qemu_host_page_size = qemu_real_host_page_size;
|
|
|
|
}
|
|
|
|
if (qemu_host_page_size < TARGET_PAGE_SIZE) {
|
|
|
|
qemu_host_page_size = TARGET_PAGE_SIZE;
|
|
|
|
}
|
|
|
|
qemu_host_page_mask = ~(qemu_host_page_size - 1);
|
2014-01-17 19:12:07 +01:00
|
|
|
}
|
2012-12-02 17:04:43 +01:00
|
|
|
|
2014-01-17 19:12:07 +01:00
|
|
|
static void page_init(void)
|
|
|
|
{
|
|
|
|
page_size_init();
|
2012-12-02 17:04:43 +01:00
|
|
|
#if defined(CONFIG_BSD) && defined(CONFIG_USER_ONLY)
|
|
|
|
{
|
|
|
|
#ifdef HAVE_KINFO_GETVMMAP
|
|
|
|
struct kinfo_vmentry *freep;
|
|
|
|
int i, cnt;
|
|
|
|
|
|
|
|
freep = kinfo_getvmmap(getpid(), &cnt);
|
|
|
|
if (freep) {
|
|
|
|
mmap_lock();
|
|
|
|
for (i = 0; i < cnt; i++) {
|
|
|
|
unsigned long startaddr, endaddr;
|
|
|
|
|
|
|
|
startaddr = freep[i].kve_start;
|
|
|
|
endaddr = freep[i].kve_end;
|
|
|
|
if (h2g_valid(startaddr)) {
|
|
|
|
startaddr = h2g(startaddr) & TARGET_PAGE_MASK;
|
|
|
|
|
|
|
|
if (h2g_valid(endaddr)) {
|
|
|
|
endaddr = h2g(endaddr);
|
|
|
|
page_set_flags(startaddr, endaddr, PAGE_RESERVED);
|
|
|
|
} else {
|
|
|
|
#if TARGET_ABI_BITS <= L1_MAP_ADDR_SPACE_BITS
|
|
|
|
endaddr = ~0ul;
|
|
|
|
page_set_flags(startaddr, endaddr, PAGE_RESERVED);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(freep);
|
|
|
|
mmap_unlock();
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
FILE *f;
|
|
|
|
|
|
|
|
last_brk = (unsigned long)sbrk(0);
|
|
|
|
|
|
|
|
f = fopen("/compat/linux/proc/self/maps", "r");
|
|
|
|
if (f) {
|
|
|
|
mmap_lock();
|
|
|
|
|
|
|
|
do {
|
|
|
|
unsigned long startaddr, endaddr;
|
|
|
|
int n;
|
|
|
|
|
|
|
|
n = fscanf(f, "%lx-%lx %*[^\n]\n", &startaddr, &endaddr);
|
|
|
|
|
|
|
|
if (n == 2 && h2g_valid(startaddr)) {
|
|
|
|
startaddr = h2g(startaddr) & TARGET_PAGE_MASK;
|
|
|
|
|
|
|
|
if (h2g_valid(endaddr)) {
|
|
|
|
endaddr = h2g(endaddr);
|
|
|
|
} else {
|
|
|
|
endaddr = ~0ul;
|
|
|
|
}
|
|
|
|
page_set_flags(startaddr, endaddr, PAGE_RESERVED);
|
|
|
|
}
|
|
|
|
} while (!feof(f));
|
|
|
|
|
|
|
|
fclose(f);
|
|
|
|
mmap_unlock();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static PageDesc *page_find_alloc(tb_page_addr_t index, int alloc)
|
|
|
|
{
|
|
|
|
PageDesc *pd;
|
|
|
|
void **lp;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Level 1. Always allocated. */
|
|
|
|
lp = l1_map + ((index >> V_L1_SHIFT) & (V_L1_SIZE - 1));
|
|
|
|
|
|
|
|
/* Level 2..N-1. */
|
2013-11-07 17:14:36 +01:00
|
|
|
for (i = V_L1_SHIFT / V_L2_BITS - 1; i > 0; i--) {
|
2012-12-02 17:04:43 +01:00
|
|
|
void **p = *lp;
|
|
|
|
|
|
|
|
if (p == NULL) {
|
|
|
|
if (!alloc) {
|
|
|
|
return NULL;
|
|
|
|
}
|
2015-04-09 22:07:33 +02:00
|
|
|
p = g_new0(void *, V_L2_SIZE);
|
2012-12-02 17:04:43 +01:00
|
|
|
*lp = p;
|
|
|
|
}
|
|
|
|
|
2013-11-07 17:14:36 +01:00
|
|
|
lp = p + ((index >> (i * V_L2_BITS)) & (V_L2_SIZE - 1));
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
pd = *lp;
|
|
|
|
if (pd == NULL) {
|
|
|
|
if (!alloc) {
|
|
|
|
return NULL;
|
|
|
|
}
|
2015-04-09 22:07:33 +02:00
|
|
|
pd = g_new0(PageDesc, V_L2_SIZE);
|
2012-12-02 17:04:43 +01:00
|
|
|
*lp = pd;
|
|
|
|
}
|
|
|
|
|
2013-11-07 17:14:36 +01:00
|
|
|
return pd + (index & (V_L2_SIZE - 1));
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline PageDesc *page_find(tb_page_addr_t index)
|
|
|
|
{
|
|
|
|
return page_find_alloc(index, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if !defined(CONFIG_USER_ONLY)
|
|
|
|
#define mmap_lock() do { } while (0)
|
|
|
|
#define mmap_unlock() do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(CONFIG_USER_ONLY)
|
|
|
|
/* Currently it is not recommended to allocate big chunks of data in
|
|
|
|
user mode. It will change when a dedicated libc will be used. */
|
|
|
|
/* ??? 64-bit hosts ought to have no problem mmaping data outside the
|
|
|
|
region in which the guest needs to run. Revisit this. */
|
|
|
|
#define USE_STATIC_CODE_GEN_BUFFER
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* ??? Should configure for this, not list operating systems here. */
|
|
|
|
#if (defined(__linux__) \
|
|
|
|
|| defined(__FreeBSD__) || defined(__FreeBSD_kernel__) \
|
|
|
|
|| defined(__DragonFly__) || defined(__OpenBSD__) \
|
|
|
|
|| defined(__NetBSD__))
|
|
|
|
# define USE_MMAP
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Minimum size of the code gen buffer. This number is randomly chosen,
|
|
|
|
but not so small that we can't have a fair number of TB's live. */
|
|
|
|
#define MIN_CODE_GEN_BUFFER_SIZE (1024u * 1024)
|
|
|
|
|
|
|
|
/* Maximum size of the code gen buffer we'd like to use. Unless otherwise
|
|
|
|
indicated, this is constrained by the range of direct branches on the
|
|
|
|
host cpu, as used by the TCG implementation of goto_tb. */
|
|
|
|
#if defined(__x86_64__)
|
|
|
|
# define MAX_CODE_GEN_BUFFER_SIZE (2ul * 1024 * 1024 * 1024)
|
|
|
|
#elif defined(__sparc__)
|
|
|
|
# define MAX_CODE_GEN_BUFFER_SIZE (2ul * 1024 * 1024 * 1024)
|
2013-06-12 17:20:22 +02:00
|
|
|
#elif defined(__aarch64__)
|
|
|
|
# define MAX_CODE_GEN_BUFFER_SIZE (128ul * 1024 * 1024)
|
2012-12-02 17:04:43 +01:00
|
|
|
#elif defined(__arm__)
|
|
|
|
# define MAX_CODE_GEN_BUFFER_SIZE (16u * 1024 * 1024)
|
|
|
|
#elif defined(__s390x__)
|
|
|
|
/* We have a +- 4GB range on the branches; leave some slop. */
|
|
|
|
# define MAX_CODE_GEN_BUFFER_SIZE (3ul * 1024 * 1024 * 1024)
|
2014-04-24 17:25:03 +02:00
|
|
|
#elif defined(__mips__)
|
|
|
|
/* We have a 256MB branch region, but leave room to make sure the
|
|
|
|
main executable is also within that region. */
|
|
|
|
# define MAX_CODE_GEN_BUFFER_SIZE (128ul * 1024 * 1024)
|
2012-12-02 17:04:43 +01:00
|
|
|
#else
|
|
|
|
# define MAX_CODE_GEN_BUFFER_SIZE ((size_t)-1)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define DEFAULT_CODE_GEN_BUFFER_SIZE_1 (32u * 1024 * 1024)
|
|
|
|
|
|
|
|
#define DEFAULT_CODE_GEN_BUFFER_SIZE \
|
|
|
|
(DEFAULT_CODE_GEN_BUFFER_SIZE_1 < MAX_CODE_GEN_BUFFER_SIZE \
|
|
|
|
? DEFAULT_CODE_GEN_BUFFER_SIZE_1 : MAX_CODE_GEN_BUFFER_SIZE)
|
|
|
|
|
|
|
|
static inline size_t size_code_gen_buffer(size_t tb_size)
|
|
|
|
{
|
|
|
|
/* Size the buffer. */
|
|
|
|
if (tb_size == 0) {
|
|
|
|
#ifdef USE_STATIC_CODE_GEN_BUFFER
|
|
|
|
tb_size = DEFAULT_CODE_GEN_BUFFER_SIZE;
|
|
|
|
#else
|
|
|
|
/* ??? Needs adjustments. */
|
|
|
|
/* ??? If we relax the requirement that CONFIG_USER_ONLY use the
|
|
|
|
static buffer, we could size this on RESERVED_VA, on the text
|
|
|
|
segment size of the executable, or continue to use the default. */
|
|
|
|
tb_size = (unsigned long)(ram_size / 4);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
if (tb_size < MIN_CODE_GEN_BUFFER_SIZE) {
|
|
|
|
tb_size = MIN_CODE_GEN_BUFFER_SIZE;
|
|
|
|
}
|
|
|
|
if (tb_size > MAX_CODE_GEN_BUFFER_SIZE) {
|
|
|
|
tb_size = MAX_CODE_GEN_BUFFER_SIZE;
|
|
|
|
}
|
2013-01-31 19:47:22 +01:00
|
|
|
tcg_ctx.code_gen_buffer_size = tb_size;
|
2012-12-02 17:04:43 +01:00
|
|
|
return tb_size;
|
|
|
|
}
|
|
|
|
|
2014-04-24 18:16:07 +02:00
|
|
|
#ifdef __mips__
|
|
|
|
/* In order to use J and JAL within the code_gen_buffer, we require
|
|
|
|
that the buffer not cross a 256MB boundary. */
|
|
|
|
static inline bool cross_256mb(void *addr, size_t size)
|
|
|
|
{
|
|
|
|
return ((uintptr_t)addr ^ ((uintptr_t)addr + size)) & 0xf0000000;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We weren't able to allocate a buffer without crossing that boundary,
|
|
|
|
so make do with the larger portion of the buffer that doesn't cross.
|
|
|
|
Returns the new base of the buffer, and adjusts code_gen_buffer_size. */
|
|
|
|
static inline void *split_cross_256mb(void *buf1, size_t size1)
|
|
|
|
{
|
|
|
|
void *buf2 = (void *)(((uintptr_t)buf1 + size1) & 0xf0000000);
|
|
|
|
size_t size2 = buf1 + size1 - buf2;
|
|
|
|
|
|
|
|
size1 = buf2 - buf1;
|
|
|
|
if (size1 < size2) {
|
|
|
|
size1 = size2;
|
|
|
|
buf1 = buf2;
|
|
|
|
}
|
|
|
|
|
|
|
|
tcg_ctx.code_gen_buffer_size = size1;
|
|
|
|
return buf1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-12-02 17:04:43 +01:00
|
|
|
#ifdef USE_STATIC_CODE_GEN_BUFFER
|
|
|
|
static uint8_t static_code_gen_buffer[DEFAULT_CODE_GEN_BUFFER_SIZE]
|
|
|
|
__attribute__((aligned(CODE_GEN_ALIGN)));
|
|
|
|
|
|
|
|
static inline void *alloc_code_gen_buffer(void)
|
|
|
|
{
|
2014-04-24 18:16:07 +02:00
|
|
|
void *buf = static_code_gen_buffer;
|
|
|
|
#ifdef __mips__
|
|
|
|
if (cross_256mb(buf, tcg_ctx.code_gen_buffer_size)) {
|
|
|
|
buf = split_cross_256mb(buf, tcg_ctx.code_gen_buffer_size);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
map_exec(buf, tcg_ctx.code_gen_buffer_size);
|
|
|
|
return buf;
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
#elif defined(USE_MMAP)
|
|
|
|
static inline void *alloc_code_gen_buffer(void)
|
|
|
|
{
|
|
|
|
int flags = MAP_PRIVATE | MAP_ANONYMOUS;
|
|
|
|
uintptr_t start = 0;
|
|
|
|
void *buf;
|
|
|
|
|
|
|
|
/* Constrain the position of the buffer based on the host cpu.
|
|
|
|
Note that these addresses are chosen in concert with the
|
|
|
|
addresses assigned in the relevant linker script file. */
|
|
|
|
# if defined(__PIE__) || defined(__PIC__)
|
|
|
|
/* Don't bother setting a preferred location if we're building
|
|
|
|
a position-independent executable. We're more likely to get
|
|
|
|
an address near the main executable if we let the kernel
|
|
|
|
choose the address. */
|
|
|
|
# elif defined(__x86_64__) && defined(MAP_32BIT)
|
|
|
|
/* Force the memory down into low memory with the executable.
|
|
|
|
Leave the choice of exact location with the kernel. */
|
|
|
|
flags |= MAP_32BIT;
|
|
|
|
/* Cannot expect to map more than 800MB in low memory. */
|
2013-01-31 19:47:22 +01:00
|
|
|
if (tcg_ctx.code_gen_buffer_size > 800u * 1024 * 1024) {
|
|
|
|
tcg_ctx.code_gen_buffer_size = 800u * 1024 * 1024;
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
# elif defined(__sparc__)
|
|
|
|
start = 0x40000000ul;
|
|
|
|
# elif defined(__s390x__)
|
|
|
|
start = 0x90000000ul;
|
2014-04-24 17:25:03 +02:00
|
|
|
# elif defined(__mips__)
|
|
|
|
/* ??? We ought to more explicitly manage layout for softmmu too. */
|
|
|
|
# ifdef CONFIG_USER_ONLY
|
|
|
|
start = 0x68000000ul;
|
|
|
|
# elif _MIPS_SIM == _ABI64
|
|
|
|
start = 0x128000000ul;
|
|
|
|
# else
|
|
|
|
start = 0x08000000ul;
|
|
|
|
# endif
|
2012-12-02 17:04:43 +01:00
|
|
|
# endif
|
|
|
|
|
2013-01-31 19:47:22 +01:00
|
|
|
buf = mmap((void *)start, tcg_ctx.code_gen_buffer_size,
|
2012-12-02 17:04:43 +01:00
|
|
|
PROT_WRITE | PROT_READ | PROT_EXEC, flags, -1, 0);
|
2014-04-24 18:16:07 +02:00
|
|
|
if (buf == MAP_FAILED) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef __mips__
|
|
|
|
if (cross_256mb(buf, tcg_ctx.code_gen_buffer_size)) {
|
2014-06-13 20:42:57 +02:00
|
|
|
/* Try again, with the original still mapped, to avoid re-acquiring
|
2014-04-24 18:16:07 +02:00
|
|
|
that 256mb crossing. This time don't specify an address. */
|
|
|
|
size_t size2, size1 = tcg_ctx.code_gen_buffer_size;
|
|
|
|
void *buf2 = mmap(NULL, size1, PROT_WRITE | PROT_READ | PROT_EXEC,
|
|
|
|
flags, -1, 0);
|
|
|
|
if (buf2 != MAP_FAILED) {
|
|
|
|
if (!cross_256mb(buf2, size1)) {
|
|
|
|
/* Success! Use the new buffer. */
|
|
|
|
munmap(buf, size1);
|
|
|
|
return buf2;
|
|
|
|
}
|
|
|
|
/* Failure. Work with what we had. */
|
|
|
|
munmap(buf2, size1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Split the original buffer. Free the smaller half. */
|
|
|
|
buf2 = split_cross_256mb(buf, size1);
|
|
|
|
size2 = tcg_ctx.code_gen_buffer_size;
|
|
|
|
munmap(buf + (buf == buf2 ? size2 : 0), size1 - size2);
|
|
|
|
return buf2;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return buf;
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void *alloc_code_gen_buffer(void)
|
|
|
|
{
|
2015-02-04 11:26:07 +01:00
|
|
|
void *buf = g_try_malloc(tcg_ctx.code_gen_buffer_size);
|
2012-12-02 17:04:43 +01:00
|
|
|
|
2014-04-24 18:16:07 +02:00
|
|
|
if (buf == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef __mips__
|
|
|
|
if (cross_256mb(buf, tcg_ctx.code_gen_buffer_size)) {
|
|
|
|
void *buf2 = g_malloc(tcg_ctx.code_gen_buffer_size);
|
|
|
|
if (buf2 != NULL && !cross_256mb(buf2, size1)) {
|
|
|
|
/* Success! Use the new buffer. */
|
|
|
|
free(buf);
|
|
|
|
buf = buf2;
|
|
|
|
} else {
|
|
|
|
/* Failure. Work with what we had. Since this is malloc
|
|
|
|
and not mmap, we can't free the other half. */
|
|
|
|
free(buf2);
|
|
|
|
buf = split_cross_256mb(buf, tcg_ctx.code_gen_buffer_size);
|
|
|
|
}
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
2014-04-24 18:16:07 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
map_exec(buf, tcg_ctx.code_gen_buffer_size);
|
2012-12-02 17:04:43 +01:00
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
#endif /* USE_STATIC_CODE_GEN_BUFFER, USE_MMAP */
|
|
|
|
|
|
|
|
static inline void code_gen_alloc(size_t tb_size)
|
|
|
|
{
|
2013-01-31 19:47:22 +01:00
|
|
|
tcg_ctx.code_gen_buffer_size = size_code_gen_buffer(tb_size);
|
|
|
|
tcg_ctx.code_gen_buffer = alloc_code_gen_buffer();
|
|
|
|
if (tcg_ctx.code_gen_buffer == NULL) {
|
2012-12-02 17:04:43 +01:00
|
|
|
fprintf(stderr, "Could not allocate dynamic translator buffer\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2013-01-31 19:47:22 +01:00
|
|
|
qemu_madvise(tcg_ctx.code_gen_buffer, tcg_ctx.code_gen_buffer_size,
|
|
|
|
QEMU_MADV_HUGEPAGE);
|
2012-12-02 17:04:43 +01:00
|
|
|
|
|
|
|
/* Steal room for the prologue at the end of the buffer. This ensures
|
|
|
|
(via the MAX_CODE_GEN_BUFFER_SIZE limits above) that direct branches
|
|
|
|
from TB's to the prologue are going to be in range. It also means
|
|
|
|
that we don't need to mark (additional) portions of the data segment
|
|
|
|
as executable. */
|
2013-01-31 19:47:22 +01:00
|
|
|
tcg_ctx.code_gen_prologue = tcg_ctx.code_gen_buffer +
|
|
|
|
tcg_ctx.code_gen_buffer_size - 1024;
|
|
|
|
tcg_ctx.code_gen_buffer_size -= 1024;
|
2012-12-02 17:04:43 +01:00
|
|
|
|
2013-01-31 19:47:22 +01:00
|
|
|
tcg_ctx.code_gen_buffer_max_size = tcg_ctx.code_gen_buffer_size -
|
2012-12-02 17:04:43 +01:00
|
|
|
(TCG_MAX_OP_SIZE * OPC_BUF_SIZE);
|
2013-01-31 19:47:22 +01:00
|
|
|
tcg_ctx.code_gen_max_blocks = tcg_ctx.code_gen_buffer_size /
|
|
|
|
CODE_GEN_AVG_BLOCK_SIZE;
|
2013-01-31 19:47:23 +01:00
|
|
|
tcg_ctx.tb_ctx.tbs =
|
|
|
|
g_malloc(tcg_ctx.code_gen_max_blocks * sizeof(TranslationBlock));
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Must be called before using the QEMU cpus. 'tb_size' is the size
|
|
|
|
(in bytes) allocated to the translation buffer. Zero means default
|
|
|
|
size. */
|
|
|
|
void tcg_exec_init(unsigned long tb_size)
|
|
|
|
{
|
|
|
|
cpu_gen_init();
|
|
|
|
code_gen_alloc(tb_size);
|
2013-01-31 19:47:22 +01:00
|
|
|
tcg_ctx.code_gen_ptr = tcg_ctx.code_gen_buffer;
|
|
|
|
tcg_register_jit(tcg_ctx.code_gen_buffer, tcg_ctx.code_gen_buffer_size);
|
2012-12-02 17:04:43 +01:00
|
|
|
page_init();
|
|
|
|
#if !defined(CONFIG_USER_ONLY) || !defined(CONFIG_USE_GUEST_BASE)
|
|
|
|
/* There's no guest base to take into account, so go ahead and
|
|
|
|
initialize the prologue now. */
|
|
|
|
tcg_prologue_init(&tcg_ctx);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
bool tcg_enabled(void)
|
|
|
|
{
|
2013-01-31 19:47:22 +01:00
|
|
|
return tcg_ctx.code_gen_buffer != NULL;
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate a new translation block. Flush the translation buffer if
|
|
|
|
too many translation blocks or too much generated code. */
|
|
|
|
static TranslationBlock *tb_alloc(target_ulong pc)
|
|
|
|
{
|
|
|
|
TranslationBlock *tb;
|
|
|
|
|
2013-01-31 19:47:23 +01:00
|
|
|
if (tcg_ctx.tb_ctx.nb_tbs >= tcg_ctx.code_gen_max_blocks ||
|
2013-01-31 19:47:22 +01:00
|
|
|
(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer) >=
|
|
|
|
tcg_ctx.code_gen_buffer_max_size) {
|
2012-12-02 17:04:43 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
2013-01-31 19:47:23 +01:00
|
|
|
tb = &tcg_ctx.tb_ctx.tbs[tcg_ctx.tb_ctx.nb_tbs++];
|
2012-12-02 17:04:43 +01:00
|
|
|
tb->pc = pc;
|
|
|
|
tb->cflags = 0;
|
|
|
|
return tb;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tb_free(TranslationBlock *tb)
|
|
|
|
{
|
|
|
|
/* In practice this is mostly used for single use temporary TB
|
|
|
|
Ignore the hard cases and just back up if this TB happens to
|
|
|
|
be the last one generated. */
|
2013-01-31 19:47:23 +01:00
|
|
|
if (tcg_ctx.tb_ctx.nb_tbs > 0 &&
|
|
|
|
tb == &tcg_ctx.tb_ctx.tbs[tcg_ctx.tb_ctx.nb_tbs - 1]) {
|
2013-01-31 19:47:22 +01:00
|
|
|
tcg_ctx.code_gen_ptr = tb->tc_ptr;
|
2013-01-31 19:47:23 +01:00
|
|
|
tcg_ctx.tb_ctx.nb_tbs--;
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void invalidate_page_bitmap(PageDesc *p)
|
|
|
|
{
|
|
|
|
if (p->code_bitmap) {
|
|
|
|
g_free(p->code_bitmap);
|
|
|
|
p->code_bitmap = NULL;
|
|
|
|
}
|
|
|
|
p->code_write_count = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set to NULL all the 'first_tb' fields in all PageDescs. */
|
|
|
|
static void page_flush_tb_1(int level, void **lp)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (*lp == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (level == 0) {
|
|
|
|
PageDesc *pd = *lp;
|
|
|
|
|
2013-11-07 17:14:36 +01:00
|
|
|
for (i = 0; i < V_L2_SIZE; ++i) {
|
2012-12-02 17:04:43 +01:00
|
|
|
pd[i].first_tb = NULL;
|
|
|
|
invalidate_page_bitmap(pd + i);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
void **pp = *lp;
|
|
|
|
|
2013-11-07 17:14:36 +01:00
|
|
|
for (i = 0; i < V_L2_SIZE; ++i) {
|
2012-12-02 17:04:43 +01:00
|
|
|
page_flush_tb_1(level - 1, pp + i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void page_flush_tb(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < V_L1_SIZE; i++) {
|
2013-11-07 17:14:36 +01:00
|
|
|
page_flush_tb_1(V_L1_SHIFT / V_L2_BITS - 1, l1_map + i);
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* flush all the translation blocks */
|
|
|
|
/* XXX: tb_flush is currently not thread safe */
|
|
|
|
void tb_flush(CPUArchState *env1)
|
|
|
|
{
|
2013-09-03 17:38:47 +02:00
|
|
|
CPUState *cpu = ENV_GET_CPU(env1);
|
2012-12-02 17:04:43 +01:00
|
|
|
|
|
|
|
#if defined(DEBUG_FLUSH)
|
|
|
|
printf("qemu: flush code_size=%ld nb_tbs=%d avg_tb_size=%ld\n",
|
2013-01-31 19:47:22 +01:00
|
|
|
(unsigned long)(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer),
|
2013-01-31 19:47:23 +01:00
|
|
|
tcg_ctx.tb_ctx.nb_tbs, tcg_ctx.tb_ctx.nb_tbs > 0 ?
|
2013-01-31 19:47:22 +01:00
|
|
|
((unsigned long)(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer)) /
|
2013-01-31 19:47:23 +01:00
|
|
|
tcg_ctx.tb_ctx.nb_tbs : 0);
|
2012-12-02 17:04:43 +01:00
|
|
|
#endif
|
2013-01-31 19:47:22 +01:00
|
|
|
if ((unsigned long)(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer)
|
|
|
|
> tcg_ctx.code_gen_buffer_size) {
|
2013-09-03 17:38:47 +02:00
|
|
|
cpu_abort(cpu, "Internal error: code buffer overflow\n");
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
2013-01-31 19:47:23 +01:00
|
|
|
tcg_ctx.tb_ctx.nb_tbs = 0;
|
2012-12-02 17:04:43 +01:00
|
|
|
|
2013-06-24 23:50:24 +02:00
|
|
|
CPU_FOREACH(cpu) {
|
2013-08-26 06:03:38 +02:00
|
|
|
memset(cpu->tb_jmp_cache, 0, sizeof(cpu->tb_jmp_cache));
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
|
2013-12-06 22:44:52 +01:00
|
|
|
memset(tcg_ctx.tb_ctx.tb_phys_hash, 0, sizeof(tcg_ctx.tb_ctx.tb_phys_hash));
|
2012-12-02 17:04:43 +01:00
|
|
|
page_flush_tb();
|
|
|
|
|
2013-01-31 19:47:22 +01:00
|
|
|
tcg_ctx.code_gen_ptr = tcg_ctx.code_gen_buffer;
|
2012-12-02 17:04:43 +01:00
|
|
|
/* XXX: flush processor icache at this point if cache flush is
|
|
|
|
expensive */
|
2013-01-31 19:47:23 +01:00
|
|
|
tcg_ctx.tb_ctx.tb_flush_count++;
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUG_TB_CHECK
|
|
|
|
|
|
|
|
static void tb_invalidate_check(target_ulong address)
|
|
|
|
{
|
|
|
|
TranslationBlock *tb;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
address &= TARGET_PAGE_MASK;
|
|
|
|
for (i = 0; i < CODE_GEN_PHYS_HASH_SIZE; i++) {
|
2013-01-31 19:47:23 +01:00
|
|
|
for (tb = tb_ctx.tb_phys_hash[i]; tb != NULL; tb = tb->phys_hash_next) {
|
2012-12-02 17:04:43 +01:00
|
|
|
if (!(address + TARGET_PAGE_SIZE <= tb->pc ||
|
|
|
|
address >= tb->pc + tb->size)) {
|
|
|
|
printf("ERROR invalidate: address=" TARGET_FMT_lx
|
|
|
|
" PC=%08lx size=%04x\n",
|
|
|
|
address, (long)tb->pc, tb->size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* verify that all the pages have correct rights for code */
|
|
|
|
static void tb_page_check(void)
|
|
|
|
{
|
|
|
|
TranslationBlock *tb;
|
|
|
|
int i, flags1, flags2;
|
|
|
|
|
|
|
|
for (i = 0; i < CODE_GEN_PHYS_HASH_SIZE; i++) {
|
2013-01-31 19:47:23 +01:00
|
|
|
for (tb = tcg_ctx.tb_ctx.tb_phys_hash[i]; tb != NULL;
|
|
|
|
tb = tb->phys_hash_next) {
|
2012-12-02 17:04:43 +01:00
|
|
|
flags1 = page_get_flags(tb->pc);
|
|
|
|
flags2 = page_get_flags(tb->pc + tb->size - 1);
|
|
|
|
if ((flags1 & PAGE_WRITE) || (flags2 & PAGE_WRITE)) {
|
|
|
|
printf("ERROR page flags: PC=%08lx size=%04x f1=%x f2=%x\n",
|
|
|
|
(long)tb->pc, tb->size, flags1, flags2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2012-12-20 02:39:16 +01:00
|
|
|
static inline void tb_hash_remove(TranslationBlock **ptb, TranslationBlock *tb)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
|
|
|
TranslationBlock *tb1;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
tb1 = *ptb;
|
|
|
|
if (tb1 == tb) {
|
2012-12-20 02:39:16 +01:00
|
|
|
*ptb = tb1->phys_hash_next;
|
2012-12-02 17:04:43 +01:00
|
|
|
break;
|
|
|
|
}
|
2012-12-20 02:39:16 +01:00
|
|
|
ptb = &tb1->phys_hash_next;
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void tb_page_remove(TranslationBlock **ptb, TranslationBlock *tb)
|
|
|
|
{
|
|
|
|
TranslationBlock *tb1;
|
|
|
|
unsigned int n1;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
tb1 = *ptb;
|
|
|
|
n1 = (uintptr_t)tb1 & 3;
|
|
|
|
tb1 = (TranslationBlock *)((uintptr_t)tb1 & ~3);
|
|
|
|
if (tb1 == tb) {
|
|
|
|
*ptb = tb1->page_next[n1];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ptb = &tb1->page_next[n1];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void tb_jmp_remove(TranslationBlock *tb, int n)
|
|
|
|
{
|
|
|
|
TranslationBlock *tb1, **ptb;
|
|
|
|
unsigned int n1;
|
|
|
|
|
|
|
|
ptb = &tb->jmp_next[n];
|
|
|
|
tb1 = *ptb;
|
|
|
|
if (tb1) {
|
|
|
|
/* find tb(n) in circular list */
|
|
|
|
for (;;) {
|
|
|
|
tb1 = *ptb;
|
|
|
|
n1 = (uintptr_t)tb1 & 3;
|
|
|
|
tb1 = (TranslationBlock *)((uintptr_t)tb1 & ~3);
|
|
|
|
if (n1 == n && tb1 == tb) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (n1 == 2) {
|
|
|
|
ptb = &tb1->jmp_first;
|
|
|
|
} else {
|
|
|
|
ptb = &tb1->jmp_next[n1];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* now we can suppress tb(n) from the list */
|
|
|
|
*ptb = tb->jmp_next[n];
|
|
|
|
|
|
|
|
tb->jmp_next[n] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* reset the jump entry 'n' of a TB so that it is not chained to
|
|
|
|
another TB */
|
|
|
|
static inline void tb_reset_jump(TranslationBlock *tb, int n)
|
|
|
|
{
|
|
|
|
tb_set_jmp_target(tb, n, (uintptr_t)(tb->tc_ptr + tb->tb_next_offset[n]));
|
|
|
|
}
|
|
|
|
|
2012-12-20 02:39:16 +01:00
|
|
|
/* invalidate one TB */
|
2012-12-02 17:04:43 +01:00
|
|
|
void tb_phys_invalidate(TranslationBlock *tb, tb_page_addr_t page_addr)
|
|
|
|
{
|
2013-05-29 22:29:20 +02:00
|
|
|
CPUState *cpu;
|
2012-12-02 17:04:43 +01:00
|
|
|
PageDesc *p;
|
|
|
|
unsigned int h, n1;
|
|
|
|
tb_page_addr_t phys_pc;
|
|
|
|
TranslationBlock *tb1, *tb2;
|
|
|
|
|
|
|
|
/* remove the TB from the hash list */
|
|
|
|
phys_pc = tb->page_addr[0] + (tb->pc & ~TARGET_PAGE_MASK);
|
|
|
|
h = tb_phys_hash_func(phys_pc);
|
2013-01-31 19:47:23 +01:00
|
|
|
tb_hash_remove(&tcg_ctx.tb_ctx.tb_phys_hash[h], tb);
|
2012-12-02 17:04:43 +01:00
|
|
|
|
|
|
|
/* remove the TB from the page list */
|
|
|
|
if (tb->page_addr[0] != page_addr) {
|
|
|
|
p = page_find(tb->page_addr[0] >> TARGET_PAGE_BITS);
|
|
|
|
tb_page_remove(&p->first_tb, tb);
|
|
|
|
invalidate_page_bitmap(p);
|
|
|
|
}
|
|
|
|
if (tb->page_addr[1] != -1 && tb->page_addr[1] != page_addr) {
|
|
|
|
p = page_find(tb->page_addr[1] >> TARGET_PAGE_BITS);
|
|
|
|
tb_page_remove(&p->first_tb, tb);
|
|
|
|
invalidate_page_bitmap(p);
|
|
|
|
}
|
|
|
|
|
2013-01-31 19:47:23 +01:00
|
|
|
tcg_ctx.tb_ctx.tb_invalidated_flag = 1;
|
2012-12-02 17:04:43 +01:00
|
|
|
|
|
|
|
/* remove the TB from the hash list */
|
|
|
|
h = tb_jmp_cache_hash_func(tb->pc);
|
2013-06-24 23:50:24 +02:00
|
|
|
CPU_FOREACH(cpu) {
|
2013-08-26 06:03:38 +02:00
|
|
|
if (cpu->tb_jmp_cache[h] == tb) {
|
|
|
|
cpu->tb_jmp_cache[h] = NULL;
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* suppress this TB from the two jump lists */
|
|
|
|
tb_jmp_remove(tb, 0);
|
|
|
|
tb_jmp_remove(tb, 1);
|
|
|
|
|
|
|
|
/* suppress any remaining jumps to this TB */
|
|
|
|
tb1 = tb->jmp_first;
|
|
|
|
for (;;) {
|
|
|
|
n1 = (uintptr_t)tb1 & 3;
|
|
|
|
if (n1 == 2) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
tb1 = (TranslationBlock *)((uintptr_t)tb1 & ~3);
|
|
|
|
tb2 = tb1->jmp_next[n1];
|
|
|
|
tb_reset_jump(tb1, n1);
|
|
|
|
tb1->jmp_next[n1] = NULL;
|
|
|
|
tb1 = tb2;
|
|
|
|
}
|
|
|
|
tb->jmp_first = (TranslationBlock *)((uintptr_t)tb | 2); /* fail safe */
|
|
|
|
|
2013-01-31 19:47:23 +01:00
|
|
|
tcg_ctx.tb_ctx.tb_phys_invalidate_count++;
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void build_page_bitmap(PageDesc *p)
|
|
|
|
{
|
|
|
|
int n, tb_start, tb_end;
|
|
|
|
TranslationBlock *tb;
|
|
|
|
|
2015-04-22 23:50:52 +02:00
|
|
|
p->code_bitmap = bitmap_new(TARGET_PAGE_SIZE);
|
2012-12-02 17:04:43 +01:00
|
|
|
|
|
|
|
tb = p->first_tb;
|
|
|
|
while (tb != NULL) {
|
|
|
|
n = (uintptr_t)tb & 3;
|
|
|
|
tb = (TranslationBlock *)((uintptr_t)tb & ~3);
|
|
|
|
/* NOTE: this is subtle as a TB may span two physical pages */
|
|
|
|
if (n == 0) {
|
|
|
|
/* NOTE: tb_end may be after the end of the page, but
|
|
|
|
it is not a problem */
|
|
|
|
tb_start = tb->pc & ~TARGET_PAGE_MASK;
|
|
|
|
tb_end = tb_start + tb->size;
|
|
|
|
if (tb_end > TARGET_PAGE_SIZE) {
|
|
|
|
tb_end = TARGET_PAGE_SIZE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
tb_start = 0;
|
|
|
|
tb_end = ((tb->pc + tb->size) & ~TARGET_PAGE_MASK);
|
|
|
|
}
|
2015-04-22 23:50:52 +02:00
|
|
|
bitmap_set(p->code_bitmap, tb_start, tb_end - tb_start);
|
2012-12-02 17:04:43 +01:00
|
|
|
tb = tb->page_next[n];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-01 17:43:17 +02:00
|
|
|
TranslationBlock *tb_gen_code(CPUState *cpu,
|
2012-12-02 17:04:43 +01:00
|
|
|
target_ulong pc, target_ulong cs_base,
|
|
|
|
int flags, int cflags)
|
|
|
|
{
|
2013-09-01 17:43:17 +02:00
|
|
|
CPUArchState *env = cpu->env_ptr;
|
2012-12-02 17:04:43 +01:00
|
|
|
TranslationBlock *tb;
|
|
|
|
tb_page_addr_t phys_pc, phys_page2;
|
|
|
|
target_ulong virt_page2;
|
|
|
|
int code_gen_size;
|
|
|
|
|
|
|
|
phys_pc = get_page_addr_code(env, pc);
|
2014-11-26 11:39:53 +01:00
|
|
|
if (use_icount) {
|
|
|
|
cflags |= CF_USE_ICOUNT;
|
|
|
|
}
|
2012-12-02 17:04:43 +01:00
|
|
|
tb = tb_alloc(pc);
|
|
|
|
if (!tb) {
|
|
|
|
/* flush must be done */
|
|
|
|
tb_flush(env);
|
|
|
|
/* cannot fail at this point */
|
|
|
|
tb = tb_alloc(pc);
|
|
|
|
/* Don't forget to invalidate previous TB info. */
|
2013-01-31 19:47:23 +01:00
|
|
|
tcg_ctx.tb_ctx.tb_invalidated_flag = 1;
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
2014-03-28 20:56:22 +01:00
|
|
|
tb->tc_ptr = tcg_ctx.code_gen_ptr;
|
2012-12-02 17:04:43 +01:00
|
|
|
tb->cs_base = cs_base;
|
|
|
|
tb->flags = flags;
|
|
|
|
tb->cflags = cflags;
|
|
|
|
cpu_gen_code(env, tb, &code_gen_size);
|
2013-01-31 19:47:22 +01:00
|
|
|
tcg_ctx.code_gen_ptr = (void *)(((uintptr_t)tcg_ctx.code_gen_ptr +
|
|
|
|
code_gen_size + CODE_GEN_ALIGN - 1) & ~(CODE_GEN_ALIGN - 1));
|
2012-12-02 17:04:43 +01:00
|
|
|
|
|
|
|
/* check next page if needed */
|
|
|
|
virt_page2 = (pc + tb->size - 1) & TARGET_PAGE_MASK;
|
|
|
|
phys_page2 = -1;
|
|
|
|
if ((pc & TARGET_PAGE_MASK) != virt_page2) {
|
|
|
|
phys_page2 = get_page_addr_code(env, virt_page2);
|
|
|
|
}
|
|
|
|
tb_link_page(tb, phys_pc, phys_page2);
|
|
|
|
return tb;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Invalidate all TBs which intersect with the target physical address range
|
|
|
|
* [start;end[. NOTE: start and end may refer to *different* physical pages.
|
|
|
|
* 'is_cpu_write_access' should be true if called from a real cpu write
|
|
|
|
* access: the virtual CPU will exit the current TB if code is modified inside
|
|
|
|
* this TB.
|
|
|
|
*/
|
2015-04-22 14:20:35 +02:00
|
|
|
void tb_invalidate_phys_range(tb_page_addr_t start, tb_page_addr_t end)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
|
|
|
while (start < end) {
|
2015-04-22 14:20:35 +02:00
|
|
|
tb_invalidate_phys_page_range(start, end, 0);
|
2012-12-02 17:04:43 +01:00
|
|
|
start &= TARGET_PAGE_MASK;
|
|
|
|
start += TARGET_PAGE_SIZE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Invalidate all TBs which intersect with the target physical address range
|
|
|
|
* [start;end[. NOTE: start and end must refer to the *same* physical page.
|
|
|
|
* 'is_cpu_write_access' should be true if called from a real cpu write
|
|
|
|
* access: the virtual CPU will exit the current TB if code is modified inside
|
|
|
|
* this TB.
|
|
|
|
*/
|
|
|
|
void tb_invalidate_phys_page_range(tb_page_addr_t start, tb_page_addr_t end,
|
|
|
|
int is_cpu_write_access)
|
|
|
|
{
|
|
|
|
TranslationBlock *tb, *tb_next, *saved_tb;
|
2013-05-27 05:17:50 +02:00
|
|
|
CPUState *cpu = current_cpu;
|
2013-09-03 10:51:26 +02:00
|
|
|
#if defined(TARGET_HAS_PRECISE_SMC)
|
2013-05-27 05:17:50 +02:00
|
|
|
CPUArchState *env = NULL;
|
|
|
|
#endif
|
2012-12-02 17:04:43 +01:00
|
|
|
tb_page_addr_t tb_start, tb_end;
|
|
|
|
PageDesc *p;
|
|
|
|
int n;
|
|
|
|
#ifdef TARGET_HAS_PRECISE_SMC
|
|
|
|
int current_tb_not_found = is_cpu_write_access;
|
|
|
|
TranslationBlock *current_tb = NULL;
|
|
|
|
int current_tb_modified = 0;
|
|
|
|
target_ulong current_pc = 0;
|
|
|
|
target_ulong current_cs_base = 0;
|
|
|
|
int current_flags = 0;
|
|
|
|
#endif /* TARGET_HAS_PRECISE_SMC */
|
|
|
|
|
|
|
|
p = page_find(start >> TARGET_PAGE_BITS);
|
|
|
|
if (!p) {
|
|
|
|
return;
|
|
|
|
}
|
2013-09-03 10:51:26 +02:00
|
|
|
#if defined(TARGET_HAS_PRECISE_SMC)
|
2013-05-27 05:17:50 +02:00
|
|
|
if (cpu != NULL) {
|
|
|
|
env = cpu->env_ptr;
|
2013-01-16 19:29:31 +01:00
|
|
|
}
|
2013-05-27 05:17:50 +02:00
|
|
|
#endif
|
2012-12-02 17:04:43 +01:00
|
|
|
|
|
|
|
/* we remove all the TBs in the range [start, end[ */
|
|
|
|
/* XXX: see if in some cases it could be faster to invalidate all
|
|
|
|
the code */
|
|
|
|
tb = p->first_tb;
|
|
|
|
while (tb != NULL) {
|
|
|
|
n = (uintptr_t)tb & 3;
|
|
|
|
tb = (TranslationBlock *)((uintptr_t)tb & ~3);
|
|
|
|
tb_next = tb->page_next[n];
|
|
|
|
/* NOTE: this is subtle as a TB may span two physical pages */
|
|
|
|
if (n == 0) {
|
|
|
|
/* NOTE: tb_end may be after the end of the page, but
|
|
|
|
it is not a problem */
|
|
|
|
tb_start = tb->page_addr[0] + (tb->pc & ~TARGET_PAGE_MASK);
|
|
|
|
tb_end = tb_start + tb->size;
|
|
|
|
} else {
|
|
|
|
tb_start = tb->page_addr[1];
|
|
|
|
tb_end = tb_start + ((tb->pc + tb->size) & ~TARGET_PAGE_MASK);
|
|
|
|
}
|
|
|
|
if (!(tb_end <= start || tb_start >= end)) {
|
|
|
|
#ifdef TARGET_HAS_PRECISE_SMC
|
|
|
|
if (current_tb_not_found) {
|
|
|
|
current_tb_not_found = 0;
|
|
|
|
current_tb = NULL;
|
2013-08-26 03:41:01 +02:00
|
|
|
if (cpu->mem_io_pc) {
|
2012-12-02 17:04:43 +01:00
|
|
|
/* now we have a real cpu fault */
|
2013-08-26 03:41:01 +02:00
|
|
|
current_tb = tb_find_pc(cpu->mem_io_pc);
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (current_tb == tb &&
|
|
|
|
(current_tb->cflags & CF_COUNT_MASK) != 1) {
|
|
|
|
/* If we are modifying the current TB, we must stop
|
|
|
|
its execution. We could be more precise by checking
|
|
|
|
that the modification is after the current PC, but it
|
|
|
|
would require a specialized function to partially
|
|
|
|
restore the CPU state */
|
|
|
|
|
|
|
|
current_tb_modified = 1;
|
2013-09-01 17:02:58 +02:00
|
|
|
cpu_restore_state_from_tb(cpu, current_tb, cpu->mem_io_pc);
|
2012-12-02 17:04:43 +01:00
|
|
|
cpu_get_tb_cpu_state(env, ¤t_pc, ¤t_cs_base,
|
|
|
|
¤t_flags);
|
|
|
|
}
|
|
|
|
#endif /* TARGET_HAS_PRECISE_SMC */
|
|
|
|
/* we need to do that to handle the case where a signal
|
|
|
|
occurs while doing tb_phys_invalidate() */
|
|
|
|
saved_tb = NULL;
|
2013-01-16 19:29:31 +01:00
|
|
|
if (cpu != NULL) {
|
|
|
|
saved_tb = cpu->current_tb;
|
|
|
|
cpu->current_tb = NULL;
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
tb_phys_invalidate(tb, -1);
|
2013-01-16 19:29:31 +01:00
|
|
|
if (cpu != NULL) {
|
|
|
|
cpu->current_tb = saved_tb;
|
2013-01-18 15:03:43 +01:00
|
|
|
if (cpu->interrupt_request && cpu->current_tb) {
|
|
|
|
cpu_interrupt(cpu, cpu->interrupt_request);
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
tb = tb_next;
|
|
|
|
}
|
|
|
|
#if !defined(CONFIG_USER_ONLY)
|
|
|
|
/* if no code remaining, no need to continue to use slow writes */
|
|
|
|
if (!p->first_tb) {
|
|
|
|
invalidate_page_bitmap(p);
|
2015-04-22 14:20:35 +02:00
|
|
|
tlb_unprotect_code(start);
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef TARGET_HAS_PRECISE_SMC
|
|
|
|
if (current_tb_modified) {
|
|
|
|
/* we generate a block containing just the instruction
|
|
|
|
modifying the memory. It will ensure that it cannot modify
|
|
|
|
itself */
|
2013-01-16 19:29:31 +01:00
|
|
|
cpu->current_tb = NULL;
|
2013-09-01 17:43:17 +02:00
|
|
|
tb_gen_code(cpu, current_pc, current_cs_base, current_flags, 1);
|
2013-09-03 02:12:23 +02:00
|
|
|
cpu_resume_from_signal(cpu, NULL);
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/* len must be <= 8 and start must be a multiple of len */
|
|
|
|
void tb_invalidate_phys_page_fast(tb_page_addr_t start, int len)
|
|
|
|
{
|
|
|
|
PageDesc *p;
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
if (1) {
|
|
|
|
qemu_log("modifying code at 0x%x size=%d EIP=%x PC=%08x\n",
|
|
|
|
cpu_single_env->mem_io_vaddr, len,
|
|
|
|
cpu_single_env->eip,
|
|
|
|
cpu_single_env->eip +
|
|
|
|
(intptr_t)cpu_single_env->segs[R_CS].base);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
p = page_find(start >> TARGET_PAGE_BITS);
|
|
|
|
if (!p) {
|
|
|
|
return;
|
|
|
|
}
|
2015-04-22 14:20:35 +02:00
|
|
|
if (!p->code_bitmap &&
|
|
|
|
++p->code_write_count >= SMC_BITMAP_USE_THRESHOLD) {
|
|
|
|
/* build code bitmap */
|
|
|
|
build_page_bitmap(p);
|
|
|
|
}
|
2012-12-02 17:04:43 +01:00
|
|
|
if (p->code_bitmap) {
|
2015-04-22 23:50:52 +02:00
|
|
|
unsigned int nr;
|
|
|
|
unsigned long b;
|
|
|
|
|
|
|
|
nr = start & ~TARGET_PAGE_MASK;
|
|
|
|
b = p->code_bitmap[BIT_WORD(nr)] >> (nr & (BITS_PER_LONG - 1));
|
2012-12-02 17:04:43 +01:00
|
|
|
if (b & ((1 << len) - 1)) {
|
|
|
|
goto do_invalidate;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
do_invalidate:
|
|
|
|
tb_invalidate_phys_page_range(start, start + len, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#if !defined(CONFIG_SOFTMMU)
|
|
|
|
static void tb_invalidate_phys_page(tb_page_addr_t addr,
|
2013-07-06 14:17:57 +02:00
|
|
|
uintptr_t pc, void *puc,
|
|
|
|
bool locked)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
|
|
|
TranslationBlock *tb;
|
|
|
|
PageDesc *p;
|
|
|
|
int n;
|
|
|
|
#ifdef TARGET_HAS_PRECISE_SMC
|
|
|
|
TranslationBlock *current_tb = NULL;
|
2013-05-27 05:17:50 +02:00
|
|
|
CPUState *cpu = current_cpu;
|
|
|
|
CPUArchState *env = NULL;
|
2012-12-02 17:04:43 +01:00
|
|
|
int current_tb_modified = 0;
|
|
|
|
target_ulong current_pc = 0;
|
|
|
|
target_ulong current_cs_base = 0;
|
|
|
|
int current_flags = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
addr &= TARGET_PAGE_MASK;
|
|
|
|
p = page_find(addr >> TARGET_PAGE_BITS);
|
|
|
|
if (!p) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
tb = p->first_tb;
|
|
|
|
#ifdef TARGET_HAS_PRECISE_SMC
|
|
|
|
if (tb && pc != 0) {
|
|
|
|
current_tb = tb_find_pc(pc);
|
|
|
|
}
|
2013-05-27 05:17:50 +02:00
|
|
|
if (cpu != NULL) {
|
|
|
|
env = cpu->env_ptr;
|
2013-01-16 19:29:31 +01:00
|
|
|
}
|
2012-12-02 17:04:43 +01:00
|
|
|
#endif
|
|
|
|
while (tb != NULL) {
|
|
|
|
n = (uintptr_t)tb & 3;
|
|
|
|
tb = (TranslationBlock *)((uintptr_t)tb & ~3);
|
|
|
|
#ifdef TARGET_HAS_PRECISE_SMC
|
|
|
|
if (current_tb == tb &&
|
|
|
|
(current_tb->cflags & CF_COUNT_MASK) != 1) {
|
|
|
|
/* If we are modifying the current TB, we must stop
|
|
|
|
its execution. We could be more precise by checking
|
|
|
|
that the modification is after the current PC, but it
|
|
|
|
would require a specialized function to partially
|
|
|
|
restore the CPU state */
|
|
|
|
|
|
|
|
current_tb_modified = 1;
|
2013-09-01 17:02:58 +02:00
|
|
|
cpu_restore_state_from_tb(cpu, current_tb, pc);
|
2012-12-02 17:04:43 +01:00
|
|
|
cpu_get_tb_cpu_state(env, ¤t_pc, ¤t_cs_base,
|
|
|
|
¤t_flags);
|
|
|
|
}
|
|
|
|
#endif /* TARGET_HAS_PRECISE_SMC */
|
|
|
|
tb_phys_invalidate(tb, addr);
|
|
|
|
tb = tb->page_next[n];
|
|
|
|
}
|
|
|
|
p->first_tb = NULL;
|
|
|
|
#ifdef TARGET_HAS_PRECISE_SMC
|
|
|
|
if (current_tb_modified) {
|
|
|
|
/* we generate a block containing just the instruction
|
|
|
|
modifying the memory. It will ensure that it cannot modify
|
|
|
|
itself */
|
2013-01-16 19:29:31 +01:00
|
|
|
cpu->current_tb = NULL;
|
2013-09-01 17:43:17 +02:00
|
|
|
tb_gen_code(cpu, current_pc, current_cs_base, current_flags, 1);
|
2013-07-06 14:17:57 +02:00
|
|
|
if (locked) {
|
|
|
|
mmap_unlock();
|
|
|
|
}
|
2013-09-03 02:12:23 +02:00
|
|
|
cpu_resume_from_signal(cpu, puc);
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* add the tb in the target page and protect it if necessary */
|
|
|
|
static inline void tb_alloc_page(TranslationBlock *tb,
|
|
|
|
unsigned int n, tb_page_addr_t page_addr)
|
|
|
|
{
|
|
|
|
PageDesc *p;
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
bool page_already_protected;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
tb->page_addr[n] = page_addr;
|
|
|
|
p = page_find_alloc(page_addr >> TARGET_PAGE_BITS, 1);
|
|
|
|
tb->page_next[n] = p->first_tb;
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
page_already_protected = p->first_tb != NULL;
|
|
|
|
#endif
|
|
|
|
p->first_tb = (TranslationBlock *)((uintptr_t)tb | n);
|
|
|
|
invalidate_page_bitmap(p);
|
|
|
|
|
|
|
|
#if defined(CONFIG_USER_ONLY)
|
|
|
|
if (p->flags & PAGE_WRITE) {
|
|
|
|
target_ulong addr;
|
|
|
|
PageDesc *p2;
|
|
|
|
int prot;
|
|
|
|
|
|
|
|
/* force the host page as non writable (writes will have a
|
|
|
|
page fault + mprotect overhead) */
|
|
|
|
page_addr &= qemu_host_page_mask;
|
|
|
|
prot = 0;
|
|
|
|
for (addr = page_addr; addr < page_addr + qemu_host_page_size;
|
|
|
|
addr += TARGET_PAGE_SIZE) {
|
|
|
|
|
|
|
|
p2 = page_find(addr >> TARGET_PAGE_BITS);
|
|
|
|
if (!p2) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
prot |= p2->flags;
|
|
|
|
p2->flags &= ~PAGE_WRITE;
|
|
|
|
}
|
|
|
|
mprotect(g2h(page_addr), qemu_host_page_size,
|
|
|
|
(prot & PAGE_BITS) & ~PAGE_WRITE);
|
|
|
|
#ifdef DEBUG_TB_INVALIDATE
|
|
|
|
printf("protecting code page: 0x" TARGET_FMT_lx "\n",
|
|
|
|
page_addr);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
/* if some code is already present, then the pages are already
|
|
|
|
protected. So we handle the case where only the first TB is
|
|
|
|
allocated in a physical page */
|
|
|
|
if (!page_already_protected) {
|
|
|
|
tlb_protect_code(page_addr);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add a new TB and link it to the physical page tables. phys_page2 is
|
|
|
|
(-1) to indicate that only one page contains the TB. */
|
|
|
|
static void tb_link_page(TranslationBlock *tb, tb_page_addr_t phys_pc,
|
|
|
|
tb_page_addr_t phys_page2)
|
|
|
|
{
|
|
|
|
unsigned int h;
|
|
|
|
TranslationBlock **ptb;
|
|
|
|
|
|
|
|
/* Grab the mmap lock to stop another thread invalidating this TB
|
|
|
|
before we are done. */
|
|
|
|
mmap_lock();
|
|
|
|
/* add in the physical hash table */
|
|
|
|
h = tb_phys_hash_func(phys_pc);
|
2013-01-31 19:47:23 +01:00
|
|
|
ptb = &tcg_ctx.tb_ctx.tb_phys_hash[h];
|
2012-12-02 17:04:43 +01:00
|
|
|
tb->phys_hash_next = *ptb;
|
|
|
|
*ptb = tb;
|
|
|
|
|
|
|
|
/* add in the page list */
|
|
|
|
tb_alloc_page(tb, 0, phys_pc & TARGET_PAGE_MASK);
|
|
|
|
if (phys_page2 != -1) {
|
|
|
|
tb_alloc_page(tb, 1, phys_page2);
|
|
|
|
} else {
|
|
|
|
tb->page_addr[1] = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
tb->jmp_first = (TranslationBlock *)((uintptr_t)tb | 2);
|
|
|
|
tb->jmp_next[0] = NULL;
|
|
|
|
tb->jmp_next[1] = NULL;
|
|
|
|
|
|
|
|
/* init original jump addresses */
|
|
|
|
if (tb->tb_next_offset[0] != 0xffff) {
|
|
|
|
tb_reset_jump(tb, 0);
|
|
|
|
}
|
|
|
|
if (tb->tb_next_offset[1] != 0xffff) {
|
|
|
|
tb_reset_jump(tb, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUG_TB_CHECK
|
|
|
|
tb_page_check();
|
|
|
|
#endif
|
|
|
|
mmap_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* find the TB 'tb' such that tb[0].tc_ptr <= tc_ptr <
|
|
|
|
tb[1].tc_ptr. Return NULL if not found */
|
2012-12-04 21:16:07 +01:00
|
|
|
static TranslationBlock *tb_find_pc(uintptr_t tc_ptr)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
|
|
|
int m_min, m_max, m;
|
|
|
|
uintptr_t v;
|
|
|
|
TranslationBlock *tb;
|
|
|
|
|
2013-01-31 19:47:23 +01:00
|
|
|
if (tcg_ctx.tb_ctx.nb_tbs <= 0) {
|
2012-12-02 17:04:43 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
2013-01-31 19:47:22 +01:00
|
|
|
if (tc_ptr < (uintptr_t)tcg_ctx.code_gen_buffer ||
|
|
|
|
tc_ptr >= (uintptr_t)tcg_ctx.code_gen_ptr) {
|
2012-12-02 17:04:43 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
/* binary search (cf Knuth) */
|
|
|
|
m_min = 0;
|
2013-01-31 19:47:23 +01:00
|
|
|
m_max = tcg_ctx.tb_ctx.nb_tbs - 1;
|
2012-12-02 17:04:43 +01:00
|
|
|
while (m_min <= m_max) {
|
|
|
|
m = (m_min + m_max) >> 1;
|
2013-01-31 19:47:23 +01:00
|
|
|
tb = &tcg_ctx.tb_ctx.tbs[m];
|
2012-12-02 17:04:43 +01:00
|
|
|
v = (uintptr_t)tb->tc_ptr;
|
|
|
|
if (v == tc_ptr) {
|
|
|
|
return tb;
|
|
|
|
} else if (tc_ptr < v) {
|
|
|
|
m_max = m - 1;
|
|
|
|
} else {
|
|
|
|
m_min = m + 1;
|
|
|
|
}
|
|
|
|
}
|
2013-01-31 19:47:23 +01:00
|
|
|
return &tcg_ctx.tb_ctx.tbs[m_max];
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
|
2015-01-20 16:19:32 +01:00
|
|
|
#if !defined(CONFIG_USER_ONLY)
|
2013-11-07 19:43:10 +01:00
|
|
|
void tb_invalidate_phys_addr(AddressSpace *as, hwaddr addr)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
|
|
|
ram_addr_t ram_addr;
|
2013-05-29 12:42:00 +02:00
|
|
|
MemoryRegion *mr;
|
2013-05-24 12:59:37 +02:00
|
|
|
hwaddr l = 1;
|
2012-12-02 17:04:43 +01:00
|
|
|
|
2015-03-18 14:21:43 +01:00
|
|
|
rcu_read_lock();
|
2013-11-07 19:43:10 +01:00
|
|
|
mr = address_space_translate(as, addr, &addr, &l, false);
|
2013-05-29 12:42:00 +02:00
|
|
|
if (!(memory_region_is_ram(mr)
|
|
|
|
|| memory_region_is_romd(mr))) {
|
2015-03-18 14:21:43 +01:00
|
|
|
rcu_read_unlock();
|
2012-12-02 17:04:43 +01:00
|
|
|
return;
|
|
|
|
}
|
2013-05-29 12:42:00 +02:00
|
|
|
ram_addr = (memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK)
|
2013-05-24 12:59:37 +02:00
|
|
|
+ addr;
|
2012-12-02 17:04:43 +01:00
|
|
|
tb_invalidate_phys_page_range(ram_addr, ram_addr + 1, 0);
|
2015-03-18 14:21:43 +01:00
|
|
|
rcu_read_unlock();
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
2015-01-20 16:19:32 +01:00
|
|
|
#endif /* !defined(CONFIG_USER_ONLY) */
|
2012-12-02 17:04:43 +01:00
|
|
|
|
2013-09-01 17:12:23 +02:00
|
|
|
void tb_check_watchpoint(CPUState *cpu)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
|
|
|
TranslationBlock *tb;
|
|
|
|
|
2013-08-26 03:41:01 +02:00
|
|
|
tb = tb_find_pc(cpu->mem_io_pc);
|
2015-06-13 00:45:59 +02:00
|
|
|
if (tb) {
|
|
|
|
/* We can use retranslation to find the PC. */
|
|
|
|
cpu_restore_state_from_tb(cpu, tb, cpu->mem_io_pc);
|
|
|
|
tb_phys_invalidate(tb, -1);
|
|
|
|
} else {
|
|
|
|
/* The exception probably happened in a helper. The CPU state should
|
|
|
|
have been saved before calling it. Fetch the PC from there. */
|
|
|
|
CPUArchState *env = cpu->env_ptr;
|
|
|
|
target_ulong pc, cs_base;
|
|
|
|
tb_page_addr_t addr;
|
|
|
|
int flags;
|
|
|
|
|
|
|
|
cpu_get_tb_cpu_state(env, &pc, &cs_base, &flags);
|
|
|
|
addr = get_page_addr_code(env, pc);
|
|
|
|
tb_invalidate_phys_range(addr, addr + 1);
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
/* mask must never be zero, except for A20 change call */
|
2013-01-18 15:03:43 +01:00
|
|
|
static void tcg_handle_interrupt(CPUState *cpu, int mask)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
|
|
|
int old_mask;
|
|
|
|
|
2013-01-17 18:51:17 +01:00
|
|
|
old_mask = cpu->interrupt_request;
|
|
|
|
cpu->interrupt_request |= mask;
|
2012-12-02 17:04:43 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If called from iothread context, wake the target cpu in
|
|
|
|
* case its halted.
|
|
|
|
*/
|
|
|
|
if (!qemu_cpu_is_self(cpu)) {
|
|
|
|
qemu_cpu_kick(cpu);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (use_icount) {
|
2013-08-26 05:51:49 +02:00
|
|
|
cpu->icount_decr.u16.high = 0xffff;
|
2013-08-26 05:15:23 +02:00
|
|
|
if (!cpu_can_do_io(cpu)
|
2012-12-02 17:04:43 +01:00
|
|
|
&& (mask & ~old_mask) != 0) {
|
2013-09-03 17:38:47 +02:00
|
|
|
cpu_abort(cpu, "Raised interrupt while not in I/O function");
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
} else {
|
2013-02-22 19:10:03 +01:00
|
|
|
cpu->tcg_exit_req = 1;
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
CPUInterruptHandler cpu_interrupt_handler = tcg_handle_interrupt;
|
|
|
|
|
|
|
|
/* in deterministic execution mode, instructions doing device I/Os
|
|
|
|
must be at the end of the TB */
|
2013-09-01 17:21:47 +02:00
|
|
|
void cpu_io_recompile(CPUState *cpu, uintptr_t retaddr)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
2013-09-03 17:38:47 +02:00
|
|
|
#if defined(TARGET_MIPS) || defined(TARGET_SH4)
|
2013-09-01 17:21:47 +02:00
|
|
|
CPUArchState *env = cpu->env_ptr;
|
2013-09-03 17:38:47 +02:00
|
|
|
#endif
|
2012-12-02 17:04:43 +01:00
|
|
|
TranslationBlock *tb;
|
|
|
|
uint32_t n, cflags;
|
|
|
|
target_ulong pc, cs_base;
|
|
|
|
uint64_t flags;
|
|
|
|
|
|
|
|
tb = tb_find_pc(retaddr);
|
|
|
|
if (!tb) {
|
2013-09-03 17:38:47 +02:00
|
|
|
cpu_abort(cpu, "cpu_io_recompile: could not find TB for pc=%p",
|
2012-12-02 17:04:43 +01:00
|
|
|
(void *)retaddr);
|
|
|
|
}
|
2013-08-26 05:51:49 +02:00
|
|
|
n = cpu->icount_decr.u16.low + tb->icount;
|
2013-09-01 17:02:58 +02:00
|
|
|
cpu_restore_state_from_tb(cpu, tb, retaddr);
|
2012-12-02 17:04:43 +01:00
|
|
|
/* Calculate how many instructions had been executed before the fault
|
|
|
|
occurred. */
|
2013-08-26 05:51:49 +02:00
|
|
|
n = n - cpu->icount_decr.u16.low;
|
2012-12-02 17:04:43 +01:00
|
|
|
/* Generate a new TB ending on the I/O insn. */
|
|
|
|
n++;
|
|
|
|
/* On MIPS and SH, delay slot instructions can only be restarted if
|
|
|
|
they were already the first instruction in the TB. If this is not
|
|
|
|
the first instruction in a TB then re-execute the preceding
|
|
|
|
branch. */
|
|
|
|
#if defined(TARGET_MIPS)
|
|
|
|
if ((env->hflags & MIPS_HFLAG_BMASK) != 0 && n > 1) {
|
2014-11-07 21:05:35 +01:00
|
|
|
env->active_tc.PC -= (env->hflags & MIPS_HFLAG_B16 ? 2 : 4);
|
2013-08-26 05:51:49 +02:00
|
|
|
cpu->icount_decr.u16.low++;
|
2012-12-02 17:04:43 +01:00
|
|
|
env->hflags &= ~MIPS_HFLAG_BMASK;
|
|
|
|
}
|
|
|
|
#elif defined(TARGET_SH4)
|
|
|
|
if ((env->flags & ((DELAY_SLOT | DELAY_SLOT_CONDITIONAL))) != 0
|
|
|
|
&& n > 1) {
|
|
|
|
env->pc -= 2;
|
2013-08-26 05:51:49 +02:00
|
|
|
cpu->icount_decr.u16.low++;
|
2012-12-02 17:04:43 +01:00
|
|
|
env->flags &= ~(DELAY_SLOT | DELAY_SLOT_CONDITIONAL);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* This should never happen. */
|
|
|
|
if (n > CF_COUNT_MASK) {
|
2013-09-03 17:38:47 +02:00
|
|
|
cpu_abort(cpu, "TB too big during recompile");
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
cflags = n | CF_LAST_IO;
|
|
|
|
pc = tb->pc;
|
|
|
|
cs_base = tb->cs_base;
|
|
|
|
flags = tb->flags;
|
|
|
|
tb_phys_invalidate(tb, -1);
|
|
|
|
/* FIXME: In theory this could raise an exception. In practice
|
|
|
|
we have already translated the block once so it's probably ok. */
|
2013-09-01 17:43:17 +02:00
|
|
|
tb_gen_code(cpu, pc, cs_base, flags, cflags);
|
2012-12-02 17:04:43 +01:00
|
|
|
/* TODO: If env->pc != tb->pc (i.e. the faulting instruction was not
|
|
|
|
the first in the TB) then we end up generating a whole new TB and
|
|
|
|
repeating the fault, which is horribly inefficient.
|
|
|
|
Better would be to execute just this insn uncached, or generate a
|
|
|
|
second new TB. */
|
2013-09-03 02:12:23 +02:00
|
|
|
cpu_resume_from_signal(cpu, NULL);
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
|
2013-09-01 17:52:07 +02:00
|
|
|
void tb_flush_jmp_cache(CPUState *cpu, target_ulong addr)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
/* Discard jump cache entries for any tb which might potentially
|
|
|
|
overlap the flushed page. */
|
|
|
|
i = tb_jmp_cache_hash_page(addr - TARGET_PAGE_SIZE);
|
2013-08-26 06:03:38 +02:00
|
|
|
memset(&cpu->tb_jmp_cache[i], 0,
|
2012-12-02 17:04:43 +01:00
|
|
|
TB_JMP_PAGE_SIZE * sizeof(TranslationBlock *));
|
|
|
|
|
|
|
|
i = tb_jmp_cache_hash_page(addr);
|
2013-08-26 06:03:38 +02:00
|
|
|
memset(&cpu->tb_jmp_cache[i], 0,
|
2012-12-02 17:04:43 +01:00
|
|
|
TB_JMP_PAGE_SIZE * sizeof(TranslationBlock *));
|
|
|
|
}
|
|
|
|
|
|
|
|
void dump_exec_info(FILE *f, fprintf_function cpu_fprintf)
|
|
|
|
{
|
|
|
|
int i, target_code_size, max_target_code_size;
|
|
|
|
int direct_jmp_count, direct_jmp2_count, cross_page;
|
|
|
|
TranslationBlock *tb;
|
|
|
|
|
|
|
|
target_code_size = 0;
|
|
|
|
max_target_code_size = 0;
|
|
|
|
cross_page = 0;
|
|
|
|
direct_jmp_count = 0;
|
|
|
|
direct_jmp2_count = 0;
|
2013-01-31 19:47:23 +01:00
|
|
|
for (i = 0; i < tcg_ctx.tb_ctx.nb_tbs; i++) {
|
|
|
|
tb = &tcg_ctx.tb_ctx.tbs[i];
|
2012-12-02 17:04:43 +01:00
|
|
|
target_code_size += tb->size;
|
|
|
|
if (tb->size > max_target_code_size) {
|
|
|
|
max_target_code_size = tb->size;
|
|
|
|
}
|
|
|
|
if (tb->page_addr[1] != -1) {
|
|
|
|
cross_page++;
|
|
|
|
}
|
|
|
|
if (tb->tb_next_offset[0] != 0xffff) {
|
|
|
|
direct_jmp_count++;
|
|
|
|
if (tb->tb_next_offset[1] != 0xffff) {
|
|
|
|
direct_jmp2_count++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* XXX: avoid using doubles ? */
|
|
|
|
cpu_fprintf(f, "Translation buffer state:\n");
|
|
|
|
cpu_fprintf(f, "gen code size %td/%zd\n",
|
2013-01-31 19:47:22 +01:00
|
|
|
tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer,
|
|
|
|
tcg_ctx.code_gen_buffer_max_size);
|
2012-12-02 17:04:43 +01:00
|
|
|
cpu_fprintf(f, "TB count %d/%d\n",
|
2013-01-31 19:47:23 +01:00
|
|
|
tcg_ctx.tb_ctx.nb_tbs, tcg_ctx.code_gen_max_blocks);
|
2012-12-02 17:04:43 +01:00
|
|
|
cpu_fprintf(f, "TB avg target size %d max=%d bytes\n",
|
2013-01-31 19:47:23 +01:00
|
|
|
tcg_ctx.tb_ctx.nb_tbs ? target_code_size /
|
|
|
|
tcg_ctx.tb_ctx.nb_tbs : 0,
|
|
|
|
max_target_code_size);
|
2012-12-02 17:04:43 +01:00
|
|
|
cpu_fprintf(f, "TB avg host size %td bytes (expansion ratio: %0.1f)\n",
|
2013-01-31 19:47:23 +01:00
|
|
|
tcg_ctx.tb_ctx.nb_tbs ? (tcg_ctx.code_gen_ptr -
|
|
|
|
tcg_ctx.code_gen_buffer) /
|
|
|
|
tcg_ctx.tb_ctx.nb_tbs : 0,
|
|
|
|
target_code_size ? (double) (tcg_ctx.code_gen_ptr -
|
|
|
|
tcg_ctx.code_gen_buffer) /
|
|
|
|
target_code_size : 0);
|
|
|
|
cpu_fprintf(f, "cross page TB count %d (%d%%)\n", cross_page,
|
|
|
|
tcg_ctx.tb_ctx.nb_tbs ? (cross_page * 100) /
|
|
|
|
tcg_ctx.tb_ctx.nb_tbs : 0);
|
2012-12-02 17:04:43 +01:00
|
|
|
cpu_fprintf(f, "direct jump count %d (%d%%) (2 jumps=%d %d%%)\n",
|
|
|
|
direct_jmp_count,
|
2013-01-31 19:47:23 +01:00
|
|
|
tcg_ctx.tb_ctx.nb_tbs ? (direct_jmp_count * 100) /
|
|
|
|
tcg_ctx.tb_ctx.nb_tbs : 0,
|
2012-12-02 17:04:43 +01:00
|
|
|
direct_jmp2_count,
|
2013-01-31 19:47:23 +01:00
|
|
|
tcg_ctx.tb_ctx.nb_tbs ? (direct_jmp2_count * 100) /
|
|
|
|
tcg_ctx.tb_ctx.nb_tbs : 0);
|
2012-12-02 17:04:43 +01:00
|
|
|
cpu_fprintf(f, "\nStatistics:\n");
|
2013-01-31 19:47:23 +01:00
|
|
|
cpu_fprintf(f, "TB flush count %d\n", tcg_ctx.tb_ctx.tb_flush_count);
|
|
|
|
cpu_fprintf(f, "TB invalidate count %d\n",
|
|
|
|
tcg_ctx.tb_ctx.tb_phys_invalidate_count);
|
2012-12-02 17:04:43 +01:00
|
|
|
cpu_fprintf(f, "TLB flush count %d\n", tlb_flush_count);
|
|
|
|
tcg_dump_info(f, cpu_fprintf);
|
|
|
|
}
|
|
|
|
|
2014-11-02 09:04:18 +01:00
|
|
|
void dump_opcount_info(FILE *f, fprintf_function cpu_fprintf)
|
|
|
|
{
|
|
|
|
tcg_dump_op_count(f, cpu_fprintf);
|
|
|
|
}
|
|
|
|
|
2012-12-02 17:04:43 +01:00
|
|
|
#else /* CONFIG_USER_ONLY */
|
|
|
|
|
2013-01-18 15:03:43 +01:00
|
|
|
void cpu_interrupt(CPUState *cpu, int mask)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
2013-01-17 18:51:17 +01:00
|
|
|
cpu->interrupt_request |= mask;
|
2013-02-22 19:10:03 +01:00
|
|
|
cpu->tcg_exit_req = 1;
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Walks guest process memory "regions" one by one
|
|
|
|
* and calls callback function 'fn' for each region.
|
|
|
|
*/
|
|
|
|
struct walk_memory_regions_data {
|
|
|
|
walk_memory_regions_fn fn;
|
|
|
|
void *priv;
|
2014-09-08 15:28:56 +02:00
|
|
|
target_ulong start;
|
2012-12-02 17:04:43 +01:00
|
|
|
int prot;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int walk_memory_regions_end(struct walk_memory_regions_data *data,
|
2014-09-08 15:28:56 +02:00
|
|
|
target_ulong end, int new_prot)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
2014-09-08 15:28:56 +02:00
|
|
|
if (data->start != -1u) {
|
2012-12-02 17:04:43 +01:00
|
|
|
int rc = data->fn(data->priv, data->start, end, data->prot);
|
|
|
|
if (rc != 0) {
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-08 15:28:56 +02:00
|
|
|
data->start = (new_prot ? end : -1u);
|
2012-12-02 17:04:43 +01:00
|
|
|
data->prot = new_prot;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int walk_memory_regions_1(struct walk_memory_regions_data *data,
|
2014-09-08 15:28:56 +02:00
|
|
|
target_ulong base, int level, void **lp)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
2014-09-08 15:28:56 +02:00
|
|
|
target_ulong pa;
|
2012-12-02 17:04:43 +01:00
|
|
|
int i, rc;
|
|
|
|
|
|
|
|
if (*lp == NULL) {
|
|
|
|
return walk_memory_regions_end(data, base, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (level == 0) {
|
|
|
|
PageDesc *pd = *lp;
|
|
|
|
|
2013-11-07 17:14:36 +01:00
|
|
|
for (i = 0; i < V_L2_SIZE; ++i) {
|
2012-12-02 17:04:43 +01:00
|
|
|
int prot = pd[i].flags;
|
|
|
|
|
|
|
|
pa = base | (i << TARGET_PAGE_BITS);
|
|
|
|
if (prot != data->prot) {
|
|
|
|
rc = walk_memory_regions_end(data, pa, prot);
|
|
|
|
if (rc != 0) {
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
void **pp = *lp;
|
|
|
|
|
2013-11-07 17:14:36 +01:00
|
|
|
for (i = 0; i < V_L2_SIZE; ++i) {
|
2014-09-08 15:28:56 +02:00
|
|
|
pa = base | ((target_ulong)i <<
|
2013-11-07 17:14:36 +01:00
|
|
|
(TARGET_PAGE_BITS + V_L2_BITS * level));
|
2012-12-02 17:04:43 +01:00
|
|
|
rc = walk_memory_regions_1(data, pa, level - 1, pp + i);
|
|
|
|
if (rc != 0) {
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int walk_memory_regions(void *priv, walk_memory_regions_fn fn)
|
|
|
|
{
|
|
|
|
struct walk_memory_regions_data data;
|
|
|
|
uintptr_t i;
|
|
|
|
|
|
|
|
data.fn = fn;
|
|
|
|
data.priv = priv;
|
2014-09-08 15:28:56 +02:00
|
|
|
data.start = -1u;
|
2012-12-02 17:04:43 +01:00
|
|
|
data.prot = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < V_L1_SIZE; i++) {
|
2014-09-08 15:28:56 +02:00
|
|
|
int rc = walk_memory_regions_1(&data, (target_ulong)i << (V_L1_SHIFT + TARGET_PAGE_BITS),
|
2013-11-07 17:14:36 +01:00
|
|
|
V_L1_SHIFT / V_L2_BITS - 1, l1_map + i);
|
2012-12-02 17:04:43 +01:00
|
|
|
if (rc != 0) {
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return walk_memory_regions_end(&data, 0, 0);
|
|
|
|
}
|
|
|
|
|
2014-09-08 15:28:56 +02:00
|
|
|
static int dump_region(void *priv, target_ulong start,
|
|
|
|
target_ulong end, unsigned long prot)
|
2012-12-02 17:04:43 +01:00
|
|
|
{
|
|
|
|
FILE *f = (FILE *)priv;
|
|
|
|
|
2014-09-08 15:28:56 +02:00
|
|
|
(void) fprintf(f, TARGET_FMT_lx"-"TARGET_FMT_lx
|
|
|
|
" "TARGET_FMT_lx" %c%c%c\n",
|
2012-12-02 17:04:43 +01:00
|
|
|
start, end, end - start,
|
|
|
|
((prot & PAGE_READ) ? 'r' : '-'),
|
|
|
|
((prot & PAGE_WRITE) ? 'w' : '-'),
|
|
|
|
((prot & PAGE_EXEC) ? 'x' : '-'));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* dump memory mappings */
|
|
|
|
void page_dump(FILE *f)
|
|
|
|
{
|
2014-09-08 15:28:56 +02:00
|
|
|
const int length = sizeof(target_ulong) * 2;
|
2013-09-12 20:09:06 +02:00
|
|
|
(void) fprintf(f, "%-*s %-*s %-*s %s\n",
|
|
|
|
length, "start", length, "end", length, "size", "prot");
|
2012-12-02 17:04:43 +01:00
|
|
|
walk_memory_regions(f, dump_region);
|
|
|
|
}
|
|
|
|
|
|
|
|
int page_get_flags(target_ulong address)
|
|
|
|
{
|
|
|
|
PageDesc *p;
|
|
|
|
|
|
|
|
p = page_find(address >> TARGET_PAGE_BITS);
|
|
|
|
if (!p) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return p->flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Modify the flags of a page and invalidate the code if necessary.
|
|
|
|
The flag PAGE_WRITE_ORG is positioned automatically depending
|
|
|
|
on PAGE_WRITE. The mmap_lock should already be held. */
|
|
|
|
void page_set_flags(target_ulong start, target_ulong end, int flags)
|
|
|
|
{
|
|
|
|
target_ulong addr, len;
|
|
|
|
|
|
|
|
/* This function should never be called with addresses outside the
|
|
|
|
guest address space. If this assert fires, it probably indicates
|
|
|
|
a missing call to h2g_valid. */
|
|
|
|
#if TARGET_ABI_BITS > L1_MAP_ADDR_SPACE_BITS
|
2014-09-08 15:28:56 +02:00
|
|
|
assert(end < ((target_ulong)1 << L1_MAP_ADDR_SPACE_BITS));
|
2012-12-02 17:04:43 +01:00
|
|
|
#endif
|
|
|
|
assert(start < end);
|
|
|
|
|
|
|
|
start = start & TARGET_PAGE_MASK;
|
|
|
|
end = TARGET_PAGE_ALIGN(end);
|
|
|
|
|
|
|
|
if (flags & PAGE_WRITE) {
|
|
|
|
flags |= PAGE_WRITE_ORG;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (addr = start, len = end - start;
|
|
|
|
len != 0;
|
|
|
|
len -= TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
|
|
|
|
PageDesc *p = page_find_alloc(addr >> TARGET_PAGE_BITS, 1);
|
|
|
|
|
|
|
|
/* If the write protection bit is set, then we invalidate
|
|
|
|
the code inside. */
|
|
|
|
if (!(p->flags & PAGE_WRITE) &&
|
|
|
|
(flags & PAGE_WRITE) &&
|
|
|
|
p->first_tb) {
|
2013-07-06 14:17:57 +02:00
|
|
|
tb_invalidate_phys_page(addr, 0, NULL, false);
|
2012-12-02 17:04:43 +01:00
|
|
|
}
|
|
|
|
p->flags = flags;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int page_check_range(target_ulong start, target_ulong len, int flags)
|
|
|
|
{
|
|
|
|
PageDesc *p;
|
|
|
|
target_ulong end;
|
|
|
|
target_ulong addr;
|
|
|
|
|
|
|
|
/* This function should never be called with addresses outside the
|
|
|
|
guest address space. If this assert fires, it probably indicates
|
|
|
|
a missing call to h2g_valid. */
|
|
|
|
#if TARGET_ABI_BITS > L1_MAP_ADDR_SPACE_BITS
|
2014-09-08 15:28:56 +02:00
|
|
|
assert(start < ((target_ulong)1 << L1_MAP_ADDR_SPACE_BITS));
|
2012-12-02 17:04:43 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
if (len == 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (start + len - 1 < start) {
|
|
|
|
/* We've wrapped around. */
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* must do before we loose bits in the next step */
|
|
|
|
end = TARGET_PAGE_ALIGN(start + len);
|
|
|
|
start = start & TARGET_PAGE_MASK;
|
|
|
|
|
|
|
|
for (addr = start, len = end - start;
|
|
|
|
len != 0;
|
|
|
|
len -= TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
|
|
|
|
p = page_find(addr >> TARGET_PAGE_BITS);
|
|
|
|
if (!p) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (!(p->flags & PAGE_VALID)) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((flags & PAGE_READ) && !(p->flags & PAGE_READ)) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (flags & PAGE_WRITE) {
|
|
|
|
if (!(p->flags & PAGE_WRITE_ORG)) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
/* unprotect the page if it was put read-only because it
|
|
|
|
contains translated code */
|
|
|
|
if (!(p->flags & PAGE_WRITE)) {
|
|
|
|
if (!page_unprotect(addr, 0, NULL)) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* called from signal handler: invalidate the code and unprotect the
|
|
|
|
page. Return TRUE if the fault was successfully handled. */
|
|
|
|
int page_unprotect(target_ulong address, uintptr_t pc, void *puc)
|
|
|
|
{
|
|
|
|
unsigned int prot;
|
|
|
|
PageDesc *p;
|
|
|
|
target_ulong host_start, host_end, addr;
|
|
|
|
|
|
|
|
/* Technically this isn't safe inside a signal handler. However we
|
|
|
|
know this only ever happens in a synchronous SEGV handler, so in
|
|
|
|
practice it seems to be ok. */
|
|
|
|
mmap_lock();
|
|
|
|
|
|
|
|
p = page_find(address >> TARGET_PAGE_BITS);
|
|
|
|
if (!p) {
|
|
|
|
mmap_unlock();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if the page was really writable, then we change its
|
|
|
|
protection back to writable */
|
|
|
|
if ((p->flags & PAGE_WRITE_ORG) && !(p->flags & PAGE_WRITE)) {
|
|
|
|
host_start = address & qemu_host_page_mask;
|
|
|
|
host_end = host_start + qemu_host_page_size;
|
|
|
|
|
|
|
|
prot = 0;
|
|
|
|
for (addr = host_start ; addr < host_end ; addr += TARGET_PAGE_SIZE) {
|
|
|
|
p = page_find(addr >> TARGET_PAGE_BITS);
|
|
|
|
p->flags |= PAGE_WRITE;
|
|
|
|
prot |= p->flags;
|
|
|
|
|
|
|
|
/* and since the content will be modified, we must invalidate
|
|
|
|
the corresponding translated code. */
|
2013-07-06 14:17:57 +02:00
|
|
|
tb_invalidate_phys_page(addr, pc, puc, true);
|
2012-12-02 17:04:43 +01:00
|
|
|
#ifdef DEBUG_TB_CHECK
|
|
|
|
tb_invalidate_check(addr);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
mprotect((void *)g2h(host_start), qemu_host_page_size,
|
|
|
|
prot & PAGE_BITS);
|
|
|
|
|
|
|
|
mmap_unlock();
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
mmap_unlock();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_USER_ONLY */
|