Statistics
| Branch: | Revision:

root / target-i386 / translate-copy.c @ 5fafdf24

History | View | Annotate | Download (33.7 kB)

1
/*
2
 *  i386 on i386 translation
3
 *
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
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 */
20
#include "config.h"
21

    
22
#include <stdarg.h>
23
#include <stdlib.h>
24
#include <stdio.h>
25
#include <string.h>
26
#include <inttypes.h>
27
#include <assert.h>
28

    
29
#include "cpu.h"
30
#include "exec-all.h"
31
#include "disas.h"
32

    
33
#ifdef USE_CODE_COPY
34

    
35
#include <signal.h>
36
#include <sys/mman.h>
37
#include <sys/ucontext.h>
38

    
39
extern char exec_loop;
40

    
41
/* operand size */
42
enum {
43
    OT_BYTE = 0,
44
    OT_WORD,
45
    OT_LONG,
46
    OT_QUAD,
47
};
48

    
49
#define PREFIX_REPZ   0x01
50
#define PREFIX_REPNZ  0x02
51
#define PREFIX_LOCK   0x04
52
#define PREFIX_DATA   0x08
53
#define PREFIX_ADR    0x10
54

    
55
typedef struct DisasContext {
56
    /* current insn context */
57
    int override; /* -1 if no override */
58
    int prefix;
59
    int aflag, dflag;
60
    target_ulong pc; /* pc = eip + cs_base */
61
    int is_jmp; /* 1 = means jump (stop translation), 2 means CPU
62
                   static state change (stop translation) */
63
    /* code output */
64
    uint8_t *gen_code_ptr;
65
    uint8_t *gen_code_start;
66
   
67
    /* current block context */
68
    target_ulong cs_base; /* base of CS segment */
69
    int pe;     /* protected mode */
70
    int code32; /* 32 bit code segment */
71
    int f_st;   /* currently unused */
72
    int vm86;   /* vm86 mode */
73
    int cpl;
74
    int iopl;
75
    int flags;
76
    struct TranslationBlock *tb;
77
} DisasContext;
78

    
79
#define CPU_FIELD_OFFSET(field) offsetof(CPUState, field)
80

    
81
#define CPU_SEG 0x64 /* fs override */
82

    
83
static inline void gb(DisasContext *s, uint32_t val)
84
{
85
    *s->gen_code_ptr++ = val;
86
}
87

    
88
static inline void gw(DisasContext *s, uint32_t val)
89
{
90
    *s->gen_code_ptr++ = val;
91
    *s->gen_code_ptr++ = val >> 8;
92
}
93

    
94
static inline void gl(DisasContext *s, uint32_t val)
95
{
96
    *s->gen_code_ptr++ = val;
97
    *s->gen_code_ptr++ = val >> 8;
98
    *s->gen_code_ptr++ = val >> 16;
99
    *s->gen_code_ptr++ = val >> 24;
100
}
101

    
102
static inline void gjmp(DisasContext *s, long val)
103
{
104
    gb(s, 0xe9); /* jmp */
105
    gl(s, val - (long)(s->gen_code_ptr + 4));
106
}
107

    
108
static inline void gen_movl_addr_im(DisasContext *s,
109
                                    uint32_t addr, uint32_t val)
110
{
111
    gb(s, CPU_SEG); /* seg movl im, addr */
112
    gb(s, 0xc7);
113
    gb(s, 0x05);
114
    gl(s, addr);
115
    gl(s, val);
116
}
117

    
118
static inline void gen_movw_addr_im(DisasContext *s,
119
                                    uint32_t addr, uint32_t val)
120
{
121
    gb(s, CPU_SEG); /* seg movl im, addr */
122
    gb(s, 0x66);
123
    gb(s, 0xc7);
124
    gb(s, 0x05);
125
    gl(s, addr);
126
    gw(s, val);
127
}
128

    
129

    
130
static void gen_jmp(DisasContext *s, uint32_t target_eip)
131
{
132
    TranslationBlock *tb = s->tb;
133

    
134
    gb(s, 0xe9); /* jmp */
135
    tb->tb_jmp_offset[0] = s->gen_code_ptr - s->gen_code_start;
136
    gl(s, 0);
137

    
138
    tb->tb_next_offset[0] = s->gen_code_ptr - s->gen_code_start;
139
    gen_movl_addr_im(s, CPU_FIELD_OFFSET(eip), target_eip);
140
    gen_movl_addr_im(s, CPU_FIELD_OFFSET(tmp0), (uint32_t)tb);
141
    gjmp(s, (long)&exec_loop);
142

    
143
    s->is_jmp = 1;
144
}
145

    
146
static void gen_jcc(DisasContext *s, int op,
147
                    uint32_t target_eip, uint32_t next_eip)
148
{
149
    TranslationBlock *tb = s->tb;
150

    
151
    gb(s, 0x0f); /* jcc */
152
    gb(s, 0x80 + op);
153
    tb->tb_jmp_offset[0] = s->gen_code_ptr - s->gen_code_start;
154
    gl(s, 0);
155
    gb(s, 0xe9); /* jmp */
156
    tb->tb_jmp_offset[1] = s->gen_code_ptr - s->gen_code_start;
157
    gl(s, 0);
158
   
159
    tb->tb_next_offset[0] = s->gen_code_ptr - s->gen_code_start;
160
    gen_movl_addr_im(s, CPU_FIELD_OFFSET(eip), target_eip);
161
    gen_movl_addr_im(s, CPU_FIELD_OFFSET(tmp0), (uint32_t)tb);
162
    gjmp(s, (long)&exec_loop);
163

    
164
    tb->tb_next_offset[1] = s->gen_code_ptr - s->gen_code_start;
165
    gen_movl_addr_im(s, CPU_FIELD_OFFSET(eip), next_eip);
166
    gen_movl_addr_im(s, CPU_FIELD_OFFSET(tmp0), (uint32_t)tb | 1);
167
    gjmp(s, (long)&exec_loop);
168

    
169
    s->is_jmp = 1;
170
}
171

    
172
static void gen_eob(DisasContext *s)
173
{
174
    gen_movl_addr_im(s, CPU_FIELD_OFFSET(tmp0), 0);
175
    gjmp(s, (long)&exec_loop);
176

    
177
    s->is_jmp = 1;
178
}
179

    
180
static inline void gen_lea_modrm(DisasContext *s, int modrm)
181
{
182
    int havesib;
183
    int base, disp;
184
    int index;
185
    int scale;
186
    int mod, rm, code;
187

    
188
    mod = (modrm >> 6) & 3;
189
    rm = modrm & 7;
190

    
191
    if (s->aflag) {
192

    
193
        havesib = 0;
194
        base = rm;
195
        index = 0;
196
        scale = 0;
197
       
198
        if (base == 4) {
199
            havesib = 1;
200
            code = ldub_code(s->pc++);
201
            scale = (code >> 6) & 3;
202
            index = (code >> 3) & 7;
203
            base = code & 7;
204
        }
205

    
206
        switch (mod) {
207
        case 0:
208
            if (base == 5) {
209
                base = -1;
210
                disp = ldl_code(s->pc);
211
                s->pc += 4;
212
            } else {
213
                disp = 0;
214
            }
215
            break;
216
        case 1:
217
            disp = (int8_t)ldub_code(s->pc++);
218
            break;
219
        default:
220
        case 2:
221
            disp = ldl_code(s->pc);
222
            s->pc += 4;
223
            break;
224
        }
225
       
226
    } else {
227
        switch (mod) {
228
        case 0:
229
            if (rm == 6) {
230
                disp = lduw_code(s->pc);
231
                s->pc += 2;
232
            } else {
233
                disp = 0;
234
            }
235
            break;
236
        case 1:
237
            disp = (int8_t)ldub_code(s->pc++);
238
            break;
239
        default:
240
        case 2:
241
            disp = lduw_code(s->pc);
242
            s->pc += 2;
243
            break;
244
        }
245
    }
246
}
247

    
248
static inline void parse_modrm(DisasContext *s, int modrm)
249
{
250
    if ((modrm & 0xc0) != 0xc0)
251
        gen_lea_modrm(s, modrm);       
252
}
253

    
254
static inline uint32_t insn_get(DisasContext *s, int ot)
255
{
256
    uint32_t ret;
257

    
258
    switch(ot) {
259
    case OT_BYTE:
260
        ret = ldub_code(s->pc);
261
        s->pc++;
262
        break;
263
    case OT_WORD:
264
        ret = lduw_code(s->pc);
265
        s->pc += 2;
266
        break;
267
    default:
268
    case OT_LONG:
269
        ret = ldl_code(s->pc);
270
        s->pc += 4;
271
        break;
272
    }
273
    return ret;
274
}
275

    
276
/* convert one instruction. s->is_jmp is set if the translation must
277
   be stopped.  */
278
static int disas_insn(DisasContext *s)
279
{
280
    target_ulong pc_start, pc_tmp, pc_start_insn;
281
    int b, prefixes, aflag, dflag, next_eip, val;
282
    int ot;
283
    int modrm, mod, op, rm;
284

    
285
    pc_start = s->pc;
286
    prefixes = 0;
287
    aflag = s->code32;
288
    dflag = s->code32;
289
    s->override = -1;
290
 next_byte:
291
    b = ldub_code(s->pc);
292
    s->pc++;
293
    /* check prefixes */
294
    switch (b) {
295
    case 0xf3:
296
        prefixes |= PREFIX_REPZ;
297
        goto next_byte;
298
    case 0xf2:
299
        prefixes |= PREFIX_REPNZ;
300
        goto next_byte;
301
    case 0xf0:
302
        prefixes |= PREFIX_LOCK;
303
        goto next_byte;
304
    case 0x2e:
305
        s->override = R_CS;
306
        goto next_byte;
307
    case 0x36:
308
        s->override = R_SS;
309
        goto next_byte;
310
    case 0x3e:
311
        s->override = R_DS;
312
        goto next_byte;
313
    case 0x26:
314
        s->override = R_ES;
315
        goto next_byte;
316
    case 0x64:
317
        s->override = R_FS;
318
        goto next_byte;
319
    case 0x65:
320
        s->override = R_GS;
321
        goto next_byte;
322
    case 0x66:
323
        prefixes |= PREFIX_DATA;
324
        goto next_byte;
325
    case 0x67:
326
        prefixes |= PREFIX_ADR;
327
        goto next_byte;
328
    }
329

    
330
    if (prefixes & PREFIX_DATA)
331
        dflag ^= 1;
332
    if (prefixes & PREFIX_ADR)
333
        aflag ^= 1;
334

    
335
    s->prefix = prefixes;
336
    s->aflag = aflag;
337
    s->dflag = dflag;
338

    
339
    /* lock generation */
340
    if (prefixes & PREFIX_LOCK)
341
        goto unsupported_op;
342
    if (s->override == R_FS || s->override == R_GS || s->override == R_CS)
343
        goto unsupported_op;
344

    
345
    pc_start_insn = s->pc - 1;
346
    /* now check op code */
347
 reswitch:
348
    switch(b) {
349
    case 0x0f:
350
        /**************************/
351
        /* extended op code */
352
        b = ldub_code(s->pc++) | 0x100;
353
        goto reswitch;
354
       
355
        /**************************/
356
        /* arith & logic */
357
    case 0x00 ... 0x05:
358
    case 0x08 ... 0x0d:
359
    case 0x10 ... 0x15:
360
    case 0x18 ... 0x1d:
361
    case 0x20 ... 0x25:
362
    case 0x28 ... 0x2d:
363
    case 0x30 ... 0x35:
364
    case 0x38 ... 0x3d:
365
        {
366
            int f;
367
            f = (b >> 1) & 3;
368

    
369
            if ((b & 1) == 0)
370
                ot = OT_BYTE;
371
            else
372
                ot = dflag ? OT_LONG : OT_WORD;
373
           
374
            switch(f) {
375
            case 0: /* OP Ev, Gv */
376
                modrm = ldub_code(s->pc++);
377
                parse_modrm(s, modrm);
378
                break;
379
            case 1: /* OP Gv, Ev */
380
                modrm = ldub_code(s->pc++);
381
                parse_modrm(s, modrm);
382
                break;
383
            case 2: /* OP A, Iv */
384
                insn_get(s, ot);
385
                break;
386
            }
387
        }
388
        break;
389

    
390
    case 0x80: /* GRP1 */
391
    case 0x81:
392
    case 0x82:
393
    case 0x83:
394
        {
395
            if ((b & 1) == 0)
396
                ot = OT_BYTE;
397
            else
398
                ot = dflag ? OT_LONG : OT_WORD;
399
           
400
            modrm = ldub_code(s->pc++);
401
            parse_modrm(s, modrm);
402

    
403
            switch(b) {
404
            default:
405
            case 0x80:
406
            case 0x81:
407
            case 0x82:
408
                insn_get(s, ot);
409
                break;
410
            case 0x83:
411
                insn_get(s, OT_BYTE);
412
                break;
413
            }
414
        }
415
        break;
416

    
417
        /**************************/
418
        /* inc, dec, and other misc arith */
419
    case 0x40 ... 0x47: /* inc Gv */
420
        break;
421
    case 0x48 ... 0x4f: /* dec Gv */
422
        break;
423
    case 0xf6: /* GRP3 */
424
    case 0xf7:
425
        if ((b & 1) == 0)
426
            ot = OT_BYTE;
427
        else
428
            ot = dflag ? OT_LONG : OT_WORD;
429

    
430
        modrm = ldub_code(s->pc++);
431
        op = (modrm >> 3) & 7;
432
        parse_modrm(s, modrm);
433

    
434
        switch(op) {
435
        case 0: /* test */
436
            insn_get(s, ot);
437
            break;
438
        case 2: /* not */
439
            break;
440
        case 3: /* neg */
441
            break;
442
        case 4: /* mul */
443
            break;
444
        case 5: /* imul */
445
            break;
446
        case 6: /* div */
447
            break;
448
        case 7: /* idiv */
449
            break;
450
        default:
451
            goto illegal_op;
452
        }
453
        break;
454

    
455
    case 0xfe: /* GRP4 */
456
    case 0xff: /* GRP5 */
457
        if ((b & 1) == 0)
458
            ot = OT_BYTE;
459
        else
460
            ot = dflag ? OT_LONG : OT_WORD;
461

    
462
        modrm = ldub_code(s->pc++);
463
        mod = (modrm >> 6) & 3;
464
        op = (modrm >> 3) & 7;
465
        if (op >= 2 && b == 0xfe) {
466
            goto illegal_op;
467
        }
468
        pc_tmp = s->pc;
469
        parse_modrm(s, modrm);
470

    
471
        switch(op) {
472
        case 0: /* inc Ev */
473
            break;
474
        case 1: /* dec Ev */
475
            break;
476
        case 2: /* call Ev */
477
            /* XXX: optimize and handle MEM exceptions specifically
478
               fs movl %eax, regs[0]
479
               movl Ev, %eax
480
               pushl next_eip
481
               fs movl %eax, eip
482
            */
483
            goto unsupported_op;
484
        case 3: /* lcall Ev */
485
            goto unsupported_op;
486
        case 4: /* jmp Ev */
487
            /* XXX: optimize and handle MEM exceptions specifically
488
               fs movl %eax, regs[0]
489
               movl Ev, %eax
490
               fs movl %eax, eip
491
            */
492
            goto unsupported_op;
493
        case 5: /* ljmp Ev */
494
            goto unsupported_op;
495
        case 6: /* push Ev */
496
            break;
497
        default:
498
            goto illegal_op;
499
        }
500
        break;
501
    case 0xa8: /* test eAX, Iv */
502
    case 0xa9:
503
        if ((b & 1) == 0)
504
            ot = OT_BYTE;
505
        else
506
            ot = dflag ? OT_LONG : OT_WORD;
507
        insn_get(s, ot);
508
        break;
509
       
510
    case 0x98: /* CWDE/CBW */
511
        break;
512
    case 0x99: /* CDQ/CWD */
513
        break;
514
    case 0x1af: /* imul Gv, Ev */
515
    case 0x69: /* imul Gv, Ev, I */
516
    case 0x6b:
517
        ot = dflag ? OT_LONG : OT_WORD;
518
        modrm = ldub_code(s->pc++);
519
        parse_modrm(s, modrm);
520
        if (b == 0x69) {
521
            insn_get(s, ot);
522
        } else if (b == 0x6b) {
523
            insn_get(s, OT_BYTE);
524
        } else {
525
        }
526
        break;
527

    
528
    case 0x84: /* test Ev, Gv */
529
    case 0x85:
530
       
531
    case 0x1c0:
532
    case 0x1c1: /* xadd Ev, Gv */
533

    
534
    case 0x1b0:
535
    case 0x1b1: /* cmpxchg Ev, Gv */
536

    
537
    case 0x8f: /* pop Ev */
538

    
539
    case 0x88:
540
    case 0x89: /* mov Gv, Ev */
541

    
542
    case 0x8a:
543
    case 0x8b: /* mov Ev, Gv */
544

    
545
    case 0x1b6: /* movzbS Gv, Eb */
546
    case 0x1b7: /* movzwS Gv, Eb */
547
    case 0x1be: /* movsbS Gv, Eb */
548
    case 0x1bf: /* movswS Gv, Eb */
549

    
550
    case 0x86:
551
    case 0x87: /* xchg Ev, Gv */
552

    
553
    case 0xd0:
554
    case 0xd1: /* shift Ev,1 */
555

    
556
    case 0xd2:
557
    case 0xd3: /* shift Ev,cl */
558

    
559
    case 0x1a5: /* shld cl */
560
    case 0x1ad: /* shrd cl */
561

    
562
    case 0x190 ... 0x19f: /* setcc Gv */
563

    
564
    /* XXX: emulate cmov if not available ? */
565
    case 0x140 ... 0x14f: /* cmov Gv, Ev */
566

    
567
    case 0x1a3: /* bt Gv, Ev */
568
    case 0x1ab: /* bts */
569
    case 0x1b3: /* btr */
570
    case 0x1bb: /* btc */
571

    
572
    case 0x1bc: /* bsf */
573
    case 0x1bd: /* bsr */
574

    
575
        modrm = ldub_code(s->pc++);
576
        parse_modrm(s, modrm);
577
        break;
578

    
579
    case 0x1c7: /* cmpxchg8b */
580
        modrm = ldub_code(s->pc++);
581
        mod = (modrm >> 6) & 3;
582
        if (mod == 3)
583
            goto illegal_op;
584
        parse_modrm(s, modrm);
585
        break;
586
       
587
        /**************************/
588
        /* push/pop */
589
    case 0x50 ... 0x57: /* push */
590
    case 0x58 ... 0x5f: /* pop */
591
    case 0x60: /* pusha */
592
    case 0x61: /* popa */
593
        break;
594

    
595
    case 0x68: /* push Iv */
596
    case 0x6a:
597
        ot = dflag ? OT_LONG : OT_WORD;
598
        if (b == 0x68)
599
            insn_get(s, ot);
600
        else
601
            insn_get(s, OT_BYTE);
602
        break;
603
    case 0xc8: /* enter */
604
        lduw_code(s->pc);
605
        s->pc += 2;
606
        ldub_code(s->pc++);
607
        break;
608
    case 0xc9: /* leave */
609
        break;
610

    
611
    case 0x06: /* push es */
612
    case 0x0e: /* push cs */
613
    case 0x16: /* push ss */
614
    case 0x1e: /* push ds */
615
        /* XXX: optimize:
616
         push segs[n].selector
617
        */
618
        goto unsupported_op;
619
    case 0x1a0: /* push fs */
620
    case 0x1a8: /* push gs */
621
        goto unsupported_op;
622
    case 0x07: /* pop es */
623
    case 0x17: /* pop ss */
624
    case 0x1f: /* pop ds */
625
        goto unsupported_op;
626
    case 0x1a1: /* pop fs */
627
    case 0x1a9: /* pop gs */
628
        goto unsupported_op;
629
    case 0x8e: /* mov seg, Gv */
630
        /* XXX: optimize:
631
           fs movl r, regs[]
632
           movl segs[].selector, r
633
           mov r, Gv
634
           fs movl regs[], r
635
        */
636
        goto unsupported_op;
637
    case 0x8c: /* mov Gv, seg */
638
        goto unsupported_op;
639
    case 0xc4: /* les Gv */
640
        op = R_ES;
641
        goto do_lxx;
642
    case 0xc5: /* lds Gv */
643
        op = R_DS;
644
        goto do_lxx;
645
    case 0x1b2: /* lss Gv */
646
        op = R_SS;
647
        goto do_lxx;
648
    case 0x1b4: /* lfs Gv */
649
        op = R_FS;
650
        goto do_lxx;
651
    case 0x1b5: /* lgs Gv */
652
        op = R_GS;
653
    do_lxx:
654
        goto unsupported_op;
655
        /************************/
656
        /* floats */
657
    case 0xd8 ... 0xdf:
658
#if 1
659
        /* currently not stable enough */
660
        goto unsupported_op;
661
#else
662
        if (s->flags & (HF_EM_MASK | HF_TS_MASK))
663
            goto unsupported_op;
664
#endif
665
#if 0
666
        /* for testing FPU context switch */
667
        {
668
            static int count;
669
            count = (count + 1) % 3;
670
            if (count != 0)
671
                goto unsupported_op;
672
        }
673
#endif
674
        modrm = ldub_code(s->pc++);
675
        mod = (modrm >> 6) & 3;
676
        rm = modrm & 7;
677
        op = ((b & 7) << 3) | ((modrm >> 3) & 7);
678
        if (mod != 3) {
679
            /* memory op */
680
            parse_modrm(s, modrm);
681
            switch(op) {
682
            case 0x00 ... 0x07: /* fxxxs */
683
            case 0x10 ... 0x17: /* fixxxl */
684
            case 0x20 ... 0x27: /* fxxxl */
685
            case 0x30 ... 0x37: /* fixxx */
686
                break;
687
            case 0x08: /* flds */
688
            case 0x0a: /* fsts */
689
            case 0x0b: /* fstps */
690
            case 0x18: /* fildl */
691
            case 0x1a: /* fistl */
692
            case 0x1b: /* fistpl */
693
            case 0x28: /* fldl */
694
            case 0x2a: /* fstl */
695
            case 0x2b: /* fstpl */
696
            case 0x38: /* filds */
697
            case 0x3a: /* fists */
698
            case 0x3b: /* fistps */
699
            case 0x0c: /* fldenv mem */
700
            case 0x0d: /* fldcw mem */
701
            case 0x0e: /* fnstenv mem */
702
            case 0x0f: /* fnstcw mem */
703
            case 0x1d: /* fldt mem */
704
            case 0x1f: /* fstpt mem */
705
            case 0x2c: /* frstor mem */
706
            case 0x2e: /* fnsave mem */
707
            case 0x2f: /* fnstsw mem */
708
            case 0x3c: /* fbld */
709
            case 0x3e: /* fbstp */
710
            case 0x3d: /* fildll */
711
            case 0x3f: /* fistpll */
712
                break;
713
            default:
714
                goto illegal_op;
715
            }
716
        } else {
717
            /* register float ops */
718
            switch(op) {
719
            case 0x08: /* fld sti */
720
            case 0x09: /* fxchg sti */
721
                break;
722
            case 0x0a: /* grp d9/2 */
723
                switch(rm) {
724
                case 0: /* fnop */
725
                    break;
726
                default:
727
                    goto illegal_op;
728
                }
729
                break;
730
            case 0x0c: /* grp d9/4 */
731
                switch(rm) {
732
                case 0: /* fchs */
733
                case 1: /* fabs */
734
                case 4: /* ftst */
735
                case 5: /* fxam */
736
                    break;
737
                default:
738
                    goto illegal_op;
739
                }
740
                break;
741
            case 0x0d: /* grp d9/5 */
742
                switch(rm) {
743
                case 0:
744
                case 1:
745
                case 2:
746
                case 3:
747
                case 4:
748
                case 5:
749
                case 6:
750
                    break;
751
                default:
752
                    goto illegal_op;
753
                }
754
                break;
755
            case 0x0e: /* grp d9/6 */
756
                break;
757
            case 0x0f: /* grp d9/7 */
758
                break;
759
            case 0x00: case 0x01: case 0x04 ... 0x07: /* fxxx st, sti */
760
            case 0x20: case 0x21: case 0x24 ... 0x27: /* fxxx sti, st */
761
            case 0x30: case 0x31: case 0x34 ... 0x37: /* fxxxp sti, st */
762
                break;
763
            case 0x02: /* fcom */
764
                break;
765
            case 0x03: /* fcomp */
766
                break;
767
            case 0x15: /* da/5 */
768
                switch(rm) {
769
                case 1: /* fucompp */
770
                    break;
771
                default:
772
                    goto illegal_op;
773
                }
774
                break;
775
            case 0x1c:
776
                switch(rm) {
777
                case 0: /* feni (287 only, just do nop here) */
778
                case 1: /* fdisi (287 only, just do nop here) */
779
                    goto unsupported_op;
780
                case 2: /* fclex */
781
                case 3: /* fninit */
782
                case 4: /* fsetpm (287 only, just do nop here) */
783
                    break;
784
                default:
785
                    goto illegal_op;
786
                }
787
                break;
788
            case 0x1d: /* fucomi */
789
                break;
790
            case 0x1e: /* fcomi */
791
                break;
792
            case 0x28: /* ffree sti */
793
                break;
794
            case 0x2a: /* fst sti */
795
                break;
796
            case 0x2b: /* fstp sti */
797
                break;
798
            case 0x2c: /* fucom st(i) */
799
                break;
800
            case 0x2d: /* fucomp st(i) */
801
                break;
802
            case 0x33: /* de/3 */
803
                switch(rm) {
804
                case 1: /* fcompp */
805
                    break;
806
                default:
807
                    goto illegal_op;
808
                }
809
                break;
810
            case 0x3c: /* df/4 */
811
                switch(rm) {
812
                case 0:
813
                    break;
814
                default:
815
                    goto illegal_op;
816
                }
817
                break;
818
            case 0x3d: /* fucomip */
819
                break;
820
            case 0x3e: /* fcomip */
821
                break;
822
            case 0x10 ... 0x13: /* fcmovxx */
823
            case 0x18 ... 0x1b:
824
                break;
825
            default:
826
                goto illegal_op;
827
            }
828
        }
829
        s->tb->cflags |= CF_TB_FP_USED;
830
        break;
831

    
832
        /**************************/
833
        /* mov */
834
    case 0xc6:
835
    case 0xc7: /* mov Ev, Iv */
836
        if ((b & 1) == 0)
837
            ot = OT_BYTE;
838
        else
839
            ot = dflag ? OT_LONG : OT_WORD;
840
        modrm = ldub_code(s->pc++);
841
        parse_modrm(s, modrm);
842
        insn_get(s, ot);
843
        break;
844

    
845
    case 0x8d: /* lea */
846
        ot = dflag ? OT_LONG : OT_WORD;
847
        modrm = ldub_code(s->pc++);
848
        mod = (modrm >> 6) & 3;
849
        if (mod == 3)
850
            goto illegal_op;
851
        parse_modrm(s, modrm);
852
        break;
853
       
854
    case 0xa0: /* mov EAX, Ov */
855
    case 0xa1:
856
    case 0xa2: /* mov Ov, EAX */
857
    case 0xa3:
858
        if ((b & 1) == 0)
859
            ot = OT_BYTE;
860
        else
861
            ot = dflag ? OT_LONG : OT_WORD;
862
        if (s->aflag)
863
            insn_get(s, OT_LONG);
864
        else
865
            insn_get(s, OT_WORD);
866
        break;
867
    case 0xd7: /* xlat */
868
        break;
869
    case 0xb0 ... 0xb7: /* mov R, Ib */
870
        insn_get(s, OT_BYTE);
871
        break;
872
    case 0xb8 ... 0xbf: /* mov R, Iv */
873
        ot = dflag ? OT_LONG : OT_WORD;
874
        insn_get(s, ot);
875
        break;
876

    
877
    case 0x91 ... 0x97: /* xchg R, EAX */
878
        break;
879

    
880
        /************************/
881
        /* shifts */
882
    case 0xc0:
883
    case 0xc1: /* shift Ev,imm */
884

    
885
    case 0x1a4: /* shld imm */
886
    case 0x1ac: /* shrd imm */
887
        modrm = ldub_code(s->pc++);
888
        parse_modrm(s, modrm);
889
        ldub_code(s->pc++);
890
        break;
891
       
892
        /************************/
893
        /* string ops */
894

    
895
    case 0xa4: /* movsS */
896
    case 0xa5:
897
        break;
898
       
899
    case 0xaa: /* stosS */
900
    case 0xab:
901
        break;
902

    
903
    case 0xac: /* lodsS */
904
    case 0xad:
905
        break;
906

    
907
    case 0xae: /* scasS */
908
    case 0xaf:
909
        break;
910

    
911
    case 0xa6: /* cmpsS */
912
    case 0xa7:
913
        break;
914

    
915
    case 0x6c: /* insS */
916
    case 0x6d:
917
        goto unsupported_op;
918

    
919
    case 0x6e: /* outsS */
920
    case 0x6f:
921
        goto unsupported_op;
922

    
923
        /************************/
924
        /* port I/O */
925
    case 0xe4:
926
    case 0xe5:
927
        goto unsupported_op;
928

    
929
    case 0xe6:
930
    case 0xe7:
931
        goto unsupported_op;
932

    
933
    case 0xec:
934
    case 0xed:
935
        goto unsupported_op;
936

    
937
    case 0xee:
938
    case 0xef:
939
        goto unsupported_op;
940

    
941
        /************************/
942
        /* control */
943
#if 0
944
    case 0xc2: /* ret im */
945
        val = ldsw_code(s->pc);
946
        s->pc += 2;
947
        gen_pop_T0(s);
948
        gen_stack_update(s, val + (2 << s->dflag));
949
        if (s->dflag == 0)
950
            gen_op_andl_T0_ffff();
951
        gen_op_jmp_T0();
952
        gen_eob(s);
953
        break;
954
#endif
955

    
956
    case 0xc3: /* ret */
957
        gb(s, CPU_SEG);
958
        if (!s->dflag) 
959
            gb(s, 0x66); /* d16 */
960
        gb(s, 0x8f); /* pop addr */
961
        gb(s, 0x05);
962
        gl(s, CPU_FIELD_OFFSET(eip));
963
        if (!s->dflag) {
964
            /* reset high bits of EIP */
965
            gen_movw_addr_im(s, CPU_FIELD_OFFSET(eip) + 2, 0);
966
        }
967
        gen_eob(s);
968
        goto no_copy;
969
    case 0xca: /* lret im */
970
    case 0xcb: /* lret */
971
    case 0xcf: /* iret */
972
    case 0x9a: /* lcall im */
973
    case 0xea: /* ljmp im */
974
        goto unsupported_op;
975

    
976
    case 0xe8: /* call im */
977
        ot = dflag ? OT_LONG : OT_WORD;
978
        val = insn_get(s, ot);
979
        next_eip = s->pc - s->cs_base;
980
        val += next_eip;
981
        if (s->dflag) {
982
            gb(s, 0x68); /* pushl imm */
983
            gl(s, next_eip);
984
        } else {
985
            gb(s, 0x66); /* pushw imm */
986
            gb(s, 0x68);
987
            gw(s, next_eip);
988
            val &= 0xffff;
989
        }
990
        gen_jmp(s, val);
991
        goto no_copy;
992
    case 0xe9: /* jmp */
993
        ot = dflag ? OT_LONG : OT_WORD;
994
        val = insn_get(s, ot);
995
        val += s->pc - s->cs_base;
996
        if (s->dflag == 0)
997
            val = val & 0xffff;
998
        gen_jmp(s, val);
999
        goto no_copy;
1000
    case 0xeb: /* jmp Jb */
1001
        val = (int8_t)insn_get(s, OT_BYTE);
1002
        val += s->pc - s->cs_base;
1003
        if (s->dflag == 0)
1004
            val = val & 0xffff;
1005
        gen_jmp(s, val);
1006
        goto no_copy;
1007
    case 0x70 ... 0x7f: /* jcc Jb */
1008
        val = (int8_t)insn_get(s, OT_BYTE);
1009
        goto do_jcc;
1010
    case 0x180 ... 0x18f: /* jcc Jv */
1011
        if (dflag) {
1012
            val = insn_get(s, OT_LONG);
1013
        } else {
1014
            val = (int16_t)insn_get(s, OT_WORD);
1015
        }
1016
    do_jcc:
1017
        next_eip = s->pc - s->cs_base;
1018
        val += next_eip;
1019
        if (s->dflag == 0)
1020
            val &= 0xffff;
1021
        gen_jcc(s, b & 0xf, val, next_eip);
1022
        goto no_copy;
1023

    
1024
        /************************/
1025
        /* flags */
1026
    case 0x9c: /* pushf */
1027
        /* XXX: put specific code ? */
1028
        goto unsupported_op;
1029
    case 0x9d: /* popf */
1030
        goto unsupported_op;
1031

    
1032
    case 0x9e: /* sahf */
1033
    case 0x9f: /* lahf */
1034
    case 0xf5: /* cmc */
1035
    case 0xf8: /* clc */
1036
    case 0xf9: /* stc */
1037
    case 0xfc: /* cld */
1038
    case 0xfd: /* std */
1039
        break;
1040

    
1041
        /************************/
1042
        /* bit operations */
1043
    case 0x1ba: /* bt/bts/btr/btc Gv, im */
1044
        ot = dflag ? OT_LONG : OT_WORD;
1045
        modrm = ldub_code(s->pc++);
1046
        op = (modrm >> 3) & 7;
1047
        parse_modrm(s, modrm);
1048
        /* load shift */
1049
        ldub_code(s->pc++);
1050
        if (op < 4)
1051
            goto illegal_op;
1052
        break;
1053
        /************************/
1054
        /* bcd */
1055
    case 0x27: /* daa */
1056
        break;
1057
    case 0x2f: /* das */
1058
        break;
1059
    case 0x37: /* aaa */
1060
        break;
1061
    case 0x3f: /* aas */
1062
        break;
1063
    case 0xd4: /* aam */
1064
        ldub_code(s->pc++);
1065
        break;
1066
    case 0xd5: /* aad */
1067
        ldub_code(s->pc++);
1068
        break;
1069
        /************************/
1070
        /* misc */
1071
    case 0x90: /* nop */
1072
        break;
1073
    case 0x9b: /* fwait */
1074
        if ((s->flags & (HF_MP_MASK | HF_TS_MASK)) ==
1075
            (HF_MP_MASK | HF_TS_MASK)) {
1076
            goto unsupported_op;
1077
        }
1078
        break;
1079
    case 0xcc: /* int3 */
1080
        goto unsupported_op;
1081
    case 0xcd: /* int N */
1082
        goto unsupported_op;
1083
    case 0xce: /* into */
1084
        goto unsupported_op;
1085
    case 0xf1: /* icebp (undocumented, exits to external debugger) */
1086
        goto unsupported_op;
1087
    case 0xfa: /* cli */
1088
        goto unsupported_op;
1089
    case 0xfb: /* sti */
1090
        goto unsupported_op;
1091
    case 0x62: /* bound */
1092
        modrm = ldub_code(s->pc++);
1093
        mod = (modrm >> 6) & 3;
1094
        if (mod == 3)
1095
            goto illegal_op;
1096
        parse_modrm(s, modrm);
1097
        break;
1098
    case 0x1c8 ... 0x1cf: /* bswap reg */
1099
        break;
1100
    case 0xd6: /* salc */
1101
        break;
1102
    case 0xe0: /* loopnz */
1103
    case 0xe1: /* loopz */
1104
    case 0xe2: /* loop */
1105
    case 0xe3: /* jecxz */
1106
        goto unsupported_op;
1107

    
1108
    case 0x130: /* wrmsr */
1109
    case 0x132: /* rdmsr */
1110
        goto unsupported_op;
1111
    case 0x131: /* rdtsc */
1112
        goto unsupported_op;
1113
    case 0x1a2: /* cpuid */
1114
        goto unsupported_op;
1115
    case 0xf4: /* hlt */
1116
        goto unsupported_op;
1117
    case 0x100:
1118
        goto unsupported_op;
1119
    case 0x101:
1120
        goto unsupported_op;
1121
    case 0x108: /* invd */
1122
    case 0x109: /* wbinvd */
1123
        goto unsupported_op;
1124
    case 0x63: /* arpl */
1125
        goto unsupported_op;
1126
    case 0x102: /* lar */
1127
    case 0x103: /* lsl */
1128
        goto unsupported_op;
1129
    case 0x118:
1130
        goto unsupported_op;
1131
    case 0x120: /* mov reg, crN */
1132
    case 0x122: /* mov crN, reg */
1133
        goto unsupported_op;
1134
    case 0x121: /* mov reg, drN */
1135
    case 0x123: /* mov drN, reg */
1136
        goto unsupported_op;
1137
    case 0x106: /* clts */
1138
        goto unsupported_op;
1139
    default:
1140
        goto illegal_op;
1141
    }
1142

    
1143
    /* just copy the code */
1144

    
1145
    /* no override yet */
1146
    if (!s->dflag)
1147
        gb(s, 0x66);
1148
    if (!s->aflag)
1149
        gb(s, 0x67);
1150
    if (prefixes & PREFIX_REPZ)
1151
        gb(s, 0xf3);
1152
    else if (prefixes & PREFIX_REPNZ)
1153
        gb(s, 0xf2);
1154
    {
1155
        int len, i;
1156
        len = s->pc - pc_start_insn;
1157
        for(i = 0; i < len; i++) {
1158
            *s->gen_code_ptr++ = ldub_code(pc_start_insn + i);
1159
        }
1160
    }
1161
 no_copy:
1162
    return 0;
1163
 illegal_op:
1164
 unsupported_op:
1165
    /* fall back to slower code gen necessary */
1166
    s->pc = pc_start;
1167
    return -1;
1168
}
1169

    
1170
#define GEN_CODE_MAX_SIZE      8192
1171
#define GEN_CODE_MAX_INSN_SIZE 512
1172

    
1173
static inline int gen_intermediate_code_internal(CPUState *env,
1174
                                                 TranslationBlock *tb,
1175
                                                 uint8_t *gen_code_ptr,
1176
                                                 int *gen_code_size_ptr,
1177
                                                 int search_pc,
1178
                                                 uint8_t *tc_ptr)
1179
{
1180
    DisasContext dc1, *dc = &dc1;
1181
    target_ulong pc_insn, pc_start, cs_base;
1182
    uint8_t *gen_code_end;
1183
    int flags, ret;
1184

    
1185
    if (env->nb_breakpoints > 0 ||
1186
        env->singlestep_enabled)
1187
        return -1;
1188
    flags = tb->flags;
1189
    if (flags & (HF_TF_MASK | HF_ADDSEG_MASK |
1190
                 HF_SOFTMMU_MASK | HF_INHIBIT_IRQ_MASK))
1191
        return -1;
1192
    if (!(flags & HF_SS32_MASK))
1193
        return -1;
1194
    if (tb->cflags & CF_SINGLE_INSN)
1195
        return -1;
1196
    gen_code_end = gen_code_ptr +
1197
        GEN_CODE_MAX_SIZE - GEN_CODE_MAX_INSN_SIZE;
1198
    dc->gen_code_ptr = gen_code_ptr;
1199
    dc->gen_code_start = gen_code_ptr;
1200

    
1201
    /* generate intermediate code */
1202
    pc_start = tb->pc;
1203
    cs_base = tb->cs_base;
1204
    dc->pc = pc_start;
1205
    dc->cs_base = cs_base;
1206
    dc->pe = (flags >> HF_PE_SHIFT) & 1;
1207
    dc->code32 = (flags >> HF_CS32_SHIFT) & 1;
1208
    dc->f_st = 0;
1209
    dc->vm86 = (flags >> VM_SHIFT) & 1;
1210
    dc->cpl = (flags >> HF_CPL_SHIFT) & 3;
1211
    dc->iopl = (flags >> IOPL_SHIFT) & 3;
1212
    dc->tb = tb;
1213
    dc->flags = flags;
1214

    
1215
    dc->is_jmp = 0;
1216

    
1217
    for(;;) {
1218
        pc_insn = dc->pc;
1219
        ret = disas_insn(dc);
1220
        if (ret < 0) {
1221
            /* unsupported insn */
1222
            if (dc->pc == pc_start) {
1223
                /* if first instruction, signal that no copying was done */
1224
                return -1;
1225
            } else {
1226
                gen_jmp(dc, dc->pc - dc->cs_base);
1227
                dc->is_jmp = 1;
1228
            }
1229
        }
1230
        if (search_pc) {
1231
            /* search pc mode */
1232
            if (tc_ptr < dc->gen_code_ptr) {
1233
                env->eip = pc_insn - cs_base;
1234
                return 0;
1235
            }
1236
        }
1237
        /* stop translation if indicated */
1238
        if (dc->is_jmp)
1239
            break;
1240
        /* if too long translation, stop generation */
1241
        if (dc->gen_code_ptr >= gen_code_end ||
1242
            (dc->pc - pc_start) >= (TARGET_PAGE_SIZE - 32)) {
1243
            gen_jmp(dc, dc->pc - dc->cs_base);
1244
            break;
1245
        }
1246
    }
1247
   
1248
#ifdef DEBUG_DISAS
1249
    if (loglevel & CPU_LOG_TB_IN_ASM) {
1250
        fprintf(logfile, "----------------\n");
1251
        fprintf(logfile, "IN: COPY: %s fpu=%d\n",
1252
                lookup_symbol(pc_start),
1253
                tb->cflags & CF_TB_FP_USED ? 1 : 0);
1254
        target_disas(logfile, pc_start, dc->pc - pc_start, !dc->code32);
1255
        fprintf(logfile, "\n");
1256
    }
1257
#endif
1258

    
1259
    if (!search_pc) {
1260
        *gen_code_size_ptr = dc->gen_code_ptr - dc->gen_code_start;
1261
        tb->size = dc->pc - pc_start;
1262
        tb->cflags |= CF_CODE_COPY;
1263
        return 0;
1264
    } else {
1265
        return -1;
1266
    }
1267
}
1268

    
1269
/* generate code by just copying data. Return -1 if cannot generate
1270
   any code. Return 0 if code was generated */
1271
int cpu_gen_code_copy(CPUState *env, TranslationBlock *tb,
1272
                      int max_code_size, int *gen_code_size_ptr)
1273
{
1274
    /* generate machine code */
1275
    tb->tb_next_offset[0] = 0xffff;
1276
    tb->tb_next_offset[1] = 0xffff;
1277
#ifdef USE_DIRECT_JUMP
1278
    /* the following two entries are optional (only used for string ops) */
1279
    tb->tb_jmp_offset[2] = 0xffff;
1280
    tb->tb_jmp_offset[3] = 0xffff;
1281
#endif
1282
    return gen_intermediate_code_internal(env, tb,
1283
                                          tb->tc_ptr, gen_code_size_ptr,
1284
                                          0, NULL);
1285
}
1286

    
1287
static uint8_t dummy_gen_code_buf[GEN_CODE_MAX_SIZE];
1288

    
1289
int cpu_restore_state_copy(TranslationBlock *tb,
1290
                           CPUState *env, unsigned long searched_pc,
1291
                           void *puc)
1292
{
1293
    struct ucontext *uc = puc;
1294
    int ret, eflags;
1295

    
1296
    /* find opc index corresponding to search_pc */
1297
    if (searched_pc < (unsigned long)tb->tc_ptr)
1298
        return -1;
1299
    searched_pc = searched_pc - (long)tb->tc_ptr + (long)dummy_gen_code_buf;
1300
    ret = gen_intermediate_code_internal(env, tb,
1301
                                         dummy_gen_code_buf, NULL,
1302
                                         1, (uint8_t *)searched_pc);
1303
    if (ret < 0)
1304
        return ret;
1305
    /* restore all the CPU state from the CPU context from the
1306
       signal. The FPU context stays in the host CPU. */
1307
   
1308
    env->regs[R_EAX] = uc->uc_mcontext.gregs[REG_EAX];
1309
    env->regs[R_ECX] = uc->uc_mcontext.gregs[REG_ECX];
1310
    env->regs[R_EDX] = uc->uc_mcontext.gregs[REG_EDX];
1311
    env->regs[R_EBX] = uc->uc_mcontext.gregs[REG_EBX];
1312
    env->regs[R_ESP] = uc->uc_mcontext.gregs[REG_ESP];
1313
    env->regs[R_EBP] = uc->uc_mcontext.gregs[REG_EBP];
1314
    env->regs[R_ESI] = uc->uc_mcontext.gregs[REG_ESI];
1315
    env->regs[R_EDI] = uc->uc_mcontext.gregs[REG_EDI];
1316
    eflags = uc->uc_mcontext.gregs[REG_EFL];
1317
    env->df = 1 - (2 * ((eflags >> 10) & 1));
1318
    env->cc_src = eflags & (CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
1319
    env->cc_op = CC_OP_EFLAGS;
1320
    return 0;
1321
}
1322

    
1323
#endif /* USE_CODE_COPY */