exec.c 61.2 KB
Newer Older
bellard's avatar
bellard committed
1
/*
bellard's avatar
bellard committed
2
 *  virtual page mapping and translated block handling
bellard's avatar
bellard committed
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 * 
 *  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
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
bellard's avatar
bellard committed
20
#include "config.h"
bellard's avatar
bellard committed
21
22
23
24
25
26
27
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <inttypes.h>
bellard's avatar
bellard committed
28
#if !defined(CONFIG_SOFTMMU)
bellard's avatar
bellard committed
29
#include <sys/mman.h>
bellard's avatar
bellard committed
30
#endif
bellard's avatar
bellard committed
31

bellard's avatar
bellard committed
32
33
#include "cpu.h"
#include "exec-all.h"
bellard's avatar
bellard committed
34

bellard's avatar
bellard committed
35
//#define DEBUG_TB_INVALIDATE
bellard's avatar
bellard committed
36
//#define DEBUG_FLUSH
37
//#define DEBUG_TLB
bellard's avatar
bellard committed
38
39
40

/* make various TB consistency checks */
//#define DEBUG_TB_CHECK 
bellard's avatar
bellard committed
41
//#define DEBUG_TLB_CHECK 
bellard's avatar
bellard committed
42
43
44
45

/* threshold to flush the translated code buffer */
#define CODE_GEN_BUFFER_MAX_SIZE (CODE_GEN_BUFFER_SIZE - CODE_GEN_MAX_SIZE)

46
47
48
49
#define SMC_BITMAP_USE_THRESHOLD 10

#define MMAP_AREA_START        0x00000000
#define MMAP_AREA_END          0xa8000000
bellard's avatar
bellard committed
50
51
52

TranslationBlock tbs[CODE_GEN_MAX_BLOCKS];
TranslationBlock *tb_hash[CODE_GEN_HASH_SIZE];
53
TranslationBlock *tb_phys_hash[CODE_GEN_PHYS_HASH_SIZE];
bellard's avatar
bellard committed
54
int nb_tbs;
bellard's avatar
bellard committed
55
56
/* any access to the tbs or the page table must use this lock */
spinlock_t tb_lock = SPIN_LOCK_UNLOCKED;
bellard's avatar
bellard committed
57
58
59
60

uint8_t code_gen_buffer[CODE_GEN_BUFFER_SIZE];
uint8_t *code_gen_ptr;

61
62
63
int phys_ram_size;
int phys_ram_fd;
uint8_t *phys_ram_base;
64
uint8_t *phys_ram_dirty;
65

bellard's avatar
bellard committed
66
typedef struct PageDesc {
67
    /* list of TBs intersecting this ram page */
bellard's avatar
bellard committed
68
    TranslationBlock *first_tb;
69
70
71
72
73
74
75
    /* 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;
    uint8_t *code_bitmap;
#if defined(CONFIG_USER_ONLY)
    unsigned long flags;
#endif
bellard's avatar
bellard committed
76
77
} PageDesc;

78
79
80
81
82
typedef struct PhysPageDesc {
    /* offset in host memory of the page + io_index in the low 12 bits */
    unsigned long phys_offset;
} PhysPageDesc;

83
84
85
86
87
88
89
90
91
92
93
94
typedef struct VirtPageDesc {
    /* physical address of code page. It is valid only if 'valid_tag'
       matches 'virt_valid_tag' */ 
    target_ulong phys_addr; 
    unsigned int valid_tag;
#if !defined(CONFIG_SOFTMMU)
    /* original page access rights. It is valid only if 'valid_tag'
       matches 'virt_valid_tag' */
    unsigned int prot;
#endif
} VirtPageDesc;

bellard's avatar
bellard committed
95
96
97
98
99
100
#define L2_BITS 10
#define L1_BITS (32 - L2_BITS - TARGET_PAGE_BITS)

#define L1_SIZE (1 << L1_BITS)
#define L2_SIZE (1 << L2_BITS)

101
static void io_mem_init(void);
bellard's avatar
bellard committed
102

bellard's avatar
bellard committed
103
104
105
106
107
unsigned long real_host_page_size;
unsigned long host_page_bits;
unsigned long host_page_size;
unsigned long host_page_mask;

108
/* XXX: for system emulation, it could just be an array */
bellard's avatar
bellard committed
109
static PageDesc *l1_map[L1_SIZE];
110
static PhysPageDesc *l1_phys_map[L1_SIZE];
bellard's avatar
bellard committed
111

112
113
114
115
116
#if !defined(CONFIG_USER_ONLY)
static VirtPageDesc *l1_virt_map[L1_SIZE];
static unsigned int virt_valid_tag;
#endif

117
118
119
120
121
/* io memory support */
CPUWriteMemoryFunc *io_mem_write[IO_MEM_NB_ENTRIES][4];
CPUReadMemoryFunc *io_mem_read[IO_MEM_NB_ENTRIES][4];
static int io_mem_nb;

122
123
124
125
126
/* log support */
char *logfilename = "/tmp/qemu.log";
FILE *logfile;
int loglevel;

bellard's avatar
bellard committed
127
static void page_init(void)
bellard's avatar
bellard committed
128
129
130
{
    /* NOTE: we can always suppose that host_page_size >=
       TARGET_PAGE_SIZE */
bellard's avatar
bellard committed
131
132
133
#ifdef _WIN32
    real_host_page_size = 4096;
#else
bellard's avatar
bellard committed
134
    real_host_page_size = getpagesize();
bellard's avatar
bellard committed
135
#endif
bellard's avatar
bellard committed
136
137
138
139
140
141
142
143
    if (host_page_size == 0)
        host_page_size = real_host_page_size;
    if (host_page_size < TARGET_PAGE_SIZE)
        host_page_size = TARGET_PAGE_SIZE;
    host_page_bits = 0;
    while ((1 << host_page_bits) < host_page_size)
        host_page_bits++;
    host_page_mask = ~(host_page_size - 1);
144
145
146
#if !defined(CONFIG_USER_ONLY)
    virt_valid_tag = 1;
#endif
bellard's avatar
bellard committed
147
148
}

bellard's avatar
bellard committed
149
static inline PageDesc *page_find_alloc(unsigned int index)
bellard's avatar
bellard committed
150
151
152
153
154
155
156
{
    PageDesc **lp, *p;

    lp = &l1_map[index >> L2_BITS];
    p = *lp;
    if (!p) {
        /* allocate if not found */
157
        p = qemu_malloc(sizeof(PageDesc) * L2_SIZE);
bellard's avatar
bellard committed
158
        memset(p, 0, sizeof(PageDesc) * L2_SIZE);
bellard's avatar
bellard committed
159
160
161
162
163
        *lp = p;
    }
    return p + (index & (L2_SIZE - 1));
}

bellard's avatar
bellard committed
164
static inline PageDesc *page_find(unsigned int index)
bellard's avatar
bellard committed
165
166
167
168
169
170
{
    PageDesc *p;

    p = l1_map[index >> L2_BITS];
    if (!p)
        return 0;
bellard's avatar
bellard committed
171
172
173
    return p + (index & (L2_SIZE - 1));
}

174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
static inline PhysPageDesc *phys_page_find_alloc(unsigned int index)
{
    PhysPageDesc **lp, *p;

    lp = &l1_phys_map[index >> L2_BITS];
    p = *lp;
    if (!p) {
        /* allocate if not found */
        p = qemu_malloc(sizeof(PhysPageDesc) * L2_SIZE);
        memset(p, 0, sizeof(PhysPageDesc) * L2_SIZE);
        *lp = p;
    }
    return p + (index & (L2_SIZE - 1));
}

static inline PhysPageDesc *phys_page_find(unsigned int index)
{
    PhysPageDesc *p;

    p = l1_phys_map[index >> L2_BITS];
    if (!p)
        return 0;
    return p + (index & (L2_SIZE - 1));
}

199
#if !defined(CONFIG_USER_ONLY)
bellard's avatar
bellard committed
200
201
static void tlb_protect_code(CPUState *env, target_ulong addr);
static void tlb_unprotect_code_phys(CPUState *env, unsigned long phys_addr, target_ulong vaddr);
202
203

static inline VirtPageDesc *virt_page_find_alloc(unsigned int index)
bellard's avatar
bellard committed
204
{
205
    VirtPageDesc **lp, *p;
bellard's avatar
bellard committed
206

207
208
209
210
    lp = &l1_virt_map[index >> L2_BITS];
    p = *lp;
    if (!p) {
        /* allocate if not found */
211
        p = qemu_malloc(sizeof(VirtPageDesc) * L2_SIZE);
212
213
214
215
216
217
218
219
220
221
222
        memset(p, 0, sizeof(VirtPageDesc) * L2_SIZE);
        *lp = p;
    }
    return p + (index & (L2_SIZE - 1));
}

static inline VirtPageDesc *virt_page_find(unsigned int index)
{
    VirtPageDesc *p;

    p = l1_virt_map[index >> L2_BITS];
bellard's avatar
bellard committed
223
224
    if (!p)
        return 0;
225
    return p + (index & (L2_SIZE - 1));
bellard's avatar
bellard committed
226
227
}

228
static void virt_page_flush(void)
bellard's avatar
bellard committed
229
{
230
231
232
233
234
235
236
237
238
239
240
241
242
    int i, j;
    VirtPageDesc *p;
    
    virt_valid_tag++;

    if (virt_valid_tag == 0) {
        virt_valid_tag = 1;
        for(i = 0; i < L1_SIZE; i++) {
            p = l1_virt_map[i];
            if (p) {
                for(j = 0; j < L2_SIZE; j++)
                    p[j].valid_tag = 0;
            }
bellard's avatar
bellard committed
243
        }
bellard's avatar
bellard committed
244
245
    }
}
246
247
248
249
250
#else
static void virt_page_flush(void)
{
}
#endif
bellard's avatar
bellard committed
251

bellard's avatar
bellard committed
252
void cpu_exec_init(void)
bellard's avatar
bellard committed
253
254
255
{
    if (!code_gen_ptr) {
        code_gen_ptr = code_gen_buffer;
bellard's avatar
bellard committed
256
        page_init();
257
        io_mem_init();
bellard's avatar
bellard committed
258
259
260
    }
}

261
262
263
static inline void invalidate_page_bitmap(PageDesc *p)
{
    if (p->code_bitmap) {
264
        qemu_free(p->code_bitmap);
265
266
267
268
269
        p->code_bitmap = NULL;
    }
    p->code_write_count = 0;
}

bellard's avatar
bellard committed
270
271
272
273
274
275
276
277
278
/* set to NULL all the 'first_tb' fields in all PageDescs */
static void page_flush_tb(void)
{
    int i, j;
    PageDesc *p;

    for(i = 0; i < L1_SIZE; i++) {
        p = l1_map[i];
        if (p) {
279
280
281
282
283
            for(j = 0; j < L2_SIZE; j++) {
                p->first_tb = NULL;
                invalidate_page_bitmap(p);
                p++;
            }
bellard's avatar
bellard committed
284
285
286
287
288
        }
    }
}

/* flush all the translation blocks */
bellard's avatar
bellard committed
289
/* XXX: tb_flush is currently not thread safe */
290
void tb_flush(CPUState *env)
bellard's avatar
bellard committed
291
292
{
    int i;
293
#if defined(DEBUG_FLUSH)
bellard's avatar
bellard committed
294
295
296
    printf("qemu: flush code_size=%d nb_tbs=%d avg_tb_size=%d\n", 
           code_gen_ptr - code_gen_buffer, 
           nb_tbs, 
297
           nb_tbs > 0 ? (code_gen_ptr - code_gen_buffer) / nb_tbs : 0);
bellard's avatar
bellard committed
298
299
300
301
#endif
    nb_tbs = 0;
    for(i = 0;i < CODE_GEN_HASH_SIZE; i++)
        tb_hash[i] = NULL;
302
303
304
305
    virt_page_flush();

    for(i = 0;i < CODE_GEN_PHYS_HASH_SIZE; i++)
        tb_phys_hash[i] = NULL;
bellard's avatar
bellard committed
306
    page_flush_tb();
307

bellard's avatar
bellard committed
308
    code_gen_ptr = code_gen_buffer;
bellard's avatar
bellard committed
309
310
    /* XXX: flush processor icache at this point if cache flush is
       expensive */
bellard's avatar
bellard committed
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
}

#ifdef DEBUG_TB_CHECK

static void tb_invalidate_check(unsigned long address)
{
    TranslationBlock *tb;
    int i;
    address &= TARGET_PAGE_MASK;
    for(i = 0;i < CODE_GEN_HASH_SIZE; i++) {
        for(tb = tb_hash[i]; tb != NULL; tb = tb->hash_next) {
            if (!(address + TARGET_PAGE_SIZE <= tb->pc ||
                  address >= tb->pc + tb->size)) {
                printf("ERROR invalidate: address=%08lx PC=%08lx size=%04x\n",
                       address, 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_HASH_SIZE; i++) {
        for(tb = tb_hash[i]; tb != NULL; tb = tb->hash_next) {
            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",
                       tb->pc, tb->size, flags1, flags2);
            }
        }
    }
}

bellard's avatar
bellard committed
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
void tb_jmp_check(TranslationBlock *tb)
{
    TranslationBlock *tb1;
    unsigned int n1;

    /* suppress any remaining jumps to this TB */
    tb1 = tb->jmp_first;
    for(;;) {
        n1 = (long)tb1 & 3;
        tb1 = (TranslationBlock *)((long)tb1 & ~3);
        if (n1 == 2)
            break;
        tb1 = tb1->jmp_next[n1];
    }
    /* check end of list */
    if (tb1 != tb) {
        printf("ERROR: jmp_list from 0x%08lx\n", (long)tb);
    }
}

bellard's avatar
bellard committed
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
#endif

/* invalidate one TB */
static inline void tb_remove(TranslationBlock **ptb, TranslationBlock *tb,
                             int next_offset)
{
    TranslationBlock *tb1;
    for(;;) {
        tb1 = *ptb;
        if (tb1 == tb) {
            *ptb = *(TranslationBlock **)((char *)tb1 + next_offset);
            break;
        }
        ptb = (TranslationBlock **)((char *)tb1 + next_offset);
    }
}

386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
static inline void tb_page_remove(TranslationBlock **ptb, TranslationBlock *tb)
{
    TranslationBlock *tb1;
    unsigned int n1;

    for(;;) {
        tb1 = *ptb;
        n1 = (long)tb1 & 3;
        tb1 = (TranslationBlock *)((long)tb1 & ~3);
        if (tb1 == tb) {
            *ptb = tb1->page_next[n1];
            break;
        }
        ptb = &tb1->page_next[n1];
    }
}

bellard's avatar
bellard committed
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
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 = (long)tb1 & 3;
            tb1 = (TranslationBlock *)((long)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, (unsigned long)(tb->tc_ptr + tb->tb_next_offset[n]));
}

438
static inline void tb_invalidate(TranslationBlock *tb)
bellard's avatar
bellard committed
439
{
bellard's avatar
bellard committed
440
    unsigned int h, n1;
441
    TranslationBlock *tb1, *tb2, **ptb;
bellard's avatar
bellard committed
442
    
443
    tb_invalidated_flag = 1;
444

bellard's avatar
bellard committed
445
446
    /* remove the TB from the hash list */
    h = tb_hash_func(tb->pc);
447
448
449
450
451
452
453
454
455
456
457
458
    ptb = &tb_hash[h];
    for(;;) {
        tb1 = *ptb;
        /* NOTE: the TB is not necessarily linked in the hash. It
           indicates that it is not currently used */
        if (tb1 == NULL)
            return;
        if (tb1 == tb) {
            *ptb = tb1->hash_next;
            break;
        }
        ptb = &tb1->hash_next;
bellard's avatar
bellard committed
459
    }
bellard's avatar
bellard committed
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477

    /* 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 = (long)tb1 & 3;
        if (n1 == 2)
            break;
        tb1 = (TranslationBlock *)((long)tb1 & ~3);
        tb2 = tb1->jmp_next[n1];
        tb_reset_jump(tb1, n1);
        tb1->jmp_next[n1] = NULL;
        tb1 = tb2;
    }
    tb->jmp_first = (TranslationBlock *)((long)tb | 2); /* fail safe */
bellard's avatar
bellard committed
478
479
}

480
static inline void tb_phys_invalidate(TranslationBlock *tb, unsigned int page_addr)
bellard's avatar
bellard committed
481
482
{
    PageDesc *p;
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
    unsigned int h;
    target_ulong phys_pc;
    
    /* 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);
    tb_remove(&tb_phys_hash[h], tb, 
              offsetof(TranslationBlock, phys_hash_next));

    /* 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);
    }

    tb_invalidate(tb);
}

static inline void set_bits(uint8_t *tab, int start, int len)
{
    int end, mask, end1;

    end = start + len;
    tab += start >> 3;
    mask = 0xff << (start & 7);
    if ((start & ~7) == (end & ~7)) {
        if (start < end) {
            mask &= ~(0xff << (end & 7));
            *tab |= mask;
        }
    } else {
        *tab++ |= mask;
        start = (start + 8) & ~7;
        end1 = end & ~7;
        while (start < end1) {
            *tab++ = 0xff;
            start += 8;
        }
        if (start < end) {
            mask = ~(0xff << (end & 7));
            *tab |= mask;
        }
    }
}

static void build_page_bitmap(PageDesc *p)
{
    int n, tb_start, tb_end;
    TranslationBlock *tb;
    
539
    p->code_bitmap = qemu_malloc(TARGET_PAGE_SIZE / 8);
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
    if (!p->code_bitmap)
        return;
    memset(p->code_bitmap, 0, TARGET_PAGE_SIZE / 8);

    tb = p->first_tb;
    while (tb != NULL) {
        n = (long)tb & 3;
        tb = (TranslationBlock *)((long)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);
        }
        set_bits(p->code_bitmap, tb_start, tb_end - tb_start);
        tb = tb->page_next[n];
    }
}

bellard's avatar
bellard committed
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
#ifdef TARGET_HAS_PRECISE_SMC

static void tb_gen_code(CPUState *env, 
                        target_ulong pc, target_ulong cs_base, int flags,
                        int cflags)
{
    TranslationBlock *tb;
    uint8_t *tc_ptr;
    target_ulong phys_pc, phys_page2, virt_page2;
    int code_gen_size;

    phys_pc = get_phys_addr_code(env, (unsigned long)pc);
    tb = tb_alloc((unsigned long)pc);
    if (!tb) {
        /* flush must be done */
        tb_flush(env);
        /* cannot fail at this point */
        tb = tb_alloc((unsigned long)pc);
    }
    tc_ptr = code_gen_ptr;
    tb->tc_ptr = tc_ptr;
    tb->cs_base = cs_base;
    tb->flags = flags;
    tb->cflags = cflags;
    cpu_gen_code(env, tb, CODE_GEN_MAX_SIZE, &code_gen_size);
    code_gen_ptr = (void *)(((unsigned long)code_gen_ptr + code_gen_size + CODE_GEN_ALIGN - 1) & ~(CODE_GEN_ALIGN - 1));
    
    /* check next page if needed */
    virt_page2 = ((unsigned long)pc + tb->size - 1) & TARGET_PAGE_MASK;
    phys_page2 = -1;
    if (((unsigned long)pc & TARGET_PAGE_MASK) != virt_page2) {
        phys_page2 = get_phys_addr_code(env, virt_page2);
    }
    tb_link_phys(tb, phys_pc, phys_page2);
}
#endif
    
602
603
/* invalidate all TBs which intersect with the target physical page
   starting in range [start;end[. NOTE: start and end must refer to
bellard's avatar
bellard committed
604
605
606
607
608
609
610
611
612
613
   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(target_ulong start, target_ulong end, 
                                   int is_cpu_write_access)
{
    int n, current_tb_modified, current_tb_not_found, current_flags;
#if defined(TARGET_HAS_PRECISE_SMC) || !defined(CONFIG_USER_ONLY)
    CPUState *env = cpu_single_env;
#endif
614
    PageDesc *p;
bellard's avatar
bellard committed
615
    TranslationBlock *tb, *tb_next, *current_tb;
616
    target_ulong tb_start, tb_end;
bellard's avatar
bellard committed
617
    target_ulong current_pc, current_cs_base;
618
619
620
621
622

    p = page_find(start >> TARGET_PAGE_BITS);
    if (!p) 
        return;
    if (!p->code_bitmap && 
bellard's avatar
bellard committed
623
624
        ++p->code_write_count >= SMC_BITMAP_USE_THRESHOLD &&
        is_cpu_write_access) {
625
626
627
628
629
630
        /* build code bitmap */
        build_page_bitmap(p);
    }

    /* 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 */
bellard's avatar
bellard committed
631
632
633
634
635
636
    current_tb_not_found = is_cpu_write_access;
    current_tb_modified = 0;
    current_tb = NULL; /* avoid warning */
    current_pc = 0; /* avoid warning */
    current_cs_base = 0; /* avoid warning */
    current_flags = 0; /* avoid warning */
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
    tb = p->first_tb;
    while (tb != NULL) {
        n = (long)tb & 3;
        tb = (TranslationBlock *)((long)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)) {
bellard's avatar
bellard committed
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
#ifdef TARGET_HAS_PRECISE_SMC
            if (current_tb_not_found) {
                current_tb_not_found = 0;
                current_tb = NULL;
                if (env->mem_write_pc) {
                    /* now we have a real cpu fault */
                    current_tb = tb_find_pc(env->mem_write_pc);
                }
            }
            if (current_tb == tb &&
                !(current_tb->cflags & CF_SINGLE_INSN)) {
                /* 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;
                cpu_restore_state(current_tb, env, 
                                  env->mem_write_pc, NULL);
#if defined(TARGET_I386)
                current_flags = env->hflags;
                current_flags |= (env->eflags & (IOPL_MASK | TF_MASK | VM_MASK));
                current_cs_base = (target_ulong)env->segs[R_CS].base;
                current_pc = current_cs_base + env->eip;
#else
#error unsupported CPU
#endif
            }
#endif /* TARGET_HAS_PRECISE_SMC */
683
684
685
686
687
688
689
690
            tb_phys_invalidate(tb, -1);
        }
        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);
bellard's avatar
bellard committed
691
692
693
694
695
696
697
698
699
700
701
702
703
        if (is_cpu_write_access) {
            tlb_unprotect_code_phys(env, start, env->mem_write_vaddr);
        }
    }
#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 */
        tb_gen_code(env, current_pc, current_cs_base, current_flags, 
                    CF_SINGLE_INSN);
        cpu_resume_from_signal(env, NULL);
704
    }
bellard's avatar
bellard committed
705
#endif
706
}
bellard's avatar
bellard committed
707

708
/* len must be <= 8 and start must be a multiple of len */
bellard's avatar
bellard committed
709
static inline void tb_invalidate_phys_page_fast(target_ulong start, int len)
710
711
712
{
    PageDesc *p;
    int offset, b;
713
714
715
716
717
718
719
#if 0
    if (cpu_single_env->cr[0] & CR0_PE_MASK) {
        printf("modifying code at 0x%x size=%d EIP=%x\n", 
               (vaddr & TARGET_PAGE_MASK) | (start & ~TARGET_PAGE_MASK), len, 
               cpu_single_env->eip);
    }
#endif
720
721
722
723
724
725
726
727
728
729
    p = page_find(start >> TARGET_PAGE_BITS);
    if (!p) 
        return;
    if (p->code_bitmap) {
        offset = start & ~TARGET_PAGE_MASK;
        b = p->code_bitmap[offset >> 3] >> (offset & 7);
        if (b & ((1 << len) - 1))
            goto do_invalidate;
    } else {
    do_invalidate:
bellard's avatar
bellard committed
730
        tb_invalidate_phys_page_range(start, start + len, 1);
731
732
733
734
    }
}

#if !defined(CONFIG_SOFTMMU)
bellard's avatar
bellard committed
735
736
static void tb_invalidate_phys_page(target_ulong addr, 
                                    unsigned long pc, void *puc)
737
{
bellard's avatar
bellard committed
738
739
    int n, current_flags, current_tb_modified;
    target_ulong current_pc, current_cs_base;
740
    PageDesc *p;
bellard's avatar
bellard committed
741
742
743
744
    TranslationBlock *tb, *current_tb;
#ifdef TARGET_HAS_PRECISE_SMC
    CPUState *env = cpu_single_env;
#endif
745
746
747
748
749
750

    addr &= TARGET_PAGE_MASK;
    p = page_find(addr >> TARGET_PAGE_BITS);
    if (!p) 
        return;
    tb = p->first_tb;
bellard's avatar
bellard committed
751
752
753
754
755
756
757
758
759
760
    current_tb_modified = 0;
    current_tb = NULL;
    current_pc = 0; /* avoid warning */
    current_cs_base = 0; /* avoid warning */
    current_flags = 0; /* avoid warning */
#ifdef TARGET_HAS_PRECISE_SMC
    if (tb && pc != 0) {
        current_tb = tb_find_pc(pc);
    }
#endif
761
762
763
    while (tb != NULL) {
        n = (long)tb & 3;
        tb = (TranslationBlock *)((long)tb & ~3);
bellard's avatar
bellard committed
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
#ifdef TARGET_HAS_PRECISE_SMC
        if (current_tb == tb &&
            !(current_tb->cflags & CF_SINGLE_INSN)) {
                /* 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;
            cpu_restore_state(current_tb, env, pc, puc);
#if defined(TARGET_I386)
            current_flags = env->hflags;
            current_flags |= (env->eflags & (IOPL_MASK | TF_MASK | VM_MASK));
            current_cs_base = (target_ulong)env->segs[R_CS].base;
            current_pc = current_cs_base + env->eip;
#else
#error unsupported CPU
#endif
        }
#endif /* TARGET_HAS_PRECISE_SMC */
785
786
787
        tb_phys_invalidate(tb, addr);
        tb = tb->page_next[n];
    }
bellard's avatar
bellard committed
788
    p->first_tb = NULL;
bellard's avatar
bellard committed
789
790
791
792
793
794
795
796
797
798
#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 */
        tb_gen_code(env, current_pc, current_cs_base, current_flags, 
                    CF_SINGLE_INSN);
        cpu_resume_from_signal(env, puc);
    }
#endif
bellard's avatar
bellard committed
799
}
800
#endif
bellard's avatar
bellard committed
801
802

/* add the tb in the target page and protect it if necessary */
803
804
static inline void tb_alloc_page(TranslationBlock *tb, 
                                 unsigned int n, unsigned int page_addr)
bellard's avatar
bellard committed
805
806
{
    PageDesc *p;
807
808
809
810
811
812
813
814
    TranslationBlock *last_first_tb;

    tb->page_addr[n] = page_addr;
    p = page_find(page_addr >> TARGET_PAGE_BITS);
    tb->page_next[n] = p->first_tb;
    last_first_tb = p->first_tb;
    p->first_tb = (TranslationBlock *)((long)tb | n);
    invalidate_page_bitmap(p);
bellard's avatar
bellard committed
815

bellard's avatar
bellard committed
816
817
#ifdef TARGET_HAS_SMC

818
#if defined(CONFIG_USER_ONLY)
bellard's avatar
bellard committed
819
    if (p->flags & PAGE_WRITE) {
820
821
822
        unsigned long host_start, host_end, addr;
        int prot;

bellard's avatar
bellard committed
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
        /* force the host page as non writable (writes will have a
           page fault + mprotect overhead) */
        host_start = page_addr & host_page_mask;
        host_end = host_start + host_page_size;
        prot = 0;
        for(addr = host_start; addr < host_end; addr += TARGET_PAGE_SIZE)
            prot |= page_get_flags(addr);
        mprotect((void *)host_start, host_page_size, 
                 (prot & PAGE_BITS) & ~PAGE_WRITE);
#ifdef DEBUG_TB_INVALIDATE
        printf("protecting code page: 0x%08lx\n", 
               host_start);
#endif
        p->flags &= ~PAGE_WRITE;
    }
838
839
840
841
842
843
844
845
846
847
848
#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 (!last_first_tb) {
        target_ulong virt_addr;

        virt_addr = (tb->pc & TARGET_PAGE_MASK) + (n << TARGET_PAGE_BITS);
        tlb_protect_code(cpu_single_env, virt_addr);        
    }
#endif
bellard's avatar
bellard committed
849
850

#endif /* TARGET_HAS_SMC */
bellard's avatar
bellard committed
851
852
853
854
}

/* Allocate a new translation block. Flush the translation buffer if
   too many translation blocks or too much generated code. */
bellard's avatar
bellard committed
855
TranslationBlock *tb_alloc(unsigned long pc)
bellard's avatar
bellard committed
856
857
858
859
860
{
    TranslationBlock *tb;

    if (nb_tbs >= CODE_GEN_MAX_BLOCKS || 
        (code_gen_ptr - code_gen_buffer) >= CODE_GEN_BUFFER_MAX_SIZE)
bellard's avatar
bellard committed
861
        return NULL;
bellard's avatar
bellard committed
862
863
    tb = &tbs[nb_tbs++];
    tb->pc = pc;
864
    tb->cflags = 0;
bellard's avatar
bellard committed
865
866
867
    return tb;
}

868
869
870
871
/* 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. */
void tb_link_phys(TranslationBlock *tb, 
                  target_ulong phys_pc, target_ulong phys_page2)
bellard's avatar
bellard committed
872
{
873
874
875
876
877
878
879
880
    unsigned int h;
    TranslationBlock **ptb;

    /* add in the physical hash table */
    h = tb_phys_hash_func(phys_pc);
    ptb = &tb_phys_hash[h];
    tb->phys_hash_next = *ptb;
    *ptb = tb;
bellard's avatar
bellard committed
881
882

    /* add in the page list */
883
884
885
886
887
    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;
bellard's avatar
bellard committed
888
889
890
#ifdef DEBUG_TB_CHECK
    tb_page_check();
#endif
891
892
893
894
895
896
897
898
899
900
901
902
903
}

/* link the tb with the other TBs */
void tb_link(TranslationBlock *tb)
{
#if !defined(CONFIG_USER_ONLY)
    {
        VirtPageDesc *vp;
        target_ulong addr;
        
        /* save the code memory mappings (needed to invalidate the code) */
        addr = tb->pc & TARGET_PAGE_MASK;
        vp = virt_page_find_alloc(addr >> TARGET_PAGE_BITS);
bellard's avatar
bellard committed
904
905
906
907
908
909
910
#ifdef DEBUG_TLB_CHECK 
        if (vp->valid_tag == virt_valid_tag &&
            vp->phys_addr != tb->page_addr[0]) {
            printf("Error tb addr=0x%x phys=0x%x vp->phys_addr=0x%x\n",
                   addr, tb->page_addr[0], vp->phys_addr);
        }
#endif
911
        vp->phys_addr = tb->page_addr[0];
912
913
914
915
916
917
        if (vp->valid_tag != virt_valid_tag) {
            vp->valid_tag = virt_valid_tag;
#if !defined(CONFIG_SOFTMMU)
            vp->prot = 0;
#endif
        }
918
919
920
921
        
        if (tb->page_addr[1] != -1) {
            addr += TARGET_PAGE_SIZE;
            vp = virt_page_find_alloc(addr >> TARGET_PAGE_BITS);
bellard's avatar
bellard committed
922
923
924
925
926
927
928
#ifdef DEBUG_TLB_CHECK 
            if (vp->valid_tag == virt_valid_tag &&
                vp->phys_addr != tb->page_addr[1]) { 
                printf("Error tb addr=0x%x phys=0x%x vp->phys_addr=0x%x\n",
                       addr, tb->page_addr[1], vp->phys_addr);
            }
#endif
929
            vp->phys_addr = tb->page_addr[1];
930
931
932
933
934
935
            if (vp->valid_tag != virt_valid_tag) {
                vp->valid_tag = virt_valid_tag;
#if !defined(CONFIG_SOFTMMU)
                vp->prot = 0;
#endif
            }
936
937
938
939
        }
    }
#endif

bellard's avatar
bellard committed
940
941
942
    tb->jmp_first = (TranslationBlock *)((long)tb | 2);
    tb->jmp_next[0] = NULL;
    tb->jmp_next[1] = NULL;
943
944
945
946
947
#ifdef USE_CODE_COPY
    tb->cflags &= ~CF_FP_USED;
    if (tb->cflags & CF_TB_FP_USED)
        tb->cflags |= CF_FP_USED;
#endif
bellard's avatar
bellard committed
948
949
950
951
952
953

    /* 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);
bellard's avatar
bellard committed
954
955
}

956
957
958
/* find the TB 'tb' such that tb[0].tc_ptr <= tc_ptr <
   tb[1].tc_ptr. Return NULL if not found */
TranslationBlock *tb_find_pc(unsigned long tc_ptr)
bellard's avatar
bellard committed
959
{
960
961
962
    int m_min, m_max, m;
    unsigned long v;
    TranslationBlock *tb;
bellard's avatar
bellard committed
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985

    if (nb_tbs <= 0)
        return NULL;
    if (tc_ptr < (unsigned long)code_gen_buffer ||
        tc_ptr >= (unsigned long)code_gen_ptr)
        return NULL;
    /* binary search (cf Knuth) */
    m_min = 0;
    m_max = nb_tbs - 1;
    while (m_min <= m_max) {
        m = (m_min + m_max) >> 1;
        tb = &tbs[m];
        v = (unsigned long)tb->tc_ptr;
        if (v == tc_ptr)
            return tb;
        else if (tc_ptr < v) {
            m_max = m - 1;
        } else {
            m_min = m + 1;
        }
    } 
    return &tbs[m_max];
}
bellard's avatar
bellard committed
986

bellard's avatar
bellard committed
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
static void tb_reset_jump_recursive(TranslationBlock *tb);

static inline void tb_reset_jump_recursive2(TranslationBlock *tb, int n)
{
    TranslationBlock *tb1, *tb_next, **ptb;
    unsigned int n1;

    tb1 = tb->jmp_next[n];
    if (tb1 != NULL) {
        /* find head of list */
        for(;;) {
            n1 = (long)tb1 & 3;
            tb1 = (TranslationBlock *)((long)tb1 & ~3);
            if (n1 == 2)
                break;
            tb1 = tb1->jmp_next[n1];
        }
        /* we are now sure now that tb jumps to tb1 */
        tb_next = tb1;

        /* remove tb from the jmp_first list */
        ptb = &tb_next->jmp_first;
        for(;;) {
            tb1 = *ptb;
            n1 = (long)tb1 & 3;
            tb1 = (TranslationBlock *)((long)tb1 & ~3);
            if (n1 == n && tb1 == tb)
                break;
            ptb = &tb1->jmp_next[n1];
        }
        *ptb = tb->jmp_next[n];
        tb->jmp_next[n] = NULL;
        
        /* suppress the jump to next tb in generated code */
        tb_reset_jump(tb, n);

1023
        /* suppress jumps in the tb on which we could have jumped */
bellard's avatar
bellard committed
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
        tb_reset_jump_recursive(tb_next);
    }
}

static void tb_reset_jump_recursive(TranslationBlock *tb)
{
    tb_reset_jump_recursive2(tb, 0);
    tb_reset_jump_recursive2(tb, 1);
}

bellard's avatar
bellard committed
1034
1035
1036
1037
1038
1039
1040
1041
static void breakpoint_invalidate(CPUState *env, target_ulong pc)
{
    target_ulong phys_addr;

    phys_addr = cpu_get_phys_page_debug(env, pc);
    tb_invalidate_phys_page_range(phys_addr, phys_addr + 1, 0);
}

1042
1043
/* add a breakpoint. EXCP_DEBUG is returned by the CPU loop if a
   breakpoint is reached */
1044
int cpu_breakpoint_insert(CPUState *env, target_ulong pc)
bellard's avatar
bellard committed
1045
{
1046
#if defined(TARGET_I386) || defined(TARGET_PPC)
bellard's avatar
bellard committed
1047
    int i;
bellard's avatar
bellard committed
1048
    
bellard's avatar
bellard committed
1049
1050
1051
1052
1053
1054
1055
1056
    for(i = 0; i < env->nb_breakpoints; i++) {
        if (env->breakpoints[i] == pc)
            return 0;
    }

    if (env->nb_breakpoints >= MAX_BREAKPOINTS)
        return -1;
    env->breakpoints[env->nb_breakpoints++] = pc;
bellard's avatar
bellard committed
1057
1058
    
    breakpoint_invalidate(env, pc);
bellard's avatar
bellard committed
1059
1060
1061
1062
1063
1064
1065
    return 0;
#else
    return -1;
#endif
}

/* remove a breakpoint */
1066
int cpu_breakpoint_remove(CPUState *env, target_ulong pc)
bellard's avatar
bellard committed
1067
{
1068
#if defined(TARGET_I386) || defined(TARGET_PPC)
bellard's avatar
bellard committed
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
    int i;
    for(i = 0; i < env->nb_breakpoints; i++) {
        if (env->breakpoints[i] == pc)
            goto found;
    }
    return -1;
 found:
    memmove(&env->breakpoints[i], &env->breakpoints[i + 1],
            (env->nb_breakpoints - (i + 1)) * sizeof(env->breakpoints[0]));
    env->nb_breakpoints--;
bellard's avatar
bellard committed
1079
1080

    breakpoint_invalidate(env, pc);
bellard's avatar
bellard committed
1081
1082
1083
1084
1085
1086
    return 0;
#else
    return -1;
#endif
}

1087
1088
1089
1090
/* enable or disable single step mode. EXCP_DEBUG is returned by the
   CPU loop after each instruction */
void cpu_single_step(CPUState *env, int enabled)
{
1091
#if defined(TARGET_I386) || defined(TARGET_PPC)
1092
1093
1094
    if (env->singlestep_enabled != enabled) {
        env->singlestep_enabled = enabled;
        /* must flush all the translated code to avoid inconsistancies */
1095
        /* XXX: only flush what is necessary */
1096
        tb_flush(env);
1097
1098
1099
1100
    }
#endif
}

1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
/* enable or disable low levels log */
void cpu_set_log(int log_flags)
{
    loglevel = log_flags;
    if (loglevel && !logfile) {
        logfile = fopen(logfilename, "w");
        if (!logfile) {
            perror(logfilename);
            _exit(1);
        }
1111
1112
1113
1114
1115
1116
1117
#if !defined(CONFIG_SOFTMMU)
        /* must avoid mmap() usage of glibc by setting a buffer "by hand" */
        {
            static uint8_t logfile_buf[4096];
            setvbuf(logfile, logfile_buf, _IOLBF, sizeof(logfile_buf));
        }
#else
1118
        setvbuf(logfile, NULL, _IOLBF, 0);
1119
#endif
1120
1121
1122
1123
1124
1125
1126
    }
}

void cpu_set_log_filename(const char *filename)
{
    logfilename = strdup(filename);
}
1127

1128
/* mask must never be zero, except for A20 change call */
bellard's avatar
bellard committed
1129
void cpu_interrupt(CPUState *env, int mask)
bellard's avatar
bellard committed
1130
1131
{
    TranslationBlock *tb;
1132
    static int interrupt_lock;
1133

bellard's avatar
bellard committed
1134
    env->interrupt_request |= mask;
bellard's avatar
bellard committed
1135
1136
1137
    /* if the cpu is currently executing code, we must unlink it and
       all the potentially executing TB */
    tb = env->current_tb;
1138
1139
    if (tb && !testandset(&interrupt_lock)) {
        env->current_tb = NULL;
bellard's avatar
bellard committed
1140
        tb_reset_jump_recursive(tb);
1141
        interrupt_lock = 0;
bellard's avatar
bellard committed
1142
1143
1144
    }
}

1145
1146
1147
1148
1149
void cpu_reset_interrupt(CPUState *env, int mask)
{
    env->interrupt_request &= ~mask;
}

1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
CPULogItem cpu_log_items[] = {
    { CPU_LOG_TB_OUT_ASM, "out_asm", 
      "show generated host assembly code for each compiled TB" },
    { CPU_LOG_TB_IN_ASM, "in_asm",
      "show target assembly code for each compiled TB" },
    { CPU_LOG_TB_OP, "op", 
      "show micro ops for each compiled TB (only usable if 'in_asm' used)" },
#ifdef TARGET_I386
    { CPU_LOG_TB_OP_OPT, "op_opt",
      "show micro ops after optimization for each compiled TB" },
#endif
    { CPU_LOG_INT, "int",
      "show interrupts/exceptions in short format" },
    { CPU_LOG_EXEC, "exec",
      "show trace before each executed TB (lots of logs)" },
1165
1166
    { CPU_LOG_TB_CPU, "cpu",
      "show CPU state before bloc translation" },
1167
1168
1169
1170
#ifdef TARGET_I386
    { CPU_LOG_PCALL, "pcall",
      "show protected mode far calls/returns/exceptions" },
#endif
1171
1172
    { CPU_LOG_IOPORT, "ioport",
      "show all i/o ports accesses" },
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
    { 0, NULL, NULL },
};

static int cmp1(const char *s1, int n, const char *s2)
{
    if (strlen(s2) != n)
        return 0;
    return memcmp(s1, s2, n) == 0;
}
      
/* takes a comma separated list of log masks. Return 0 if error. */
int cpu_str_to_log_mask(const char *str)
{
    CPULogItem *item;
    int mask;
    const char *p, *p1;

    p = str;
    mask = 0;
    for(;;) {
        p1 = strchr(p, ',');
        if (!p1)
            p1 = p + strlen(p);
        for(item = cpu_log_items; item->mask != 0; item++) {
            if (cmp1(p, p1 - p, item->name))
                goto found;
        }
        return 0;
    found:
        mask |= item->mask;
        if (*p1 != ',')
            break;
        p = p1 + 1;
    }
    return mask;
}
bellard's avatar
bellard committed
1209

bellard's avatar
bellard committed
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
void cpu_abort(CPUState *env, const char *fmt, ...)
{
    va_list ap;

    va_start(ap, fmt);
    fprintf(stderr, "qemu: fatal: ");
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, "\n");
#ifdef TARGET_I386
    cpu_x86_dump_state(env, stderr, X86_DUMP_FPU | X86_DUMP_CCOP);
#endif
    va_end(ap);
    abort();
}

1225
1226
#if !defined(CONFIG_USER_ONLY)

1227
1228
1229
/* NOTE: if flush_global is true, also flush global entries (not
   implemented yet) */
void tlb_flush(CPUState *env, int flush_global)
1230
1231
{
    int i;
1232

1233
1234
1235
#if defined(DEBUG_TLB)
    printf("tlb_flush:\n");
#endif
1236
1237
1238
1239
    /* must reset current TB so that interrupts cannot modify the
       links while we are modifying them */
    env->current_tb = NULL;

1240
1241
1242
1243
1244
1245
    for(i = 0; i < CPU_TLB_SIZE; i++) {
        env->tlb_read[0][i].address = -1;
        env->tlb_write[0][i].address = -1;
        env->tlb_read[1][i].address = -1;
        env->tlb_write[1][i].address = -1;
    }
1246
1247
1248
1249
1250
1251
1252
1253

    virt_page_flush();
    for(i = 0;i < CODE_GEN_HASH_SIZE; i++)
        tb_hash[i] = NULL;

#if !defined(CONFIG_SOFTMMU)
    munmap((void *)MMAP_AREA_START, MMAP_AREA_END - MMAP_AREA_START);
#endif
1254
1255
}

bellard's avatar
bellard committed
1256
static inline void tlb_flush_entry(CPUTLBEntry *tlb_entry, target_ulong addr)
bellard's avatar
bellard committed
1257
1258
1259
1260
1261
1262
{
    if (addr == (tlb_entry->address & 
                 (TARGET_PAGE_MASK | TLB_INVALID_MASK)))
        tlb_entry->address = -1;
}

1263
void tlb_flush_page(CPUState *env, target_ulong addr)
1264
{
1265
1266
1267
1268
    int i, n;
    VirtPageDesc *vp;
    PageDesc *p;
    TranslationBlock *tb;
1269

1270
1271
1272
#if defined(DEBUG_TLB)
    printf("tlb_flush_page: 0x%08x\n", addr);
#endif
1273
1274
1275
    /* must reset current TB so that interrupts cannot modify the
       links while we are modifying them */
    env->current_tb = NULL;
bellard's avatar
bellard committed
1276
1277
1278
1279
1280
1281
1282

    addr &= TARGET_PAGE_MASK;
    i = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
    tlb_flush_entry(&env->tlb_read[0][i], addr);
    tlb_flush_entry(&env->tlb_write[0][i], addr);
    tlb_flush_entry(&env->tlb_read[1][i], addr);
    tlb_flush_entry(&env->tlb_write[1][i], addr);
1283

1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
    /* remove from the virtual pc hash table all the TB at this
       virtual address */
    
    vp = virt_page_find(addr >> TARGET_PAGE_BITS);
    if (vp && vp->valid_tag == virt_valid_tag) {
        p = page_find(vp->phys_addr >> TARGET_PAGE_BITS);
        if (p) {
            /* we remove all the links to the TBs in this virtual page */
            tb = p->first_tb;
            while (tb != NULL) {
                n = (long)tb & 3;
                tb = (TranslationBlock *)((long)tb & ~3);
                if ((tb->pc & TARGET_PAGE_MASK) == addr ||
                    ((tb->pc + tb->size - 1) & TARGET_PAGE_MASK) == addr) {
                    tb_invalidate(tb);
                }
                tb = tb->page_next[n];
            }
        }
bellard's avatar
bellard committed
1303
        vp->valid_tag = 0;
1304
1305
    }

1306
#if !defined(CONFIG_SOFTMMU)
1307
    if (addr < MMAP_AREA_END)
1308
        munmap((void *)addr, TARGET_PAGE_SIZE);
bellard's avatar
bellard committed
1309
#endif
1310
1311
}

bellard's avatar
bellard committed
1312
static inline void tlb_protect_code1(CPUTLBEntry *tlb_entry, target_ulong addr)
1313
1314
1315
{
    if (addr == (tlb_entry->address & 
                 (TARGET_PAGE_MASK | TLB_INVALID_MASK)) &&
bellard's avatar
bellard committed
1316
1317
        (tlb_entry->address & ~TARGET_PAGE_MASK) != IO_MEM_CODE &&
        (tlb_entry->address & ~TARGET_PAGE_MASK) != IO_MEM_ROM) {
1318
        tlb_entry->address = (tlb_entry->address & TARGET_PAGE_MASK) | IO_MEM_CODE;
1319
1320
1321
1322
1323
    }
}

/* update the TLBs so that writes to code in the virtual page 'addr'
   can be detected */
bellard's avatar
bellard committed
1324
static void tlb_protect_code(CPUState *env, target_ulong addr)
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
{
    int i;

    addr &= TARGET_PAGE_MASK;
    i = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
    tlb_protect_code1(&env->tlb_write[0][i], addr);
    tlb_protect_code1(&env->tlb_write[1][i], addr);
#if !defined(CONFIG_SOFTMMU)
    /* NOTE: as we generated the code for this page, it is already at
       least readable */
    if (addr < MMAP_AREA_END)
        mprotect((void *)addr, TARGET_PAGE_SIZE, PROT_READ);
#endif
}

static inline void tlb_unprotect_code2(CPUTLBEntry *tlb_entry, 
bellard's avatar
bellard committed
1341
                                       unsigned long phys_addr)
1342
1343
1344
{
    if ((tlb_entry->address & ~TARGET_PAGE_MASK) == IO_MEM_CODE &&
        ((tlb_entry->address & TARGET_PAGE_MASK) + tlb_entry->addend) == phys_addr) {
1345
        tlb_entry->address = (tlb_entry->address & TARGET_PAGE_MASK) | IO_MEM_NOTDIRTY;
1346
1347
1348
1349
1350
    }
}

/* update the TLB so that writes in physical page 'phys_addr' are no longer
   tested self modifying code */
bellard's avatar
bellard committed
1351
static void tlb_unprotect_code_phys(CPUState *env, unsigned long phys_addr, target_ulong vaddr)
1352
1353
1354
1355
{
    int i;

    phys_addr &= TARGET_PAGE_MASK;
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
    phys_addr += (long)phys_ram_base;
    i = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
    tlb_unprotect_code2(&env->tlb_write[0][i], phys_addr);
    tlb_unprotect_code2(&env->tlb_write[1][i], phys_addr);
}

static inline void tlb_reset_dirty_range(CPUTLBEntry *tlb_entry, 
                                         unsigned long start, unsigned long length)
{
    unsigned long addr;
    if ((tlb_entry->address & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {
        addr = (tlb_entry->address & TARGET_PAGE_MASK) + tlb_entry->addend;
        if ((addr - start) < length) {
            tlb_entry->address = (tlb_entry->address & TARGET_PAGE_MASK) | IO_MEM_NOTDIRTY;
        }
    }
}

void cpu_physical_memory_reset_dirty(target_ulong start, target_ulong end)
{
    CPUState *env;
bellard's avatar
bellard committed
1377
    unsigned long length, start1;
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
    int i;

    start &= TARGET_PAGE_MASK;
    end = TARGET_PAGE_ALIGN(end);

    length = end - start;
    if (length == 0)
        return;
    memset(phys_ram_dirty + (start >> TARGET_PAGE_BITS), 0, length >> TARGET_PAGE_BITS);

    env = cpu_single_env;
    /* we modify the TLB cache so that the dirty bit will be set again
       when accessing the range */
1391
    start1 = start + (unsigned long)phys_ram_base;
1392
    for(i = 0; i < CPU_TLB_SIZE; i++)
1393
        tlb_reset_dirty_range(&env->tlb_write[0][i], start1, length);
1394
    for(i = 0; i < CPU_TLB_SIZE; i++)
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
        tlb_reset_dirty_range(&env->tlb_write[1][i], start1, length);

#if !defined(CONFIG_SOFTMMU)
    /* XXX: this is expensive */
    {
        VirtPageDesc *p;
        int j;
        target_ulong addr;

        for(i = 0; i < L1_SIZE; i++) {
            p = l1_virt_map[i];
            if (p) {
                addr = i << (TARGET_PAGE_BITS + L2_BITS);
                for(j = 0; j < L2_SIZE; j++) {
                    if (p->valid_tag == virt_valid_tag &&
                        p->phys_addr >= start && p->phys_addr < end &&
                        (p->prot & PROT_WRITE)) {
                        if (addr < MMAP_AREA_END) {
                            mprotect((void *)addr, TARGET_PAGE_SIZE, 
                                     p->prot & ~PROT_WRITE);
                        }
                    }
                    addr += TARGET_PAGE_SIZE;
                    p++;
                }
            }
        }
    }
#endif
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
}

static inline void tlb_set_dirty1(CPUTLBEntry *tlb_entry, 
                                    unsigned long start)
{
    unsigned long addr;
    if ((tlb_entry->address & ~TARGET_PAGE_MASK) == IO_MEM_NOTDIRTY) {
        addr = (tlb_entry->address & TARGET_PAGE_MASK) + tlb_entry->addend;
        if (addr == start) {
            tlb_entry->address = (tlb_entry->address & TARGET_PAGE_MASK) | IO_MEM_RAM;
        }
    }
}

/* update the TLB corresponding to virtual page vaddr and phys addr
   addr so that it is no longer dirty */
static inline void tlb_set_dirty(unsigned long addr, target_ulong vaddr)
{
    CPUState *env = cpu_single_env;
    int i;

    phys_ram_dirty[(addr - (unsigned long)phys_ram_base) >> TARGET_PAGE_BITS] = 1;

    addr &= TARGET_PAGE_MASK;
    i = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
    tlb_set_dirty1(&env->tlb_write[0][i], addr);
    tlb_set_dirty1(&env->tlb_write[1][i], addr);
1451
1452
}

1453
1454
1455
1456
/* add a new TLB entry. At most one entry for a given virtual address
   is permitted. Return 0 if OK or 2 if the page could not be mapped
   (can only happen in non SOFTMMU mode for I/O pages or pages
   conflicting with the host address space). */
1457
1458
int tlb_set_page(CPUState *env, target_ulong vaddr, 
                 target_phys_addr_t paddr, int prot, 
1459
1460
                 int is_user, int is_softmmu)
{
1461
    PhysPageDesc *p;
bellard's avatar
bellard committed
1462
    unsigned long pd;
1463
1464
    TranslationBlock *first_tb;
    unsigned int index;
bellard's avatar
bellard committed
1465
1466
    target_ulong address;
    unsigned long addend;
1467
1468
    int ret;

1469
1470
    p = phys_page_find(paddr >> TARGET_PAGE_BITS);
    first_tb = NULL;
1471
1472
1473
    if (!p) {
        pd = IO_MEM_UNASSIGNED;
    } else {
1474
        PageDesc *p1;
1475
        pd = p->phys_offset;
1476
1477
1478
1479
1480
        if ((pd & ~TARGET_PAGE_MASK) <= IO_MEM_ROM) {
            /* NOTE: we also allocate the page at this stage */
            p1 = page_find_alloc(pd >> TARGET_PAGE_BITS);
            first_tb = p1->first_tb;
        }
1481
1482
1483
1484
1485
1486
1487