]> git.proxmox.com Git - mirror_qemu.git/blame - translate-all.c
target-ppc: VSX Stage 4: Refactor lxsdx
[mirror_qemu.git] / translate-all.c
CommitLineData
d19893da
FB
1/*
2 * Host code generation
5fafdf24 3 *
d19893da
FB
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
8167ee88 17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
d19893da 18 */
5b6dd868
BS
19#ifdef _WIN32
20#include <windows.h>
21#else
22#include <sys/types.h>
23#include <sys/mman.h>
24#endif
d19893da
FB
25#include <stdarg.h>
26#include <stdlib.h>
27#include <stdio.h>
28#include <string.h>
29#include <inttypes.h>
30
31#include "config.h"
2054396a 32
5b6dd868 33#include "qemu-common.h"
af5ad107 34#define NO_CPU_IO_DEFS
d3eead2e 35#include "cpu.h"
76cad711 36#include "disas/disas.h"
57fec1fe 37#include "tcg.h"
5b6dd868
BS
38#if defined(CONFIG_USER_ONLY)
39#include "qemu.h"
40#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
41#include <sys/param.h>
42#if __FreeBSD_version >= 700104
43#define HAVE_KINFO_GETVMMAP
44#define sigqueue sigqueue_freebsd /* avoid redefinition */
45#include <sys/time.h>
46#include <sys/proc.h>
47#include <machine/profile.h>
48#define _KERNEL
49#include <sys/user.h>
50#undef _KERNEL
51#undef sigqueue
52#include <libutil.h>
53#endif
54#endif
0bc3cd62
PB
55#else
56#include "exec/address-spaces.h"
5b6dd868
BS
57#endif
58
022c62cb 59#include "exec/cputlb.h"
5b6dd868 60#include "translate-all.h"
0aa09897 61#include "qemu/timer.h"
5b6dd868
BS
62
63//#define DEBUG_TB_INVALIDATE
64//#define DEBUG_FLUSH
65/* make various TB consistency checks */
66//#define DEBUG_TB_CHECK
67
68#if !defined(CONFIG_USER_ONLY)
69/* TB consistency checks only implemented for usermode emulation. */
70#undef DEBUG_TB_CHECK
71#endif
72
73#define SMC_BITMAP_USE_THRESHOLD 10
74
5b6dd868
BS
75typedef struct PageDesc {
76 /* list of TBs intersecting this ram page */
77 TranslationBlock *first_tb;
78 /* in order to optimize self modifying code, we count the number
79 of lookups we do to a given page to use a bitmap */
80 unsigned int code_write_count;
81 uint8_t *code_bitmap;
82#if defined(CONFIG_USER_ONLY)
83 unsigned long flags;
84#endif
85} PageDesc;
86
87/* In system mode we want L1_MAP to be based on ram offsets,
88 while in user mode we want it to be based on virtual addresses. */
89#if !defined(CONFIG_USER_ONLY)
90#if HOST_LONG_BITS < TARGET_PHYS_ADDR_SPACE_BITS
91# define L1_MAP_ADDR_SPACE_BITS HOST_LONG_BITS
92#else
93# define L1_MAP_ADDR_SPACE_BITS TARGET_PHYS_ADDR_SPACE_BITS
94#endif
95#else
96# define L1_MAP_ADDR_SPACE_BITS TARGET_VIRT_ADDR_SPACE_BITS
97#endif
98
03f49957
PB
99/* Size of the L2 (and L3, etc) page tables. */
100#define V_L2_BITS 10
101#define V_L2_SIZE (1 << V_L2_BITS)
102
5b6dd868
BS
103/* The bits remaining after N lower levels of page tables. */
104#define V_L1_BITS_REM \
03f49957 105 ((L1_MAP_ADDR_SPACE_BITS - TARGET_PAGE_BITS) % V_L2_BITS)
5b6dd868
BS
106
107#if V_L1_BITS_REM < 4
03f49957 108#define V_L1_BITS (V_L1_BITS_REM + V_L2_BITS)
5b6dd868
BS
109#else
110#define V_L1_BITS V_L1_BITS_REM
111#endif
112
113#define V_L1_SIZE ((target_ulong)1 << V_L1_BITS)
114
115#define V_L1_SHIFT (L1_MAP_ADDR_SPACE_BITS - TARGET_PAGE_BITS - V_L1_BITS)
116
117uintptr_t qemu_real_host_page_size;
118uintptr_t qemu_host_page_size;
119uintptr_t qemu_host_page_mask;
120
121/* This is a multi-level map on the virtual address space.
122 The bottom level has pointers to PageDesc. */
123static void *l1_map[V_L1_SIZE];
124
57fec1fe
FB
125/* code generation context */
126TCGContext tcg_ctx;
d19893da 127
5b6dd868
BS
128static void tb_link_page(TranslationBlock *tb, tb_page_addr_t phys_pc,
129 tb_page_addr_t phys_page2);
a8a826a3 130static TranslationBlock *tb_find_pc(uintptr_t tc_ptr);
5b6dd868 131
57fec1fe
FB
132void cpu_gen_init(void)
133{
134 tcg_context_init(&tcg_ctx);
57fec1fe
FB
135}
136
d19893da 137/* return non zero if the very first instruction is invalid so that
5fafdf24 138 the virtual CPU can trigger an exception.
d19893da
FB
139
140 '*gen_code_size_ptr' contains the size of the generated code (host
141 code).
142*/
9349b4f9 143int cpu_gen_code(CPUArchState *env, TranslationBlock *tb, int *gen_code_size_ptr)
d19893da 144{
57fec1fe 145 TCGContext *s = &tcg_ctx;
d19893da
FB
146 uint8_t *gen_code_buf;
147 int gen_code_size;
57fec1fe
FB
148#ifdef CONFIG_PROFILER
149 int64_t ti;
150#endif
151
152#ifdef CONFIG_PROFILER
b67d9a52
FB
153 s->tb_count1++; /* includes aborted translations because of
154 exceptions */
57fec1fe
FB
155 ti = profile_getclock();
156#endif
157 tcg_func_start(s);
d19893da 158
2cfc5f17
TS
159 gen_intermediate_code(env, tb);
160
ec6338ba 161 /* generate machine code */
57fec1fe 162 gen_code_buf = tb->tc_ptr;
ec6338ba
FB
163 tb->tb_next_offset[0] = 0xffff;
164 tb->tb_next_offset[1] = 0xffff;
57fec1fe 165 s->tb_next_offset = tb->tb_next_offset;
4cbb86e1 166#ifdef USE_DIRECT_JUMP
57fec1fe
FB
167 s->tb_jmp_offset = tb->tb_jmp_offset;
168 s->tb_next = NULL;
d19893da 169#else
57fec1fe
FB
170 s->tb_jmp_offset = NULL;
171 s->tb_next = tb->tb_next;
d19893da 172#endif
57fec1fe
FB
173
174#ifdef CONFIG_PROFILER
b67d9a52
FB
175 s->tb_count++;
176 s->interm_time += profile_getclock() - ti;
177 s->code_time -= profile_getclock();
57fec1fe 178#endif
54604f74 179 gen_code_size = tcg_gen_code(s, gen_code_buf);
d19893da 180 *gen_code_size_ptr = gen_code_size;
57fec1fe 181#ifdef CONFIG_PROFILER
b67d9a52
FB
182 s->code_time += profile_getclock();
183 s->code_in_len += tb->size;
184 s->code_out_len += gen_code_size;
57fec1fe
FB
185#endif
186
d19893da 187#ifdef DEBUG_DISAS
8fec2b8c 188 if (qemu_loglevel_mask(CPU_LOG_TB_OUT_ASM)) {
93fcfe39
AL
189 qemu_log("OUT: [size=%d]\n", *gen_code_size_ptr);
190 log_disas(tb->tc_ptr, *gen_code_size_ptr);
191 qemu_log("\n");
31b1a7b4 192 qemu_log_flush();
d19893da
FB
193 }
194#endif
195 return 0;
196}
197
5fafdf24 198/* The cpu state corresponding to 'searched_pc' is restored.
d19893da 199 */
a8a826a3
BS
200static int cpu_restore_state_from_tb(TranslationBlock *tb, CPUArchState *env,
201 uintptr_t searched_pc)
d19893da 202{
57fec1fe
FB
203 TCGContext *s = &tcg_ctx;
204 int j;
6375e09e 205 uintptr_t tc_ptr;
57fec1fe
FB
206#ifdef CONFIG_PROFILER
207 int64_t ti;
208#endif
209
210#ifdef CONFIG_PROFILER
211 ti = profile_getclock();
212#endif
213 tcg_func_start(s);
d19893da 214
2cfc5f17 215 gen_intermediate_code_pc(env, tb);
3b46e624 216
2e70f6ef
PB
217 if (use_icount) {
218 /* Reset the cycle counter to the start of the block. */
219 env->icount_decr.u16.low += tb->icount;
220 /* Clear the IO flag. */
221 env->can_do_io = 0;
222 }
223
d19893da 224 /* find opc index corresponding to search_pc */
6375e09e 225 tc_ptr = (uintptr_t)tb->tc_ptr;
d19893da
FB
226 if (searched_pc < tc_ptr)
227 return -1;
57fec1fe
FB
228
229 s->tb_next_offset = tb->tb_next_offset;
230#ifdef USE_DIRECT_JUMP
231 s->tb_jmp_offset = tb->tb_jmp_offset;
232 s->tb_next = NULL;
233#else
234 s->tb_jmp_offset = NULL;
235 s->tb_next = tb->tb_next;
236#endif
54604f74 237 j = tcg_gen_code_search_pc(s, (uint8_t *)tc_ptr, searched_pc - tc_ptr);
57fec1fe
FB
238 if (j < 0)
239 return -1;
d19893da 240 /* now find start of instruction before */
ab1103de 241 while (s->gen_opc_instr_start[j] == 0) {
d19893da 242 j--;
ab1103de 243 }
c9c99c22 244 env->icount_decr.u16.low -= s->gen_opc_icount[j];
3b46e624 245
e87b7cb0 246 restore_state_to_opc(env, tb, j);
57fec1fe
FB
247
248#ifdef CONFIG_PROFILER
b67d9a52
FB
249 s->restore_time += profile_getclock() - ti;
250 s->restore_count++;
57fec1fe 251#endif
d19893da
FB
252 return 0;
253}
5b6dd868 254
a8a826a3
BS
255bool cpu_restore_state(CPUArchState *env, uintptr_t retaddr)
256{
257 TranslationBlock *tb;
258
259 tb = tb_find_pc(retaddr);
260 if (tb) {
261 cpu_restore_state_from_tb(tb, env, retaddr);
262 return true;
263 }
264 return false;
265}
266
5b6dd868
BS
267#ifdef _WIN32
268static inline void map_exec(void *addr, long size)
269{
270 DWORD old_protect;
271 VirtualProtect(addr, size,
272 PAGE_EXECUTE_READWRITE, &old_protect);
273}
274#else
275static inline void map_exec(void *addr, long size)
276{
277 unsigned long start, end, page_size;
278
279 page_size = getpagesize();
280 start = (unsigned long)addr;
281 start &= ~(page_size - 1);
282
283 end = (unsigned long)addr + size;
284 end += page_size - 1;
285 end &= ~(page_size - 1);
286
287 mprotect((void *)start, end - start,
288 PROT_READ | PROT_WRITE | PROT_EXEC);
289}
290#endif
291
47c16ed5 292void page_size_init(void)
5b6dd868
BS
293{
294 /* NOTE: we can always suppose that qemu_host_page_size >=
295 TARGET_PAGE_SIZE */
296#ifdef _WIN32
47c16ed5 297 SYSTEM_INFO system_info;
5b6dd868 298
47c16ed5
AK
299 GetSystemInfo(&system_info);
300 qemu_real_host_page_size = system_info.dwPageSize;
5b6dd868
BS
301#else
302 qemu_real_host_page_size = getpagesize();
303#endif
304 if (qemu_host_page_size == 0) {
305 qemu_host_page_size = qemu_real_host_page_size;
306 }
307 if (qemu_host_page_size < TARGET_PAGE_SIZE) {
308 qemu_host_page_size = TARGET_PAGE_SIZE;
309 }
310 qemu_host_page_mask = ~(qemu_host_page_size - 1);
47c16ed5 311}
5b6dd868 312
47c16ed5
AK
313static void page_init(void)
314{
315 page_size_init();
5b6dd868
BS
316#if defined(CONFIG_BSD) && defined(CONFIG_USER_ONLY)
317 {
318#ifdef HAVE_KINFO_GETVMMAP
319 struct kinfo_vmentry *freep;
320 int i, cnt;
321
322 freep = kinfo_getvmmap(getpid(), &cnt);
323 if (freep) {
324 mmap_lock();
325 for (i = 0; i < cnt; i++) {
326 unsigned long startaddr, endaddr;
327
328 startaddr = freep[i].kve_start;
329 endaddr = freep[i].kve_end;
330 if (h2g_valid(startaddr)) {
331 startaddr = h2g(startaddr) & TARGET_PAGE_MASK;
332
333 if (h2g_valid(endaddr)) {
334 endaddr = h2g(endaddr);
335 page_set_flags(startaddr, endaddr, PAGE_RESERVED);
336 } else {
337#if TARGET_ABI_BITS <= L1_MAP_ADDR_SPACE_BITS
338 endaddr = ~0ul;
339 page_set_flags(startaddr, endaddr, PAGE_RESERVED);
340#endif
341 }
342 }
343 }
344 free(freep);
345 mmap_unlock();
346 }
347#else
348 FILE *f;
349
350 last_brk = (unsigned long)sbrk(0);
351
352 f = fopen("/compat/linux/proc/self/maps", "r");
353 if (f) {
354 mmap_lock();
355
356 do {
357 unsigned long startaddr, endaddr;
358 int n;
359
360 n = fscanf(f, "%lx-%lx %*[^\n]\n", &startaddr, &endaddr);
361
362 if (n == 2 && h2g_valid(startaddr)) {
363 startaddr = h2g(startaddr) & TARGET_PAGE_MASK;
364
365 if (h2g_valid(endaddr)) {
366 endaddr = h2g(endaddr);
367 } else {
368 endaddr = ~0ul;
369 }
370 page_set_flags(startaddr, endaddr, PAGE_RESERVED);
371 }
372 } while (!feof(f));
373
374 fclose(f);
375 mmap_unlock();
376 }
377#endif
378 }
379#endif
380}
381
382static PageDesc *page_find_alloc(tb_page_addr_t index, int alloc)
383{
384 PageDesc *pd;
385 void **lp;
386 int i;
387
388#if defined(CONFIG_USER_ONLY)
389 /* We can't use g_malloc because it may recurse into a locked mutex. */
390# define ALLOC(P, SIZE) \
391 do { \
392 P = mmap(NULL, SIZE, PROT_READ | PROT_WRITE, \
393 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); \
394 } while (0)
395#else
396# define ALLOC(P, SIZE) \
397 do { P = g_malloc0(SIZE); } while (0)
398#endif
399
400 /* Level 1. Always allocated. */
401 lp = l1_map + ((index >> V_L1_SHIFT) & (V_L1_SIZE - 1));
402
403 /* Level 2..N-1. */
03f49957 404 for (i = V_L1_SHIFT / V_L2_BITS - 1; i > 0; i--) {
5b6dd868
BS
405 void **p = *lp;
406
407 if (p == NULL) {
408 if (!alloc) {
409 return NULL;
410 }
03f49957 411 ALLOC(p, sizeof(void *) * V_L2_SIZE);
5b6dd868
BS
412 *lp = p;
413 }
414
03f49957 415 lp = p + ((index >> (i * V_L2_BITS)) & (V_L2_SIZE - 1));
5b6dd868
BS
416 }
417
418 pd = *lp;
419 if (pd == NULL) {
420 if (!alloc) {
421 return NULL;
422 }
03f49957 423 ALLOC(pd, sizeof(PageDesc) * V_L2_SIZE);
5b6dd868
BS
424 *lp = pd;
425 }
426
427#undef ALLOC
428
03f49957 429 return pd + (index & (V_L2_SIZE - 1));
5b6dd868
BS
430}
431
432static inline PageDesc *page_find(tb_page_addr_t index)
433{
434 return page_find_alloc(index, 0);
435}
436
437#if !defined(CONFIG_USER_ONLY)
438#define mmap_lock() do { } while (0)
439#define mmap_unlock() do { } while (0)
440#endif
441
442#if defined(CONFIG_USER_ONLY)
443/* Currently it is not recommended to allocate big chunks of data in
444 user mode. It will change when a dedicated libc will be used. */
445/* ??? 64-bit hosts ought to have no problem mmaping data outside the
446 region in which the guest needs to run. Revisit this. */
447#define USE_STATIC_CODE_GEN_BUFFER
448#endif
449
450/* ??? Should configure for this, not list operating systems here. */
451#if (defined(__linux__) \
452 || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) \
453 || defined(__DragonFly__) || defined(__OpenBSD__) \
454 || defined(__NetBSD__))
455# define USE_MMAP
456#endif
457
458/* Minimum size of the code gen buffer. This number is randomly chosen,
459 but not so small that we can't have a fair number of TB's live. */
460#define MIN_CODE_GEN_BUFFER_SIZE (1024u * 1024)
461
462/* Maximum size of the code gen buffer we'd like to use. Unless otherwise
463 indicated, this is constrained by the range of direct branches on the
464 host cpu, as used by the TCG implementation of goto_tb. */
465#if defined(__x86_64__)
466# define MAX_CODE_GEN_BUFFER_SIZE (2ul * 1024 * 1024 * 1024)
467#elif defined(__sparc__)
468# define MAX_CODE_GEN_BUFFER_SIZE (2ul * 1024 * 1024 * 1024)
4a136e0a
CF
469#elif defined(__aarch64__)
470# define MAX_CODE_GEN_BUFFER_SIZE (128ul * 1024 * 1024)
5b6dd868
BS
471#elif defined(__arm__)
472# define MAX_CODE_GEN_BUFFER_SIZE (16u * 1024 * 1024)
473#elif defined(__s390x__)
474 /* We have a +- 4GB range on the branches; leave some slop. */
475# define MAX_CODE_GEN_BUFFER_SIZE (3ul * 1024 * 1024 * 1024)
476#else
477# define MAX_CODE_GEN_BUFFER_SIZE ((size_t)-1)
478#endif
479
480#define DEFAULT_CODE_GEN_BUFFER_SIZE_1 (32u * 1024 * 1024)
481
482#define DEFAULT_CODE_GEN_BUFFER_SIZE \
483 (DEFAULT_CODE_GEN_BUFFER_SIZE_1 < MAX_CODE_GEN_BUFFER_SIZE \
484 ? DEFAULT_CODE_GEN_BUFFER_SIZE_1 : MAX_CODE_GEN_BUFFER_SIZE)
485
486static inline size_t size_code_gen_buffer(size_t tb_size)
487{
488 /* Size the buffer. */
489 if (tb_size == 0) {
490#ifdef USE_STATIC_CODE_GEN_BUFFER
491 tb_size = DEFAULT_CODE_GEN_BUFFER_SIZE;
492#else
493 /* ??? Needs adjustments. */
494 /* ??? If we relax the requirement that CONFIG_USER_ONLY use the
495 static buffer, we could size this on RESERVED_VA, on the text
496 segment size of the executable, or continue to use the default. */
497 tb_size = (unsigned long)(ram_size / 4);
498#endif
499 }
500 if (tb_size < MIN_CODE_GEN_BUFFER_SIZE) {
501 tb_size = MIN_CODE_GEN_BUFFER_SIZE;
502 }
503 if (tb_size > MAX_CODE_GEN_BUFFER_SIZE) {
504 tb_size = MAX_CODE_GEN_BUFFER_SIZE;
505 }
0b0d3320 506 tcg_ctx.code_gen_buffer_size = tb_size;
5b6dd868
BS
507 return tb_size;
508}
509
510#ifdef USE_STATIC_CODE_GEN_BUFFER
511static uint8_t static_code_gen_buffer[DEFAULT_CODE_GEN_BUFFER_SIZE]
512 __attribute__((aligned(CODE_GEN_ALIGN)));
513
514static inline void *alloc_code_gen_buffer(void)
515{
0b0d3320 516 map_exec(static_code_gen_buffer, tcg_ctx.code_gen_buffer_size);
5b6dd868
BS
517 return static_code_gen_buffer;
518}
519#elif defined(USE_MMAP)
520static inline void *alloc_code_gen_buffer(void)
521{
522 int flags = MAP_PRIVATE | MAP_ANONYMOUS;
523 uintptr_t start = 0;
524 void *buf;
525
526 /* Constrain the position of the buffer based on the host cpu.
527 Note that these addresses are chosen in concert with the
528 addresses assigned in the relevant linker script file. */
529# if defined(__PIE__) || defined(__PIC__)
530 /* Don't bother setting a preferred location if we're building
531 a position-independent executable. We're more likely to get
532 an address near the main executable if we let the kernel
533 choose the address. */
534# elif defined(__x86_64__) && defined(MAP_32BIT)
535 /* Force the memory down into low memory with the executable.
536 Leave the choice of exact location with the kernel. */
537 flags |= MAP_32BIT;
538 /* Cannot expect to map more than 800MB in low memory. */
0b0d3320
EV
539 if (tcg_ctx.code_gen_buffer_size > 800u * 1024 * 1024) {
540 tcg_ctx.code_gen_buffer_size = 800u * 1024 * 1024;
5b6dd868
BS
541 }
542# elif defined(__sparc__)
543 start = 0x40000000ul;
544# elif defined(__s390x__)
545 start = 0x90000000ul;
546# endif
547
0b0d3320 548 buf = mmap((void *)start, tcg_ctx.code_gen_buffer_size,
5b6dd868
BS
549 PROT_WRITE | PROT_READ | PROT_EXEC, flags, -1, 0);
550 return buf == MAP_FAILED ? NULL : buf;
551}
552#else
553static inline void *alloc_code_gen_buffer(void)
554{
0b0d3320 555 void *buf = g_malloc(tcg_ctx.code_gen_buffer_size);
5b6dd868
BS
556
557 if (buf) {
0b0d3320 558 map_exec(buf, tcg_ctx.code_gen_buffer_size);
5b6dd868
BS
559 }
560 return buf;
561}
562#endif /* USE_STATIC_CODE_GEN_BUFFER, USE_MMAP */
563
564static inline void code_gen_alloc(size_t tb_size)
565{
0b0d3320
EV
566 tcg_ctx.code_gen_buffer_size = size_code_gen_buffer(tb_size);
567 tcg_ctx.code_gen_buffer = alloc_code_gen_buffer();
568 if (tcg_ctx.code_gen_buffer == NULL) {
5b6dd868
BS
569 fprintf(stderr, "Could not allocate dynamic translator buffer\n");
570 exit(1);
571 }
572
0b0d3320
EV
573 qemu_madvise(tcg_ctx.code_gen_buffer, tcg_ctx.code_gen_buffer_size,
574 QEMU_MADV_HUGEPAGE);
5b6dd868
BS
575
576 /* Steal room for the prologue at the end of the buffer. This ensures
577 (via the MAX_CODE_GEN_BUFFER_SIZE limits above) that direct branches
578 from TB's to the prologue are going to be in range. It also means
579 that we don't need to mark (additional) portions of the data segment
580 as executable. */
0b0d3320
EV
581 tcg_ctx.code_gen_prologue = tcg_ctx.code_gen_buffer +
582 tcg_ctx.code_gen_buffer_size - 1024;
583 tcg_ctx.code_gen_buffer_size -= 1024;
5b6dd868 584
0b0d3320 585 tcg_ctx.code_gen_buffer_max_size = tcg_ctx.code_gen_buffer_size -
5b6dd868 586 (TCG_MAX_OP_SIZE * OPC_BUF_SIZE);
0b0d3320
EV
587 tcg_ctx.code_gen_max_blocks = tcg_ctx.code_gen_buffer_size /
588 CODE_GEN_AVG_BLOCK_SIZE;
5e5f07e0
EV
589 tcg_ctx.tb_ctx.tbs =
590 g_malloc(tcg_ctx.code_gen_max_blocks * sizeof(TranslationBlock));
5b6dd868
BS
591}
592
593/* Must be called before using the QEMU cpus. 'tb_size' is the size
594 (in bytes) allocated to the translation buffer. Zero means default
595 size. */
596void tcg_exec_init(unsigned long tb_size)
597{
598 cpu_gen_init();
599 code_gen_alloc(tb_size);
0b0d3320
EV
600 tcg_ctx.code_gen_ptr = tcg_ctx.code_gen_buffer;
601 tcg_register_jit(tcg_ctx.code_gen_buffer, tcg_ctx.code_gen_buffer_size);
5b6dd868
BS
602 page_init();
603#if !defined(CONFIG_USER_ONLY) || !defined(CONFIG_USE_GUEST_BASE)
604 /* There's no guest base to take into account, so go ahead and
605 initialize the prologue now. */
606 tcg_prologue_init(&tcg_ctx);
607#endif
608}
609
610bool tcg_enabled(void)
611{
0b0d3320 612 return tcg_ctx.code_gen_buffer != NULL;
5b6dd868
BS
613}
614
615/* Allocate a new translation block. Flush the translation buffer if
616 too many translation blocks or too much generated code. */
617static TranslationBlock *tb_alloc(target_ulong pc)
618{
619 TranslationBlock *tb;
620
5e5f07e0 621 if (tcg_ctx.tb_ctx.nb_tbs >= tcg_ctx.code_gen_max_blocks ||
0b0d3320
EV
622 (tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer) >=
623 tcg_ctx.code_gen_buffer_max_size) {
5b6dd868
BS
624 return NULL;
625 }
5e5f07e0 626 tb = &tcg_ctx.tb_ctx.tbs[tcg_ctx.tb_ctx.nb_tbs++];
5b6dd868
BS
627 tb->pc = pc;
628 tb->cflags = 0;
629 return tb;
630}
631
632void tb_free(TranslationBlock *tb)
633{
634 /* In practice this is mostly used for single use temporary TB
635 Ignore the hard cases and just back up if this TB happens to
636 be the last one generated. */
5e5f07e0
EV
637 if (tcg_ctx.tb_ctx.nb_tbs > 0 &&
638 tb == &tcg_ctx.tb_ctx.tbs[tcg_ctx.tb_ctx.nb_tbs - 1]) {
0b0d3320 639 tcg_ctx.code_gen_ptr = tb->tc_ptr;
5e5f07e0 640 tcg_ctx.tb_ctx.nb_tbs--;
5b6dd868
BS
641 }
642}
643
644static inline void invalidate_page_bitmap(PageDesc *p)
645{
646 if (p->code_bitmap) {
647 g_free(p->code_bitmap);
648 p->code_bitmap = NULL;
649 }
650 p->code_write_count = 0;
651}
652
653/* Set to NULL all the 'first_tb' fields in all PageDescs. */
654static void page_flush_tb_1(int level, void **lp)
655{
656 int i;
657
658 if (*lp == NULL) {
659 return;
660 }
661 if (level == 0) {
662 PageDesc *pd = *lp;
663
03f49957 664 for (i = 0; i < V_L2_SIZE; ++i) {
5b6dd868
BS
665 pd[i].first_tb = NULL;
666 invalidate_page_bitmap(pd + i);
667 }
668 } else {
669 void **pp = *lp;
670
03f49957 671 for (i = 0; i < V_L2_SIZE; ++i) {
5b6dd868
BS
672 page_flush_tb_1(level - 1, pp + i);
673 }
674 }
675}
676
677static void page_flush_tb(void)
678{
679 int i;
680
681 for (i = 0; i < V_L1_SIZE; i++) {
03f49957 682 page_flush_tb_1(V_L1_SHIFT / V_L2_BITS - 1, l1_map + i);
5b6dd868
BS
683 }
684}
685
686/* flush all the translation blocks */
687/* XXX: tb_flush is currently not thread safe */
688void tb_flush(CPUArchState *env1)
689{
182735ef 690 CPUState *cpu;
5b6dd868
BS
691
692#if defined(DEBUG_FLUSH)
693 printf("qemu: flush code_size=%ld nb_tbs=%d avg_tb_size=%ld\n",
0b0d3320 694 (unsigned long)(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer),
5e5f07e0 695 tcg_ctx.tb_ctx.nb_tbs, tcg_ctx.tb_ctx.nb_tbs > 0 ?
0b0d3320 696 ((unsigned long)(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer)) /
5e5f07e0 697 tcg_ctx.tb_ctx.nb_tbs : 0);
5b6dd868 698#endif
0b0d3320
EV
699 if ((unsigned long)(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer)
700 > tcg_ctx.code_gen_buffer_size) {
5b6dd868
BS
701 cpu_abort(env1, "Internal error: code buffer overflow\n");
702 }
5e5f07e0 703 tcg_ctx.tb_ctx.nb_tbs = 0;
5b6dd868 704
bdc44640 705 CPU_FOREACH(cpu) {
182735ef
AF
706 CPUArchState *env = cpu->env_ptr;
707
eb2535f4 708 memset(env->tb_jmp_cache, 0, sizeof(env->tb_jmp_cache));
5b6dd868
BS
709 }
710
eb2535f4 711 memset(tcg_ctx.tb_ctx.tb_phys_hash, 0, sizeof(tcg_ctx.tb_ctx.tb_phys_hash));
5b6dd868
BS
712 page_flush_tb();
713
0b0d3320 714 tcg_ctx.code_gen_ptr = tcg_ctx.code_gen_buffer;
5b6dd868
BS
715 /* XXX: flush processor icache at this point if cache flush is
716 expensive */
5e5f07e0 717 tcg_ctx.tb_ctx.tb_flush_count++;
5b6dd868
BS
718}
719
720#ifdef DEBUG_TB_CHECK
721
722static void tb_invalidate_check(target_ulong address)
723{
724 TranslationBlock *tb;
725 int i;
726
727 address &= TARGET_PAGE_MASK;
728 for (i = 0; i < CODE_GEN_PHYS_HASH_SIZE; i++) {
5e5f07e0 729 for (tb = tb_ctx.tb_phys_hash[i]; tb != NULL; tb = tb->phys_hash_next) {
5b6dd868
BS
730 if (!(address + TARGET_PAGE_SIZE <= tb->pc ||
731 address >= tb->pc + tb->size)) {
732 printf("ERROR invalidate: address=" TARGET_FMT_lx
733 " PC=%08lx size=%04x\n",
734 address, (long)tb->pc, tb->size);
735 }
736 }
737 }
738}
739
740/* verify that all the pages have correct rights for code */
741static void tb_page_check(void)
742{
743 TranslationBlock *tb;
744 int i, flags1, flags2;
745
746 for (i = 0; i < CODE_GEN_PHYS_HASH_SIZE; i++) {
5e5f07e0
EV
747 for (tb = tcg_ctx.tb_ctx.tb_phys_hash[i]; tb != NULL;
748 tb = tb->phys_hash_next) {
5b6dd868
BS
749 flags1 = page_get_flags(tb->pc);
750 flags2 = page_get_flags(tb->pc + tb->size - 1);
751 if ((flags1 & PAGE_WRITE) || (flags2 & PAGE_WRITE)) {
752 printf("ERROR page flags: PC=%08lx size=%04x f1=%x f2=%x\n",
753 (long)tb->pc, tb->size, flags1, flags2);
754 }
755 }
756 }
757}
758
759#endif
760
0c884d16 761static inline void tb_hash_remove(TranslationBlock **ptb, TranslationBlock *tb)
5b6dd868
BS
762{
763 TranslationBlock *tb1;
764
765 for (;;) {
766 tb1 = *ptb;
767 if (tb1 == tb) {
0c884d16 768 *ptb = tb1->phys_hash_next;
5b6dd868
BS
769 break;
770 }
0c884d16 771 ptb = &tb1->phys_hash_next;
5b6dd868
BS
772 }
773}
774
775static inline void tb_page_remove(TranslationBlock **ptb, TranslationBlock *tb)
776{
777 TranslationBlock *tb1;
778 unsigned int n1;
779
780 for (;;) {
781 tb1 = *ptb;
782 n1 = (uintptr_t)tb1 & 3;
783 tb1 = (TranslationBlock *)((uintptr_t)tb1 & ~3);
784 if (tb1 == tb) {
785 *ptb = tb1->page_next[n1];
786 break;
787 }
788 ptb = &tb1->page_next[n1];
789 }
790}
791
792static inline void tb_jmp_remove(TranslationBlock *tb, int n)
793{
794 TranslationBlock *tb1, **ptb;
795 unsigned int n1;
796
797 ptb = &tb->jmp_next[n];
798 tb1 = *ptb;
799 if (tb1) {
800 /* find tb(n) in circular list */
801 for (;;) {
802 tb1 = *ptb;
803 n1 = (uintptr_t)tb1 & 3;
804 tb1 = (TranslationBlock *)((uintptr_t)tb1 & ~3);
805 if (n1 == n && tb1 == tb) {
806 break;
807 }
808 if (n1 == 2) {
809 ptb = &tb1->jmp_first;
810 } else {
811 ptb = &tb1->jmp_next[n1];
812 }
813 }
814 /* now we can suppress tb(n) from the list */
815 *ptb = tb->jmp_next[n];
816
817 tb->jmp_next[n] = NULL;
818 }
819}
820
821/* reset the jump entry 'n' of a TB so that it is not chained to
822 another TB */
823static inline void tb_reset_jump(TranslationBlock *tb, int n)
824{
825 tb_set_jmp_target(tb, n, (uintptr_t)(tb->tc_ptr + tb->tb_next_offset[n]));
826}
827
0c884d16 828/* invalidate one TB */
5b6dd868
BS
829void tb_phys_invalidate(TranslationBlock *tb, tb_page_addr_t page_addr)
830{
182735ef 831 CPUState *cpu;
5b6dd868
BS
832 PageDesc *p;
833 unsigned int h, n1;
834 tb_page_addr_t phys_pc;
835 TranslationBlock *tb1, *tb2;
836
837 /* remove the TB from the hash list */
838 phys_pc = tb->page_addr[0] + (tb->pc & ~TARGET_PAGE_MASK);
839 h = tb_phys_hash_func(phys_pc);
5e5f07e0 840 tb_hash_remove(&tcg_ctx.tb_ctx.tb_phys_hash[h], tb);
5b6dd868
BS
841
842 /* remove the TB from the page list */
843 if (tb->page_addr[0] != page_addr) {
844 p = page_find(tb->page_addr[0] >> TARGET_PAGE_BITS);
845 tb_page_remove(&p->first_tb, tb);
846 invalidate_page_bitmap(p);
847 }
848 if (tb->page_addr[1] != -1 && tb->page_addr[1] != page_addr) {
849 p = page_find(tb->page_addr[1] >> TARGET_PAGE_BITS);
850 tb_page_remove(&p->first_tb, tb);
851 invalidate_page_bitmap(p);
852 }
853
5e5f07e0 854 tcg_ctx.tb_ctx.tb_invalidated_flag = 1;
5b6dd868
BS
855
856 /* remove the TB from the hash list */
857 h = tb_jmp_cache_hash_func(tb->pc);
bdc44640 858 CPU_FOREACH(cpu) {
182735ef
AF
859 CPUArchState *env = cpu->env_ptr;
860
5b6dd868
BS
861 if (env->tb_jmp_cache[h] == tb) {
862 env->tb_jmp_cache[h] = NULL;
863 }
864 }
865
866 /* suppress this TB from the two jump lists */
867 tb_jmp_remove(tb, 0);
868 tb_jmp_remove(tb, 1);
869
870 /* suppress any remaining jumps to this TB */
871 tb1 = tb->jmp_first;
872 for (;;) {
873 n1 = (uintptr_t)tb1 & 3;
874 if (n1 == 2) {
875 break;
876 }
877 tb1 = (TranslationBlock *)((uintptr_t)tb1 & ~3);
878 tb2 = tb1->jmp_next[n1];
879 tb_reset_jump(tb1, n1);
880 tb1->jmp_next[n1] = NULL;
881 tb1 = tb2;
882 }
883 tb->jmp_first = (TranslationBlock *)((uintptr_t)tb | 2); /* fail safe */
884
5e5f07e0 885 tcg_ctx.tb_ctx.tb_phys_invalidate_count++;
5b6dd868
BS
886}
887
888static inline void set_bits(uint8_t *tab, int start, int len)
889{
890 int end, mask, end1;
891
892 end = start + len;
893 tab += start >> 3;
894 mask = 0xff << (start & 7);
895 if ((start & ~7) == (end & ~7)) {
896 if (start < end) {
897 mask &= ~(0xff << (end & 7));
898 *tab |= mask;
899 }
900 } else {
901 *tab++ |= mask;
902 start = (start + 8) & ~7;
903 end1 = end & ~7;
904 while (start < end1) {
905 *tab++ = 0xff;
906 start += 8;
907 }
908 if (start < end) {
909 mask = ~(0xff << (end & 7));
910 *tab |= mask;
911 }
912 }
913}
914
915static void build_page_bitmap(PageDesc *p)
916{
917 int n, tb_start, tb_end;
918 TranslationBlock *tb;
919
920 p->code_bitmap = g_malloc0(TARGET_PAGE_SIZE / 8);
921
922 tb = p->first_tb;
923 while (tb != NULL) {
924 n = (uintptr_t)tb & 3;
925 tb = (TranslationBlock *)((uintptr_t)tb & ~3);
926 /* NOTE: this is subtle as a TB may span two physical pages */
927 if (n == 0) {
928 /* NOTE: tb_end may be after the end of the page, but
929 it is not a problem */
930 tb_start = tb->pc & ~TARGET_PAGE_MASK;
931 tb_end = tb_start + tb->size;
932 if (tb_end > TARGET_PAGE_SIZE) {
933 tb_end = TARGET_PAGE_SIZE;
934 }
935 } else {
936 tb_start = 0;
937 tb_end = ((tb->pc + tb->size) & ~TARGET_PAGE_MASK);
938 }
939 set_bits(p->code_bitmap, tb_start, tb_end - tb_start);
940 tb = tb->page_next[n];
941 }
942}
943
944TranslationBlock *tb_gen_code(CPUArchState *env,
945 target_ulong pc, target_ulong cs_base,
946 int flags, int cflags)
947{
948 TranslationBlock *tb;
949 uint8_t *tc_ptr;
950 tb_page_addr_t phys_pc, phys_page2;
951 target_ulong virt_page2;
952 int code_gen_size;
953
954 phys_pc = get_page_addr_code(env, pc);
955 tb = tb_alloc(pc);
956 if (!tb) {
957 /* flush must be done */
958 tb_flush(env);
959 /* cannot fail at this point */
960 tb = tb_alloc(pc);
961 /* Don't forget to invalidate previous TB info. */
5e5f07e0 962 tcg_ctx.tb_ctx.tb_invalidated_flag = 1;
5b6dd868 963 }
0b0d3320 964 tc_ptr = tcg_ctx.code_gen_ptr;
5b6dd868
BS
965 tb->tc_ptr = tc_ptr;
966 tb->cs_base = cs_base;
967 tb->flags = flags;
968 tb->cflags = cflags;
969 cpu_gen_code(env, tb, &code_gen_size);
0b0d3320
EV
970 tcg_ctx.code_gen_ptr = (void *)(((uintptr_t)tcg_ctx.code_gen_ptr +
971 code_gen_size + CODE_GEN_ALIGN - 1) & ~(CODE_GEN_ALIGN - 1));
5b6dd868
BS
972
973 /* check next page if needed */
974 virt_page2 = (pc + tb->size - 1) & TARGET_PAGE_MASK;
975 phys_page2 = -1;
976 if ((pc & TARGET_PAGE_MASK) != virt_page2) {
977 phys_page2 = get_page_addr_code(env, virt_page2);
978 }
979 tb_link_page(tb, phys_pc, phys_page2);
980 return tb;
981}
982
983/*
984 * Invalidate all TBs which intersect with the target physical address range
985 * [start;end[. NOTE: start and end may refer to *different* physical pages.
986 * 'is_cpu_write_access' should be true if called from a real cpu write
987 * access: the virtual CPU will exit the current TB if code is modified inside
988 * this TB.
989 */
990void tb_invalidate_phys_range(tb_page_addr_t start, tb_page_addr_t end,
991 int is_cpu_write_access)
992{
993 while (start < end) {
994 tb_invalidate_phys_page_range(start, end, is_cpu_write_access);
995 start &= TARGET_PAGE_MASK;
996 start += TARGET_PAGE_SIZE;
997 }
998}
999
1000/*
1001 * Invalidate all TBs which intersect with the target physical address range
1002 * [start;end[. NOTE: start and end must refer to the *same* physical page.
1003 * 'is_cpu_write_access' should be true if called from a real cpu write
1004 * access: the virtual CPU will exit the current TB if code is modified inside
1005 * this TB.
1006 */
1007void tb_invalidate_phys_page_range(tb_page_addr_t start, tb_page_addr_t end,
1008 int is_cpu_write_access)
1009{
1010 TranslationBlock *tb, *tb_next, *saved_tb;
4917cf44
AF
1011 CPUState *cpu = current_cpu;
1012#if defined(TARGET_HAS_PRECISE_SMC) || !defined(CONFIG_USER_ONLY)
1013 CPUArchState *env = NULL;
1014#endif
5b6dd868
BS
1015 tb_page_addr_t tb_start, tb_end;
1016 PageDesc *p;
1017 int n;
1018#ifdef TARGET_HAS_PRECISE_SMC
1019 int current_tb_not_found = is_cpu_write_access;
1020 TranslationBlock *current_tb = NULL;
1021 int current_tb_modified = 0;
1022 target_ulong current_pc = 0;
1023 target_ulong current_cs_base = 0;
1024 int current_flags = 0;
1025#endif /* TARGET_HAS_PRECISE_SMC */
1026
1027 p = page_find(start >> TARGET_PAGE_BITS);
1028 if (!p) {
1029 return;
1030 }
1031 if (!p->code_bitmap &&
1032 ++p->code_write_count >= SMC_BITMAP_USE_THRESHOLD &&
1033 is_cpu_write_access) {
1034 /* build code bitmap */
1035 build_page_bitmap(p);
1036 }
4917cf44
AF
1037#if defined(TARGET_HAS_PRECISE_SMC) || !defined(CONFIG_USER_ONLY)
1038 if (cpu != NULL) {
1039 env = cpu->env_ptr;
d77953b9 1040 }
4917cf44 1041#endif
5b6dd868
BS
1042
1043 /* we remove all the TBs in the range [start, end[ */
1044 /* XXX: see if in some cases it could be faster to invalidate all
1045 the code */
1046 tb = p->first_tb;
1047 while (tb != NULL) {
1048 n = (uintptr_t)tb & 3;
1049 tb = (TranslationBlock *)((uintptr_t)tb & ~3);
1050 tb_next = tb->page_next[n];
1051 /* NOTE: this is subtle as a TB may span two physical pages */
1052 if (n == 0) {
1053 /* NOTE: tb_end may be after the end of the page, but
1054 it is not a problem */
1055 tb_start = tb->page_addr[0] + (tb->pc & ~TARGET_PAGE_MASK);
1056 tb_end = tb_start + tb->size;
1057 } else {
1058 tb_start = tb->page_addr[1];
1059 tb_end = tb_start + ((tb->pc + tb->size) & ~TARGET_PAGE_MASK);
1060 }
1061 if (!(tb_end <= start || tb_start >= end)) {
1062#ifdef TARGET_HAS_PRECISE_SMC
1063 if (current_tb_not_found) {
1064 current_tb_not_found = 0;
1065 current_tb = NULL;
1066 if (env->mem_io_pc) {
1067 /* now we have a real cpu fault */
1068 current_tb = tb_find_pc(env->mem_io_pc);
1069 }
1070 }
1071 if (current_tb == tb &&
1072 (current_tb->cflags & CF_COUNT_MASK) != 1) {
1073 /* If we are modifying the current TB, we must stop
1074 its execution. We could be more precise by checking
1075 that the modification is after the current PC, but it
1076 would require a specialized function to partially
1077 restore the CPU state */
1078
1079 current_tb_modified = 1;
a8a826a3 1080 cpu_restore_state_from_tb(current_tb, env, env->mem_io_pc);
5b6dd868
BS
1081 cpu_get_tb_cpu_state(env, &current_pc, &current_cs_base,
1082 &current_flags);
1083 }
1084#endif /* TARGET_HAS_PRECISE_SMC */
1085 /* we need to do that to handle the case where a signal
1086 occurs while doing tb_phys_invalidate() */
1087 saved_tb = NULL;
d77953b9
AF
1088 if (cpu != NULL) {
1089 saved_tb = cpu->current_tb;
1090 cpu->current_tb = NULL;
5b6dd868
BS
1091 }
1092 tb_phys_invalidate(tb, -1);
d77953b9
AF
1093 if (cpu != NULL) {
1094 cpu->current_tb = saved_tb;
c3affe56
AF
1095 if (cpu->interrupt_request && cpu->current_tb) {
1096 cpu_interrupt(cpu, cpu->interrupt_request);
5b6dd868
BS
1097 }
1098 }
1099 }
1100 tb = tb_next;
1101 }
1102#if !defined(CONFIG_USER_ONLY)
1103 /* if no code remaining, no need to continue to use slow writes */
1104 if (!p->first_tb) {
1105 invalidate_page_bitmap(p);
1106 if (is_cpu_write_access) {
1107 tlb_unprotect_code_phys(env, start, env->mem_io_vaddr);
1108 }
1109 }
1110#endif
1111#ifdef TARGET_HAS_PRECISE_SMC
1112 if (current_tb_modified) {
1113 /* we generate a block containing just the instruction
1114 modifying the memory. It will ensure that it cannot modify
1115 itself */
d77953b9 1116 cpu->current_tb = NULL;
5b6dd868
BS
1117 tb_gen_code(env, current_pc, current_cs_base, current_flags, 1);
1118 cpu_resume_from_signal(env, NULL);
1119 }
1120#endif
1121}
1122
1123/* len must be <= 8 and start must be a multiple of len */
1124void tb_invalidate_phys_page_fast(tb_page_addr_t start, int len)
1125{
1126 PageDesc *p;
1127 int offset, b;
1128
1129#if 0
1130 if (1) {
1131 qemu_log("modifying code at 0x%x size=%d EIP=%x PC=%08x\n",
1132 cpu_single_env->mem_io_vaddr, len,
1133 cpu_single_env->eip,
1134 cpu_single_env->eip +
1135 (intptr_t)cpu_single_env->segs[R_CS].base);
1136 }
1137#endif
1138 p = page_find(start >> TARGET_PAGE_BITS);
1139 if (!p) {
1140 return;
1141 }
1142 if (p->code_bitmap) {
1143 offset = start & ~TARGET_PAGE_MASK;
1144 b = p->code_bitmap[offset >> 3] >> (offset & 7);
1145 if (b & ((1 << len) - 1)) {
1146 goto do_invalidate;
1147 }
1148 } else {
1149 do_invalidate:
1150 tb_invalidate_phys_page_range(start, start + len, 1);
1151 }
1152}
1153
1154#if !defined(CONFIG_SOFTMMU)
1155static void tb_invalidate_phys_page(tb_page_addr_t addr,
d02532f0
AG
1156 uintptr_t pc, void *puc,
1157 bool locked)
5b6dd868
BS
1158{
1159 TranslationBlock *tb;
1160 PageDesc *p;
1161 int n;
1162#ifdef TARGET_HAS_PRECISE_SMC
1163 TranslationBlock *current_tb = NULL;
4917cf44
AF
1164 CPUState *cpu = current_cpu;
1165 CPUArchState *env = NULL;
5b6dd868
BS
1166 int current_tb_modified = 0;
1167 target_ulong current_pc = 0;
1168 target_ulong current_cs_base = 0;
1169 int current_flags = 0;
1170#endif
1171
1172 addr &= TARGET_PAGE_MASK;
1173 p = page_find(addr >> TARGET_PAGE_BITS);
1174 if (!p) {
1175 return;
1176 }
1177 tb = p->first_tb;
1178#ifdef TARGET_HAS_PRECISE_SMC
1179 if (tb && pc != 0) {
1180 current_tb = tb_find_pc(pc);
1181 }
4917cf44
AF
1182 if (cpu != NULL) {
1183 env = cpu->env_ptr;
d77953b9 1184 }
5b6dd868
BS
1185#endif
1186 while (tb != NULL) {
1187 n = (uintptr_t)tb & 3;
1188 tb = (TranslationBlock *)((uintptr_t)tb & ~3);
1189#ifdef TARGET_HAS_PRECISE_SMC
1190 if (current_tb == tb &&
1191 (current_tb->cflags & CF_COUNT_MASK) != 1) {
1192 /* If we are modifying the current TB, we must stop
1193 its execution. We could be more precise by checking
1194 that the modification is after the current PC, but it
1195 would require a specialized function to partially
1196 restore the CPU state */
1197
1198 current_tb_modified = 1;
a8a826a3 1199 cpu_restore_state_from_tb(current_tb, env, pc);
5b6dd868
BS
1200 cpu_get_tb_cpu_state(env, &current_pc, &current_cs_base,
1201 &current_flags);
1202 }
1203#endif /* TARGET_HAS_PRECISE_SMC */
1204 tb_phys_invalidate(tb, addr);
1205 tb = tb->page_next[n];
1206 }
1207 p->first_tb = NULL;
1208#ifdef TARGET_HAS_PRECISE_SMC
1209 if (current_tb_modified) {
1210 /* we generate a block containing just the instruction
1211 modifying the memory. It will ensure that it cannot modify
1212 itself */
d77953b9 1213 cpu->current_tb = NULL;
5b6dd868 1214 tb_gen_code(env, current_pc, current_cs_base, current_flags, 1);
d02532f0
AG
1215 if (locked) {
1216 mmap_unlock();
1217 }
5b6dd868
BS
1218 cpu_resume_from_signal(env, puc);
1219 }
1220#endif
1221}
1222#endif
1223
1224/* add the tb in the target page and protect it if necessary */
1225static inline void tb_alloc_page(TranslationBlock *tb,
1226 unsigned int n, tb_page_addr_t page_addr)
1227{
1228 PageDesc *p;
1229#ifndef CONFIG_USER_ONLY
1230 bool page_already_protected;
1231#endif
1232
1233 tb->page_addr[n] = page_addr;
1234 p = page_find_alloc(page_addr >> TARGET_PAGE_BITS, 1);
1235 tb->page_next[n] = p->first_tb;
1236#ifndef CONFIG_USER_ONLY
1237 page_already_protected = p->first_tb != NULL;
1238#endif
1239 p->first_tb = (TranslationBlock *)((uintptr_t)tb | n);
1240 invalidate_page_bitmap(p);
1241
1242#if defined(TARGET_HAS_SMC) || 1
1243
1244#if defined(CONFIG_USER_ONLY)
1245 if (p->flags & PAGE_WRITE) {
1246 target_ulong addr;
1247 PageDesc *p2;
1248 int prot;
1249
1250 /* force the host page as non writable (writes will have a
1251 page fault + mprotect overhead) */
1252 page_addr &= qemu_host_page_mask;
1253 prot = 0;
1254 for (addr = page_addr; addr < page_addr + qemu_host_page_size;
1255 addr += TARGET_PAGE_SIZE) {
1256
1257 p2 = page_find(addr >> TARGET_PAGE_BITS);
1258 if (!p2) {
1259 continue;
1260 }
1261 prot |= p2->flags;
1262 p2->flags &= ~PAGE_WRITE;
1263 }
1264 mprotect(g2h(page_addr), qemu_host_page_size,
1265 (prot & PAGE_BITS) & ~PAGE_WRITE);
1266#ifdef DEBUG_TB_INVALIDATE
1267 printf("protecting code page: 0x" TARGET_FMT_lx "\n",
1268 page_addr);
1269#endif
1270 }
1271#else
1272 /* if some code is already present, then the pages are already
1273 protected. So we handle the case where only the first TB is
1274 allocated in a physical page */
1275 if (!page_already_protected) {
1276 tlb_protect_code(page_addr);
1277 }
1278#endif
1279
1280#endif /* TARGET_HAS_SMC */
1281}
1282
1283/* add a new TB and link it to the physical page tables. phys_page2 is
1284 (-1) to indicate that only one page contains the TB. */
1285static void tb_link_page(TranslationBlock *tb, tb_page_addr_t phys_pc,
1286 tb_page_addr_t phys_page2)
1287{
1288 unsigned int h;
1289 TranslationBlock **ptb;
1290
1291 /* Grab the mmap lock to stop another thread invalidating this TB
1292 before we are done. */
1293 mmap_lock();
1294 /* add in the physical hash table */
1295 h = tb_phys_hash_func(phys_pc);
5e5f07e0 1296 ptb = &tcg_ctx.tb_ctx.tb_phys_hash[h];
5b6dd868
BS
1297 tb->phys_hash_next = *ptb;
1298 *ptb = tb;
1299
1300 /* add in the page list */
1301 tb_alloc_page(tb, 0, phys_pc & TARGET_PAGE_MASK);
1302 if (phys_page2 != -1) {
1303 tb_alloc_page(tb, 1, phys_page2);
1304 } else {
1305 tb->page_addr[1] = -1;
1306 }
1307
1308 tb->jmp_first = (TranslationBlock *)((uintptr_t)tb | 2);
1309 tb->jmp_next[0] = NULL;
1310 tb->jmp_next[1] = NULL;
1311
1312 /* init original jump addresses */
1313 if (tb->tb_next_offset[0] != 0xffff) {
1314 tb_reset_jump(tb, 0);
1315 }
1316 if (tb->tb_next_offset[1] != 0xffff) {
1317 tb_reset_jump(tb, 1);
1318 }
1319
1320#ifdef DEBUG_TB_CHECK
1321 tb_page_check();
1322#endif
1323 mmap_unlock();
1324}
1325
5b6dd868
BS
1326/* find the TB 'tb' such that tb[0].tc_ptr <= tc_ptr <
1327 tb[1].tc_ptr. Return NULL if not found */
a8a826a3 1328static TranslationBlock *tb_find_pc(uintptr_t tc_ptr)
5b6dd868
BS
1329{
1330 int m_min, m_max, m;
1331 uintptr_t v;
1332 TranslationBlock *tb;
1333
5e5f07e0 1334 if (tcg_ctx.tb_ctx.nb_tbs <= 0) {
5b6dd868
BS
1335 return NULL;
1336 }
0b0d3320
EV
1337 if (tc_ptr < (uintptr_t)tcg_ctx.code_gen_buffer ||
1338 tc_ptr >= (uintptr_t)tcg_ctx.code_gen_ptr) {
5b6dd868
BS
1339 return NULL;
1340 }
1341 /* binary search (cf Knuth) */
1342 m_min = 0;
5e5f07e0 1343 m_max = tcg_ctx.tb_ctx.nb_tbs - 1;
5b6dd868
BS
1344 while (m_min <= m_max) {
1345 m = (m_min + m_max) >> 1;
5e5f07e0 1346 tb = &tcg_ctx.tb_ctx.tbs[m];
5b6dd868
BS
1347 v = (uintptr_t)tb->tc_ptr;
1348 if (v == tc_ptr) {
1349 return tb;
1350 } else if (tc_ptr < v) {
1351 m_max = m - 1;
1352 } else {
1353 m_min = m + 1;
1354 }
1355 }
5e5f07e0 1356 return &tcg_ctx.tb_ctx.tbs[m_max];
5b6dd868
BS
1357}
1358
5b6dd868 1359#if defined(TARGET_HAS_ICE) && !defined(CONFIG_USER_ONLY)
29d8ec7b 1360void tb_invalidate_phys_addr(AddressSpace *as, hwaddr addr)
5b6dd868
BS
1361{
1362 ram_addr_t ram_addr;
5c8a00ce 1363 MemoryRegion *mr;
149f54b5 1364 hwaddr l = 1;
5b6dd868 1365
29d8ec7b 1366 mr = address_space_translate(as, addr, &addr, &l, false);
5c8a00ce
PB
1367 if (!(memory_region_is_ram(mr)
1368 || memory_region_is_romd(mr))) {
5b6dd868
BS
1369 return;
1370 }
5c8a00ce 1371 ram_addr = (memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK)
149f54b5 1372 + addr;
5b6dd868
BS
1373 tb_invalidate_phys_page_range(ram_addr, ram_addr + 1, 0);
1374}
1375#endif /* TARGET_HAS_ICE && !defined(CONFIG_USER_ONLY) */
1376
5b6dd868
BS
1377void tb_check_watchpoint(CPUArchState *env)
1378{
1379 TranslationBlock *tb;
1380
1381 tb = tb_find_pc(env->mem_io_pc);
1382 if (!tb) {
1383 cpu_abort(env, "check_watchpoint: could not find TB for pc=%p",
1384 (void *)env->mem_io_pc);
1385 }
a8a826a3 1386 cpu_restore_state_from_tb(tb, env, env->mem_io_pc);
5b6dd868
BS
1387 tb_phys_invalidate(tb, -1);
1388}
1389
1390#ifndef CONFIG_USER_ONLY
1391/* mask must never be zero, except for A20 change call */
c3affe56 1392static void tcg_handle_interrupt(CPUState *cpu, int mask)
5b6dd868 1393{
c3affe56 1394 CPUArchState *env = cpu->env_ptr;
5b6dd868
BS
1395 int old_mask;
1396
259186a7
AF
1397 old_mask = cpu->interrupt_request;
1398 cpu->interrupt_request |= mask;
5b6dd868
BS
1399
1400 /*
1401 * If called from iothread context, wake the target cpu in
1402 * case its halted.
1403 */
1404 if (!qemu_cpu_is_self(cpu)) {
1405 qemu_cpu_kick(cpu);
1406 return;
1407 }
1408
1409 if (use_icount) {
1410 env->icount_decr.u16.high = 0xffff;
1411 if (!can_do_io(env)
1412 && (mask & ~old_mask) != 0) {
1413 cpu_abort(env, "Raised interrupt while not in I/O function");
1414 }
1415 } else {
378df4b2 1416 cpu->tcg_exit_req = 1;
5b6dd868
BS
1417 }
1418}
1419
1420CPUInterruptHandler cpu_interrupt_handler = tcg_handle_interrupt;
1421
1422/* in deterministic execution mode, instructions doing device I/Os
1423 must be at the end of the TB */
1424void cpu_io_recompile(CPUArchState *env, uintptr_t retaddr)
1425{
1426 TranslationBlock *tb;
1427 uint32_t n, cflags;
1428 target_ulong pc, cs_base;
1429 uint64_t flags;
1430
1431 tb = tb_find_pc(retaddr);
1432 if (!tb) {
1433 cpu_abort(env, "cpu_io_recompile: could not find TB for pc=%p",
1434 (void *)retaddr);
1435 }
1436 n = env->icount_decr.u16.low + tb->icount;
a8a826a3 1437 cpu_restore_state_from_tb(tb, env, retaddr);
5b6dd868
BS
1438 /* Calculate how many instructions had been executed before the fault
1439 occurred. */
1440 n = n - env->icount_decr.u16.low;
1441 /* Generate a new TB ending on the I/O insn. */
1442 n++;
1443 /* On MIPS and SH, delay slot instructions can only be restarted if
1444 they were already the first instruction in the TB. If this is not
1445 the first instruction in a TB then re-execute the preceding
1446 branch. */
1447#if defined(TARGET_MIPS)
1448 if ((env->hflags & MIPS_HFLAG_BMASK) != 0 && n > 1) {
1449 env->active_tc.PC -= 4;
1450 env->icount_decr.u16.low++;
1451 env->hflags &= ~MIPS_HFLAG_BMASK;
1452 }
1453#elif defined(TARGET_SH4)
1454 if ((env->flags & ((DELAY_SLOT | DELAY_SLOT_CONDITIONAL))) != 0
1455 && n > 1) {
1456 env->pc -= 2;
1457 env->icount_decr.u16.low++;
1458 env->flags &= ~(DELAY_SLOT | DELAY_SLOT_CONDITIONAL);
1459 }
1460#endif
1461 /* This should never happen. */
1462 if (n > CF_COUNT_MASK) {
1463 cpu_abort(env, "TB too big during recompile");
1464 }
1465
1466 cflags = n | CF_LAST_IO;
1467 pc = tb->pc;
1468 cs_base = tb->cs_base;
1469 flags = tb->flags;
1470 tb_phys_invalidate(tb, -1);
1471 /* FIXME: In theory this could raise an exception. In practice
1472 we have already translated the block once so it's probably ok. */
1473 tb_gen_code(env, pc, cs_base, flags, cflags);
1474 /* TODO: If env->pc != tb->pc (i.e. the faulting instruction was not
1475 the first in the TB) then we end up generating a whole new TB and
1476 repeating the fault, which is horribly inefficient.
1477 Better would be to execute just this insn uncached, or generate a
1478 second new TB. */
1479 cpu_resume_from_signal(env, NULL);
1480}
1481
1482void tb_flush_jmp_cache(CPUArchState *env, target_ulong addr)
1483{
1484 unsigned int i;
1485
1486 /* Discard jump cache entries for any tb which might potentially
1487 overlap the flushed page. */
1488 i = tb_jmp_cache_hash_page(addr - TARGET_PAGE_SIZE);
1489 memset(&env->tb_jmp_cache[i], 0,
1490 TB_JMP_PAGE_SIZE * sizeof(TranslationBlock *));
1491
1492 i = tb_jmp_cache_hash_page(addr);
1493 memset(&env->tb_jmp_cache[i], 0,
1494 TB_JMP_PAGE_SIZE * sizeof(TranslationBlock *));
1495}
1496
1497void dump_exec_info(FILE *f, fprintf_function cpu_fprintf)
1498{
1499 int i, target_code_size, max_target_code_size;
1500 int direct_jmp_count, direct_jmp2_count, cross_page;
1501 TranslationBlock *tb;
1502
1503 target_code_size = 0;
1504 max_target_code_size = 0;
1505 cross_page = 0;
1506 direct_jmp_count = 0;
1507 direct_jmp2_count = 0;
5e5f07e0
EV
1508 for (i = 0; i < tcg_ctx.tb_ctx.nb_tbs; i++) {
1509 tb = &tcg_ctx.tb_ctx.tbs[i];
5b6dd868
BS
1510 target_code_size += tb->size;
1511 if (tb->size > max_target_code_size) {
1512 max_target_code_size = tb->size;
1513 }
1514 if (tb->page_addr[1] != -1) {
1515 cross_page++;
1516 }
1517 if (tb->tb_next_offset[0] != 0xffff) {
1518 direct_jmp_count++;
1519 if (tb->tb_next_offset[1] != 0xffff) {
1520 direct_jmp2_count++;
1521 }
1522 }
1523 }
1524 /* XXX: avoid using doubles ? */
1525 cpu_fprintf(f, "Translation buffer state:\n");
1526 cpu_fprintf(f, "gen code size %td/%zd\n",
0b0d3320
EV
1527 tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer,
1528 tcg_ctx.code_gen_buffer_max_size);
5b6dd868 1529 cpu_fprintf(f, "TB count %d/%d\n",
5e5f07e0 1530 tcg_ctx.tb_ctx.nb_tbs, tcg_ctx.code_gen_max_blocks);
5b6dd868 1531 cpu_fprintf(f, "TB avg target size %d max=%d bytes\n",
5e5f07e0
EV
1532 tcg_ctx.tb_ctx.nb_tbs ? target_code_size /
1533 tcg_ctx.tb_ctx.nb_tbs : 0,
1534 max_target_code_size);
5b6dd868 1535 cpu_fprintf(f, "TB avg host size %td bytes (expansion ratio: %0.1f)\n",
5e5f07e0
EV
1536 tcg_ctx.tb_ctx.nb_tbs ? (tcg_ctx.code_gen_ptr -
1537 tcg_ctx.code_gen_buffer) /
1538 tcg_ctx.tb_ctx.nb_tbs : 0,
1539 target_code_size ? (double) (tcg_ctx.code_gen_ptr -
1540 tcg_ctx.code_gen_buffer) /
1541 target_code_size : 0);
1542 cpu_fprintf(f, "cross page TB count %d (%d%%)\n", cross_page,
1543 tcg_ctx.tb_ctx.nb_tbs ? (cross_page * 100) /
1544 tcg_ctx.tb_ctx.nb_tbs : 0);
5b6dd868
BS
1545 cpu_fprintf(f, "direct jump count %d (%d%%) (2 jumps=%d %d%%)\n",
1546 direct_jmp_count,
5e5f07e0
EV
1547 tcg_ctx.tb_ctx.nb_tbs ? (direct_jmp_count * 100) /
1548 tcg_ctx.tb_ctx.nb_tbs : 0,
5b6dd868 1549 direct_jmp2_count,
5e5f07e0
EV
1550 tcg_ctx.tb_ctx.nb_tbs ? (direct_jmp2_count * 100) /
1551 tcg_ctx.tb_ctx.nb_tbs : 0);
5b6dd868 1552 cpu_fprintf(f, "\nStatistics:\n");
5e5f07e0
EV
1553 cpu_fprintf(f, "TB flush count %d\n", tcg_ctx.tb_ctx.tb_flush_count);
1554 cpu_fprintf(f, "TB invalidate count %d\n",
1555 tcg_ctx.tb_ctx.tb_phys_invalidate_count);
5b6dd868
BS
1556 cpu_fprintf(f, "TLB flush count %d\n", tlb_flush_count);
1557 tcg_dump_info(f, cpu_fprintf);
1558}
1559
1560#else /* CONFIG_USER_ONLY */
1561
c3affe56 1562void cpu_interrupt(CPUState *cpu, int mask)
5b6dd868 1563{
259186a7 1564 cpu->interrupt_request |= mask;
378df4b2 1565 cpu->tcg_exit_req = 1;
5b6dd868
BS
1566}
1567
1568/*
1569 * Walks guest process memory "regions" one by one
1570 * and calls callback function 'fn' for each region.
1571 */
1572struct walk_memory_regions_data {
1573 walk_memory_regions_fn fn;
1574 void *priv;
1575 uintptr_t start;
1576 int prot;
1577};
1578
1579static int walk_memory_regions_end(struct walk_memory_regions_data *data,
1580 abi_ulong end, int new_prot)
1581{
1582 if (data->start != -1ul) {
1583 int rc = data->fn(data->priv, data->start, end, data->prot);
1584 if (rc != 0) {
1585 return rc;
1586 }
1587 }
1588
1589 data->start = (new_prot ? end : -1ul);
1590 data->prot = new_prot;
1591
1592 return 0;
1593}
1594
1595static int walk_memory_regions_1(struct walk_memory_regions_data *data,
1596 abi_ulong base, int level, void **lp)
1597{
1598 abi_ulong pa;
1599 int i, rc;
1600
1601 if (*lp == NULL) {
1602 return walk_memory_regions_end(data, base, 0);
1603 }
1604
1605 if (level == 0) {
1606 PageDesc *pd = *lp;
1607
03f49957 1608 for (i = 0; i < V_L2_SIZE; ++i) {
5b6dd868
BS
1609 int prot = pd[i].flags;
1610
1611 pa = base | (i << TARGET_PAGE_BITS);
1612 if (prot != data->prot) {
1613 rc = walk_memory_regions_end(data, pa, prot);
1614 if (rc != 0) {
1615 return rc;
1616 }
1617 }
1618 }
1619 } else {
1620 void **pp = *lp;
1621
03f49957 1622 for (i = 0; i < V_L2_SIZE; ++i) {
5b6dd868 1623 pa = base | ((abi_ulong)i <<
03f49957 1624 (TARGET_PAGE_BITS + V_L2_BITS * level));
5b6dd868
BS
1625 rc = walk_memory_regions_1(data, pa, level - 1, pp + i);
1626 if (rc != 0) {
1627 return rc;
1628 }
1629 }
1630 }
1631
1632 return 0;
1633}
1634
1635int walk_memory_regions(void *priv, walk_memory_regions_fn fn)
1636{
1637 struct walk_memory_regions_data data;
1638 uintptr_t i;
1639
1640 data.fn = fn;
1641 data.priv = priv;
1642 data.start = -1ul;
1643 data.prot = 0;
1644
1645 for (i = 0; i < V_L1_SIZE; i++) {
1646 int rc = walk_memory_regions_1(&data, (abi_ulong)i << V_L1_SHIFT,
03f49957 1647 V_L1_SHIFT / V_L2_BITS - 1, l1_map + i);
5b6dd868
BS
1648
1649 if (rc != 0) {
1650 return rc;
1651 }
1652 }
1653
1654 return walk_memory_regions_end(&data, 0, 0);
1655}
1656
1657static int dump_region(void *priv, abi_ulong start,
1658 abi_ulong end, unsigned long prot)
1659{
1660 FILE *f = (FILE *)priv;
1661
1662 (void) fprintf(f, TARGET_ABI_FMT_lx"-"TARGET_ABI_FMT_lx
1663 " "TARGET_ABI_FMT_lx" %c%c%c\n",
1664 start, end, end - start,
1665 ((prot & PAGE_READ) ? 'r' : '-'),
1666 ((prot & PAGE_WRITE) ? 'w' : '-'),
1667 ((prot & PAGE_EXEC) ? 'x' : '-'));
1668
1669 return 0;
1670}
1671
1672/* dump memory mappings */
1673void page_dump(FILE *f)
1674{
227b8175
SW
1675 const int length = sizeof(abi_ulong) * 2;
1676 (void) fprintf(f, "%-*s %-*s %-*s %s\n",
1677 length, "start", length, "end", length, "size", "prot");
5b6dd868
BS
1678 walk_memory_regions(f, dump_region);
1679}
1680
1681int page_get_flags(target_ulong address)
1682{
1683 PageDesc *p;
1684
1685 p = page_find(address >> TARGET_PAGE_BITS);
1686 if (!p) {
1687 return 0;
1688 }
1689 return p->flags;
1690}
1691
1692/* Modify the flags of a page and invalidate the code if necessary.
1693 The flag PAGE_WRITE_ORG is positioned automatically depending
1694 on PAGE_WRITE. The mmap_lock should already be held. */
1695void page_set_flags(target_ulong start, target_ulong end, int flags)
1696{
1697 target_ulong addr, len;
1698
1699 /* This function should never be called with addresses outside the
1700 guest address space. If this assert fires, it probably indicates
1701 a missing call to h2g_valid. */
1702#if TARGET_ABI_BITS > L1_MAP_ADDR_SPACE_BITS
1703 assert(end < ((abi_ulong)1 << L1_MAP_ADDR_SPACE_BITS));
1704#endif
1705 assert(start < end);
1706
1707 start = start & TARGET_PAGE_MASK;
1708 end = TARGET_PAGE_ALIGN(end);
1709
1710 if (flags & PAGE_WRITE) {
1711 flags |= PAGE_WRITE_ORG;
1712 }
1713
1714 for (addr = start, len = end - start;
1715 len != 0;
1716 len -= TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
1717 PageDesc *p = page_find_alloc(addr >> TARGET_PAGE_BITS, 1);
1718
1719 /* If the write protection bit is set, then we invalidate
1720 the code inside. */
1721 if (!(p->flags & PAGE_WRITE) &&
1722 (flags & PAGE_WRITE) &&
1723 p->first_tb) {
d02532f0 1724 tb_invalidate_phys_page(addr, 0, NULL, false);
5b6dd868
BS
1725 }
1726 p->flags = flags;
1727 }
1728}
1729
1730int page_check_range(target_ulong start, target_ulong len, int flags)
1731{
1732 PageDesc *p;
1733 target_ulong end;
1734 target_ulong addr;
1735
1736 /* This function should never be called with addresses outside the
1737 guest address space. If this assert fires, it probably indicates
1738 a missing call to h2g_valid. */
1739#if TARGET_ABI_BITS > L1_MAP_ADDR_SPACE_BITS
1740 assert(start < ((abi_ulong)1 << L1_MAP_ADDR_SPACE_BITS));
1741#endif
1742
1743 if (len == 0) {
1744 return 0;
1745 }
1746 if (start + len - 1 < start) {
1747 /* We've wrapped around. */
1748 return -1;
1749 }
1750
1751 /* must do before we loose bits in the next step */
1752 end = TARGET_PAGE_ALIGN(start + len);
1753 start = start & TARGET_PAGE_MASK;
1754
1755 for (addr = start, len = end - start;
1756 len != 0;
1757 len -= TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
1758 p = page_find(addr >> TARGET_PAGE_BITS);
1759 if (!p) {
1760 return -1;
1761 }
1762 if (!(p->flags & PAGE_VALID)) {
1763 return -1;
1764 }
1765
1766 if ((flags & PAGE_READ) && !(p->flags & PAGE_READ)) {
1767 return -1;
1768 }
1769 if (flags & PAGE_WRITE) {
1770 if (!(p->flags & PAGE_WRITE_ORG)) {
1771 return -1;
1772 }
1773 /* unprotect the page if it was put read-only because it
1774 contains translated code */
1775 if (!(p->flags & PAGE_WRITE)) {
1776 if (!page_unprotect(addr, 0, NULL)) {
1777 return -1;
1778 }
1779 }
1780 return 0;
1781 }
1782 }
1783 return 0;
1784}
1785
1786/* called from signal handler: invalidate the code and unprotect the
1787 page. Return TRUE if the fault was successfully handled. */
1788int page_unprotect(target_ulong address, uintptr_t pc, void *puc)
1789{
1790 unsigned int prot;
1791 PageDesc *p;
1792 target_ulong host_start, host_end, addr;
1793
1794 /* Technically this isn't safe inside a signal handler. However we
1795 know this only ever happens in a synchronous SEGV handler, so in
1796 practice it seems to be ok. */
1797 mmap_lock();
1798
1799 p = page_find(address >> TARGET_PAGE_BITS);
1800 if (!p) {
1801 mmap_unlock();
1802 return 0;
1803 }
1804
1805 /* if the page was really writable, then we change its
1806 protection back to writable */
1807 if ((p->flags & PAGE_WRITE_ORG) && !(p->flags & PAGE_WRITE)) {
1808 host_start = address & qemu_host_page_mask;
1809 host_end = host_start + qemu_host_page_size;
1810
1811 prot = 0;
1812 for (addr = host_start ; addr < host_end ; addr += TARGET_PAGE_SIZE) {
1813 p = page_find(addr >> TARGET_PAGE_BITS);
1814 p->flags |= PAGE_WRITE;
1815 prot |= p->flags;
1816
1817 /* and since the content will be modified, we must invalidate
1818 the corresponding translated code. */
d02532f0 1819 tb_invalidate_phys_page(addr, pc, puc, true);
5b6dd868
BS
1820#ifdef DEBUG_TB_CHECK
1821 tb_invalidate_check(addr);
1822#endif
1823 }
1824 mprotect((void *)g2h(host_start), qemu_host_page_size,
1825 prot & PAGE_BITS);
1826
1827 mmap_unlock();
1828 return 1;
1829 }
1830 mmap_unlock();
1831 return 0;
1832}
1833#endif /* CONFIG_USER_ONLY */